/*

/ Author: Sam Rushing <rushing@nightmare.com>

/ Hacked for Unix by AMK

/ $Id$

/ Modified to support mmap with offset - to map a 'window' of a file

/ Author: Yotam Medini yotamm@mellanox.co.il

/

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

*/

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include "pycore_bytesobject.h" // _PyBytes_Find()

#include "pycore_fileutils.h" // _Py_stat_struct

#include "structmember.h" // PyMemberDef

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

#ifndef MS_WINDOWS

#define UNIX

# ifdef HAVE_FCNTL_H

# include <fcntl.h>

# endif /* HAVE_FCNTL_H */

#endif

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

}

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

}

#define my_getallocationgranularity my_getpagesize

#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

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;

#else

off_t offset;

#endif

Py_ssize_t exports;

#ifdef MS_WINDOWS

HANDLE map_handle;

HANDLE file_handle;

wchar_t * tagname;

#endif

#ifdef UNIX

int fd;

#endif

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

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???

*/

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

#endif

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)

#define CHECK_VALID_OR_RELEASE(err, buffer) \

do { \

if (self->map_handle == NULL) { \

PyErr_SetString(PyExc_ValueError, "mmap closed or invalid"); \

PyBuffer_Release(&(buffer)); \

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)

#define CHECK_VALID_OR_RELEASE(err, buffer) \

do { \

if (self->data == NULL) { \

PyErr_SetString(PyExc_ValueError, "mmap closed or invalid"); \

PyBuffer_Release(&(buffer)); \

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;

CHECK_VALID(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 {

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;

Py_ssize_t res;

CHECK_VALID_OR_RELEASE(NULL, view);

if (end < start) {

res = -1;

}

else if (reverse) {

assert(0 <= start && start <= end && end <= self->size);

res = _PyBytes_ReverseFind(

self->data + start, end - start,

view.buf, view.len, start);

}

else {

assert(0 <= start && start <= end && end <= self->size);

res = _PyBytes_Find(

self->data + start, end - start,

view.buf, view.len, start);

}

PyBuffer_Release(&view);

return PyLong_FromSsize_t(res);

}

}

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;

}

CHECK_VALID_OR_RELEASE(NULL, data);

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;

CHECK_VALID(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,

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

#else

return PyLong_FromLong(status.st_size);

#endif

}

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

}

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 error = 0, file_resize_error = 0;

char* old_data = self->data;

LARGE_INTEGER offset, max_size;

offset.QuadPart = self->offset;

max_size.QuadPart = self->offset + new_size;

/* close the file mapping */

CloseHandle(self->map_handle);

/* if the file mapping still exists, it cannot be resized. */

if (self->tagname) {

self->map_handle = OpenFileMappingW(FILE_MAP_WRITE, FALSE,

self->tagname);

if (self->map_handle) {

PyErr_SetFromWindowsErr(ERROR_USER_MAPPED_FILE);

return NULL;

}

} else {

self->map_handle = NULL;

}

/* if it's not the paging file, unmap the view and resize the file */

if (self->file_handle != INVALID_HANDLE_VALUE) {

if (!UnmapViewOfFile(self->data)) {

return PyErr_SetFromWindowsErr(GetLastError());

};

self->data = NULL;

/* resize the file */

if (!SetFilePointerEx(self->file_handle, max_size, NULL,

FILE_BEGIN) ||

!SetEndOfFile(self->file_handle)) {

/* resizing failed. try to remap the file */

file_resize_error = GetLastError();

max_size.QuadPart = self->size;

new_size = self->size;

}

}

/* create a new file mapping and map a new view */

/* FIXME: call CreateFileMappingW with wchar_t tagname */

self->map_handle = CreateFileMappingW(

self->file_handle,

NULL,

PAGE_READWRITE,

max_size.HighPart,

max_size.LowPart,

self->tagname);

error = GetLastError();

/* ERROR_ALREADY_EXISTS implies that between our closing the handle above and

calling CreateFileMapping here, someone's created a different mapping with

the same name. There's nothing we can usefully do so we invalidate our

mapping and error out.

*/

if (error == ERROR_ALREADY_EXISTS) {

CloseHandle(self->map_handle);

self->map_handle = NULL;

}

else if (self->map_handle != NULL) {

self->data = MapViewOfFile(self->map_handle,

FILE_MAP_WRITE,

offset.HighPart,

offset.LowPart,

new_size);

if (self->data != NULL) {

/* copy the old view if using the paging file */

if (self->file_handle == INVALID_HANDLE_VALUE) {

memcpy(self->data, old_data,

self->size < new_size ? self->size : new_size);

if (!UnmapViewOfFile(old_data)) {

error = GetLastError();

}

}

self->size = new_size;

}

else {

error = GetLastError();

CloseHandle(self->map_handle);

self->map_handle = NULL;

}

}

if (error) {

return PyErr_SetFromWindowsErr(error);

return NULL;

}

/* It's possible for a resize to fail, typically because another mapping

is still held against the same underlying file. Even if nothing has

failed -- ie we're still returning a valid file mapping -- raise the

error as an exception as the resize won't have happened

*/

if (file_resize_error) {

PyErr_SetFromWindowsErr(file_resize_error);

return NULL;

}

Py_RETURN_NONE;

#endif /* MS_WINDOWS */

#ifdef UNIX

#ifndef HAVE_MREMAP

PyErr_SetString(PyExc_SystemError,

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

return NULL;

#else

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

#else

#if defined(__NetBSD__)

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

#else

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

#endif /* __NetBSD__ */

#endif

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;

#else

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

return NULL;

#endif

}

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;

CHECK_VALID(NULL);

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

#endif

}

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)

{

return mmap_close_method((mmap_object *)self, NULL);

}

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"

# else

# define _Py_FORMAT_OFFSET "ld"

# endif

if (mobj->data == NULL)

#endif

{

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)

{

size_t res = _PyObject_SIZE(Py_TYPE(self));

if (self->tagname) {

res += (wcslen(self->tagname) + 1) * sizeof(self->tagname[0]);

}

return PyLong_FromSize_t(res);

}

#endif

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

}

CHECK_VALID(NULL);

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

#endif

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

#endif

{NULL, NULL} /* sentinel */

};

static PyGetSetDef mmap_object_getset[] = {

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

{NULL}

};

/* Functions for treating an mmap'ed file as a buffer */

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;

}

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

CHECK_VALID(NULL);

if (slicelen <= 0)

return PyBytes_FromStringAndSize("", 0);

else if (step == 1)

return PyBytes_FromStringAndSize(self->data + start,

slicelen);