#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include "structmember.h" // PyMemberDef

#include <stddef.h> // offsetof()

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

Py_ssize_t exports;

#ifdef MS_WINDOWS

HANDLE map_handle;

HANDLE file_handle;

char * tagname;

#ifdef UNIX

int fd;

PyObject *weakreflist;

access_mode access;

} mmap_object;

typedef struct {

PyTypeObject *mmap_object_type;

} mmap_state;

static mmap_state *

get_mmap_state(PyObject *module)

{

mmap_state *state = PyModule_GetState(module);

assert(state);

return state;

}

static int

mmap_object_traverse(mmap_object *m_obj, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(m_obj));

return 0;

}

static void

mmap_object_dealloc(mmap_object *m_obj)

{

PyTypeObject *tp = Py_TYPE(m_obj);

PyObject_GC_UnTrack(m_obj);

#ifdef MS_WINDOWS

Py_BEGIN_ALLOW_THREADS

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

Py_END_ALLOW_THREADS

if (m_obj->tagname)

PyMem_Free(m_obj->tagname);

#endif /* MS_WINDOWS */

#ifdef UNIX

Py_BEGIN_ALLOW_THREADS

if (m_obj->fd >= 0)

(void) close(m_obj->fd);

if (m_obj->data!=NULL) {

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

}

Py_END_ALLOW_THREADS

#endif /* UNIX */

if (m_obj->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) m_obj);

tp->tp_free(m_obj);

Py_DECREF(tp);

}

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

HANDLE map_handle = self->map_handle;

HANDLE file_handle = self->file_handle;

char *data = self->data;

self->map_handle = NULL;

self->file_handle = INVALID_HANDLE_VALUE;

self->data = NULL;

Py_BEGIN_ALLOW_THREADS

if (data != NULL) {

UnmapViewOfFile(data);

}

if (map_handle != NULL) {

CloseHandle(map_handle);

}

if (file_handle != INVALID_HANDLE_VALUE) {

CloseHandle(file_handle);

}

Py_END_ALLOW_THREADS

#endif /* MS_WINDOWS */

#ifdef UNIX

int fd = self->fd;

char *data = self->data;

self->fd = -1;

self->data = NULL;

Py_BEGIN_ALLOW_THREADS

if (0 <= fd)

(void) close(fd);

if (data != NULL) {

munmap(data, self->size);

}

Py_END_ALLOW_THREADS

Py_RETURN_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 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", _Py_convert_optional_to_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_RETURN_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_RETURN_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_RETURN_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)

Py_RETURN_NONE;

#ifdef MS_WINDOWS

if (!FlushViewOfFile(self->data+offset, size)) {

PyErr_SetFromWindowsErr(GetLastError());

return NULL;

}

Py_RETURN_NONE;

#elif defined(UNIX)

/* XXX flags for msync? */

if (-1 == msync(self->data + offset, size, MS_SYNC)) {

PyErr_SetFromErrno(PyExc_OSError);

return NULL;

}

Py_RETURN_NONE;

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_RETURN_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_RETURN_NONE;

bounds:

PyErr_SetString(PyExc_ValueError,

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

return NULL;

}

}

static PyObject *

mmap_closed_get(mmap_object *self, void *Py_UNUSED(ignored))

{

#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_CallMethodIdNoArgs(self, &PyId_close);

}

static PyObject *

mmap__repr__method(PyObject *self)

{

mmap_object *mobj = (mmap_object *)self;

#ifdef MS_WINDOWS

#define _Py_FORMAT_OFFSET "lld"

if (mobj->map_handle == NULL)

#elif defined(UNIX)

# ifdef HAVE_LARGEFILE_SUPPORT

# define _Py_FORMAT_OFFSET "lld"

# define _Py_FORMAT_OFFSET "ld"

if (mobj->data == NULL)

{

return PyUnicode_FromFormat("<%s closed=True>", Py_TYPE(self)->tp_name);

} else {

const char *access_str;

switch (mobj->access) {

case ACCESS_DEFAULT:

access_str = "ACCESS_DEFAULT";

break;

case ACCESS_READ:

access_str = "ACCESS_READ";

break;

case ACCESS_WRITE:

access_str = "ACCESS_WRITE";

break;

case ACCESS_COPY:

access_str = "ACCESS_COPY";

break;

default:

Py_UNREACHABLE();

}

return PyUnicode_FromFormat("<%s closed=False, access=%s, length=%zd, "

"pos=%zd, offset=%" _Py_FORMAT_OFFSET ">",

Py_TYPE(self)->tp_name, access_str,

mobj->size, mobj->pos, mobj->offset);

}

}

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

}

#ifdef HAVE_MADVISE

static PyObject *

mmap_madvise_method(mmap_object *self, PyObject *args)

{

int option;

Py_ssize_t start = 0, length;

CHECK_VALID(NULL);

length = self->size;

if (!PyArg_ParseTuple(args, "i|nn:madvise", &option, &start, &length)) {

return NULL;

}

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

PyErr_SetString(PyExc_ValueError, "madvise start out of bounds");

return NULL;

}

if (length < 0) {

PyErr_SetString(PyExc_ValueError, "madvise length invalid");

return NULL;

}

if (PY_SSIZE_T_MAX - start < length) {

PyErr_SetString(PyExc_OverflowError, "madvise length too large");

return NULL;

}

if (start + length > self->size) {

length = self->size - start;

}

if (madvise(self->data + start, length, option) != 0) {

PyErr_SetFromErrno(PyExc_OSError);

return NULL;

}

Py_RETURN_NONE;

}

#endif // HAVE_MADVISE

static struct PyMemberDef mmap_object_members[] = {

{"__weaklistoffset__", T_PYSSIZET, offsetof(mmap_object, weakreflist), READONLY},

{NULL},

};

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

#ifdef HAVE_MADVISE

{"madvise", (PyCFunction) mmap_madvise_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);

size_t cur;

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