Bug Summary

File:Objects/frameobject.c
Location:line 480, column 13
Description:Access to field 'co_nlocals' results in a dereference of a null pointer (loaded from field 'f_code')

Annotated Source Code

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)) ((a) < (b) ? (a) : (b))
13#define MAX(a, b)((a) > (b) ? (a) : (b)) ((a) > (b) ? (a) : (b))
14
15#define OFF(x)__builtin_offsetof(PyFrameObject, x) offsetof(PyFrameObject, x)__builtin_offsetof(PyFrameObject, x)
16
17static PyMemberDef frame_memberlist[] = {
18 {"f_back", T_OBJECT6, OFF(f_back)__builtin_offsetof(PyFrameObject, f_back), READONLY1},
19 {"f_code", T_OBJECT6, OFF(f_code)__builtin_offsetof(PyFrameObject, f_code), READONLY1},
20 {"f_builtins", T_OBJECT6, OFF(f_builtins)__builtin_offsetof(PyFrameObject, f_builtins),READONLY1},
21 {"f_globals", T_OBJECT6, OFF(f_globals)__builtin_offsetof(PyFrameObject, f_globals), READONLY1},
22 {"f_lasti", T_INT1, OFF(f_lasti)__builtin_offsetof(PyFrameObject, f_lasti), READONLY1},
23 {NULL((void*)0)} /* Sentinel */
24};
25
26static PyObject *
27frame_getlocals(PyFrameObject *f, void *closure)
28{
29 PyFrame_FastToLocals(f);
30 Py_INCREF(f->f_locals)( _Py_RefTotal++ , ((PyObject*)(f->f_locals))->ob_refcnt
++)
;
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((void*)0); /* The bytecode for the frame... */
73 Py_ssize_t code_len = 0; /* ...and its length */
74 unsigned char *lnotab = NULL((void*)0); /* 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_MAXBLOCKS20]; /* Walking the 'finally' blocks */
87 int in_finally[CO_MAXBLOCKS20]; /* (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)((((PyObject*)(p_new_lineno))->ob_type) == &PyLong_Type
)
) {
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_LONG8 > SIZEOF_INT4
112 || l_new_lineno > INT_MAX2147483647
113 || l_new_lineno < INT_MIN(-2147483647 -1)
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)((new_lasti) < (f->f_lasti) ? (new_lasti) : (f->f_lasti
))
;
164 max_addr = MAX(new_lasti, f->f_lasti)((new_lasti) > (f->f_lasti) ? (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_TOP4 || code[new_lasti] == POP_TOP1) {
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))((__builtin_object_size (blockstack, 0) != (size_t) -1) ? __builtin___memset_chk
(blockstack, '\0', sizeof(blockstack), __builtin_object_size
(blockstack, 0)) : __inline_memset_chk (blockstack, '\0', sizeof
(blockstack)))
;
194 memset(in_finally, '\0', sizeof(in_finally))((__builtin_object_size (in_finally, 0) != (size_t) -1) ? __builtin___memset_chk
(in_finally, '\0', sizeof(in_finally), __builtin_object_size
(in_finally, 0)) : __inline_memset_chk (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_LOOP120:
200 case SETUP_EXCEPT121:
201 case SETUP_FINALLY122:
202 blockstack[blockstack_top++] = addr;
203 in_finally[blockstack_top-1] = 0;
204 break;
205
206 case POP_BLOCK87:
207 assert(blockstack_top > 0)(__builtin_expect(!(blockstack_top > 0), 0) ? __assert_rtn
(__func__, "Objects/frameobject.c", 207, "blockstack_top > 0"
) : (void)0)
;
208 setup_op = code[blockstack[blockstack_top-1]];
209 if (setup_op == SETUP_FINALLY122) {
210 in_finally[blockstack_top-1] = 1;
211 }
212 else {
213 blockstack_top--;
214 }
215 break;
216
217 case END_FINALLY88:
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_FINALLY122) {
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_ARGUMENT90) {
256 addr += 2;
257 }
258 }
259
260 /* Verify that the blockstack tracking code didn't get lost. */
261 assert(blockstack_top == 0)(__builtin_expect(!(blockstack_top == 0), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 261, "blockstack_top == 0") : (void
)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_LOOP120:
284 case SETUP_EXCEPT121:
285 case SETUP_FINALLY122:
286 delta_iblock++;
287 break;
288
289 case POP_BLOCK87:
290 delta_iblock--;
291 break;
292 }
293
294 min_delta_iblock = MIN(min_delta_iblock, delta_iblock)((min_delta_iblock) < (delta_iblock) ? (min_delta_iblock) :
(delta_iblock))
;
295
296 if (op >= HAVE_ARGUMENT90) {
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)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt !=
0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 324, (PyObject *)(v)); } else _Py_Dealloc
((PyObject *)(v)); } while (0)
;
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((void*)0))
340 trace = Py_None(&_Py_NoneStruct);
341
342 Py_INCREF(trace)( _Py_RefTotal++ , ((PyObject*)(trace))->ob_refcnt++);
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)do { if ((v) == ((void*)0)) ; else ( _Py_RefTotal++ , ((PyObject
*)(v))->ob_refcnt++); } while (0)
;
357 f->f_trace = v;
358 Py_XDECREF(old_value)do { if ((old_value) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(old_value))->ob_refcnt != 0) { if (((PyObject
*)old_value)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 358, (PyObject *)(old_value)); } else _Py_Dealloc((PyObject
*)(old_value)); } while (0); } while (0)
;
359
360 return 0;
361}
362
363
364static PyGetSetDef frame_getsetlist[] = {
365 {"f_locals", (getter)frame_getlocals, NULL((void*)0), NULL((void*)0)},
366 {"f_lineno", (getter)frame_getlineno,
367 (setter)frame_setlineno, NULL((void*)0)},
368 {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL((void*)0)},
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((void*)0);
416static int numfree = 0; /* number of frames currently in free_list */
417/* max value for numfree */
418#define PyFrame_MAXFREELIST200 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)if (_PyTrash_delete_nesting < 50) { ++_PyTrash_delete_nesting
;
428 /* Kill all local variables */
429 valuestack = f->f_valuestack;
430 for (p = f->f_localsplus; p < valuestack; p++)
431 Py_CLEAR(*p)do { if (*p) { PyObject *_py_tmp = (PyObject *)(*p); (*p) = (
(void*)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp))
->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt
< 0) _Py_NegativeRefcount("Objects/frameobject.c", 431, (
PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp
)); } while (0); } } while (0)
;
432
433 /* Free stack */
434 if (f->f_stacktop != NULL((void*)0)) {
435 for (p = valuestack; p < f->f_stacktop; p++)
436 Py_XDECREF(*p)do { if ((*p) == ((void*)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(*p))->ob_refcnt != 0) { if (((PyObject*)*p
)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 436, (PyObject *)(*p)); } else _Py_Dealloc((PyObject *)(*p)
); } while (0); } while (0)
;
437 }
438
439 Py_XDECREF(f->f_back)do { if ((f->f_back) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(f->f_back))->ob_refcnt != 0) { if (
((PyObject*)f->f_back)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 439, (PyObject *)(f->f_back)); }
else _Py_Dealloc((PyObject *)(f->f_back)); } while (0); }
while (0)
;
440 Py_DECREF(f->f_builtins)do { if (_Py_RefTotal-- , --((PyObject*)(f->f_builtins))->
ob_refcnt != 0) { if (((PyObject*)f->f_builtins)->ob_refcnt
< 0) _Py_NegativeRefcount("Objects/frameobject.c", 440, (
PyObject *)(f->f_builtins)); } else _Py_Dealloc((PyObject *
)(f->f_builtins)); } while (0)
;
441 Py_DECREF(f->f_globals)do { if (_Py_RefTotal-- , --((PyObject*)(f->f_globals))->
ob_refcnt != 0) { if (((PyObject*)f->f_globals)->ob_refcnt
< 0) _Py_NegativeRefcount("Objects/frameobject.c", 441, (
PyObject *)(f->f_globals)); } else _Py_Dealloc((PyObject *
)(f->f_globals)); } while (0)
;
442 Py_CLEAR(f->f_locals)do { if (f->f_locals) { PyObject *_py_tmp = (PyObject *)(f
->f_locals); (f->f_locals) = ((void*)0); do { if (_Py_RefTotal
-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0) { if (((PyObject
*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 442, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *
)(_py_tmp)); } while (0); } } while (0)
;
443 Py_CLEAR(f->f_trace)do { if (f->f_trace) { PyObject *_py_tmp = (PyObject *)(f->
f_trace); (f->f_trace) = ((void*)0); do { if (_Py_RefTotal
-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0) { if (((PyObject
*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 443, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *
)(_py_tmp)); } while (0); } } while (0)
;
444 Py_CLEAR(f->f_exc_type)do { if (f->f_exc_type) { PyObject *_py_tmp = (PyObject *)
(f->f_exc_type); (f->f_exc_type) = ((void*)0); do { if (
_Py_RefTotal-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0)
{ if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 444, (PyObject *)(_py_tmp)); } else
_Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (
0)
;
445 Py_CLEAR(f->f_exc_value)do { if (f->f_exc_value) { PyObject *_py_tmp = (PyObject *
)(f->f_exc_value); (f->f_exc_value) = ((void*)0); do { if
(_Py_RefTotal-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0
) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 445, (PyObject *)(_py_tmp)); } else
_Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (
0)
;
446 Py_CLEAR(f->f_exc_traceback)do { if (f->f_exc_traceback) { PyObject *_py_tmp = (PyObject
*)(f->f_exc_traceback); (f->f_exc_traceback) = ((void*
)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp))->ob_refcnt
!= 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 446, (PyObject *)(_py_tmp)); } else
_Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (
0)
;
447
448 co = f->f_code;
449 if (co->co_zombieframe == NULL((void*)0))
450 co->co_zombieframe = f;
451 else if (numfree < PyFrame_MAXFREELIST200) {
452 ++numfree;
453 f->f_back = free_list;
454 free_list = f;
455 }
456 else
457 PyObject_GC_Del(f);
458
459 Py_DECREF(co)do { if (_Py_RefTotal-- , --((PyObject*)(co))->ob_refcnt !=
0) { if (((PyObject*)co)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 459, (PyObject *)(co)); } else _Py_Dealloc
((PyObject *)(co)); } while (0)
;
460 Py_TRASHCAN_SAFE_END(f)--_PyTrash_delete_nesting; if (_PyTrash_delete_later &&
_PyTrash_delete_nesting <= 0) _PyTrash_destroy_chain(); }
else _PyTrash_deposit_object((PyObject*)f);
461}
462
463static int
464frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
465{
466 PyObject **fastlocals, **p;
467 int i, slots;
468
469 Py_VISIT(f->f_back)do { if (f->f_back) { int vret = visit((PyObject *)(f->
f_back), arg); if (vret) return vret; } } while (0)
;
470 Py_VISIT(f->f_code)do { if (f->f_code) { int vret = visit((PyObject *)(f->
f_code), arg); if (vret) return vret; } } while (0)
;
471 Py_VISIT(f->f_builtins)do { if (f->f_builtins) { int vret = visit((PyObject *)(f->
f_builtins), arg); if (vret) return vret; } } while (0)
;
472 Py_VISIT(f->f_globals)do { if (f->f_globals) { int vret = visit((PyObject *)(f->
f_globals), arg); if (vret) return vret; } } while (0)
;
473 Py_VISIT(f->f_locals)do { if (f->f_locals) { int vret = visit((PyObject *)(f->
f_locals), arg); if (vret) return vret; } } while (0)
;
474 Py_VISIT(f->f_trace)do { if (f->f_trace) { int vret = visit((PyObject *)(f->
f_trace), arg); if (vret) return vret; } } while (0)
;
475 Py_VISIT(f->f_exc_type)do { if (f->f_exc_type) { int vret = visit((PyObject *)(f->
f_exc_type), arg); if (vret) return vret; } } while (0)
;
476 Py_VISIT(f->f_exc_value)do { if (f->f_exc_value) { int vret = visit((PyObject *)(f
->f_exc_value), arg); if (vret) return vret; } } while (0)
;
477 Py_VISIT(f->f_exc_traceback)do { if (f->f_exc_traceback) { int vret = visit((PyObject *
)(f->f_exc_traceback), arg); if (vret) return vret; } } while
(0)
;
478
479 /* locals */
480 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars)(((PyVarObject*)(f->f_code->co_cellvars))->ob_size) + PyTuple_GET_SIZE(f->f_code->co_freevars)(((PyVarObject*)(f->f_code->co_freevars))->ob_size);
Access to field 'co_nlocals' results in a dereference of a null pointer (loaded from field 'f_code')
481 fastlocals = f->f_localsplus;
482 for (i = slots; --i >= 0; ++fastlocals)
483 Py_VISIT(*fastlocals)do { if (*fastlocals) { int vret = visit((PyObject *)(*fastlocals
), arg); if (vret) return vret; } } while (0)
;
484
485 /* stack */
486 if (f->f_stacktop != NULL((void*)0)) {
487 for (p = f->f_valuestack; p < f->f_stacktop; p++)
488 Py_VISIT(*p)do { if (*p) { int vret = visit((PyObject *)(*p), arg); if (vret
) return vret; } } while (0)
;
489 }
490 return 0;
491}
492
493static void
494frame_clear(PyFrameObject *f)
495{
496 PyObject **fastlocals, **p, **oldtop;
497 int i, slots;
498
499 /* Before anything else, make sure that this frame is clearly marked
500 * as being defunct! Else, e.g., a generator reachable from this
501 * frame may also point to this frame, believe itself to still be
502 * active, and try cleaning up this frame again.
503 */
504 oldtop = f->f_stacktop;
505 f->f_stacktop = NULL((void*)0);
506
507 Py_CLEAR(f->f_exc_type)do { if (f->f_exc_type) { PyObject *_py_tmp = (PyObject *)
(f->f_exc_type); (f->f_exc_type) = ((void*)0); do { if (
_Py_RefTotal-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0)
{ if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 507, (PyObject *)(_py_tmp)); } else
_Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (
0)
;
508 Py_CLEAR(f->f_exc_value)do { if (f->f_exc_value) { PyObject *_py_tmp = (PyObject *
)(f->f_exc_value); (f->f_exc_value) = ((void*)0); do { if
(_Py_RefTotal-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0
) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 508, (PyObject *)(_py_tmp)); } else
_Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (
0)
;
509 Py_CLEAR(f->f_exc_traceback)do { if (f->f_exc_traceback) { PyObject *_py_tmp = (PyObject
*)(f->f_exc_traceback); (f->f_exc_traceback) = ((void*
)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp))->ob_refcnt
!= 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 509, (PyObject *)(_py_tmp)); } else
_Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (
0)
;
510 Py_CLEAR(f->f_trace)do { if (f->f_trace) { PyObject *_py_tmp = (PyObject *)(f->
f_trace); (f->f_trace) = ((void*)0); do { if (_Py_RefTotal
-- , --((PyObject*)(_py_tmp))->ob_refcnt != 0) { if (((PyObject
*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 510, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *
)(_py_tmp)); } while (0); } } while (0)
;
511
512 /* locals */
513 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars)(((PyVarObject*)(f->f_code->co_cellvars))->ob_size) + PyTuple_GET_SIZE(f->f_code->co_freevars)(((PyVarObject*)(f->f_code->co_freevars))->ob_size);
514 fastlocals = f->f_localsplus;
515 for (i = slots; --i >= 0; ++fastlocals)
516 Py_CLEAR(*fastlocals)do { if (*fastlocals) { PyObject *_py_tmp = (PyObject *)(*fastlocals
); (*fastlocals) = ((void*)0); do { if (_Py_RefTotal-- , --((
PyObject*)(_py_tmp))->ob_refcnt != 0) { if (((PyObject*)_py_tmp
)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 516, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *
)(_py_tmp)); } while (0); } } while (0)
;
517
518 /* stack */
519 if (oldtop != NULL((void*)0)) {
520 for (p = f->f_valuestack; p < oldtop; p++)
521 Py_CLEAR(*p)do { if (*p) { PyObject *_py_tmp = (PyObject *)(*p); (*p) = (
(void*)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp))
->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt
< 0) _Py_NegativeRefcount("Objects/frameobject.c", 521, (
PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp
)); } while (0); } } while (0)
;
522 }
523}
524
525static PyObject *
526frame_sizeof(PyFrameObject *f)
527{
528 Py_ssize_t res, extras, ncells, nfrees;
529
530 ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars)(((PyVarObject*)(f->f_code->co_cellvars))->ob_size);
531 nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars)(((PyVarObject*)(f->f_code->co_freevars))->ob_size);
532 extras = f->f_code->co_stacksize + f->f_code->co_nlocals +
533 ncells + nfrees;
534 /* subtract one as it is already included in PyFrameObject */
535 res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *);
536
537 return PyLong_FromSsize_t(res);
538}
539
540PyDoc_STRVAR(sizeof__doc__,static char sizeof__doc__[] = "F.__sizeof__() -> size of F in memory, in bytes"
541"F.__sizeof__() -> size of F in memory, in bytes")static char sizeof__doc__[] = "F.__sizeof__() -> size of F in memory, in bytes";
542
543static PyMethodDef frame_methods[] = {
544 {"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS0x0004,
545 sizeof__doc__},
546 {NULL((void*)0), NULL((void*)0)} /* sentinel */
547};
548
549PyTypeObject PyFrame_Type = {
550 PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
551 "frame",
552 sizeof(PyFrameObject),
553 sizeof(PyObject *),
554 (destructor)frame_dealloc, /* tp_dealloc */
555 0, /* tp_print */
556 0, /* tp_getattr */
557 0, /* tp_setattr */
558 0, /* tp_reserved */
559 0, /* tp_repr */
560 0, /* tp_as_number */
561 0, /* tp_as_sequence */
562 0, /* tp_as_mapping */
563 0, /* tp_hash */
564 0, /* tp_call */
565 0, /* tp_str */
566 PyObject_GenericGetAttr, /* tp_getattro */
567 PyObject_GenericSetAttr, /* tp_setattro */
568 0, /* tp_as_buffer */
569 Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_HAVE_GC(1L<<14),/* tp_flags */
570 0, /* tp_doc */
571 (traverseproc)frame_traverse, /* tp_traverse */
572 (inquiry)frame_clear, /* tp_clear */
573 0, /* tp_richcompare */
574 0, /* tp_weaklistoffset */
575 0, /* tp_iter */
576 0, /* tp_iternext */
577 frame_methods, /* tp_methods */
578 frame_memberlist, /* tp_members */
579 frame_getsetlist, /* tp_getset */
580 0, /* tp_base */
581 0, /* tp_dict */
582};
583
584static PyObject *builtin_object;
585
586int _PyFrame_Init()
587{
588 builtin_object = PyUnicode_InternFromString("__builtins__");
589 if (builtin_object == NULL((void*)0))
590 return 0;
591 return 1;
592}
593
594PyFrameObject *
595PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
596 PyObject *locals)
597{
598 PyFrameObject *back = tstate->frame;
599 PyFrameObject *f;
600 PyObject *builtins;
601 Py_ssize_t i;
602
603#ifdef Py_DEBUG1
604 if (code == NULL((void*)0) || globals == NULL((void*)0) || !PyDict_Check(globals)((((((PyObject*)(globals))->ob_type))->tp_flags & (
(1L<<29))) != 0)
||
605 (locals != NULL((void*)0) && !PyMapping_Check(locals))) {
606 PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/frameobject.c", 606);
607 return NULL((void*)0);
608 }
609#endif
610 if (back == NULL((void*)0) || back->f_globals != globals) {
611 builtins = PyDict_GetItem(globals, builtin_object);
612 if (builtins) {
613 if (PyModule_Check(builtins)((((PyObject*)(builtins))->ob_type) == (&PyModule_Type
) || PyType_IsSubtype((((PyObject*)(builtins))->ob_type), (
&PyModule_Type)))
) {
614 builtins = PyModule_GetDict(builtins);
615 assert(!builtins || PyDict_Check(builtins))(__builtin_expect(!(!builtins || ((((((PyObject*)(builtins))->
ob_type))->tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn
(__func__, "Objects/frameobject.c", 615, "!builtins || PyDict_Check(builtins)"
) : (void)0)
;
616 }
617 else if (!PyDict_Check(builtins)((((((PyObject*)(builtins))->ob_type))->tp_flags & (
(1L<<29))) != 0)
)
618 builtins = NULL((void*)0);
619 }
620 if (builtins == NULL((void*)0)) {
621 /* No builtins! Make up a minimal one
622 Give them 'None', at least. */
623 builtins = PyDict_New();
624 if (builtins == NULL((void*)0) ||
625 PyDict_SetItemString(
626 builtins, "None", Py_None(&_Py_NoneStruct)) < 0)
627 return NULL((void*)0);
628 }
629 else
630 Py_INCREF(builtins)( _Py_RefTotal++ , ((PyObject*)(builtins))->ob_refcnt++);
631
632 }
633 else {
634 /* If we share the globals, we share the builtins.
635 Save a lookup and a call. */
636 builtins = back->f_builtins;
637 assert(builtins != NULL && PyDict_Check(builtins))(__builtin_expect(!(builtins != ((void*)0) && ((((((PyObject
*)(builtins))->ob_type))->tp_flags & ((1L<<29
))) != 0)), 0) ? __assert_rtn(__func__, "Objects/frameobject.c"
, 637, "builtins != NULL && PyDict_Check(builtins)") :
(void)0)
;
638 Py_INCREF(builtins)( _Py_RefTotal++ , ((PyObject*)(builtins))->ob_refcnt++);
639 }
640 if (code->co_zombieframe != NULL((void*)0)) {
641 f = code->co_zombieframe;
642 code->co_zombieframe = NULL((void*)0);
643 _Py_NewReference((PyObject *)f);
644 assert(f->f_code == code)(__builtin_expect(!(f->f_code == code), 0) ? __assert_rtn(
__func__, "Objects/frameobject.c", 644, "f->f_code == code"
) : (void)0)
;
645 }
646 else {
647 Py_ssize_t extras, ncells, nfrees;
648 ncells = PyTuple_GET_SIZE(code->co_cellvars)(((PyVarObject*)(code->co_cellvars))->ob_size);
649 nfrees = PyTuple_GET_SIZE(code->co_freevars)(((PyVarObject*)(code->co_freevars))->ob_size);
650 extras = code->co_stacksize + code->co_nlocals + ncells +
651 nfrees;
652 if (free_list == NULL((void*)0)) {
653 f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type,( (PyFrameObject *) _PyObject_GC_NewVar((&PyFrame_Type), (
extras)) )
654 extras)( (PyFrameObject *) _PyObject_GC_NewVar((&PyFrame_Type), (
extras)) )
;
655 if (f == NULL((void*)0)) {
656 Py_DECREF(builtins)do { if (_Py_RefTotal-- , --((PyObject*)(builtins))->ob_refcnt
!= 0) { if (((PyObject*)builtins)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 656, (PyObject *)(builtins)); } else
_Py_Dealloc((PyObject *)(builtins)); } while (0)
;
657 return NULL((void*)0);
658 }
659 }
660 else {
661 assert(numfree > 0)(__builtin_expect(!(numfree > 0), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 661, "numfree > 0") : (void)0)
;
662 --numfree;
663 f = free_list;
664 free_list = free_list->f_back;
665 if (Py_SIZE(f)(((PyVarObject*)(f))->ob_size) < extras) {
666 f = PyObject_GC_Resize(PyFrameObject, f, extras)( (PyFrameObject *) _PyObject_GC_Resize((PyVarObject *)(f), (
extras)) )
;
667 if (f == NULL((void*)0)) {
668 Py_DECREF(builtins)do { if (_Py_RefTotal-- , --((PyObject*)(builtins))->ob_refcnt
!= 0) { if (((PyObject*)builtins)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 668, (PyObject *)(builtins)); } else
_Py_Dealloc((PyObject *)(builtins)); } while (0)
;
669 return NULL((void*)0);
670 }
671 }
672 _Py_NewReference((PyObject *)f);
673 }
674
675 f->f_code = code;
676 extras = code->co_nlocals + ncells + nfrees;
677 f->f_valuestack = f->f_localsplus + extras;
678 for (i=0; i<extras; i++)
679 f->f_localsplus[i] = NULL((void*)0);
680 f->f_locals = NULL((void*)0);
681 f->f_trace = NULL((void*)0);
682 f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL((void*)0);
683 }
684 f->f_stacktop = f->f_valuestack;
685 f->f_builtins = builtins;
686 Py_XINCREF(back)do { if ((back) == ((void*)0)) ; else ( _Py_RefTotal++ , ((PyObject
*)(back))->ob_refcnt++); } while (0)
;
687 f->f_back = back;
688 Py_INCREF(code)( _Py_RefTotal++ , ((PyObject*)(code))->ob_refcnt++);
689 Py_INCREF(globals)( _Py_RefTotal++ , ((PyObject*)(globals))->ob_refcnt++);
690 f->f_globals = globals;
691 /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
692 if ((code->co_flags & (CO_NEWLOCALS0x0002 | CO_OPTIMIZED0x0001)) ==
693 (CO_NEWLOCALS0x0002 | CO_OPTIMIZED0x0001))
694 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
695 else if (code->co_flags & CO_NEWLOCALS0x0002) {
696 locals = PyDict_New();
697 if (locals == NULL((void*)0)) {
698 Py_DECREF(f)do { if (_Py_RefTotal-- , --((PyObject*)(f))->ob_refcnt !=
0) { if (((PyObject*)f)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 698, (PyObject *)(f)); } else _Py_Dealloc
((PyObject *)(f)); } while (0)
;
699 return NULL((void*)0);
700 }
701 f->f_locals = locals;
702 }
703 else {
704 if (locals == NULL((void*)0))
705 locals = globals;
706 Py_INCREF(locals)( _Py_RefTotal++ , ((PyObject*)(locals))->ob_refcnt++);
707 f->f_locals = locals;
708 }
709 f->f_tstate = tstate;
710
711 f->f_lasti = -1;
712 f->f_lineno = code->co_firstlineno;
713 f->f_iblock = 0;
714
715 _PyObject_GC_TRACK(f)do { PyGC_Head *g = ((PyGC_Head *)(f)-1); if (g->gc.gc_refs
!= (-2)) Py_FatalError("GC object already tracked"); g->gc
.gc_refs = (-3); g->gc.gc_next = _PyGC_generation0; g->
gc.gc_prev = _PyGC_generation0->gc.gc_prev; g->gc.gc_prev
->gc.gc_next = g; _PyGC_generation0->gc.gc_prev = g; } while
(0);
;
716 return f;
717}
718
719/* Block management */
720
721void
722PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
723{
724 PyTryBlock *b;
725 if (f->f_iblock >= CO_MAXBLOCKS20)
726 Py_FatalError("XXX block stack overflow");
727 b = &f->f_blockstack[f->f_iblock++];
728 b->b_type = type;
729 b->b_level = level;
730 b->b_handler = handler;
731}
732
733PyTryBlock *
734PyFrame_BlockPop(PyFrameObject *f)
735{
736 PyTryBlock *b;
737 if (f->f_iblock <= 0)
738 Py_FatalError("XXX block stack underflow");
739 b = &f->f_blockstack[--f->f_iblock];
740 return b;
741}
742
743/* Convert between "fast" version of locals and dictionary version.
744
745 map and values are input arguments. map is a tuple of strings.
746 values is an array of PyObject*. At index i, map[i] is the name of
747 the variable with value values[i]. The function copies the first
748 nmap variable from map/values into dict. If values[i] is NULL,
749 the variable is deleted from dict.
750
751 If deref is true, then the values being copied are cell variables
752 and the value is extracted from the cell variable before being put
753 in dict.
754
755 Exceptions raised while modifying the dict are silently ignored,
756 because there is no good way to report them.
757 */
758
759static void
760map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
761 int deref)
762{
763 Py_ssize_t j;
764 assert(PyTuple_Check(map))(__builtin_expect(!(((((((PyObject*)(map))->ob_type))->
tp_flags & ((1L<<26))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 764, "PyTuple_Check(map)") : (void
)0)
;
765 assert(PyDict_Check(dict))(__builtin_expect(!(((((((PyObject*)(dict))->ob_type))->
tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 765, "PyDict_Check(dict)") : (void
)0)
;
766 assert(PyTuple_Size(map) >= nmap)(__builtin_expect(!(PyTuple_Size(map) >= nmap), 0) ? __assert_rtn
(__func__, "Objects/frameobject.c", 766, "PyTuple_Size(map) >= nmap"
) : (void)0)
;
767 for (j = nmap; --j >= 0; ) {
768 PyObject *key = PyTuple_GET_ITEM(map, j)(((PyTupleObject *)(map))->ob_item[j]);
769 PyObject *value = values[j];
770 assert(PyUnicode_Check(key))(__builtin_expect(!(((((((PyObject*)(key))->ob_type))->
tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 770, "PyUnicode_Check(key)") : (void
)0)
;
771 if (deref) {
772 assert(PyCell_Check(value))(__builtin_expect(!(((((PyObject*)(value))->ob_type) == &
PyCell_Type)), 0) ? __assert_rtn(__func__, "Objects/frameobject.c"
, 772, "PyCell_Check(value)") : (void)0)
;
773 value = PyCell_GET(value)(((PyCellObject *)(value))->ob_ref);
774 }
775 if (value == NULL((void*)0)) {
776 if (PyObject_DelItem(dict, key) != 0)
777 PyErr_Clear();
778 }
779 else {
780 if (PyObject_SetItem(dict, key, value) != 0)
781 PyErr_Clear();
782 }
783 }
784}
785
786/* Copy values from the "locals" dict into the fast locals.
787
788 dict is an input argument containing string keys representing
789 variables names and arbitrary PyObject* as values.
790
791 map and values are input arguments. map is a tuple of strings.
792 values is an array of PyObject*. At index i, map[i] is the name of
793 the variable with value values[i]. The function copies the first
794 nmap variable from map/values into dict. If values[i] is NULL,
795 the variable is deleted from dict.
796
797 If deref is true, then the values being copied are cell variables
798 and the value is extracted from the cell variable before being put
799 in dict. If clear is true, then variables in map but not in dict
800 are set to NULL in map; if clear is false, variables missing in
801 dict are ignored.
802
803 Exceptions raised while modifying the dict are silently ignored,
804 because there is no good way to report them.
805*/
806
807static void
808dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
809 int deref, int clear)
810{
811 Py_ssize_t j;
812 assert(PyTuple_Check(map))(__builtin_expect(!(((((((PyObject*)(map))->ob_type))->
tp_flags & ((1L<<26))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 812, "PyTuple_Check(map)") : (void
)0)
;
813 assert(PyDict_Check(dict))(__builtin_expect(!(((((((PyObject*)(dict))->ob_type))->
tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 813, "PyDict_Check(dict)") : (void
)0)
;
814 assert(PyTuple_Size(map) >= nmap)(__builtin_expect(!(PyTuple_Size(map) >= nmap), 0) ? __assert_rtn
(__func__, "Objects/frameobject.c", 814, "PyTuple_Size(map) >= nmap"
) : (void)0)
;
815 for (j = nmap; --j >= 0; ) {
816 PyObject *key = PyTuple_GET_ITEM(map, j)(((PyTupleObject *)(map))->ob_item[j]);
817 PyObject *value = PyObject_GetItem(dict, key);
818 assert(PyUnicode_Check(key))(__builtin_expect(!(((((((PyObject*)(key))->ob_type))->
tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 818, "PyUnicode_Check(key)") : (void
)0)
;
819 /* We only care about NULLs if clear is true. */
820 if (value == NULL((void*)0)) {
821 PyErr_Clear();
822 if (!clear)
823 continue;
824 }
825 if (deref) {
826 assert(PyCell_Check(values[j]))(__builtin_expect(!(((((PyObject*)(values[j]))->ob_type) ==
&PyCell_Type)), 0) ? __assert_rtn(__func__, "Objects/frameobject.c"
, 826, "PyCell_Check(values[j])") : (void)0)
;
827 if (PyCell_GET(values[j])(((PyCellObject *)(values[j]))->ob_ref) != value) {
828 if (PyCell_Set(values[j], value) < 0)
829 PyErr_Clear();
830 }
831 } else if (values[j] != value) {
832 Py_XINCREF(value)do { if ((value) == ((void*)0)) ; else ( _Py_RefTotal++ , ((PyObject
*)(value))->ob_refcnt++); } while (0)
;
833 Py_XDECREF(values[j])do { if ((values[j]) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(values[j]))->ob_refcnt != 0) { if (((PyObject
*)values[j])->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 833, (PyObject *)(values[j])); } else _Py_Dealloc((PyObject
*)(values[j])); } while (0); } while (0)
;
834 values[j] = value;
835 }
836 Py_XDECREF(value)do { if ((value) == ((void*)0)) ; else do { if (_Py_RefTotal--
, --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject
*)value)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/frameobject.c"
, 836, (PyObject *)(value)); } else _Py_Dealloc((PyObject *)(
value)); } while (0); } while (0)
;
837 }
838}
839
840void
841PyFrame_FastToLocals(PyFrameObject *f)
842{
843 /* Merge fast locals into f->f_locals */
844 PyObject *locals, *map;
845 PyObject **fast;
846 PyObject *error_type, *error_value, *error_traceback;
847 PyCodeObject *co;
848 Py_ssize_t j;
849 int ncells, nfreevars;
850 if (f == NULL((void*)0))
851 return;
852 locals = f->f_locals;
853 if (locals == NULL((void*)0)) {
854 locals = f->f_locals = PyDict_New();
855 if (locals == NULL((void*)0)) {
856 PyErr_Clear(); /* Can't report it :-( */
857 return;
858 }
859 }
860 co = f->f_code;
861 map = co->co_varnames;
862 if (!PyTuple_Check(map)((((((PyObject*)(map))->ob_type))->tp_flags & ((1L<<
26))) != 0)
)
863 return;
864 PyErr_Fetch(&error_type, &error_value, &error_traceback);
865 fast = f->f_localsplus;
866 j = PyTuple_GET_SIZE(map)(((PyVarObject*)(map))->ob_size);
867 if (j > co->co_nlocals)
868 j = co->co_nlocals;
869 if (co->co_nlocals)
870 map_to_dict(map, j, locals, fast, 0);
871 ncells = PyTuple_GET_SIZE(co->co_cellvars)(((PyVarObject*)(co->co_cellvars))->ob_size);
872 nfreevars = PyTuple_GET_SIZE(co->co_freevars)(((PyVarObject*)(co->co_freevars))->ob_size);
873 if (ncells || nfreevars) {
874 map_to_dict(co->co_cellvars, ncells,
875 locals, fast + co->co_nlocals, 1);
876 /* If the namespace is unoptimized, then one of the
877 following cases applies:
878 1. It does not contain free variables, because it
879 uses import * or is a top-level namespace.
880 2. It is a class namespace.
881 We don't want to accidentally copy free variables
882 into the locals dict used by the class.
883 */
884 if (co->co_flags & CO_OPTIMIZED0x0001) {
885 map_to_dict(co->co_freevars, nfreevars,
886 locals, fast + co->co_nlocals + ncells, 1);
887 }
888 }
889 PyErr_Restore(error_type, error_value, error_traceback);
890}
891
892void
893PyFrame_LocalsToFast(PyFrameObject *f, int clear)
894{
895 /* Merge f->f_locals into fast locals */
896 PyObject *locals, *map;
897 PyObject **fast;
898 PyObject *error_type, *error_value, *error_traceback;
899 PyCodeObject *co;
900 Py_ssize_t j;
901 int ncells, nfreevars;
902 if (f == NULL((void*)0))
903 return;
904 locals = f->f_locals;
905 co = f->f_code;
906 map = co->co_varnames;
907 if (locals == NULL((void*)0))
908 return;
909 if (!PyTuple_Check(map)((((((PyObject*)(map))->ob_type))->tp_flags & ((1L<<
26))) != 0)
)
910 return;
911 PyErr_Fetch(&error_type, &error_value, &error_traceback);
912 fast = f->f_localsplus;
913 j = PyTuple_GET_SIZE(map)(((PyVarObject*)(map))->ob_size);
914 if (j > co->co_nlocals)
915 j = co->co_nlocals;
916 if (co->co_nlocals)
917 dict_to_map(co->co_varnames, j, locals, fast, 0, clear);
918 ncells = PyTuple_GET_SIZE(co->co_cellvars)(((PyVarObject*)(co->co_cellvars))->ob_size);
919 nfreevars = PyTuple_GET_SIZE(co->co_freevars)(((PyVarObject*)(co->co_freevars))->ob_size);
920 if (ncells || nfreevars) {
921 dict_to_map(co->co_cellvars, ncells,
922 locals, fast + co->co_nlocals, 1, clear);
923 /* Same test as in PyFrame_FastToLocals() above. */
924 if (co->co_flags & CO_OPTIMIZED0x0001) {
925 dict_to_map(co->co_freevars, nfreevars,
926 locals, fast + co->co_nlocals + ncells, 1,
927 clear);
928 }
929 }
930 PyErr_Restore(error_type, error_value, error_traceback);
931}
932
933/* Clear out the free list */
934int
935PyFrame_ClearFreeList(void)
936{
937 int freelist_size = numfree;
938
939 while (free_list != NULL((void*)0)) {
940 PyFrameObject *f = free_list;
941 free_list = free_list->f_back;
942 PyObject_GC_Del(f);
943 --numfree;
944 }
945 assert(numfree == 0)(__builtin_expect(!(numfree == 0), 0) ? __assert_rtn(__func__
, "Objects/frameobject.c", 945, "numfree == 0") : (void)0)
;
946 return freelist_size;
947}
948
949void
950PyFrame_Fini(void)
951{
952 (void)PyFrame_ClearFreeList();
953 Py_XDECREF(builtin_object)do { if ((builtin_object) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(builtin_object))->ob_refcnt != 0) { if
(((PyObject*)builtin_object)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/frameobject.c", 953, (PyObject *)(builtin_object));
} else _Py_Dealloc((PyObject *)(builtin_object)); } while (0
); } while (0)
;
954 builtin_object = NULL((void*)0);
955}