Check in Daniel Stutzbach's _fileio.c and test_fileio.py

(see SF#1671314) with small tweaks.
The io module now uses this instead of its own implementation
of the FileIO class, if it can import _fileio.

5 files changed, 1002 insertions, 1 deletions

diff --git a/Lib/io.py b/Lib/io.py
index db0ba7e..4c1912e 100644
--- a/Lib/io.py
+++ b/Lib/io.py
@@ -177,7 +177,7 @@ class RawIOBase:
         raise IOError(".fileno() not supported")
 
 
-class FileIO(RawIOBase):
+class _PyFileIO(RawIOBase):
 
     """Raw I/O implementation for OS files."""
 
@@ -243,6 +243,18 @@ class FileIO(RawIOBase):
         return self._fd
 
 
+try:
+    import _fileio
+except ImportError:
+    # Let's use the Python version
+    FileIO = _PyFileIO
+else:
+    # Create a trivial subclass with the proper inheritance structure
+    class FileIO(_fileio._FileIO, RawIOBase):
+        """Raw I/O implementation for OS files."""
+        # XXX More docs
+
+
 class SocketIO(RawIOBase):
 
     """Raw I/O implementation for stream sockets."""
diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py
new file mode 100644
index 0000000..8ebba2b
--- /dev/null
+++ b/Lib/test/test_fileio.py
@@ -0,0 +1,227 @@
+/* Adapted from test_file.py by Daniel Stutzbach */
+
+import sys
+import os
+import unittest
+from array import array
+from weakref import proxy
+
+from test.test_support import TESTFN, findfile, run_unittest
+from UserList import UserList
+
+import _fileio
+
+class AutoFileTests(unittest.TestCase):
+    # file tests for which a test file is automatically set up
+
+    def setUp(self):
+        self.f = _fileio._FileIO(TESTFN, 'w')
+
+    def tearDown(self):
+        if self.f:
+            self.f.close()
+        os.remove(TESTFN)
+
+    def testWeakRefs(self):
+        # verify weak references
+        p = proxy(self.f)
+        p.write(bytes(range(10)))
+        self.assertEquals(self.f.tell(), p.tell())
+        self.f.close()
+        self.f = None
+        self.assertRaises(ReferenceError, getattr, p, 'tell')
+
+    def testSeekTell(self):
+        self.f.write(bytes(range(20)))
+        self.assertEquals(self.f.tell(), 20)
+        self.f.seek(0)
+        self.assertEquals(self.f.tell(), 0)
+        self.f.seek(10)
+        self.assertEquals(self.f.tell(), 10)
+        self.f.seek(5, 1)
+        self.assertEquals(self.f.tell(), 15)
+        self.f.seek(-5, 1)
+        self.assertEquals(self.f.tell(), 10)
+        self.f.seek(-5, 2)
+        self.assertEquals(self.f.tell(), 15)
+
+    def testAttributes(self):
+        # verify expected attributes exist
+        f = self.f
+        # XXX do we want these?
+        #f.name     # merely shouldn't blow up
+        #f.mode     # ditto
+        #f.closed   # ditto
+
+        # verify the others aren't
+        for attr in 'name', 'mode', 'closed':
+            self.assertRaises((AttributeError, TypeError), setattr, f, attr, 'oops')
+
+    def testReadinto(self):
+        # verify readinto
+        self.f.write(bytes([1, 2]))
+        self.f.close()
+        a = array('b', 'x'*10)
+        self.f = _fileio._FileIO(TESTFN, 'r')
+        n = self.f.readinto(a)
+        self.assertEquals(array('b', [1, 2]), a[:n])
+
+    def testRepr(self):
+        # verify repr works
+        return # XXX doesn't work yet
+        self.assert_(repr(self.f).startswith("<open file '" + TESTFN))
+
+    def testErrors(self):
+        f = self.f
+        self.assert_(not f.isatty())
+        #self.assert_(not f.closed) # XXX Do we want to support these?
+        #self.assertEquals(f.name, TESTFN)
+
+        self.assertRaises(TypeError, f.readinto, "")
+        f.close()
+        #self.assert_(f.closed) # XXX
+
+    def testMethods(self):
+        methods = ['fileno', 'isatty', 'read', 'readinto',
+                   'seek', 'tell', 'truncate', 'write', 'seekable',
+                   'readable', 'writable']
+        if sys.platform.startswith('atheos'):
+            methods.remove('truncate')
+
+        # __exit__ should close the file
+        self.f.__exit__(None, None, None)
+        #self.assert_(self.f.closed) # XXX
+
+        for methodname in methods:
+            method = getattr(self.f, methodname)
+            # should raise on closed file
+            self.assertRaises(ValueError, method)
+
+        # file is closed, __exit__ shouldn't do anything
+        self.assertEquals(self.f.__exit__(None, None, None), None)
+        # it must also return None if an exception was given
+        try:
+            1/0
+        except:
+            self.assertEquals(self.f.__exit__(*sys.exc_info()), None)
+
+
+class OtherFileTests(unittest.TestCase):
+
+    def testAbles(self):
+        try:
+            f = _fileio._FileIO(TESTFN, "w")
+            self.assertEquals(f.readable(), False)
+            self.assertEquals(f.writable(), True)
+            self.assertEquals(f.seekable(), True)
+            f.close()
+            
+            f = _fileio._FileIO(TESTFN, "r")
+            self.assertEquals(f.readable(), True)
+            self.assertEquals(f.writable(), False)
+            self.assertEquals(f.seekable(), True)
+            f.close()
+            
+            f = _fileio._FileIO(TESTFN, "a+")
+            self.assertEquals(f.readable(), True)
+            self.assertEquals(f.writable(), True)
+            self.assertEquals(f.seekable(), True)
+            self.assertEquals(f.isatty(), False)
+            f.close()
+            
+            f = _fileio._FileIO("/dev/tty", "a") # XXX, won't work on e.g., Windows
+            self.assertEquals(f.readable(), False)
+            self.assertEquals(f.writable(), True)
+            ##self.assertEquals(f.seekable(), False) # XXX True on OSX!?
+            self.assertEquals(f.isatty(), True)
+            f.close()
+        finally:
+            os.unlink(TESTFN)
+
+    def testModeStrings(self):
+        # check invalid mode strings
+        for mode in ("", "aU", "wU+", "rb", "rt"):
+            try:
+                f = _fileio._FileIO(TESTFN, mode)
+            except ValueError:
+                pass
+            else:
+                f.close()
+                self.fail('%r is an invalid file mode' % mode)
+
+    def testStdin(self):
+        ## This causes the interpreter to exit on OSF1 v5.1.
+        #if sys.platform != 'osf1V5':
+        #    self.assertRaises(IOError, sys.stdin.seek, -1)
+        #else:
+        #    print((
+        #        '  Skipping sys.stdin.seek(-1), it may crash the interpreter.'
+        #        ' Test manually.'), file=sys.__stdout__)
+        #self.assertRaises(IOError, sys.stdin.truncate)
+        # XXX Comment this out since sys.stdin is currently an old style file 
+        pass
+
+    def testUnicodeOpen(self):
+        # verify repr works for unicode too
+        f = _fileio._FileIO(unicode(TESTFN), "w")
+        # XXX doesn't work yet:
+        ##self.assert_(repr(f).startswith("<open file u'" + TESTFN))
+        f.close()
+        os.unlink(TESTFN)
+
+    def testBadModeArgument(self):
+        # verify that we get a sensible error message for bad mode argument
+        bad_mode = "qwerty"
+        try:
+            f = _fileio._FileIO(TESTFN, bad_mode)
+        except ValueError as msg:
+            if msg.message != 0:
+                s = str(msg)
+                if s.find(TESTFN) != -1 or s.find(bad_mode) == -1:
+                    self.fail("bad error message for invalid mode: %s" % s)
+            # if msg[0] == 0, we're probably on Windows where there may be
+            # no obvious way to discover why open() failed.
+        else:
+            f.close()
+            self.fail("no error for invalid mode: %s" % bad_mode)
+
+    def testTruncateOnWindows(self):
+        def bug801631():
+            # SF bug <http://www.python.org/sf/801631>
+            # "file.truncate fault on windows"
+            f = _fileio._FileIO(TESTFN, 'w')
+            f.write(bytes(range(11)))
+            f.close()
+
+            f = _fileio._FileIO(TESTFN,'r+')
+            data = f.read(5)
+            if data != bytes(range(5)):
+                self.fail("Read on file opened for update failed %r" % data)
+            if f.tell() != 5:
+                self.fail("File pos after read wrong %d" % f.tell())
+
+            f.truncate()
+            if f.tell() != 5:
+                self.fail("File pos after ftruncate wrong %d" % f.tell())
+
+            f.close()
+            size = os.path.getsize(TESTFN)
+            if size != 5:
+                self.fail("File size after ftruncate wrong %d" % size)
+
+        try:
+            bug801631()
+        finally:
+            os.unlink(TESTFN)
+
+def test_main():
+    # Historically, these tests have been sloppy about removing TESTFN.
+    # So get rid of it no matter what.
+    try:
+        run_unittest(AutoFileTests, OtherFileTests)
+    finally:
+        if os.path.exists(TESTFN):
+            os.unlink(TESTFN)
+
+if __name__ == '__main__':
+    test_main()
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 193130e..956a502 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -5,7 +5,9 @@ from test import test_support
 
 import io
 
+
 class MockIO(io.RawIOBase):
+
     def __init__(self, readStack=()):
         self._readStack = list(readStack)
         self._writeStack = []
@@ -38,10 +40,13 @@ class MockIO(io.RawIOBase):
     def tell(self):
         return 42
 
+
 class MockNonBlockWriterIO(io.RawIOBase):
+
     def __init__(self, blockingScript):
         self.bs = list(blockingScript)
         self._write_stack = []
+
     def write(self, b):
         self._write_stack.append(b)
         n = self.bs.pop(0)
@@ -49,9 +54,11 @@ class MockNonBlockWriterIO(io.RawIOBase):
             raise io.BlockingIO(0, "test blocking", -n)
         else:
             return n
+
     def writable(self):
         return True
 
+
 class IOTest(unittest.TestCase):
 
     def tearDown(self):
@@ -110,7 +117,38 @@ class IOTest(unittest.TestCase):
         f = io.BytesIO(data)
         self.read_ops(f)
 
+    def test_fileio_FileIO(self):
+        import _fileio
+        f = _fileio._FileIO(test_support.TESTFN, "w")
+        self.assertEqual(f.readable(), False)
+        self.assertEqual(f.writable(), True)
+        self.assertEqual(f.seekable(), True)
+        self.write_ops(f)
+        f.close()
+        f = _fileio._FileIO(test_support.TESTFN, "r")
+        self.assertEqual(f.readable(), True)
+        self.assertEqual(f.writable(), False)
+        self.assertEqual(f.seekable(), True)
+        self.read_ops(f)
+        f.close()
+
+    def test_PyFileIO(self):
+        f = io._PyFileIO(test_support.TESTFN, "w")
+        self.assertEqual(f.readable(), False)
+        self.assertEqual(f.writable(), True)
+        self.assertEqual(f.seekable(), True)
+        self.write_ops(f)
+        f.close()
+        f = io._PyFileIO(test_support.TESTFN, "r")
+        self.assertEqual(f.readable(), True)
+        self.assertEqual(f.writable(), False)
+        self.assertEqual(f.seekable(), True)
+        self.read_ops(f)
+        f.close()
+
+
 class BytesIOTest(unittest.TestCase):
+
     def testInit(self):
         buf = b"1234567890"
         bytesIo = io.BytesIO(buf)
@@ -152,7 +190,9 @@ class BytesIOTest(unittest.TestCase):
         bytesIo.seek(10000)
         self.assertEquals(10000, bytesIo.tell())
 
+
 class BufferedReaderTest(unittest.TestCase):
+
     def testRead(self):
         rawIo = MockIO((b"abc", b"d", b"efg"))
         bufIo = io.BufferedReader(rawIo)
@@ -193,7 +233,9 @@ class BufferedReaderTest(unittest.TestCase):
         # this test. Else, write it.
         pass
 
+
 class BufferedWriterTest(unittest.TestCase):
+
     def testWrite(self):
         # Write to the buffered IO but don't overflow the buffer.
         writer = MockIO()
@@ -246,7 +288,9 @@ class BufferedWriterTest(unittest.TestCase):
 
         self.assertEquals(b"abc", writer._writeStack[0])
 
+
 class BufferedRWPairTest(unittest.TestCase):
+
     def testRWPair(self):
         r = MockIO(())
         w = MockIO()
@@ -254,7 +298,9 @@ class BufferedRWPairTest(unittest.TestCase):
 
         # XXX need implementation
 
+
 class BufferedRandom(unittest.TestCase):
+
     def testReadAndWrite(self):
         raw = MockIO((b"asdf", b"ghjk"))
         rw = io.BufferedRandom(raw, 8, 12)
diff --git a/Modules/_fileio.c b/Modules/_fileio.c
new file mode 100644
index 0000000..9ab27c1
--- /dev/null
+++ b/Modules/_fileio.c
@@ -0,0 +1,713 @@
+/* Author: Daniel Stutzbach */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stddef.h> /* For offsetof */
+
+/*
+ * Known likely problems:
+ *
+ * - Files larger then 2**32-1
+ * - Files with unicode filenames
+ * - Passing numbers greater than 2**32-1 when an integer is expected
+ * - Making it work on Windows and other oddball platforms
+ *
+ * To Do:
+ *
+ * - autoconfify header file inclusion
+ * - Make the ABC RawIO type and inherit from it.
+ *
+ * Unanswered questions:
+ *
+ * - Add mode, name, and closed properties a la Python 2 file objects?
+ * - Do we need a (*close)() in the struct like Python 2 file objects,
+ *   for not-quite-ordinary-file objects?
+ */
+
+#ifdef MS_WINDOWS
+/* can simulate truncate with Win32 API functions; see file_truncate */
+#define HAVE_FTRUNCATE
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+typedef struct {
+	PyObject_HEAD
+	int fd;
+	int own_fd; /* 1 means we should close fd */
+	int readable;
+	int writable;
+	int seekable; /* -1 means unknown */
+	PyObject *weakreflist;
+} PyFileIOObject;
+
+#define PyFileIO_Check(op) (PyObject_TypeCheck((op), &PyFileIO_Type))
+
+/* Note: if this function is changed so that it can return a true value,
+ * then we need a separate function for __exit__
+ */
+static PyObject *
+fileio_close(PyFileIOObject *self)
+{
+	if (self->fd >= 0) {
+		Py_BEGIN_ALLOW_THREADS
+		errno = 0;
+		close(self->fd);
+		Py_END_ALLOW_THREADS
+		if (errno < 0) {
+			PyErr_SetFromErrno(PyExc_IOError);
+			return NULL;
+		}
+		self->fd = -1;
+	}
+
+	Py_RETURN_NONE;
+}
+
+static PyObject *
+fileio_new(PyTypeObject *type, PyObject *args, PyObject *kews)
+{
+	PyFileIOObject *self;
+
+	assert(type != NULL && type->tp_alloc != NULL);
+
+	self = (PyFileIOObject *) type->tp_alloc(type, 0);
+	if (self != NULL) {
+		self->fd = -1;
+		self->weakreflist = NULL;
+		self->own_fd = 1;
+		self->seekable = -1;
+	}
+
+	return (PyObject *) self;
+}
+
+/* On Unix, open will succeed for directories.
+   In Python, there should be no file objects referring to
+   directories, so we need a check.  */
+
+static int
+dircheck(PyFileIOObject* self)
+{
+#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)
+	struct stat buf;
+	if (self->fd < 0)
+		return 0;
+	if (fstat(self->fd, &buf) == 0 && S_ISDIR(buf.st_mode)) {
+#ifdef HAVE_STRERROR
+		char *msg = strerror(EISDIR);
+#else
+		char *msg = "Is a directory";
+#endif
+		PyObject *exc;
+		PyObject *closeresult = fileio_close(self);
+		Py_DECREF(closeresult);
+		
+		exc = PyObject_CallFunction(PyExc_IOError, "(is)",
+					    EISDIR, msg);
+		PyErr_SetObject(PyExc_IOError, exc);
+		Py_XDECREF(exc);
+		return -1;
+	}
+#endif
+	return 0;
+}
+
+
+static int
+fileio_init(PyObject *oself, PyObject *args, PyObject *kwds)
+{
+	PyFileIOObject *self = (PyFileIOObject *) oself;
+	static char *kwlist[] = {"filename", "mode", NULL};
+	char *name = NULL;
+	char *mode = "r";
+        char *s;
+	int wideargument = 0;
+	int ret = 0;
+	int rwa = 0, plus = 0, append = 0;
+	int flags = 0;
+
+	assert(PyFileIO_Check(oself));
+	if (self->fd >= 0)
+	{
+		/* Have to close the existing file first. */
+		PyObject *closeresult = fileio_close(self);
+		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|s:fileio",
+						kwlist, &po, &mode)) {
+			wideargument = 1;
+		} else {
+			/* Drop the argument parsing error as narrow
+			   strings are also valid. */
+			PyErr_Clear();
+		}
+
+		PyErr_SetString(PyExc_NotImplementedError,
+				"Windows wide filenames are not yet supported");
+		goto error;
+	}
+#endif
+
+	if (!wideargument) {
+		if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|s:fileio",
+						 kwlist,
+						 Py_FileSystemDefaultEncoding,
+						 &name, &mode))
+			goto error;
+	}
+
+	self->readable = self->writable = 0;
+        s = mode;
+	while (*s) {
+		switch (*s++) {
+		case 'r':
+			if (rwa) {
+			bad_mode:
+				PyErr_SetString(PyExc_ValueError,
+						"Must have exactly one of read/write/append mode");
+				goto error;
+			}
+			rwa = 1;
+			self->readable = 1;
+			break;
+		case 'w':
+			if (rwa)
+				goto bad_mode;
+			rwa = 1;
+			self->writable = 1;
+			flags |= O_CREAT | O_TRUNC;
+			break;
+		case 'a':
+			if (rwa)
+				goto bad_mode;
+			rwa = 1;
+			self->writable = 1;
+			flags |= O_CREAT;
+			append = 1;
+			break;
+		case '+':
+			if (plus)
+				goto bad_mode;
+			self->readable = self->writable = 1;
+			plus = 1;
+			break;
+		default:
+			PyErr_Format(PyExc_ValueError,
+				     "invalid mode: %.200s", mode);
+			goto error;
+		}
+	}
+
+	if (!rwa)
+		goto bad_mode;
+
+	if (self->readable && self->writable)
+		flags |= O_RDWR;
+	else if (self->readable)
+		flags |= O_RDONLY;
+	else
+		flags |= O_WRONLY;
+
+#ifdef O_BINARY
+	flags |= O_BINARY;
+#endif
+
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	self->fd = open(name, flags, 0666);
+	Py_END_ALLOW_THREADS
+	if (self->fd < 0 || dircheck(self) < 0) {
+		PyErr_SetFromErrnoWithFilename(PyExc_IOError, name);
+		goto error;
+	}
+
+	goto done;
+
+ error:
+	ret = -1;
+	
+ done:
+	PyMem_Free(name);
+	return ret;
+}
+
+static void
+fileio_dealloc(PyFileIOObject *self)
+{
+	if (self->weakreflist != NULL)
+		PyObject_ClearWeakRefs((PyObject *) self);
+
+	if (self->fd >= 0 && self->own_fd) {
+		PyObject *closeresult = fileio_close(self);
+		if (closeresult == NULL) {
+#ifdef HAVE_STRERROR
+			PySys_WriteStderr("close failed: [Errno %d] %s\n", errno, strerror(errno));
+#else
+			PySys_WriteStderr("close failed: [Errno %d]\n", errno);
+#endif
+		} else 
+			Py_DECREF(closeresult);
+	}
+
+	self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *
+err_closed(void)
+{
+	PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");
+	return NULL;
+}
+
+static PyObject *
+fileio_fileno(PyFileIOObject *self)
+{
+	if (self->fd < 0)
+		return err_closed();
+	return PyInt_FromLong((long) self->fd);
+}
+
+static PyObject *
+fileio_readable(PyFileIOObject *self)
+{
+	if (self->fd < 0)
+		return err_closed();
+	return PyInt_FromLong((long) self->readable);
+}
+
+static PyObject *
+fileio_writable(PyFileIOObject *self)
+{
+	if (self->fd < 0)
+		return err_closed();
+	return PyInt_FromLong((long) self->writable);
+}
+
+static PyObject *
+fileio_seekable(PyFileIOObject *self)
+{
+	if (self->fd < 0)
+		return err_closed();
+	if (self->seekable < 0) {
+		int ret;
+		Py_BEGIN_ALLOW_THREADS
+		ret = lseek(self->fd, 0, SEEK_CUR);
+		Py_END_ALLOW_THREADS
+		if (ret < 0)
+			self->seekable = 0;
+		else
+			self->seekable = 1;
+	}
+	return PyInt_FromLong((long) self->seekable);
+}
+
+static PyObject *
+fileio_readinto(PyFileIOObject *self, PyObject *args)
+{
+	char *ptr;
+	Py_ssize_t n;
+	
+	if (self->fd < 0)
+		return err_closed();
+	if (!PyArg_ParseTuple(args, "w#", &ptr, &n))
+		return NULL;
+
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	n = read(self->fd, ptr, n);
+	Py_END_ALLOW_THREADS
+	if (n < 0) {
+		if (errno == EAGAIN)
+			Py_RETURN_NONE;
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+
+	return PyInt_FromLong(n);
+}
+
+static PyObject *
+fileio_read(PyFileIOObject *self, PyObject *args)
+{
+	char *ptr;
+	Py_ssize_t n, size;
+	PyObject *bytes;
+
+	if (self->fd < 0)
+		return err_closed();
+
+	if (!PyArg_ParseTuple(args, "i", &size))
+		return NULL;
+
+	bytes = PyBytes_FromStringAndSize(NULL, size);
+	if (bytes == NULL)
+		return NULL;
+	ptr = PyBytes_AsString(bytes);
+
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	n = read(self->fd, ptr, size);
+	Py_END_ALLOW_THREADS
+
+	if (n < 0) {
+		if (errno == EAGAIN)
+			Py_RETURN_NONE;
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+
+	if (n != size) {
+		if (PyBytes_Resize(bytes, n) < 0) {
+			Py_DECREF(bytes);
+                        return NULL;
+		}
+        }
+
+	return (PyObject *) bytes;
+}
+
+static PyObject *
+fileio_write(PyFileIOObject *self, PyObject *args)
+{
+	Py_ssize_t n;
+	char *ptr;
+
+	if (self->fd < 0)
+		return err_closed();
+	if (!PyArg_ParseTuple(args, "s#", &ptr, &n))
+		return NULL;
+
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	n = write(self->fd, ptr, n);
+	Py_END_ALLOW_THREADS
+
+	if (n < 0) {
+		if (errno == EAGAIN)
+			Py_RETURN_NONE;
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+
+	return PyInt_FromLong(n);
+}
+
+static PyObject *
+fileio_seek(PyFileIOObject *self, PyObject *args)
+{
+	Py_ssize_t offset;
+	Py_ssize_t whence = 0;
+
+	if (self->fd < 0)
+		return err_closed();
+
+	if (!PyArg_ParseTuple(args, "i|i", &offset, &whence))
+		return NULL;
+
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	offset = lseek(self->fd, offset, whence);
+	Py_END_ALLOW_THREADS
+
+	if (offset < 0) {
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+
+	Py_RETURN_NONE;
+}
+
+static PyObject *
+fileio_tell(PyFileIOObject *self, PyObject *args)
+{
+	Py_ssize_t offset;
+
+	if (self->fd < 0)
+		return err_closed();
+
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	offset = lseek(self->fd, 0, SEEK_CUR);
+	Py_END_ALLOW_THREADS
+	
+	if (offset < 0) {
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+
+	return PyInt_FromLong(offset);
+}
+
+#ifdef HAVE_FTRUNCATE
+static PyObject *
+fileio_truncate(PyFileIOObject *self, PyObject *args)
+{
+	Py_ssize_t length;
+	int ret;
+
+	if (self->fd < 0)
+		return err_closed();
+
+	/* Setup default value */
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	length = lseek(self->fd, 0, SEEK_CUR);
+	Py_END_ALLOW_THREADS
+
+	if (length < 0) {
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+	
+	if (!PyArg_ParseTuple(args, "|i", &length))
+		return NULL;
+
+#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;
+		Py_ssize_t initialpos;
+
+		/* 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(self->fd, length);
+	Py_END_ALLOW_THREADS
+#endif /* !MS_WINDOWS */
+
+	if (ret < 0) {
+		onioerror:
+		PyErr_SetFromErrno(PyExc_IOError);
+		return NULL;
+	}
+
+	/* Return to initial position */
+	Py_BEGIN_ALLOW_THREADS
+	errno = 0;
+	ret = lseek(self->fd, length, SEEK_SET);
+	Py_END_ALLOW_THREADS
+	if (ret < 0)
+		goto onioerror;
+		
+	Py_RETURN_NONE;
+}
+#endif
+
+static PyObject *
+fileio_repr(PyFileIOObject *self)
+{
+	PyObject *ret = NULL;
+
+	ret = PyString_FromFormat("<%s file at %p>",
+				  self->fd < 0 ? "closed" : "open",
+				  self);
+	return ret;
+}
+
+static PyObject *
+fileio_isatty(PyFileIOObject *self)
+{
+	long res;
+	
+	if (self->fd < 0)
+		return err_closed();
+	Py_BEGIN_ALLOW_THREADS
+	res = isatty(self->fd);
+	Py_END_ALLOW_THREADS
+	return PyBool_FromLong(res);
+}
+
+static PyObject *
+fileio_self(PyFileIOObject *self)
+{
+	if (self->fd < 0)
+		return err_closed();
+	Py_INCREF(self);
+	return (PyObject *)self;
+}
+
+PyDoc_STRVAR(fileio_doc,
+"file(name: str[, mode: str]) -> file IO 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 '+' to the mode to allow simultaneous\n"
+"reading and writing.");
+
+PyDoc_STRVAR(read_doc,
+"read(size: int) -> bytes.  read at most size bytes, returned as bytes.\n"
+"\n"
+"Only makes one system call, so less data may be returned than requested\n"
+"In non-blocking mode, returns None if no data is available.  On\n"
+"end-of-file, returns 0.");
+
+PyDoc_STRVAR(write_doc,
+"write(b: bytes) -> int.  Write bytes b to file, return number written.\n"
+"\n"
+"Only makes one system call, so not all of the data may be written.\n"
+"The number of bytes actually written is returned.");
+
+PyDoc_STRVAR(fileno_doc,
+"fileno() -> int. \"file descriptor\".\n"
+"\n"
+"This is needed for lower-level file interfaces, such the fcntl module.");
+
+PyDoc_STRVAR(seek_doc,
+"seek(offset: int[, whence: int]) -> 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)."
+"\n"
+"Note that not all file objects are seekable.");
+
+PyDoc_STRVAR(truncate_doc,
+"truncate([size: int]) -> None.	 Truncate the file to at most size bytes.\n"
+"\n"
+"Size defaults to the current file position, as returned by tell().");
+
+PyDoc_STRVAR(tell_doc,
+"tell() -> int.	 Current file position");
+
+PyDoc_STRVAR(readinto_doc,
+"readinto() -> Undocumented.  Don't use this; it may go away.");
+
+PyDoc_STRVAR(close_doc,
+"close() -> None.  Close the file.\n"
+"\n"
+"A closed file cannot be used for further I/O operations.  close() may be\n"
+"called more than once without error.  Changes the fileno to -1.");
+
+PyDoc_STRVAR(isatty_doc,
+"isatty() -> bool.  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.");
+
+PyDoc_STRVAR(seekable_doc,
+"seekable() -> bool.  True if file supports random-access.");
+
+PyDoc_STRVAR(readable_doc,
+"readable() -> bool.  True if file was opened in a read mode.");
+
+PyDoc_STRVAR(writable_doc,
+"writable() -> bool.  True if file was opened in a write mode.");
+
+static PyMethodDef fileio_methods[] = {
+	{"read",     (PyCFunction)fileio_read,	   METH_VARARGS, read_doc},
+	{"readinto", (PyCFunction)fileio_readinto, METH_VARARGS, readinto_doc},
+	{"write",    (PyCFunction)fileio_write,	   METH_VARARGS, write_doc},
+	{"seek",     (PyCFunction)fileio_seek,	   METH_VARARGS, seek_doc},
+	{"tell",     (PyCFunction)fileio_tell,	   METH_VARARGS, tell_doc},
+	{"truncate", (PyCFunction)fileio_truncate, METH_VARARGS, truncate_doc},
+	{"close",    (PyCFunction)fileio_close,	   METH_NOARGS,	 close_doc},
+	{"seekable", (PyCFunction)fileio_seekable, METH_NOARGS,	 seekable_doc},
+	{"readable", (PyCFunction)fileio_readable, METH_NOARGS,	 readable_doc},
+	{"writable", (PyCFunction)fileio_writable, METH_NOARGS,	 writable_doc},
+	{"fileno",   (PyCFunction)fileio_fileno,   METH_NOARGS,	 fileno_doc},
+	{"isatty",   (PyCFunction)fileio_isatty,   METH_NOARGS,	 isatty_doc},
+	{"__enter__",(PyCFunction)fileio_self,	   METH_NOARGS,	 enter_doc},
+	{"__exit__", (PyCFunction)fileio_close,	   METH_VARARGS, exit_doc},
+	{NULL,	     NULL}	       /* sentinel */
+};
+
+PyTypeObject PyFileIO_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,
+	"FileIO",
+	sizeof(PyFileIOObject),
+	0,
+	(destructor)fileio_dealloc,		/* tp_dealloc */
+	0,					/* tp_print */
+	0,					/* tp_getattr */
+	0,					/* tp_setattr */
+	0,					/* tp_compare */
+	(reprfunc)fileio_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 */
+	fileio_doc,				/* tp_doc */
+	0,					/* tp_traverse */
+	0,					/* tp_clear */
+	0,					/* tp_richcompare */
+	offsetof(PyFileIOObject, weakreflist),	/* tp_weaklistoffset */
+	0,					/* tp_iter */
+	0,					/* tp_iternext */
+	fileio_methods,				/* tp_methods */
+	0,					/* tp_members */
+	0,					/* tp_getset */
+	0,					/* tp_base */
+	0,					/* tp_dict */
+	0,					/* tp_descr_get */
+	0,					/* tp_descr_set */
+	0,					/* tp_dictoffset */
+	fileio_init,				/* tp_init */
+	PyType_GenericAlloc,			/* tp_alloc */
+	fileio_new,				/* tp_new */
+	PyObject_Del,				/* tp_free */
+};
+
+static PyMethodDef module_methods[] = {
+	{NULL, NULL}
+};
+
+PyMODINIT_FUNC
+init_fileio(void)
+{
+	PyObject *m;	/* a module object */
+
+	m = Py_InitModule3("_fileio", module_methods,
+			   "Fast implementation of io.FileIO.");
+	if (m == NULL)
+		return;
+	if (PyType_Ready(&PyFileIO_Type) < 0)
+		return;
+	Py_INCREF(&PyFileIO_Type);
+	PyModule_AddObject(m, "_FileIO", (PyObject *) &PyFileIO_Type);
+}
diff --git a/setup.py b/setup.py
index 3417865..573fba2 100644
--- a/setup.py
+++ b/setup.py
@@ -1037,6 +1037,9 @@ class PyBuildExt(build_ext):
         # Thomas Heller's _ctypes module
         self.detect_ctypes(inc_dirs, lib_dirs)
 
+        # _fileio -- supposedly cross platform
+        exts.append(Extension('_fileio', ['_fileio.c']))
+
         # Platform-specific libraries
         if platform == 'linux2':
             # Linux-specific modules