Changeset 388 for python/vendor/current/Objects/frameobject.c
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Objects/frameobject.c
r2 r388 16 16 17 17 static PyMemberDef frame_memberlist[] = { 18 {"f_back", T_OBJECT, OFF(f_back), RO}, 19 {"f_code", T_OBJECT, OFF(f_code), RO}, 20 {"f_builtins", T_OBJECT, OFF(f_builtins),RO}, 21 {"f_globals", T_OBJECT, OFF(f_globals), RO}, 22 {"f_lasti", T_INT, OFF(f_lasti), RO}, 23 {"f_exc_type", T_OBJECT, OFF(f_exc_type)}, 24 {"f_exc_value", T_OBJECT, OFF(f_exc_value)}, 25 {"f_exc_traceback", T_OBJECT, OFF(f_exc_traceback)}, 26 {NULL} /* Sentinel */ 18 {"f_back", T_OBJECT, OFF(f_back), RO}, 19 {"f_code", T_OBJECT, OFF(f_code), RO}, 20 {"f_builtins", T_OBJECT, OFF(f_builtins),RO}, 21 {"f_globals", T_OBJECT, OFF(f_globals), RO}, 22 {"f_lasti", T_INT, OFF(f_lasti), RO}, 23 {NULL} /* Sentinel */ 27 24 }; 25 26 #define WARN_GET_SET(NAME) \ 27 static PyObject * frame_get_ ## NAME(PyFrameObject *f) { \ 28 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \ 29 return NULL; \ 30 if (f->NAME) { \ 31 Py_INCREF(f->NAME); \ 32 return f->NAME; \ 33 } \ 34 Py_RETURN_NONE; \ 35 } \ 36 static int frame_set_ ## NAME(PyFrameObject *f, PyObject *new) { \ 37 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \ 38 return -1; \ 39 if (f->NAME) { \ 40 Py_CLEAR(f->NAME); \ 41 } \ 42 if (new == Py_None) \ 43 new = NULL; \ 44 Py_XINCREF(new); \ 45 f->NAME = new; \ 46 return 0; \ 47 } 48 49 50 WARN_GET_SET(f_exc_traceback) 51 WARN_GET_SET(f_exc_type) 52 WARN_GET_SET(f_exc_value) 53 28 54 29 55 static PyObject * 30 56 frame_getlocals(PyFrameObject *f, void *closure) 31 57 { 32 PyFrame_FastToLocals(f); 33 Py_INCREF(f->f_locals); 34 return f->f_locals; 58 PyFrame_FastToLocals(f); 59 Py_INCREF(f->f_locals); 60 return f->f_locals; 61 } 62 63 int 64 PyFrame_GetLineNumber(PyFrameObject *f) 65 { 66 if (f->f_trace) 67 return f->f_lineno; 68 else 69 return PyCode_Addr2Line(f->f_code, f->f_lasti); 35 70 } 36 71 … … 38 73 frame_getlineno(PyFrameObject *f, void *closure) 39 74 { 40 int lineno; 41 42 if (f->f_trace) 43 lineno = f->f_lineno; 44 else 45 lineno = PyCode_Addr2Line(f->f_code, f->f_lasti); 46 47 return PyInt_FromLong(lineno); 75 return PyInt_FromLong(PyFrame_GetLineNumber(f)); 48 76 } 49 77 50 78 /* Setter for f_lineno - you can set f_lineno from within a trace function in 51 * order to jump to a given line of code, subject to some restrictions. 79 * order to jump to a given line of code, subject to some restrictions. Most 52 80 * lines are OK to jump to because they don't make any assumptions about the 53 81 * state of the stack (obvious because you could remove the line and the code … … 66 94 frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno) 67 95 { 68 int new_lineno = 0; /* The new value of f_lineno */ 69 int new_lasti = 0; /* The new value of f_lasti */ 70 int new_iblock = 0; /* The new value of f_iblock */ 71 unsigned char *code = NULL; /* The bytecode for the frame... */ 72 Py_ssize_t code_len = 0; /* ...and its length */ 73 unsigned char *lnotab = NULL; /* Iterating over co_lnotab */ 74 Py_ssize_t lnotab_len = 0; /* (ditto) */ 75 int offset = 0; /* (ditto) */ 76 int line = 0; /* (ditto) */ 77 int addr = 0; /* (ditto) */ 78 int min_addr = 0; /* Scanning the SETUPs and POPs */ 79 int max_addr = 0; /* (ditto) */ 80 int delta_iblock = 0; /* (ditto) */ 81 int min_delta_iblock = 0; /* (ditto) */ 82 int min_iblock = 0; /* (ditto) */ 83 int f_lasti_setup_addr = 0; /* Policing no-jump-into-finally */ 84 int new_lasti_setup_addr = 0; /* (ditto) */ 85 int blockstack[CO_MAXBLOCKS]; /* Walking the 'finally' blocks */ 86 int in_finally[CO_MAXBLOCKS]; /* (ditto) */ 87 int blockstack_top = 0; /* (ditto) */ 88 unsigned char setup_op = 0; /* (ditto) */ 89 char *tmp; 90 91 /* f_lineno must be an integer. */ 92 if (!PyInt_Check(p_new_lineno)) { 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 trace function"); 104 return -1; 105 } 106 107 /* Fail if the line comes before the start of the code block. */ 108 new_lineno = (int) PyInt_AsLong(p_new_lineno); 109 if (new_lineno < f->f_code->co_firstlineno) { 110 PyErr_Format(PyExc_ValueError, 111 "line %d comes before the current code block", 112 new_lineno); 113 return -1; 114 } 115 116 /* Find the bytecode offset for the start of the given line, or the 117 * first code-owning line after it. */ 118 PyString_AsStringAndSize(f->f_code->co_lnotab, 119 &tmp, &lnotab_len); 120 lnotab = (unsigned char *) tmp; 121 addr = 0; 122 line = f->f_code->co_firstlineno; 123 new_lasti = -1; 124 for (offset = 0; offset < lnotab_len; offset += 2) { 125 addr += lnotab[offset]; 126 line += lnotab[offset+1]; 127 if (line >= new_lineno) { 128 new_lasti = addr; 129 new_lineno = line; 130 break; 131 } 132 } 133 134 /* If we didn't reach the requested line, return an error. */ 135 if (new_lasti == -1) { 136 PyErr_Format(PyExc_ValueError, 137 "line %d comes after the current code block", 138 new_lineno); 139 return -1; 140 } 141 142 /* We're now ready to look at the bytecode. */ 143 PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len); 144 min_addr = MIN(new_lasti, f->f_lasti); 145 max_addr = MAX(new_lasti, f->f_lasti); 146 147 /* You can't jump onto a line with an 'except' statement on it - 148 * they expect to have an exception on the top of the stack, which 149 * won't be true if you jump to them. They always start with code 150 * that either pops the exception using POP_TOP (plain 'except:' 151 * lines do this) or duplicates the exception on the stack using 152 * DUP_TOP (if there's an exception type specified). See compile.c, 153 * 'com_try_except' for the full details. There aren't any other 154 * cases (AFAIK) where a line's code can start with DUP_TOP or 155 * POP_TOP, but if any ever appear, they'll be subject to the same 156 * restriction (but with a different error message). */ 157 if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) { 158 PyErr_SetString(PyExc_ValueError, 159 "can't jump to 'except' line as there's no exception"); 160 return -1; 161 } 162 163 /* You can't jump into or out of a 'finally' block because the 'try' 164 * block leaves something on the stack for the END_FINALLY to clean 165 * up. So we walk the bytecode, maintaining a simulated blockstack. 166 * When we reach the old or new address and it's in a 'finally' block 167 * we note the address of the corresponding SETUP_FINALLY. The jump 168 * is only legal if neither address is in a 'finally' block or 169 * they're both in the same one. 'blockstack' is a stack of the 170 * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks 171 * whether we're in a 'finally' block at each blockstack level. */ 172 f_lasti_setup_addr = -1; 173 new_lasti_setup_addr = -1; 174 memset(blockstack, '\0', sizeof(blockstack)); 175 memset(in_finally, '\0', sizeof(in_finally)); 176 blockstack_top = 0; 177 for (addr = 0; addr < code_len; addr++) { 178 unsigned char op = code[addr]; 179 switch (op) { 180 case SETUP_LOOP: 181 case SETUP_EXCEPT: 182 case SETUP_FINALLY: 183 blockstack[blockstack_top++] = addr; 184 in_finally[blockstack_top-1] = 0; 185 break; 186 187 case POP_BLOCK: 188 assert(blockstack_top > 0); 189 setup_op = code[blockstack[blockstack_top-1]]; 190 if (setup_op == SETUP_FINALLY) { 191 in_finally[blockstack_top-1] = 1; 192 } 193 else { 194 blockstack_top--; 195 } 196 break; 197 198 case END_FINALLY: 199 /* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist 200 * in the bytecode but don't correspond to an actual 201 * 'finally' block. (If blockstack_top is 0, we must 202 * be seeing such an END_FINALLY.) */ 203 if (blockstack_top > 0) { 204 setup_op = code[blockstack[blockstack_top-1]]; 205 if (setup_op == SETUP_FINALLY) { 206 blockstack_top--; 207 } 208 } 209 break; 210 } 211 212 /* For the addresses we're interested in, see whether they're 213 * within a 'finally' block and if so, remember the address 214 * of the SETUP_FINALLY. */ 215 if (addr == new_lasti || addr == f->f_lasti) { 216 int i = 0; 217 int setup_addr = -1; 218 for (i = blockstack_top-1; i >= 0; i--) { 219 if (in_finally[i]) { 220 setup_addr = blockstack[i]; 221 break; 222 } 223 } 224 225 if (setup_addr != -1) { 226 if (addr == new_lasti) { 227 new_lasti_setup_addr = setup_addr; 228 } 229 230 if (addr == f->f_lasti) { 231 f_lasti_setup_addr = setup_addr; 232 } 233 } 234 } 235 236 if (op >= HAVE_ARGUMENT) { 237 addr += 2; 238 } 239 } 240 241 /* Verify that the blockstack tracking code didn't get lost. */ 242 assert(blockstack_top == 0); 243 244 /* After all that, are we jumping into / out of a 'finally' block? */ 245 if (new_lasti_setup_addr != f_lasti_setup_addr) { 246 PyErr_SetString(PyExc_ValueError, 247 "can't jump into or out of a 'finally' block"); 248 return -1; 249 } 250 251 252 /* Police block-jumping (you can't jump into the middle of a block) 253 * and ensure that the blockstack finishes up in a sensible state (by 254 * popping any blocks we're jumping out of). We look at all the 255 * blockstack operations between the current position and the new 256 * one, and keep track of how many blocks we drop out of on the way. 257 * By also keeping track of the lowest blockstack position we see, we 258 * can tell whether the jump goes into any blocks without coming out 259 * again - in that case we raise an exception below. */ 260 delta_iblock = 0; 261 for (addr = min_addr; addr < max_addr; addr++) { 262 unsigned char op = code[addr]; 263 switch (op) { 264 case SETUP_LOOP: 265 case SETUP_EXCEPT: 266 case SETUP_FINALLY: 267 delta_iblock++; 268 break; 269 270 case POP_BLOCK: 271 delta_iblock--; 272 break; 273 } 274 275 min_delta_iblock = MIN(min_delta_iblock, delta_iblock); 276 277 if (op >= HAVE_ARGUMENT) { 278 addr += 2; 279 } 280 } 281 282 /* Derive the absolute iblock values from the deltas. */ 283 min_iblock = f->f_iblock + min_delta_iblock; 284 if (new_lasti > f->f_lasti) { 285 /* Forwards jump. */ 286 new_iblock = f->f_iblock + delta_iblock; 287 } 288 else { 289 /* Backwards jump. */ 290 new_iblock = f->f_iblock - delta_iblock; 291 } 292 293 /* Are we jumping into a block? */ 294 if (new_iblock > min_iblock) { 295 PyErr_SetString(PyExc_ValueError, 296 "can't jump into the middle of a block"); 297 return -1; 298 } 299 300 /* Pop any blocks that we're jumping out of. */ 301 while (f->f_iblock > new_iblock) { 302 PyTryBlock *b = &f->f_blockstack[--f->f_iblock]; 303 while ((f->f_stacktop - f->f_valuestack) > b->b_level) { 304 PyObject *v = (*--f->f_stacktop); 305 Py_DECREF(v); 306 } 307 } 308 309 /* Finally set the new f_lineno and f_lasti and return OK. */ 310 f->f_lineno = new_lineno; 311 f->f_lasti = new_lasti; 312 return 0; 96 int new_lineno = 0; /* The new value of f_lineno */ 97 int new_lasti = 0; /* The new value of f_lasti */ 98 int new_iblock = 0; /* The new value of f_iblock */ 99 unsigned char *code = NULL; /* The bytecode for the frame... */ 100 Py_ssize_t code_len = 0; /* ...and its length */ 101 unsigned char *lnotab = NULL; /* Iterating over co_lnotab */ 102 Py_ssize_t lnotab_len = 0; /* (ditto) */ 103 int offset = 0; /* (ditto) */ 104 int line = 0; /* (ditto) */ 105 int addr = 0; /* (ditto) */ 106 int min_addr = 0; /* Scanning the SETUPs and POPs */ 107 int max_addr = 0; /* (ditto) */ 108 int delta_iblock = 0; /* (ditto) */ 109 int min_delta_iblock = 0; /* (ditto) */ 110 int min_iblock = 0; /* (ditto) */ 111 int f_lasti_setup_addr = 0; /* Policing no-jump-into-finally */ 112 int new_lasti_setup_addr = 0; /* (ditto) */ 113 int blockstack[CO_MAXBLOCKS]; /* Walking the 'finally' blocks */ 114 int in_finally[CO_MAXBLOCKS]; /* (ditto) */ 115 int blockstack_top = 0; /* (ditto) */ 116 unsigned char setup_op = 0; /* (ditto) */ 117 118 /* f_lineno must be an integer. */ 119 if (!PyInt_Check(p_new_lineno)) { 120 PyErr_SetString(PyExc_ValueError, 121 "lineno must be an integer"); 122 return -1; 123 } 124 125 /* You can only do this from within a trace function, not via 126 * _getframe or similar hackery. */ 127 if (!f->f_trace) 128 { 129 PyErr_Format(PyExc_ValueError, 130 "f_lineno can only be set by a" 131 " line trace function"); 132 return -1; 133 } 134 135 /* Fail if the line comes before the start of the code block. */ 136 new_lineno = (int) PyInt_AsLong(p_new_lineno); 137 if (new_lineno < f->f_code->co_firstlineno) { 138 PyErr_Format(PyExc_ValueError, 139 "line %d comes before the current code block", 140 new_lineno); 141 return -1; 142 } 143 else if (new_lineno == f->f_code->co_firstlineno) { 144 new_lasti = 0; 145 new_lineno = f->f_code->co_firstlineno; 146 } 147 else { 148 /* Find the bytecode offset for the start of the given 149 * line, or the first code-owning line after it. */ 150 char *tmp; 151 PyString_AsStringAndSize(f->f_code->co_lnotab, 152 &tmp, &lnotab_len); 153 lnotab = (unsigned char *) tmp; 154 addr = 0; 155 line = f->f_code->co_firstlineno; 156 new_lasti = -1; 157 for (offset = 0; offset < lnotab_len; offset += 2) { 158 addr += lnotab[offset]; 159 line += lnotab[offset+1]; 160 if (line >= new_lineno) { 161 new_lasti = addr; 162 new_lineno = line; 163 break; 164 } 165 } 166 } 167 168 /* If we didn't reach the requested line, return an error. */ 169 if (new_lasti == -1) { 170 PyErr_Format(PyExc_ValueError, 171 "line %d comes after the current code block", 172 new_lineno); 173 return -1; 174 } 175 176 /* We're now ready to look at the bytecode. */ 177 PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len); 178 min_addr = MIN(new_lasti, f->f_lasti); 179 max_addr = MAX(new_lasti, f->f_lasti); 180 181 /* You can't jump onto a line with an 'except' statement on it - 182 * they expect to have an exception on the top of the stack, which 183 * won't be true if you jump to them. They always start with code 184 * that either pops the exception using POP_TOP (plain 'except:' 185 * lines do this) or duplicates the exception on the stack using 186 * DUP_TOP (if there's an exception type specified). See compile.c, 187 * 'com_try_except' for the full details. There aren't any other 188 * cases (AFAIK) where a line's code can start with DUP_TOP or 189 * POP_TOP, but if any ever appear, they'll be subject to the same 190 * restriction (but with a different error message). */ 191 if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) { 192 PyErr_SetString(PyExc_ValueError, 193 "can't jump to 'except' line as there's no exception"); 194 return -1; 195 } 196 197 /* You can't jump into or out of a 'finally' block because the 'try' 198 * block leaves something on the stack for the END_FINALLY to clean 199 * up. So we walk the bytecode, maintaining a simulated blockstack. 200 * When we reach the old or new address and it's in a 'finally' block 201 * we note the address of the corresponding SETUP_FINALLY. The jump 202 * is only legal if neither address is in a 'finally' block or 203 * they're both in the same one. 'blockstack' is a stack of the 204 * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks 205 * whether we're in a 'finally' block at each blockstack level. */ 206 f_lasti_setup_addr = -1; 207 new_lasti_setup_addr = -1; 208 memset(blockstack, '\0', sizeof(blockstack)); 209 memset(in_finally, '\0', sizeof(in_finally)); 210 blockstack_top = 0; 211 for (addr = 0; addr < code_len; addr++) { 212 unsigned char op = code[addr]; 213 switch (op) { 214 case SETUP_LOOP: 215 case SETUP_EXCEPT: 216 case SETUP_FINALLY: 217 case SETUP_WITH: 218 blockstack[blockstack_top++] = addr; 219 in_finally[blockstack_top-1] = 0; 220 break; 221 222 case POP_BLOCK: 223 assert(blockstack_top > 0); 224 setup_op = code[blockstack[blockstack_top-1]]; 225 if (setup_op == SETUP_FINALLY || setup_op == SETUP_WITH) { 226 in_finally[blockstack_top-1] = 1; 227 } 228 else { 229 blockstack_top--; 230 } 231 break; 232 233 case END_FINALLY: 234 /* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist 235 * in the bytecode but don't correspond to an actual 236 * 'finally' block. (If blockstack_top is 0, we must 237 * be seeing such an END_FINALLY.) */ 238 if (blockstack_top > 0) { 239 setup_op = code[blockstack[blockstack_top-1]]; 240 if (setup_op == SETUP_FINALLY || setup_op == SETUP_WITH) { 241 blockstack_top--; 242 } 243 } 244 break; 245 } 246 247 /* For the addresses we're interested in, see whether they're 248 * within a 'finally' block and if so, remember the address 249 * of the SETUP_FINALLY. */ 250 if (addr == new_lasti || addr == f->f_lasti) { 251 int i = 0; 252 int setup_addr = -1; 253 for (i = blockstack_top-1; i >= 0; i--) { 254 if (in_finally[i]) { 255 setup_addr = blockstack[i]; 256 break; 257 } 258 } 259 260 if (setup_addr != -1) { 261 if (addr == new_lasti) { 262 new_lasti_setup_addr = setup_addr; 263 } 264 265 if (addr == f->f_lasti) { 266 f_lasti_setup_addr = setup_addr; 267 } 268 } 269 } 270 271 if (op >= HAVE_ARGUMENT) { 272 addr += 2; 273 } 274 } 275 276 /* Verify that the blockstack tracking code didn't get lost. */ 277 assert(blockstack_top == 0); 278 279 /* After all that, are we jumping into / out of a 'finally' block? */ 280 if (new_lasti_setup_addr != f_lasti_setup_addr) { 281 PyErr_SetString(PyExc_ValueError, 282 "can't jump into or out of a 'finally' block"); 283 return -1; 284 } 285 286 287 /* Police block-jumping (you can't jump into the middle of a block) 288 * and ensure that the blockstack finishes up in a sensible state (by 289 * popping any blocks we're jumping out of). We look at all the 290 * blockstack operations between the current position and the new 291 * one, and keep track of how many blocks we drop out of on the way. 292 * By also keeping track of the lowest blockstack position we see, we 293 * can tell whether the jump goes into any blocks without coming out 294 * again - in that case we raise an exception below. */ 295 delta_iblock = 0; 296 for (addr = min_addr; addr < max_addr; addr++) { 297 unsigned char op = code[addr]; 298 switch (op) { 299 case SETUP_LOOP: 300 case SETUP_EXCEPT: 301 case SETUP_FINALLY: 302 case SETUP_WITH: 303 delta_iblock++; 304 break; 305 306 case POP_BLOCK: 307 delta_iblock--; 308 break; 309 } 310 311 min_delta_iblock = MIN(min_delta_iblock, delta_iblock); 312 313 if (op >= HAVE_ARGUMENT) { 314 addr += 2; 315 } 316 } 317 318 /* Derive the absolute iblock values from the deltas. */ 319 min_iblock = f->f_iblock + min_delta_iblock; 320 if (new_lasti > f->f_lasti) { 321 /* Forwards jump. */ 322 new_iblock = f->f_iblock + delta_iblock; 323 } 324 else { 325 /* Backwards jump. */ 326 new_iblock = f->f_iblock - delta_iblock; 327 } 328 329 /* Are we jumping into a block? */ 330 if (new_iblock > min_iblock) { 331 PyErr_SetString(PyExc_ValueError, 332 "can't jump into the middle of a block"); 333 return -1; 334 } 335 336 /* Pop any blocks that we're jumping out of. */ 337 while (f->f_iblock > new_iblock) { 338 PyTryBlock *b = &f->f_blockstack[--f->f_iblock]; 339 while ((f->f_stacktop - f->f_valuestack) > b->b_level) { 340 PyObject *v = (*--f->f_stacktop); 341 Py_DECREF(v); 342 } 343 } 344 345 /* Finally set the new f_lineno and f_lasti and return OK. */ 346 f->f_lineno = new_lineno; 347 f->f_lasti = new_lasti; 348 return 0; 313 349 } 314 350 … … 316 352 frame_gettrace(PyFrameObject *f, void *closure) 317 353 { 318 319 320 321 322 323 324 325 354 PyObject* trace = f->f_trace; 355 356 if (trace == NULL) 357 trace = Py_None; 358 359 Py_INCREF(trace); 360 361 return trace; 326 362 } 327 363 … … 329 365 frame_settrace(PyFrameObject *f, PyObject* v, void *closure) 330 366 { 331 /* We rely on f_lineno being accurate when f_trace is set. */ 332 333 PyObject* old_value = f->f_trace; 334 335 Py_XINCREF(v); 336 f->f_trace = v; 337 338 if (v != NULL) 339 f->f_lineno = PyCode_Addr2Line(f->f_code, f->f_lasti); 340 341 Py_XDECREF(old_value); 342 343 return 0; 367 PyObject* old_value; 368 369 /* We rely on f_lineno being accurate when f_trace is set. */ 370 f->f_lineno = PyFrame_GetLineNumber(f); 371 372 old_value = f->f_trace; 373 Py_XINCREF(v); 374 f->f_trace = v; 375 Py_XDECREF(old_value); 376 377 return 0; 344 378 } 345 379 … … 347 381 frame_getrestricted(PyFrameObject *f, void *closure) 348 382 { 349 383 return PyBool_FromLong(PyFrame_IsRestricted(f)); 350 384 } 351 385 352 386 static PyGetSetDef frame_getsetlist[] = { 353 {"f_locals", (getter)frame_getlocals, NULL, NULL}, 354 {"f_lineno", (getter)frame_getlineno, 355 (setter)frame_setlineno, NULL}, 356 {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL}, 357 {"f_restricted",(getter)frame_getrestricted,NULL, NULL}, 358 {0} 387 {"f_locals", (getter)frame_getlocals, NULL, NULL}, 388 {"f_lineno", (getter)frame_getlineno, 389 (setter)frame_setlineno, NULL}, 390 {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL}, 391 {"f_restricted",(getter)frame_getrestricted,NULL, NULL}, 392 {"f_exc_traceback", (getter)frame_get_f_exc_traceback, 393 (setter)frame_set_f_exc_traceback, NULL}, 394 {"f_exc_type", (getter)frame_get_f_exc_type, 395 (setter)frame_set_f_exc_type, NULL}, 396 {"f_exc_value", (getter)frame_get_f_exc_value, 397 (setter)frame_set_f_exc_value, NULL}, 398 {0} 359 399 }; 360 400 … … 373 413 374 414 * ob_type, ob_size, f_code, f_valuestack; 375 415 376 416 * f_locals, f_trace, 377 417 f_exc_type, f_exc_value, f_exc_traceback are NULL; … … 384 424 a stack frame is on the free list, only the following members have 385 425 a meaning: 386 ob_type== &Frametype387 f_backnext item on free list, or NULL388 f_stacksizesize of value stack389 ob_sizesize of localsplus426 ob_type == &Frametype 427 f_back next item on free list, or NULL 428 f_stacksize size of value stack 429 ob_size size of localsplus 390 430 Note that the value and block stacks are preserved -- this can save 391 431 another malloc() call or two (and two free() calls as well!). … … 403 443 404 444 static PyFrameObject *free_list = NULL; 405 static int numfree = 0; 445 static int numfree = 0; /* number of frames currently in free_list */ 406 446 /* max value for numfree */ 407 #define PyFrame_MAXFREELIST 200 447 #define PyFrame_MAXFREELIST 200 408 448 409 449 static void 410 450 frame_dealloc(PyFrameObject *f) 411 451 { 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 else 446 447 448 449 452 PyObject **p, **valuestack; 453 PyCodeObject *co; 454 455 PyObject_GC_UnTrack(f); 456 Py_TRASHCAN_SAFE_BEGIN(f) 457 /* Kill all local variables */ 458 valuestack = f->f_valuestack; 459 for (p = f->f_localsplus; p < valuestack; p++) 460 Py_CLEAR(*p); 461 462 /* Free stack */ 463 if (f->f_stacktop != NULL) { 464 for (p = valuestack; p < f->f_stacktop; p++) 465 Py_XDECREF(*p); 466 } 467 468 Py_XDECREF(f->f_back); 469 Py_DECREF(f->f_builtins); 470 Py_DECREF(f->f_globals); 471 Py_CLEAR(f->f_locals); 472 Py_CLEAR(f->f_trace); 473 Py_CLEAR(f->f_exc_type); 474 Py_CLEAR(f->f_exc_value); 475 Py_CLEAR(f->f_exc_traceback); 476 477 co = f->f_code; 478 if (co->co_zombieframe == NULL) 479 co->co_zombieframe = f; 480 else if (numfree < PyFrame_MAXFREELIST) { 481 ++numfree; 482 f->f_back = free_list; 483 free_list = f; 484 } 485 else 486 PyObject_GC_Del(f); 487 488 Py_DECREF(co); 489 Py_TRASHCAN_SAFE_END(f) 450 490 } 451 491 … … 453 493 frame_traverse(PyFrameObject *f, visitproc visit, void *arg) 454 494 { 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 495 PyObject **fastlocals, **p; 496 int i, slots; 497 498 Py_VISIT(f->f_back); 499 Py_VISIT(f->f_code); 500 Py_VISIT(f->f_builtins); 501 Py_VISIT(f->f_globals); 502 Py_VISIT(f->f_locals); 503 Py_VISIT(f->f_trace); 504 Py_VISIT(f->f_exc_type); 505 Py_VISIT(f->f_exc_value); 506 Py_VISIT(f->f_exc_traceback); 507 508 /* locals */ 509 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars); 510 fastlocals = f->f_localsplus; 511 for (i = slots; --i >= 0; ++fastlocals) 512 Py_VISIT(*fastlocals); 513 514 /* stack */ 515 if (f->f_stacktop != NULL) { 516 for (p = f->f_valuestack; p < f->f_stacktop; p++) 517 Py_VISIT(*p); 518 } 519 return 0; 480 520 } 481 521 … … 483 523 frame_clear(PyFrameObject *f) 484 524 { 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 525 PyObject **fastlocals, **p, **oldtop; 526 int i, slots; 527 528 /* Before anything else, make sure that this frame is clearly marked 529 * as being defunct! Else, e.g., a generator reachable from this 530 * frame may also point to this frame, believe itself to still be 531 * active, and try cleaning up this frame again. 532 */ 533 oldtop = f->f_stacktop; 534 f->f_stacktop = NULL; 535 536 Py_CLEAR(f->f_exc_type); 537 Py_CLEAR(f->f_exc_value); 538 Py_CLEAR(f->f_exc_traceback); 539 Py_CLEAR(f->f_trace); 540 541 /* locals */ 542 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars); 543 fastlocals = f->f_localsplus; 544 for (i = slots; --i >= 0; ++fastlocals) 545 Py_CLEAR(*fastlocals); 546 547 /* stack */ 548 if (oldtop != NULL) { 549 for (p = f->f_valuestack; p < oldtop; p++) 550 Py_CLEAR(*p); 551 } 512 552 } 513 553 … … 515 555 frame_sizeof(PyFrameObject *f) 516 556 { 517 518 519 520 521 522 523 524 525 526 557 Py_ssize_t res, extras, ncells, nfrees; 558 559 ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars); 560 nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars); 561 extras = f->f_code->co_stacksize + f->f_code->co_nlocals + 562 ncells + nfrees; 563 /* subtract one as it is already included in PyFrameObject */ 564 res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *); 565 566 return PyInt_FromSsize_t(res); 527 567 } 528 568 … … 531 571 532 572 static PyMethodDef frame_methods[] = { 533 {"__sizeof__", (PyCFunction)frame_sizeof,METH_NOARGS,534 535 {NULL, NULL}/* sentinel */573 {"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS, 574 sizeof__doc__}, 575 {NULL, NULL} /* sentinel */ 536 576 }; 537 577 538 578 PyTypeObject PyFrame_Type = { 539 540 541 542 543 (destructor)frame_dealloc,/* tp_dealloc */544 0,/* tp_print */545 0,/* tp_getattr */546 0,/* tp_setattr */547 0,/* tp_compare */548 0,/* tp_repr */549 0,/* tp_as_number */550 0,/* tp_as_sequence */551 0,/* tp_as_mapping */552 0,/* tp_hash */553 0,/* tp_call */554 0,/* tp_str */555 PyObject_GenericGetAttr,/* tp_getattro */556 PyObject_GenericSetAttr,/* tp_setattro */557 0,/* tp_as_buffer */558 559 0,/* tp_doc */560 (traverseproc)frame_traverse,/* tp_traverse */561 (inquiry)frame_clear,/* tp_clear */562 0,/* tp_richcompare */563 0,/* tp_weaklistoffset */564 0,/* tp_iter */565 0,/* tp_iternext */566 frame_methods,/* tp_methods */567 frame_memberlist,/* tp_members */568 frame_getsetlist,/* tp_getset */569 0,/* tp_base */570 0,/* tp_dict */579 PyVarObject_HEAD_INIT(&PyType_Type, 0) 580 "frame", 581 sizeof(PyFrameObject), 582 sizeof(PyObject *), 583 (destructor)frame_dealloc, /* tp_dealloc */ 584 0, /* tp_print */ 585 0, /* tp_getattr */ 586 0, /* tp_setattr */ 587 0, /* tp_compare */ 588 0, /* tp_repr */ 589 0, /* tp_as_number */ 590 0, /* tp_as_sequence */ 591 0, /* tp_as_mapping */ 592 0, /* tp_hash */ 593 0, /* tp_call */ 594 0, /* tp_str */ 595 PyObject_GenericGetAttr, /* tp_getattro */ 596 PyObject_GenericSetAttr, /* tp_setattro */ 597 0, /* tp_as_buffer */ 598 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 599 0, /* tp_doc */ 600 (traverseproc)frame_traverse, /* tp_traverse */ 601 (inquiry)frame_clear, /* tp_clear */ 602 0, /* tp_richcompare */ 603 0, /* tp_weaklistoffset */ 604 0, /* tp_iter */ 605 0, /* tp_iternext */ 606 frame_methods, /* tp_methods */ 607 frame_memberlist, /* tp_members */ 608 frame_getsetlist, /* tp_getset */ 609 0, /* tp_base */ 610 0, /* tp_dict */ 571 611 }; 572 612 … … 575 615 int _PyFrame_Init() 576 616 { 577 578 579 580 617 builtin_object = PyString_InternFromString("__builtins__"); 618 if (builtin_object == NULL) 619 return 0; 620 return 1; 581 621 } 582 622 583 623 PyFrameObject * 584 624 PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, 585 586 { 587 588 589 590 625 PyObject *locals) 626 { 627 PyFrameObject *back = tstate->frame; 628 PyFrameObject *f; 629 PyObject *builtins; 630 Py_ssize_t i; 591 631 592 632 #ifdef Py_DEBUG 593 594 595 596 597 633 if (code == NULL || globals == NULL || !PyDict_Check(globals) || 634 (locals != NULL && !PyMapping_Check(locals))) { 635 PyErr_BadInternalCall(); 636 return NULL; 637 } 598 638 #endif 599 600 601 602 603 604 605 606 607 608 609 610 /* No builtins!Make up a minimal one611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 639 if (back == NULL || back->f_globals != globals) { 640 builtins = PyDict_GetItem(globals, builtin_object); 641 if (builtins) { 642 if (PyModule_Check(builtins)) { 643 builtins = PyModule_GetDict(builtins); 644 assert(!builtins || PyDict_Check(builtins)); 645 } 646 else if (!PyDict_Check(builtins)) 647 builtins = NULL; 648 } 649 if (builtins == NULL) { 650 /* No builtins! Make up a minimal one 651 Give them 'None', at least. */ 652 builtins = PyDict_New(); 653 if (builtins == NULL || 654 PyDict_SetItemString( 655 builtins, "None", Py_None) < 0) 656 return NULL; 657 } 658 else 659 Py_INCREF(builtins); 660 661 } 662 else { 663 /* If we share the globals, we share the builtins. 664 Save a lookup and a call. */ 665 builtins = back->f_builtins; 666 assert(builtins != NULL && PyDict_Check(builtins)); 667 Py_INCREF(builtins); 668 } 669 if (code->co_zombieframe != NULL) { 670 f = code->co_zombieframe; 671 code->co_zombieframe = NULL; 672 _Py_NewReference((PyObject *)f); 673 assert(f->f_code == code); 674 } 675 else { 676 Py_ssize_t extras, ncells, nfrees; 677 ncells = PyTuple_GET_SIZE(code->co_cellvars); 678 nfrees = PyTuple_GET_SIZE(code->co_freevars); 679 extras = code->co_stacksize + code->co_nlocals + ncells + 680 nfrees; 681 if (free_list == NULL) { 682 f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, 683 extras); 684 if (f == NULL) { 685 Py_DECREF(builtins); 686 return NULL; 687 } 688 } 689 else { 690 assert(numfree > 0); 691 --numfree; 692 f = free_list; 693 free_list = free_list->f_back; 694 if (Py_SIZE(f) < extras) { 695 f = PyObject_GC_Resize(PyFrameObject, f, extras); 696 if (f == NULL) { 697 Py_DECREF(builtins); 698 return NULL; 699 } 700 } 701 _Py_NewReference((PyObject *)f); 702 } 703 704 f->f_code = code; 705 extras = code->co_nlocals + ncells + nfrees; 706 f->f_valuestack = f->f_localsplus + extras; 707 for (i=0; i<extras; i++) 708 f->f_localsplus[i] = NULL; 709 f->f_locals = NULL; 710 f->f_trace = NULL; 711 f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL; 712 } 713 f->f_stacktop = f->f_valuestack; 714 f->f_builtins = builtins; 715 Py_XINCREF(back); 716 f->f_back = back; 717 Py_INCREF(code); 718 Py_INCREF(globals); 719 f->f_globals = globals; 720 /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */ 721 if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) == 722 (CO_NEWLOCALS | CO_OPTIMIZED)) 723 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */ 724 else if (code->co_flags & CO_NEWLOCALS) { 725 locals = PyDict_New(); 726 if (locals == NULL) { 727 Py_DECREF(f); 728 return NULL; 729 } 730 f->f_locals = locals; 731 } 732 else { 733 if (locals == NULL) 734 locals = globals; 735 Py_INCREF(locals); 736 f->f_locals = locals; 737 } 738 f->f_tstate = tstate; 739 740 f->f_lasti = -1; 741 f->f_lineno = code->co_firstlineno; 742 f->f_iblock = 0; 743 744 _PyObject_GC_TRACK(f); 745 return f; 706 746 } 707 747 … … 711 751 PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level) 712 752 { 713 714 715 716 717 718 719 753 PyTryBlock *b; 754 if (f->f_iblock >= CO_MAXBLOCKS) 755 Py_FatalError("XXX block stack overflow"); 756 b = &f->f_blockstack[f->f_iblock++]; 757 b->b_type = type; 758 b->b_level = level; 759 b->b_handler = handler; 720 760 } 721 761 … … 723 763 PyFrame_BlockPop(PyFrameObject *f) 724 764 { 725 726 727 728 729 765 PyTryBlock *b; 766 if (f->f_iblock <= 0) 767 Py_FatalError("XXX block stack underflow"); 768 b = &f->f_blockstack[--f->f_iblock]; 769 return b; 730 770 } 731 771 732 772 /* Convert between "fast" version of locals and dictionary version. 733 734 map and values are input arguments. 773 774 map and values are input arguments. map is a tuple of strings. 735 775 values is an array of PyObject*. At index i, map[i] is the name of 736 776 the variable with value values[i]. The function copies the first … … 748 788 static void 749 789 map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, 750 751 { 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 790 int deref) 791 { 792 Py_ssize_t j; 793 assert(PyTuple_Check(map)); 794 assert(PyDict_Check(dict)); 795 assert(PyTuple_Size(map) >= nmap); 796 for (j = nmap; --j >= 0; ) { 797 PyObject *key = PyTuple_GET_ITEM(map, j); 798 PyObject *value = values[j]; 799 assert(PyString_Check(key)); 800 if (deref) { 801 assert(PyCell_Check(value)); 802 value = PyCell_GET(value); 803 } 804 if (value == NULL) { 805 if (PyObject_DelItem(dict, key) != 0) 806 PyErr_Clear(); 807 } 808 else { 809 if (PyObject_SetItem(dict, key, value) != 0) 810 PyErr_Clear(); 811 } 812 } 773 813 } 774 814 … … 778 818 variables names and arbitrary PyObject* as values. 779 819 780 map and values are input arguments. 820 map and values are input arguments. map is a tuple of strings. 781 821 values is an array of PyObject*. At index i, map[i] is the name of 782 822 the variable with value values[i]. The function copies the first … … 796 836 static void 797 837 dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, 798 799 { 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 838 int deref, int clear) 839 { 840 Py_ssize_t j; 841 assert(PyTuple_Check(map)); 842 assert(PyDict_Check(dict)); 843 assert(PyTuple_Size(map) >= nmap); 844 for (j = nmap; --j >= 0; ) { 845 PyObject *key = PyTuple_GET_ITEM(map, j); 846 PyObject *value = PyObject_GetItem(dict, key); 847 assert(PyString_Check(key)); 848 /* We only care about NULLs if clear is true. */ 849 if (value == NULL) { 850 PyErr_Clear(); 851 if (!clear) 852 continue; 853 } 854 if (deref) { 855 assert(PyCell_Check(values[j])); 856 if (PyCell_GET(values[j]) != value) { 857 if (PyCell_Set(values[j], value) < 0) 858 PyErr_Clear(); 859 } 860 } else if (values[j] != value) { 861 Py_XINCREF(value); 862 Py_XDECREF(values[j]); 863 values[j] = value; 864 } 865 Py_XDECREF(value); 866 } 827 867 } 828 868 … … 830 870 PyFrame_FastToLocals(PyFrameObject *f) 831 871 { 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 /* If the namespace is unoptimized, then one of the 866 867 868 869 870 871 872 873 874 875 876 877 878 872 /* Merge fast locals into f->f_locals */ 873 PyObject *locals, *map; 874 PyObject **fast; 875 PyObject *error_type, *error_value, *error_traceback; 876 PyCodeObject *co; 877 Py_ssize_t j; 878 int ncells, nfreevars; 879 if (f == NULL) 880 return; 881 locals = f->f_locals; 882 if (locals == NULL) { 883 locals = f->f_locals = PyDict_New(); 884 if (locals == NULL) { 885 PyErr_Clear(); /* Can't report it :-( */ 886 return; 887 } 888 } 889 co = f->f_code; 890 map = co->co_varnames; 891 if (!PyTuple_Check(map)) 892 return; 893 PyErr_Fetch(&error_type, &error_value, &error_traceback); 894 fast = f->f_localsplus; 895 j = PyTuple_GET_SIZE(map); 896 if (j > co->co_nlocals) 897 j = co->co_nlocals; 898 if (co->co_nlocals) 899 map_to_dict(map, j, locals, fast, 0); 900 ncells = PyTuple_GET_SIZE(co->co_cellvars); 901 nfreevars = PyTuple_GET_SIZE(co->co_freevars); 902 if (ncells || nfreevars) { 903 map_to_dict(co->co_cellvars, ncells, 904 locals, fast + co->co_nlocals, 1); 905 /* If the namespace is unoptimized, then one of the 906 following cases applies: 907 1. It does not contain free variables, because it 908 uses import * or is a top-level namespace. 909 2. It is a class namespace. 910 We don't want to accidentally copy free variables 911 into the locals dict used by the class. 912 */ 913 if (co->co_flags & CO_OPTIMIZED) { 914 map_to_dict(co->co_freevars, nfreevars, 915 locals, fast + co->co_nlocals + ncells, 1); 916 } 917 } 918 PyErr_Restore(error_type, error_value, error_traceback); 879 919 } 880 920 … … 882 922 PyFrame_LocalsToFast(PyFrameObject *f, int clear) 883 923 { 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 locals, fast + co->co_nlocals + ncells, 1, 916 917 918 919 924 /* Merge f->f_locals into fast locals */ 925 PyObject *locals, *map; 926 PyObject **fast; 927 PyObject *error_type, *error_value, *error_traceback; 928 PyCodeObject *co; 929 Py_ssize_t j; 930 int ncells, nfreevars; 931 if (f == NULL) 932 return; 933 locals = f->f_locals; 934 co = f->f_code; 935 map = co->co_varnames; 936 if (locals == NULL) 937 return; 938 if (!PyTuple_Check(map)) 939 return; 940 PyErr_Fetch(&error_type, &error_value, &error_traceback); 941 fast = f->f_localsplus; 942 j = PyTuple_GET_SIZE(map); 943 if (j > co->co_nlocals) 944 j = co->co_nlocals; 945 if (co->co_nlocals) 946 dict_to_map(co->co_varnames, j, locals, fast, 0, clear); 947 ncells = PyTuple_GET_SIZE(co->co_cellvars); 948 nfreevars = PyTuple_GET_SIZE(co->co_freevars); 949 if (ncells || nfreevars) { 950 dict_to_map(co->co_cellvars, ncells, 951 locals, fast + co->co_nlocals, 1, clear); 952 /* Same test as in PyFrame_FastToLocals() above. */ 953 if (co->co_flags & CO_OPTIMIZED) { 954 dict_to_map(co->co_freevars, nfreevars, 955 locals, fast + co->co_nlocals + ncells, 1, 956 clear); 957 } 958 } 959 PyErr_Restore(error_type, error_value, error_traceback); 920 960 } 921 961 … … 924 964 PyFrame_ClearFreeList(void) 925 965 { 926 927 928 929 930 931 932 933 934 935 966 int freelist_size = numfree; 967 968 while (free_list != NULL) { 969 PyFrameObject *f = free_list; 970 free_list = free_list->f_back; 971 PyObject_GC_Del(f); 972 --numfree; 973 } 974 assert(numfree == 0); 975 return freelist_size; 936 976 } 937 977 … … 939 979 PyFrame_Fini(void) 940 980 { 941 942 943 944 } 981 (void)PyFrame_ClearFreeList(); 982 Py_XDECREF(builtin_object); 983 builtin_object = NULL; 984 }
Note:
See TracChangeset
for help on using the changeset viewer.