Changeset 388 for python/vendor/current/Python/symtable.c
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
-
python/vendor/current/Python/symtable.c (modified) (22 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Python/symtable.c
r2 r388 20 20 static PySTEntryObject * 21 21 ste_new(struct symtable *st, identifier name, _Py_block_ty block, 22 void *key, int lineno) 23 { 24 PySTEntryObject *ste = NULL; 25 PyObject *k; 26 27 k = PyLong_FromVoidPtr(key); 28 if (k == NULL) 29 goto fail; 30 ste = PyObject_New(PySTEntryObject, &PySTEntry_Type); 31 if (ste == NULL) 32 goto fail; 33 ste->ste_table = st; 34 ste->ste_id = k; 35 ste->ste_tmpname = 0; 36 37 ste->ste_name = name; 38 Py_INCREF(name); 39 40 ste->ste_symbols = NULL; 41 ste->ste_varnames = NULL; 42 ste->ste_children = NULL; 43 44 ste->ste_symbols = PyDict_New(); 45 if (ste->ste_symbols == NULL) 46 goto fail; 47 48 ste->ste_varnames = PyList_New(0); 49 if (ste->ste_varnames == NULL) 50 goto fail; 51 52 ste->ste_children = PyList_New(0); 53 if (ste->ste_children == NULL) 54 goto fail; 55 56 ste->ste_type = block; 57 ste->ste_unoptimized = 0; 58 ste->ste_nested = 0; 59 ste->ste_free = 0; 60 ste->ste_varargs = 0; 61 ste->ste_varkeywords = 0; 62 ste->ste_opt_lineno = 0; 63 ste->ste_tmpname = 0; 64 ste->ste_lineno = lineno; 65 66 if (st->st_cur != NULL && 67 (st->st_cur->ste_nested || 68 st->st_cur->ste_type == FunctionBlock)) 69 ste->ste_nested = 1; 70 ste->ste_child_free = 0; 71 ste->ste_generator = 0; 72 ste->ste_returns_value = 0; 73 74 if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0) 75 goto fail; 76 77 return ste; 22 void *key, int lineno) 23 { 24 PySTEntryObject *ste = NULL; 25 PyObject *k = NULL; 26 27 k = PyLong_FromVoidPtr(key); 28 if (k == NULL) 29 goto fail; 30 ste = PyObject_New(PySTEntryObject, &PySTEntry_Type); 31 if (ste == NULL) { 32 Py_DECREF(k); 33 goto fail; 34 } 35 ste->ste_table = st; 36 ste->ste_id = k; /* ste owns reference to k */ 37 38 ste->ste_name = name; 39 Py_INCREF(name); 40 41 ste->ste_symbols = NULL; 42 ste->ste_varnames = NULL; 43 ste->ste_children = NULL; 44 45 ste->ste_symbols = PyDict_New(); 46 if (ste->ste_symbols == NULL) 47 goto fail; 48 49 ste->ste_varnames = PyList_New(0); 50 if (ste->ste_varnames == NULL) 51 goto fail; 52 53 ste->ste_children = PyList_New(0); 54 if (ste->ste_children == NULL) 55 goto fail; 56 57 ste->ste_type = block; 58 ste->ste_unoptimized = 0; 59 ste->ste_nested = 0; 60 ste->ste_free = 0; 61 ste->ste_varargs = 0; 62 ste->ste_varkeywords = 0; 63 ste->ste_opt_lineno = 0; 64 ste->ste_tmpname = 0; 65 ste->ste_lineno = lineno; 66 67 if (st->st_cur != NULL && 68 (st->st_cur->ste_nested || 69 st->st_cur->ste_type == FunctionBlock)) 70 ste->ste_nested = 1; 71 ste->ste_child_free = 0; 72 ste->ste_generator = 0; 73 ste->ste_returns_value = 0; 74 75 if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0) 76 goto fail; 77 78 return ste; 78 79 fail: 79 80 80 Py_XDECREF(ste); 81 return NULL; 81 82 } 82 83 … … 84 85 ste_repr(PySTEntryObject *ste) 85 86 { 86 87 88 89 90 91 92 87 char buf[256]; 88 89 PyOS_snprintf(buf, sizeof(buf), 90 "<symtable entry %.100s(%ld), line %d>", 91 PyString_AS_STRING(ste->ste_name), 92 PyInt_AS_LONG(ste->ste_id), ste->ste_lineno); 93 return PyString_FromString(buf); 93 94 } 94 95 … … 96 97 ste_dealloc(PySTEntryObject *ste) 97 98 { 98 99 100 101 102 103 104 99 ste->ste_table = NULL; 100 Py_XDECREF(ste->ste_id); 101 Py_XDECREF(ste->ste_name); 102 Py_XDECREF(ste->ste_symbols); 103 Py_XDECREF(ste->ste_varnames); 104 Py_XDECREF(ste->ste_children); 105 PyObject_Del(ste); 105 106 } 106 107 … … 108 109 109 110 static PyMemberDef ste_memberlist[] = { 110 111 112 113 114 115 116 117 118 119 111 {"id", T_OBJECT, OFF(ste_id), READONLY}, 112 {"name", T_OBJECT, OFF(ste_name), READONLY}, 113 {"symbols", T_OBJECT, OFF(ste_symbols), READONLY}, 114 {"varnames", T_OBJECT, OFF(ste_varnames), READONLY}, 115 {"children", T_OBJECT, OFF(ste_children), READONLY}, 116 {"optimized",T_INT, OFF(ste_unoptimized), READONLY}, 117 {"nested", T_INT, OFF(ste_nested), READONLY}, 118 {"type", T_INT, OFF(ste_type), READONLY}, 119 {"lineno", T_INT, OFF(ste_lineno), READONLY}, 120 {NULL} 120 121 }; 121 122 122 123 PyTypeObject PySTEntry_Type = { 123 124 125 126 127 128 129 0,/* tp_getattr */130 0,/* tp_setattr */131 0,/* tp_compare */132 (reprfunc)ste_repr,/* tp_repr */133 0,/* tp_as_number */134 0,/* tp_as_sequence */135 0,/* tp_as_mapping */136 0,/* tp_hash */137 0,/* tp_call */138 0,/* tp_str */139 PyObject_GenericGetAttr,/* tp_getattro */140 0,/* tp_setattro */141 0,/* tp_as_buffer */142 Py_TPFLAGS_DEFAULT,/* tp_flags */143 0,/* tp_doc */144 0,/* tp_traverse */145 0,/* tp_clear */146 0,/* tp_richcompare */147 0,/* tp_weaklistoffset */148 0,/* tp_iter */149 0,/* tp_iternext */150 0,/* tp_methods */151 ste_memberlist,/* tp_members */152 0,/* tp_getset */153 0,/* tp_base */154 0,/* tp_dict */155 0,/* tp_descr_get */156 0,/* tp_descr_set */157 0,/* tp_dictoffset */158 0,/* tp_init */159 0,/* tp_alloc */160 0,/* tp_new */124 PyVarObject_HEAD_INIT(&PyType_Type, 0) 125 "symtable entry", 126 sizeof(PySTEntryObject), 127 0, 128 (destructor)ste_dealloc, /* tp_dealloc */ 129 0, /* tp_print */ 130 0, /* tp_getattr */ 131 0, /* tp_setattr */ 132 0, /* tp_compare */ 133 (reprfunc)ste_repr, /* tp_repr */ 134 0, /* tp_as_number */ 135 0, /* tp_as_sequence */ 136 0, /* tp_as_mapping */ 137 0, /* tp_hash */ 138 0, /* tp_call */ 139 0, /* tp_str */ 140 PyObject_GenericGetAttr, /* tp_getattro */ 141 0, /* tp_setattro */ 142 0, /* tp_as_buffer */ 143 Py_TPFLAGS_DEFAULT, /* tp_flags */ 144 0, /* tp_doc */ 145 0, /* tp_traverse */ 146 0, /* tp_clear */ 147 0, /* tp_richcompare */ 148 0, /* tp_weaklistoffset */ 149 0, /* tp_iter */ 150 0, /* tp_iternext */ 151 0, /* tp_methods */ 152 ste_memberlist, /* tp_members */ 153 0, /* tp_getset */ 154 0, /* tp_base */ 155 0, /* tp_dict */ 156 0, /* tp_descr_get */ 157 0, /* tp_descr_set */ 158 0, /* tp_dictoffset */ 159 0, /* tp_init */ 160 0, /* tp_alloc */ 161 0, /* tp_new */ 161 162 }; 162 163 163 164 static int symtable_analyze(struct symtable *st); 164 165 static int symtable_warn(struct symtable *st, char *msg, int lineno); 165 static int symtable_enter_block(struct symtable *st, identifier name, 166 166 static int symtable_enter_block(struct symtable *st, identifier name, 167 _Py_block_ty block, void *ast, int lineno); 167 168 static int symtable_exit_block(struct symtable *st, void *ast); 168 169 static int symtable_visit_stmt(struct symtable *st, stmt_ty s); 169 170 static int symtable_visit_expr(struct symtable *st, expr_ty s); 170 171 static int symtable_visit_genexp(struct symtable *st, expr_ty s); 172 static int symtable_visit_setcomp(struct symtable *st, expr_ty e); 173 static int symtable_visit_dictcomp(struct symtable *st, expr_ty e); 171 174 static int symtable_visit_arguments(struct symtable *st, arguments_ty); 172 175 static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty); … … 180 183 181 184 182 static identifier top = NULL, lambda = NULL, genexpr = NULL; 185 static identifier top = NULL, lambda = NULL, genexpr = NULL, setcomp = NULL, 186 dictcomp = NULL; 183 187 184 188 #define GET_IDENTIFIER(VAR) \ 185 189 ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR))) 186 190 187 191 #define DUPLICATE_ARGUMENT \ … … 191 195 symtable_new(void) 192 196 { 193 struct symtable *st; 194 195 st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable)); 196 if (st == NULL) 197 return NULL; 198 199 st->st_filename = NULL; 200 st->st_symbols = NULL; 201 202 if ((st->st_stack = PyList_New(0)) == NULL) 203 goto fail; 204 if ((st->st_symbols = PyDict_New()) == NULL) 205 goto fail; 206 st->st_cur = NULL; 207 st->st_tmpname = 0; 208 st->st_private = NULL; 209 return st; 197 struct symtable *st; 198 199 st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable)); 200 if (st == NULL) 201 return NULL; 202 203 st->st_filename = NULL; 204 st->st_symbols = NULL; 205 206 if ((st->st_stack = PyList_New(0)) == NULL) 207 goto fail; 208 if ((st->st_symbols = PyDict_New()) == NULL) 209 goto fail; 210 st->st_cur = NULL; 211 st->st_private = NULL; 212 return st; 210 213 fail: 211 212 214 PySymtable_Free(st); 215 return NULL; 213 216 } 214 217 … … 216 219 PySymtable_Build(mod_ty mod, const char *filename, PyFutureFeatures *future) 217 220 { 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 if (!symtable_visit_stmt(st, 240 241 242 243 244 245 246 247 248 249 250 if (!symtable_visit_stmt(st, 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 221 struct symtable *st = symtable_new(); 222 asdl_seq *seq; 223 int i; 224 225 if (st == NULL) 226 return st; 227 st->st_filename = filename; 228 st->st_future = future; 229 if (!GET_IDENTIFIER(top) || 230 !symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0)) { 231 PySymtable_Free(st); 232 return NULL; 233 } 234 235 st->st_top = st->st_cur; 236 st->st_cur->ste_unoptimized = OPT_TOPLEVEL; 237 /* Any other top-level initialization? */ 238 switch (mod->kind) { 239 case Module_kind: 240 seq = mod->v.Module.body; 241 for (i = 0; i < asdl_seq_LEN(seq); i++) 242 if (!symtable_visit_stmt(st, 243 (stmt_ty)asdl_seq_GET(seq, i))) 244 goto error; 245 break; 246 case Expression_kind: 247 if (!symtable_visit_expr(st, mod->v.Expression.body)) 248 goto error; 249 break; 250 case Interactive_kind: 251 seq = mod->v.Interactive.body; 252 for (i = 0; i < asdl_seq_LEN(seq); i++) 253 if (!symtable_visit_stmt(st, 254 (stmt_ty)asdl_seq_GET(seq, i))) 255 goto error; 256 break; 257 case Suite_kind: 258 PyErr_SetString(PyExc_RuntimeError, 259 "this compiler does not handle Suites"); 260 goto error; 261 } 262 if (!symtable_exit_block(st, (void *)mod)) { 263 PySymtable_Free(st); 264 return NULL; 265 } 266 if (symtable_analyze(st)) 267 return st; 268 PySymtable_Free(st); 269 return NULL; 267 270 error: 268 269 270 271 (void) symtable_exit_block(st, (void *)mod); 272 PySymtable_Free(st); 273 return NULL; 271 274 } 272 275 … … 274 277 PySymtable_Free(struct symtable *st) 275 278 { 276 277 278 279 Py_XDECREF(st->st_symbols); 280 Py_XDECREF(st->st_stack); 281 PyMem_Free((void *)st); 279 282 } 280 283 … … 282 285 PySymtable_Lookup(struct symtable *st, void *key) 283 286 { 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 } 302 303 int 287 PyObject *k, *v; 288 289 k = PyLong_FromVoidPtr(key); 290 if (k == NULL) 291 return NULL; 292 v = PyDict_GetItem(st->st_symbols, k); 293 if (v) { 294 assert(PySTEntry_Check(v)); 295 Py_INCREF(v); 296 } 297 else { 298 PyErr_SetString(PyExc_KeyError, 299 "unknown symbol table entry"); 300 } 301 302 Py_DECREF(k); 303 return (PySTEntryObject *)v; 304 } 305 306 int 304 307 PyST_GetScope(PySTEntryObject *ste, PyObject *name) 305 308 { 306 307 308 309 310 309 PyObject *v = PyDict_GetItem(ste->ste_symbols, name); 310 if (!v) 311 return 0; 312 assert(PyInt_Check(v)); 313 return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK; 311 314 } 312 315 … … 315 318 316 319 The next several functions are helpers for PySymtable_Analyze(), 317 which determines whether a name is local, global, or free. In addition, 320 which determines whether a name is local, global, or free. In addition, 318 321 it determines which local variables are cell variables; they provide 319 bindings that are used for free variables in enclosed blocks. 320 321 There are also two kinds of free variables, implicit and explicit. An 322 bindings that are used for free variables in enclosed blocks. 323 324 There are also two kinds of free variables, implicit and explicit. An 322 325 explicit global is declared with the global statement. An implicit 323 326 global is a free variable for which the compiler has found no binding … … 329 332 330 333 The symbol table requires two passes to determine the scope of each name. 331 The first pass collects raw facts from the AST: the name is a parameter 334 The first pass collects raw facts from the AST: the name is a parameter 332 335 here, the name is used by not defined here, etc. The second pass analyzes 333 336 these facts during a pass over the PySTEntryObjects created during pass 1. 334 337 335 338 When a function is entered during the second pass, the parent passes 336 the set of all name bindings visible to its children. These bindings 339 the set of all name bindings visible to its children. These bindings 337 340 are used to determine if the variable is free or an implicit global. 338 341 After doing the local analysis, it analyzes each of its child blocks 339 using an updated set of name bindings. 340 341 The children update the free variable set. If a local variable is free 342 in a child, the variable is marked as a cell. The current function must 343 provide runtime storage for the variable that may outlive the function's 342 using an updated set of name bindings. 343 344 The children update the free variable set. If a local variable is free 345 in a child, the variable is marked as a cell. The current function must 346 provide runtime storage for the variable that may outlive the function's 344 347 frame. Cell variables are removed from the free set before the analyze 345 348 function returns to its parent. 346 349 347 350 The sets of bound and free variables are implemented as dictionaries 348 351 mapping strings to None. … … 350 353 351 354 #define SET_SCOPE(DICT, NAME, I) { \ 352 353 354 355 356 357 358 359 355 PyObject *o = PyInt_FromLong(I); \ 356 if (!o) \ 357 return 0; \ 358 if (PyDict_SetItem((DICT), (NAME), o) < 0) { \ 359 Py_DECREF(o); \ 360 return 0; \ 361 } \ 362 Py_DECREF(o); \ 360 363 } 361 364 … … 367 370 */ 368 371 369 static int 372 static int 370 373 analyze_name(PySTEntryObject *ste, PyObject *dict, PyObject *name, long flags, 371 PyObject *bound, PyObject *local, PyObject *free, 372 373 { 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 374 PyObject *bound, PyObject *local, PyObject *free, 375 PyObject *global) 376 { 377 if (flags & DEF_GLOBAL) { 378 if (flags & DEF_PARAM) { 379 PyErr_Format(PyExc_SyntaxError, 380 "name '%s' is local and global", 381 PyString_AS_STRING(name)); 382 PyErr_SyntaxLocation(ste->ste_table->st_filename, 383 ste->ste_lineno); 384 385 return 0; 386 } 387 SET_SCOPE(dict, name, GLOBAL_EXPLICIT); 388 if (PyDict_SetItem(global, name, Py_None) < 0) 389 return 0; 390 if (bound && PyDict_GetItem(bound, name)) { 391 if (PyDict_DelItem(bound, name) < 0) 392 return 0; 393 } 394 return 1; 395 } 396 if (flags & DEF_BOUND) { 397 SET_SCOPE(dict, name, LOCAL); 398 if (PyDict_SetItem(local, name, Py_None) < 0) 399 return 0; 400 if (PyDict_GetItem(global, name)) { 401 if (PyDict_DelItem(global, name) < 0) 402 return 0; 403 } 404 return 1; 405 } 406 /* If an enclosing block has a binding for this name, it 407 is a free variable rather than a global variable. 408 Note that having a non-NULL bound implies that the block 409 is nested. 410 */ 411 if (bound && PyDict_GetItem(bound, name)) { 412 SET_SCOPE(dict, name, FREE); 413 ste->ste_free = 1; 414 if (PyDict_SetItem(free, name, Py_None) < 0) 415 return 0; 416 return 1; 417 } 418 /* If a parent has a global statement, then call it global 419 explicit? It could also be global implicit. 420 */ 421 else if (global && PyDict_GetItem(global, name)) { 422 SET_SCOPE(dict, name, GLOBAL_IMPLICIT); 423 return 1; 424 } 425 else { 426 if (ste->ste_nested) 427 ste->ste_free = 1; 428 SET_SCOPE(dict, name, GLOBAL_IMPLICIT); 429 return 1; 430 } 431 /* Should never get here. */ 432 PyErr_Format(PyExc_SystemError, "failed to set scope for %s", 433 PyString_AS_STRING(name)); 434 return 0; 432 435 } 433 436 … … 445 448 analyze_cells(PyObject *scope, PyObject *free) 446 449 { 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 from free. It is safe to replace the value of name 464 465 466 467 468 469 470 471 450 PyObject *name, *v, *w; 451 int success = 0; 452 Py_ssize_t pos = 0; 453 454 w = PyInt_FromLong(CELL); 455 if (!w) 456 return 0; 457 while (PyDict_Next(scope, &pos, &name, &v)) { 458 long flags; 459 assert(PyInt_Check(v)); 460 flags = PyInt_AS_LONG(v); 461 if (flags != LOCAL) 462 continue; 463 if (!PyDict_GetItem(free, name)) 464 continue; 465 /* Replace LOCAL with CELL for this name, and remove 466 from free. It is safe to replace the value of name 467 in the dict, because it will not cause a resize. 468 */ 469 if (PyDict_SetItem(scope, name, w) < 0) 470 goto error; 471 if (!PyDict_DelItem(free, name) < 0) 472 goto error; 473 } 474 success = 1; 472 475 error: 473 474 476 Py_DECREF(w); 477 return success; 475 478 } 476 479 … … 478 481 static int 479 482 check_unoptimized(const PySTEntryObject* ste) { 480 481 482 483 484 485 486 487 trailer = (ste->ste_child_free ? 488 489 490 491 492 493 494 495 496 PyOS_snprintf(buf, sizeof(buf), 497 498 "because it is%s",499 500 501 502 503 504 505 506 507 508 PyOS_snprintf(buf, sizeof(buf), 509 510 511 512 513 514 515 516 PyErr_SyntaxLocation(ste->ste_table->st_filename, 517 518 519 } 520 521 /* Enter the final scope information into the st_symbols dict. 522 * 483 char buf[300]; 484 const char* trailer; 485 486 if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized 487 || !(ste->ste_free || ste->ste_child_free)) 488 return 1; 489 490 trailer = (ste->ste_child_free ? 491 "contains a nested function with free variables" : 492 "is a nested function"); 493 494 switch (ste->ste_unoptimized) { 495 case OPT_TOPLEVEL: /* exec / import * at top-level is fine */ 496 case OPT_EXEC: /* qualified exec is fine */ 497 return 1; 498 case OPT_IMPORT_STAR: 499 PyOS_snprintf(buf, sizeof(buf), 500 "import * is not allowed in function '%.100s' " 501 "because it %s", 502 PyString_AS_STRING(ste->ste_name), trailer); 503 break; 504 case OPT_BARE_EXEC: 505 PyOS_snprintf(buf, sizeof(buf), 506 "unqualified exec is not allowed in function " 507 "'%.100s' it %s", 508 PyString_AS_STRING(ste->ste_name), trailer); 509 break; 510 default: 511 PyOS_snprintf(buf, sizeof(buf), 512 "function '%.100s' uses import * and bare exec, " 513 "which are illegal because it %s", 514 PyString_AS_STRING(ste->ste_name), trailer); 515 break; 516 } 517 518 PyErr_SetString(PyExc_SyntaxError, buf); 519 PyErr_SyntaxLocation(ste->ste_table->st_filename, 520 ste->ste_opt_lineno); 521 return 0; 522 } 523 524 /* Enter the final scope information into the st_symbols dict. 525 * 523 526 * All arguments are dicts. Modifies symbols, others are read-only. 524 527 */ 525 528 static int 526 update_symbols(PyObject *symbols, PyObject *scope, 529 update_symbols(PyObject *symbols, PyObject *scope, 527 530 PyObject *bound, PyObject *free, int classflag) 528 531 { 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 if (classflag && 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 } 532 PyObject *name, *v, *u, *w, *free_value = NULL; 533 Py_ssize_t pos = 0; 534 535 while (PyDict_Next(symbols, &pos, &name, &v)) { 536 long i, flags; 537 assert(PyInt_Check(v)); 538 flags = PyInt_AS_LONG(v); 539 w = PyDict_GetItem(scope, name); 540 assert(w && PyInt_Check(w)); 541 i = PyInt_AS_LONG(w); 542 flags |= (i << SCOPE_OFF); 543 u = PyInt_FromLong(flags); 544 if (!u) 545 return 0; 546 if (PyDict_SetItem(symbols, name, u) < 0) { 547 Py_DECREF(u); 548 return 0; 549 } 550 Py_DECREF(u); 551 } 552 553 free_value = PyInt_FromLong(FREE << SCOPE_OFF); 554 if (!free_value) 555 return 0; 556 557 /* add a free variable when it's only use is for creating a closure */ 558 pos = 0; 559 while (PyDict_Next(free, &pos, &name, &v)) { 560 PyObject *o = PyDict_GetItem(symbols, name); 561 562 if (o) { 563 /* It could be a free variable in a method of 564 the class that has the same name as a local 565 or global in the class scope. 566 */ 567 if (classflag && 568 PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) { 569 long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS; 570 o = PyInt_FromLong(i); 571 if (!o) { 572 Py_DECREF(free_value); 573 return 0; 574 } 575 if (PyDict_SetItem(symbols, name, o) < 0) { 576 Py_DECREF(o); 577 Py_DECREF(free_value); 578 return 0; 579 } 580 Py_DECREF(o); 581 } 582 /* else it's not free, probably a cell */ 583 continue; 584 } 585 if (!PyDict_GetItem(bound, name)) 586 continue; /* it's a global */ 587 588 if (PyDict_SetItem(symbols, name, free_value) < 0) { 589 Py_DECREF(free_value); 590 return 0; 591 } 592 } 593 Py_DECREF(free_value); 594 return 1; 595 } 593 596 594 597 /* Make final symbol table decisions for block of ste. … … 613 616 614 617 static int 615 analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, 616 PyObject *global, PyObject* child_free); 617 618 static int 619 analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, 620 PyObject *global) 621 { 622 PyObject *name, *v, *local = NULL, *scope = NULL; 623 PyObject *newbound = NULL, *newglobal = NULL; 624 PyObject *newfree = NULL, *allfree = NULL; 625 int i, success = 0; 626 Py_ssize_t pos = 0; 627 628 local = PyDict_New(); /* collect new names bound in block */ 629 if (!local) 630 goto error; 631 scope = PyDict_New(); /* collect scopes defined for each name */ 632 if (!scope) 633 goto error; 634 635 /* Allocate new global and bound variable dictionaries. These 636 dictionaries hold the names visible in nested blocks. For 637 ClassBlocks, the bound and global names are initialized 638 before analyzing names, because class bindings aren't 639 visible in methods. For other blocks, they are initialized 640 after names are analyzed. 641 */ 642 643 /* TODO(jhylton): Package these dicts in a struct so that we 644 can write reasonable helper functions? 645 */ 646 newglobal = PyDict_New(); 647 if (!newglobal) 648 goto error; 649 newbound = PyDict_New(); 650 if (!newbound) 651 goto error; 652 newfree = PyDict_New(); 653 if (!newfree) 654 goto error; 655 656 if (ste->ste_type == ClassBlock) { 657 if (PyDict_Update(newglobal, global) < 0) 658 goto error; 659 if (bound) 660 if (PyDict_Update(newbound, bound) < 0) 661 goto error; 662 } 663 664 while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) { 665 long flags = PyInt_AS_LONG(v); 666 if (!analyze_name(ste, scope, name, flags, 667 bound, local, free, global)) 668 goto error; 669 } 670 671 if (ste->ste_type != ClassBlock) { 672 if (ste->ste_type == FunctionBlock) { 673 if (PyDict_Update(newbound, local) < 0) 674 goto error; 675 } 676 if (bound) { 677 if (PyDict_Update(newbound, bound) < 0) 678 goto error; 679 } 680 if (PyDict_Update(newglobal, global) < 0) 681 goto error; 682 } 683 684 /* Recursively call analyze_block() on each child block. 685 686 newbound, newglobal now contain the names visible in 687 nested blocks. The free variables in the children will 688 be collected in allfree. 689 */ 690 allfree = PyDict_New(); 691 if (!allfree) 692 goto error; 693 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) { 694 PyObject *c = PyList_GET_ITEM(ste->ste_children, i); 695 PySTEntryObject* entry; 696 assert(c && PySTEntry_Check(c)); 697 entry = (PySTEntryObject*)c; 698 if (!analyze_child_block(entry, newbound, newfree, newglobal, 699 allfree)) 700 goto error; 701 if (entry->ste_free || entry->ste_child_free) 702 ste->ste_child_free = 1; 703 } 704 705 PyDict_Update(newfree, allfree); 706 if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree)) 707 goto error; 708 if (!update_symbols(ste->ste_symbols, scope, bound, newfree, 709 ste->ste_type == ClassBlock)) 710 goto error; 711 if (!check_unoptimized(ste)) 712 goto error; 713 714 if (PyDict_Update(free, newfree) < 0) 715 goto error; 716 success = 1; 618 analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, 619 PyObject *global, PyObject* child_free); 620 621 static int 622 analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, 623 PyObject *global) 624 { 625 PyObject *name, *v, *local = NULL, *scope = NULL; 626 PyObject *newbound = NULL, *newglobal = NULL; 627 PyObject *newfree = NULL, *allfree = NULL; 628 int i, success = 0; 629 Py_ssize_t pos = 0; 630 631 local = PyDict_New(); /* collect new names bound in block */ 632 if (!local) 633 goto error; 634 scope = PyDict_New(); /* collect scopes defined for each name */ 635 if (!scope) 636 goto error; 637 638 /* Allocate new global and bound variable dictionaries. These 639 dictionaries hold the names visible in nested blocks. For 640 ClassBlocks, the bound and global names are initialized 641 before analyzing names, because class bindings aren't 642 visible in methods. For other blocks, they are initialized 643 after names are analyzed. 644 */ 645 646 /* TODO(jhylton): Package these dicts in a struct so that we 647 can write reasonable helper functions? 648 */ 649 newglobal = PyDict_New(); 650 if (!newglobal) 651 goto error; 652 newbound = PyDict_New(); 653 if (!newbound) 654 goto error; 655 newfree = PyDict_New(); 656 if (!newfree) 657 goto error; 658 659 if (ste->ste_type == ClassBlock) { 660 if (PyDict_Update(newglobal, global) < 0) 661 goto error; 662 if (bound) 663 if (PyDict_Update(newbound, bound) < 0) 664 goto error; 665 } 666 667 while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) { 668 long flags = PyInt_AS_LONG(v); 669 if (!analyze_name(ste, scope, name, flags, 670 bound, local, free, global)) 671 goto error; 672 } 673 674 if (ste->ste_type != ClassBlock) { 675 if (ste->ste_type == FunctionBlock) { 676 if (PyDict_Update(newbound, local) < 0) 677 goto error; 678 } 679 if (bound) { 680 if (PyDict_Update(newbound, bound) < 0) 681 goto error; 682 } 683 if (PyDict_Update(newglobal, global) < 0) 684 goto error; 685 } 686 687 /* Recursively call analyze_block() on each child block. 688 689 newbound, newglobal now contain the names visible in 690 nested blocks. The free variables in the children will 691 be collected in allfree. 692 */ 693 allfree = PyDict_New(); 694 if (!allfree) 695 goto error; 696 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) { 697 PyObject *c = PyList_GET_ITEM(ste->ste_children, i); 698 PySTEntryObject* entry; 699 assert(c && PySTEntry_Check(c)); 700 entry = (PySTEntryObject*)c; 701 if (!analyze_child_block(entry, newbound, newfree, newglobal, 702 allfree)) 703 goto error; 704 if (entry->ste_free || entry->ste_child_free) 705 ste->ste_child_free = 1; 706 } 707 708 if (PyDict_Update(newfree, allfree) < 0) 709 goto error; 710 if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree)) 711 goto error; 712 if (!update_symbols(ste->ste_symbols, scope, bound, newfree, 713 ste->ste_type == ClassBlock)) 714 goto error; 715 if (!check_unoptimized(ste)) 716 goto error; 717 718 if (PyDict_Update(free, newfree) < 0) 719 goto error; 720 success = 1; 717 721 error: 718 719 720 721 722 723 724 725 726 727 } 728 729 static int 730 analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, 731 732 { 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 722 Py_XDECREF(local); 723 Py_XDECREF(scope); 724 Py_XDECREF(newbound); 725 Py_XDECREF(newglobal); 726 Py_XDECREF(newfree); 727 Py_XDECREF(allfree); 728 if (!success) 729 assert(PyErr_Occurred()); 730 return success; 731 } 732 733 static int 734 analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, 735 PyObject *global, PyObject* child_free) 736 { 737 PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL; 738 739 /* Copy the bound and global dictionaries. 740 741 These dictionary are used by all blocks enclosed by the 742 current block. The analyze_block() call modifies these 743 dictionaries. 744 745 */ 746 temp_bound = PyDict_New(); 747 if (!temp_bound) 748 goto error; 749 if (PyDict_Update(temp_bound, bound) < 0) 750 goto error; 751 temp_free = PyDict_New(); 752 if (!temp_free) 753 goto error; 754 if (PyDict_Update(temp_free, free) < 0) 755 goto error; 756 temp_global = PyDict_New(); 757 if (!temp_global) 758 goto error; 759 if (PyDict_Update(temp_global, global) < 0) 760 goto error; 761 762 if (!analyze_block(entry, temp_bound, temp_free, temp_global)) 763 goto error; 764 if (PyDict_Update(child_free, temp_free) < 0) 765 goto error; 766 Py_DECREF(temp_bound); 767 Py_DECREF(temp_free); 768 Py_DECREF(temp_global); 769 return 1; 766 770 error: 767 768 769 770 771 Py_XDECREF(temp_bound); 772 Py_XDECREF(temp_free); 773 Py_XDECREF(temp_global); 774 return 0; 771 775 } 772 776 … … 774 778 symtable_analyze(struct symtable *st) 775 779 { 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 780 PyObject *free, *global; 781 int r; 782 783 free = PyDict_New(); 784 if (!free) 785 return 0; 786 global = PyDict_New(); 787 if (!global) { 788 Py_DECREF(free); 789 return 0; 790 } 791 r = analyze_block(st->st_top, NULL, free, global); 792 Py_DECREF(free); 793 Py_DECREF(global); 794 return r; 791 795 } 792 796 … … 795 799 symtable_warn(struct symtable *st, char *msg, int lineno) 796 800 { 797 798 lineno, NULL, NULL) < 0){799 800 801 PyErr_SyntaxLocation(st->st_filename, 802 803 804 805 806 801 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename, 802 lineno, NULL, NULL) < 0) { 803 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) { 804 PyErr_SetString(PyExc_SyntaxError, msg); 805 PyErr_SyntaxLocation(st->st_filename, 806 st->st_cur->ste_lineno); 807 } 808 return 0; 809 } 810 return 1; 807 811 } 808 812 … … 815 819 symtable_exit_block(struct symtable *st, void *ast) 816 820 { 817 818 819 820 821 822 st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack, 823 824 825 826 827 828 829 830 831 } 832 833 static int 834 symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block, 835 836 { 837 838 839 840 841 842 843 844 845 846 847 848 849 if (name == GET_IDENTIFIER(top))850 851 852 if (PyList_Append(prev->ste_children, 853 854 855 856 857 821 Py_ssize_t end; 822 823 Py_CLEAR(st->st_cur); 824 end = PyList_GET_SIZE(st->st_stack) - 1; 825 if (end >= 0) { 826 st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack, 827 end); 828 if (st->st_cur == NULL) 829 return 0; 830 Py_INCREF(st->st_cur); 831 if (PySequence_DelItem(st->st_stack, end) < 0) 832 return 0; 833 } 834 return 1; 835 } 836 837 static int 838 symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block, 839 void *ast, int lineno) 840 { 841 PySTEntryObject *prev = NULL; 842 843 if (st->st_cur) { 844 prev = st->st_cur; 845 if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) { 846 return 0; 847 } 848 Py_DECREF(st->st_cur); 849 } 850 st->st_cur = ste_new(st, name, block, ast, lineno); 851 if (st->st_cur == NULL) 852 return 0; 853 if (block == ModuleBlock) 854 st->st_global = st->st_cur->ste_symbols; 855 if (prev) { 856 if (PyList_Append(prev->ste_children, 857 (PyObject *)st->st_cur) < 0) { 858 return 0; 859 } 860 } 861 return 1; 858 862 } 859 863 … … 861 865 symtable_lookup(struct symtable *st, PyObject *name) 862 866 { 863 PyObject *o; 864 PyObject *mangled = _Py_Mangle(st->st_private, name); 865 if (!mangled) 866 return 0; 867 o = PyDict_GetItem(st->st_cur->ste_symbols, mangled); 868 Py_DECREF(mangled); 869 if (!o) 870 return 0; 871 return PyInt_AsLong(o); 872 } 873 874 static int 875 symtable_add_def(struct symtable *st, PyObject *name, int flag) 876 { 877 PyObject *o; 878 PyObject *dict; 879 long val; 880 PyObject *mangled = _Py_Mangle(st->st_private, name); 881 882 if (!mangled) 883 return 0; 884 dict = st->st_cur->ste_symbols; 885 if ((o = PyDict_GetItem(dict, mangled))) { 886 val = PyInt_AS_LONG(o); 887 if ((flag & DEF_PARAM) && (val & DEF_PARAM)) { 888 /* Is it better to use 'mangled' or 'name' here? */ 889 PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT, 890 PyString_AsString(name)); 891 PyErr_SyntaxLocation(st->st_filename, 892 st->st_cur->ste_lineno); 893 goto error; 894 } 895 val |= flag; 896 } else 897 val = flag; 898 o = PyInt_FromLong(val); 867 PyObject *o; 868 PyObject *mangled = _Py_Mangle(st->st_private, name); 869 if (!mangled) 870 return 0; 871 o = PyDict_GetItem(st->st_cur->ste_symbols, mangled); 872 Py_DECREF(mangled); 873 if (!o) 874 return 0; 875 return PyInt_AsLong(o); 876 } 877 878 static int 879 symtable_add_def(struct symtable *st, PyObject *name, int flag) 880 { 881 PyObject *o; 882 PyObject *dict; 883 long val; 884 PyObject *mangled = _Py_Mangle(st->st_private, name); 885 886 if (!mangled) 887 return 0; 888 dict = st->st_cur->ste_symbols; 889 if ((o = PyDict_GetItem(dict, mangled))) { 890 val = PyInt_AS_LONG(o); 891 if ((flag & DEF_PARAM) && (val & DEF_PARAM)) { 892 /* Is it better to use 'mangled' or 'name' here? */ 893 PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT, 894 PyString_AsString(name)); 895 PyErr_SyntaxLocation(st->st_filename, 896 st->st_cur->ste_lineno); 897 goto error; 898 } 899 val |= flag; 900 } else 901 val = flag; 902 o = PyInt_FromLong(val); 903 if (o == NULL) 904 goto error; 905 if (PyDict_SetItem(dict, mangled, o) < 0) { 906 Py_DECREF(o); 907 goto error; 908 } 909 Py_DECREF(o); 910 911 if (flag & DEF_PARAM) { 912 if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0) 913 goto error; 914 } else if (flag & DEF_GLOBAL) { 915 /* XXX need to update DEF_GLOBAL for other flags too; 916 perhaps only DEF_FREE_GLOBAL */ 917 val = flag; 918 if ((o = PyDict_GetItem(st->st_global, mangled))) { 919 val |= PyInt_AS_LONG(o); 920 } 921 o = PyInt_FromLong(val); 899 922 if (o == NULL) 900 goto error; 901 if (PyDict_SetItem(dict, mangled, o) < 0) { 902 Py_DECREF(o); 903 goto error; 904 } 905 Py_DECREF(o); 906 907 if (flag & DEF_PARAM) { 908 if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0) 909 goto error; 910 } else if (flag & DEF_GLOBAL) { 911 /* XXX need to update DEF_GLOBAL for other flags too; 912 perhaps only DEF_FREE_GLOBAL */ 913 val = flag; 914 if ((o = PyDict_GetItem(st->st_global, mangled))) { 915 val |= PyInt_AS_LONG(o); 916 } 917 o = PyInt_FromLong(val); 918 if (o == NULL) 919 goto error; 920 if (PyDict_SetItem(st->st_global, mangled, o) < 0) { 921 Py_DECREF(o); 922 goto error; 923 } 924 Py_DECREF(o); 925 } 926 Py_DECREF(mangled); 927 return 1; 923 goto error; 924 if (PyDict_SetItem(st->st_global, mangled, o) < 0) { 925 Py_DECREF(o); 926 goto error; 927 } 928 Py_DECREF(o); 929 } 930 Py_DECREF(mangled); 931 return 1; 928 932 929 933 error: 930 931 934 Py_DECREF(mangled); 935 return 0; 932 936 } 933 937 934 938 /* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument. 935 939 They use the ASDL name to synthesize the name of the C type and the visit 936 function. 937 940 function. 941 938 942 VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is 939 943 useful if the first node in the sequence requires special treatment. … … 941 945 942 946 #define VISIT(ST, TYPE, V) \ 943 944 return 0; 947 if (!symtable_visit_ ## TYPE((ST), (V))) \ 948 return 0; 945 949 946 950 #define VISIT_IN_BLOCK(ST, TYPE, V, S) \ 947 948 949 950 951 if (!symtable_visit_ ## TYPE((ST), (V))) { \ 952 symtable_exit_block((ST), (S)); \ 953 return 0; \ 954 } 951 955 952 956 #define VISIT_SEQ(ST, TYPE, SEQ) { \ 953 954 955 956 957 958 959 957 int i; \ 958 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 959 for (i = 0; i < asdl_seq_LEN(seq); i++) { \ 960 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \ 961 if (!symtable_visit_ ## TYPE((ST), elt)) \ 962 return 0; \ 963 } \ 960 964 } 961 965 962 966 #define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \ 963 964 965 966 967 968 969 970 971 967 int i; \ 968 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 969 for (i = 0; i < asdl_seq_LEN(seq); i++) { \ 970 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \ 971 if (!symtable_visit_ ## TYPE((ST), elt)) { \ 972 symtable_exit_block((ST), (S)); \ 973 return 0; \ 974 } \ 975 } \ 972 976 } 973 977 974 978 #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \ 975 976 977 978 979 980 981 979 int i; \ 980 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 981 for (i = (START); i < asdl_seq_LEN(seq); i++) { \ 982 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \ 983 if (!symtable_visit_ ## TYPE((ST), elt)) \ 984 return 0; \ 985 } \ 982 986 } 983 987 984 988 #define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \ 985 int i; \ 986 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 987 for (i = (START); i < asdl_seq_LEN(seq); i++) { \ 988 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \ 989 if (!symtable_visit_ ## TYPE((ST), elt)) { \ 990 symtable_exit_block((ST), (S)); \ 991 return 0; \ 992 } \ 993 } \ 989 int i; \ 990 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 991 for (i = (START); i < asdl_seq_LEN(seq); i++) { \ 992 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \ 993 if (!symtable_visit_ ## TYPE((ST), elt)) { \ 994 symtable_exit_block((ST), (S)); \ 995 return 0; \ 996 } \ 997 } \ 998 } 999 1000 static int 1001 symtable_visit_stmt(struct symtable *st, stmt_ty s) 1002 { 1003 switch (s->kind) { 1004 case FunctionDef_kind: 1005 if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL)) 1006 return 0; 1007 if (s->v.FunctionDef.args->defaults) 1008 VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults); 1009 if (s->v.FunctionDef.decorator_list) 1010 VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list); 1011 if (!symtable_enter_block(st, s->v.FunctionDef.name, 1012 FunctionBlock, (void *)s, s->lineno)) 1013 return 0; 1014 VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s); 1015 VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s); 1016 if (!symtable_exit_block(st, s)) 1017 return 0; 1018 break; 1019 case ClassDef_kind: { 1020 PyObject *tmp; 1021 if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL)) 1022 return 0; 1023 VISIT_SEQ(st, expr, s->v.ClassDef.bases); 1024 if (s->v.ClassDef.decorator_list) 1025 VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list); 1026 if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock, 1027 (void *)s, s->lineno)) 1028 return 0; 1029 tmp = st->st_private; 1030 st->st_private = s->v.ClassDef.name; 1031 VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s); 1032 st->st_private = tmp; 1033 if (!symtable_exit_block(st, s)) 1034 return 0; 1035 break; 1036 } 1037 case Return_kind: 1038 if (s->v.Return.value) { 1039 VISIT(st, expr, s->v.Return.value); 1040 st->st_cur->ste_returns_value = 1; 1041 if (st->st_cur->ste_generator) { 1042 PyErr_SetString(PyExc_SyntaxError, 1043 RETURN_VAL_IN_GENERATOR); 1044 PyErr_SyntaxLocation(st->st_filename, 1045 s->lineno); 1046 return 0; 1047 } 1048 } 1049 break; 1050 case Delete_kind: 1051 VISIT_SEQ(st, expr, s->v.Delete.targets); 1052 break; 1053 case Assign_kind: 1054 VISIT_SEQ(st, expr, s->v.Assign.targets); 1055 VISIT(st, expr, s->v.Assign.value); 1056 break; 1057 case AugAssign_kind: 1058 VISIT(st, expr, s->v.AugAssign.target); 1059 VISIT(st, expr, s->v.AugAssign.value); 1060 break; 1061 case Print_kind: 1062 if (s->v.Print.dest) 1063 VISIT(st, expr, s->v.Print.dest); 1064 VISIT_SEQ(st, expr, s->v.Print.values); 1065 break; 1066 case For_kind: 1067 VISIT(st, expr, s->v.For.target); 1068 VISIT(st, expr, s->v.For.iter); 1069 VISIT_SEQ(st, stmt, s->v.For.body); 1070 if (s->v.For.orelse) 1071 VISIT_SEQ(st, stmt, s->v.For.orelse); 1072 break; 1073 case While_kind: 1074 VISIT(st, expr, s->v.While.test); 1075 VISIT_SEQ(st, stmt, s->v.While.body); 1076 if (s->v.While.orelse) 1077 VISIT_SEQ(st, stmt, s->v.While.orelse); 1078 break; 1079 case If_kind: 1080 /* XXX if 0: and lookup_yield() hacks */ 1081 VISIT(st, expr, s->v.If.test); 1082 VISIT_SEQ(st, stmt, s->v.If.body); 1083 if (s->v.If.orelse) 1084 VISIT_SEQ(st, stmt, s->v.If.orelse); 1085 break; 1086 case Raise_kind: 1087 if (s->v.Raise.type) { 1088 VISIT(st, expr, s->v.Raise.type); 1089 if (s->v.Raise.inst) { 1090 VISIT(st, expr, s->v.Raise.inst); 1091 if (s->v.Raise.tback) 1092 VISIT(st, expr, s->v.Raise.tback); 1093 } 1094 } 1095 break; 1096 case TryExcept_kind: 1097 VISIT_SEQ(st, stmt, s->v.TryExcept.body); 1098 VISIT_SEQ(st, stmt, s->v.TryExcept.orelse); 1099 VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers); 1100 break; 1101 case TryFinally_kind: 1102 VISIT_SEQ(st, stmt, s->v.TryFinally.body); 1103 VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody); 1104 break; 1105 case Assert_kind: 1106 VISIT(st, expr, s->v.Assert.test); 1107 if (s->v.Assert.msg) 1108 VISIT(st, expr, s->v.Assert.msg); 1109 break; 1110 case Import_kind: 1111 VISIT_SEQ(st, alias, s->v.Import.names); 1112 /* XXX Don't have the lineno available inside 1113 visit_alias */ 1114 if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno) 1115 st->st_cur->ste_opt_lineno = s->lineno; 1116 break; 1117 case ImportFrom_kind: 1118 VISIT_SEQ(st, alias, s->v.ImportFrom.names); 1119 /* XXX Don't have the lineno available inside 1120 visit_alias */ 1121 if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno) 1122 st->st_cur->ste_opt_lineno = s->lineno; 1123 break; 1124 case Exec_kind: 1125 VISIT(st, expr, s->v.Exec.body); 1126 if (!st->st_cur->ste_opt_lineno) 1127 st->st_cur->ste_opt_lineno = s->lineno; 1128 if (s->v.Exec.globals) { 1129 st->st_cur->ste_unoptimized |= OPT_EXEC; 1130 VISIT(st, expr, s->v.Exec.globals); 1131 if (s->v.Exec.locals) 1132 VISIT(st, expr, s->v.Exec.locals); 1133 } else { 1134 st->st_cur->ste_unoptimized |= OPT_BARE_EXEC; 1135 } 1136 break; 1137 case Global_kind: { 1138 int i; 1139 asdl_seq *seq = s->v.Global.names; 1140 for (i = 0; i < asdl_seq_LEN(seq); i++) { 1141 identifier name = (identifier)asdl_seq_GET(seq, i); 1142 char *c_name = PyString_AS_STRING(name); 1143 long cur = symtable_lookup(st, name); 1144 if (cur < 0) 1145 return 0; 1146 if (cur & (DEF_LOCAL | USE)) { 1147 char buf[256]; 1148 if (cur & DEF_LOCAL) 1149 PyOS_snprintf(buf, sizeof(buf), 1150 GLOBAL_AFTER_ASSIGN, 1151 c_name); 1152 else 1153 PyOS_snprintf(buf, sizeof(buf), 1154 GLOBAL_AFTER_USE, 1155 c_name); 1156 if (!symtable_warn(st, buf, s->lineno)) 1157 return 0; 1158 } 1159 if (!symtable_add_def(st, name, DEF_GLOBAL)) 1160 return 0; 1161 } 1162 break; 1163 } 1164 case Expr_kind: 1165 VISIT(st, expr, s->v.Expr.value); 1166 break; 1167 case Pass_kind: 1168 case Break_kind: 1169 case Continue_kind: 1170 /* nothing to do here */ 1171 break; 1172 case With_kind: 1173 VISIT(st, expr, s->v.With.context_expr); 1174 if (s->v.With.optional_vars) { 1175 VISIT(st, expr, s->v.With.optional_vars); 1176 } 1177 VISIT_SEQ(st, stmt, s->v.With.body); 1178 break; 1179 } 1180 return 1; 1181 } 1182 1183 static int 1184 symtable_visit_expr(struct symtable *st, expr_ty e) 1185 { 1186 switch (e->kind) { 1187 case BoolOp_kind: 1188 VISIT_SEQ(st, expr, e->v.BoolOp.values); 1189 break; 1190 case BinOp_kind: 1191 VISIT(st, expr, e->v.BinOp.left); 1192 VISIT(st, expr, e->v.BinOp.right); 1193 break; 1194 case UnaryOp_kind: 1195 VISIT(st, expr, e->v.UnaryOp.operand); 1196 break; 1197 case Lambda_kind: { 1198 if (!GET_IDENTIFIER(lambda)) 1199 return 0; 1200 if (e->v.Lambda.args->defaults) 1201 VISIT_SEQ(st, expr, e->v.Lambda.args->defaults); 1202 if (!symtable_enter_block(st, lambda, 1203 FunctionBlock, (void *)e, e->lineno)) 1204 return 0; 1205 VISIT_IN_BLOCK(st, arguments, e->v.Lambda.args, (void*)e); 1206 VISIT_IN_BLOCK(st, expr, e->v.Lambda.body, (void*)e); 1207 if (!symtable_exit_block(st, (void *)e)) 1208 return 0; 1209 break; 1210 } 1211 case IfExp_kind: 1212 VISIT(st, expr, e->v.IfExp.test); 1213 VISIT(st, expr, e->v.IfExp.body); 1214 VISIT(st, expr, e->v.IfExp.orelse); 1215 break; 1216 case Dict_kind: 1217 VISIT_SEQ(st, expr, e->v.Dict.keys); 1218 VISIT_SEQ(st, expr, e->v.Dict.values); 1219 break; 1220 case Set_kind: 1221 VISIT_SEQ(st, expr, e->v.Set.elts); 1222 break; 1223 case ListComp_kind: 1224 VISIT(st, expr, e->v.ListComp.elt); 1225 VISIT_SEQ(st, comprehension, e->v.ListComp.generators); 1226 break; 1227 case GeneratorExp_kind: 1228 if (!symtable_visit_genexp(st, e)) 1229 return 0; 1230 break; 1231 case SetComp_kind: 1232 if (!symtable_visit_setcomp(st, e)) 1233 return 0; 1234 break; 1235 case DictComp_kind: 1236 if (!symtable_visit_dictcomp(st, e)) 1237 return 0; 1238 break; 1239 case Yield_kind: 1240 if (e->v.Yield.value) 1241 VISIT(st, expr, e->v.Yield.value); 1242 st->st_cur->ste_generator = 1; 1243 if (st->st_cur->ste_returns_value) { 1244 PyErr_SetString(PyExc_SyntaxError, 1245 RETURN_VAL_IN_GENERATOR); 1246 PyErr_SyntaxLocation(st->st_filename, 1247 e->lineno); 1248 return 0; 1249 } 1250 break; 1251 case Compare_kind: 1252 VISIT(st, expr, e->v.Compare.left); 1253 VISIT_SEQ(st, expr, e->v.Compare.comparators); 1254 break; 1255 case Call_kind: 1256 VISIT(st, expr, e->v.Call.func); 1257 VISIT_SEQ(st, expr, e->v.Call.args); 1258 VISIT_SEQ(st, keyword, e->v.Call.keywords); 1259 if (e->v.Call.starargs) 1260 VISIT(st, expr, e->v.Call.starargs); 1261 if (e->v.Call.kwargs) 1262 VISIT(st, expr, e->v.Call.kwargs); 1263 break; 1264 case Repr_kind: 1265 VISIT(st, expr, e->v.Repr.value); 1266 break; 1267 case Num_kind: 1268 case Str_kind: 1269 /* Nothing to do here. */ 1270 break; 1271 /* The following exprs can be assignment targets. */ 1272 case Attribute_kind: 1273 VISIT(st, expr, e->v.Attribute.value); 1274 break; 1275 case Subscript_kind: 1276 VISIT(st, expr, e->v.Subscript.value); 1277 VISIT(st, slice, e->v.Subscript.slice); 1278 break; 1279 case Name_kind: 1280 if (!symtable_add_def(st, e->v.Name.id, 1281 e->v.Name.ctx == Load ? USE : DEF_LOCAL)) 1282 return 0; 1283 break; 1284 /* child nodes of List and Tuple will have expr_context set */ 1285 case List_kind: 1286 VISIT_SEQ(st, expr, e->v.List.elts); 1287 break; 1288 case Tuple_kind: 1289 VISIT_SEQ(st, expr, e->v.Tuple.elts); 1290 break; 1291 } 1292 return 1; 1293 } 1294 1295 static int 1296 symtable_implicit_arg(struct symtable *st, int pos) 1297 { 1298 PyObject *id = PyString_FromFormat(".%d", pos); 1299 if (id == NULL) 1300 return 0; 1301 if (!symtable_add_def(st, id, DEF_PARAM)) { 1302 Py_DECREF(id); 1303 return 0; 1304 } 1305 Py_DECREF(id); 1306 return 1; 1307 } 1308 1309 static int 1310 symtable_visit_params(struct symtable *st, asdl_seq *args, int toplevel) 1311 { 1312 int i; 1313 1314 /* go through all the toplevel arguments first */ 1315 for (i = 0; i < asdl_seq_LEN(args); i++) { 1316 expr_ty arg = (expr_ty)asdl_seq_GET(args, i); 1317 if (arg->kind == Name_kind) { 1318 assert(arg->v.Name.ctx == Param || 1319 (arg->v.Name.ctx == Store && !toplevel)); 1320 if (!symtable_add_def(st, arg->v.Name.id, DEF_PARAM)) 1321 return 0; 1322 } 1323 else if (arg->kind == Tuple_kind) { 1324 assert(arg->v.Tuple.ctx == Store); 1325 if (toplevel) { 1326 if (!symtable_implicit_arg(st, i)) 1327 return 0; 1328 } 1329 } 1330 else { 1331 PyErr_SetString(PyExc_SyntaxError, 1332 "invalid expression in parameter list"); 1333 PyErr_SyntaxLocation(st->st_filename, 1334 st->st_cur->ste_lineno); 1335 return 0; 1336 } 1337 } 1338 1339 if (!toplevel) { 1340 if (!symtable_visit_params_nested(st, args)) 1341 return 0; 1342 } 1343 1344 return 1; 1345 } 1346 1347 static int 1348 symtable_visit_params_nested(struct symtable *st, asdl_seq *args) 1349 { 1350 int i; 1351 for (i = 0; i < asdl_seq_LEN(args); i++) { 1352 expr_ty arg = (expr_ty)asdl_seq_GET(args, i); 1353 if (arg->kind == Tuple_kind && 1354 !symtable_visit_params(st, arg->v.Tuple.elts, 0)) 1355 return 0; 1356 } 1357 1358 return 1; 1359 } 1360 1361 static int 1362 symtable_visit_arguments(struct symtable *st, arguments_ty a) 1363 { 1364 /* skip default arguments inside function block 1365 XXX should ast be different? 1366 */ 1367 if (a->args && !symtable_visit_params(st, a->args, 1)) 1368 return 0; 1369 if (a->vararg) { 1370 if (!symtable_add_def(st, a->vararg, DEF_PARAM)) 1371 return 0; 1372 st->st_cur->ste_varargs = 1; 1373 } 1374 if (a->kwarg) { 1375 if (!symtable_add_def(st, a->kwarg, DEF_PARAM)) 1376 return 0; 1377 st->st_cur->ste_varkeywords = 1; 1378 } 1379 if (a->args && !symtable_visit_params_nested(st, a->args)) 1380 return 0; 1381 return 1; 1382 } 1383 1384 1385 static int 1386 symtable_visit_excepthandler(struct symtable *st, excepthandler_ty eh) 1387 { 1388 if (eh->v.ExceptHandler.type) 1389 VISIT(st, expr, eh->v.ExceptHandler.type); 1390 if (eh->v.ExceptHandler.name) 1391 VISIT(st, expr, eh->v.ExceptHandler.name); 1392 VISIT_SEQ(st, stmt, eh->v.ExceptHandler.body); 1393 return 1; 1394 } 1395 1396 1397 static int 1398 symtable_visit_alias(struct symtable *st, alias_ty a) 1399 { 1400 /* Compute store_name, the name actually bound by the import 1401 operation. It is different than a->name when a->name is a 1402 dotted package name (e.g. spam.eggs) 1403 */ 1404 PyObject *store_name; 1405 PyObject *name = (a->asname == NULL) ? a->name : a->asname; 1406 const char *base = PyString_AS_STRING(name); 1407 char *dot = strchr(base, '.'); 1408 if (dot) { 1409 store_name = PyString_FromStringAndSize(base, dot - base); 1410 if (!store_name) 1411 return 0; 1412 } 1413 else { 1414 store_name = name; 1415 Py_INCREF(store_name); 1416 } 1417 if (strcmp(PyString_AS_STRING(name), "*")) { 1418 int r = symtable_add_def(st, store_name, DEF_IMPORT); 1419 Py_DECREF(store_name); 1420 return r; 1421 } 1422 else { 1423 if (st->st_cur->ste_type != ModuleBlock) { 1424 int lineno = st->st_cur->ste_lineno; 1425 if (!symtable_warn(st, IMPORT_STAR_WARNING, lineno)) { 1426 Py_DECREF(store_name); 1427 return 0; 1428 } 1429 } 1430 st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR; 1431 Py_DECREF(store_name); 1432 return 1; 1433 } 1434 } 1435 1436 1437 static int 1438 symtable_visit_comprehension(struct symtable *st, comprehension_ty lc) 1439 { 1440 VISIT(st, expr, lc->target); 1441 VISIT(st, expr, lc->iter); 1442 VISIT_SEQ(st, expr, lc->ifs); 1443 return 1; 1444 } 1445 1446 1447 static int 1448 symtable_visit_keyword(struct symtable *st, keyword_ty k) 1449 { 1450 VISIT(st, expr, k->value); 1451 return 1; 1452 } 1453 1454 1455 static int 1456 symtable_visit_slice(struct symtable *st, slice_ty s) 1457 { 1458 switch (s->kind) { 1459 case Slice_kind: 1460 if (s->v.Slice.lower) 1461 VISIT(st, expr, s->v.Slice.lower) 1462 if (s->v.Slice.upper) 1463 VISIT(st, expr, s->v.Slice.upper) 1464 if (s->v.Slice.step) 1465 VISIT(st, expr, s->v.Slice.step) 1466 break; 1467 case ExtSlice_kind: 1468 VISIT_SEQ(st, slice, s->v.ExtSlice.dims) 1469 break; 1470 case Index_kind: 1471 VISIT(st, expr, s->v.Index.value) 1472 break; 1473 case Ellipsis_kind: 1474 break; 1475 } 1476 return 1; 994 1477 } 995 1478 … … 997 1480 symtable_new_tmpname(struct symtable *st) 998 1481 { 999 char tmpname[256]; 1000 identifier tmp; 1001 1002 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]", 1003 ++st->st_cur->ste_tmpname); 1004 tmp = PyString_InternFromString(tmpname); 1005 if (!tmp) 1006 return 0; 1007 if (!symtable_add_def(st, tmp, DEF_LOCAL)) 1008 return 0; 1009 Py_DECREF(tmp); 1010 return 1; 1011 } 1012 1013 static int 1014 symtable_visit_stmt(struct symtable *st, stmt_ty s) 1015 { 1016 switch (s->kind) { 1017 case FunctionDef_kind: 1018 if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL)) 1019 return 0; 1020 if (s->v.FunctionDef.args->defaults) 1021 VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults); 1022 if (s->v.FunctionDef.decorator_list) 1023 VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list); 1024 if (!symtable_enter_block(st, s->v.FunctionDef.name, 1025 FunctionBlock, (void *)s, s->lineno)) 1026 return 0; 1027 VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s); 1028 VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s); 1029 if (!symtable_exit_block(st, s)) 1030 return 0; 1031 break; 1032 case ClassDef_kind: { 1033 PyObject *tmp; 1034 if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL)) 1035 return 0; 1036 VISIT_SEQ(st, expr, s->v.ClassDef.bases); 1037 if (s->v.ClassDef.decorator_list) 1038 VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list); 1039 if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock, 1040 (void *)s, s->lineno)) 1041 return 0; 1042 tmp = st->st_private; 1043 st->st_private = s->v.ClassDef.name; 1044 VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s); 1045 st->st_private = tmp; 1046 if (!symtable_exit_block(st, s)) 1047 return 0; 1048 break; 1049 } 1050 case Return_kind: 1051 if (s->v.Return.value) { 1052 VISIT(st, expr, s->v.Return.value); 1053 st->st_cur->ste_returns_value = 1; 1054 if (st->st_cur->ste_generator) { 1055 PyErr_SetString(PyExc_SyntaxError, 1056 RETURN_VAL_IN_GENERATOR); 1057 PyErr_SyntaxLocation(st->st_filename, 1058 s->lineno); 1059 return 0; 1060 } 1061 } 1062 break; 1063 case Delete_kind: 1064 VISIT_SEQ(st, expr, s->v.Delete.targets); 1065 break; 1066 case Assign_kind: 1067 VISIT_SEQ(st, expr, s->v.Assign.targets); 1068 VISIT(st, expr, s->v.Assign.value); 1069 break; 1070 case AugAssign_kind: 1071 VISIT(st, expr, s->v.AugAssign.target); 1072 VISIT(st, expr, s->v.AugAssign.value); 1073 break; 1074 case Print_kind: 1075 if (s->v.Print.dest) 1076 VISIT(st, expr, s->v.Print.dest); 1077 VISIT_SEQ(st, expr, s->v.Print.values); 1078 break; 1079 case For_kind: 1080 VISIT(st, expr, s->v.For.target); 1081 VISIT(st, expr, s->v.For.iter); 1082 VISIT_SEQ(st, stmt, s->v.For.body); 1083 if (s->v.For.orelse) 1084 VISIT_SEQ(st, stmt, s->v.For.orelse); 1085 break; 1086 case While_kind: 1087 VISIT(st, expr, s->v.While.test); 1088 VISIT_SEQ(st, stmt, s->v.While.body); 1089 if (s->v.While.orelse) 1090 VISIT_SEQ(st, stmt, s->v.While.orelse); 1091 break; 1092 case If_kind: 1093 /* XXX if 0: and lookup_yield() hacks */ 1094 VISIT(st, expr, s->v.If.test); 1095 VISIT_SEQ(st, stmt, s->v.If.body); 1096 if (s->v.If.orelse) 1097 VISIT_SEQ(st, stmt, s->v.If.orelse); 1098 break; 1099 case Raise_kind: 1100 if (s->v.Raise.type) { 1101 VISIT(st, expr, s->v.Raise.type); 1102 if (s->v.Raise.inst) { 1103 VISIT(st, expr, s->v.Raise.inst); 1104 if (s->v.Raise.tback) 1105 VISIT(st, expr, s->v.Raise.tback); 1106 } 1107 } 1108 break; 1109 case TryExcept_kind: 1110 VISIT_SEQ(st, stmt, s->v.TryExcept.body); 1111 VISIT_SEQ(st, stmt, s->v.TryExcept.orelse); 1112 VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers); 1113 break; 1114 case TryFinally_kind: 1115 VISIT_SEQ(st, stmt, s->v.TryFinally.body); 1116 VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody); 1117 break; 1118 case Assert_kind: 1119 VISIT(st, expr, s->v.Assert.test); 1120 if (s->v.Assert.msg) 1121 VISIT(st, expr, s->v.Assert.msg); 1122 break; 1123 case Import_kind: 1124 VISIT_SEQ(st, alias, s->v.Import.names); 1125 /* XXX Don't have the lineno available inside 1126 visit_alias */ 1127 if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno) 1128 st->st_cur->ste_opt_lineno = s->lineno; 1129 break; 1130 case ImportFrom_kind: 1131 VISIT_SEQ(st, alias, s->v.ImportFrom.names); 1132 /* XXX Don't have the lineno available inside 1133 visit_alias */ 1134 if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno) 1135 st->st_cur->ste_opt_lineno = s->lineno; 1136 break; 1137 case Exec_kind: 1138 VISIT(st, expr, s->v.Exec.body); 1139 if (!st->st_cur->ste_opt_lineno) 1140 st->st_cur->ste_opt_lineno = s->lineno; 1141 if (s->v.Exec.globals) { 1142 st->st_cur->ste_unoptimized |= OPT_EXEC; 1143 VISIT(st, expr, s->v.Exec.globals); 1144 if (s->v.Exec.locals) 1145 VISIT(st, expr, s->v.Exec.locals); 1146 } else { 1147 st->st_cur->ste_unoptimized |= OPT_BARE_EXEC; 1148 } 1149 break; 1150 case Global_kind: { 1151 int i; 1152 asdl_seq *seq = s->v.Global.names; 1153 for (i = 0; i < asdl_seq_LEN(seq); i++) { 1154 identifier name = (identifier)asdl_seq_GET(seq, i); 1155 char *c_name = PyString_AS_STRING(name); 1156 long cur = symtable_lookup(st, name); 1157 if (cur < 0) 1158 return 0; 1159 if (cur & (DEF_LOCAL | USE)) { 1160 char buf[256]; 1161 if (cur & DEF_LOCAL) 1162 PyOS_snprintf(buf, sizeof(buf), 1163 GLOBAL_AFTER_ASSIGN, 1164 c_name); 1165 else 1166 PyOS_snprintf(buf, sizeof(buf), 1167 GLOBAL_AFTER_USE, 1168 c_name); 1169 if (!symtable_warn(st, buf, s->lineno)) 1170 return 0; 1171 } 1172 if (!symtable_add_def(st, name, DEF_GLOBAL)) 1173 return 0; 1174 } 1175 break; 1176 } 1177 case Expr_kind: 1178 VISIT(st, expr, s->v.Expr.value); 1179 break; 1180 case Pass_kind: 1181 case Break_kind: 1182 case Continue_kind: 1183 /* nothing to do here */ 1184 break; 1185 case With_kind: 1186 if (!symtable_new_tmpname(st)) 1187 return 0; 1188 VISIT(st, expr, s->v.With.context_expr); 1189 if (s->v.With.optional_vars) { 1190 if (!symtable_new_tmpname(st)) 1191 return 0; 1192 VISIT(st, expr, s->v.With.optional_vars); 1193 } 1194 VISIT_SEQ(st, stmt, s->v.With.body); 1195 break; 1196 } 1197 return 1; 1198 } 1199 1200 static int 1201 symtable_visit_expr(struct symtable *st, expr_ty e) 1202 { 1203 switch (e->kind) { 1204 case BoolOp_kind: 1205 VISIT_SEQ(st, expr, e->v.BoolOp.values); 1206 break; 1207 case BinOp_kind: 1208 VISIT(st, expr, e->v.BinOp.left); 1209 VISIT(st, expr, e->v.BinOp.right); 1210 break; 1211 case UnaryOp_kind: 1212 VISIT(st, expr, e->v.UnaryOp.operand); 1213 break; 1214 case Lambda_kind: { 1215 if (!GET_IDENTIFIER(lambda) || 1216 !symtable_add_def(st, lambda, DEF_LOCAL)) 1217 return 0; 1218 if (e->v.Lambda.args->defaults) 1219 VISIT_SEQ(st, expr, e->v.Lambda.args->defaults); 1220 if (!symtable_enter_block(st, lambda, 1221 FunctionBlock, (void *)e, e->lineno)) 1222 return 0; 1223 VISIT_IN_BLOCK(st, arguments, e->v.Lambda.args, (void*)e); 1224 VISIT_IN_BLOCK(st, expr, e->v.Lambda.body, (void*)e); 1225 if (!symtable_exit_block(st, (void *)e)) 1226 return 0; 1227 break; 1228 } 1229 case IfExp_kind: 1230 VISIT(st, expr, e->v.IfExp.test); 1231 VISIT(st, expr, e->v.IfExp.body); 1232 VISIT(st, expr, e->v.IfExp.orelse); 1233 break; 1234 case Dict_kind: 1235 VISIT_SEQ(st, expr, e->v.Dict.keys); 1236 VISIT_SEQ(st, expr, e->v.Dict.values); 1237 break; 1238 case ListComp_kind: 1239 if (!symtable_new_tmpname(st)) 1240 return 0; 1241 VISIT(st, expr, e->v.ListComp.elt); 1242 VISIT_SEQ(st, comprehension, e->v.ListComp.generators); 1243 break; 1244 case GeneratorExp_kind: 1245 if (!symtable_visit_genexp(st, e)) 1246 return 0; 1247 break; 1248 case Yield_kind: 1249 if (e->v.Yield.value) 1250 VISIT(st, expr, e->v.Yield.value); 1251 st->st_cur->ste_generator = 1; 1252 if (st->st_cur->ste_returns_value) { 1253 PyErr_SetString(PyExc_SyntaxError, 1254 RETURN_VAL_IN_GENERATOR); 1255 PyErr_SyntaxLocation(st->st_filename, 1256 e->lineno); 1257 return 0; 1258 } 1259 break; 1260 case Compare_kind: 1261 VISIT(st, expr, e->v.Compare.left); 1262 VISIT_SEQ(st, expr, e->v.Compare.comparators); 1263 break; 1264 case Call_kind: 1265 VISIT(st, expr, e->v.Call.func); 1266 VISIT_SEQ(st, expr, e->v.Call.args); 1267 VISIT_SEQ(st, keyword, e->v.Call.keywords); 1268 if (e->v.Call.starargs) 1269 VISIT(st, expr, e->v.Call.starargs); 1270 if (e->v.Call.kwargs) 1271 VISIT(st, expr, e->v.Call.kwargs); 1272 break; 1273 case Repr_kind: 1274 VISIT(st, expr, e->v.Repr.value); 1275 break; 1276 case Num_kind: 1277 case Str_kind: 1278 /* Nothing to do here. */ 1279 break; 1280 /* The following exprs can be assignment targets. */ 1281 case Attribute_kind: 1282 VISIT(st, expr, e->v.Attribute.value); 1283 break; 1284 case Subscript_kind: 1285 VISIT(st, expr, e->v.Subscript.value); 1286 VISIT(st, slice, e->v.Subscript.slice); 1287 break; 1288 case Name_kind: 1289 if (!symtable_add_def(st, e->v.Name.id, 1290 e->v.Name.ctx == Load ? USE : DEF_LOCAL)) 1291 return 0; 1292 break; 1293 /* child nodes of List and Tuple will have expr_context set */ 1294 case List_kind: 1295 VISIT_SEQ(st, expr, e->v.List.elts); 1296 break; 1297 case Tuple_kind: 1298 VISIT_SEQ(st, expr, e->v.Tuple.elts); 1299 break; 1300 } 1301 return 1; 1302 } 1303 1304 static int 1305 symtable_implicit_arg(struct symtable *st, int pos) 1306 { 1307 PyObject *id = PyString_FromFormat(".%d", pos); 1308 if (id == NULL) 1309 return 0; 1310 if (!symtable_add_def(st, id, DEF_PARAM)) { 1311 Py_DECREF(id); 1312 return 0; 1313 } 1314 Py_DECREF(id); 1315 return 1; 1316 } 1317 1318 static int 1319 symtable_visit_params(struct symtable *st, asdl_seq *args, int toplevel) 1320 { 1321 int i; 1322 1323 /* go through all the toplevel arguments first */ 1324 for (i = 0; i < asdl_seq_LEN(args); i++) { 1325 expr_ty arg = (expr_ty)asdl_seq_GET(args, i); 1326 if (arg->kind == Name_kind) { 1327 assert(arg->v.Name.ctx == Param || 1328 (arg->v.Name.ctx == Store && !toplevel)); 1329 if (!symtable_add_def(st, arg->v.Name.id, DEF_PARAM)) 1330 return 0; 1331 } 1332 else if (arg->kind == Tuple_kind) { 1333 assert(arg->v.Tuple.ctx == Store); 1334 if (toplevel) { 1335 if (!symtable_implicit_arg(st, i)) 1336 return 0; 1337 } 1338 } 1339 else { 1340 PyErr_SetString(PyExc_SyntaxError, 1341 "invalid expression in parameter list"); 1342 PyErr_SyntaxLocation(st->st_filename, 1343 st->st_cur->ste_lineno); 1344 return 0; 1345 } 1346 } 1347 1348 if (!toplevel) { 1349 if (!symtable_visit_params_nested(st, args)) 1350 return 0; 1351 } 1352 1353 return 1; 1354 } 1355 1356 static int 1357 symtable_visit_params_nested(struct symtable *st, asdl_seq *args) 1358 { 1359 int i; 1360 for (i = 0; i < asdl_seq_LEN(args); i++) { 1361 expr_ty arg = (expr_ty)asdl_seq_GET(args, i); 1362 if (arg->kind == Tuple_kind && 1363 !symtable_visit_params(st, arg->v.Tuple.elts, 0)) 1364 return 0; 1365 } 1366 1367 return 1; 1368 } 1369 1370 static int 1371 symtable_visit_arguments(struct symtable *st, arguments_ty a) 1372 { 1373 /* skip default arguments inside function block 1374 XXX should ast be different? 1375 */ 1376 if (a->args && !symtable_visit_params(st, a->args, 1)) 1377 return 0; 1378 if (a->vararg) { 1379 if (!symtable_add_def(st, a->vararg, DEF_PARAM)) 1380 return 0; 1381 st->st_cur->ste_varargs = 1; 1382 } 1383 if (a->kwarg) { 1384 if (!symtable_add_def(st, a->kwarg, DEF_PARAM)) 1385 return 0; 1386 st->st_cur->ste_varkeywords = 1; 1387 } 1388 if (a->args && !symtable_visit_params_nested(st, a->args)) 1389 return 0; 1390 return 1; 1391 } 1392 1393 1394 static int 1395 symtable_visit_excepthandler(struct symtable *st, excepthandler_ty eh) 1396 { 1397 if (eh->v.ExceptHandler.type) 1398 VISIT(st, expr, eh->v.ExceptHandler.type); 1399 if (eh->v.ExceptHandler.name) 1400 VISIT(st, expr, eh->v.ExceptHandler.name); 1401 VISIT_SEQ(st, stmt, eh->v.ExceptHandler.body); 1402 return 1; 1403 } 1404 1405 1406 static int 1407 symtable_visit_alias(struct symtable *st, alias_ty a) 1408 { 1409 /* Compute store_name, the name actually bound by the import 1410 operation. It is diferent than a->name when a->name is a 1411 dotted package name (e.g. spam.eggs) 1412 */ 1413 PyObject *store_name; 1414 PyObject *name = (a->asname == NULL) ? a->name : a->asname; 1415 const char *base = PyString_AS_STRING(name); 1416 char *dot = strchr(base, '.'); 1417 if (dot) { 1418 store_name = PyString_FromStringAndSize(base, dot - base); 1419 if (!store_name) 1420 return 0; 1421 } 1422 else { 1423 store_name = name; 1424 Py_INCREF(store_name); 1425 } 1426 if (strcmp(PyString_AS_STRING(name), "*")) { 1427 int r = symtable_add_def(st, store_name, DEF_IMPORT); 1428 Py_DECREF(store_name); 1429 return r; 1430 } 1431 else { 1432 if (st->st_cur->ste_type != ModuleBlock) { 1433 int lineno = st->st_cur->ste_lineno; 1434 if (!symtable_warn(st, IMPORT_STAR_WARNING, lineno)) { 1435 Py_DECREF(store_name); 1436 return 0; 1437 } 1438 } 1439 st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR; 1440 Py_DECREF(store_name); 1441 return 1; 1442 } 1443 } 1444 1445 1446 static int 1447 symtable_visit_comprehension(struct symtable *st, comprehension_ty lc) 1448 { 1449 VISIT(st, expr, lc->target); 1450 VISIT(st, expr, lc->iter); 1451 VISIT_SEQ(st, expr, lc->ifs); 1452 return 1; 1453 } 1454 1455 1456 static int 1457 symtable_visit_keyword(struct symtable *st, keyword_ty k) 1458 { 1459 VISIT(st, expr, k->value); 1460 return 1; 1461 } 1462 1463 1464 static int 1465 symtable_visit_slice(struct symtable *st, slice_ty s) 1466 { 1467 switch (s->kind) { 1468 case Slice_kind: 1469 if (s->v.Slice.lower) 1470 VISIT(st, expr, s->v.Slice.lower) 1471 if (s->v.Slice.upper) 1472 VISIT(st, expr, s->v.Slice.upper) 1473 if (s->v.Slice.step) 1474 VISIT(st, expr, s->v.Slice.step) 1475 break; 1476 case ExtSlice_kind: 1477 VISIT_SEQ(st, slice, s->v.ExtSlice.dims) 1478 break; 1479 case Index_kind: 1480 VISIT(st, expr, s->v.Index.value) 1481 break; 1482 case Ellipsis_kind: 1483 break; 1484 } 1485 return 1; 1486 } 1487 1488 static int 1482 char tmpname[256]; 1483 identifier tmp; 1484 1485 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]", 1486 ++st->st_cur->ste_tmpname); 1487 tmp = PyString_InternFromString(tmpname); 1488 if (!tmp) 1489 return 0; 1490 if (!symtable_add_def(st, tmp, DEF_LOCAL)) 1491 return 0; 1492 Py_DECREF(tmp); 1493 return 1; 1494 } 1495 1496 static int 1497 symtable_handle_comprehension(struct symtable *st, expr_ty e, 1498 identifier scope_name, asdl_seq *generators, 1499 expr_ty elt, expr_ty value) 1500 { 1501 int is_generator = (e->kind == GeneratorExp_kind); 1502 int needs_tmp = !is_generator; 1503 comprehension_ty outermost = ((comprehension_ty) 1504 asdl_seq_GET(generators, 0)); 1505 /* Outermost iterator is evaluated in current scope */ 1506 VISIT(st, expr, outermost->iter); 1507 /* Create comprehension scope for the rest */ 1508 if (!scope_name || 1509 !symtable_enter_block(st, scope_name, FunctionBlock, (void *)e, 0)) { 1510 return 0; 1511 } 1512 st->st_cur->ste_generator = is_generator; 1513 /* Outermost iter is received as an argument */ 1514 if (!symtable_implicit_arg(st, 0)) { 1515 symtable_exit_block(st, (void *)e); 1516 return 0; 1517 } 1518 /* Allocate temporary name if needed */ 1519 if (needs_tmp && !symtable_new_tmpname(st)) { 1520 symtable_exit_block(st, (void *)e); 1521 return 0; 1522 } 1523 VISIT_IN_BLOCK(st, expr, outermost->target, (void*)e); 1524 VISIT_SEQ_IN_BLOCK(st, expr, outermost->ifs, (void*)e); 1525 VISIT_SEQ_TAIL_IN_BLOCK(st, comprehension, 1526 generators, 1, (void*)e); 1527 if (value) 1528 VISIT_IN_BLOCK(st, expr, value, (void*)e); 1529 VISIT_IN_BLOCK(st, expr, elt, (void*)e); 1530 return symtable_exit_block(st, (void *)e); 1531 } 1532 1533 static int 1489 1534 symtable_visit_genexp(struct symtable *st, expr_ty e) 1490 1535 { 1491 comprehension_ty outermost = ((comprehension_ty) 1492 (asdl_seq_GET(e->v.GeneratorExp.generators, 0))); 1493 /* Outermost iterator is evaluated in current scope */ 1494 VISIT(st, expr, outermost->iter); 1495 /* Create generator scope for the rest */ 1496 if (!GET_IDENTIFIER(genexpr) || 1497 !symtable_enter_block(st, genexpr, FunctionBlock, (void *)e, e->lineno)) { 1498 return 0; 1499 } 1500 st->st_cur->ste_generator = 1; 1501 /* Outermost iter is received as an argument */ 1502 if (!symtable_implicit_arg(st, 0)) { 1503 symtable_exit_block(st, (void *)e); 1504 return 0; 1505 } 1506 VISIT_IN_BLOCK(st, expr, outermost->target, (void*)e); 1507 VISIT_SEQ_IN_BLOCK(st, expr, outermost->ifs, (void*)e); 1508 VISIT_SEQ_TAIL_IN_BLOCK(st, comprehension, 1509 e->v.GeneratorExp.generators, 1, (void*)e); 1510 VISIT_IN_BLOCK(st, expr, e->v.GeneratorExp.elt, (void*)e); 1511 return symtable_exit_block(st, (void *)e); 1512 } 1536 return symtable_handle_comprehension(st, e, GET_IDENTIFIER(genexpr), 1537 e->v.GeneratorExp.generators, 1538 e->v.GeneratorExp.elt, NULL); 1539 } 1540 1541 static int 1542 symtable_visit_setcomp(struct symtable *st, expr_ty e) 1543 { 1544 return symtable_handle_comprehension(st, e, GET_IDENTIFIER(setcomp), 1545 e->v.SetComp.generators, 1546 e->v.SetComp.elt, NULL); 1547 } 1548 1549 static int 1550 symtable_visit_dictcomp(struct symtable *st, expr_ty e) 1551 { 1552 return symtable_handle_comprehension(st, e, GET_IDENTIFIER(dictcomp), 1553 e->v.DictComp.generators, 1554 e->v.DictComp.key, 1555 e->v.DictComp.value); 1556 }
Note:
See TracChangeset
for help on using the changeset viewer.
