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