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