1 /* Frame object implementation */ 2 3 #include "Python.h" 4 5 #include "code.h" 6 #include "frameobject.h" 7 #include "opcode.h" 8 #include "structmember.h" 9 10 #undef MIN 11 #undef MAX 12 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 13 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 14 15 #define OFF(x) offsetof(PyFrameObject, x) 16 17 static PyMemberDef frame_memberlist[] = { 18 {"f_back", T_OBJECT, OFF(f_back), RO}, 19 {"f_code", T_OBJECT, OFF(f_code), RO}, 20 {"f_builtins", T_OBJECT, OFF(f_builtins),RO}, 21 {"f_globals", T_OBJECT, OFF(f_globals), RO}, 22 {"f_lasti", T_INT, OFF(f_lasti), RO}, 23 {NULL} /* Sentinel */ 24 }; 25 26 #define WARN_GET_SET(NAME) \ 27 static PyObject * frame_get_ ## NAME(PyFrameObject *f) { \ 28 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \ 29 return NULL; \ 30 if (f->NAME) { \ 31 Py_INCREF(f->NAME); \ 32 return f->NAME; \ 33 } \ 34 Py_RETURN_NONE; \ 35 } \ 36 static int frame_set_ ## NAME(PyFrameObject *f, PyObject *new) { \ 37 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \ 38 return -1; \ 39 if (f->NAME) { \ 40 Py_CLEAR(f->NAME); \ 41 } \ 42 if (new == Py_None) \ 43 new = NULL; \ 44 Py_XINCREF(new); \ 45 f->NAME = new; \ 46 return 0; \ 47 } 48 49 50 WARN_GET_SET(f_exc_traceback) 51 WARN_GET_SET(f_exc_type) 52 WARN_GET_SET(f_exc_value) 53 54 55 static PyObject * 56 frame_getlocals(PyFrameObject *f, void *closure) 57 { 58 PyFrame_FastToLocals(f); 59 Py_INCREF(f->f_locals); 60 return f->f_locals; 61 } 62 63 int 64 PyFrame_GetLineNumber(PyFrameObject *f) 65 { 66 if (f->f_trace) 67 return f->f_lineno; 68 else 69 return PyCode_Addr2Line(f->f_code, f->f_lasti); 70 } 71 72 static PyObject * 73 frame_getlineno(PyFrameObject *f, void *closure) 74 { 75 return PyInt_FromLong(PyFrame_GetLineNumber(f)); 76 } 77 78 /* Setter for f_lineno - you can set f_lineno from within a trace function in 79 * order to jump to a given line of code, subject to some restrictions. Most 80 * lines are OK to jump to because they don't make any assumptions about the 81 * state of the stack (obvious because you could remove the line and the code 82 * would still work without any stack errors), but there are some constructs 83 * that limit jumping: 84 * 85 * o Lines with an 'except' statement on them can't be jumped to, because 86 * they expect an exception to be on the top of the stack. 87 * o Lines that live in a 'finally' block can't be jumped from or to, since 88 * the END_FINALLY expects to clean up the stack after the 'try' block. 89 * o 'try'/'for'/'while' blocks can't be jumped into because the blockstack 90 * needs to be set up before their code runs, and for 'for' loops the 91 * iterator needs to be on the stack. 92 */ 93 static int 94 frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno) 95 { 96 int new_lineno = 0; /* The new value of f_lineno */ 97 int new_lasti = 0; /* The new value of f_lasti */ 98 int new_iblock = 0; /* The new value of f_iblock */ 99 unsigned char *code = NULL; /* The bytecode for the frame... */ 100 Py_ssize_t code_len = 0; /* ...and its length */ 101 unsigned char *lnotab = NULL; /* Iterating over co_lnotab */ 102 Py_ssize_t lnotab_len = 0; /* (ditto) */ 103 int offset = 0; /* (ditto) */ 104 int line = 0; /* (ditto) */ 105 int addr = 0; /* (ditto) */ 106 int min_addr = 0; /* Scanning the SETUPs and POPs */ 107 int max_addr = 0; /* (ditto) */ 108 int delta_iblock = 0; /* (ditto) */ 109 int min_delta_iblock = 0; /* (ditto) */ 110 int min_iblock = 0; /* (ditto) */ 111 int f_lasti_setup_addr = 0; /* Policing no-jump-into-finally */ 112 int new_lasti_setup_addr = 0; /* (ditto) */ 113 int blockstack[CO_MAXBLOCKS]; /* Walking the 'finally' blocks */ 114 int in_finally[CO_MAXBLOCKS]; /* (ditto) */ 115 int blockstack_top = 0; /* (ditto) */ 116 unsigned char setup_op = 0; /* (ditto) */ 117 118 /* f_lineno must be an integer. */ 119 if (!PyInt_Check(p_new_lineno)) { 120 PyErr_SetString(PyExc_ValueError, 121 "lineno must be an integer"); 122 return -1; 123 } 124 125 /* You can only do this from within a trace function, not via 126 * _getframe or similar hackery. */ 127 if (!f->f_trace) 128 { 129 PyErr_Format(PyExc_ValueError, 130 "f_lineno can only be set by a" 131 " line trace function"); 132 return -1; 133 } 134 135 /* Fail if the line comes before the start of the code block. */ 136 new_lineno = (int) PyInt_AsLong(p_new_lineno); 137 if (new_lineno < f->f_code->co_firstlineno) { 138 PyErr_Format(PyExc_ValueError, 139 "line %d comes before the current code block", 140 new_lineno); 141 return -1; 142 } 143 else if (new_lineno == f->f_code->co_firstlineno) { 144 new_lasti = 0; 145 new_lineno = f->f_code->co_firstlineno; 146 } 147 else { 148 /* Find the bytecode offset for the start of the given 149 * line, or the first code-owning line after it. */ 150 char *tmp; 151 PyString_AsStringAndSize(f->f_code->co_lnotab, 152 &tmp, &lnotab_len); 153 lnotab = (unsigned char *) tmp; 154 addr = 0; 155 line = f->f_code->co_firstlineno; 156 new_lasti = -1; 157 for (offset = 0; offset < lnotab_len; offset += 2) { 158 addr += lnotab[offset]; 159 line += lnotab[offset+1]; 160 if (line >= new_lineno) { 161 new_lasti = addr; 162 new_lineno = line; 163 break; 164 } 165 } 166 } 167 168 /* If we didn't reach the requested line, return an error. */ 169 if (new_lasti == -1) { 170 PyErr_Format(PyExc_ValueError, 171 "line %d comes after the current code block", 172 new_lineno); 173 return -1; 174 } 175 176 /* We're now ready to look at the bytecode. */ 177 PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len); 178 min_addr = MIN(new_lasti, f->f_lasti); 179 max_addr = MAX(new_lasti, f->f_lasti); 180 181 /* You can't jump onto a line with an 'except' statement on it - 182 * they expect to have an exception on the top of the stack, which 183 * won't be true if you jump to them. They always start with code 184 * that either pops the exception using POP_TOP (plain 'except:' 185 * lines do this) or duplicates the exception on the stack using 186 * DUP_TOP (if there's an exception type specified). See compile.c, 187 * 'com_try_except' for the full details. There aren't any other 188 * cases (AFAIK) where a line's code can start with DUP_TOP or 189 * POP_TOP, but if any ever appear, they'll be subject to the same 190 * restriction (but with a different error message). */ 191 if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) { 192 PyErr_SetString(PyExc_ValueError, 193 "can't jump to 'except' line as there's no exception"); 194 return -1; 195 } 196 197 /* You can't jump into or out of a 'finally' block because the 'try' 198 * block leaves something on the stack for the END_FINALLY to clean 199 * up. So we walk the bytecode, maintaining a simulated blockstack. 200 * When we reach the old or new address and it's in a 'finally' block 201 * we note the address of the corresponding SETUP_FINALLY. The jump 202 * is only legal if neither address is in a 'finally' block or 203 * they're both in the same one. 'blockstack' is a stack of the 204 * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks 205 * whether we're in a 'finally' block at each blockstack level. */ 206 f_lasti_setup_addr = -1; 207 new_lasti_setup_addr = -1; 208 memset(blockstack, '\0', sizeof(blockstack)); 209 memset(in_finally, '\0', sizeof(in_finally)); 210 blockstack_top = 0; 211 for (addr = 0; addr < code_len; addr++) { 212 unsigned char op = code[addr]; 213 switch (op) { 214 case SETUP_LOOP: 215 case SETUP_EXCEPT: 216 case SETUP_FINALLY: 217 case SETUP_WITH: 218 blockstack[blockstack_top++] = addr; 219 in_finally[blockstack_top-1] = 0; 220 break; 221 222 case POP_BLOCK: 223 assert(blockstack_top > 0); 224 setup_op = code[blockstack[blockstack_top-1]]; 225 if (setup_op == SETUP_FINALLY || setup_op == SETUP_WITH) { 226 in_finally[blockstack_top-1] = 1; 227 } 228 else { 229 blockstack_top--; 230 } 231 break; 232 233 case END_FINALLY: 234 /* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist 235 * in the bytecode but don't correspond to an actual 236 * 'finally' block. (If blockstack_top is 0, we must 237 * be seeing such an END_FINALLY.) */ 238 if (blockstack_top > 0) { 239 setup_op = code[blockstack[blockstack_top-1]]; 240 if (setup_op == SETUP_FINALLY || setup_op == SETUP_WITH) { 241 blockstack_top--; 242 } 243 } 244 break; 245 } 246 247 /* For the addresses we're interested in, see whether they're 248 * within a 'finally' block and if so, remember the address 249 * of the SETUP_FINALLY. */ 250 if (addr == new_lasti || addr == f->f_lasti) { 251 int i = 0; 252 int setup_addr = -1; 253 for (i = blockstack_top-1; i >= 0; i--) { 254 if (in_finally[i]) { 255 setup_addr = blockstack[i]; 256 break; 257 } 258 } 259 260 if (setup_addr != -1) { 261 if (addr == new_lasti) { 262 new_lasti_setup_addr = setup_addr; 263 } 264 265 if (addr == f->f_lasti) { 266 f_lasti_setup_addr = setup_addr; 267 } 268 } 269 } 270 271 if (op >= HAVE_ARGUMENT) { 272 addr += 2; 273 } 274 } 275 276 /* Verify that the blockstack tracking code didn't get lost. */ 277 assert(blockstack_top == 0); 278 279 /* After all that, are we jumping into / out of a 'finally' block? */ 280 if (new_lasti_setup_addr != f_lasti_setup_addr) { 281 PyErr_SetString(PyExc_ValueError, 282 "can't jump into or out of a 'finally' block"); 283 return -1; 284 } 285 286 287 /* Police block-jumping (you can't jump into the middle of a block) 288 * and ensure that the blockstack finishes up in a sensible state (by 289 * popping any blocks we're jumping out of). We look at all the 290 * blockstack operations between the current position and the new 291 * one, and keep track of how many blocks we drop out of on the way. 292 * By also keeping track of the lowest blockstack position we see, we 293 * can tell whether the jump goes into any blocks without coming out 294 * again - in that case we raise an exception below. */ 295 delta_iblock = 0; 296 for (addr = min_addr; addr < max_addr; addr++) { 297 unsigned char op = code[addr]; 298 switch (op) { 299 case SETUP_LOOP: 300 case SETUP_EXCEPT: 301 case SETUP_FINALLY: 302 case SETUP_WITH: 303 delta_iblock++; 304 break; 305 306 case POP_BLOCK: 307 delta_iblock--; 308 break; 309 } 310 311 min_delta_iblock = MIN(min_delta_iblock, delta_iblock); 312 313 if (op >= HAVE_ARGUMENT) { 314 addr += 2; 315 } 316 } 317 318 /* Derive the absolute iblock values from the deltas. */ 319 min_iblock = f->f_iblock + min_delta_iblock; 320 if (new_lasti > f->f_lasti) { 321 /* Forwards jump. */ 322 new_iblock = f->f_iblock + delta_iblock; 323 } 324 else { 325 /* Backwards jump. */ 326 new_iblock = f->f_iblock - delta_iblock; 327 } 328 329 /* Are we jumping into a block? */ 330 if (new_iblock > min_iblock) { 331 PyErr_SetString(PyExc_ValueError, 332 "can't jump into the middle of a block"); 333 return -1; 334 } 335 336 /* Pop any blocks that we're jumping out of. */ 337 while (f->f_iblock > new_iblock) { 338 PyTryBlock *b = &f->f_blockstack[--f->f_iblock]; 339 while ((f->f_stacktop - f->f_valuestack) > b->b_level) { 340 PyObject *v = (*--f->f_stacktop); 341 Py_DECREF(v); 342 } 343 } 344 345 /* Finally set the new f_lineno and f_lasti and return OK. */ 346 f->f_lineno = new_lineno; 347 f->f_lasti = new_lasti; 348 return 0; 349 } 350 351 static PyObject * 352 frame_gettrace(PyFrameObject *f, void *closure) 353 { 354 PyObject* trace = f->f_trace; 355 356 if (trace == NULL) 357 trace = Py_None; 358 359 Py_INCREF(trace); 360 361 return trace; 362 } 363 364 static int 365 frame_settrace(PyFrameObject *f, PyObject* v, void *closure) 366 { 367 PyObject* old_value; 368 369 /* We rely on f_lineno being accurate when f_trace is set. */ 370 f->f_lineno = PyFrame_GetLineNumber(f); 371 372 old_value = f->f_trace; 373 Py_XINCREF(v); 374 f->f_trace = v; 375 Py_XDECREF(old_value); 376 377 return 0; 378 } 379 380 static PyObject * 381 frame_getrestricted(PyFrameObject *f, void *closure) 382 { 383 return PyBool_FromLong(PyFrame_IsRestricted(f)); 384 } 385 386 static PyGetSetDef frame_getsetlist[] = { 387 {"f_locals", (getter)frame_getlocals, NULL, NULL}, 388 {"f_lineno", (getter)frame_getlineno, 389 (setter)frame_setlineno, NULL}, 390 {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL}, 391 {"f_restricted",(getter)frame_getrestricted,NULL, NULL}, 392 {"f_exc_traceback", (getter)frame_get_f_exc_traceback, 393 (setter)frame_set_f_exc_traceback, NULL}, 394 {"f_exc_type", (getter)frame_get_f_exc_type, 395 (setter)frame_set_f_exc_type, NULL}, 396 {"f_exc_value", (getter)frame_get_f_exc_value, 397 (setter)frame_set_f_exc_value, NULL}, 398 {0} 399 }; 400 401 /* Stack frames are allocated and deallocated at a considerable rate. 402 In an attempt to improve the speed of function calls, we: 403 404 1. Hold a single "zombie" frame on each code object. This retains 405 the allocated and initialised frame object from an invocation of 406 the code object. The zombie is reanimated the next time we need a 407 frame object for that code object. Doing this saves the malloc/ 408 realloc required when using a free_list frame that isn't the 409 correct size. It also saves some field initialisation. 410 411 In zombie mode, no field of PyFrameObject holds a reference, but 412 the following fields are still valid: 413 414 * ob_type, ob_size, f_code, f_valuestack; 415 416 * f_locals, f_trace, 417 f_exc_type, f_exc_value, f_exc_traceback are NULL; 418 419 * f_localsplus does not require re-allocation and 420 the local variables in f_localsplus are NULL. 421 422 2. We also maintain a separate free list of stack frames (just like 423 integers are allocated in a special way -- see intobject.c). When 424 a stack frame is on the free list, only the following members have 425 a meaning: 426 ob_type == &Frametype 427 f_back next item on free list, or NULL 428 f_stacksize size of value stack 429 ob_size size of localsplus 430 Note that the value and block stacks are preserved -- this can save 431 another malloc() call or two (and two free() calls as well!). 432 Also note that, unlike for integers, each frame object is a 433 malloc'ed object in its own right -- it is only the actual calls to 434 malloc() that we are trying to save here, not the administration. 435 After all, while a typical program may make millions of calls, a 436 call depth of more than 20 or 30 is probably already exceptional 437 unless the program contains run-away recursion. I hope. 438 439 Later, PyFrame_MAXFREELIST was added to bound the # of frames saved on 440 free_list. Else programs creating lots of cyclic trash involving 441 frames could provoke free_list into growing without bound. 442 */ 443 444 static PyFrameObject *free_list = NULL; 445 static int numfree = 0; /* number of frames currently in free_list */ 446 /* max value for numfree */ 447 #define PyFrame_MAXFREELIST 200 448 449 static void 450 frame_dealloc(PyFrameObject *f) 451 { 452 PyObject **p, **valuestack; 453 PyCodeObject *co; 454 455 PyObject_GC_UnTrack(f); 456 Py_TRASHCAN_SAFE_BEGIN(f) 457 /* Kill all local variables */ 458 valuestack = f->f_valuestack; 459 for (p = f->f_localsplus; p < valuestack; p++) 460 Py_CLEAR(*p); 461 462 /* Free stack */ 463 if (f->f_stacktop != NULL) { 464 for (p = valuestack; p < f->f_stacktop; p++) 465 Py_XDECREF(*p); 466 } 467 468 Py_XDECREF(f->f_back); 469 Py_DECREF(f->f_builtins); 470 Py_DECREF(f->f_globals); 471 Py_CLEAR(f->f_locals); 472 Py_CLEAR(f->f_trace); 473 Py_CLEAR(f->f_exc_type); 474 Py_CLEAR(f->f_exc_value); 475 Py_CLEAR(f->f_exc_traceback); 476 477 co = f->f_code; 478 if (co->co_zombieframe == NULL) 479 co->co_zombieframe = f; 480 else if (numfree < PyFrame_MAXFREELIST) { 481 ++numfree; 482 f->f_back = free_list; 483 free_list = f; 484 } 485 else 486 PyObject_GC_Del(f); 487 488 Py_DECREF(co); 489 Py_TRASHCAN_SAFE_END(f) 490 } 491 492 static int 493 frame_traverse(PyFrameObject *f, visitproc visit, void *arg) 494 { 495 PyObject **fastlocals, **p; 496 int i, slots; 497 498 Py_VISIT(f->f_back); 499 Py_VISIT(f->f_code); 500 Py_VISIT(f->f_builtins); 501 Py_VISIT(f->f_globals); 502 Py_VISIT(f->f_locals); 503 Py_VISIT(f->f_trace); 504 Py_VISIT(f->f_exc_type); 505 Py_VISIT(f->f_exc_value); 506 Py_VISIT(f->f_exc_traceback); 507 508 /* locals */ 509 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars); 510 fastlocals = f->f_localsplus; 511 for (i = slots; --i >= 0; ++fastlocals) 512 Py_VISIT(*fastlocals); 513 514 /* stack */ 515 if (f->f_stacktop != NULL) { 516 for (p = f->f_valuestack; p < f->f_stacktop; p++) 517 Py_VISIT(*p); 518 } 519 return 0; 520 } 521 522 static void 523 frame_clear(PyFrameObject *f) 524 { 525 PyObject **fastlocals, **p, **oldtop; 526 int i, slots; 527 528 /* Before anything else, make sure that this frame is clearly marked 529 * as being defunct! Else, e.g., a generator reachable from this 530 * frame may also point to this frame, believe itself to still be 531 * active, and try cleaning up this frame again. 532 */ 533 oldtop = f->f_stacktop; 534 f->f_stacktop = NULL; 535 536 Py_CLEAR(f->f_exc_type); 537 Py_CLEAR(f->f_exc_value); 538 Py_CLEAR(f->f_exc_traceback); 539 Py_CLEAR(f->f_trace); 540 541 /* locals */ 542 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars); 543 fastlocals = f->f_localsplus; 544 for (i = slots; --i >= 0; ++fastlocals) 545 Py_CLEAR(*fastlocals); 546 547 /* stack */ 548 if (oldtop != NULL) { 549 for (p = f->f_valuestack; p < oldtop; p++) 550 Py_CLEAR(*p); 551 } 552 } 553 554 static PyObject * 555 frame_sizeof(PyFrameObject *f) 556 { 557 Py_ssize_t res, extras, ncells, nfrees; 558 559 ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars); 560 nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars); 561 extras = f->f_code->co_stacksize + f->f_code->co_nlocals + 562 ncells + nfrees; 563 /* subtract one as it is already included in PyFrameObject */ 564 res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *); 565 566 return PyInt_FromSsize_t(res); 567 } 568 569 PyDoc_STRVAR(sizeof__doc__, 570 "F.__sizeof__() -> size of F in memory, in bytes"); 571 572 static PyMethodDef frame_methods[] = { 573 {"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS, 574 sizeof__doc__}, 575 {NULL, NULL} /* sentinel */ 576 }; 577 578 PyTypeObject PyFrame_Type = { 579 PyVarObject_HEAD_INIT(&PyType_Type, 0) 580 "frame", 581 sizeof(PyFrameObject), 582 sizeof(PyObject *), 583 (destructor)frame_dealloc, /* tp_dealloc */ 584 0, /* tp_print */ 585 0, /* tp_getattr */ 586 0, /* tp_setattr */ 587 0, /* tp_compare */ 588 0, /* tp_repr */ 589 0, /* tp_as_number */ 590 0, /* tp_as_sequence */ 591 0, /* tp_as_mapping */ 592 0, /* tp_hash */ 593 0, /* tp_call */ 594 0, /* tp_str */ 595 PyObject_GenericGetAttr, /* tp_getattro */ 596 PyObject_GenericSetAttr, /* tp_setattro */ 597 0, /* tp_as_buffer */ 598 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 599 0, /* tp_doc */ 600 (traverseproc)frame_traverse, /* tp_traverse */ 601 (inquiry)frame_clear, /* tp_clear */ 602 0, /* tp_richcompare */ 603 0, /* tp_weaklistoffset */ 604 0, /* tp_iter */ 605 0, /* tp_iternext */ 606 frame_methods, /* tp_methods */ 607 frame_memberlist, /* tp_members */ 608 frame_getsetlist, /* tp_getset */ 609 0, /* tp_base */ 610 0, /* tp_dict */ 611 }; 612 613 static PyObject *builtin_object; 614 615 int _PyFrame_Init() 616 { 617 builtin_object = PyString_InternFromString("__builtins__"); 618 if (builtin_object == NULL) 619 return 0; 620 return 1; 621 } 622 623 PyFrameObject * 624 PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, 625 PyObject *locals) 626 { 627 PyFrameObject *back = tstate->frame; 628 PyFrameObject *f; 629 PyObject *builtins; 630 Py_ssize_t i; 631 632 #ifdef Py_DEBUG 633 if (code == NULL || globals == NULL || !PyDict_Check(globals) || 634 (locals != NULL && !PyMapping_Check(locals))) { 635 PyErr_BadInternalCall(); 636 return NULL; 637 } 638 #endif 639 if (back == NULL || back->f_globals != globals) { 640 builtins = PyDict_GetItem(globals, builtin_object); 641 if (builtins) { 642 if (PyModule_Check(builtins)) { 643 builtins = PyModule_GetDict(builtins); 644 assert(!builtins || PyDict_Check(builtins)); 645 } 646 else if (!PyDict_Check(builtins)) 647 builtins = NULL; 648 } 649 if (builtins == NULL) { 650 /* No builtins! Make up a minimal one 651 Give them 'None', at least. */ 652 builtins = PyDict_New(); 653 if (builtins == NULL || 654 PyDict_SetItemString( 655 builtins, "None", Py_None) < 0) 656 return NULL; 657 } 658 else 659 Py_INCREF(builtins); 660 661 } 662 else { 663 /* If we share the globals, we share the builtins. 664 Save a lookup and a call. */ 665 builtins = back->f_builtins; 666 assert(builtins != NULL && PyDict_Check(builtins)); 667 Py_INCREF(builtins); 668 } 669 if (code->co_zombieframe != NULL) { 670 f = code->co_zombieframe; 671 code->co_zombieframe = NULL; 672 _Py_NewReference((PyObject *)f); 673 assert(f->f_code == code); 674 } 675 else { 676 Py_ssize_t extras, ncells, nfrees; 677 ncells = PyTuple_GET_SIZE(code->co_cellvars); 678 nfrees = PyTuple_GET_SIZE(code->co_freevars); 679 extras = code->co_stacksize + code->co_nlocals + ncells + 680 nfrees; 681 if (free_list == NULL) { 682 f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, 683 extras); 684 if (f == NULL) { 685 Py_DECREF(builtins); 686 return NULL; 687 } 688 } 689 else { 690 assert(numfree > 0); 691 --numfree; 692 f = free_list; 693 free_list = free_list->f_back; 694 if (Py_SIZE(f) < extras) { 695 f = PyObject_GC_Resize(PyFrameObject, f, extras); 696 if (f == NULL) { 697 Py_DECREF(builtins); 698 return NULL; 699 } 700 } 701 _Py_NewReference((PyObject *)f); 702 } 703 704 f->f_code = code; 705 extras = code->co_nlocals + ncells + nfrees; 706 f->f_valuestack = f->f_localsplus + extras; 707 for (i=0; i<extras; i++) 708 f->f_localsplus[i] = NULL; 709 f->f_locals = NULL; 710 f->f_trace = NULL; 711 f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL; 712 } 713 f->f_stacktop = f->f_valuestack; 714 f->f_builtins = builtins; 715 Py_XINCREF(back); 716 f->f_back = back; 717 Py_INCREF(code); 718 Py_INCREF(globals); 719 f->f_globals = globals; 720 /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */ 721 if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) == 722 (CO_NEWLOCALS | CO_OPTIMIZED)) 723 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */ 724 else if (code->co_flags & CO_NEWLOCALS) { 725 locals = PyDict_New(); 726 if (locals == NULL) { 727 Py_DECREF(f); 728 return NULL; 729 } 730 f->f_locals = locals; 731 } 732 else { 733 if (locals == NULL) 734 locals = globals; 735 Py_INCREF(locals); 736 f->f_locals = locals; 737 } 738 f->f_tstate = tstate; 739 740 f->f_lasti = -1; 741 f->f_lineno = code->co_firstlineno; 742 f->f_iblock = 0; 743 744 _PyObject_GC_TRACK(f); 745 return f; 746 } 747 748 /* Block management */ 749 750 void 751 PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level) 752 { 753 PyTryBlock *b; 754 if (f->f_iblock >= CO_MAXBLOCKS) 755 Py_FatalError("XXX block stack overflow"); 756 b = &f->f_blockstack[f->f_iblock++]; 757 b->b_type = type; 758 b->b_level = level; 759 b->b_handler = handler; 760 } 761 762 PyTryBlock * 763 PyFrame_BlockPop(PyFrameObject *f) 764 { 765 PyTryBlock *b; 766 if (f->f_iblock <= 0) 767 Py_FatalError("XXX block stack underflow"); 768 b = &f->f_blockstack[--f->f_iblock]; 769 return b; 770 } 771 772 /* Convert between "fast" version of locals and dictionary version. 773 774 map and values are input arguments. map is a tuple of strings. 775 values is an array of PyObject*. At index i, map[i] is the name of 776 the variable with value values[i]. The function copies the first 777 nmap variable from map/values into dict. If values[i] is NULL, 778 the variable is deleted from dict. 779 780 If deref is true, then the values being copied are cell variables 781 and the value is extracted from the cell variable before being put 782 in dict. 783 784 Exceptions raised while modifying the dict are silently ignored, 785 because there is no good way to report them. 786 */ 787 788 static void 789 map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, 790 int deref) 791 { 792 Py_ssize_t j; 793 assert(PyTuple_Check(map)); 794 assert(PyDict_Check(dict)); 795 assert(PyTuple_Size(map) >= nmap); 796 for (j = nmap; --j >= 0; ) { 797 PyObject *key = PyTuple_GET_ITEM(map, j); 798 PyObject *value = values[j]; 799 assert(PyString_Check(key)); 800 if (deref) { 801 assert(PyCell_Check(value)); 802 value = PyCell_GET(value); 803 } 804 if (value == NULL) { 805 if (PyObject_DelItem(dict, key) != 0) 806 PyErr_Clear(); 807 } 808 else { 809 if (PyObject_SetItem(dict, key, value) != 0) 810 PyErr_Clear(); 811 } 812 } 813 } 814 815 /* Copy values from the "locals" dict into the fast locals. 816 817 dict is an input argument containing string keys representing 818 variables names and arbitrary PyObject* as values. 819 820 map and values are input arguments. map is a tuple of strings. 821 values is an array of PyObject*. At index i, map[i] is the name of 822 the variable with value values[i]. The function copies the first 823 nmap variable from map/values into dict. If values[i] is NULL, 824 the variable is deleted from dict. 825 826 If deref is true, then the values being copied are cell variables 827 and the value is extracted from the cell variable before being put 828 in dict. If clear is true, then variables in map but not in dict 829 are set to NULL in map; if clear is false, variables missing in 830 dict are ignored. 831 832 Exceptions raised while modifying the dict are silently ignored, 833 because there is no good way to report them. 834 */ 835 836 static void 837 dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, 838 int deref, int clear) 839 { 840 Py_ssize_t j; 841 assert(PyTuple_Check(map)); 842 assert(PyDict_Check(dict)); 843 assert(PyTuple_Size(map) >= nmap); 844 for (j = nmap; --j >= 0; ) { 845 PyObject *key = PyTuple_GET_ITEM(map, j); 846 PyObject *value = PyObject_GetItem(dict, key); 847 assert(PyString_Check(key)); 848 /* We only care about NULLs if clear is true. */ 849 if (value == NULL) { 850 PyErr_Clear(); 851 if (!clear) 852 continue; 853 } 854 if (deref) { 855 assert(PyCell_Check(values[j])); 856 if (PyCell_GET(values[j]) != value) { 857 if (PyCell_Set(values[j], value) < 0) 858 PyErr_Clear(); 859 } 860 } else if (values[j] != value) { 861 Py_XINCREF(value); 862 Py_XDECREF(values[j]); 863 values[j] = value; 864 } 865 Py_XDECREF(value); 866 } 867 } 868 869 void 870 PyFrame_FastToLocals(PyFrameObject *f) 871 { 872 /* Merge fast locals into f->f_locals */ 873 PyObject *locals, *map; 874 PyObject **fast; 875 PyObject *error_type, *error_value, *error_traceback; 876 PyCodeObject *co; 877 Py_ssize_t j; 878 int ncells, nfreevars; 879 if (f == NULL) 880 return; 881 locals = f->f_locals; 882 if (locals == NULL) { 883 locals = f->f_locals = PyDict_New(); 884 if (locals == NULL) { 885 PyErr_Clear(); /* Can't report it :-( */ 886 return; 887 } 888 } 889 co = f->f_code; 890 map = co->co_varnames; 891 if (!PyTuple_Check(map)) 892 return; 893 PyErr_Fetch(&error_type, &error_value, &error_traceback); 894 fast = f->f_localsplus; 895 j = PyTuple_GET_SIZE(map); 896 if (j > co->co_nlocals) 897 j = co->co_nlocals; 898 if (co->co_nlocals) 899 map_to_dict(map, j, locals, fast, 0); 900 ncells = PyTuple_GET_SIZE(co->co_cellvars); 901 nfreevars = PyTuple_GET_SIZE(co->co_freevars); 902 if (ncells || nfreevars) { 903 map_to_dict(co->co_cellvars, ncells, 904 locals, fast + co->co_nlocals, 1); 905 /* If the namespace is unoptimized, then one of the 906 following cases applies: 907 1. It does not contain free variables, because it 908 uses import * or is a top-level namespace. 909 2. It is a class namespace. 910 We don't want to accidentally copy free variables 911 into the locals dict used by the class. 912 */ 913 if (co->co_flags & CO_OPTIMIZED) { 914 map_to_dict(co->co_freevars, nfreevars, 915 locals, fast + co->co_nlocals + ncells, 1); 916 } 917 } 918 PyErr_Restore(error_type, error_value, error_traceback); 919 } 920 921 void 922 PyFrame_LocalsToFast(PyFrameObject *f, int clear) 923 { 924 /* Merge f->f_locals into fast locals */ 925 PyObject *locals, *map; 926 PyObject **fast; 927 PyObject *error_type, *error_value, *error_traceback; 928 PyCodeObject *co; 929 Py_ssize_t j; 930 int ncells, nfreevars; 931 if (f == NULL) 932 return; 933 locals = f->f_locals; 934 co = f->f_code; 935 map = co->co_varnames; 936 if (locals == NULL) 937 return; 938 if (!PyTuple_Check(map)) 939 return; 940 PyErr_Fetch(&error_type, &error_value, &error_traceback); 941 fast = f->f_localsplus; 942 j = PyTuple_GET_SIZE(map); 943 if (j > co->co_nlocals) 944 j = co->co_nlocals; 945 if (co->co_nlocals) 946 dict_to_map(co->co_varnames, j, locals, fast, 0, clear); 947 ncells = PyTuple_GET_SIZE(co->co_cellvars); 948 nfreevars = PyTuple_GET_SIZE(co->co_freevars); 949 if (ncells || nfreevars) { 950 dict_to_map(co->co_cellvars, ncells, 951 locals, fast + co->co_nlocals, 1, clear); 952 /* Same test as in PyFrame_FastToLocals() above. */ 953 if (co->co_flags & CO_OPTIMIZED) { 954 dict_to_map(co->co_freevars, nfreevars, 955 locals, fast + co->co_nlocals + ncells, 1, 956 clear); 957 } 958 } 959 PyErr_Restore(error_type, error_value, error_traceback); 960 } 961 962 /* Clear out the free list */ 963 int 964 PyFrame_ClearFreeList(void) 965 { 966 int freelist_size = numfree; 967 968 while (free_list != NULL) { 969 PyFrameObject *f = free_list; 970 free_list = free_list->f_back; 971 PyObject_GC_Del(f); 972 --numfree; 973 } 974 assert(numfree == 0); 975 return freelist_size; 976 } 977 978 void 979 PyFrame_Fini(void) 980 { 981 (void)PyFrame_ClearFreeList(); 982 Py_XDECREF(builtin_object); 983 builtin_object = NULL; 984 } 985
