• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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)
WARN_GET_SET(f_exc_type)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
PyFrame_GetLineNumber(PyFrameObject * f)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 *
frame_getlineno(PyFrameObject * f,void * closure)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
frame_setlineno(PyFrameObject * f,PyObject * p_new_lineno)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 *
frame_gettrace(PyFrameObject * f,void * closure)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
frame_settrace(PyFrameObject * f,PyObject * v,void * closure)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 *
frame_getrestricted(PyFrameObject * f,void * closure)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
frame_dealloc(PyFrameObject * f)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
frame_traverse(PyFrameObject * f,visitproc visit,void * arg)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
frame_clear(PyFrameObject * f)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 *
frame_sizeof(PyFrameObject * f)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 
_PyFrame_Init()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 *
PyFrame_New(PyThreadState * tstate,PyCodeObject * code,PyObject * globals,PyObject * locals)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
PyFrame_BlockSetup(PyFrameObject * f,int type,int handler,int level)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 *
PyFrame_BlockPop(PyFrameObject * f)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
map_to_dict(PyObject * map,Py_ssize_t nmap,PyObject * dict,PyObject ** values,int deref)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
dict_to_map(PyObject * map,Py_ssize_t nmap,PyObject * dict,PyObject ** values,int deref,int clear)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
PyFrame_FastToLocals(PyFrameObject * f)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
PyFrame_LocalsToFast(PyFrameObject * f,int clear)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
PyFrame_ClearFreeList(void)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
PyFrame_Fini(void)979 PyFrame_Fini(void)
980 {
981     (void)PyFrame_ClearFreeList();
982     Py_XDECREF(builtin_object);
983     builtin_object = NULL;
984 }
985