2 #include "Python-ast.h"
5 #include "structmember.h"
7 /* error strings used for warnings */
8 #define GLOBAL_AFTER_ASSIGN \
9 "name '%.400s' is assigned to before global declaration"
11 #define GLOBAL_AFTER_USE \
12 "name '%.400s' is used prior to global declaration"
14 #define IMPORT_STAR_WARNING "import * only allowed at module level"
16 #define RETURN_VAL_IN_GENERATOR \
17 "'return' with argument inside generator"
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
)
24 PySTEntryObject
*ste
= NULL
;
27 k
= PyLong_FromVoidPtr(key
);
30 ste
= (PySTEntryObject
*)PyObject_New(PySTEntryObject
,
39 ste
->ste_symbols
= NULL
;
40 ste
->ste_varnames
= NULL
;
41 ste
->ste_children
= NULL
;
43 ste
->ste_symbols
= PyDict_New();
44 if (ste
->ste_symbols
== NULL
)
47 ste
->ste_varnames
= PyList_New(0);
48 if (ste
->ste_varnames
== NULL
)
51 ste
->ste_children
= PyList_New(0);
52 if (ste
->ste_children
== NULL
)
55 ste
->ste_type
= block
;
56 ste
->ste_unoptimized
= 0;
60 ste
->ste_varkeywords
= 0;
61 ste
->ste_opt_lineno
= 0;
63 ste
->ste_lineno
= lineno
;
65 if (st
->st_cur
!= NULL
&&
66 (st
->st_cur
->ste_nested
||
67 st
->st_cur
->ste_type
== FunctionBlock
))
69 ste
->ste_child_free
= 0;
70 ste
->ste_generator
= 0;
71 ste
->ste_returns_value
= 0;
73 if (PyDict_SetItem(st
->st_symbols
, ste
->ste_id
, (PyObject
*)ste
) < 0)
83 ste_repr(PySTEntryObject
*ste
)
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
);
95 ste_dealloc(PySTEntryObject
*ste
)
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
);
106 #define OFF(x) offsetof(PySTEntryObject, x)
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
},
119 PyTypeObject PySTEntry_Type
= {
120 PyObject_HEAD_INIT(&PyType_Type
)
123 sizeof(PySTEntryObject
),
125 (destructor
)ste_dealloc
, /* tp_dealloc */
130 (reprfunc
)ste_repr
, /* tp_repr */
131 0, /* tp_as_number */
132 0, /* tp_as_sequence */
133 0, /* tp_as_mapping */
137 PyObject_GenericGetAttr
, /* tp_getattro */
139 0, /* tp_as_buffer */
140 Py_TPFLAGS_DEFAULT
, /* tp_flags */
144 0, /* tp_richcompare */
145 0, /* tp_weaklistoffset */
149 ste_memberlist
, /* tp_members */
153 0, /* tp_descr_get */
154 0, /* tp_descr_set */
155 0, /* tp_dictoffset */
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
);
180 static identifier top
= NULL
, lambda
= NULL
, genexpr
= NULL
;
182 #define GET_IDENTIFIER(VAR) \
183 ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))
185 #define DUPLICATE_ARGUMENT \
186 "duplicate argument '%s' in function definition"
188 static struct symtable
*
193 st
= (struct symtable
*)PyMem_Malloc(sizeof(struct symtable
));
197 st
->st_filename
= NULL
;
198 st
->st_symbols
= NULL
;
200 if ((st
->st_stack
= PyList_New(0)) == NULL
)
202 if ((st
->st_symbols
= PyDict_New()) == NULL
)
206 st
->st_private
= NULL
;
214 PySymtable_Build(mod_ty mod
, const char *filename
, PyFutureFeatures
*future
)
216 struct symtable
*st
= symtable_new();
222 st
->st_filename
= filename
;
223 st
->st_future
= future
;
224 symtable_enter_block(st
, GET_IDENTIFIER(top
), ModuleBlock
,
226 st
->st_top
= st
->st_cur
;
227 st
->st_cur
->ste_unoptimized
= OPT_TOPLEVEL
;
228 /* Any other top-level initialization? */
231 seq
= mod
->v
.Module
.body
;
232 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++)
233 if (!symtable_visit_stmt(st
,
234 (stmt_ty
)asdl_seq_GET(seq
, i
)))
237 case Expression_kind
:
238 if (!symtable_visit_expr(st
, mod
->v
.Expression
.body
))
241 case Interactive_kind
:
242 seq
= mod
->v
.Interactive
.body
;
243 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++)
244 if (!symtable_visit_stmt(st
,
245 (stmt_ty
)asdl_seq_GET(seq
, i
)))
249 PyErr_SetString(PyExc_RuntimeError
,
250 "this compiler does not handle Suites");
253 if (!symtable_exit_block(st
, (void *)mod
)) {
257 if (symtable_analyze(st
))
262 (void) symtable_exit_block(st
, (void *)mod
);
268 PySymtable_Free(struct symtable
*st
)
270 Py_XDECREF(st
->st_symbols
);
271 Py_XDECREF(st
->st_stack
);
272 PyMem_Free((void *)st
);
276 PySymtable_Lookup(struct symtable
*st
, void *key
)
280 k
= PyLong_FromVoidPtr(key
);
283 v
= PyDict_GetItem(st
->st_symbols
, k
);
285 assert(PySTEntry_Check(v
));
289 PyErr_SetString(PyExc_KeyError
,
290 "unknown symbol table entry");
294 return (PySTEntryObject
*)v
;
298 PyST_GetScope(PySTEntryObject
*ste
, PyObject
*name
)
300 PyObject
*v
= PyDict_GetItem(ste
->ste_symbols
, name
);
303 assert(PyInt_Check(v
));
304 return (PyInt_AS_LONG(v
) >> SCOPE_OFF
) & SCOPE_MASK
;
308 /* Analyze raw symbol information to determine scope of each name.
310 The next several functions are helpers for PySymtable_Analyze(),
311 which determines whether a name is local, global, or free. In addition,
312 it determines which local variables are cell variables; they provide
313 bindings that are used for free variables in enclosed blocks.
315 There are also two kinds of free variables, implicit and explicit. An
316 explicit global is declared with the global statement. An implicit
317 global is a free variable for which the compiler has found no binding
318 in an enclosing function scope. The implicit global is either a global
319 or a builtin. Python's module and class blocks use the xxx_NAME opcodes
320 to handle these names to implement slightly odd semantics. In such a
321 block, the name is treated as global until it is assigned to; then it
322 is treated as a local.
324 The symbol table requires two passes to determine the scope of each name.
325 The first pass collects raw facts from the AST: the name is a parameter
326 here, the name is used by not defined here, etc. The second pass analyzes
327 these facts during a pass over the PySTEntryObjects created during pass 1.
329 When a function is entered during the second pass, the parent passes
330 the set of all name bindings visible to its children. These bindings
331 are used to determine if the variable is free or an implicit global.
332 After doing the local analysis, it analyzes each of its child blocks
333 using an updated set of name bindings.
335 The children update the free variable set. If a local variable is free
336 in a child, the variable is marked as a cell. The current function must
337 provide runtime storage for the variable that may outlive the function's
338 frame. Cell variables are removed from the free set before the analyze
339 function returns to its parent.
341 The sets of bound and free variables are implemented as dictionaries
342 mapping strings to None.
345 #define SET_SCOPE(DICT, NAME, I) { \
346 PyObject *o = PyInt_FromLong(I); \
349 if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
356 /* Decide on scope of name, given flags.
358 The dicts passed in as arguments are modified as necessary.
359 ste is passed so that flags can be updated.
363 analyze_name(PySTEntryObject
*ste
, PyObject
*dict
, PyObject
*name
, long flags
,
364 PyObject
*bound
, PyObject
*local
, PyObject
*free
,
367 if (flags
& DEF_GLOBAL
) {
368 if (flags
& DEF_PARAM
) {
369 PyErr_Format(PyExc_SyntaxError
,
370 "name '%s' is local and global",
371 PyString_AS_STRING(name
));
374 SET_SCOPE(dict
, name
, GLOBAL_EXPLICIT
);
375 if (PyDict_SetItem(global
, name
, Py_None
) < 0)
377 if (bound
&& PyDict_GetItem(bound
, name
)) {
378 if (PyDict_DelItem(bound
, name
) < 0)
383 if (flags
& DEF_BOUND
) {
384 SET_SCOPE(dict
, name
, LOCAL
);
385 if (PyDict_SetItem(local
, name
, Py_None
) < 0)
387 if (PyDict_GetItem(global
, name
)) {
388 if (PyDict_DelItem(global
, name
) < 0)
393 /* If an enclosing block has a binding for this name, it
394 is a free variable rather than a global variable.
395 Note that having a non-NULL bound implies that the block
398 if (bound
&& PyDict_GetItem(bound
, name
)) {
399 SET_SCOPE(dict
, name
, FREE
);
401 if (PyDict_SetItem(free
, name
, Py_None
) < 0)
405 /* If a parent has a global statement, then call it global
406 explicit? It could also be global implicit.
408 else if (global
&& PyDict_GetItem(global
, name
)) {
409 SET_SCOPE(dict
, name
, GLOBAL_EXPLICIT
);
415 SET_SCOPE(dict
, name
, GLOBAL_IMPLICIT
);
418 return 0; /* Can't get here */
423 /* If a name is defined in free and also in locals, then this block
424 provides the binding for the free variable. The name should be
425 marked CELL in this block and removed from the free list.
427 Note that the current block's free variables are included in free.
428 That's safe because no name can be free and local in the same scope.
432 analyze_cells(PyObject
*scope
, PyObject
*free
)
434 PyObject
*name
, *v
, *w
;
438 w
= PyInt_FromLong(CELL
);
441 while (PyDict_Next(scope
, &pos
, &name
, &v
)) {
443 assert(PyInt_Check(v
));
444 flags
= PyInt_AS_LONG(v
);
447 if (!PyDict_GetItem(free
, name
))
449 /* Replace LOCAL with CELL for this name, and remove
450 from free. It is safe to replace the value of name
451 in the dict, because it will not cause a resize.
453 if (PyDict_SetItem(scope
, name
, w
) < 0)
455 if (!PyDict_DelItem(free
, name
) < 0)
464 /* Check for illegal statements in unoptimized namespaces */
466 check_unoptimized(const PySTEntryObject
* ste
) {
470 if (ste
->ste_type
!= FunctionBlock
|| !ste
->ste_unoptimized
471 || !(ste
->ste_free
|| ste
->ste_child_free
))
474 trailer
= (ste
->ste_child_free
?
475 "contains a nested function with free variables" :
476 "is a nested function");
478 switch (ste
->ste_unoptimized
) {
479 case OPT_TOPLEVEL
: /* exec / import * at top-level is fine */
480 case OPT_EXEC
: /* qualified exec is fine */
482 case OPT_IMPORT_STAR
:
483 PyOS_snprintf(buf
, sizeof(buf
),
484 "import * is not allowed in function '%.100s' "
486 PyString_AS_STRING(ste
->ste_name
), trailer
);
489 PyOS_snprintf(buf
, sizeof(buf
),
490 "unqualified exec is not allowed in function "
492 PyString_AS_STRING(ste
->ste_name
), trailer
);
495 PyOS_snprintf(buf
, sizeof(buf
),
496 "function '%.100s' uses import * and bare exec, "
497 "which are illegal because it %s",
498 PyString_AS_STRING(ste
->ste_name
), trailer
);
502 PyErr_SetString(PyExc_SyntaxError
, buf
);
503 PyErr_SyntaxLocation(ste
->ste_table
->st_filename
,
504 ste
->ste_opt_lineno
);
508 /* Enter the final scope information into the st_symbols dict.
510 * All arguments are dicts. Modifies symbols, others are read-only.
513 update_symbols(PyObject
*symbols
, PyObject
*scope
,
514 PyObject
*bound
, PyObject
*free
, int classflag
)
516 PyObject
*name
, *v
, *u
, *w
, *free_value
= NULL
;
519 while (PyDict_Next(symbols
, &pos
, &name
, &v
)) {
521 assert(PyInt_Check(v
));
522 flags
= PyInt_AS_LONG(v
);
523 w
= PyDict_GetItem(scope
, name
);
524 assert(w
&& PyInt_Check(w
));
525 i
= PyInt_AS_LONG(w
);
526 flags
|= (i
<< SCOPE_OFF
);
527 u
= PyInt_FromLong(flags
);
528 if (PyDict_SetItem(symbols
, name
, u
) < 0) {
535 free_value
= PyInt_FromLong(FREE
<< SCOPE_OFF
);
539 /* add a free variable when it's only use is for creating a closure */
541 while (PyDict_Next(free
, &pos
, &name
, &v
)) {
542 PyObject
*o
= PyDict_GetItem(symbols
, name
);
545 /* It could be a free variable in a method of
546 the class that has the same name as a local
547 or global in the class scope.
550 PyInt_AS_LONG(o
) & (DEF_BOUND
| DEF_GLOBAL
)) {
551 long i
= PyInt_AS_LONG(o
) | DEF_FREE_CLASS
;
552 o
= PyInt_FromLong(i
);
554 Py_DECREF(free_value
);
557 if (PyDict_SetItem(symbols
, name
, o
) < 0) {
559 Py_DECREF(free_value
);
564 /* else it's not free, probably a cell */
567 if (!PyDict_GetItem(bound
, name
))
568 continue; /* it's a global */
570 if (PyDict_SetItem(symbols
, name
, free_value
) < 0) {
571 Py_DECREF(free_value
);
575 Py_DECREF(free_value
);
579 /* Make final symbol table decisions for block of ste.
581 ste -- current symtable entry (input/output)
582 bound -- set of variables bound in enclosing scopes (input)
583 free -- set of free variables in enclosed scopes (output)
584 globals -- set of declared global variables in enclosing scopes (input)
588 analyze_block(PySTEntryObject
*ste
, PyObject
*bound
, PyObject
*free
,
591 PyObject
*name
, *v
, *local
= NULL
, *scope
= NULL
, *newbound
= NULL
;
592 PyObject
*newglobal
= NULL
, *newfree
= NULL
;
596 local
= PyDict_New();
599 scope
= PyDict_New();
602 newglobal
= PyDict_New();
605 newfree
= PyDict_New();
608 newbound
= PyDict_New();
612 if (ste
->ste_type
== ClassBlock
) {
613 /* make a copy of globals before calling analyze_name(),
614 because global statements in the class have no effect
617 if (PyDict_Update(newglobal
, global
) < 0)
620 if (PyDict_Update(newbound
, bound
) < 0)
624 assert(PySTEntry_Check(ste
));
625 assert(PyDict_Check(ste
->ste_symbols
));
626 while (PyDict_Next(ste
->ste_symbols
, &pos
, &name
, &v
)) {
627 long flags
= PyInt_AS_LONG(v
);
628 if (!analyze_name(ste
, scope
, name
, flags
, bound
, local
, free
,
633 if (ste
->ste_type
!= ClassBlock
) {
634 if (ste
->ste_type
== FunctionBlock
) {
635 if (PyDict_Update(newbound
, local
) < 0)
639 if (PyDict_Update(newbound
, bound
) < 0)
642 if (PyDict_Update(newglobal
, global
) < 0)
646 /* Recursively call analyze_block() on each child block */
647 for (i
= 0; i
< PyList_GET_SIZE(ste
->ste_children
); ++i
) {
648 PyObject
*c
= PyList_GET_ITEM(ste
->ste_children
, i
);
649 PySTEntryObject
* entry
;
650 assert(c
&& PySTEntry_Check(c
));
651 entry
= (PySTEntryObject
*)c
;
652 if (!analyze_block(entry
, newbound
, newfree
, newglobal
))
654 if (entry
->ste_free
|| entry
->ste_child_free
)
655 ste
->ste_child_free
= 1;
658 if (ste
->ste_type
== FunctionBlock
&& !analyze_cells(scope
, newfree
))
660 if (!update_symbols(ste
->ste_symbols
, scope
, bound
, newfree
,
661 ste
->ste_type
== ClassBlock
))
663 if (!check_unoptimized(ste
))
666 if (PyDict_Update(free
, newfree
) < 0)
672 Py_XDECREF(newbound
);
673 Py_XDECREF(newglobal
);
676 assert(PyErr_Occurred());
681 symtable_analyze(struct symtable
*st
)
683 PyObject
*free
, *global
;
689 global
= PyDict_New();
694 r
= analyze_block(st
->st_top
, NULL
, free
, global
);
702 symtable_warn(struct symtable
*st
, char *msg
, int lineno
)
704 if (PyErr_WarnExplicit(PyExc_SyntaxWarning
, msg
, st
->st_filename
,
705 lineno
, NULL
, NULL
) < 0) {
706 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning
)) {
707 PyErr_SetString(PyExc_SyntaxError
, msg
);
708 PyErr_SyntaxLocation(st
->st_filename
,
709 st
->st_cur
->ste_lineno
);
716 /* symtable_enter_block() gets a reference via PySTEntry_New().
717 This reference is released when the block is exited, via the DECREF
718 in symtable_exit_block().
722 symtable_exit_block(struct symtable
*st
, void *ast
)
726 Py_DECREF(st
->st_cur
);
727 end
= PyList_GET_SIZE(st
->st_stack
) - 1;
729 st
->st_cur
= (PySTEntryObject
*)PyList_GET_ITEM(st
->st_stack
,
731 Py_INCREF(st
->st_cur
);
732 if (PySequence_DelItem(st
->st_stack
, end
) < 0)
739 symtable_enter_block(struct symtable
*st
, identifier name
, _Py_block_ty block
,
740 void *ast
, int lineno
)
742 PySTEntryObject
*prev
= NULL
;
746 if (PyList_Append(st
->st_stack
, (PyObject
*)st
->st_cur
) < 0) {
749 Py_DECREF(st
->st_cur
);
751 st
->st_cur
= PySTEntry_New(st
, name
, block
, ast
, lineno
);
752 if (name
== GET_IDENTIFIER(top
))
753 st
->st_global
= st
->st_cur
->ste_symbols
;
755 if (PyList_Append(prev
->ste_children
,
756 (PyObject
*)st
->st_cur
) < 0) {
764 symtable_lookup(struct symtable
*st
, PyObject
*name
)
767 PyObject
*mangled
= _Py_Mangle(st
->st_private
, name
);
770 o
= PyDict_GetItem(st
->st_cur
->ste_symbols
, mangled
);
774 return PyInt_AsLong(o
);
778 symtable_add_def(struct symtable
*st
, PyObject
*name
, int flag
)
783 PyObject
*mangled
= _Py_Mangle(st
->st_private
, name
);
787 dict
= st
->st_cur
->ste_symbols
;
788 if ((o
= PyDict_GetItem(dict
, mangled
))) {
789 val
= PyInt_AS_LONG(o
);
790 if ((flag
& DEF_PARAM
) && (val
& DEF_PARAM
)) {
791 /* Is it better to use 'mangled' or 'name' here? */
792 PyErr_Format(PyExc_SyntaxError
, DUPLICATE_ARGUMENT
,
793 PyString_AsString(name
));
794 PyErr_SyntaxLocation(st
->st_filename
,
795 st
->st_cur
->ste_lineno
);
801 o
= PyInt_FromLong(val
);
804 if (PyDict_SetItem(dict
, mangled
, o
) < 0) {
810 if (flag
& DEF_PARAM
) {
811 if (PyList_Append(st
->st_cur
->ste_varnames
, mangled
) < 0)
813 } else if (flag
& DEF_GLOBAL
) {
814 /* XXX need to update DEF_GLOBAL for other flags too;
815 perhaps only DEF_FREE_GLOBAL */
817 if ((o
= PyDict_GetItem(st
->st_global
, mangled
))) {
818 val
|= PyInt_AS_LONG(o
);
820 o
= PyInt_FromLong(val
);
823 if (PyDict_SetItem(st
->st_global
, mangled
, o
) < 0) {
837 /* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.
838 They use the ASDL name to synthesize the name of the C type and the visit
841 VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is
842 useful if the first node in the sequence requires special treatment.
845 #define VISIT(ST, TYPE, V) \
846 if (!symtable_visit_ ## TYPE((ST), (V))) \
849 #define VISIT_IN_BLOCK(ST, TYPE, V, S) \
850 if (!symtable_visit_ ## TYPE((ST), (V))) { \
851 symtable_exit_block((ST), (S)); \
855 #define VISIT_SEQ(ST, TYPE, SEQ) { \
857 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
858 for (i = 0; i < asdl_seq_LEN(seq); i++) { \
859 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
860 if (!symtable_visit_ ## TYPE((ST), elt)) \
865 #define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \
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 symtable_exit_block((ST), (S)); \
877 #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
879 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
880 for (i = (START); i < asdl_seq_LEN(seq); i++) { \
881 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
882 if (!symtable_visit_ ## TYPE((ST), elt)) \
887 #define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \
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 symtable_exit_block((ST), (S)); \
900 symtable_new_tmpname(struct symtable
*st
)
905 PyOS_snprintf(tmpname
, sizeof(tmpname
), "_[%d]",
906 ++st
->st_cur
->ste_tmpname
);
907 tmp
= PyString_InternFromString(tmpname
);
908 if (!symtable_add_def(st
, tmp
, DEF_LOCAL
))
915 symtable_visit_stmt(struct symtable
*st
, stmt_ty s
)
918 case FunctionDef_kind
:
919 if (!symtable_add_def(st
, s
->v
.FunctionDef
.name
, DEF_LOCAL
))
921 if (s
->v
.FunctionDef
.args
->defaults
)
922 VISIT_SEQ(st
, expr
, s
->v
.FunctionDef
.args
->defaults
);
923 if (s
->v
.FunctionDef
.decorators
)
924 VISIT_SEQ(st
, expr
, s
->v
.FunctionDef
.decorators
);
925 if (!symtable_enter_block(st
, s
->v
.FunctionDef
.name
,
926 FunctionBlock
, (void *)s
, s
->lineno
))
928 VISIT_IN_BLOCK(st
, arguments
, s
->v
.FunctionDef
.args
, s
);
929 VISIT_SEQ_IN_BLOCK(st
, stmt
, s
->v
.FunctionDef
.body
, s
);
930 if (!symtable_exit_block(st
, s
))
933 case ClassDef_kind
: {
935 if (!symtable_add_def(st
, s
->v
.ClassDef
.name
, DEF_LOCAL
))
937 VISIT_SEQ(st
, expr
, s
->v
.ClassDef
.bases
);
938 if (!symtable_enter_block(st
, s
->v
.ClassDef
.name
, ClassBlock
,
939 (void *)s
, s
->lineno
))
941 tmp
= st
->st_private
;
942 st
->st_private
= s
->v
.ClassDef
.name
;
943 VISIT_SEQ_IN_BLOCK(st
, stmt
, s
->v
.ClassDef
.body
, s
);
944 st
->st_private
= tmp
;
945 if (!symtable_exit_block(st
, s
))
950 if (s
->v
.Return
.value
) {
951 VISIT(st
, expr
, s
->v
.Return
.value
);
952 st
->st_cur
->ste_returns_value
= 1;
953 if (st
->st_cur
->ste_generator
) {
954 PyErr_SetString(PyExc_SyntaxError
,
955 RETURN_VAL_IN_GENERATOR
);
956 PyErr_SyntaxLocation(st
->st_filename
,
963 VISIT_SEQ(st
, expr
, s
->v
.Delete
.targets
);
966 VISIT_SEQ(st
, expr
, s
->v
.Assign
.targets
);
967 VISIT(st
, expr
, s
->v
.Assign
.value
);
970 VISIT(st
, expr
, s
->v
.AugAssign
.target
);
971 VISIT(st
, expr
, s
->v
.AugAssign
.value
);
975 VISIT(st
, expr
, s
->v
.Print
.dest
);
976 VISIT_SEQ(st
, expr
, s
->v
.Print
.values
);
979 VISIT(st
, expr
, s
->v
.For
.target
);
980 VISIT(st
, expr
, s
->v
.For
.iter
);
981 VISIT_SEQ(st
, stmt
, s
->v
.For
.body
);
983 VISIT_SEQ(st
, stmt
, s
->v
.For
.orelse
);
986 VISIT(st
, expr
, s
->v
.While
.test
);
987 VISIT_SEQ(st
, stmt
, s
->v
.While
.body
);
988 if (s
->v
.While
.orelse
)
989 VISIT_SEQ(st
, stmt
, s
->v
.While
.orelse
);
992 /* XXX if 0: and lookup_yield() hacks */
993 VISIT(st
, expr
, s
->v
.If
.test
);
994 VISIT_SEQ(st
, stmt
, s
->v
.If
.body
);
996 VISIT_SEQ(st
, stmt
, s
->v
.If
.orelse
);
999 if (s
->v
.Raise
.type
) {
1000 VISIT(st
, expr
, s
->v
.Raise
.type
);
1001 if (s
->v
.Raise
.inst
) {
1002 VISIT(st
, expr
, s
->v
.Raise
.inst
);
1003 if (s
->v
.Raise
.tback
)
1004 VISIT(st
, expr
, s
->v
.Raise
.tback
);
1008 case TryExcept_kind
:
1009 VISIT_SEQ(st
, stmt
, s
->v
.TryExcept
.body
);
1010 VISIT_SEQ(st
, stmt
, s
->v
.TryExcept
.orelse
);
1011 VISIT_SEQ(st
, excepthandler
, s
->v
.TryExcept
.handlers
);
1013 case TryFinally_kind
:
1014 VISIT_SEQ(st
, stmt
, s
->v
.TryFinally
.body
);
1015 VISIT_SEQ(st
, stmt
, s
->v
.TryFinally
.finalbody
);
1018 VISIT(st
, expr
, s
->v
.Assert
.test
);
1019 if (s
->v
.Assert
.msg
)
1020 VISIT(st
, expr
, s
->v
.Assert
.msg
);
1023 VISIT_SEQ(st
, alias
, s
->v
.Import
.names
);
1024 /* XXX Don't have the lineno available inside
1026 if (st
->st_cur
->ste_unoptimized
&& !st
->st_cur
->ste_opt_lineno
)
1027 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1029 case ImportFrom_kind
:
1030 VISIT_SEQ(st
, alias
, s
->v
.ImportFrom
.names
);
1031 /* XXX Don't have the lineno available inside
1033 if (st
->st_cur
->ste_unoptimized
&& !st
->st_cur
->ste_opt_lineno
)
1034 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1037 VISIT(st
, expr
, s
->v
.Exec
.body
);
1038 if (!st
->st_cur
->ste_opt_lineno
)
1039 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1040 if (s
->v
.Exec
.globals
) {
1041 st
->st_cur
->ste_unoptimized
|= OPT_EXEC
;
1042 VISIT(st
, expr
, s
->v
.Exec
.globals
);
1043 if (s
->v
.Exec
.locals
)
1044 VISIT(st
, expr
, s
->v
.Exec
.locals
);
1046 st
->st_cur
->ste_unoptimized
|= OPT_BARE_EXEC
;
1051 asdl_seq
*seq
= s
->v
.Global
.names
;
1052 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++) {
1053 identifier name
= (identifier
)asdl_seq_GET(seq
, i
);
1054 char *c_name
= PyString_AS_STRING(name
);
1055 long cur
= symtable_lookup(st
, name
);
1058 if (cur
& (DEF_LOCAL
| USE
)) {
1060 if (cur
& DEF_LOCAL
)
1061 PyOS_snprintf(buf
, sizeof(buf
),
1062 GLOBAL_AFTER_ASSIGN
,
1065 PyOS_snprintf(buf
, sizeof(buf
),
1068 if (!symtable_warn(st
, buf
, s
->lineno
))
1071 if (!symtable_add_def(st
, name
, DEF_GLOBAL
))
1077 VISIT(st
, expr
, s
->v
.Expr
.value
);
1082 /* nothing to do here */
1085 if (!symtable_new_tmpname(st
))
1087 VISIT(st
, expr
, s
->v
.With
.context_expr
);
1088 if (s
->v
.With
.optional_vars
) {
1089 if (!symtable_new_tmpname(st
))
1091 VISIT(st
, expr
, s
->v
.With
.optional_vars
);
1093 VISIT_SEQ(st
, stmt
, s
->v
.With
.body
);
1100 symtable_visit_expr(struct symtable
*st
, expr_ty e
)
1104 VISIT_SEQ(st
, expr
, e
->v
.BoolOp
.values
);
1107 VISIT(st
, expr
, e
->v
.BinOp
.left
);
1108 VISIT(st
, expr
, e
->v
.BinOp
.right
);
1111 VISIT(st
, expr
, e
->v
.UnaryOp
.operand
);
1114 if (!symtable_add_def(st
, GET_IDENTIFIER(lambda
), DEF_LOCAL
))
1116 if (e
->v
.Lambda
.args
->defaults
)
1117 VISIT_SEQ(st
, expr
, e
->v
.Lambda
.args
->defaults
);
1118 /* XXX how to get line numbers for expressions */
1119 if (!symtable_enter_block(st
, GET_IDENTIFIER(lambda
),
1120 FunctionBlock
, (void *)e
, 0))
1122 VISIT_IN_BLOCK(st
, arguments
, e
->v
.Lambda
.args
, (void*)e
);
1123 VISIT_IN_BLOCK(st
, expr
, e
->v
.Lambda
.body
, (void*)e
);
1124 if (!symtable_exit_block(st
, (void *)e
))
1129 VISIT(st
, expr
, e
->v
.IfExp
.test
);
1130 VISIT(st
, expr
, e
->v
.IfExp
.body
);
1131 VISIT(st
, expr
, e
->v
.IfExp
.orelse
);
1134 VISIT_SEQ(st
, expr
, e
->v
.Dict
.keys
);
1135 VISIT_SEQ(st
, expr
, e
->v
.Dict
.values
);
1138 if (!symtable_new_tmpname(st
))
1140 VISIT(st
, expr
, e
->v
.ListComp
.elt
);
1141 VISIT_SEQ(st
, comprehension
, e
->v
.ListComp
.generators
);
1143 case GeneratorExp_kind
:
1144 if (!symtable_visit_genexp(st
, e
))
1148 if (e
->v
.Yield
.value
)
1149 VISIT(st
, expr
, e
->v
.Yield
.value
);
1150 st
->st_cur
->ste_generator
= 1;
1151 if (st
->st_cur
->ste_returns_value
) {
1152 PyErr_SetString(PyExc_SyntaxError
,
1153 RETURN_VAL_IN_GENERATOR
);
1154 PyErr_SyntaxLocation(st
->st_filename
,
1160 VISIT(st
, expr
, e
->v
.Compare
.left
);
1161 VISIT_SEQ(st
, expr
, e
->v
.Compare
.comparators
);
1164 VISIT(st
, expr
, e
->v
.Call
.func
);
1165 VISIT_SEQ(st
, expr
, e
->v
.Call
.args
);
1166 VISIT_SEQ(st
, keyword
, e
->v
.Call
.keywords
);
1167 if (e
->v
.Call
.starargs
)
1168 VISIT(st
, expr
, e
->v
.Call
.starargs
);
1169 if (e
->v
.Call
.kwargs
)
1170 VISIT(st
, expr
, e
->v
.Call
.kwargs
);
1173 VISIT(st
, expr
, e
->v
.Repr
.value
);
1177 /* Nothing to do here. */
1179 /* The following exprs can be assignment targets. */
1180 case Attribute_kind
:
1181 VISIT(st
, expr
, e
->v
.Attribute
.value
);
1183 case Subscript_kind
:
1184 VISIT(st
, expr
, e
->v
.Subscript
.value
);
1185 VISIT(st
, slice
, e
->v
.Subscript
.slice
);
1188 if (!symtable_add_def(st
, e
->v
.Name
.id
,
1189 e
->v
.Name
.ctx
== Load
? USE
: DEF_LOCAL
))
1192 /* child nodes of List and Tuple will have expr_context set */
1194 VISIT_SEQ(st
, expr
, e
->v
.List
.elts
);
1197 VISIT_SEQ(st
, expr
, e
->v
.Tuple
.elts
);
1204 symtable_implicit_arg(struct symtable
*st
, int pos
)
1206 PyObject
*id
= PyString_FromFormat(".%d", pos
);
1209 if (!symtable_add_def(st
, id
, DEF_PARAM
)) {
1218 symtable_visit_params(struct symtable
*st
, asdl_seq
*args
, int toplevel
)
1222 /* go through all the toplevel arguments first */
1223 for (i
= 0; i
< asdl_seq_LEN(args
); i
++) {
1224 expr_ty arg
= (expr_ty
)asdl_seq_GET(args
, i
);
1225 if (arg
->kind
== Name_kind
) {
1226 assert(arg
->v
.Name
.ctx
== Param
||
1227 (arg
->v
.Name
.ctx
== Store
&& !toplevel
));
1228 if (!symtable_add_def(st
, arg
->v
.Name
.id
, DEF_PARAM
))
1231 else if (arg
->kind
== Tuple_kind
) {
1232 assert(arg
->v
.Tuple
.ctx
== Store
);
1234 if (!symtable_implicit_arg(st
, i
))
1239 PyErr_SetString(PyExc_SyntaxError
,
1240 "invalid expression in parameter list");
1241 PyErr_SyntaxLocation(st
->st_filename
,
1242 st
->st_cur
->ste_lineno
);
1248 if (!symtable_visit_params_nested(st
, args
))
1256 symtable_visit_params_nested(struct symtable
*st
, asdl_seq
*args
)
1259 for (i
= 0; i
< asdl_seq_LEN(args
); i
++) {
1260 expr_ty arg
= (expr_ty
)asdl_seq_GET(args
, i
);
1261 if (arg
->kind
== Tuple_kind
&&
1262 !symtable_visit_params(st
, arg
->v
.Tuple
.elts
, 0))
1270 symtable_visit_arguments(struct symtable
*st
, arguments_ty a
)
1272 /* skip default arguments inside function block
1273 XXX should ast be different?
1275 if (a
->args
&& !symtable_visit_params(st
, a
->args
, 1))
1278 if (!symtable_add_def(st
, a
->vararg
, DEF_PARAM
))
1280 st
->st_cur
->ste_varargs
= 1;
1283 if (!symtable_add_def(st
, a
->kwarg
, DEF_PARAM
))
1285 st
->st_cur
->ste_varkeywords
= 1;
1287 if (a
->args
&& !symtable_visit_params_nested(st
, a
->args
))
1294 symtable_visit_excepthandler(struct symtable
*st
, excepthandler_ty eh
)
1297 VISIT(st
, expr
, eh
->type
);
1299 VISIT(st
, expr
, eh
->name
);
1300 VISIT_SEQ(st
, stmt
, eh
->body
);
1306 symtable_visit_alias(struct symtable
*st
, alias_ty a
)
1308 /* Compute store_name, the name actually bound by the import
1309 operation. It is diferent than a->name when a->name is a
1310 dotted package name (e.g. spam.eggs)
1312 PyObject
*store_name
;
1313 PyObject
*name
= (a
->asname
== NULL
) ? a
->name
: a
->asname
;
1314 const char *base
= PyString_AS_STRING(name
);
1315 char *dot
= strchr(base
, '.');
1317 store_name
= PyString_FromStringAndSize(base
, dot
- base
);
1320 Py_INCREF(store_name
);
1322 if (strcmp(PyString_AS_STRING(name
), "*")) {
1323 int r
= symtable_add_def(st
, store_name
, DEF_IMPORT
);
1324 Py_DECREF(store_name
);
1328 if (st
->st_cur
->ste_type
!= ModuleBlock
) {
1329 int lineno
= st
->st_cur
->ste_lineno
;
1330 if (!symtable_warn(st
, IMPORT_STAR_WARNING
, lineno
)) {
1331 Py_DECREF(store_name
);
1335 st
->st_cur
->ste_unoptimized
|= OPT_IMPORT_STAR
;
1336 Py_DECREF(store_name
);
1343 symtable_visit_comprehension(struct symtable
*st
, comprehension_ty lc
)
1345 VISIT(st
, expr
, lc
->target
);
1346 VISIT(st
, expr
, lc
->iter
);
1347 VISIT_SEQ(st
, expr
, lc
->ifs
);
1353 symtable_visit_keyword(struct symtable
*st
, keyword_ty k
)
1355 VISIT(st
, expr
, k
->value
);
1361 symtable_visit_slice(struct symtable
*st
, slice_ty s
)
1365 if (s
->v
.Slice
.lower
)
1366 VISIT(st
, expr
, s
->v
.Slice
.lower
)
1367 if (s
->v
.Slice
.upper
)
1368 VISIT(st
, expr
, s
->v
.Slice
.upper
)
1369 if (s
->v
.Slice
.step
)
1370 VISIT(st
, expr
, s
->v
.Slice
.step
)
1373 VISIT_SEQ(st
, slice
, s
->v
.ExtSlice
.dims
)
1376 VISIT(st
, expr
, s
->v
.Index
.value
)
1385 symtable_visit_genexp(struct symtable
*st
, expr_ty e
)
1387 comprehension_ty outermost
= ((comprehension_ty
)
1388 (asdl_seq_GET(e
->v
.GeneratorExp
.generators
, 0)));
1389 /* Outermost iterator is evaluated in current scope */
1390 VISIT(st
, expr
, outermost
->iter
);
1391 /* Create generator scope for the rest */
1392 if (!symtable_enter_block(st
, GET_IDENTIFIER(genexpr
),
1393 FunctionBlock
, (void *)e
, 0)) {
1396 st
->st_cur
->ste_generator
= 1;
1397 /* Outermost iter is received as an argument */
1398 if (!symtable_implicit_arg(st
, 0)) {
1399 symtable_exit_block(st
, (void *)e
);
1402 VISIT_IN_BLOCK(st
, expr
, outermost
->target
, (void*)e
);
1403 VISIT_SEQ_IN_BLOCK(st
, expr
, outermost
->ifs
, (void*)e
);
1404 VISIT_SEQ_TAIL_IN_BLOCK(st
, comprehension
,
1405 e
->v
.GeneratorExp
.generators
, 1, (void*)e
);
1406 VISIT_IN_BLOCK(st
, expr
, e
->v
.GeneratorExp
.elt
, (void*)e
);
1407 if (!symtable_exit_block(st
, (void *)e
))