1 /* Abstract Object Interface (many thanks to Jim Fulton) */ 2 3 #include "Python.h" 4 #include <ctype.h> 5 #include "structmember.h" /* we need the offsetof() macro from there */ 6 #include "longintrepr.h" 7 8 #define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \ 9 Py_TPFLAGS_CHECKTYPES) 10 11 12 /* Shorthands to return certain errors */ 13 14 static PyObject * 15 type_error(const char *msg, PyObject *obj) 16 { 17 PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name); 18 return NULL; 19 } 20 21 static PyObject * 22 null_error(void) 23 { 24 if (!PyErr_Occurred()) 25 PyErr_SetString(PyExc_SystemError, 26 "null argument to internal routine"); 27 return NULL; 28 } 29 30 /* Operations on any object */ 31 32 int 33 PyObject_Cmp(PyObject *o1, PyObject *o2, int *result) 34 { 35 int r; 36 37 if (o1 == NULL || o2 == NULL) { 38 null_error(); 39 return -1; 40 } 41 r = PyObject_Compare(o1, o2); 42 if (PyErr_Occurred()) 43 return -1; 44 *result = r; 45 return 0; 46 } 47 48 PyObject * 49 PyObject_Type(PyObject *o) 50 { 51 PyObject *v; 52 53 if (o == NULL) 54 return null_error(); 55 v = (PyObject *)o->ob_type; 56 Py_INCREF(v); 57 return v; 58 } 59 60 Py_ssize_t 61 PyObject_Size(PyObject *o) 62 { 63 PySequenceMethods *m; 64 65 if (o == NULL) { 66 null_error(); 67 return -1; 68 } 69 70 m = o->ob_type->tp_as_sequence; 71 if (m && m->sq_length) 72 return m->sq_length(o); 73 74 return PyMapping_Size(o); 75 } 76 77 #undef PyObject_Length 78 Py_ssize_t 79 PyObject_Length(PyObject *o) 80 { 81 return PyObject_Size(o); 82 } 83 #define PyObject_Length PyObject_Size 84 85 86 /* The length hint function returns a non-negative value from o.__len__() 87 or o.__length_hint__(). If those methods aren't found or return a negative 88 value, then the defaultvalue is returned. If one of the calls fails, 89 this function returns -1. 90 */ 91 92 Py_ssize_t 93 _PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue) 94 { 95 static PyObject *hintstrobj = NULL; 96 PyObject *ro, *hintmeth; 97 Py_ssize_t rv; 98 99 /* try o.__len__() */ 100 rv = PyObject_Size(o); 101 if (rv >= 0) 102 return rv; 103 if (PyErr_Occurred()) { 104 if (!PyErr_ExceptionMatches(PyExc_TypeError) && 105 !PyErr_ExceptionMatches(PyExc_AttributeError)) 106 return -1; 107 PyErr_Clear(); 108 } 109 110 if (PyInstance_Check(o)) 111 return defaultvalue; 112 /* try o.__length_hint__() */ 113 hintmeth = _PyObject_LookupSpecial(o, "__length_hint__", &hintstrobj); 114 if (hintmeth == NULL) { 115 if (PyErr_Occurred()) 116 return -1; 117 else 118 return defaultvalue; 119 } 120 ro = PyObject_CallFunctionObjArgs(hintmeth, NULL); 121 Py_DECREF(hintmeth); 122 if (ro == NULL) { 123 if (!PyErr_ExceptionMatches(PyExc_TypeError) && 124 !PyErr_ExceptionMatches(PyExc_AttributeError)) 125 return -1; 126 PyErr_Clear(); 127 return defaultvalue; 128 } 129 rv = PyNumber_Check(ro) ? PyInt_AsSsize_t(ro) : defaultvalue; 130 Py_DECREF(ro); 131 return rv; 132 } 133 134 PyObject * 135 PyObject_GetItem(PyObject *o, PyObject *key) 136 { 137 PyMappingMethods *m; 138 139 if (o == NULL || key == NULL) 140 return null_error(); 141 142 m = o->ob_type->tp_as_mapping; 143 if (m && m->mp_subscript) 144 return m->mp_subscript(o, key); 145 146 if (o->ob_type->tp_as_sequence) { 147 if (PyIndex_Check(key)) { 148 Py_ssize_t key_value; 149 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError); 150 if (key_value == -1 && PyErr_Occurred()) 151 return NULL; 152 return PySequence_GetItem(o, key_value); 153 } 154 else if (o->ob_type->tp_as_sequence->sq_item) 155 return type_error("sequence index must " 156 "be integer, not '%.200s'", key); 157 } 158 159 return type_error("'%.200s' object has no attribute '__getitem__'", o); 160 } 161 162 int 163 PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value) 164 { 165 PyMappingMethods *m; 166 167 if (o == NULL || key == NULL || value == NULL) { 168 null_error(); 169 return -1; 170 } 171 m = o->ob_type->tp_as_mapping; 172 if (m && m->mp_ass_subscript) 173 return m->mp_ass_subscript(o, key, value); 174 175 if (o->ob_type->tp_as_sequence) { 176 if (PyIndex_Check(key)) { 177 Py_ssize_t key_value; 178 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError); 179 if (key_value == -1 && PyErr_Occurred()) 180 return -1; 181 return PySequence_SetItem(o, key_value, value); 182 } 183 else if (o->ob_type->tp_as_sequence->sq_ass_item) { 184 type_error("sequence index must be " 185 "integer, not '%.200s'", key); 186 return -1; 187 } 188 } 189 190 type_error("'%.200s' object does not support item assignment", o); 191 return -1; 192 } 193 194 int 195 PyObject_DelItem(PyObject *o, PyObject *key) 196 { 197 PyMappingMethods *m; 198 199 if (o == NULL || key == NULL) { 200 null_error(); 201 return -1; 202 } 203 m = o->ob_type->tp_as_mapping; 204 if (m && m->mp_ass_subscript) 205 return m->mp_ass_subscript(o, key, (PyObject*)NULL); 206 207 if (o->ob_type->tp_as_sequence) { 208 if (PyIndex_Check(key)) { 209 Py_ssize_t key_value; 210 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError); 211 if (key_value == -1 && PyErr_Occurred()) 212 return -1; 213 return PySequence_DelItem(o, key_value); 214 } 215 else if (o->ob_type->tp_as_sequence->sq_ass_item) { 216 type_error("sequence index must be " 217 "integer, not '%.200s'", key); 218 return -1; 219 } 220 } 221 222 type_error("'%.200s' object does not support item deletion", o); 223 return -1; 224 } 225 226 int 227 PyObject_DelItemString(PyObject *o, char *key) 228 { 229 PyObject *okey; 230 int ret; 231 232 if (o == NULL || key == NULL) { 233 null_error(); 234 return -1; 235 } 236 okey = PyString_FromString(key); 237 if (okey == NULL) 238 return -1; 239 ret = PyObject_DelItem(o, okey); 240 Py_DECREF(okey); 241 return ret; 242 } 243 244 int 245 PyObject_AsCharBuffer(PyObject *obj, 246 const char **buffer, 247 Py_ssize_t *buffer_len) 248 { 249 PyBufferProcs *pb; 250 char *pp; 251 Py_ssize_t len; 252 253 if (obj == NULL || buffer == NULL || buffer_len == NULL) { 254 null_error(); 255 return -1; 256 } 257 pb = obj->ob_type->tp_as_buffer; 258 if (pb == NULL || 259 pb->bf_getcharbuffer == NULL || 260 pb->bf_getsegcount == NULL) { 261 PyErr_SetString(PyExc_TypeError, 262 "expected a string or other character buffer object"); 263 return -1; 264 } 265 if ((*pb->bf_getsegcount)(obj,NULL) != 1) { 266 PyErr_SetString(PyExc_TypeError, 267 "expected a single-segment buffer object"); 268 return -1; 269 } 270 len = (*pb->bf_getcharbuffer)(obj, 0, &pp); 271 if (len < 0) 272 return -1; 273 *buffer = pp; 274 *buffer_len = len; 275 return 0; 276 } 277 278 int 279 PyObject_CheckReadBuffer(PyObject *obj) 280 { 281 PyBufferProcs *pb = obj->ob_type->tp_as_buffer; 282 283 if (pb == NULL || 284 pb->bf_getreadbuffer == NULL || 285 pb->bf_getsegcount == NULL || 286 (*pb->bf_getsegcount)(obj, NULL) != 1) 287 return 0; 288 return 1; 289 } 290 291 int PyObject_AsReadBuffer(PyObject *obj, 292 const void **buffer, 293 Py_ssize_t *buffer_len) 294 { 295 PyBufferProcs *pb; 296 void *pp; 297 Py_ssize_t len; 298 299 if (obj == NULL || buffer == NULL || buffer_len == NULL) { 300 null_error(); 301 return -1; 302 } 303 pb = obj->ob_type->tp_as_buffer; 304 if (pb == NULL || 305 pb->bf_getreadbuffer == NULL || 306 pb->bf_getsegcount == NULL) { 307 PyErr_SetString(PyExc_TypeError, 308 "expected a readable buffer object"); 309 return -1; 310 } 311 if ((*pb->bf_getsegcount)(obj, NULL) != 1) { 312 PyErr_SetString(PyExc_TypeError, 313 "expected a single-segment buffer object"); 314 return -1; 315 } 316 len = (*pb->bf_getreadbuffer)(obj, 0, &pp); 317 if (len < 0) 318 return -1; 319 *buffer = pp; 320 *buffer_len = len; 321 return 0; 322 } 323 324 int PyObject_AsWriteBuffer(PyObject *obj, 325 void **buffer, 326 Py_ssize_t *buffer_len) 327 { 328 PyBufferProcs *pb; 329 void*pp; 330 Py_ssize_t len; 331 332 if (obj == NULL || buffer == NULL || buffer_len == NULL) { 333 null_error(); 334 return -1; 335 } 336 pb = obj->ob_type->tp_as_buffer; 337 if (pb == NULL || 338 pb->bf_getwritebuffer == NULL || 339 pb->bf_getsegcount == NULL) { 340 PyErr_SetString(PyExc_TypeError, 341 "expected a writeable buffer object"); 342 return -1; 343 } 344 if ((*pb->bf_getsegcount)(obj, NULL) != 1) { 345 PyErr_SetString(PyExc_TypeError, 346 "expected a single-segment buffer object"); 347 return -1; 348 } 349 len = (*pb->bf_getwritebuffer)(obj,0,&pp); 350 if (len < 0) 351 return -1; 352 *buffer = pp; 353 *buffer_len = len; 354 return 0; 355 } 356 357 /* Buffer C-API for Python 3.0 */ 358 359 int 360 PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags) 361 { 362 if (!PyObject_CheckBuffer(obj)) { 363 PyErr_Format(PyExc_TypeError, 364 "'%100s' does not have the buffer interface", 365 Py_TYPE(obj)->tp_name); 366 return -1; 367 } 368 return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags); 369 } 370 371 static int 372 _IsFortranContiguous(Py_buffer *view) 373 { 374 Py_ssize_t sd, dim; 375 int i; 376 377 if (view->ndim == 0) return 1; 378 if (view->strides == NULL) return (view->ndim == 1); 379 380 sd = view->itemsize; 381 if (view->ndim == 1) return (view->shape[0] == 1 || 382 sd == view->strides[0]); 383 for (i=0; i<view->ndim; i++) { 384 dim = view->shape[i]; 385 if (dim == 0) return 1; 386 if (view->strides[i] != sd) return 0; 387 sd *= dim; 388 } 389 return 1; 390 } 391 392 static int 393 _IsCContiguous(Py_buffer *view) 394 { 395 Py_ssize_t sd, dim; 396 int i; 397 398 if (view->ndim == 0) return 1; 399 if (view->strides == NULL) return 1; 400 401 sd = view->itemsize; 402 if (view->ndim == 1) return (view->shape[0] == 1 || 403 sd == view->strides[0]); 404 for (i=view->ndim-1; i>=0; i--) { 405 dim = view->shape[i]; 406 if (dim == 0) return 1; 407 if (view->strides[i] != sd) return 0; 408 sd *= dim; 409 } 410 return 1; 411 } 412 413 int 414 PyBuffer_IsContiguous(Py_buffer *view, char fort) 415 { 416 417 if (view->suboffsets != NULL) return 0; 418 419 if (fort == 'C') 420 return _IsCContiguous(view); 421 else if (fort == 'F') 422 return _IsFortranContiguous(view); 423 else if (fort == 'A') 424 return (_IsCContiguous(view) || _IsFortranContiguous(view)); 425 return 0; 426 } 427 428 429 void* 430 PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices) 431 { 432 char* pointer; 433 int i; 434 pointer = (char *)view->buf; 435 for (i = 0; i < view->ndim; i++) { 436 pointer += view->strides[i]*indices[i]; 437 if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) { 438 pointer = *((char**)pointer) + view->suboffsets[i]; 439 } 440 } 441 return (void*)pointer; 442 } 443 444 445 void 446 _Py_add_one_to_index_F(int nd, Py_ssize_t *index, const Py_ssize_t *shape) 447 { 448 int k; 449 450 for (k=0; k<nd; k++) { 451 if (index[k] < shape[k]-1) { 452 index[k]++; 453 break; 454 } 455 else { 456 index[k] = 0; 457 } 458 } 459 } 460 461 void 462 _Py_add_one_to_index_C(int nd, Py_ssize_t *index, const Py_ssize_t *shape) 463 { 464 int k; 465 466 for (k=nd-1; k>=0; k--) { 467 if (index[k] < shape[k]-1) { 468 index[k]++; 469 break; 470 } 471 else { 472 index[k] = 0; 473 } 474 } 475 } 476 477 /* view is not checked for consistency in either of these. It is 478 assumed that the size of the buffer is view->len in 479 view->len / view->itemsize elements. 480 */ 481 482 int 483 PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort) 484 { 485 int k; 486 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *); 487 Py_ssize_t *indices, elements; 488 char *dest, *ptr; 489 490 if (len > view->len) { 491 len = view->len; 492 } 493 494 if (PyBuffer_IsContiguous(view, fort)) { 495 /* simplest copy is all that is needed */ 496 memcpy(buf, view->buf, len); 497 return 0; 498 } 499 500 /* Otherwise a more elaborate scheme is needed */ 501 502 /* view->ndim <= 64 */ 503 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim)); 504 if (indices == NULL) { 505 PyErr_NoMemory(); 506 return -1; 507 } 508 for (k=0; k<view->ndim;k++) { 509 indices[k] = 0; 510 } 511 512 if (fort == 'F') { 513 addone = _Py_add_one_to_index_F; 514 } 515 else { 516 addone = _Py_add_one_to_index_C; 517 } 518 dest = buf; 519 /* XXX : This is not going to be the fastest code in the world 520 several optimizations are possible. 521 */ 522 elements = len / view->itemsize; 523 while (elements--) { 524 ptr = PyBuffer_GetPointer(view, indices); 525 memcpy(dest, ptr, view->itemsize); 526 dest += view->itemsize; 527 addone(view->ndim, indices, view->shape); 528 } 529 PyMem_Free(indices); 530 return 0; 531 } 532 533 int 534 PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort) 535 { 536 int k; 537 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *); 538 Py_ssize_t *indices, elements; 539 char *src, *ptr; 540 541 if (len > view->len) { 542 len = view->len; 543 } 544 545 if (PyBuffer_IsContiguous(view, fort)) { 546 /* simplest copy is all that is needed */ 547 memcpy(view->buf, buf, len); 548 return 0; 549 } 550 551 /* Otherwise a more elaborate scheme is needed */ 552 553 /* view->ndim <= 64 */ 554 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim)); 555 if (indices == NULL) { 556 PyErr_NoMemory(); 557 return -1; 558 } 559 for (k=0; k<view->ndim;k++) { 560 indices[k] = 0; 561 } 562 563 if (fort == 'F') { 564 addone = _Py_add_one_to_index_F; 565 } 566 else { 567 addone = _Py_add_one_to_index_C; 568 } 569 src = buf; 570 /* XXX : This is not going to be the fastest code in the world 571 several optimizations are possible. 572 */ 573 elements = len / view->itemsize; 574 while (elements--) { 575 ptr = PyBuffer_GetPointer(view, indices); 576 memcpy(ptr, src, view->itemsize); 577 src += view->itemsize; 578 addone(view->ndim, indices, view->shape); 579 } 580 581 PyMem_Free(indices); 582 return 0; 583 } 584 585 int PyObject_CopyData(PyObject *dest, PyObject *src) 586 { 587 Py_buffer view_dest, view_src; 588 int k; 589 Py_ssize_t *indices, elements; 590 char *dptr, *sptr; 591 592 if (!PyObject_CheckBuffer(dest) || 593 !PyObject_CheckBuffer(src)) { 594 PyErr_SetString(PyExc_TypeError, 595 "both destination and source must have the "\ 596 "buffer interface"); 597 return -1; 598 } 599 600 if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1; 601 if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) { 602 PyBuffer_Release(&view_dest); 603 return -1; 604 } 605 606 if (view_dest.len < view_src.len) { 607 PyErr_SetString(PyExc_BufferError, 608 "destination is too small to receive data from source"); 609 PyBuffer_Release(&view_dest); 610 PyBuffer_Release(&view_src); 611 return -1; 612 } 613 614 if ((PyBuffer_IsContiguous(&view_dest, 'C') && 615 PyBuffer_IsContiguous(&view_src, 'C')) || 616 (PyBuffer_IsContiguous(&view_dest, 'F') && 617 PyBuffer_IsContiguous(&view_src, 'F'))) { 618 /* simplest copy is all that is needed */ 619 memcpy(view_dest.buf, view_src.buf, view_src.len); 620 PyBuffer_Release(&view_dest); 621 PyBuffer_Release(&view_src); 622 return 0; 623 } 624 625 /* Otherwise a more elaborate copy scheme is needed */ 626 627 /* XXX(nnorwitz): need to check for overflow! */ 628 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim); 629 if (indices == NULL) { 630 PyErr_NoMemory(); 631 PyBuffer_Release(&view_dest); 632 PyBuffer_Release(&view_src); 633 return -1; 634 } 635 for (k=0; k<view_src.ndim;k++) { 636 indices[k] = 0; 637 } 638 elements = 1; 639 for (k=0; k<view_src.ndim; k++) { 640 /* XXX(nnorwitz): can this overflow? */ 641 elements *= view_src.shape[k]; 642 } 643 while (elements--) { 644 _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape); 645 dptr = PyBuffer_GetPointer(&view_dest, indices); 646 sptr = PyBuffer_GetPointer(&view_src, indices); 647 memcpy(dptr, sptr, view_src.itemsize); 648 } 649 PyMem_Free(indices); 650 PyBuffer_Release(&view_dest); 651 PyBuffer_Release(&view_src); 652 return 0; 653 } 654 655 void 656 PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape, 657 Py_ssize_t *strides, int itemsize, 658 char fort) 659 { 660 int k; 661 Py_ssize_t sd; 662 663 sd = itemsize; 664 if (fort == 'F') { 665 for (k=0; k<nd; k++) { 666 strides[k] = sd; 667 sd *= shape[k]; 668 } 669 } 670 else { 671 for (k=nd-1; k>=0; k--) { 672 strides[k] = sd; 673 sd *= shape[k]; 674 } 675 } 676 return; 677 } 678 679 int 680 PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len, 681 int readonly, int flags) 682 { 683 if (view == NULL) return 0; 684 if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) && 685 (readonly == 1)) { 686 PyErr_SetString(PyExc_BufferError, 687 "Object is not writable."); 688 return -1; 689 } 690 691 view->obj = obj; 692 if (obj) 693 Py_INCREF(obj); 694 view->buf = buf; 695 view->len = len; 696 view->readonly = readonly; 697 view->itemsize = 1; 698 view->format = NULL; 699 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) 700 view->format = "B"; 701 view->ndim = 1; 702 view->shape = NULL; 703 if ((flags & PyBUF_ND) == PyBUF_ND) 704 view->shape = &(view->len); 705 view->strides = NULL; 706 if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) 707 view->strides = &(view->itemsize); 708 view->suboffsets = NULL; 709 view->internal = NULL; 710 return 0; 711 } 712 713 void 714 PyBuffer_Release(Py_buffer *view) 715 { 716 PyObject *obj = view->obj; 717 if (obj && Py_TYPE(obj)->tp_as_buffer && Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer) 718 Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer(obj, view); 719 Py_XDECREF(obj); 720 view->obj = NULL; 721 } 722 723 PyObject * 724 PyObject_Format(PyObject* obj, PyObject *format_spec) 725 { 726 PyObject *empty = NULL; 727 PyObject *result = NULL; 728 #ifdef Py_USING_UNICODE 729 int spec_is_unicode; 730 int result_is_unicode; 731 #endif 732 733 /* If no format_spec is provided, use an empty string */ 734 if (format_spec == NULL) { 735 empty = PyString_FromStringAndSize(NULL, 0); 736 format_spec = empty; 737 } 738 739 /* Check the format_spec type, and make sure it's str or unicode */ 740 #ifdef Py_USING_UNICODE 741 if (PyUnicode_Check(format_spec)) 742 spec_is_unicode = 1; 743 else if (PyString_Check(format_spec)) 744 spec_is_unicode = 0; 745 else { 746 #else 747 if (!PyString_Check(format_spec)) { 748 #endif 749 PyErr_Format(PyExc_TypeError, 750 "format expects arg 2 to be string " 751 "or unicode, not %.100s", Py_TYPE(format_spec)->tp_name); 752 goto done; 753 } 754 755 /* Check for a __format__ method and call it. */ 756 if (PyInstance_Check(obj)) { 757 /* We're an instance of a classic class */ 758 PyObject *bound_method = PyObject_GetAttrString(obj, "__format__"); 759 if (bound_method != NULL) { 760 result = PyObject_CallFunctionObjArgs(bound_method, 761 format_spec, 762 NULL); 763 Py_DECREF(bound_method); 764 } else { 765 PyObject *self_as_str = NULL; 766 PyObject *format_method = NULL; 767 Py_ssize_t format_len; 768 769 PyErr_Clear(); 770 /* Per the PEP, convert to str (or unicode, 771 depending on the type of the format 772 specifier). For new-style classes, this 773 logic is done by object.__format__(). */ 774 #ifdef Py_USING_UNICODE 775 if (spec_is_unicode) { 776 format_len = PyUnicode_GET_SIZE(format_spec); 777 self_as_str = PyObject_Unicode(obj); 778 } else 779 #endif 780 { 781 format_len = PyString_GET_SIZE(format_spec); 782 self_as_str = PyObject_Str(obj); 783 } 784 if (self_as_str == NULL) 785 goto done1; 786 787 if (format_len > 0) { 788 /* See the almost identical code in 789 typeobject.c for new-style 790 classes. */ 791 if (PyErr_WarnEx( 792 PyExc_PendingDeprecationWarning, 793 "object.__format__ with a non-empty " 794 "format string is deprecated", 1) 795 < 0) { 796 goto done1; 797 } 798 /* Eventually this will become an 799 error: 800 PyErr_Format(PyExc_TypeError, 801 "non-empty format string passed to " 802 "object.__format__"); 803 goto done1; 804 */ 805 } 806 807 /* Then call str.__format__ on that result */ 808 format_method = PyObject_GetAttrString(self_as_str, "__format__"); 809 if (format_method == NULL) { 810 goto done1; 811 } 812 result = PyObject_CallFunctionObjArgs(format_method, 813 format_spec, 814 NULL); 815 done1: 816 Py_XDECREF(self_as_str); 817 Py_XDECREF(format_method); 818 if (result == NULL) 819 goto done; 820 } 821 } else { 822 /* Not an instance of a classic class, use the code 823 from py3k */ 824 static PyObject *format_cache = NULL; 825 826 /* Find the (unbound!) __format__ method (a borrowed 827 reference) */ 828 PyObject *method = _PyObject_LookupSpecial(obj, "__format__", 829 &format_cache); 830 if (method == NULL) { 831 if (!PyErr_Occurred()) 832 PyErr_Format(PyExc_TypeError, 833 "Type %.100s doesn't define __format__", 834 Py_TYPE(obj)->tp_name); 835 goto done; 836 } 837 /* And call it. */ 838 result = PyObject_CallFunctionObjArgs(method, format_spec, NULL); 839 Py_DECREF(method); 840 } 841 842 if (result == NULL) 843 goto done; 844 845 /* Check the result type, and make sure it's str or unicode */ 846 #ifdef Py_USING_UNICODE 847 if (PyUnicode_Check(result)) 848 result_is_unicode = 1; 849 else if (PyString_Check(result)) 850 result_is_unicode = 0; 851 else { 852 #else 853 if (!PyString_Check(result)) { 854 #endif 855 PyErr_Format(PyExc_TypeError, 856 "%.100s.__format__ must return string or " 857 "unicode, not %.100s", Py_TYPE(obj)->tp_name, 858 Py_TYPE(result)->tp_name); 859 Py_DECREF(result); 860 result = NULL; 861 goto done; 862 } 863 864 /* Convert to unicode, if needed. Required if spec is unicode 865 and result is str */ 866 #ifdef Py_USING_UNICODE 867 if (spec_is_unicode && !result_is_unicode) { 868 PyObject *tmp = PyObject_Unicode(result); 869 /* This logic works whether or not tmp is NULL */ 870 Py_DECREF(result); 871 result = tmp; 872 } 873 #endif 874 875 done: 876 Py_XDECREF(empty); 877 return result; 878 } 879 880 /* Operations on numbers */ 881 882 int 883 PyNumber_Check(PyObject *o) 884 { 885 return o && o->ob_type->tp_as_number && 886 (o->ob_type->tp_as_number->nb_int || 887 o->ob_type->tp_as_number->nb_float); 888 } 889 890 /* Binary operators */ 891 892 /* New style number protocol support */ 893 894 #define NB_SLOT(x) offsetof(PyNumberMethods, x) 895 #define NB_BINOP(nb_methods, slot) \ 896 (*(binaryfunc*)(& ((char*)nb_methods)[slot])) 897 #define NB_TERNOP(nb_methods, slot) \ 898 (*(ternaryfunc*)(& ((char*)nb_methods)[slot])) 899 900 /* 901 Calling scheme used for binary operations: 902 903 v w Action 904 ------------------------------------------------------------------- 905 new new w.op(v,w)[*], v.op(v,w), w.op(v,w) 906 new old v.op(v,w), coerce(v,w), v.op(v,w) 907 old new w.op(v,w), coerce(v,w), v.op(v,w) 908 old old coerce(v,w), v.op(v,w) 909 910 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of 911 v->ob_type 912 913 Legend: 914 ------- 915 * new == new style number 916 * old == old style number 917 * Action indicates the order in which operations are tried until either 918 a valid result is produced or an error occurs. 919 920 */ 921 922 static PyObject * 923 binary_op1(PyObject *v, PyObject *w, const int op_slot) 924 { 925 PyObject *x; 926 binaryfunc slotv = NULL; 927 binaryfunc slotw = NULL; 928 929 if (v->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(v)) 930 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot); 931 if (w->ob_type != v->ob_type && 932 w->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(w)) { 933 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot); 934 if (slotw == slotv) 935 slotw = NULL; 936 } 937 if (slotv) { 938 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) { 939 x = slotw(v, w); 940 if (x != Py_NotImplemented) 941 return x; 942 Py_DECREF(x); /* can't do it */ 943 slotw = NULL; 944 } 945 x = slotv(v, w); 946 if (x != Py_NotImplemented) 947 return x; 948 Py_DECREF(x); /* can't do it */ 949 } 950 if (slotw) { 951 x = slotw(v, w); 952 if (x != Py_NotImplemented) 953 return x; 954 Py_DECREF(x); /* can't do it */ 955 } 956 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w)) { 957 int err = PyNumber_CoerceEx(&v, &w); 958 if (err < 0) { 959 return NULL; 960 } 961 if (err == 0) { 962 PyNumberMethods *mv = v->ob_type->tp_as_number; 963 if (mv) { 964 binaryfunc slot; 965 slot = NB_BINOP(mv, op_slot); 966 if (slot) { 967 x = slot(v, w); 968 Py_DECREF(v); 969 Py_DECREF(w); 970 return x; 971 } 972 } 973 /* CoerceEx incremented the reference counts */ 974 Py_DECREF(v); 975 Py_DECREF(w); 976 } 977 } 978 Py_INCREF(Py_NotImplemented); 979 return Py_NotImplemented; 980 } 981 982 static PyObject * 983 binop_type_error(PyObject *v, PyObject *w, const char *op_name) 984 { 985 PyErr_Format(PyExc_TypeError, 986 "unsupported operand type(s) for %.100s: " 987 "'%.100s' and '%.100s'", 988 op_name, 989 v->ob_type->tp_name, 990 w->ob_type->tp_name); 991 return NULL; 992 } 993 994 static PyObject * 995 binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name) 996 { 997 PyObject *result = binary_op1(v, w, op_slot); 998 if (result == Py_NotImplemented) { 999 Py_DECREF(result); 1000 return binop_type_error(v, w, op_name); 1001 } 1002 return result; 1003 } 1004 1005 1006 /* 1007 Calling scheme used for ternary operations: 1008 1009 *** In some cases, w.op is called before v.op; see binary_op1. *** 1010 1011 v w z Action 1012 ------------------------------------------------------------------- 1013 new new new v.op(v,w,z), w.op(v,w,z), z.op(v,w,z) 1014 new old new v.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z) 1015 old new new w.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z) 1016 old old new z.op(v,w,z), coerce(v,w,z), v.op(v,w,z) 1017 new new old v.op(v,w,z), w.op(v,w,z), coerce(v,w,z), v.op(v,w,z) 1018 new old old v.op(v,w,z), coerce(v,w,z), v.op(v,w,z) 1019 old new old w.op(v,w,z), coerce(v,w,z), v.op(v,w,z) 1020 old old old coerce(v,w,z), v.op(v,w,z) 1021 1022 Legend: 1023 ------- 1024 * new == new style number 1025 * old == old style number 1026 * Action indicates the order in which operations are tried until either 1027 a valid result is produced or an error occurs. 1028 * coerce(v,w,z) actually does: coerce(v,w), coerce(v,z), coerce(w,z) and 1029 only if z != Py_None; if z == Py_None, then it is treated as absent 1030 variable and only coerce(v,w) is tried. 1031 1032 */ 1033 1034 static PyObject * 1035 ternary_op(PyObject *v, 1036 PyObject *w, 1037 PyObject *z, 1038 const int op_slot, 1039 const char *op_name) 1040 { 1041 PyNumberMethods *mv, *mw, *mz; 1042 PyObject *x = NULL; 1043 ternaryfunc slotv = NULL; 1044 ternaryfunc slotw = NULL; 1045 ternaryfunc slotz = NULL; 1046 1047 mv = v->ob_type->tp_as_number; 1048 mw = w->ob_type->tp_as_number; 1049 if (mv != NULL && NEW_STYLE_NUMBER(v)) 1050 slotv = NB_TERNOP(mv, op_slot); 1051 if (w->ob_type != v->ob_type && 1052 mw != NULL && NEW_STYLE_NUMBER(w)) { 1053 slotw = NB_TERNOP(mw, op_slot); 1054 if (slotw == slotv) 1055 slotw = NULL; 1056 } 1057 if (slotv) { 1058 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) { 1059 x = slotw(v, w, z); 1060 if (x != Py_NotImplemented) 1061 return x; 1062 Py_DECREF(x); /* can't do it */ 1063 slotw = NULL; 1064 } 1065 x = slotv(v, w, z); 1066 if (x != Py_NotImplemented) 1067 return x; 1068 Py_DECREF(x); /* can't do it */ 1069 } 1070 if (slotw) { 1071 x = slotw(v, w, z); 1072 if (x != Py_NotImplemented) 1073 return x; 1074 Py_DECREF(x); /* can't do it */ 1075 } 1076 mz = z->ob_type->tp_as_number; 1077 if (mz != NULL && NEW_STYLE_NUMBER(z)) { 1078 slotz = NB_TERNOP(mz, op_slot); 1079 if (slotz == slotv || slotz == slotw) 1080 slotz = NULL; 1081 if (slotz) { 1082 x = slotz(v, w, z); 1083 if (x != Py_NotImplemented) 1084 return x; 1085 Py_DECREF(x); /* can't do it */ 1086 } 1087 } 1088 1089 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w) || 1090 (z != Py_None && !NEW_STYLE_NUMBER(z))) { 1091 /* we have an old style operand, coerce */ 1092 PyObject *v1, *z1, *w2, *z2; 1093 int c; 1094 1095 c = PyNumber_Coerce(&v, &w); 1096 if (c != 0) 1097 goto error3; 1098 1099 /* Special case: if the third argument is None, it is 1100 treated as absent argument and not coerced. */ 1101 if (z == Py_None) { 1102 if (v->ob_type->tp_as_number) { 1103 slotz = NB_TERNOP(v->ob_type->tp_as_number, 1104 op_slot); 1105 if (slotz) 1106 x = slotz(v, w, z); 1107 else 1108 c = -1; 1109 } 1110 else 1111 c = -1; 1112 goto error2; 1113 } 1114 v1 = v; 1115 z1 = z; 1116 c = PyNumber_Coerce(&v1, &z1); 1117 if (c != 0) 1118 goto error2; 1119 w2 = w; 1120 z2 = z1; 1121 c = PyNumber_Coerce(&w2, &z2); 1122 if (c != 0) 1123 goto error1; 1124 1125 if (v1->ob_type->tp_as_number != NULL) { 1126 slotv = NB_TERNOP(v1->ob_type->tp_as_number, 1127 op_slot); 1128 if (slotv) 1129 x = slotv(v1, w2, z2); 1130 else 1131 c = -1; 1132 } 1133 else 1134 c = -1; 1135 1136 Py_DECREF(w2); 1137 Py_DECREF(z2); 1138 error1: 1139 Py_DECREF(v1); 1140 Py_DECREF(z1); 1141 error2: 1142 Py_DECREF(v); 1143 Py_DECREF(w); 1144 error3: 1145 if (c >= 0) 1146 return x; 1147 } 1148 1149 if (z == Py_None) 1150 PyErr_Format( 1151 PyExc_TypeError, 1152 "unsupported operand type(s) for ** or pow(): " 1153 "'%.100s' and '%.100s'", 1154 v->ob_type->tp_name, 1155 w->ob_type->tp_name); 1156 else 1157 PyErr_Format( 1158 PyExc_TypeError, 1159 "unsupported operand type(s) for pow(): " 1160 "'%.100s', '%.100s', '%.100s'", 1161 v->ob_type->tp_name, 1162 w->ob_type->tp_name, 1163 z->ob_type->tp_name); 1164 return NULL; 1165 } 1166 1167 #define BINARY_FUNC(func, op, op_name) \ 1168 PyObject * \ 1169 func(PyObject *v, PyObject *w) { \ 1170 return binary_op(v, w, NB_SLOT(op), op_name); \ 1171 } 1172 1173 BINARY_FUNC(PyNumber_Or, nb_or, "|") 1174 BINARY_FUNC(PyNumber_Xor, nb_xor, "^") 1175 BINARY_FUNC(PyNumber_And, nb_and, "&") 1176 BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<") 1177 BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>") 1178 BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-") 1179 BINARY_FUNC(PyNumber_Divide, nb_divide, "/") 1180 BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()") 1181 1182 PyObject * 1183 PyNumber_Add(PyObject *v, PyObject *w) 1184 { 1185 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add)); 1186 if (result == Py_NotImplemented) { 1187 PySequenceMethods *m = v->ob_type->tp_as_sequence; 1188 Py_DECREF(result); 1189 if (m && m->sq_concat) { 1190 return (*m->sq_concat)(v, w); 1191 } 1192 result = binop_type_error(v, w, "+"); 1193 } 1194 return result; 1195 } 1196 1197 static PyObject * 1198 sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n) 1199 { 1200 Py_ssize_t count; 1201 if (PyIndex_Check(n)) { 1202 count = PyNumber_AsSsize_t(n, PyExc_OverflowError); 1203 if (count == -1 && PyErr_Occurred()) 1204 return NULL; 1205 } 1206 else { 1207 return type_error("can't multiply sequence by " 1208 "non-int of type '%.200s'", n); 1209 } 1210 return (*repeatfunc)(seq, count); 1211 } 1212 1213 PyObject * 1214 PyNumber_Multiply(PyObject *v, PyObject *w) 1215 { 1216 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply)); 1217 if (result == Py_NotImplemented) { 1218 PySequenceMethods *mv = v->ob_type->tp_as_sequence; 1219 PySequenceMethods *mw = w->ob_type->tp_as_sequence; 1220 Py_DECREF(result); 1221 if (mv && mv->sq_repeat) { 1222 return sequence_repeat(mv->sq_repeat, v, w); 1223 } 1224 else if (mw && mw->sq_repeat) { 1225 return sequence_repeat(mw->sq_repeat, w, v); 1226 } 1227 result = binop_type_error(v, w, "*"); 1228 } 1229 return result; 1230 } 1231 1232 PyObject * 1233 PyNumber_FloorDivide(PyObject *v, PyObject *w) 1234 { 1235 /* XXX tp_flags test */ 1236 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//"); 1237 } 1238 1239 PyObject * 1240 PyNumber_TrueDivide(PyObject *v, PyObject *w) 1241 { 1242 /* XXX tp_flags test */ 1243 return binary_op(v, w, NB_SLOT(nb_true_divide), "/"); 1244 } 1245 1246 PyObject * 1247 PyNumber_Remainder(PyObject *v, PyObject *w) 1248 { 1249 return binary_op(v, w, NB_SLOT(nb_remainder), "%"); 1250 } 1251 1252 PyObject * 1253 PyNumber_Power(PyObject *v, PyObject *w, PyObject *z) 1254 { 1255 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()"); 1256 } 1257 1258 /* Binary in-place operators */ 1259 1260 /* The in-place operators are defined to fall back to the 'normal', 1261 non in-place operations, if the in-place methods are not in place. 1262 1263 - If the left hand object has the appropriate struct members, and 1264 they are filled, call the appropriate function and return the 1265 result. No coercion is done on the arguments; the left-hand object 1266 is the one the operation is performed on, and it's up to the 1267 function to deal with the right-hand object. 1268 1269 - Otherwise, in-place modification is not supported. Handle it exactly as 1270 a non in-place operation of the same kind. 1271 1272 */ 1273 1274 #define HASINPLACE(t) \ 1275 PyType_HasFeature((t)->ob_type, Py_TPFLAGS_HAVE_INPLACEOPS) 1276 1277 static PyObject * 1278 binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot) 1279 { 1280 PyNumberMethods *mv = v->ob_type->tp_as_number; 1281 if (mv != NULL && HASINPLACE(v)) { 1282 binaryfunc slot = NB_BINOP(mv, iop_slot); 1283 if (slot) { 1284 PyObject *x = (slot)(v, w); 1285 if (x != Py_NotImplemented) { 1286 return x; 1287 } 1288 Py_DECREF(x); 1289 } 1290 } 1291 return binary_op1(v, w, op_slot); 1292 } 1293 1294 static PyObject * 1295 binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot, 1296 const char *op_name) 1297 { 1298 PyObject *result = binary_iop1(v, w, iop_slot, op_slot); 1299 if (result == Py_NotImplemented) { 1300 Py_DECREF(result); 1301 return binop_type_error(v, w, op_name); 1302 } 1303 return result; 1304 } 1305 1306 #define INPLACE_BINOP(func, iop, op, op_name) \ 1307 PyObject * \ 1308 func(PyObject *v, PyObject *w) { \ 1309 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \ 1310 } 1311 1312 INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=") 1313 INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=") 1314 INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=") 1315 INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=") 1316 INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=") 1317 INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=") 1318 INPLACE_BINOP(PyNumber_InPlaceDivide, nb_inplace_divide, nb_divide, "/=") 1319 1320 PyObject * 1321 PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w) 1322 { 1323 /* XXX tp_flags test */ 1324 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide), 1325 NB_SLOT(nb_floor_divide), "//="); 1326 } 1327 1328 PyObject * 1329 PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w) 1330 { 1331 /* XXX tp_flags test */ 1332 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide), 1333 NB_SLOT(nb_true_divide), "/="); 1334 } 1335 1336 PyObject * 1337 PyNumber_InPlaceAdd(PyObject *v, PyObject *w) 1338 { 1339 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add), 1340 NB_SLOT(nb_add)); 1341 if (result == Py_NotImplemented) { 1342 PySequenceMethods *m = v->ob_type->tp_as_sequence; 1343 Py_DECREF(result); 1344 if (m != NULL) { 1345 binaryfunc f = NULL; 1346 if (HASINPLACE(v)) 1347 f = m->sq_inplace_concat; 1348 if (f == NULL) 1349 f = m->sq_concat; 1350 if (f != NULL) 1351 return (*f)(v, w); 1352 } 1353 result = binop_type_error(v, w, "+="); 1354 } 1355 return result; 1356 } 1357 1358 PyObject * 1359 PyNumber_InPlaceMultiply(PyObject *v, PyObject *w) 1360 { 1361 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply), 1362 NB_SLOT(nb_multiply)); 1363 if (result == Py_NotImplemented) { 1364 ssizeargfunc f = NULL; 1365 PySequenceMethods *mv = v->ob_type->tp_as_sequence; 1366 PySequenceMethods *mw = w->ob_type->tp_as_sequence; 1367 Py_DECREF(result); 1368 if (mv != NULL) { 1369 if (HASINPLACE(v)) 1370 f = mv->sq_inplace_repeat; 1371 if (f == NULL) 1372 f = mv->sq_repeat; 1373 if (f != NULL) 1374 return sequence_repeat(f, v, w); 1375 } 1376 else if (mw != NULL) { 1377 /* Note that the right hand operand should not be 1378 * mutated in this case so sq_inplace_repeat is not 1379 * used. */ 1380 if (mw->sq_repeat) 1381 return sequence_repeat(mw->sq_repeat, w, v); 1382 } 1383 result = binop_type_error(v, w, "*="); 1384 } 1385 return result; 1386 } 1387 1388 PyObject * 1389 PyNumber_InPlaceRemainder(PyObject *v, PyObject *w) 1390 { 1391 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder), 1392 NB_SLOT(nb_remainder), "%="); 1393 } 1394 1395 PyObject * 1396 PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z) 1397 { 1398 if (HASINPLACE(v) && v->ob_type->tp_as_number && 1399 v->ob_type->tp_as_number->nb_inplace_power != NULL) { 1400 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**="); 1401 } 1402 else { 1403 return ternary_op(v, w, z, NB_SLOT(nb_power), "**="); 1404 } 1405 } 1406 1407 1408 /* Unary operators and functions */ 1409 1410 PyObject * 1411 PyNumber_Negative(PyObject *o) 1412 { 1413 PyNumberMethods *m; 1414 1415 if (o == NULL) 1416 return null_error(); 1417 m = o->ob_type->tp_as_number; 1418 if (m && m->nb_negative) 1419 return (*m->nb_negative)(o); 1420 1421 return type_error("bad operand type for unary -: '%.200s'", o); 1422 } 1423 1424 PyObject * 1425 PyNumber_Positive(PyObject *o) 1426 { 1427 PyNumberMethods *m; 1428 1429 if (o == NULL) 1430 return null_error(); 1431 m = o->ob_type->tp_as_number; 1432 if (m && m->nb_positive) 1433 return (*m->nb_positive)(o); 1434 1435 return type_error("bad operand type for unary +: '%.200s'", o); 1436 } 1437 1438 PyObject * 1439 PyNumber_Invert(PyObject *o) 1440 { 1441 PyNumberMethods *m; 1442 1443 if (o == NULL) 1444 return null_error(); 1445 m = o->ob_type->tp_as_number; 1446 if (m && m->nb_invert) 1447 return (*m->nb_invert)(o); 1448 1449 return type_error("bad operand type for unary ~: '%.200s'", o); 1450 } 1451 1452 PyObject * 1453 PyNumber_Absolute(PyObject *o) 1454 { 1455 PyNumberMethods *m; 1456 1457 if (o == NULL) 1458 return null_error(); 1459 m = o->ob_type->tp_as_number; 1460 if (m && m->nb_absolute) 1461 return m->nb_absolute(o); 1462 1463 return type_error("bad operand type for abs(): '%.200s'", o); 1464 } 1465 1466 /* Add a check for embedded NULL-bytes in the argument. */ 1467 static PyObject * 1468 int_from_string(const char *s, Py_ssize_t len) 1469 { 1470 char *end; 1471 PyObject *x; 1472 1473 x = PyInt_FromString((char*)s, &end, 10); 1474 if (x == NULL) 1475 return NULL; 1476 if (end != s + len) { 1477 PyErr_SetString(PyExc_ValueError, 1478 "null byte in argument for int()"); 1479 Py_DECREF(x); 1480 return NULL; 1481 } 1482 return x; 1483 } 1484 1485 /* Return a Python Int or Long from the object item 1486 Raise TypeError if the result is not an int-or-long 1487 or if the object cannot be interpreted as an index. 1488 */ 1489 PyObject * 1490 PyNumber_Index(PyObject *item) 1491 { 1492 PyObject *result = NULL; 1493 if (item == NULL) 1494 return null_error(); 1495 if (PyInt_Check(item) || PyLong_Check(item)) { 1496 Py_INCREF(item); 1497 return item; 1498 } 1499 if (PyIndex_Check(item)) { 1500 result = item->ob_type->tp_as_number->nb_index(item); 1501 if (result && 1502 !PyInt_Check(result) && !PyLong_Check(result)) { 1503 PyErr_Format(PyExc_TypeError, 1504 "__index__ returned non-(int,long) " \ 1505 "(type %.200s)", 1506 result->ob_type->tp_name); 1507 Py_DECREF(result); 1508 return NULL; 1509 } 1510 } 1511 else { 1512 PyErr_Format(PyExc_TypeError, 1513 "'%.200s' object cannot be interpreted " 1514 "as an index", item->ob_type->tp_name); 1515 } 1516 return result; 1517 } 1518 1519 /* Return an error on Overflow only if err is not NULL*/ 1520 1521 Py_ssize_t 1522 PyNumber_AsSsize_t(PyObject *item, PyObject *err) 1523 { 1524 Py_ssize_t result; 1525 PyObject *runerr; 1526 PyObject *value = PyNumber_Index(item); 1527 if (value == NULL) 1528 return -1; 1529 1530 /* We're done if PyInt_AsSsize_t() returns without error. */ 1531 result = PyInt_AsSsize_t(value); 1532 if (result != -1 || !(runerr = PyErr_Occurred())) 1533 goto finish; 1534 1535 /* Error handling code -- only manage OverflowError differently */ 1536 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) 1537 goto finish; 1538 1539 PyErr_Clear(); 1540 /* If no error-handling desired then the default clipping 1541 is sufficient. 1542 */ 1543 if (!err) { 1544 assert(PyLong_Check(value)); 1545 /* Whether or not it is less than or equal to 1546 zero is determined by the sign of ob_size 1547 */ 1548 if (_PyLong_Sign(value) < 0) 1549 result = PY_SSIZE_T_MIN; 1550 else 1551 result = PY_SSIZE_T_MAX; 1552 } 1553 else { 1554 /* Otherwise replace the error with caller's error object. */ 1555 PyErr_Format(err, 1556 "cannot fit '%.200s' into an index-sized integer", 1557 item->ob_type->tp_name); 1558 } 1559 1560 finish: 1561 Py_DECREF(value); 1562 return result; 1563 } 1564 1565 1566 PyObject * 1567 _PyNumber_ConvertIntegralToInt(PyObject *integral, const char* error_format) 1568 { 1569 const char *type_name; 1570 static PyObject *int_name = NULL; 1571 if (int_name == NULL) { 1572 int_name = PyString_InternFromString("__int__"); 1573 if (int_name == NULL) 1574 return NULL; 1575 } 1576 1577 if (integral && (!PyInt_Check(integral) && 1578 !PyLong_Check(integral))) { 1579 /* Don't go through tp_as_number->nb_int to avoid 1580 hitting the classic class fallback to __trunc__. */ 1581 PyObject *int_func = PyObject_GetAttr(integral, int_name); 1582 if (int_func == NULL) { 1583 PyErr_Clear(); /* Raise a different error. */ 1584 goto non_integral_error; 1585 } 1586 Py_DECREF(integral); 1587 integral = PyEval_CallObject(int_func, NULL); 1588 Py_DECREF(int_func); 1589 if (integral && (!PyInt_Check(integral) && 1590 !PyLong_Check(integral))) { 1591 goto non_integral_error; 1592 } 1593 } 1594 return integral; 1595 1596 non_integral_error: 1597 if (PyInstance_Check(integral)) { 1598 type_name = PyString_AS_STRING(((PyInstanceObject *)integral) 1599 ->in_class->cl_name); 1600 } 1601 else { 1602 type_name = integral->ob_type->tp_name; 1603 } 1604 PyErr_Format(PyExc_TypeError, error_format, type_name); 1605 Py_DECREF(integral); 1606 return NULL; 1607 } 1608 1609 1610 PyObject * 1611 PyNumber_Int(PyObject *o) 1612 { 1613 PyNumberMethods *m; 1614 static PyObject *trunc_name = NULL; 1615 PyObject *trunc_func; 1616 const char *buffer; 1617 Py_ssize_t buffer_len; 1618 1619 if (trunc_name == NULL) { 1620 trunc_name = PyString_InternFromString("__trunc__"); 1621 if (trunc_name == NULL) 1622 return NULL; 1623 } 1624 1625 if (o == NULL) 1626 return null_error(); 1627 if (PyInt_CheckExact(o)) { 1628 Py_INCREF(o); 1629 return o; 1630 } 1631 m = o->ob_type->tp_as_number; 1632 if (m && m->nb_int) { /* This should include subclasses of int */ 1633 /* Classic classes always take this branch. */ 1634 PyObject *res = m->nb_int(o); 1635 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) { 1636 PyErr_Format(PyExc_TypeError, 1637 "__int__ returned non-int (type %.200s)", 1638 res->ob_type->tp_name); 1639 Py_DECREF(res); 1640 return NULL; 1641 } 1642 return res; 1643 } 1644 if (PyInt_Check(o)) { /* An int subclass without nb_int */ 1645 PyIntObject *io = (PyIntObject*)o; 1646 return PyInt_FromLong(io->ob_ival); 1647 } 1648 trunc_func = PyObject_GetAttr(o, trunc_name); 1649 if (trunc_func) { 1650 PyObject *truncated = PyEval_CallObject(trunc_func, NULL); 1651 Py_DECREF(trunc_func); 1652 /* __trunc__ is specified to return an Integral type, but 1653 int() needs to return an int. */ 1654 return _PyNumber_ConvertIntegralToInt( 1655 truncated, 1656 "__trunc__ returned non-Integral (type %.200s)"); 1657 } 1658 PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */ 1659 1660 if (PyString_Check(o)) 1661 return int_from_string(PyString_AS_STRING(o), 1662 PyString_GET_SIZE(o)); 1663 #ifdef Py_USING_UNICODE 1664 if (PyUnicode_Check(o)) 1665 return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o), 1666 PyUnicode_GET_SIZE(o), 1667 10); 1668 #endif 1669 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len)) { 1670 PyObject *result, *str; 1671 1672 /* Copy to NUL-terminated buffer. */ 1673 str = PyString_FromStringAndSize((const char *)buffer, buffer_len); 1674 if (str == NULL) 1675 return NULL; 1676 result = int_from_string(PyString_AS_STRING(str), buffer_len); 1677 Py_DECREF(str); 1678 return result; 1679 } 1680 1681 return type_error("int() argument must be a string or a " 1682 "number, not '%.200s'", o); 1683 } 1684 1685 /* Add a check for embedded NULL-bytes in the argument. */ 1686 static PyObject * 1687 long_from_string(const char *s, Py_ssize_t len) 1688 { 1689 char *end; 1690 PyObject *x; 1691 1692 x = PyLong_FromString((char*)s, &end, 10); 1693 if (x == NULL) 1694 return NULL; 1695 if (end != s + len) { 1696 PyErr_SetString(PyExc_ValueError, 1697 "null byte in argument for long()"); 1698 Py_DECREF(x); 1699 return NULL; 1700 } 1701 return x; 1702 } 1703 1704 PyObject * 1705 PyNumber_Long(PyObject *o) 1706 { 1707 PyNumberMethods *m; 1708 static PyObject *trunc_name = NULL; 1709 PyObject *trunc_func; 1710 const char *buffer; 1711 Py_ssize_t buffer_len; 1712 1713 if (trunc_name == NULL) { 1714 trunc_name = PyString_InternFromString("__trunc__"); 1715 if (trunc_name == NULL) 1716 return NULL; 1717 } 1718 1719 if (o == NULL) 1720 return null_error(); 1721 m = o->ob_type->tp_as_number; 1722 if (m && m->nb_long) { /* This should include subclasses of long */ 1723 /* Classic classes always take this branch. */ 1724 PyObject *res = m->nb_long(o); 1725 if (res == NULL) 1726 return NULL; 1727 if (PyInt_Check(res)) { 1728 long value = PyInt_AS_LONG(res); 1729 Py_DECREF(res); 1730 return PyLong_FromLong(value); 1731 } 1732 else if (!PyLong_Check(res)) { 1733 PyErr_Format(PyExc_TypeError, 1734 "__long__ returned non-long (type %.200s)", 1735 res->ob_type->tp_name); 1736 Py_DECREF(res); 1737 return NULL; 1738 } 1739 return res; 1740 } 1741 if (PyLong_Check(o)) /* A long subclass without nb_long */ 1742 return _PyLong_Copy((PyLongObject *)o); 1743 trunc_func = PyObject_GetAttr(o, trunc_name); 1744 if (trunc_func) { 1745 PyObject *truncated = PyEval_CallObject(trunc_func, NULL); 1746 PyObject *int_instance; 1747 Py_DECREF(trunc_func); 1748 /* __trunc__ is specified to return an Integral type, 1749 but long() needs to return a long. */ 1750 int_instance = _PyNumber_ConvertIntegralToInt( 1751 truncated, 1752 "__trunc__ returned non-Integral (type %.200s)"); 1753 if (int_instance && PyInt_Check(int_instance)) { 1754 /* Make sure that long() returns a long instance. */ 1755 long value = PyInt_AS_LONG(int_instance); 1756 Py_DECREF(int_instance); 1757 return PyLong_FromLong(value); 1758 } 1759 return int_instance; 1760 } 1761 PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */ 1762 1763 if (PyString_Check(o)) 1764 /* need to do extra error checking that PyLong_FromString() 1765 * doesn't do. In particular long('9.5') must raise an 1766 * exception, not truncate the float. 1767 */ 1768 return long_from_string(PyString_AS_STRING(o), 1769 PyString_GET_SIZE(o)); 1770 #ifdef Py_USING_UNICODE 1771 if (PyUnicode_Check(o)) 1772 /* The above check is done in PyLong_FromUnicode(). */ 1773 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o), 1774 PyUnicode_GET_SIZE(o), 1775 10); 1776 #endif 1777 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len)) { 1778 PyObject *result, *str; 1779 1780 /* Copy to NUL-terminated buffer. */ 1781 str = PyString_FromStringAndSize((const char *)buffer, buffer_len); 1782 if (str == NULL) 1783 return NULL; 1784 result = long_from_string(PyString_AS_STRING(str), buffer_len); 1785 Py_DECREF(str); 1786 return result; 1787 } 1788 return type_error("long() argument must be a string or a " 1789 "number, not '%.200s'", o); 1790 } 1791 1792 PyObject * 1793 PyNumber_Float(PyObject *o) 1794 { 1795 PyNumberMethods *m; 1796 1797 if (o == NULL) 1798 return null_error(); 1799 m = o->ob_type->tp_as_number; 1800 if (m && m->nb_float) { /* This should include subclasses of float */ 1801 PyObject *res = m->nb_float(o); 1802 if (res && !PyFloat_Check(res)) { 1803 PyErr_Format(PyExc_TypeError, 1804 "__float__ returned non-float (type %.200s)", 1805 res->ob_type->tp_name); 1806 Py_DECREF(res); 1807 return NULL; 1808 } 1809 return res; 1810 } 1811 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */ 1812 PyFloatObject *po = (PyFloatObject *)o; 1813 return PyFloat_FromDouble(po->ob_fval); 1814 } 1815 return PyFloat_FromString(o, NULL); 1816 } 1817 1818 PyObject * 1819 PyNumber_ToBase(PyObject *n, int base) 1820 { 1821 PyObject *res = NULL; 1822 PyObject *index = PyNumber_Index(n); 1823 1824 if (!index) 1825 return NULL; 1826 if (PyLong_Check(index)) 1827 res = _PyLong_Format(index, base, 0, 1); 1828 else if (PyInt_Check(index)) 1829 res = _PyInt_Format((PyIntObject*)index, base, 1); 1830 else 1831 /* It should not be possible to get here, as 1832 PyNumber_Index already has a check for the same 1833 condition */ 1834 PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not " 1835 "int or long"); 1836 Py_DECREF(index); 1837 return res; 1838 } 1839 1840 1841 /* Operations on sequences */ 1842 1843 int 1844 PySequence_Check(PyObject *s) 1845 { 1846 if (s == NULL) 1847 return 0; 1848 if (PyInstance_Check(s)) 1849 return PyObject_HasAttrString(s, "__getitem__"); 1850 if (PyDict_Check(s)) 1851 return 0; 1852 return s->ob_type->tp_as_sequence && 1853 s->ob_type->tp_as_sequence->sq_item != NULL; 1854 } 1855 1856 Py_ssize_t 1857 PySequence_Size(PyObject *s) 1858 { 1859 PySequenceMethods *m; 1860 1861 if (s == NULL) { 1862 null_error(); 1863 return -1; 1864 } 1865 1866 m = s->ob_type->tp_as_sequence; 1867 if (m && m->sq_length) 1868 return m->sq_length(s); 1869 1870 type_error("object of type '%.200s' has no len()", s); 1871 return -1; 1872 } 1873 1874 #undef PySequence_Length 1875 Py_ssize_t 1876 PySequence_Length(PyObject *s) 1877 { 1878 return PySequence_Size(s); 1879 } 1880 #define PySequence_Length PySequence_Size 1881 1882 PyObject * 1883 PySequence_Concat(PyObject *s, PyObject *o) 1884 { 1885 PySequenceMethods *m; 1886 1887 if (s == NULL || o == NULL) 1888 return null_error(); 1889 1890 m = s->ob_type->tp_as_sequence; 1891 if (m && m->sq_concat) 1892 return m->sq_concat(s, o); 1893 1894 /* Instances of user classes defining an __add__() method only 1895 have an nb_add slot, not an sq_concat slot. So we fall back 1896 to nb_add if both arguments appear to be sequences. */ 1897 if (PySequence_Check(s) && PySequence_Check(o)) { 1898 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add)); 1899 if (result != Py_NotImplemented) 1900 return result; 1901 Py_DECREF(result); 1902 } 1903 return type_error("'%.200s' object can't be concatenated", s); 1904 } 1905 1906 PyObject * 1907 PySequence_Repeat(PyObject *o, Py_ssize_t count) 1908 { 1909 PySequenceMethods *m; 1910 1911 if (o == NULL) 1912 return null_error(); 1913 1914 m = o->ob_type->tp_as_sequence; 1915 if (m && m->sq_repeat) 1916 return m->sq_repeat(o, count); 1917 1918 /* Instances of user classes defining a __mul__() method only 1919 have an nb_multiply slot, not an sq_repeat slot. so we fall back 1920 to nb_multiply if o appears to be a sequence. */ 1921 if (PySequence_Check(o)) { 1922 PyObject *n, *result; 1923 n = PyInt_FromSsize_t(count); 1924 if (n == NULL) 1925 return NULL; 1926 result = binary_op1(o, n, NB_SLOT(nb_multiply)); 1927 Py_DECREF(n); 1928 if (result != Py_NotImplemented) 1929 return result; 1930 Py_DECREF(result); 1931 } 1932 return type_error("'%.200s' object can't be repeated", o); 1933 } 1934 1935 PyObject * 1936 PySequence_InPlaceConcat(PyObject *s, PyObject *o) 1937 { 1938 PySequenceMethods *m; 1939 1940 if (s == NULL || o == NULL) 1941 return null_error(); 1942 1943 m = s->ob_type->tp_as_sequence; 1944 if (m && HASINPLACE(s) && m->sq_inplace_concat) 1945 return m->sq_inplace_concat(s, o); 1946 if (m && m->sq_concat) 1947 return m->sq_concat(s, o); 1948 1949 if (PySequence_Check(s) && PySequence_Check(o)) { 1950 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add), 1951 NB_SLOT(nb_add)); 1952 if (result != Py_NotImplemented) 1953 return result; 1954 Py_DECREF(result); 1955 } 1956 return type_error("'%.200s' object can't be concatenated", s); 1957 } 1958 1959 PyObject * 1960 PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count) 1961 { 1962 PySequenceMethods *m; 1963 1964 if (o == NULL) 1965 return null_error(); 1966 1967 m = o->ob_type->tp_as_sequence; 1968 if (m && HASINPLACE(o) && m->sq_inplace_repeat) 1969 return m->sq_inplace_repeat(o, count); 1970 if (m && m->sq_repeat) 1971 return m->sq_repeat(o, count); 1972 1973 if (PySequence_Check(o)) { 1974 PyObject *n, *result; 1975 n = PyInt_FromSsize_t(count); 1976 if (n == NULL) 1977 return NULL; 1978 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply), 1979 NB_SLOT(nb_multiply)); 1980 Py_DECREF(n); 1981 if (result != Py_NotImplemented) 1982 return result; 1983 Py_DECREF(result); 1984 } 1985 return type_error("'%.200s' object can't be repeated", o); 1986 } 1987 1988 PyObject * 1989 PySequence_GetItem(PyObject *s, Py_ssize_t i) 1990 { 1991 PySequenceMethods *m; 1992 1993 if (s == NULL) 1994 return null_error(); 1995 1996 m = s->ob_type->tp_as_sequence; 1997 if (m && m->sq_item) { 1998 if (i < 0) { 1999 if (m->sq_length) { 2000 Py_ssize_t l = (*m->sq_length)(s); 2001 if (l < 0) 2002 return NULL; 2003 i += l; 2004 } 2005 } 2006 return m->sq_item(s, i); 2007 } 2008 2009 return type_error("'%.200s' object does not support indexing", s); 2010 } 2011 2012 PyObject * 2013 PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2) 2014 { 2015 PySequenceMethods *m; 2016 PyMappingMethods *mp; 2017 2018 if (!s) return null_error(); 2019 2020 m = s->ob_type->tp_as_sequence; 2021 if (m && m->sq_slice) { 2022 if (i1 < 0 || i2 < 0) { 2023 if (m->sq_length) { 2024 Py_ssize_t l = (*m->sq_length)(s); 2025 if (l < 0) 2026 return NULL; 2027 if (i1 < 0) 2028 i1 += l; 2029 if (i2 < 0) 2030 i2 += l; 2031 } 2032 } 2033 return m->sq_slice(s, i1, i2); 2034 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) { 2035 PyObject *res; 2036 PyObject *slice = _PySlice_FromIndices(i1, i2); 2037 if (!slice) 2038 return NULL; 2039 res = mp->mp_subscript(s, slice); 2040 Py_DECREF(slice); 2041 return res; 2042 } 2043 2044 return type_error("'%.200s' object is unsliceable", s); 2045 } 2046 2047 int 2048 PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o) 2049 { 2050 PySequenceMethods *m; 2051 2052 if (s == NULL) { 2053 null_error(); 2054 return -1; 2055 } 2056 2057 m = s->ob_type->tp_as_sequence; 2058 if (m && m->sq_ass_item) { 2059 if (i < 0) { 2060 if (m->sq_length) { 2061 Py_ssize_t l = (*m->sq_length)(s); 2062 if (l < 0) 2063 return -1; 2064 i += l; 2065 } 2066 } 2067 return m->sq_ass_item(s, i, o); 2068 } 2069 2070 type_error("'%.200s' object does not support item assignment", s); 2071 return -1; 2072 } 2073 2074 int 2075 PySequence_DelItem(PyObject *s, Py_ssize_t i) 2076 { 2077 PySequenceMethods *m; 2078 2079 if (s == NULL) { 2080 null_error(); 2081 return -1; 2082 } 2083 2084 m = s->ob_type->tp_as_sequence; 2085 if (m && m->sq_ass_item) { 2086 if (i < 0) { 2087 if (m->sq_length) { 2088 Py_ssize_t l = (*m->sq_length)(s); 2089 if (l < 0) 2090 return -1; 2091 i += l; 2092 } 2093 } 2094 return m->sq_ass_item(s, i, (PyObject *)NULL); 2095 } 2096 2097 type_error("'%.200s' object doesn't support item deletion", s); 2098 return -1; 2099 } 2100 2101 int 2102 PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o) 2103 { 2104 PySequenceMethods *m; 2105 PyMappingMethods *mp; 2106 2107 if (s == NULL) { 2108 null_error(); 2109 return -1; 2110 } 2111 2112 m = s->ob_type->tp_as_sequence; 2113 if (m && m->sq_ass_slice) { 2114 if (i1 < 0 || i2 < 0) { 2115 if (m->sq_length) { 2116 Py_ssize_t l = (*m->sq_length)(s); 2117 if (l < 0) 2118 return -1; 2119 if (i1 < 0) 2120 i1 += l; 2121 if (i2 < 0) 2122 i2 += l; 2123 } 2124 } 2125 return m->sq_ass_slice(s, i1, i2, o); 2126 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) { 2127 int res; 2128 PyObject *slice = _PySlice_FromIndices(i1, i2); 2129 if (!slice) 2130 return -1; 2131 res = mp->mp_ass_subscript(s, slice, o); 2132 Py_DECREF(slice); 2133 return res; 2134 } 2135 2136 type_error("'%.200s' object doesn't support slice assignment", s); 2137 return -1; 2138 } 2139 2140 int 2141 PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2) 2142 { 2143 PySequenceMethods *m; 2144 2145 if (s == NULL) { 2146 null_error(); 2147 return -1; 2148 } 2149 2150 m = s->ob_type->tp_as_sequence; 2151 if (m && m->sq_ass_slice) { 2152 if (i1 < 0 || i2 < 0) { 2153 if (m->sq_length) { 2154 Py_ssize_t l = (*m->sq_length)(s); 2155 if (l < 0) 2156 return -1; 2157 if (i1 < 0) 2158 i1 += l; 2159 if (i2 < 0) 2160 i2 += l; 2161 } 2162 } 2163 return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL); 2164 } 2165 type_error("'%.200s' object doesn't support slice deletion", s); 2166 return -1; 2167 } 2168 2169 PyObject * 2170 PySequence_Tuple(PyObject *v) 2171 { 2172 PyObject *it; /* iter(v) */ 2173 Py_ssize_t n; /* guess for result tuple size */ 2174 PyObject *result = NULL; 2175 Py_ssize_t j; 2176 2177 if (v == NULL) 2178 return null_error(); 2179 2180 /* Special-case the common tuple and list cases, for efficiency. */ 2181 if (PyTuple_CheckExact(v)) { 2182 /* Note that we can't know whether it's safe to return 2183 a tuple *subclass* instance as-is, hence the restriction 2184 to exact tuples here. In contrast, lists always make 2185 a copy, so there's no need for exactness below. */ 2186 Py_INCREF(v); 2187 return v; 2188 } 2189 if (PyList_CheckExact(v)) 2190 return PyList_AsTuple(v); 2191 2192 /* Get iterator. */ 2193 it = PyObject_GetIter(v); 2194 if (it == NULL) 2195 return NULL; 2196 2197 /* Guess result size and allocate space. */ 2198 n = _PyObject_LengthHint(v, 10); 2199 if (n == -1) 2200 goto Fail; 2201 result = PyTuple_New(n); 2202 if (result == NULL) 2203 goto Fail; 2204 2205 /* Fill the tuple. */ 2206 for (j = 0; ; ++j) { 2207 PyObject *item = PyIter_Next(it); 2208 if (item == NULL) { 2209 if (PyErr_Occurred()) 2210 goto Fail; 2211 break; 2212 } 2213 if (j >= n) { 2214 size_t newn = (size_t)n; 2215 /* The over-allocation strategy can grow a bit faster 2216 than for lists because unlike lists the 2217 over-allocation isn't permanent -- we reclaim 2218 the excess before the end of this routine. 2219 So, grow by ten and then add 25%. 2220 */ 2221 newn += 10u; 2222 newn += newn >> 2; 2223 if (newn > PY_SSIZE_T_MAX) { 2224 /* Check for overflow */ 2225 PyErr_NoMemory(); 2226 Py_DECREF(item); 2227 goto Fail; 2228 } 2229 n = (Py_ssize_t)newn; 2230 if (_PyTuple_Resize(&result, n) != 0) { 2231 Py_DECREF(item); 2232 goto Fail; 2233 } 2234 } 2235 PyTuple_SET_ITEM(result, j, item); 2236 } 2237 2238 /* Cut tuple back if guess was too large. */ 2239 if (j < n && 2240 _PyTuple_Resize(&result, j) != 0) 2241 goto Fail; 2242 2243 Py_DECREF(it); 2244 return result; 2245 2246 Fail: 2247 Py_XDECREF(result); 2248 Py_DECREF(it); 2249 return NULL; 2250 } 2251 2252 PyObject * 2253 PySequence_List(PyObject *v) 2254 { 2255 PyObject *result; /* result list */ 2256 PyObject *rv; /* return value from PyList_Extend */ 2257 2258 if (v == NULL) 2259 return null_error(); 2260 2261 result = PyList_New(0); 2262 if (result == NULL) 2263 return NULL; 2264 2265 rv = _PyList_Extend((PyListObject *)result, v); 2266 if (rv == NULL) { 2267 Py_DECREF(result); 2268 return NULL; 2269 } 2270 Py_DECREF(rv); 2271 return result; 2272 } 2273 2274 PyObject * 2275 PySequence_Fast(PyObject *v, const char *m) 2276 { 2277 PyObject *it; 2278 2279 if (v == NULL) 2280 return null_error(); 2281 2282 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) { 2283 Py_INCREF(v); 2284 return v; 2285 } 2286 2287 it = PyObject_GetIter(v); 2288 if (it == NULL) { 2289 if (PyErr_ExceptionMatches(PyExc_TypeError)) 2290 PyErr_SetString(PyExc_TypeError, m); 2291 return NULL; 2292 } 2293 2294 v = PySequence_List(it); 2295 Py_DECREF(it); 2296 2297 return v; 2298 } 2299 2300 /* Iterate over seq. Result depends on the operation: 2301 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq. 2302 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq; 2303 set ValueError and return -1 if none found; also return -1 on error. 2304 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error. 2305 */ 2306 Py_ssize_t 2307 _PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation) 2308 { 2309 Py_ssize_t n; 2310 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */ 2311 PyObject *it; /* iter(seq) */ 2312 2313 if (seq == NULL || obj == NULL) { 2314 null_error(); 2315 return -1; 2316 } 2317 2318 it = PyObject_GetIter(seq); 2319 if (it == NULL) { 2320 type_error("argument of type '%.200s' is not iterable", seq); 2321 return -1; 2322 } 2323 2324 n = wrapped = 0; 2325 for (;;) { 2326 int cmp; 2327 PyObject *item = PyIter_Next(it); 2328 if (item == NULL) { 2329 if (PyErr_Occurred()) 2330 goto Fail; 2331 break; 2332 } 2333 2334 cmp = PyObject_RichCompareBool(obj, item, Py_EQ); 2335 Py_DECREF(item); 2336 if (cmp < 0) 2337 goto Fail; 2338 if (cmp > 0) { 2339 switch (operation) { 2340 case PY_ITERSEARCH_COUNT: 2341 if (n == PY_SSIZE_T_MAX) { 2342 PyErr_SetString(PyExc_OverflowError, 2343 "count exceeds C integer size"); 2344 goto Fail; 2345 } 2346 ++n; 2347 break; 2348 2349 case PY_ITERSEARCH_INDEX: 2350 if (wrapped) { 2351 PyErr_SetString(PyExc_OverflowError, 2352 "index exceeds C integer size"); 2353 goto Fail; 2354 } 2355 goto Done; 2356 2357 case PY_ITERSEARCH_CONTAINS: 2358 n = 1; 2359 goto Done; 2360 2361 default: 2362 assert(!"unknown operation"); 2363 } 2364 } 2365 2366 if (operation == PY_ITERSEARCH_INDEX) { 2367 if (n == PY_SSIZE_T_MAX) 2368 wrapped = 1; 2369 ++n; 2370 } 2371 } 2372 2373 if (operation != PY_ITERSEARCH_INDEX) 2374 goto Done; 2375 2376 PyErr_SetString(PyExc_ValueError, 2377 "sequence.index(x): x not in sequence"); 2378 /* fall into failure code */ 2379 Fail: 2380 n = -1; 2381 /* fall through */ 2382 Done: 2383 Py_DECREF(it); 2384 return n; 2385 2386 } 2387 2388 /* Return # of times o appears in s. */ 2389 Py_ssize_t 2390 PySequence_Count(PyObject *s, PyObject *o) 2391 { 2392 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT); 2393 } 2394 2395 /* Return -1 if error; 1 if ob in seq; 0 if ob not in seq. 2396 * Use sq_contains if possible, else defer to _PySequence_IterSearch(). 2397 */ 2398 int 2399 PySequence_Contains(PyObject *seq, PyObject *ob) 2400 { 2401 Py_ssize_t result; 2402 if (PyType_HasFeature(seq->ob_type, Py_TPFLAGS_HAVE_SEQUENCE_IN)) { 2403 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence; 2404 if (sqm != NULL && sqm->sq_contains != NULL) 2405 return (*sqm->sq_contains)(seq, ob); 2406 } 2407 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS); 2408 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int); 2409 } 2410 2411 /* Backwards compatibility */ 2412 #undef PySequence_In 2413 int 2414 PySequence_In(PyObject *w, PyObject *v) 2415 { 2416 return PySequence_Contains(w, v); 2417 } 2418 2419 Py_ssize_t 2420 PySequence_Index(PyObject *s, PyObject *o) 2421 { 2422 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX); 2423 } 2424 2425 /* Operations on mappings */ 2426 2427 int 2428 PyMapping_Check(PyObject *o) 2429 { 2430 if (o && PyInstance_Check(o)) 2431 return PyObject_HasAttrString(o, "__getitem__"); 2432 2433 return o && o->ob_type->tp_as_mapping && 2434 o->ob_type->tp_as_mapping->mp_subscript && 2435 !(o->ob_type->tp_as_sequence && 2436 o->ob_type->tp_as_sequence->sq_slice); 2437 } 2438 2439 Py_ssize_t 2440 PyMapping_Size(PyObject *o) 2441 { 2442 PyMappingMethods *m; 2443 2444 if (o == NULL) { 2445 null_error(); 2446 return -1; 2447 } 2448 2449 m = o->ob_type->tp_as_mapping; 2450 if (m && m->mp_length) 2451 return m->mp_length(o); 2452 2453 type_error("object of type '%.200s' has no len()", o); 2454 return -1; 2455 } 2456 2457 #undef PyMapping_Length 2458 Py_ssize_t 2459 PyMapping_Length(PyObject *o) 2460 { 2461 return PyMapping_Size(o); 2462 } 2463 #define PyMapping_Length PyMapping_Size 2464 2465 PyObject * 2466 PyMapping_GetItemString(PyObject *o, char *key) 2467 { 2468 PyObject *okey, *r; 2469 2470 if (key == NULL) 2471 return null_error(); 2472 2473 okey = PyString_FromString(key); 2474 if (okey == NULL) 2475 return NULL; 2476 r = PyObject_GetItem(o, okey); 2477 Py_DECREF(okey); 2478 return r; 2479 } 2480 2481 int 2482 PyMapping_SetItemString(PyObject *o, char *key, PyObject *value) 2483 { 2484 PyObject *okey; 2485 int r; 2486 2487 if (key == NULL) { 2488 null_error(); 2489 return -1; 2490 } 2491 2492 okey = PyString_FromString(key); 2493 if (okey == NULL) 2494 return -1; 2495 r = PyObject_SetItem(o, okey, value); 2496 Py_DECREF(okey); 2497 return r; 2498 } 2499 2500 int 2501 PyMapping_HasKeyString(PyObject *o, char *key) 2502 { 2503 PyObject *v; 2504 2505 v = PyMapping_GetItemString(o, key); 2506 if (v) { 2507 Py_DECREF(v); 2508 return 1; 2509 } 2510 PyErr_Clear(); 2511 return 0; 2512 } 2513 2514 int 2515 PyMapping_HasKey(PyObject *o, PyObject *key) 2516 { 2517 PyObject *v; 2518 2519 v = PyObject_GetItem(o, key); 2520 if (v) { 2521 Py_DECREF(v); 2522 return 1; 2523 } 2524 PyErr_Clear(); 2525 return 0; 2526 } 2527 2528 /* Operations on callable objects */ 2529 2530 /* XXX PyCallable_Check() is in object.c */ 2531 2532 PyObject * 2533 PyObject_CallObject(PyObject *o, PyObject *a) 2534 { 2535 return PyEval_CallObjectWithKeywords(o, a, NULL); 2536 } 2537 2538 PyObject * 2539 PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) 2540 { 2541 ternaryfunc call; 2542 2543 if ((call = func->ob_type->tp_call) != NULL) { 2544 PyObject *result; 2545 if (Py_EnterRecursiveCall(" while calling a Python object")) 2546 return NULL; 2547 result = (*call)(func, arg, kw); 2548 Py_LeaveRecursiveCall(); 2549 if (result == NULL && !PyErr_Occurred()) 2550 PyErr_SetString( 2551 PyExc_SystemError, 2552 "NULL result without error in PyObject_Call"); 2553 return result; 2554 } 2555 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable", 2556 func->ob_type->tp_name); 2557 return NULL; 2558 } 2559 2560 static PyObject* 2561 call_function_tail(PyObject *callable, PyObject *args) 2562 { 2563 PyObject *retval; 2564 2565 if (args == NULL) 2566 return NULL; 2567 2568 if (!PyTuple_Check(args)) { 2569 PyObject *a; 2570 2571 a = PyTuple_New(1); 2572 if (a == NULL) { 2573 Py_DECREF(args); 2574 return NULL; 2575 } 2576 PyTuple_SET_ITEM(a, 0, args); 2577 args = a; 2578 } 2579 retval = PyObject_Call(callable, args, NULL); 2580 2581 Py_DECREF(args); 2582 2583 return retval; 2584 } 2585 2586 PyObject * 2587 PyObject_CallFunction(PyObject *callable, char *format, ...) 2588 { 2589 va_list va; 2590 PyObject *args; 2591 2592 if (callable == NULL) 2593 return null_error(); 2594 2595 if (format && *format) { 2596 va_start(va, format); 2597 args = Py_VaBuildValue(format, va); 2598 va_end(va); 2599 } 2600 else 2601 args = PyTuple_New(0); 2602 2603 return call_function_tail(callable, args); 2604 } 2605 2606 PyObject * 2607 _PyObject_CallFunction_SizeT(PyObject *callable, char *format, ...) 2608 { 2609 va_list va; 2610 PyObject *args; 2611 2612 if (callable == NULL) 2613 return null_error(); 2614 2615 if (format && *format) { 2616 va_start(va, format); 2617 args = _Py_VaBuildValue_SizeT(format, va); 2618 va_end(va); 2619 } 2620 else 2621 args = PyTuple_New(0); 2622 2623 return call_function_tail(callable, args); 2624 } 2625 2626 PyObject * 2627 PyObject_CallMethod(PyObject *o, char *name, char *format, ...) 2628 { 2629 va_list va; 2630 PyObject *args; 2631 PyObject *func = NULL; 2632 PyObject *retval = NULL; 2633 2634 if (o == NULL || name == NULL) 2635 return null_error(); 2636 2637 func = PyObject_GetAttrString(o, name); 2638 if (func == NULL) 2639 return NULL; 2640 2641 if (!PyCallable_Check(func)) { 2642 type_error("attribute of type '%.200s' is not callable", func); 2643 goto exit; 2644 } 2645 2646 if (format && *format) { 2647 va_start(va, format); 2648 args = Py_VaBuildValue(format, va); 2649 va_end(va); 2650 } 2651 else 2652 args = PyTuple_New(0); 2653 2654 retval = call_function_tail(func, args); 2655 2656 exit: 2657 /* args gets consumed in call_function_tail */ 2658 Py_XDECREF(func); 2659 2660 return retval; 2661 } 2662 2663 PyObject * 2664 _PyObject_CallMethod_SizeT(PyObject *o, char *name, char *format, ...) 2665 { 2666 va_list va; 2667 PyObject *args; 2668 PyObject *func = NULL; 2669 PyObject *retval = NULL; 2670 2671 if (o == NULL || name == NULL) 2672 return null_error(); 2673 2674 func = PyObject_GetAttrString(o, name); 2675 if (func == NULL) 2676 return NULL; 2677 2678 if (!PyCallable_Check(func)) { 2679 type_error("attribute of type '%.200s' is not callable", func); 2680 goto exit; 2681 } 2682 2683 if (format && *format) { 2684 va_start(va, format); 2685 args = _Py_VaBuildValue_SizeT(format, va); 2686 va_end(va); 2687 } 2688 else 2689 args = PyTuple_New(0); 2690 2691 retval = call_function_tail(func, args); 2692 2693 exit: 2694 /* args gets consumed in call_function_tail */ 2695 Py_XDECREF(func); 2696 2697 return retval; 2698 } 2699 2700 2701 static PyObject * 2702 objargs_mktuple(va_list va) 2703 { 2704 int i, n = 0; 2705 va_list countva; 2706 PyObject *result, *tmp; 2707 2708 #ifdef VA_LIST_IS_ARRAY 2709 memcpy(countva, va, sizeof(va_list)); 2710 #else 2711 #ifdef __va_copy 2712 __va_copy(countva, va); 2713 #else 2714 countva = va; 2715 #endif 2716 #endif 2717 2718 while (((PyObject *)va_arg(countva, PyObject *)) != NULL) 2719 ++n; 2720 result = PyTuple_New(n); 2721 if (result != NULL && n > 0) { 2722 for (i = 0; i < n; ++i) { 2723 tmp = (PyObject *)va_arg(va, PyObject *); 2724 PyTuple_SET_ITEM(result, i, tmp); 2725 Py_INCREF(tmp); 2726 } 2727 } 2728 return result; 2729 } 2730 2731 PyObject * 2732 PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...) 2733 { 2734 PyObject *args, *tmp; 2735 va_list vargs; 2736 2737 if (callable == NULL || name == NULL) 2738 return null_error(); 2739 2740 callable = PyObject_GetAttr(callable, name); 2741 if (callable == NULL) 2742 return NULL; 2743 2744 /* count the args */ 2745 va_start(vargs, name); 2746 args = objargs_mktuple(vargs); 2747 va_end(vargs); 2748 if (args == NULL) { 2749 Py_DECREF(callable); 2750 return NULL; 2751 } 2752 tmp = PyObject_Call(callable, args, NULL); 2753 Py_DECREF(args); 2754 Py_DECREF(callable); 2755 2756 return tmp; 2757 } 2758 2759 PyObject * 2760 PyObject_CallFunctionObjArgs(PyObject *callable, ...) 2761 { 2762 PyObject *args, *tmp; 2763 va_list vargs; 2764 2765 if (callable == NULL) 2766 return null_error(); 2767 2768 /* count the args */ 2769 va_start(vargs, callable); 2770 args = objargs_mktuple(vargs); 2771 va_end(vargs); 2772 if (args == NULL) 2773 return NULL; 2774 tmp = PyObject_Call(callable, args, NULL); 2775 Py_DECREF(args); 2776 2777 return tmp; 2778 } 2779 2780 2781 /* isinstance(), issubclass() */ 2782 2783 /* abstract_get_bases() has logically 4 return states, with a sort of 0th 2784 * state that will almost never happen. 2785 * 2786 * 0. creating the __bases__ static string could get a MemoryError 2787 * 1. getattr(cls, '__bases__') could raise an AttributeError 2788 * 2. getattr(cls, '__bases__') could raise some other exception 2789 * 3. getattr(cls, '__bases__') could return a tuple 2790 * 4. getattr(cls, '__bases__') could return something other than a tuple 2791 * 2792 * Only state #3 is a non-error state and only it returns a non-NULL object 2793 * (it returns the retrieved tuple). 2794 * 2795 * Any raised AttributeErrors are masked by clearing the exception and 2796 * returning NULL. If an object other than a tuple comes out of __bases__, 2797 * then again, the return value is NULL. So yes, these two situations 2798 * produce exactly the same results: NULL is returned and no error is set. 2799 * 2800 * If some exception other than AttributeError is raised, then NULL is also 2801 * returned, but the exception is not cleared. That's because we want the 2802 * exception to be propagated along. 2803 * 2804 * Callers are expected to test for PyErr_Occurred() when the return value 2805 * is NULL to decide whether a valid exception should be propagated or not. 2806 * When there's no exception to propagate, it's customary for the caller to 2807 * set a TypeError. 2808 */ 2809 static PyObject * 2810 abstract_get_bases(PyObject *cls) 2811 { 2812 static PyObject *__bases__ = NULL; 2813 PyObject *bases; 2814 2815 if (__bases__ == NULL) { 2816 __bases__ = PyString_InternFromString("__bases__"); 2817 if (__bases__ == NULL) 2818 return NULL; 2819 } 2820 bases = PyObject_GetAttr(cls, __bases__); 2821 if (bases == NULL) { 2822 if (PyErr_ExceptionMatches(PyExc_AttributeError)) 2823 PyErr_Clear(); 2824 return NULL; 2825 } 2826 if (!PyTuple_Check(bases)) { 2827 Py_DECREF(bases); 2828 return NULL; 2829 } 2830 return bases; 2831 } 2832 2833 2834 static int 2835 abstract_issubclass(PyObject *derived, PyObject *cls) 2836 { 2837 PyObject *bases = NULL; 2838 Py_ssize_t i, n; 2839 int r = 0; 2840 2841 while (1) { 2842 if (derived == cls) 2843 return 1; 2844 bases = abstract_get_bases(derived); 2845 if (bases == NULL) { 2846 if (PyErr_Occurred()) 2847 return -1; 2848 return 0; 2849 } 2850 n = PyTuple_GET_SIZE(bases); 2851 if (n == 0) { 2852 Py_DECREF(bases); 2853 return 0; 2854 } 2855 /* Avoid recursivity in the single inheritance case */ 2856 if (n == 1) { 2857 derived = PyTuple_GET_ITEM(bases, 0); 2858 Py_DECREF(bases); 2859 continue; 2860 } 2861 for (i = 0; i < n; i++) { 2862 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls); 2863 if (r != 0) 2864 break; 2865 } 2866 Py_DECREF(bases); 2867 return r; 2868 } 2869 } 2870 2871 static int 2872 check_class(PyObject *cls, const char *error) 2873 { 2874 PyObject *bases = abstract_get_bases(cls); 2875 if (bases == NULL) { 2876 /* Do not mask errors. */ 2877 if (!PyErr_Occurred()) 2878 PyErr_SetString(PyExc_TypeError, error); 2879 return 0; 2880 } 2881 Py_DECREF(bases); 2882 return -1; 2883 } 2884 2885 static int 2886 recursive_isinstance(PyObject *inst, PyObject *cls) 2887 { 2888 PyObject *icls; 2889 static PyObject *__class__ = NULL; 2890 int retval = 0; 2891 2892 if (__class__ == NULL) { 2893 __class__ = PyString_InternFromString("__class__"); 2894 if (__class__ == NULL) 2895 return -1; 2896 } 2897 2898 if (PyClass_Check(cls) && PyInstance_Check(inst)) { 2899 PyObject *inclass = 2900 (PyObject*)((PyInstanceObject*)inst)->in_class; 2901 retval = PyClass_IsSubclass(inclass, cls); 2902 } 2903 else if (PyType_Check(cls)) { 2904 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls); 2905 if (retval == 0) { 2906 PyObject *c = PyObject_GetAttr(inst, __class__); 2907 if (c == NULL) { 2908 PyErr_Clear(); 2909 } 2910 else { 2911 if (c != (PyObject *)(inst->ob_type) && 2912 PyType_Check(c)) 2913 retval = PyType_IsSubtype( 2914 (PyTypeObject *)c, 2915 (PyTypeObject *)cls); 2916 Py_DECREF(c); 2917 } 2918 } 2919 } 2920 else { 2921 if (!check_class(cls, 2922 "isinstance() arg 2 must be a class, type," 2923 " or tuple of classes and types")) 2924 return -1; 2925 icls = PyObject_GetAttr(inst, __class__); 2926 if (icls == NULL) { 2927 PyErr_Clear(); 2928 retval = 0; 2929 } 2930 else { 2931 retval = abstract_issubclass(icls, cls); 2932 Py_DECREF(icls); 2933 } 2934 } 2935 2936 return retval; 2937 } 2938 2939 int 2940 PyObject_IsInstance(PyObject *inst, PyObject *cls) 2941 { 2942 static PyObject *name = NULL; 2943 2944 /* Quick test for an exact match */ 2945 if (Py_TYPE(inst) == (PyTypeObject *)cls) 2946 return 1; 2947 2948 if (PyTuple_Check(cls)) { 2949 Py_ssize_t i; 2950 Py_ssize_t n; 2951 int r = 0; 2952 2953 if (Py_EnterRecursiveCall(" in __instancecheck__")) 2954 return -1; 2955 n = PyTuple_GET_SIZE(cls); 2956 for (i = 0; i < n; ++i) { 2957 PyObject *item = PyTuple_GET_ITEM(cls, i); 2958 r = PyObject_IsInstance(inst, item); 2959 if (r != 0) 2960 /* either found it, or got an error */ 2961 break; 2962 } 2963 Py_LeaveRecursiveCall(); 2964 return r; 2965 } 2966 2967 if (!(PyClass_Check(cls) || PyInstance_Check(cls))) { 2968 PyObject *checker; 2969 checker = _PyObject_LookupSpecial(cls, "__instancecheck__", &name); 2970 if (checker != NULL) { 2971 PyObject *res; 2972 int ok = -1; 2973 if (Py_EnterRecursiveCall(" in __instancecheck__")) { 2974 Py_DECREF(checker); 2975 return ok; 2976 } 2977 res = PyObject_CallFunctionObjArgs(checker, inst, NULL); 2978 Py_LeaveRecursiveCall(); 2979 Py_DECREF(checker); 2980 if (res != NULL) { 2981 ok = PyObject_IsTrue(res); 2982 Py_DECREF(res); 2983 } 2984 return ok; 2985 } 2986 else if (PyErr_Occurred()) 2987 return -1; 2988 } 2989 return recursive_isinstance(inst, cls); 2990 } 2991 2992 static int 2993 recursive_issubclass(PyObject *derived, PyObject *cls) 2994 { 2995 int retval; 2996 2997 if (PyType_Check(cls) && PyType_Check(derived)) { 2998 /* Fast path (non-recursive) */ 2999 return PyType_IsSubtype( 3000 (PyTypeObject *)derived, (PyTypeObject *)cls); 3001 } 3002 if (!PyClass_Check(derived) || !PyClass_Check(cls)) { 3003 if (!check_class(derived, 3004 "issubclass() arg 1 must be a class")) 3005 return -1; 3006 3007 if (!check_class(cls, 3008 "issubclass() arg 2 must be a class" 3009 " or tuple of classes")) 3010 return -1; 3011 retval = abstract_issubclass(derived, cls); 3012 } 3013 else { 3014 /* shortcut */ 3015 if (!(retval = (derived == cls))) 3016 retval = PyClass_IsSubclass(derived, cls); 3017 } 3018 3019 return retval; 3020 } 3021 3022 int 3023 PyObject_IsSubclass(PyObject *derived, PyObject *cls) 3024 { 3025 static PyObject *name = NULL; 3026 3027 if (PyTuple_Check(cls)) { 3028 Py_ssize_t i; 3029 Py_ssize_t n; 3030 int r = 0; 3031 3032 if (Py_EnterRecursiveCall(" in __subclasscheck__")) 3033 return -1; 3034 n = PyTuple_GET_SIZE(cls); 3035 for (i = 0; i < n; ++i) { 3036 PyObject *item = PyTuple_GET_ITEM(cls, i); 3037 r = PyObject_IsSubclass(derived, item); 3038 if (r != 0) 3039 /* either found it, or got an error */ 3040 break; 3041 } 3042 Py_LeaveRecursiveCall(); 3043 return r; 3044 } 3045 if (!(PyClass_Check(cls) || PyInstance_Check(cls))) { 3046 PyObject *checker; 3047 checker = _PyObject_LookupSpecial(cls, "__subclasscheck__", &name); 3048 if (checker != NULL) { 3049 PyObject *res; 3050 int ok = -1; 3051 if (Py_EnterRecursiveCall(" in __subclasscheck__")) { 3052 Py_DECREF(checker); 3053 return ok; 3054 } 3055 res = PyObject_CallFunctionObjArgs(checker, derived, NULL); 3056 Py_LeaveRecursiveCall(); 3057 Py_DECREF(checker); 3058 if (res != NULL) { 3059 ok = PyObject_IsTrue(res); 3060 Py_DECREF(res); 3061 } 3062 return ok; 3063 } 3064 else if (PyErr_Occurred()) { 3065 return -1; 3066 } 3067 } 3068 return recursive_issubclass(derived, cls); 3069 } 3070 3071 int 3072 _PyObject_RealIsInstance(PyObject *inst, PyObject *cls) 3073 { 3074 return recursive_isinstance(inst, cls); 3075 } 3076 3077 int 3078 _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls) 3079 { 3080 return recursive_issubclass(derived, cls); 3081 } 3082 3083 3084 PyObject * 3085 PyObject_GetIter(PyObject *o) 3086 { 3087 PyTypeObject *t = o->ob_type; 3088 getiterfunc f = NULL; 3089 if (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER)) 3090 f = t->tp_iter; 3091 if (f == NULL) { 3092 if (PySequence_Check(o)) 3093 return PySeqIter_New(o); 3094 return type_error("'%.200s' object is not iterable", o); 3095 } 3096 else { 3097 PyObject *res = (*f)(o); 3098 if (res != NULL && !PyIter_Check(res)) { 3099 PyErr_Format(PyExc_TypeError, 3100 "iter() returned non-iterator " 3101 "of type '%.100s'", 3102 res->ob_type->tp_name); 3103 Py_DECREF(res); 3104 res = NULL; 3105 } 3106 return res; 3107 } 3108 } 3109 3110 /* Return next item. 3111 * If an error occurs, return NULL. PyErr_Occurred() will be true. 3112 * If the iteration terminates normally, return NULL and clear the 3113 * PyExc_StopIteration exception (if it was set). PyErr_Occurred() 3114 * will be false. 3115 * Else return the next object. PyErr_Occurred() will be false. 3116 */ 3117 PyObject * 3118 PyIter_Next(PyObject *iter) 3119 { 3120 PyObject *result; 3121 result = (*iter->ob_type->tp_iternext)(iter); 3122 if (result == NULL && 3123 PyErr_Occurred() && 3124 PyErr_ExceptionMatches(PyExc_StopIteration)) 3125 PyErr_Clear(); 3126 return result; 3127 } 3128
