1 2 /* Generic object operations; and implementation of None (NoObject) */ 3 4 #include "Python.h" 5 #include "frameobject.h" 6 7 #ifdef __cplusplus 8 extern "C" { 9 #endif 10 11 #ifdef Py_REF_DEBUG 12 Py_ssize_t _Py_RefTotal; 13 14 Py_ssize_t 15 _Py_GetRefTotal(void) 16 { 17 PyObject *o; 18 Py_ssize_t total = _Py_RefTotal; 19 /* ignore the references to the dummy object of the dicts and sets 20 because they are not reliable and not useful (now that the 21 hash table code is well-tested) */ 22 o = _PyDict_Dummy(); 23 if (o != NULL) 24 total -= o->ob_refcnt; 25 o = _PySet_Dummy(); 26 if (o != NULL) 27 total -= o->ob_refcnt; 28 return total; 29 } 30 #endif /* Py_REF_DEBUG */ 31 32 int Py_DivisionWarningFlag; 33 int Py_Py3kWarningFlag; 34 35 /* Object allocation routines used by NEWOBJ and NEWVAROBJ macros. 36 These are used by the individual routines for object creation. 37 Do not call them otherwise, they do not initialize the object! */ 38 39 #ifdef Py_TRACE_REFS 40 /* Head of circular doubly-linked list of all objects. These are linked 41 * together via the _ob_prev and _ob_next members of a PyObject, which 42 * exist only in a Py_TRACE_REFS build. 43 */ 44 static PyObject refchain = {&refchain, &refchain}; 45 46 /* Insert op at the front of the list of all objects. If force is true, 47 * op is added even if _ob_prev and _ob_next are non-NULL already. If 48 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing. 49 * force should be true if and only if op points to freshly allocated, 50 * uninitialized memory, or you've unlinked op from the list and are 51 * relinking it into the front. 52 * Note that objects are normally added to the list via _Py_NewReference, 53 * which is called by PyObject_Init. Not all objects are initialized that 54 * way, though; exceptions include statically allocated type objects, and 55 * statically allocated singletons (like Py_True and Py_None). 56 */ 57 void 58 _Py_AddToAllObjects(PyObject *op, int force) 59 { 60 #ifdef Py_DEBUG 61 if (!force) { 62 /* If it's initialized memory, op must be in or out of 63 * the list unambiguously. 64 */ 65 assert((op->_ob_prev == NULL) == (op->_ob_next == NULL)); 66 } 67 #endif 68 if (force || op->_ob_prev == NULL) { 69 op->_ob_next = refchain._ob_next; 70 op->_ob_prev = &refchain; 71 refchain._ob_next->_ob_prev = op; 72 refchain._ob_next = op; 73 } 74 } 75 #endif /* Py_TRACE_REFS */ 76 77 #ifdef COUNT_ALLOCS 78 static PyTypeObject *type_list; 79 /* All types are added to type_list, at least when 80 they get one object created. That makes them 81 immortal, which unfortunately contributes to 82 garbage itself. If unlist_types_without_objects 83 is set, they will be removed from the type_list 84 once the last object is deallocated. */ 85 static int unlist_types_without_objects; 86 extern Py_ssize_t tuple_zero_allocs, fast_tuple_allocs; 87 extern Py_ssize_t quick_int_allocs, quick_neg_int_allocs; 88 extern Py_ssize_t null_strings, one_strings; 89 void 90 dump_counts(FILE* f) 91 { 92 PyTypeObject *tp; 93 94 for (tp = type_list; tp; tp = tp->tp_next) 95 fprintf(f, "%s alloc'd: %" PY_FORMAT_SIZE_T "d, " 96 "freed: %" PY_FORMAT_SIZE_T "d, " 97 "max in use: %" PY_FORMAT_SIZE_T "d\n", 98 tp->tp_name, tp->tp_allocs, tp->tp_frees, 99 tp->tp_maxalloc); 100 fprintf(f, "fast tuple allocs: %" PY_FORMAT_SIZE_T "d, " 101 "empty: %" PY_FORMAT_SIZE_T "d\n", 102 fast_tuple_allocs, tuple_zero_allocs); 103 fprintf(f, "fast int allocs: pos: %" PY_FORMAT_SIZE_T "d, " 104 "neg: %" PY_FORMAT_SIZE_T "d\n", 105 quick_int_allocs, quick_neg_int_allocs); 106 fprintf(f, "null strings: %" PY_FORMAT_SIZE_T "d, " 107 "1-strings: %" PY_FORMAT_SIZE_T "d\n", 108 null_strings, one_strings); 109 } 110 111 PyObject * 112 get_counts(void) 113 { 114 PyTypeObject *tp; 115 PyObject *result; 116 PyObject *v; 117 118 result = PyList_New(0); 119 if (result == NULL) 120 return NULL; 121 for (tp = type_list; tp; tp = tp->tp_next) { 122 v = Py_BuildValue("(snnn)", tp->tp_name, tp->tp_allocs, 123 tp->tp_frees, tp->tp_maxalloc); 124 if (v == NULL) { 125 Py_DECREF(result); 126 return NULL; 127 } 128 if (PyList_Append(result, v) < 0) { 129 Py_DECREF(v); 130 Py_DECREF(result); 131 return NULL; 132 } 133 Py_DECREF(v); 134 } 135 return result; 136 } 137 138 void 139 inc_count(PyTypeObject *tp) 140 { 141 if (tp->tp_next == NULL && tp->tp_prev == NULL) { 142 /* first time; insert in linked list */ 143 if (tp->tp_next != NULL) /* sanity check */ 144 Py_FatalError("XXX inc_count sanity check"); 145 if (type_list) 146 type_list->tp_prev = tp; 147 tp->tp_next = type_list; 148 /* Note that as of Python 2.2, heap-allocated type objects 149 * can go away, but this code requires that they stay alive 150 * until program exit. That's why we're careful with 151 * refcounts here. type_list gets a new reference to tp, 152 * while ownership of the reference type_list used to hold 153 * (if any) was transferred to tp->tp_next in the line above. 154 * tp is thus effectively immortal after this. 155 */ 156 Py_INCREF(tp); 157 type_list = tp; 158 #ifdef Py_TRACE_REFS 159 /* Also insert in the doubly-linked list of all objects, 160 * if not already there. 161 */ 162 _Py_AddToAllObjects((PyObject *)tp, 0); 163 #endif 164 } 165 tp->tp_allocs++; 166 if (tp->tp_allocs - tp->tp_frees > tp->tp_maxalloc) 167 tp->tp_maxalloc = tp->tp_allocs - tp->tp_frees; 168 } 169 170 void dec_count(PyTypeObject *tp) 171 { 172 tp->tp_frees++; 173 if (unlist_types_without_objects && 174 tp->tp_allocs == tp->tp_frees) { 175 /* unlink the type from type_list */ 176 if (tp->tp_prev) 177 tp->tp_prev->tp_next = tp->tp_next; 178 else 179 type_list = tp->tp_next; 180 if (tp->tp_next) 181 tp->tp_next->tp_prev = tp->tp_prev; 182 tp->tp_next = tp->tp_prev = NULL; 183 Py_DECREF(tp); 184 } 185 } 186 187 #endif 188 189 #ifdef Py_REF_DEBUG 190 /* Log a fatal error; doesn't return. */ 191 void 192 _Py_NegativeRefcount(const char *fname, int lineno, PyObject *op) 193 { 194 char buf[300]; 195 196 PyOS_snprintf(buf, sizeof(buf), 197 "%s:%i object at %p has negative ref count " 198 "%" PY_FORMAT_SIZE_T "d", 199 fname, lineno, op, op->ob_refcnt); 200 Py_FatalError(buf); 201 } 202 203 #endif /* Py_REF_DEBUG */ 204 205 void 206 Py_IncRef(PyObject *o) 207 { 208 Py_XINCREF(o); 209 } 210 211 void 212 Py_DecRef(PyObject *o) 213 { 214 Py_XDECREF(o); 215 } 216 217 PyObject * 218 PyObject_Init(PyObject *op, PyTypeObject *tp) 219 { 220 if (op == NULL) 221 return PyErr_NoMemory(); 222 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */ 223 Py_TYPE(op) = tp; 224 _Py_NewReference(op); 225 return op; 226 } 227 228 PyVarObject * 229 PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size) 230 { 231 if (op == NULL) 232 return (PyVarObject *) PyErr_NoMemory(); 233 /* Any changes should be reflected in PyObject_INIT_VAR */ 234 op->ob_size = size; 235 Py_TYPE(op) = tp; 236 _Py_NewReference((PyObject *)op); 237 return op; 238 } 239 240 PyObject * 241 _PyObject_New(PyTypeObject *tp) 242 { 243 PyObject *op; 244 op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp)); 245 if (op == NULL) 246 return PyErr_NoMemory(); 247 return PyObject_INIT(op, tp); 248 } 249 250 PyVarObject * 251 _PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems) 252 { 253 PyVarObject *op; 254 const size_t size = _PyObject_VAR_SIZE(tp, nitems); 255 op = (PyVarObject *) PyObject_MALLOC(size); 256 if (op == NULL) 257 return (PyVarObject *)PyErr_NoMemory(); 258 return PyObject_INIT_VAR(op, tp, nitems); 259 } 260 261 /* for binary compatibility with 2.2 */ 262 #undef _PyObject_Del 263 void 264 _PyObject_Del(PyObject *op) 265 { 266 PyObject_FREE(op); 267 } 268 269 /* Implementation of PyObject_Print with recursion checking */ 270 static int 271 internal_print(PyObject *op, FILE *fp, int flags, int nesting) 272 { 273 int ret = 0; 274 if (nesting > 10) { 275 PyErr_SetString(PyExc_RuntimeError, "print recursion"); 276 return -1; 277 } 278 if (PyErr_CheckSignals()) 279 return -1; 280 #ifdef USE_STACKCHECK 281 if (PyOS_CheckStack()) { 282 PyErr_SetString(PyExc_MemoryError, "stack overflow"); 283 return -1; 284 } 285 #endif 286 clearerr(fp); /* Clear any previous error condition */ 287 if (op == NULL) { 288 Py_BEGIN_ALLOW_THREADS 289 fprintf(fp, "<nil>"); 290 Py_END_ALLOW_THREADS 291 } 292 else { 293 if (op->ob_refcnt <= 0) 294 /* XXX(twouters) cast refcount to long until %zd is 295 universally available */ 296 Py_BEGIN_ALLOW_THREADS 297 fprintf(fp, "<refcnt %ld at %p>", 298 (long)op->ob_refcnt, op); 299 Py_END_ALLOW_THREADS 300 else if (Py_TYPE(op)->tp_print == NULL) { 301 PyObject *s; 302 if (flags & Py_PRINT_RAW) 303 s = PyObject_Str(op); 304 else 305 s = PyObject_Repr(op); 306 if (s == NULL) 307 ret = -1; 308 else { 309 ret = internal_print(s, fp, Py_PRINT_RAW, 310 nesting+1); 311 } 312 Py_XDECREF(s); 313 } 314 else 315 ret = (*Py_TYPE(op)->tp_print)(op, fp, flags); 316 } 317 if (ret == 0) { 318 if (ferror(fp)) { 319 PyErr_SetFromErrno(PyExc_IOError); 320 clearerr(fp); 321 ret = -1; 322 } 323 } 324 return ret; 325 } 326 327 int 328 PyObject_Print(PyObject *op, FILE *fp, int flags) 329 { 330 return internal_print(op, fp, flags, 0); 331 } 332 333 334 /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */ 335 void _PyObject_Dump(PyObject* op) 336 { 337 if (op == NULL) 338 fprintf(stderr, "NULL\n"); 339 else { 340 #ifdef WITH_THREAD 341 PyGILState_STATE gil; 342 #endif 343 fprintf(stderr, "object : "); 344 #ifdef WITH_THREAD 345 gil = PyGILState_Ensure(); 346 #endif 347 (void)PyObject_Print(op, stderr, 0); 348 #ifdef WITH_THREAD 349 PyGILState_Release(gil); 350 #endif 351 /* XXX(twouters) cast refcount to long until %zd is 352 universally available */ 353 fprintf(stderr, "\n" 354 "type : %s\n" 355 "refcount: %ld\n" 356 "address : %p\n", 357 Py_TYPE(op)==NULL ? "NULL" : Py_TYPE(op)->tp_name, 358 (long)op->ob_refcnt, 359 op); 360 } 361 } 362 363 PyObject * 364 PyObject_Repr(PyObject *v) 365 { 366 if (PyErr_CheckSignals()) 367 return NULL; 368 #ifdef USE_STACKCHECK 369 if (PyOS_CheckStack()) { 370 PyErr_SetString(PyExc_MemoryError, "stack overflow"); 371 return NULL; 372 } 373 #endif 374 if (v == NULL) 375 return PyString_FromString("<NULL>"); 376 else if (Py_TYPE(v)->tp_repr == NULL) 377 return PyString_FromFormat("<%s object at %p>", 378 Py_TYPE(v)->tp_name, v); 379 else { 380 PyObject *res; 381 res = (*Py_TYPE(v)->tp_repr)(v); 382 if (res == NULL) 383 return NULL; 384 #ifdef Py_USING_UNICODE 385 if (PyUnicode_Check(res)) { 386 PyObject* str; 387 str = PyUnicode_AsEncodedString(res, NULL, NULL); 388 Py_DECREF(res); 389 if (str) 390 res = str; 391 else 392 return NULL; 393 } 394 #endif 395 if (!PyString_Check(res)) { 396 PyErr_Format(PyExc_TypeError, 397 "__repr__ returned non-string (type %.200s)", 398 Py_TYPE(res)->tp_name); 399 Py_DECREF(res); 400 return NULL; 401 } 402 return res; 403 } 404 } 405 406 PyObject * 407 _PyObject_Str(PyObject *v) 408 { 409 PyObject *res; 410 int type_ok; 411 if (v == NULL) 412 return PyString_FromString("<NULL>"); 413 if (PyString_CheckExact(v)) { 414 Py_INCREF(v); 415 return v; 416 } 417 #ifdef Py_USING_UNICODE 418 if (PyUnicode_CheckExact(v)) { 419 Py_INCREF(v); 420 return v; 421 } 422 #endif 423 if (Py_TYPE(v)->tp_str == NULL) 424 return PyObject_Repr(v); 425 426 /* It is possible for a type to have a tp_str representation that loops 427 infinitely. */ 428 if (Py_EnterRecursiveCall(" while getting the str of an object")) 429 return NULL; 430 res = (*Py_TYPE(v)->tp_str)(v); 431 Py_LeaveRecursiveCall(); 432 if (res == NULL) 433 return NULL; 434 type_ok = PyString_Check(res); 435 #ifdef Py_USING_UNICODE 436 type_ok = type_ok || PyUnicode_Check(res); 437 #endif 438 if (!type_ok) { 439 PyErr_Format(PyExc_TypeError, 440 "__str__ returned non-string (type %.200s)", 441 Py_TYPE(res)->tp_name); 442 Py_DECREF(res); 443 return NULL; 444 } 445 return res; 446 } 447 448 PyObject * 449 PyObject_Str(PyObject *v) 450 { 451 PyObject *res = _PyObject_Str(v); 452 if (res == NULL) 453 return NULL; 454 #ifdef Py_USING_UNICODE 455 if (PyUnicode_Check(res)) { 456 PyObject* str; 457 str = PyUnicode_AsEncodedString(res, NULL, NULL); 458 Py_DECREF(res); 459 if (str) 460 res = str; 461 else 462 return NULL; 463 } 464 #endif 465 assert(PyString_Check(res)); 466 return res; 467 } 468 469 #ifdef Py_USING_UNICODE 470 PyObject * 471 PyObject_Unicode(PyObject *v) 472 { 473 PyObject *res = NULL; 474 PyObject *func = NULL; 475 PyObject *str = NULL; 476 int unicode_method_found = 0; 477 static PyObject *unicodestr = NULL; 478 479 if (v == NULL) { 480 res = PyString_FromString("<NULL>"); 481 if (res == NULL) 482 return NULL; 483 str = PyUnicode_FromEncodedObject(res, NULL, "strict"); 484 Py_DECREF(res); 485 return str; 486 } else if (PyUnicode_CheckExact(v)) { 487 Py_INCREF(v); 488 return v; 489 } 490 491 if (PyInstance_Check(v)) { 492 /* We're an instance of a classic class */ 493 /* Try __unicode__ from the instance -- alas we have no type */ 494 func = PyObject_GetAttr(v, unicodestr); 495 if (func != NULL) { 496 unicode_method_found = 1; 497 res = PyObject_CallFunctionObjArgs(func, NULL); 498 Py_DECREF(func); 499 } 500 else { 501 PyErr_Clear(); 502 } 503 } 504 else { 505 /* Not a classic class instance, try __unicode__. */ 506 func = _PyObject_LookupSpecial(v, "__unicode__", &unicodestr); 507 if (func != NULL) { 508 unicode_method_found = 1; 509 res = PyObject_CallFunctionObjArgs(func, NULL); 510 Py_DECREF(func); 511 } 512 else if (PyErr_Occurred()) 513 return NULL; 514 } 515 516 /* Didn't find __unicode__ */ 517 if (!unicode_method_found) { 518 if (PyUnicode_Check(v)) { 519 /* For a Unicode subtype that's didn't overwrite __unicode__, 520 return a true Unicode object with the same data. */ 521 return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v), 522 PyUnicode_GET_SIZE(v)); 523 } 524 if (PyString_CheckExact(v)) { 525 Py_INCREF(v); 526 res = v; 527 } 528 else { 529 if (Py_TYPE(v)->tp_str != NULL) 530 res = (*Py_TYPE(v)->tp_str)(v); 531 else 532 res = PyObject_Repr(v); 533 } 534 } 535 536 if (res == NULL) 537 return NULL; 538 if (!PyUnicode_Check(res)) { 539 str = PyUnicode_FromEncodedObject(res, NULL, "strict"); 540 Py_DECREF(res); 541 res = str; 542 } 543 return res; 544 } 545 #endif 546 547 548 /* Helper to warn about deprecated tp_compare return values. Return: 549 -2 for an exception; 550 -1 if v < w; 551 0 if v == w; 552 1 if v > w. 553 (This function cannot return 2.) 554 */ 555 static int 556 adjust_tp_compare(int c) 557 { 558 if (PyErr_Occurred()) { 559 if (c != -1 && c != -2) { 560 PyObject *t, *v, *tb; 561 PyErr_Fetch(&t, &v, &tb); 562 if (PyErr_Warn(PyExc_RuntimeWarning, 563 "tp_compare didn't return -1 or -2 " 564 "for exception") < 0) { 565 Py_XDECREF(t); 566 Py_XDECREF(v); 567 Py_XDECREF(tb); 568 } 569 else 570 PyErr_Restore(t, v, tb); 571 } 572 return -2; 573 } 574 else if (c < -1 || c > 1) { 575 if (PyErr_Warn(PyExc_RuntimeWarning, 576 "tp_compare didn't return -1, 0 or 1") < 0) 577 return -2; 578 else 579 return c < -1 ? -1 : 1; 580 } 581 else { 582 assert(c >= -1 && c <= 1); 583 return c; 584 } 585 } 586 587 588 /* Macro to get the tp_richcompare field of a type if defined */ 589 #define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \ 590 ? (t)->tp_richcompare : NULL) 591 592 /* Map rich comparison operators to their swapped version, e.g. LT --> GT */ 593 int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE}; 594 595 /* Try a genuine rich comparison, returning an object. Return: 596 NULL for exception; 597 NotImplemented if this particular rich comparison is not implemented or 598 undefined; 599 some object not equal to NotImplemented if it is implemented 600 (this latter object may not be a Boolean). 601 */ 602 static PyObject * 603 try_rich_compare(PyObject *v, PyObject *w, int op) 604 { 605 richcmpfunc f; 606 PyObject *res; 607 608 if (v->ob_type != w->ob_type && 609 PyType_IsSubtype(w->ob_type, v->ob_type) && 610 (f = RICHCOMPARE(w->ob_type)) != NULL) { 611 res = (*f)(w, v, _Py_SwappedOp[op]); 612 if (res != Py_NotImplemented) 613 return res; 614 Py_DECREF(res); 615 } 616 if ((f = RICHCOMPARE(v->ob_type)) != NULL) { 617 res = (*f)(v, w, op); 618 if (res != Py_NotImplemented) 619 return res; 620 Py_DECREF(res); 621 } 622 if ((f = RICHCOMPARE(w->ob_type)) != NULL) { 623 return (*f)(w, v, _Py_SwappedOp[op]); 624 } 625 res = Py_NotImplemented; 626 Py_INCREF(res); 627 return res; 628 } 629 630 /* Try a genuine rich comparison, returning an int. Return: 631 -1 for exception (including the case where try_rich_compare() returns an 632 object that's not a Boolean); 633 0 if the outcome is false; 634 1 if the outcome is true; 635 2 if this particular rich comparison is not implemented or undefined. 636 */ 637 static int 638 try_rich_compare_bool(PyObject *v, PyObject *w, int op) 639 { 640 PyObject *res; 641 int ok; 642 643 if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL) 644 return 2; /* Shortcut, avoid INCREF+DECREF */ 645 res = try_rich_compare(v, w, op); 646 if (res == NULL) 647 return -1; 648 if (res == Py_NotImplemented) { 649 Py_DECREF(res); 650 return 2; 651 } 652 ok = PyObject_IsTrue(res); 653 Py_DECREF(res); 654 return ok; 655 } 656 657 /* Try rich comparisons to determine a 3-way comparison. Return: 658 -2 for an exception; 659 -1 if v < w; 660 0 if v == w; 661 1 if v > w; 662 2 if this particular rich comparison is not implemented or undefined. 663 */ 664 static int 665 try_rich_to_3way_compare(PyObject *v, PyObject *w) 666 { 667 static struct { int op; int outcome; } tries[3] = { 668 /* Try this operator, and if it is true, use this outcome: */ 669 {Py_EQ, 0}, 670 {Py_LT, -1}, 671 {Py_GT, 1}, 672 }; 673 int i; 674 675 if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL) 676 return 2; /* Shortcut */ 677 678 for (i = 0; i < 3; i++) { 679 switch (try_rich_compare_bool(v, w, tries[i].op)) { 680 case -1: 681 return -2; 682 case 1: 683 return tries[i].outcome; 684 } 685 } 686 687 return 2; 688 } 689 690 /* Try a 3-way comparison, returning an int. Return: 691 -2 for an exception; 692 -1 if v < w; 693 0 if v == w; 694 1 if v > w; 695 2 if this particular 3-way comparison is not implemented or undefined. 696 */ 697 static int 698 try_3way_compare(PyObject *v, PyObject *w) 699 { 700 int c; 701 cmpfunc f; 702 703 /* Comparisons involving instances are given to instance_compare, 704 which has the same return conventions as this function. */ 705 706 f = v->ob_type->tp_compare; 707 if (PyInstance_Check(v)) 708 return (*f)(v, w); 709 if (PyInstance_Check(w)) 710 return (*w->ob_type->tp_compare)(v, w); 711 712 /* If both have the same (non-NULL) tp_compare, use it. */ 713 if (f != NULL && f == w->ob_type->tp_compare) { 714 c = (*f)(v, w); 715 return adjust_tp_compare(c); 716 } 717 718 /* If either tp_compare is _PyObject_SlotCompare, that's safe. */ 719 if (f == _PyObject_SlotCompare || 720 w->ob_type->tp_compare == _PyObject_SlotCompare) 721 return _PyObject_SlotCompare(v, w); 722 723 /* If we're here, v and w, 724 a) are not instances; 725 b) have different types or a type without tp_compare; and 726 c) don't have a user-defined tp_compare. 727 tp_compare implementations in C assume that both arguments 728 have their type, so we give up if the coercion fails or if 729 it yields types which are still incompatible (which can 730 happen with a user-defined nb_coerce). 731 */ 732 c = PyNumber_CoerceEx(&v, &w); 733 if (c < 0) 734 return -2; 735 if (c > 0) 736 return 2; 737 f = v->ob_type->tp_compare; 738 if (f != NULL && f == w->ob_type->tp_compare) { 739 c = (*f)(v, w); 740 Py_DECREF(v); 741 Py_DECREF(w); 742 return adjust_tp_compare(c); 743 } 744 745 /* No comparison defined */ 746 Py_DECREF(v); 747 Py_DECREF(w); 748 return 2; 749 } 750 751 /* Final fallback 3-way comparison, returning an int. Return: 752 -2 if an error occurred; 753 -1 if v < w; 754 0 if v == w; 755 1 if v > w. 756 */ 757 static int 758 default_3way_compare(PyObject *v, PyObject *w) 759 { 760 int c; 761 const char *vname, *wname; 762 763 if (v->ob_type == w->ob_type) { 764 /* When comparing these pointers, they must be cast to 765 * integer types (i.e. Py_uintptr_t, our spelling of C9X's 766 * uintptr_t). ANSI specifies that pointer compares other 767 * than == and != to non-related structures are undefined. 768 */ 769 Py_uintptr_t vv = (Py_uintptr_t)v; 770 Py_uintptr_t ww = (Py_uintptr_t)w; 771 return (vv < ww) ? -1 : (vv > ww) ? 1 : 0; 772 } 773 774 /* None is smaller than anything */ 775 if (v == Py_None) 776 return -1; 777 if (w == Py_None) 778 return 1; 779 780 /* different type: compare type names; numbers are smaller */ 781 if (PyNumber_Check(v)) 782 vname = ""; 783 else 784 vname = v->ob_type->tp_name; 785 if (PyNumber_Check(w)) 786 wname = ""; 787 else 788 wname = w->ob_type->tp_name; 789 c = strcmp(vname, wname); 790 if (c < 0) 791 return -1; 792 if (c > 0) 793 return 1; 794 /* Same type name, or (more likely) incomparable numeric types */ 795 return ((Py_uintptr_t)(v->ob_type) < ( 796 Py_uintptr_t)(w->ob_type)) ? -1 : 1; 797 } 798 799 /* Do a 3-way comparison, by hook or by crook. Return: 800 -2 for an exception (but see below); 801 -1 if v < w; 802 0 if v == w; 803 1 if v > w; 804 BUT: if the object implements a tp_compare function, it returns 805 whatever this function returns (whether with an exception or not). 806 */ 807 static int 808 do_cmp(PyObject *v, PyObject *w) 809 { 810 int c; 811 cmpfunc f; 812 813 if (v->ob_type == w->ob_type 814 && (f = v->ob_type->tp_compare) != NULL) { 815 c = (*f)(v, w); 816 if (PyInstance_Check(v)) { 817 /* Instance tp_compare has a different signature. 818 But if it returns undefined we fall through. */ 819 if (c != 2) 820 return c; 821 /* Else fall through to try_rich_to_3way_compare() */ 822 } 823 else 824 return adjust_tp_compare(c); 825 } 826 /* We only get here if one of the following is true: 827 a) v and w have different types 828 b) v and w have the same type, which doesn't have tp_compare 829 c) v and w are instances, and either __cmp__ is not defined or 830 __cmp__ returns NotImplemented 831 */ 832 c = try_rich_to_3way_compare(v, w); 833 if (c < 2) 834 return c; 835 c = try_3way_compare(v, w); 836 if (c < 2) 837 return c; 838 return default_3way_compare(v, w); 839 } 840 841 /* Compare v to w. Return 842 -1 if v < w or exception (PyErr_Occurred() true in latter case). 843 0 if v == w. 844 1 if v > w. 845 XXX The docs (C API manual) say the return value is undefined in case 846 XXX of error. 847 */ 848 int 849 PyObject_Compare(PyObject *v, PyObject *w) 850 { 851 int result; 852 853 if (v == NULL || w == NULL) { 854 PyErr_BadInternalCall(); 855 return -1; 856 } 857 if (v == w) 858 return 0; 859 if (Py_EnterRecursiveCall(" in cmp")) 860 return -1; 861 result = do_cmp(v, w); 862 Py_LeaveRecursiveCall(); 863 return result < 0 ? -1 : result; 864 } 865 866 /* Return (new reference to) Py_True or Py_False. */ 867 static PyObject * 868 convert_3way_to_object(int op, int c) 869 { 870 PyObject *result; 871 switch (op) { 872 case Py_LT: c = c < 0; break; 873 case Py_LE: c = c <= 0; break; 874 case Py_EQ: c = c == 0; break; 875 case Py_NE: c = c != 0; break; 876 case Py_GT: c = c > 0; break; 877 case Py_GE: c = c >= 0; break; 878 } 879 result = c ? Py_True : Py_False; 880 Py_INCREF(result); 881 return result; 882 } 883 884 /* We want a rich comparison but don't have one. Try a 3-way cmp instead. 885 Return 886 NULL if error 887 Py_True if v op w 888 Py_False if not (v op w) 889 */ 890 static PyObject * 891 try_3way_to_rich_compare(PyObject *v, PyObject *w, int op) 892 { 893 int c; 894 895 c = try_3way_compare(v, w); 896 if (c >= 2) { 897 898 /* Py3K warning if types are not equal and comparison isn't == or != */ 899 if (Py_Py3kWarningFlag && 900 v->ob_type != w->ob_type && op != Py_EQ && op != Py_NE && 901 PyErr_WarnEx(PyExc_DeprecationWarning, 902 "comparing unequal types not supported " 903 "in 3.x", 1) < 0) { 904 return NULL; 905 } 906 907 c = default_3way_compare(v, w); 908 } 909 if (c <= -2) 910 return NULL; 911 return convert_3way_to_object(op, c); 912 } 913 914 /* Do rich comparison on v and w. Return 915 NULL if error 916 Else a new reference to an object other than Py_NotImplemented, usually(?): 917 Py_True if v op w 918 Py_False if not (v op w) 919 */ 920 static PyObject * 921 do_richcmp(PyObject *v, PyObject *w, int op) 922 { 923 PyObject *res; 924 925 res = try_rich_compare(v, w, op); 926 if (res != Py_NotImplemented) 927 return res; 928 Py_DECREF(res); 929 930 return try_3way_to_rich_compare(v, w, op); 931 } 932 933 /* Return: 934 NULL for exception; 935 some object not equal to NotImplemented if it is implemented 936 (this latter object may not be a Boolean). 937 */ 938 PyObject * 939 PyObject_RichCompare(PyObject *v, PyObject *w, int op) 940 { 941 PyObject *res; 942 943 assert(Py_LT <= op && op <= Py_GE); 944 if (Py_EnterRecursiveCall(" in cmp")) 945 return NULL; 946 947 /* If the types are equal, and not old-style instances, try to 948 get out cheap (don't bother with coercions etc.). */ 949 if (v->ob_type == w->ob_type && !PyInstance_Check(v)) { 950 cmpfunc fcmp; 951 richcmpfunc frich = RICHCOMPARE(v->ob_type); 952 /* If the type has richcmp, try it first. try_rich_compare 953 tries it two-sided, which is not needed since we've a 954 single type only. */ 955 if (frich != NULL) { 956 res = (*frich)(v, w, op); 957 if (res != Py_NotImplemented) 958 goto Done; 959 Py_DECREF(res); 960 } 961 /* No richcmp, or this particular richmp not implemented. 962 Try 3-way cmp. */ 963 fcmp = v->ob_type->tp_compare; 964 if (fcmp != NULL) { 965 int c = (*fcmp)(v, w); 966 c = adjust_tp_compare(c); 967 if (c == -2) { 968 res = NULL; 969 goto Done; 970 } 971 res = convert_3way_to_object(op, c); 972 goto Done; 973 } 974 } 975 976 /* Fast path not taken, or couldn't deliver a useful result. */ 977 res = do_richcmp(v, w, op); 978 Done: 979 Py_LeaveRecursiveCall(); 980 return res; 981 } 982 983 /* Return -1 if error; 1 if v op w; 0 if not (v op w). */ 984 int 985 PyObject_RichCompareBool(PyObject *v, PyObject *w, int op) 986 { 987 PyObject *res; 988 int ok; 989 990 /* Quick result when objects are the same. 991 Guarantees that identity implies equality. */ 992 if (v == w) { 993 if (op == Py_EQ) 994 return 1; 995 else if (op == Py_NE) 996 return 0; 997 } 998 999 res = PyObject_RichCompare(v, w, op); 1000 if (res == NULL) 1001 return -1; 1002 if (PyBool_Check(res)) 1003 ok = (res == Py_True); 1004 else 1005 ok = PyObject_IsTrue(res); 1006 Py_DECREF(res); 1007 return ok; 1008 } 1009 1010 /* Set of hash utility functions to help maintaining the invariant that 1011 if a==b then hash(a)==hash(b) 1012 1013 All the utility functions (_Py_Hash*()) return "-1" to signify an error. 1014 */ 1015 1016 long 1017 _Py_HashDouble(double v) 1018 { 1019 double intpart, fractpart; 1020 int expo; 1021 long hipart; 1022 long x; /* the final hash value */ 1023 /* This is designed so that Python numbers of different types 1024 * that compare equal hash to the same value; otherwise comparisons 1025 * of mapping keys will turn out weird. 1026 */ 1027 1028 if (!Py_IS_FINITE(v)) { 1029 if (Py_IS_INFINITY(v)) 1030 return v < 0 ? -271828 : 314159; 1031 else 1032 return 0; 1033 } 1034 fractpart = modf(v, &intpart); 1035 if (fractpart == 0.0) { 1036 /* This must return the same hash as an equal int or long. */ 1037 if (intpart > LONG_MAX/2 || -intpart > LONG_MAX/2) { 1038 /* Convert to long and use its hash. */ 1039 PyObject *plong; /* converted to Python long */ 1040 plong = PyLong_FromDouble(v); 1041 if (plong == NULL) 1042 return -1; 1043 x = PyObject_Hash(plong); 1044 Py_DECREF(plong); 1045 return x; 1046 } 1047 /* Fits in a C long == a Python int, so is its own hash. */ 1048 x = (long)intpart; 1049 if (x == -1) 1050 x = -2; 1051 return x; 1052 } 1053 /* The fractional part is non-zero, so we don't have to worry about 1054 * making this match the hash of some other type. 1055 * Use frexp to get at the bits in the double. 1056 * Since the VAX D double format has 56 mantissa bits, which is the 1057 * most of any double format in use, each of these parts may have as 1058 * many as (but no more than) 56 significant bits. 1059 * So, assuming sizeof(long) >= 4, each part can be broken into two 1060 * longs; frexp and multiplication are used to do that. 1061 * Also, since the Cray double format has 15 exponent bits, which is 1062 * the most of any double format in use, shifting the exponent field 1063 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4). 1064 */ 1065 v = frexp(v, &expo); 1066 v *= 2147483648.0; /* 2**31 */ 1067 hipart = (long)v; /* take the top 32 bits */ 1068 v = (v - (double)hipart) * 2147483648.0; /* get the next 32 bits */ 1069 x = hipart + (long)v + (expo << 15); 1070 if (x == -1) 1071 x = -2; 1072 return x; 1073 } 1074 1075 long 1076 _Py_HashPointer(void *p) 1077 { 1078 long x; 1079 size_t y = (size_t)p; 1080 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid 1081 excessive hash collisions for dicts and sets */ 1082 y = (y >> 4) | (y << (8 * SIZEOF_VOID_P - 4)); 1083 x = (long)y; 1084 if (x == -1) 1085 x = -2; 1086 return x; 1087 } 1088 1089 long 1090 PyObject_HashNotImplemented(PyObject *self) 1091 { 1092 PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'", 1093 self->ob_type->tp_name); 1094 return -1; 1095 } 1096 1097 long 1098 PyObject_Hash(PyObject *v) 1099 { 1100 PyTypeObject *tp = v->ob_type; 1101 if (tp->tp_hash != NULL) 1102 return (*tp->tp_hash)(v); 1103 /* To keep to the general practice that inheriting 1104 * solely from object in C code should work without 1105 * an explicit call to PyType_Ready, we implicitly call 1106 * PyType_Ready here and then check the tp_hash slot again 1107 */ 1108 if (tp->tp_dict == NULL) { 1109 if (PyType_Ready(tp) < 0) 1110 return -1; 1111 if (tp->tp_hash != NULL) 1112 return (*tp->tp_hash)(v); 1113 } 1114 if (tp->tp_compare == NULL && RICHCOMPARE(tp) == NULL) { 1115 return _Py_HashPointer(v); /* Use address as hash value */ 1116 } 1117 /* If there's a cmp but no hash defined, the object can't be hashed */ 1118 return PyObject_HashNotImplemented(v); 1119 } 1120 1121 PyObject * 1122 PyObject_GetAttrString(PyObject *v, const char *name) 1123 { 1124 PyObject *w, *res; 1125 1126 if (Py_TYPE(v)->tp_getattr != NULL) 1127 return (*Py_TYPE(v)->tp_getattr)(v, (char*)name); 1128 w = PyString_InternFromString(name); 1129 if (w == NULL) 1130 return NULL; 1131 res = PyObject_GetAttr(v, w); 1132 Py_XDECREF(w); 1133 return res; 1134 } 1135 1136 int 1137 PyObject_HasAttrString(PyObject *v, const char *name) 1138 { 1139 PyObject *res = PyObject_GetAttrString(v, name); 1140 if (res != NULL) { 1141 Py_DECREF(res); 1142 return 1; 1143 } 1144 PyErr_Clear(); 1145 return 0; 1146 } 1147 1148 int 1149 PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w) 1150 { 1151 PyObject *s; 1152 int res; 1153 1154 if (Py_TYPE(v)->tp_setattr != NULL) 1155 return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w); 1156 s = PyString_InternFromString(name); 1157 if (s == NULL) 1158 return -1; 1159 res = PyObject_SetAttr(v, s, w); 1160 Py_XDECREF(s); 1161 return res; 1162 } 1163 1164 PyObject * 1165 PyObject_GetAttr(PyObject *v, PyObject *name) 1166 { 1167 PyTypeObject *tp = Py_TYPE(v); 1168 1169 if (!PyString_Check(name)) { 1170 #ifdef Py_USING_UNICODE 1171 /* The Unicode to string conversion is done here because the 1172 existing tp_getattro slots expect a string object as name 1173 and we wouldn't want to break those. */ 1174 if (PyUnicode_Check(name)) { 1175 name = _PyUnicode_AsDefaultEncodedString(name, NULL); 1176 if (name == NULL) 1177 return NULL; 1178 } 1179 else 1180 #endif 1181 { 1182 PyErr_Format(PyExc_TypeError, 1183 "attribute name must be string, not '%.200s'", 1184 Py_TYPE(name)->tp_name); 1185 return NULL; 1186 } 1187 } 1188 if (tp->tp_getattro != NULL) 1189 return (*tp->tp_getattro)(v, name); 1190 if (tp->tp_getattr != NULL) 1191 return (*tp->tp_getattr)(v, PyString_AS_STRING(name)); 1192 PyErr_Format(PyExc_AttributeError, 1193 "'%.50s' object has no attribute '%.400s'", 1194 tp->tp_name, PyString_AS_STRING(name)); 1195 return NULL; 1196 } 1197 1198 int 1199 PyObject_HasAttr(PyObject *v, PyObject *name) 1200 { 1201 PyObject *res = PyObject_GetAttr(v, name); 1202 if (res != NULL) { 1203 Py_DECREF(res); 1204 return 1; 1205 } 1206 PyErr_Clear(); 1207 return 0; 1208 } 1209 1210 int 1211 PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value) 1212 { 1213 PyTypeObject *tp = Py_TYPE(v); 1214 int err; 1215 1216 if (!PyString_Check(name)){ 1217 #ifdef Py_USING_UNICODE 1218 /* The Unicode to string conversion is done here because the 1219 existing tp_setattro slots expect a string object as name 1220 and we wouldn't want to break those. */ 1221 if (PyUnicode_Check(name)) { 1222 name = PyUnicode_AsEncodedString(name, NULL, NULL); 1223 if (name == NULL) 1224 return -1; 1225 } 1226 else 1227 #endif 1228 { 1229 PyErr_Format(PyExc_TypeError, 1230 "attribute name must be string, not '%.200s'", 1231 Py_TYPE(name)->tp_name); 1232 return -1; 1233 } 1234 } 1235 else 1236 Py_INCREF(name); 1237 1238 PyString_InternInPlace(&name); 1239 if (tp->tp_setattro != NULL) { 1240 err = (*tp->tp_setattro)(v, name, value); 1241 Py_DECREF(name); 1242 return err; 1243 } 1244 if (tp->tp_setattr != NULL) { 1245 err = (*tp->tp_setattr)(v, PyString_AS_STRING(name), value); 1246 Py_DECREF(name); 1247 return err; 1248 } 1249 Py_DECREF(name); 1250 if (tp->tp_getattr == NULL && tp->tp_getattro == NULL) 1251 PyErr_Format(PyExc_TypeError, 1252 "'%.100s' object has no attributes " 1253 "(%s .%.100s)", 1254 tp->tp_name, 1255 value==NULL ? "del" : "assign to", 1256 PyString_AS_STRING(name)); 1257 else 1258 PyErr_Format(PyExc_TypeError, 1259 "'%.100s' object has only read-only attributes " 1260 "(%s .%.100s)", 1261 tp->tp_name, 1262 value==NULL ? "del" : "assign to", 1263 PyString_AS_STRING(name)); 1264 return -1; 1265 } 1266 1267 /* Helper to get a pointer to an object's __dict__ slot, if any */ 1268 1269 PyObject ** 1270 _PyObject_GetDictPtr(PyObject *obj) 1271 { 1272 Py_ssize_t dictoffset; 1273 PyTypeObject *tp = Py_TYPE(obj); 1274 1275 if (!(tp->tp_flags & Py_TPFLAGS_HAVE_CLASS)) 1276 return NULL; 1277 dictoffset = tp->tp_dictoffset; 1278 if (dictoffset == 0) 1279 return NULL; 1280 if (dictoffset < 0) { 1281 Py_ssize_t tsize; 1282 size_t size; 1283 1284 tsize = ((PyVarObject *)obj)->ob_size; 1285 if (tsize < 0) 1286 tsize = -tsize; 1287 size = _PyObject_VAR_SIZE(tp, tsize); 1288 1289 dictoffset += (long)size; 1290 assert(dictoffset > 0); 1291 assert(dictoffset % SIZEOF_VOID_P == 0); 1292 } 1293 return (PyObject **) ((char *)obj + dictoffset); 1294 } 1295 1296 PyObject * 1297 PyObject_SelfIter(PyObject *obj) 1298 { 1299 Py_INCREF(obj); 1300 return obj; 1301 } 1302 1303 /* Helper used when the __next__ method is removed from a type: 1304 tp_iternext is never NULL and can be safely called without checking 1305 on every iteration. 1306 */ 1307 1308 PyObject * 1309 _PyObject_NextNotImplemented(PyObject *self) 1310 { 1311 PyErr_Format(PyExc_TypeError, 1312 "'%.200s' object is not iterable", 1313 Py_TYPE(self)->tp_name); 1314 return NULL; 1315 } 1316 1317 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */ 1318 1319 PyObject * 1320 _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name, PyObject *dict) 1321 { 1322 PyTypeObject *tp = Py_TYPE(obj); 1323 PyObject *descr = NULL; 1324 PyObject *res = NULL; 1325 descrgetfunc f; 1326 Py_ssize_t dictoffset; 1327 PyObject **dictptr; 1328 1329 if (!PyString_Check(name)){ 1330 #ifdef Py_USING_UNICODE 1331 /* The Unicode to string conversion is done here because the 1332 existing tp_setattro slots expect a string object as name 1333 and we wouldn't want to break those. */ 1334 if (PyUnicode_Check(name)) { 1335 name = PyUnicode_AsEncodedString(name, NULL, NULL); 1336 if (name == NULL) 1337 return NULL; 1338 } 1339 else 1340 #endif 1341 { 1342 PyErr_Format(PyExc_TypeError, 1343 "attribute name must be string, not '%.200s'", 1344 Py_TYPE(name)->tp_name); 1345 return NULL; 1346 } 1347 } 1348 else 1349 Py_INCREF(name); 1350 1351 if (tp->tp_dict == NULL) { 1352 if (PyType_Ready(tp) < 0) 1353 goto done; 1354 } 1355 1356 #if 0 /* XXX this is not quite _PyType_Lookup anymore */ 1357 /* Inline _PyType_Lookup */ 1358 { 1359 Py_ssize_t i, n; 1360 PyObject *mro, *base, *dict; 1361 1362 /* Look in tp_dict of types in MRO */ 1363 mro = tp->tp_mro; 1364 assert(mro != NULL); 1365 assert(PyTuple_Check(mro)); 1366 n = PyTuple_GET_SIZE(mro); 1367 for (i = 0; i < n; i++) { 1368 base = PyTuple_GET_ITEM(mro, i); 1369 if (PyClass_Check(base)) 1370 dict = ((PyClassObject *)base)->cl_dict; 1371 else { 1372 assert(PyType_Check(base)); 1373 dict = ((PyTypeObject *)base)->tp_dict; 1374 } 1375 assert(dict && PyDict_Check(dict)); 1376 descr = PyDict_GetItem(dict, name); 1377 if (descr != NULL) 1378 break; 1379 } 1380 } 1381 #else 1382 descr = _PyType_Lookup(tp, name); 1383 #endif 1384 1385 Py_XINCREF(descr); 1386 1387 f = NULL; 1388 if (descr != NULL && 1389 PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) { 1390 f = descr->ob_type->tp_descr_get; 1391 if (f != NULL && PyDescr_IsData(descr)) { 1392 res = f(descr, obj, (PyObject *)obj->ob_type); 1393 Py_DECREF(descr); 1394 goto done; 1395 } 1396 } 1397 1398 if (dict == NULL) { 1399 /* Inline _PyObject_GetDictPtr */ 1400 dictoffset = tp->tp_dictoffset; 1401 if (dictoffset != 0) { 1402 if (dictoffset < 0) { 1403 Py_ssize_t tsize; 1404 size_t size; 1405 1406 tsize = ((PyVarObject *)obj)->ob_size; 1407 if (tsize < 0) 1408 tsize = -tsize; 1409 size = _PyObject_VAR_SIZE(tp, tsize); 1410 1411 dictoffset += (long)size; 1412 assert(dictoffset > 0); 1413 assert(dictoffset % SIZEOF_VOID_P == 0); 1414 } 1415 dictptr = (PyObject **) ((char *)obj + dictoffset); 1416 dict = *dictptr; 1417 } 1418 } 1419 if (dict != NULL) { 1420 Py_INCREF(dict); 1421 res = PyDict_GetItem(dict, name); 1422 if (res != NULL) { 1423 Py_INCREF(res); 1424 Py_XDECREF(descr); 1425 Py_DECREF(dict); 1426 goto done; 1427 } 1428 Py_DECREF(dict); 1429 } 1430 1431 if (f != NULL) { 1432 res = f(descr, obj, (PyObject *)Py_TYPE(obj)); 1433 Py_DECREF(descr); 1434 goto done; 1435 } 1436 1437 if (descr != NULL) { 1438 res = descr; 1439 /* descr was already increfed above */ 1440 goto done; 1441 } 1442 1443 PyErr_Format(PyExc_AttributeError, 1444 "'%.50s' object has no attribute '%.400s'", 1445 tp->tp_name, PyString_AS_STRING(name)); 1446 done: 1447 Py_DECREF(name); 1448 return res; 1449 } 1450 1451 PyObject * 1452 PyObject_GenericGetAttr(PyObject *obj, PyObject *name) 1453 { 1454 return _PyObject_GenericGetAttrWithDict(obj, name, NULL); 1455 } 1456 1457 int 1458 _PyObject_GenericSetAttrWithDict(PyObject *obj, PyObject *name, 1459 PyObject *value, PyObject *dict) 1460 { 1461 PyTypeObject *tp = Py_TYPE(obj); 1462 PyObject *descr; 1463 descrsetfunc f; 1464 PyObject **dictptr; 1465 int res = -1; 1466 1467 if (!PyString_Check(name)){ 1468 #ifdef Py_USING_UNICODE 1469 /* The Unicode to string conversion is done here because the 1470 existing tp_setattro slots expect a string object as name 1471 and we wouldn't want to break those. */ 1472 if (PyUnicode_Check(name)) { 1473 name = PyUnicode_AsEncodedString(name, NULL, NULL); 1474 if (name == NULL) 1475 return -1; 1476 } 1477 else 1478 #endif 1479 { 1480 PyErr_Format(PyExc_TypeError, 1481 "attribute name must be string, not '%.200s'", 1482 Py_TYPE(name)->tp_name); 1483 return -1; 1484 } 1485 } 1486 else 1487 Py_INCREF(name); 1488 1489 if (tp->tp_dict == NULL) { 1490 if (PyType_Ready(tp) < 0) 1491 goto done; 1492 } 1493 1494 descr = _PyType_Lookup(tp, name); 1495 f = NULL; 1496 if (descr != NULL && 1497 PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) { 1498 f = descr->ob_type->tp_descr_set; 1499 if (f != NULL && PyDescr_IsData(descr)) { 1500 res = f(descr, obj, value); 1501 goto done; 1502 } 1503 } 1504 1505 if (dict == NULL) { 1506 dictptr = _PyObject_GetDictPtr(obj); 1507 if (dictptr != NULL) { 1508 dict = *dictptr; 1509 if (dict == NULL && value != NULL) { 1510 dict = PyDict_New(); 1511 if (dict == NULL) 1512 goto done; 1513 *dictptr = dict; 1514 } 1515 } 1516 } 1517 if (dict != NULL) { 1518 Py_INCREF(dict); 1519 if (value == NULL) 1520 res = PyDict_DelItem(dict, name); 1521 else 1522 res = PyDict_SetItem(dict, name, value); 1523 if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError)) 1524 PyErr_SetObject(PyExc_AttributeError, name); 1525 Py_DECREF(dict); 1526 goto done; 1527 } 1528 1529 if (f != NULL) { 1530 res = f(descr, obj, value); 1531 goto done; 1532 } 1533 1534 if (descr == NULL) { 1535 PyErr_Format(PyExc_AttributeError, 1536 "'%.100s' object has no attribute '%.200s'", 1537 tp->tp_name, PyString_AS_STRING(name)); 1538 goto done; 1539 } 1540 1541 PyErr_Format(PyExc_AttributeError, 1542 "'%.50s' object attribute '%.400s' is read-only", 1543 tp->tp_name, PyString_AS_STRING(name)); 1544 done: 1545 Py_DECREF(name); 1546 return res; 1547 } 1548 1549 int 1550 PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value) 1551 { 1552 return _PyObject_GenericSetAttrWithDict(obj, name, value, NULL); 1553 } 1554 1555 1556 /* Test a value used as condition, e.g., in a for or if statement. 1557 Return -1 if an error occurred */ 1558 1559 int 1560 PyObject_IsTrue(PyObject *v) 1561 { 1562 Py_ssize_t res; 1563 if (v == Py_True) 1564 return 1; 1565 if (v == Py_False) 1566 return 0; 1567 if (v == Py_None) 1568 return 0; 1569 else if (v->ob_type->tp_as_number != NULL && 1570 v->ob_type->tp_as_number->nb_nonzero != NULL) 1571 res = (*v->ob_type->tp_as_number->nb_nonzero)(v); 1572 else if (v->ob_type->tp_as_mapping != NULL && 1573 v->ob_type->tp_as_mapping->mp_length != NULL) 1574 res = (*v->ob_type->tp_as_mapping->mp_length)(v); 1575 else if (v->ob_type->tp_as_sequence != NULL && 1576 v->ob_type->tp_as_sequence->sq_length != NULL) 1577 res = (*v->ob_type->tp_as_sequence->sq_length)(v); 1578 else 1579 return 1; 1580 /* if it is negative, it should be either -1 or -2 */ 1581 return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int); 1582 } 1583 1584 /* equivalent of 'not v' 1585 Return -1 if an error occurred */ 1586 1587 int 1588 PyObject_Not(PyObject *v) 1589 { 1590 int res; 1591 res = PyObject_IsTrue(v); 1592 if (res < 0) 1593 return res; 1594 return res == 0; 1595 } 1596 1597 /* Coerce two numeric types to the "larger" one. 1598 Increment the reference count on each argument. 1599 Return value: 1600 -1 if an error occurred; 1601 0 if the coercion succeeded (and then the reference counts are increased); 1602 1 if no coercion is possible (and no error is raised). 1603 */ 1604 int 1605 PyNumber_CoerceEx(PyObject **pv, PyObject **pw) 1606 { 1607 register PyObject *v = *pv; 1608 register PyObject *w = *pw; 1609 int res; 1610 1611 /* Shortcut only for old-style types */ 1612 if (v->ob_type == w->ob_type && 1613 !PyType_HasFeature(v->ob_type, Py_TPFLAGS_CHECKTYPES)) 1614 { 1615 Py_INCREF(v); 1616 Py_INCREF(w); 1617 return 0; 1618 } 1619 if (v->ob_type->tp_as_number && v->ob_type->tp_as_number->nb_coerce) { 1620 res = (*v->ob_type->tp_as_number->nb_coerce)(pv, pw); 1621 if (res <= 0) 1622 return res; 1623 } 1624 if (w->ob_type->tp_as_number && w->ob_type->tp_as_number->nb_coerce) { 1625 res = (*w->ob_type->tp_as_number->nb_coerce)(pw, pv); 1626 if (res <= 0) 1627 return res; 1628 } 1629 return 1; 1630 } 1631 1632 /* Coerce two numeric types to the "larger" one. 1633 Increment the reference count on each argument. 1634 Return -1 and raise an exception if no coercion is possible 1635 (and then no reference count is incremented). 1636 */ 1637 int 1638 PyNumber_Coerce(PyObject **pv, PyObject **pw) 1639 { 1640 int err = PyNumber_CoerceEx(pv, pw); 1641 if (err <= 0) 1642 return err; 1643 PyErr_SetString(PyExc_TypeError, "number coercion failed"); 1644 return -1; 1645 } 1646 1647 1648 /* Test whether an object can be called */ 1649 1650 int 1651 PyCallable_Check(PyObject *x) 1652 { 1653 if (x == NULL) 1654 return 0; 1655 if (PyInstance_Check(x)) { 1656 PyObject *call = PyObject_GetAttrString(x, "__call__"); 1657 if (call == NULL) { 1658 PyErr_Clear(); 1659 return 0; 1660 } 1661 /* Could test recursively but don't, for fear of endless 1662 recursion if some joker sets self.__call__ = self */ 1663 Py_DECREF(call); 1664 return 1; 1665 } 1666 else { 1667 return x->ob_type->tp_call != NULL; 1668 } 1669 } 1670 1671 /* ------------------------- PyObject_Dir() helpers ------------------------- */ 1672 1673 /* Helper for PyObject_Dir. 1674 Merge the __dict__ of aclass into dict, and recursively also all 1675 the __dict__s of aclass's base classes. The order of merging isn't 1676 defined, as it's expected that only the final set of dict keys is 1677 interesting. 1678 Return 0 on success, -1 on error. 1679 */ 1680 1681 static int 1682 merge_class_dict(PyObject* dict, PyObject* aclass) 1683 { 1684 PyObject *classdict; 1685 PyObject *bases; 1686 1687 assert(PyDict_Check(dict)); 1688 assert(aclass); 1689 1690 /* Merge in the type's dict (if any). */ 1691 classdict = PyObject_GetAttrString(aclass, "__dict__"); 1692 if (classdict == NULL) 1693 PyErr_Clear(); 1694 else { 1695 int status = PyDict_Update(dict, classdict); 1696 Py_DECREF(classdict); 1697 if (status < 0) 1698 return -1; 1699 } 1700 1701 /* Recursively merge in the base types' (if any) dicts. */ 1702 bases = PyObject_GetAttrString(aclass, "__bases__"); 1703 if (bases == NULL) 1704 PyErr_Clear(); 1705 else { 1706 /* We have no guarantee that bases is a real tuple */ 1707 Py_ssize_t i, n; 1708 n = PySequence_Size(bases); /* This better be right */ 1709 if (n < 0) 1710 PyErr_Clear(); 1711 else { 1712 for (i = 0; i < n; i++) { 1713 int status; 1714 PyObject *base = PySequence_GetItem(bases, i); 1715 if (base == NULL) { 1716 Py_DECREF(bases); 1717 return -1; 1718 } 1719 status = merge_class_dict(dict, base); 1720 Py_DECREF(base); 1721 if (status < 0) { 1722 Py_DECREF(bases); 1723 return -1; 1724 } 1725 } 1726 } 1727 Py_DECREF(bases); 1728 } 1729 return 0; 1730 } 1731 1732 /* Helper for PyObject_Dir. 1733 If obj has an attr named attrname that's a list, merge its string 1734 elements into keys of dict. 1735 Return 0 on success, -1 on error. Errors due to not finding the attr, 1736 or the attr not being a list, are suppressed. 1737 */ 1738 1739 static int 1740 merge_list_attr(PyObject* dict, PyObject* obj, const char *attrname) 1741 { 1742 PyObject *list; 1743 int result = 0; 1744 1745 assert(PyDict_Check(dict)); 1746 assert(obj); 1747 assert(attrname); 1748 1749 list = PyObject_GetAttrString(obj, attrname); 1750 if (list == NULL) 1751 PyErr_Clear(); 1752 1753 else if (PyList_Check(list)) { 1754 int i; 1755 for (i = 0; i < PyList_GET_SIZE(list); ++i) { 1756 PyObject *item = PyList_GET_ITEM(list, i); 1757 if (PyString_Check(item)) { 1758 result = PyDict_SetItem(dict, item, Py_None); 1759 if (result < 0) 1760 break; 1761 } 1762 } 1763 if (Py_Py3kWarningFlag && 1764 (strcmp(attrname, "__members__") == 0 || 1765 strcmp(attrname, "__methods__") == 0)) { 1766 if (PyErr_WarnEx(PyExc_DeprecationWarning, 1767 "__members__ and __methods__ not " 1768 "supported in 3.x", 1) < 0) { 1769 Py_XDECREF(list); 1770 return -1; 1771 } 1772 } 1773 } 1774 1775 Py_XDECREF(list); 1776 return result; 1777 } 1778 1779 /* Helper for PyObject_Dir without arguments: returns the local scope. */ 1780 static PyObject * 1781 _dir_locals(void) 1782 { 1783 PyObject *names; 1784 PyObject *locals = PyEval_GetLocals(); 1785 1786 if (locals == NULL) { 1787 PyErr_SetString(PyExc_SystemError, "frame does not exist"); 1788 return NULL; 1789 } 1790 1791 names = PyMapping_Keys(locals); 1792 if (!names) 1793 return NULL; 1794 if (!PyList_Check(names)) { 1795 PyErr_Format(PyExc_TypeError, 1796 "dir(): expected keys() of locals to be a list, " 1797 "not '%.200s'", Py_TYPE(names)->tp_name); 1798 Py_DECREF(names); 1799 return NULL; 1800 } 1801 /* the locals don't need to be DECREF'd */ 1802 return names; 1803 } 1804 1805 /* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__. 1806 We deliberately don't suck up its __class__, as methods belonging to the 1807 metaclass would probably be more confusing than helpful. 1808 */ 1809 static PyObject * 1810 _specialized_dir_type(PyObject *obj) 1811 { 1812 PyObject *result = NULL; 1813 PyObject *dict = PyDict_New(); 1814 1815 if (dict != NULL && merge_class_dict(dict, obj) == 0) 1816 result = PyDict_Keys(dict); 1817 1818 Py_XDECREF(dict); 1819 return result; 1820 } 1821 1822 /* Helper for PyObject_Dir of module objects: returns the module's __dict__. */ 1823 static PyObject * 1824 _specialized_dir_module(PyObject *obj) 1825 { 1826 PyObject *result = NULL; 1827 PyObject *dict = PyObject_GetAttrString(obj, "__dict__"); 1828 1829 if (dict != NULL) { 1830 if (PyDict_Check(dict)) 1831 result = PyDict_Keys(dict); 1832 else { 1833 char *name = PyModule_GetName(obj); 1834 if (name) 1835 PyErr_Format(PyExc_TypeError, 1836 "%.200s.__dict__ is not a dictionary", 1837 name); 1838 } 1839 } 1840 1841 Py_XDECREF(dict); 1842 return result; 1843 } 1844 1845 /* Helper for PyObject_Dir of generic objects: returns __dict__, __class__, 1846 and recursively up the __class__.__bases__ chain. 1847 */ 1848 static PyObject * 1849 _generic_dir(PyObject *obj) 1850 { 1851 PyObject *result = NULL; 1852 PyObject *dict = NULL; 1853 PyObject *itsclass = NULL; 1854 1855 /* Get __dict__ (which may or may not be a real dict...) */ 1856 dict = PyObject_GetAttrString(obj, "__dict__"); 1857 if (dict == NULL) { 1858 PyErr_Clear(); 1859 dict = PyDict_New(); 1860 } 1861 else if (!PyDict_Check(dict)) { 1862 Py_DECREF(dict); 1863 dict = PyDict_New(); 1864 } 1865 else { 1866 /* Copy __dict__ to avoid mutating it. */ 1867 PyObject *temp = PyDict_Copy(dict); 1868 Py_DECREF(dict); 1869 dict = temp; 1870 } 1871 1872 if (dict == NULL) 1873 goto error; 1874 1875 /* Merge in __members__ and __methods__ (if any). 1876 * This is removed in Python 3000. */ 1877 if (merge_list_attr(dict, obj, "__members__") < 0) 1878 goto error; 1879 if (merge_list_attr(dict, obj, "__methods__") < 0) 1880 goto error; 1881 1882 /* Merge in attrs reachable from its class. */ 1883 itsclass = PyObject_GetAttrString(obj, "__class__"); 1884 if (itsclass == NULL) 1885 /* XXX(tomer): Perhaps fall back to obj->ob_type if no 1886 __class__ exists? */ 1887 PyErr_Clear(); 1888 else { 1889 if (merge_class_dict(dict, itsclass) != 0) 1890 goto error; 1891 } 1892 1893 result = PyDict_Keys(dict); 1894 /* fall through */ 1895 error: 1896 Py_XDECREF(itsclass); 1897 Py_XDECREF(dict); 1898 return result; 1899 } 1900 1901 /* Helper for PyObject_Dir: object introspection. 1902 This calls one of the above specialized versions if no __dir__ method 1903 exists. */ 1904 static PyObject * 1905 _dir_object(PyObject *obj) 1906 { 1907 PyObject *result = NULL; 1908 static PyObject *dir_str = NULL; 1909 PyObject *dirfunc; 1910 1911 assert(obj); 1912 if (PyInstance_Check(obj)) { 1913 dirfunc = PyObject_GetAttrString(obj, "__dir__"); 1914 if (dirfunc == NULL) { 1915 if (PyErr_ExceptionMatches(PyExc_AttributeError)) 1916 PyErr_Clear(); 1917 else 1918 return NULL; 1919 } 1920 } 1921 else { 1922 dirfunc = _PyObject_LookupSpecial(obj, "__dir__", &dir_str); 1923 if (PyErr_Occurred()) 1924 return NULL; 1925 } 1926 if (dirfunc == NULL) { 1927 /* use default implementation */ 1928 if (PyModule_Check(obj)) 1929 result = _specialized_dir_module(obj); 1930 else if (PyType_Check(obj) || PyClass_Check(obj)) 1931 result = _specialized_dir_type(obj); 1932 else 1933 result = _generic_dir(obj); 1934 } 1935 else { 1936 /* use __dir__ */ 1937 result = PyObject_CallFunctionObjArgs(dirfunc, NULL); 1938 Py_DECREF(dirfunc); 1939 if (result == NULL) 1940 return NULL; 1941 1942 /* result must be a list */ 1943 /* XXX(gbrandl): could also check if all items are strings */ 1944 if (!PyList_Check(result)) { 1945 PyErr_Format(PyExc_TypeError, 1946 "__dir__() must return a list, not %.200s", 1947 Py_TYPE(result)->tp_name); 1948 Py_DECREF(result); 1949 result = NULL; 1950 } 1951 } 1952 1953 return result; 1954 } 1955 1956 /* Implementation of dir() -- if obj is NULL, returns the names in the current 1957 (local) scope. Otherwise, performs introspection of the object: returns a 1958 sorted list of attribute names (supposedly) accessible from the object 1959 */ 1960 PyObject * 1961 PyObject_Dir(PyObject *obj) 1962 { 1963 PyObject * result; 1964 1965 if (obj == NULL) 1966 /* no object -- introspect the locals */ 1967 result = _dir_locals(); 1968 else 1969 /* object -- introspect the object */ 1970 result = _dir_object(obj); 1971 1972 assert(result == NULL || PyList_Check(result)); 1973 1974 if (result != NULL && PyList_Sort(result) != 0) { 1975 /* sorting the list failed */ 1976 Py_DECREF(result); 1977 result = NULL; 1978 } 1979 1980 return result; 1981 } 1982 1983 /* 1984 NoObject is usable as a non-NULL undefined value, used by the macro None. 1985 There is (and should be!) no way to create other objects of this type, 1986 so there is exactly one (which is indestructible, by the way). 1987 (XXX This type and the type of NotImplemented below should be unified.) 1988 */ 1989 1990 /* ARGSUSED */ 1991 static PyObject * 1992 none_repr(PyObject *op) 1993 { 1994 return PyString_FromString("None"); 1995 } 1996 1997 /* ARGUSED */ 1998 static void 1999 none_dealloc(PyObject* ignore) 2000 { 2001 /* This should never get called, but we also don't want to SEGV if 2002 * we accidentally decref None out of existence. 2003 */ 2004 Py_FatalError("deallocating None"); 2005 } 2006 2007 2008 static PyTypeObject PyNone_Type = { 2009 PyVarObject_HEAD_INIT(&PyType_Type, 0) 2010 "NoneType", 2011 0, 2012 0, 2013 none_dealloc, /*tp_dealloc*/ /*never called*/ 2014 0, /*tp_print*/ 2015 0, /*tp_getattr*/ 2016 0, /*tp_setattr*/ 2017 0, /*tp_compare*/ 2018 none_repr, /*tp_repr*/ 2019 0, /*tp_as_number*/ 2020 0, /*tp_as_sequence*/ 2021 0, /*tp_as_mapping*/ 2022 (hashfunc)_Py_HashPointer, /*tp_hash */ 2023 }; 2024 2025 PyObject _Py_NoneStruct = { 2026 _PyObject_EXTRA_INIT 2027 1, &PyNone_Type 2028 }; 2029 2030 /* NotImplemented is an object that can be used to signal that an 2031 operation is not implemented for the given type combination. */ 2032 2033 static PyObject * 2034 NotImplemented_repr(PyObject *op) 2035 { 2036 return PyString_FromString("NotImplemented"); 2037 } 2038 2039 static PyTypeObject PyNotImplemented_Type = { 2040 PyVarObject_HEAD_INIT(&PyType_Type, 0) 2041 "NotImplementedType", 2042 0, 2043 0, 2044 none_dealloc, /*tp_dealloc*/ /*never called*/ 2045 0, /*tp_print*/ 2046 0, /*tp_getattr*/ 2047 0, /*tp_setattr*/ 2048 0, /*tp_compare*/ 2049 NotImplemented_repr, /*tp_repr*/ 2050 0, /*tp_as_number*/ 2051 0, /*tp_as_sequence*/ 2052 0, /*tp_as_mapping*/ 2053 0, /*tp_hash */ 2054 }; 2055 2056 PyObject _Py_NotImplementedStruct = { 2057 _PyObject_EXTRA_INIT 2058 1, &PyNotImplemented_Type 2059 }; 2060 2061 void 2062 _Py_ReadyTypes(void) 2063 { 2064 if (PyType_Ready(&PyType_Type) < 0) 2065 Py_FatalError("Can't initialize type type"); 2066 2067 if (PyType_Ready(&_PyWeakref_RefType) < 0) 2068 Py_FatalError("Can't initialize weakref type"); 2069 2070 if (PyType_Ready(&_PyWeakref_CallableProxyType) < 0) 2071 Py_FatalError("Can't initialize callable weakref proxy type"); 2072 2073 if (PyType_Ready(&_PyWeakref_ProxyType) < 0) 2074 Py_FatalError("Can't initialize weakref proxy type"); 2075 2076 if (PyType_Ready(&PyBool_Type) < 0) 2077 Py_FatalError("Can't initialize bool type"); 2078 2079 if (PyType_Ready(&PyString_Type) < 0) 2080 Py_FatalError("Can't initialize str type"); 2081 2082 if (PyType_Ready(&PyByteArray_Type) < 0) 2083 Py_FatalError("Can't initialize bytearray type"); 2084 2085 if (PyType_Ready(&PyList_Type) < 0) 2086 Py_FatalError("Can't initialize list type"); 2087 2088 if (PyType_Ready(&PyNone_Type) < 0) 2089 Py_FatalError("Can't initialize None type"); 2090 2091 if (PyType_Ready(&PyNotImplemented_Type) < 0) 2092 Py_FatalError("Can't initialize NotImplemented type"); 2093 2094 if (PyType_Ready(&PyTraceBack_Type) < 0) 2095 Py_FatalError("Can't initialize traceback type"); 2096 2097 if (PyType_Ready(&PySuper_Type) < 0) 2098 Py_FatalError("Can't initialize super type"); 2099 2100 if (PyType_Ready(&PyBaseObject_Type) < 0) 2101 Py_FatalError("Can't initialize object type"); 2102 2103 if (PyType_Ready(&PyRange_Type) < 0) 2104 Py_FatalError("Can't initialize xrange type"); 2105 2106 if (PyType_Ready(&PyDict_Type) < 0) 2107 Py_FatalError("Can't initialize dict type"); 2108 2109 if (PyType_Ready(&PySet_Type) < 0) 2110 Py_FatalError("Can't initialize set type"); 2111 2112 if (PyType_Ready(&PyUnicode_Type) < 0) 2113 Py_FatalError("Can't initialize unicode type"); 2114 2115 if (PyType_Ready(&PySlice_Type) < 0) 2116 Py_FatalError("Can't initialize slice type"); 2117 2118 if (PyType_Ready(&PyStaticMethod_Type) < 0) 2119 Py_FatalError("Can't initialize static method type"); 2120 2121 #ifndef WITHOUT_COMPLEX 2122 if (PyType_Ready(&PyComplex_Type) < 0) 2123 Py_FatalError("Can't initialize complex type"); 2124 #endif 2125 2126 if (PyType_Ready(&PyFloat_Type) < 0) 2127 Py_FatalError("Can't initialize float type"); 2128 2129 if (PyType_Ready(&PyBuffer_Type) < 0) 2130 Py_FatalError("Can't initialize buffer type"); 2131 2132 if (PyType_Ready(&PyLong_Type) < 0) 2133 Py_FatalError("Can't initialize long type"); 2134 2135 if (PyType_Ready(&PyInt_Type) < 0) 2136 Py_FatalError("Can't initialize int type"); 2137 2138 if (PyType_Ready(&PyFrozenSet_Type) < 0) 2139 Py_FatalError("Can't initialize frozenset type"); 2140 2141 if (PyType_Ready(&PyProperty_Type) < 0) 2142 Py_FatalError("Can't initialize property type"); 2143 2144 if (PyType_Ready(&PyMemoryView_Type) < 0) 2145 Py_FatalError("Can't initialize memoryview type"); 2146 2147 if (PyType_Ready(&PyTuple_Type) < 0) 2148 Py_FatalError("Can't initialize tuple type"); 2149 2150 if (PyType_Ready(&PyEnum_Type) < 0) 2151 Py_FatalError("Can't initialize enumerate type"); 2152 2153 if (PyType_Ready(&PyReversed_Type) < 0) 2154 Py_FatalError("Can't initialize reversed type"); 2155 2156 if (PyType_Ready(&PyCode_Type) < 0) 2157 Py_FatalError("Can't initialize code type"); 2158 2159 if (PyType_Ready(&PyFrame_Type) < 0) 2160 Py_FatalError("Can't initialize frame type"); 2161 2162 if (PyType_Ready(&PyCFunction_Type) < 0) 2163 Py_FatalError("Can't initialize builtin function type"); 2164 2165 if (PyType_Ready(&PyMethod_Type) < 0) 2166 Py_FatalError("Can't initialize method type"); 2167 2168 if (PyType_Ready(&PyFunction_Type) < 0) 2169 Py_FatalError("Can't initialize function type"); 2170 2171 if (PyType_Ready(&PyClass_Type) < 0) 2172 Py_FatalError("Can't initialize class type"); 2173 2174 if (PyType_Ready(&PyDictProxy_Type) < 0) 2175 Py_FatalError("Can't initialize dict proxy type"); 2176 2177 if (PyType_Ready(&PyGen_Type) < 0) 2178 Py_FatalError("Can't initialize generator type"); 2179 2180 if (PyType_Ready(&PyGetSetDescr_Type) < 0) 2181 Py_FatalError("Can't initialize get-set descriptor type"); 2182 2183 if (PyType_Ready(&PyWrapperDescr_Type) < 0) 2184 Py_FatalError("Can't initialize wrapper type"); 2185 2186 if (PyType_Ready(&PyInstance_Type) < 0) 2187 Py_FatalError("Can't initialize instance type"); 2188 2189 if (PyType_Ready(&PyEllipsis_Type) < 0) 2190 Py_FatalError("Can't initialize ellipsis type"); 2191 2192 if (PyType_Ready(&PyMemberDescr_Type) < 0) 2193 Py_FatalError("Can't initialize member descriptor type"); 2194 2195 if (PyType_Ready(&PyFile_Type) < 0) 2196 Py_FatalError("Can't initialize file type"); 2197 } 2198 2199 2200 #ifdef Py_TRACE_REFS 2201 2202 void 2203 _Py_NewReference(PyObject *op) 2204 { 2205 _Py_INC_REFTOTAL; 2206 op->ob_refcnt = 1; 2207 _Py_AddToAllObjects(op, 1); 2208 _Py_INC_TPALLOCS(op); 2209 } 2210 2211 void 2212 _Py_ForgetReference(register PyObject *op) 2213 { 2214 #ifdef SLOW_UNREF_CHECK 2215 register PyObject *p; 2216 #endif 2217 if (op->ob_refcnt < 0) 2218 Py_FatalError("UNREF negative refcnt"); 2219 if (op == &refchain || 2220 op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op) 2221 Py_FatalError("UNREF invalid object"); 2222 #ifdef SLOW_UNREF_CHECK 2223 for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) { 2224 if (p == op) 2225 break; 2226 } 2227 if (p == &refchain) /* Not found */ 2228 Py_FatalError("UNREF unknown object"); 2229 #endif 2230 op->_ob_next->_ob_prev = op->_ob_prev; 2231 op->_ob_prev->_ob_next = op->_ob_next; 2232 op->_ob_next = op->_ob_prev = NULL; 2233 _Py_INC_TPFREES(op); 2234 } 2235 2236 void 2237 _Py_Dealloc(PyObject *op) 2238 { 2239 destructor dealloc = Py_TYPE(op)->tp_dealloc; 2240 _Py_ForgetReference(op); 2241 (*dealloc)(op); 2242 } 2243 2244 /* Print all live objects. Because PyObject_Print is called, the 2245 * interpreter must be in a healthy state. 2246 */ 2247 void 2248 _Py_PrintReferences(FILE *fp) 2249 { 2250 PyObject *op; 2251 fprintf(fp, "Remaining objects:\n"); 2252 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) { 2253 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] ", op, op->ob_refcnt); 2254 if (PyObject_Print(op, fp, 0) != 0) 2255 PyErr_Clear(); 2256 putc('\n', fp); 2257 } 2258 } 2259 2260 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this 2261 * doesn't make any calls to the Python C API, so is always safe to call. 2262 */ 2263 void 2264 _Py_PrintReferenceAddresses(FILE *fp) 2265 { 2266 PyObject *op; 2267 fprintf(fp, "Remaining object addresses:\n"); 2268 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) 2269 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op, 2270 op->ob_refcnt, Py_TYPE(op)->tp_name); 2271 } 2272 2273 PyObject * 2274 _Py_GetObjects(PyObject *self, PyObject *args) 2275 { 2276 int i, n; 2277 PyObject *t = NULL; 2278 PyObject *res, *op; 2279 2280 if (!PyArg_ParseTuple(args, "i|O", &n, &t)) 2281 return NULL; 2282 op = refchain._ob_next; 2283 res = PyList_New(0); 2284 if (res == NULL) 2285 return NULL; 2286 for (i = 0; (n == 0 || i < n) && op != &refchain; i++) { 2287 while (op == self || op == args || op == res || op == t || 2288 (t != NULL && Py_TYPE(op) != (PyTypeObject *) t)) { 2289 op = op->_ob_next; 2290 if (op == &refchain) 2291 return res; 2292 } 2293 if (PyList_Append(res, op) < 0) { 2294 Py_DECREF(res); 2295 return NULL; 2296 } 2297 op = op->_ob_next; 2298 } 2299 return res; 2300 } 2301 2302 #endif 2303 2304 2305 /* Hack to force loading of capsule.o */ 2306 PyTypeObject *_Py_capsule_hack = &PyCapsule_Type; 2307 2308 2309 /* Hack to force loading of cobject.o */ 2310 PyTypeObject *_Py_cobject_hack = &PyCObject_Type; 2311 2312 2313 /* Hack to force loading of abstract.o */ 2314 Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size; 2315 2316 2317 /* Python's malloc wrappers (see pymem.h) */ 2318 2319 void * 2320 PyMem_Malloc(size_t nbytes) 2321 { 2322 return PyMem_MALLOC(nbytes); 2323 } 2324 2325 void * 2326 PyMem_Realloc(void *p, size_t nbytes) 2327 { 2328 return PyMem_REALLOC(p, nbytes); 2329 } 2330 2331 void 2332 PyMem_Free(void *p) 2333 { 2334 PyMem_FREE(p); 2335 } 2336 2337 2338 /* These methods are used to control infinite recursion in repr, str, print, 2339 etc. Container objects that may recursively contain themselves, 2340 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and 2341 Py_ReprLeave() to avoid infinite recursion. 2342 2343 Py_ReprEnter() returns 0 the first time it is called for a particular 2344 object and 1 every time thereafter. It returns -1 if an exception 2345 occurred. Py_ReprLeave() has no return value. 2346 2347 See dictobject.c and listobject.c for examples of use. 2348 */ 2349 2350 #define KEY "Py_Repr" 2351 2352 int 2353 Py_ReprEnter(PyObject *obj) 2354 { 2355 PyObject *dict; 2356 PyObject *list; 2357 Py_ssize_t i; 2358 2359 dict = PyThreadState_GetDict(); 2360 if (dict == NULL) 2361 return 0; 2362 list = PyDict_GetItemString(dict, KEY); 2363 if (list == NULL) { 2364 list = PyList_New(0); 2365 if (list == NULL) 2366 return -1; 2367 if (PyDict_SetItemString(dict, KEY, list) < 0) 2368 return -1; 2369 Py_DECREF(list); 2370 } 2371 i = PyList_GET_SIZE(list); 2372 while (--i >= 0) { 2373 if (PyList_GET_ITEM(list, i) == obj) 2374 return 1; 2375 } 2376 PyList_Append(list, obj); 2377 return 0; 2378 } 2379 2380 void 2381 Py_ReprLeave(PyObject *obj) 2382 { 2383 PyObject *dict; 2384 PyObject *list; 2385 Py_ssize_t i; 2386 2387 dict = PyThreadState_GetDict(); 2388 if (dict == NULL) 2389 return; 2390 list = PyDict_GetItemString(dict, KEY); 2391 if (list == NULL || !PyList_Check(list)) 2392 return; 2393 i = PyList_GET_SIZE(list); 2394 /* Count backwards because we always expect obj to be list[-1] */ 2395 while (--i >= 0) { 2396 if (PyList_GET_ITEM(list, i) == obj) { 2397 PyList_SetSlice(list, i, i + 1, NULL); 2398 break; 2399 } 2400 } 2401 } 2402 2403 /* Trashcan support. */ 2404 2405 /* Current call-stack depth of tp_dealloc calls. */ 2406 int _PyTrash_delete_nesting = 0; 2407 2408 /* List of objects that still need to be cleaned up, singly linked via their 2409 * gc headers' gc_prev pointers. 2410 */ 2411 PyObject *_PyTrash_delete_later = NULL; 2412 2413 /* Add op to the _PyTrash_delete_later list. Called when the current 2414 * call-stack depth gets large. op must be a currently untracked gc'ed 2415 * object, with refcount 0. Py_DECREF must already have been called on it. 2416 */ 2417 void 2418 _PyTrash_deposit_object(PyObject *op) 2419 { 2420 assert(PyObject_IS_GC(op)); 2421 assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED); 2422 assert(op->ob_refcnt == 0); 2423 _Py_AS_GC(op)->gc.gc_prev = (PyGC_Head *)_PyTrash_delete_later; 2424 _PyTrash_delete_later = op; 2425 } 2426 2427 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when 2428 * the call-stack unwinds again. 2429 */ 2430 void 2431 _PyTrash_destroy_chain(void) 2432 { 2433 while (_PyTrash_delete_later) { 2434 PyObject *op = _PyTrash_delete_later; 2435 destructor dealloc = Py_TYPE(op)->tp_dealloc; 2436 2437 _PyTrash_delete_later = 2438 (PyObject*) _Py_AS_GC(op)->gc.gc_prev; 2439 2440 /* Call the deallocator directly. This used to try to 2441 * fool Py_DECREF into calling it indirectly, but 2442 * Py_DECREF was already called on this object, and in 2443 * assorted non-release builds calling Py_DECREF again ends 2444 * up distorting allocation statistics. 2445 */ 2446 assert(op->ob_refcnt == 0); 2447 ++_PyTrash_delete_nesting; 2448 (*dealloc)(op); 2449 --_PyTrash_delete_nesting; 2450 } 2451 } 2452 2453 #ifdef __cplusplus 2454 } 2455 #endif 2456
