diff options
| -rw-r--r-- | Modules/mmapmodule.c | 1111 |
1 files changed, 569 insertions, 542 deletions
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c index bff22b2..66f0e48 100644 --- a/Modules/mmapmodule.c +++ b/Modules/mmapmodule.c @@ -1,7 +1,7 @@ -/* -*- Mode: C++; tab-width: 4 -*- - / Author: Sam Rushing <rushing@nightmare.com> +/* + / Author: Sam Rushing <rushing@nightmare.com> / Hacked for Unix by A.M. Kuchling <amk1@bigfoot.com> - / $Id$ + / $Id$ / mmapmodule.cpp -- map a view of a file into memory / @@ -16,6 +16,8 @@ / ftp://squirl.nightmare.com/pub/python/python-ext. */ +#include <Python.h> + #ifndef MS_WIN32 #define UNIX #endif @@ -29,23 +31,21 @@ #include <sys/mman.h> #endif -#include <Python.h> - #include <string.h> #include <sys/types.h> static PyObject *mmap_module_error; typedef struct { - PyObject_HEAD - char * data; - size_t size; - size_t pos; + PyObject_HEAD + char * data; + size_t size; + size_t pos; #ifdef MS_WIN32 - HANDLE map_handle; - HFILE file_handle; - char * tagname; + HANDLE map_handle; + HFILE file_handle; + char * tagname; #endif #ifdef UNIX @@ -57,201 +57,205 @@ static void mmap_object_dealloc(mmap_object * m_obj) { #ifdef MS_WIN32 - UnmapViewOfFile (m_obj->data); - CloseHandle (m_obj->map_handle); - CloseHandle ((HANDLE)m_obj->file_handle); + UnmapViewOfFile (m_obj->data); + CloseHandle (m_obj->map_handle); + CloseHandle ((HANDLE)m_obj->file_handle); #endif /* MS_WIN32 */ #ifdef UNIX - if (m_obj->data!=NULL) { - msync(m_obj->data, m_obj->size, MS_SYNC | MS_INVALIDATE); - munmap(m_obj->data, m_obj->size); - } + if (m_obj->data!=NULL) { + msync(m_obj->data, m_obj->size, MS_SYNC | MS_INVALIDATE); + munmap(m_obj->data, m_obj->size); + } #endif /* UNIX */ - PyMem_DEL(m_obj); + PyMem_DEL(m_obj); } static PyObject * mmap_close_method (mmap_object * self, PyObject * args) { #ifdef MS_WIN32 - UnmapViewOfFile (self->data); - CloseHandle (self->map_handle); - CloseHandle ((HANDLE)self->file_handle); - self->map_handle = (HANDLE) NULL; + UnmapViewOfFile (self->data); + CloseHandle (self->map_handle); + CloseHandle ((HANDLE)self->file_handle); + self->map_handle = (HANDLE) NULL; #endif /* MS_WIN32 */ #ifdef UNIX - munmap(self->data, self->size); - self->data = NULL; + munmap(self->data, self->size); + self->data = NULL; #endif - Py_INCREF (Py_None); - return (Py_None); + Py_INCREF (Py_None); + return (Py_None); } #ifdef MS_WIN32 -#define CHECK_VALID(err) \ -do { \ - if (!self->map_handle) { \ - PyErr_SetString (PyExc_ValueError, "mmap closed or invalid");\ - return err; \ - } \ +#define CHECK_VALID(err) \ +do { \ + if (!self->map_handle) { \ + PyErr_SetString (PyExc_ValueError, "mmap closed or invalid"); \ + return err; \ + } \ } while (0) #endif /* MS_WIN32 */ #ifdef UNIX -#define CHECK_VALID(err) \ -do { \ - if (self->data == NULL) { \ - PyErr_SetString (PyExc_ValueError, "mmap closed or invalid"); \ - return err; \ - } \ +#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 * args) + PyObject * args) { - char value; - char * where = (self->data+self->pos); - CHECK_VALID(NULL); - if ((where >= 0) && (where < (self->data+self->size))) { - value = (char) *(where); - self->pos += 1; - return Py_BuildValue("c", (char) *(where)); - } else { - PyErr_SetString (PyExc_ValueError, "read byte out of range"); - return NULL; - } + char value; + char * where = (self->data+self->pos); + CHECK_VALID(NULL); + if ((where >= 0) && (where < (self->data+self->size))) { + value = (char) *(where); + self->pos += 1; + return Py_BuildValue("c", (char) *(where)); + } else { + PyErr_SetString (PyExc_ValueError, "read byte out of range"); + return NULL; + } } static PyObject * mmap_read_line_method (mmap_object * self, - PyObject * args) + PyObject * args) { - char * start; - char * eof = self->data+self->size; - char * eol; - PyObject * result; - - CHECK_VALID(NULL); - start = self->data+self->pos; - - /* strchr was a bad idea here - there's no way to range - check it. there is no 'strnchr' */ - for (eol = start; (eol < eof) && (*eol != '\n') ; eol++) - { /* do nothing */ } - - result = Py_BuildValue("s#", start, (long) (++eol - start)); - self->pos += (eol - start); - return (result); + char * start; + char * eof = self->data+self->size; + char * eol; + PyObject * result; + + CHECK_VALID(NULL); + start = self->data+self->pos; + + /* strchr was a bad idea here - there's no way to range + check it. there is no 'strnchr' */ + for (eol = start; (eol < eof) && (*eol != '\n') ; eol++) + { /* do nothing */ } + + result = Py_BuildValue("s#", start, (long) (++eol - start)); + self->pos += (eol - start); + return (result); } static PyObject * mmap_read_method (mmap_object * self, - PyObject * args) + PyObject * args) { - long num_bytes; - PyObject *result; - - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "l", &num_bytes)) - return(NULL); - - /* silently 'adjust' out-of-range requests */ - if ((self->pos + num_bytes) > self->size) { - num_bytes -= (self->pos+num_bytes) - self->size; - } - result = Py_BuildValue("s#", self->data+self->pos, num_bytes); - self->pos += num_bytes; - return (result); + long num_bytes; + PyObject *result; + + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "l", &num_bytes)) + return(NULL); + + /* silently 'adjust' out-of-range requests */ + if ((self->pos + num_bytes) > self->size) { + 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) + PyObject *args) { - long start = self->pos; - char * needle; - int len; + long start = self->pos; + char * needle; + int len; - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "s#|l", &needle, &len, &start)) { - return NULL; - } else { - char * p = self->data+self->pos; - char * e = self->data+self->size; - while (p < e) { - char * s = p; - char * n = needle; - while ((s<e) && (*n) && !(*s-*n)) { - s++, n++; - } - if (!*n) { - return Py_BuildValue ("l", (long) (p - (self->data + start))); - } - p++; - } - return Py_BuildValue ("l", (long) -1); + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "s#|l", &needle, &len, &start)) { + return NULL; + } else { + char * p = self->data+self->pos; + char * e = self->data+self->size; + while (p < e) { + char * s = p; + char * n = needle; + while ((s<e) && (*n) && !(*s-*n)) { + s++, n++; + } + if (!*n) { + return Py_BuildValue ( + "l", + (long) (p - (self->data + start))); + } + p++; } + return Py_BuildValue ("l", (long) -1); + } } static PyObject * mmap_write_method (mmap_object * self, - PyObject * args) + PyObject * args) { - long length; - char * data; + long length; + char * data; - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "s#", &data, &length)) - return(NULL); + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "s#", &data, &length)) + return(NULL); - if ((self->pos + length) > self->size) { - PyErr_SetString (mmap_module_error, "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); + 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) + PyObject * args) { - char value; + char value; - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "c", &value)) - return(NULL); + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "c", &value)) + return(NULL); - *(self->data+self->pos) = value; - self->pos += 1; - Py_INCREF (Py_None); - return (Py_None); + *(self->data+self->pos) = value; + self->pos += 1; + Py_INCREF (Py_None); + return (Py_None); } static PyObject * mmap_size_method (mmap_object * self, - PyObject * args) + PyObject * args) { - CHECK_VALID(NULL); + CHECK_VALID(NULL); #ifdef MS_WIN32 - if (self->file_handle != (HFILE) 0xFFFFFFFF) { - return (Py_BuildValue ("l", GetFileSize ((HANDLE)self->file_handle, NULL))); - } else { - return (Py_BuildValue ("l", self->size) ); - } + if (self->file_handle != (HFILE) 0xFFFFFFFF) { + return (Py_BuildValue ( + "l", + GetFileSize ((HANDLE)self->file_handle, NULL))); + } else { + return (Py_BuildValue ("l", self->size) ); + } #endif /* MS_WIN32 */ #ifdef UNIX - return (Py_BuildValue ("l", self->size) ); + return (Py_BuildValue ("l", self->size) ); #endif /* UNIX */ } @@ -266,70 +270,72 @@ mmap_size_method (mmap_object * self, static PyObject * mmap_resize_method (mmap_object * self, - PyObject * args) + PyObject * args) { - unsigned long new_size; - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "l", &new_size)) { - return NULL; + unsigned long new_size; + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "l", &new_size)) { + return NULL; #ifdef MS_WIN32 - } else { - /* First, unmap the file view */ - UnmapViewOfFile (self->data); - /* Close the mapping object */ - CloseHandle ((HANDLE)self->map_handle); - /* Move to the desired EOF position */ - SetFilePointer ((HANDLE)self->file_handle, new_size, NULL, FILE_BEGIN); - /* Change the size of the file */ - SetEndOfFile ((HANDLE)self->file_handle); - /* Create another mapping object and remap the file view */ - self->map_handle = CreateFileMapping ((HANDLE) self->file_handle, - NULL, - PAGE_READWRITE, - 0, - new_size, - self->tagname); - char complaint[256]; - 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 { - sprintf (complaint, "MapViewOfFile failed: %ld", GetLastError()); - } - } else { - sprintf (complaint, "CreateFileMapping failed: %ld", GetLastError()); - } - PyErr_SetString (mmap_module_error, complaint); - return (NULL); + } else { + DWORD dwErrCode = 0; + /* First, unmap the file view */ + UnmapViewOfFile (self->data); + /* Close the mapping object */ + CloseHandle ((HANDLE)self->map_handle); + /* Move to the desired EOF position */ + SetFilePointer ((HANDLE)self->file_handle, + new_size, NULL, FILE_BEGIN); + /* Change the size of the file */ + SetEndOfFile ((HANDLE)self->file_handle); + /* Create another mapping object and remap the file view */ + self->map_handle = CreateFileMapping ( + (HANDLE) self->file_handle, + NULL, + PAGE_READWRITE, + 0, + new_size, + 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_WIN32 */ #ifdef UNIX #ifndef MREMAP_MAYMOVE } else { - PyErr_SetString(PyExc_SystemError, "mmap: resizing not available--no mremap()"); - return NULL; + PyErr_SetString(PyExc_SystemError, + "mmap: resizing not available--no mremap()"); + return NULL; #else } else { - void *newmap; + void *newmap; - newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE); - 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; + newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE); + 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 /* MREMAP_MAYMOVE */ #endif /* UNIX */ } @@ -338,372 +344,381 @@ mmap_resize_method (mmap_object * self, static PyObject * mmap_tell_method (mmap_object * self, PyObject * args) { - CHECK_VALID(NULL); - return (Py_BuildValue ("l", self->pos) ); + CHECK_VALID(NULL); + return (Py_BuildValue ("l", self->pos) ); } static PyObject * mmap_flush_method (mmap_object * self, PyObject * args) { - size_t offset = 0; - size_t size = self->size; - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "|ll", &offset, &size)) { - return NULL; - } else if ((offset + size) > self->size) { - PyErr_SetString (PyExc_ValueError, "flush values out of range"); - return NULL; - } else { + size_t offset = 0; + size_t size = self->size; + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "|ll", &offset, &size)) { + return NULL; + } else if ((offset + size) > self->size) { + PyErr_SetString (PyExc_ValueError, + "flush values out of range"); + return NULL; + } else { #ifdef MS_WIN32 - return (Py_BuildValue ("l", FlushViewOfFile (self->data+offset, size))); + return (Py_BuildValue ( + "l", FlushViewOfFile (self->data+offset, size))); #endif /* MS_WIN32 */ #ifdef UNIX - /* XXX semantics of return value? */ - /* XXX flags for msync? */ - if (-1 == msync(self->data + offset, size, MS_SYNC | MS_INVALIDATE)) - { - PyErr_SetFromErrno(mmap_module_error); - return NULL; - } - return Py_BuildValue ("l", 0); -#endif /* UNIX */ + /* XXX semantics of return value? */ + /* XXX flags for msync? */ + if (-1 == msync(self->data + offset, size, + MS_SYNC | MS_INVALIDATE)) + { + PyErr_SetFromErrno(mmap_module_error); + return NULL; } + return Py_BuildValue ("l", 0); +#endif /* UNIX */ + } } static PyObject * mmap_seek_method (mmap_object * self, PyObject * args) { - /* ptrdiff_t dist; */ - long dist; - int how=0; - CHECK_VALID(NULL); - if (!PyArg_ParseTuple (args, "l|i", &dist, &how)) { - return(NULL); + /* ptrdiff_t dist; */ + long dist; + int how=0; + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "l|i", &dist, &how)) { + return(NULL); + } else { + unsigned long where; + switch (how) { + case 0: + where = dist; + break; + case 1: + where = self->pos + dist; + break; + case 2: + where = self->size - dist; + break; + default: + PyErr_SetString (PyExc_ValueError, + "unknown seek type"); + return NULL; + } + if ((where >= 0) && (where < (self->size))) { + self->pos = where; + Py_INCREF (Py_None); + return (Py_None); } else { - unsigned long where; - switch (how) { - case 0: - where = dist; - break; - case 1: - where = self->pos + dist; - break; - case 2: - where = self->size - dist; - break; - default: - PyErr_SetString (PyExc_ValueError, "unknown seek type"); - return NULL; - } - if ((where >= 0) && (where < (self->size))) { - self->pos = where; - Py_INCREF (Py_None); - return (Py_None); - } else { - PyErr_SetString (PyExc_ValueError, "seek out of range"); - return NULL; - } + 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, "iii", &dest, &src, &count)) { - return NULL; + unsigned long dest, src, count; + CHECK_VALID(NULL); + if (!PyArg_ParseTuple (args, "iii", &dest, &src, &count)) { + 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 { - /* 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; - } + 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, 1}, - {"find", (PyCFunction) mmap_find_method, 1}, - {"flush", (PyCFunction) mmap_flush_method, 1}, - {"move", (PyCFunction) mmap_move_method, 1}, - {"read", (PyCFunction) mmap_read_method, 1}, - {"read_byte", (PyCFunction) mmap_read_byte_method, 1}, - {"readline", (PyCFunction) mmap_read_line_method, 1}, - {"resize", (PyCFunction) mmap_resize_method, 1}, - {"seek", (PyCFunction) mmap_seek_method, 1}, - {"size", (PyCFunction) mmap_size_method, 1}, - {"tell", (PyCFunction) mmap_tell_method, 1}, - {"write", (PyCFunction) mmap_write_method, 1}, - {"write_byte",(PyCFunction) mmap_write_byte_method, 1}, - {NULL, NULL} /* sentinel */ + {"close", (PyCFunction) mmap_close_method, 1}, + {"find", (PyCFunction) mmap_find_method, 1}, + {"flush", (PyCFunction) mmap_flush_method, 1}, + {"move", (PyCFunction) mmap_move_method, 1}, + {"read", (PyCFunction) mmap_read_method, 1}, + {"read_byte", (PyCFunction) mmap_read_byte_method, 1}, + {"readline", (PyCFunction) mmap_read_line_method, 1}, + {"resize", (PyCFunction) mmap_resize_method, 1}, + {"seek", (PyCFunction) mmap_seek_method, 1}, + {"size", (PyCFunction) mmap_size_method, 1}, + {"tell", (PyCFunction) mmap_tell_method, 1}, + {"write", (PyCFunction) mmap_write_method, 1}, + {"write_byte", (PyCFunction) mmap_write_byte_method, 1}, + {NULL, NULL} /* sentinel */ }; /* Functions for treating an mmap'ed file as a buffer */ static int mmap_buffer_getreadbuf(self, index, ptr) - mmap_object *self; + mmap_object *self; int 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; + CHECK_VALID(-1); + if ( index != 0 ) { + PyErr_SetString(PyExc_SystemError, + "Accessing non-existent mmap segment"); + return -1; + } + *ptr = self->data; + return self->size; } static int mmap_buffer_getwritebuf(self, index, ptr) - mmap_object *self; -int index; -const void **ptr; + mmap_object *self; + int 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; + CHECK_VALID(-1); + if ( index != 0 ) { + PyErr_SetString(PyExc_SystemError, + "Accessing non-existent mmap segment"); + return -1; + } + *ptr = self->data; + return self->size; } static int mmap_buffer_getsegcount(self, lenp) - mmap_object *self; -int *lenp; + mmap_object *self; + int *lenp; { - CHECK_VALID(-1); - if (lenp) - *lenp = self->size; - return 1; + CHECK_VALID(-1); + if (lenp) + *lenp = self->size; + return 1; } static int mmap_buffer_getcharbuffer(self, index, ptr) - mmap_object *self; -int index; -const void **ptr; + mmap_object *self; + int 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; + 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); + return Py_FindMethod (mmap_object_methods, (PyObject *)self, name); } static int mmap_length(self) - mmap_object *self; + mmap_object *self; { - CHECK_VALID(-1); - return self->size; + CHECK_VALID(-1); + return self->size; } static PyObject * mmap_item(self, i) - mmap_object *self; -int i; + mmap_object *self; + int i; { - CHECK_VALID(NULL); - if (i < 0 || i >= self->size) { - PyErr_SetString(PyExc_IndexError, "mmap index out of range"); - return NULL; - } - return PyString_FromStringAndSize(self->data + i, 1); + CHECK_VALID(NULL); + if (i < 0 || 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(self, ilow, ihigh) - mmap_object *self; -int ilow, ihigh; + mmap_object *self; + int ilow, ihigh; { - CHECK_VALID(NULL); - if (ilow < 0) - ilow = 0; - else if (ilow > self->size) - ilow = self->size; - if (ihigh < 0) - ihigh = 0; - if (ihigh < ilow) - ihigh = ilow; - else if (ihigh > self->size) - ihigh = self->size; - - return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow); + CHECK_VALID(NULL); + if (ilow < 0) + ilow = 0; + else if (ilow > self->size) + ilow = self->size; + if (ihigh < 0) + ihigh = 0; + if (ihigh < ilow) + ihigh = ilow; + else if (ihigh > self->size) + ihigh = self->size; + + return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow); } static PyObject * mmap_concat(self, bb) - mmap_object *self; -PyObject *bb; + mmap_object *self; + PyObject *bb; { - CHECK_VALID(NULL); - PyErr_SetString(PyExc_SystemError, "mmaps don't support concatenation"); - return NULL; + CHECK_VALID(NULL); + PyErr_SetString(PyExc_SystemError, + "mmaps don't support concatenation"); + return NULL; } static PyObject * mmap_repeat(self, n) - mmap_object *self; -int n; + mmap_object *self; + int n; { - CHECK_VALID(NULL); - PyErr_SetString(PyExc_SystemError, "mmaps don't support repeat operation"); - return NULL; + CHECK_VALID(NULL); + PyErr_SetString(PyExc_SystemError, + "mmaps don't support repeat operation"); + return NULL; } static int mmap_ass_slice(self, ilow, ihigh, v) - mmap_object *self; -int ilow, ihigh; -PyObject *v; + mmap_object *self; + int ilow, ihigh; + PyObject *v; { - unsigned char *buf; - - CHECK_VALID(-1); - if (ilow < 0) - ilow = 0; - else if (ilow > self->size) - ilow = self->size; - if (ihigh < 0) - ihigh = 0; - if (ihigh < ilow) - ihigh = ilow; - else if (ihigh > self->size) - ihigh = self->size; - - 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; - } - buf = PyString_AsString(v); - memcpy(self->data + ilow, buf, ihigh-ilow); - return 0; + unsigned char *buf; + + CHECK_VALID(-1); + if (ilow < 0) + ilow = 0; + else if (ilow > self->size) + ilow = self->size; + if (ihigh < 0) + ihigh = 0; + if (ihigh < ilow) + ihigh = ilow; + else if (ihigh > self->size) + ihigh = self->size; + + 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; + } + buf = PyString_AsString(v); + memcpy(self->data + ilow, buf, ihigh-ilow); + return 0; } static int mmap_ass_item(self, i, v) - mmap_object *self; -int i; -PyObject *v; + mmap_object *self; + int i; + PyObject *v; { - unsigned char *buf; + unsigned char *buf; - CHECK_VALID(-1); - if (i < 0 || i >= self->size) { - PyErr_SetString(PyExc_IndexError, "mmap index out of range"); - return -1; - } - if (! (PyString_Check(v) && PyString_Size(v)==1) ) { - PyErr_SetString(PyExc_IndexError, - "mmap assignment must be single-character string"); - return -1; - } - buf = PyString_AsString(v); - self->data[i] = buf[0]; - return 0; + CHECK_VALID(-1); + if (i < 0 || i >= self->size) { + PyErr_SetString(PyExc_IndexError, "mmap index out of range"); + return -1; + } + if (! (PyString_Check(v) && PyString_Size(v)==1) ) { + PyErr_SetString(PyExc_IndexError, + "mmap assignment must be single-character string"); + return -1; + } + buf = PyString_AsString(v); + self->data[i] = buf[0]; + return 0; } static PySequenceMethods mmap_as_sequence = { - (inquiry)mmap_length, /*sq_length*/ - (binaryfunc)mmap_concat, /*sq_concat*/ - (intargfunc)mmap_repeat, /*sq_repeat*/ - (intargfunc)mmap_item, /*sq_item*/ - (intintargfunc)mmap_slice, /*sq_slice*/ - (intobjargproc)mmap_ass_item, /*sq_ass_item*/ - (intintobjargproc)mmap_ass_slice, /*sq_ass_slice*/ + (inquiry)mmap_length, /*sq_length*/ + (binaryfunc)mmap_concat, /*sq_concat*/ + (intargfunc)mmap_repeat, /*sq_repeat*/ + (intargfunc)mmap_item, /*sq_item*/ + (intintargfunc)mmap_slice, /*sq_slice*/ + (intobjargproc)mmap_ass_item, /*sq_ass_item*/ + (intintobjargproc)mmap_ass_slice, /*sq_ass_slice*/ }; static PyBufferProcs mmap_as_buffer = { - (getreadbufferproc)mmap_buffer_getreadbuf, - (getwritebufferproc)mmap_buffer_getwritebuf, - (getsegcountproc)mmap_buffer_getsegcount, - (getcharbufferproc)mmap_buffer_getcharbuffer, + (getreadbufferproc)mmap_buffer_getreadbuf, + (getwritebufferproc)mmap_buffer_getwritebuf, + (getsegcountproc)mmap_buffer_getsegcount, + (getcharbufferproc)mmap_buffer_getcharbuffer, }; static PyTypeObject mmap_object_type = { - PyObject_HEAD_INIT(&PyType_Type) - 0, /* ob_size */ - "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*/ + PyObject_HEAD_INIT(0) /* patched in module init */ + 0, /* ob_size */ + "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*/ }; #ifdef UNIX static PyObject * new_mmap_object (PyObject * self, PyObject * args, PyObject *kwdict) { - mmap_object * m_obj; - unsigned long map_size; - int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ; - char * filename; - int namelen; - char *keywords[] = {"file", "size", "flags", "prot", NULL}; - - if (!PyArg_ParseTupleAndKeywords(args, kwdict, - "il|ii", keywords, - &fd, &map_size, &flags, &prot) - ) - return NULL; + mmap_object * m_obj; + unsigned long map_size; + int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ; + char * filename; + int namelen; + char *keywords[] = {"file", "size", "flags", "prot", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwdict, + "il|ii", keywords, + &fd, &map_size, &flags, &prot) + ) + return NULL; - m_obj = PyObject_NEW (mmap_object, &mmap_object_type); - if (m_obj == NULL) {return NULL;} - m_obj->size = (size_t) map_size; - m_obj->pos = (size_t) 0; - m_obj->data = mmap(NULL, map_size, - prot, flags, - fd, 0); - if (m_obj->data == (void *)-1) - { - Py_DECREF(m_obj); - PyErr_SetFromErrno(mmap_module_error); - return NULL; - } - return (PyObject *)m_obj; + m_obj = PyObject_NEW (mmap_object, &mmap_object_type); + if (m_obj == NULL) {return NULL;} + m_obj->size = (size_t) map_size; + m_obj->pos = (size_t) 0; + m_obj->data = mmap(NULL, map_size, + prot, flags, + fd, 0); + if (m_obj->data == (void *)-1) + { + Py_DECREF(m_obj); + PyErr_SetFromErrno(mmap_module_error); + return NULL; + } + return (PyObject *)m_obj; } #endif /* UNIX */ @@ -711,93 +726,95 @@ new_mmap_object (PyObject * self, PyObject * args, PyObject *kwdict) static PyObject * new_mmap_object (PyObject * self, PyObject * args) { - mmap_object * m_obj; - unsigned long map_size; - char * filename; - int namelen; - char * tagname; - - char complaint[256]; - HFILE fh = 0; - OFSTRUCT file_info; - - if (!PyArg_Parse (args, - "(s#zl)", - &filename, - &namelen, - &tagname, - &map_size) - ) - return NULL; + mmap_object * m_obj; + unsigned long map_size; + char * filename; + int namelen; + char * tagname = ""; + + DWORD dwErr = 0; + int fileno; + HFILE fh = 0; + OFSTRUCT file_info; + + /* Patch the object type */ + mmap_object_type.ob_type = &PyType_Type; + + if (!PyArg_ParseTuple(args, + "il|z", + &fileno, + &map_size, + &tagname) + ) + return NULL; - /* if an actual filename has been specified */ - if (namelen != 0) { - fh = OpenFile (filename, &file_info, OF_READWRITE); - if (fh == HFILE_ERROR) { - sprintf (complaint, "OpenFile failed: %ld", GetLastError()); - PyErr_SetString(mmap_module_error, complaint); - return NULL; - } + /* if an actual filename has been specified */ + if (fileno != 0) { + fh = _get_osfhandle(fileno); + if (fh==-1) { + PyErr_SetFromErrno(mmap_module_error); + return NULL; } - - m_obj = PyObject_NEW (mmap_object, &mmap_object_type); - - if (fh) { - m_obj->file_handle = fh; - if (!map_size) { - m_obj->size = GetFileSize ((HANDLE)fh, NULL); - } else { - m_obj->size = map_size; - } - } - else { - m_obj->file_handle = (HFILE) 0xFFFFFFFF; - m_obj->size = map_size; +// +// fh = OpenFile (filename, &file_info, OF_READWRITE); +// if (fh == HFILE_ERROR) { +// PyErr_SetFromWindowsErr(GetLastError()); +// return NULL; +// } + } + + m_obj = PyObject_NEW (mmap_object, &mmap_object_type); + + if (fh) { + m_obj->file_handle = fh; + if (!map_size) { + m_obj->size = GetFileSize ((HANDLE)fh, NULL); + } else { + m_obj->size = map_size; } - - /* set the initial position */ - m_obj->pos = (size_t) 0; - - m_obj->map_handle = CreateFileMapping ((HANDLE) m_obj->file_handle, - NULL, - PAGE_READWRITE, - 0, - m_obj->size, - tagname); - if (m_obj->map_handle != NULL) { - m_obj->data = (char *) MapViewOfFile (m_obj->map_handle, - FILE_MAP_WRITE, - 0, - 0, - 0); - if (m_obj->data != NULL) { - return ((PyObject *) m_obj); - } else { - sprintf (complaint, "MapViewOfFile failed: %ld", GetLastError()); - } + } + else { + m_obj->file_handle = (HFILE) 0xFFFFFFFF; + m_obj->size = map_size; + } + + /* set the initial position */ + m_obj->pos = (size_t) 0; + + m_obj->map_handle = CreateFileMapping ((HANDLE) m_obj->file_handle, + NULL, + PAGE_READWRITE, + 0, + m_obj->size, + tagname); + if (m_obj->map_handle != NULL) { + m_obj->data = (char *) MapViewOfFile (m_obj->map_handle, + FILE_MAP_WRITE, + 0, + 0, + 0); + if (m_obj->data != NULL) { + return ((PyObject *) m_obj); } else { - sprintf (complaint, "CreateFileMapping failed: %ld", GetLastError()); + dwErr = GetLastError(); } - PyErr_SetString (mmap_module_error, complaint); - return (NULL); + } else { + dwErr = GetLastError(); + } + PyErr_SetFromWindowsErr(dwErr); + return (NULL); } #endif /* MS_WIN32 */ /* List of functions exported by this module */ static struct PyMethodDef mmap_functions[] = { -#ifdef MS_WIN32 - {"mmap", (PyCFunction) new_mmap_object}, -#endif /* MS_WIN32 */ - -#ifdef UNIX - {"mmap", (PyCFunction) new_mmap_object, - METH_VARARGS|METH_KEYWORDS}, -#endif /* UNIX */ - {NULL, NULL} /* Sentinel */ + {"mmap", (PyCFunction) new_mmap_object, + METH_VARARGS|METH_KEYWORDS}, + {NULL, NULL} /* Sentinel */ }; #ifdef MS_WIN32 -extern"C" __declspec(dllexport) void +__declspec(dllexport) void #endif /* MS_WIN32 */ #ifdef UNIX extern void @@ -805,44 +822,54 @@ extern void initmmap(void) { - PyObject *dict, *module; - module = Py_InitModule ("mmap", mmap_functions); - dict = PyModule_GetDict (module); - mmap_module_error = PyString_FromString ("mmap error"); - PyDict_SetItemString (dict, "error", mmap_module_error); - + PyObject *dict, *module; + module = Py_InitModule ("mmap", mmap_functions); + dict = PyModule_GetDict (module); + mmap_module_error = PyExc_EnvironmentError; + Py_INCREF(mmap_module_error); + PyDict_SetItemString (dict, "error", mmap_module_error); #ifdef PROT_EXEC - PyDict_SetItemString (dict, "PROT_EXEC", PyInt_FromLong(PROT_EXEC) ); + PyDict_SetItemString (dict, "PROT_EXEC", PyInt_FromLong(PROT_EXEC) ); #endif #ifdef PROT_READ - PyDict_SetItemString (dict, "PROT_READ", PyInt_FromLong(PROT_READ) ); + PyDict_SetItemString (dict, "PROT_READ", PyInt_FromLong(PROT_READ) ); #endif #ifdef PROT_WRITE - PyDict_SetItemString (dict, "PROT_WRITE", PyInt_FromLong(PROT_WRITE) ); + PyDict_SetItemString (dict, "PROT_WRITE", PyInt_FromLong(PROT_WRITE) ); #endif #ifdef MAP_SHARED - PyDict_SetItemString (dict, "MAP_SHARED", PyInt_FromLong(MAP_SHARED) ); + PyDict_SetItemString (dict, "MAP_SHARED", PyInt_FromLong(MAP_SHARED) ); #endif #ifdef MAP_PRIVATE - PyDict_SetItemString (dict, "MAP_PRIVATE", PyInt_FromLong(MAP_PRIVATE) ); + PyDict_SetItemString (dict, "MAP_PRIVATE", + PyInt_FromLong(MAP_PRIVATE) ); #endif #ifdef MAP_DENYWRITE - PyDict_SetItemString (dict, "MAP_DENYWRITE", PyInt_FromLong(MAP_DENYWRITE) ); + PyDict_SetItemString (dict, "MAP_DENYWRITE", + PyInt_FromLong(MAP_DENYWRITE) ); #endif #ifdef MAP_EXECUTABLE - PyDict_SetItemString (dict, "MAP_EXECUTABLE", PyInt_FromLong(MAP_EXECUTABLE) ); + PyDict_SetItemString (dict, "MAP_EXECUTABLE", + PyInt_FromLong(MAP_EXECUTABLE) ); #endif #ifdef MAP_ANON - PyDict_SetItemString (dict, "MAP_ANON", PyInt_FromLong(MAP_ANON) ); - PyDict_SetItemString (dict, "MAP_ANONYMOUS", PyInt_FromLong(MAP_ANON) ); + PyDict_SetItemString (dict, "MAP_ANON", PyInt_FromLong(MAP_ANON) ); + PyDict_SetItemString (dict, "MAP_ANONYMOUS", + PyInt_FromLong(MAP_ANON) ); #endif #ifdef UNIX - PyDict_SetItemString (dict, "PAGESIZE", PyInt_FromLong( (long)getpagesize() ) ); + PyDict_SetItemString (dict, "PAGESIZE", + PyInt_FromLong( (long)getpagesize() ) ); #endif +#ifdef MS_WIN32 + { + SYSTEM_INFO si; + GetSystemInfo(&si); + PyDict_SetItemString (dict, "PAGESIZE", + PyInt_FromLong( si.dwPageSize ) ); + } +#endif /* MS_WIN32 */ } - - - |