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
= PyObject_New(PySTEntryObject
, &PySTEntry_Type
);
40 ste
->ste_symbols
= NULL
;
41 ste
->ste_varnames
= NULL
;
42 ste
->ste_children
= NULL
;
44 ste
->ste_symbols
= PyDict_New();
45 if (ste
->ste_symbols
== NULL
)
48 ste
->ste_varnames
= PyList_New(0);
49 if (ste
->ste_varnames
== NULL
)
52 ste
->ste_children
= PyList_New(0);
53 if (ste
->ste_children
== NULL
)
56 ste
->ste_type
= block
;
57 ste
->ste_unoptimized
= 0;
61 ste
->ste_varkeywords
= 0;
62 ste
->ste_opt_lineno
= 0;
64 ste
->ste_lineno
= lineno
;
66 if (st
->st_cur
!= NULL
&&
67 (st
->st_cur
->ste_nested
||
68 st
->st_cur
->ste_type
== FunctionBlock
))
70 ste
->ste_child_free
= 0;
71 ste
->ste_generator
= 0;
72 ste
->ste_returns_value
= 0;
74 if (PyDict_SetItem(st
->st_symbols
, ste
->ste_id
, (PyObject
*)ste
) < 0)
84 ste_repr(PySTEntryObject
*ste
)
88 PyOS_snprintf(buf
, sizeof(buf
),
89 "<symtable entry %.100s(%ld), line %d>",
90 PyString_AS_STRING(ste
->ste_name
),
91 PyInt_AS_LONG(ste
->ste_id
), ste
->ste_lineno
);
92 return PyString_FromString(buf
);
96 ste_dealloc(PySTEntryObject
*ste
)
98 ste
->ste_table
= NULL
;
99 Py_XDECREF(ste
->ste_id
);
100 Py_XDECREF(ste
->ste_name
);
101 Py_XDECREF(ste
->ste_symbols
);
102 Py_XDECREF(ste
->ste_varnames
);
103 Py_XDECREF(ste
->ste_children
);
107 #define OFF(x) offsetof(PySTEntryObject, x)
109 static PyMemberDef ste_memberlist
[] = {
110 {"id", T_OBJECT
, OFF(ste_id
), READONLY
},
111 {"name", T_OBJECT
, OFF(ste_name
), READONLY
},
112 {"symbols", T_OBJECT
, OFF(ste_symbols
), READONLY
},
113 {"varnames", T_OBJECT
, OFF(ste_varnames
), READONLY
},
114 {"children", T_OBJECT
, OFF(ste_children
), READONLY
},
115 {"type", T_INT
, OFF(ste_type
), READONLY
},
116 {"lineno", T_INT
, OFF(ste_lineno
), READONLY
},
120 PyTypeObject PySTEntry_Type
= {
121 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
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 if (!GET_IDENTIFIER(top
) ||
225 !symtable_enter_block(st
, top
, ModuleBlock
, (void *)mod
, 0)) {
230 st
->st_top
= st
->st_cur
;
231 st
->st_cur
->ste_unoptimized
= OPT_TOPLEVEL
;
232 /* Any other top-level initialization? */
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
)))
241 case Expression_kind
:
242 if (!symtable_visit_expr(st
, mod
->v
.Expression
.body
))
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
)))
253 PyErr_SetString(PyExc_RuntimeError
,
254 "this compiler does not handle Suites");
257 if (!symtable_exit_block(st
, (void *)mod
)) {
261 if (symtable_analyze(st
))
266 (void) symtable_exit_block(st
, (void *)mod
);
272 PySymtable_Free(struct symtable
*st
)
274 Py_XDECREF(st
->st_symbols
);
275 Py_XDECREF(st
->st_stack
);
276 PyMem_Free((void *)st
);
280 PySymtable_Lookup(struct symtable
*st
, void *key
)
284 k
= PyLong_FromVoidPtr(key
);
287 v
= PyDict_GetItem(st
->st_symbols
, k
);
289 assert(PySTEntry_Check(v
));
293 PyErr_SetString(PyExc_KeyError
,
294 "unknown symbol table entry");
298 return (PySTEntryObject
*)v
;
302 PyST_GetScope(PySTEntryObject
*ste
, PyObject
*name
)
304 PyObject
*v
= PyDict_GetItem(ste
->ste_symbols
, name
);
307 assert(PyInt_Check(v
));
308 return (PyInt_AS_LONG(v
) >> SCOPE_OFF
) & SCOPE_MASK
;
312 /* Analyze raw symbol information to determine scope of each name.
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.
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.
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.
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.
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.
345 The sets of bound and free variables are implemented as dictionaries
346 mapping strings to None.
349 #define SET_SCOPE(DICT, NAME, I) { \
350 PyObject *o = PyInt_FromLong(I); \
353 if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
360 /* Decide on scope of name, given flags.
362 The dicts passed in as arguments are modified as necessary.
363 ste is passed so that flags can be updated.
367 analyze_name(PySTEntryObject
*ste
, PyObject
*dict
, PyObject
*name
, long flags
,
368 PyObject
*bound
, PyObject
*local
, PyObject
*free
,
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
));
378 SET_SCOPE(dict
, name
, GLOBAL_EXPLICIT
);
379 if (PyDict_SetItem(global
, name
, Py_None
) < 0)
381 if (bound
&& PyDict_GetItem(bound
, name
)) {
382 if (PyDict_DelItem(bound
, name
) < 0)
387 if (flags
& DEF_BOUND
) {
388 SET_SCOPE(dict
, name
, LOCAL
);
389 if (PyDict_SetItem(local
, name
, Py_None
) < 0)
391 if (PyDict_GetItem(global
, name
)) {
392 if (PyDict_DelItem(global
, name
) < 0)
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
402 if (bound
&& PyDict_GetItem(bound
, name
)) {
403 SET_SCOPE(dict
, name
, FREE
);
405 if (PyDict_SetItem(free
, name
, Py_None
) < 0)
409 /* If a parent has a global statement, then call it global
410 explicit? It could also be global implicit.
412 else if (global
&& PyDict_GetItem(global
, name
)) {
413 SET_SCOPE(dict
, name
, GLOBAL_EXPLICIT
);
419 SET_SCOPE(dict
, name
, GLOBAL_IMPLICIT
);
422 return 0; /* Can't get here */
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.
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.
436 analyze_cells(PyObject
*scope
, PyObject
*free
)
438 PyObject
*name
, *v
, *w
;
442 w
= PyInt_FromLong(CELL
);
445 while (PyDict_Next(scope
, &pos
, &name
, &v
)) {
447 assert(PyInt_Check(v
));
448 flags
= PyInt_AS_LONG(v
);
451 if (!PyDict_GetItem(free
, name
))
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.
457 if (PyDict_SetItem(scope
, name
, w
) < 0)
459 if (!PyDict_DelItem(free
, name
) < 0)
468 /* Check for illegal statements in unoptimized namespaces */
470 check_unoptimized(const PySTEntryObject
* ste
) {
474 if (ste
->ste_type
!= FunctionBlock
|| !ste
->ste_unoptimized
475 || !(ste
->ste_free
|| ste
->ste_child_free
))
478 trailer
= (ste
->ste_child_free
?
479 "contains a nested function with free variables" :
480 "is a nested function");
482 switch (ste
->ste_unoptimized
) {
483 case OPT_TOPLEVEL
: /* exec / import * at top-level is fine */
484 case OPT_EXEC
: /* qualified exec is fine */
486 case OPT_IMPORT_STAR
:
487 PyOS_snprintf(buf
, sizeof(buf
),
488 "import * is not allowed in function '%.100s' "
490 PyString_AS_STRING(ste
->ste_name
), trailer
);
493 PyOS_snprintf(buf
, sizeof(buf
),
494 "unqualified exec is not allowed in function "
496 PyString_AS_STRING(ste
->ste_name
), trailer
);
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
);
506 PyErr_SetString(PyExc_SyntaxError
, buf
);
507 PyErr_SyntaxLocation(ste
->ste_table
->st_filename
,
508 ste
->ste_opt_lineno
);
512 /* Enter the final scope information into the st_symbols dict.
514 * All arguments are dicts. Modifies symbols, others are read-only.
517 update_symbols(PyObject
*symbols
, PyObject
*scope
,
518 PyObject
*bound
, PyObject
*free
, int classflag
)
520 PyObject
*name
, *v
, *u
, *w
, *free_value
= NULL
;
523 while (PyDict_Next(symbols
, &pos
, &name
, &v
)) {
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
);
534 if (PyDict_SetItem(symbols
, name
, u
) < 0) {
541 free_value
= PyInt_FromLong(FREE
<< SCOPE_OFF
);
545 /* add a free variable when it's only use is for creating a closure */
547 while (PyDict_Next(free
, &pos
, &name
, &v
)) {
548 PyObject
*o
= PyDict_GetItem(symbols
, name
);
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.
556 PyInt_AS_LONG(o
) & (DEF_BOUND
| DEF_GLOBAL
)) {
557 long i
= PyInt_AS_LONG(o
) | DEF_FREE_CLASS
;
558 o
= PyInt_FromLong(i
);
560 Py_DECREF(free_value
);
563 if (PyDict_SetItem(symbols
, name
, o
) < 0) {
565 Py_DECREF(free_value
);
570 /* else it's not free, probably a cell */
573 if (!PyDict_GetItem(bound
, name
))
574 continue; /* it's a global */
576 if (PyDict_SetItem(symbols
, name
, free_value
) < 0) {
577 Py_DECREF(free_value
);
581 Py_DECREF(free_value
);
585 /* Make final symbol table decisions for block of ste.
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)
594 analyze_block(PySTEntryObject
*ste
, PyObject
*bound
, PyObject
*free
,
597 PyObject
*name
, *v
, *local
= NULL
, *scope
= NULL
, *newbound
= NULL
;
598 PyObject
*newglobal
= NULL
, *newfree
= NULL
;
602 local
= PyDict_New();
605 scope
= PyDict_New();
608 newglobal
= PyDict_New();
611 newfree
= PyDict_New();
614 newbound
= PyDict_New();
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
623 if (PyDict_Update(newglobal
, global
) < 0)
626 if (PyDict_Update(newbound
, bound
) < 0)
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
,
639 if (ste
->ste_type
!= ClassBlock
) {
640 if (ste
->ste_type
== FunctionBlock
) {
641 if (PyDict_Update(newbound
, local
) < 0)
645 if (PyDict_Update(newbound
, bound
) < 0)
648 if (PyDict_Update(newglobal
, global
) < 0)
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
))
660 if (entry
->ste_free
|| entry
->ste_child_free
)
661 ste
->ste_child_free
= 1;
664 if (ste
->ste_type
== FunctionBlock
&& !analyze_cells(scope
, newfree
))
666 if (!update_symbols(ste
->ste_symbols
, scope
, bound
, newfree
,
667 ste
->ste_type
== ClassBlock
))
669 if (!check_unoptimized(ste
))
672 if (PyDict_Update(free
, newfree
) < 0)
678 Py_XDECREF(newbound
);
679 Py_XDECREF(newglobal
);
682 assert(PyErr_Occurred());
687 symtable_analyze(struct symtable
*st
)
689 PyObject
*free
, *global
;
695 global
= PyDict_New();
700 r
= analyze_block(st
->st_top
, NULL
, free
, global
);
708 symtable_warn(struct symtable
*st
, char *msg
, int lineno
)
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
);
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().
728 symtable_exit_block(struct symtable
*st
, void *ast
)
732 Py_CLEAR(st
->st_cur
);
733 end
= PyList_GET_SIZE(st
->st_stack
) - 1;
735 st
->st_cur
= (PySTEntryObject
*)PyList_GET_ITEM(st
->st_stack
,
737 if (st
->st_cur
== NULL
)
739 Py_INCREF(st
->st_cur
);
740 if (PySequence_DelItem(st
->st_stack
, end
) < 0)
747 symtable_enter_block(struct symtable
*st
, identifier name
, _Py_block_ty block
,
748 void *ast
, int lineno
)
750 PySTEntryObject
*prev
= NULL
;
754 if (PyList_Append(st
->st_stack
, (PyObject
*)st
->st_cur
) < 0) {
757 Py_DECREF(st
->st_cur
);
759 st
->st_cur
= PySTEntry_New(st
, name
, block
, ast
, lineno
);
760 if (st
->st_cur
== NULL
)
762 if (name
== GET_IDENTIFIER(top
))
763 st
->st_global
= st
->st_cur
->ste_symbols
;
765 if (PyList_Append(prev
->ste_children
,
766 (PyObject
*)st
->st_cur
) < 0) {
774 symtable_lookup(struct symtable
*st
, PyObject
*name
)
777 PyObject
*mangled
= _Py_Mangle(st
->st_private
, name
);
780 o
= PyDict_GetItem(st
->st_cur
->ste_symbols
, mangled
);
784 return PyInt_AsLong(o
);
788 symtable_add_def(struct symtable
*st
, PyObject
*name
, int flag
)
793 PyObject
*mangled
= _Py_Mangle(st
->st_private
, name
);
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
);
811 o
= PyInt_FromLong(val
);
814 if (PyDict_SetItem(dict
, mangled
, o
) < 0) {
820 if (flag
& DEF_PARAM
) {
821 if (PyList_Append(st
->st_cur
->ste_varnames
, mangled
) < 0)
823 } else if (flag
& DEF_GLOBAL
) {
824 /* XXX need to update DEF_GLOBAL for other flags too;
825 perhaps only DEF_FREE_GLOBAL */
827 if ((o
= PyDict_GetItem(st
->st_global
, mangled
))) {
828 val
|= PyInt_AS_LONG(o
);
830 o
= PyInt_FromLong(val
);
833 if (PyDict_SetItem(st
->st_global
, mangled
, o
) < 0) {
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
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.
855 #define VISIT(ST, TYPE, V) \
856 if (!symtable_visit_ ## TYPE((ST), (V))) \
859 #define VISIT_IN_BLOCK(ST, TYPE, V, S) \
860 if (!symtable_visit_ ## TYPE((ST), (V))) { \
861 symtable_exit_block((ST), (S)); \
865 #define VISIT_SEQ(ST, TYPE, SEQ) { \
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)) \
875 #define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \
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)); \
887 #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
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)) \
897 #define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \
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)); \
910 symtable_new_tmpname(struct symtable
*st
)
915 PyOS_snprintf(tmpname
, sizeof(tmpname
), "_[%d]",
916 ++st
->st_cur
->ste_tmpname
);
917 tmp
= PyString_InternFromString(tmpname
);
920 if (!symtable_add_def(st
, tmp
, DEF_LOCAL
))
927 symtable_visit_stmt(struct symtable
*st
, stmt_ty s
)
930 case FunctionDef_kind
:
931 if (!symtable_add_def(st
, s
->v
.FunctionDef
.name
, DEF_LOCAL
))
933 if (s
->v
.FunctionDef
.args
->defaults
)
934 VISIT_SEQ(st
, expr
, s
->v
.FunctionDef
.args
->defaults
);
935 if (s
->v
.FunctionDef
.decorator_list
)
936 VISIT_SEQ(st
, expr
, s
->v
.FunctionDef
.decorator_list
);
937 if (!symtable_enter_block(st
, s
->v
.FunctionDef
.name
,
938 FunctionBlock
, (void *)s
, s
->lineno
))
940 VISIT_IN_BLOCK(st
, arguments
, s
->v
.FunctionDef
.args
, s
);
941 VISIT_SEQ_IN_BLOCK(st
, stmt
, s
->v
.FunctionDef
.body
, s
);
942 if (!symtable_exit_block(st
, s
))
945 case ClassDef_kind
: {
947 if (!symtable_add_def(st
, s
->v
.ClassDef
.name
, DEF_LOCAL
))
949 VISIT_SEQ(st
, expr
, s
->v
.ClassDef
.bases
);
950 if (s
->v
.ClassDef
.decorator_list
)
951 VISIT_SEQ(st
, expr
, s
->v
.ClassDef
.decorator_list
);
952 if (!symtable_enter_block(st
, s
->v
.ClassDef
.name
, ClassBlock
,
953 (void *)s
, s
->lineno
))
955 tmp
= st
->st_private
;
956 st
->st_private
= s
->v
.ClassDef
.name
;
957 VISIT_SEQ_IN_BLOCK(st
, stmt
, s
->v
.ClassDef
.body
, s
);
958 st
->st_private
= tmp
;
959 if (!symtable_exit_block(st
, s
))
964 if (s
->v
.Return
.value
) {
965 VISIT(st
, expr
, s
->v
.Return
.value
);
966 st
->st_cur
->ste_returns_value
= 1;
967 if (st
->st_cur
->ste_generator
) {
968 PyErr_SetString(PyExc_SyntaxError
,
969 RETURN_VAL_IN_GENERATOR
);
970 PyErr_SyntaxLocation(st
->st_filename
,
977 VISIT_SEQ(st
, expr
, s
->v
.Delete
.targets
);
980 VISIT_SEQ(st
, expr
, s
->v
.Assign
.targets
);
981 VISIT(st
, expr
, s
->v
.Assign
.value
);
984 VISIT(st
, expr
, s
->v
.AugAssign
.target
);
985 VISIT(st
, expr
, s
->v
.AugAssign
.value
);
989 VISIT(st
, expr
, s
->v
.Print
.dest
);
990 VISIT_SEQ(st
, expr
, s
->v
.Print
.values
);
993 VISIT(st
, expr
, s
->v
.For
.target
);
994 VISIT(st
, expr
, s
->v
.For
.iter
);
995 VISIT_SEQ(st
, stmt
, s
->v
.For
.body
);
997 VISIT_SEQ(st
, stmt
, s
->v
.For
.orelse
);
1000 VISIT(st
, expr
, s
->v
.While
.test
);
1001 VISIT_SEQ(st
, stmt
, s
->v
.While
.body
);
1002 if (s
->v
.While
.orelse
)
1003 VISIT_SEQ(st
, stmt
, s
->v
.While
.orelse
);
1006 /* XXX if 0: and lookup_yield() hacks */
1007 VISIT(st
, expr
, s
->v
.If
.test
);
1008 VISIT_SEQ(st
, stmt
, s
->v
.If
.body
);
1010 VISIT_SEQ(st
, stmt
, s
->v
.If
.orelse
);
1013 if (s
->v
.Raise
.type
) {
1014 VISIT(st
, expr
, s
->v
.Raise
.type
);
1015 if (s
->v
.Raise
.inst
) {
1016 VISIT(st
, expr
, s
->v
.Raise
.inst
);
1017 if (s
->v
.Raise
.tback
)
1018 VISIT(st
, expr
, s
->v
.Raise
.tback
);
1022 case TryExcept_kind
:
1023 VISIT_SEQ(st
, stmt
, s
->v
.TryExcept
.body
);
1024 VISIT_SEQ(st
, stmt
, s
->v
.TryExcept
.orelse
);
1025 VISIT_SEQ(st
, excepthandler
, s
->v
.TryExcept
.handlers
);
1027 case TryFinally_kind
:
1028 VISIT_SEQ(st
, stmt
, s
->v
.TryFinally
.body
);
1029 VISIT_SEQ(st
, stmt
, s
->v
.TryFinally
.finalbody
);
1032 VISIT(st
, expr
, s
->v
.Assert
.test
);
1033 if (s
->v
.Assert
.msg
)
1034 VISIT(st
, expr
, s
->v
.Assert
.msg
);
1037 VISIT_SEQ(st
, alias
, s
->v
.Import
.names
);
1038 /* XXX Don't have the lineno available inside
1040 if (st
->st_cur
->ste_unoptimized
&& !st
->st_cur
->ste_opt_lineno
)
1041 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1043 case ImportFrom_kind
:
1044 VISIT_SEQ(st
, alias
, s
->v
.ImportFrom
.names
);
1045 /* XXX Don't have the lineno available inside
1047 if (st
->st_cur
->ste_unoptimized
&& !st
->st_cur
->ste_opt_lineno
)
1048 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1051 VISIT(st
, expr
, s
->v
.Exec
.body
);
1052 if (!st
->st_cur
->ste_opt_lineno
)
1053 st
->st_cur
->ste_opt_lineno
= s
->lineno
;
1054 if (s
->v
.Exec
.globals
) {
1055 st
->st_cur
->ste_unoptimized
|= OPT_EXEC
;
1056 VISIT(st
, expr
, s
->v
.Exec
.globals
);
1057 if (s
->v
.Exec
.locals
)
1058 VISIT(st
, expr
, s
->v
.Exec
.locals
);
1060 st
->st_cur
->ste_unoptimized
|= OPT_BARE_EXEC
;
1065 asdl_seq
*seq
= s
->v
.Global
.names
;
1066 for (i
= 0; i
< asdl_seq_LEN(seq
); i
++) {
1067 identifier name
= (identifier
)asdl_seq_GET(seq
, i
);
1068 char *c_name
= PyString_AS_STRING(name
);
1069 long cur
= symtable_lookup(st
, name
);
1072 if (cur
& (DEF_LOCAL
| USE
)) {
1074 if (cur
& DEF_LOCAL
)
1075 PyOS_snprintf(buf
, sizeof(buf
),
1076 GLOBAL_AFTER_ASSIGN
,
1079 PyOS_snprintf(buf
, sizeof(buf
),
1082 if (!symtable_warn(st
, buf
, s
->lineno
))
1085 if (!symtable_add_def(st
, name
, DEF_GLOBAL
))
1091 VISIT(st
, expr
, s
->v
.Expr
.value
);
1096 /* nothing to do here */
1099 if (!symtable_new_tmpname(st
))
1101 VISIT(st
, expr
, s
->v
.With
.context_expr
);
1102 if (s
->v
.With
.optional_vars
) {
1103 if (!symtable_new_tmpname(st
))
1105 VISIT(st
, expr
, s
->v
.With
.optional_vars
);
1107 VISIT_SEQ(st
, stmt
, s
->v
.With
.body
);
1114 symtable_visit_expr(struct symtable
*st
, expr_ty e
)
1118 VISIT_SEQ(st
, expr
, e
->v
.BoolOp
.values
);
1121 VISIT(st
, expr
, e
->v
.BinOp
.left
);
1122 VISIT(st
, expr
, e
->v
.BinOp
.right
);
1125 VISIT(st
, expr
, e
->v
.UnaryOp
.operand
);
1128 if (!GET_IDENTIFIER(lambda
) ||
1129 !symtable_add_def(st
, lambda
, DEF_LOCAL
))
1131 if (e
->v
.Lambda
.args
->defaults
)
1132 VISIT_SEQ(st
, expr
, e
->v
.Lambda
.args
->defaults
);
1133 /* XXX how to get line numbers for expressions */
1134 if (!symtable_enter_block(st
, lambda
,
1135 FunctionBlock
, (void *)e
, 0))
1137 VISIT_IN_BLOCK(st
, arguments
, e
->v
.Lambda
.args
, (void*)e
);
1138 VISIT_IN_BLOCK(st
, expr
, e
->v
.Lambda
.body
, (void*)e
);
1139 if (!symtable_exit_block(st
, (void *)e
))
1144 VISIT(st
, expr
, e
->v
.IfExp
.test
);
1145 VISIT(st
, expr
, e
->v
.IfExp
.body
);
1146 VISIT(st
, expr
, e
->v
.IfExp
.orelse
);
1149 VISIT_SEQ(st
, expr
, e
->v
.Dict
.keys
);
1150 VISIT_SEQ(st
, expr
, e
->v
.Dict
.values
);
1153 if (!symtable_new_tmpname(st
))
1155 VISIT(st
, expr
, e
->v
.ListComp
.elt
);
1156 VISIT_SEQ(st
, comprehension
, e
->v
.ListComp
.generators
);
1158 case GeneratorExp_kind
:
1159 if (!symtable_visit_genexp(st
, e
))
1163 if (e
->v
.Yield
.value
)
1164 VISIT(st
, expr
, e
->v
.Yield
.value
);
1165 st
->st_cur
->ste_generator
= 1;
1166 if (st
->st_cur
->ste_returns_value
) {
1167 PyErr_SetString(PyExc_SyntaxError
,
1168 RETURN_VAL_IN_GENERATOR
);
1169 PyErr_SyntaxLocation(st
->st_filename
,
1175 VISIT(st
, expr
, e
->v
.Compare
.left
);
1176 VISIT_SEQ(st
, expr
, e
->v
.Compare
.comparators
);
1179 VISIT(st
, expr
, e
->v
.Call
.func
);
1180 VISIT_SEQ(st
, expr
, e
->v
.Call
.args
);
1181 VISIT_SEQ(st
, keyword
, e
->v
.Call
.keywords
);
1182 if (e
->v
.Call
.starargs
)
1183 VISIT(st
, expr
, e
->v
.Call
.starargs
);
1184 if (e
->v
.Call
.kwargs
)
1185 VISIT(st
, expr
, e
->v
.Call
.kwargs
);
1188 VISIT(st
, expr
, e
->v
.Repr
.value
);
1192 /* Nothing to do here. */
1194 /* The following exprs can be assignment targets. */
1195 case Attribute_kind
:
1196 VISIT(st
, expr
, e
->v
.Attribute
.value
);
1198 case Subscript_kind
:
1199 VISIT(st
, expr
, e
->v
.Subscript
.value
);
1200 VISIT(st
, slice
, e
->v
.Subscript
.slice
);
1203 if (!symtable_add_def(st
, e
->v
.Name
.id
,
1204 e
->v
.Name
.ctx
== Load
? USE
: DEF_LOCAL
))
1207 /* child nodes of List and Tuple will have expr_context set */
1209 VISIT_SEQ(st
, expr
, e
->v
.List
.elts
);
1212 VISIT_SEQ(st
, expr
, e
->v
.Tuple
.elts
);
1219 symtable_implicit_arg(struct symtable
*st
, int pos
)
1221 PyObject
*id
= PyString_FromFormat(".%d", pos
);
1224 if (!symtable_add_def(st
, id
, DEF_PARAM
)) {
1233 symtable_visit_params(struct symtable
*st
, asdl_seq
*args
, int toplevel
)
1237 /* go through all the toplevel arguments first */
1238 for (i
= 0; i
< asdl_seq_LEN(args
); i
++) {
1239 expr_ty arg
= (expr_ty
)asdl_seq_GET(args
, i
);
1240 if (arg
->kind
== Name_kind
) {
1241 assert(arg
->v
.Name
.ctx
== Param
||
1242 (arg
->v
.Name
.ctx
== Store
&& !toplevel
));
1243 if (!symtable_add_def(st
, arg
->v
.Name
.id
, DEF_PARAM
))
1246 else if (arg
->kind
== Tuple_kind
) {
1247 assert(arg
->v
.Tuple
.ctx
== Store
);
1249 if (!symtable_implicit_arg(st
, i
))
1254 PyErr_SetString(PyExc_SyntaxError
,
1255 "invalid expression in parameter list");
1256 PyErr_SyntaxLocation(st
->st_filename
,
1257 st
->st_cur
->ste_lineno
);
1263 if (!symtable_visit_params_nested(st
, args
))
1271 symtable_visit_params_nested(struct symtable
*st
, asdl_seq
*args
)
1274 for (i
= 0; i
< asdl_seq_LEN(args
); i
++) {
1275 expr_ty arg
= (expr_ty
)asdl_seq_GET(args
, i
);
1276 if (arg
->kind
== Tuple_kind
&&
1277 !symtable_visit_params(st
, arg
->v
.Tuple
.elts
, 0))
1285 symtable_visit_arguments(struct symtable
*st
, arguments_ty a
)
1287 /* skip default arguments inside function block
1288 XXX should ast be different?
1290 if (a
->args
&& !symtable_visit_params(st
, a
->args
, 1))
1293 if (!symtable_add_def(st
, a
->vararg
, DEF_PARAM
))
1295 st
->st_cur
->ste_varargs
= 1;
1298 if (!symtable_add_def(st
, a
->kwarg
, DEF_PARAM
))
1300 st
->st_cur
->ste_varkeywords
= 1;
1302 if (a
->args
&& !symtable_visit_params_nested(st
, a
->args
))
1309 symtable_visit_excepthandler(struct symtable
*st
, excepthandler_ty eh
)
1311 if (eh
->v
.ExceptHandler
.type
)
1312 VISIT(st
, expr
, eh
->v
.ExceptHandler
.type
);
1313 if (eh
->v
.ExceptHandler
.name
)
1314 VISIT(st
, expr
, eh
->v
.ExceptHandler
.name
);
1315 VISIT_SEQ(st
, stmt
, eh
->v
.ExceptHandler
.body
);
1321 symtable_visit_alias(struct symtable
*st
, alias_ty a
)
1323 /* Compute store_name, the name actually bound by the import
1324 operation. It is diferent than a->name when a->name is a
1325 dotted package name (e.g. spam.eggs)
1327 PyObject
*store_name
;
1328 PyObject
*name
= (a
->asname
== NULL
) ? a
->name
: a
->asname
;
1329 const char *base
= PyString_AS_STRING(name
);
1330 char *dot
= strchr(base
, '.');
1332 store_name
= PyString_FromStringAndSize(base
, dot
- base
);
1338 Py_INCREF(store_name
);
1340 if (strcmp(PyString_AS_STRING(name
), "*")) {
1341 int r
= symtable_add_def(st
, store_name
, DEF_IMPORT
);
1342 Py_DECREF(store_name
);
1346 if (st
->st_cur
->ste_type
!= ModuleBlock
) {
1347 int lineno
= st
->st_cur
->ste_lineno
;
1348 if (!symtable_warn(st
, IMPORT_STAR_WARNING
, lineno
)) {
1349 Py_DECREF(store_name
);
1353 st
->st_cur
->ste_unoptimized
|= OPT_IMPORT_STAR
;
1354 Py_DECREF(store_name
);
1361 symtable_visit_comprehension(struct symtable
*st
, comprehension_ty lc
)
1363 VISIT(st
, expr
, lc
->target
);
1364 VISIT(st
, expr
, lc
->iter
);
1365 VISIT_SEQ(st
, expr
, lc
->ifs
);
1371 symtable_visit_keyword(struct symtable
*st
, keyword_ty k
)
1373 VISIT(st
, expr
, k
->value
);
1379 symtable_visit_slice(struct symtable
*st
, slice_ty s
)
1383 if (s
->v
.Slice
.lower
)
1384 VISIT(st
, expr
, s
->v
.Slice
.lower
)
1385 if (s
->v
.Slice
.upper
)
1386 VISIT(st
, expr
, s
->v
.Slice
.upper
)
1387 if (s
->v
.Slice
.step
)
1388 VISIT(st
, expr
, s
->v
.Slice
.step
)
1391 VISIT_SEQ(st
, slice
, s
->v
.ExtSlice
.dims
)
1394 VISIT(st
, expr
, s
->v
.Index
.value
)
1403 symtable_visit_genexp(struct symtable
*st
, expr_ty e
)
1405 comprehension_ty outermost
= ((comprehension_ty
)
1406 (asdl_seq_GET(e
->v
.GeneratorExp
.generators
, 0)));
1407 /* Outermost iterator is evaluated in current scope */
1408 VISIT(st
, expr
, outermost
->iter
);
1409 /* Create generator scope for the rest */
1410 if (!GET_IDENTIFIER(genexpr
) ||
1411 !symtable_enter_block(st
, genexpr
, FunctionBlock
, (void *)e
, 0)) {
1414 st
->st_cur
->ste_generator
= 1;
1415 /* Outermost iter is received as an argument */
1416 if (!symtable_implicit_arg(st
, 0)) {
1417 symtable_exit_block(st
, (void *)e
);
1420 VISIT_IN_BLOCK(st
, expr
, outermost
->target
, (void*)e
);
1421 VISIT_SEQ_IN_BLOCK(st
, expr
, outermost
->ifs
, (void*)e
);
1422 VISIT_SEQ_TAIL_IN_BLOCK(st
, comprehension
,
1423 e
->v
.GeneratorExp
.generators
, 1, (void*)e
);
1424 VISIT_IN_BLOCK(st
, expr
, e
->v
.GeneratorExp
.elt
, (void*)e
);
1425 return symtable_exit_block(st
, (void *)e
);