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 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
122 sizeof(PySTEntryObject
),
124 (destructor
)ste_dealloc
, /* tp_dealloc */
129 (reprfunc
)ste_repr
, /* tp_repr */
130 0, /* tp_as_number */
131 0, /* tp_as_sequence */
132 0, /* tp_as_mapping */
136 PyObject_GenericGetAttr
, /* tp_getattro */
138 0, /* tp_as_buffer */
139 Py_TPFLAGS_DEFAULT
, /* tp_flags */
143 0, /* tp_richcompare */
144 0, /* tp_weaklistoffset */
148 ste_memberlist
, /* tp_members */
152 0, /* tp_descr_get */
153 0, /* tp_descr_set */
154 0, /* tp_dictoffset */
160 static int symtable_analyze(struct symtable
*st
);
161 static int symtable_warn(struct symtable
*st
, char *msg
, int lineno
);
162 static int symtable_enter_block(struct symtable
*st
, identifier name
,
163 _Py_block_ty block
, void *ast
, int lineno
);
164 static int symtable_exit_block(struct symtable
*st
, void *ast
);
165 static int symtable_visit_stmt(struct symtable
*st
, stmt_ty s
);
166 static int symtable_visit_expr(struct symtable
*st
, expr_ty s
);
167 static int symtable_visit_genexp(struct symtable
*st
, expr_ty s
);
168 static int symtable_visit_arguments(struct symtable
*st
, arguments_ty
);
169 static int symtable_visit_excepthandler(struct symtable
*st
, excepthandler_ty
);
170 static int symtable_visit_alias(struct symtable
*st
, alias_ty
);
171 static int symtable_visit_comprehension(struct symtable
*st
, comprehension_ty
);
172 static int symtable_visit_keyword(struct symtable
*st
, keyword_ty
);
173 static int symtable_visit_slice(struct symtable
*st
, slice_ty
);
174 static int symtable_visit_params(struct symtable
*st
, asdl_seq
*args
, int top
);
175 static int symtable_visit_params_nested(struct symtable
*st
, asdl_seq
*args
);
176 static int symtable_implicit_arg(struct symtable
*st
, int pos
);
179 static identifier top
= NULL
, lambda
= NULL
, genexpr
= NULL
;
181 #define GET_IDENTIFIER(VAR) \
182 ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))
184 #define DUPLICATE_ARGUMENT \
185 "duplicate argument '%s' in function definition"
187 static struct symtable
*
192 st
= (struct symtable
*)PyMem_Malloc(sizeof(struct symtable
));
196 st
->st_filename
= NULL
;
197 st
->st_symbols
= NULL
;
199 if ((st
->st_stack
= PyList_New(0)) == NULL
)
201 if ((st
->st_symbols
= PyDict_New()) == NULL
)
205 st
->st_private
= NULL
;
213 PySymtable_Build(mod_ty mod
, const char *filename
, PyFutureFeatures
*future
)
215 struct symtable
*st
= symtable_new();
221 st
->st_filename
= filename
;
222 st
->st_future
= future
;
223 if (!GET_IDENTIFIER(top
) ||
224 !symtable_enter_block(st
, top
, ModuleBlock
, (void *)mod
, 0)) {
229 st
->st_top
= st
->st_cur
;
230 st
->st_cur
->ste_unoptimized
= OPT_TOPLEVEL
;
231 /* Any other top-level initialization? */
234 seq
= mod
->v
.Module
.body
;
235 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++)
236 if (!symtable_visit_stmt(st
,
237 (stmt_ty
)asdl_seq_GET(seq
, i
)))
240 case Expression_kind
:
241 if (!symtable_visit_expr(st
, mod
->v
.Expression
.body
))
244 case Interactive_kind
:
245 seq
= mod
->v
.Interactive
.body
;
246 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++)
247 if (!symtable_visit_stmt(st
,
248 (stmt_ty
)asdl_seq_GET(seq
, i
)))
252 PyErr_SetString(PyExc_RuntimeError
,
253 "this compiler does not handle Suites");
256 if (!symtable_exit_block(st
, (void *)mod
)) {
260 if (symtable_analyze(st
))
265 (void) symtable_exit_block(st
, (void *)mod
);
271 PySymtable_Free(struct symtable
*st
)
273 Py_XDECREF(st
->st_symbols
);
274 Py_XDECREF(st
->st_stack
);
275 PyMem_Free((void *)st
);
279 PySymtable_Lookup(struct symtable
*st
, void *key
)
283 k
= PyLong_FromVoidPtr(key
);
286 v
= PyDict_GetItem(st
->st_symbols
, k
);
288 assert(PySTEntry_Check(v
));
292 PyErr_SetString(PyExc_KeyError
,
293 "unknown symbol table entry");
297 return (PySTEntryObject
*)v
;
301 PyST_GetScope(PySTEntryObject
*ste
, PyObject
*name
)
303 PyObject
*v
= PyDict_GetItem(ste
->ste_symbols
, name
);
306 assert(PyInt_Check(v
));
307 return (PyInt_AS_LONG(v
) >> SCOPE_OFF
) & SCOPE_MASK
;
311 /* Analyze raw symbol information to determine scope of each name.
313 The next several functions are helpers for PySymtable_Analyze(),
314 which determines whether a name is local, global, or free. In addition,
315 it determines which local variables are cell variables; they provide
316 bindings that are used for free variables in enclosed blocks.
318 There are also two kinds of free variables, implicit and explicit. An
319 explicit global is declared with the global statement. An implicit
320 global is a free variable for which the compiler has found no binding
321 in an enclosing function scope. The implicit global is either a global
322 or a builtin. Python's module and class blocks use the xxx_NAME opcodes
323 to handle these names to implement slightly odd semantics. In such a
324 block, the name is treated as global until it is assigned to; then it
325 is treated as a local.
327 The symbol table requires two passes to determine the scope of each name.
328 The first pass collects raw facts from the AST: the name is a parameter
329 here, the name is used by not defined here, etc. The second pass analyzes
330 these facts during a pass over the PySTEntryObjects created during pass 1.
332 When a function is entered during the second pass, the parent passes
333 the set of all name bindings visible to its children. These bindings
334 are used to determine if the variable is free or an implicit global.
335 After doing the local analysis, it analyzes each of its child blocks
336 using an updated set of name bindings.
338 The children update the free variable set. If a local variable is free
339 in a child, the variable is marked as a cell. The current function must
340 provide runtime storage for the variable that may outlive the function's
341 frame. Cell variables are removed from the free set before the analyze
342 function returns to its parent.
344 The sets of bound and free variables are implemented as dictionaries
345 mapping strings to None.
348 #define SET_SCOPE(DICT, NAME, I) { \
349 PyObject *o = PyInt_FromLong(I); \
352 if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
359 /* Decide on scope of name, given flags.
361 The dicts passed in as arguments are modified as necessary.
362 ste is passed so that flags can be updated.
366 analyze_name(PySTEntryObject
*ste
, PyObject
*dict
, PyObject
*name
, long flags
,
367 PyObject
*bound
, PyObject
*local
, PyObject
*free
,
370 if (flags
& DEF_GLOBAL
) {
371 if (flags
& DEF_PARAM
) {
372 PyErr_Format(PyExc_SyntaxError
,
373 "name '%s' is local and global",
374 PyString_AS_STRING(name
));
377 SET_SCOPE(dict
, name
, GLOBAL_EXPLICIT
);
378 if (PyDict_SetItem(global
, name
, Py_None
) < 0)
380 if (bound
&& PyDict_GetItem(bound
, name
)) {
381 if (PyDict_DelItem(bound
, name
) < 0)
386 if (flags
& DEF_BOUND
) {
387 SET_SCOPE(dict
, name
, LOCAL
);
388 if (PyDict_SetItem(local
, name
, Py_None
) < 0)
390 if (PyDict_GetItem(global
, name
)) {
391 if (PyDict_DelItem(global
, name
) < 0)
396 /* If an enclosing block has a binding for this name, it
397 is a free variable rather than a global variable.
398 Note that having a non-NULL bound implies that the block
401 if (bound
&& PyDict_GetItem(bound
, name
)) {
402 SET_SCOPE(dict
, name
, FREE
);
404 if (PyDict_SetItem(free
, name
, Py_None
) < 0)
408 /* If a parent has a global statement, then call it global
409 explicit? It could also be global implicit.
411 else if (global
&& PyDict_GetItem(global
, name
)) {
412 SET_SCOPE(dict
, name
, GLOBAL_EXPLICIT
);
418 SET_SCOPE(dict
, name
, GLOBAL_IMPLICIT
);
421 return 0; /* Can't get here */
426 /* If a name is defined in free and also in locals, then this block
427 provides the binding for the free variable. The name should be
428 marked CELL in this block and removed from the free list.
430 Note that the current block's free variables are included in free.
431 That's safe because no name can be free and local in the same scope.
435 analyze_cells(PyObject
*scope
, PyObject
*free
)
437 PyObject
*name
, *v
, *w
;
441 w
= PyInt_FromLong(CELL
);
444 while (PyDict_Next(scope
, &pos
, &name
, &v
)) {
446 assert(PyInt_Check(v
));
447 flags
= PyInt_AS_LONG(v
);
450 if (!PyDict_GetItem(free
, name
))
452 /* Replace LOCAL with CELL for this name, and remove
453 from free. It is safe to replace the value of name
454 in the dict, because it will not cause a resize.
456 if (PyDict_SetItem(scope
, name
, w
) < 0)
458 if (!PyDict_DelItem(free
, name
) < 0)
467 /* Check for illegal statements in unoptimized namespaces */
469 check_unoptimized(const PySTEntryObject
* ste
) {
473 if (ste
->ste_type
!= FunctionBlock
|| !ste
->ste_unoptimized
474 || !(ste
->ste_free
|| ste
->ste_child_free
))
477 trailer
= (ste
->ste_child_free
?
478 "contains a nested function with free variables" :
479 "is a nested function");
481 switch (ste
->ste_unoptimized
) {
482 case OPT_TOPLEVEL
: /* exec / import * at top-level is fine */
483 case OPT_EXEC
: /* qualified exec is fine */
485 case OPT_IMPORT_STAR
:
486 PyOS_snprintf(buf
, sizeof(buf
),
487 "import * is not allowed in function '%.100s' "
489 PyString_AS_STRING(ste
->ste_name
), trailer
);
492 PyOS_snprintf(buf
, sizeof(buf
),
493 "unqualified exec is not allowed in function "
495 PyString_AS_STRING(ste
->ste_name
), trailer
);
498 PyOS_snprintf(buf
, sizeof(buf
),
499 "function '%.100s' uses import * and bare exec, "
500 "which are illegal because it %s",
501 PyString_AS_STRING(ste
->ste_name
), trailer
);
505 PyErr_SetString(PyExc_SyntaxError
, buf
);
506 PyErr_SyntaxLocation(ste
->ste_table
->st_filename
,
507 ste
->ste_opt_lineno
);
511 /* Enter the final scope information into the st_symbols dict.
513 * All arguments are dicts. Modifies symbols, others are read-only.
516 update_symbols(PyObject
*symbols
, PyObject
*scope
,
517 PyObject
*bound
, PyObject
*free
, int classflag
)
519 PyObject
*name
, *v
, *u
, *w
, *free_value
= NULL
;
522 while (PyDict_Next(symbols
, &pos
, &name
, &v
)) {
524 assert(PyInt_Check(v
));
525 flags
= PyInt_AS_LONG(v
);
526 w
= PyDict_GetItem(scope
, name
);
527 assert(w
&& PyInt_Check(w
));
528 i
= PyInt_AS_LONG(w
);
529 flags
|= (i
<< SCOPE_OFF
);
530 u
= PyInt_FromLong(flags
);
533 if (PyDict_SetItem(symbols
, name
, u
) < 0) {
540 free_value
= PyInt_FromLong(FREE
<< SCOPE_OFF
);
544 /* add a free variable when it's only use is for creating a closure */
546 while (PyDict_Next(free
, &pos
, &name
, &v
)) {
547 PyObject
*o
= PyDict_GetItem(symbols
, name
);
550 /* It could be a free variable in a method of
551 the class that has the same name as a local
552 or global in the class scope.
555 PyInt_AS_LONG(o
) & (DEF_BOUND
| DEF_GLOBAL
)) {
556 long i
= PyInt_AS_LONG(o
) | DEF_FREE_CLASS
;
557 o
= PyInt_FromLong(i
);
559 Py_DECREF(free_value
);
562 if (PyDict_SetItem(symbols
, name
, o
) < 0) {
564 Py_DECREF(free_value
);
569 /* else it's not free, probably a cell */
572 if (!PyDict_GetItem(bound
, name
))
573 continue; /* it's a global */
575 if (PyDict_SetItem(symbols
, name
, free_value
) < 0) {
576 Py_DECREF(free_value
);
580 Py_DECREF(free_value
);
584 /* Make final symbol table decisions for block of ste.
586 ste -- current symtable entry (input/output)
587 bound -- set of variables bound in enclosing scopes (input)
588 free -- set of free variables in enclosed scopes (output)
589 globals -- set of declared global variables in enclosing scopes (input)
593 analyze_block(PySTEntryObject
*ste
, PyObject
*bound
, PyObject
*free
,
596 PyObject
*name
, *v
, *local
= NULL
, *scope
= NULL
, *newbound
= NULL
;
597 PyObject
*newglobal
= NULL
, *newfree
= NULL
;
601 local
= PyDict_New();
604 scope
= PyDict_New();
607 newglobal
= PyDict_New();
610 newfree
= PyDict_New();
613 newbound
= PyDict_New();
617 if (ste
->ste_type
== ClassBlock
) {
618 /* make a copy of globals before calling analyze_name(),
619 because global statements in the class have no effect
622 if (PyDict_Update(newglobal
, global
) < 0)
625 if (PyDict_Update(newbound
, bound
) < 0)
629 assert(PySTEntry_Check(ste
));
630 assert(PyDict_Check(ste
->ste_symbols
));
631 while (PyDict_Next(ste
->ste_symbols
, &pos
, &name
, &v
)) {
632 long flags
= PyInt_AS_LONG(v
);
633 if (!analyze_name(ste
, scope
, name
, flags
, bound
, local
, free
,
638 if (ste
->ste_type
!= ClassBlock
) {
639 if (ste
->ste_type
== FunctionBlock
) {
640 if (PyDict_Update(newbound
, local
) < 0)
644 if (PyDict_Update(newbound
, bound
) < 0)
647 if (PyDict_Update(newglobal
, global
) < 0)
651 /* Recursively call analyze_block() on each child block */
652 for (i
= 0; i
< PyList_GET_SIZE(ste
->ste_children
); ++i
) {
653 PyObject
*c
= PyList_GET_ITEM(ste
->ste_children
, i
);
654 PySTEntryObject
* entry
;
655 assert(c
&& PySTEntry_Check(c
));
656 entry
= (PySTEntryObject
*)c
;
657 if (!analyze_block(entry
, newbound
, newfree
, newglobal
))
659 if (entry
->ste_free
|| entry
->ste_child_free
)
660 ste
->ste_child_free
= 1;
663 if (ste
->ste_type
== FunctionBlock
&& !analyze_cells(scope
, newfree
))
665 if (!update_symbols(ste
->ste_symbols
, scope
, bound
, newfree
,
666 ste
->ste_type
== ClassBlock
))
668 if (!check_unoptimized(ste
))
671 if (PyDict_Update(free
, newfree
) < 0)
677 Py_XDECREF(newbound
);
678 Py_XDECREF(newglobal
);
681 assert(PyErr_Occurred());
686 symtable_analyze(struct symtable
*st
)
688 PyObject
*free
, *global
;
694 global
= PyDict_New();
699 r
= analyze_block(st
->st_top
, NULL
, free
, global
);
707 symtable_warn(struct symtable
*st
, char *msg
, int lineno
)
709 if (PyErr_WarnExplicit(PyExc_SyntaxWarning
, msg
, st
->st_filename
,
710 lineno
, NULL
, NULL
) < 0) {
711 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning
)) {
712 PyErr_SetString(PyExc_SyntaxError
, msg
);
713 PyErr_SyntaxLocation(st
->st_filename
,
714 st
->st_cur
->ste_lineno
);
721 /* symtable_enter_block() gets a reference via PySTEntry_New().
722 This reference is released when the block is exited, via the DECREF
723 in symtable_exit_block().
727 symtable_exit_block(struct symtable
*st
, void *ast
)
731 Py_CLEAR(st
->st_cur
);
732 end
= PyList_GET_SIZE(st
->st_stack
) - 1;
734 st
->st_cur
= (PySTEntryObject
*)PyList_GET_ITEM(st
->st_stack
,
736 if (st
->st_cur
== NULL
)
738 Py_INCREF(st
->st_cur
);
739 if (PySequence_DelItem(st
->st_stack
, end
) < 0)
746 symtable_enter_block(struct symtable
*st
, identifier name
, _Py_block_ty block
,
747 void *ast
, int lineno
)
749 PySTEntryObject
*prev
= NULL
;
753 if (PyList_Append(st
->st_stack
, (PyObject
*)st
->st_cur
) < 0) {
756 Py_DECREF(st
->st_cur
);
758 st
->st_cur
= PySTEntry_New(st
, name
, block
, ast
, lineno
);
759 if (st
->st_cur
== NULL
)
761 if (name
== GET_IDENTIFIER(top
))
762 st
->st_global
= st
->st_cur
->ste_symbols
;
764 if (PyList_Append(prev
->ste_children
,
765 (PyObject
*)st
->st_cur
) < 0) {
773 symtable_lookup(struct symtable
*st
, PyObject
*name
)
776 PyObject
*mangled
= _Py_Mangle(st
->st_private
, name
);
779 o
= PyDict_GetItem(st
->st_cur
->ste_symbols
, mangled
);
783 return PyInt_AsLong(o
);
787 symtable_add_def(struct symtable
*st
, PyObject
*name
, int flag
)
792 PyObject
*mangled
= _Py_Mangle(st
->st_private
, name
);
796 dict
= st
->st_cur
->ste_symbols
;
797 if ((o
= PyDict_GetItem(dict
, mangled
))) {
798 val
= PyInt_AS_LONG(o
);
799 if ((flag
& DEF_PARAM
) && (val
& DEF_PARAM
)) {
800 /* Is it better to use 'mangled' or 'name' here? */
801 PyErr_Format(PyExc_SyntaxError
, DUPLICATE_ARGUMENT
,
802 PyString_AsString(name
));
803 PyErr_SyntaxLocation(st
->st_filename
,
804 st
->st_cur
->ste_lineno
);
810 o
= PyInt_FromLong(val
);
813 if (PyDict_SetItem(dict
, mangled
, o
) < 0) {
819 if (flag
& DEF_PARAM
) {
820 if (PyList_Append(st
->st_cur
->ste_varnames
, mangled
) < 0)
822 } else if (flag
& DEF_GLOBAL
) {
823 /* XXX need to update DEF_GLOBAL for other flags too;
824 perhaps only DEF_FREE_GLOBAL */
826 if ((o
= PyDict_GetItem(st
->st_global
, mangled
))) {
827 val
|= PyInt_AS_LONG(o
);
829 o
= PyInt_FromLong(val
);
832 if (PyDict_SetItem(st
->st_global
, mangled
, o
) < 0) {
846 /* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.
847 They use the ASDL name to synthesize the name of the C type and the visit
850 VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is
851 useful if the first node in the sequence requires special treatment.
854 #define VISIT(ST, TYPE, V) \
855 if (!symtable_visit_ ## TYPE((ST), (V))) \
858 #define VISIT_IN_BLOCK(ST, TYPE, V, S) \
859 if (!symtable_visit_ ## TYPE((ST), (V))) { \
860 symtable_exit_block((ST), (S)); \
864 #define VISIT_SEQ(ST, TYPE, SEQ) { \
866 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
867 for (i = 0; i < asdl_seq_LEN(seq); i++) { \
868 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
869 if (!symtable_visit_ ## TYPE((ST), elt)) \
874 #define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \
876 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
877 for (i = 0; i < asdl_seq_LEN(seq); i++) { \
878 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
879 if (!symtable_visit_ ## TYPE((ST), elt)) { \
880 symtable_exit_block((ST), (S)); \
886 #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
888 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
889 for (i = (START); i < asdl_seq_LEN(seq); i++) { \
890 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
891 if (!symtable_visit_ ## TYPE((ST), elt)) \
896 #define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \
898 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
899 for (i = (START); i < asdl_seq_LEN(seq); i++) { \
900 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
901 if (!symtable_visit_ ## TYPE((ST), elt)) { \
902 symtable_exit_block((ST), (S)); \
909 symtable_new_tmpname(struct symtable
*st
)
914 PyOS_snprintf(tmpname
, sizeof(tmpname
), "_[%d]",
915 ++st
->st_cur
->ste_tmpname
);
916 tmp
= PyString_InternFromString(tmpname
);
919 if (!symtable_add_def(st
, tmp
, DEF_LOCAL
))
926 symtable_visit_stmt(struct symtable
*st
, stmt_ty s
)
929 case FunctionDef_kind
:
930 if (!symtable_add_def(st
, s
->v
.FunctionDef
.name
, DEF_LOCAL
))
932 if (s
->v
.FunctionDef
.args
->defaults
)
933 VISIT_SEQ(st
, expr
, s
->v
.FunctionDef
.args
->defaults
);
934 if (s
->v
.FunctionDef
.decorators
)
935 VISIT_SEQ(st
, expr
, s
->v
.FunctionDef
.decorators
);
936 if (!symtable_enter_block(st
, s
->v
.FunctionDef
.name
,
937 FunctionBlock
, (void *)s
, s
->lineno
))
939 VISIT_IN_BLOCK(st
, arguments
, s
->v
.FunctionDef
.args
, s
);
940 VISIT_SEQ_IN_BLOCK(st
, stmt
, s
->v
.FunctionDef
.body
, s
);
941 if (!symtable_exit_block(st
, s
))
944 case ClassDef_kind
: {
946 if (!symtable_add_def(st
, s
->v
.ClassDef
.name
, DEF_LOCAL
))
948 VISIT_SEQ(st
, expr
, s
->v
.ClassDef
.bases
);
949 if (!symtable_enter_block(st
, s
->v
.ClassDef
.name
, ClassBlock
,
950 (void *)s
, s
->lineno
))
952 tmp
= st
->st_private
;
953 st
->st_private
= s
->v
.ClassDef
.name
;
954 VISIT_SEQ_IN_BLOCK(st
, stmt
, s
->v
.ClassDef
.body
, s
);
955 st
->st_private
= tmp
;
956 if (!symtable_exit_block(st
, s
))
961 if (s
->v
.Return
.value
) {
962 VISIT(st
, expr
, s
->v
.Return
.value
);
963 st
->st_cur
->ste_returns_value
= 1;
964 if (st
->st_cur
->ste_generator
) {
965 PyErr_SetString(PyExc_SyntaxError
,
966 RETURN_VAL_IN_GENERATOR
);
967 PyErr_SyntaxLocation(st
->st_filename
,
974 VISIT_SEQ(st
, expr
, s
->v
.Delete
.targets
);
977 VISIT_SEQ(st
, expr
, s
->v
.Assign
.targets
);
978 VISIT(st
, expr
, s
->v
.Assign
.value
);
981 VISIT(st
, expr
, s
->v
.AugAssign
.target
);
982 VISIT(st
, expr
, s
->v
.AugAssign
.value
);
986 VISIT(st
, expr
, s
->v
.Print
.dest
);
987 VISIT_SEQ(st
, expr
, s
->v
.Print
.values
);
990 VISIT(st
, expr
, s
->v
.For
.target
);
991 VISIT(st
, expr
, s
->v
.For
.iter
);
992 VISIT_SEQ(st
, stmt
, s
->v
.For
.body
);
994 VISIT_SEQ(st
, stmt
, s
->v
.For
.orelse
);
997 VISIT(st
, expr
, s
->v
.While
.test
);
998 VISIT_SEQ(st
, stmt
, s
->v
.While
.body
);
999 if (s
->v
.While
.orelse
)
1000 VISIT_SEQ(st
, stmt
, s
->v
.While
.orelse
);
1003 /* XXX if 0: and lookup_yield() hacks */
1004 VISIT(st
, expr
, s
->v
.If
.test
);
1005 VISIT_SEQ(st
, stmt
, s
->v
.If
.body
);
1007 VISIT_SEQ(st
, stmt
, s
->v
.If
.orelse
);
1010 if (s
->v
.Raise
.type
) {
1011 VISIT(st
, expr
, s
->v
.Raise
.type
);
1012 if (s
->v
.Raise
.inst
) {
1013 VISIT(st
, expr
, s
->v
.Raise
.inst
);
1014 if (s
->v
.Raise
.tback
)
1015 VISIT(st
, expr
, s
->v
.Raise
.tback
);
1019 case TryExcept_kind
:
1020 VISIT_SEQ(st
, stmt
, s
->v
.TryExcept
.body
);
1021 VISIT_SEQ(st
, stmt
, s
->v
.TryExcept
.orelse
);
1022 VISIT_SEQ(st
, excepthandler
, s
->v
.TryExcept
.handlers
);
1024 case TryFinally_kind
:
1025 VISIT_SEQ(st
, stmt
, s
->v
.TryFinally
.body
);
1026 VISIT_SEQ(st
, stmt
, s
->v
.TryFinally
.finalbody
);
1029 VISIT(st
, expr
, s
->v
.Assert
.test
);
1030 if (s
->v
.Assert
.msg
)
1031 VISIT(st
, expr
, s
->v
.Assert
.msg
);
1034 VISIT_SEQ(st
, alias
, s
->v
.Import
.names
);
1035 /* XXX Don't have the lineno available inside
1037 if (st
->st_cur
->ste_unoptimized
&& !st
->st_cur
->ste_opt_lineno
)
1038 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1040 case ImportFrom_kind
:
1041 VISIT_SEQ(st
, alias
, s
->v
.ImportFrom
.names
);
1042 /* XXX Don't have the lineno available inside
1044 if (st
->st_cur
->ste_unoptimized
&& !st
->st_cur
->ste_opt_lineno
)
1045 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1048 VISIT(st
, expr
, s
->v
.Exec
.body
);
1049 if (!st
->st_cur
->ste_opt_lineno
)
1050 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1051 if (s
->v
.Exec
.globals
) {
1052 st
->st_cur
->ste_unoptimized
|= OPT_EXEC
;
1053 VISIT(st
, expr
, s
->v
.Exec
.globals
);
1054 if (s
->v
.Exec
.locals
)
1055 VISIT(st
, expr
, s
->v
.Exec
.locals
);
1057 st
->st_cur
->ste_unoptimized
|= OPT_BARE_EXEC
;
1062 asdl_seq
*seq
= s
->v
.Global
.names
;
1063 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++) {
1064 identifier name
= (identifier
)asdl_seq_GET(seq
, i
);
1065 char *c_name
= PyString_AS_STRING(name
);
1066 long cur
= symtable_lookup(st
, name
);
1069 if (cur
& (DEF_LOCAL
| USE
)) {
1071 if (cur
& DEF_LOCAL
)
1072 PyOS_snprintf(buf
, sizeof(buf
),
1073 GLOBAL_AFTER_ASSIGN
,
1076 PyOS_snprintf(buf
, sizeof(buf
),
1079 if (!symtable_warn(st
, buf
, s
->lineno
))
1082 if (!symtable_add_def(st
, name
, DEF_GLOBAL
))
1088 VISIT(st
, expr
, s
->v
.Expr
.value
);
1093 /* nothing to do here */
1096 if (!symtable_new_tmpname(st
))
1098 VISIT(st
, expr
, s
->v
.With
.context_expr
);
1099 if (s
->v
.With
.optional_vars
) {
1100 if (!symtable_new_tmpname(st
))
1102 VISIT(st
, expr
, s
->v
.With
.optional_vars
);
1104 VISIT_SEQ(st
, stmt
, s
->v
.With
.body
);
1111 symtable_visit_expr(struct symtable
*st
, expr_ty e
)
1115 VISIT_SEQ(st
, expr
, e
->v
.BoolOp
.values
);
1118 VISIT(st
, expr
, e
->v
.BinOp
.left
);
1119 VISIT(st
, expr
, e
->v
.BinOp
.right
);
1122 VISIT(st
, expr
, e
->v
.UnaryOp
.operand
);
1125 if (!GET_IDENTIFIER(lambda
) ||
1126 !symtable_add_def(st
, lambda
, DEF_LOCAL
))
1128 if (e
->v
.Lambda
.args
->defaults
)
1129 VISIT_SEQ(st
, expr
, e
->v
.Lambda
.args
->defaults
);
1130 /* XXX how to get line numbers for expressions */
1131 if (!symtable_enter_block(st
, lambda
,
1132 FunctionBlock
, (void *)e
, 0))
1134 VISIT_IN_BLOCK(st
, arguments
, e
->v
.Lambda
.args
, (void*)e
);
1135 VISIT_IN_BLOCK(st
, expr
, e
->v
.Lambda
.body
, (void*)e
);
1136 if (!symtable_exit_block(st
, (void *)e
))
1141 VISIT(st
, expr
, e
->v
.IfExp
.test
);
1142 VISIT(st
, expr
, e
->v
.IfExp
.body
);
1143 VISIT(st
, expr
, e
->v
.IfExp
.orelse
);
1146 VISIT_SEQ(st
, expr
, e
->v
.Dict
.keys
);
1147 VISIT_SEQ(st
, expr
, e
->v
.Dict
.values
);
1150 if (!symtable_new_tmpname(st
))
1152 VISIT(st
, expr
, e
->v
.ListComp
.elt
);
1153 VISIT_SEQ(st
, comprehension
, e
->v
.ListComp
.generators
);
1155 case GeneratorExp_kind
:
1156 if (!symtable_visit_genexp(st
, e
))
1160 if (e
->v
.Yield
.value
)
1161 VISIT(st
, expr
, e
->v
.Yield
.value
);
1162 st
->st_cur
->ste_generator
= 1;
1163 if (st
->st_cur
->ste_returns_value
) {
1164 PyErr_SetString(PyExc_SyntaxError
,
1165 RETURN_VAL_IN_GENERATOR
);
1166 PyErr_SyntaxLocation(st
->st_filename
,
1172 VISIT(st
, expr
, e
->v
.Compare
.left
);
1173 VISIT_SEQ(st
, expr
, e
->v
.Compare
.comparators
);
1176 VISIT(st
, expr
, e
->v
.Call
.func
);
1177 VISIT_SEQ(st
, expr
, e
->v
.Call
.args
);
1178 VISIT_SEQ(st
, keyword
, e
->v
.Call
.keywords
);
1179 if (e
->v
.Call
.starargs
)
1180 VISIT(st
, expr
, e
->v
.Call
.starargs
);
1181 if (e
->v
.Call
.kwargs
)
1182 VISIT(st
, expr
, e
->v
.Call
.kwargs
);
1185 VISIT(st
, expr
, e
->v
.Repr
.value
);
1189 /* Nothing to do here. */
1191 /* The following exprs can be assignment targets. */
1192 case Attribute_kind
:
1193 VISIT(st
, expr
, e
->v
.Attribute
.value
);
1195 case Subscript_kind
:
1196 VISIT(st
, expr
, e
->v
.Subscript
.value
);
1197 VISIT(st
, slice
, e
->v
.Subscript
.slice
);
1200 if (!symtable_add_def(st
, e
->v
.Name
.id
,
1201 e
->v
.Name
.ctx
== Load
? USE
: DEF_LOCAL
))
1204 /* child nodes of List and Tuple will have expr_context set */
1206 VISIT_SEQ(st
, expr
, e
->v
.List
.elts
);
1209 VISIT_SEQ(st
, expr
, e
->v
.Tuple
.elts
);
1216 symtable_implicit_arg(struct symtable
*st
, int pos
)
1218 PyObject
*id
= PyString_FromFormat(".%d", pos
);
1221 if (!symtable_add_def(st
, id
, DEF_PARAM
)) {
1230 symtable_visit_params(struct symtable
*st
, asdl_seq
*args
, int toplevel
)
1234 /* go through all the toplevel arguments first */
1235 for (i
= 0; i
< asdl_seq_LEN(args
); i
++) {
1236 expr_ty arg
= (expr_ty
)asdl_seq_GET(args
, i
);
1237 if (arg
->kind
== Name_kind
) {
1238 assert(arg
->v
.Name
.ctx
== Param
||
1239 (arg
->v
.Name
.ctx
== Store
&& !toplevel
));
1240 if (!symtable_add_def(st
, arg
->v
.Name
.id
, DEF_PARAM
))
1243 else if (arg
->kind
== Tuple_kind
) {
1244 assert(arg
->v
.Tuple
.ctx
== Store
);
1246 if (!symtable_implicit_arg(st
, i
))
1251 PyErr_SetString(PyExc_SyntaxError
,
1252 "invalid expression in parameter list");
1253 PyErr_SyntaxLocation(st
->st_filename
,
1254 st
->st_cur
->ste_lineno
);
1260 if (!symtable_visit_params_nested(st
, args
))
1268 symtable_visit_params_nested(struct symtable
*st
, asdl_seq
*args
)
1271 for (i
= 0; i
< asdl_seq_LEN(args
); i
++) {
1272 expr_ty arg
= (expr_ty
)asdl_seq_GET(args
, i
);
1273 if (arg
->kind
== Tuple_kind
&&
1274 !symtable_visit_params(st
, arg
->v
.Tuple
.elts
, 0))
1282 symtable_visit_arguments(struct symtable
*st
, arguments_ty a
)
1284 /* skip default arguments inside function block
1285 XXX should ast be different?
1287 if (a
->args
&& !symtable_visit_params(st
, a
->args
, 1))
1290 if (!symtable_add_def(st
, a
->vararg
, DEF_PARAM
))
1292 st
->st_cur
->ste_varargs
= 1;
1295 if (!symtable_add_def(st
, a
->kwarg
, DEF_PARAM
))
1297 st
->st_cur
->ste_varkeywords
= 1;
1299 if (a
->args
&& !symtable_visit_params_nested(st
, a
->args
))
1306 symtable_visit_excepthandler(struct symtable
*st
, excepthandler_ty eh
)
1309 VISIT(st
, expr
, eh
->type
);
1311 VISIT(st
, expr
, eh
->name
);
1312 VISIT_SEQ(st
, stmt
, eh
->body
);
1318 symtable_visit_alias(struct symtable
*st
, alias_ty a
)
1320 /* Compute store_name, the name actually bound by the import
1321 operation. It is diferent than a->name when a->name is a
1322 dotted package name (e.g. spam.eggs)
1324 PyObject
*store_name
;
1325 PyObject
*name
= (a
->asname
== NULL
) ? a
->name
: a
->asname
;
1326 const char *base
= PyString_AS_STRING(name
);
1327 char *dot
= strchr(base
, '.');
1329 store_name
= PyString_FromStringAndSize(base
, dot
- base
);
1335 Py_INCREF(store_name
);
1337 if (strcmp(PyString_AS_STRING(name
), "*")) {
1338 int r
= symtable_add_def(st
, store_name
, DEF_IMPORT
);
1339 Py_DECREF(store_name
);
1343 if (st
->st_cur
->ste_type
!= ModuleBlock
) {
1344 int lineno
= st
->st_cur
->ste_lineno
;
1345 if (!symtable_warn(st
, IMPORT_STAR_WARNING
, lineno
)) {
1346 Py_DECREF(store_name
);
1350 st
->st_cur
->ste_unoptimized
|= OPT_IMPORT_STAR
;
1351 Py_DECREF(store_name
);
1358 symtable_visit_comprehension(struct symtable
*st
, comprehension_ty lc
)
1360 VISIT(st
, expr
, lc
->target
);
1361 VISIT(st
, expr
, lc
->iter
);
1362 VISIT_SEQ(st
, expr
, lc
->ifs
);
1368 symtable_visit_keyword(struct symtable
*st
, keyword_ty k
)
1370 VISIT(st
, expr
, k
->value
);
1376 symtable_visit_slice(struct symtable
*st
, slice_ty s
)
1380 if (s
->v
.Slice
.lower
)
1381 VISIT(st
, expr
, s
->v
.Slice
.lower
)
1382 if (s
->v
.Slice
.upper
)
1383 VISIT(st
, expr
, s
->v
.Slice
.upper
)
1384 if (s
->v
.Slice
.step
)
1385 VISIT(st
, expr
, s
->v
.Slice
.step
)
1388 VISIT_SEQ(st
, slice
, s
->v
.ExtSlice
.dims
)
1391 VISIT(st
, expr
, s
->v
.Index
.value
)
1400 symtable_visit_genexp(struct symtable
*st
, expr_ty e
)
1402 comprehension_ty outermost
= ((comprehension_ty
)
1403 (asdl_seq_GET(e
->v
.GeneratorExp
.generators
, 0)));
1404 /* Outermost iterator is evaluated in current scope */
1405 VISIT(st
, expr
, outermost
->iter
);
1406 /* Create generator scope for the rest */
1407 if (!GET_IDENTIFIER(genexpr
) ||
1408 !symtable_enter_block(st
, genexpr
, FunctionBlock
, (void *)e
, 0)) {
1411 st
->st_cur
->ste_generator
= 1;
1412 /* Outermost iter is received as an argument */
1413 if (!symtable_implicit_arg(st
, 0)) {
1414 symtable_exit_block(st
, (void *)e
);
1417 VISIT_IN_BLOCK(st
, expr
, outermost
->target
, (void*)e
);
1418 VISIT_SEQ_IN_BLOCK(st
, expr
, outermost
->ifs
, (void*)e
);
1419 VISIT_SEQ_TAIL_IN_BLOCK(st
, comprehension
,
1420 e
->v
.GeneratorExp
.generators
, 1, (void*)e
);
1421 VISIT_IN_BLOCK(st
, expr
, e
->v
.GeneratorExp
.elt
, (void*)e
);
1422 return symtable_exit_block(st
, (void *)e
);