Hacked for Win32 by Mark Hammond.

Reformatted for 8-space tabs and fitted into 80-char lines by GvR.

Mark writes:

* the Win32 version now accepts the same args as the Unix version.
The win32 specific "tag" param is now optional.  The end result is
that the exact same test suite runs on Windows (definately a worthy
goal!).

* I changed the error object.  All occurences of the error, except
for 1, corresponds to an underlying OS error.  This one was changed
to a ValueError (a better error for that condition), and the module
error object is now simply EnvironmentError.  All win32 error
routines now call the new Windows specific error handler.

1 files changed, 569 insertions, 542 deletions

diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index bff22b2..66f0e48 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -1,7 +1,7 @@
-/* -*- Mode: C++; tab-width: 4 -*-
- /	Author: Sam Rushing <rushing@nightmare.com>
+/*
+ /  Author: Sam Rushing <rushing@nightmare.com>
  /  Hacked for Unix by A.M. Kuchling <amk1@bigfoot.com> 
- /	$Id$
+ /  $Id$
 
  / mmapmodule.cpp -- map a view of a file into memory
  /
@@ -16,6 +16,8 @@
  / ftp://squirl.nightmare.com/pub/python/python-ext.
 */
 
+#include <Python.h>
+
 #ifndef MS_WIN32
 #define UNIX
 #endif
@@ -29,23 +31,21 @@
 #include <sys/mman.h>
 #endif
 
-#include <Python.h>
-
 #include <string.h>
 #include <sys/types.h>
 
 static PyObject *mmap_module_error;
 
 typedef struct {
-		PyObject_HEAD
-		char *	data;
-		size_t	size;
-		size_t	pos;
+	PyObject_HEAD
+	char *	data;
+	size_t	size;
+	size_t	pos;
 
 #ifdef MS_WIN32
-		HANDLE	map_handle;
-		HFILE		file_handle;
-		char *	tagname;
+	HANDLE	map_handle;
+	HFILE	file_handle;
+	char *	tagname;
 #endif
 
 #ifdef UNIX
@@ -57,201 +57,205 @@ static void
 mmap_object_dealloc(mmap_object * m_obj)
 {
 #ifdef MS_WIN32
-		UnmapViewOfFile (m_obj->data);
-		CloseHandle (m_obj->map_handle);
-		CloseHandle ((HANDLE)m_obj->file_handle);
+	UnmapViewOfFile (m_obj->data);
+	CloseHandle (m_obj->map_handle);
+	CloseHandle ((HANDLE)m_obj->file_handle);
 #endif /* MS_WIN32 */
 
 #ifdef UNIX
-		if (m_obj->data!=NULL) {
-				msync(m_obj->data, m_obj->size, MS_SYNC | MS_INVALIDATE);
-				munmap(m_obj->data, m_obj->size);
-		}
+	if (m_obj->data!=NULL) {
+		msync(m_obj->data, m_obj->size, MS_SYNC | MS_INVALIDATE);
+		munmap(m_obj->data, m_obj->size);
+	}
 #endif /* UNIX */
 
-		PyMem_DEL(m_obj);
+	PyMem_DEL(m_obj);
 }
 
 static PyObject *
 mmap_close_method (mmap_object * self, PyObject * args)
 {
 #ifdef MS_WIN32
-		UnmapViewOfFile (self->data);
-		CloseHandle (self->map_handle);
-		CloseHandle ((HANDLE)self->file_handle);
-		self->map_handle = (HANDLE) NULL;
+	UnmapViewOfFile (self->data);
+	CloseHandle (self->map_handle);
+	CloseHandle ((HANDLE)self->file_handle);
+	self->map_handle = (HANDLE) NULL;
 #endif /* MS_WIN32 */
 
 #ifdef UNIX
-		munmap(self->data, self->size);
-		self->data = NULL;
+	munmap(self->data, self->size);
+	self->data = NULL;
 #endif
 
-		Py_INCREF (Py_None);
-		return (Py_None);
+	Py_INCREF (Py_None);
+	return (Py_None);
 }
 
 #ifdef MS_WIN32
-#define CHECK_VALID(err)  											    \
-do {																	\
-	if (!self->map_handle) {											 \
-		PyErr_SetString (PyExc_ValueError, "mmap closed or invalid");\
-		return err;													     \
-	}																	 \
+#define CHECK_VALID(err)						\
+do {									\
+    if (!self->map_handle) {						\
+	PyErr_SetString (PyExc_ValueError, "mmap closed or invalid");	\
+	return err;							\
+    }									\
 } while (0)
 #endif /* MS_WIN32 */
 
 #ifdef UNIX
-#define CHECK_VALID(err)												\
-do {																	\
-    if (self->data == NULL) {										    \
-    	PyErr_SetString (PyExc_ValueError, "mmap closed or invalid");	\
-        return err;														    \
-        }																	\
+#define CHECK_VALID(err)						\
+do {									\
+    if (self->data == NULL) {						\
+	PyErr_SetString (PyExc_ValueError, "mmap closed or invalid");	\
+	return err;							\
+	}								\
 } while (0)
 #endif /* UNIX */
 
 static PyObject *
 mmap_read_byte_method (mmap_object * self,
-						   PyObject * args)
+			   PyObject * args)
 {
-		char value;
-		char * where = (self->data+self->pos);
-		CHECK_VALID(NULL);
-		if ((where >= 0) && (where < (self->data+self->size))) {
-				value = (char) *(where);
-				self->pos += 1;
-				return Py_BuildValue("c", (char) *(where));
-		} else {
-				PyErr_SetString (PyExc_ValueError, "read byte out of range");
-				return NULL;
-		}
+	char value;
+	char * where = (self->data+self->pos);
+	CHECK_VALID(NULL);
+	if ((where >= 0) && (where < (self->data+self->size))) {
+		value = (char) *(where);
+		self->pos += 1;
+		return Py_BuildValue("c", (char) *(where));
+	} else {
+		PyErr_SetString (PyExc_ValueError, "read byte out of range");
+		return NULL;
+	}
 }
 
 static PyObject *
 mmap_read_line_method (mmap_object * self,
-						   PyObject * args)
+			   PyObject * args)
 {
-		char * start;
-		char * eof = self->data+self->size;
-		char * eol;
-		PyObject * result;
-
-		CHECK_VALID(NULL);
-		start = self->data+self->pos;
-
-		/* strchr was a bad idea here - there's no way to range
-		   check it.  there is no 'strnchr' */
-		for (eol = start; (eol < eof) && (*eol != '\n') ; eol++)
-		{ /* do nothing */ }
-
-		result = Py_BuildValue("s#", start, (long) (++eol - start));
-		self->pos += (eol - start);
-		return (result);
+	char * start;
+	char * eof = self->data+self->size;
+	char * eol;
+	PyObject * result;
+
+	CHECK_VALID(NULL);
+	start = self->data+self->pos;
+
+	/* strchr was a bad idea here - there's no way to range
+	   check it.  there is no 'strnchr' */
+	for (eol = start; (eol < eof) && (*eol != '\n') ; eol++)
+	{ /* do nothing */ }
+
+	result = Py_BuildValue("s#", start, (long) (++eol - start));
+	self->pos += (eol - start);
+	return (result);
 }
 
 static PyObject *
 mmap_read_method (mmap_object * self,
-					  PyObject * args)
+		      PyObject * args)
 {
-		long num_bytes;
-		PyObject *result;
-
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "l", &num_bytes))
-				return(NULL);
-
-		/* silently 'adjust' out-of-range requests */
-		if ((self->pos + num_bytes) > self->size) {
-				num_bytes -= (self->pos+num_bytes) - self->size;
-		}
-		result = Py_BuildValue("s#", self->data+self->pos, num_bytes);
-		self->pos += num_bytes;  
-		return (result);
+	long num_bytes;
+	PyObject *result;
+
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "l", &num_bytes))
+		return(NULL);
+
+	/* silently 'adjust' out-of-range requests */
+	if ((self->pos + num_bytes) > self->size) {
+		num_bytes -= (self->pos+num_bytes) - self->size;
+	}
+	result = Py_BuildValue("s#", self->data+self->pos, num_bytes);
+	self->pos += num_bytes;	 
+	return (result);
 }
 
 static PyObject *
 mmap_find_method (mmap_object *self,
-					  PyObject *args)
+		      PyObject *args)
 {
-		long start = self->pos;
-		char * needle;
-		int len;
+	long start = self->pos;
+	char * needle;
+	int len;
 
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "s#|l", &needle, &len, &start)) {
-				return NULL;
-		} else {
-				char * p = self->data+self->pos;
-				char * e = self->data+self->size;
-				while (p < e) {
-						char * s = p;
-						char * n = needle;
-						while ((s<e) && (*n) && !(*s-*n)) {
-								s++, n++;
-						}
-						if (!*n) {
-								return Py_BuildValue ("l", (long) (p - (self->data + start)));
-						}
-						p++;
-				}
-				return Py_BuildValue ("l", (long) -1);
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "s#|l", &needle, &len, &start)) {
+		return NULL;
+	} else {
+		char * p = self->data+self->pos;
+		char * e = self->data+self->size;
+		while (p < e) {
+			char * s = p;
+			char * n = needle;
+			while ((s<e) && (*n) && !(*s-*n)) {
+				s++, n++;
+			}
+			if (!*n) {
+				return Py_BuildValue (
+					"l",
+					(long) (p - (self->data + start)));
+			}
+			p++;
 		}
+		return Py_BuildValue ("l", (long) -1);
+	}
 }
 
 static PyObject *
 mmap_write_method (mmap_object * self,
-					   PyObject * args)
+		       PyObject * args)
 {
-		long length;
-		char * data;
+	long length;
+	char * data;
 
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "s#", &data, &length))
-				return(NULL);
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "s#", &data, &length))
+		return(NULL);
 
-		if ((self->pos + length) > self->size) {
-				PyErr_SetString (mmap_module_error, "data out of range");
-				return NULL;
-		}
-		memcpy (self->data+self->pos, data, length);
-		self->pos = self->pos+length;
-		Py_INCREF (Py_None);
-		return (Py_None);
+	if ((self->pos + length) > self->size) {
+		PyErr_SetString (PyExc_ValueError, "data out of range");
+		return NULL;
+	}
+	memcpy (self->data+self->pos, data, length);
+	self->pos = self->pos+length;
+	Py_INCREF (Py_None);
+	return (Py_None);
 }
 
 static PyObject *
 mmap_write_byte_method (mmap_object * self,
-							PyObject * args)
+			    PyObject * args)
 {
-		char value;
+	char value;
 
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "c", &value))
-				return(NULL);
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "c", &value))
+		return(NULL);
 
-		*(self->data+self->pos) = value;
-		self->pos += 1;
-		Py_INCREF (Py_None);
-		return (Py_None);
+	*(self->data+self->pos) = value;
+	self->pos += 1;
+	Py_INCREF (Py_None);
+	return (Py_None);
 }
 
 static PyObject *
 mmap_size_method (mmap_object * self,
-					  PyObject * args)
+		      PyObject * args)
 {
-		CHECK_VALID(NULL);
+	CHECK_VALID(NULL);
 
 #ifdef MS_WIN32
-		if (self->file_handle != (HFILE) 0xFFFFFFFF) {
-				return (Py_BuildValue ("l", GetFileSize ((HANDLE)self->file_handle, NULL)));
-		} else {
-				return (Py_BuildValue ("l", self->size) );
-		}
+	if (self->file_handle != (HFILE) 0xFFFFFFFF) {
+		return (Py_BuildValue (
+			"l",
+			GetFileSize ((HANDLE)self->file_handle, NULL)));
+	} else {
+		return (Py_BuildValue ("l", self->size) );
+	}
 #endif /* MS_WIN32 */
 
 #ifdef UNIX
-		return (Py_BuildValue ("l", self->size) );
+	return (Py_BuildValue ("l", self->size) );
 #endif /* UNIX */
 }
 
@@ -266,70 +270,72 @@ mmap_size_method (mmap_object * self,
 
 static PyObject *
 mmap_resize_method (mmap_object * self,
-						PyObject * args)
+			PyObject * args)
 {
-		unsigned long new_size;
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "l", &new_size)) {
-				return NULL;
+	unsigned long new_size;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "l", &new_size)) {
+		return NULL;
 #ifdef MS_WIN32
-		} else { 
-				/* First, unmap the file view */
-				UnmapViewOfFile (self->data);
-				/* Close the mapping object */
-				CloseHandle ((HANDLE)self->map_handle);
-				/* Move to the desired EOF position */
-				SetFilePointer ((HANDLE)self->file_handle, new_size, NULL, FILE_BEGIN);
-				/* Change the size of the file */
-				SetEndOfFile ((HANDLE)self->file_handle);
-				/* Create another mapping object and remap the file view */
-				self->map_handle = CreateFileMapping ((HANDLE) self->file_handle,
-													  NULL,
-													  PAGE_READWRITE,
-													  0,
-													  new_size,
-													  self->tagname);
-				char complaint[256];
-				if (self->map_handle != NULL) {
-						self->data = (char *) MapViewOfFile (self->map_handle,
-															 FILE_MAP_WRITE,
-															 0,
-															 0,
-															 0);
-						if (self->data != NULL) {
-								self->size = new_size;
-								Py_INCREF (Py_None);
-								return Py_None;
-						} else {
-								sprintf (complaint, "MapViewOfFile failed: %ld", GetLastError());
-						}
-				} else {
-						sprintf (complaint, "CreateFileMapping failed: %ld", GetLastError());
-				}
-				PyErr_SetString (mmap_module_error, complaint);
-				return (NULL);
+	} else { 
+		DWORD dwErrCode = 0;
+		/* First, unmap the file view */
+		UnmapViewOfFile (self->data);
+		/* Close the mapping object */
+		CloseHandle ((HANDLE)self->map_handle);
+		/* Move to the desired EOF position */
+		SetFilePointer ((HANDLE)self->file_handle,
+				new_size, NULL, FILE_BEGIN);
+		/* Change the size of the file */
+		SetEndOfFile ((HANDLE)self->file_handle);
+		/* Create another mapping object and remap the file view */
+		self->map_handle = CreateFileMapping (
+			(HANDLE) self->file_handle,
+			NULL,
+			PAGE_READWRITE,
+			0,
+			new_size,
+			self->tagname);
+		if (self->map_handle != NULL) {
+			self->data = (char *) MapViewOfFile (self->map_handle,
+							     FILE_MAP_WRITE,
+							     0,
+							     0,
+							     0);
+			if (self->data != NULL) {
+				self->size = new_size;
+				Py_INCREF (Py_None);
+				return Py_None;
+			} else {
+				dwErrCode = GetLastError();
+			}
+		} else {
+			dwErrCode = GetLastError();
 		}
+		PyErr_SetFromWindowsErr(dwErrCode);
+		return (NULL);
 #endif /* MS_WIN32 */
 
 #ifdef UNIX
 #ifndef MREMAP_MAYMOVE
 } else {
-		PyErr_SetString(PyExc_SystemError, "mmap: resizing not available--no mremap()");
-		return NULL;
+	PyErr_SetString(PyExc_SystemError,
+			"mmap: resizing not available--no mremap()");
+	return NULL;
 #else
 } else {
-		void *newmap;
+	void *newmap;
 
-		newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);
-		if (newmap == (void *)-1) 
-		{
-				PyErr_SetFromErrno(mmap_module_error);
-				return NULL;
-		}
-		self->data = newmap;
-		self->size = new_size;
-		Py_INCREF(Py_None);
-		return Py_None;
+	newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);
+	if (newmap == (void *)-1) 
+	{
+		PyErr_SetFromErrno(mmap_module_error);
+		return NULL;
+	}
+	self->data = newmap;
+	self->size = new_size;
+	Py_INCREF(Py_None);
+	return Py_None;
 #endif /* MREMAP_MAYMOVE */
 #endif /* UNIX */
 }
@@ -338,372 +344,381 @@ mmap_resize_method (mmap_object * self,
 static PyObject *
 mmap_tell_method (mmap_object * self, PyObject * args)
 {
-		CHECK_VALID(NULL);
-		return (Py_BuildValue ("l", self->pos) );
+	CHECK_VALID(NULL);
+	return (Py_BuildValue ("l", self->pos) );
 }
 
 static PyObject *
 mmap_flush_method (mmap_object * self, PyObject * args)
 {
-		size_t offset	= 0;
-		size_t size	= self->size;
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "|ll", &offset, &size)) {
-				return NULL;
-		} else if ((offset + size) > self->size) {
-				PyErr_SetString (PyExc_ValueError, "flush values out of range");
-				return NULL;
-		} else {
+	size_t offset	= 0;
+	size_t size = self->size;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "|ll", &offset, &size)) {
+		return NULL;
+	} else if ((offset + size) > self->size) {
+		PyErr_SetString (PyExc_ValueError,
+				 "flush values out of range");
+		return NULL;
+	} else {
 #ifdef MS_WIN32
-				return (Py_BuildValue ("l", FlushViewOfFile (self->data+offset, size)));
+		return (Py_BuildValue (
+			"l", FlushViewOfFile (self->data+offset, size)));
 #endif /* MS_WIN32 */
 #ifdef UNIX
-                /* XXX semantics of return value? */
-                /* XXX flags for msync? */
-				if (-1 == msync(self->data + offset, size, MS_SYNC | MS_INVALIDATE))
-				{
-						PyErr_SetFromErrno(mmap_module_error);
-						return NULL;
-				}
-				return Py_BuildValue ("l", 0);	
-#endif /* UNIX */	
+		/* XXX semantics of return value? */
+		/* XXX flags for msync? */
+		if (-1 == msync(self->data + offset, size,
+				MS_SYNC | MS_INVALIDATE))
+		{
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
 		}
+		return Py_BuildValue ("l", 0);	
+#endif /* UNIX */   
+	}
 }
 
 static PyObject *
 mmap_seek_method (mmap_object * self, PyObject * args)
 {
-		/* ptrdiff_t dist; */
-		long dist;
-		int how=0;
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "l|i", &dist, &how)) {
-				return(NULL);
+	/* ptrdiff_t dist; */
+	long dist;
+	int how=0;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "l|i", &dist, &how)) {
+		return(NULL);
+	} else {
+		unsigned long where;
+		switch (how) {
+		case 0:
+			where = dist;
+			break;
+		case 1:
+			where = self->pos + dist;
+			break;
+		case 2:
+			where = self->size - dist;
+			break;
+		default:
+			PyErr_SetString (PyExc_ValueError,
+					 "unknown seek type");
+			return NULL;
+		}
+		if ((where >= 0) && (where < (self->size))) {
+			self->pos = where;
+			Py_INCREF (Py_None);
+			return (Py_None);
 		} else {
-				unsigned long where;
-				switch (how) {
-				case 0:
-						where = dist;
-						break;
-				case 1:
-						where = self->pos + dist;
-						break;
-				case 2:
-						where = self->size - dist;
-						break;
-				default:
-						PyErr_SetString (PyExc_ValueError, "unknown seek type");
-						return NULL;
-				}
-				if ((where >= 0) && (where < (self->size))) {
-						self->pos = where;
-						Py_INCREF (Py_None);
-						return (Py_None);
-				} else {
-						PyErr_SetString (PyExc_ValueError, "seek out of range");
-						return NULL;
-				}
+			PyErr_SetString (PyExc_ValueError,
+					 "seek out of range");
+			return NULL;
 		}
+	}
 }
 
 static PyObject *
 mmap_move_method (mmap_object * self, PyObject * args)
 {
-		unsigned long dest, src, count;
-		CHECK_VALID(NULL);
-		if (!PyArg_ParseTuple (args, "iii", &dest, &src, &count)) {
-				return NULL;
+	unsigned long dest, src, count;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple (args, "iii", &dest, &src, &count)) {
+		return NULL;
+	} else {
+		/* bounds check the values */
+		if (/* end of source after end of data?? */
+			((src+count) > self->size)
+			/* dest will fit? */
+			|| (dest+count > self->size)) {
+			PyErr_SetString (PyExc_ValueError,
+					 "source or destination out of range");
+			return NULL;
 		} else {
-				/* bounds check the values */
-				if (/* end of source after end of data?? */
-						((src+count) > self->size)
-						/* dest will fit? */
-						|| (dest+count > self->size)) {
-						PyErr_SetString (PyExc_ValueError,
-										 "source or destination out of range");
-						return NULL;
-				} else {
-						memmove (self->data+dest, self->data+src, count);
-						Py_INCREF (Py_None);
-						return Py_None;
-				}
+			memmove (self->data+dest, self->data+src, count);
+			Py_INCREF (Py_None);
+			return Py_None;
 		}
+	}
 }
 
 static struct PyMethodDef mmap_object_methods[] = {
-		{"close",		(PyCFunction) mmap_close_method,		1},
-		{"find",		(PyCFunction) mmap_find_method,			1},
-		{"flush",		(PyCFunction) mmap_flush_method,		1},
-		{"move",		(PyCFunction) mmap_move_method,			1},
-		{"read",		(PyCFunction) mmap_read_method,			1},
-		{"read_byte", (PyCFunction) mmap_read_byte_method,	1},
-		{"readline",	(PyCFunction) mmap_read_line_method,	1},
-		{"resize",	(PyCFunction) mmap_resize_method,		1},
-		{"seek",		(PyCFunction) mmap_seek_method,			1},
-		{"size",		(PyCFunction) mmap_size_method,			1},
-		{"tell",		(PyCFunction) mmap_tell_method,			1},
-		{"write",		(PyCFunction) mmap_write_method,		1},
-		{"write_byte",(PyCFunction) mmap_write_byte_method,	1},
-		{NULL,	   NULL}	   /* sentinel */
+	{"close",	(PyCFunction) mmap_close_method,	1},
+	{"find",	(PyCFunction) mmap_find_method,		1},
+	{"flush",	(PyCFunction) mmap_flush_method,	1},
+	{"move",	(PyCFunction) mmap_move_method,		1},
+	{"read",	(PyCFunction) mmap_read_method,		1},
+	{"read_byte",	(PyCFunction) mmap_read_byte_method,  	1},
+	{"readline",	(PyCFunction) mmap_read_line_method,	1},
+	{"resize",	(PyCFunction) mmap_resize_method,	1},
+	{"seek",	(PyCFunction) mmap_seek_method,		1},
+	{"size",	(PyCFunction) mmap_size_method,		1},
+	{"tell",	(PyCFunction) mmap_tell_method,		1},
+	{"write",	(PyCFunction) mmap_write_method,	1},
+	{"write_byte",	(PyCFunction) mmap_write_byte_method,	1},
+	{NULL,	   NULL}       /* sentinel */
 };
 
 /* Functions for treating an mmap'ed file as a buffer */
 
 static int
 mmap_buffer_getreadbuf(self, index, ptr)
-        mmap_object *self;
+	mmap_object *self;
 int index;
 const void **ptr;
 {
-		CHECK_VALID(-1);
-		if ( index != 0 ) {
-				PyErr_SetString(PyExc_SystemError, "Accessing non-existent mmap segment");
-				return -1;
-		}
-		*ptr = self->data;
-		return self->size;
+	CHECK_VALID(-1);
+	if ( index != 0 ) {
+		PyErr_SetString(PyExc_SystemError,
+				"Accessing non-existent mmap segment");
+		return -1;
+	}
+	*ptr = self->data;
+	return self->size;
 }
 
 static int
 mmap_buffer_getwritebuf(self, index, ptr)
-        mmap_object *self;
-int index;
-const void **ptr;
+	mmap_object *self;
+	int index;
+	const void **ptr;
 {  
-		CHECK_VALID(-1);
-		if ( index != 0 ) {
-				PyErr_SetString(PyExc_SystemError, "Accessing non-existent mmap segment");
-				return -1;
-		}
-		*ptr = self->data;
-		return self->size;
+	CHECK_VALID(-1);
+	if ( index != 0 ) {
+		PyErr_SetString(PyExc_SystemError,
+				"Accessing non-existent mmap segment");
+		return -1;
+	}
+	*ptr = self->data;
+	return self->size;
 }
 
 static int
 mmap_buffer_getsegcount(self, lenp)
-        mmap_object *self;
-int *lenp;
+	mmap_object *self;
+	int *lenp;
 {
-		CHECK_VALID(-1);
-		if (lenp) 
-				*lenp = self->size;
-		return 1;
+	CHECK_VALID(-1);
+	if (lenp) 
+		*lenp = self->size;
+	return 1;
 }
 
 static int
 mmap_buffer_getcharbuffer(self, index, ptr)
-        mmap_object *self;
-int index;
-const void **ptr;
+	mmap_object *self;
+	int index;
+	const void **ptr;
 {
-		if ( index != 0 ) {
-				PyErr_SetString(PyExc_SystemError,
-								"accessing non-existent buffer segment");
-				return -1;
-		}
-		*ptr = (const char *)self->data;
-		return self->size;
+	if ( index != 0 ) {
+		PyErr_SetString(PyExc_SystemError,
+				"accessing non-existent buffer segment");
+		return -1;
+	}
+	*ptr = (const char *)self->data;
+	return self->size;
 }
 
 static PyObject *
 mmap_object_getattr(mmap_object * self, char * name)
 {
-		return Py_FindMethod (mmap_object_methods, (PyObject *)self, name);
+	return Py_FindMethod (mmap_object_methods, (PyObject *)self, name);
 }
 
 static int
 mmap_length(self)
-        mmap_object *self;
+	mmap_object *self;
 {
-		CHECK_VALID(-1);
-		return self->size;
+	CHECK_VALID(-1);
+	return self->size;
 }
 
 static PyObject *
 mmap_item(self, i)
-        mmap_object *self;
-int i;
+	mmap_object *self;
+	int i;
 {
-		CHECK_VALID(NULL);
-		if (i < 0 || i >= self->size) {
-				PyErr_SetString(PyExc_IndexError, "mmap index out of range");
-				return NULL;
-		}
-		return PyString_FromStringAndSize(self->data + i, 1);
+	CHECK_VALID(NULL);
+	if (i < 0 || i >= self->size) {
+		PyErr_SetString(PyExc_IndexError, "mmap index out of range");
+		return NULL;
+	}
+	return PyString_FromStringAndSize(self->data + i, 1);
 }
 
 static PyObject *
 mmap_slice(self, ilow, ihigh)
-        mmap_object *self;
-int ilow, ihigh;
+	mmap_object *self;
+	int ilow, ihigh;
 {
-		CHECK_VALID(NULL);
-		if (ilow < 0)
-				ilow = 0;
-		else if (ilow > self->size)
-				ilow = self->size;
-		if (ihigh < 0)
-				ihigh = 0;
-		if (ihigh < ilow)
-				ihigh = ilow;
-		else if (ihigh > self->size)
-				ihigh = self->size;
-	
-		return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
+	CHECK_VALID(NULL);
+	if (ilow < 0)
+		ilow = 0;
+	else if (ilow > self->size)
+		ilow = self->size;
+	if (ihigh < 0)
+		ihigh = 0;
+	if (ihigh < ilow)
+		ihigh = ilow;
+	else if (ihigh > self->size)
+		ihigh = self->size;
+    
+	return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
 }
 
 static PyObject *
 mmap_concat(self, bb)
-        mmap_object *self;
-PyObject *bb;
+	mmap_object *self;
+	PyObject *bb;
 {
-		CHECK_VALID(NULL);
-		PyErr_SetString(PyExc_SystemError, "mmaps don't support concatenation");
-		return NULL;
+	CHECK_VALID(NULL);
+	PyErr_SetString(PyExc_SystemError,
+			"mmaps don't support concatenation");
+	return NULL;
 }
 
 static PyObject *
 mmap_repeat(self, n)
-        mmap_object *self;
-int n;
+	mmap_object *self;
+	int n;
 {
-		CHECK_VALID(NULL);
-		PyErr_SetString(PyExc_SystemError, "mmaps don't support repeat operation");
-		return NULL;
+	CHECK_VALID(NULL);
+	PyErr_SetString(PyExc_SystemError,
+			"mmaps don't support repeat operation");
+	return NULL;
 }
 
 static int
 mmap_ass_slice(self, ilow, ihigh, v)
-        mmap_object *self;
-int ilow, ihigh;
-PyObject *v;
+	mmap_object *self;
+	int ilow, ihigh;
+	PyObject *v;
 {
-		unsigned char *buf;
-
-		CHECK_VALID(-1);
-		if (ilow < 0)
-				ilow = 0;
-		else if (ilow > self->size)
-				ilow = self->size;
-		if (ihigh < 0)
-				ihigh = 0;
-		if (ihigh < ilow)
-				ihigh = ilow;
-		else if (ihigh > self->size)
-				ihigh = self->size;
-	
-		if (! (PyString_Check(v)) ) {
-				PyErr_SetString(PyExc_IndexError, 
-								"mmap slice assignment must be a string");
-				return -1;
-		}
-		if ( PyString_Size(v) != (ihigh - ilow) ) {
-				PyErr_SetString(PyExc_IndexError, 
-								"mmap slice assignment is wrong size");
-				return -1;
-		}
-		buf = PyString_AsString(v);
-		memcpy(self->data + ilow, buf, ihigh-ilow);
-		return 0;
+	unsigned char *buf;
+
+	CHECK_VALID(-1);
+	if (ilow < 0)
+		ilow = 0;
+	else if (ilow > self->size)
+		ilow = self->size;
+	if (ihigh < 0)
+		ihigh = 0;
+	if (ihigh < ilow)
+		ihigh = ilow;
+	else if (ihigh > self->size)
+		ihigh = self->size;
+    
+	if (! (PyString_Check(v)) ) {
+		PyErr_SetString(PyExc_IndexError, 
+				"mmap slice assignment must be a string");
+		return -1;
+	}
+	if ( PyString_Size(v) != (ihigh - ilow) ) {
+		PyErr_SetString(PyExc_IndexError, 
+				"mmap slice assignment is wrong size");
+		return -1;
+	}
+	buf = PyString_AsString(v);
+	memcpy(self->data + ilow, buf, ihigh-ilow);
+	return 0;
 }
 
 static int
 mmap_ass_item(self, i, v)
-        mmap_object *self;
-int i;
-PyObject *v;
+	mmap_object *self;
+	int i;
+	PyObject *v;
 {
-		unsigned char *buf;
+	unsigned char *buf;
  
-		CHECK_VALID(-1);
-		if (i < 0 || i >= self->size) {
-				PyErr_SetString(PyExc_IndexError, "mmap index out of range");
-				return -1;
-		}
-		if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
-				PyErr_SetString(PyExc_IndexError, 
-								"mmap assignment must be single-character string");
-				return -1;
-		}
-		buf = PyString_AsString(v);
-		self->data[i] = buf[0];
-		return 0;
+	CHECK_VALID(-1);
+	if (i < 0 || i >= self->size) {
+		PyErr_SetString(PyExc_IndexError, "mmap index out of range");
+		return -1;
+	}
+	if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
+		PyErr_SetString(PyExc_IndexError, 
+			"mmap assignment must be single-character string");
+		return -1;
+	}
+	buf = PyString_AsString(v);
+	self->data[i] = buf[0];
+	return 0;
 }
 
 static PySequenceMethods mmap_as_sequence = {
-        (inquiry)mmap_length,                  /*sq_length*/
-        (binaryfunc)mmap_concat,               /*sq_concat*/
-        (intargfunc)mmap_repeat,               /*sq_repeat*/
-        (intargfunc)mmap_item,                 /*sq_item*/
-        (intintargfunc)mmap_slice,             /*sq_slice*/
-        (intobjargproc)mmap_ass_item,          /*sq_ass_item*/
-        (intintobjargproc)mmap_ass_slice,      /*sq_ass_slice*/
+	(inquiry)mmap_length,		       /*sq_length*/
+	(binaryfunc)mmap_concat,	       /*sq_concat*/
+	(intargfunc)mmap_repeat,	       /*sq_repeat*/
+	(intargfunc)mmap_item,		       /*sq_item*/
+	(intintargfunc)mmap_slice,	       /*sq_slice*/
+	(intobjargproc)mmap_ass_item,	       /*sq_ass_item*/
+	(intintobjargproc)mmap_ass_slice,      /*sq_ass_slice*/
 };
 
 static PyBufferProcs mmap_as_buffer = {
-        (getreadbufferproc)mmap_buffer_getreadbuf,
-        (getwritebufferproc)mmap_buffer_getwritebuf,
-        (getsegcountproc)mmap_buffer_getsegcount,
-        (getcharbufferproc)mmap_buffer_getcharbuffer,
+	(getreadbufferproc)mmap_buffer_getreadbuf,
+	(getwritebufferproc)mmap_buffer_getwritebuf,
+	(getsegcountproc)mmap_buffer_getsegcount,
+	(getcharbufferproc)mmap_buffer_getcharbuffer,
 };
 
 static PyTypeObject mmap_object_type = {
-		PyObject_HEAD_INIT(&PyType_Type)
-		0,									/* ob_size */
-		"mmap",							/* tp_name */
-		sizeof(mmap_object),				/* tp_size */
-		0,									/* tp_itemsize */
-		/* methods */
-		(destructor) mmap_object_dealloc, /* tp_dealloc */
-		0,									/* tp_print */
-		(getattrfunc) mmap_object_getattr,/* tp_getattr */
-		0,									/* tp_setattr */
-		0,									/* tp_compare */
-		0,									/* tp_repr */
-		0,									/* tp_as_number */
-		&mmap_as_sequence,                /*tp_as_sequence*/
-		0,                                    /*tp_as_mapping*/
-		0,                                    /*tp_hash*/
-		0,                                    /*tp_call*/
-		0,                                    /*tp_str*/
-		0,                                    /*tp_getattro*/
-		0,                                    /*tp_setattro*/
-		&mmap_as_buffer,                  /*tp_as_buffer*/
-		Py_TPFLAGS_HAVE_GETCHARBUFFER,        /*tp_flags*/
-		0,                                    /*tp_doc*/
+	PyObject_HEAD_INIT(0) /* patched in module init */
+	0,					/* ob_size */
+	"mmap",					/* tp_name */
+	sizeof(mmap_object),			/* tp_size */
+	0,					/* tp_itemsize */
+	/* methods */
+	(destructor) mmap_object_dealloc,	/* tp_dealloc */
+	0,					/* tp_print */
+	(getattrfunc) mmap_object_getattr,	/* tp_getattr */
+	0,					/* tp_setattr */
+	0,					/* tp_compare */
+	0,					/* tp_repr */
+	0,					/* tp_as_number */
+	&mmap_as_sequence,			/*tp_as_sequence*/
+	0,					/*tp_as_mapping*/
+	0,					/*tp_hash*/
+	0,					/*tp_call*/
+	0,					/*tp_str*/
+	0,					/*tp_getattro*/
+	0,					/*tp_setattro*/
+	&mmap_as_buffer,			/*tp_as_buffer*/
+	Py_TPFLAGS_HAVE_GETCHARBUFFER,		/*tp_flags*/
+	0,					/*tp_doc*/
 };
 
 #ifdef UNIX 
 static PyObject *
 new_mmap_object (PyObject * self, PyObject * args, PyObject *kwdict)
 {
-		mmap_object * m_obj;
-		unsigned long map_size;
-		int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
-		char * filename;
-		int namelen;
-		char *keywords[] = {"file", "size", "flags", "prot", NULL};
-
-		if (!PyArg_ParseTupleAndKeywords(args, kwdict, 
-										 "il|ii", keywords, 
-										 &fd, &map_size, &flags, &prot)
-				)
-				return NULL;
+	mmap_object * m_obj;
+	unsigned long map_size;
+	int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
+	char * filename;
+	int namelen;
+	char *keywords[] = {"file", "size", "flags", "prot", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwdict, 
+					 "il|ii", keywords, 
+					 &fd, &map_size, &flags, &prot)
+		)
+		return NULL;
   
-		m_obj = PyObject_NEW (mmap_object, &mmap_object_type);
-		if (m_obj == NULL) {return NULL;}
-		m_obj->size = (size_t) map_size;
-		m_obj->pos = (size_t) 0;
-		m_obj->data = mmap(NULL, map_size, 
-						   prot, flags,
-						   fd, 0);
-		if (m_obj->data == (void *)-1)
-		{
-				Py_DECREF(m_obj);
-				PyErr_SetFromErrno(mmap_module_error);
-				return NULL;
-		}
-		return (PyObject *)m_obj;
+	m_obj = PyObject_NEW (mmap_object, &mmap_object_type);
+	if (m_obj == NULL) {return NULL;}
+	m_obj->size = (size_t) map_size;
+	m_obj->pos = (size_t) 0;
+	m_obj->data = mmap(NULL, map_size, 
+			   prot, flags,
+			   fd, 0);
+	if (m_obj->data == (void *)-1)
+	{
+		Py_DECREF(m_obj);
+		PyErr_SetFromErrno(mmap_module_error);
+		return NULL;
+	}
+	return (PyObject *)m_obj;
 }
 #endif /* UNIX */
 
@@ -711,93 +726,95 @@ new_mmap_object (PyObject * self, PyObject * args, PyObject *kwdict)
 static PyObject *
 new_mmap_object (PyObject * self, PyObject * args)
 {
-		mmap_object * m_obj;
-		unsigned long map_size;
-		char * filename;
-		int namelen;
-		char * tagname;
-
-		char complaint[256];
-		HFILE fh = 0;
-		OFSTRUCT file_info;
-
-		if (!PyArg_Parse (args,
-						  "(s#zl)",
-						  &filename,
-						  &namelen,
-						  &tagname,
-						  &map_size)
-				)
-				return NULL;
+	mmap_object * m_obj;
+	unsigned long map_size;
+	char * filename;
+	int namelen;
+	char * tagname = "";
+
+	DWORD dwErr = 0;
+	int fileno;
+	HFILE fh = 0;
+	OFSTRUCT file_info;
+
+	/* Patch the object type */
+	mmap_object_type.ob_type = &PyType_Type;
+
+	if (!PyArg_ParseTuple(args,
+			  "il|z",
+			  &fileno,
+			  &map_size,
+			  &tagname)
+		)
+		return NULL;
   
-		/* if an actual filename has been specified */
-		if (namelen != 0) {
-				fh = OpenFile (filename, &file_info, OF_READWRITE);
-				if (fh == HFILE_ERROR) {
-						sprintf (complaint, "OpenFile failed: %ld", GetLastError());
-						PyErr_SetString(mmap_module_error, complaint);
-						return NULL;
-				}
+	/* if an actual filename has been specified */
+	if (fileno != 0) {
+		fh = _get_osfhandle(fileno);
+		if (fh==-1) {
+		    PyErr_SetFromErrno(mmap_module_error);
+		    return NULL;
 		}
-
-		m_obj = PyObject_NEW (mmap_object, &mmap_object_type);
-	
-		if (fh) {
-				m_obj->file_handle = fh;
-				if (!map_size) {
-						m_obj->size = GetFileSize ((HANDLE)fh, NULL);
-				} else {
-						m_obj->size = map_size;
-				}
-		}
-		else {
-				m_obj->file_handle = (HFILE) 0xFFFFFFFF;
-				m_obj->size = map_size;
+//
+//		fh = OpenFile (filename, &file_info, OF_READWRITE);
+//		if (fh == HFILE_ERROR) {
+//			PyErr_SetFromWindowsErr(GetLastError());
+//			return NULL;
+//		}
+	}
+
+	m_obj = PyObject_NEW (mmap_object, &mmap_object_type);
+    
+	if (fh) {
+		m_obj->file_handle = fh;
+		if (!map_size) {
+			m_obj->size = GetFileSize ((HANDLE)fh, NULL);
+		} else {
+			m_obj->size = map_size;
 		}
-
-		/* set the initial position */
-		m_obj->pos = (size_t) 0;
-
-		m_obj->map_handle = CreateFileMapping ((HANDLE) m_obj->file_handle,
-											   NULL,
-											   PAGE_READWRITE,
-											   0,
-											   m_obj->size,
-											   tagname);
-		if (m_obj->map_handle != NULL) {
-				m_obj->data = (char *) MapViewOfFile (m_obj->map_handle,
-													  FILE_MAP_WRITE,
-													  0,
-													  0,
-													  0);
-				if (m_obj->data != NULL) {
-						return ((PyObject *) m_obj);
-				} else {
-						sprintf (complaint, "MapViewOfFile failed: %ld", GetLastError());
-				}
+	}
+	else {
+		m_obj->file_handle = (HFILE) 0xFFFFFFFF;
+		m_obj->size = map_size;
+	}
+
+	/* set the initial position */
+	m_obj->pos = (size_t) 0;
+
+	m_obj->map_handle = CreateFileMapping ((HANDLE) m_obj->file_handle,
+					       NULL,
+					       PAGE_READWRITE,
+					       0,
+					       m_obj->size,
+					       tagname);
+	if (m_obj->map_handle != NULL) {
+		m_obj->data = (char *) MapViewOfFile (m_obj->map_handle,
+						      FILE_MAP_WRITE,
+						      0,
+						      0,
+						      0);
+		if (m_obj->data != NULL) {
+			return ((PyObject *) m_obj);
 		} else {
-				sprintf (complaint, "CreateFileMapping failed: %ld", GetLastError());
+		    dwErr = GetLastError();
 		}
-		PyErr_SetString (mmap_module_error, complaint);
-		return (NULL);
+	} else {
+		dwErr = GetLastError();
+	}
+	PyErr_SetFromWindowsErr(dwErr);
+	return (NULL);
 }
 #endif /* MS_WIN32 */
 
 /* List of functions exported by this module */
 static struct PyMethodDef mmap_functions[] = {
-#ifdef MS_WIN32
-		{"mmap",		(PyCFunction) new_mmap_object},
-#endif /* MS_WIN32 */
-
-#ifdef UNIX
-		{"mmap",		(PyCFunction) new_mmap_object, 
-		 METH_VARARGS|METH_KEYWORDS},
-#endif /* UNIX */
-		{NULL,			NULL}		 /* Sentinel */
+	{"mmap",	(PyCFunction) new_mmap_object, 
+	 METH_VARARGS|METH_KEYWORDS},
+	{NULL,		NULL}	     /* Sentinel */
 };
 
 #ifdef MS_WIN32
-extern"C" __declspec(dllexport) void
+__declspec(dllexport) void
 #endif /* MS_WIN32 */
 #ifdef UNIX
 extern void
@@ -805,44 +822,54 @@ extern void
 
 initmmap(void)
 {
-		PyObject *dict, *module;
-		module = Py_InitModule ("mmap", mmap_functions);
-		dict = PyModule_GetDict (module);
-		mmap_module_error = PyString_FromString ("mmap error");
-		PyDict_SetItemString (dict, "error", mmap_module_error);
-
+	PyObject *dict, *module;
+	module = Py_InitModule ("mmap", mmap_functions);
+	dict = PyModule_GetDict (module);
+	mmap_module_error = PyExc_EnvironmentError;
+	Py_INCREF(mmap_module_error);
+	PyDict_SetItemString (dict, "error", mmap_module_error);
 #ifdef PROT_EXEC
-		PyDict_SetItemString (dict, "PROT_EXEC", PyInt_FromLong(PROT_EXEC) );
+	PyDict_SetItemString (dict, "PROT_EXEC", PyInt_FromLong(PROT_EXEC) );
 #endif
 #ifdef PROT_READ
-		PyDict_SetItemString (dict, "PROT_READ", PyInt_FromLong(PROT_READ) );
+	PyDict_SetItemString (dict, "PROT_READ", PyInt_FromLong(PROT_READ) );
 #endif
 #ifdef PROT_WRITE
-		PyDict_SetItemString (dict, "PROT_WRITE", PyInt_FromLong(PROT_WRITE) );
+	PyDict_SetItemString (dict, "PROT_WRITE", PyInt_FromLong(PROT_WRITE) );
 #endif
 
 #ifdef MAP_SHARED
-		PyDict_SetItemString (dict, "MAP_SHARED", PyInt_FromLong(MAP_SHARED) );
+	PyDict_SetItemString (dict, "MAP_SHARED", PyInt_FromLong(MAP_SHARED) );
 #endif
 #ifdef MAP_PRIVATE
-		PyDict_SetItemString (dict, "MAP_PRIVATE", PyInt_FromLong(MAP_PRIVATE) );
+	PyDict_SetItemString (dict, "MAP_PRIVATE",
+			      PyInt_FromLong(MAP_PRIVATE) );
 #endif
 #ifdef MAP_DENYWRITE
-		PyDict_SetItemString (dict, "MAP_DENYWRITE", PyInt_FromLong(MAP_DENYWRITE) );
+	PyDict_SetItemString (dict, "MAP_DENYWRITE",
+			      PyInt_FromLong(MAP_DENYWRITE) );
 #endif
 #ifdef MAP_EXECUTABLE
-		PyDict_SetItemString (dict, "MAP_EXECUTABLE", PyInt_FromLong(MAP_EXECUTABLE) );
+	PyDict_SetItemString (dict, "MAP_EXECUTABLE",
+			      PyInt_FromLong(MAP_EXECUTABLE) );
 #endif
 #ifdef MAP_ANON
-		PyDict_SetItemString (dict, "MAP_ANON", PyInt_FromLong(MAP_ANON) );
-		PyDict_SetItemString (dict, "MAP_ANONYMOUS", PyInt_FromLong(MAP_ANON) );
+	PyDict_SetItemString (dict, "MAP_ANON", PyInt_FromLong(MAP_ANON) );
+	PyDict_SetItemString (dict, "MAP_ANONYMOUS",
+			      PyInt_FromLong(MAP_ANON) );
 #endif
 
 #ifdef UNIX
-		PyDict_SetItemString (dict, "PAGESIZE", PyInt_FromLong( (long)getpagesize() ) );
+	PyDict_SetItemString (dict, "PAGESIZE",
+			      PyInt_FromLong( (long)getpagesize() ) );
 #endif
+#ifdef MS_WIN32
+	{
+	    SYSTEM_INFO si;
+	    GetSystemInfo(&si);
+	    PyDict_SetItemString (dict, "PAGESIZE",
+				  PyInt_FromLong( si.dwPageSize ) );
+	}
+#endif /* MS_WIN32 */
 
 }
-
-
-