+++ /dev/null
-\r
-/* Buffer object implementation */\r
-\r
-#include "Python.h"\r
-\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- PyObject *b_base;\r
- void *b_ptr;\r
- Py_ssize_t b_size;\r
- Py_ssize_t b_offset;\r
- int b_readonly;\r
- long b_hash;\r
-} PyBufferObject;\r
-\r
-\r
-enum buffer_t {\r
- READ_BUFFER,\r
- WRITE_BUFFER,\r
- CHAR_BUFFER,\r
- ANY_BUFFER\r
-};\r
-\r
-static int\r
-get_buf(PyBufferObject *self, void **ptr, Py_ssize_t *size,\r
- enum buffer_t buffer_type)\r
-{\r
- if (self->b_base == NULL) {\r
- assert (ptr != NULL);\r
- *ptr = self->b_ptr;\r
- *size = self->b_size;\r
- }\r
- else {\r
- Py_ssize_t count, offset;\r
- readbufferproc proc = 0;\r
- PyBufferProcs *bp = self->b_base->ob_type->tp_as_buffer;\r
- if ((*bp->bf_getsegcount)(self->b_base, NULL) != 1) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "single-segment buffer object expected");\r
- return 0;\r
- }\r
- if ((buffer_type == READ_BUFFER) ||\r
- ((buffer_type == ANY_BUFFER) && self->b_readonly))\r
- proc = bp->bf_getreadbuffer;\r
- else if ((buffer_type == WRITE_BUFFER) ||\r
- (buffer_type == ANY_BUFFER))\r
- proc = (readbufferproc)bp->bf_getwritebuffer;\r
- else if (buffer_type == CHAR_BUFFER) {\r
- if (!PyType_HasFeature(self->ob_type,\r
- Py_TPFLAGS_HAVE_GETCHARBUFFER)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "Py_TPFLAGS_HAVE_GETCHARBUFFER needed");\r
- return 0;\r
- }\r
- proc = (readbufferproc)bp->bf_getcharbuffer;\r
- }\r
- if (!proc) {\r
- char *buffer_type_name;\r
- switch (buffer_type) {\r
- case READ_BUFFER:\r
- buffer_type_name = "read";\r
- break;\r
- case WRITE_BUFFER:\r
- buffer_type_name = "write";\r
- break;\r
- case CHAR_BUFFER:\r
- buffer_type_name = "char";\r
- break;\r
- default:\r
- buffer_type_name = "no";\r
- break;\r
- }\r
- PyErr_Format(PyExc_TypeError,\r
- "%s buffer type not available",\r
- buffer_type_name);\r
- return 0;\r
- }\r
- if ((count = (*proc)(self->b_base, 0, ptr)) < 0)\r
- return 0;\r
- /* apply constraints to the start/end */\r
- if (self->b_offset > count)\r
- offset = count;\r
- else\r
- offset = self->b_offset;\r
- *(char **)ptr = *(char **)ptr + offset;\r
- if (self->b_size == Py_END_OF_BUFFER)\r
- *size = count;\r
- else\r
- *size = self->b_size;\r
- if (*size > count - offset)\r
- *size = count - offset;\r
- }\r
- return 1;\r
-}\r
-\r
-\r
-static PyObject *\r
-buffer_from_memory(PyObject *base, Py_ssize_t size, Py_ssize_t offset, void *ptr,\r
- int readonly)\r
-{\r
- PyBufferObject * b;\r
-\r
- if (size < 0 && size != Py_END_OF_BUFFER) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "size must be zero or positive");\r
- return NULL;\r
- }\r
- if (offset < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "offset must be zero or positive");\r
- return NULL;\r
- }\r
-\r
- b = PyObject_NEW(PyBufferObject, &PyBuffer_Type);\r
- if ( b == NULL )\r
- return NULL;\r
-\r
- Py_XINCREF(base);\r
- b->b_base = base;\r
- b->b_ptr = ptr;\r
- b->b_size = size;\r
- b->b_offset = offset;\r
- b->b_readonly = readonly;\r
- b->b_hash = -1;\r
-\r
- return (PyObject *) b;\r
-}\r
-\r
-static PyObject *\r
-buffer_from_object(PyObject *base, Py_ssize_t size, Py_ssize_t offset, int readonly)\r
-{\r
- if (offset < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "offset must be zero or positive");\r
- return NULL;\r
- }\r
- if ( PyBuffer_Check(base) && (((PyBufferObject *)base)->b_base) ) {\r
- /* another buffer, refer to the base object */\r
- PyBufferObject *b = (PyBufferObject *)base;\r
- if (b->b_size != Py_END_OF_BUFFER) {\r
- Py_ssize_t base_size = b->b_size - offset;\r
- if (base_size < 0)\r
- base_size = 0;\r
- if (size == Py_END_OF_BUFFER || size > base_size)\r
- size = base_size;\r
- }\r
- offset += b->b_offset;\r
- base = b->b_base;\r
- }\r
- return buffer_from_memory(base, size, offset, NULL, readonly);\r
-}\r
-\r
-\r
-PyObject *\r
-PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)\r
-{\r
- PyBufferProcs *pb = base->ob_type->tp_as_buffer;\r
-\r
- if ( pb == NULL ||\r
- pb->bf_getreadbuffer == NULL ||\r
- pb->bf_getsegcount == NULL )\r
- {\r
- PyErr_SetString(PyExc_TypeError, "buffer object expected");\r
- return NULL;\r
- }\r
-\r
- return buffer_from_object(base, size, offset, 1);\r
-}\r
-\r
-PyObject *\r
-PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)\r
-{\r
- PyBufferProcs *pb = base->ob_type->tp_as_buffer;\r
-\r
- if ( pb == NULL ||\r
- pb->bf_getwritebuffer == NULL ||\r
- pb->bf_getsegcount == NULL )\r
- {\r
- PyErr_SetString(PyExc_TypeError, "buffer object expected");\r
- return NULL;\r
- }\r
-\r
- return buffer_from_object(base, size, offset, 0);\r
-}\r
-\r
-PyObject *\r
-PyBuffer_FromMemory(void *ptr, Py_ssize_t size)\r
-{\r
- return buffer_from_memory(NULL, size, 0, ptr, 1);\r
-}\r
-\r
-PyObject *\r
-PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size)\r
-{\r
- return buffer_from_memory(NULL, size, 0, ptr, 0);\r
-}\r
-\r
-PyObject *\r
-PyBuffer_New(Py_ssize_t size)\r
-{\r
- PyObject *o;\r
- PyBufferObject * b;\r
-\r
- if (size < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "size must be zero or positive");\r
- return NULL;\r
- }\r
- if (sizeof(*b) > PY_SSIZE_T_MAX - size) {\r
- /* unlikely */\r
- return PyErr_NoMemory();\r
- }\r
- /* Inline PyObject_New */\r
- o = (PyObject *)PyObject_MALLOC(sizeof(*b) + size);\r
- if ( o == NULL )\r
- return PyErr_NoMemory();\r
- b = (PyBufferObject *) PyObject_INIT(o, &PyBuffer_Type);\r
-\r
- b->b_base = NULL;\r
- b->b_ptr = (void *)(b + 1);\r
- b->b_size = size;\r
- b->b_offset = 0;\r
- b->b_readonly = 0;\r
- b->b_hash = -1;\r
-\r
- return o;\r
-}\r
-\r
-/* Methods */\r
-\r
-static PyObject *\r
-buffer_new(PyTypeObject *type, PyObject *args, PyObject *kw)\r
-{\r
- PyObject *ob;\r
- Py_ssize_t offset = 0;\r
- Py_ssize_t size = Py_END_OF_BUFFER;\r
-\r
- if (PyErr_WarnPy3k("buffer() not supported in 3.x", 1) < 0)\r
- return NULL;\r
-\r
- if (!_PyArg_NoKeywords("buffer()", kw))\r
- return NULL;\r
-\r
- if (!PyArg_ParseTuple(args, "O|nn:buffer", &ob, &offset, &size))\r
- return NULL;\r
- return PyBuffer_FromObject(ob, offset, size);\r
-}\r
-\r
-PyDoc_STRVAR(buffer_doc,\r
-"buffer(object [, offset[, size]])\n\\r
-\n\\r
-Create a new buffer object which references the given object.\n\\r
-The buffer will reference a slice of the target object from the\n\\r
-start of the object (or at the specified offset). The slice will\n\\r
-extend to the end of the target object (or with the specified size).");\r
-\r
-\r
-static void\r
-buffer_dealloc(PyBufferObject *self)\r
-{\r
- Py_XDECREF(self->b_base);\r
- PyObject_DEL(self);\r
-}\r
-\r
-static int\r
-buffer_compare(PyBufferObject *self, PyBufferObject *other)\r
-{\r
- void *p1, *p2;\r
- Py_ssize_t len_self, len_other, min_len;\r
- int cmp;\r
-\r
- if (!get_buf(self, &p1, &len_self, ANY_BUFFER))\r
- return -1;\r
- if (!get_buf(other, &p2, &len_other, ANY_BUFFER))\r
- return -1;\r
- min_len = (len_self < len_other) ? len_self : len_other;\r
- if (min_len > 0) {\r
- cmp = memcmp(p1, p2, min_len);\r
- if (cmp != 0)\r
- return cmp < 0 ? -1 : 1;\r
- }\r
- return (len_self < len_other) ? -1 : (len_self > len_other) ? 1 : 0;\r
-}\r
-\r
-static PyObject *\r
-buffer_repr(PyBufferObject *self)\r
-{\r
- const char *status = self->b_readonly ? "read-only" : "read-write";\r
-\r
- if ( self->b_base == NULL )\r
- return PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",\r
- status,\r
- self->b_ptr,\r
- self->b_size,\r
- self);\r
- else\r
- return PyString_FromFormat(\r
- "<%s buffer for %p, size %zd, offset %zd at %p>",\r
- status,\r
- self->b_base,\r
- self->b_size,\r
- self->b_offset,\r
- self);\r
-}\r
-\r
-static long\r
-buffer_hash(PyBufferObject *self)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- register Py_ssize_t len;\r
- register unsigned char *p;\r
- register long x;\r
-\r
- if ( self->b_hash != -1 )\r
- return self->b_hash;\r
-\r
- /* XXX potential bugs here, a readonly buffer does not imply that the\r
- * underlying memory is immutable. b_readonly is a necessary but not\r
- * sufficient condition for a buffer to be hashable. Perhaps it would\r
- * be better to only allow hashing if the underlying object is known to\r
- * be immutable (e.g. PyString_Check() is true). Another idea would\r
- * be to call tp_hash on the underlying object and see if it raises\r
- * an error. */\r
- if ( !self->b_readonly )\r
- {\r
- PyErr_SetString(PyExc_TypeError,\r
- "writable buffers are not hashable");\r
- return -1;\r
- }\r
-\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return -1;\r
- p = (unsigned char *) ptr;\r
- len = size;\r
- /*\r
- We make the hash of the empty buffer be 0, rather than using\r
- (prefix ^ suffix), since this slightly obfuscates the hash secret\r
- */\r
- if (len == 0) {\r
- self->b_hash = 0;\r
- return 0;\r
- }\r
- x = _Py_HashSecret.prefix;\r
- x ^= *p << 7;\r
- while (--len >= 0)\r
- x = (1000003*x) ^ *p++;\r
- x ^= size;\r
- x ^= _Py_HashSecret.suffix;\r
- if (x == -1)\r
- x = -2;\r
- self->b_hash = x;\r
- return x;\r
-}\r
-\r
-static PyObject *\r
-buffer_str(PyBufferObject *self)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return NULL;\r
- return PyString_FromStringAndSize((const char *)ptr, size);\r
-}\r
-\r
-/* Sequence methods */\r
-\r
-static Py_ssize_t\r
-buffer_length(PyBufferObject *self)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return -1;\r
- return size;\r
-}\r
-\r
-static PyObject *\r
-buffer_concat(PyBufferObject *self, PyObject *other)\r
-{\r
- PyBufferProcs *pb = other->ob_type->tp_as_buffer;\r
- void *ptr1, *ptr2;\r
- char *p;\r
- PyObject *ob;\r
- Py_ssize_t size, count;\r
-\r
- if ( pb == NULL ||\r
- pb->bf_getreadbuffer == NULL ||\r
- pb->bf_getsegcount == NULL )\r
- {\r
- PyErr_BadArgument();\r
- return NULL;\r
- }\r
- if ( (*pb->bf_getsegcount)(other, NULL) != 1 )\r
- {\r
- /* ### use a different exception type/message? */\r
- PyErr_SetString(PyExc_TypeError,\r
- "single-segment buffer object expected");\r
- return NULL;\r
- }\r
-\r
- if (!get_buf(self, &ptr1, &size, ANY_BUFFER))\r
- return NULL;\r
-\r
- /* optimize special case */\r
- if ( size == 0 )\r
- {\r
- Py_INCREF(other);\r
- return other;\r
- }\r
-\r
- if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )\r
- return NULL;\r
-\r
- assert(count <= PY_SIZE_MAX - size);\r
-\r
- ob = PyString_FromStringAndSize(NULL, size + count);\r
- if ( ob == NULL )\r
- return NULL;\r
- p = PyString_AS_STRING(ob);\r
- memcpy(p, ptr1, size);\r
- memcpy(p + size, ptr2, count);\r
-\r
- /* there is an extra byte in the string object, so this is safe */\r
- p[size + count] = '\0';\r
-\r
- return ob;\r
-}\r
-\r
-static PyObject *\r
-buffer_repeat(PyBufferObject *self, Py_ssize_t count)\r
-{\r
- PyObject *ob;\r
- register char *p;\r
- void *ptr;\r
- Py_ssize_t size;\r
-\r
- if ( count < 0 )\r
- count = 0;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return NULL;\r
- if (count > PY_SSIZE_T_MAX / size) {\r
- PyErr_SetString(PyExc_MemoryError, "result too large");\r
- return NULL;\r
- }\r
- ob = PyString_FromStringAndSize(NULL, size * count);\r
- if ( ob == NULL )\r
- return NULL;\r
-\r
- p = PyString_AS_STRING(ob);\r
- while ( count-- )\r
- {\r
- memcpy(p, ptr, size);\r
- p += size;\r
- }\r
-\r
- /* there is an extra byte in the string object, so this is safe */\r
- *p = '\0';\r
-\r
- return ob;\r
-}\r
-\r
-static PyObject *\r
-buffer_item(PyBufferObject *self, Py_ssize_t idx)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return NULL;\r
- if ( idx < 0 || idx >= size ) {\r
- PyErr_SetString(PyExc_IndexError, "buffer index out of range");\r
- return NULL;\r
- }\r
- return PyString_FromStringAndSize((char *)ptr + idx, 1);\r
-}\r
-\r
-static PyObject *\r
-buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return NULL;\r
- if ( left < 0 )\r
- left = 0;\r
- if ( right < 0 )\r
- right = 0;\r
- if ( right > size )\r
- right = size;\r
- if ( right < left )\r
- right = left;\r
- return PyString_FromStringAndSize((char *)ptr + left,\r
- right - left);\r
-}\r
-\r
-static PyObject *\r
-buffer_subscript(PyBufferObject *self, PyObject *item)\r
-{\r
- void *p;\r
- Py_ssize_t size;\r
-\r
- if (!get_buf(self, &p, &size, ANY_BUFFER))\r
- return NULL;\r
- if (PyIndex_Check(item)) {\r
- Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);\r
- if (i == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (i < 0)\r
- i += size;\r
- return buffer_item(self, i);\r
- }\r
- else if (PySlice_Check(item)) {\r
- Py_ssize_t start, stop, step, slicelength, cur, i;\r
-\r
- if (PySlice_GetIndicesEx((PySliceObject*)item, size,\r
- &start, &stop, &step, &slicelength) < 0) {\r
- return NULL;\r
- }\r
-\r
- if (slicelength <= 0)\r
- return PyString_FromStringAndSize("", 0);\r
- else if (step == 1)\r
- return PyString_FromStringAndSize((char *)p + start,\r
- stop - start);\r
- else {\r
- PyObject *result;\r
- char *source_buf = (char *)p;\r
- char *result_buf = (char *)PyMem_Malloc(slicelength);\r
-\r
- if (result_buf == NULL)\r
- return PyErr_NoMemory();\r
-\r
- for (cur = start, i = 0; i < slicelength;\r
- cur += step, i++) {\r
- result_buf[i] = source_buf[cur];\r
- }\r
-\r
- result = PyString_FromStringAndSize(result_buf,\r
- slicelength);\r
- PyMem_Free(result_buf);\r
- return result;\r
- }\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "sequence index must be integer");\r
- return NULL;\r
- }\r
-}\r
-\r
-static int\r
-buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)\r
-{\r
- PyBufferProcs *pb;\r
- void *ptr1, *ptr2;\r
- Py_ssize_t size;\r
- Py_ssize_t count;\r
-\r
- if ( self->b_readonly ) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "buffer is read-only");\r
- return -1;\r
- }\r
-\r
- if (!get_buf(self, &ptr1, &size, ANY_BUFFER))\r
- return -1;\r
-\r
- if (idx < 0 || idx >= size) {\r
- PyErr_SetString(PyExc_IndexError,\r
- "buffer assignment index out of range");\r
- return -1;\r
- }\r
-\r
- pb = other ? other->ob_type->tp_as_buffer : NULL;\r
- if ( pb == NULL ||\r
- pb->bf_getreadbuffer == NULL ||\r
- pb->bf_getsegcount == NULL )\r
- {\r
- PyErr_BadArgument();\r
- return -1;\r
- }\r
- if ( (*pb->bf_getsegcount)(other, NULL) != 1 )\r
- {\r
- /* ### use a different exception type/message? */\r
- PyErr_SetString(PyExc_TypeError,\r
- "single-segment buffer object expected");\r
- return -1;\r
- }\r
-\r
- if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )\r
- return -1;\r
- if ( count != 1 ) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "right operand must be a single byte");\r
- return -1;\r
- }\r
-\r
- ((char *)ptr1)[idx] = *(char *)ptr2;\r
- return 0;\r
-}\r
-\r
-static int\r
-buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObject *other)\r
-{\r
- PyBufferProcs *pb;\r
- void *ptr1, *ptr2;\r
- Py_ssize_t size;\r
- Py_ssize_t slice_len;\r
- Py_ssize_t count;\r
-\r
- if ( self->b_readonly ) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "buffer is read-only");\r
- return -1;\r
- }\r
-\r
- pb = other ? other->ob_type->tp_as_buffer : NULL;\r
- if ( pb == NULL ||\r
- pb->bf_getreadbuffer == NULL ||\r
- pb->bf_getsegcount == NULL )\r
- {\r
- PyErr_BadArgument();\r
- return -1;\r
- }\r
- if ( (*pb->bf_getsegcount)(other, NULL) != 1 )\r
- {\r
- /* ### use a different exception type/message? */\r
- PyErr_SetString(PyExc_TypeError,\r
- "single-segment buffer object expected");\r
- return -1;\r
- }\r
- if (!get_buf(self, &ptr1, &size, ANY_BUFFER))\r
- return -1;\r
- if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )\r
- return -1;\r
-\r
- if ( left < 0 )\r
- left = 0;\r
- else if ( left > size )\r
- left = size;\r
- if ( right < left )\r
- right = left;\r
- else if ( right > size )\r
- right = size;\r
- slice_len = right - left;\r
-\r
- if ( count != slice_len ) {\r
- PyErr_SetString(\r
- PyExc_TypeError,\r
- "right operand length must match slice length");\r
- return -1;\r
- }\r
-\r
- if ( slice_len )\r
- memcpy((char *)ptr1 + left, ptr2, slice_len);\r
-\r
- return 0;\r
-}\r
-\r
-static int\r
-buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)\r
-{\r
- PyBufferProcs *pb;\r
- void *ptr1, *ptr2;\r
- Py_ssize_t selfsize;\r
- Py_ssize_t othersize;\r
-\r
- if ( self->b_readonly ) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "buffer is read-only");\r
- return -1;\r
- }\r
-\r
- pb = value ? value->ob_type->tp_as_buffer : NULL;\r
- if ( pb == NULL ||\r
- pb->bf_getreadbuffer == NULL ||\r
- pb->bf_getsegcount == NULL )\r
- {\r
- PyErr_BadArgument();\r
- return -1;\r
- }\r
- if ( (*pb->bf_getsegcount)(value, NULL) != 1 )\r
- {\r
- /* ### use a different exception type/message? */\r
- PyErr_SetString(PyExc_TypeError,\r
- "single-segment buffer object expected");\r
- return -1;\r
- }\r
- if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))\r
- return -1;\r
- if (PyIndex_Check(item)) {\r
- Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);\r
- if (i == -1 && PyErr_Occurred())\r
- return -1;\r
- if (i < 0)\r
- i += selfsize;\r
- return buffer_ass_item(self, i, value);\r
- }\r
- else if (PySlice_Check(item)) {\r
- Py_ssize_t start, stop, step, slicelength;\r
-\r
- if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize,\r
- &start, &stop, &step, &slicelength) < 0)\r
- return -1;\r
-\r
- if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0)\r
- return -1;\r
-\r
- if (othersize != slicelength) {\r
- PyErr_SetString(\r
- PyExc_TypeError,\r
- "right operand length must match slice length");\r
- return -1;\r
- }\r
-\r
- if (slicelength == 0)\r
- return 0;\r
- else if (step == 1) {\r
- memcpy((char *)ptr1 + start, ptr2, slicelength);\r
- return 0;\r
- }\r
- else {\r
- Py_ssize_t cur, i;\r
-\r
- for (cur = start, i = 0; i < slicelength;\r
- cur += step, i++) {\r
- ((char *)ptr1)[cur] = ((char *)ptr2)[i];\r
- }\r
-\r
- return 0;\r
- }\r
- } else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "buffer indices must be integers");\r
- return -1;\r
- }\r
-}\r
-\r
-/* Buffer methods */\r
-\r
-static Py_ssize_t\r
-buffer_getreadbuf(PyBufferObject *self, Py_ssize_t idx, void **pp)\r
-{\r
- Py_ssize_t size;\r
- if ( idx != 0 ) {\r
- PyErr_SetString(PyExc_SystemError,\r
- "accessing non-existent buffer segment");\r
- return -1;\r
- }\r
- if (!get_buf(self, pp, &size, READ_BUFFER))\r
- return -1;\r
- return size;\r
-}\r
-\r
-static Py_ssize_t\r
-buffer_getwritebuf(PyBufferObject *self, Py_ssize_t idx, void **pp)\r
-{\r
- Py_ssize_t size;\r
-\r
- if ( self->b_readonly )\r
- {\r
- PyErr_SetString(PyExc_TypeError, "buffer is read-only");\r
- return -1;\r
- }\r
-\r
- if ( idx != 0 ) {\r
- PyErr_SetString(PyExc_SystemError,\r
- "accessing non-existent buffer segment");\r
- return -1;\r
- }\r
- if (!get_buf(self, pp, &size, WRITE_BUFFER))\r
- return -1;\r
- return size;\r
-}\r
-\r
-static Py_ssize_t\r
-buffer_getsegcount(PyBufferObject *self, Py_ssize_t *lenp)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return -1;\r
- if (lenp)\r
- *lenp = size;\r
- return 1;\r
-}\r
-\r
-static Py_ssize_t\r
-buffer_getcharbuf(PyBufferObject *self, Py_ssize_t idx, const char **pp)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if ( idx != 0 ) {\r
- PyErr_SetString(PyExc_SystemError,\r
- "accessing non-existent buffer segment");\r
- return -1;\r
- }\r
- if (!get_buf(self, &ptr, &size, CHAR_BUFFER))\r
- return -1;\r
- *pp = (const char *)ptr;\r
- return size;\r
-}\r
-\r
-static int buffer_getbuffer(PyBufferObject *self, Py_buffer *buf, int flags)\r
-{\r
- void *ptr;\r
- Py_ssize_t size;\r
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))\r
- return -1;\r
- return PyBuffer_FillInfo(buf, (PyObject*)self, ptr, size,\r
- self->b_readonly, flags);\r
-}\r
-\r
-static PySequenceMethods buffer_as_sequence = {\r
- (lenfunc)buffer_length, /*sq_length*/\r
- (binaryfunc)buffer_concat, /*sq_concat*/\r
- (ssizeargfunc)buffer_repeat, /*sq_repeat*/\r
- (ssizeargfunc)buffer_item, /*sq_item*/\r
- (ssizessizeargfunc)buffer_slice, /*sq_slice*/\r
- (ssizeobjargproc)buffer_ass_item, /*sq_ass_item*/\r
- (ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/\r
-};\r
-\r
-static PyMappingMethods buffer_as_mapping = {\r
- (lenfunc)buffer_length,\r
- (binaryfunc)buffer_subscript,\r
- (objobjargproc)buffer_ass_subscript,\r
-};\r
-\r
-static PyBufferProcs buffer_as_buffer = {\r
- (readbufferproc)buffer_getreadbuf,\r
- (writebufferproc)buffer_getwritebuf,\r
- (segcountproc)buffer_getsegcount,\r
- (charbufferproc)buffer_getcharbuf,\r
- (getbufferproc)buffer_getbuffer,\r
-};\r
-\r
-PyTypeObject PyBuffer_Type = {\r
- PyVarObject_HEAD_INIT(&PyType_Type, 0)\r
- "buffer",\r
- sizeof(PyBufferObject),\r
- 0,\r
- (destructor)buffer_dealloc, /* tp_dealloc */\r
- 0, /* tp_print */\r
- 0, /* tp_getattr */\r
- 0, /* tp_setattr */\r
- (cmpfunc)buffer_compare, /* tp_compare */\r
- (reprfunc)buffer_repr, /* tp_repr */\r
- 0, /* tp_as_number */\r
- &buffer_as_sequence, /* tp_as_sequence */\r
- &buffer_as_mapping, /* tp_as_mapping */\r
- (hashfunc)buffer_hash, /* tp_hash */\r
- 0, /* tp_call */\r
- (reprfunc)buffer_str, /* tp_str */\r
- PyObject_GenericGetAttr, /* tp_getattro */\r
- 0, /* tp_setattro */\r
- &buffer_as_buffer, /* tp_as_buffer */\r
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GETCHARBUFFER | Py_TPFLAGS_HAVE_NEWBUFFER, /* tp_flags */\r
- buffer_doc, /* tp_doc */\r
- 0, /* tp_traverse */\r
- 0, /* tp_clear */\r
- 0, /* tp_richcompare */\r
- 0, /* tp_weaklistoffset */\r
- 0, /* tp_iter */\r
- 0, /* tp_iternext */\r
- 0, /* tp_methods */\r
- 0, /* tp_members */\r
- 0, /* tp_getset */\r
- 0, /* tp_base */\r
- 0, /* tp_dict */\r
- 0, /* tp_descr_get */\r
- 0, /* tp_descr_set */\r
- 0, /* tp_dictoffset */\r
- 0, /* tp_init */\r
- 0, /* tp_alloc */\r
- buffer_new, /* tp_new */\r
-};\r
projects / mirror_edk2.git / blobdiff