Rip out the file object's implementation.

Fixed test_import.py while I was at it.

However, there's still a problem in import.c -- get_file() can leak a
FILE struct (not a file descriptor though).  I'm not sure how to fix
this; closing the FILE* closes the file descriptor, and that's the
wrong thing to do when there's still a Python file object keeping the
file descriptor open.  I also would rather not mess with dup(), as it
won't port to Windows.

14 files changed, 105 insertions, 2536 deletions

diff --git a/Include/fileobject.h b/Include/fileobject.h
index 8fed9a3..2d8c397 100644
--- a/Include/fileobject.h
+++ b/Include/fileobject.h
@@ -1,5 +1,4 @@
-
-/* File object interface */
+/* File object interface (what's left of it -- see io.py) */
 
 #ifndef Py_FILEOBJECT_H
 #define Py_FILEOBJECT_H
@@ -7,59 +6,20 @@
 extern "C" {
 #endif
 
-typedef struct {
-	PyObject_HEAD
-	FILE *f_fp;
-	PyObject *f_name;
-	PyObject *f_mode;
-	int (*f_close)(FILE *);
-	int f_binary;		/* Flag which indicates whether the file is 
-				   open in binary (1) or text (0) mode */
-	char* f_buf;		/* Allocated readahead buffer */
-	char* f_bufend;		/* Points after last occupied position */
-	char* f_bufptr;		/* Current buffer position */
-	char *f_setbuf;		/* Buffer for setbuf(3) and setvbuf(3) */
-	int f_univ_newline;	/* Handle any newline convention */
-	int f_newlinetypes;	/* Types of newlines seen */
-	int f_skipnextlf;	/* Skip next \n */
-	PyObject *f_encoding;
-	PyObject *weakreflist; /* List of weak references */
-} PyFileObject;
-
-PyAPI_DATA(PyTypeObject) PyFile_Type;
-
-#define PyFile_Check(op) PyObject_TypeCheck(op, &PyFile_Type)
-#define PyFile_CheckExact(op) ((op)->ob_type == &PyFile_Type)
+#define PY_STDIOTEXTMODE "b"
 
-PyAPI_FUNC(PyObject *) PyFile_FromString(char *, char *);
-PyAPI_FUNC(void) PyFile_SetBufSize(PyObject *, int);
-PyAPI_FUNC(int) PyFile_SetEncoding(PyObject *, const char *);
-PyAPI_FUNC(PyObject *) PyFile_FromFile(FILE *, char *, char *,
-                                             int (*)(FILE *));
-PyAPI_FUNC(FILE *) PyFile_AsFile(PyObject *);
-PyAPI_FUNC(PyObject *) PyFile_Name(PyObject *);
+PyAPI_FUNC(PyObject *) PyFile_FromFile(FILE *, char *, char *, int (*)(FILE*));
 PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int);
 PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int);
 PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *);
 PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *);
+PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
 
 /* The default encoding used by the platform file system APIs
    If non-NULL, this is different than the default encoding for strings
 */
 PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;
 
-/* Routines to replace fread() and fgets() which accept any of \r, \n
-   or \r\n as line terminators.
-*/
-#define PY_STDIOTEXTMODE "b"
-char *Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
-size_t Py_UniversalNewlineFread(char *, size_t, FILE *, PyObject *);
-
-/* A routine to do sanity checking on the file mode string.  returns
-   non-zero on if an exception occurred
-*/
-int _PyFile_SanitizeMode(char *mode);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Include/sysmodule.h b/Include/sysmodule.h
index 1c9b187..3ff01bd 100644
--- a/Include/sysmodule.h
+++ b/Include/sysmodule.h
@@ -9,7 +9,6 @@ extern "C" {
 
 PyAPI_FUNC(PyObject *) PySys_GetObject(char *);
 PyAPI_FUNC(int) PySys_SetObject(char *, PyObject *);
-PyAPI_FUNC(FILE *) PySys_GetFile(char *, FILE *);
 PyAPI_FUNC(void) PySys_SetArgv(int, char **);
 PyAPI_FUNC(void) PySys_SetPath(char *);
 
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index 918e22d..2680320 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -1287,12 +1287,13 @@ PyCursesWindow_PutWin(PyCursesWindowObject *self, PyObject *args)
   
   if (!PyArg_ParseTuple(args, "O;fileobj", &temp))
     return NULL;
-  if (!PyFile_Check(temp)) {
-    PyErr_SetString(PyExc_TypeError, "argument must be a file object");
-    return NULL;
-  }
+  PyErr_SetString(PyExc_TypeError, "argument must be a file object");
+  return NULL;
+
+#if 0
   return PyCursesCheckERR(putwin(self->win, PyFile_AsFile(temp)), 
 			  "putwin");
+#endif
 }
 
 static PyObject *
@@ -1748,11 +1749,10 @@ PyCurses_GetWin(PyCursesWindowObject *self, PyObject *temp)
 
   PyCursesInitialised
 
-  if (!PyFile_Check(temp)) {
-    PyErr_SetString(PyExc_TypeError, "argument must be a file object");
-    return NULL;
-  }
+  PyErr_SetString(PyExc_TypeError, "argument must be a file object");
+  return NULL;
 
+#if 0
   win = getwin(PyFile_AsFile(temp));
 
   if (win == NULL) {
@@ -1761,6 +1761,7 @@ PyCurses_GetWin(PyCursesWindowObject *self, PyObject *temp)
   }
 
   return PyCursesWindow_New(win);
+#endif
 }
 
 static PyObject *
diff --git a/Modules/bz2module.c b/Modules/bz2module.c
index d4f2743..029232c 100644
--- a/Modules/bz2module.c
+++ b/Modules/bz2module.c
@@ -1075,6 +1075,7 @@ BZ2File_seek(BZ2FileObject *self, PyObject *args)
 		offset -= self->pos;
 	} else {
 		/* we cannot move back, so rewind the stream */
+		FILE *fp = NULL; /* XXX temporary!!! */
 		BZ2_bzReadClose(&bzerror, self->fp);
 		if (bzerror != BZ_OK) {
 			Util_CatchBZ2Error(bzerror);
@@ -1086,7 +1087,7 @@ BZ2File_seek(BZ2FileObject *self, PyObject *args)
 		Py_DECREF(ret);
 		ret = NULL;
 		self->pos = 0;
-		self->fp = BZ2_bzReadOpen(&bzerror, PyFile_AsFile(self->file),
+		self->fp = BZ2_bzReadOpen(&bzerror, fp,
 					  0, 0, NULL, 0);
 		if (bzerror != BZ_OK) {
 			Util_CatchBZ2Error(bzerror);
@@ -1286,6 +1287,7 @@ BZ2File_init(BZ2FileObject *self, PyObject *args, PyObject *kwargs)
 {
 	static char *kwlist[] = {"filename", "mode", "buffering",
                                        "compresslevel", 0};
+	FILE *fp = NULL; /* XXX temporary!!! */
 	PyObject *name;
 	char *mode = "r";
 	int buffering = -1;
@@ -1347,8 +1349,8 @@ BZ2File_init(BZ2FileObject *self, PyObject *args, PyObject *kwargs)
 
 	mode = (mode_char == 'r') ? "rb" : "wb";
 
-	self->file = PyObject_CallFunction((PyObject*)&PyFile_Type, "(Osi)",
-					   name, mode, buffering);
+	self->file = NULL; /* XXX io.open(name, mode, buffering); */
+	PyErr_SetString(PyExc_RuntimeError, "can't open bz2 files yet");
 	if (self->file == NULL)
 		return -1;
 
@@ -1365,11 +1367,11 @@ BZ2File_init(BZ2FileObject *self, PyObject *args, PyObject *kwargs)
 
 	if (mode_char == 'r')
 		self->fp = BZ2_bzReadOpen(&bzerror,
-					  PyFile_AsFile(self->file),
+					  fp,
 					  0, 0, NULL, 0);
 	else
 		self->fp = BZ2_bzWriteOpen(&bzerror,
-					   PyFile_AsFile(self->file),
+					   fp,
 					   compresslevel, 0, 0);
 
 	if (bzerror != BZ_OK) {
diff --git a/Modules/cPickle.c b/Modules/cPickle.c
index a4dff7b..f0b3c8a 100644
--- a/Modules/cPickle.c
+++ b/Modules/cPickle.c
@@ -418,31 +418,6 @@ cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...)
 }
 
 static int
-write_file(Picklerobject *self, const char *s, Py_ssize_t  n)
-{
-	size_t nbyteswritten;
-
-	if (s == NULL) {
-		return 0;
-	}
-
-	if (n > INT_MAX) {
-		/* String too large */
-		return -1;
-	}
-
-	Py_BEGIN_ALLOW_THREADS
-	nbyteswritten = fwrite(s, sizeof(char), n, self->fp);
-	Py_END_ALLOW_THREADS
-	if (nbyteswritten != (size_t)n) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		return -1;
-	}
-
-	return (int)n;
-}
-
-static int
 write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t  n)
 {
 	if (s == NULL) {
@@ -517,92 +492,6 @@ write_other(Picklerobject *self, const char *s, Py_ssize_t  _n)
 
 
 static Py_ssize_t
-read_file(Unpicklerobject *self, char **s, Py_ssize_t n)
-{
-	size_t nbytesread;
-
-	if (self->buf_size == 0) {
-		int size;
-
-		size = ((n < 32) ? 32 : n);
-		if (!( self->buf = (char *)malloc(size))) {
-			PyErr_NoMemory();
-			return -1;
-		}
-
-		self->buf_size = size;
-	}
-	else if (n > self->buf_size) {
-		char *newbuf = (char *)realloc(self->buf, n);
-		if (!newbuf)  {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->buf = newbuf;
-		self->buf_size = n;
-	}
-
-	Py_BEGIN_ALLOW_THREADS
-	nbytesread = fread(self->buf, sizeof(char), n, self->fp);
-	Py_END_ALLOW_THREADS
-	if (nbytesread != (size_t)n) {
-		if (feof(self->fp)) {
-			PyErr_SetNone(PyExc_EOFError);
-			return -1;
-		}
-
-		PyErr_SetFromErrno(PyExc_IOError);
-		return -1;
-	}
-
-	*s = self->buf;
-
-	return n;
-}
-
-
-static Py_ssize_t
-readline_file(Unpicklerobject *self, char **s)
-{
-	int i;
-
-	if (self->buf_size == 0) {
-		if (!( self->buf = (char *)malloc(40))) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->buf_size = 40;
-	}
-
-	i = 0;
-	while (1) {
-		int bigger;
-		char *newbuf;
-		for (; i < (self->buf_size - 1); i++) {
-			if (feof(self->fp) ||
-			    (self->buf[i] = getc(self->fp)) == '\n') {
-				self->buf[i + 1] = '\0';
-				*s = self->buf;
-				return i + 1;
-			}
-		}
-		bigger = self->buf_size << 1;
-		if (bigger <= 0) {	/* overflow */
-			PyErr_NoMemory();
-			return -1;
-		}
-		newbuf = (char *)realloc(self->buf, bigger);
-		if (!newbuf)  {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->buf = newbuf;
-		self->buf_size = bigger;
-	}
-}
-
-
-static Py_ssize_t
 read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t  n)
 {
 	char *ptr;
@@ -2665,16 +2554,7 @@ newPicklerobject(PyObject *file, int proto)
 	if (!( self->memo = PyDict_New()))
 		goto err;
 
-	if (PyFile_Check(file)) {
-		self->fp = PyFile_AsFile(file);
-		if (self->fp == NULL) {
-			PyErr_SetString(PyExc_ValueError,
-					"I/O operation on closed file");
-			goto err;
-		}
-		self->write_func = write_file;
-	}
-	else if (PycStringIO_OutputCheck(file)) {
+        if (PycStringIO_OutputCheck(file)) {
 		self->write_func = write_cStringIO;
 	}
 	else if (file == Py_None) {
@@ -4988,17 +4868,7 @@ newUnpicklerobject(PyObject *f)
 	self->file = f;
 
 	/* Set read, readline based on type of f */
-	if (PyFile_Check(f)) {
-		self->fp = PyFile_AsFile(f);
-		if (self->fp == NULL) {
-			PyErr_SetString(PyExc_ValueError,
-					"I/O operation on closed file");
-			goto err;
-		}
-		self->read_func = read_file;
-		self->readline_func = readline_file;
-	}
-	else if (PycStringIO_InputCheck(f)) {
+	if (PycStringIO_InputCheck(f)) {
 		self->fp = NULL;
 		self->read_func = read_cStringIO;
 		self->readline_func = readline_cStringIO;
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index aebae1c..c583edf 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -956,10 +956,7 @@ xmlparse_ParseFile(xmlparseobject *self, PyObject *f)
     FILE *fp;
     PyObject *readmethod = NULL;
 
-    if (PyFile_Check(f)) {
-        fp = PyFile_AsFile(f);
-    }
-    else {
+    {
         fp = NULL;
         readmethod = PyObject_GetAttrString(f, "read");
         if (readmethod == NULL) {
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 2d9fcf9..a0779d4 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -1,36 +1,7 @@
-/* File object implementation */
+/* File object implementation (what's left of it -- see io.py) */
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
-#include "structmember.h"
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif /* HAVE_SYS_TYPES_H */
-
-#ifdef MS_WINDOWS
-#define fileno _fileno
-/* can simulate truncate with Win32 API functions; see file_truncate */
-#define HAVE_FTRUNCATE
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif
-
-#ifdef _MSC_VER
-/* Need GetVersion to see if on NT so safe to use _wfopen */
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif /* _MSC_VER */
-
-#if defined(PYOS_OS2) && defined(PYCC_GCC)
-#include <io.h>
-#endif
-
-#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
-
-#ifndef DONT_HAVE_ERRNO_H
-#include <errno.h>
-#endif
 
 #ifdef HAVE_GETC_UNLOCKED
 #define GETC(f) getc_unlocked(f)
@@ -42,7 +13,7 @@
 #define FUNLOCKFILE(f)
 #endif
 
-/* Bits in f_newlinetypes */
+/* Newline flags */
 #define NEWLINE_UNKNOWN	0	/* No newline seen, yet */
 #define NEWLINE_CR 1		/* \r newline seen */
 #define NEWLINE_LF 2		/* \n newline seen */
@@ -52,1212 +23,31 @@
 extern "C" {
 #endif
 
-FILE *
-PyFile_AsFile(PyObject *f)
-{
-	if (f == NULL || !PyFile_Check(f))
-		return NULL;
-	else
-		return ((PyFileObject *)f)->f_fp;
-}
-
-PyObject *
-PyFile_Name(PyObject *f)
-{
-	if (f == NULL || !PyFile_Check(f))
-		return NULL;
-	else
-		return ((PyFileObject *)f)->f_name;
-}
-
-/* On Unix, fopen will succeed for directories.
-   In Python, there should be no file objects referring to
-   directories, so we need a check.  */
-
-static PyFileObject*
-dircheck(PyFileObject* f)
-{
-#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)
-	struct stat buf;
-	if (f->f_fp == NULL)
-		return f;
-	if (fstat(fileno(f->f_fp), &buf) == 0 &&
-	    S_ISDIR(buf.st_mode)) {
-#ifdef HAVE_STRERROR
-		char *msg = strerror(EISDIR);
-#else
-		char *msg = "Is a directory";
-#endif
-		PyObject *exc = PyObject_CallFunction(PyExc_IOError, "(is)",
-						      EISDIR, msg);
-		PyErr_SetObject(PyExc_IOError, exc);
-		Py_XDECREF(exc);
-		return NULL;
-	}
-#endif
-	return f;
-}
-
-
-static PyObject *
-fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode,
-		 int (*close)(FILE *))
-{
-	assert(name != NULL);
-	assert(f != NULL);
-	assert(PyFile_Check(f));
-	assert(f->f_fp == NULL);
-
-	Py_DECREF(f->f_name);
-	Py_DECREF(f->f_mode);
-	Py_DECREF(f->f_encoding);
-
-        Py_INCREF(name);
-        f->f_name = name;
-
-	f->f_mode = PyString_FromString(mode);
-
-	f->f_close = close;
-	f->f_binary = strchr(mode,'b') != NULL;
-	f->f_buf = NULL;
-	f->f_univ_newline = (strchr(mode, 'U') != NULL);
-	f->f_newlinetypes = NEWLINE_UNKNOWN;
-	f->f_skipnextlf = 0;
-	Py_INCREF(Py_None);
-	f->f_encoding = Py_None;
-
-	if (f->f_mode == NULL)
-		return NULL;
-	f->f_fp = fp;
-        f = dircheck(f);
-	return (PyObject *) f;
-}
-
-/* check for known incorrect mode strings - problem is, platforms are
-   free to accept any mode characters they like and are supposed to
-   ignore stuff they don't understand... write or append mode with
-   universal newline support is expressly forbidden by PEP 278.
-   Additionally, remove the 'U' from the mode string as platforms
-   won't know what it is. Non-zero return signals an exception */
-int
-_PyFile_SanitizeMode(char *mode)
-{
-	char *upos;
-	size_t len = strlen(mode);
-
-	if (!len) {
-		PyErr_SetString(PyExc_ValueError, "empty mode string");
-		return -1;
-	}
-
-	upos = strchr(mode, 'U');
-	if (upos) {
-		memmove(upos, upos+1, len-(upos-mode)); /* incl null char */
-
-		if (mode[0] == 'w' || mode[0] == 'a') {
-			PyErr_Format(PyExc_ValueError, "universal newline "
-			             "mode can only be used with modes "
-				     "starting with 'r'");
-			return -1;
-		}
-
-		if (mode[0] != 'r') {
-			memmove(mode+1, mode, strlen(mode)+1);
-			mode[0] = 'r';
-		}
-
-		if (!strchr(mode, 'b')) {
-			memmove(mode+2, mode+1, strlen(mode));
-			mode[1] = 'b';
-		}
-	} else if (mode[0] != 'r' && mode[0] != 'w' && mode[0] != 'a') {
-		PyErr_Format(PyExc_ValueError, "mode string must begin with "
-	        	    "one of 'r', 'w', 'a' or 'U', not '%.200s'", mode);
-		return -1;
-	}
-
-	return 0;
-}
-
-static PyObject *
-open_the_file(PyFileObject *f, char *name, char *mode)
-{
-	char *newmode;
-	assert(f != NULL);
-	assert(PyFile_Check(f));
-#ifdef MS_WINDOWS
-	/* windows ignores the passed name in order to support Unicode */
-	assert(f->f_name != NULL);
-#else
-	assert(name != NULL);
-#endif
-	assert(mode != NULL);
-	assert(f->f_fp == NULL);
-
-	/* probably need to replace 'U' by 'rb' */
-	newmode = PyMem_MALLOC(strlen(mode) + 3);
-	if (!newmode) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	strcpy(newmode, mode);
-
-	if (_PyFile_SanitizeMode(newmode)) {
-		f = NULL;
-		goto cleanup;
-	}
-
-	errno = 0;
-
-#ifdef MS_WINDOWS
-	if (PyUnicode_Check(f->f_name)) {
-		PyObject *wmode;
-		wmode = PyUnicode_DecodeASCII(newmode, strlen(newmode), NULL);
-		if (f->f_name && wmode) {
-			Py_BEGIN_ALLOW_THREADS
-			/* PyUnicode_AS_UNICODE OK without thread
-			   lock as it is a simple dereference. */
-			f->f_fp = _wfopen(PyUnicode_AS_UNICODE(f->f_name),
-					  PyUnicode_AS_UNICODE(wmode));
-			Py_END_ALLOW_THREADS
-		}
-		Py_XDECREF(wmode);
-	}
-#endif
-	if (NULL == f->f_fp && NULL != name) {
-		Py_BEGIN_ALLOW_THREADS
-		f->f_fp = fopen(name, newmode);
-		Py_END_ALLOW_THREADS
-	}
-
-	if (f->f_fp == NULL) {
-#if defined  _MSC_VER && (_MSC_VER < 1400 || !defined(__STDC_SECURE_LIB__))
-		/* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings,
-		 * across all Windows flavors.  When it sets EINVAL varies
-		 * across Windows flavors, the exact conditions aren't
-		 * documented, and the answer lies in the OS's implementation
-		 * of Win32's CreateFile function (whose source is secret).
-		 * Seems the best we can do is map EINVAL to ENOENT.
-		 * Starting with Visual Studio .NET 2005, EINVAL is correctly
-		 * set by our CRT error handler (set in exceptions.c.)
-		 */
-		if (errno == 0)	/* bad mode string */
-			errno = EINVAL;
-		else if (errno == EINVAL) /* unknown, but not a mode string */
-			errno = ENOENT;
-#endif
-		if (errno == EINVAL)
-			PyErr_Format(PyExc_IOError, "invalid mode: %s",
-				     mode);
-		else
-			PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, f->f_name);
-		f = NULL;
-	}
-	if (f != NULL)
-		f = dircheck(f);
-
-cleanup:
-	PyMem_FREE(newmode);
-
-	return (PyObject *)f;
-}
+/* External C interface */
 
 PyObject *
 PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *))
 {
-	PyObject *io = NULL, *stream = NULL;
+	PyObject *io, *stream, *nameobj;
 
 	io = PyImport_ImportModule("io");
 	if (io == NULL)
 		return NULL;
-	stream = PyObject_CallMethod(io, "open", "ss", name, mode);
-	if (stream == NULL) {
-		Py_XDECREF(io);
-		return NULL;
-	}
-	if (close != NULL)
-		close(fp);
-	return stream;
-}
-
-PyObject *
-PyFile_FromString(char *name, char *mode)
-{
-	extern int fclose(FILE *);
-	PyFileObject *f;
-
-	f = (PyFileObject *)PyFile_FromFile((FILE *)NULL, name, mode, fclose);
-	if (f != NULL) {
-		if (open_the_file(f, name, mode) == NULL) {
-			Py_DECREF(f);
-			f = NULL;
-		}
-	}
-	return (PyObject *)f;
-}
-
-void
-PyFile_SetBufSize(PyObject *f, int bufsize)
-{
-	PyFileObject *file = (PyFileObject *)f;
-	if (bufsize >= 0) {
-		int type;
-		switch (bufsize) {
-		case 0:
-			type = _IONBF;
-			break;
-#ifdef HAVE_SETVBUF
-		case 1:
-			type = _IOLBF;
-			bufsize = BUFSIZ;
-			break;
-#endif
-		default:
-			type = _IOFBF;
-#ifndef HAVE_SETVBUF
-			bufsize = BUFSIZ;
-#endif
-			break;
-		}
-		fflush(file->f_fp);
-		if (type == _IONBF) {
-			PyMem_Free(file->f_setbuf);
-			file->f_setbuf = NULL;
-		} else {
-			file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf, 
-                                                                bufsize);
-		}
-#ifdef HAVE_SETVBUF
-		setvbuf(file->f_fp, file->f_setbuf, type, bufsize);
-#else /* !HAVE_SETVBUF */
-		setbuf(file->f_fp, file->f_setbuf);
-#endif /* !HAVE_SETVBUF */
-	}
-}
-
-/* Set the encoding used to output Unicode strings.
-   Returh 1 on success, 0 on failure. */
-
-int
-PyFile_SetEncoding(PyObject *f, const char *enc)
-{
-	PyFileObject *file = (PyFileObject*)f;
-	PyObject *str = PyString_FromString(enc);
-
-	assert(PyFile_Check(f));
-	if (!str)
-		return 0;
-	Py_DECREF(file->f_encoding);
-	file->f_encoding = str;
-	return 1;
-}
-
-static PyObject *
-err_closed(void)
-{
-	PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");
-	return NULL;
-}
-
-/* Refuse regular file I/O if there's data in the iteration-buffer.
- * Mixing them would cause data to arrive out of order, as the read*
- * methods don't use the iteration buffer. */
-static PyObject *
-err_iterbuffered(void)
-{
-	PyErr_SetString(PyExc_ValueError,
-		"Mixing iteration and read methods would lose data");
-	return NULL;
-}
-
-static void drop_readahead(PyFileObject *);
-
-/* Methods */
-
-static void
-file_dealloc(PyFileObject *f)
-{
-	int sts = 0;
-	if (f->weakreflist != NULL)
-		PyObject_ClearWeakRefs((PyObject *) f);
-	if (f->f_fp != NULL && f->f_close != NULL) {
-		Py_BEGIN_ALLOW_THREADS
-		sts = (*f->f_close)(f->f_fp);
-		Py_END_ALLOW_THREADS
-		if (sts == EOF) 
-#ifdef HAVE_STRERROR
-			PySys_WriteStderr("close failed: [Errno %d] %s\n", errno, strerror(errno)); 
-#else
-			PySys_WriteStderr("close failed: [Errno %d]\n", errno); 
-#endif
-	}
-	PyMem_Free(f->f_setbuf);
-	Py_XDECREF(f->f_name);
-	Py_XDECREF(f->f_mode);
-	Py_XDECREF(f->f_encoding);
-	drop_readahead(f);
-	f->ob_type->tp_free((PyObject *)f);
-}
-
-static PyObject *
-file_repr(PyFileObject *f)
-{
-	if (PyUnicode_Check(f->f_name)) {
-		PyObject *ret = NULL;
-		PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
-		const char *name_str = name ? PyString_AsString(name) : "?";
-		ret = PyUnicode_FromFormat("<%s file u'%s', mode '%s' at %p>",
-				   f->f_fp == NULL ? "closed" : "open",
-				   name_str,
-				   PyString_AsString(f->f_mode),
-				   f);
-		Py_XDECREF(name);
-		return ret;
-	} else {
-		return PyUnicode_FromFormat("<%s file '%s', mode '%s' at %p>",
-				   f->f_fp == NULL ? "closed" : "open",
-				   PyString_AsString(f->f_name),
-				   PyString_AsString(f->f_mode),
-				   f);
-	}
-}
-
-static PyObject *
-file_close(PyFileObject *f)
-{
-	int sts = 0;
-	if (f->f_fp != NULL) {
-		if (f->f_close != NULL) {
-			Py_BEGIN_ALLOW_THREADS
-			errno = 0;
-			sts = (*f->f_close)(f->f_fp);
-			Py_END_ALLOW_THREADS
-		}
-		f->f_fp = NULL;
-	}
-	PyMem_Free(f->f_setbuf);
-	f->f_setbuf = NULL;
-	if (sts == EOF)
-		return PyErr_SetFromErrno(PyExc_IOError);
-	if (sts != 0)
-		return PyInt_FromLong((long)sts);
-	Py_INCREF(Py_None);
-	return Py_None;
-}
-
-
-/* Our very own off_t-like type, 64-bit if possible */
-#if !defined(HAVE_LARGEFILE_SUPPORT)
-typedef off_t Py_off_t;
-#elif SIZEOF_OFF_T >= 8
-typedef off_t Py_off_t;
-#elif SIZEOF_FPOS_T >= 8
-typedef fpos_t Py_off_t;
-#else
-#error "Large file support, but neither off_t nor fpos_t is large enough."
-#endif
-
-
-/* a portable fseek() function
-   return 0 on success, non-zero on failure (with errno set) */
-static int
-_portable_fseek(FILE *fp, Py_off_t offset, int whence)
-{
-#if !defined(HAVE_LARGEFILE_SUPPORT)
-	return fseek(fp, offset, whence);
-#elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8
-	return fseeko(fp, offset, whence);
-#elif defined(HAVE_FSEEK64)
-	return fseek64(fp, offset, whence);
-#elif defined(__BEOS__)
-	return _fseek(fp, offset, whence);
-#elif SIZEOF_FPOS_T >= 8
-	/* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos()
-	   and fgetpos() to implement fseek()*/
-	fpos_t pos;
-	switch (whence) {
-	case SEEK_END:
-#ifdef MS_WINDOWS
-		fflush(fp);
-		if (_lseeki64(fileno(fp), 0, 2) == -1)
-			return -1;
-#else
-		if (fseek(fp, 0, SEEK_END) != 0)
-			return -1;
-#endif
-		/* fall through */
-	case SEEK_CUR:
-		if (fgetpos(fp, &pos) != 0)
-			return -1;
-		offset += pos;
-		break;
-	/* case SEEK_SET: break; */
-	}
-	return fsetpos(fp, &offset);
-#else
-#error "Large file support, but no way to fseek."
-#endif
-}
-
-
-/* a portable ftell() function
-   Return -1 on failure with errno set appropriately, current file
-   position on success */
-static Py_off_t
-_portable_ftell(FILE* fp)
-{
-#if !defined(HAVE_LARGEFILE_SUPPORT)
-	return ftell(fp);
-#elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8
-	return ftello(fp);
-#elif defined(HAVE_FTELL64)
-	return ftell64(fp);
-#elif SIZEOF_FPOS_T >= 8
-	fpos_t pos;
-	if (fgetpos(fp, &pos) != 0)
-		return -1;
-	return pos;
-#else
-#error "Large file support, but no way to ftell."
-#endif
-}
-
-
-static PyObject *
-file_seek(PyFileObject *f, PyObject *args)
-{
-	int whence;
-	int ret;
-	Py_off_t offset;
-	PyObject *offobj, *off_index;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	drop_readahead(f);
-	whence = 0;
-	if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &whence))
+	stream = PyObject_CallMethod(io, "open", "is", fileno(fp), mode);
+        Py_DECREF(io);
+	if (stream == NULL)
 		return NULL;
-	off_index = PyNumber_Index(offobj);
-	if (!off_index) {
-		if (!PyFloat_Check(offobj))
-			return NULL;
-		/* Deprecated in 2.6 */
+        nameobj = PyUnicode_FromString(name);
+        if (nameobj == NULL)
 		PyErr_Clear();
-		if (PyErr_Warn(PyExc_DeprecationWarning,
-			       "integer argument expected, got float"))
-			return NULL;
-		off_index = offobj;
-		Py_INCREF(offobj);
-	}
-#if !defined(HAVE_LARGEFILE_SUPPORT)
-	offset = PyInt_AsLong(off_index);
-#else
-	offset = PyLong_Check(off_index) ?
-		PyLong_AsLongLong(off_index) : PyInt_AsLong(off_index);
-#endif
-	Py_DECREF(off_index);
-	if (PyErr_Occurred())
-		return NULL;
-
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	ret = _portable_fseek(f->f_fp, offset, whence);
-	Py_END_ALLOW_THREADS
-
-	if (ret != 0) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		clearerr(f->f_fp);
-		return NULL;
-	}
-	f->f_skipnextlf = 0;
-	Py_INCREF(Py_None);
-	return Py_None;
-}
-
-
-#ifdef HAVE_FTRUNCATE
-static PyObject *
-file_truncate(PyFileObject *f, PyObject *args)
-{
-	Py_off_t newsize;
-	PyObject *newsizeobj = NULL;
-	Py_off_t initialpos;
-	int ret;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	if (!PyArg_UnpackTuple(args, "truncate", 0, 1, &newsizeobj))
-		return NULL;
-
-	/* Get current file position.  If the file happens to be open for
-	 * update and the last operation was an input operation, C doesn't
-	 * define what the later fflush() will do, but we promise truncate()
-	 * won't change the current position (and fflush() *does* change it
-	 * then at least on Windows).  The easiest thing is to capture
-	 * current pos now and seek back to it at the end.
-	 */
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	initialpos = _portable_ftell(f->f_fp);
-	Py_END_ALLOW_THREADS
-	if (initialpos == -1)
-		goto onioerror;
-
-	/* Set newsize to current postion if newsizeobj NULL, else to the
-	 * specified value.
-	 */
-	if (newsizeobj != NULL) {
-#if !defined(HAVE_LARGEFILE_SUPPORT)
-		newsize = PyInt_AsLong(newsizeobj);
-#else
-		newsize = PyLong_Check(newsizeobj) ?
-				PyLong_AsLongLong(newsizeobj) :
-				PyInt_AsLong(newsizeobj);
-#endif
-		if (PyErr_Occurred())
-			return NULL;
-	}
-	else /* default to current position */
-		newsize = initialpos;
-
-	/* Flush the stream.  We're mixing stream-level I/O with lower-level
-	 * I/O, and a flush may be necessary to synch both platform views
-	 * of the current file state.
-	 */
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	ret = fflush(f->f_fp);
-	Py_END_ALLOW_THREADS
-	if (ret != 0)
-		goto onioerror;
-
-#ifdef MS_WINDOWS
-	/* MS _chsize doesn't work if newsize doesn't fit in 32 bits,
-	   so don't even try using it. */
-	{
-		HANDLE hFile;
-
-		/* Have to move current pos to desired endpoint on Windows. */
-		Py_BEGIN_ALLOW_THREADS
-		errno = 0;
-		ret = _portable_fseek(f->f_fp, newsize, SEEK_SET) != 0;
-		Py_END_ALLOW_THREADS
-		if (ret)
-			goto onioerror;
-
-		/* Truncate.  Note that this may grow the file! */
-		Py_BEGIN_ALLOW_THREADS
-		errno = 0;
-		hFile = (HANDLE)_get_osfhandle(fileno(f->f_fp));
-		ret = hFile == (HANDLE)-1;
-		if (ret == 0) {
-			ret = SetEndOfFile(hFile) == 0;
-			if (ret)
-				errno = EACCES;
-		}
-		Py_END_ALLOW_THREADS
-		if (ret)
-			goto onioerror;
-	}
-#else
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	ret = ftruncate(fileno(f->f_fp), newsize);
-	Py_END_ALLOW_THREADS
-	if (ret != 0)
-		goto onioerror;
-#endif /* !MS_WINDOWS */
-
-	/* Restore original file position. */
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	ret = _portable_fseek(f->f_fp, initialpos, SEEK_SET) != 0;
-	Py_END_ALLOW_THREADS
-	if (ret)
-		goto onioerror;
-
-	Py_INCREF(Py_None);
-	return Py_None;
-
-onioerror:
-	PyErr_SetFromErrno(PyExc_IOError);
-	clearerr(f->f_fp);
-	return NULL;
-}
-#endif /* HAVE_FTRUNCATE */
-
-static PyObject *
-file_tell(PyFileObject *f)
-{
-	Py_off_t pos;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	pos = _portable_ftell(f->f_fp);
-	Py_END_ALLOW_THREADS
-	if (pos == -1) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		clearerr(f->f_fp);
-		return NULL;
-	}
-	if (f->f_skipnextlf) {
-		int c;
-		c = GETC(f->f_fp);
-		if (c == '\n') {
-			pos++;
-			f->f_skipnextlf = 0;
-		} else if (c != EOF) ungetc(c, f->f_fp);
-	}
-#if !defined(HAVE_LARGEFILE_SUPPORT)
-	return PyInt_FromLong(pos);
-#else
-	return PyLong_FromLongLong(pos);
-#endif
-}
-
-static PyObject *
-file_fileno(PyFileObject *f)
-{
-	if (f->f_fp == NULL)
-		return err_closed();
-	return PyInt_FromLong((long) fileno(f->f_fp));
-}
-
-static PyObject *
-file_flush(PyFileObject *f)
-{
-	int res;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	res = fflush(f->f_fp);
-	Py_END_ALLOW_THREADS
-	if (res != 0) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		clearerr(f->f_fp);
-		return NULL;
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
-}
-
-static PyObject *
-file_isatty(PyFileObject *f)
-{
-	long res;
-	if (f->f_fp == NULL)
-		return err_closed();
-	Py_BEGIN_ALLOW_THREADS
-	res = isatty((int)fileno(f->f_fp));
-	Py_END_ALLOW_THREADS
-	return PyBool_FromLong(res);
-}
-
-
-#if BUFSIZ < 8192
-#define SMALLCHUNK 8192
-#else
-#define SMALLCHUNK BUFSIZ
-#endif
-
-#if SIZEOF_INT < 4
-#define BIGCHUNK  (512 * 32)
-#else
-#define BIGCHUNK  (512 * 1024)
-#endif
-
-static size_t
-new_buffersize(PyFileObject *f, size_t currentsize)
-{
-#ifdef HAVE_FSTAT
-	off_t pos, end;
-	struct stat st;
-	if (fstat(fileno(f->f_fp), &st) == 0) {
-		end = st.st_size;
-		/* The following is not a bug: we really need to call lseek()
-		   *and* ftell().  The reason is that some stdio libraries
-		   mistakenly flush their buffer when ftell() is called and
-		   the lseek() call it makes fails, thereby throwing away
-		   data that cannot be recovered in any way.  To avoid this,
-		   we first test lseek(), and only call ftell() if lseek()
-		   works.  We can't use the lseek() value either, because we
-		   need to take the amount of buffered data into account.
-		   (Yet another reason why stdio stinks. :-) */
-		pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR);
-		if (pos >= 0) {
-			pos = ftell(f->f_fp);
-		}
-		if (pos < 0)
-			clearerr(f->f_fp);
-		if (end > pos && pos >= 0)
-			return currentsize + end - pos + 1;
-		/* Add 1 so if the file were to grow we'd notice. */
-	}
-#endif
-	if (currentsize > SMALLCHUNK) {
-		/* Keep doubling until we reach BIGCHUNK;
-		   then keep adding BIGCHUNK. */
-		if (currentsize <= BIGCHUNK)
-			return currentsize + currentsize;
-		else
-			return currentsize + BIGCHUNK;
-	}
-	return currentsize + SMALLCHUNK;
-}
-
-#if defined(EWOULDBLOCK) && defined(EAGAIN) && EWOULDBLOCK != EAGAIN
-#define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK || (x) == EAGAIN)
-#else
-#ifdef EWOULDBLOCK
-#define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK)
-#else
-#ifdef EAGAIN
-#define BLOCKED_ERRNO(x) ((x) == EAGAIN)
-#else
-#define BLOCKED_ERRNO(x) 0
-#endif
-#endif
-#endif
-
-static PyObject *
-file_read(PyFileObject *f, PyObject *args)
-{
-	long bytesrequested = -1;
-	size_t bytesread, buffersize, chunksize;
-	PyObject *v;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	/* refuse to mix with f.next() */
-	if (f->f_buf != NULL &&
-	    (f->f_bufend - f->f_bufptr) > 0 &&
-	    f->f_buf[0] != '\0')
-		return err_iterbuffered();
-	if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested))
-		return NULL;
-	if (bytesrequested < 0)
-		buffersize = new_buffersize(f, (size_t)0);
-	else
-		buffersize = bytesrequested;
-	if (buffersize > PY_SSIZE_T_MAX) {
-		PyErr_SetString(PyExc_OverflowError,
-	"requested number of bytes is more than a Python string can hold");
-		return NULL;
-	}
-	v = PyString_FromStringAndSize((char *)NULL, buffersize);
-	if (v == NULL)
-		return NULL;
-	bytesread = 0;
-	for (;;) {
-		Py_BEGIN_ALLOW_THREADS
-		errno = 0;
-		chunksize = Py_UniversalNewlineFread(BUF(v) + bytesread,
-			  buffersize - bytesread, f->f_fp, (PyObject *)f);
-		Py_END_ALLOW_THREADS
-		if (chunksize == 0) {
-			if (!ferror(f->f_fp))
-				break;
-			clearerr(f->f_fp);
-			/* When in non-blocking mode, data shouldn't
-			 * be discarded if a blocking signal was
-			 * received. That will also happen if
-			 * chunksize != 0, but bytesread < buffersize. */
-			if (bytesread > 0 && BLOCKED_ERRNO(errno))
-				break;
-			PyErr_SetFromErrno(PyExc_IOError);
-			Py_DECREF(v);
-			return NULL;
-		}
-		bytesread += chunksize;
-		if (bytesread < buffersize) {
-			clearerr(f->f_fp);
-			break;
-		}
-		if (bytesrequested < 0) {
-			buffersize = new_buffersize(f, buffersize);
-			if (_PyString_Resize(&v, buffersize) < 0)
-				return NULL;
-		} else {
-			/* Got what was requested. */
-			break;
-		}
-	}
-	if (bytesread != buffersize)
-		_PyString_Resize(&v, bytesread);
-	return v;
-}
-
-static PyObject *
-file_readinto(PyFileObject *f, PyObject *args)
-{
-	char *ptr;
-	Py_ssize_t ntodo;
-	Py_ssize_t ndone, nnow;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	if (!f->f_binary) {
-		PyErr_SetString(PyExc_TypeError,
-				"readinto() requires binary mode");
-		return NULL;
-	}
-	/* refuse to mix with f.next() */
-	if (f->f_buf != NULL &&
-	    (f->f_bufend - f->f_bufptr) > 0 &&
-	    f->f_buf[0] != '\0')
-		return err_iterbuffered();
-	if (!PyArg_ParseTuple(args, "w#", &ptr, &ntodo))
-		return NULL;
-	ndone = 0;
-	while (ntodo > 0) {
-		Py_BEGIN_ALLOW_THREADS
-		errno = 0;
-		nnow = Py_UniversalNewlineFread(ptr+ndone, ntodo, f->f_fp,
-						(PyObject *)f);
-		Py_END_ALLOW_THREADS
-		if (nnow == 0) {
-			if (!ferror(f->f_fp))
-				break;
-			PyErr_SetFromErrno(PyExc_IOError);
-			clearerr(f->f_fp);
-			return NULL;
-		}
-		ndone += nnow;
-		ntodo -= nnow;
-	}
-	return PyInt_FromSsize_t(ndone);
-}
-
-/**************************************************************************
-Routine to get next line using platform fgets().
-
-Under MSVC 6:
-
-+ MS threadsafe getc is very slow (multiple layers of function calls before+
-  after each character, to lock+unlock the stream).
-+ The stream-locking functions are MS-internal -- can't access them from user
-  code.
-+ There's nothing Tim could find in the MS C or platform SDK libraries that
-  can worm around this.
-+ MS fgets locks/unlocks only once per line; it's the only hook we have.
-
-So we use fgets for speed(!), despite that it's painful.
-
-MS realloc is also slow.
-
-Reports from other platforms on this method vs getc_unlocked (which MS doesn't
-have):
-	Linux		a wash
-	Solaris		a wash
-	Tru64 Unix	getline_via_fgets significantly faster
-
-CAUTION:  The C std isn't clear about this:  in those cases where fgets
-writes something into the buffer, can it write into any position beyond the
-required trailing null byte?  MSVC 6 fgets does not, and no platform is (yet)
-known on which it does; and it would be a strange way to code fgets. Still,
-getline_via_fgets may not work correctly if it does.  The std test
-test_bufio.py should fail if platform fgets() routinely writes beyond the
-trailing null byte.  #define DONT_USE_FGETS_IN_GETLINE to disable this code.
-**************************************************************************/
-
-/* Use this routine if told to, or by default on non-get_unlocked()
- * platforms unless told not to.  Yikes!  Let's spell that out:
- * On a platform with getc_unlocked():
- *     By default, use getc_unlocked().
- *     If you want to use fgets() instead, #define USE_FGETS_IN_GETLINE.
- * On a platform without getc_unlocked():
- *     By default, use fgets().
- *     If you don't want to use fgets(), #define DONT_USE_FGETS_IN_GETLINE.
- */
-#if !defined(USE_FGETS_IN_GETLINE) && !defined(HAVE_GETC_UNLOCKED)
-#define USE_FGETS_IN_GETLINE
-#endif
-
-#if defined(DONT_USE_FGETS_IN_GETLINE) && defined(USE_FGETS_IN_GETLINE)
-#undef USE_FGETS_IN_GETLINE
-#endif
-
-#ifdef USE_FGETS_IN_GETLINE
-static PyObject*
-getline_via_fgets(FILE *fp)
-{
-/* INITBUFSIZE is the maximum line length that lets us get away with the fast
- * no-realloc, one-fgets()-call path.  Boosting it isn't free, because we have
- * to fill this much of the buffer with a known value in order to figure out
- * how much of the buffer fgets() overwrites.  So if INITBUFSIZE is larger
- * than "most" lines, we waste time filling unused buffer slots.  100 is
- * surely adequate for most peoples' email archives, chewing over source code,
- * etc -- "regular old text files".
- * MAXBUFSIZE is the maximum line length that lets us get away with the less
- * fast (but still zippy) no-realloc, two-fgets()-call path.  See above for
- * cautions about boosting that.  300 was chosen because the worst real-life
- * text-crunching job reported on Python-Dev was a mail-log crawler where over
- * half the lines were 254 chars.
- */
-#define INITBUFSIZE 100
-#define MAXBUFSIZE 300
-	char* p;	/* temp */
-	char buf[MAXBUFSIZE];
-	PyObject* v;	/* the string object result */
-	char* pvfree;	/* address of next free slot */
-	char* pvend;    /* address one beyond last free slot */
-	size_t nfree;	/* # of free buffer slots; pvend-pvfree */
-	size_t total_v_size;  /* total # of slots in buffer */
-	size_t increment;	/* amount to increment the buffer */
-	size_t prev_v_size;
-
-	/* Optimize for normal case:  avoid _PyString_Resize if at all
-	 * possible via first reading into stack buffer "buf".
-	 */
-	total_v_size = INITBUFSIZE;	/* start small and pray */
-	pvfree = buf;
-	for (;;) {
-		Py_BEGIN_ALLOW_THREADS
-		pvend = buf + total_v_size;
-		nfree = pvend - pvfree;
-		memset(pvfree, '\n', nfree);
-		assert(nfree < INT_MAX); /* Should be atmost MAXBUFSIZE */
-		p = fgets(pvfree, (int)nfree, fp);
-		Py_END_ALLOW_THREADS
-
-		if (p == NULL) {
-			clearerr(fp);
-			if (PyErr_CheckSignals())
-				return NULL;
-			v = PyString_FromStringAndSize(buf, pvfree - buf);
-			return v;
-		}
-		/* fgets read *something* */
-		p = memchr(pvfree, '\n', nfree);
-		if (p != NULL) {
-			/* Did the \n come from fgets or from us?
-			 * Since fgets stops at the first \n, and then writes
-			 * \0, if it's from fgets a \0 must be next.  But if
-			 * that's so, it could not have come from us, since
-			 * the \n's we filled the buffer with have only more
-			 * \n's to the right.
-			 */
-			if (p+1 < pvend && *(p+1) == '\0') {
-				/* It's from fgets:  we win!  In particular,
-				 * we haven't done any mallocs yet, and can
-				 * build the final result on the first try.
-				 */
-				++p;	/* include \n from fgets */
-			}
-			else {
-				/* Must be from us:  fgets didn't fill the
-				 * buffer and didn't find a newline, so it
-				 * must be the last and newline-free line of
-				 * the file.
-				 */
-				assert(p > pvfree && *(p-1) == '\0');
-				--p;	/* don't include \0 from fgets */
-			}
-			v = PyString_FromStringAndSize(buf, p - buf);
-			return v;
-		}
-		/* yuck:  fgets overwrote all the newlines, i.e. the entire
-		 * buffer.  So this line isn't over yet, or maybe it is but
-		 * we're exactly at EOF.  If we haven't already, try using the
-		 * rest of the stack buffer.
-		 */
-		assert(*(pvend-1) == '\0');
-		if (pvfree == buf) {
-			pvfree = pvend - 1;	/* overwrite trailing null */
-			total_v_size = MAXBUFSIZE;
-		}
-		else
-			break;
-	}
-
-	/* The stack buffer isn't big enough; malloc a string object and read
-	 * into its buffer.
-	 */
-	total_v_size = MAXBUFSIZE << 1;
-	v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
-	if (v == NULL)
-		return v;
-	/* copy over everything except the last null byte */
-	memcpy(BUF(v), buf, MAXBUFSIZE-1);
-	pvfree = BUF(v) + MAXBUFSIZE - 1;
-
-	/* Keep reading stuff into v; if it ever ends successfully, break
-	 * after setting p one beyond the end of the line.  The code here is
-	 * very much like the code above, except reads into v's buffer; see
-	 * the code above for detailed comments about the logic.
-	 */
-	for (;;) {
-		Py_BEGIN_ALLOW_THREADS
-		pvend = BUF(v) + total_v_size;
-		nfree = pvend - pvfree;
-		memset(pvfree, '\n', nfree);
-		assert(nfree < INT_MAX);
-		p = fgets(pvfree, (int)nfree, fp);
-		Py_END_ALLOW_THREADS
-
-		if (p == NULL) {
-			clearerr(fp);
-			if (PyErr_CheckSignals()) {
-				Py_DECREF(v);
-				return NULL;
-			}
-			p = pvfree;
-			break;
-		}
-		p = memchr(pvfree, '\n', nfree);
-		if (p != NULL) {
-			if (p+1 < pvend && *(p+1) == '\0') {
-				/* \n came from fgets */
-				++p;
-				break;
-			}
-			/* \n came from us; last line of file, no newline */
-			assert(p > pvfree && *(p-1) == '\0');
-			--p;
-			break;
-		}
-		/* expand buffer and try again */
-		assert(*(pvend-1) == '\0');
-		increment = total_v_size >> 2;	/* mild exponential growth */
-		prev_v_size = total_v_size;
-		total_v_size += increment;
-		/* check for overflow */
-		if (total_v_size <= prev_v_size ||
-		    total_v_size > PY_SSIZE_T_MAX) {
-			PyErr_SetString(PyExc_OverflowError,
-			    "line is longer than a Python string can hold");
-			Py_DECREF(v);
-			return NULL;
-		}
-		if (_PyString_Resize(&v, (int)total_v_size) < 0)
-			return NULL;
-		/* overwrite the trailing null byte */
-		pvfree = BUF(v) + (prev_v_size - 1);
-	}
-	if (BUF(v) + total_v_size != p)
-		_PyString_Resize(&v, p - BUF(v));
-	return v;
-#undef INITBUFSIZE
-#undef MAXBUFSIZE
-}
-#endif	/* ifdef USE_FGETS_IN_GETLINE */
-
-/* Internal routine to get a line.
-   Size argument interpretation:
-   > 0: max length;
-   <= 0: read arbitrary line
-*/
-
-static PyObject *
-get_line(PyFileObject *f, int n)
-{
-	FILE *fp = f->f_fp;
-	int c;
-	char *buf, *end;
-	size_t total_v_size;	/* total # of slots in buffer */
-	size_t used_v_size;	/* # used slots in buffer */
-	size_t increment;       /* amount to increment the buffer */
-	PyObject *v;
-	int newlinetypes = f->f_newlinetypes;
-	int skipnextlf = f->f_skipnextlf;
-	int univ_newline = f->f_univ_newline;
-
-#if defined(USE_FGETS_IN_GETLINE)
-	if (n <= 0 && !univ_newline )
-		return getline_via_fgets(fp);
-#endif
-	total_v_size = n > 0 ? n : 100;
-	v = PyString_FromStringAndSize((char *)NULL, total_v_size);
-	if (v == NULL)
-		return NULL;
-	buf = BUF(v);
-	end = buf + total_v_size;
-
-	for (;;) {
-		Py_BEGIN_ALLOW_THREADS
-		FLOCKFILE(fp);
-		if (univ_newline) {
-			c = 'x'; /* Shut up gcc warning */
-			while ( buf != end && (c = GETC(fp)) != EOF ) {
-				if (skipnextlf ) {
-					skipnextlf = 0;
-					if (c == '\n') {
-						/* Seeing a \n here with
-						 * skipnextlf true means we
-						 * saw a \r before.
-						 */
-						newlinetypes |= NEWLINE_CRLF;
-						c = GETC(fp);
-						if (c == EOF) break;
-					} else {
-						newlinetypes |= NEWLINE_CR;
-					}
-				}
-				if (c == '\r') {
-					skipnextlf = 1;
-					c = '\n';
-				} else if ( c == '\n')
-					newlinetypes |= NEWLINE_LF;
-				*buf++ = c;
-				if (c == '\n') break;
-			}
-			if ( c == EOF && skipnextlf )
-				newlinetypes |= NEWLINE_CR;
-		} else /* If not universal newlines use the normal loop */
-		while ((c = GETC(fp)) != EOF &&
-		       (*buf++ = c) != '\n' &&
-			buf != end)
-			;
-		FUNLOCKFILE(fp);
-		Py_END_ALLOW_THREADS
-		f->f_newlinetypes = newlinetypes;
-		f->f_skipnextlf = skipnextlf;
-		if (c == '\n')
-			break;
-		if (c == EOF) {
-			if (ferror(fp)) {
-				PyErr_SetFromErrno(PyExc_IOError);
-				clearerr(fp);
-				Py_DECREF(v);
-				return NULL;
-			}
-			clearerr(fp);
-			if (PyErr_CheckSignals()) {
-				Py_DECREF(v);
-				return NULL;
-			}
-			break;
-		}
-		/* Must be because buf == end */
-		if (n > 0)
-			break;
-		used_v_size = total_v_size;
-		increment = total_v_size >> 2; /* mild exponential growth */
-		total_v_size += increment;
-		if (total_v_size > PY_SSIZE_T_MAX) {
-			PyErr_SetString(PyExc_OverflowError,
-			    "line is longer than a Python string can hold");
-			Py_DECREF(v);
-			return NULL;
-		}
-		if (_PyString_Resize(&v, total_v_size) < 0)
-			return NULL;
-		buf = BUF(v) + used_v_size;
-		end = BUF(v) + total_v_size;
+	else {
+		if (PyObject_SetAttrString(stream, "name", nameobj) < 0)
+			PyErr_Clear();
+		Py_DECREF(nameobj);
 	}
-
-	used_v_size = buf - BUF(v);
-	if (used_v_size != total_v_size)
-		_PyString_Resize(&v, used_v_size);
-	return v;
+	return stream;
 }
 
-/* External C interface */
-
 PyObject *
 PyFile_GetLine(PyObject *f, int n)
 {
@@ -1268,18 +58,7 @@ PyFile_GetLine(PyObject *f, int n)
 		return NULL;
 	}
 
-	if (PyFile_Check(f)) {
-		PyFileObject *fo = (PyFileObject *)f;
-		if (fo->f_fp == NULL)
-			return err_closed();
-		/* refuse to mix with f.next() */
-		if (fo->f_buf != NULL &&
-		    (fo->f_bufend - fo->f_bufptr) > 0 &&
-		    fo->f_buf[0] != '\0')
-			return err_iterbuffered();
-		result = get_line(fo, n);
-	}
-	else {
+	{
 		PyObject *reader;
 		PyObject *args;
 
@@ -1349,759 +128,6 @@ PyFile_GetLine(PyObject *f, int n)
 	return result;
 }
 
-/* Python method */
-
-static PyObject *
-file_readline(PyFileObject *f, PyObject *args)
-{
-	int n = -1;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	/* refuse to mix with f.next() */
-	if (f->f_buf != NULL &&
-	    (f->f_bufend - f->f_bufptr) > 0 &&
-	    f->f_buf[0] != '\0')
-		return err_iterbuffered();
-	if (!PyArg_ParseTuple(args, "|i:readline", &n))
-		return NULL;
-	if (n == 0)
-		return PyString_FromString("");
-	if (n < 0)
-		n = 0;
-	return get_line(f, n);
-}
-
-static PyObject *
-file_readlines(PyFileObject *f, PyObject *args)
-{
-	long sizehint = 0;
-	PyObject *list;
-	PyObject *line;
-	char small_buffer[SMALLCHUNK];
-	char *buffer = small_buffer;
-	size_t buffersize = SMALLCHUNK;
-	PyObject *big_buffer = NULL;
-	size_t nfilled = 0;
-	size_t nread;
-	size_t totalread = 0;
-	char *p, *q, *end;
-	int err;
-	int shortread = 0;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-	/* refuse to mix with f.next() */
-	if (f->f_buf != NULL &&
-	    (f->f_bufend - f->f_bufptr) > 0 &&
-	    f->f_buf[0] != '\0')
-		return err_iterbuffered();
-	if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint))
-		return NULL;
-	if ((list = PyList_New(0)) == NULL)
-		return NULL;
-	for (;;) {
-		if (shortread)
-			nread = 0;
-		else {
-			Py_BEGIN_ALLOW_THREADS
-			errno = 0;
-			nread = Py_UniversalNewlineFread(buffer+nfilled,
-				buffersize-nfilled, f->f_fp, (PyObject *)f);
-			Py_END_ALLOW_THREADS
-			shortread = (nread < buffersize-nfilled);
-		}
-		if (nread == 0) {
-			sizehint = 0;
-			if (!ferror(f->f_fp))
-				break;
-			PyErr_SetFromErrno(PyExc_IOError);
-			clearerr(f->f_fp);
-		  error:
-			Py_DECREF(list);
-			list = NULL;
-			goto cleanup;
-		}
-		totalread += nread;
-		p = (char *)memchr(buffer+nfilled, '\n', nread);
-		if (p == NULL) {
-			/* Need a larger buffer to fit this line */
-			nfilled += nread;
-			buffersize *= 2;
-			if (buffersize > PY_SSIZE_T_MAX) {
-				PyErr_SetString(PyExc_OverflowError,
-			    "line is longer than a Python string can hold");
-				goto error;
-			}
-			if (big_buffer == NULL) {
-				/* Create the big buffer */
-				big_buffer = PyString_FromStringAndSize(
-					NULL, buffersize);
-				if (big_buffer == NULL)
-					goto error;
-				buffer = PyString_AS_STRING(big_buffer);
-				memcpy(buffer, small_buffer, nfilled);
-			}
-			else {
-				/* Grow the big buffer */
-				if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
-					goto error;
-				buffer = PyString_AS_STRING(big_buffer);
-			}
-			continue;
-		}
-		end = buffer+nfilled+nread;
-		q = buffer;
-		do {
-			/* Process complete lines */
-			p++;
-			line = PyString_FromStringAndSize(q, p-q);
-			if (line == NULL)
-				goto error;
-			err = PyList_Append(list, line);
-			Py_DECREF(line);
-			if (err != 0)
-				goto error;
-			q = p;
-			p = (char *)memchr(q, '\n', end-q);
-		} while (p != NULL);
-		/* Move the remaining incomplete line to the start */
-		nfilled = end-q;
-		memmove(buffer, q, nfilled);
-		if (sizehint > 0)
-			if (totalread >= (size_t)sizehint)
-				break;
-	}
-	if (nfilled != 0) {
-		/* Partial last line */
-		line = PyString_FromStringAndSize(buffer, nfilled);
-		if (line == NULL)
-			goto error;
-		if (sizehint > 0) {
-			/* Need to complete the last line */
-			PyObject *rest = get_line(f, 0);
-			if (rest == NULL) {
-				Py_DECREF(line);
-				goto error;
-			}
-			PyString_Concat(&line, rest);
-			Py_DECREF(rest);
-			if (line == NULL)
-				goto error;
-		}
-		err = PyList_Append(list, line);
-		Py_DECREF(line);
-		if (err != 0)
-			goto error;
-	}
-  cleanup:
-	Py_XDECREF(big_buffer);
-	return list;
-}
-
-static PyObject *
-file_write(PyFileObject *f, PyObject *args)
-{
-	char *s;
-	Py_ssize_t n, n2;
-	if (f->f_fp == NULL)
-		return err_closed();
-	if (!PyArg_ParseTuple(args, f->f_binary ? "s#" : "t#", &s, &n))
-		return NULL;
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	n2 = fwrite(s, 1, n, f->f_fp);
-	Py_END_ALLOW_THREADS
-	if (n2 != n) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		clearerr(f->f_fp);
-		return NULL;
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
-}
-
-static PyObject *
-file_writelines(PyFileObject *f, PyObject *seq)
-{
-#define CHUNKSIZE 1000
-	PyObject *list, *line;
-	PyObject *it;	/* iter(seq) */
-	PyObject *result;
-	int index, islist;
-	Py_ssize_t i, j, nwritten, len;
-
-	assert(seq != NULL);
-	if (f->f_fp == NULL)
-		return err_closed();
-
-	result = NULL;
-	list = NULL;
-	islist = PyList_Check(seq);
-	if  (islist)
-		it = NULL;
-	else {
-		it = PyObject_GetIter(seq);
-		if (it == NULL) {
-			PyErr_SetString(PyExc_TypeError,
-				"writelines() requires an iterable argument");
-			return NULL;
-		}
-		/* From here on, fail by going to error, to reclaim "it". */
-		list = PyList_New(CHUNKSIZE);
-		if (list == NULL)
-			goto error;
-	}
-
-	/* Strategy: slurp CHUNKSIZE lines into a private list,
-	   checking that they are all strings, then write that list
-	   without holding the interpreter lock, then come back for more. */
-	for (index = 0; ; index += CHUNKSIZE) {
-		if (islist) {
-			Py_XDECREF(list);
-			list = PyList_GetSlice(seq, index, index+CHUNKSIZE);
-			if (list == NULL)
-				goto error;
-			j = PyList_GET_SIZE(list);
-		}
-		else {
-			for (j = 0; j < CHUNKSIZE; j++) {
-				line = PyIter_Next(it);
-				if (line == NULL) {
-					if (PyErr_Occurred())
-						goto error;
-					break;
-				}
-				PyList_SetItem(list, j, line);
-			}
-		}
-		if (j == 0)
-			break;
-
-		/* Check that all entries are indeed strings. If not,
-		   apply the same rules as for file.write() and
-		   convert the results to strings. This is slow, but
-		   seems to be the only way since all conversion APIs
-		   could potentially execute Python code. */
-		for (i = 0; i < j; i++) {
-			PyObject *v = PyList_GET_ITEM(list, i);
-			if (!PyString_Check(v)) {
-			    	const char *buffer;
-				if (((f->f_binary &&
-				      PyObject_AsReadBuffer(v,
-					      (const void**)&buffer,
-							    &len)) ||
-				     PyObject_AsCharBuffer(v,
-							   &buffer,
-							   &len))) {
-					PyErr_SetString(PyExc_TypeError,
-			"writelines() argument must be a sequence of strings");
-					goto error;
-				}
-				line = PyString_FromStringAndSize(buffer,
-								  len);
-				if (line == NULL)
-					goto error;
-				Py_DECREF(v);
-				PyList_SET_ITEM(list, i, line);
-			}
-		}
-
-		/* Since we are releasing the global lock, the
-		   following code may *not* execute Python code. */
-		Py_BEGIN_ALLOW_THREADS
-		errno = 0;
-		for (i = 0; i < j; i++) {
-		    	line = PyList_GET_ITEM(list, i);
-			len = PyString_GET_SIZE(line);
-			nwritten = fwrite(PyString_AS_STRING(line),
-					  1, len, f->f_fp);
-			if (nwritten != len) {
-				Py_BLOCK_THREADS
-				PyErr_SetFromErrno(PyExc_IOError);
-				clearerr(f->f_fp);
-				goto error;
-			}
-		}
-		Py_END_ALLOW_THREADS
-
-		if (j < CHUNKSIZE)
-			break;
-	}
-
-	Py_INCREF(Py_None);
-	result = Py_None;
-  error:
-	Py_XDECREF(list);
-  	Py_XDECREF(it);
-	return result;
-#undef CHUNKSIZE
-}
-
-static PyObject *
-file_self(PyFileObject *f)
-{
-	if (f->f_fp == NULL)
-		return err_closed();
-	Py_INCREF(f);
-	return (PyObject *)f;
-}
-
-static PyObject *
-file_exit(PyFileObject *f, PyObject *args)
-{
-	PyObject *ret = file_close(f);
-	if (!ret)
-		/* If error occurred, pass through */
-		return NULL;
-	Py_DECREF(ret);
-	/* We cannot return the result of close since a true
-	 * value will be interpreted as "yes, swallow the
-	 * exception if one was raised inside the with block". */
-	Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(readline_doc,
-"readline([size]) -> next line from the file, as a string.\n"
-"\n"
-"Retain newline.  A non-negative size argument limits the maximum\n"
-"number of bytes to return (an incomplete line may be returned then).\n"
-"Return an empty string at EOF.");
-
-PyDoc_STRVAR(read_doc,
-"read([size]) -> read at most size bytes, returned as a string.\n"
-"\n"
-"If the size argument is negative or omitted, read until EOF is reached.\n"
-"Notice that when in non-blocking mode, less data than what was requested\n"
-"may be returned, even if no size parameter was given.");
-
-PyDoc_STRVAR(write_doc,
-"write(str) -> None.  Write string str to file.\n"
-"\n"
-"Note that due to buffering, flush() or close() may be needed before\n"
-"the file on disk reflects the data written.");
-
-PyDoc_STRVAR(fileno_doc,
-"fileno() -> integer \"file descriptor\".\n"
-"\n"
-"This is needed for lower-level file interfaces, such os.read().");
-
-PyDoc_STRVAR(seek_doc,
-"seek(offset[, whence]) -> None.  Move to new file position.\n"
-"\n"
-"Argument offset is a byte count.  Optional argument whence defaults to\n"
-"0 (offset from start of file, offset should be >= 0); other values are 1\n"
-"(move relative to current position, positive or negative), and 2 (move\n"
-"relative to end of file, usually negative, although many platforms allow\n"
-"seeking beyond the end of a file).  If the file is opened in text mode,\n"
-"only offsets returned by tell() are legal.  Use of other offsets causes\n"
-"undefined behavior."
-"\n"
-"Note that not all file objects are seekable.");
-
-#ifdef HAVE_FTRUNCATE
-PyDoc_STRVAR(truncate_doc,
-"truncate([size]) -> None.  Truncate the file to at most size bytes.\n"
-"\n"
-"Size defaults to the current file position, as returned by tell().");
-#endif
-
-PyDoc_STRVAR(tell_doc,
-"tell() -> current file position, an integer (may be a long integer).");
-
-PyDoc_STRVAR(readinto_doc,
-"readinto() -> Undocumented.  Don't use this; it may go away.");
-
-PyDoc_STRVAR(readlines_doc,
-"readlines([size]) -> list of strings, each a line from the file.\n"
-"\n"
-"Call readline() repeatedly and return a list of the lines so read.\n"
-"The optional size argument, if given, is an approximate bound on the\n"
-"total number of bytes in the lines returned.");
-
-PyDoc_STRVAR(writelines_doc,
-"writelines(sequence_of_strings) -> None.  Write the strings to the file.\n"
-"\n"
-"Note that newlines are not added.  The sequence can be any iterable object\n"
-"producing strings. This is equivalent to calling write() for each string.");
-
-PyDoc_STRVAR(flush_doc,
-"flush() -> None.  Flush the internal I/O buffer.");
-
-PyDoc_STRVAR(close_doc,
-"close() -> None or (perhaps) an integer.  Close the file.\n"
-"\n"
-"Sets data attribute .closed to True.  A closed file cannot be used for\n"
-"further I/O operations.  close() may be called more than once without\n"
-"error.  Some kinds of file objects (for example, opened by popen())\n"
-"may return an exit status upon closing.");
-
-PyDoc_STRVAR(isatty_doc,
-"isatty() -> true or false.  True if the file is connected to a tty device.");
-
-PyDoc_STRVAR(enter_doc,
-	     "__enter__() -> self.");
-
-PyDoc_STRVAR(exit_doc,
-	     "__exit__(*excinfo) -> None.  Closes the file.");
-
-static PyMethodDef file_methods[] = {
-	{"readline",  (PyCFunction)file_readline, METH_VARARGS, readline_doc},
-	{"read",      (PyCFunction)file_read,     METH_VARARGS, read_doc},
-	{"write",     (PyCFunction)file_write,    METH_VARARGS, write_doc},
-	{"fileno",    (PyCFunction)file_fileno,   METH_NOARGS,  fileno_doc},
-	{"seek",      (PyCFunction)file_seek,     METH_VARARGS, seek_doc},
-#ifdef HAVE_FTRUNCATE
-	{"truncate",  (PyCFunction)file_truncate, METH_VARARGS, truncate_doc},
-#endif
-	{"tell",      (PyCFunction)file_tell,     METH_NOARGS,  tell_doc},
-	{"readinto",  (PyCFunction)file_readinto, METH_VARARGS, readinto_doc},
-	{"readlines", (PyCFunction)file_readlines,METH_VARARGS, readlines_doc},
-	{"writelines",(PyCFunction)file_writelines, METH_O,    writelines_doc},
-	{"flush",     (PyCFunction)file_flush,    METH_NOARGS,  flush_doc},
-	{"close",     (PyCFunction)file_close,    METH_NOARGS,  close_doc},
-	{"isatty",    (PyCFunction)file_isatty,   METH_NOARGS,  isatty_doc},
-	{"__enter__", (PyCFunction)file_self,     METH_NOARGS,  enter_doc},
-	{"__exit__",  (PyCFunction)file_exit,     METH_VARARGS, exit_doc},
-	{NULL,	      NULL}		/* sentinel */
-};
-
-#define OFF(x) offsetof(PyFileObject, x)
-
-static PyMemberDef file_memberlist[] = {
-	{"mode",	T_OBJECT,	OFF(f_mode),	RO,
-	 "file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)"},
-	{"name",	T_OBJECT,	OFF(f_name),	RO,
-	 "file name"},
-	{"encoding",	T_OBJECT,	OFF(f_encoding),	RO,
-	 "file encoding"},
-	/* getattr(f, "closed") is implemented without this table */
-	{NULL}	/* Sentinel */
-};
-
-static PyObject *
-get_closed(PyFileObject *f, void *closure)
-{
-	return PyBool_FromLong((long)(f->f_fp == 0));
-}
-static PyObject *
-get_newlines(PyFileObject *f, void *closure)
-{
-	switch (f->f_newlinetypes) {
-	case NEWLINE_UNKNOWN:
-		Py_INCREF(Py_None);
-		return Py_None;
-	case NEWLINE_CR:
-		return PyString_FromString("\r");
-	case NEWLINE_LF:
-		return PyString_FromString("\n");
-	case NEWLINE_CR|NEWLINE_LF:
-		return Py_BuildValue("(ss)", "\r", "\n");
-	case NEWLINE_CRLF:
-		return PyString_FromString("\r\n");
-	case NEWLINE_CR|NEWLINE_CRLF:
-		return Py_BuildValue("(ss)", "\r", "\r\n");
-	case NEWLINE_LF|NEWLINE_CRLF:
-		return Py_BuildValue("(ss)", "\n", "\r\n");
-	case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF:
-		return Py_BuildValue("(sss)", "\r", "\n", "\r\n");
-	default:
-		PyErr_Format(PyExc_SystemError,
-			     "Unknown newlines value 0x%x\n",
-			     f->f_newlinetypes);
-		return NULL;
-	}
-}
-
-static PyGetSetDef file_getsetlist[] = {
-	{"closed", (getter)get_closed, NULL, "True if the file is closed"},
-	{"newlines", (getter)get_newlines, NULL,
-	 "end-of-line convention used in this file"},
-	{0},
-};
-
-static void
-drop_readahead(PyFileObject *f)
-{
-	if (f->f_buf != NULL) {
-		PyMem_Free(f->f_buf);
-		f->f_buf = NULL;
-	}
-}
-
-/* Make sure that file has a readahead buffer with at least one byte
-   (unless at EOF) and no more than bufsize.  Returns negative value on
-   error, will set MemoryError if bufsize bytes cannot be allocated. */
-static int
-readahead(PyFileObject *f, int bufsize)
-{
-	Py_ssize_t chunksize;
-
-	if (f->f_buf != NULL) {
-		if( (f->f_bufend - f->f_bufptr) >= 1)
-			return 0;
-		else
-			drop_readahead(f);
-	}
-	if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) {
-		PyErr_NoMemory();
-		return -1;
-	}
-	Py_BEGIN_ALLOW_THREADS
-	errno = 0;
-	chunksize = Py_UniversalNewlineFread(
-		f->f_buf, bufsize, f->f_fp, (PyObject *)f);
-	Py_END_ALLOW_THREADS
-	if (chunksize == 0) {
-		if (ferror(f->f_fp)) {
-			PyErr_SetFromErrno(PyExc_IOError);
-			clearerr(f->f_fp);
-			drop_readahead(f);
-			return -1;
-		}
-	}
-	f->f_bufptr = f->f_buf;
-	f->f_bufend = f->f_buf + chunksize;
-	return 0;
-}
-
-/* Used by file_iternext.  The returned string will start with 'skip'
-   uninitialized bytes followed by the remainder of the line. Don't be
-   horrified by the recursive call: maximum recursion depth is limited by
-   logarithmic buffer growth to about 50 even when reading a 1gb line. */
-
-static PyStringObject *
-readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
-{
-	PyStringObject* s;
-	char *bufptr;
-	char *buf;
-	Py_ssize_t len;
-
-	if (f->f_buf == NULL)
-		if (readahead(f, bufsize) < 0)
-			return NULL;
-
-	len = f->f_bufend - f->f_bufptr;
-	if (len == 0)
-		return (PyStringObject *)
-			PyString_FromStringAndSize(NULL, skip);
-	bufptr = (char *)memchr(f->f_bufptr, '\n', len);
-	if (bufptr != NULL) {
-		bufptr++;			/* Count the '\n' */
-		len = bufptr - f->f_bufptr;
-		s = (PyStringObject *)
-			PyString_FromStringAndSize(NULL, skip+len);
-		if (s == NULL)
-			return NULL;
-		memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
-		f->f_bufptr = bufptr;
-		if (bufptr == f->f_bufend)
-			drop_readahead(f);
-	} else {
-		bufptr = f->f_bufptr;
-		buf = f->f_buf;
-		f->f_buf = NULL; 	/* Force new readahead buffer */
-		assert(skip+len < INT_MAX);
-                s = readahead_get_line_skip(
-			f, (int)(skip+len), bufsize + (bufsize>>2) );
-		if (s == NULL) {
-		        PyMem_Free(buf);
-			return NULL;
-		}
-		memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
-		PyMem_Free(buf);
-	}
-	return s;
-}
-
-/* A larger buffer size may actually decrease performance. */
-#define READAHEAD_BUFSIZE 8192
-
-static PyObject *
-file_iternext(PyFileObject *f)
-{
-	PyStringObject* l;
-
-	if (f->f_fp == NULL)
-		return err_closed();
-
-	l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
-	if (l == NULL || PyString_GET_SIZE(l) == 0) {
-		Py_XDECREF(l);
-		return NULL;
-	}
-	return (PyObject *)l;
-}
-
-
-static PyObject *
-file_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-	PyObject *self;
-	static PyObject *not_yet_string;
-
-        PyErr_SetString(PyExc_SystemError, "attempt to create old file");
-        return NULL;
-
-	assert(type != NULL && type->tp_alloc != NULL);
-
-	if (not_yet_string == NULL) {
-		not_yet_string = PyString_FromString("<uninitialized file>");
-		if (not_yet_string == NULL)
-			return NULL;
-	}
-
-	self = type->tp_alloc(type, 0);
-	if (self != NULL) {
-		/* Always fill in the name and mode, so that nobody else
-		   needs to special-case NULLs there. */
-		Py_INCREF(not_yet_string);
-		((PyFileObject *)self)->f_name = not_yet_string;
-		Py_INCREF(not_yet_string);
-		((PyFileObject *)self)->f_mode = not_yet_string;
-		Py_INCREF(Py_None);
-		((PyFileObject *)self)->f_encoding = Py_None;
-		((PyFileObject *)self)->weakreflist = NULL;
-	}
-	return self;
-}
-
-static int
-file_init(PyObject *self, PyObject *args, PyObject *kwds)
-{
-	PyFileObject *foself = (PyFileObject *)self;
-	int ret = 0;
-	static char *kwlist[] = {"name", "mode", "buffering", 0};
-	char *name = NULL;
-	char *mode = "r";
-	int bufsize = -1;
-	int wideargument = 0;
-
-	assert(PyFile_Check(self));
-	if (foself->f_fp != NULL) {
-		/* Have to close the existing file first. */
-		PyObject *closeresult = file_close(foself);
-		if (closeresult == NULL)
-			return -1;
-		Py_DECREF(closeresult);
-	}
-
-#ifdef Py_WIN_WIDE_FILENAMES
-	if (GetVersion() < 0x80000000) {    /* On NT, so wide API available */
-		PyObject *po;
-		if (PyArg_ParseTupleAndKeywords(args, kwds, "U|si:file",
-						kwlist, &po, &mode, &bufsize)) {
-			wideargument = 1;
-			if (fill_file_fields(foself, NULL, po, mode,
-					     fclose) == NULL)
-				goto Error;
-		} else {
-			/* Drop the argument parsing error as narrow
-			   strings are also valid. */
-			PyErr_Clear();
-		}
-	}
-#endif
-
-	if (!wideargument) {
-                PyObject *o_name;
-
-		if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:file", kwlist,
-						 Py_FileSystemDefaultEncoding,
-						 &name,
-						 &mode, &bufsize))
-			return -1;
-
-                /* We parse again to get the name as a PyObject */
-                if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|si:file", 
-                                                 kwlist, &o_name, &mode, 
-                                                 &bufsize))
-                        goto Error;
-
-		if (fill_file_fields(foself, NULL, o_name, mode,
-				     fclose) == NULL)
-			goto Error;
-	}
-	if (open_the_file(foself, name, mode) == NULL)
-		goto Error;
-	foself->f_setbuf = NULL;
-	PyFile_SetBufSize(self, bufsize);
-	goto Done;
-
-Error:
-	ret = -1;
-	/* fall through */
-Done:
-	PyMem_Free(name); /* free the encoded string */
-	return ret;
-}
-
-PyDoc_VAR(file_doc) =
-PyDoc_STR(
-"file(name[, mode[, buffering]]) -> file object\n"
-"\n"
-"Open a file.  The mode can be 'r', 'w' or 'a' for reading (default),\n"
-"writing or appending.  The file will be created if it doesn't exist\n"
-"when opened for writing or appending; it will be truncated when\n"
-"opened for writing.  Add a 'b' to the mode for binary files.\n"
-"Add a '+' to the mode to allow simultaneous reading and writing.\n"
-"If the buffering argument is given, 0 means unbuffered, 1 means line\n"
-"buffered, and larger numbers specify the buffer size.\n"
-)
-PyDoc_STR(
-"Add a 'U' to mode to open the file for input with universal newline\n"
-"support.  Any line ending in the input file will be seen as a '\\n'\n"
-"in Python.  Also, a file so opened gains the attribute 'newlines';\n"
-"the value for this attribute is one of None (no newline read yet),\n"
-"'\\r', '\\n', '\\r\\n' or a tuple containing all the newline types seen.\n"
-"\n"
-"'U' cannot be combined with 'w' or '+' mode.\n"
-);
-
-PyTypeObject PyFile_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
-	"file",
-	sizeof(PyFileObject),
-	0,
-	(destructor)file_dealloc,		/* tp_dealloc */
-	0,					/* tp_print */
-	0,			 		/* tp_getattr */
-	0,			 		/* tp_setattr */
-	0,					/* tp_compare */
-	(reprfunc)file_repr, 			/* tp_repr */
-	0,					/* tp_as_number */
-	0,					/* tp_as_sequence */
-	0,					/* tp_as_mapping */
-	0,					/* tp_hash */
-	0,					/* tp_call */
-	0,					/* tp_str */
-	PyObject_GenericGetAttr,		/* tp_getattro */
-	0,					/* tp_setattro */
-	0,					/* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	file_doc,				/* tp_doc */
-	0,					/* tp_traverse */
-	0,					/* tp_clear */
-	0,					/* tp_richcompare */
-	offsetof(PyFileObject, weakreflist),	/* tp_weaklistoffset */
-	(getiterfunc)file_self,			/* tp_iter */
-	(iternextfunc)file_iternext,		/* tp_iternext */
-	file_methods,				/* tp_methods */
-	file_memberlist,			/* tp_members */
-	file_getsetlist,			/* tp_getset */
-	0,					/* tp_base */
-	0,					/* tp_dict */
-	0,					/* tp_descr_get */
-	0,					/* tp_descr_set */
-	0,					/* tp_dictoffset */
-	file_init,				/* tp_init */
-	PyType_GenericAlloc,			/* tp_alloc */
-	file_new,				/* tp_new */
-	PyObject_Del,                           /* tp_free */
-};
-
 /* Interfaces to write objects/strings to file-like objects */
 
 int
@@ -2112,28 +138,6 @@ PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
 		PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
 		return -1;
 	}
-	else if (PyFile_Check(f)) {
-		FILE *fp = PyFile_AsFile(f);
-		PyObject *enc = ((PyFileObject*)f)->f_encoding;
-		int result;
-		if (fp == NULL) {
-			err_closed();
-			return -1;
-		}
-                if ((flags & Py_PRINT_RAW) &&
-		    PyUnicode_Check(v) && enc != Py_None) {
-			char *cenc = PyString_AS_STRING(enc);
-			value = PyUnicode_AsEncodedString(v, cenc, "strict");
-			if (value == NULL)
-				return -1;
-		} else {
-			value = v;
-			Py_INCREF(value);
-		}
-		result = PyObject_Print(value, fp, flags);
-		Py_DECREF(value);
-		return result;
-	}
 	writer = PyObject_GetAttrString(f, "write");
 	if (writer == NULL)
 		return -1;
@@ -2176,15 +180,6 @@ PyFile_WriteString(const char *s, PyObject *f)
 					"null file for PyFile_WriteString");
 		return -1;
 	}
-	else if (PyFile_Check(f)) {
-		FILE *fp = PyFile_AsFile(f);
-		if (fp == NULL) {
-			err_closed();
-			return -1;
-		}
-		fputs(s, fp);
-		return 0;
-	}
 	else if (!PyErr_Occurred()) {
 		PyObject *v = PyString_FromString(s);
 		int err;
@@ -2205,7 +200,8 @@ PyFile_WriteString(const char *s, PyObject *f)
    -1 is returned on failure.
 */
 
-int PyObject_AsFileDescriptor(PyObject *o)
+int
+PyObject_AsFileDescriptor(PyObject *o)
 {
 	int fd;
 	PyObject *meth;
@@ -2255,10 +251,6 @@ int PyObject_AsFileDescriptor(PyObject *o)
 	return fd;
 }
 
-/* From here on we need access to the real fgets and fread */
-#undef fgets
-#undef fread
-
 /*
 ** Py_UniversalNewlineFgets is an fgets variation that understands
 ** all of \r, \n and \r\n conventions.
@@ -2280,18 +272,10 @@ Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
 	int c;
 	int newlinetypes = 0;
 	int skipnextlf = 0;
-	int univ_newline = 1;
 
 	if (fobj) {
-		if (!PyFile_Check(fobj)) {
-			errno = ENXIO;	/* What can you do... */
-			return NULL;
-		}
-		univ_newline = ((PyFileObject *)fobj)->f_univ_newline;
-		if ( !univ_newline )
-			return fgets(buf, n, stream);
-		newlinetypes = ((PyFileObject *)fobj)->f_newlinetypes;
-		skipnextlf = ((PyFileObject *)fobj)->f_skipnextlf;
+		errno = ENXIO;	/* What can you do... */
+		return NULL;
 	}
 	FLOCKFILE(stream);
 	c = 'x'; /* Shut up gcc warning */
@@ -2331,10 +315,7 @@ Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
 		newlinetypes |= NEWLINE_CR;
 	FUNLOCKFILE(stream);
 	*p = '\0';
-	if (fobj) {
-		((PyFileObject *)fobj)->f_newlinetypes = newlinetypes;
-		((PyFileObject *)fobj)->f_skipnextlf = skipnextlf;
-	} else if ( skipnextlf ) {
+	if ( skipnextlf ) {
 		/* If we have no file object we cannot save the
 		** skipnextlf flag. We have to readahead, which
 		** will cause a pause if we're reading from an
@@ -2351,88 +332,6 @@ Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
 	return buf;
 }
 
-/*
-** Py_UniversalNewlineFread is an fread variation that understands
-** all of \r, \n and \r\n conventions.
-** The stream should be opened in binary mode.
-** fobj must be a PyFileObject. In this case there
-** is no readahead but in stead a flag is used to skip a following
-** \n on the next read. Also, if the file is open in binary mode
-** the whole conversion is skipped. Finally, the routine keeps track of
-** the different types of newlines seen.
-*/
-size_t
-Py_UniversalNewlineFread(char *buf, size_t n,
-			 FILE *stream, PyObject *fobj)
-{
-	char *dst = buf;
-	PyFileObject *f = (PyFileObject *)fobj;
-	int newlinetypes, skipnextlf;
-
-	assert(buf != NULL);
-	assert(stream != NULL);
-
-	if (!fobj || !PyFile_Check(fobj)) {
-		errno = ENXIO;	/* What can you do... */
-		return 0;
-	}
-	if (!f->f_univ_newline)
-		return fread(buf, 1, n, stream);
-	newlinetypes = f->f_newlinetypes;
-	skipnextlf = f->f_skipnextlf;
-	/* Invariant:  n is the number of bytes remaining to be filled
-	 * in the buffer.
-	 */
-	while (n) {
-		size_t nread;
-		int shortread;
-		char *src = dst;
-
-		nread = fread(dst, 1, n, stream);
-		assert(nread <= n);
-		if (nread == 0)
-			break;
-
-		n -= nread; /* assuming 1 byte out for each in; will adjust */
-		shortread = n != 0;	/* true iff EOF or error */
-		while (nread--) {
-			char c = *src++;
-			if (c == '\r') {
-				/* Save as LF and set flag to skip next LF. */
-				*dst++ = '\n';
-				skipnextlf = 1;
-			}
-			else if (skipnextlf && c == '\n') {
-				/* Skip LF, and remember we saw CR LF. */
-				skipnextlf = 0;
-				newlinetypes |= NEWLINE_CRLF;
-				++n;
-			}
-			else {
-				/* Normal char to be stored in buffer.  Also
-				 * update the newlinetypes flag if either this
-				 * is an LF or the previous char was a CR.
-				 */
-				if (c == '\n')
-					newlinetypes |= NEWLINE_LF;
-				else if (skipnextlf)
-					newlinetypes |= NEWLINE_CR;
-				*dst++ = c;
-				skipnextlf = 0;
-			}
-		}
-		if (shortread) {
-			/* If this is EOF, update type flags. */
-			if (skipnextlf && feof(stream))
-				newlinetypes |= NEWLINE_CR;
-			break;
-		}
-	}
-	f->f_newlinetypes = newlinetypes;
-	f->f_skipnextlf = skipnextlf;
-	return dst - buf;
-}
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Parser/tokenizer.c b/Parser/tokenizer.c
index e7dada6..27f665a 100644
--- a/Parser/tokenizer.c
+++ b/Parser/tokenizer.c
@@ -669,66 +669,6 @@ PyTokenizer_Free(struct tok_state *tok)
 	PyMem_FREE(tok);
 }
 
-#if !defined(PGEN)
-static int
-tok_stdin_decode(struct tok_state *tok, char **inp)
-{
-	PyObject *enc, *sysstdin, *decoded, *utf8;
-	const char *encoding;
-	char *converted;
-
-	if (PySys_GetFile((char *)"stdin", NULL) != stdin)
-		return 0;
-	sysstdin = PySys_GetObject("stdin");
-	if (sysstdin == NULL || !PyFile_Check(sysstdin))
-		return 0;
-
-	enc = ((PyFileObject *)sysstdin)->f_encoding;
-	if (enc == NULL || !PyString_Check(enc))
-		return 0;
-	Py_INCREF(enc);
-
-	encoding = PyString_AsString(enc);
-	decoded = PyUnicode_Decode(*inp, strlen(*inp), encoding, NULL);
-	if (decoded == NULL)
-		goto error_clear;
-
-	utf8 = PyUnicode_AsEncodedString(decoded, "utf-8", NULL);
-	Py_DECREF(decoded);
-	if (utf8 == NULL)
-		goto error_clear;
-
-	assert(PyBytes_Check(utf8));
-	converted = new_string(PyBytes_AS_STRING(utf8),
-			       PyBytes_GET_SIZE(utf8));
-	Py_DECREF(utf8);
-	if (converted == NULL)
-		goto error_nomem;
-
-	PyMem_FREE(*inp);
-	*inp = converted;
-	if (tok->encoding != NULL)
-		PyMem_FREE(tok->encoding);
-	tok->encoding = new_string(encoding, strlen(encoding));
-	if (tok->encoding == NULL)
-		goto error_nomem;
-
-	Py_DECREF(enc);
-	return 0;
-
-error_nomem:
-	Py_DECREF(enc);
-	tok->done = E_NOMEM;
-	return -1;
-
-error_clear:
-	/* Fallback to iso-8859-1: for backward compatibility */
-	Py_DECREF(enc);
-	PyErr_Clear();
-	return 0;
-}
-#endif
-
 /* Get next char, updating state; error code goes into tok->done */
 
 static int
@@ -768,10 +708,6 @@ tok_nextc(register struct tok_state *tok)
 				PyMem_FREE(newtok);
 				tok->done = E_EOF;
 			}
-#if !defined(PGEN)
-			else if (tok_stdin_decode(tok, &newtok) != 0)
-				PyMem_FREE(newtok);
-#endif
 			else if (tok->start != NULL) {
 				size_t start = tok->start - tok->buf;
 				size_t oldlen = tok->cur - tok->buf;
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index d4c8a74..3b43ff9 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -659,8 +659,7 @@ builtin_exec(PyObject *self, PyObject *args)
 		locals = globals;
 	if (!PyString_Check(prog) &&
 	    !PyUnicode_Check(prog) &&
-	    !PyCode_Check(prog) &&
-	    !PyFile_Check(prog)) {
+	    !PyCode_Check(prog)) {
 		PyErr_Format(PyExc_TypeError,
 			"exec() arg 1 must be a string, file, or code "
 			"object, not %.100s", prog->ob_type->tp_name);
@@ -692,18 +691,6 @@ builtin_exec(PyObject *self, PyObject *args)
 		}
 		v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
 	}
-	else if (PyFile_Check(prog)) {
-		FILE *fp = PyFile_AsFile(prog);
-		char *name = PyString_AsString(PyFile_Name(prog));
-		PyCompilerFlags cf;
-		cf.cf_flags = 0;
-		if (PyEval_MergeCompilerFlags(&cf))
-			v = PyRun_FileFlags(fp, name, Py_file_input, globals,
-					    locals, &cf);
-		else
-			v = PyRun_File(fp, name, Py_file_input, globals,
-				       locals);
-	}
 	else {
 		char *str = source_as_string(prog);
 		PyCompilerFlags cf;
diff --git a/Python/import.c b/Python/import.c
index 4786f1b..5680abc 100644
--- a/Python/import.c
+++ b/Python/import.c
@@ -2764,19 +2764,21 @@ static FILE *
 get_file(char *pathname, PyObject *fob, char *mode)
 {
 	FILE *fp;
+	if (mode[0] == 'U')
+		mode = "r" PY_STDIOTEXTMODE;
 	if (fob == NULL) {
-		if (mode[0] == 'U')
-			mode = "r" PY_STDIOTEXTMODE;
 		fp = fopen(pathname, mode);
-		if (fp == NULL)
-			PyErr_SetFromErrno(PyExc_IOError);
 	}
 	else {
-		fp = PyFile_AsFile(fob);
-		if (fp == NULL)
-			PyErr_SetString(PyExc_ValueError,
-					"bad/closed file object");
+		int fd = PyObject_AsFileDescriptor(fob);
+		if (fd == -1)
+			return NULL;
+		/* XXX This will leak a FILE struct. Fix this!!!!
+		   (But it doesn't leak a file descrioptor!) */
+		fp = fdopen(fd, mode);
 	}
+	if (fp == NULL)
+		PyErr_SetFromErrno(PyExc_IOError);
 	return fp;
 }
 
@@ -2788,8 +2790,8 @@ imp_load_compiled(PyObject *self, PyObject *args)
 	PyObject *fob = NULL;
 	PyObject *m;
 	FILE *fp;
-	if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
-			      &PyFile_Type, &fob))
+	if (!PyArg_ParseTuple(args, "ss|O:load_compiled",
+			      &name, &pathname, &fob))
 		return NULL;
 	fp = get_file(pathname, fob, "rb");
 	if (fp == NULL)
@@ -2810,8 +2812,8 @@ imp_load_dynamic(PyObject *self, PyObject *args)
 	PyObject *fob = NULL;
 	PyObject *m;
 	FILE *fp = NULL;
-	if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
-			      &PyFile_Type, &fob))
+	if (!PyArg_ParseTuple(args, "ss|O:load_dynamic",
+			      &name, &pathname, &fob))
 		return NULL;
 	if (fob) {
 		fp = get_file(pathname, fob, "r");
@@ -2832,8 +2834,8 @@ imp_load_source(PyObject *self, PyObject *args)
 	PyObject *fob = NULL;
 	PyObject *m;
 	FILE *fp;
-	if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
-			      &PyFile_Type, &fob))
+	if (!PyArg_ParseTuple(args, "ss|O:load_source",
+			      &name, &pathname, &fob))
 		return NULL;
 	fp = get_file(pathname, fob, "r");
 	if (fp == NULL)
@@ -2873,12 +2875,7 @@ imp_load_module(PyObject *self, PyObject *args)
 	if (fob == Py_None)
 		fp = NULL;
 	else {
-		if (!PyFile_Check(fob)) {
-			PyErr_SetString(PyExc_ValueError,
-				"load_module arg#2 should be a file or None");
-			return NULL;
-		}
-		fp = get_file(pathname, fob, mode);
+		fp = get_file(NULL, fob, mode);
 		if (fp == NULL)
 			return NULL;
 	}
diff --git a/Python/marshal.c b/Python/marshal.c
index 262c185..85926ed 100644
--- a/Python/marshal.c
+++ b/Python/marshal.c
@@ -1138,81 +1138,52 @@ PyMarshal_WriteObjectToString(PyObject *x, int version)
 static PyObject *
 marshal_dump(PyObject *self, PyObject *args)
 {
-	WFILE wf;
+	/* XXX Quick hack -- need to do this differently */
 	PyObject *x;
 	PyObject *f;
 	int version = Py_MARSHAL_VERSION;
+	PyObject *s;
+	PyObject *res;
 	if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
 		return NULL;
-	if (!PyFile_Check(f)) {
-		/* XXX Quick hack -- need to do this differently */
-		PyObject *s = PyMarshal_WriteObjectToString(x, version);
-		PyObject *res = NULL;
-		if (s != NULL) {
-			res = PyObject_CallMethod(f, "write", "O", s);
-			Py_DECREF(s);
-		}
-		return res;
-	}
-	wf.fp = PyFile_AsFile(f);
-	wf.str = NULL;
-	wf.ptr = wf.end = NULL;
-	wf.error = 0;
-	wf.depth = 0;
-	wf.strings = (version > 0) ? PyDict_New() : 0;
-	wf.version = version;
-	w_object(x, &wf);
-	Py_XDECREF(wf.strings);
-	if (wf.error) {
-		PyErr_SetString(PyExc_ValueError,
-				(wf.error==1)?"unmarshallable object"
-				:"object too deeply nested to marshal");
+	s = PyMarshal_WriteObjectToString(x, version);
+	if (s == NULL)
 		return NULL;
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+	res = PyObject_CallMethod(f, "write", "O", s);
+	Py_DECREF(s);
+	return res;
 }
 
 static PyObject *
 marshal_load(PyObject *self, PyObject *f)
 {
+	/* XXX Quick hack -- need to do this differently */
+	PyObject *data, *result;
 	RFILE rf;
-	PyObject *result;
-	if (!PyFile_Check(f)) {
-		/* XXX Quick hack -- need to do this differently */
-		PyObject *data, *result;
-		RFILE rf;
-		data = PyObject_CallMethod(f, "read", "");
-		if (data == NULL)
-			return NULL;
-		rf.fp = NULL;
-		if (PyString_Check(data)) {
-			rf.ptr = PyString_AS_STRING(data);
-			rf.end = rf.ptr + PyString_GET_SIZE(data);
-		}
-		else if (PyBytes_Check(data)) {
-			rf.ptr = PyBytes_AS_STRING(data);
-			rf.end = rf.ptr + PyBytes_GET_SIZE(data);
-		}
-		else {
-			PyErr_Format(PyExc_TypeError,
-				     "f.read() returned neither string "
-				     "nor bytes but %.100s",
-				     data->ob_type->tp_name);
-			Py_DECREF(data);
-			return NULL;
-		}
-		rf.strings = PyList_New(0);
-		result = read_object(&rf);
-		Py_DECREF(rf.strings);
+	data = PyObject_CallMethod(f, "read", "");
+	if (data == NULL)
+		return NULL;
+	rf.fp = NULL;
+	if (PyString_Check(data)) {
+		rf.ptr = PyString_AS_STRING(data);
+		rf.end = rf.ptr + PyString_GET_SIZE(data);
+	}
+	else if (PyBytes_Check(data)) {
+		rf.ptr = PyBytes_AS_STRING(data);
+		rf.end = rf.ptr + PyBytes_GET_SIZE(data);
+	}
+	else {
+		PyErr_Format(PyExc_TypeError,
+			     "f.read() returned neither string "
+			     "nor bytes but %.100s",
+			     data->ob_type->tp_name);
 		Py_DECREF(data);
-		return result;
+		return NULL;
 	}
-	rf.fp = PyFile_AsFile(f);
 	rf.strings = PyList_New(0);
-	rf.depth = 0;
 	result = read_object(&rf);
 	Py_DECREF(rf.strings);
+	Py_DECREF(data);
 	return result;
 }
 
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
index 5daf7dd..db21daf 100644
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -155,7 +155,6 @@ Py_InitializeEx(int install_sigs)
 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
 	char *codeset;
 	char *saved_locale;
-	PyObject *sys_stream, *sys_isatty;
 #endif
 	extern void _Py_ReadyTypes(void);
 
@@ -273,39 +272,6 @@ Py_InitializeEx(int install_sigs)
 	free(saved_locale);
 
 	if (codeset) {
-		sys_stream = PySys_GetObject("stdin");
-		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-		if (!sys_isatty)
-			PyErr_Clear();
-		if(sys_isatty && PyObject_IsTrue(sys_isatty) &&
-		   PyFile_Check(sys_stream)) {
-			if (!PyFile_SetEncoding(sys_stream, codeset))
-				Py_FatalError("Cannot set codeset of stdin");
-		}
-		Py_XDECREF(sys_isatty);
-
-		sys_stream = PySys_GetObject("stdout");
-		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-		if (!sys_isatty)
-			PyErr_Clear();
-		if(sys_isatty && PyObject_IsTrue(sys_isatty) &&
-		   PyFile_Check(sys_stream)) {
-			if (!PyFile_SetEncoding(sys_stream, codeset))
-				Py_FatalError("Cannot set codeset of stdout");
-		}
-		Py_XDECREF(sys_isatty);
-
-		sys_stream = PySys_GetObject("stderr");
-		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-		if (!sys_isatty)
-			PyErr_Clear();
-		if(sys_isatty && PyObject_IsTrue(sys_isatty) &&
-		   PyFile_Check(sys_stream)) {
-			if (!PyFile_SetEncoding(sys_stream, codeset))
-				Py_FatalError("Cannot set codeset of stderr");
-		}
-		Py_XDECREF(sys_isatty);
-
 		if (!Py_FileSystemDefaultEncoding)
 			Py_FileSystemDefaultEncoding = codeset;
 		else
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 1b7674b..71a455a 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -55,18 +55,6 @@ PySys_GetObject(char *name)
 	return PyDict_GetItemString(sd, name);
 }
 
-FILE *
-PySys_GetFile(char *name, FILE *def)
-{
-	FILE *fp = NULL;
-	PyObject *v = PySys_GetObject(name);
-	if (v != NULL && PyFile_Check(v))
-		fp = PyFile_AsFile(v);
-	if (fp == NULL)
-		fp = def;
-	return fp;
-}
-
 int
 PySys_SetObject(char *name, PyObject *v)
 {
@@ -1353,25 +1341,21 @@ mywrite(char *name, FILE *fp, const char *format, va_list va)
 {
 	PyObject *file;
 	PyObject *error_type, *error_value, *error_traceback;
+	char buffer[1001];
+	int written;
 
 	PyErr_Fetch(&error_type, &error_value, &error_traceback);
 	file = PySys_GetObject(name);
-	if (file == NULL || PyFile_AsFile(file) == fp)
-		vfprintf(fp, format, va);
-	else {
-		char buffer[1001];
-		const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
-						   format, va);
-		if (PyFile_WriteString(buffer, file) != 0) {
+	written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va);
+	if (PyFile_WriteString(buffer, file) != 0) {
+		PyErr_Clear();
+		fputs(buffer, fp);
+	}
+	if (written < 0 || (size_t)written >= sizeof(buffer)) {
+		const char *truncated = "... truncated";
+		if (PyFile_WriteString(truncated, file) != 0) {
 			PyErr_Clear();
-			fputs(buffer, fp);
-		}
-		if (written < 0 || (size_t)written >= sizeof(buffer)) {
-			const char *truncated = "... truncated";
-			if (PyFile_WriteString(truncated, file) != 0) {
-				PyErr_Clear();
-				fputs(truncated, fp);
-			}
+			fputs(truncated, fp);
 		}
 	}
 	PyErr_Restore(error_type, error_value, error_traceback);
diff --git a/runtests.sh b/runtests.sh
index 7372d8e..ddc00b0 100755
--- a/runtests.sh
+++ b/runtests.sh
@@ -24,8 +24,8 @@ mkdir -p OUT
 >BAD
 >SKIPPED
 
-# The -uall flag (edit this file to change).
-UALL="-uall"
+# The -u flag (edit this file to change).
+UFLAG="-unetwork"
 
 # Compute the list of tests to run.
 case $# in
@@ -41,7 +41,7 @@ esac
 for T in $TESTS
 do
     echo -n $T
-    if $PYTHON Lib/test/regrtest.py $UALL $T >OUT/$T.out 2>&1
+    if $PYTHON Lib/test/regrtest.py $UFLAG $T >OUT/$T.out 2>&1
     then
 	if grep -q "1 test skipped:" OUT/$T.out
 	then
@@ -55,6 +55,6 @@ do
 	echo " BAD"
         echo $T >>BAD
 	echo "---------- Re-running test in verbose mode ----------" >>OUT/$T
-	$PYTHON Lib/test/regrtest.py -v $UALL $T >>OUT/$T.out 2>&1
+	$PYTHON Lib/test/regrtest.py -v $UFLAG $T >>OUT/$T.out 2>&1
     fi
 done