Quickly renamed the last directory.

1 files changed, 296 insertions, 295 deletions

diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 2ba63bd..cee41a10 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -31,10 +31,8 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* File object implementation */
 
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
 #include "structmember.h"
-#include "ceval.h"
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
@@ -48,69 +46,69 @@ PERFORMANCE OF THIS SOFTWARE.
 #define NO_FOPEN_ERRNO
 #endif
 
-#define BUF(v) GETSTRINGVALUE((stringobject *)v)
+#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
 
 #include <errno.h>
 
 typedef struct {
-	OB_HEAD
+	PyObject_HEAD
 	FILE *f_fp;
-	object *f_name;
-	object *f_mode;
-	int (*f_close) PROTO((FILE *));
+	PyObject *f_name;
+	PyObject *f_mode;
+	int (*f_close) Py_PROTO((FILE *));
 	int f_softspace; /* Flag used by 'print' command */
-} fileobject;
+} PyFileObject;
 
 FILE *
-getfilefile(f)
-	object *f;
+PyFile_AsFile(f)
+	PyObject *f;
 {
-	if (f == NULL || !is_fileobject(f))
+	if (f == NULL || !PyFile_Check(f))
 		return NULL;
 	else
-		return ((fileobject *)f)->f_fp;
+		return ((PyFileObject *)f)->f_fp;
 }
 
-object *
-getfilename(f)
-	object *f;
+PyObject *
+PyFile_Name(f)
+	PyObject *f;
 {
-	if (f == NULL || !is_fileobject(f))
+	if (f == NULL || !PyFile_Check(f))
 		return NULL;
 	else
-		return ((fileobject *)f)->f_name;
+		return ((PyFileObject *)f)->f_name;
 }
 
-object *
-newopenfileobject(fp, name, mode, close)
+PyObject *
+PyFile_FromFile(fp, name, mode, close)
 	FILE *fp;
 	char *name;
 	char *mode;
-	int (*close) FPROTO((FILE *));
+	int (*close) Py_FPROTO((FILE *));
 {
-	fileobject *f = NEWOBJ(fileobject, &Filetype);
+	PyFileObject *f = PyObject_NEW(PyFileObject, &PyFile_Type);
 	if (f == NULL)
 		return NULL;
 	f->f_fp = NULL;
-	f->f_name = newstringobject(name);
-	f->f_mode = newstringobject(mode);
+	f->f_name = PyString_FromString(name);
+	f->f_mode = PyString_FromString(mode);
 	f->f_close = close;
 	f->f_softspace = 0;
 	if (f->f_name == NULL || f->f_mode == NULL) {
-		DECREF(f);
+		Py_DECREF(f);
 		return NULL;
 	}
 	f->f_fp = fp;
-	return (object *) f;
+	return (PyObject *) f;
 }
 
-object *
-newfileobject(name, mode)
+PyObject *
+PyFile_FromString(name, mode)
 	char *name, *mode;
 {
-	extern int fclose PROTO((FILE *));
-	fileobject *f;
-	f = (fileobject *) newopenfileobject((FILE *)NULL, name, mode, fclose);
+	extern int fclose Py_PROTO((FILE *));
+	PyFileObject *f;
+	f = (PyFileObject *) PyFile_FromFile((FILE *)NULL, name, mode, fclose);
 	if (f == NULL)
 		return NULL;
 #ifdef HAVE_FOPENRF
@@ -121,28 +119,28 @@ newfileobject(name, mode)
 	else
 #endif
 	{
-		BGN_SAVE
+		Py_BEGIN_ALLOW_THREADS
 		f->f_fp = fopen(name, mode);
-		END_SAVE
+		Py_END_ALLOW_THREADS
 	}
 	if (f->f_fp == NULL) {
 #ifdef NO_FOPEN_ERRNO
 		if ( errno == 0 ) {
-			err_setstr(IOError, "Cannot open file");
-			DECREF(f);
+			PyErr_SetString(PyExc_IOError, "Cannot open file");
+			Py_DECREF(f);
 			return NULL;
 		}
 #endif
-		err_errno(IOError);
-		DECREF(f);
+		PyErr_SetFromErrno(PyExc_IOError);
+		Py_DECREF(f);
 		return NULL;
 	}
-	return (object *)f;
+	return (PyObject *)f;
 }
 
 void
-setfilebufsize(f, bufsize)
-	object *f;
+PyFile_SetBufSize(f, bufsize)
+	PyObject *f;
 	int bufsize;
 {
 	if (bufsize >= 0) {
@@ -159,15 +157,16 @@ setfilebufsize(f, bufsize)
 		default:
 			type = _IOFBF;
 		}
-		setvbuf(((fileobject *)f)->f_fp, (char *)NULL, type, bufsize);
+		setvbuf(((PyFileObject *)f)->f_fp, (char *)NULL,
+			type, bufsize);
 #endif /* HAVE_SETVBUF */
 	}
 }
 
-static object *
+static PyObject *
 err_closed()
 {
-	err_setstr(ValueError, "I/O operation on closed file");
+	PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");
 	return NULL;
 }
 
@@ -175,62 +174,62 @@ err_closed()
 
 static void
 file_dealloc(f)
-	fileobject *f;
+	PyFileObject *f;
 {
 	if (f->f_fp != NULL && f->f_close != NULL) {
-		BGN_SAVE
+		Py_BEGIN_ALLOW_THREADS
 		(*f->f_close)(f->f_fp);
-		END_SAVE
+		Py_END_ALLOW_THREADS
 	}
 	if (f->f_name != NULL)
-		DECREF(f->f_name);
+		Py_DECREF(f->f_name);
 	if (f->f_mode != NULL)
-		DECREF(f->f_mode);
+		Py_DECREF(f->f_mode);
 	free((char *)f);
 }
 
-static object *
+static PyObject *
 file_repr(f)
-	fileobject *f;
+	PyFileObject *f;
 {
 	char buf[300];
 	sprintf(buf, "<%s file '%.256s', mode '%.10s' at %lx>",
 		f->f_fp == NULL ? "closed" : "open",
-		getstringvalue(f->f_name),
-		getstringvalue(f->f_mode),
+		PyString_AsString(f->f_name),
+		PyString_AsString(f->f_mode),
 		(long)f);
-	return newstringobject(buf);
+	return PyString_FromString(buf);
 }
 
-static object *
+static PyObject *
 file_close(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	int sts = 0;
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
 	if (f->f_fp != NULL) {
 		if (f->f_close != NULL) {
-			BGN_SAVE
+			Py_BEGIN_ALLOW_THREADS
 			errno = 0;
 			sts = (*f->f_close)(f->f_fp);
-			END_SAVE
+			Py_END_ALLOW_THREADS
 		}
 		f->f_fp = NULL;
 	}
 	if (sts == EOF)
-		return err_errno(IOError);
+		return PyErr_SetFromErrno(PyExc_IOError);
 	if (sts != 0)
-		return newintobject((long)sts);
-	INCREF(None);
-	return None;
+		return PyInt_FromLong((long)sts);
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 file_seek(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	long offset;
 	int whence;
@@ -239,165 +238,165 @@ file_seek(f, args)
 	if (f->f_fp == NULL)
 		return err_closed();
 	whence = 0;
-	if (!getargs(args, "l", &offset)) {
-		err_clear();
-		if (!getargs(args, "(li)", &offset, &whence))
+	if (!PyArg_Parse(args, "l", &offset)) {
+		PyErr_Clear();
+		if (!PyArg_Parse(args, "(li)", &offset, &whence))
 			return NULL;
 	}
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
 	ret = fseek(f->f_fp, offset, whence);
-	END_SAVE
+	Py_END_ALLOW_THREADS
 	if (ret != 0) {
-		err_errno(IOError);
+		PyErr_SetFromErrno(PyExc_IOError);
 		clearerr(f->f_fp);
 		return NULL;
 	}
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 #ifdef HAVE_FTRUNCATE
-static object *
+static PyObject *
 file_truncate(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	long newsize;
 	int ret;
 	
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getargs(args, "l", &newsize)) {
-		err_clear();
-		if (!getnoarg(args))
+	if (!PyArg_Parse(args, "l", &newsize)) {
+		PyErr_Clear();
+		if (!PyArg_NoArgs(args))
 		        return NULL;
-		BGN_SAVE
+		Py_BEGIN_ALLOW_THREADS
 		errno = 0;
 		newsize =  ftell(f->f_fp); /* default to current position*/
-		END_SAVE
+		Py_END_ALLOW_THREADS
 		if (newsize == -1L) {
-		        err_errno(IOError);
+		        PyErr_SetFromErrno(PyExc_IOError);
 			clearerr(f->f_fp);
 			return NULL;
 		}
 	}
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
 	ret = fflush(f->f_fp);
-	END_SAVE
+	Py_END_ALLOW_THREADS
 	if (ret == 0) {
-	        BGN_SAVE
+	        Py_BEGIN_ALLOW_THREADS
 		errno = 0;
 		ret = ftruncate(fileno(f->f_fp), newsize);
-		END_SAVE
+		Py_END_ALLOW_THREADS
 	}
 	if (ret != 0) {
-		err_errno(IOError);
+		PyErr_SetFromErrno(PyExc_IOError);
 		clearerr(f->f_fp);
 		return NULL;
 	}
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 #endif /* HAVE_FTRUNCATE */
 
-static object *
+static PyObject *
 file_tell(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	long offset;
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
 	offset = ftell(f->f_fp);
-	END_SAVE
+	Py_END_ALLOW_THREADS
 	if (offset == -1L) {
-		err_errno(IOError);
+		PyErr_SetFromErrno(PyExc_IOError);
 		clearerr(f->f_fp);
 		return NULL;
 	}
-	return newintobject(offset);
+	return PyInt_FromLong(offset);
 }
 
-static object *
+static PyObject *
 file_fileno(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
-	return newintobject((long) fileno(f->f_fp));
+	return PyInt_FromLong((long) fileno(f->f_fp));
 }
 
-static object *
+static PyObject *
 file_flush(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	int res;
 	
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
 	res = fflush(f->f_fp);
-	END_SAVE
+	Py_END_ALLOW_THREADS
 	if (res != 0) {
-		err_errno(IOError);
+		PyErr_SetFromErrno(PyExc_IOError);
 		clearerr(f->f_fp);
 		return NULL;
 	}
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 file_isatty(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	long res;
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	res = isatty((int)fileno(f->f_fp));
-	END_SAVE
-	return newintobject(res);
+	Py_END_ALLOW_THREADS
+	return PyInt_FromLong(res);
 }
 
-static object *
+static PyObject *
 file_read(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	int n, n1, n2, n3;
-	object *v;
+	PyObject *v;
 	
 	if (f->f_fp == NULL)
 		return err_closed();
 	if (args == NULL)
 		n = -1;
 	else {
-		if (!getargs(args, "i", &n))
+		if (!PyArg_Parse(args, "i", &n))
 			return NULL;
 	}
 	n2 = n >= 0 ? n : BUFSIZ;
-	v = newsizedstringobject((char *)NULL, n2);
+	v = PyString_FromStringAndSize((char *)NULL, n2);
 	if (v == NULL)
 		return NULL;
 	n1 = 0;
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	for (;;) {
 		n3 = fread(BUF(v)+n1, 1, n2-n1, f->f_fp);
 		/* XXX Error check? */
@@ -408,15 +407,15 @@ file_read(f, args)
 			break;
 		if (n < 0) {
 			n2 = n1 + BUFSIZ;
-			RET_SAVE
-			if (resizestring(&v, n2) < 0)
+			Py_BLOCK_THREADS
+			if (_PyString_Resize(&v, n2) < 0)
 				return NULL;
-			RES_SAVE
+			Py_UNBLOCK_THREADS
 		}
 	}
-	END_SAVE
+	Py_END_ALLOW_THREADS
 	if (n1 != n2)
-		resizestring(&v, n1);
+		_PyString_Resize(&v, n1);
 	return v;
 }
 
@@ -427,38 +426,38 @@ file_read(f, args)
    < 0: strip trailing '\n', raise EOFError if EOF reached immediately
 */
 
-static object *
+static PyObject *
 getline(f, n)
-	fileobject *f;
+	PyFileObject *f;
 	int n;
 {
 	register FILE *fp;
 	register int c;
 	register char *buf, *end;
 	int n1, n2;
-	object *v;
+	PyObject *v;
 
 	fp = f->f_fp;
 	n2 = n > 0 ? n : 100;
-	v = newsizedstringobject((char *)NULL, n2);
+	v = PyString_FromStringAndSize((char *)NULL, n2);
 	if (v == NULL)
 		return NULL;
 	buf = BUF(v);
 	end = buf + n2;
 
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	for (;;) {
 		if ((c = getc(fp)) == EOF) {
 			clearerr(fp);
-			if (sigcheck()) {
-				RET_SAVE
-				DECREF(v);
+			if (PyErr_CheckSignals()) {
+				Py_BLOCK_THREADS
+				Py_DECREF(v);
 				return NULL;
 			}
 			if (n < 0 && buf == BUF(v)) {
-				RET_SAVE
-				DECREF(v);
-				err_setstr(EOFError,
+				Py_BLOCK_THREADS
+				Py_DECREF(v);
+				PyErr_SetString(PyExc_EOFError,
 					   "EOF when reading a line");
 				return NULL;
 			}
@@ -474,90 +473,91 @@ getline(f, n)
 				break;
 			n1 = n2;
 			n2 += 1000;
-			RET_SAVE
-			if (resizestring(&v, n2) < 0)
+			Py_BLOCK_THREADS
+			if (_PyString_Resize(&v, n2) < 0)
 				return NULL;
-			RES_SAVE
+			Py_UNBLOCK_THREADS
 			buf = BUF(v) + n1;
 			end = BUF(v) + n2;
 		}
 	}
-	END_SAVE
+	Py_END_ALLOW_THREADS
 
 	n1 = buf - BUF(v);
 	if (n1 != n2)
-		resizestring(&v, n1);
+		_PyString_Resize(&v, n1);
 	return v;
 }
 
 /* External C interface */
 
-object *
-filegetline(f, n)
-	object *f;
+PyObject *
+PyFile_GetLine(f, n)
+	PyObject *f;
 	int n;
 {
 	if (f == NULL) {
-		err_badcall();
+		PyErr_BadInternalCall();
 		return NULL;
 	}
-	if (!is_fileobject(f)) {
-		object *reader;
-		object *args;
-		object *result;
-		reader = getattr(f, "readline");
+	if (!PyFile_Check(f)) {
+		PyObject *reader;
+		PyObject *args;
+		PyObject *result;
+		reader = PyObject_GetAttrString(f, "readline");
 		if (reader == NULL)
 			return NULL;
 		if (n <= 0)
-			args = mkvalue("()");
+			args = Py_BuildValue("()");
 		else
-			args = mkvalue("(i)", n);
+			args = Py_BuildValue("(i)", n);
 		if (args == NULL) {
-			DECREF(reader);
+			Py_DECREF(reader);
 			return NULL;
 		}
-		result = call_object(reader, args);
-		DECREF(reader);
-		DECREF(args);
-		if (result != NULL && !is_stringobject(result)) {
-			DECREF(result);
+		result = PyEval_CallObject(reader, args);
+		Py_DECREF(reader);
+		Py_DECREF(args);
+		if (result != NULL && !PyString_Check(result)) {
+			Py_DECREF(result);
 			result = NULL;
-			err_setstr(TypeError,
+			PyErr_SetString(PyExc_TypeError,
 				   "object.readline() returned non-string");
 		}
 		if (n < 0 && result != NULL) {
-			char *s = getstringvalue(result);
-			int len = getstringsize(result);
+			char *s = PyString_AsString(result);
+			int len = PyString_Size(result);
 			if (len == 0) {
-				DECREF(result);
+				Py_DECREF(result);
 				result = NULL;
-				err_setstr(EOFError,
+				PyErr_SetString(PyExc_EOFError,
 					   "EOF when reading a line");
 			}
 			else if (s[len-1] == '\n') {
 				if (result->ob_refcnt == 1)
-					resizestring(&result, len-1);
+					_PyString_Resize(&result, len-1);
 				else {
-					object *v;
-					v = newsizedstringobject(s, len-1);
-					DECREF(result);
+					PyObject *v;
+					v = PyString_FromStringAndSize(s,
+								       len-1);
+					Py_DECREF(result);
 					result = v;
 				}
 			}
 		}
 		return result;
 	}
-	if (((fileobject*)f)->f_fp == NULL)
+	if (((PyFileObject*)f)->f_fp == NULL)
 		return err_closed();
-	return getline((fileobject *)f, n);
+	return getline((PyFileObject *)f, n);
 }
 
 /* Python method */
 
-static object *
+static PyObject *
 file_readline(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	int n;
 
@@ -566,10 +566,10 @@ file_readline(f, args)
 	if (args == NULL)
 		n = 0; /* Unlimited */
 	else {
-		if (!getintarg(args, &n))
+		if (!PyArg_Parse(args, "i", &n))
 			return NULL;
 		if (n == 0)
-			return newstringobject("");
+			return PyString_FromString("");
 		if (n < 0)
 			n = 0;
 	}
@@ -577,121 +577,121 @@ file_readline(f, args)
 	return getline(f, n);
 }
 
-static object *
+static PyObject *
 file_readlines(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
-	object *list;
-	object *line;
+	PyObject *list;
+	PyObject *line;
 
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
-	if ((list = newlistobject(0)) == NULL)
+	if ((list = PyList_New(0)) == NULL)
 		return NULL;
 	for (;;) {
 		line = getline(f, 0);
-		if (line != NULL && getstringsize(line) == 0) {
-			DECREF(line);
+		if (line != NULL && PyString_Size(line) == 0) {
+			Py_DECREF(line);
 			break;
 		}
-		if (line == NULL || addlistitem(list, line) != 0) {
-			DECREF(list);
-			XDECREF(line);
+		if (line == NULL || PyList_Append(list, line) != 0) {
+			Py_DECREF(list);
+			Py_XDECREF(line);
 			return NULL;
 		}
-		DECREF(line);
+		Py_DECREF(line);
 	}
 	return list;
 }
 
-static object *
+static PyObject *
 file_write(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	char *s;
 	int n, n2;
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (!getargs(args, "s#", &s, &n))
+	if (!PyArg_Parse(args, "s#", &s, &n))
 		return NULL;
 	f->f_softspace = 0;
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
 	n2 = fwrite(s, 1, n, f->f_fp);
-	END_SAVE
+	Py_END_ALLOW_THREADS
 	if (n2 != n) {
-		err_errno(IOError);
+		PyErr_SetFromErrno(PyExc_IOError);
 		clearerr(f->f_fp);
 		return NULL;
 	}
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 file_writelines(f, args)
-	fileobject *f;
-	object *args;
+	PyFileObject *f;
+	PyObject *args;
 {
 	int i, n;
 	if (f->f_fp == NULL)
 		return err_closed();
-	if (args == NULL || !is_listobject(args)) {
-		err_setstr(TypeError,
+	if (args == NULL || !PyList_Check(args)) {
+		PyErr_SetString(PyExc_TypeError,
 			   "writelines() requires list of strings");
 		return NULL;
 	}
-	n = getlistsize(args);
+	n = PyList_Size(args);
 	f->f_softspace = 0;
-	BGN_SAVE
+	Py_BEGIN_ALLOW_THREADS
 	errno = 0;
 	for (i = 0; i < n; i++) {
-		object *line = getlistitem(args, i);
+		PyObject *line = PyList_GetItem(args, i);
 		int len;
 		int nwritten;
-		if (!is_stringobject(line)) {
-			RET_SAVE
-			err_setstr(TypeError,
+		if (!PyString_Check(line)) {
+			Py_BLOCK_THREADS
+			PyErr_SetString(PyExc_TypeError,
 				   "writelines() requires list of strings");
 			return NULL;
 		}
-		len = getstringsize(line);
-		nwritten = fwrite(getstringvalue(line), 1, len, f->f_fp);
+		len = PyString_Size(line);
+		nwritten = fwrite(PyString_AsString(line), 1, len, f->f_fp);
 		if (nwritten != len) {
-			RET_SAVE
-			err_errno(IOError);
+			Py_BLOCK_THREADS
+			PyErr_SetFromErrno(PyExc_IOError);
 			clearerr(f->f_fp);
 			return NULL;
 		}
 	}
-	END_SAVE
-	INCREF(None);
-	return None;
+	Py_END_ALLOW_THREADS
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static struct methodlist file_methods[] = {
-	{"close",	(method)file_close, 0},
-	{"flush",	(method)file_flush, 0},
-	{"fileno",	(method)file_fileno, 0},
-	{"isatty",	(method)file_isatty, 0},
-	{"read",	(method)file_read, 0},
-	{"readline",	(method)file_readline, 0},
-	{"readlines",	(method)file_readlines, 0},
-	{"seek",	(method)file_seek, 0},
+static PyMethodDef file_methods[] = {
+	{"close",	(PyCFunction)file_close, 0},
+	{"flush",	(PyCFunction)file_flush, 0},
+	{"fileno",	(PyCFunction)file_fileno, 0},
+	{"isatty",	(PyCFunction)file_isatty, 0},
+	{"read",	(PyCFunction)file_read, 0},
+	{"readline",	(PyCFunction)file_readline, 0},
+	{"readlines",	(PyCFunction)file_readlines, 0},
+	{"seek",	(PyCFunction)file_seek, 0},
 #ifdef HAVE_FTRUNCATE
-	{"truncate",	(method)file_truncate, 0},
+	{"truncate",	(PyCFunction)file_truncate, 0},
 #endif
-	{"tell",	(method)file_tell, 0},
-	{"write",	(method)file_write, 0},
-	{"writelines",	(method)file_writelines, 0},
+	{"tell",	(PyCFunction)file_tell, 0},
+	{"write",	(PyCFunction)file_write, 0},
+	{"writelines",	(PyCFunction)file_writelines, 0},
 	{NULL,		NULL}		/* sentinel */
 };
 
-#define OFF(x) offsetof(fileobject, x)
+#define OFF(x) offsetof(PyFileObject, x)
 
 static struct memberlist file_memberlist[] = {
 	{"softspace",	T_INT,		OFF(f_softspace)},
@@ -702,40 +702,41 @@ static struct memberlist file_memberlist[] = {
 	{NULL}	/* Sentinel */
 };
 
-static object *
+static PyObject *
 file_getattr(f, name)
-	fileobject *f;
+	PyFileObject *f;
 	char *name;
 {
-	object *res;
+	PyObject *res;
 
-	res = findmethod(file_methods, (object *)f, name);
+	res = Py_FindMethod(file_methods, (PyObject *)f, name);
 	if (res != NULL)
 		return res;
-	err_clear();
+	PyErr_Clear();
 	if (strcmp(name, "closed") == 0)
-		return newintobject((long)(f->f_fp == 0));
-	return getmember((char *)f, file_memberlist, name);
+		return PyInt_FromLong((long)(f->f_fp == 0));
+	return PyMember_Get((char *)f, file_memberlist, name);
 }
 
 static int
 file_setattr(f, name, v)
-	fileobject *f;
+	PyFileObject *f;
 	char *name;
-	object *v;
+	PyObject *v;
 {
 	if (v == NULL) {
-		err_setstr(AttributeError, "can't delete file attributes");
+		PyErr_SetString(PyExc_AttributeError,
+				"can't delete file attributes");
 		return -1;
 	}
-	return setmember((char *)f, file_memberlist, name, v);
+	return PyMember_Set((char *)f, file_memberlist, name, v);
 }
 
-typeobject Filetype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject PyFile_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,
 	"file",
-	sizeof(fileobject),
+	sizeof(PyFileObject),
 	0,
 	(destructor)file_dealloc, /*tp_dealloc*/
 	0,		/*tp_print*/
@@ -748,35 +749,35 @@ typeobject Filetype = {
 /* Interface for the 'soft space' between print items. */
 
 int
-softspace(f, newflag)
-	object *f;
+PyFile_SoftSpace(f, newflag)
+	PyObject *f;
 	int newflag;
 {
 	int oldflag = 0;
 	if (f == NULL) {
 		/* Do nothing */
 	}
-	else if (is_fileobject(f)) {
-		oldflag = ((fileobject *)f)->f_softspace;
-		((fileobject *)f)->f_softspace = newflag;
+	else if (PyFile_Check(f)) {
+		oldflag = ((PyFileObject *)f)->f_softspace;
+		((PyFileObject *)f)->f_softspace = newflag;
 	}
 	else {
-		object *v;
-		v = getattr(f, "softspace");
+		PyObject *v;
+		v = PyObject_GetAttrString(f, "softspace");
 		if (v == NULL)
-			err_clear();
+			PyErr_Clear();
 		else {
-			if (is_intobject(v))
-				oldflag = getintvalue(v);
-			DECREF(v);
+			if (PyInt_Check(v))
+				oldflag = PyInt_AsLong(v);
+			Py_DECREF(v);
 		}
-		v = newintobject((long)newflag);
+		v = PyInt_FromLong((long)newflag);
 		if (v == NULL)
-			err_clear();
+			PyErr_Clear();
 		else {
-			if (setattr(f, "softspace", v) != 0)
-				err_clear();
-			DECREF(v);
+			if (PyObject_SetAttrString(f, "softspace", v) != 0)
+				PyErr_Clear();
+			Py_DECREF(v);
 		}
 	}
 	return oldflag;
@@ -785,73 +786,73 @@ softspace(f, newflag)
 /* Interfaces to write objects/strings to file-like objects */
 
 int
-writeobject(v, f, flags)
-	object *v;
-	object *f;
+PyFile_WriteObject(v, f, flags)
+	PyObject *v;
+	PyObject *f;
 	int flags;
 {
-	object *writer, *value, *args, *result;
+	PyObject *writer, *value, *args, *result;
 	if (f == NULL) {
-		err_setstr(TypeError, "writeobject with NULL file");
+		PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
 		return -1;
 	}
-	else if (is_fileobject(f)) {
-		FILE *fp = getfilefile(f);
+	else if (PyFile_Check(f)) {
+		FILE *fp = PyFile_AsFile(f);
 		if (fp == NULL) {
 			err_closed();
 			return -1;
 		}
-		return printobject(v, fp, flags);
+		return PyObject_Print(v, fp, flags);
 	}
-	writer = getattr(f, "write");
+	writer = PyObject_GetAttrString(f, "write");
 	if (writer == NULL)
 		return -1;
-	if (flags & PRINT_RAW)
-		value = strobject(v);
+	if (flags & Py_PRINT_RAW)
+		value = PyObject_Str(v);
 	else
-		value = reprobject(v);
+		value = PyObject_Repr(v);
 	if (value == NULL) {
-		DECREF(writer);
+		Py_DECREF(writer);
 		return -1;
 	}
-	args = mkvalue("(O)", value);
+	args = Py_BuildValue("(O)", value);
 	if (value == NULL) {
-		DECREF(value);
-		DECREF(writer);
+		Py_DECREF(value);
+		Py_DECREF(writer);
 		return -1;
 	}
-	result = call_object(writer, args);
-	DECREF(args);
-	DECREF(value);
-	DECREF(writer);
+	result = PyEval_CallObject(writer, args);
+	Py_DECREF(args);
+	Py_DECREF(value);
+	Py_DECREF(writer);
 	if (result == NULL)
 		return -1;
-	DECREF(result);
+	Py_DECREF(result);
 	return 0;
 }
 
 void
-writestring(s, f)
+PyFile_WriteString(s, f)
 	char *s;
-	object *f;
+	PyObject *f;
 {
 	if (f == NULL) {
 		/* Do nothing */
 	}
-	else if (is_fileobject(f)) {
-		FILE *fp = getfilefile(f);
+	else if (PyFile_Check(f)) {
+		FILE *fp = PyFile_AsFile(f);
 		if (fp != NULL)
 			fputs(s, fp);
 	}
-	else if (!err_occurred()) {
-		object *v = newstringobject(s);
+	else if (!PyErr_Occurred()) {
+		PyObject *v = PyString_FromString(s);
 		if (v == NULL) {
-			err_clear();
+			PyErr_Clear();
 		}
 		else {
-			if (writeobject(v, f, PRINT_RAW) != 0)
-				err_clear();
-			DECREF(v);
+			if (PyFile_WriteObject(v, f, Py_PRINT_RAW) != 0)
+				PyErr_Clear();
+			Py_DECREF(v);
 		}
 	}
 }