add hg and python

1 files changed, 1186 insertions, 0 deletions

diff --git a/sys/src/cmd/python/Modules/mmapmodule.c b/sys/src/cmd/python/Modules/mmapmodule.c
new file mode 100644
index 000000000..9716e303d
--- /dev/null
+++ b/sys/src/cmd/python/Modules/mmapmodule.c
@@ -0,0 +1,1186 @@
+/*
+ /  Author: Sam Rushing <rushing@nightmare.com>
+ /  Hacked for Unix by AMK
+ /  $Id: mmapmodule.c 51474 2006-08-22 13:57:07Z neal.norwitz $
+
+ / mmapmodule.cpp -- map a view of a file into memory
+ /
+ / todo: need permission flags, perhaps a 'chsize' analog
+ /   not all functions check range yet!!!
+ /
+ /
+ / This version of mmapmodule.c has been changed significantly
+ / from the original mmapfile.c on which it was based.
+ / The original version of mmapfile is maintained by Sam at
+ / ftp://squirl.nightmare.com/pub/python/python-ext.
+*/
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#ifndef MS_WINDOWS
+#define UNIX
+#endif
+
+#ifdef MS_WINDOWS
+#include <windows.h>
+static int
+my_getpagesize(void)
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	return si.dwPageSize;
+}
+#endif
+
+#ifdef UNIX
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
+static int
+my_getpagesize(void)
+{
+	return sysconf(_SC_PAGESIZE);
+}
+#else
+#define my_getpagesize getpagesize
+#endif
+
+#endif /* UNIX */
+
+#include <string.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif /* HAVE_SYS_TYPES_H */
+
+/* Prefer MAP_ANONYMOUS since MAP_ANON is deprecated according to man page. */
+#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
+#  define MAP_ANONYMOUS MAP_ANON
+#endif
+
+static PyObject *mmap_module_error;
+
+typedef enum
+{
+	ACCESS_DEFAULT,
+	ACCESS_READ,
+	ACCESS_WRITE,
+	ACCESS_COPY
+} access_mode;
+
+typedef struct {
+	PyObject_HEAD
+	char *	data;
+	size_t	size;
+	size_t	pos;
+
+#ifdef MS_WINDOWS
+	HANDLE	map_handle;
+	HANDLE	file_handle;
+	char *	tagname;
+#endif
+
+#ifdef UNIX
+        int fd;
+#endif
+
+        access_mode access;
+} mmap_object;
+
+
+static void
+mmap_object_dealloc(mmap_object *m_obj)
+{
+#ifdef MS_WINDOWS
+	if (m_obj->data != NULL)
+		UnmapViewOfFile (m_obj->data);
+	if (m_obj->map_handle != INVALID_HANDLE_VALUE)
+		CloseHandle (m_obj->map_handle);
+	if (m_obj->file_handle != INVALID_HANDLE_VALUE)
+		CloseHandle (m_obj->file_handle);
+	if (m_obj->tagname)
+		PyMem_Free(m_obj->tagname);
+#endif /* MS_WINDOWS */
+
+#ifdef UNIX
+	if (m_obj->fd >= 0)
+		(void) close(m_obj->fd);
+	if (m_obj->data!=NULL) {
+		msync(m_obj->data, m_obj->size, MS_SYNC);
+		munmap(m_obj->data, m_obj->size);
+	}
+#endif /* UNIX */
+
+	PyObject_Del(m_obj);
+}
+
+static PyObject *
+mmap_close_method(mmap_object *self, PyObject *unused)
+{
+#ifdef MS_WINDOWS
+	/* For each resource we maintain, we need to check
+	   the value is valid, and if so, free the resource
+	   and set the member value to an invalid value so
+	   the dealloc does not attempt to resource clearing
+	   again.
+	   TODO - should we check for errors in the close operations???
+	*/
+	if (self->data != NULL) {
+		UnmapViewOfFile(self->data);
+		self->data = NULL;
+	}
+	if (self->map_handle != INVALID_HANDLE_VALUE) {
+		CloseHandle(self->map_handle);
+		self->map_handle = INVALID_HANDLE_VALUE;
+	}
+	if (self->file_handle != INVALID_HANDLE_VALUE) {
+		CloseHandle(self->file_handle);
+		self->file_handle = INVALID_HANDLE_VALUE;
+	}
+#endif /* MS_WINDOWS */
+
+#ifdef UNIX
+	(void) close(self->fd);
+	self->fd = -1;
+	if (self->data != NULL) {
+		munmap(self->data, self->size);
+		self->data = NULL;
+	}
+#endif
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+#ifdef MS_WINDOWS
+#define CHECK_VALID(err)						\
+do {									\
+    if (self->map_handle == INVALID_HANDLE_VALUE) {						\
+	PyErr_SetString(PyExc_ValueError, "mmap closed or invalid");	\
+	return err;							\
+    }									\
+} while (0)
+#endif /* MS_WINDOWS */
+
+#ifdef UNIX
+#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 *unused)
+{
+	CHECK_VALID(NULL);
+	if (self->pos < self->size) {
+	        char value = self->data[self->pos];
+		self->pos += 1;
+		return Py_BuildValue("c", value);
+	} else {
+		PyErr_SetString(PyExc_ValueError, "read byte out of range");
+		return NULL;
+	}
+}
+
+static PyObject *
+mmap_read_line_method(mmap_object *self,
+		      PyObject *unused)
+{
+	char *start = self->data+self->pos;
+	char *eof = self->data+self->size;
+	char *eol;
+	PyObject *result;
+
+	CHECK_VALID(NULL);
+
+	eol = memchr(start, '\n', self->size - self->pos);
+	if (!eol)
+		eol = eof;
+	else
+		++eol;		/* we're interested in the position after the
+				   newline. */
+	result = PyString_FromStringAndSize(start, (eol - start));
+	self->pos += (eol - start);
+	return result;
+}
+
+static PyObject *
+mmap_read_method(mmap_object *self,
+		 PyObject *args)
+{
+	Py_ssize_t num_bytes;
+	PyObject *result;
+
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "n:read", &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)
+{
+	Py_ssize_t start = self->pos;
+	char *needle;
+	Py_ssize_t len;
+
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "s#|n:find", &needle, &len, &start)) {
+		return NULL;
+	} else {
+		char *p;
+		char *e = self->data + self->size;
+
+                if (start < 0)
+			start += self->size;
+                if (start < 0)
+			start = 0;
+                else if ((size_t)start > self->size)
+			start = self->size;
+
+		for (p = self->data + start; p + len <= e; ++p) {
+			Py_ssize_t i;
+			for (i = 0; i < len && needle[i] == p[i]; ++i)
+				/* nothing */;
+			if (i == len) {
+				return PyInt_FromSsize_t(p - self->data);
+			}
+		}
+		return PyInt_FromLong(-1);
+	}
+}
+
+static int
+is_writeable(mmap_object *self)
+{
+	if (self->access != ACCESS_READ)
+		return 1;
+	PyErr_Format(PyExc_TypeError, "mmap can't modify a readonly memory map.");
+	return 0;
+}
+
+static int
+is_resizeable(mmap_object *self)
+{
+	if ((self->access == ACCESS_WRITE) || (self->access == ACCESS_DEFAULT))
+		return 1;
+	PyErr_Format(PyExc_TypeError,
+		     "mmap can't resize a readonly or copy-on-write memory map.");
+	return 0;
+}
+
+
+static PyObject *
+mmap_write_method(mmap_object *self,
+		  PyObject *args)
+{
+	Py_ssize_t length;
+	char *data;
+
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "s#:write", &data, &length))
+		return(NULL);
+
+	if (!is_writeable(self))
+		return NULL;
+
+	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)
+{
+	char value;
+
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "c:write_byte", &value))
+		return(NULL);
+
+	if (!is_writeable(self))
+		return NULL;
+	*(self->data+self->pos) = value;
+	self->pos += 1;
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+mmap_size_method(mmap_object *self,
+		 PyObject *unused)
+{
+	CHECK_VALID(NULL);
+
+#ifdef MS_WINDOWS
+	if (self->file_handle != INVALID_HANDLE_VALUE) {
+		DWORD low,high;
+		PY_LONG_LONG size;
+		low = GetFileSize(self->file_handle, &high);
+		if (low == INVALID_FILE_SIZE) {
+			/* It might be that the function appears to have failed,
+			   when indeed its size equals INVALID_FILE_SIZE */
+			DWORD error = GetLastError();
+			if (error != NO_ERROR)
+				return PyErr_SetFromWindowsErr(error);
+		}
+		if (!high && low < LONG_MAX)
+			return PyInt_FromLong((long)low);
+		size = (((PY_LONG_LONG)high)<<32) + low;
+		return PyLong_FromLongLong(size);
+	} else {
+		return PyInt_FromSsize_t(self->size);
+	}
+#endif /* MS_WINDOWS */
+
+#ifdef UNIX
+	{
+		struct stat buf;
+		if (-1 == fstat(self->fd, &buf)) {
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
+		}
+		return PyInt_FromSsize_t(buf.st_size);
+	}
+#endif /* UNIX */
+}
+
+/* This assumes that you want the entire file mapped,
+ / and when recreating the map will make the new file
+ / have the new size
+ /
+ / Is this really necessary?  This could easily be done
+ / from python by just closing and re-opening with the
+ / new size?
+ */
+
+static PyObject *
+mmap_resize_method(mmap_object *self,
+		   PyObject *args)
+{
+	Py_ssize_t new_size;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "n:resize", &new_size) ||
+	    !is_resizeable(self)) {
+		return NULL;
+#ifdef MS_WINDOWS
+	} else {
+		DWORD dwErrCode = 0;
+		DWORD newSizeLow, newSizeHigh;
+		/* First, unmap the file view */
+		UnmapViewOfFile(self->data);
+		/* Close the mapping object */
+		CloseHandle(self->map_handle);
+		/* Move to the desired EOF position */
+#if SIZEOF_SIZE_T > 4
+		newSizeHigh = (DWORD)(new_size >> 32);
+		newSizeLow = (DWORD)(new_size & 0xFFFFFFFF);
+#else
+		newSizeHigh = 0;
+		newSizeLow = (DWORD)new_size;
+#endif
+		SetFilePointer(self->file_handle,
+			       newSizeLow, &newSizeHigh, FILE_BEGIN);
+		/* Change the size of the file */
+		SetEndOfFile(self->file_handle);
+		/* Create another mapping object and remap the file view */
+		self->map_handle = CreateFileMapping(
+			self->file_handle,
+			NULL,
+			PAGE_READWRITE,
+			newSizeHigh,
+			newSizeLow,
+			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_WINDOWS */
+
+#ifdef UNIX
+#ifndef HAVE_MREMAP
+	} else {
+		PyErr_SetString(PyExc_SystemError,
+				"mmap: resizing not available--no mremap()");
+		return NULL;
+#else
+	} else {
+		void *newmap;
+
+		if (ftruncate(self->fd, new_size) == -1) {
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
+		}
+
+#ifdef MREMAP_MAYMOVE
+		newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);
+#else
+		newmap = mremap(self->data, self->size, new_size, 0);
+#endif
+		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 /* HAVE_MREMAP */
+#endif /* UNIX */
+	}
+}
+
+static PyObject *
+mmap_tell_method(mmap_object *self, PyObject *unused)
+{
+	CHECK_VALID(NULL);
+	return PyInt_FromSize_t(self->pos);
+}
+
+static PyObject *
+mmap_flush_method(mmap_object *self, PyObject *args)
+{
+	Py_ssize_t offset = 0;
+	Py_ssize_t size = self->size;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "|nn:flush", &offset, &size))
+		return NULL;
+	if ((size_t)(offset + size) > self->size) {
+		PyErr_SetString(PyExc_ValueError, "flush values out of range");
+		return NULL;
+	} else {
+#ifdef MS_WINDOWS
+		return PyInt_FromLong((long)
+                                      FlushViewOfFile(self->data+offset, size));
+#endif /* MS_WINDOWS */
+#ifdef UNIX
+		/* XXX semantics of return value? */
+		/* XXX flags for msync? */
+		if (-1 == msync(self->data + offset, size,
+				MS_SYNC))
+		{
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
+		}
+		return PyInt_FromLong(0);
+#endif /* UNIX */
+	}
+}
+
+static PyObject *
+mmap_seek_method(mmap_object *self, PyObject *args)
+{
+	Py_ssize_t dist;
+	int how=0;
+	CHECK_VALID(NULL);
+	if (!PyArg_ParseTuple(args, "n|i:seek", &dist, &how))
+		return NULL;
+	else {
+		size_t where;
+		switch (how) {
+		case 0: /* relative to start */
+			if (dist < 0)
+				goto onoutofrange;
+			where = dist;
+			break;
+		case 1: /* relative to current position */
+			if ((Py_ssize_t)self->pos + dist < 0)
+				goto onoutofrange;
+			where = self->pos + dist;
+			break;
+		case 2: /* relative to end */
+			if ((Py_ssize_t)self->size + dist < 0)
+				goto onoutofrange;
+			where = self->size + dist;
+			break;
+		default:
+			PyErr_SetString(PyExc_ValueError, "unknown seek type");
+			return NULL;
+		}
+		if (where > self->size)
+			goto onoutofrange;
+		self->pos = where;
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+  onoutofrange:
+	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, "kkk:move", &dest, &src, &count) ||
+	    !is_writeable(self)) {
+		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;
+		}
+	}
+}
+
+static struct PyMethodDef mmap_object_methods[] = {
+	{"close",	(PyCFunction) mmap_close_method,	METH_NOARGS},
+	{"find",	(PyCFunction) mmap_find_method,		METH_VARARGS},
+	{"flush",	(PyCFunction) mmap_flush_method,	METH_VARARGS},
+	{"move",	(PyCFunction) mmap_move_method,		METH_VARARGS},
+	{"read",	(PyCFunction) mmap_read_method,		METH_VARARGS},
+	{"read_byte",	(PyCFunction) mmap_read_byte_method,  	METH_NOARGS},
+	{"readline",	(PyCFunction) mmap_read_line_method,	METH_NOARGS},
+	{"resize",	(PyCFunction) mmap_resize_method,	METH_VARARGS},
+	{"seek",	(PyCFunction) mmap_seek_method,		METH_VARARGS},
+	{"size",	(PyCFunction) mmap_size_method,		METH_NOARGS},
+	{"tell",	(PyCFunction) mmap_tell_method,		METH_NOARGS},
+	{"write",	(PyCFunction) mmap_write_method,	METH_VARARGS},
+	{"write_byte",	(PyCFunction) mmap_write_byte_method,	METH_VARARGS},
+	{NULL,	   NULL}       /* sentinel */
+};
+
+/* Functions for treating an mmap'ed file as a buffer */
+
+static Py_ssize_t
+mmap_buffer_getreadbuf(mmap_object *self, Py_ssize_t 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;
+}
+
+static Py_ssize_t
+mmap_buffer_getwritebuf(mmap_object *self, Py_ssize_t index, const void **ptr)
+{
+	CHECK_VALID(-1);
+	if (index != 0) {
+		PyErr_SetString(PyExc_SystemError,
+				"Accessing non-existent mmap segment");
+		return -1;
+	}
+	if (!is_writeable(self))
+		return -1;
+	*ptr = self->data;
+	return self->size;
+}
+
+static Py_ssize_t
+mmap_buffer_getsegcount(mmap_object *self, Py_ssize_t *lenp)
+{
+	CHECK_VALID(-1);
+	if (lenp)
+		*lenp = self->size;
+	return 1;
+}
+
+static Py_ssize_t
+mmap_buffer_getcharbuffer(mmap_object *self, Py_ssize_t 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;
+}
+
+static PyObject *
+mmap_object_getattr(mmap_object *self, char *name)
+{
+	return Py_FindMethod(mmap_object_methods, (PyObject *)self, name);
+}
+
+static Py_ssize_t
+mmap_length(mmap_object *self)
+{
+	CHECK_VALID(-1);
+	return self->size;
+}
+
+static PyObject *
+mmap_item(mmap_object *self, Py_ssize_t i)
+{
+	CHECK_VALID(NULL);
+	if (i < 0 || (size_t)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(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh)
+{
+	CHECK_VALID(NULL);
+	if (ilow < 0)
+		ilow = 0;
+	else if ((size_t)ilow > self->size)
+		ilow = self->size;
+	if (ihigh < 0)
+		ihigh = 0;
+	if (ihigh < ilow)
+		ihigh = ilow;
+	else if ((size_t)ihigh > self->size)
+		ihigh = self->size;
+
+	return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
+}
+
+static PyObject *
+mmap_concat(mmap_object *self, PyObject *bb)
+{
+	CHECK_VALID(NULL);
+	PyErr_SetString(PyExc_SystemError,
+			"mmaps don't support concatenation");
+	return NULL;
+}
+
+static PyObject *
+mmap_repeat(mmap_object *self, Py_ssize_t n)
+{
+	CHECK_VALID(NULL);
+	PyErr_SetString(PyExc_SystemError,
+			"mmaps don't support repeat operation");
+	return NULL;
+}
+
+static int
+mmap_ass_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
+{
+	const char *buf;
+
+	CHECK_VALID(-1);
+	if (ilow < 0)
+		ilow = 0;
+	else if ((size_t)ilow > self->size)
+		ilow = self->size;
+	if (ihigh < 0)
+		ihigh = 0;
+	if (ihigh < ilow)
+		ihigh = ilow;
+	else if ((size_t)ihigh > self->size)
+		ihigh = self->size;
+
+	if (v == NULL) {
+		PyErr_SetString(PyExc_TypeError,
+				"mmap object doesn't support slice deletion");
+		return -1;
+	}
+	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;
+	}
+	if (!is_writeable(self))
+		return -1;
+	buf = PyString_AsString(v);
+	memcpy(self->data + ilow, buf, ihigh-ilow);
+	return 0;
+}
+
+static int
+mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v)
+{
+	const char *buf;
+
+	CHECK_VALID(-1);
+	if (i < 0 || (size_t)i >= self->size) {
+		PyErr_SetString(PyExc_IndexError, "mmap index out of range");
+		return -1;
+	}
+	if (v == NULL) {
+		PyErr_SetString(PyExc_TypeError,
+				"mmap object doesn't support item deletion");
+		return -1;
+	}
+	if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
+		PyErr_SetString(PyExc_IndexError,
+				"mmap assignment must be single-character string");
+		return -1;
+	}
+	if (!is_writeable(self))
+		return -1;
+	buf = PyString_AsString(v);
+	self->data[i] = buf[0];
+	return 0;
+}
+
+static PySequenceMethods mmap_as_sequence = {
+	(lenfunc)mmap_length,		       /*sq_length*/
+	(binaryfunc)mmap_concat,	       /*sq_concat*/
+	(ssizeargfunc)mmap_repeat,	       /*sq_repeat*/
+	(ssizeargfunc)mmap_item,		       /*sq_item*/
+	(ssizessizeargfunc)mmap_slice,	       /*sq_slice*/
+	(ssizeobjargproc)mmap_ass_item,	       /*sq_ass_item*/
+	(ssizessizeobjargproc)mmap_ass_slice,      /*sq_ass_slice*/
+};
+
+static PyBufferProcs mmap_as_buffer = {
+	(readbufferproc)mmap_buffer_getreadbuf,
+	(writebufferproc)mmap_buffer_getwritebuf,
+	(segcountproc)mmap_buffer_getsegcount,
+	(charbufferproc)mmap_buffer_getcharbuffer,
+};
+
+static PyTypeObject mmap_object_type = {
+	PyObject_HEAD_INIT(0) /* patched in module init */
+	0,					/* ob_size */
+	"mmap.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*/
+};
+
+
+/* extract the map size from the given PyObject
+
+   Returns -1 on error, with an appropriate Python exception raised. On
+   success, the map size is returned. */
+static Py_ssize_t
+_GetMapSize(PyObject *o)
+{
+	if (PyIndex_Check(o)) {
+		Py_ssize_t i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
+		if (i==-1 && PyErr_Occurred()) 
+			return -1;
+		if (i < 0) {	 
+			PyErr_SetString(PyExc_OverflowError,
+					"memory mapped size must be positive");
+			return -1;
+		}
+		return i;
+	}
+
+	PyErr_SetString(PyExc_TypeError, "map size must be an integral value");
+	return -1;
+}
+
+#ifdef UNIX
+static PyObject *
+new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
+{
+#ifdef HAVE_FSTAT
+	struct stat st;
+#endif
+	mmap_object *m_obj;
+	PyObject *map_size_obj = NULL;
+	Py_ssize_t map_size;
+	int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
+	int devzero = -1;
+	int access = (int)ACCESS_DEFAULT;
+	static char *keywords[] = {"fileno", "length",
+                                         "flags", "prot",
+                                         "access", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii", keywords,
+					 &fd, &map_size_obj, &flags, &prot,
+                                         &access))
+		return NULL;
+	map_size = _GetMapSize(map_size_obj);
+	if (map_size < 0)
+		return NULL;
+
+	if ((access != (int)ACCESS_DEFAULT) &&
+	    ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ))))
+		return PyErr_Format(PyExc_ValueError,
+				    "mmap can't specify both access and flags, prot.");
+	switch ((access_mode)access) {
+	case ACCESS_READ:
+		flags = MAP_SHARED;
+		prot = PROT_READ;
+		break;
+	case ACCESS_WRITE:
+		flags = MAP_SHARED;
+		prot = PROT_READ | PROT_WRITE;
+		break;
+	case ACCESS_COPY:
+		flags = MAP_PRIVATE;
+		prot = PROT_READ | PROT_WRITE;
+		break;
+	case ACCESS_DEFAULT:
+		/* use the specified or default values of flags and prot */
+		break;
+	default:
+		return PyErr_Format(PyExc_ValueError,
+				    "mmap invalid access parameter.");
+	}
+
+#ifdef HAVE_FSTAT
+#  ifdef __VMS
+	/* on OpenVMS we must ensure that all bytes are written to the file */
+	fsync(fd);
+#  endif
+	if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
+		if (map_size == 0) {
+			map_size = st.st_size;
+		} else if ((size_t)map_size > st.st_size) {
+			PyErr_SetString(PyExc_ValueError,
+					"mmap length is greater than file size");
+			return NULL;
+		}
+	}
+#endif
+	m_obj = PyObject_New(mmap_object, &mmap_object_type);
+	if (m_obj == NULL) {return NULL;}
+	m_obj->data = NULL;
+	m_obj->size = (size_t) map_size;
+	m_obj->pos = (size_t) 0;
+	if (fd == -1) {
+		m_obj->fd = -1;
+		/* Assume the caller wants to map anonymous memory.
+		   This is the same behaviour as Windows.  mmap.mmap(-1, size)
+		   on both Windows and Unix map anonymous memory.
+		*/
+#ifdef MAP_ANONYMOUS
+		/* BSD way to map anonymous memory */
+		flags |= MAP_ANONYMOUS;
+#else
+		/* SVR4 method to map anonymous memory is to open /dev/zero */
+		fd = devzero = open("/dev/zero", O_RDWR);
+		if (devzero == -1) {
+			Py_DECREF(m_obj);
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
+		}
+#endif
+	} else {
+		m_obj->fd = dup(fd);
+		if (m_obj->fd == -1) {
+			Py_DECREF(m_obj);
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
+		}
+	}
+
+	m_obj->data = mmap(NULL, map_size,
+			   prot, flags,
+			   fd, 0);
+
+	if (devzero != -1) {
+		close(devzero);
+	}
+
+	if (m_obj->data == (char *)-1) {
+	        m_obj->data = NULL;
+		Py_DECREF(m_obj);
+		PyErr_SetFromErrno(mmap_module_error);
+		return NULL;
+	}
+	m_obj->access = (access_mode)access;
+	return (PyObject *)m_obj;
+}
+#endif /* UNIX */
+
+#ifdef MS_WINDOWS
+static PyObject *
+new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
+{
+	mmap_object *m_obj;
+	PyObject *map_size_obj = NULL;
+	Py_ssize_t map_size;
+	DWORD size_hi;	/* upper 32 bits of m_obj->size */
+	DWORD size_lo;	/* lower 32 bits of m_obj->size */
+	char *tagname = "";
+	DWORD dwErr = 0;
+	int fileno;
+	HANDLE fh = 0;
+	int access = (access_mode)ACCESS_DEFAULT;
+	DWORD flProtect, dwDesiredAccess;
+	static char *keywords[] = { "fileno", "length",
+                                          "tagname",
+                                          "access", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|zi", keywords,
+					 &fileno, &map_size_obj,
+					 &tagname, &access)) {
+		return NULL;
+	}
+
+	switch((access_mode)access) {
+	case ACCESS_READ:
+		flProtect = PAGE_READONLY;
+		dwDesiredAccess = FILE_MAP_READ;
+		break;
+	case ACCESS_DEFAULT:  case ACCESS_WRITE:
+		flProtect = PAGE_READWRITE;
+		dwDesiredAccess = FILE_MAP_WRITE;
+		break;
+	case ACCESS_COPY:
+		flProtect = PAGE_WRITECOPY;
+		dwDesiredAccess = FILE_MAP_COPY;
+		break;
+	default:
+		return PyErr_Format(PyExc_ValueError,
+				    "mmap invalid access parameter.");
+	}
+
+	map_size = _GetMapSize(map_size_obj);
+	if (map_size < 0)
+		return NULL;
+
+	/* assume -1 and 0 both mean invalid filedescriptor
+	   to 'anonymously' map memory.
+	   XXX: fileno == 0 is a valid fd, but was accepted prior to 2.5.
+	   XXX: Should this code be added?
+	   if (fileno == 0)
+	   	PyErr_Warn(PyExc_DeprecationWarning,
+			   "don't use 0 for anonymous memory");
+	 */
+	if (fileno != -1 && fileno != 0) {
+		fh = (HANDLE)_get_osfhandle(fileno);
+		if (fh==(HANDLE)-1) {
+			PyErr_SetFromErrno(mmap_module_error);
+			return NULL;
+		}
+		/* Win9x appears to need us seeked to zero */
+		lseek(fileno, 0, SEEK_SET);
+	}
+
+	m_obj = PyObject_New(mmap_object, &mmap_object_type);
+	if (m_obj == NULL)
+		return NULL;
+	/* Set every field to an invalid marker, so we can safely
+	   destruct the object in the face of failure */
+	m_obj->data = NULL;
+	m_obj->file_handle = INVALID_HANDLE_VALUE;
+	m_obj->map_handle = INVALID_HANDLE_VALUE;
+	m_obj->tagname = NULL;
+
+	if (fh) {
+		/* It is necessary to duplicate the handle, so the
+		   Python code can close it on us */
+		if (!DuplicateHandle(
+			GetCurrentProcess(), /* source process handle */
+			fh, /* handle to be duplicated */
+			GetCurrentProcess(), /* target proc handle */
+			(LPHANDLE)&m_obj->file_handle, /* result */
+			0, /* access - ignored due to options value */
+			FALSE, /* inherited by child processes? */
+			DUPLICATE_SAME_ACCESS)) { /* options */
+			dwErr = GetLastError();
+			Py_DECREF(m_obj);
+			PyErr_SetFromWindowsErr(dwErr);
+			return NULL;
+		}
+		if (!map_size) {
+			DWORD low,high;
+			low = GetFileSize(fh, &high);
+			/* low might just happen to have the value INVALID_FILE_SIZE;
+    			   so we need to check the last error also. */
+			if (low == INVALID_FILE_SIZE &&
+			    (dwErr = GetLastError()) != NO_ERROR) {
+				Py_DECREF(m_obj);
+				return PyErr_SetFromWindowsErr(dwErr);
+			}	
+				    
+#if SIZEOF_SIZE_T > 4
+			m_obj->size = (((size_t)high)<<32) + low;
+#else
+			if (high)
+				/* File is too large to map completely */
+				m_obj->size = (size_t)-1;
+			else
+				m_obj->size = low;
+#endif
+		} else {
+			m_obj->size = map_size;
+		}
+	}
+	else {
+		m_obj->size = map_size;
+	}
+
+	/* set the initial position */
+	m_obj->pos = (size_t) 0;
+
+	/* set the tag name */
+	if (tagname != NULL && *tagname != '\0') {
+		m_obj->tagname = PyMem_Malloc(strlen(tagname)+1);
+		if (m_obj->tagname == NULL) {
+			PyErr_NoMemory();
+			Py_DECREF(m_obj);
+			return NULL;
+		}
+		strcpy(m_obj->tagname, tagname);
+	}
+	else
+		m_obj->tagname = NULL;
+
+	m_obj->access = (access_mode)access;
+	/* DWORD is a 4-byte int.  If we're on a box where size_t consumes
+	 * more than 4 bytes, we need to break it apart.  Else (size_t
+	 * consumes 4 bytes), C doesn't define what happens if we shift
+	 * right by 32, so we need different code.
+	 */
+#if SIZEOF_SIZE_T > 4
+	size_hi = (DWORD)(m_obj->size >> 32);
+	size_lo = (DWORD)(m_obj->size & 0xFFFFFFFF);
+#else
+	size_hi = 0;
+	size_lo = (DWORD)m_obj->size;
+#endif
+	m_obj->map_handle = CreateFileMapping(m_obj->file_handle,
+					      NULL,
+					      flProtect,
+					      size_hi,
+					      size_lo,
+					      m_obj->tagname);
+	if (m_obj->map_handle != NULL) {
+		m_obj->data = (char *) MapViewOfFile(m_obj->map_handle,
+						     dwDesiredAccess,
+						     0,
+						     0,
+						     0);
+		if (m_obj->data != NULL)
+			return (PyObject *)m_obj;
+		else
+			dwErr = GetLastError();
+	} else
+		dwErr = GetLastError();
+	Py_DECREF(m_obj);
+	PyErr_SetFromWindowsErr(dwErr);
+	return NULL;
+}
+#endif /* MS_WINDOWS */
+
+/* List of functions exported by this module */
+static struct PyMethodDef mmap_functions[] = {
+	{"mmap",	(PyCFunction) new_mmap_object,
+	 METH_VARARGS|METH_KEYWORDS},
+	{NULL,		NULL}	     /* Sentinel */
+};
+
+static void
+setint(PyObject *d, const char *name, long value)
+{
+	PyObject *o = PyInt_FromLong(value);
+	if (o && PyDict_SetItemString(d, name, o) == 0) {
+		Py_DECREF(o);
+	}
+}
+
+PyMODINIT_FUNC
+	initmmap(void)
+{
+	PyObject *dict, *module;
+
+	/* Patch the object type */
+	mmap_object_type.ob_type = &PyType_Type;
+
+	module = Py_InitModule("mmap", mmap_functions);
+	if (module == NULL)
+		return;
+	dict = PyModule_GetDict(module);
+	if (!dict)
+		return;
+	mmap_module_error = PyExc_EnvironmentError;
+	PyDict_SetItemString(dict, "error", mmap_module_error);
+#ifdef PROT_EXEC
+	setint(dict, "PROT_EXEC", PROT_EXEC);
+#endif
+#ifdef PROT_READ
+	setint(dict, "PROT_READ", PROT_READ);
+#endif
+#ifdef PROT_WRITE
+	setint(dict, "PROT_WRITE", PROT_WRITE);
+#endif
+
+#ifdef MAP_SHARED
+	setint(dict, "MAP_SHARED", MAP_SHARED);
+#endif
+#ifdef MAP_PRIVATE
+	setint(dict, "MAP_PRIVATE", MAP_PRIVATE);
+#endif
+#ifdef MAP_DENYWRITE
+	setint(dict, "MAP_DENYWRITE", MAP_DENYWRITE);
+#endif
+#ifdef MAP_EXECUTABLE
+	setint(dict, "MAP_EXECUTABLE", MAP_EXECUTABLE);
+#endif
+#ifdef MAP_ANONYMOUS
+	setint(dict, "MAP_ANON", MAP_ANONYMOUS);
+	setint(dict, "MAP_ANONYMOUS", MAP_ANONYMOUS);
+#endif
+
+	setint(dict, "PAGESIZE", (long)my_getpagesize());
+
+	setint(dict, "ACCESS_READ", ACCESS_READ);
+	setint(dict, "ACCESS_WRITE", ACCESS_WRITE);
+	setint(dict, "ACCESS_COPY", ACCESS_COPY);
+}