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