blob: 05d504c2cb64cabc9d1f24cb8c31e9f92dea9d3e [file] [log] [blame]
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00001#include "Python.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002#include "Python-ast.h"
3#include "code.h"
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004#include "symtable.h"
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005#include "structmember.h"
6
Neal Norwitz5d0ad502005-12-19 04:27:42 +00007/* error strings used for warnings */
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00008#define GLOBAL_AFTER_ASSIGN \
9"name '%.400s' is assigned to before global declaration"
Jeremy Hylton29906402001-12-10 00:53:18 +000010
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000011#define GLOBAL_AFTER_USE \
12"name '%.400s' is used prior to global declaration"
Jeremy Hylton29906402001-12-10 00:53:18 +000013
Neal Norwitz5d0ad502005-12-19 04:27:42 +000014#define IMPORT_STAR_WARNING "import * only allowed at module level"
15
Georg Brandlddbaa662006-06-04 21:56:52 +000016#define RETURN_VAL_IN_GENERATOR \
17 "'return' with argument inside generator"
Neal Norwitz5d0ad502005-12-19 04:27:42 +000018
Neal Norwitz090b3dd2006-02-28 22:36:46 +000019/* XXX(nnorwitz): change name since static? */
20static PySTEntryObject *
Neal Norwitz62c2fac2005-10-24 00:30:44 +000021PySTEntry_New(struct symtable *st, identifier name, _Py_block_ty block,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000022 void *key, int lineno)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000023{
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000024 PySTEntryObject *ste = NULL;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +000025 PyObject *k;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000026
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000027 k = PyLong_FromVoidPtr(key);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000028 if (k == NULL)
29 goto fail;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000030 ste = (PySTEntryObject *)PyObject_New(PySTEntryObject,
31 &PySTEntry_Type);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000032 ste->ste_table = st;
33 ste->ste_id = k;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000034 ste->ste_tmpname = 0;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000035
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000036 ste->ste_name = name;
37 Py_INCREF(name);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000038
Neal Norwitzb6fc9df2005-11-13 18:50:34 +000039 ste->ste_symbols = NULL;
40 ste->ste_varnames = NULL;
41 ste->ste_children = NULL;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000042
Neal Norwitzb6fc9df2005-11-13 18:50:34 +000043 ste->ste_symbols = PyDict_New();
44 if (ste->ste_symbols == NULL)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000045 goto fail;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +000046
47 ste->ste_varnames = PyList_New(0);
48 if (ste->ste_varnames == NULL)
49 goto fail;
50
51 ste->ste_children = PyList_New(0);
52 if (ste->ste_children == NULL)
53 goto fail;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000054
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000055 ste->ste_type = block;
56 ste->ste_unoptimized = 0;
57 ste->ste_nested = 0;
58 ste->ste_free = 0;
59 ste->ste_varargs = 0;
60 ste->ste_varkeywords = 0;
Jeremy Hylton86424e32001-12-04 02:41:46 +000061 ste->ste_opt_lineno = 0;
Jeremy Hylton4d508ad2003-05-21 17:34:50 +000062 ste->ste_tmpname = 0;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000063 ste->ste_lineno = lineno;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000064
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000065 if (st->st_cur != NULL &&
66 (st->st_cur->ste_nested ||
67 st->st_cur->ste_type == FunctionBlock))
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000068 ste->ste_nested = 1;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000069 ste->ste_child_free = 0;
Tim Peters5ca576e2001-06-18 22:08:13 +000070 ste->ste_generator = 0;
Georg Brandlddbaa662006-06-04 21:56:52 +000071 ste->ste_returns_value = 0;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000072
73 if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0)
74 goto fail;
Jeremy Hylton74b3bc42001-02-23 17:55:27 +000075
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000076 return ste;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000077 fail:
78 Py_XDECREF(ste);
79 return NULL;
80}
81
82static PyObject *
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000083ste_repr(PySTEntryObject *ste)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000084{
85 char buf[256];
86
Barry Warsaw4b4ab202001-11-28 21:36:28 +000087 PyOS_snprintf(buf, sizeof(buf),
88 "<symtable entry %.100s(%ld), line %d>",
89 PyString_AS_STRING(ste->ste_name),
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000090 PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000091 return PyString_FromString(buf);
92}
93
94static void
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000095ste_dealloc(PySTEntryObject *ste)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000096{
97 ste->ste_table = NULL;
98 Py_XDECREF(ste->ste_id);
99 Py_XDECREF(ste->ste_name);
100 Py_XDECREF(ste->ste_symbols);
101 Py_XDECREF(ste->ste_varnames);
102 Py_XDECREF(ste->ste_children);
103 PyObject_Del(ste);
104}
105
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000106#define OFF(x) offsetof(PySTEntryObject, x)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000107
Guido van Rossum6f799372001-09-20 20:46:19 +0000108static PyMemberDef ste_memberlist[] = {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000109 {"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},
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000116 {NULL}
117};
118
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000119PyTypeObject PySTEntry_Type = {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000120 PyObject_HEAD_INIT(&PyType_Type)
121 0,
122 "symtable entry",
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000123 sizeof(PySTEntryObject),
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000124 0,
125 (destructor)ste_dealloc, /* tp_dealloc */
126 0, /* tp_print */
Guido van Rossum6f799372001-09-20 20:46:19 +0000127 0, /* tp_getattr */
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000128 0, /* tp_setattr */
129 0, /* tp_compare */
130 (reprfunc)ste_repr, /* tp_repr */
131 0, /* tp_as_number */
132 0, /* tp_as_sequence */
133 0, /* tp_as_mapping */
134 0, /* tp_hash */
135 0, /* tp_call */
136 0, /* tp_str */
Guido van Rossum6f799372001-09-20 20:46:19 +0000137 PyObject_GenericGetAttr, /* tp_getattro */
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000138 0, /* tp_setattro */
139 0, /* tp_as_buffer */
140 Py_TPFLAGS_DEFAULT, /* tp_flags */
141 0, /* tp_doc */
Guido van Rossum6f799372001-09-20 20:46:19 +0000142 0, /* tp_traverse */
143 0, /* tp_clear */
144 0, /* tp_richcompare */
145 0, /* tp_weaklistoffset */
146 0, /* tp_iter */
147 0, /* tp_iternext */
148 0, /* tp_methods */
149 ste_memberlist, /* tp_members */
150 0, /* tp_getset */
151 0, /* tp_base */
152 0, /* tp_dict */
153 0, /* tp_descr_get */
154 0, /* tp_descr_set */
155 0, /* tp_dictoffset */
156 0, /* tp_init */
157 0, /* tp_alloc */
158 0, /* tp_new */
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000159};
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000160
161static int symtable_analyze(struct symtable *st);
Neal Norwitz5d0ad502005-12-19 04:27:42 +0000162static int symtable_warn(struct symtable *st, char *msg, int lineno);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000163static int symtable_enter_block(struct symtable *st, identifier name,
Neal Norwitz62c2fac2005-10-24 00:30:44 +0000164 _Py_block_ty block, void *ast, int lineno);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000165static int symtable_exit_block(struct symtable *st, void *ast);
166static int symtable_visit_stmt(struct symtable *st, stmt_ty s);
167static int symtable_visit_expr(struct symtable *st, expr_ty s);
168static int symtable_visit_genexp(struct symtable *st, expr_ty s);
169static int symtable_visit_arguments(struct symtable *st, arguments_ty);
170static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty);
171static int symtable_visit_alias(struct symtable *st, alias_ty);
172static int symtable_visit_comprehension(struct symtable *st, comprehension_ty);
173static int symtable_visit_keyword(struct symtable *st, keyword_ty);
174static int symtable_visit_slice(struct symtable *st, slice_ty);
175static int symtable_visit_params(struct symtable *st, asdl_seq *args, int top);
176static int symtable_visit_params_nested(struct symtable *st, asdl_seq *args);
177static int symtable_implicit_arg(struct symtable *st, int pos);
178
179
Nick Coghlan99b25332005-11-16 12:45:24 +0000180static identifier top = NULL, lambda = NULL, genexpr = NULL;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000181
182#define GET_IDENTIFIER(VAR) \
183 ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))
184
185#define DUPLICATE_ARGUMENT \
186"duplicate argument '%s' in function definition"
187
188static struct symtable *
189symtable_new(void)
190{
191 struct symtable *st;
192
193 st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));
194 if (st == NULL)
195 return NULL;
196
197 st->st_filename = NULL;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000198 st->st_symbols = NULL;
199
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000200 if ((st->st_stack = PyList_New(0)) == NULL)
201 goto fail;
202 if ((st->st_symbols = PyDict_New()) == NULL)
203 goto fail;
204 st->st_cur = NULL;
205 st->st_tmpname = 0;
206 st->st_private = NULL;
207 return st;
208 fail:
209 PySymtable_Free(st);
210 return NULL;
211}
212
213struct symtable *
214PySymtable_Build(mod_ty mod, const char *filename, PyFutureFeatures *future)
215{
216 struct symtable *st = symtable_new();
217 asdl_seq *seq;
218 int i;
219
220 if (st == NULL)
221 return st;
222 st->st_filename = filename;
223 st->st_future = future;
Neal Norwitz76059362006-08-19 04:52:03 +0000224 if (!GET_IDENTIFIER(top) ||
225 !symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0)) {
Neal Norwitzd12bd012006-07-21 07:59:47 +0000226 PySymtable_Free(st);
227 return NULL;
228 }
229
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000230 st->st_top = st->st_cur;
231 st->st_cur->ste_unoptimized = OPT_TOPLEVEL;
232 /* Any other top-level initialization? */
233 switch (mod->kind) {
234 case Module_kind:
235 seq = mod->v.Module.body;
236 for (i = 0; i < asdl_seq_LEN(seq); i++)
Anthony Baxter019aec62006-04-12 04:00:50 +0000237 if (!symtable_visit_stmt(st,
238 (stmt_ty)asdl_seq_GET(seq, i)))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000239 goto error;
240 break;
241 case Expression_kind:
242 if (!symtable_visit_expr(st, mod->v.Expression.body))
243 goto error;
244 break;
245 case Interactive_kind:
246 seq = mod->v.Interactive.body;
247 for (i = 0; i < asdl_seq_LEN(seq); i++)
Anthony Baxter019aec62006-04-12 04:00:50 +0000248 if (!symtable_visit_stmt(st,
249 (stmt_ty)asdl_seq_GET(seq, i)))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000250 goto error;
251 break;
252 case Suite_kind:
253 PyErr_SetString(PyExc_RuntimeError,
254 "this compiler does not handle Suites");
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000255 goto error;
256 }
257 if (!symtable_exit_block(st, (void *)mod)) {
258 PySymtable_Free(st);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000259 return NULL;
260 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000261 if (symtable_analyze(st))
262 return st;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000263 PySymtable_Free(st);
264 return NULL;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000265 error:
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000266 (void) symtable_exit_block(st, (void *)mod);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000267 PySymtable_Free(st);
268 return NULL;
269}
270
271void
272PySymtable_Free(struct symtable *st)
273{
274 Py_XDECREF(st->st_symbols);
275 Py_XDECREF(st->st_stack);
276 PyMem_Free((void *)st);
277}
278
279PySTEntryObject *
280PySymtable_Lookup(struct symtable *st, void *key)
281{
282 PyObject *k, *v;
283
284 k = PyLong_FromVoidPtr(key);
285 if (k == NULL)
286 return NULL;
287 v = PyDict_GetItem(st->st_symbols, k);
288 if (v) {
289 assert(PySTEntry_Check(v));
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000290 Py_INCREF(v);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000291 }
292 else {
293 PyErr_SetString(PyExc_KeyError,
294 "unknown symbol table entry");
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000295 }
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000296
297 Py_DECREF(k);
298 return (PySTEntryObject *)v;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000299}
300
301int
302PyST_GetScope(PySTEntryObject *ste, PyObject *name)
303{
304 PyObject *v = PyDict_GetItem(ste->ste_symbols, name);
305 if (!v)
306 return 0;
307 assert(PyInt_Check(v));
308 return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
309}
310
311
312/* Analyze raw symbol information to determine scope of each name.
313
314 The next several functions are helpers for PySymtable_Analyze(),
315 which determines whether a name is local, global, or free. In addition,
316 it determines which local variables are cell variables; they provide
317 bindings that are used for free variables in enclosed blocks.
318
319 There are also two kinds of free variables, implicit and explicit. An
320 explicit global is declared with the global statement. An implicit
321 global is a free variable for which the compiler has found no binding
322 in an enclosing function scope. The implicit global is either a global
323 or a builtin. Python's module and class blocks use the xxx_NAME opcodes
324 to handle these names to implement slightly odd semantics. In such a
325 block, the name is treated as global until it is assigned to; then it
326 is treated as a local.
327
328 The symbol table requires two passes to determine the scope of each name.
329 The first pass collects raw facts from the AST: the name is a parameter
330 here, the name is used by not defined here, etc. The second pass analyzes
331 these facts during a pass over the PySTEntryObjects created during pass 1.
332
333 When a function is entered during the second pass, the parent passes
334 the set of all name bindings visible to its children. These bindings
335 are used to determine if the variable is free or an implicit global.
336 After doing the local analysis, it analyzes each of its child blocks
337 using an updated set of name bindings.
338
339 The children update the free variable set. If a local variable is free
340 in a child, the variable is marked as a cell. The current function must
341 provide runtime storage for the variable that may outlive the function's
342 frame. Cell variables are removed from the free set before the analyze
343 function returns to its parent.
344
345 The sets of bound and free variables are implemented as dictionaries
346 mapping strings to None.
347*/
348
349#define SET_SCOPE(DICT, NAME, I) { \
350 PyObject *o = PyInt_FromLong(I); \
351 if (!o) \
352 return 0; \
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000353 if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
354 Py_DECREF(o); \
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000355 return 0; \
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000356 } \
357 Py_DECREF(o); \
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000358}
359
360/* Decide on scope of name, given flags.
361
362 The dicts passed in as arguments are modified as necessary.
363 ste is passed so that flags can be updated.
364*/
365
366static int
Neal Norwitz46b7bda2006-01-08 01:06:06 +0000367analyze_name(PySTEntryObject *ste, PyObject *dict, PyObject *name, long flags,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000368 PyObject *bound, PyObject *local, PyObject *free,
369 PyObject *global)
370{
371 if (flags & DEF_GLOBAL) {
372 if (flags & DEF_PARAM) {
373 PyErr_Format(PyExc_SyntaxError,
374 "name '%s' is local and global",
375 PyString_AS_STRING(name));
376 return 0;
377 }
378 SET_SCOPE(dict, name, GLOBAL_EXPLICIT);
379 if (PyDict_SetItem(global, name, Py_None) < 0)
380 return 0;
381 if (bound && PyDict_GetItem(bound, name)) {
382 if (PyDict_DelItem(bound, name) < 0)
383 return 0;
384 }
385 return 1;
386 }
387 if (flags & DEF_BOUND) {
388 SET_SCOPE(dict, name, LOCAL);
389 if (PyDict_SetItem(local, name, Py_None) < 0)
390 return 0;
391 if (PyDict_GetItem(global, name)) {
392 if (PyDict_DelItem(global, name) < 0)
393 return 0;
394 }
395 return 1;
396 }
397 /* If an enclosing block has a binding for this name, it
398 is a free variable rather than a global variable.
399 Note that having a non-NULL bound implies that the block
400 is nested.
401 */
402 if (bound && PyDict_GetItem(bound, name)) {
403 SET_SCOPE(dict, name, FREE);
404 ste->ste_free = 1;
405 if (PyDict_SetItem(free, name, Py_None) < 0)
406 return 0;
407 return 1;
408 }
409 /* If a parent has a global statement, then call it global
410 explicit? It could also be global implicit.
411 */
412 else if (global && PyDict_GetItem(global, name)) {
413 SET_SCOPE(dict, name, GLOBAL_EXPLICIT);
414 return 1;
415 }
416 else {
417 if (ste->ste_nested)
418 ste->ste_free = 1;
419 SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
420 return 1;
421 }
422 return 0; /* Can't get here */
423}
424
425#undef SET_SCOPE
426
427/* If a name is defined in free and also in locals, then this block
428 provides the binding for the free variable. The name should be
429 marked CELL in this block and removed from the free list.
430
431 Note that the current block's free variables are included in free.
432 That's safe because no name can be free and local in the same scope.
433*/
434
435static int
436analyze_cells(PyObject *scope, PyObject *free)
437{
438 PyObject *name, *v, *w;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000439 int success = 0;
440 Py_ssize_t pos = 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000441
442 w = PyInt_FromLong(CELL);
443 if (!w)
444 return 0;
445 while (PyDict_Next(scope, &pos, &name, &v)) {
Tim Petersd8fe7ab2006-01-08 02:19:07 +0000446 long flags;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000447 assert(PyInt_Check(v));
Tim Petersd8fe7ab2006-01-08 02:19:07 +0000448 flags = PyInt_AS_LONG(v);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000449 if (flags != LOCAL)
450 continue;
451 if (!PyDict_GetItem(free, name))
452 continue;
453 /* Replace LOCAL with CELL for this name, and remove
454 from free. It is safe to replace the value of name
455 in the dict, because it will not cause a resize.
456 */
457 if (PyDict_SetItem(scope, name, w) < 0)
458 goto error;
459 if (!PyDict_DelItem(free, name) < 0)
460 goto error;
461 }
462 success = 1;
463 error:
464 Py_DECREF(w);
465 return success;
466}
467
468/* Check for illegal statements in unoptimized namespaces */
469static int
470check_unoptimized(const PySTEntryObject* ste) {
471 char buf[300];
Armin Rigo31441302005-10-21 12:57:31 +0000472 const char* trailer;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000473
Neil Schemenauer2dfcef52005-10-23 18:50:36 +0000474 if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000475 || !(ste->ste_free || ste->ste_child_free))
476 return 1;
477
Armin Rigo31441302005-10-21 12:57:31 +0000478 trailer = (ste->ste_child_free ?
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000479 "contains a nested function with free variables" :
480 "is a nested function");
481
482 switch (ste->ste_unoptimized) {
483 case OPT_TOPLEVEL: /* exec / import * at top-level is fine */
484 case OPT_EXEC: /* qualified exec is fine */
485 return 1;
486 case OPT_IMPORT_STAR:
487 PyOS_snprintf(buf, sizeof(buf),
488 "import * is not allowed in function '%.100s' "
489 "because it is %s",
490 PyString_AS_STRING(ste->ste_name), trailer);
491 break;
492 case OPT_BARE_EXEC:
493 PyOS_snprintf(buf, sizeof(buf),
494 "unqualified exec is not allowed in function "
495 "'%.100s' it %s",
496 PyString_AS_STRING(ste->ste_name), trailer);
497 break;
498 default:
499 PyOS_snprintf(buf, sizeof(buf),
500 "function '%.100s' uses import * and bare exec, "
501 "which are illegal because it %s",
502 PyString_AS_STRING(ste->ste_name), trailer);
503 break;
504 }
505
506 PyErr_SetString(PyExc_SyntaxError, buf);
507 PyErr_SyntaxLocation(ste->ste_table->st_filename,
508 ste->ste_opt_lineno);
509 return 0;
510}
511
512/* Enter the final scope information into the st_symbols dict.
513 *
514 * All arguments are dicts. Modifies symbols, others are read-only.
515*/
516static int
517update_symbols(PyObject *symbols, PyObject *scope,
Anthony Baxter019aec62006-04-12 04:00:50 +0000518 PyObject *bound, PyObject *free, int classflag)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000519{
520 PyObject *name, *v, *u, *w, *free_value = NULL;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000521 Py_ssize_t pos = 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000522
523 while (PyDict_Next(symbols, &pos, &name, &v)) {
Neal Norwitz46b7bda2006-01-08 01:06:06 +0000524 long i, flags;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000525 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);
Neal Norwitz18b6adf2006-07-23 07:50:36 +0000532 if (!u)
533 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000534 if (PyDict_SetItem(symbols, name, u) < 0) {
535 Py_DECREF(u);
536 return 0;
537 }
538 Py_DECREF(u);
539 }
540
541 free_value = PyInt_FromLong(FREE << SCOPE_OFF);
542 if (!free_value)
543 return 0;
544
545 /* add a free variable when it's only use is for creating a closure */
546 pos = 0;
547 while (PyDict_Next(free, &pos, &name, &v)) {
548 PyObject *o = PyDict_GetItem(symbols, name);
549
550 if (o) {
551 /* It could be a free variable in a method of
552 the class that has the same name as a local
553 or global in the class scope.
554 */
Anthony Baxter019aec62006-04-12 04:00:50 +0000555 if (classflag &&
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000556 PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) {
Neal Norwitz46b7bda2006-01-08 01:06:06 +0000557 long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000558 o = PyInt_FromLong(i);
559 if (!o) {
560 Py_DECREF(free_value);
561 return 0;
562 }
563 if (PyDict_SetItem(symbols, name, o) < 0) {
564 Py_DECREF(o);
565 Py_DECREF(free_value);
566 return 0;
567 }
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000568 Py_DECREF(o);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000569 }
570 /* else it's not free, probably a cell */
571 continue;
572 }
573 if (!PyDict_GetItem(bound, name))
574 continue; /* it's a global */
575
576 if (PyDict_SetItem(symbols, name, free_value) < 0) {
577 Py_DECREF(free_value);
578 return 0;
579 }
580 }
581 Py_DECREF(free_value);
582 return 1;
583}
584
585/* Make final symbol table decisions for block of ste.
586 Arguments:
587 ste -- current symtable entry (input/output)
588 bound -- set of variables bound in enclosing scopes (input)
589 free -- set of free variables in enclosed scopes (output)
590 globals -- set of declared global variables in enclosing scopes (input)
591*/
592
593static int
594analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
595 PyObject *global)
596{
597 PyObject *name, *v, *local = NULL, *scope = NULL, *newbound = NULL;
598 PyObject *newglobal = NULL, *newfree = NULL;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000599 int i, success = 0;
600 Py_ssize_t pos = 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000601
602 local = PyDict_New();
603 if (!local)
604 goto error;
605 scope = PyDict_New();
606 if (!scope)
607 goto error;
608 newglobal = PyDict_New();
609 if (!newglobal)
610 goto error;
611 newfree = PyDict_New();
612 if (!newfree)
613 goto error;
614 newbound = PyDict_New();
615 if (!newbound)
616 goto error;
617
618 if (ste->ste_type == ClassBlock) {
619 /* make a copy of globals before calling analyze_name(),
620 because global statements in the class have no effect
621 on nested functions.
622 */
623 if (PyDict_Update(newglobal, global) < 0)
624 goto error;
625 if (bound)
626 if (PyDict_Update(newbound, bound) < 0)
627 goto error;
628 }
629
630 assert(PySTEntry_Check(ste));
631 assert(PyDict_Check(ste->ste_symbols));
632 while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
Neal Norwitz46b7bda2006-01-08 01:06:06 +0000633 long flags = PyInt_AS_LONG(v);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000634 if (!analyze_name(ste, scope, name, flags, bound, local, free,
635 global))
636 goto error;
637 }
638
639 if (ste->ste_type != ClassBlock) {
640 if (ste->ste_type == FunctionBlock) {
641 if (PyDict_Update(newbound, local) < 0)
642 goto error;
643 }
644 if (bound) {
645 if (PyDict_Update(newbound, bound) < 0)
646 goto error;
647 }
648 if (PyDict_Update(newglobal, global) < 0)
649 goto error;
650 }
651
652 /* Recursively call analyze_block() on each child block */
653 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
654 PyObject *c = PyList_GET_ITEM(ste->ste_children, i);
Armin Rigo31441302005-10-21 12:57:31 +0000655 PySTEntryObject* entry;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000656 assert(c && PySTEntry_Check(c));
Armin Rigo31441302005-10-21 12:57:31 +0000657 entry = (PySTEntryObject*)c;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000658 if (!analyze_block(entry, newbound, newfree, newglobal))
659 goto error;
660 if (entry->ste_free || entry->ste_child_free)
661 ste->ste_child_free = 1;
662 }
663
664 if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree))
665 goto error;
666 if (!update_symbols(ste->ste_symbols, scope, bound, newfree,
667 ste->ste_type == ClassBlock))
668 goto error;
669 if (!check_unoptimized(ste))
670 goto error;
671
672 if (PyDict_Update(free, newfree) < 0)
673 goto error;
674 success = 1;
675 error:
676 Py_XDECREF(local);
677 Py_XDECREF(scope);
678 Py_XDECREF(newbound);
679 Py_XDECREF(newglobal);
680 Py_XDECREF(newfree);
681 if (!success)
682 assert(PyErr_Occurred());
683 return success;
684}
685
686static int
687symtable_analyze(struct symtable *st)
688{
689 PyObject *free, *global;
690 int r;
691
692 free = PyDict_New();
693 if (!free)
694 return 0;
695 global = PyDict_New();
696 if (!global) {
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000697 Py_DECREF(free);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000698 return 0;
699 }
700 r = analyze_block(st->st_top, NULL, free, global);
701 Py_DECREF(free);
702 Py_DECREF(global);
703 return r;
704}
705
706
707static int
Neal Norwitz5d0ad502005-12-19 04:27:42 +0000708symtable_warn(struct symtable *st, char *msg, int lineno)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000709{
710 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename,
Neal Norwitz5d0ad502005-12-19 04:27:42 +0000711 lineno, NULL, NULL) < 0) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000712 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
713 PyErr_SetString(PyExc_SyntaxError, msg);
714 PyErr_SyntaxLocation(st->st_filename,
715 st->st_cur->ste_lineno);
716 }
717 return 0;
718 }
719 return 1;
720}
721
722/* symtable_enter_block() gets a reference via PySTEntry_New().
723 This reference is released when the block is exited, via the DECREF
724 in symtable_exit_block().
725*/
726
727static int
728symtable_exit_block(struct symtable *st, void *ast)
729{
Martin v. Löwisd96ee902006-02-16 14:37:16 +0000730 Py_ssize_t end;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000731
Neal Norwitzb59d08c2006-07-22 16:20:49 +0000732 Py_CLEAR(st->st_cur);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000733 end = PyList_GET_SIZE(st->st_stack) - 1;
734 if (end >= 0) {
735 st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack,
736 end);
Neal Norwitzd12bd012006-07-21 07:59:47 +0000737 if (st->st_cur == NULL)
738 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000739 Py_INCREF(st->st_cur);
740 if (PySequence_DelItem(st->st_stack, end) < 0)
741 return 0;
742 }
743 return 1;
744}
745
746static int
Neal Norwitz62c2fac2005-10-24 00:30:44 +0000747symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000748 void *ast, int lineno)
749{
750 PySTEntryObject *prev = NULL;
751
752 if (st->st_cur) {
753 prev = st->st_cur;
754 if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000755 return 0;
756 }
757 Py_DECREF(st->st_cur);
758 }
759 st->st_cur = PySTEntry_New(st, name, block, ast, lineno);
Neal Norwitzd12bd012006-07-21 07:59:47 +0000760 if (st->st_cur == NULL)
761 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000762 if (name == GET_IDENTIFIER(top))
763 st->st_global = st->st_cur->ste_symbols;
764 if (prev) {
765 if (PyList_Append(prev->ste_children,
766 (PyObject *)st->st_cur) < 0) {
767 return 0;
768 }
769 }
770 return 1;
771}
772
Neal Norwitz46b7bda2006-01-08 01:06:06 +0000773static long
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000774symtable_lookup(struct symtable *st, PyObject *name)
775{
776 PyObject *o;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000777 PyObject *mangled = _Py_Mangle(st->st_private, name);
778 if (!mangled)
779 return 0;
780 o = PyDict_GetItem(st->st_cur->ste_symbols, mangled);
781 Py_DECREF(mangled);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000782 if (!o)
783 return 0;
784 return PyInt_AsLong(o);
785}
786
787static int
788symtable_add_def(struct symtable *st, PyObject *name, int flag)
789{
790 PyObject *o;
791 PyObject *dict;
Neal Norwitz46b7bda2006-01-08 01:06:06 +0000792 long val;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000793 PyObject *mangled = _Py_Mangle(st->st_private, name);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000794
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000795 if (!mangled)
796 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000797 dict = st->st_cur->ste_symbols;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000798 if ((o = PyDict_GetItem(dict, mangled))) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000799 val = PyInt_AS_LONG(o);
800 if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000801 /* Is it better to use 'mangled' or 'name' here? */
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000802 PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,
803 PyString_AsString(name));
804 PyErr_SyntaxLocation(st->st_filename,
805 st->st_cur->ste_lineno);
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000806 goto error;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000807 }
808 val |= flag;
809 } else
810 val = flag;
811 o = PyInt_FromLong(val);
812 if (o == NULL)
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000813 goto error;
814 if (PyDict_SetItem(dict, mangled, o) < 0) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000815 Py_DECREF(o);
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000816 goto error;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000817 }
818 Py_DECREF(o);
819
820 if (flag & DEF_PARAM) {
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000821 if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0)
822 goto error;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000823 } else if (flag & DEF_GLOBAL) {
824 /* XXX need to update DEF_GLOBAL for other flags too;
825 perhaps only DEF_FREE_GLOBAL */
826 val = flag;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000827 if ((o = PyDict_GetItem(st->st_global, mangled))) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000828 val |= PyInt_AS_LONG(o);
829 }
830 o = PyInt_FromLong(val);
831 if (o == NULL)
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000832 goto error;
833 if (PyDict_SetItem(st->st_global, mangled, o) < 0) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000834 Py_DECREF(o);
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000835 goto error;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000836 }
837 Py_DECREF(o);
838 }
Neal Norwitz4737b232005-11-19 23:58:29 +0000839 Py_DECREF(mangled);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000840 return 1;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000841
842error:
843 Py_DECREF(mangled);
844 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000845}
846
847/* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.
848 They use the ASDL name to synthesize the name of the C type and the visit
849 function.
850
851 VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is
852 useful if the first node in the sequence requires special treatment.
853*/
854
855#define VISIT(ST, TYPE, V) \
856 if (!symtable_visit_ ## TYPE((ST), (V))) \
857 return 0;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000858
859#define VISIT_IN_BLOCK(ST, TYPE, V, S) \
860 if (!symtable_visit_ ## TYPE((ST), (V))) { \
861 symtable_exit_block((ST), (S)); \
862 return 0; \
863 }
864
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000865#define VISIT_SEQ(ST, TYPE, SEQ) { \
866 int i; \
867 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
868 for (i = 0; i < asdl_seq_LEN(seq); i++) { \
Anthony Baxter019aec62006-04-12 04:00:50 +0000869 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000870 if (!symtable_visit_ ## TYPE((ST), elt)) \
871 return 0; \
872 } \
873}
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000874
875#define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \
876 int i; \
877 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
878 for (i = 0; i < asdl_seq_LEN(seq); i++) { \
Anthony Baxter019aec62006-04-12 04:00:50 +0000879 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000880 if (!symtable_visit_ ## TYPE((ST), elt)) { \
881 symtable_exit_block((ST), (S)); \
882 return 0; \
883 } \
884 } \
885}
886
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000887#define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
888 int i; \
889 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
890 for (i = (START); i < asdl_seq_LEN(seq); i++) { \
Anthony Baxter019aec62006-04-12 04:00:50 +0000891 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000892 if (!symtable_visit_ ## TYPE((ST), elt)) \
893 return 0; \
894 } \
895}
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000896
897#define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \
898 int i; \
899 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
900 for (i = (START); i < asdl_seq_LEN(seq); i++) { \
Anthony Baxter019aec62006-04-12 04:00:50 +0000901 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000902 if (!symtable_visit_ ## TYPE((ST), elt)) { \
903 symtable_exit_block((ST), (S)); \
904 return 0; \
905 } \
906 } \
907}
908
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000909static int
Guido van Rossumc2e20742006-02-27 22:32:47 +0000910symtable_new_tmpname(struct symtable *st)
911{
912 char tmpname[256];
913 identifier tmp;
914
915 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",
916 ++st->st_cur->ste_tmpname);
917 tmp = PyString_InternFromString(tmpname);
Neal Norwitz6f5ff3f2006-08-12 01:43:40 +0000918 if (!tmp)
919 return 0;
Guido van Rossumc2e20742006-02-27 22:32:47 +0000920 if (!symtable_add_def(st, tmp, DEF_LOCAL))
921 return 0;
922 Py_DECREF(tmp);
923 return 1;
924}
925
926static int
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000927symtable_visit_stmt(struct symtable *st, stmt_ty s)
928{
929 switch (s->kind) {
930 case FunctionDef_kind:
931 if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL))
932 return 0;
933 if (s->v.FunctionDef.args->defaults)
934 VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults);
935 if (s->v.FunctionDef.decorators)
936 VISIT_SEQ(st, expr, s->v.FunctionDef.decorators);
937 if (!symtable_enter_block(st, s->v.FunctionDef.name,
938 FunctionBlock, (void *)s, s->lineno))
939 return 0;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000940 VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s);
941 VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000942 if (!symtable_exit_block(st, s))
943 return 0;
944 break;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000945 case ClassDef_kind: {
946 PyObject *tmp;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000947 if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL))
948 return 0;
949 VISIT_SEQ(st, expr, s->v.ClassDef.bases);
950 if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock,
951 (void *)s, s->lineno))
952 return 0;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000953 tmp = st->st_private;
954 st->st_private = s->v.ClassDef.name;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +0000955 VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s);
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000956 st->st_private = tmp;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000957 if (!symtable_exit_block(st, s))
958 return 0;
959 break;
Neil Schemenauer8b528b22005-10-23 18:37:42 +0000960 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000961 case Return_kind:
Georg Brandlddbaa662006-06-04 21:56:52 +0000962 if (s->v.Return.value) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000963 VISIT(st, expr, s->v.Return.value);
Georg Brandlddbaa662006-06-04 21:56:52 +0000964 st->st_cur->ste_returns_value = 1;
965 if (st->st_cur->ste_generator) {
966 PyErr_SetString(PyExc_SyntaxError,
967 RETURN_VAL_IN_GENERATOR);
968 PyErr_SyntaxLocation(st->st_filename,
969 s->lineno);
970 return 0;
971 }
972 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000973 break;
974 case Delete_kind:
975 VISIT_SEQ(st, expr, s->v.Delete.targets);
976 break;
977 case Assign_kind:
978 VISIT_SEQ(st, expr, s->v.Assign.targets);
979 VISIT(st, expr, s->v.Assign.value);
980 break;
981 case AugAssign_kind:
982 VISIT(st, expr, s->v.AugAssign.target);
983 VISIT(st, expr, s->v.AugAssign.value);
984 break;
985 case Print_kind:
986 if (s->v.Print.dest)
987 VISIT(st, expr, s->v.Print.dest);
988 VISIT_SEQ(st, expr, s->v.Print.values);
989 break;
990 case For_kind:
991 VISIT(st, expr, s->v.For.target);
992 VISIT(st, expr, s->v.For.iter);
993 VISIT_SEQ(st, stmt, s->v.For.body);
994 if (s->v.For.orelse)
995 VISIT_SEQ(st, stmt, s->v.For.orelse);
996 break;
997 case While_kind:
998 VISIT(st, expr, s->v.While.test);
999 VISIT_SEQ(st, stmt, s->v.While.body);
1000 if (s->v.While.orelse)
1001 VISIT_SEQ(st, stmt, s->v.While.orelse);
1002 break;
1003 case If_kind:
1004 /* XXX if 0: and lookup_yield() hacks */
1005 VISIT(st, expr, s->v.If.test);
1006 VISIT_SEQ(st, stmt, s->v.If.body);
1007 if (s->v.If.orelse)
1008 VISIT_SEQ(st, stmt, s->v.If.orelse);
1009 break;
1010 case Raise_kind:
1011 if (s->v.Raise.type) {
1012 VISIT(st, expr, s->v.Raise.type);
1013 if (s->v.Raise.inst) {
1014 VISIT(st, expr, s->v.Raise.inst);
1015 if (s->v.Raise.tback)
1016 VISIT(st, expr, s->v.Raise.tback);
1017 }
1018 }
1019 break;
1020 case TryExcept_kind:
1021 VISIT_SEQ(st, stmt, s->v.TryExcept.body);
1022 VISIT_SEQ(st, stmt, s->v.TryExcept.orelse);
1023 VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers);
1024 break;
1025 case TryFinally_kind:
1026 VISIT_SEQ(st, stmt, s->v.TryFinally.body);
1027 VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody);
1028 break;
1029 case Assert_kind:
1030 VISIT(st, expr, s->v.Assert.test);
1031 if (s->v.Assert.msg)
1032 VISIT(st, expr, s->v.Assert.msg);
1033 break;
1034 case Import_kind:
1035 VISIT_SEQ(st, alias, s->v.Import.names);
1036 /* XXX Don't have the lineno available inside
1037 visit_alias */
1038 if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
1039 st->st_cur->ste_opt_lineno = s->lineno;
1040 break;
1041 case ImportFrom_kind:
1042 VISIT_SEQ(st, alias, s->v.ImportFrom.names);
1043 /* XXX Don't have the lineno available inside
1044 visit_alias */
1045 if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
1046 st->st_cur->ste_opt_lineno = s->lineno;
1047 break;
1048 case Exec_kind:
1049 VISIT(st, expr, s->v.Exec.body);
1050 if (!st->st_cur->ste_opt_lineno)
1051 st->st_cur->ste_opt_lineno = s->lineno;
1052 if (s->v.Exec.globals) {
1053 st->st_cur->ste_unoptimized |= OPT_EXEC;
1054 VISIT(st, expr, s->v.Exec.globals);
1055 if (s->v.Exec.locals)
1056 VISIT(st, expr, s->v.Exec.locals);
1057 } else {
1058 st->st_cur->ste_unoptimized |= OPT_BARE_EXEC;
1059 }
1060 break;
1061 case Global_kind: {
1062 int i;
1063 asdl_seq *seq = s->v.Global.names;
1064 for (i = 0; i < asdl_seq_LEN(seq); i++) {
Anthony Baxter019aec62006-04-12 04:00:50 +00001065 identifier name = (identifier)asdl_seq_GET(seq, i);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001066 char *c_name = PyString_AS_STRING(name);
Neal Norwitz46b7bda2006-01-08 01:06:06 +00001067 long cur = symtable_lookup(st, name);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001068 if (cur < 0)
1069 return 0;
1070 if (cur & (DEF_LOCAL | USE)) {
Neal Norwitzb6fc9df2005-11-13 18:50:34 +00001071 char buf[256];
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001072 if (cur & DEF_LOCAL)
1073 PyOS_snprintf(buf, sizeof(buf),
1074 GLOBAL_AFTER_ASSIGN,
1075 c_name);
1076 else
1077 PyOS_snprintf(buf, sizeof(buf),
1078 GLOBAL_AFTER_USE,
1079 c_name);
Neal Norwitz5d0ad502005-12-19 04:27:42 +00001080 if (!symtable_warn(st, buf, s->lineno))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001081 return 0;
1082 }
1083 if (!symtable_add_def(st, name, DEF_GLOBAL))
1084 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001085 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001086 break;
1087 }
1088 case Expr_kind:
1089 VISIT(st, expr, s->v.Expr.value);
1090 break;
1091 case Pass_kind:
1092 case Break_kind:
1093 case Continue_kind:
1094 /* nothing to do here */
1095 break;
Guido van Rossumc2e20742006-02-27 22:32:47 +00001096 case With_kind:
1097 if (!symtable_new_tmpname(st))
1098 return 0;
1099 VISIT(st, expr, s->v.With.context_expr);
1100 if (s->v.With.optional_vars) {
1101 if (!symtable_new_tmpname(st))
1102 return 0;
1103 VISIT(st, expr, s->v.With.optional_vars);
1104 }
1105 VISIT_SEQ(st, stmt, s->v.With.body);
1106 break;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001107 }
1108 return 1;
1109}
1110
1111static int
1112symtable_visit_expr(struct symtable *st, expr_ty e)
1113{
1114 switch (e->kind) {
1115 case BoolOp_kind:
1116 VISIT_SEQ(st, expr, e->v.BoolOp.values);
1117 break;
1118 case BinOp_kind:
1119 VISIT(st, expr, e->v.BinOp.left);
1120 VISIT(st, expr, e->v.BinOp.right);
1121 break;
1122 case UnaryOp_kind:
1123 VISIT(st, expr, e->v.UnaryOp.operand);
1124 break;
1125 case Lambda_kind: {
Neal Norwitz76059362006-08-19 04:52:03 +00001126 if (!GET_IDENTIFIER(lambda) ||
1127 !symtable_add_def(st, lambda, DEF_LOCAL))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001128 return 0;
1129 if (e->v.Lambda.args->defaults)
1130 VISIT_SEQ(st, expr, e->v.Lambda.args->defaults);
1131 /* XXX how to get line numbers for expressions */
Neal Norwitz76059362006-08-19 04:52:03 +00001132 if (!symtable_enter_block(st, lambda,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001133 FunctionBlock, (void *)e, 0))
1134 return 0;
Neal Norwitzb6fc9df2005-11-13 18:50:34 +00001135 VISIT_IN_BLOCK(st, arguments, e->v.Lambda.args, (void*)e);
1136 VISIT_IN_BLOCK(st, expr, e->v.Lambda.body, (void*)e);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001137 if (!symtable_exit_block(st, (void *)e))
1138 return 0;
1139 break;
1140 }
Thomas Woutersdca3b9c2006-02-27 00:24:13 +00001141 case IfExp_kind:
1142 VISIT(st, expr, e->v.IfExp.test);
1143 VISIT(st, expr, e->v.IfExp.body);
1144 VISIT(st, expr, e->v.IfExp.orelse);
1145 break;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001146 case Dict_kind:
1147 VISIT_SEQ(st, expr, e->v.Dict.keys);
1148 VISIT_SEQ(st, expr, e->v.Dict.values);
1149 break;
Guido van Rossumc2e20742006-02-27 22:32:47 +00001150 case ListComp_kind:
1151 if (!symtable_new_tmpname(st))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001152 return 0;
1153 VISIT(st, expr, e->v.ListComp.elt);
1154 VISIT_SEQ(st, comprehension, e->v.ListComp.generators);
1155 break;
Guido van Rossumc2e20742006-02-27 22:32:47 +00001156 case GeneratorExp_kind:
1157 if (!symtable_visit_genexp(st, e))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001158 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001159 break;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001160 case Yield_kind:
1161 if (e->v.Yield.value)
1162 VISIT(st, expr, e->v.Yield.value);
1163 st->st_cur->ste_generator = 1;
Georg Brandlddbaa662006-06-04 21:56:52 +00001164 if (st->st_cur->ste_returns_value) {
1165 PyErr_SetString(PyExc_SyntaxError,
1166 RETURN_VAL_IN_GENERATOR);
1167 PyErr_SyntaxLocation(st->st_filename,
1168 e->lineno);
1169 return 0;
1170 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001171 break;
1172 case Compare_kind:
1173 VISIT(st, expr, e->v.Compare.left);
1174 VISIT_SEQ(st, expr, e->v.Compare.comparators);
1175 break;
1176 case Call_kind:
1177 VISIT(st, expr, e->v.Call.func);
1178 VISIT_SEQ(st, expr, e->v.Call.args);
1179 VISIT_SEQ(st, keyword, e->v.Call.keywords);
1180 if (e->v.Call.starargs)
1181 VISIT(st, expr, e->v.Call.starargs);
1182 if (e->v.Call.kwargs)
1183 VISIT(st, expr, e->v.Call.kwargs);
1184 break;
1185 case Repr_kind:
1186 VISIT(st, expr, e->v.Repr.value);
1187 break;
1188 case Num_kind:
1189 case Str_kind:
1190 /* Nothing to do here. */
1191 break;
1192 /* The following exprs can be assignment targets. */
1193 case Attribute_kind:
1194 VISIT(st, expr, e->v.Attribute.value);
1195 break;
1196 case Subscript_kind:
1197 VISIT(st, expr, e->v.Subscript.value);
1198 VISIT(st, slice, e->v.Subscript.slice);
1199 break;
1200 case Name_kind:
1201 if (!symtable_add_def(st, e->v.Name.id,
1202 e->v.Name.ctx == Load ? USE : DEF_LOCAL))
1203 return 0;
1204 break;
1205 /* child nodes of List and Tuple will have expr_context set */
1206 case List_kind:
1207 VISIT_SEQ(st, expr, e->v.List.elts);
1208 break;
1209 case Tuple_kind:
1210 VISIT_SEQ(st, expr, e->v.Tuple.elts);
1211 break;
1212 }
1213 return 1;
1214}
1215
1216static int
1217symtable_implicit_arg(struct symtable *st, int pos)
1218{
1219 PyObject *id = PyString_FromFormat(".%d", pos);
1220 if (id == NULL)
1221 return 0;
1222 if (!symtable_add_def(st, id, DEF_PARAM)) {
1223 Py_DECREF(id);
1224 return 0;
1225 }
1226 Py_DECREF(id);
1227 return 1;
1228}
1229
1230static int
1231symtable_visit_params(struct symtable *st, asdl_seq *args, int toplevel)
1232{
Neal Norwitzdaf595f2006-01-07 21:24:54 +00001233 int i;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001234
1235 /* go through all the toplevel arguments first */
1236 for (i = 0; i < asdl_seq_LEN(args); i++) {
Anthony Baxter019aec62006-04-12 04:00:50 +00001237 expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001238 if (arg->kind == Name_kind) {
1239 assert(arg->v.Name.ctx == Param ||
1240 (arg->v.Name.ctx == Store && !toplevel));
1241 if (!symtable_add_def(st, arg->v.Name.id, DEF_PARAM))
1242 return 0;
1243 }
1244 else if (arg->kind == Tuple_kind) {
1245 assert(arg->v.Tuple.ctx == Store);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001246 if (toplevel) {
1247 if (!symtable_implicit_arg(st, i))
1248 return 0;
1249 }
1250 }
1251 else {
Neal Norwitz4737b232005-11-19 23:58:29 +00001252 PyErr_SetString(PyExc_SyntaxError,
1253 "invalid expression in parameter list");
1254 PyErr_SyntaxLocation(st->st_filename,
1255 st->st_cur->ste_lineno);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001256 return 0;
1257 }
1258 }
1259
1260 if (!toplevel) {
1261 if (!symtable_visit_params_nested(st, args))
1262 return 0;
1263 }
1264
1265 return 1;
1266}
1267
1268static int
1269symtable_visit_params_nested(struct symtable *st, asdl_seq *args)
1270{
1271 int i;
1272 for (i = 0; i < asdl_seq_LEN(args); i++) {
Anthony Baxter019aec62006-04-12 04:00:50 +00001273 expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001274 if (arg->kind == Tuple_kind &&
1275 !symtable_visit_params(st, arg->v.Tuple.elts, 0))
1276 return 0;
1277 }
1278
1279 return 1;
1280}
1281
1282static int
1283symtable_visit_arguments(struct symtable *st, arguments_ty a)
1284{
1285 /* skip default arguments inside function block
1286 XXX should ast be different?
1287 */
1288 if (a->args && !symtable_visit_params(st, a->args, 1))
1289 return 0;
1290 if (a->vararg) {
1291 if (!symtable_add_def(st, a->vararg, DEF_PARAM))
1292 return 0;
1293 st->st_cur->ste_varargs = 1;
1294 }
1295 if (a->kwarg) {
1296 if (!symtable_add_def(st, a->kwarg, DEF_PARAM))
1297 return 0;
1298 st->st_cur->ste_varkeywords = 1;
1299 }
1300 if (a->args && !symtable_visit_params_nested(st, a->args))
1301 return 0;
1302 return 1;
1303}
1304
1305
1306static int
1307symtable_visit_excepthandler(struct symtable *st, excepthandler_ty eh)
1308{
1309 if (eh->type)
1310 VISIT(st, expr, eh->type);
1311 if (eh->name)
1312 VISIT(st, expr, eh->name);
1313 VISIT_SEQ(st, stmt, eh->body);
1314 return 1;
1315}
1316
1317
1318static int
1319symtable_visit_alias(struct symtable *st, alias_ty a)
1320{
1321 /* Compute store_name, the name actually bound by the import
1322 operation. It is diferent than a->name when a->name is a
1323 dotted package name (e.g. spam.eggs)
1324 */
1325 PyObject *store_name;
1326 PyObject *name = (a->asname == NULL) ? a->name : a->asname;
1327 const char *base = PyString_AS_STRING(name);
1328 char *dot = strchr(base, '.');
Neal Norwitz6f5ff3f2006-08-12 01:43:40 +00001329 if (dot) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001330 store_name = PyString_FromStringAndSize(base, dot - base);
Neal Norwitz6f5ff3f2006-08-12 01:43:40 +00001331 if (!store_name)
1332 return 0;
1333 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001334 else {
1335 store_name = name;
1336 Py_INCREF(store_name);
1337 }
1338 if (strcmp(PyString_AS_STRING(name), "*")) {
1339 int r = symtable_add_def(st, store_name, DEF_IMPORT);
1340 Py_DECREF(store_name);
1341 return r;
1342 }
1343 else {
1344 if (st->st_cur->ste_type != ModuleBlock) {
Neal Norwitz5d0ad502005-12-19 04:27:42 +00001345 int lineno = st->st_cur->ste_lineno;
1346 if (!symtable_warn(st, IMPORT_STAR_WARNING, lineno)) {
Neal Norwitz3715c3e2005-11-24 22:09:18 +00001347 Py_DECREF(store_name);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001348 return 0;
Neal Norwitz3715c3e2005-11-24 22:09:18 +00001349 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001350 }
1351 st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR;
Neal Norwitz4737b232005-11-19 23:58:29 +00001352 Py_DECREF(store_name);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001353 return 1;
1354 }
1355}
1356
1357
1358static int
1359symtable_visit_comprehension(struct symtable *st, comprehension_ty lc)
1360{
1361 VISIT(st, expr, lc->target);
1362 VISIT(st, expr, lc->iter);
1363 VISIT_SEQ(st, expr, lc->ifs);
1364 return 1;
1365}
1366
1367
1368static int
1369symtable_visit_keyword(struct symtable *st, keyword_ty k)
1370{
1371 VISIT(st, expr, k->value);
1372 return 1;
1373}
1374
1375
1376static int
1377symtable_visit_slice(struct symtable *st, slice_ty s)
1378{
1379 switch (s->kind) {
1380 case Slice_kind:
1381 if (s->v.Slice.lower)
1382 VISIT(st, expr, s->v.Slice.lower)
1383 if (s->v.Slice.upper)
1384 VISIT(st, expr, s->v.Slice.upper)
1385 if (s->v.Slice.step)
1386 VISIT(st, expr, s->v.Slice.step)
1387 break;
1388 case ExtSlice_kind:
1389 VISIT_SEQ(st, slice, s->v.ExtSlice.dims)
1390 break;
1391 case Index_kind:
1392 VISIT(st, expr, s->v.Index.value)
1393 break;
1394 case Ellipsis_kind:
1395 break;
1396 }
1397 return 1;
1398}
1399
1400static int
1401symtable_visit_genexp(struct symtable *st, expr_ty e)
1402{
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001403 comprehension_ty outermost = ((comprehension_ty)
1404 (asdl_seq_GET(e->v.GeneratorExp.generators, 0)));
1405 /* Outermost iterator is evaluated in current scope */
1406 VISIT(st, expr, outermost->iter);
1407 /* Create generator scope for the rest */
Neal Norwitz76059362006-08-19 04:52:03 +00001408 if (!GET_IDENTIFIER(genexpr) ||
1409 !symtable_enter_block(st, genexpr, FunctionBlock, (void *)e, 0)) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001410 return 0;
1411 }
1412 st->st_cur->ste_generator = 1;
1413 /* Outermost iter is received as an argument */
1414 if (!symtable_implicit_arg(st, 0)) {
Neal Norwitzb6fc9df2005-11-13 18:50:34 +00001415 symtable_exit_block(st, (void *)e);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001416 return 0;
1417 }
Neal Norwitzb6fc9df2005-11-13 18:50:34 +00001418 VISIT_IN_BLOCK(st, expr, outermost->target, (void*)e);
1419 VISIT_SEQ_IN_BLOCK(st, expr, outermost->ifs, (void*)e);
1420 VISIT_SEQ_TAIL_IN_BLOCK(st, comprehension,
1421 e->v.GeneratorExp.generators, 1, (void*)e);
1422 VISIT_IN_BLOCK(st, expr, e->v.GeneratorExp.elt, (void*)e);
Neal Norwitz76059362006-08-19 04:52:03 +00001423 return symtable_exit_block(st, (void *)e);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001424}