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
842
AppPkg/Applications/Python/Python-2.7.10/Objects/memoryobject.c
Normal file
842
AppPkg/Applications/Python/Python-2.7.10/Objects/memoryobject.c
Normal file
@ -0,0 +1,842 @@
|
||||
|
||||
/* Memoryview object implementation */
|
||||
|
||||
#include "Python.h"
|
||||
|
||||
static Py_ssize_t
|
||||
get_shape0(Py_buffer *buf)
|
||||
{
|
||||
if (buf->shape != NULL)
|
||||
return buf->shape[0];
|
||||
if (buf->ndim == 0)
|
||||
return 1;
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"exported buffer does not have any shape information associated "
|
||||
"to it");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void
|
||||
dup_buffer(Py_buffer *dest, Py_buffer *src)
|
||||
{
|
||||
*dest = *src;
|
||||
if (src->ndim == 1 && src->shape != NULL) {
|
||||
dest->shape = &(dest->smalltable[0]);
|
||||
dest->shape[0] = get_shape0(src);
|
||||
}
|
||||
if (src->ndim == 1 && src->strides != NULL) {
|
||||
dest->strides = &(dest->smalltable[1]);
|
||||
dest->strides[0] = src->strides[0];
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags)
|
||||
{
|
||||
int res = 0;
|
||||
if (self->view.obj != NULL)
|
||||
res = PyObject_GetBuffer(self->view.obj, view, flags);
|
||||
if (view)
|
||||
dup_buffer(view, &self->view);
|
||||
return res;
|
||||
}
|
||||
|
||||
static void
|
||||
memory_releasebuf(PyMemoryViewObject *self, Py_buffer *view)
|
||||
{
|
||||
PyBuffer_Release(view);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(memory_doc,
|
||||
"memoryview(object)\n\
|
||||
\n\
|
||||
Create a new memoryview object which references the given object.");
|
||||
|
||||
PyObject *
|
||||
PyMemoryView_FromBuffer(Py_buffer *info)
|
||||
{
|
||||
PyMemoryViewObject *mview;
|
||||
|
||||
mview = (PyMemoryViewObject *)
|
||||
PyObject_GC_New(PyMemoryViewObject, &PyMemoryView_Type);
|
||||
if (mview == NULL)
|
||||
return NULL;
|
||||
mview->base = NULL;
|
||||
dup_buffer(&mview->view, info);
|
||||
/* NOTE: mview->view.obj should already have been incref'ed as
|
||||
part of PyBuffer_FillInfo(). */
|
||||
_PyObject_GC_TRACK(mview);
|
||||
return (PyObject *)mview;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
PyMemoryView_FromObject(PyObject *base)
|
||||
{
|
||||
PyMemoryViewObject *mview;
|
||||
Py_buffer view;
|
||||
|
||||
if (!PyObject_CheckBuffer(base)) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"cannot make memory view because object does "
|
||||
"not have the buffer interface");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (PyObject_GetBuffer(base, &view, PyBUF_FULL_RO) < 0)
|
||||
return NULL;
|
||||
|
||||
mview = (PyMemoryViewObject *)PyMemoryView_FromBuffer(&view);
|
||||
if (mview == NULL) {
|
||||
PyBuffer_Release(&view);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mview->base = base;
|
||||
Py_INCREF(base);
|
||||
return (PyObject *)mview;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
|
||||
{
|
||||
PyObject *obj;
|
||||
static char *kwlist[] = {"object", 0};
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:memoryview", kwlist,
|
||||
&obj)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return PyMemoryView_FromObject(obj);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
_strided_copy_nd(char *dest, char *src, int nd, Py_ssize_t *shape,
|
||||
Py_ssize_t *strides, Py_ssize_t itemsize, char fort)
|
||||
{
|
||||
int k;
|
||||
Py_ssize_t outstride;
|
||||
|
||||
if (nd==0) {
|
||||
memcpy(dest, src, itemsize);
|
||||
}
|
||||
else if (nd == 1) {
|
||||
for (k = 0; k<shape[0]; k++) {
|
||||
memcpy(dest, src, itemsize);
|
||||
dest += itemsize;
|
||||
src += strides[0];
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (fort == 'F') {
|
||||
/* Copy first dimension first,
|
||||
second dimension second, etc...
|
||||
Set up the recursive loop backwards so that final
|
||||
dimension is actually copied last.
|
||||
*/
|
||||
outstride = itemsize;
|
||||
for (k=1; k<nd-1;k++) {
|
||||
outstride *= shape[k];
|
||||
}
|
||||
for (k=0; k<shape[nd-1]; k++) {
|
||||
_strided_copy_nd(dest, src, nd-1, shape,
|
||||
strides, itemsize, fort);
|
||||
dest += outstride;
|
||||
src += strides[nd-1];
|
||||
}
|
||||
}
|
||||
|
||||
else {
|
||||
/* Copy last dimension first,
|
||||
second-to-last dimension second, etc.
|
||||
Set up the recursion so that the
|
||||
first dimension is copied last
|
||||
*/
|
||||
outstride = itemsize;
|
||||
for (k=1; k < nd; k++) {
|
||||
outstride *= shape[k];
|
||||
}
|
||||
for (k=0; k<shape[0]; k++) {
|
||||
_strided_copy_nd(dest, src, nd-1, shape+1,
|
||||
strides+1, itemsize,
|
||||
fort);
|
||||
dest += outstride;
|
||||
src += strides[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
static int
|
||||
_indirect_copy_nd(char *dest, Py_buffer *view, char fort)
|
||||
{
|
||||
Py_ssize_t *indices;
|
||||
int k;
|
||||
Py_ssize_t elements;
|
||||
char *ptr;
|
||||
void (*func)(int, Py_ssize_t *, const Py_ssize_t *);
|
||||
|
||||
if (view->ndim > PY_SSIZE_T_MAX / sizeof(Py_ssize_t)) {
|
||||
PyErr_NoMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view->ndim);
|
||||
if (indices == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return -1;
|
||||
}
|
||||
for (k=0; k<view->ndim;k++) {
|
||||
indices[k] = 0;
|
||||
}
|
||||
|
||||
elements = 1;
|
||||
for (k=0; k<view->ndim; k++) {
|
||||
elements *= view->shape[k];
|
||||
}
|
||||
if (fort == 'F') {
|
||||
func = _Py_add_one_to_index_F;
|
||||
}
|
||||
else {
|
||||
func = _Py_add_one_to_index_C;
|
||||
}
|
||||
while (elements--) {
|
||||
func(view->ndim, indices, view->shape);
|
||||
ptr = PyBuffer_GetPointer(view, indices);
|
||||
memcpy(dest, ptr, view->itemsize);
|
||||
dest += view->itemsize;
|
||||
}
|
||||
|
||||
PyMem_Free(indices);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
Get a the data from an object as a contiguous chunk of memory (in
|
||||
either 'C' or 'F'ortran order) even if it means copying it into a
|
||||
separate memory area.
|
||||
|
||||
Returns a new reference to a Memory view object. If no copy is needed,
|
||||
the memory view object points to the original memory and holds a
|
||||
lock on the original. If a copy is needed, then the memory view object
|
||||
points to a brand-new Bytes object (and holds a memory lock on it).
|
||||
|
||||
buffertype
|
||||
|
||||
PyBUF_READ buffer only needs to be read-only
|
||||
PyBUF_WRITE buffer needs to be writable (give error if not contiguous)
|
||||
PyBUF_SHADOW buffer needs to be writable so shadow it with
|
||||
a contiguous buffer if it is not. The view will point to
|
||||
the shadow buffer which can be written to and then
|
||||
will be copied back into the other buffer when the memory
|
||||
view is de-allocated. While the shadow buffer is
|
||||
being used, it will have an exclusive write lock on
|
||||
the original buffer.
|
||||
*/
|
||||
|
||||
PyObject *
|
||||
PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char fort)
|
||||
{
|
||||
PyMemoryViewObject *mem;
|
||||
PyObject *bytes;
|
||||
Py_buffer *view;
|
||||
int flags;
|
||||
char *dest;
|
||||
|
||||
if (!PyObject_CheckBuffer(obj)) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"object does not have the buffer interface");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mem = PyObject_GC_New(PyMemoryViewObject, &PyMemoryView_Type);
|
||||
if (mem == NULL)
|
||||
return NULL;
|
||||
|
||||
view = &mem->view;
|
||||
flags = PyBUF_FULL_RO;
|
||||
switch(buffertype) {
|
||||
case PyBUF_WRITE:
|
||||
flags = PyBUF_FULL;
|
||||
break;
|
||||
}
|
||||
|
||||
if (PyObject_GetBuffer(obj, view, flags) != 0) {
|
||||
Py_DECREF(mem);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (PyBuffer_IsContiguous(view, fort)) {
|
||||
/* no copy needed */
|
||||
Py_INCREF(obj);
|
||||
mem->base = obj;
|
||||
_PyObject_GC_TRACK(mem);
|
||||
return (PyObject *)mem;
|
||||
}
|
||||
/* otherwise a copy is needed */
|
||||
if (buffertype == PyBUF_WRITE) {
|
||||
Py_DECREF(mem);
|
||||
PyErr_SetString(PyExc_BufferError,
|
||||
"writable contiguous buffer requested "
|
||||
"for a non-contiguousobject.");
|
||||
return NULL;
|
||||
}
|
||||
bytes = PyBytes_FromStringAndSize(NULL, view->len);
|
||||
if (bytes == NULL) {
|
||||
Py_DECREF(mem);
|
||||
return NULL;
|
||||
}
|
||||
dest = PyBytes_AS_STRING(bytes);
|
||||
/* different copying strategy depending on whether
|
||||
or not any pointer de-referencing is needed
|
||||
*/
|
||||
/* strided or in-direct copy */
|
||||
if (view->suboffsets==NULL) {
|
||||
_strided_copy_nd(dest, view->buf, view->ndim, view->shape,
|
||||
view->strides, view->itemsize, fort);
|
||||
}
|
||||
else {
|
||||
if (_indirect_copy_nd(dest, view, fort) < 0) {
|
||||
Py_DECREF(bytes);
|
||||
Py_DECREF(mem);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (buffertype == PyBUF_SHADOW) {
|
||||
/* return a shadowed memory-view object */
|
||||
view->buf = dest;
|
||||
mem->base = PyTuple_Pack(2, obj, bytes);
|
||||
Py_DECREF(bytes);
|
||||
if (mem->base == NULL) {
|
||||
Py_DECREF(mem);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
PyBuffer_Release(view); /* XXX ? */
|
||||
/* steal the reference */
|
||||
mem->base = bytes;
|
||||
}
|
||||
_PyObject_GC_TRACK(mem);
|
||||
return (PyObject *)mem;
|
||||
}
|
||||
|
||||
|
||||
static PyObject *
|
||||
memory_format_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return PyString_FromString(self->view.format);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_itemsize_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return PyLong_FromSsize_t(self->view.itemsize);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
_IntTupleFromSsizet(int len, Py_ssize_t *vals)
|
||||
{
|
||||
int i;
|
||||
PyObject *o;
|
||||
PyObject *intTuple;
|
||||
|
||||
if (vals == NULL) {
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
intTuple = PyTuple_New(len);
|
||||
if (!intTuple) return NULL;
|
||||
for(i=0; i<len; i++) {
|
||||
o = PyLong_FromSsize_t(vals[i]);
|
||||
if (!o) {
|
||||
Py_DECREF(intTuple);
|
||||
return NULL;
|
||||
}
|
||||
PyTuple_SET_ITEM(intTuple, i, o);
|
||||
}
|
||||
return intTuple;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_shape_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return _IntTupleFromSsizet(self->view.ndim, self->view.shape);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_strides_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return _IntTupleFromSsizet(self->view.ndim, self->view.strides);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_suboffsets_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return _IntTupleFromSsizet(self->view.ndim, self->view.suboffsets);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_readonly_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return PyBool_FromLong(self->view.readonly);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_ndim_get(PyMemoryViewObject *self)
|
||||
{
|
||||
return PyLong_FromLong(self->view.ndim);
|
||||
}
|
||||
|
||||
static PyGetSetDef memory_getsetlist[] ={
|
||||
{"format", (getter)memory_format_get, NULL, NULL},
|
||||
{"itemsize", (getter)memory_itemsize_get, NULL, NULL},
|
||||
{"shape", (getter)memory_shape_get, NULL, NULL},
|
||||
{"strides", (getter)memory_strides_get, NULL, NULL},
|
||||
{"suboffsets", (getter)memory_suboffsets_get, NULL, NULL},
|
||||
{"readonly", (getter)memory_readonly_get, NULL, NULL},
|
||||
{"ndim", (getter)memory_ndim_get, NULL, NULL},
|
||||
{NULL, NULL, NULL, NULL},
|
||||
};
|
||||
|
||||
|
||||
static PyObject *
|
||||
memory_tobytes(PyMemoryViewObject *self, PyObject *noargs)
|
||||
{
|
||||
Py_buffer view;
|
||||
PyObject *res;
|
||||
|
||||
if (PyObject_GetBuffer((PyObject *)self, &view, PyBUF_SIMPLE) < 0)
|
||||
return NULL;
|
||||
|
||||
res = PyBytes_FromStringAndSize(NULL, view.len);
|
||||
PyBuffer_ToContiguous(PyBytes_AS_STRING(res), &view, view.len, 'C');
|
||||
PyBuffer_Release(&view);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* TODO: rewrite this function using the struct module to unpack
|
||||
each buffer item */
|
||||
|
||||
static PyObject *
|
||||
memory_tolist(PyMemoryViewObject *mem, PyObject *noargs)
|
||||
{
|
||||
Py_buffer *view = &(mem->view);
|
||||
Py_ssize_t i;
|
||||
PyObject *res, *item;
|
||||
char *buf;
|
||||
|
||||
if (strcmp(view->format, "B") || view->itemsize != 1) {
|
||||
PyErr_SetString(PyExc_NotImplementedError,
|
||||
"tolist() only supports byte views");
|
||||
return NULL;
|
||||
}
|
||||
if (view->ndim != 1) {
|
||||
PyErr_SetString(PyExc_NotImplementedError,
|
||||
"tolist() only supports one-dimensional objects");
|
||||
return NULL;
|
||||
}
|
||||
res = PyList_New(view->len);
|
||||
if (res == NULL)
|
||||
return NULL;
|
||||
buf = view->buf;
|
||||
for (i = 0; i < view->len; i++) {
|
||||
item = PyInt_FromLong((unsigned char) *buf);
|
||||
if (item == NULL) {
|
||||
Py_DECREF(res);
|
||||
return NULL;
|
||||
}
|
||||
PyList_SET_ITEM(res, i, item);
|
||||
buf++;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static PyMethodDef memory_methods[] = {
|
||||
{"tobytes", (PyCFunction)memory_tobytes, METH_NOARGS, NULL},
|
||||
{"tolist", (PyCFunction)memory_tolist, METH_NOARGS, NULL},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
|
||||
static void
|
||||
memory_dealloc(PyMemoryViewObject *self)
|
||||
{
|
||||
_PyObject_GC_UNTRACK(self);
|
||||
if (self->view.obj != NULL) {
|
||||
if (self->base && PyTuple_Check(self->base)) {
|
||||
/* Special case when first element is generic object
|
||||
with buffer interface and the second element is a
|
||||
contiguous "shadow" that must be copied back into
|
||||
the data areay of the first tuple element before
|
||||
releasing the buffer on the first element.
|
||||
*/
|
||||
|
||||
PyObject_CopyData(PyTuple_GET_ITEM(self->base,0),
|
||||
PyTuple_GET_ITEM(self->base,1));
|
||||
|
||||
/* The view member should have readonly == -1 in
|
||||
this instance indicating that the memory can
|
||||
be "locked" and was locked and will be unlocked
|
||||
again after this call.
|
||||
*/
|
||||
PyBuffer_Release(&(self->view));
|
||||
}
|
||||
else {
|
||||
PyBuffer_Release(&(self->view));
|
||||
}
|
||||
Py_CLEAR(self->base);
|
||||
}
|
||||
PyObject_GC_Del(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_repr(PyMemoryViewObject *self)
|
||||
{
|
||||
return PyString_FromFormat("<memory at %p>", self);
|
||||
}
|
||||
|
||||
/* Sequence methods */
|
||||
static Py_ssize_t
|
||||
memory_length(PyMemoryViewObject *self)
|
||||
{
|
||||
return get_shape0(&self->view);
|
||||
}
|
||||
|
||||
/* Alternate version of memory_subcript that only accepts indices.
|
||||
Used by PySeqIter_New().
|
||||
*/
|
||||
static PyObject *
|
||||
memory_item(PyMemoryViewObject *self, Py_ssize_t result)
|
||||
{
|
||||
Py_buffer *view = &(self->view);
|
||||
|
||||
if (view->ndim == 0) {
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"invalid indexing of 0-dim memory");
|
||||
return NULL;
|
||||
}
|
||||
if (view->ndim == 1) {
|
||||
/* Return a bytes object */
|
||||
char *ptr;
|
||||
ptr = (char *)view->buf;
|
||||
if (result < 0) {
|
||||
result += get_shape0(view);
|
||||
}
|
||||
if ((result < 0) || (result >= get_shape0(view))) {
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"index out of bounds");
|
||||
return NULL;
|
||||
}
|
||||
if (view->strides == NULL)
|
||||
ptr += view->itemsize * result;
|
||||
else
|
||||
ptr += view->strides[0] * result;
|
||||
if (view->suboffsets != NULL &&
|
||||
view->suboffsets[0] >= 0) {
|
||||
ptr = *((char **)ptr) + view->suboffsets[0];
|
||||
}
|
||||
return PyBytes_FromStringAndSize(ptr, view->itemsize);
|
||||
} else {
|
||||
/* Return a new memory-view object */
|
||||
Py_buffer newview;
|
||||
memset(&newview, 0, sizeof(newview));
|
||||
/* XXX: This needs to be fixed so it actually returns a sub-view */
|
||||
return PyMemoryView_FromBuffer(&newview);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
mem[obj] returns a bytes object holding the data for one element if
|
||||
obj fully indexes the memory view or another memory-view object
|
||||
if it does not.
|
||||
|
||||
0-d memory-view objects can be referenced using ... or () but
|
||||
not with anything else.
|
||||
*/
|
||||
static PyObject *
|
||||
memory_subscript(PyMemoryViewObject *self, PyObject *key)
|
||||
{
|
||||
Py_buffer *view;
|
||||
view = &(self->view);
|
||||
|
||||
if (view->ndim == 0) {
|
||||
if (key == Py_Ellipsis ||
|
||||
(PyTuple_Check(key) && PyTuple_GET_SIZE(key)==0)) {
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"invalid indexing of 0-dim memory");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (PyIndex_Check(key)) {
|
||||
Py_ssize_t result;
|
||||
result = PyNumber_AsSsize_t(key, NULL);
|
||||
if (result == -1 && PyErr_Occurred())
|
||||
return NULL;
|
||||
return memory_item(self, result);
|
||||
}
|
||||
else if (PySlice_Check(key)) {
|
||||
Py_ssize_t start, stop, step, slicelength;
|
||||
|
||||
if (PySlice_GetIndicesEx((PySliceObject*)key, get_shape0(view),
|
||||
&start, &stop, &step, &slicelength) < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (step == 1 && view->ndim == 1) {
|
||||
Py_buffer newview;
|
||||
void *newbuf = (char *) view->buf
|
||||
+ start * view->itemsize;
|
||||
int newflags = view->readonly
|
||||
? PyBUF_CONTIG_RO : PyBUF_CONTIG;
|
||||
|
||||
/* XXX There should be an API to create a subbuffer */
|
||||
if (view->obj != NULL) {
|
||||
if (PyObject_GetBuffer(view->obj, &newview, newflags) == -1)
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
newview = *view;
|
||||
}
|
||||
newview.buf = newbuf;
|
||||
newview.len = slicelength * newview.itemsize;
|
||||
newview.format = view->format;
|
||||
newview.shape = &(newview.smalltable[0]);
|
||||
newview.shape[0] = slicelength;
|
||||
newview.strides = &(newview.itemsize);
|
||||
return PyMemoryView_FromBuffer(&newview);
|
||||
}
|
||||
PyErr_SetNone(PyExc_NotImplementedError);
|
||||
return NULL;
|
||||
}
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"cannot index memory using \"%.200s\"",
|
||||
key->ob_type->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/* Need to support assigning memory if we can */
|
||||
static int
|
||||
memory_ass_sub(PyMemoryViewObject *self, PyObject *key, PyObject *value)
|
||||
{
|
||||
Py_ssize_t start, len, bytelen;
|
||||
Py_buffer srcview;
|
||||
Py_buffer *view = &(self->view);
|
||||
char *srcbuf, *destbuf;
|
||||
|
||||
if (view->readonly) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"cannot modify read-only memory");
|
||||
return -1;
|
||||
}
|
||||
if (value == NULL) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"cannot delete memory");
|
||||
return -1;
|
||||
}
|
||||
if (view->ndim != 1) {
|
||||
PyErr_SetNone(PyExc_NotImplementedError);
|
||||
return -1;
|
||||
}
|
||||
if (PyIndex_Check(key)) {
|
||||
start = PyNumber_AsSsize_t(key, NULL);
|
||||
if (start == -1 && PyErr_Occurred())
|
||||
return -1;
|
||||
if (start < 0) {
|
||||
start += get_shape0(view);
|
||||
}
|
||||
if ((start < 0) || (start >= get_shape0(view))) {
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"index out of bounds");
|
||||
return -1;
|
||||
}
|
||||
len = 1;
|
||||
}
|
||||
else if (PySlice_Check(key)) {
|
||||
Py_ssize_t stop, step;
|
||||
|
||||
if (PySlice_GetIndicesEx((PySliceObject*)key, get_shape0(view),
|
||||
&start, &stop, &step, &len) < 0) {
|
||||
return -1;
|
||||
}
|
||||
if (step != 1) {
|
||||
PyErr_SetNone(PyExc_NotImplementedError);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"cannot index memory using \"%.200s\"",
|
||||
key->ob_type->tp_name);
|
||||
return -1;
|
||||
}
|
||||
if (PyObject_GetBuffer(value, &srcview, PyBUF_CONTIG_RO) == -1) {
|
||||
return -1;
|
||||
}
|
||||
/* XXX should we allow assignment of different item sizes
|
||||
as long as the byte length is the same?
|
||||
(e.g. assign 2 shorts to a 4-byte slice) */
|
||||
if (srcview.itemsize != view->itemsize) {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"mismatching item sizes for \"%.200s\" and \"%.200s\"",
|
||||
view->obj->ob_type->tp_name, srcview.obj->ob_type->tp_name);
|
||||
goto _error;
|
||||
}
|
||||
bytelen = len * view->itemsize;
|
||||
if (bytelen != srcview.len) {
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"cannot modify size of memoryview object");
|
||||
goto _error;
|
||||
}
|
||||
/* Do the actual copy */
|
||||
destbuf = (char *) view->buf + start * view->itemsize;
|
||||
srcbuf = (char *) srcview.buf;
|
||||
if (destbuf + bytelen < srcbuf || srcbuf + bytelen < destbuf)
|
||||
/* No overlapping */
|
||||
memcpy(destbuf, srcbuf, bytelen);
|
||||
else
|
||||
memmove(destbuf, srcbuf, bytelen);
|
||||
|
||||
PyBuffer_Release(&srcview);
|
||||
return 0;
|
||||
|
||||
_error:
|
||||
PyBuffer_Release(&srcview);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
memory_richcompare(PyObject *v, PyObject *w, int op)
|
||||
{
|
||||
Py_buffer vv, ww;
|
||||
int equal = 0;
|
||||
PyObject *res;
|
||||
|
||||
vv.obj = NULL;
|
||||
ww.obj = NULL;
|
||||
if (op != Py_EQ && op != Py_NE)
|
||||
goto _notimpl;
|
||||
if (PyObject_GetBuffer(v, &vv, PyBUF_CONTIG_RO) == -1) {
|
||||
PyErr_Clear();
|
||||
goto _notimpl;
|
||||
}
|
||||
if (PyObject_GetBuffer(w, &ww, PyBUF_CONTIG_RO) == -1) {
|
||||
PyErr_Clear();
|
||||
goto _notimpl;
|
||||
}
|
||||
|
||||
if (vv.itemsize != ww.itemsize || vv.len != ww.len)
|
||||
goto _end;
|
||||
|
||||
equal = !memcmp(vv.buf, ww.buf, vv.len);
|
||||
|
||||
_end:
|
||||
PyBuffer_Release(&vv);
|
||||
PyBuffer_Release(&ww);
|
||||
if ((equal && op == Py_EQ) || (!equal && op == Py_NE))
|
||||
res = Py_True;
|
||||
else
|
||||
res = Py_False;
|
||||
Py_INCREF(res);
|
||||
return res;
|
||||
|
||||
_notimpl:
|
||||
PyBuffer_Release(&vv);
|
||||
PyBuffer_Release(&ww);
|
||||
Py_INCREF(Py_NotImplemented);
|
||||
return Py_NotImplemented;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
memory_traverse(PyMemoryViewObject *self, visitproc visit, void *arg)
|
||||
{
|
||||
if (self->base != NULL)
|
||||
Py_VISIT(self->base);
|
||||
if (self->view.obj != NULL)
|
||||
Py_VISIT(self->view.obj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
memory_clear(PyMemoryViewObject *self)
|
||||
{
|
||||
Py_CLEAR(self->base);
|
||||
PyBuffer_Release(&self->view);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* As mapping */
|
||||
static PyMappingMethods memory_as_mapping = {
|
||||
(lenfunc)memory_length, /* mp_length */
|
||||
(binaryfunc)memory_subscript, /* mp_subscript */
|
||||
(objobjargproc)memory_ass_sub, /* mp_ass_subscript */
|
||||
};
|
||||
|
||||
static PySequenceMethods memory_as_sequence = {
|
||||
0, /* sq_length */
|
||||
0, /* sq_concat */
|
||||
0, /* sq_repeat */
|
||||
(ssizeargfunc)memory_item, /* sq_item */
|
||||
};
|
||||
|
||||
/* Buffer methods */
|
||||
static PyBufferProcs memory_as_buffer = {
|
||||
0, /* bf_getreadbuffer */
|
||||
0, /* bf_getwritebuffer */
|
||||
0, /* bf_getsegcount */
|
||||
0, /* bf_getcharbuffer */
|
||||
(getbufferproc)memory_getbuf, /* bf_getbuffer */
|
||||
(releasebufferproc)memory_releasebuf, /* bf_releasebuffer */
|
||||
};
|
||||
|
||||
|
||||
PyTypeObject PyMemoryView_Type = {
|
||||
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
||||
"memoryview",
|
||||
sizeof(PyMemoryViewObject),
|
||||
0,
|
||||
(destructor)memory_dealloc, /* tp_dealloc */
|
||||
0, /* tp_print */
|
||||
0, /* tp_getattr */
|
||||
0, /* tp_setattr */
|
||||
0, /* tp_compare */
|
||||
(reprfunc)memory_repr, /* tp_repr */
|
||||
0, /* tp_as_number */
|
||||
&memory_as_sequence, /* tp_as_sequence */
|
||||
&memory_as_mapping, /* tp_as_mapping */
|
||||
0, /* tp_hash */
|
||||
0, /* tp_call */
|
||||
0, /* tp_str */
|
||||
PyObject_GenericGetAttr, /* tp_getattro */
|
||||
0, /* tp_setattro */
|
||||
&memory_as_buffer, /* tp_as_buffer */
|
||||
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
||||
Py_TPFLAGS_HAVE_NEWBUFFER, /* tp_flags */
|
||||
memory_doc, /* tp_doc */
|
||||
(traverseproc)memory_traverse, /* tp_traverse */
|
||||
(inquiry)memory_clear, /* tp_clear */
|
||||
memory_richcompare, /* tp_richcompare */
|
||||
0, /* tp_weaklistoffset */
|
||||
0, /* tp_iter */
|
||||
0, /* tp_iternext */
|
||||
memory_methods, /* tp_methods */
|
||||
0, /* tp_members */
|
||||
memory_getsetlist, /* 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 */
|
||||
memory_new, /* tp_new */
|
||||
};
|
||||
Reference in New Issue
Block a user