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') |
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 | |
17 | static 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 | |
26 | static PyObject * |
27 | frame_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 | |
34 | int |
35 | PyFrame_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 | |
43 | static PyObject * |
44 | frame_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 | */ |
64 | static int |
65 | frame_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 | |
334 | static PyObject * |
335 | frame_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 | |
347 | static int |
348 | frame_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 | |
364 | static 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 | |
415 | static PyFrameObject *free_list = NULL((void*)0); |
416 | static int numfree = 0; /* number of frames currently in free_list */ |
417 | /* max value for numfree */ |
418 | #define PyFrame_MAXFREELIST200 200 |
419 | |
420 | static void |
421 | frame_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 | |
463 | static int |
464 | frame_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 | |
493 | static void |
494 | frame_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 | |
525 | static PyObject * |
526 | frame_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 | |
540 | PyDoc_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 | |
543 | static PyMethodDef frame_methods[] = { |
544 | {"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS0x0004, |
545 | sizeof__doc__}, |
546 | {NULL((void*)0), NULL((void*)0)} /* sentinel */ |
547 | }; |
548 | |
549 | PyTypeObject 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 | |
584 | static PyObject *builtin_object; |
585 | |
586 | int _PyFrame_Init() |
587 | { |
588 | builtin_object = PyUnicode_InternFromString("__builtins__"); |
589 | if (builtin_object == NULL((void*)0)) |
590 | return 0; |
591 | return 1; |
592 | } |
593 | |
594 | PyFrameObject * |
595 | PyFrame_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 | |
721 | void |
722 | PyFrame_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 | |
733 | PyTryBlock * |
734 | PyFrame_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 | |
759 | static void |
760 | map_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 | |
807 | static void |
808 | dict_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 | |
840 | void |
841 | PyFrame_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 | |
892 | void |
893 | PyFrame_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 */ |
934 | int |
935 | PyFrame_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 | |
949 | void |
950 | PyFrame_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 | } |