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