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 (*size > count - offset) 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 /* 338 We make the hash of the empty buffer be 0, rather than using 339 (prefix ^ suffix), since this slightly obfuscates the hash secret 340 */ 341 if (len == 0) { 342 self->b_hash = 0; 343 return 0; 344 } 345 x = _Py_HashSecret.prefix; 346 x ^= *p << 7; 347 while (--len >= 0) 348 x = (1000003*x) ^ *p++; 349 x ^= size; 350 x ^= _Py_HashSecret.suffix; 351 if (x == -1) 352 x = -2; 353 self->b_hash = x; 354 return x; 355 } 356 357 static PyObject * 358 buffer_str(PyBufferObject *self) 359 { 360 void *ptr; 361 Py_ssize_t size; 362 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 363 return NULL; 364 return PyString_FromStringAndSize((const char *)ptr, size); 365 } 366 367 /* Sequence methods */ 368 369 static Py_ssize_t 370 buffer_length(PyBufferObject *self) 371 { 372 void *ptr; 373 Py_ssize_t size; 374 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 375 return -1; 376 return size; 377 } 378 379 static PyObject * 380 buffer_concat(PyBufferObject *self, PyObject *other) 381 { 382 PyBufferProcs *pb = other->ob_type->tp_as_buffer; 383 void *ptr1, *ptr2; 384 char *p; 385 PyObject *ob; 386 Py_ssize_t size, count; 387 388 if ( pb == NULL || 389 pb->bf_getreadbuffer == NULL || 390 pb->bf_getsegcount == NULL ) 391 { 392 PyErr_BadArgument(); 393 return NULL; 394 } 395 if ( (*pb->bf_getsegcount)(other, NULL) != 1 ) 396 { 397 /* ### use a different exception type/message? */ 398 PyErr_SetString(PyExc_TypeError, 399 "single-segment buffer object expected"); 400 return NULL; 401 } 402 403 if (!get_buf(self, &ptr1, &size, ANY_BUFFER)) 404 return NULL; 405 406 /* optimize special case */ 407 if ( size == 0 ) 408 { 409 Py_INCREF(other); 410 return other; 411 } 412 413 if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 ) 414 return NULL; 415 416 assert(count <= PY_SIZE_MAX - size); 417 418 ob = PyString_FromStringAndSize(NULL, size + count); 419 if ( ob == NULL ) 420 return NULL; 421 p = PyString_AS_STRING(ob); 422 memcpy(p, ptr1, size); 423 memcpy(p + size, ptr2, count); 424 425 /* there is an extra byte in the string object, so this is safe */ 426 p[size + count] = '\0'; 427 428 return ob; 429 } 430 431 static PyObject * 432 buffer_repeat(PyBufferObject *self, Py_ssize_t count) 433 { 434 PyObject *ob; 435 register char *p; 436 void *ptr; 437 Py_ssize_t size; 438 439 if ( count < 0 ) 440 count = 0; 441 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 442 return NULL; 443 if (count > PY_SSIZE_T_MAX / size) { 444 PyErr_SetString(PyExc_MemoryError, "result too large"); 445 return NULL; 446 } 447 ob = PyString_FromStringAndSize(NULL, size * count); 448 if ( ob == NULL ) 449 return NULL; 450 451 p = PyString_AS_STRING(ob); 452 while ( count-- ) 453 { 454 memcpy(p, ptr, size); 455 p += size; 456 } 457 458 /* there is an extra byte in the string object, so this is safe */ 459 *p = '\0'; 460 461 return ob; 462 } 463 464 static PyObject * 465 buffer_item(PyBufferObject *self, Py_ssize_t idx) 466 { 467 void *ptr; 468 Py_ssize_t size; 469 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 470 return NULL; 471 if ( idx < 0 || idx >= size ) { 472 PyErr_SetString(PyExc_IndexError, "buffer index out of range"); 473 return NULL; 474 } 475 return PyString_FromStringAndSize((char *)ptr + idx, 1); 476 } 477 478 static PyObject * 479 buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right) 480 { 481 void *ptr; 482 Py_ssize_t size; 483 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 484 return NULL; 485 if ( left < 0 ) 486 left = 0; 487 if ( right < 0 ) 488 right = 0; 489 if ( right > size ) 490 right = size; 491 if ( right < left ) 492 right = left; 493 return PyString_FromStringAndSize((char *)ptr + left, 494 right - left); 495 } 496 497 static PyObject * 498 buffer_subscript(PyBufferObject *self, PyObject *item) 499 { 500 void *p; 501 Py_ssize_t size; 502 503 if (!get_buf(self, &p, &size, ANY_BUFFER)) 504 return NULL; 505 if (PyIndex_Check(item)) { 506 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 507 if (i == -1 && PyErr_Occurred()) 508 return NULL; 509 if (i < 0) 510 i += size; 511 return buffer_item(self, i); 512 } 513 else if (PySlice_Check(item)) { 514 Py_ssize_t start, stop, step, slicelength, cur, i; 515 516 if (PySlice_GetIndicesEx((PySliceObject*)item, size, 517 &start, &stop, &step, &slicelength) < 0) { 518 return NULL; 519 } 520 521 if (slicelength <= 0) 522 return PyString_FromStringAndSize("", 0); 523 else if (step == 1) 524 return PyString_FromStringAndSize((char *)p + start, 525 stop - start); 526 else { 527 PyObject *result; 528 char *source_buf = (char *)p; 529 char *result_buf = (char *)PyMem_Malloc(slicelength); 530 531 if (result_buf == NULL) 532 return PyErr_NoMemory(); 533 534 for (cur = start, i = 0; i < slicelength; 535 cur += step, i++) { 536 result_buf[i] = source_buf[cur]; 537 } 538 539 result = PyString_FromStringAndSize(result_buf, 540 slicelength); 541 PyMem_Free(result_buf); 542 return result; 543 } 544 } 545 else { 546 PyErr_SetString(PyExc_TypeError, 547 "sequence index must be integer"); 548 return NULL; 549 } 550 } 551 552 static int 553 buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other) 554 { 555 PyBufferProcs *pb; 556 void *ptr1, *ptr2; 557 Py_ssize_t size; 558 Py_ssize_t count; 559 560 if ( self->b_readonly ) { 561 PyErr_SetString(PyExc_TypeError, 562 "buffer is read-only"); 563 return -1; 564 } 565 566 if (!get_buf(self, &ptr1, &size, ANY_BUFFER)) 567 return -1; 568 569 if (idx < 0 || idx >= size) { 570 PyErr_SetString(PyExc_IndexError, 571 "buffer assignment index out of range"); 572 return -1; 573 } 574 575 pb = other ? other->ob_type->tp_as_buffer : NULL; 576 if ( pb == NULL || 577 pb->bf_getreadbuffer == NULL || 578 pb->bf_getsegcount == NULL ) 579 { 580 PyErr_BadArgument(); 581 return -1; 582 } 583 if ( (*pb->bf_getsegcount)(other, NULL) != 1 ) 584 { 585 /* ### use a different exception type/message? */ 586 PyErr_SetString(PyExc_TypeError, 587 "single-segment buffer object expected"); 588 return -1; 589 } 590 591 if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 ) 592 return -1; 593 if ( count != 1 ) { 594 PyErr_SetString(PyExc_TypeError, 595 "right operand must be a single byte"); 596 return -1; 597 } 598 599 ((char *)ptr1)[idx] = *(char *)ptr2; 600 return 0; 601 } 602 603 static int 604 buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObject *other) 605 { 606 PyBufferProcs *pb; 607 void *ptr1, *ptr2; 608 Py_ssize_t size; 609 Py_ssize_t slice_len; 610 Py_ssize_t count; 611 612 if ( self->b_readonly ) { 613 PyErr_SetString(PyExc_TypeError, 614 "buffer is read-only"); 615 return -1; 616 } 617 618 pb = other ? other->ob_type->tp_as_buffer : NULL; 619 if ( pb == NULL || 620 pb->bf_getreadbuffer == NULL || 621 pb->bf_getsegcount == NULL ) 622 { 623 PyErr_BadArgument(); 624 return -1; 625 } 626 if ( (*pb->bf_getsegcount)(other, NULL) != 1 ) 627 { 628 /* ### use a different exception type/message? */ 629 PyErr_SetString(PyExc_TypeError, 630 "single-segment buffer object expected"); 631 return -1; 632 } 633 if (!get_buf(self, &ptr1, &size, ANY_BUFFER)) 634 return -1; 635 if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 ) 636 return -1; 637 638 if ( left < 0 ) 639 left = 0; 640 else if ( left > size ) 641 left = size; 642 if ( right < left ) 643 right = left; 644 else if ( right > size ) 645 right = size; 646 slice_len = right - left; 647 648 if ( count != slice_len ) { 649 PyErr_SetString( 650 PyExc_TypeError, 651 "right operand length must match slice length"); 652 return -1; 653 } 654 655 if ( slice_len ) 656 memcpy((char *)ptr1 + left, ptr2, slice_len); 657 658 return 0; 659 } 660 661 static int 662 buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value) 663 { 664 PyBufferProcs *pb; 665 void *ptr1, *ptr2; 666 Py_ssize_t selfsize; 667 Py_ssize_t othersize; 668 669 if ( self->b_readonly ) { 670 PyErr_SetString(PyExc_TypeError, 671 "buffer is read-only"); 672 return -1; 673 } 674 675 pb = value ? value->ob_type->tp_as_buffer : NULL; 676 if ( pb == NULL || 677 pb->bf_getreadbuffer == NULL || 678 pb->bf_getsegcount == NULL ) 679 { 680 PyErr_BadArgument(); 681 return -1; 682 } 683 if ( (*pb->bf_getsegcount)(value, NULL) != 1 ) 684 { 685 /* ### use a different exception type/message? */ 686 PyErr_SetString(PyExc_TypeError, 687 "single-segment buffer object expected"); 688 return -1; 689 } 690 if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER)) 691 return -1; 692 if (PyIndex_Check(item)) { 693 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 694 if (i == -1 && PyErr_Occurred()) 695 return -1; 696 if (i < 0) 697 i += selfsize; 698 return buffer_ass_item(self, i, value); 699 } 700 else if (PySlice_Check(item)) { 701 Py_ssize_t start, stop, step, slicelength; 702 703 if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize, 704 &start, &stop, &step, &slicelength) < 0) 705 return -1; 706 707 if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0) 708 return -1; 709 710 if (othersize != slicelength) { 711 PyErr_SetString( 712 PyExc_TypeError, 713 "right operand length must match slice length"); 714 return -1; 715 } 716 717 if (slicelength == 0) 718 return 0; 719 else if (step == 1) { 720 memcpy((char *)ptr1 + start, ptr2, slicelength); 721 return 0; 722 } 723 else { 724 Py_ssize_t cur, i; 725 726 for (cur = start, i = 0; i < slicelength; 727 cur += step, i++) { 728 ((char *)ptr1)[cur] = ((char *)ptr2)[i]; 729 } 730 731 return 0; 732 } 733 } else { 734 PyErr_SetString(PyExc_TypeError, 735 "buffer indices must be integers"); 736 return -1; 737 } 738 } 739 740 /* Buffer methods */ 741 742 static Py_ssize_t 743 buffer_getreadbuf(PyBufferObject *self, Py_ssize_t idx, void **pp) 744 { 745 Py_ssize_t size; 746 if ( idx != 0 ) { 747 PyErr_SetString(PyExc_SystemError, 748 "accessing non-existent buffer segment"); 749 return -1; 750 } 751 if (!get_buf(self, pp, &size, READ_BUFFER)) 752 return -1; 753 return size; 754 } 755 756 static Py_ssize_t 757 buffer_getwritebuf(PyBufferObject *self, Py_ssize_t idx, void **pp) 758 { 759 Py_ssize_t size; 760 761 if ( self->b_readonly ) 762 { 763 PyErr_SetString(PyExc_TypeError, "buffer is read-only"); 764 return -1; 765 } 766 767 if ( idx != 0 ) { 768 PyErr_SetString(PyExc_SystemError, 769 "accessing non-existent buffer segment"); 770 return -1; 771 } 772 if (!get_buf(self, pp, &size, WRITE_BUFFER)) 773 return -1; 774 return size; 775 } 776 777 static Py_ssize_t 778 buffer_getsegcount(PyBufferObject *self, Py_ssize_t *lenp) 779 { 780 void *ptr; 781 Py_ssize_t size; 782 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 783 return -1; 784 if (lenp) 785 *lenp = size; 786 return 1; 787 } 788 789 static Py_ssize_t 790 buffer_getcharbuf(PyBufferObject *self, Py_ssize_t idx, const char **pp) 791 { 792 void *ptr; 793 Py_ssize_t size; 794 if ( idx != 0 ) { 795 PyErr_SetString(PyExc_SystemError, 796 "accessing non-existent buffer segment"); 797 return -1; 798 } 799 if (!get_buf(self, &ptr, &size, CHAR_BUFFER)) 800 return -1; 801 *pp = (const char *)ptr; 802 return size; 803 } 804 805 static int buffer_getbuffer(PyBufferObject *self, Py_buffer *buf, int flags) 806 { 807 void *ptr; 808 Py_ssize_t size; 809 if (!get_buf(self, &ptr, &size, ANY_BUFFER)) 810 return -1; 811 return PyBuffer_FillInfo(buf, (PyObject*)self, ptr, size, 812 self->b_readonly, flags); 813 } 814 815 static PySequenceMethods buffer_as_sequence = { 816 (lenfunc)buffer_length, /*sq_length*/ 817 (binaryfunc)buffer_concat, /*sq_concat*/ 818 (ssizeargfunc)buffer_repeat, /*sq_repeat*/ 819 (ssizeargfunc)buffer_item, /*sq_item*/ 820 (ssizessizeargfunc)buffer_slice, /*sq_slice*/ 821 (ssizeobjargproc)buffer_ass_item, /*sq_ass_item*/ 822 (ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/ 823 }; 824 825 static PyMappingMethods buffer_as_mapping = { 826 (lenfunc)buffer_length, 827 (binaryfunc)buffer_subscript, 828 (objobjargproc)buffer_ass_subscript, 829 }; 830 831 static PyBufferProcs buffer_as_buffer = { 832 (readbufferproc)buffer_getreadbuf, 833 (writebufferproc)buffer_getwritebuf, 834 (segcountproc)buffer_getsegcount, 835 (charbufferproc)buffer_getcharbuf, 836 (getbufferproc)buffer_getbuffer, 837 }; 838 839 PyTypeObject PyBuffer_Type = { 840 PyVarObject_HEAD_INIT(&PyType_Type, 0) 841 "buffer", 842 sizeof(PyBufferObject), 843 0, 844 (destructor)buffer_dealloc, /* tp_dealloc */ 845 0, /* tp_print */ 846 0, /* tp_getattr */ 847 0, /* tp_setattr */ 848 (cmpfunc)buffer_compare, /* tp_compare */ 849 (reprfunc)buffer_repr, /* tp_repr */ 850 0, /* tp_as_number */ 851 &buffer_as_sequence, /* tp_as_sequence */ 852 &buffer_as_mapping, /* tp_as_mapping */ 853 (hashfunc)buffer_hash, /* tp_hash */ 854 0, /* tp_call */ 855 (reprfunc)buffer_str, /* tp_str */ 856 PyObject_GenericGetAttr, /* tp_getattro */ 857 0, /* tp_setattro */ 858 &buffer_as_buffer, /* tp_as_buffer */ 859 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GETCHARBUFFER | Py_TPFLAGS_HAVE_NEWBUFFER, /* tp_flags */ 860 buffer_doc, /* tp_doc */ 861 0, /* tp_traverse */ 862 0, /* tp_clear */ 863 0, /* tp_richcompare */ 864 0, /* tp_weaklistoffset */ 865 0, /* tp_iter */ 866 0, /* tp_iternext */ 867 0, /* tp_methods */ 868 0, /* tp_members */ 869 0, /* tp_getset */ 870 0, /* tp_base */ 871 0, /* tp_dict */ 872 0, /* tp_descr_get */ 873 0, /* tp_descr_set */ 874 0, /* tp_dictoffset */ 875 0, /* tp_init */ 876 0, /* tp_alloc */ 877 buffer_new, /* tp_new */ 878 }; 879
