diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 69cb7aa..d15fab1 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -44,140 +44,137 @@
 - ps1, ps2: optional primary and secondary prompts (strings)
 */
 
-#include "allobjects.h"
+#include "Python.h"
 
-#include "sysmodule.h"
-#include "import.h"
-#include "modsupport.h"
 #include "osdefs.h"
 
-object *sys_trace, *sys_profile;
-int sys_checkinterval = 10;
+PyObject *_PySys_TraceFunc, *_PySys_ProfileFunc;
+int _PySys_CheckInterval = 10;
 
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
-static object *sysdict;
+static PyObject *sysdict;
 
 #ifdef MS_COREDLL
 extern void *PyWin_DLLhModule;
 #endif
 
-object *
-sysget(name)
+PyObject *
+PySys_GetObject(name)
 	char *name;
 {
-	return dictlookup(sysdict, name);
+	return PyDict_GetItemString(sysdict, name);
 }
 
 FILE *
-sysgetfile(name, def)
+PySys_GetFile(name, def)
 	char *name;
 	FILE *def;
 {
 	FILE *fp = NULL;
-	object *v = sysget(name);
-	if (v != NULL && is_fileobject(v))
-		fp = getfilefile(v);
+	PyObject *v = PySys_GetObject(name);
+	if (v != NULL && PyFile_Check(v))
+		fp = PyFile_AsFile(v);
 	if (fp == NULL)
 		fp = def;
 	return fp;
 }
 
 int
-sysset(name, v)
+PySys_SetObject(name, v)
 	char *name;
-	object *v;
+	PyObject *v;
 {
 	if (v == NULL) {
-		if (dictlookup(sysdict, name) == NULL)
+		if (PyDict_GetItemString(sysdict, name) == NULL)
 			return 0;
 		else
-			return dictremove(sysdict, name);
+			return PyDict_DelItemString(sysdict, name);
 	}
 	else
-		return dictinsert(sysdict, name, v);
+		return PyDict_SetItemString(sysdict, name, v);
 }
 
-static object *
+static PyObject *
 sys_exit(self, args)
-	object *self;
-	object *args;
+	PyObject *self;
+	PyObject *args;
 {
 	/* Raise SystemExit so callers may catch it or clean up. */
-	err_setval(SystemExit, args);
+	PyErr_SetObject(PyExc_SystemExit, args);
 	return NULL;
 }
 
-static object *
+static PyObject *
 sys_settrace(self, args)
-	object *self;
-	object *args;
+	PyObject *self;
+	PyObject *args;
 {
-	if (args == None)
+	if (args == Py_None)
 		args = NULL;
 	else
-		XINCREF(args);
-	XDECREF(sys_trace);
-	sys_trace = args;
-	INCREF(None);
-	return None;
+		Py_XINCREF(args);
+	Py_XDECREF(_PySys_TraceFunc);
+	_PySys_TraceFunc = args;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 sys_setprofile(self, args)
-	object *self;
-	object *args;
+	PyObject *self;
+	PyObject *args;
 {
-	if (args == None)
+	if (args == Py_None)
 		args = NULL;
 	else
-		XINCREF(args);
-	XDECREF(sys_profile);
-	sys_profile = args;
-	INCREF(None);
-	return None;
+		Py_XINCREF(args);
+	Py_XDECREF(_PySys_ProfileFunc);
+	_PySys_ProfileFunc = args;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 sys_setcheckinterval(self, args)
-	object *self;
-	object *args;
+	PyObject *self;
+	PyObject *args;
 {
-	if (!newgetargs(args, "i", &sys_checkinterval))
+	if (!PyArg_ParseTuple(args, "i", &_PySys_CheckInterval))
 		return NULL;
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 #ifdef USE_MALLOPT
 /* Link with -lmalloc (or -lmpc) on an SGI */
 #include <malloc.h>
 
-static object *
+static PyObject *
 sys_mdebug(self, args)
-	object *self;
-	object *args;
+	PyObject *self;
+	PyObject *args;
 {
 	int flag;
-	if (!getargs(args, "i", &flag))
+	if (!PyArg_Parse(args, "i", &flag))
 		return NULL;
 	mallopt(M_DEBUG, flag);
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 #endif /* USE_MALLOPT */
 
-static object *
+static PyObject *
 sys_getrefcount(self, args)
-	object *self;
-	object *args;
+	PyObject *self;
+	PyObject *args;
 {
-	object *arg;
-	if (!getargs(args, "O", &arg))
+	PyObject *arg;
+	if (!PyArg_Parse(args, "O", &arg))
 		return NULL;
-	return newintobject((long) arg->ob_refcnt);
+	return PyInt_FromLong((long) arg->ob_refcnt);
 }
 
 #ifdef COUNT_ALLOCS
@@ -203,7 +200,7 @@
 extern PyObject *_Py_GetDXProfile Py_PROTO((PyObject *,  PyObject *));
 #endif
 
-static struct methodlist sys_methods[] = {
+static PyMethodDef sys_methods[] = {
 	/* Might as well keep this in alphabetic order */
 	{"exit",	sys_exit, 0},
 #ifdef COUNT_ALLOCS
@@ -225,93 +222,100 @@
 	{NULL,		NULL}		/* sentinel */
 };
 
-static object *sysin, *sysout, *syserr;
+static PyObject *sysin, *sysout, *syserr;
 
-static object *
+static PyObject *
 list_builtin_module_names()
 {
-	object *list = newlistobject(0);
+	PyObject *list = PyList_New(0);
 	int i;
 	if (list == NULL)
 		return NULL;
 	for (i = 0; inittab[i].name != NULL; i++) {
-		object *name = newstringobject(inittab[i].name);
+		PyObject *name = PyString_FromString(inittab[i].name);
 		if (name == NULL)
 			break;
-		addlistitem(list, name);
-		DECREF(name);
+		PyList_Append(list, name);
+		Py_DECREF(name);
 	}
-	if (sortlist(list) != 0) {
-		DECREF(list);
+	if (PyList_Sort(list) != 0) {
+		Py_DECREF(list);
 		list = NULL;
 	}
 	if (list) {
-		object *v = listtuple(list);
-		DECREF(list);
+		PyObject *v = PyList_AsTuple(list);
+		Py_DECREF(list);
 		list = v;
 	}
 	return list;
 }
 
 void
-initsys()
+PySys_Init()
 {
-	extern long getmaxint PROTO((void));
-	extern char *getversion PROTO((void));
-	extern char *getcopyright PROTO((void));
-	extern char *getplatform PROTO((void));
-	extern char *Py_GetPrefix PROTO((void));
-	extern char *Py_GetExecPrefix PROTO((void));
-	extern int fclose PROTO((FILE *));
-	object *m = initmodule("sys", sys_methods);
-	object *v;
-	sysdict = getmoduledict(m);
-	INCREF(sysdict);
+	extern long PyInt_GetMax Py_PROTO((void));
+	extern char *Py_GetVersion Py_PROTO((void));
+	extern char *Py_GetCopyright Py_PROTO((void));
+	extern char *Py_GetPlatform Py_PROTO((void));
+	extern char *Py_GetPrefix Py_PROTO((void));
+	extern char *Py_GetExecPrefix Py_PROTO((void));
+	extern int fclose Py_PROTO((FILE *));
+	PyObject *m = Py_InitModule("sys", sys_methods);
+	PyObject *v;
+	sysdict = PyModule_GetDict(m);
+	Py_INCREF(sysdict);
 	/* NB keep an extra ref to the std files to avoid closing them
 	   when the user deletes them */
-	sysin = newopenfileobject(stdin, "<stdin>", "r", fclose);
-	sysout = newopenfileobject(stdout, "<stdout>", "w", fclose);
-	syserr = newopenfileobject(stderr, "<stderr>", "w", fclose);
-	if (err_occurred())
-		fatal("can't initialize sys.std{in,out,err}");
-	dictinsert(sysdict, "stdin", sysin);
-	dictinsert(sysdict, "stdout", sysout);
-	dictinsert(sysdict, "stderr", syserr);
-	dictinsert(sysdict, "version", v = newstringobject(getversion()));
-	XDECREF(v);
-	dictinsert(sysdict, "copyright", v = newstringobject(getcopyright()));
-	XDECREF(v);
-	dictinsert(sysdict, "platform", v = newstringobject(getplatform()));
-	XDECREF(v);
-	dictinsert(sysdict, "prefix", v = newstringobject(Py_GetPrefix()));
-	XDECREF(v);
-	dictinsert(sysdict, "exec_prefix",
-		   v = newstringobject(Py_GetExecPrefix()));
-	XDECREF(v);
-	dictinsert(sysdict, "maxint", v = newintobject(getmaxint()));
-	XDECREF(v);
-	dictinsert(sysdict, "modules", get_modules());
-	dictinsert(sysdict, "builtin_module_names",
+	sysin = PyFile_FromFile(stdin, "<stdin>", "r", fclose);
+	sysout = PyFile_FromFile(stdout, "<stdout>", "w", fclose);
+	syserr = PyFile_FromFile(stderr, "<stderr>", "w", fclose);
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize sys.std{in,out,err}");
+	PyDict_SetItemString(sysdict, "stdin", sysin);
+	PyDict_SetItemString(sysdict, "stdout", sysout);
+	PyDict_SetItemString(sysdict, "stderr", syserr);
+	PyDict_SetItemString(sysdict, "version",
+			     v = PyString_FromString(Py_GetVersion()));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "copyright",
+			     v = PyString_FromString(Py_GetCopyright()));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "platform",
+			     v = PyString_FromString(Py_GetPlatform()));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "prefix",
+			     v = PyString_FromString(Py_GetPrefix()));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "exec_prefix",
+		   v = PyString_FromString(Py_GetExecPrefix()));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "maxint",
+			     v = PyInt_FromLong(PyInt_GetMax()));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "modules", PyImport_GetModuleDict());
+	PyDict_SetItemString(sysdict, "builtin_module_names",
 		   v = list_builtin_module_names());
-	XDECREF(v);
+	Py_XDECREF(v);
 #ifdef MS_COREDLL
-	dictinsert(sysdict, "dllhandle", v = newintobject((int)PyWin_DLLhModule));
-	XDECREF(v);
-	dictinsert(sysdict, "winver", v = newstringobject(MS_DLL_ID));
-	XDECREF(v);
+	PyDict_SetItemString(sysdict, "dllhandle",
+			     v = PyInt_FromLong((int)PyWin_DLLhModule));
+	Py_XDECREF(v);
+	PyDict_SetItemString(sysdict, "winver",
+			     v = PyString_FromString(MS_DLL_ID));
+	Py_XDECREF(v);
 #endif
-	if (err_occurred())
-		fatal("can't insert sys.* objects in sys dict");
+	if (PyErr_Occurred())
+		Py_FatalError("can't insert sys.* objects in sys dict");
 }
 
-static object *
+static PyObject *
 makepathobject(path, delim)
 	char *path;
 	int delim;
 {
 	int i, n;
 	char *p;
-	object *v, *w;
+	PyObject *v, *w;
 	
 	n = 1;
 	p = path;
@@ -319,19 +323,19 @@
 		n++;
 		p++;
 	}
-	v = newlistobject(n);
+	v = PyList_New(n);
 	if (v == NULL)
 		return NULL;
 	for (i = 0; ; i++) {
 		p = strchr(path, delim);
 		if (p == NULL)
 			p = strchr(path, '\0'); /* End of string */
-		w = newsizedstringobject(path, (int) (p - path));
+		w = PyString_FromStringAndSize(path, (int) (p - path));
 		if (w == NULL) {
-			DECREF(v);
+			Py_DECREF(v);
 			return NULL;
 		}
-		setlistitem(v, i, w);
+		PyList_SetItem(v, i, w);
 		if (*p == '\0')
 			break;
 		path = p+1;
@@ -340,61 +344,61 @@
 }
 
 void
-setpythonpath(path)
+PySys_SetPath(path)
 	char *path;
 {
-	object *v;
+	PyObject *v;
 	if ((v = makepathobject(path, DELIM)) == NULL)
-		fatal("can't create sys.path");
-	if (sysset("path", v) != 0)
-		fatal("can't assign sys.path");
-	DECREF(v);
+		Py_FatalError("can't create sys.path");
+	if (PySys_SetObject("path", v) != 0)
+		Py_FatalError("can't assign sys.path");
+	Py_DECREF(v);
 }
 
-static object *
+static PyObject *
 makeargvobject(argc, argv)
 	int argc;
 	char **argv;
 {
-	object *av;
+	PyObject *av;
 	if (argc <= 0 || argv == NULL) {
 		/* Ensure at least one (empty) argument is seen */
 		static char *empty_argv[1] = {""};
 		argv = empty_argv;
 		argc = 1;
 	}
-	av = newlistobject(argc);
+	av = PyList_New(argc);
 	if (av != NULL) {
 		int i;
 		for (i = 0; i < argc; i++) {
-			object *v = newstringobject(argv[i]);
+			PyObject *v = PyString_FromString(argv[i]);
 			if (v == NULL) {
-				DECREF(av);
+				Py_DECREF(av);
 				av = NULL;
 				break;
 			}
-			setlistitem(av, i, v);
+			PyList_SetItem(av, i, v);
 		}
 	}
 	return av;
 }
 
 void
-setpythonargv(argc, argv)
+PySys_SetArgv(argc, argv)
 	int argc;
 	char **argv;
 {
-	object *av = makeargvobject(argc, argv);
-	object *path = sysget("path");
+	PyObject *av = makeargvobject(argc, argv);
+	PyObject *path = PySys_GetObject("path");
 	if (av == NULL)
-		fatal("no mem for sys.argv");
-	if (sysset("argv", av) != 0)
-		fatal("can't assign sys.argv");
+		Py_FatalError("no mem for sys.argv");
+	if (PySys_SetObject("argv", av) != 0)
+		Py_FatalError("can't assign sys.argv");
 	if (path != NULL) {
 		char *argv0 = argv[0];
 		char *p = NULL;
 		int n = 0;
-		object *a;
+		PyObject *a;
 #ifdef HAVE_READLINK
 		char link[MAXPATHLEN+1];
 		char argv0copy[2*MAXPATHLEN+1];
@@ -448,12 +452,12 @@
 #endif /* Unix */
 		}
 #endif /* All others */
-		a = newsizedstringobject(argv0, n);
+		a = PyString_FromStringAndSize(argv0, n);
 		if (a == NULL)
-			fatal("no mem for sys.path insertion");
-		if (inslistitem(path, 0, a) < 0)
-			fatal("sys.path.insert(0) failed");
-		DECREF(a);
+			Py_FatalError("no mem for sys.path insertion");
+		if (PyList_Insert(path, 0, a) < 0)
+			Py_FatalError("sys.path.insert(0) failed");
+		Py_DECREF(a);
 	}
-	DECREF(av);
+	Py_DECREF(av);
 }
diff --git a/Python/traceback.c b/Python/traceback.c
index f9b840e..9633db1 100644
--- a/Python/traceback.c
+++ b/Python/traceback.c
@@ -31,19 +31,17 @@
 
 /* Traceback implementation */
 
-#include "allobjects.h"
+#include "Python.h"
 
-#include "sysmodule.h"
 #include "compile.h"
 #include "frameobject.h"
-#include "traceback.h"
 #include "structmember.h"
 #include "osdefs.h"
 
 typedef struct _tracebackobject {
-	OB_HEAD
+	PyObject_HEAD
 	struct _tracebackobject *tb_next;
-	frameobject *tb_frame;
+	PyFrameObject *tb_frame;
 	int tb_lasti;
 	int tb_lineno;
 } tracebackobject;
@@ -58,28 +56,28 @@
 	{NULL}	/* Sentinel */
 };
 
-static object *
+static PyObject *
 tb_getattr(tb, name)
 	tracebackobject *tb;
 	char *name;
 {
-	return getmember((char *)tb, tb_memberlist, name);
+	return PyMember_Get((char *)tb, tb_memberlist, name);
 }
 
 static void
 tb_dealloc(tb)
 	tracebackobject *tb;
 {
-	XDECREF(tb->tb_next);
-	XDECREF(tb->tb_frame);
-	DEL(tb);
+	Py_XDECREF(tb->tb_next);
+	Py_XDECREF(tb->tb_frame);
+	PyMem_DEL(tb);
 }
 
 #define Tracebacktype PyTraceBack_Type
 #define is_tracebackobject PyTraceBack_Check
 
-typeobject Tracebacktype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject Tracebacktype = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,
 	"traceback",
 	sizeof(tracebackobject),
@@ -98,20 +96,20 @@
 static tracebackobject *
 newtracebackobject(next, frame, lasti, lineno)
 	tracebackobject *next;
-	frameobject *frame;
+	PyFrameObject *frame;
 	int lasti, lineno;
 {
 	tracebackobject *tb;
 	if ((next != NULL && !is_tracebackobject(next)) ||
-			frame == NULL || !is_frameobject(frame)) {
-		err_badcall();
+			frame == NULL || !PyFrame_Check(frame)) {
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	tb = NEWOBJ(tracebackobject, &Tracebacktype);
+	tb = PyObject_NEW(tracebackobject, &Tracebacktype);
 	if (tb != NULL) {
-		XINCREF(next);
+		Py_XINCREF(next);
 		tb->tb_next = next;
-		XINCREF(frame);
+		Py_XINCREF(frame);
 		tb->tb_frame = frame;
 		tb->tb_lasti = lasti;
 		tb->tb_lineno = lineno;
@@ -122,44 +120,45 @@
 static tracebackobject *tb_current = NULL;
 
 int
-tb_here(frame)
-	frameobject *frame;
+PyTraceBack_Here(frame)
+	PyFrameObject *frame;
 {
 	tracebackobject *tb;
-	tb = newtracebackobject(tb_current, frame, frame->f_lasti, frame->f_lineno);
+	tb = newtracebackobject(tb_current, frame,
+				frame->f_lasti, frame->f_lineno);
 	if (tb == NULL)
 		return -1;
-	XDECREF(tb_current);
+	Py_XDECREF(tb_current);
 	tb_current = tb;
 	return 0;
 }
 
-object *
-tb_fetch()
+PyObject *
+PyTraceBack_Fetch()
 {
-	object *v;
-	v = (object *)tb_current;
+	PyObject *v;
+	v = (PyObject *)tb_current;
 	tb_current = NULL;
 	return v;
 }
 
 int
-tb_store(v)
-	object *v;
+PyTraceBack_Store(v)
+	PyObject *v;
 {
 	if (v != NULL && !is_tracebackobject(v)) {
-		err_badcall();
+		PyErr_BadInternalCall();
 		return -1;
 	}
-	XDECREF(tb_current);
-	XINCREF(v);
+	Py_XDECREF(tb_current);
+	Py_XINCREF(v);
 	tb_current = (tracebackobject *)v;
 	return 0;
 }
 
 static void
 tb_displayline(f, filename, lineno, name)
-	object *f;
+	PyObject *f;
 	char *filename;
 	int lineno;
 	char *name;
@@ -177,25 +176,25 @@
 	xfp = fopen(filename, "r");
 	if (xfp == NULL) {
 		/* Search tail of filename in sys.path before giving up */
-		object *path;
+		PyObject *path;
 		char *tail = strrchr(filename, SEP);
 		if (tail == NULL)
 			tail = filename;
 		else
 			tail++;
-		path = sysget("path");
-		if (path != NULL && is_listobject(path)) {
-			int npath = getlistsize(path);
+		path = PySys_GetObject("path");
+		if (path != NULL && PyList_Check(path)) {
+			int npath = PyList_Size(path);
 			int taillen = strlen(tail);
 			char namebuf[MAXPATHLEN+1];
 			for (i = 0; i < npath; i++) {
-				object *v = getlistitem(path, i);
-				if (is_stringobject(v)) {
+				PyObject *v = PyList_GetItem(path, i);
+				if (PyString_Check(v)) {
 					int len;
-					len = getstringsize(v);
+					len = PyString_Size(v);
 					if (len + 1 + taillen >= MAXPATHLEN)
 						continue; /* Too long */
-					strcpy(namebuf, getstringvalue(v));
+					strcpy(namebuf, PyString_AsString(v));
 					if ((int)strlen(namebuf) != len)
 						continue; /* v contains '\0' */
 					if (len > 0 && namebuf[len-1] != SEP)
@@ -211,7 +210,7 @@
 		}
 	}
 	sprintf(linebuf, FMT, filename, lineno, name);
-	writestring(linebuf, f);
+	PyFile_WriteString(linebuf, f);
 	if (xfp == NULL)
 		return;
 	for (i = 0; i < lineno; i++) {
@@ -222,10 +221,10 @@
 		char *p = linebuf;
 		while (*p == ' ' || *p == '\t' || *p == '\014')
 			p++;
-		writestring("    ", f);
-		writestring(p, f);
+		PyFile_WriteString("    ", f);
+		PyFile_WriteString(p, f);
 		if (strchr(p, '\n') == NULL)
-			writestring("\n", f);
+			PyFile_WriteString("\n", f);
 	}
 	fclose(xfp);
 }
@@ -233,7 +232,7 @@
 static void
 tb_printinternal(tb, f, limit)
 	tracebackobject *tb;
-	object *f;
+	PyObject *f;
 	int limit;
 {
 	int depth = 0;
@@ -242,14 +241,15 @@
 		depth++;
 		tb1 = tb1->tb_next;
 	}
-	while (tb != NULL && !intrcheck()) {
+	while (tb != NULL && !PyOS_InterruptOccurred()) {
 		if (depth <= limit) {
 			tb->tb_lineno = PyCode_Addr2Line(tb->tb_frame->f_code,
 							 tb->tb_lasti);
 			tb_displayline(f,
-			    getstringvalue(tb->tb_frame->f_code->co_filename),
+			    PyString_AsString(
+				    tb->tb_frame->f_code->co_filename),
 			    tb->tb_lineno,
-			    getstringvalue(tb->tb_frame->f_code->co_name));
+			    PyString_AsString(tb->tb_frame->f_code->co_name));
 		}
 		depth--;
 		tb = tb->tb_next;
@@ -257,25 +257,25 @@
 }
 
 int
-tb_print(v, f)
-	object *v;
-	object *f;
+PyTraceBack_Print(v, f)
+	PyObject *v;
+	PyObject *f;
 {
-	object *limitv;
+	PyObject *limitv;
 	int limit = 1000;
 	if (v == NULL)
 		return 0;
 	if (!is_tracebackobject(v)) {
-		err_badcall();
+		PyErr_BadInternalCall();
 		return -1;
 	}
-	limitv = sysget("tracebacklimit");
-	if (limitv && is_intobject(limitv)) {
-		limit = getintvalue(limitv);
+	limitv = PySys_GetObject("tracebacklimit");
+	if (limitv && PyInt_Check(limitv)) {
+		limit = PyInt_AsLong(limitv);
 		if (limit <= 0)
 			return 0;
 	}
-	writestring("Traceback (innermost last):\n", f);
+	PyFile_WriteString("Traceback (innermost last):\n", f);
 	tb_printinternal((tracebackobject *)v, f, limit);
 	return 0;
 }