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