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 /* We rely on f_lineno being accurate when f_trace is set. */ 368 f->f_lineno = PyFrame_GetLineNumber(f); 369 370 if (v == Py_None) 371 v = NULL; 372 Py_XINCREF(v); 373 Py_XSETREF(f->f_trace, v); 374 375 return 0; 376 } 377 378 static PyObject * 379 frame_getrestricted(PyFrameObject *f, void *closure) 380 { 381 return PyBool_FromLong(PyFrame_IsRestricted(f)); 382 } 383 384 static PyGetSetDef frame_getsetlist[] = { 385 {"f_locals", (getter)frame_getlocals, NULL, NULL}, 386 {"f_lineno", (getter)frame_getlineno, 387 (setter)frame_setlineno, NULL}, 388 {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL}, 389 {"f_restricted",(getter)frame_getrestricted,NULL, NULL}, 390 {"f_exc_traceback", (getter)frame_get_f_exc_traceback, 391 (setter)frame_set_f_exc_traceback, NULL}, 392 {"f_exc_type", (getter)frame_get_f_exc_type, 393 (setter)frame_set_f_exc_type, NULL}, 394 {"f_exc_value", (getter)frame_get_f_exc_value, 395 (setter)frame_set_f_exc_value, NULL}, 396 {0} 397 }; 398 399 /* Stack frames are allocated and deallocated at a considerable rate. 400 In an attempt to improve the speed of function calls, we: 401 402 1. Hold a single "zombie" frame on each code object. This retains 403 the allocated and initialised frame object from an invocation of 404 the code object. The zombie is reanimated the next time we need a 405 frame object for that code object. Doing this saves the malloc/ 406 realloc required when using a free_list frame that isn't the 407 correct size. It also saves some field initialisation. 408 409 In zombie mode, no field of PyFrameObject holds a reference, but 410 the following fields are still valid: 411 412 * ob_type, ob_size, f_code, f_valuestack; 413 414 * f_locals, f_trace, 415 f_exc_type, f_exc_value, f_exc_traceback are NULL; 416 417 * f_localsplus does not require re-allocation and 418 the local variables in f_localsplus are NULL. 419 420 2. We also maintain a separate free list of stack frames (just like 421 integers are allocated in a special way -- see intobject.c). When 422 a stack frame is on the free list, only the following members have 423 a meaning: 424 ob_type == &Frametype 425 f_back next item on free list, or NULL 426 f_stacksize size of value stack 427 ob_size size of localsplus 428 Note that the value and block stacks are preserved -- this can save 429 another malloc() call or two (and two free() calls as well!). 430 Also note that, unlike for integers, each frame object is a 431 malloc'ed object in its own right -- it is only the actual calls to 432 malloc() that we are trying to save here, not the administration. 433 After all, while a typical program may make millions of calls, a 434 call depth of more than 20 or 30 is probably already exceptional 435 unless the program contains run-away recursion. I hope. 436 437 Later, PyFrame_MAXFREELIST was added to bound the # of frames saved on 438 free_list. Else programs creating lots of cyclic trash involving 439 frames could provoke free_list into growing without bound. 440 */ 441 442 static PyFrameObject *free_list = NULL; 443 static int numfree = 0; /* number of frames currently in free_list */ 444 /* max value for numfree */ 445 #define PyFrame_MAXFREELIST 200 446 447 static void 448 frame_dealloc(PyFrameObject *f) 449 { 450 PyObject **p, **valuestack; 451 PyCodeObject *co; 452 453 PyObject_GC_UnTrack(f); 454 Py_TRASHCAN_SAFE_BEGIN(f) 455 /* Kill all local variables */ 456 valuestack = f->f_valuestack; 457 for (p = f->f_localsplus; p < valuestack; p++) 458 Py_CLEAR(*p); 459 460 /* Free stack */ 461 if (f->f_stacktop != NULL) { 462 for (p = valuestack; p < f->f_stacktop; p++) 463 Py_XDECREF(*p); 464 } 465 466 Py_XDECREF(f->f_back); 467 Py_DECREF(f->f_builtins); 468 Py_DECREF(f->f_globals); 469 Py_CLEAR(f->f_locals); 470 Py_CLEAR(f->f_trace); 471 Py_CLEAR(f->f_exc_type); 472 Py_CLEAR(f->f_exc_value); 473 Py_CLEAR(f->f_exc_traceback); 474 475 co = f->f_code; 476 if (co->co_zombieframe == NULL) 477 co->co_zombieframe = f; 478 else if (numfree < PyFrame_MAXFREELIST) { 479 ++numfree; 480 f->f_back = free_list; 481 free_list = f; 482 } 483 else 484 PyObject_GC_Del(f); 485 486 Py_DECREF(co); 487 Py_TRASHCAN_SAFE_END(f) 488 } 489 490 static int 491 frame_traverse(PyFrameObject *f, visitproc visit, void *arg) 492 { 493 PyObject **fastlocals, **p; 494 int i, slots; 495 496 Py_VISIT(f->f_back); 497 Py_VISIT(f->f_code); 498 Py_VISIT(f->f_builtins); 499 Py_VISIT(f->f_globals); 500 Py_VISIT(f->f_locals); 501 Py_VISIT(f->f_trace); 502 Py_VISIT(f->f_exc_type); 503 Py_VISIT(f->f_exc_value); 504 Py_VISIT(f->f_exc_traceback); 505 506 /* locals */ 507 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars); 508 fastlocals = f->f_localsplus; 509 for (i = slots; --i >= 0; ++fastlocals) 510 Py_VISIT(*fastlocals); 511 512 /* stack */ 513 if (f->f_stacktop != NULL) { 514 for (p = f->f_valuestack; p < f->f_stacktop; p++) 515 Py_VISIT(*p); 516 } 517 return 0; 518 } 519 520 static void 521 frame_clear(PyFrameObject *f) 522 { 523 PyObject **fastlocals, **p, **oldtop; 524 int i, slots; 525 526 /* Before anything else, make sure that this frame is clearly marked 527 * as being defunct! Else, e.g., a generator reachable from this 528 * frame may also point to this frame, believe itself to still be 529 * active, and try cleaning up this frame again. 530 */ 531 oldtop = f->f_stacktop; 532 f->f_stacktop = NULL; 533 534 Py_CLEAR(f->f_exc_type); 535 Py_CLEAR(f->f_exc_value); 536 Py_CLEAR(f->f_exc_traceback); 537 Py_CLEAR(f->f_trace); 538 539 /* locals */ 540 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars); 541 fastlocals = f->f_localsplus; 542 for (i = slots; --i >= 0; ++fastlocals) 543 Py_CLEAR(*fastlocals); 544 545 /* stack */ 546 if (oldtop != NULL) { 547 for (p = f->f_valuestack; p < oldtop; p++) 548 Py_CLEAR(*p); 549 } 550 } 551 552 static PyObject * 553 frame_sizeof(PyFrameObject *f) 554 { 555 Py_ssize_t res, extras, ncells, nfrees; 556 557 ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars); 558 nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars); 559 extras = f->f_code->co_stacksize + f->f_code->co_nlocals + 560 ncells + nfrees; 561 /* subtract one as it is already included in PyFrameObject */ 562 res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *); 563 564 return PyInt_FromSsize_t(res); 565 } 566 567 PyDoc_STRVAR(sizeof__doc__, 568 "F.__sizeof__() -> size of F in memory, in bytes"); 569 570 static PyMethodDef frame_methods[] = { 571 {"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS, 572 sizeof__doc__}, 573 {NULL, NULL} /* sentinel */ 574 }; 575 576 PyTypeObject PyFrame_Type = { 577 PyVarObject_HEAD_INIT(&PyType_Type, 0) 578 "frame", 579 sizeof(PyFrameObject), 580 sizeof(PyObject *), 581 (destructor)frame_dealloc, /* tp_dealloc */ 582 0, /* tp_print */ 583 0, /* tp_getattr */ 584 0, /* tp_setattr */ 585 0, /* tp_compare */ 586 0, /* tp_repr */ 587 0, /* tp_as_number */ 588 0, /* tp_as_sequence */ 589 0, /* tp_as_mapping */ 590 0, /* tp_hash */ 591 0, /* tp_call */ 592 0, /* tp_str */ 593 PyObject_GenericGetAttr, /* tp_getattro */ 594 PyObject_GenericSetAttr, /* tp_setattro */ 595 0, /* tp_as_buffer */ 596 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 597 0, /* tp_doc */ 598 (traverseproc)frame_traverse, /* tp_traverse */ 599 (inquiry)frame_clear, /* tp_clear */ 600 0, /* tp_richcompare */ 601 0, /* tp_weaklistoffset */ 602 0, /* tp_iter */ 603 0, /* tp_iternext */ 604 frame_methods, /* tp_methods */ 605 frame_memberlist, /* tp_members */ 606 frame_getsetlist, /* tp_getset */ 607 0, /* tp_base */ 608 0, /* tp_dict */ 609 }; 610 611 static PyObject *builtin_object; 612 613 int _PyFrame_Init() 614 { 615 builtin_object = PyString_InternFromString("__builtins__"); 616 if (builtin_object == NULL) 617 return 0; 618 return 1; 619 } 620 621 PyFrameObject * 622 PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, 623 PyObject *locals) 624 { 625 PyFrameObject *back = tstate->frame; 626 PyFrameObject *f; 627 PyObject *builtins; 628 Py_ssize_t i; 629 630 #ifdef Py_DEBUG 631 if (code == NULL || globals == NULL || !PyDict_Check(globals) || 632 (locals != NULL && !PyMapping_Check(locals))) { 633 PyErr_BadInternalCall(); 634 return NULL; 635 } 636 #endif 637 if (back == NULL || back->f_globals != globals) { 638 builtins = PyDict_GetItem(globals, builtin_object); 639 if (builtins) { 640 if (PyModule_Check(builtins)) { 641 builtins = PyModule_GetDict(builtins); 642 assert(!builtins || PyDict_Check(builtins)); 643 } 644 else if (!PyDict_Check(builtins)) 645 builtins = NULL; 646 } 647 if (builtins == NULL) { 648 /* No builtins! Make up a minimal one 649 Give them 'None', at least. */ 650 builtins = PyDict_New(); 651 if (builtins == NULL || 652 PyDict_SetItemString( 653 builtins, "None", Py_None) < 0) 654 return NULL; 655 } 656 else 657 Py_INCREF(builtins); 658 659 } 660 else { 661 /* If we share the globals, we share the builtins. 662 Save a lookup and a call. */ 663 builtins = back->f_builtins; 664 assert(builtins != NULL && PyDict_Check(builtins)); 665 Py_INCREF(builtins); 666 } 667 if (code->co_zombieframe != NULL) { 668 f = code->co_zombieframe; 669 code->co_zombieframe = NULL; 670 _Py_NewReference((PyObject *)f); 671 assert(f->f_code == code); 672 } 673 else { 674 Py_ssize_t extras, ncells, nfrees; 675 ncells = PyTuple_GET_SIZE(code->co_cellvars); 676 nfrees = PyTuple_GET_SIZE(code->co_freevars); 677 extras = code->co_stacksize + code->co_nlocals + ncells + 678 nfrees; 679 if (free_list == NULL) { 680 f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, 681 extras); 682 if (f == NULL) { 683 Py_DECREF(builtins); 684 return NULL; 685 } 686 } 687 else { 688 assert(numfree > 0); 689 --numfree; 690 f = free_list; 691 free_list = free_list->f_back; 692 if (Py_SIZE(f) < extras) { 693 f = PyObject_GC_Resize(PyFrameObject, f, extras); 694 if (f == NULL) { 695 Py_DECREF(builtins); 696 return NULL; 697 } 698 } 699 _Py_NewReference((PyObject *)f); 700 } 701 702 f->f_code = code; 703 extras = code->co_nlocals + ncells + nfrees; 704 f->f_valuestack = f->f_localsplus + extras; 705 for (i=0; i<extras; i++) 706 f->f_localsplus[i] = NULL; 707 f->f_locals = NULL; 708 f->f_trace = NULL; 709 f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL; 710 } 711 f->f_stacktop = f->f_valuestack; 712 f->f_builtins = builtins; 713 Py_XINCREF(back); 714 f->f_back = back; 715 Py_INCREF(code); 716 Py_INCREF(globals); 717 f->f_globals = globals; 718 /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */ 719 if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) == 720 (CO_NEWLOCALS | CO_OPTIMIZED)) 721 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */ 722 else if (code->co_flags & CO_NEWLOCALS) { 723 locals = PyDict_New(); 724 if (locals == NULL) { 725 Py_DECREF(f); 726 return NULL; 727 } 728 f->f_locals = locals; 729 } 730 else { 731 if (locals == NULL) 732 locals = globals; 733 Py_INCREF(locals); 734 f->f_locals = locals; 735 } 736 f->f_tstate = tstate; 737 738 f->f_lasti = -1; 739 f->f_lineno = code->co_firstlineno; 740 f->f_iblock = 0; 741 742 _PyObject_GC_TRACK(f); 743 return f; 744 } 745 746 /* Block management */ 747 748 void 749 PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level) 750 { 751 PyTryBlock *b; 752 if (f->f_iblock >= CO_MAXBLOCKS) 753 Py_FatalError("XXX block stack overflow"); 754 b = &f->f_blockstack[f->f_iblock++]; 755 b->b_type = type; 756 b->b_level = level; 757 b->b_handler = handler; 758 } 759 760 PyTryBlock * 761 PyFrame_BlockPop(PyFrameObject *f) 762 { 763 PyTryBlock *b; 764 if (f->f_iblock <= 0) 765 Py_FatalError("XXX block stack underflow"); 766 b = &f->f_blockstack[--f->f_iblock]; 767 return b; 768 } 769 770 /* Convert between "fast" version of locals and dictionary version. 771 772 map and values are input arguments. map is a tuple of strings. 773 values is an array of PyObject*. At index i, map[i] is the name of 774 the variable with value values[i]. The function copies the first 775 nmap variable from map/values into dict. If values[i] is NULL, 776 the variable is deleted from dict. 777 778 If deref is true, then the values being copied are cell variables 779 and the value is extracted from the cell variable before being put 780 in dict. 781 782 Exceptions raised while modifying the dict are silently ignored, 783 because there is no good way to report them. 784 */ 785 786 static void 787 map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, 788 int deref) 789 { 790 Py_ssize_t j; 791 assert(PyTuple_Check(map)); 792 assert(PyDict_Check(dict)); 793 assert(PyTuple_Size(map) >= nmap); 794 for (j = nmap; --j >= 0; ) { 795 PyObject *key = PyTuple_GET_ITEM(map, j); 796 PyObject *value = values[j]; 797 assert(PyString_Check(key)); 798 if (deref) { 799 assert(PyCell_Check(value)); 800 value = PyCell_GET(value); 801 } 802 if (value == NULL) { 803 if (PyObject_DelItem(dict, key) != 0) 804 PyErr_Clear(); 805 } 806 else { 807 if (PyObject_SetItem(dict, key, value) != 0) 808 PyErr_Clear(); 809 } 810 } 811 } 812 813 /* Copy values from the "locals" dict into the fast locals. 814 815 dict is an input argument containing string keys representing 816 variables names and arbitrary PyObject* as values. 817 818 map and values are input arguments. map is a tuple of strings. 819 values is an array of PyObject*. At index i, map[i] is the name of 820 the variable with value values[i]. The function copies the first 821 nmap variable from map/values into dict. If values[i] is NULL, 822 the variable is deleted from dict. 823 824 If deref is true, then the values being copied are cell variables 825 and the value is extracted from the cell variable before being put 826 in dict. If clear is true, then variables in map but not in dict 827 are set to NULL in map; if clear is false, variables missing in 828 dict are ignored. 829 830 Exceptions raised while modifying the dict are silently ignored, 831 because there is no good way to report them. 832 */ 833 834 static void 835 dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, 836 int deref, int clear) 837 { 838 Py_ssize_t j; 839 assert(PyTuple_Check(map)); 840 assert(PyDict_Check(dict)); 841 assert(PyTuple_Size(map) >= nmap); 842 for (j = nmap; --j >= 0; ) { 843 PyObject *key = PyTuple_GET_ITEM(map, j); 844 PyObject *value = PyObject_GetItem(dict, key); 845 assert(PyString_Check(key)); 846 /* We only care about NULLs if clear is true. */ 847 if (value == NULL) { 848 PyErr_Clear(); 849 if (!clear) 850 continue; 851 } 852 if (deref) { 853 assert(PyCell_Check(values[j])); 854 if (PyCell_GET(values[j]) != value) { 855 if (PyCell_Set(values[j], value) < 0) 856 PyErr_Clear(); 857 } 858 } else if (values[j] != value) { 859 Py_XINCREF(value); 860 Py_XSETREF(values[j], value); 861 } 862 Py_XDECREF(value); 863 } 864 } 865 866 void 867 PyFrame_FastToLocals(PyFrameObject *f) 868 { 869 /* Merge fast locals into f->f_locals */ 870 PyObject *locals, *map; 871 PyObject **fast; 872 PyObject *error_type, *error_value, *error_traceback; 873 PyCodeObject *co; 874 Py_ssize_t j; 875 int ncells, nfreevars; 876 if (f == NULL) 877 return; 878 locals = f->f_locals; 879 if (locals == NULL) { 880 locals = f->f_locals = PyDict_New(); 881 if (locals == NULL) { 882 PyErr_Clear(); /* Can't report it :-( */ 883 return; 884 } 885 } 886 co = f->f_code; 887 map = co->co_varnames; 888 if (!PyTuple_Check(map)) 889 return; 890 PyErr_Fetch(&error_type, &error_value, &error_traceback); 891 fast = f->f_localsplus; 892 j = PyTuple_GET_SIZE(map); 893 if (j > co->co_nlocals) 894 j = co->co_nlocals; 895 if (co->co_nlocals) 896 map_to_dict(map, j, locals, fast, 0); 897 ncells = PyTuple_GET_SIZE(co->co_cellvars); 898 nfreevars = PyTuple_GET_SIZE(co->co_freevars); 899 if (ncells || nfreevars) { 900 map_to_dict(co->co_cellvars, ncells, 901 locals, fast + co->co_nlocals, 1); 902 /* If the namespace is unoptimized, then one of the 903 following cases applies: 904 1. It does not contain free variables, because it 905 uses import * or is a top-level namespace. 906 2. It is a class namespace. 907 We don't want to accidentally copy free variables 908 into the locals dict used by the class. 909 */ 910 if (co->co_flags & CO_OPTIMIZED) { 911 map_to_dict(co->co_freevars, nfreevars, 912 locals, fast + co->co_nlocals + ncells, 1); 913 } 914 } 915 PyErr_Restore(error_type, error_value, error_traceback); 916 } 917 918 void 919 PyFrame_LocalsToFast(PyFrameObject *f, int clear) 920 { 921 /* Merge f->f_locals into fast locals */ 922 PyObject *locals, *map; 923 PyObject **fast; 924 PyObject *error_type, *error_value, *error_traceback; 925 PyCodeObject *co; 926 Py_ssize_t j; 927 int ncells, nfreevars; 928 if (f == NULL) 929 return; 930 locals = f->f_locals; 931 co = f->f_code; 932 map = co->co_varnames; 933 if (locals == NULL) 934 return; 935 if (!PyTuple_Check(map)) 936 return; 937 PyErr_Fetch(&error_type, &error_value, &error_traceback); 938 fast = f->f_localsplus; 939 j = PyTuple_GET_SIZE(map); 940 if (j > co->co_nlocals) 941 j = co->co_nlocals; 942 if (co->co_nlocals) 943 dict_to_map(co->co_varnames, j, locals, fast, 0, clear); 944 ncells = PyTuple_GET_SIZE(co->co_cellvars); 945 nfreevars = PyTuple_GET_SIZE(co->co_freevars); 946 if (ncells || nfreevars) { 947 dict_to_map(co->co_cellvars, ncells, 948 locals, fast + co->co_nlocals, 1, clear); 949 /* Same test as in PyFrame_FastToLocals() above. */ 950 if (co->co_flags & CO_OPTIMIZED) { 951 dict_to_map(co->co_freevars, nfreevars, 952 locals, fast + co->co_nlocals + ncells, 1, 953 clear); 954 } 955 } 956 PyErr_Restore(error_type, error_value, error_traceback); 957 } 958 959 /* Clear out the free list */ 960 int 961 PyFrame_ClearFreeList(void) 962 { 963 int freelist_size = numfree; 964 965 while (free_list != NULL) { 966 PyFrameObject *f = free_list; 967 free_list = free_list->f_back; 968 PyObject_GC_Del(f); 969 --numfree; 970 } 971 assert(numfree == 0); 972 return freelist_size; 973 } 974 975 void 976 PyFrame_Fini(void) 977 { 978 (void)PyFrame_ClearFreeList(); 979 Py_XDECREF(builtin_object); 980 builtin_object = NULL; 981 } 982
