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

}

static int

my_getallocationgranularity (void)

{

SYSTEM_INFO si;

GetSystemInfo(&si);

return si.dwAllocationGranularity;

}

#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_getallocationgranularity my_getpagesize

#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; /* relative to offset */

size_t offset;

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

Py_TYPE(m_obj)->tp_free((PyObject*)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_gfind(mmap_object *self,

PyObject *args,

int reverse)

{

Py_ssize_t start = self->pos;

Py_ssize_t end = self->size;

const char *needle;

Py_ssize_t len;

CHECK_VALID(NULL);

if (!PyArg_ParseTuple(args, reverse ? "s#|nn:rfind" : "s#|nn:find",

&needle, &len, &start, &end)) {

return NULL;

} else {

const char *p, *start_p, *end_p;

int sign = reverse ? -1 : 1;

if (start < 0)

start += self->size;

if (start < 0)

start = 0;

else if ((size_t)start > self->size)

start = self->size;

if (end < 0)

end += self->size;

if (end < 0)

end = 0;

else if ((size_t)end > self->size)

end = self->size;

start_p = self->data + start;

end_p = self->data + end;

for (p = (reverse ? end_p - len : start_p);

(p >= start_p) && (p + len <= end_p); p += sign) {

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

mmap_find_method(mmap_object *self,

PyObject *args)

{

return mmap_gfind(self, args, 0);

}

static PyObject *

mmap_rfind_method(mmap_object *self,

PyObject *args)

{

return mmap_gfind(self, args, 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 off_hi, off_lo, 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)((self->offset + new_size) >> 32);

newSizeLow = (DWORD)((self->offset + new_size) & 0xFFFFFFFF);

off_hi = (DWORD)(self->offset >> 32);

off_lo = (DWORD)(self->offset & 0xFFFFFFFF);

newSizeHigh = 0;

newSizeLow = (DWORD)new_size;

off_hi = 0;

off_lo = (DWORD)self->offset;

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,

0,

0,

self->tagname);

if (self->map_handle != NULL) {

self->data = (char *) MapViewOfFile(self->map_handle,

FILE_MAP_WRITE,

off_hi,

off_lo,

new_size);

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;

}

#ifdef MS_WINDOWS

return PyInt_FromLong((long) FlushViewOfFile(self->data+offset, size));

#elif defined(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);

PyErr_SetString(PyExc_ValueError, "flush not supported on this system");

return NULL;

}

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

{"rfind", (PyCFunction) mmap_rfind_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 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_subscript(mmap_object *self, PyObject *item)

{

CHECK_VALID(NULL);

if (PyIndex_Check(item)) {

Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);

if (i == -1 && PyErr_Occurred())

return NULL;

if (i < 0)

i += self->size;

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

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelen;

if (PySlice_GetIndicesEx((PySliceObject *)item, self->size,

&start, &stop, &step, &slicelen) < 0) {

return NULL;

}

if (slicelen <= 0)

return PyString_FromStringAndSize("", 0);

else if (step == 1)

return PyString_FromStringAndSize(self->data + start,

slicelen);

else {

char *result_buf = (char *)PyMem_Malloc(slicelen);

Py_ssize_t cur, i;

PyObject *result;

if (result_buf == NULL)

return PyErr_NoMemory();

for (cur = start, i = 0; i < slicelen;

cur += step, i++) {

result_buf[i] = self->data[cur];

}

result = PyString_FromStringAndSize(result_buf,

slicelen);

PyMem_Free(result_buf);

return result;

}

}

else {

PyErr_SetString(PyExc_TypeError,

"mmap indices must be integers");

return NULL;

}

}

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 int

mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value)

{

CHECK_VALID(-1);

if (PyIndex_Check(item)) {

Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);

const char *buf;

if (i == -1 && PyErr_Occurred())

return -1;

if (i < 0)

i += self->size;

if (i < 0 || (size_t)i > self->size) {

PyErr_SetString(PyExc_IndexError,

"mmap index out of range");

return -1;

}

if (value == NULL) {

PyErr_SetString(PyExc_TypeError,

"mmap object doesn't support item deletion");

return -1;

}

if (!PyString_Check(value) || PyString_Size(value) != 1) {

PyErr_SetString(PyExc_IndexError,

"mmap assignment must be single-character string");

return -1;

}

if (!is_writeable(self))

return -1;

buf = PyString_AsString(value);

self->data[i] = buf[0];

return 0;

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelen;

if (PySlice_GetIndicesEx((PySliceObject *)item,

self->size, &start, &stop,

&step, &slicelen) < 0) {

return -1;

}

if (value == NULL) {

PyErr_SetString(PyExc_TypeError,

"mmap object doesn't support slice deletion");

return -1;

}

if (!PyString_Check(value)) {

PyErr_SetString(PyExc_IndexError,

"mmap slice assignment must be a string");

return -1;

}

if (PyString_Size(value) != slicelen) {

PyErr_SetString(PyExc_IndexError,

"mmap slice assignment is wrong size");

return -1;

}

if (!is_writeable(self))

return -1;

if (slicelen == 0)

return 0;

else if (step == 1) {

const char *buf = PyString_AsString(value);

if (buf == NULL)

return -1;

memcpy(self->data + start, buf, slicelen);

return 0;

}

else {

Py_ssize_t cur, i;

const char *buf = PyString_AsString(value);

if (buf == NULL)

return -1;

for (cur = start, i = 0; i < slicelen;

cur += step, i++) {

self->data[cur] = buf[i];

}

return 0;

}

}

else {

PyErr_SetString(PyExc_TypeError,

"mmap indices must be integer");

return -1;

}

}

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 PyMappingMethods mmap_as_mapping = {

(lenfunc)mmap_length,

(binaryfunc)mmap_subscript,

(objobjargproc)mmap_ass_subscript,

};

static PyBufferProcs mmap_as_buffer = {

(readbufferproc)mmap_buffer_getreadbuf,

(writebufferproc)mmap_buffer_getwritebuf,

(segcountproc)mmap_buffer_getsegcount,

(charbufferproc)mmap_buffer_getcharbuffer,

};

static PyObject *

new_mmap_object(PyTypeObject *type, PyObject *args, PyObject *kwdict);

PyDoc_STRVAR(mmap_doc,

To map anonymous memory, pass -1 as the fileno (both versions).");