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