#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include "structmember.h"

#ifndef MS_WINDOWS

#define UNIX

# ifdef HAVE_FCNTL_H

# include <fcntl.h>

# endif /* HAVE_FCNTL_H */

#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

typedef enum

{

ACCESS_DEFAULT,

ACCESS_READ,

ACCESS_WRITE,

ACCESS_COPY

} access_mode;

typedef struct {

PyObject_HEAD

char * data;

Py_ssize_t size;

Py_ssize_t pos; /* relative to offset */

#ifdef MS_WINDOWS

long long offset;

off_t offset;

int exports;

#ifdef MS_WINDOWS

HANDLE map_handle;

HANDLE file_handle;

char * tagname;

#ifdef UNIX

int fd;

PyObject *weakreflist;

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 != NULL)

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

munmap(m_obj->data, m_obj->size);

}

#endif /* UNIX */

if (m_obj->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) m_obj);

Py_TYPE(m_obj)->tp_free((PyObject*)m_obj);

}

static PyObject *

mmap_close_method(mmap_object *self, PyObject *unused)

{

if (self->exports > 0) {

PyErr_SetString(PyExc_BufferError, "cannot close "\

"exported pointers exist");

return NULL;

}

#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 != NULL) {

CloseHandle(self->map_handle);

self->map_handle = NULL;

}

if (self->file_handle != INVALID_HANDLE_VALUE) {

CloseHandle(self->file_handle);

self->file_handle = INVALID_HANDLE_VALUE;

}

#endif /* MS_WINDOWS */

#ifdef UNIX

if (0 <= self->fd)

(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 == NULL) { \

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

PyErr_SetString(PyExc_ValueError, "read byte out of range");

return NULL;

}

return PyLong_FromLong((unsigned char)self->data[self->pos++]);

}

static PyObject *

mmap_read_line_method(mmap_object *self,

PyObject *unused)

{

Py_ssize_t remaining;

char *start, *eol;

PyObject *result;

CHECK_VALID(NULL);

remaining = (self->pos < self->size) ? self->size - self->pos : 0;

if (!remaining)

return PyBytes_FromString("");

start = self->data + self->pos;

eol = memchr(start, '\n', remaining);

if (!eol)

eol = self->data + self->size;

else

++eol; /* advance past newline */

result = PyBytes_FromStringAndSize(start, (eol - start));

self->pos += (eol - start);

return result;

}

static int

mmap_convert_ssize_t(PyObject *obj, void *result) {

Py_ssize_t limit;

if (obj == Py_None) {

limit = -1;

}

else if (PyNumber_Check(obj)) {

limit = PyNumber_AsSsize_t(obj, PyExc_OverflowError);

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

return 0;

}

else {

PyErr_Format(PyExc_TypeError,

"integer argument expected, got '%.200s'",

Py_TYPE(obj)->tp_name);

return 0;

}

*((Py_ssize_t *)result) = limit;

return 1;

}

static PyObject *

mmap_read_method(mmap_object *self,

PyObject *args)

{

Py_ssize_t num_bytes = PY_SSIZE_T_MAX, remaining;

PyObject *result;

CHECK_VALID(NULL);

if (!PyArg_ParseTuple(args, "|O&:read", mmap_convert_ssize_t, &num_bytes))

return(NULL);

/* silently 'adjust' out-of-range requests */

remaining = (self->pos < self->size) ? self->size - self->pos : 0;

if (num_bytes < 0 || num_bytes > remaining)

num_bytes = remaining;

result = PyBytes_FromStringAndSize(&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;

Py_buffer view;

CHECK_VALID(NULL);

if (!PyArg_ParseTuple(args, reverse ? "y*|nn:rfind" : "y*|nn:find",

&view, &start, &end)) {

return NULL;

} else {

const char *p, *start_p, *end_p;

int sign = reverse ? -1 : 1;

const char *needle = view.buf;

Py_ssize_t len = view.len;

if (start < 0)

start += self->size;

if (start < 0)

start = 0;

else if (start > self->size)

start = self->size;

if (end < 0)

end += self->size;

if (end < 0)

end = 0;

else if (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) {

PyBuffer_Release(&view);

return PyLong_FromSsize_t(p - self->data);

}

}

PyBuffer_Release(&view);

return PyLong_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_writable(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->exports > 0) {

PyErr_SetString(PyExc_BufferError,

"mmap can't resize with extant buffers exported.");

return 0;

}

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_buffer data;

CHECK_VALID(NULL);

if (!PyArg_ParseTuple(args, "y*:write", &data))

return(NULL);

if (!is_writable(self)) {

PyBuffer_Release(&data);

return NULL;

}

if (self->pos > self->size || self->size - self->pos < data.len) {

PyBuffer_Release(&data);

PyErr_SetString(PyExc_ValueError, "data out of range");

return NULL;

}

memcpy(&self->data[self->pos], data.buf, data.len);

self->pos += data.len;

PyBuffer_Release(&data);

return PyLong_FromSsize_t(data.len);

}

static PyObject *

mmap_write_byte_method(mmap_object *self,

PyObject *args)

{

char value;

CHECK_VALID(NULL);

if (!PyArg_ParseTuple(args, "b:write_byte", &value))

return(NULL);

if (!is_writable(self))

return NULL;

if (self->pos < self->size) {

self->data[self->pos++] = value;

Py_INCREF(Py_None);

return Py_None;

}

else {

PyErr_SetString(PyExc_ValueError, "write byte out of range");

return NULL;

}

}

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;

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 PyLong_FromLong((long)low);

size = (((long long)high)<<32) + low;

return PyLong_FromLongLong(size);

} else {

return PyLong_FromSsize_t(self->size);

}

#endif /* MS_WINDOWS */

#ifdef UNIX

{

struct _Py_stat_struct status;

if (_Py_fstat(self->fd, &status) == -1)

return NULL;

#ifdef HAVE_LARGEFILE_SUPPORT

return PyLong_FromLongLong(status.st_size);

return PyLong_FromLong(status.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;

}

if (new_size < 0 || PY_SSIZE_T_MAX - new_size < self->offset) {

PyErr_SetString(PyExc_ValueError, "new size out of range");

return NULL;

}

{

#ifdef MS_WINDOWS

DWORD dwErrCode = 0;

DWORD off_hi, off_lo, newSizeLow, newSizeHigh;

/* First, unmap the file view */

UnmapViewOfFile(self->data);

self->data = NULL;

/* Close the mapping object */

CloseHandle(self->map_handle);

self->map_handle = NULL;

/* Move to the desired EOF position */

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

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

CloseHandle(self->map_handle);

self->map_handle = NULL;

}

} else {

dwErrCode = GetLastError();

}

PyErr_SetFromWindowsErr(dwErrCode);

return NULL;

#endif /* MS_WINDOWS */

#ifdef UNIX

#ifndef HAVE_MREMAP

PyErr_SetString(PyExc_SystemError,

"mmap: resizing not available--no mremap()");

return NULL;

void *newmap;

if (self->fd != -1 && ftruncate(self->fd, self->offset + new_size) == -1) {

PyErr_SetFromErrno(PyExc_OSError);

return NULL;

}

#ifdef MREMAP_MAYMOVE

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

#if defined(__NetBSD__)

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

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

#endif /* __NetBSD__ */

if (newmap == (void *)-1)

{

PyErr_SetFromErrno(PyExc_OSError);

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 PyLong_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 < 0 || offset < 0 || self->size - offset < size) {

PyErr_SetString(PyExc_ValueError, "flush values out of range");

return NULL;

}

if (self->access == ACCESS_READ || self->access == ACCESS_COPY)

return PyLong_FromLong(0);

#ifdef MS_WINDOWS

return PyLong_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(PyExc_OSError);

return NULL;

}

return PyLong_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 {

Py_ssize_t where;

switch (how) {

case 0: /* relative to start */

where = dist;

break;

case 1: /* relative to current position */

if (PY_SSIZE_T_MAX - self->pos < dist)

goto onoutofrange;

where = self->pos + dist;

break;

case 2: /* relative to end */

if (PY_SSIZE_T_MAX - self->size < dist)

goto onoutofrange;

where = self->size + dist;

break;

default:

PyErr_SetString(PyExc_ValueError, "unknown seek type");

return NULL;

}

if (where > self->size || where < 0)

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)

{

Py_ssize_t dest, src, cnt;

CHECK_VALID(NULL);

if (!PyArg_ParseTuple(args, "nnn:move", &dest, &src, &cnt) ||

!is_writable(self)) {

return NULL;

} else {

/* bounds check the values */

if (dest < 0 || src < 0 || cnt < 0)

goto bounds;

if (self->size - dest < cnt || self->size - src < cnt)

goto bounds;

memmove(&self->data[dest], &self->data[src], cnt);

Py_INCREF(Py_None);

return Py_None;

bounds:

PyErr_SetString(PyExc_ValueError,

"source, destination, or count out of range");

return NULL;

}

}

static PyObject *

mmap_closed_get(mmap_object *self)

{

#ifdef MS_WINDOWS

return PyBool_FromLong(self->map_handle == NULL ? 1 : 0);

#elif defined(UNIX)

return PyBool_FromLong(self->data == NULL ? 1 : 0);

}

static PyObject *

mmap__enter__method(mmap_object *self, PyObject *args)

{

CHECK_VALID(NULL);

Py_INCREF(self);

return (PyObject *)self;

}

static PyObject *

mmap__exit__method(PyObject *self, PyObject *args)

{

_Py_IDENTIFIER(close);

return _PyObject_CallMethodId(self, &PyId_close, NULL);

}

#ifdef MS_WINDOWS

static PyObject *

mmap__sizeof__method(mmap_object *self, void *unused)

{

Py_ssize_t res;

res = _PyObject_SIZE(Py_TYPE(self));

if (self->tagname)

res += strlen(self->tagname) + 1;

return PyLong_FromSsize_t(res);

}

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

{"__enter__", (PyCFunction) mmap__enter__method, METH_NOARGS},

{"__exit__", (PyCFunction) mmap__exit__method, METH_VARARGS},

#ifdef MS_WINDOWS

{"__sizeof__", (PyCFunction) mmap__sizeof__method, METH_NOARGS},

{NULL, NULL} /* sentinel */

};

static PyGetSetDef mmap_object_getset[] = {

{"closed", (getter) mmap_closed_get, NULL, NULL},

{NULL}

};

static int

mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags)

{

CHECK_VALID(-1);

if (PyBuffer_FillInfo(view, (PyObject*)self, self->data, self->size,

(self->access == ACCESS_READ), flags) < 0)

return -1;

self->exports++;

return 0;

}

static void

mmap_buffer_releasebuf(mmap_object *self, Py_buffer *view)

{

self->exports--;

}

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 || i >= self->size) {

PyErr_SetString(PyExc_IndexError, "mmap index out of range");

return NULL;

}

return PyBytes_FromStringAndSize(self->data + i, 1);

}

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 || i >= self->size) {

PyErr_SetString(PyExc_IndexError,

"mmap index out of range");

return NULL;

}

return PyLong_FromLong(Py_CHARMASK(self->data[i]));

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelen;

if (PySlice_Unpack(item, &start, &stop, &step) < 0) {

return NULL;

}

slicelen = PySlice_AdjustIndices(self->size, &start, &stop, step);

if (slicelen <= 0)

return PyBytes_FromStringAndSize("", 0);

else if (step == 1)

return PyBytes_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 = PyBytes_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_item(mmap_object *self, Py_ssize_t i, PyObject *v)

{

const char *buf;

CHECK_VALID(-1);

if (i < 0 || 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 (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) {

PyErr_SetString(PyExc_IndexError,

"mmap assignment must be length-1 bytes()");

return -1;

}

if (!is_writable(self))

return -1;

buf = PyBytes_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 (!is_writable(self))

return -1;

if (PyIndex_Check(item)) {

Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);

Py_ssize_t v;

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

return -1;

if (i < 0)

i += self->size;

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

PyErr_SetString(PyExc_IndexError,

"mmap index out of range");

return -1;

}

if (value == NULL) {

PyErr_SetString(PyExc_TypeError,

"mmap doesn't support item deletion");

return -1;

}

if (!PyIndex_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"mmap item value must be an int");

return -1;

}

v = PyNumber_AsSsize_t(value, PyExc_TypeError);

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

return -1;

if (v < 0 || v > 255) {

PyErr_SetString(PyExc_ValueError,

"mmap item value must be "

"in range(0, 256)");

return -1;

}

self->data[i] = (char) v;

return 0;

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelen;

Py_buffer vbuf;

if (PySlice_Unpack(item, &start, &stop, &step) < 0) {

return -1;

}

slicelen = PySlice_AdjustIndices(self->size, &start, &stop, step);

if (value == NULL) {

PyErr_SetString(PyExc_TypeError,

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

return -1;

}

if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0)

return -1;

if (vbuf.len != slicelen) {

PyErr_SetString(PyExc_IndexError,

"mmap slice assignment is wrong size");

PyBuffer_Release(&vbuf);

return -1;

}

if (slicelen == 0) {

}

else if (step == 1) {

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

}

else {

Py_ssize_t cur, i;

for (cur = start, i = 0;

i < slicelen;

cur += step, i++)

{

self->data[cur] = ((char *)vbuf.buf)[i];

}

}

PyBuffer_Release(&vbuf);

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

0, /*sq_slice*/

(ssizeobjargproc)mmap_ass_item, /*sq_ass_item*/

0, /*sq_ass_slice*/

};

static PyMappingMethods mmap_as_mapping = {

(lenfunc)mmap_length,

(binaryfunc)mmap_subscript,

(objobjargproc)mmap_ass_subscript,

};

static PyBufferProcs mmap_as_buffer = {

(getbufferproc)mmap_buffer_getbuf,

(releasebufferproc)mmap_buffer_releasebuf,

};

static PyObject *

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