Objects/bufferobject.c

   1
   2 /* Buffer object implementation */
   3
   4 #include "Python.h"
   5
   6
   7 typedef struct {
   8         PyObject_HEAD
   9         PyObject *b_base;
  10         void *b_ptr;
  11         Py_ssize_t b_size;
  12         Py_ssize_t b_offset;
  13         int b_readonly;
  14         long b_hash;
  15 } PyBufferObject;
  16
  17
  18 enum buffer_t {
  19     READ_BUFFER,
  20     WRITE_BUFFER,
  21     CHAR_BUFFER,
  22     ANY_BUFFER
  23 };
  24
  25 static int
  26 get_buf(PyBufferObject *self, void **ptr, Py_ssize_t *size,
  27         enum buffer_t buffer_type)
  28 {
  29         if (self->b_base == NULL) {
  30                 assert (ptr != NULL);
  31                 *ptr = self->b_ptr;
  32                 *size = self->b_size;
  33         }
  34         else {
  35                 Py_ssize_t count, offset;
  36                 readbufferproc proc = 0;
  37                 PyBufferProcs *bp = self->b_base->ob_type->tp_as_buffer;
  38                 if ((*bp->bf_getsegcount)(self->b_base, NULL) != 1) {
  39                         PyErr_SetString(PyExc_TypeError,
  40                                 "single-segment buffer object expected");
  41                         return 0;
  42                 }
  43                 if ((buffer_type == READ_BUFFER) ||
  44                         ((buffer_type == ANY_BUFFER) && self->b_readonly))
  45                     proc = bp->bf_getreadbuffer;
  46                 else if ((buffer_type == WRITE_BUFFER) ||
  47                         (buffer_type == ANY_BUFFER))
  48                     proc = (readbufferproc)bp->bf_getwritebuffer;
  49                 else if (buffer_type == CHAR_BUFFER) {
  50                     if (!PyType_HasFeature(self->ob_type,
  51                                 Py_TPFLAGS_HAVE_GETCHARBUFFER)) {
  52                         PyErr_SetString(PyExc_TypeError,
  53                                 "Py_TPFLAGS_HAVE_GETCHARBUFFER needed");
  54                         return 0;
  55                     }
  56                     proc = (readbufferproc)bp->bf_getcharbuffer;
  57                 }
  58                 if (!proc) {
  59                     char *buffer_type_name;
  60                     switch (buffer_type) {
  61                         case READ_BUFFER:
  62                             buffer_type_name = "read";
  63                             break;
  64                         case WRITE_BUFFER:
  65                             buffer_type_name = "write";
  66                             break;
  67                         case CHAR_BUFFER:
  68                             buffer_type_name = "char";
  69                             break;
  70                         default:
  71                             buffer_type_name = "no";
  72                             break;
  73                     }
  74                     PyErr_Format(PyExc_TypeError,
  75                             "%s buffer type not available",
  76                             buffer_type_name);
  77                     return 0;
  78                 }
  79                 if ((count = (*proc)(self->b_base, 0, ptr)) < 0)
  80                         return 0;
  81                 /* apply constraints to the start/end */
  82                 if (self->b_offset > count)
  83                         offset = count;
  84                 else
  85                         offset = self->b_offset;
  86                 *(char **)ptr = *(char **)ptr + offset;
  87                 if (self->b_size == Py_END_OF_BUFFER)
  88                         *size = count;
  89                 else
  90                         *size = self->b_size;
  91                 if (offset + *size > count)
  92                         *size = count - offset;
  93         }
  94         return 1;
  95 }
  96
  97
  98 static PyObject *
  99 buffer_from_memory(PyObject *base, Py_ssize_t size, Py_ssize_t offset, void *ptr,
 100                    int readonly)
 101 {
 102         PyBufferObject * b;
 103
 104         if (size < 0 && size != Py_END_OF_BUFFER) {
 105                 PyErr_SetString(PyExc_ValueError,
 106                                 "size must be zero or positive");
 107                 return NULL;
 108         }
 109         if (offset < 0) {
 110                 PyErr_SetString(PyExc_ValueError,
 111                                 "offset must be zero or positive");
 112                 return NULL;
 113         }
 114
 115         b = PyObject_NEW(PyBufferObject, &PyBuffer_Type);
 116         if ( b == NULL )
 117                 return NULL;
 118
 119         Py_XINCREF(base);
 120         b->b_base = base;
 121         b->b_ptr = ptr;
 122         b->b_size = size;
 123         b->b_offset = offset;
 124         b->b_readonly = readonly;
 125         b->b_hash = -1;
 126
 127         return (PyObject *) b;
 128 }
 129
 130 static PyObject *
 131 buffer_from_object(PyObject *base, Py_ssize_t size, Py_ssize_t offset, int readonly)
 132 {
 133         if (offset < 0) {
 134                 PyErr_SetString(PyExc_ValueError,
 135                                 "offset must be zero or positive");
 136                 return NULL;
 137         }
 138         if ( PyBuffer_Check(base) && (((PyBufferObject *)base)->b_base) ) {
 139                 /* another buffer, refer to the base object */
 140                 PyBufferObject *b = (PyBufferObject *)base;
 141                 if (b->b_size != Py_END_OF_BUFFER) {
 142                         Py_ssize_t base_size = b->b_size - offset;
 143                         if (base_size < 0)
 144                                 base_size = 0;
 145                         if (size == Py_END_OF_BUFFER || size > base_size)
 146                                 size = base_size;
 147                 }
 148                 offset += b->b_offset;
 149                 base = b->b_base;
 150         }
 151         return buffer_from_memory(base, size, offset, NULL, readonly);
 152 }
 153
 154
 155 PyObject *
 156 PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
 157 {
 158         PyBufferProcs *pb = base->ob_type->tp_as_buffer;
 159
 160         if ( pb == NULL ||
 161              pb->bf_getreadbuffer == NULL ||
 162              pb->bf_getsegcount == NULL )
 163         {
 164                 PyErr_SetString(PyExc_TypeError, "buffer object expected");
 165                 return NULL;
 166         }
 167
 168         return buffer_from_object(base, size, offset, 1);
 169 }
 170
 171 PyObject *
 172 PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
 173 {
 174         PyBufferProcs *pb = base->ob_type->tp_as_buffer;
 175
 176         if ( pb == NULL ||
 177              pb->bf_getwritebuffer == NULL ||
 178              pb->bf_getsegcount == NULL )
 179         {
 180                 PyErr_SetString(PyExc_TypeError, "buffer object expected");
 181                 return NULL;
 182         }
 183
 184         return buffer_from_object(base, size,  offset, 0);
 185 }
 186
 187 PyObject *
 188 PyBuffer_FromMemory(void *ptr, Py_ssize_t size)
 189 {
 190         return buffer_from_memory(NULL, size, 0, ptr, 1);
 191 }
 192
 193 PyObject *
 194 PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size)
 195 {
 196         return buffer_from_memory(NULL, size, 0, ptr, 0);
 197 }
 198
 199 PyObject *
 200 PyBuffer_New(Py_ssize_t size)
 201 {
 202         PyObject *o;
 203         PyBufferObject * b;
 204
 205         if (size < 0) {
 206                 PyErr_SetString(PyExc_ValueError,
 207                                 "size must be zero or positive");
 208                 return NULL;
 209         }
 210         if (sizeof(*b) > PY_SSIZE_T_MAX - size) {
 211                 /* unlikely */
 212                 return PyErr_NoMemory();
 213         }
 214         /* Inline PyObject_New */
 215         o = (PyObject *)PyObject_MALLOC(sizeof(*b) + size);
 216         if ( o == NULL )
 217                 return PyErr_NoMemory();
 218         b = (PyBufferObject *) PyObject_INIT(o, &PyBuffer_Type);
 219
 220         b->b_base = NULL;
 221         b->b_ptr = (void *)(b + 1);
 222         b->b_size = size;
 223         b->b_offset = 0;
 224         b->b_readonly = 0;
 225         b->b_hash = -1;
 226
 227         return o;
 228 }
 229
 230 /* Methods */
 231
 232 static PyObject *
 233 buffer_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 234 {
 235         PyObject *ob;
 236         Py_ssize_t offset = 0;
 237         Py_ssize_t size = Py_END_OF_BUFFER;
 238
 239         if (PyErr_WarnPy3k("buffer() not supported in 3.x", 1) < 0)
 240                 return NULL;
 241
 242         if (!_PyArg_NoKeywords("buffer()", kw))
 243                 return NULL;
 244
 245         if (!PyArg_ParseTuple(args, "O|nn:buffer", &ob, &offset, &size))
 246             return NULL;
 247         return PyBuffer_FromObject(ob, offset, size);
 248 }
 249
 250 PyDoc_STRVAR(buffer_doc,
 251 "buffer(object [, offset[, size]])\n\
 252 \n\
 253 Create a new buffer object which references the given object.\n\
 254 The buffer will reference a slice of the target object from the\n\
 255 start of the object (or at the specified offset). The slice will\n\
 256 extend to the end of the target object (or with the specified size).");
 257
 258
 259 static void
 260 buffer_dealloc(PyBufferObject *self)
 261 {
 262         Py_XDECREF(self->b_base);
 263         PyObject_DEL(self);
 264 }
 265
 266 static int
 267 buffer_compare(PyBufferObject *self, PyBufferObject *other)
 268 {
 269         void *p1, *p2;
 270         Py_ssize_t len_self, len_other, min_len;
 271         int cmp;
 272
 273         if (!get_buf(self, &p1, &len_self, ANY_BUFFER))
 274                 return -1;
 275         if (!get_buf(other, &p2, &len_other, ANY_BUFFER))
 276                 return -1;
 277         min_len = (len_self < len_other) ? len_self : len_other;
 278         if (min_len > 0) {
 279                 cmp = memcmp(p1, p2, min_len);
 280                 if (cmp != 0)
 281                         return cmp < 0 ? -1 : 1;
 282         }
 283         return (len_self < len_other) ? -1 : (len_self > len_other) ? 1 : 0;
 284 }
 285
 286 static PyObject *
 287 buffer_repr(PyBufferObject *self)
 288 {
 289         const char *status = self->b_readonly ? "read-only" : "read-write";
 290
 291         if ( self->b_base == NULL )
 292                 return PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",
 293                                            status,
 294                                            self->b_ptr,
 295                                            self->b_size,
 296                                            self);
 297         else
 298                 return PyString_FromFormat(
 299                         "<%s buffer for %p, size %zd, offset %zd at %p>",
 300                         status,
 301                         self->b_base,
 302                         self->b_size,
 303                         self->b_offset,
 304                         self);
 305 }
 306
 307 static long
 308 buffer_hash(PyBufferObject *self)
 309 {
 310         void *ptr;
 311         Py_ssize_t size;
 312         register Py_ssize_t len;
 313         register unsigned char *p;
 314         register long x;
 315
 316         if ( self->b_hash != -1 )
 317                 return self->b_hash;
 318
 319         /* XXX potential bugs here, a readonly buffer does not imply that the
 320          * underlying memory is immutable.  b_readonly is a necessary but not
 321          * sufficient condition for a buffer to be hashable.  Perhaps it would
 322          * be better to only allow hashing if the underlying object is known to
 323          * be immutable (e.g. PyString_Check() is true).  Another idea would
 324          * be to call tp_hash on the underlying object and see if it raises
 325          * an error. */
 326         if ( !self->b_readonly )
 327         {
 328                 PyErr_SetString(PyExc_TypeError,
 329                                 "writable buffers are not hashable");
 330                 return -1;
 331         }
 332
 333         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 334                 return -1;
 335         p = (unsigned char *) ptr;
 336         len = size;
 337         x = *p << 7;
 338         while (--len >= 0)
 339                 x = (1000003*x) ^ *p++;
 340         x ^= size;
 341         if (x == -1)
 342                 x = -2;
 343         self->b_hash = x;
 344         return x;
 345 }
 346
 347 static PyObject *
 348 buffer_str(PyBufferObject *self)
 349 {
 350         void *ptr;
 351         Py_ssize_t size;
 352         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 353                 return NULL;
 354         return PyString_FromStringAndSize((const char *)ptr, size);
 355 }
 356
 357 /* Sequence methods */
 358
 359 static Py_ssize_t
 360 buffer_length(PyBufferObject *self)
 361 {
 362         void *ptr;
 363         Py_ssize_t size;
 364         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 365                 return -1;
 366         return size;
 367 }
 368
 369 static PyObject *
 370 buffer_concat(PyBufferObject *self, PyObject *other)
 371 {
 372         PyBufferProcs *pb = other->ob_type->tp_as_buffer;
 373         void *ptr1, *ptr2;
 374         char *p;
 375         PyObject *ob;
 376         Py_ssize_t size, count;
 377
 378         if ( pb == NULL ||
 379              pb->bf_getreadbuffer == NULL ||
 380              pb->bf_getsegcount == NULL )
 381         {
 382                 PyErr_BadArgument();
 383                 return NULL;
 384         }
 385         if ( (*pb->bf_getsegcount)(other, NULL) != 1 )
 386         {
 387                 /* ### use a different exception type/message? */
 388                 PyErr_SetString(PyExc_TypeError,
 389                                 "single-segment buffer object expected");
 390                 return NULL;
 391         }
 392
 393         if (!get_buf(self, &ptr1, &size, ANY_BUFFER))
 394                 return NULL;
 395
 396         /* optimize special case */
 397         if ( size == 0 )
 398         {
 399             Py_INCREF(other);
 400             return other;
 401         }
 402
 403         if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
 404                 return NULL;
 405
 406         assert(count <= PY_SIZE_MAX - size);
 407
 408         ob = PyString_FromStringAndSize(NULL, size + count);
 409         if ( ob == NULL )
 410                 return NULL;
 411         p = PyString_AS_STRING(ob);
 412         memcpy(p, ptr1, size);
 413         memcpy(p + size, ptr2, count);
 414
 415         /* there is an extra byte in the string object, so this is safe */
 416         p[size + count] = '\0';
 417
 418         return ob;
 419 }
 420
 421 static PyObject *
 422 buffer_repeat(PyBufferObject *self, Py_ssize_t count)
 423 {
 424         PyObject *ob;
 425         register char *p;
 426         void *ptr;
 427         Py_ssize_t size;
 428
 429         if ( count < 0 )
 430                 count = 0;
 431         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 432                 return NULL;
 433         if (count > PY_SSIZE_T_MAX / size) {
 434                 PyErr_SetString(PyExc_MemoryError, "result too large");
 435                 return NULL;
 436         }
 437         ob = PyString_FromStringAndSize(NULL, size * count);
 438         if ( ob == NULL )
 439                 return NULL;
 440
 441         p = PyString_AS_STRING(ob);
 442         while ( count-- )
 443         {
 444             memcpy(p, ptr, size);
 445             p += size;
 446         }
 447
 448         /* there is an extra byte in the string object, so this is safe */
 449         *p = '\0';
 450
 451         return ob;
 452 }
 453
 454 static PyObject *
 455 buffer_item(PyBufferObject *self, Py_ssize_t idx)
 456 {
 457         void *ptr;
 458         Py_ssize_t size;
 459         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 460                 return NULL;
 461         if ( idx < 0 || idx >= size ) {
 462                 PyErr_SetString(PyExc_IndexError, "buffer index out of range");
 463                 return NULL;
 464         }
 465         return PyString_FromStringAndSize((char *)ptr + idx, 1);
 466 }
 467
 468 static PyObject *
 469 buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)
 470 {
 471         void *ptr;
 472         Py_ssize_t size;
 473         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 474                 return NULL;
 475         if ( left < 0 )
 476                 left = 0;
 477         if ( right < 0 )
 478                 right = 0;
 479         if ( right > size )
 480                 right = size;
 481         if ( right < left )
 482                 right = left;
 483         return PyString_FromStringAndSize((char *)ptr + left,
 484                                           right - left);
 485 }
 486
 487 static PyObject *
 488 buffer_subscript(PyBufferObject *self, PyObject *item)
 489 {
 490         void *p;
 491         Py_ssize_t size;
 492
 493         if (!get_buf(self, &p, &size, ANY_BUFFER))
 494                 return NULL;
 495         if (PyIndex_Check(item)) {
 496                 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
 497                 if (i == -1 && PyErr_Occurred())
 498                         return NULL;
 499                 if (i < 0)
 500                         i += size;
 501                 return buffer_item(self, i);
 502         }
 503         else if (PySlice_Check(item)) {
 504                 Py_ssize_t start, stop, step, slicelength, cur, i;
 505
 506                 if (PySlice_GetIndicesEx((PySliceObject*)item, size,
 507                                  &start, &stop, &step, &slicelength) < 0) {
 508                         return NULL;
 509                 }
 510
 511                 if (slicelength <= 0)
 512                         return PyString_FromStringAndSize("", 0);
 513                 else if (step == 1)
 514                         return PyString_FromStringAndSize((char *)p + start,
 515                                                           stop - start);
 516                 else {
 517                         PyObject *result;
 518                         char *source_buf = (char *)p;
 519                         char *result_buf = (char *)PyMem_Malloc(slicelength);
 520
 521                         if (result_buf == NULL)
 522                                 return PyErr_NoMemory();
 523
 524                         for (cur = start, i = 0; i < slicelength;
 525                              cur += step, i++) {
 526                                 result_buf[i] = source_buf[cur];
 527                         }
 528
 529                         result = PyString_FromStringAndSize(result_buf,
 530                                                             slicelength);
 531                         PyMem_Free(result_buf);
 532                         return result;
 533                 }
 534         }
 535         else {
 536                 PyErr_SetString(PyExc_TypeError,
 537                                 "sequence index must be integer");
 538                 return NULL;
 539         }
 540 }
 541
 542 static int
 543 buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)
 544 {
 545         PyBufferProcs *pb;
 546         void *ptr1, *ptr2;
 547         Py_ssize_t size;
 548         Py_ssize_t count;
 549
 550         if ( self->b_readonly ) {
 551                 PyErr_SetString(PyExc_TypeError,
 552                                 "buffer is read-only");
 553                 return -1;
 554         }
 555
 556         if (!get_buf(self, &ptr1, &size, ANY_BUFFER))
 557                 return -1;
 558
 559         if (idx < 0 || idx >= size) {
 560                 PyErr_SetString(PyExc_IndexError,
 561                                 "buffer assignment index out of range");
 562                 return -1;
 563         }
 564
 565         pb = other ? other->ob_type->tp_as_buffer : NULL;
 566         if ( pb == NULL ||
 567              pb->bf_getreadbuffer == NULL ||
 568              pb->bf_getsegcount == NULL )
 569         {
 570                 PyErr_BadArgument();
 571                 return -1;
 572         }
 573         if ( (*pb->bf_getsegcount)(other, NULL) != 1 )
 574         {
 575                 /* ### use a different exception type/message? */
 576                 PyErr_SetString(PyExc_TypeError,
 577                                 "single-segment buffer object expected");
 578                 return -1;
 579         }
 580
 581         if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
 582                 return -1;
 583         if ( count != 1 ) {
 584                 PyErr_SetString(PyExc_TypeError,
 585                                 "right operand must be a single byte");
 586                 return -1;
 587         }
 588
 589         ((char *)ptr1)[idx] = *(char *)ptr2;
 590         return 0;
 591 }
 592
 593 static int
 594 buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObject *other)
 595 {
 596         PyBufferProcs *pb;
 597         void *ptr1, *ptr2;
 598         Py_ssize_t size;
 599         Py_ssize_t slice_len;
 600         Py_ssize_t count;
 601
 602         if ( self->b_readonly ) {
 603                 PyErr_SetString(PyExc_TypeError,
 604                                 "buffer is read-only");
 605                 return -1;
 606         }
 607
 608         pb = other ? other->ob_type->tp_as_buffer : NULL;
 609         if ( pb == NULL ||
 610              pb->bf_getreadbuffer == NULL ||
 611              pb->bf_getsegcount == NULL )
 612         {
 613                 PyErr_BadArgument();
 614                 return -1;
 615         }
 616         if ( (*pb->bf_getsegcount)(other, NULL) != 1 )
 617         {
 618                 /* ### use a different exception type/message? */
 619                 PyErr_SetString(PyExc_TypeError,
 620                                 "single-segment buffer object expected");
 621                 return -1;
 622         }
 623         if (!get_buf(self, &ptr1, &size, ANY_BUFFER))
 624                 return -1;
 625         if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
 626                 return -1;
 627
 628         if ( left < 0 )
 629                 left = 0;
 630         else if ( left > size )
 631                 left = size;
 632         if ( right < left )
 633                 right = left;
 634         else if ( right > size )
 635                 right = size;
 636         slice_len = right - left;
 637
 638         if ( count != slice_len ) {
 639                 PyErr_SetString(
 640                         PyExc_TypeError,
 641                         "right operand length must match slice length");
 642                 return -1;
 643         }
 644
 645         if ( slice_len )
 646             memcpy((char *)ptr1 + left, ptr2, slice_len);
 647
 648         return 0;
 649 }
 650
 651 static int
 652 buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)
 653 {
 654         PyBufferProcs *pb;
 655         void *ptr1, *ptr2;
 656         Py_ssize_t selfsize;
 657         Py_ssize_t othersize;
 658
 659         if ( self->b_readonly ) {
 660                 PyErr_SetString(PyExc_TypeError,
 661                                 "buffer is read-only");
 662                 return -1;
 663         }
 664
 665         pb = value ? value->ob_type->tp_as_buffer : NULL;
 666         if ( pb == NULL ||
 667              pb->bf_getreadbuffer == NULL ||
 668              pb->bf_getsegcount == NULL )
 669         {
 670                 PyErr_BadArgument();
 671                 return -1;
 672         }
 673         if ( (*pb->bf_getsegcount)(value, NULL) != 1 )
 674         {
 675                 /* ### use a different exception type/message? */
 676                 PyErr_SetString(PyExc_TypeError,
 677                                 "single-segment buffer object expected");
 678                 return -1;
 679         }
 680         if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
 681                 return -1;
 682         if (PyIndex_Check(item)) {
 683                 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
 684                 if (i == -1 && PyErr_Occurred())
 685                         return -1;
 686                 if (i < 0)
 687                         i += selfsize;
 688                 return buffer_ass_item(self, i, value);
 689         }
 690         else if (PySlice_Check(item)) {
 691                 Py_ssize_t start, stop, step, slicelength;
 692
 693                 if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize,
 694                                 &start, &stop, &step, &slicelength) < 0)
 695                         return -1;
 696
 697                 if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0)
 698                         return -1;
 699
 700                 if (othersize != slicelength) {
 701                         PyErr_SetString(
 702                                 PyExc_TypeError,
 703                                 "right operand length must match slice length");
 704                         return -1;
 705                 }
 706
 707                 if (slicelength == 0)
 708                         return 0;
 709                 else if (step == 1) {
 710                         memcpy((char *)ptr1 + start, ptr2, slicelength);
 711                         return 0;
 712                 }
 713                 else {
 714                         Py_ssize_t cur, i;
 715
 716                         for (cur = start, i = 0; i < slicelength;
 717                              cur += step, i++) {
 718                                 ((char *)ptr1)[cur] = ((char *)ptr2)[i];
 719                         }
 720
 721                         return 0;
 722                 }
 723         } else {
 724                 PyErr_SetString(PyExc_TypeError,
 725                                 "buffer indices must be integers");
 726                 return -1;
 727         }
 728 }
 729
 730 /* Buffer methods */
 731
 732 static Py_ssize_t
 733 buffer_getreadbuf(PyBufferObject *self, Py_ssize_t idx, void **pp)
 734 {
 735         Py_ssize_t size;
 736         if ( idx != 0 ) {
 737                 PyErr_SetString(PyExc_SystemError,
 738                                 "accessing non-existent buffer segment");
 739                 return -1;
 740         }
 741         if (!get_buf(self, pp, &size, READ_BUFFER))
 742                 return -1;
 743         return size;
 744 }
 745
 746 static Py_ssize_t
 747 buffer_getwritebuf(PyBufferObject *self, Py_ssize_t idx, void **pp)
 748 {
 749         Py_ssize_t size;
 750
 751         if ( self->b_readonly )
 752         {
 753                 PyErr_SetString(PyExc_TypeError, "buffer is read-only");
 754                 return -1;
 755         }
 756
 757         if ( idx != 0 ) {
 758                 PyErr_SetString(PyExc_SystemError,
 759                                 "accessing non-existent buffer segment");
 760                 return -1;
 761         }
 762         if (!get_buf(self, pp, &size, WRITE_BUFFER))
 763                 return -1;
 764         return size;
 765 }
 766
 767 static Py_ssize_t
 768 buffer_getsegcount(PyBufferObject *self, Py_ssize_t *lenp)
 769 {
 770         void *ptr;
 771         Py_ssize_t size;
 772         if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 773                 return -1;
 774         if (lenp)
 775                 *lenp = size;
 776         return 1;
 777 }
 778
 779 static Py_ssize_t
 780 buffer_getcharbuf(PyBufferObject *self, Py_ssize_t idx, const char **pp)
 781 {
 782         void *ptr;
 783         Py_ssize_t size;
 784         if ( idx != 0 ) {
 785                 PyErr_SetString(PyExc_SystemError,
 786                                 "accessing non-existent buffer segment");
 787                 return -1;
 788         }
 789         if (!get_buf(self, &ptr, &size, CHAR_BUFFER))
 790                 return -1;
 791         *pp = (const char *)ptr;
 792         return size;
 793 }
 794
 795 static PySequenceMethods buffer_as_sequence = {
 796         (lenfunc)buffer_length, /*sq_length*/
 797         (binaryfunc)buffer_concat, /*sq_concat*/
 798         (ssizeargfunc)buffer_repeat, /*sq_repeat*/
 799         (ssizeargfunc)buffer_item, /*sq_item*/
 800         (ssizessizeargfunc)buffer_slice, /*sq_slice*/
 801         (ssizeobjargproc)buffer_ass_item, /*sq_ass_item*/
 802         (ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/
 803 };
 804
 805 static PyMappingMethods buffer_as_mapping = {
 806         (lenfunc)buffer_length,
 807         (binaryfunc)buffer_subscript,
 808         (objobjargproc)buffer_ass_subscript,
 809 };
 810
 811 static PyBufferProcs buffer_as_buffer = {
 812         (readbufferproc)buffer_getreadbuf,
 813         (writebufferproc)buffer_getwritebuf,
 814         (segcountproc)buffer_getsegcount,
 815         (charbufferproc)buffer_getcharbuf,
 816 };
 817
 818 PyTypeObject PyBuffer_Type = {
 819         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 820         "buffer",
 821         sizeof(PyBufferObject),
 822         0,
 823         (destructor)buffer_dealloc,             /* tp_dealloc */
 824         0,                                      /* tp_print */
 825         0,                                      /* tp_getattr */
 826         0,                                      /* tp_setattr */
 827         (cmpfunc)buffer_compare,                /* tp_compare */
 828         (reprfunc)buffer_repr,                  /* tp_repr */
 829         0,                                      /* tp_as_number */
 830         &buffer_as_sequence,                    /* tp_as_sequence */
 831         &buffer_as_mapping,                     /* tp_as_mapping */
 832         (hashfunc)buffer_hash,                  /* tp_hash */
 833         0,                                      /* tp_call */
 834         (reprfunc)buffer_str,                   /* tp_str */
 835         PyObject_GenericGetAttr,                /* tp_getattro */
 836         0,                                      /* tp_setattro */
 837         &buffer_as_buffer,                      /* tp_as_buffer */
 838         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GETCHARBUFFER, /* tp_flags */
 839         buffer_doc,                             /* tp_doc */
 840         0,                                      /* tp_traverse */
 841         0,                                      /* tp_clear */
 842         0,                                      /* tp_richcompare */
 843         0,                                      /* tp_weaklistoffset */
 844         0,                                      /* tp_iter */
 845         0,                                      /* tp_iternext */
 846         0,                                      /* tp_methods */
 847         0,                                      /* tp_members */
 848         0,                                      /* tp_getset */
 849         0,                                      /* tp_base */
 850         0,                                      /* tp_dict */
 851         0,                                      /* tp_descr_get */
 852         0,                                      /* tp_descr_set */
 853         0,                                      /* tp_dictoffset */
 854         0,                                      /* tp_init */
 855         0,                                      /* tp_alloc */
 856         buffer_new,                             /* tp_new */
 857 };