AppPkg/Applications/Python/Python-2.7.2/Objects/memoryobject.c

   1
   2 /* Memoryview object implementation */
   3
   4 #include "Python.h"
   5
   6 static Py_ssize_t
   7 get_shape0(Py_buffer *buf)
   8 {
   9     if (buf->shape != NULL)
  10         return buf->shape[0];
  11     if (buf->ndim == 0)
  12         return 1;
  13     PyErr_SetString(PyExc_TypeError,
  14         "exported buffer does not have any shape information associated "
  15         "to it");
  16     return -1;
  17 }
  18
  19 static void
  20 dup_buffer(Py_buffer *dest, Py_buffer *src)
  21 {
  22     *dest = *src;
  23     if (src->ndim == 1 && src->shape != NULL) {
  24         dest->shape = &(dest->smalltable[0]);
  25         dest->shape[0] = get_shape0(src);
  26     }
  27     if (src->ndim == 1 && src->strides != NULL) {
  28         dest->strides = &(dest->smalltable[1]);
  29         dest->strides[0] = src->strides[0];
  30     }
  31 }
  32
  33 static int
  34 memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags)
  35 {
  36     int res = 0;
  37     if (self->view.obj != NULL)
  38         res = PyObject_GetBuffer(self->view.obj, view, flags);
  39     if (view)
  40         dup_buffer(view, &self->view);
  41     return res;
  42 }
  43
  44 static void
  45 memory_releasebuf(PyMemoryViewObject *self, Py_buffer *view)
  46 {
  47     PyBuffer_Release(view);
  48 }
  49
  50 PyDoc_STRVAR(memory_doc,
  51 "memoryview(object)\n\
  52 \n\
  53 Create a new memoryview object which references the given object.");
  54
  55 PyObject *
  56 PyMemoryView_FromBuffer(Py_buffer *info)
  57 {
  58     PyMemoryViewObject *mview;
  59
  60     mview = (PyMemoryViewObject *)
  61         PyObject_GC_New(PyMemoryViewObject, &PyMemoryView_Type);
  62     if (mview == NULL)
  63         return NULL;
  64     mview->base = NULL;
  65     dup_buffer(&mview->view, info);
  66     /* NOTE: mview->view.obj should already have been incref'ed as
  67        part of PyBuffer_FillInfo(). */
  68     _PyObject_GC_TRACK(mview);
  69     return (PyObject *)mview;
  70 }
  71
  72 PyObject *
  73 PyMemoryView_FromObject(PyObject *base)
  74 {
  75     PyMemoryViewObject *mview;
  76     Py_buffer view;
  77
  78     if (!PyObject_CheckBuffer(base)) {
  79         PyErr_SetString(PyExc_TypeError,
  80             "cannot make memory view because object does "
  81             "not have the buffer interface");
  82         return NULL;
  83     }
  84
  85     if (PyObject_GetBuffer(base, &view, PyBUF_FULL_RO) < 0)
  86         return NULL;
  87
  88     mview = (PyMemoryViewObject *)PyMemoryView_FromBuffer(&view);
  89     if (mview == NULL) {
  90         PyBuffer_Release(&view);
  91         return NULL;
  92     }
  93
  94     mview->base = base;
  95     Py_INCREF(base);
  96     return (PyObject *)mview;
  97 }
  98
  99 static PyObject *
 100 memory_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 101 {
 102     PyObject *obj;
 103     static char *kwlist[] = {"object", 0};
 104
 105     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:memoryview", kwlist,
 106                                      &obj)) {
 107         return NULL;
 108     }
 109
 110     return PyMemoryView_FromObject(obj);
 111 }
 112
 113
 114 static void
 115 _strided_copy_nd(char *dest, char *src, int nd, Py_ssize_t *shape,
 116                  Py_ssize_t *strides, Py_ssize_t itemsize, char fort)
 117 {
 118     int k;
 119     Py_ssize_t outstride;
 120
 121     if (nd==0) {
 122         memcpy(dest, src, itemsize);
 123     }
 124     else if (nd == 1) {
 125         for (k = 0; k<shape[0]; k++) {
 126             memcpy(dest, src, itemsize);
 127             dest += itemsize;
 128             src += strides[0];
 129         }
 130     }
 131     else {
 132         if (fort == 'F') {
 133             /* Copy first dimension first,
 134                second dimension second, etc...
 135                Set up the recursive loop backwards so that final
 136                dimension is actually copied last.
 137             */
 138             outstride = itemsize;
 139             for (k=1; k<nd-1;k++) {
 140                 outstride *= shape[k];
 141             }
 142             for (k=0; k<shape[nd-1]; k++) {
 143                 _strided_copy_nd(dest, src, nd-1, shape,
 144                                  strides, itemsize, fort);
 145                 dest += outstride;
 146                 src += strides[nd-1];
 147             }
 148         }
 149
 150         else {
 151             /* Copy last dimension first,
 152                second-to-last dimension second, etc.
 153                Set up the recursion so that the
 154                first dimension is copied last
 155             */
 156             outstride = itemsize;
 157             for (k=1; k < nd; k++) {
 158                 outstride *= shape[k];
 159             }
 160             for (k=0; k<shape[0]; k++) {
 161                 _strided_copy_nd(dest, src, nd-1, shape+1,
 162                                  strides+1, itemsize,
 163                                  fort);
 164                 dest += outstride;
 165                 src += strides[0];
 166             }
 167         }
 168     }
 169     return;
 170 }
 171
 172 static int
 173 _indirect_copy_nd(char *dest, Py_buffer *view, char fort)
 174 {
 175     Py_ssize_t *indices;
 176     int k;
 177     Py_ssize_t elements;
 178     char *ptr;
 179     void (*func)(int, Py_ssize_t *, const Py_ssize_t *);
 180
 181     if (view->ndim > PY_SSIZE_T_MAX / sizeof(Py_ssize_t)) {
 182         PyErr_NoMemory();
 183         return -1;
 184     }
 185
 186     indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view->ndim);
 187     if (indices == NULL) {
 188         PyErr_NoMemory();
 189         return -1;
 190     }
 191     for (k=0; k<view->ndim;k++) {
 192         indices[k] = 0;
 193     }
 194
 195     elements = 1;
 196     for (k=0; k<view->ndim; k++) {
 197         elements *= view->shape[k];
 198     }
 199     if (fort == 'F') {
 200         func = _Py_add_one_to_index_F;
 201     }
 202     else {
 203         func = _Py_add_one_to_index_C;
 204     }
 205     while (elements--) {
 206         func(view->ndim, indices, view->shape);
 207         ptr = PyBuffer_GetPointer(view, indices);
 208         memcpy(dest, ptr, view->itemsize);
 209         dest += view->itemsize;
 210     }
 211
 212     PyMem_Free(indices);
 213     return 0;
 214 }
 215
 216 /*
 217    Get a the data from an object as a contiguous chunk of memory (in
 218    either 'C' or 'F'ortran order) even if it means copying it into a
 219    separate memory area.
 220
 221    Returns a new reference to a Memory view object.  If no copy is needed,
 222    the memory view object points to the original memory and holds a
 223    lock on the original.  If a copy is needed, then the memory view object
 224    points to a brand-new Bytes object (and holds a memory lock on it).
 225
 226    buffertype
 227
 228    PyBUF_READ  buffer only needs to be read-only
 229    PyBUF_WRITE buffer needs to be writable (give error if not contiguous)
 230    PyBUF_SHADOW buffer needs to be writable so shadow it with
 231                 a contiguous buffer if it is not. The view will point to
 232                 the shadow buffer which can be written to and then
 233                 will be copied back into the other buffer when the memory
 234                 view is de-allocated.  While the shadow buffer is
 235                 being used, it will have an exclusive write lock on
 236                 the original buffer.
 237  */
 238
 239 PyObject *
 240 PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char fort)
 241 {
 242     PyMemoryViewObject *mem;
 243     PyObject *bytes;
 244     Py_buffer *view;
 245     int flags;
 246     char *dest;
 247
 248     if (!PyObject_CheckBuffer(obj)) {
 249         PyErr_SetString(PyExc_TypeError,
 250                         "object does not have the buffer interface");
 251         return NULL;
 252     }
 253
 254     mem = PyObject_GC_New(PyMemoryViewObject, &PyMemoryView_Type);
 255     if (mem == NULL)
 256         return NULL;
 257
 258     view = &mem->view;
 259     flags = PyBUF_FULL_RO;
 260     switch(buffertype) {
 261     case PyBUF_WRITE:
 262         flags = PyBUF_FULL;
 263         break;
 264     }
 265
 266     if (PyObject_GetBuffer(obj, view, flags) != 0) {
 267         Py_DECREF(mem);
 268         return NULL;
 269     }
 270
 271     if (PyBuffer_IsContiguous(view, fort)) {
 272         /* no copy needed */
 273         Py_INCREF(obj);
 274         mem->base = obj;
 275         _PyObject_GC_TRACK(mem);
 276         return (PyObject *)mem;
 277     }
 278     /* otherwise a copy is needed */
 279     if (buffertype == PyBUF_WRITE) {
 280         Py_DECREF(mem);
 281         PyErr_SetString(PyExc_BufferError,
 282                         "writable contiguous buffer requested "
 283                         "for a non-contiguousobject.");
 284         return NULL;
 285     }
 286     bytes = PyBytes_FromStringAndSize(NULL, view->len);
 287     if (bytes == NULL) {
 288         Py_DECREF(mem);
 289         return NULL;
 290     }
 291     dest = PyBytes_AS_STRING(bytes);
 292     /* different copying strategy depending on whether
 293        or not any pointer de-referencing is needed
 294     */
 295     /* strided or in-direct copy */
 296     if (view->suboffsets==NULL) {
 297         _strided_copy_nd(dest, view->buf, view->ndim, view->shape,
 298                          view->strides, view->itemsize, fort);
 299     }
 300     else {
 301         if (_indirect_copy_nd(dest, view, fort) < 0) {
 302             Py_DECREF(bytes);
 303             Py_DECREF(mem);
 304             return NULL;
 305         }
 306     }
 307     if (buffertype == PyBUF_SHADOW) {
 308         /* return a shadowed memory-view object */
 309         view->buf = dest;
 310         mem->base = PyTuple_Pack(2, obj, bytes);
 311         Py_DECREF(bytes);
 312         if (mem->base == NULL) {
 313             Py_DECREF(mem);
 314             return NULL;
 315         }
 316     }
 317     else {
 318         PyBuffer_Release(view);  /* XXX ? */
 319         /* steal the reference */
 320         mem->base = bytes;
 321     }
 322     _PyObject_GC_TRACK(mem);
 323     return (PyObject *)mem;
 324 }
 325
 326
 327 static PyObject *
 328 memory_format_get(PyMemoryViewObject *self)
 329 {
 330     return PyString_FromString(self->view.format);
 331 }
 332
 333 static PyObject *
 334 memory_itemsize_get(PyMemoryViewObject *self)
 335 {
 336     return PyLong_FromSsize_t(self->view.itemsize);
 337 }
 338
 339 static PyObject *
 340 _IntTupleFromSsizet(int len, Py_ssize_t *vals)
 341 {
 342     int i;
 343     PyObject *o;
 344     PyObject *intTuple;
 345
 346     if (vals == NULL) {
 347         Py_INCREF(Py_None);
 348         return Py_None;
 349     }
 350     intTuple = PyTuple_New(len);
 351     if (!intTuple) return NULL;
 352     for(i=0; i<len; i++) {
 353         o = PyLong_FromSsize_t(vals[i]);
 354         if (!o) {
 355             Py_DECREF(intTuple);
 356             return NULL;
 357         }
 358         PyTuple_SET_ITEM(intTuple, i, o);
 359     }
 360     return intTuple;
 361 }
 362
 363 static PyObject *
 364 memory_shape_get(PyMemoryViewObject *self)
 365 {
 366     return _IntTupleFromSsizet(self->view.ndim, self->view.shape);
 367 }
 368
 369 static PyObject *
 370 memory_strides_get(PyMemoryViewObject *self)
 371 {
 372     return _IntTupleFromSsizet(self->view.ndim, self->view.strides);
 373 }
 374
 375 static PyObject *
 376 memory_suboffsets_get(PyMemoryViewObject *self)
 377 {
 378     return _IntTupleFromSsizet(self->view.ndim, self->view.suboffsets);
 379 }
 380
 381 static PyObject *
 382 memory_readonly_get(PyMemoryViewObject *self)
 383 {
 384     return PyBool_FromLong(self->view.readonly);
 385 }
 386
 387 static PyObject *
 388 memory_ndim_get(PyMemoryViewObject *self)
 389 {
 390     return PyLong_FromLong(self->view.ndim);
 391 }
 392
 393 static PyGetSetDef memory_getsetlist[] ={
 394     {"format",          (getter)memory_format_get,      NULL, NULL},
 395     {"itemsize",        (getter)memory_itemsize_get,    NULL, NULL},
 396     {"shape",           (getter)memory_shape_get,       NULL, NULL},
 397     {"strides",         (getter)memory_strides_get,     NULL, NULL},
 398     {"suboffsets",      (getter)memory_suboffsets_get,  NULL, NULL},
 399     {"readonly",        (getter)memory_readonly_get,    NULL, NULL},
 400     {"ndim",            (getter)memory_ndim_get,        NULL, NULL},
 401     {NULL, NULL, NULL, NULL},
 402 };
 403
 404
 405 static PyObject *
 406 memory_tobytes(PyMemoryViewObject *self, PyObject *noargs)
 407 {
 408     Py_buffer view;
 409     PyObject *res;
 410
 411     if (PyObject_GetBuffer((PyObject *)self, &view, PyBUF_SIMPLE) < 0)
 412         return NULL;
 413
 414     res = PyBytes_FromStringAndSize(NULL, view.len);
 415     PyBuffer_ToContiguous(PyBytes_AS_STRING(res), &view, view.len, 'C');
 416     PyBuffer_Release(&view);
 417     return res;
 418 }
 419
 420 /* TODO: rewrite this function using the struct module to unpack
 421    each buffer item */
 422
 423 static PyObject *
 424 memory_tolist(PyMemoryViewObject *mem, PyObject *noargs)
 425 {
 426     Py_buffer *view = &(mem->view);
 427     Py_ssize_t i;
 428     PyObject *res, *item;
 429     char *buf;
 430
 431     if (strcmp(view->format, "B") || view->itemsize != 1) {
 432         PyErr_SetString(PyExc_NotImplementedError,
 433                 "tolist() only supports byte views");
 434         return NULL;
 435     }
 436     if (view->ndim != 1) {
 437         PyErr_SetString(PyExc_NotImplementedError,
 438                 "tolist() only supports one-dimensional objects");
 439         return NULL;
 440     }
 441     res = PyList_New(view->len);
 442     if (res == NULL)
 443         return NULL;
 444     buf = view->buf;
 445     for (i = 0; i < view->len; i++) {
 446         item = PyInt_FromLong((unsigned char) *buf);
 447         if (item == NULL) {
 448             Py_DECREF(res);
 449             return NULL;
 450         }
 451         PyList_SET_ITEM(res, i, item);
 452         buf++;
 453     }
 454     return res;
 455 }
 456
 457 static PyMethodDef memory_methods[] = {
 458     {"tobytes", (PyCFunction)memory_tobytes, METH_NOARGS, NULL},
 459     {"tolist", (PyCFunction)memory_tolist, METH_NOARGS, NULL},
 460     {NULL,          NULL}           /* sentinel */
 461 };
 462
 463
 464 static void
 465 memory_dealloc(PyMemoryViewObject *self)
 466 {
 467     _PyObject_GC_UNTRACK(self);
 468     if (self->view.obj != NULL) {
 469         if (self->base && PyTuple_Check(self->base)) {
 470             /* Special case when first element is generic object
 471                with buffer interface and the second element is a
 472                contiguous "shadow" that must be copied back into
 473                the data areay of the first tuple element before
 474                releasing the buffer on the first element.
 475             */
 476
 477             PyObject_CopyData(PyTuple_GET_ITEM(self->base,0),
 478                               PyTuple_GET_ITEM(self->base,1));
 479
 480             /* The view member should have readonly == -1 in
 481                this instance indicating that the memory can
 482                be "locked" and was locked and will be unlocked
 483                again after this call.
 484             */
 485             PyBuffer_Release(&(self->view));
 486         }
 487         else {
 488             PyBuffer_Release(&(self->view));
 489         }
 490         Py_CLEAR(self->base);
 491     }
 492     PyObject_GC_Del(self);
 493 }
 494
 495 static PyObject *
 496 memory_repr(PyMemoryViewObject *self)
 497 {
 498     return PyString_FromFormat("<memory at %p>", self);
 499 }
 500
 501 /* Sequence methods */
 502 static Py_ssize_t
 503 memory_length(PyMemoryViewObject *self)
 504 {
 505     return get_shape0(&self->view);
 506 }
 507
 508 /* Alternate version of memory_subcript that only accepts indices.
 509    Used by PySeqIter_New().
 510 */
 511 static PyObject *
 512 memory_item(PyMemoryViewObject *self, Py_ssize_t result)
 513 {
 514     Py_buffer *view = &(self->view);
 515
 516     if (view->ndim == 0) {
 517         PyErr_SetString(PyExc_IndexError,
 518                         "invalid indexing of 0-dim memory");
 519         return NULL;
 520     }
 521     if (view->ndim == 1) {
 522         /* Return a bytes object */
 523         char *ptr;
 524         ptr = (char *)view->buf;
 525         if (result < 0) {
 526             result += get_shape0(view);
 527         }
 528         if ((result < 0) || (result >= get_shape0(view))) {
 529             PyErr_SetString(PyExc_IndexError,
 530                                 "index out of bounds");
 531             return NULL;
 532         }
 533         if (view->strides == NULL)
 534             ptr += view->itemsize * result;
 535         else
 536             ptr += view->strides[0] * result;
 537         if (view->suboffsets != NULL &&
 538             view->suboffsets[0] >= 0) {
 539             ptr = *((char **)ptr) + view->suboffsets[0];
 540         }
 541         return PyBytes_FromStringAndSize(ptr, view->itemsize);
 542     } else {
 543         /* Return a new memory-view object */
 544         Py_buffer newview;
 545         memset(&newview, 0, sizeof(newview));
 546         /* XXX:  This needs to be fixed so it actually returns a sub-view */
 547         return PyMemoryView_FromBuffer(&newview);
 548     }
 549 }
 550
 551 /*
 552   mem[obj] returns a bytes object holding the data for one element if
 553            obj fully indexes the memory view or another memory-view object
 554            if it does not.
 555
 556            0-d memory-view objects can be referenced using ... or () but
 557            not with anything else.
 558  */
 559 static PyObject *
 560 memory_subscript(PyMemoryViewObject *self, PyObject *key)
 561 {
 562     Py_buffer *view;
 563     view = &(self->view);
 564
 565     if (view->ndim == 0) {
 566         if (key == Py_Ellipsis ||
 567             (PyTuple_Check(key) && PyTuple_GET_SIZE(key)==0)) {
 568             Py_INCREF(self);
 569             return (PyObject *)self;
 570         }
 571         else {
 572             PyErr_SetString(PyExc_IndexError,
 573                                 "invalid indexing of 0-dim memory");
 574             return NULL;
 575         }
 576     }
 577     if (PyIndex_Check(key)) {
 578         Py_ssize_t result;
 579         result = PyNumber_AsSsize_t(key, NULL);
 580         if (result == -1 && PyErr_Occurred())
 581                 return NULL;
 582         return memory_item(self, result);
 583     }
 584     else if (PySlice_Check(key)) {
 585         Py_ssize_t start, stop, step, slicelength;
 586
 587         if (PySlice_GetIndicesEx((PySliceObject*)key, get_shape0(view),
 588                                  &start, &stop, &step, &slicelength) < 0) {
 589             return NULL;
 590         }
 591
 592         if (step == 1 && view->ndim == 1) {
 593             Py_buffer newview;
 594             void *newbuf = (char *) view->buf
 595                                     + start * view->itemsize;
 596             int newflags = view->readonly
 597                     ? PyBUF_CONTIG_RO : PyBUF_CONTIG;
 598
 599             /* XXX There should be an API to create a subbuffer */
 600             if (view->obj != NULL) {
 601                 if (PyObject_GetBuffer(view->obj, &newview, newflags) == -1)
 602                     return NULL;
 603             }
 604             else {
 605                 newview = *view;
 606             }
 607             newview.buf = newbuf;
 608             newview.len = slicelength * newview.itemsize;
 609             newview.format = view->format;
 610             newview.shape = &(newview.smalltable[0]);
 611             newview.shape[0] = slicelength;
 612             newview.strides = &(newview.itemsize);
 613             return PyMemoryView_FromBuffer(&newview);
 614         }
 615         PyErr_SetNone(PyExc_NotImplementedError);
 616         return NULL;
 617     }
 618     PyErr_Format(PyExc_TypeError,
 619         "cannot index memory using \"%.200s\"",
 620         key->ob_type->tp_name);
 621     return NULL;
 622 }
 623
 624
 625 /* Need to support assigning memory if we can */
 626 static int
 627 memory_ass_sub(PyMemoryViewObject *self, PyObject *key, PyObject *value)
 628 {
 629     Py_ssize_t start, len, bytelen;
 630     Py_buffer srcview;
 631     Py_buffer *view = &(self->view);
 632     char *srcbuf, *destbuf;
 633
 634     if (view->readonly) {
 635         PyErr_SetString(PyExc_TypeError,
 636             "cannot modify read-only memory");
 637         return -1;
 638     }
 639     if (value == NULL) {
 640         PyErr_SetString(PyExc_TypeError,
 641                         "cannot delete memory");
 642         return -1;
 643     }
 644     if (view->ndim != 1) {
 645         PyErr_SetNone(PyExc_NotImplementedError);
 646         return -1;
 647     }
 648     if (PyIndex_Check(key)) {
 649         start = PyNumber_AsSsize_t(key, NULL);
 650         if (start == -1 && PyErr_Occurred())
 651             return -1;
 652         if (start < 0) {
 653             start += get_shape0(view);
 654         }
 655         if ((start < 0) || (start >= get_shape0(view))) {
 656             PyErr_SetString(PyExc_IndexError,
 657                             "index out of bounds");
 658             return -1;
 659         }
 660         len = 1;
 661     }
 662     else if (PySlice_Check(key)) {
 663         Py_ssize_t stop, step;
 664
 665         if (PySlice_GetIndicesEx((PySliceObject*)key, get_shape0(view),
 666                          &start, &stop, &step, &len) < 0) {
 667             return -1;
 668         }
 669         if (step != 1) {
 670             PyErr_SetNone(PyExc_NotImplementedError);
 671             return -1;
 672         }
 673     }
 674     else {
 675         PyErr_Format(PyExc_TypeError,
 676             "cannot index memory using \"%.200s\"",
 677             key->ob_type->tp_name);
 678         return -1;
 679     }
 680     if (PyObject_GetBuffer(value, &srcview, PyBUF_CONTIG_RO) == -1) {
 681         return -1;
 682     }
 683     /* XXX should we allow assignment of different item sizes
 684        as long as the byte length is the same?
 685        (e.g. assign 2 shorts to a 4-byte slice) */
 686     if (srcview.itemsize != view->itemsize) {
 687         PyErr_Format(PyExc_TypeError,
 688             "mismatching item sizes for \"%.200s\" and \"%.200s\"",
 689             view->obj->ob_type->tp_name, srcview.obj->ob_type->tp_name);
 690         goto _error;
 691     }
 692     bytelen = len * view->itemsize;
 693     if (bytelen != srcview.len) {
 694         PyErr_SetString(PyExc_ValueError,
 695             "cannot modify size of memoryview object");
 696         goto _error;
 697     }
 698     /* Do the actual copy */
 699     destbuf = (char *) view->buf + start * view->itemsize;
 700     srcbuf = (char *) srcview.buf;
 701     if (destbuf + bytelen < srcbuf || srcbuf + bytelen < destbuf)
 702         /* No overlapping */
 703         memcpy(destbuf, srcbuf, bytelen);
 704     else
 705         memmove(destbuf, srcbuf, bytelen);
 706
 707     PyBuffer_Release(&srcview);
 708     return 0;
 709
 710 _error:
 711     PyBuffer_Release(&srcview);
 712     return -1;
 713 }
 714
 715 static PyObject *
 716 memory_richcompare(PyObject *v, PyObject *w, int op)
 717 {
 718     Py_buffer vv, ww;
 719     int equal = 0;
 720     PyObject *res;
 721
 722     vv.obj = NULL;
 723     ww.obj = NULL;
 724     if (op != Py_EQ && op != Py_NE)
 725         goto _notimpl;
 726     if (PyObject_GetBuffer(v, &vv, PyBUF_CONTIG_RO) == -1) {
 727         PyErr_Clear();
 728         goto _notimpl;
 729     }
 730     if (PyObject_GetBuffer(w, &ww, PyBUF_CONTIG_RO) == -1) {
 731         PyErr_Clear();
 732         goto _notimpl;
 733     }
 734
 735     if (vv.itemsize != ww.itemsize || vv.len != ww.len)
 736         goto _end;
 737
 738     equal = !memcmp(vv.buf, ww.buf, vv.len);
 739
 740 _end:
 741     PyBuffer_Release(&vv);
 742     PyBuffer_Release(&ww);
 743     if ((equal && op == Py_EQ) || (!equal && op == Py_NE))
 744         res = Py_True;
 745     else
 746         res = Py_False;
 747     Py_INCREF(res);
 748     return res;
 749
 750 _notimpl:
 751     PyBuffer_Release(&vv);
 752     PyBuffer_Release(&ww);
 753     Py_INCREF(Py_NotImplemented);
 754     return Py_NotImplemented;
 755 }
 756
 757
 758 static int
 759 memory_traverse(PyMemoryViewObject *self, visitproc visit, void *arg)
 760 {
 761     if (self->base != NULL)
 762         Py_VISIT(self->base);
 763     if (self->view.obj != NULL)
 764         Py_VISIT(self->view.obj);
 765     return 0;
 766 }
 767
 768 static int
 769 memory_clear(PyMemoryViewObject *self)
 770 {
 771     Py_CLEAR(self->base);
 772     PyBuffer_Release(&self->view);
 773     return 0;
 774 }
 775
 776
 777 /* As mapping */
 778 static PyMappingMethods memory_as_mapping = {
 779     (lenfunc)memory_length,               /* mp_length */
 780     (binaryfunc)memory_subscript,         /* mp_subscript */
 781     (objobjargproc)memory_ass_sub,        /* mp_ass_subscript */
 782 };
 783
 784 static PySequenceMethods memory_as_sequence = {
 785         0,                                  /* sq_length */
 786         0,                                  /* sq_concat */
 787         0,                                  /* sq_repeat */
 788         (ssizeargfunc)memory_item,          /* sq_item */
 789 };
 790
 791 /* Buffer methods */
 792 static PyBufferProcs memory_as_buffer = {
 793     0,                                    /* bf_getreadbuffer */
 794     0,                                    /* bf_getwritebuffer */
 795     0,                                    /* bf_getsegcount */
 796     0,                                    /* bf_getcharbuffer */
 797     (getbufferproc)memory_getbuf,         /* bf_getbuffer */
 798     (releasebufferproc)memory_releasebuf, /* bf_releasebuffer */
 799 };
 800
 801
 802 PyTypeObject PyMemoryView_Type = {
 803     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 804     "memoryview",
 805     sizeof(PyMemoryViewObject),
 806     0,
 807     (destructor)memory_dealloc,               /* tp_dealloc */
 808     0,                                        /* tp_print */
 809     0,                                        /* tp_getattr */
 810     0,                                        /* tp_setattr */
 811     0,                                        /* tp_compare */
 812     (reprfunc)memory_repr,                    /* tp_repr */
 813     0,                                        /* tp_as_number */
 814     &memory_as_sequence,                      /* tp_as_sequence */
 815     &memory_as_mapping,                       /* tp_as_mapping */
 816     0,                                        /* tp_hash */
 817     0,                                        /* tp_call */
 818     0,                                        /* tp_str */
 819     PyObject_GenericGetAttr,                  /* tp_getattro */
 820     0,                                        /* tp_setattro */
 821     &memory_as_buffer,                        /* tp_as_buffer */
 822     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
 823         Py_TPFLAGS_HAVE_NEWBUFFER,            /* tp_flags */
 824     memory_doc,                               /* tp_doc */
 825     (traverseproc)memory_traverse,            /* tp_traverse */
 826     (inquiry)memory_clear,                    /* tp_clear */
 827     memory_richcompare,                       /* tp_richcompare */
 828     0,                                        /* tp_weaklistoffset */
 829     0,                                        /* tp_iter */
 830     0,                                        /* tp_iternext */
 831     memory_methods,                           /* tp_methods */
 832     0,                                        /* tp_members */
 833     memory_getsetlist,                        /* tp_getset */
 834     0,                                        /* tp_base */
 835     0,                                        /* tp_dict */
 836     0,                                        /* tp_descr_get */
 837     0,                                        /* tp_descr_set */
 838     0,                                        /* tp_dictoffset */
 839     0,                                        /* tp_init */
 840     0,                                        /* tp_alloc */
 841     memory_new,                               /* tp_new */
 842 };