#define PY_SSIZE_T_CLEAN

#include <Python.h>

#ifndef MS_WINDOWS

#define UNIX

#ifdef MS_WINDOWS

#include <windows.h>

static int

my_getpagesize(void)

{

SYSTEM_INFO si;

GetSystemInfo(&si);

return si.dwPageSize;

}

#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);

}

#define my_getpagesize getpagesize

#endif /* UNIX */

#include <string.h>

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */

#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)

# define MAP_ANONYMOUS MAP_ANON

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;

#ifdef UNIX

int fd;

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

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;

}

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

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 (num_bytes > self->size - self->pos) {

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,

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 */

}

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);

newSizeHigh = 0;

newSizeLow = (DWORD)new_size;

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 {

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);

newmap = mremap(self->data, self->size, new_size, 0);

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 */

};

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*/

};

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;

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.");

}

if (prot == PROT_READ) {

access = ACCESS_READ;

}

#ifdef HAVE_FSTAT

# ifdef __VMS

/* on OpenVMS we must ensure that all bytes are written to the file */

fsync(fd);

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;

}

}

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.

#ifdef MAP_ANONYMOUS

/* BSD way to map anonymous memory */

flags |= MAP_ANONYMOUS;

/* 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;

}

} 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;