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
},
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) \
36 static int frame_set_ ## NAME(PyFrameObject *f, PyObject *new) { \
37 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \
50 WARN_GET_SET(f_exc_traceback
)
51 WARN_GET_SET(f_exc_type
)
52 WARN_GET_SET(f_exc_value
)
56 frame_getlocals(PyFrameObject
*f
, void *closure
)
58 PyFrame_FastToLocals(f
);
59 Py_INCREF(f
->f_locals
);
64 PyFrame_GetLineNumber(PyFrameObject
*f
)
69 return PyCode_Addr2Line(f
->f_code
, f
->f_lasti
);
73 frame_getlineno(PyFrameObject
*f
, void *closure
)
75 return PyInt_FromLong(PyFrame_GetLineNumber(f
));
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
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.
94 frame_setlineno(PyFrameObject
*f
, PyObject
* p_new_lineno
)
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) */
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");
125 /* You can only do this from within a trace function, not via
126 * _getframe or similar hackery. */
129 PyErr_Format(PyExc_ValueError
,
130 "f_lineno can only be set by a"
131 " line trace function");
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",
143 else if (new_lineno
== f
->f_code
->co_firstlineno
) {
145 new_lineno
= f
->f_code
->co_firstlineno
;
148 /* Find the bytecode offset for the start of the given
149 * line, or the first code-owning line after it. */
151 PyString_AsStringAndSize(f
->f_code
->co_lnotab
,
153 lnotab
= (unsigned char *) tmp
;
155 line
= f
->f_code
->co_firstlineno
;
157 for (offset
= 0; offset
< lnotab_len
; offset
+= 2) {
158 addr
+= lnotab
[offset
];
159 line
+= lnotab
[offset
+1];
160 if (line
>= new_lineno
) {
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",
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
);
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");
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
));
211 for (addr
= 0; addr
< code_len
; addr
++) {
212 unsigned char op
= code
[addr
];
218 blockstack
[blockstack_top
++] = addr
;
219 in_finally
[blockstack_top
-1] = 0;
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;
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
) {
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
) {
253 for (i
= blockstack_top
-1; i
>= 0; i
--) {
255 setup_addr
= blockstack
[i
];
260 if (setup_addr
!= -1) {
261 if (addr
== new_lasti
) {
262 new_lasti_setup_addr
= setup_addr
;
265 if (addr
== f
->f_lasti
) {
266 f_lasti_setup_addr
= setup_addr
;
271 if (op
>= HAVE_ARGUMENT
) {
276 /* Verify that the blockstack tracking code didn't get lost. */
277 assert(blockstack_top
== 0);
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");
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. */
296 for (addr
= min_addr
; addr
< max_addr
; addr
++) {
297 unsigned char op
= code
[addr
];
311 min_delta_iblock
= MIN(min_delta_iblock
, delta_iblock
);
313 if (op
>= HAVE_ARGUMENT
) {
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
) {
322 new_iblock
= f
->f_iblock
+ delta_iblock
;
325 /* Backwards jump. */
326 new_iblock
= f
->f_iblock
- delta_iblock
;
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");
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
);
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
;
352 frame_gettrace(PyFrameObject
*f
, void *closure
)
354 PyObject
* trace
= f
->f_trace
;
365 frame_settrace(PyFrameObject
*f
, PyObject
* v
, void *closure
)
369 /* We rely on f_lineno being accurate when f_trace is set. */
370 f
->f_lineno
= PyFrame_GetLineNumber(f
);
372 old_value
= f
->f_trace
;
375 Py_XDECREF(old_value
);
381 frame_getrestricted(PyFrameObject
*f
, void *closure
)
383 return PyBool_FromLong(PyFrame_IsRestricted(f
));
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
},
401 /* Stack frames are allocated and deallocated at a considerable rate.
402 In an attempt to improve the speed of function calls, we:
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.
411 In zombie mode, no field of PyFrameObject holds a reference, but
412 the following fields are still valid:
414 * ob_type, ob_size, f_code, f_valuestack;
417 f_exc_type, f_exc_value, f_exc_traceback are NULL;
419 * f_localsplus does not require re-allocation and
420 the local variables in f_localsplus are NULL.
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
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.
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.
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
450 frame_dealloc(PyFrameObject
*f
)
452 PyObject
**p
, **valuestack
;
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
++)
463 if (f
->f_stacktop
!= NULL
) {
464 for (p
= valuestack
; p
< f
->f_stacktop
; p
++)
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
);
478 if (co
->co_zombieframe
== NULL
)
479 co
->co_zombieframe
= f
;
480 else if (numfree
< PyFrame_MAXFREELIST
) {
482 f
->f_back
= free_list
;
489 Py_TRASHCAN_SAFE_END(f
)
493 frame_traverse(PyFrameObject
*f
, visitproc visit
, void *arg
)
495 PyObject
**fastlocals
, **p
;
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
);
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
);
515 if (f
->f_stacktop
!= NULL
) {
516 for (p
= f
->f_valuestack
; p
< f
->f_stacktop
; p
++)
523 frame_clear(PyFrameObject
*f
)
525 PyObject
**fastlocals
, **p
, **oldtop
;
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.
533 oldtop
= f
->f_stacktop
;
534 f
->f_stacktop
= NULL
;
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
);
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
);
548 if (oldtop
!= NULL
) {
549 for (p
= f
->f_valuestack
; p
< oldtop
; p
++)
555 frame_sizeof(PyFrameObject
*f
)
557 Py_ssize_t res
, extras
, ncells
, nfrees
;
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
+
563 /* subtract one as it is already included in PyFrameObject */
564 res
= sizeof(PyFrameObject
) + (extras
-1) * sizeof(PyObject
*);
566 return PyInt_FromSsize_t(res
);
569 PyDoc_STRVAR(sizeof__doc__
,
570 "F.__sizeof__() -> size of F in memory, in bytes");
572 static PyMethodDef frame_methods
[] = {
573 {"__sizeof__", (PyCFunction
)frame_sizeof
, METH_NOARGS
,
575 {NULL
, NULL
} /* sentinel */
578 PyTypeObject PyFrame_Type
= {
579 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
581 sizeof(PyFrameObject
),
583 (destructor
)frame_dealloc
, /* tp_dealloc */
589 0, /* tp_as_number */
590 0, /* tp_as_sequence */
591 0, /* tp_as_mapping */
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 */
600 (traverseproc
)frame_traverse
, /* tp_traverse */
601 (inquiry
)frame_clear
, /* tp_clear */
602 0, /* tp_richcompare */
603 0, /* tp_weaklistoffset */
606 frame_methods
, /* tp_methods */
607 frame_memberlist
, /* tp_members */
608 frame_getsetlist
, /* tp_getset */
613 static PyObject
*builtin_object
;
617 builtin_object
= PyString_InternFromString("__builtins__");
618 if (builtin_object
== NULL
)
624 PyFrame_New(PyThreadState
*tstate
, PyCodeObject
*code
, PyObject
*globals
,
627 PyFrameObject
*back
= tstate
->frame
;
633 if (code
== NULL
|| globals
== NULL
|| !PyDict_Check(globals
) ||
634 (locals
!= NULL
&& !PyMapping_Check(locals
))) {
635 PyErr_BadInternalCall();
639 if (back
== NULL
|| back
->f_globals
!= globals
) {
640 builtins
= PyDict_GetItem(globals
, builtin_object
);
642 if (PyModule_Check(builtins
)) {
643 builtins
= PyModule_GetDict(builtins
);
644 assert(!builtins
|| PyDict_Check(builtins
));
646 else if (!PyDict_Check(builtins
))
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)
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
));
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
);
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
+
681 if (free_list
== NULL
) {
682 f
= PyObject_GC_NewVar(PyFrameObject
, &PyFrame_Type
,
693 free_list
= free_list
->f_back
;
694 if (Py_SIZE(f
) < extras
) {
695 f
= PyObject_GC_Resize(PyFrameObject
, f
, extras
);
701 _Py_NewReference((PyObject
*)f
);
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
;
711 f
->f_exc_type
= f
->f_exc_value
= f
->f_exc_traceback
= NULL
;
713 f
->f_stacktop
= f
->f_valuestack
;
714 f
->f_builtins
= builtins
;
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
) {
730 f
->f_locals
= locals
;
736 f
->f_locals
= locals
;
738 f
->f_tstate
= tstate
;
741 f
->f_lineno
= code
->co_firstlineno
;
744 _PyObject_GC_TRACK(f
);
748 /* Block management */
751 PyFrame_BlockSetup(PyFrameObject
*f
, int type
, int handler
, int level
)
754 if (f
->f_iblock
>= CO_MAXBLOCKS
)
755 Py_FatalError("XXX block stack overflow");
756 b
= &f
->f_blockstack
[f
->f_iblock
++];
759 b
->b_handler
= handler
;
763 PyFrame_BlockPop(PyFrameObject
*f
)
766 if (f
->f_iblock
<= 0)
767 Py_FatalError("XXX block stack underflow");
768 b
= &f
->f_blockstack
[--f
->f_iblock
];
772 /* Convert between "fast" version of locals and dictionary version.
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.
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
784 Exceptions raised while modifying the dict are silently ignored,
785 because there is no good way to report them.
789 map_to_dict(PyObject
*map
, Py_ssize_t nmap
, PyObject
*dict
, PyObject
**values
,
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
));
801 assert(PyCell_Check(value
));
802 value
= PyCell_GET(value
);
805 if (PyObject_DelItem(dict
, key
) != 0)
809 if (PyObject_SetItem(dict
, key
, value
) != 0)
815 /* Copy values from the "locals" dict into the fast locals.
817 dict is an input argument containing string keys representing
818 variables names and arbitrary PyObject* as values.
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.
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
832 Exceptions raised while modifying the dict are silently ignored,
833 because there is no good way to report them.
837 dict_to_map(PyObject
*map
, Py_ssize_t nmap
, PyObject
*dict
, PyObject
**values
,
838 int deref
, int clear
)
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. */
855 assert(PyCell_Check(values
[j
]));
856 if (PyCell_GET(values
[j
]) != value
) {
857 if (PyCell_Set(values
[j
], value
) < 0)
860 } else if (values
[j
] != value
) {
862 Py_XDECREF(values
[j
]);
870 PyFrame_FastToLocals(PyFrameObject
*f
)
872 /* Merge fast locals into f->f_locals */
873 PyObject
*locals
, *map
;
875 PyObject
*error_type
, *error_value
, *error_traceback
;
878 int ncells
, nfreevars
;
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 :-( */
890 map
= co
->co_varnames
;
891 if (!PyTuple_Check(map
))
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
)
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.
913 if (co
->co_flags
& CO_OPTIMIZED
) {
914 map_to_dict(co
->co_freevars
, nfreevars
,
915 locals
, fast
+ co
->co_nlocals
+ ncells
, 1);
918 PyErr_Restore(error_type
, error_value
, error_traceback
);
922 PyFrame_LocalsToFast(PyFrameObject
*f
, int clear
)
924 /* Merge f->f_locals into fast locals */
925 PyObject
*locals
, *map
;
927 PyObject
*error_type
, *error_value
, *error_traceback
;
930 int ncells
, nfreevars
;
933 locals
= f
->f_locals
;
935 map
= co
->co_varnames
;
938 if (!PyTuple_Check(map
))
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
)
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,
959 PyErr_Restore(error_type
, error_value
, error_traceback
);
962 /* Clear out the free list */
964 PyFrame_ClearFreeList(void)
966 int freelist_size
= numfree
;
968 while (free_list
!= NULL
) {
969 PyFrameObject
*f
= free_list
;
970 free_list
= free_list
->f_back
;
974 assert(numfree
== 0);
975 return freelist_size
;
981 (void)PyFrame_ClearFreeList();
982 Py_XDECREF(builtin_object
);
983 builtin_object
= NULL
;