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