Quickly renamed the last directory.

1 files changed, 537 insertions, 525 deletions

diff --git a/Objects/classobject.c b/Objects/classobject.c
index d78b758..72f8c11 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -31,51 +31,52 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Class object implementation */
 
-#include "allobjects.h"
+#include "Python.h"
 #include "structmember.h"
 
 /* Forward */
-static object *class_lookup PROTO((classobject *, object *, classobject **));
-static object *instance_getattr1 PROTO((instanceobject *, object *));
-
-object *
-newclassobject(bases, dict, name)
-	object *bases; /* NULL or tuple of classobjects! */
-	object *dict;
-	object *name; /* String; NULL if unknown */
+static PyObject *class_lookup
+	Py_PROTO((PyClassObject *, PyObject *, PyClassObject **));
+static PyObject *instance_getattr1 Py_PROTO((PyInstanceObject *, PyObject *));
+
+PyObject *
+PyClass_New(bases, dict, name)
+	PyObject *bases; /* NULL or tuple of classobjects! */
+	PyObject *dict;
+	PyObject *name; /* String; NULL if unknown */
 {
 #ifdef SUPPORT_OBSOLETE_ACCESS
 	int pos;
-	object *key, *value;
+	PyObject *key, *value;
 #endif
-	classobject *op, *dummy;
-	static object *getattrstr, *setattrstr, *delattrstr;
-	static object *docstr;
+	PyClassObject *op, *dummy;
+	static PyObject *getattrstr, *setattrstr, *delattrstr;
+	static PyObject *docstr;
 	if (docstr == NULL) {
 		docstr= PyString_InternFromString("__doc__");
 		if (docstr == NULL)
 			return NULL;
 	}
-	if (mappinglookup(dict, docstr) == NULL) {
-		if (mappinginsert(dict, docstr, None) < 0)
+	if (PyDict_GetItem(dict, docstr) == NULL) {
+		if (PyDict_SetItem(dict, docstr, Py_None) < 0)
 			return NULL;
 	}
 	if (bases == NULL) {
-		bases = newtupleobject(0);
+		bases = PyTuple_New(0);
 		if (bases == NULL)
 			return NULL;
 	}
 	else
-		INCREF(bases);
-	op = NEWOBJ(classobject, &Classtype);
+		Py_INCREF(bases);
+	op = PyObject_NEW(PyClassObject, &PyClass_Type);
 	if (op == NULL) {
-		DECREF(bases);
+		Py_DECREF(bases);
 		return NULL;
 	}
 	op->cl_bases = bases;
-	INCREF(dict);
+	Py_INCREF(dict);
 	op->cl_dict = dict;
-	XINCREF(name);
+	Py_XINCREF(name);
 	op->cl_name = name;
 	if (getattrstr == NULL) {
 		getattrstr = PyString_InternFromString("__getattr__");
@@ -85,102 +86,103 @@ newclassobject(bases, dict, name)
 	op->cl_getattr = class_lookup(op, getattrstr, &dummy);
 	op->cl_setattr = class_lookup(op, setattrstr, &dummy);
 	op->cl_delattr = class_lookup(op, delattrstr, &dummy);
-	XINCREF(op->cl_getattr);
-	XINCREF(op->cl_setattr);
-	XINCREF(op->cl_delattr);
+	Py_XINCREF(op->cl_getattr);
+	Py_XINCREF(op->cl_setattr);
+	Py_XINCREF(op->cl_delattr);
 #ifdef SUPPORT_OBSOLETE_ACCESS
 	pos = 0;
-	while (mappinggetnext(dict, &pos, &key, &value)) {
-		if (is_accessobject(value))
-			setaccessowner(value, (object *)op);
+	while (PyDict_Next(dict, &pos, &key, &value)) {
+		if (PyAccess_Check(value))
+			PyAccess_SetOwner(value, (PyObject *)op);
 	}
 #endif
-	return (object *) op;
+	return (PyObject *) op;
 }
 
 /* Class methods */
 
 static void
 class_dealloc(op)
-	classobject *op;
+	PyClassObject *op;
 {
-	DECREF(op->cl_bases);
-	DECREF(op->cl_dict);
-	XDECREF(op->cl_name);
+	Py_DECREF(op->cl_bases);
+	Py_DECREF(op->cl_dict);
+	Py_XDECREF(op->cl_name);
 	free((ANY *)op);
 }
 
-static object *
+static PyObject *
 class_lookup(cp, name, pclass)
-	classobject *cp;
-	object *name;
-	classobject **pclass;
+	PyClassObject *cp;
+	PyObject *name;
+	PyClassObject **pclass;
 {
 	int i, n;
-	object *value = mappinglookup(cp->cl_dict, name);
+	PyObject *value = PyDict_GetItem(cp->cl_dict, name);
 	if (value != NULL) {
 		*pclass = cp;
 		return value;
 	}
-	n = gettuplesize(cp->cl_bases);
+	n = PyTuple_Size(cp->cl_bases);
 	for (i = 0; i < n; i++) {
-		object *v = class_lookup((classobject *)
-				 gettupleitem(cp->cl_bases, i), name, pclass);
+		PyObject *v = class_lookup(
+			(PyClassObject *)
+			PyTuple_GetItem(cp->cl_bases, i), name, pclass);
 		if (v != NULL)
 			return v;
 	}
 	return NULL;
 }
 
-static object *
+static PyObject *
 class_getattr(op, name)
-	register classobject *op;
-	object *name;
+	register PyClassObject *op;
+	PyObject *name;
 {
-	register object *v;
-	register char *sname = getstringvalue(name);
-	classobject *class;
+	register PyObject *v;
+	register char *sname = PyString_AsString(name);
+	PyClassObject *class;
 	if (sname[0] == '_' && sname[1] == '_') {
 		if (strcmp(sname, "__dict__") == 0) {
-			if (getrestricted()) {
-				err_setstr(RuntimeError,
-					   "class.__dict__ not accessible in restricted mode");
+			if (PyEval_GetRestricted()) {
+				PyErr_SetString(PyExc_RuntimeError,
+			   "class.__dict__ not accessible in restricted mode");
 				return NULL;
 			}
-			INCREF(op->cl_dict);
+			Py_INCREF(op->cl_dict);
 			return op->cl_dict;
 		}
 		if (strcmp(sname, "__bases__") == 0) {
-			INCREF(op->cl_bases);
+			Py_INCREF(op->cl_bases);
 			return op->cl_bases;
 		}
 		if (strcmp(sname, "__name__") == 0) {
 			if (op->cl_name == NULL)
-				v = None;
+				v = Py_None;
 			else
 				v = op->cl_name;
-			INCREF(v);
+			Py_INCREF(v);
 			return v;
 		}
 	}
 	v = class_lookup(op, name, &class);
 	if (v == NULL) {
-		err_setval(AttributeError, name);
+		PyErr_SetObject(PyExc_AttributeError, name);
 		return NULL;
 	}
 #ifdef SUPPORT_OBSOLETE_ACCESS
-	if (is_accessobject(v)) {
-		v = getaccessvalue(v, getowner());
+	if (PyAccess_Check(v)) {
+		v = PyAccess_AsValue(v, PyEval_GetOwner());
 		if (v == NULL)
 			return NULL;
 	}
 	else
 #endif
-		INCREF(v);
-	if (is_funcobject(v)) {
-		object *w = newinstancemethodobject(v, (object *)NULL,
-						    (object *)class);
-		DECREF(v);
+		Py_INCREF(v);
+	if (PyFunction_Check(v)) {
+		PyObject *w = PyMethod_New(v, (PyObject *)NULL,
+						    (PyObject *)class);
+		Py_DECREF(v);
 		v = w;
 	}
 	return v;
@@ -188,61 +190,62 @@ class_getattr(op, name)
 
 static int
 class_setattr(op, name, v)
-	classobject *op;
-	object *name;
-	object *v;
+	PyClassObject *op;
+	PyObject *name;
+	PyObject *v;
 {
 #ifdef SUPPORT_OBSOLETE_ACCESS
-	object *ac;
+	PyObject *ac;
 #endif
-	char *sname = getstringvalue(name);
+	char *sname = PyString_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
-		int n = getstringsize(name);
+		int n = PyString_Size(name);
 		if (sname[n-1] == '_' && sname[n-2] == '_') {
-			err_setstr(TypeError, "read-only special attribute");
+			PyErr_SetString(PyExc_TypeError,
+					"read-only special attribute");
 			return -1;
 		}
 	}
-	if (getrestricted()) {
-		err_setstr(RuntimeError,
+	if (PyEval_GetRestricted()) {
+		PyErr_SetString(PyExc_RuntimeError,
 			   "classes are read-only in restricted mode");
 		return -1;
 	}
 #ifdef SUPPORT_OBSOLETE_ACCESS
-	ac = mappinglookup(op->cl_dict, name);
-	if (ac != NULL && is_accessobject(ac))
-		return setaccessvalue(ac, getowner(), v);
+	ac = PyDict_GetItem(op->cl_dict, name);
+	if (ac != NULL && PyAccess_Check(ac))
+		return PyAccess_SetValue(ac, PyEval_GetOwner(), v);
 #endif
 	if (v == NULL) {
-		int rv = mappingremove(op->cl_dict, name);
+		int rv = PyDict_DelItem(op->cl_dict, name);
 		if (rv < 0)
-			err_setstr(AttributeError,
+			PyErr_SetString(PyExc_AttributeError,
 				   "delete non-existing class attribute");
 		return rv;
 	}
 	else
-		return mappinginsert(op->cl_dict, name, v);
+		return PyDict_SetItem(op->cl_dict, name, v);
 }
 
-static object *
+static PyObject *
 class_repr(op)
-	classobject *op;
+	PyClassObject *op;
 {
 	char buf[140];
 	char *name;
-	if (op->cl_name == NULL || !is_stringobject(op->cl_name))
+	if (op->cl_name == NULL || !PyString_Check(op->cl_name))
 		name = "?";
 	else
-		name = getstringvalue(op->cl_name);
+		name = PyString_AsString(op->cl_name);
 	sprintf(buf, "<class %.100s at %lx>", name, (long)op);
-	return newstringobject(buf);
+	return PyString_FromString(buf);
 }
 
-typeobject Classtype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject PyClass_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,
 	"class",
-	sizeof(classobject),
+	sizeof(PyClassObject),
 	0,
 	(destructor)class_dealloc, /*tp_dealloc*/
 	0,		/*tp_print*/
@@ -261,20 +264,20 @@ typeobject Classtype = {
 };
 
 int
-issubclass(class, base)
-	object *class;
-	object *base;
+PyClass_IsSubclass(class, base)
+	PyObject *class;
+	PyObject *base;
 {
 	int i, n;
-	classobject *cp;
+	PyClassObject *cp;
 	if (class == base)
 		return 1;
-	if (class == NULL || !is_classobject(class))
+	if (class == NULL || !PyClass_Check(class))
 		return 0;
-	cp = (classobject *)class;
-	n = gettuplesize(cp->cl_bases);
+	cp = (PyClassObject *)class;
+	n = PyTuple_Size(cp->cl_bases);
 	for (i = 0; i < n; i++) {
-		if (issubclass(gettupleitem(cp->cl_bases, i), base))
+		if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
 			return 1;
 	}
 	return 0;
@@ -286,34 +289,35 @@ issubclass(class, base)
 #ifdef SUPPORT_OBSOLETE_ACCESS
 static int
 addaccess(class, inst)
-	classobject *class;
-	instanceobject *inst;
+	PyClassObject *class;
+	PyInstanceObject *inst;
 {
 	int i, n, pos, ret;
-	object *key, *value, *ac;
+	PyObject *key, *value, *ac;
 	
-	n = gettuplesize(class->cl_bases);
+	n = PyTuple_Size(class->cl_bases);
 	for (i = 0; i < n; i++) {
-		if (addaccess((classobject *)gettupleitem(class->cl_bases, i), inst) < 0)
+		if (addaccess((PyClassObject *)PyTuple_GetItem(
+			      class->cl_bases, i), inst) < 0)
 			return -1;
 	}
 	
 	pos = 0;
-	while (mappinggetnext(class->cl_dict, &pos, &key, &value)) {
-		if (!is_accessobject(value))
+	while (PyDict_Next(class->cl_dict, &pos, &key, &value)) {
+		if (!PyAccess_Check(value))
 			continue;
-		if (hasaccessvalue(value))
+		if (PyAccess_HasValue(value))
 			continue;
-		ac = dict2lookup(inst->in_dict, key);
-		if (ac != NULL && is_accessobject(ac)) {
-			err_setval(ConflictError, key);
+		ac = PyDict_GetItem(inst->in_dict, key);
+		if (ac != NULL && PyAccess_Check(ac)) {
+			PyErr_SetObject(PyExc_ConflictError, key);
 			return -1;
 		}
-		ac = cloneaccessobject(value);
+		ac = PyAccess_Clone(value);
 		if (ac == NULL)
 			return -1;
-		ret = dict2insert(inst->in_dict, key, ac);
-		DECREF(ac);
+		ret = PyDict_SetItem(inst->in_dict, key, ac);
+		Py_DECREF(ac);
 		if (ret != 0)
 			return -1;
     	}
@@ -321,125 +325,125 @@ addaccess(class, inst)
 }
 #endif
 
-object *
-newinstanceobject(class, arg, kw)
-	object *class;
-	object *arg;
-	object *kw;
+PyObject *
+PyInstance_New(class, arg, kw)
+	PyObject *class;
+	PyObject *arg;
+	PyObject *kw;
 {
-	register instanceobject *inst;
-	object *init;
-	static object *initstr;
-	if (!is_classobject(class)) {
-		err_badcall();
+	register PyInstanceObject *inst;
+	PyObject *init;
+	static PyObject *initstr;
+	if (!PyClass_Check(class)) {
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	inst = NEWOBJ(instanceobject, &Instancetype);
+	inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
 	if (inst == NULL)
 		return NULL;
-	INCREF(class);
-	inst->in_class = (classobject *)class;
-	inst->in_dict = newdictobject();
+	Py_INCREF(class);
+	inst->in_class = (PyClassObject *)class;
+	inst->in_dict = PyDict_New();
 	if (inst->in_dict == NULL
 #ifdef SUPPORT_OBSOLETE_ACCESS
-	    || addaccess((classobject *)class, inst) != 0
+	    || addaccess((PyClassObject *)class, inst) != 0
 #endif
 		) {
-		DECREF(inst);
+		Py_DECREF(inst);
 		return NULL;
 	}
 	if (initstr == NULL)
 		initstr = PyString_InternFromString("__init__");
 	init = instance_getattr1(inst, initstr);
 	if (init == NULL) {
-		err_clear();
-		if ((arg != NULL && (!is_tupleobject(arg) ||
-				     gettuplesize(arg) != 0))
-		    || (kw != NULL && (!is_dictobject(kw) ||
-				      getdictsize(kw) != 0))) {
-			err_setstr(TypeError,
+		PyErr_Clear();
+		if ((arg != NULL && (!PyTuple_Check(arg) ||
+				     PyTuple_Size(arg) != 0))
+		    || (kw != NULL && (!PyDict_Check(kw) ||
+				      PyDict_Size(kw) != 0))) {
+			PyErr_SetString(PyExc_TypeError,
 				   "this constructor takes no arguments");
-			DECREF(inst);
+			Py_DECREF(inst);
 			inst = NULL;
 		}
 	}
 	else {
-		object *res = PyEval_CallObjectWithKeywords(init, arg, kw);
-		DECREF(init);
+		PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
+		Py_DECREF(init);
 		if (res == NULL) {
-			DECREF(inst);
+			Py_DECREF(inst);
 			inst = NULL;
 		}
 		else {
-			if (res != None) {
-				err_setstr(TypeError,
+			if (res != Py_None) {
+				PyErr_SetString(PyExc_TypeError,
 					   "__init__() should return None");
-				DECREF(inst);
+				Py_DECREF(inst);
 				inst = NULL;
 			}
-			DECREF(res);
+			Py_DECREF(res);
 		}
 	}
-	return (object *)inst;
+	return (PyObject *)inst;
 }
 
 /* Instance methods */
 
 static void
 instance_dealloc(inst)
-	register instanceobject *inst;
+	register PyInstanceObject *inst;
 {
-	object *error_type, *error_value, *error_traceback;
-	object *del;
-	static object *delstr;
+	PyObject *error_type, *error_value, *error_traceback;
+	PyObject *del;
+	static PyObject *delstr;
 	/* Call the __del__ method if it exists.  First temporarily
 	   revive the object and save the current exception, if any. */
 #ifdef Py_TRACE_REFS
 	/* much too complicated if Py_TRACE_REFS defined */
-	extern long ref_total;
-	inst->ob_type = &Instancetype;
-	NEWREF(inst);
-	ref_total--;		/* compensate for increment in NEWREF */
+	extern long _Py_RefTotal;
+	inst->ob_type = &PyInstance_Type;
+	_Py_NewReference(inst);
+	_Py_RefTotal--;		/* compensate for increment in NEWREF */
 #ifdef COUNT_ALLOCS
 	inst->ob_type->tp_alloc--; /* ditto */
 #endif
 #else /* !Py_TRACE_REFS */
-	INCREF(inst);
+	Py_INCREF(inst);
 #endif /* !Py_TRACE_REFS */
-	err_fetch(&error_type, &error_value, &error_traceback);
+	PyErr_Fetch(&error_type, &error_value, &error_traceback);
 	if (delstr == NULL)
 		delstr = PyString_InternFromString("__del__");
 	if ((del = instance_getattr1(inst, delstr)) != NULL) {
-		object *res = call_object(del, (object *)NULL);
+		PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
 		if (res == NULL) {
-			object *f, *t, *v, *tb;
- 			err_fetch(&t, &v, &tb);
-			f = sysget("stderr");
-			err_clear();
+			PyObject *f, *t, *v, *tb;
+ 			PyErr_Fetch(&t, &v, &tb);
+			f = PySys_GetObject("stderr");
+			PyErr_Clear();
 			if (f != NULL) {
-				writestring("Exception ", f);
+				PyFile_WriteString("Exception ", f);
 				if (t) {
-					writeobject(t, f, Py_PRINT_RAW);
-					if (v && v != None) {
-						writestring(": ", f);
-						writeobject(v, f, 0);
+					PyFile_WriteObject(t, f, Py_PRINT_RAW);
+					if (v && v != Py_None) {
+						PyFile_WriteString(": ", f);
+						PyFile_WriteObject(v, f, 0);
 					}
 				}
-				writestring(" in ", f);
-				writeobject(del, f, 0);
-				writestring(" ignored\n", f);
-				err_clear(); /* Just in case */
+				PyFile_WriteString(" in ", f);
+				PyFile_WriteObject(del, f, 0);
+				PyFile_WriteString(" ignored\n", f);
+				PyErr_Clear(); /* Just in case */
 			}
 			Py_XDECREF(t);
 			Py_XDECREF(v);
 			Py_XDECREF(tb);
 		}
 		else
-			DECREF(res);
-		DECREF(del);
+			Py_DECREF(res);
+		Py_DECREF(del);
 	}
 	/* Restore the saved exception and undo the temporary revival */
-	err_restore(error_type, error_value, error_traceback);
+	PyErr_Restore(error_type, error_value, error_traceback);
 	/* Can't use DECREF here, it would cause a recursive call */
 	if (--inst->ob_refcnt > 0) {
 #ifdef COUNT_ALLOCS
@@ -451,70 +455,70 @@ instance_dealloc(inst)
 #ifdef COUNT_ALLOCS
 	inst->ob_type->tp_free--;	/* compensate for increment in UNREF */
 #endif
-	UNREF(inst);
+	_Py_ForgetReference(inst);
 	inst->ob_type = NULL;
 #endif /* Py_TRACE_REFS */
-	DECREF(inst->in_class);
-	XDECREF(inst->in_dict);
+	Py_DECREF(inst->in_class);
+	Py_XDECREF(inst->in_dict);
 	free((ANY *)inst);
 }
 
-static object *
+static PyObject *
 instance_getattr1(inst, name)
-	register instanceobject *inst;
-	object *name;
+	register PyInstanceObject *inst;
+	PyObject *name;
 {
-	register object *v;
-	register char *sname = getstringvalue(name);
-	classobject *class;
+	register PyObject *v;
+	register char *sname = PyString_AsString(name);
+	PyClassObject *class;
 	if (sname[0] == '_' && sname[1] == '_') {
 		if (strcmp(sname, "__dict__") == 0) {
-			if (getrestricted()) {
-				err_setstr(RuntimeError,
-					   "instance.__dict__ not accessible in restricted mode");
+			if (PyEval_GetRestricted()) {
+				PyErr_SetString(PyExc_RuntimeError,
+			"instance.__dict__ not accessible in restricted mode");
 				return NULL;
 			}
-			INCREF(inst->in_dict);
+			Py_INCREF(inst->in_dict);
 			return inst->in_dict;
 		}
 		if (strcmp(sname, "__class__") == 0) {
-			INCREF(inst->in_class);
-			return (object *)inst->in_class;
+			Py_INCREF(inst->in_class);
+			return (PyObject *)inst->in_class;
 		}
 	}
 	class = NULL;
-	v = mappinglookup(inst->in_dict, name);
+	v = PyDict_GetItem(inst->in_dict, name);
 	if (v == NULL) {
 		v = class_lookup(inst->in_class, name, &class);
 		if (v == NULL) {
-			err_setval(AttributeError, name);
+			PyErr_SetObject(PyExc_AttributeError, name);
 			return NULL;
 		}
 	}
 #ifdef SUPPORT_OBSOLETE_ACCESS
-	if (is_accessobject(v)) {
-		v = getaccessvalue(v, getowner());
+	if (PyAccess_Check(v)) {
+		v = PyAccess_AsValue(v, PyEval_GetOwner());
 		if (v == NULL)
 			return NULL;
 	}
 	else
 #endif
-		INCREF(v);
+		Py_INCREF(v);
 	if (class != NULL) {
-		if (is_funcobject(v)) {
-			object *w = newinstancemethodobject(v, (object *)inst,
-							    (object *)class);
-			DECREF(v);
+		if (PyFunction_Check(v)) {
+			PyObject *w = PyMethod_New(v, (PyObject *)inst,
+							    (PyObject *)class);
+			Py_DECREF(v);
 			v = w;
 		}
-		else if (is_instancemethodobject(v)) {
-			object *im_class = instancemethodgetclass(v);
+		else if (PyMethod_Check(v)) {
+			PyObject *im_class = PyMethod_Class(v);
 			/* Only if classes are compatible */
-			if (issubclass((object *)class, im_class)) {
-				object *im_func = instancemethodgetfunc(v);
-				object *w = newinstancemethodobject(im_func,
-						(object *)inst, im_class);
-				DECREF(v);
+			if (PyClass_IsSubclass((PyObject *)class, im_class)) {
+				PyObject *im_func = PyMethod_Function(v);
+				PyObject *w = PyMethod_New(im_func,
+						(PyObject *)inst, im_class);
+				Py_DECREF(v);
 				v = w;
 			}
 		}
@@ -522,62 +526,63 @@ instance_getattr1(inst, name)
 	return v;
 }
 
-static object *
+static PyObject *
 instance_getattr(inst, name)
-	register instanceobject *inst;
-	object *name;
+	register PyInstanceObject *inst;
+	PyObject *name;
 {
-	register object *func, *res;
+	register PyObject *func, *res;
 	res = instance_getattr1(inst, name);
 	if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
-		object *args;
-		err_clear();
-		args = mkvalue("(OO)", inst, name);
+		PyObject *args;
+		PyErr_Clear();
+		args = Py_BuildValue("(OO)", inst, name);
 		if (args == NULL)
 			return NULL;
-		res = call_object(func, args);
-		DECREF(args);
+		res = PyEval_CallObject(func, args);
+		Py_DECREF(args);
 	}
 	return res;
 }
 
 static int
 instance_setattr1(inst, name, v)
-	instanceobject *inst;
-	object *name;
-	object *v;
+	PyInstanceObject *inst;
+	PyObject *name;
+	PyObject *v;
 {
 #ifdef SUPPORT_OBSOLETE_ACCESS
-	object *ac;
-	ac = mappinglookup(inst->in_dict, name);
-	if (ac != NULL && is_accessobject(ac))
-		return setaccessvalue(ac, getowner(), v);
+	PyObject *ac;
+	ac = PyDict_GetItem(inst->in_dict, name);
+	if (ac != NULL && PyAccess_Check(ac))
+		return PyAccess_SetValue(ac, PyEval_GetOwner(), v);
 #endif
 	if (v == NULL) {
-		int rv = mappingremove(inst->in_dict, name);
+		int rv = PyDict_DelItem(inst->in_dict, name);
 		if (rv < 0)
-			err_setstr(AttributeError,
+			PyErr_SetString(PyExc_AttributeError,
 				   "delete non-existing instance attribute");
 		return rv;
 	}
 	else
-		return mappinginsert(inst->in_dict, name, v);
+		return PyDict_SetItem(inst->in_dict, name, v);
 }
 
 static int
 instance_setattr(inst, name, v)
-	instanceobject *inst;
-	object *name;
-	object *v;
+	PyInstanceObject *inst;
+	PyObject *name;
+	PyObject *v;
 {
-	object *func, *args, *res;
-	char *sname = getstringvalue(name);
+	PyObject *func, *args, *res;
+	char *sname = PyString_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_'
 	    && (strcmp(sname, "__dict__") == 0 ||
 		strcmp(sname, "__class__") == 0)) {
-	        int n = getstringsize(name);
+	        int n = PyString_Size(name);
 		if (sname[n-1] == '_' && sname[n-2] == '_') {
-			err_setstr(TypeError, "read-only special attribute");
+			PyErr_SetString(PyExc_TypeError,
+					"read-only special attribute");
 			return -1;
 		}
 	}
@@ -588,68 +593,68 @@ instance_setattr(inst, name, v)
 	if (func == NULL)
 		return instance_setattr1(inst, name, v);
 	if (v == NULL)
-		args = mkvalue("(OO)", inst, name);
+		args = Py_BuildValue("(OO)", inst, name);
 	else
-		args = mkvalue("(OOO)", inst, name, v);
+		args = Py_BuildValue("(OOO)", inst, name, v);
 	if (args == NULL)
 		return -1;
-	res = call_object(func, args);
-	DECREF(args);
+	res = PyEval_CallObject(func, args);
+	Py_DECREF(args);
 	if (res == NULL)
 		return -1;
-	DECREF(res);
+	Py_DECREF(res);
 	return 0;
 }
 
-static object *
+static PyObject *
 instance_repr(inst)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 {
-	object *func;
-	object *res;
-	static object *reprstr;
+	PyObject *func;
+	PyObject *res;
+	static PyObject *reprstr;
 
 	if (reprstr == NULL)
 		reprstr = PyString_InternFromString("__repr__");
 	func = instance_getattr(inst, reprstr);
 	if (func == NULL) {
 		char buf[140];
-		object *classname = inst->in_class->cl_name;
+		PyObject *classname = inst->in_class->cl_name;
 		char *cname;
-		if (classname != NULL && is_stringobject(classname))
-			cname = getstringvalue(classname);
+		if (classname != NULL && PyString_Check(classname))
+			cname = PyString_AsString(classname);
 		else
 			cname = "?";
-		err_clear();
+		PyErr_Clear();
 		sprintf(buf, "<%.100s instance at %lx>", cname, (long)inst);
-		return newstringobject(buf);
+		return PyString_FromString(buf);
 	}
-	res = call_object(func, (object *)NULL);
-	DECREF(func);
+	res = PyEval_CallObject(func, (PyObject *)NULL);
+	Py_DECREF(func);
 	return res;
 }
 
-static object *
+static PyObject *
 instance_compare1(inst, other)
-	object *inst, *other;
+	PyObject *inst, *other;
 {
-	return instancebinop(inst, other, "__cmp__", "__rcmp__",
+	return PyInstance_DoBinOp(inst, other, "__cmp__", "__rcmp__",
 			     instance_compare1);
 }
 
 static int
 instance_compare(inst, other)
-	object *inst, *other;
+	PyObject *inst, *other;
 {
-	object *result;
+	PyObject *result;
 	long outcome;
 	result = instance_compare1(inst, other);
-	if (result == NULL || !is_intobject(result)) {
-		err_clear();
+	if (result == NULL || !PyInt_Check(result)) {
+		PyErr_Clear();
 		return (inst < other) ? -1 : 1;
 	}
-	outcome = getintvalue(result);
-	DECREF(result);
+	outcome = PyInt_AsLong(result);
+	Py_DECREF(result);
 	if (outcome < 0)
 		return -1;
 	else if (outcome > 0)
@@ -659,12 +664,12 @@ instance_compare(inst, other)
 
 static long
 instance_hash(inst)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 {
-	object *func;
-	object *res;
+	PyObject *func;
+	PyObject *res;
 	long outcome;
-	static object *hashstr, *cmpstr;
+	static PyObject *hashstr, *cmpstr;
 
 	if (hashstr == NULL)
 		hashstr = PyString_InternFromString("__hash__");
@@ -672,45 +677,46 @@ instance_hash(inst)
 	if (func == NULL) {
 		/* If there is no __cmp__ method, we hash on the address.
 		   If a __cmp__ method exists, there must be a __hash__. */
-		err_clear();
+		PyErr_Clear();
 		if (cmpstr == NULL)
 			cmpstr = PyString_InternFromString("__cmp__");
 		func = instance_getattr(inst, cmpstr);
 		if (func == NULL) {
-			err_clear();
+			PyErr_Clear();
 			outcome = (long)inst;
 			if (outcome == -1)
 				outcome = -2;
 			return outcome;
 		}
-		err_setstr(TypeError, "unhashable instance");
+		PyErr_SetString(PyExc_TypeError, "unhashable instance");
 		return -1;
 	}
-	res = call_object(func, (object *)NULL);
-	DECREF(func);
+	res = PyEval_CallObject(func, (PyObject *)NULL);
+	Py_DECREF(func);
 	if (res == NULL)
 		return -1;
-	if (is_intobject(res)) {
-		outcome = getintvalue(res);
+	if (PyInt_Check(res)) {
+		outcome = PyInt_AsLong(res);
 		if (outcome == -1)
 			outcome = -2;
 	}
 	else {
-		err_setstr(TypeError, "__hash__() should return an int");
+		PyErr_SetString(PyExc_TypeError,
+				"__hash__() should return an int");
 		outcome = -1;
 	}
-	DECREF(res);
+	Py_DECREF(res);
 	return outcome;
 }
 
-static object *getitemstr, *setitemstr, *delitemstr, *lenstr;
+static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
 
 static int
 instance_length(inst)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 {
-	object *func;
-	object *res;
+	PyObject *func;
+	PyObject *res;
 	int outcome;
 
 	if (lenstr == NULL)
@@ -718,57 +724,59 @@ instance_length(inst)
 	func = instance_getattr(inst, lenstr);
 	if (func == NULL)
 		return -1;
-	res = call_object(func, (object *)NULL);
-	DECREF(func);
+	res = PyEval_CallObject(func, (PyObject *)NULL);
+	Py_DECREF(func);
 	if (res == NULL)
 		return -1;
-	if (is_intobject(res)) {
-		outcome = getintvalue(res);
+	if (PyInt_Check(res)) {
+		outcome = PyInt_AsLong(res);
 		if (outcome < 0)
-			err_setstr(ValueError, "__len__() should return >= 0");
+			PyErr_SetString(PyExc_ValueError,
+					"__len__() should return >= 0");
 	}
 	else {
-		err_setstr(TypeError, "__len__() should return an int");
+		PyErr_SetString(PyExc_TypeError,
+				"__len__() should return an int");
 		outcome = -1;
 	}
-	DECREF(res);
+	Py_DECREF(res);
 	return outcome;
 }
 
-static object *
+static PyObject *
 instance_subscript(inst, key)
-	instanceobject *inst;
-	object *key;
+	PyInstanceObject *inst;
+	PyObject *key;
 {
-	object *func;
-	object *arg;
-	object *res;
+	PyObject *func;
+	PyObject *arg;
+	PyObject *res;
 
 	if (getitemstr == NULL)
 		getitemstr = PyString_InternFromString("__getitem__");
 	func = instance_getattr(inst, getitemstr);
 	if (func == NULL)
 		return NULL;
-	arg = mkvalue("(O)", key);
+	arg = Py_BuildValue("(O)", key);
 	if (arg == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return NULL;
 	}
-	res = call_object(func, arg);
-	DECREF(func);
-	DECREF(arg);
+	res = PyEval_CallObject(func, arg);
+	Py_DECREF(func);
+	Py_DECREF(arg);
 	return res;
 }
 
 static int
 instance_ass_subscript(inst, key, value)
-	instanceobject*inst;
-	object *key;
-	object *value;
+	PyInstanceObject*inst;
+	PyObject *key;
+	PyObject *value;
 {
-	object *func;
-	object *arg;
-	object *res;
+	PyObject *func;
+	PyObject *arg;
+	PyObject *res;
 
 	if (value == NULL) {
 		if (delitemstr == NULL)
@@ -783,82 +791,82 @@ instance_ass_subscript(inst, key, value)
 	if (func == NULL)
 		return -1;
 	if (value == NULL)
-		arg = mkvalue("(O)", key);
+		arg = Py_BuildValue("(O)", key);
 	else
-		arg = mkvalue("(OO)", key, value);
+		arg = Py_BuildValue("(OO)", key, value);
 	if (arg == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return -1;
 	}
-	res = call_object(func, arg);
-	DECREF(func);
-	DECREF(arg);
+	res = PyEval_CallObject(func, arg);
+	Py_DECREF(func);
+	Py_DECREF(arg);
 	if (res == NULL)
 		return -1;
-	DECREF(res);
+	Py_DECREF(res);
 	return 0;
 }
 
-static mapping_methods instance_as_mapping = {
+static PyMappingMethods instance_as_mapping = {
 	(inquiry)instance_length, /*mp_length*/
 	(binaryfunc)instance_subscript, /*mp_subscript*/
 	(objobjargproc)instance_ass_subscript, /*mp_ass_subscript*/
 };
 
-static object *
+static PyObject *
 instance_item(inst, i)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 	int i;
 {
-	object *func, *arg, *res;
+	PyObject *func, *arg, *res;
 
 	if (getitemstr == NULL)
 		getitemstr = PyString_InternFromString("__getitem__");
 	func = instance_getattr(inst, getitemstr);
 	if (func == NULL)
 		return NULL;
-	arg = mkvalue("(i)", i);
+	arg = Py_BuildValue("(i)", i);
 	if (arg == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return NULL;
 	}
-	res = call_object(func, arg);
-	DECREF(func);
-	DECREF(arg);
+	res = PyEval_CallObject(func, arg);
+	Py_DECREF(func);
+	Py_DECREF(arg);
 	return res;
 }
 
-static object *
+static PyObject *
 instance_slice(inst, i, j)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 	int i, j;
 {
-	object *func, *arg, *res;
-	static object *getslicestr;
+	PyObject *func, *arg, *res;
+	static PyObject *getslicestr;
 
 	if (getslicestr == NULL)
 		getslicestr = PyString_InternFromString("__getslice__");
 	func = instance_getattr(inst, getslicestr);
 	if (func == NULL)
 		return NULL;
-	arg = mkvalue("(ii)", i, j);
+	arg = Py_BuildValue("(ii)", i, j);
 	if (arg == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return NULL;
 	}
-	res = call_object(func, arg);
-	DECREF(func);
-	DECREF(arg);
+	res = PyEval_CallObject(func, arg);
+	Py_DECREF(func);
+	Py_DECREF(arg);
 	return res;
 }
 
 static int
 instance_ass_item(inst, i, item)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 	int i;
-	object *item;
+	PyObject *item;
 {
-	object *func, *arg, *res;
+	PyObject *func, *arg, *res;
 
 	if (item == NULL) {
 		if (delitemstr == NULL)
@@ -873,61 +881,63 @@ instance_ass_item(inst, i, item)
 	if (func == NULL)
 		return -1;
 	if (item == NULL)
-		arg = mkvalue("i", i);
+		arg = Py_BuildValue("i", i);
 	else
-		arg = mkvalue("(iO)", i, item);
+		arg = Py_BuildValue("(iO)", i, item);
 	if (arg == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return -1;
 	}
-	res = call_object(func, arg);
-	DECREF(func);
-	DECREF(arg);
+	res = PyEval_CallObject(func, arg);
+	Py_DECREF(func);
+	Py_DECREF(arg);
 	if (res == NULL)
 		return -1;
-	DECREF(res);
+	Py_DECREF(res);
 	return 0;
 }
 
 static int
 instance_ass_slice(inst, i, j, value)
-	instanceobject *inst;
+	PyInstanceObject *inst;
 	int i, j;
-	object *value;
+	PyObject *value;
 {
-	object *func, *arg, *res;
-	static object *setslicestr, *delslicestr;
+	PyObject *func, *arg, *res;
+	static PyObject *setslicestr, *delslicestr;
 
 	if (value == NULL) {
 		if (delslicestr == NULL)
-			delslicestr = PyString_InternFromString("__delslice__");
+			delslicestr =
+				PyString_InternFromString("__delslice__");
 		func = instance_getattr(inst, delslicestr);
 	}
 	else {
 		if (setslicestr == NULL)
-			setslicestr = PyString_InternFromString("__setslice__");
+			setslicestr =
+				PyString_InternFromString("__setslice__");
 		func = instance_getattr(inst, setslicestr);
 	}
 	if (func == NULL)
 		return -1;
 	if (value == NULL)
-		arg = mkvalue("(ii)", i, j);
+		arg = Py_BuildValue("(ii)", i, j);
 	else
-		arg = mkvalue("(iiO)", i, j, value);
+		arg = Py_BuildValue("(iiO)", i, j, value);
 	if (arg == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return -1;
 	}
-	res = call_object(func, arg);
-	DECREF(func);
-	DECREF(arg);
+	res = PyEval_CallObject(func, arg);
+	Py_DECREF(func);
+	Py_DECREF(arg);
 	if (res == NULL)
 		return -1;
-	DECREF(res);
+	Py_DECREF(res);
 	return 0;
 }
 
-static sequence_methods instance_as_sequence = {
+static PySequenceMethods instance_as_sequence = {
 	(inquiry)instance_length, /*sq_length*/
 	0, /*sq_concat*/
 	0, /*sq_repeat*/
@@ -937,44 +947,44 @@ static sequence_methods instance_as_sequence = {
 	(intintobjargproc)instance_ass_slice, /*sq_ass_slice*/
 };
 
-static object *
+static PyObject *
 generic_unary_op(self, methodname)
-	instanceobject *self;
-	object *methodname;
+	PyInstanceObject *self;
+	PyObject *methodname;
 {
-	object *func, *res;
+	PyObject *func, *res;
 
 	if ((func = instance_getattr(self, methodname)) == NULL)
 		return NULL;
-	res = call_object(func, (object *)NULL);
-	DECREF(func);
+	res = PyEval_CallObject(func, (PyObject *)NULL);
+	Py_DECREF(func);
 	return res;
 }
 
 
 /* Forward */
-static int halfbinop Py_PROTO((object *, object *, char *, object **,
-			  object * (*) Py_PROTO((object *, object *)), int ));
+static int halfbinop Py_PROTO((PyObject *, PyObject *, char *, PyObject **,
+		PyObject * (*) Py_PROTO((PyObject *, PyObject *)), int ));
 
 
 /* Implement a binary operator involving at least one class instance. */
 
-object *
-instancebinop(v, w, opname, ropname, thisfunc)
-	object *v;
-	object *w;
+PyObject *
+PyInstance_DoBinOp(v, w, opname, ropname, thisfunc)
+	PyObject *v;
+	PyObject *w;
 	char *opname;
 	char *ropname;
-	object * (*thisfunc) PROTO((object *, object *));
+	PyObject * (*thisfunc) Py_PROTO((PyObject *, PyObject *));
 {
 	char buf[256];
-	object *result = NULL;
+	PyObject *result = NULL;
 	if (halfbinop(v, w, opname, &result, thisfunc, 0) <= 0)
 		return result;
 	if (halfbinop(w, v, ropname, &result, thisfunc, 1) <= 0)
 		return result;
 	sprintf(buf, "%s nor %s defined for these operands", opname, ropname);
-	err_setstr(TypeError, buf);
+	PyErr_SetString(PyExc_TypeError, buf);
 	return NULL;
 }
 
@@ -986,152 +996,152 @@ instancebinop(v, w, opname, ropname, thisfunc)
    1  if we could try another operation
 */
 
-static object *coerce_obj;
+static PyObject *coerce_obj;
 
 static int
 halfbinop(v, w, opname, r_result, thisfunc, swapped)
-	object *v;
-	object *w;
+	PyObject *v;
+	PyObject *w;
 	char *opname;
-	object **r_result;
-	object * (*thisfunc) PROTO((object *, object *));
+	PyObject **r_result;
+	PyObject * (*thisfunc) Py_PROTO((PyObject *, PyObject *));
 	int swapped;
 {
-	object *func;
-	object *args;
-	object *coerce;
-	object *coerced = NULL;
-	object *v1;
+	PyObject *func;
+	PyObject *args;
+	PyObject *PyNumber_Coerce;
+	PyObject *coerced = NULL;
+	PyObject *v1;
 	
-	if (!is_instanceobject(v))
+	if (!PyInstance_Check(v))
 		return 1;
 	if (coerce_obj == NULL) {
 		coerce_obj = PyString_InternFromString("__coerce__");
 		if (coerce_obj == NULL)
 			return -1;
 	}
-	coerce = getattro(v, coerce_obj);
-	if (coerce == NULL) {
-		err_clear();
+	PyNumber_Coerce = PyObject_GetAttr(v, coerce_obj);
+	if (PyNumber_Coerce == NULL) {
+		PyErr_Clear();
 	}
 	else {
-		args = mkvalue("(O)", w);
+		args = Py_BuildValue("(O)", w);
 		if (args == NULL) {
 			return -1;
 		}
-		coerced = call_object(coerce, args);
-		DECREF(args);
-		DECREF(coerce);
+		coerced = PyEval_CallObject(PyNumber_Coerce, args);
+		Py_DECREF(args);
+		Py_DECREF(PyNumber_Coerce);
 		if (coerced == NULL) {
 			return -1;
 		}
-		if (coerced == None) {
-			DECREF(coerced);
+		if (coerced == Py_None) {
+			Py_DECREF(coerced);
 			return 1;
 		}
-		if (!is_tupleobject(coerced) || gettuplesize(coerced) != 2) {
-			DECREF(coerced);
-			err_setstr(TypeError,
+		if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
+			Py_DECREF(coerced);
+			PyErr_SetString(PyExc_TypeError,
 				   "coercion should return None or 2-tuple");
 			return -1;
 		}
-		v1 = gettupleitem(coerced, 0);
-		w = gettupleitem(coerced, 1);
+		v1 = PyTuple_GetItem(coerced, 0);
+		w = PyTuple_GetItem(coerced, 1);
 		if (v1 != v) {
 			v = v1;
-			if (!is_instanceobject(v) && !is_instanceobject(w)) {
+			if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
 				if (swapped)
 					*r_result = (*thisfunc)(w, v);
 				else
 					*r_result = (*thisfunc)(v, w);
-				DECREF(coerced);
+				Py_DECREF(coerced);
 				return *r_result == NULL ? -1 : 0;
 			}
 		}
-		w = gettupleitem(coerced, 1);
+		w = PyTuple_GetItem(coerced, 1);
 	}
-	func = getattr(v, opname);
+	func = PyObject_GetAttrString(v, opname);
 	if (func == NULL) {
-		XDECREF(coerced);
-		if (err_occurred() != AttributeError)
+		Py_XDECREF(coerced);
+		if (PyErr_Occurred() != PyExc_AttributeError)
 			return -1;
-		err_clear();
+		PyErr_Clear();
 		return 1;
 	}
-	args = mkvalue("(O)", w);
+	args = Py_BuildValue("(O)", w);
 	if (args == NULL) {
-		DECREF(func);
-		XDECREF(coerced);
+		Py_DECREF(func);
+		Py_XDECREF(coerced);
 		return -1;
 	}
-	*r_result = call_object(func, args);
-	DECREF(args);
-	DECREF(func);
-	XDECREF(coerced);
+	*r_result = PyEval_CallObject(func, args);
+	Py_DECREF(args);
+	Py_DECREF(func);
+	Py_XDECREF(coerced);
 	return *r_result == NULL ? -1 : 0;
 }
 
 static int
 instance_coerce(pv, pw)
-	object **pv;
-	object **pw;
+	PyObject **pv;
+	PyObject **pw;
 {
-	object *v = *pv;
-	object *w = *pw;
-	object *coerce;
-	object *args;
-	object *coerced;
+	PyObject *v = *pv;
+	PyObject *w = *pw;
+	PyObject *PyNumber_Coerce;
+	PyObject *args;
+	PyObject *coerced;
 
 	if (coerce_obj == NULL) {
 		coerce_obj = PyString_InternFromString("__coerce__");
 		if (coerce_obj == NULL)
 			return -1;
 	}
-	coerce = getattro(v, coerce_obj);
-	if (coerce == NULL) {
+	PyNumber_Coerce = PyObject_GetAttr(v, coerce_obj);
+	if (PyNumber_Coerce == NULL) {
 		/* No __coerce__ method: always OK */
-		err_clear();
-		INCREF(v);
-		INCREF(w);
+		PyErr_Clear();
+		Py_INCREF(v);
+		Py_INCREF(w);
 		return 0;
 	}
 	/* Has __coerce__ method: call it */
-	args = mkvalue("(O)", w);
+	args = Py_BuildValue("(O)", w);
 	if (args == NULL) {
 		return -1;
 	}
-	coerced = call_object(coerce, args);
-	DECREF(args);
-	DECREF(coerce);
+	coerced = PyEval_CallObject(PyNumber_Coerce, args);
+	Py_DECREF(args);
+	Py_DECREF(PyNumber_Coerce);
 	if (coerced == NULL) {
 		/* __coerce__ call raised an exception */
 		return -1;
 	}
-	if (coerced == None) {
+	if (coerced == Py_None) {
 		/* __coerce__ says "I can't do it" */
-		DECREF(coerced);
+		Py_DECREF(coerced);
 		return 1;
 	}
-	if (!is_tupleobject(coerced) || gettuplesize(coerced) != 2) {
+	if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
 		/* __coerce__ return value is malformed */
-		DECREF(coerced);
-		err_setstr(TypeError,
+		Py_DECREF(coerced);
+		PyErr_SetString(PyExc_TypeError,
 			   "coercion should return None or 2-tuple");
 		return -1;
 	}
 	/* __coerce__ returned two new values */
-	*pv = gettupleitem(coerced, 0);
-	*pw = gettupleitem(coerced, 1);
-	INCREF(*pv);
-	INCREF(*pw);
-	DECREF(coerced);
+	*pv = PyTuple_GetItem(coerced, 0);
+	*pw = PyTuple_GetItem(coerced, 1);
+	Py_INCREF(*pv);
+	Py_INCREF(*pw);
+	Py_DECREF(coerced);
 	return 0;
 }
 
 
 #define UNARY(funcname, methodname) \
-static object *funcname(self) instanceobject *self; { \
-	static object *o; \
+static PyObject *funcname(self) PyInstanceObject *self; { \
+	static PyObject *o; \
 	if (o == NULL) o = PyString_InternFromString(methodname); \
 	return generic_unary_op(self, o); \
 }
@@ -1142,38 +1152,40 @@ UNARY(instance_abs, "__abs__")
 
 static int
 instance_nonzero(self)
-	instanceobject *self;
+	PyInstanceObject *self;
 {
-	object *func, *res;
+	PyObject *func, *res;
 	long outcome;
-	static object *nonzerostr;
+	static PyObject *nonzerostr;
 
 	if (nonzerostr == NULL)
 		nonzerostr = PyString_InternFromString("__nonzero__");
 	if ((func = instance_getattr(self, nonzerostr)) == NULL) {
-		err_clear();
+		PyErr_Clear();
 		if (lenstr == NULL)
 			lenstr = PyString_InternFromString("__len__");
 		if ((func = instance_getattr(self, lenstr)) == NULL) {
-			err_clear();
+			PyErr_Clear();
 			/* Fall back to the default behavior:
 			   all instances are nonzero */
 			return 1;
 		}
 	}
-	res = call_object(func, (object *)NULL);
-	DECREF(func);
+	res = PyEval_CallObject(func, (PyObject *)NULL);
+	Py_DECREF(func);
 	if (res == NULL)
 		return -1;
-	if (!is_intobject(res)) {
-		DECREF(res);
-		err_setstr(TypeError, "__nonzero__ should return an int");
+	if (!PyInt_Check(res)) {
+		Py_DECREF(res);
+		PyErr_SetString(PyExc_TypeError,
+				"__nonzero__ should return an int");
 		return -1;
 	}
-	outcome = getintvalue(res);
-	DECREF(res);
+	outcome = PyInt_AsLong(res);
+	Py_DECREF(res);
 	if (outcome < 0) {
-		err_setstr(ValueError, "__nonzero__ should return >= 0");
+		PyErr_SetString(PyExc_ValueError,
+				"__nonzero__ should return >= 0");
 		return -1;
 	}
 	return outcome > 0;
@@ -1187,35 +1199,35 @@ UNARY(instance_oct, "__oct__")
 UNARY(instance_hex, "__hex__")
 
 /* This version is for ternary calls only (z != None) */
-static object *
+static PyObject *
 instance_pow(v, w, z)
-	object *v;
-	object *w;
-	object *z;
+	PyObject *v;
+	PyObject *w;
+	PyObject *z;
 {
 	/* XXX Doesn't do coercions... */
-	object *func;
-	object *args;
-	object *result;
-	static object *powstr;
+	PyObject *func;
+	PyObject *args;
+	PyObject *result;
+	static PyObject *powstr;
 
 	if (powstr == NULL)
 		powstr = PyString_InternFromString("__pow__");
-	func = getattro(v, powstr);
+	func = PyObject_GetAttr(v, powstr);
 	if (func == NULL)
 		return NULL;
-	args = mkvalue("(OO)", w, z);
+	args = Py_BuildValue("(OO)", w, z);
 	if (args == NULL) {
-		DECREF(func);
+		Py_DECREF(func);
 		return NULL;
 	}
-	result = call_object(func, args);
-	DECREF(func);
-	DECREF(args);
+	result = PyEval_CallObject(func, args);
+	Py_DECREF(func);
+	Py_DECREF(args);
 	return result;
 }
 
-static number_methods instance_as_number = {
+static PyNumberMethods instance_as_number = {
 	0, /*nb_add*/
 	0, /*nb_subtract*/
 	0, /*nb_multiply*/
@@ -1241,11 +1253,11 @@ static number_methods instance_as_number = {
 	(unaryfunc)instance_hex, /*nb_hex*/
 };
 
-typeobject Instancetype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject PyInstance_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,
 	"instance",
-	sizeof(instanceobject),
+	sizeof(PyInstanceObject),
 	0,
 	(destructor)instance_dealloc, /*tp_dealloc*/
 	0,			/*tp_print*/
@@ -1271,71 +1283,71 @@ typeobject Instancetype = {
 */
 
 typedef struct {
-	OB_HEAD
-	object	*im_func;	/* The function implementing the method */
-	object	*im_self;	/* The instance it is bound to, or NULL */
-	object	*im_class;	/* The class that defined the method */
-} instancemethodobject;
-
-object *
-newinstancemethodobject(func, self, class)
-	object *func;
-	object *self;
-	object *class;
+	PyObject_HEAD
+	PyObject *im_func;	/* The function implementing the method */
+	PyObject *im_self;	/* The instance it is bound to, or NULL */
+	PyObject *im_class;	/* The class that defined the method */
+} PyMethodObject;
+
+PyObject *
+PyMethod_New(func, self, class)
+	PyObject *func;
+	PyObject *self;
+	PyObject *class;
 {
-	register instancemethodobject *im;
-	if (!is_funcobject(func)) {
-		err_badcall();
+	register PyMethodObject *im;
+	if (!PyFunction_Check(func)) {
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	im = NEWOBJ(instancemethodobject, &Instancemethodtype);
+	im = PyObject_NEW(PyMethodObject, &PyMethod_Type);
 	if (im == NULL)
 		return NULL;
-	INCREF(func);
+	Py_INCREF(func);
 	im->im_func = func;
-	XINCREF(self);
+	Py_XINCREF(self);
 	im->im_self = self;
-	INCREF(class);
+	Py_INCREF(class);
 	im->im_class = class;
-	return (object *)im;
+	return (PyObject *)im;
 }
 
-object *
-instancemethodgetfunc(im)
-	register object *im;
+PyObject *
+PyMethod_Function(im)
+	register PyObject *im;
 {
-	if (!is_instancemethodobject(im)) {
-		err_badcall();
+	if (!PyMethod_Check(im)) {
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	return ((instancemethodobject *)im)->im_func;
+	return ((PyMethodObject *)im)->im_func;
 }
 
-object *
-instancemethodgetself(im)
-	register object *im;
+PyObject *
+PyMethod_Self(im)
+	register PyObject *im;
 {
-	if (!is_instancemethodobject(im)) {
-		err_badcall();
+	if (!PyMethod_Check(im)) {
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	return ((instancemethodobject *)im)->im_self;
+	return ((PyMethodObject *)im)->im_self;
 }
 
-object *
-instancemethodgetclass(im)
-	register object *im;
+PyObject *
+PyMethod_Class(im)
+	register PyObject *im;
 {
-	if (!is_instancemethodobject(im)) {
-		err_badcall();
+	if (!PyMethod_Check(im)) {
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	return ((instancemethodobject *)im)->im_class;
+	return ((PyMethodObject *)im)->im_class;
 }
 
 /* Class method methods */
 
-#define OFF(x) offsetof(instancemethodobject, x)
+#define OFF(x) offsetof(PyMethodObject, x)
 
 static struct memberlist instancemethod_memberlist[] = {
 	{"im_func",	T_OBJECT,	OFF(im_func)},
@@ -1347,106 +1359,106 @@ static struct memberlist instancemethod_memberlist[] = {
 	{NULL}	/* Sentinel */
 };
 
-static object *
+static PyObject *
 instancemethod_getattr(im, name)
-	register instancemethodobject *im;
-	object *name;
+	register PyMethodObject *im;
+	PyObject *name;
 {
-	char *sname = getstringvalue(name);
+	char *sname = PyString_AsString(name);
 	if (sname[0] == '_') {
-		funcobject *func = (funcobject *)(im->im_func);
+		PyFunctionObject *func = (PyFunctionObject *)(im->im_func);
 		if (strcmp(sname, "__name__") == 0) {
-			INCREF(func->func_name);
+			Py_INCREF(func->func_name);
 			return func->func_name;
 		}
 		if (strcmp(sname, "__doc__") == 0) {
-			INCREF(func->func_doc);
+			Py_INCREF(func->func_doc);
 			return func->func_doc;
 		}
 	}
-	if (getrestricted()) {
-		err_setstr(RuntimeError,
-			   "instance-method attributes not accessible in restricted mode");
+	if (PyEval_GetRestricted()) {
+		PyErr_SetString(PyExc_RuntimeError,
+	    "instance-method attributes not accessible in restricted mode");
 		return NULL;
 	}
-	return getmember((char *)im, instancemethod_memberlist, sname);
+	return PyMember_Get((char *)im, instancemethod_memberlist, sname);
 }
 
 static void
 instancemethod_dealloc(im)
-	register instancemethodobject *im;
+	register PyMethodObject *im;
 {
-	DECREF(im->im_func);
-	XDECREF(im->im_self);
-	DECREF(im->im_class);
+	Py_DECREF(im->im_func);
+	Py_XDECREF(im->im_self);
+	Py_DECREF(im->im_class);
 	free((ANY *)im);
 }
 
 static int
 instancemethod_compare(a, b)
-	instancemethodobject *a, *b;
+	PyMethodObject *a, *b;
 {
 	if (a->im_self != b->im_self)
 		return (a->im_self < b->im_self) ? -1 : 1;
-	return cmpobject(a->im_func, b->im_func);
+	return PyObject_Compare(a->im_func, b->im_func);
 }
 
-static object *
+static PyObject *
 instancemethod_repr(a)
-	instancemethodobject *a;
+	PyMethodObject *a;
 {
 	char buf[240];
-	instanceobject *self = (instanceobject *)(a->im_self);
-	funcobject *func = (funcobject *)(a->im_func);
-	classobject *class = (classobject *)(a->im_class);
-	object *fclassname, *iclassname, *funcname;
+	PyInstanceObject *self = (PyInstanceObject *)(a->im_self);
+	PyFunctionObject *func = (PyFunctionObject *)(a->im_func);
+	PyClassObject *class = (PyClassObject *)(a->im_class);
+	PyObject *fclassname, *iclassname, *funcname;
 	char *fcname, *icname, *fname;
 	fclassname = class->cl_name;
 	funcname = func->func_name;
-	if (fclassname != NULL && is_stringobject(fclassname))
-		fcname = getstringvalue(fclassname);
+	if (fclassname != NULL && PyString_Check(fclassname))
+		fcname = PyString_AsString(fclassname);
 	else
 		fcname = "?";
-	if (funcname != NULL && is_stringobject(funcname))
-		fname = getstringvalue(funcname);
+	if (funcname != NULL && PyString_Check(funcname))
+		fname = PyString_AsString(funcname);
 	else
 		fname = "?";
 	if (self == NULL)
 		sprintf(buf, "<unbound method %.100s.%.100s>", fcname, fname);
 	else {
 		iclassname = self->in_class->cl_name;
-		if (iclassname != NULL && is_stringobject(iclassname))
-			icname = getstringvalue(iclassname);
+		if (iclassname != NULL && PyString_Check(iclassname))
+			icname = PyString_AsString(iclassname);
 		else
 			icname = "?";
 		sprintf(buf, "<method %.60s.%.60s of %.60s instance at %lx>",
 			fcname, fname, icname, (long)self);
 	}
-	return newstringobject(buf);
+	return PyString_FromString(buf);
 }
 
 static long
 instancemethod_hash(a)
-	instancemethodobject *a;
+	PyMethodObject *a;
 {
 	long x, y;
 	if (a->im_self == NULL)
-		x = hashobject(None);
+		x = PyObject_Hash(Py_None);
 	else
-		x = hashobject(a->im_self);
+		x = PyObject_Hash(a->im_self);
 	if (x == -1)
 		return -1;
-	y = hashobject(a->im_func);
+	y = PyObject_Hash(a->im_func);
 	if (y == -1)
 		return -1;
 	return x ^ y;
 }
 
-typeobject Instancemethodtype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject PyMethod_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,
 	"instance method",
-	sizeof(instancemethodobject),
+	sizeof(PyMethodObject),
 	0,
 	(destructor)instancemethod_dealloc, /*tp_dealloc*/
 	0,			/*tp_print*/