1 /* Frame object implementation */
6 #include "frameobject.h"
8 #include "structmember.h"
12 #define MIN(a, b) ((a) < (b) ? (a) : (b))
13 #define MAX(a, b) ((a) > (b) ? (a) : (b))
15 #define OFF(x) offsetof(PyFrameObject, x)
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 {"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
)},
30 frame_getlocals(PyFrameObject
*f
, void *closure
)
32 PyFrame_FastToLocals(f
);
33 Py_INCREF(f
->f_locals
);
38 frame_getlineno(PyFrameObject
*f
, void *closure
)
45 lineno
= PyCode_Addr2Line(f
->f_code
, f
->f_lasti
);
47 return PyInt_FromLong(lineno
);
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
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.
66 frame_setlineno(PyFrameObject
*f
, PyObject
* p_new_lineno
)
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) */
90 /* f_lineno must be an integer. */
91 if (!PyInt_Check(p_new_lineno
)) {
92 PyErr_SetString(PyExc_ValueError
,
93 "lineno must be an integer");
97 /* You can only do this from within a trace function, not via
98 * _getframe or similar hackery. */
101 PyErr_Format(PyExc_ValueError
,
102 "f_lineno can only be set by a trace function");
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",
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
);
119 line
= f
->f_code
->co_firstlineno
;
121 for (offset
= 0; offset
< lnotab_len
; offset
+= 2) {
122 addr
+= lnotab
[offset
];
123 line
+= lnotab
[offset
+1];
124 if (line
>= new_lineno
) {
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",
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
);
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");
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
));
174 for (addr
= 0; addr
< code_len
; addr
++) {
175 unsigned char op
= code
[addr
];
180 blockstack
[blockstack_top
++] = addr
;
181 in_finally
[blockstack_top
-1] = 0;
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;
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
) {
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
) {
215 for (i
= blockstack_top
-1; i
>= 0; i
--) {
217 setup_addr
= blockstack
[i
];
222 if (setup_addr
!= -1) {
223 if (addr
== new_lasti
) {
224 new_lasti_setup_addr
= setup_addr
;
227 if (addr
== f
->f_lasti
) {
228 f_lasti_setup_addr
= setup_addr
;
233 if (op
>= HAVE_ARGUMENT
) {
238 /* Verify that the blockstack tracking code didn't get lost. */
239 assert(blockstack_top
== 0);
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");
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. */
258 for (addr
= min_addr
; addr
< max_addr
; addr
++) {
259 unsigned char op
= code
[addr
];
272 min_delta_iblock
= MIN(min_delta_iblock
, delta_iblock
);
274 if (op
>= HAVE_ARGUMENT
) {
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
) {
283 new_iblock
= f
->f_iblock
+ delta_iblock
;
286 /* Backwards jump. */
287 new_iblock
= f
->f_iblock
- delta_iblock
;
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");
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
);
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
;
313 frame_gettrace(PyFrameObject
*f
, void *closure
)
315 PyObject
* trace
= f
->f_trace
;
326 frame_settrace(PyFrameObject
*f
, PyObject
* v
, void *closure
)
328 /* We rely on f_lineno being accurate when f_trace is set. */
330 PyObject
* old_value
= f
->f_trace
;
336 f
->f_lineno
= PyCode_Addr2Line(f
->f_code
, f
->f_lasti
);
338 Py_XDECREF(old_value
);
344 frame_getrestricted(PyFrameObject
*f
, void *closure
)
346 return PyBool_FromLong(PyFrame_IsRestricted(f
));
349 static PyGetSetDef frame_getsetlist
[] = {
350 {"f_locals", (getter
)frame_getlocals
, NULL
, NULL
},
351 {"f_lineno", (getter
)frame_getlineno
,
352 (setter
)frame_setlineno
, NULL
},
353 {"f_trace", (getter
)frame_gettrace
, (setter
)frame_settrace
, NULL
},
354 {"f_restricted",(getter
)frame_getrestricted
,NULL
, NULL
},
358 /* Stack frames are allocated and deallocated at a considerable rate.
359 In an attempt to improve the speed of function calls, we:
361 1. Hold a single "zombie" frame on each code object. This retains
362 the allocated and initialised frame object from an invocation of
363 the code object. The zombie is reanimated the next time we need a
364 frame object for that code object. Doing this saves the malloc/
365 realloc required when using a free_list frame that isn't the
366 correct size. It also saves some field initialisation.
368 In zombie mode, no field of PyFrameObject holds a reference, but
369 the following fields are still valid:
371 * ob_type, ob_size, f_code, f_valuestack;
374 f_exc_type, f_exc_value, f_exc_traceback are NULL;
376 * f_localsplus does not require re-allocation and
377 the local variables in f_localsplus are NULL.
379 2. We also maintain a separate free list of stack frames (just like
380 integers are allocated in a special way -- see intobject.c). When
381 a stack frame is on the free list, only the following members have
383 ob_type == &Frametype
384 f_back next item on free list, or NULL
385 f_stacksize size of value stack
386 ob_size size of localsplus
387 Note that the value and block stacks are preserved -- this can save
388 another malloc() call or two (and two free() calls as well!).
389 Also note that, unlike for integers, each frame object is a
390 malloc'ed object in its own right -- it is only the actual calls to
391 malloc() that we are trying to save here, not the administration.
392 After all, while a typical program may make millions of calls, a
393 call depth of more than 20 or 30 is probably already exceptional
394 unless the program contains run-away recursion. I hope.
396 Later, PyFrame_MAXFREELIST was added to bound the # of frames saved on
397 free_list. Else programs creating lots of cyclic trash involving
398 frames could provoke free_list into growing without bound.
401 static PyFrameObject
*free_list
= NULL
;
402 static int numfree
= 0; /* number of frames currently in free_list */
403 /* max value for numfree */
404 #define PyFrame_MAXFREELIST 200
407 frame_dealloc(PyFrameObject
*f
)
409 PyObject
**p
, **valuestack
;
412 PyObject_GC_UnTrack(f
);
413 Py_TRASHCAN_SAFE_BEGIN(f
)
414 /* Kill all local variables */
415 valuestack
= f
->f_valuestack
;
416 for (p
= f
->f_localsplus
; p
< valuestack
; p
++)
420 if (f
->f_stacktop
!= NULL
) {
421 for (p
= valuestack
; p
< f
->f_stacktop
; p
++)
425 Py_XDECREF(f
->f_back
);
426 Py_DECREF(f
->f_builtins
);
427 Py_DECREF(f
->f_globals
);
428 Py_CLEAR(f
->f_locals
);
429 Py_CLEAR(f
->f_trace
);
430 Py_CLEAR(f
->f_exc_type
);
431 Py_CLEAR(f
->f_exc_value
);
432 Py_CLEAR(f
->f_exc_traceback
);
435 if (co
->co_zombieframe
== NULL
)
436 co
->co_zombieframe
= f
;
437 else if (numfree
< PyFrame_MAXFREELIST
) {
439 f
->f_back
= free_list
;
446 Py_TRASHCAN_SAFE_END(f
)
450 frame_traverse(PyFrameObject
*f
, visitproc visit
, void *arg
)
452 PyObject
**fastlocals
, **p
;
457 Py_VISIT(f
->f_builtins
);
458 Py_VISIT(f
->f_globals
);
459 Py_VISIT(f
->f_locals
);
460 Py_VISIT(f
->f_trace
);
461 Py_VISIT(f
->f_exc_type
);
462 Py_VISIT(f
->f_exc_value
);
463 Py_VISIT(f
->f_exc_traceback
);
466 slots
= f
->f_code
->co_nlocals
+ PyTuple_GET_SIZE(f
->f_code
->co_cellvars
) + PyTuple_GET_SIZE(f
->f_code
->co_freevars
);
467 fastlocals
= f
->f_localsplus
;
468 for (i
= slots
; --i
>= 0; ++fastlocals
)
469 Py_VISIT(*fastlocals
);
472 if (f
->f_stacktop
!= NULL
) {
473 for (p
= f
->f_valuestack
; p
< f
->f_stacktop
; p
++)
480 frame_clear(PyFrameObject
*f
)
482 PyObject
**fastlocals
, **p
, **oldtop
;
485 /* Before anything else, make sure that this frame is clearly marked
486 * as being defunct! Else, e.g., a generator reachable from this
487 * frame may also point to this frame, believe itself to still be
488 * active, and try cleaning up this frame again.
490 oldtop
= f
->f_stacktop
;
491 f
->f_stacktop
= NULL
;
493 Py_CLEAR(f
->f_exc_type
);
494 Py_CLEAR(f
->f_exc_value
);
495 Py_CLEAR(f
->f_exc_traceback
);
496 Py_CLEAR(f
->f_trace
);
499 slots
= f
->f_code
->co_nlocals
+ PyTuple_GET_SIZE(f
->f_code
->co_cellvars
) + PyTuple_GET_SIZE(f
->f_code
->co_freevars
);
500 fastlocals
= f
->f_localsplus
;
501 for (i
= slots
; --i
>= 0; ++fastlocals
)
502 Py_CLEAR(*fastlocals
);
505 if (oldtop
!= NULL
) {
506 for (p
= f
->f_valuestack
; p
< oldtop
; p
++)
512 frame_sizeof(PyFrameObject
*f
)
514 Py_ssize_t res
, extras
, ncells
, nfrees
;
516 ncells
= PyTuple_GET_SIZE(f
->f_code
->co_cellvars
);
517 nfrees
= PyTuple_GET_SIZE(f
->f_code
->co_freevars
);
518 extras
= f
->f_code
->co_stacksize
+ f
->f_code
->co_nlocals
+
520 // subtract one as it is already included in PyFrameObject
521 res
= sizeof(PyFrameObject
) + (extras
-1) * sizeof(PyObject
*);
523 return PyInt_FromSsize_t(res
);
526 PyDoc_STRVAR(sizeof__doc__
,
527 "F.__sizeof__() -> size of F in memory, in bytes");
529 static PyMethodDef frame_methods
[] = {
530 {"__sizeof__", (PyCFunction
)frame_sizeof
, METH_NOARGS
,
532 {NULL
, NULL
} /* sentinel */
535 PyTypeObject PyFrame_Type
= {
536 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
538 sizeof(PyFrameObject
),
540 (destructor
)frame_dealloc
, /* tp_dealloc */
546 0, /* tp_as_number */
547 0, /* tp_as_sequence */
548 0, /* tp_as_mapping */
552 PyObject_GenericGetAttr
, /* tp_getattro */
553 PyObject_GenericSetAttr
, /* tp_setattro */
554 0, /* tp_as_buffer */
555 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
,/* tp_flags */
557 (traverseproc
)frame_traverse
, /* tp_traverse */
558 (inquiry
)frame_clear
, /* tp_clear */
559 0, /* tp_richcompare */
560 0, /* tp_weaklistoffset */
563 frame_methods
, /* tp_methods */
564 frame_memberlist
, /* tp_members */
565 frame_getsetlist
, /* tp_getset */
570 static PyObject
*builtin_object
;
574 builtin_object
= PyString_InternFromString("__builtins__");
575 return (builtin_object
!= NULL
);
579 PyFrame_New(PyThreadState
*tstate
, PyCodeObject
*code
, PyObject
*globals
,
582 PyFrameObject
*back
= tstate
->frame
;
588 if (code
== NULL
|| globals
== NULL
|| !PyDict_Check(globals
) ||
589 (locals
!= NULL
&& !PyMapping_Check(locals
))) {
590 PyErr_BadInternalCall();
594 if (back
== NULL
|| back
->f_globals
!= globals
) {
595 builtins
= PyDict_GetItem(globals
, builtin_object
);
597 if (PyModule_Check(builtins
)) {
598 builtins
= PyModule_GetDict(builtins
);
599 assert(!builtins
|| PyDict_Check(builtins
));
601 else if (!PyDict_Check(builtins
))
604 if (builtins
== NULL
) {
605 /* No builtins! Make up a minimal one
606 Give them 'None', at least. */
607 builtins
= PyDict_New();
608 if (builtins
== NULL
||
609 PyDict_SetItemString(
610 builtins
, "None", Py_None
) < 0)
618 /* If we share the globals, we share the builtins.
619 Save a lookup and a call. */
620 builtins
= back
->f_builtins
;
621 assert(builtins
!= NULL
&& PyDict_Check(builtins
));
624 if (code
->co_zombieframe
!= NULL
) {
625 f
= code
->co_zombieframe
;
626 code
->co_zombieframe
= NULL
;
627 _Py_NewReference((PyObject
*)f
);
628 assert(f
->f_code
== code
);
631 Py_ssize_t extras
, ncells
, nfrees
;
632 ncells
= PyTuple_GET_SIZE(code
->co_cellvars
);
633 nfrees
= PyTuple_GET_SIZE(code
->co_freevars
);
634 extras
= code
->co_stacksize
+ code
->co_nlocals
+ ncells
+
636 if (free_list
== NULL
) {
637 f
= PyObject_GC_NewVar(PyFrameObject
, &PyFrame_Type
,
648 free_list
= free_list
->f_back
;
649 if (Py_SIZE(f
) < extras
) {
650 f
= PyObject_GC_Resize(PyFrameObject
, f
, extras
);
656 _Py_NewReference((PyObject
*)f
);
660 extras
= code
->co_nlocals
+ ncells
+ nfrees
;
661 f
->f_valuestack
= f
->f_localsplus
+ extras
;
662 for (i
=0; i
<extras
; i
++)
663 f
->f_localsplus
[i
] = NULL
;
666 f
->f_exc_type
= f
->f_exc_value
= f
->f_exc_traceback
= NULL
;
668 f
->f_stacktop
= f
->f_valuestack
;
669 f
->f_builtins
= builtins
;
674 f
->f_globals
= globals
;
675 /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
676 if ((code
->co_flags
& (CO_NEWLOCALS
| CO_OPTIMIZED
)) ==
677 (CO_NEWLOCALS
| CO_OPTIMIZED
))
678 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
679 else if (code
->co_flags
& CO_NEWLOCALS
) {
680 locals
= PyDict_New();
681 if (locals
== NULL
) {
685 f
->f_locals
= locals
;
691 f
->f_locals
= locals
;
693 f
->f_tstate
= tstate
;
696 f
->f_lineno
= code
->co_firstlineno
;
699 _PyObject_GC_TRACK(f
);
703 /* Block management */
706 PyFrame_BlockSetup(PyFrameObject
*f
, int type
, int handler
, int level
)
709 if (f
->f_iblock
>= CO_MAXBLOCKS
)
710 Py_FatalError("XXX block stack overflow");
711 b
= &f
->f_blockstack
[f
->f_iblock
++];
714 b
->b_handler
= handler
;
718 PyFrame_BlockPop(PyFrameObject
*f
)
721 if (f
->f_iblock
<= 0)
722 Py_FatalError("XXX block stack underflow");
723 b
= &f
->f_blockstack
[--f
->f_iblock
];
727 /* Convert between "fast" version of locals and dictionary version.
729 map and values are input arguments. map is a tuple of strings.
730 values is an array of PyObject*. At index i, map[i] is the name of
731 the variable with value values[i]. The function copies the first
732 nmap variable from map/values into dict. If values[i] is NULL,
733 the variable is deleted from dict.
735 If deref is true, then the values being copied are cell variables
736 and the value is extracted from the cell variable before being put
739 Exceptions raised while modifying the dict are silently ignored,
740 because there is no good way to report them.
744 map_to_dict(PyObject
*map
, Py_ssize_t nmap
, PyObject
*dict
, PyObject
**values
,
748 assert(PyTuple_Check(map
));
749 assert(PyDict_Check(dict
));
750 assert(PyTuple_Size(map
) >= nmap
);
751 for (j
= nmap
; --j
>= 0; ) {
752 PyObject
*key
= PyTuple_GET_ITEM(map
, j
);
753 PyObject
*value
= values
[j
];
754 assert(PyString_Check(key
));
756 assert(PyCell_Check(value
));
757 value
= PyCell_GET(value
);
760 if (PyObject_DelItem(dict
, key
) != 0)
764 if (PyObject_SetItem(dict
, key
, value
) != 0)
770 /* Copy values from the "locals" dict into the fast locals.
772 dict is an input argument containing string keys representing
773 variables names and arbitrary PyObject* as values.
775 map and values are input arguments. map is a tuple of strings.
776 values is an array of PyObject*. At index i, map[i] is the name of
777 the variable with value values[i]. The function copies the first
778 nmap variable from map/values into dict. If values[i] is NULL,
779 the variable is deleted from dict.
781 If deref is true, then the values being copied are cell variables
782 and the value is extracted from the cell variable before being put
783 in dict. If clear is true, then variables in map but not in dict
784 are set to NULL in map; if clear is false, variables missing in
787 Exceptions raised while modifying the dict are silently ignored,
788 because there is no good way to report them.
792 dict_to_map(PyObject
*map
, Py_ssize_t nmap
, PyObject
*dict
, PyObject
**values
,
793 int deref
, int clear
)
796 assert(PyTuple_Check(map
));
797 assert(PyDict_Check(dict
));
798 assert(PyTuple_Size(map
) >= nmap
);
799 for (j
= nmap
; --j
>= 0; ) {
800 PyObject
*key
= PyTuple_GET_ITEM(map
, j
);
801 PyObject
*value
= PyObject_GetItem(dict
, key
);
802 assert(PyString_Check(key
));
803 /* We only care about NULLs if clear is true. */
810 assert(PyCell_Check(values
[j
]));
811 if (PyCell_GET(values
[j
]) != value
) {
812 if (PyCell_Set(values
[j
], value
) < 0)
815 } else if (values
[j
] != value
) {
817 Py_XDECREF(values
[j
]);
825 PyFrame_FastToLocals(PyFrameObject
*f
)
827 /* Merge fast locals into f->f_locals */
828 PyObject
*locals
, *map
;
830 PyObject
*error_type
, *error_value
, *error_traceback
;
833 int ncells
, nfreevars
;
836 locals
= f
->f_locals
;
837 if (locals
== NULL
) {
838 locals
= f
->f_locals
= PyDict_New();
839 if (locals
== NULL
) {
840 PyErr_Clear(); /* Can't report it :-( */
845 map
= co
->co_varnames
;
846 if (!PyTuple_Check(map
))
848 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
849 fast
= f
->f_localsplus
;
850 j
= PyTuple_GET_SIZE(map
);
851 if (j
> co
->co_nlocals
)
854 map_to_dict(map
, j
, locals
, fast
, 0);
855 ncells
= PyTuple_GET_SIZE(co
->co_cellvars
);
856 nfreevars
= PyTuple_GET_SIZE(co
->co_freevars
);
857 if (ncells
|| nfreevars
) {
858 map_to_dict(co
->co_cellvars
, ncells
,
859 locals
, fast
+ co
->co_nlocals
, 1);
860 /* If the namespace is unoptimized, then one of the
861 following cases applies:
862 1. It does not contain free variables, because it
863 uses import * or is a top-level namespace.
864 2. It is a class namespace.
865 We don't want to accidentally copy free variables
866 into the locals dict used by the class.
868 if (co
->co_flags
& CO_OPTIMIZED
) {
869 map_to_dict(co
->co_freevars
, nfreevars
,
870 locals
, fast
+ co
->co_nlocals
+ ncells
, 1);
873 PyErr_Restore(error_type
, error_value
, error_traceback
);
877 PyFrame_LocalsToFast(PyFrameObject
*f
, int clear
)
879 /* Merge f->f_locals into fast locals */
880 PyObject
*locals
, *map
;
882 PyObject
*error_type
, *error_value
, *error_traceback
;
885 int ncells
, nfreevars
;
888 locals
= f
->f_locals
;
890 map
= co
->co_varnames
;
893 if (!PyTuple_Check(map
))
895 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
896 fast
= f
->f_localsplus
;
897 j
= PyTuple_GET_SIZE(map
);
898 if (j
> co
->co_nlocals
)
901 dict_to_map(co
->co_varnames
, j
, locals
, fast
, 0, clear
);
902 ncells
= PyTuple_GET_SIZE(co
->co_cellvars
);
903 nfreevars
= PyTuple_GET_SIZE(co
->co_freevars
);
904 if (ncells
|| nfreevars
) {
905 dict_to_map(co
->co_cellvars
, ncells
,
906 locals
, fast
+ co
->co_nlocals
, 1, clear
);
907 /* Same test as in PyFrame_FastToLocals() above. */
908 if (co
->co_flags
& CO_OPTIMIZED
) {
909 dict_to_map(co
->co_freevars
, nfreevars
,
910 locals
, fast
+ co
->co_nlocals
+ ncells
, 1,
914 PyErr_Restore(error_type
, error_value
, error_traceback
);
917 /* Clear out the free list */
919 PyFrame_ClearFreeList(void)
921 int freelist_size
= numfree
;
923 while (free_list
!= NULL
) {
924 PyFrameObject
*f
= free_list
;
925 free_list
= free_list
->f_back
;
929 assert(numfree
== 0);
930 return freelist_size
;
936 (void)PyFrame_ClearFreeList();
937 Py_XDECREF(builtin_object
);
938 builtin_object
= NULL
;