1 #include "Python.h"

     2 #include "Python-ast.h"

     3 #include "code.h"

     4 #include "symtable.h"

     5 #include "structmember.h"

     6 

     7 /* error strings used for warnings */

     8 #define GLOBAL_AFTER_ASSIGN \

     9 "name '%.400s' is assigned to before global declaration"

    10 

    11 #define GLOBAL_AFTER_USE \

    12 "name '%.400s' is used prior to global declaration"

    13 

    14 #define IMPORT_STAR_WARNING "import * only allowed at module level"

    15 

    16 #define RETURN_VAL_IN_GENERATOR \

    17     "'return' with argument inside generator"

    18 

    19 

    20 static PySTEntryObject *

    21 ste_new(struct symtable *st, identifier name, _Py_block_ty block,

    22 	      void *key, int lineno)

    23 {

    24 	PySTEntryObject *ste = NULL;

    25 	PyObject *k;

    26 

    27 	k = PyLong_FromVoidPtr(key);

    28 	if (k == NULL)

    29 		goto fail;

    30 	ste = PyObject_New(PySTEntryObject, &PySTEntry_Type);

    31 	if (ste == NULL)

    32 		goto fail;

    33 	ste->ste_table = st;

    34 	ste->ste_id = k;

    35 	ste->ste_tmpname = 0;

    36 

    37 	ste->ste_name = name;

    38 	Py_INCREF(name);

    39 

    40 	ste->ste_symbols = NULL;

    41 	ste->ste_varnames = NULL;

    42 	ste->ste_children = NULL;

    43 

    44 	ste->ste_symbols = PyDict_New();

    45 	if (ste->ste_symbols == NULL)

    46 	    goto fail;

    47 

    48 	ste->ste_varnames = PyList_New(0);

    49 	if (ste->ste_varnames == NULL)

    50 	    goto fail;

    51 

    52 	ste->ste_children = PyList_New(0);

    53 	if (ste->ste_children == NULL)

    54 	    goto fail;

    55 

    56 	ste->ste_type = block;

    57 	ste->ste_unoptimized = 0;

    58 	ste->ste_nested = 0;

    59 	ste->ste_free = 0;

    60 	ste->ste_varargs = 0;

    61 	ste->ste_varkeywords = 0;

    62 	ste->ste_opt_lineno = 0;

    63 	ste->ste_tmpname = 0;

    64 	ste->ste_lineno = lineno;

    65 

    66 	if (st->st_cur != NULL &&

    67 	    (st->st_cur->ste_nested ||

    68 	     st->st_cur->ste_type == FunctionBlock))

    69 		ste->ste_nested = 1;

    70 	ste->ste_child_free = 0;

    71 	ste->ste_generator = 0;

    72 	ste->ste_returns_value = 0;

    73 

    74 	if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0)

    75 	    goto fail;

    76 	

    77 	return ste;

    78  fail:

    79 	Py_XDECREF(ste);

    80 	return NULL;

    81 }

    82 

    83 static PyObject *

    84 ste_repr(PySTEntryObject *ste)

    85 {

    86 	char buf[256];

    87 

    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);

    93 }

    94 

    95 static void

    96 ste_dealloc(PySTEntryObject *ste)

    97 {

    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);

   104 	PyObject_Del(ste);

   105 }

   106 

   107 #define OFF(x) offsetof(PySTEntryObject, x)

   108 

   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         {"optimized",T_INT,    OFF(ste_unoptimized), READONLY},

   116 	{"nested",   T_INT,    OFF(ste_nested), READONLY},

   117 	{"type",     T_INT,    OFF(ste_type), READONLY},

   118 	{"lineno",   T_INT,    OFF(ste_lineno), READONLY},

   119 	{NULL}

   120 };

   121 

   122 PyTypeObject PySTEntry_Type = {

   123 	PyVarObject_HEAD_INIT(&PyType_Type, 0)

   124 	"symtable entry",

   125 	sizeof(PySTEntryObject),

   126 	0,

   127 	(destructor)ste_dealloc,                /* tp_dealloc */

   128 	0,                                      /* tp_print */

   129 	0,			               /* tp_getattr */

   130 	0,					/* tp_setattr */

   131 	0,			                /* tp_compare */

   132 	(reprfunc)ste_repr,			/* tp_repr */

   133 	0,					/* tp_as_number */

   134 	0,			                /* tp_as_sequence */

   135 	0,					/* tp_as_mapping */

   136 	0,					/* tp_hash */

   137 	0,					/* tp_call */

   138 	0,					/* tp_str */

   139 	PyObject_GenericGetAttr,		/* tp_getattro */

   140 	0,					/* tp_setattro */

   141 	0,					/* tp_as_buffer */

   142 	Py_TPFLAGS_DEFAULT,	                /* tp_flags */

   143  	0,					/* tp_doc */

   144 	0,					/* tp_traverse */

   145 	0,					/* tp_clear */

   146 	0,					/* tp_richcompare */

   147 	0,					/* tp_weaklistoffset */

   148 	0,					/* tp_iter */

   149 	0,					/* tp_iternext */

   150 	0,					/* tp_methods */

   151 	ste_memberlist,				/* tp_members */

   152 	0,					/* tp_getset */

   153 	0,					/* tp_base */

   154 	0,					/* tp_dict */

   155 	0,					/* tp_descr_get */

   156 	0,					/* tp_descr_set */

   157 	0,					/* tp_dictoffset */

   158 	0,					/* tp_init */

   159 	0,					/* tp_alloc */

   160 	0,					/* tp_new */

   161 };

   162 

   163 static int symtable_analyze(struct symtable *st);

   164 static int symtable_warn(struct symtable *st, char *msg, int lineno);

   165 static int symtable_enter_block(struct symtable *st, identifier name, 

   166 				_Py_block_ty block, void *ast, int lineno);

   167 static int symtable_exit_block(struct symtable *st, void *ast);

   168 static int symtable_visit_stmt(struct symtable *st, stmt_ty s);

   169 static int symtable_visit_expr(struct symtable *st, expr_ty s);

   170 static int symtable_visit_genexp(struct symtable *st, expr_ty s);

   171 static int symtable_visit_arguments(struct symtable *st, arguments_ty);

   172 static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty);

   173 static int symtable_visit_alias(struct symtable *st, alias_ty);

   174 static int symtable_visit_comprehension(struct symtable *st, comprehension_ty);

   175 static int symtable_visit_keyword(struct symtable *st, keyword_ty);

   176 static int symtable_visit_slice(struct symtable *st, slice_ty);

   177 static int symtable_visit_params(struct symtable *st, asdl_seq *args, int top);

   178 static int symtable_visit_params_nested(struct symtable *st, asdl_seq *args);

   179 static int symtable_implicit_arg(struct symtable *st, int pos);

   180 

   181 

   182 static identifier top = NULL, lambda = NULL, genexpr = NULL;

   183 

   184 #define GET_IDENTIFIER(VAR) \

   185 	((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))

   186 

   187 #define DUPLICATE_ARGUMENT \

   188 "duplicate argument '%s' in function definition"

   189 

   190 static struct symtable *

   191 symtable_new(void)

   192 {

   193 	struct symtable *st;

   194 

   195 	st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));

   196 	if (st == NULL)

   197 		return NULL;

   198 

   199 	st->st_filename = NULL;

   200 	st->st_symbols = NULL;

   201 

   202 	if ((st->st_stack = PyList_New(0)) == NULL)

   203 		goto fail;

   204 	if ((st->st_symbols = PyDict_New()) == NULL)

   205 		goto fail; 

   206 	st->st_cur = NULL;

   207 	st->st_tmpname = 0;

   208 	st->st_private = NULL;

   209 	return st;

   210  fail:

   211 	PySymtable_Free(st);

   212 	return NULL;

   213 }

   214 

   215 struct symtable *

   216 PySymtable_Build(mod_ty mod, const char *filename, PyFutureFeatures *future)

   217 {

   218 	struct symtable *st = symtable_new();

   219 	asdl_seq *seq;

   220 	int i;

   221 

   222 	if (st == NULL)

   223 		return st;

   224 	st->st_filename = filename;

   225 	st->st_future = future;

   226 	if (!GET_IDENTIFIER(top) ||

   227 	    !symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0)) {

   228 		PySymtable_Free(st);

   229 		return NULL;

   230 	}

   231 

   232 	st->st_top = st->st_cur;

   233 	st->st_cur->ste_unoptimized = OPT_TOPLEVEL;

   234 	/* Any other top-level initialization? */

   235 	switch (mod->kind) {

   236 	case Module_kind:

   237 		seq = mod->v.Module.body;

   238 		for (i = 0; i < asdl_seq_LEN(seq); i++)

   239 			if (!symtable_visit_stmt(st, 

   240                                     (stmt_ty)asdl_seq_GET(seq, i)))

   241 				goto error;

   242 		break;

   243 	case Expression_kind:

   244 		if (!symtable_visit_expr(st, mod->v.Expression.body))

   245 			goto error;

   246 		break;

   247 	case Interactive_kind:

   248 		seq = mod->v.Interactive.body;

   249 		for (i = 0; i < asdl_seq_LEN(seq); i++)

   250 			if (!symtable_visit_stmt(st, 

   251                                     (stmt_ty)asdl_seq_GET(seq, i)))

   252 				goto error;

   253 		break;

   254 	case Suite_kind:

   255 		PyErr_SetString(PyExc_RuntimeError,

   256 				"this compiler does not handle Suites");

   257 		goto error;

   258 	}

   259 	if (!symtable_exit_block(st, (void *)mod)) {

   260 		PySymtable_Free(st);

   261 		return NULL;

   262 	}

   263 	if (symtable_analyze(st))

   264 		return st;

   265 	PySymtable_Free(st);

   266 	return NULL;

   267  error:

   268 	(void) symtable_exit_block(st, (void *)mod);

   269 	PySymtable_Free(st);

   270 	return NULL;

   271 }

   272 

   273 void

   274 PySymtable_Free(struct symtable *st)

   275 {

   276 	Py_XDECREF(st->st_symbols);

   277 	Py_XDECREF(st->st_stack);

   278 	PyMem_Free((void *)st);

   279 }

   280 

   281 PySTEntryObject *

   282 PySymtable_Lookup(struct symtable *st, void *key)

   283 {

   284 	PyObject *k, *v;

   285 

   286 	k = PyLong_FromVoidPtr(key);

   287 	if (k == NULL)

   288 		return NULL;

   289 	v = PyDict_GetItem(st->st_symbols, k);

   290 	if (v) {

   291 		assert(PySTEntry_Check(v));

   292 		Py_INCREF(v);

   293 	}

   294 	else {

   295 		PyErr_SetString(PyExc_KeyError,

   296 				"unknown symbol table entry");

   297 	}

   298 

   299 	Py_DECREF(k);

   300 	return (PySTEntryObject *)v;

   301 }

   302 

   303 int 

   304 PyST_GetScope(PySTEntryObject *ste, PyObject *name)

   305 {

   306 	PyObject *v = PyDict_GetItem(ste->ste_symbols, name);

   307 	if (!v)

   308 		return 0;

   309 	assert(PyInt_Check(v));

   310 	return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;

   311 }

   312 

   313 

   314 /* Analyze raw symbol information to determine scope of each name.

   315 

   316    The next several functions are helpers for PySymtable_Analyze(),

   317    which determines whether a name is local, global, or free.  In addition, 

   318    it determines which local variables are cell variables; they provide

   319    bindings that are used for free variables in enclosed blocks.  

   320 

   321    There are also two kinds of free variables, implicit and explicit.  An 

   322    explicit global is declared with the global statement.  An implicit

   323    global is a free variable for which the compiler has found no binding

   324    in an enclosing function scope.  The implicit global is either a global

   325    or a builtin.  Python's module and class blocks use the xxx_NAME opcodes

   326    to handle these names to implement slightly odd semantics.  In such a

   327    block, the name is treated as global until it is assigned to; then it

   328    is treated as a local.

   329 

   330    The symbol table requires two passes to determine the scope of each name.

   331    The first pass collects raw facts from the AST: the name is a parameter 

   332    here, the name is used by not defined here, etc.  The second pass analyzes

   333    these facts during a pass over the PySTEntryObjects created during pass 1.

   334 

   335    When a function is entered during the second pass, the parent passes

   336    the set of all name bindings visible to its children.  These bindings 

   337    are used to determine if the variable is free or an implicit global.

   338    After doing the local analysis, it analyzes each of its child blocks

   339    using an updated set of name bindings.  

   340 

   341    The children update the free variable set.  If a local variable is free 

   342    in a child, the variable is marked as a cell.  The current function must 

   343    provide runtime storage for the variable that may outlive the function's 

   344    frame.  Cell variables are removed from the free set before the analyze

   345    function returns to its parent.

   346    

   347    The sets of bound and free variables are implemented as dictionaries

   348    mapping strings to None.

   349 */

   350 

   351 #define SET_SCOPE(DICT, NAME, I) { \

   352 	PyObject *o = PyInt_FromLong(I); \

   353 	if (!o) \

   354 		return 0; \

   355 	if (PyDict_SetItem((DICT), (NAME), o) < 0) { \

   356 		Py_DECREF(o); \

   357 		return 0; \

   358 	} \

   359 	Py_DECREF(o); \

   360 }

   361 

   362 /* Decide on scope of name, given flags.

   363 

   364    The dicts passed in as arguments are modified as necessary.

   365    ste is passed so that flags can be updated.

   366 */

   367 

   368 static int 

   369 analyze_name(PySTEntryObject *ste, PyObject *dict, PyObject *name, long flags,

   370 	     PyObject *bound, PyObject *local, PyObject *free, 

   371 	     PyObject *global)

   372 {

   373 	if (flags & DEF_GLOBAL) {

   374 		if (flags & DEF_PARAM) {

   375 			PyErr_Format(PyExc_SyntaxError,

   376 				     "name '%s' is local and global",

   377 				     PyString_AS_STRING(name));

   378 			PyErr_SyntaxLocation(ste->ste_table->st_filename,

   379 					     ste->ste_lineno);

   380 			

   381 			return 0;

   382 		}

   383 		SET_SCOPE(dict, name, GLOBAL_EXPLICIT);

   384 		if (PyDict_SetItem(global, name, Py_None) < 0)

   385 			return 0;

   386 		if (bound && PyDict_GetItem(bound, name)) {

   387 			if (PyDict_DelItem(bound, name) < 0)

   388 				return 0;

   389 		}

   390 		return 1;

   391 	}

   392 	if (flags & DEF_BOUND) {

   393 		SET_SCOPE(dict, name, LOCAL);

   394 		if (PyDict_SetItem(local, name, Py_None) < 0)

   395 			return 0;

   396 		if (PyDict_GetItem(global, name)) {

   397 			if (PyDict_DelItem(global, name) < 0)

   398 				return 0;

   399 		}

   400 		return 1;

   401 	}

   402 	/* If an enclosing block has a binding for this name, it

   403 	   is a free variable rather than a global variable.

   404 	   Note that having a non-NULL bound implies that the block

   405 	   is nested.

   406 	*/

   407 	if (bound && PyDict_GetItem(bound, name)) {

   408 		SET_SCOPE(dict, name, FREE);

   409 		ste->ste_free = 1;

   410 		if (PyDict_SetItem(free, name, Py_None) < 0)

   411 			return 0;

   412 		return 1;

   413 	}

   414 	/* If a parent has a global statement, then call it global

   415 	   explicit?  It could also be global implicit.

   416 	 */

   417 	else if (global && PyDict_GetItem(global, name)) {

   418 		SET_SCOPE(dict, name, GLOBAL_EXPLICIT);

   419 		return 1;

   420 	}

   421 	else {

   422 		if (ste->ste_nested)

   423 			ste->ste_free = 1;

   424 		SET_SCOPE(dict, name, GLOBAL_IMPLICIT);

   425 		return 1;

   426 	}

   427 	return 0; /* Can't get here */

   428 }

   429 

   430 #undef SET_SCOPE

   431 

   432 /* If a name is defined in free and also in locals, then this block

   433    provides the binding for the free variable.  The name should be

   434    marked CELL in this block and removed from the free list.

   435 

   436    Note that the current block's free variables are included in free.

   437    That's safe because no name can be free and local in the same scope.

   438 */

   439 

   440 static int

   441 analyze_cells(PyObject *scope, PyObject *free)

   442 {

   443         PyObject *name, *v, *w;

   444 	int success = 0;

   445 	Py_ssize_t pos = 0;

   446 

   447 	w = PyInt_FromLong(CELL);

   448 	if (!w)

   449 		return 0;

   450 	while (PyDict_Next(scope, &pos, &name, &v)) {

   451 		long flags;

   452 		assert(PyInt_Check(v));

   453 		flags = PyInt_AS_LONG(v);

   454 		if (flags != LOCAL)

   455 			continue;

   456 		if (!PyDict_GetItem(free, name))

   457 			continue;

   458 		/* Replace LOCAL with CELL for this name, and remove

   459 		   from free. It is safe to replace the value of name 

   460 		   in the dict, because it will not cause a resize.

   461 		 */

   462 		if (PyDict_SetItem(scope, name, w) < 0)

   463 			goto error;

   464 		if (!PyDict_DelItem(free, name) < 0)

   465 			goto error;

   466 	}

   467 	success = 1;

   468  error:

   469 	Py_DECREF(w);

   470 	return success;

   471 }

   472 

   473 /* Check for illegal statements in unoptimized namespaces */

   474 static int

   475 check_unoptimized(const PySTEntryObject* ste) {

   476 	char buf[300];

   477 	const char* trailer;

   478 

   479 	if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized

   480 	    || !(ste->ste_free || ste->ste_child_free))

   481 		return 1;

   482 

   483 	trailer = (ste->ste_child_free ? 

   484 		       "contains a nested function with free variables" :

   485 			       "is a nested function");

   486 

   487 	switch (ste->ste_unoptimized) {

   488 	case OPT_TOPLEVEL: /* exec / import * at top-level is fine */

   489 	case OPT_EXEC: /* qualified exec is fine */

   490 		return 1;

   491 	case OPT_IMPORT_STAR:

   492 		PyOS_snprintf(buf, sizeof(buf), 

   493 			      "import * is not allowed in function '%.100s' "

   494 			      "because it is %s",

   495 			      PyString_AS_STRING(ste->ste_name), trailer);

   496 		break;

   497 	case OPT_BARE_EXEC:

   498 		PyOS_snprintf(buf, sizeof(buf),

   499 			      "unqualified exec is not allowed in function "

   500 			      "'%.100s' it %s",

   501 			      PyString_AS_STRING(ste->ste_name), trailer);

   502 		break;

   503 	default:

   504 		PyOS_snprintf(buf, sizeof(buf), 

   505 			      "function '%.100s' uses import * and bare exec, "

   506 			      "which are illegal because it %s",

   507 			      PyString_AS_STRING(ste->ste_name), trailer);

   508 		break;

   509 	}

   510 

   511 	PyErr_SetString(PyExc_SyntaxError, buf);

   512 	PyErr_SyntaxLocation(ste->ste_table->st_filename, 

   513 			     ste->ste_opt_lineno);

   514 	return 0;

   515 }

   516 

   517 /* Enter the final scope information into the st_symbols dict. 

   518  * 

   519  * All arguments are dicts.  Modifies symbols, others are read-only.

   520 */

   521 static int

   522 update_symbols(PyObject *symbols, PyObject *scope, 

   523                PyObject *bound, PyObject *free, int classflag)

   524 {

   525 	PyObject *name, *v, *u, *w, *free_value = NULL;

   526 	Py_ssize_t pos = 0;

   527 

   528 	while (PyDict_Next(symbols, &pos, &name, &v)) {

   529 		long i, flags;

   530 		assert(PyInt_Check(v));

   531 		flags = PyInt_AS_LONG(v);

   532 		w = PyDict_GetItem(scope, name);

   533 		assert(w && PyInt_Check(w));

   534 		i = PyInt_AS_LONG(w);

   535 		flags |= (i << SCOPE_OFF);

   536 		u = PyInt_FromLong(flags);

   537 		if (!u)

   538 			return 0;

   539 		if (PyDict_SetItem(symbols, name, u) < 0) {

   540 			Py_DECREF(u);

   541 			return 0;

   542 		}

   543 		Py_DECREF(u);

   544 	}

   545 

   546         free_value = PyInt_FromLong(FREE << SCOPE_OFF);

   547         if (!free_value)

   548 		return 0;

   549 

   550         /* add a free variable when it's only use is for creating a closure */

   551         pos = 0;

   552 	while (PyDict_Next(free, &pos, &name, &v)) {

   553 		PyObject *o = PyDict_GetItem(symbols, name);

   554 

   555 		if (o) {

   556 			/* It could be a free variable in a method of

   557 			   the class that has the same name as a local

   558 			   or global in the class scope.

   559 			*/

   560 			if  (classflag && 

   561 			     PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) {

   562 				long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS;

   563 				o = PyInt_FromLong(i);

   564 				if (!o) {

   565 					Py_DECREF(free_value);

   566 					return 0;

   567 				}

   568 				if (PyDict_SetItem(symbols, name, o) < 0) {

   569 					Py_DECREF(o);

   570 					Py_DECREF(free_value);

   571 					return 0;

   572 				}

   573 				Py_DECREF(o);

   574 			}

   575 			/* else it's not free, probably a cell */

   576 			continue;

   577 		}

   578 		if (!PyDict_GetItem(bound, name))

   579 			continue;       /* it's a global */

   580 

   581 		if (PyDict_SetItem(symbols, name, free_value) < 0) {

   582 			Py_DECREF(free_value);

   583 			return 0;

   584 		}

   585         }

   586         Py_DECREF(free_value);

   587 	return 1;

   588 }   

   589 

   590 /* Make final symbol table decisions for block of ste.

   591    Arguments:

   592    ste -- current symtable entry (input/output)

   593    bound -- set of variables bound in enclosing scopes (input)

   594    free -- set of free variables in enclosed scopes (output)

   595    globals -- set of declared global variables in enclosing scopes (input)

   596 */

   597 

   598 static int

   599 analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, 

   600 	      PyObject *global)

   601 {

   602 	PyObject *name, *v, *local = NULL, *scope = NULL, *newbound = NULL;

   603 	PyObject *newglobal = NULL, *newfree = NULL;

   604 	int i, success = 0;

   605 	Py_ssize_t pos = 0;

   606 

   607 	local = PyDict_New();

   608 	if (!local)

   609 		goto error;

   610 	scope = PyDict_New();

   611 	if (!scope)

   612 		goto error;

   613 	newglobal = PyDict_New();

   614 	if (!newglobal)

   615 		goto error;

   616 	newfree = PyDict_New();

   617 	if (!newfree)

   618 		goto error;

   619 	newbound = PyDict_New();

   620 	if (!newbound)

   621 		goto error;

   622 

   623 	if (ste->ste_type == ClassBlock) {

   624 		/* make a copy of globals before calling analyze_name(),

   625 		   because global statements in the class have no effect

   626 		   on nested functions.

   627 		*/

   628 		if (PyDict_Update(newglobal, global) < 0)

   629 			goto error;

   630 		if (bound)

   631 			if (PyDict_Update(newbound, bound) < 0)

   632 				goto error;

   633 	}

   634 

   635 	assert(PySTEntry_Check(ste));

   636 	assert(PyDict_Check(ste->ste_symbols));

   637 	while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {

   638 		long flags = PyInt_AS_LONG(v);

   639 		if (!analyze_name(ste, scope, name, flags, bound, local, free,

   640 				  global))

   641 			goto error;

   642 	}

   643 

   644 	if (ste->ste_type != ClassBlock) {

   645 		if (ste->ste_type == FunctionBlock) {

   646 			if (PyDict_Update(newbound, local) < 0)

   647 				goto error;

   648 		}

   649 		if (bound) {

   650 			if (PyDict_Update(newbound, bound) < 0)

   651 				goto error;

   652 		}

   653 		if (PyDict_Update(newglobal, global) < 0)

   654 			goto error;

   655 	}

   656 

   657 	/* Recursively call analyze_block() on each child block */

   658 	for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {

   659 		PyObject *c = PyList_GET_ITEM(ste->ste_children, i);

   660 		PySTEntryObject* entry;

   661 		assert(c && PySTEntry_Check(c));

   662 		entry = (PySTEntryObject*)c;

   663 		if (!analyze_block(entry, newbound, newfree, newglobal))

   664 			goto error;

   665 		if (entry->ste_free || entry->ste_child_free)

   666 			ste->ste_child_free = 1;

   667 	}

   668 

   669 	if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree))

   670 		goto error;

   671 	if (!update_symbols(ste->ste_symbols, scope, bound, newfree,

   672 			    ste->ste_type == ClassBlock))

   673 		goto error;

   674 	if (!check_unoptimized(ste))

   675 		goto error;

   676 

   677 	if (PyDict_Update(free, newfree) < 0)

   678 		goto error;

   679 	success = 1;

   680  error:

   681 	Py_XDECREF(local);

   682 	Py_XDECREF(scope);

   683 	Py_XDECREF(newbound);

   684 	Py_XDECREF(newglobal);

   685 	Py_XDECREF(newfree);

   686 	if (!success)

   687 		assert(PyErr_Occurred());

   688 	return success;

   689 }

   690 

   691 static int

   692 symtable_analyze(struct symtable *st)

   693 {

   694 	PyObject *free, *global;

   695 	int r;

   696 

   697 	free = PyDict_New();

   698 	if (!free)

   699 	    return 0;

   700 	global = PyDict_New();

   701 	if (!global) {

   702 	    Py_DECREF(free);

   703 	    return 0;

   704 	}

   705 	r = analyze_block(st->st_top, NULL, free, global);

   706 	Py_DECREF(free);

   707 	Py_DECREF(global);

   708 	return r;

   709 }

   710 

   711 

   712 static int

   713 symtable_warn(struct symtable *st, char *msg, int lineno)

   714 {

   715 	if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename,

   716 			       lineno, NULL, NULL) < 0)	{

   717 		if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {

   718 			PyErr_SetString(PyExc_SyntaxError, msg);

   719 			PyErr_SyntaxLocation(st->st_filename, 

   720 					     st->st_cur->ste_lineno);

   721 		}

   722 		return 0;

   723 	}

   724 	return 1;

   725 }

   726 

   727 /* symtable_enter_block() gets a reference via ste_new.

   728    This reference is released when the block is exited, via the DECREF

   729    in symtable_exit_block().

   730 */

   731 

   732 static int

   733 symtable_exit_block(struct symtable *st, void *ast)

   734 {

   735 	Py_ssize_t end;

   736 

   737 	Py_CLEAR(st->st_cur);

   738 	end = PyList_GET_SIZE(st->st_stack) - 1;

   739 	if (end >= 0) {

   740 		st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack, 

   741 								end);

   742 		if (st->st_cur == NULL)

   743 			return 0;

   744 		Py_INCREF(st->st_cur);

   745 		if (PySequence_DelItem(st->st_stack, end) < 0)

   746 			return 0;

   747 	}

   748 	return 1;

   749 }

   750 

   751 static int

   752 symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block, 

   753 		     void *ast, int lineno)

   754 {

   755 	PySTEntryObject *prev = NULL;

   756 

   757 	if (st->st_cur) {

   758 		prev = st->st_cur;

   759 		if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) {

   760 			return 0;

   761 		}

   762 		Py_DECREF(st->st_cur);

   763 	}

   764 	st->st_cur = ste_new(st, name, block, ast, lineno);

   765 	if (st->st_cur == NULL)

   766 		return 0;

   767 	if (name == GET_IDENTIFIER(top))

   768 		st->st_global = st->st_cur->ste_symbols;

   769 	if (prev) {

   770 		if (PyList_Append(prev->ste_children, 

   771 				  (PyObject *)st->st_cur) < 0) {

   772 			return 0;

   773 		}

   774 	}

   775 	return 1;

   776 }

   777 

   778 static long

   779 symtable_lookup(struct symtable *st, PyObject *name)

   780 {

   781 	PyObject *o;

   782 	PyObject *mangled = _Py_Mangle(st->st_private, name);

   783 	if (!mangled)

   784 		return 0;

   785 	o = PyDict_GetItem(st->st_cur->ste_symbols, mangled);

   786 	Py_DECREF(mangled);

   787 	if (!o)

   788 		return 0;

   789 	return PyInt_AsLong(o);

   790 }

   791 

   792 static int

   793 symtable_add_def(struct symtable *st, PyObject *name, int flag) 

   794 {

   795 	PyObject *o;

   796 	PyObject *dict;

   797 	long val;

   798 	PyObject *mangled = _Py_Mangle(st->st_private, name);

   799 

   800 	if (!mangled)

   801 		return 0;

   802 	dict = st->st_cur->ste_symbols;

   803 	if ((o = PyDict_GetItem(dict, mangled))) {

   804 	    val = PyInt_AS_LONG(o);

   805 	    if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {

   806 		    /* Is it better to use 'mangled' or 'name' here? */

   807 		    PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,

   808 				 PyString_AsString(name));

   809 		    PyErr_SyntaxLocation(st->st_filename,

   810 				       st->st_cur->ste_lineno);

   811 		    goto error;

   812 	    }

   813 	    val |= flag;

   814 	} else

   815 	    val = flag;

   816 	o = PyInt_FromLong(val);

   817         if (o == NULL)

   818 	    goto error;

   819 	if (PyDict_SetItem(dict, mangled, o) < 0) {

   820 		Py_DECREF(o);

   821 		goto error;

   822 	}

   823 	Py_DECREF(o);

   824 

   825 	if (flag & DEF_PARAM) {

   826 		if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0)

   827 			goto error;

   828 	} else	if (flag & DEF_GLOBAL) {

   829 		/* XXX need to update DEF_GLOBAL for other flags too;

   830 		   perhaps only DEF_FREE_GLOBAL */

   831 		val = flag;

   832 		if ((o = PyDict_GetItem(st->st_global, mangled))) {

   833 			val |= PyInt_AS_LONG(o);

   834 		}

   835 		o = PyInt_FromLong(val);

   836 		if (o == NULL)

   837 			goto error;

   838 		if (PyDict_SetItem(st->st_global, mangled, o) < 0) {

   839 			Py_DECREF(o);

   840 			goto error;

   841 		}

   842 		Py_DECREF(o);

   843 	}

   844 	Py_DECREF(mangled);

   845 	return 1;

   846 

   847 error:

   848 	Py_DECREF(mangled);

   849 	return 0;

   850 }

   851 

   852 /* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.

   853    They use the ASDL name to synthesize the name of the C type and the visit

   854    function. 

   855    

   856    VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is

   857    useful if the first node in the sequence requires special treatment.

   858 */

   859 

   860 #define VISIT(ST, TYPE, V) \

   861 	if (!symtable_visit_ ## TYPE((ST), (V))) \

   862 		return 0; 

   863 

   864 #define VISIT_IN_BLOCK(ST, TYPE, V, S) \

   865 	if (!symtable_visit_ ## TYPE((ST), (V))) { \

   866 		symtable_exit_block((ST), (S)); \

   867 		return 0; \

   868 	}

   869 

   870 #define VISIT_SEQ(ST, TYPE, SEQ) { \

   871 	int i; \

   872 	asdl_seq *seq = (SEQ); /* avoid variable capture */ \

   873 	for (i = 0; i < asdl_seq_LEN(seq); i++) { \

   874 		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \

   875 		if (!symtable_visit_ ## TYPE((ST), elt)) \

   876 			return 0; \

   877 	} \

   878 }

   879 

   880 #define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \

   881 	int i; \

   882 	asdl_seq *seq = (SEQ); /* avoid variable capture */ \

   883 	for (i = 0; i < asdl_seq_LEN(seq); i++) { \

   884 		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \

   885 		if (!symtable_visit_ ## TYPE((ST), elt)) { \

   886 			symtable_exit_block((ST), (S)); \

   887 			return 0; \

   888 		} \

   889 	} \

   890 }

   891 

   892 #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \

   893 	int i; \

   894 	asdl_seq *seq = (SEQ); /* avoid variable capture */ \

   895 	for (i = (START); i < asdl_seq_LEN(seq); i++) { \

   896 		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \

   897 		if (!symtable_visit_ ## TYPE((ST), elt)) \

   898 			return 0; \

   899 	} \

   900 }

   901 

   902 #define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \

   903 	int i; \

   904 	asdl_seq *seq = (SEQ); /* avoid variable capture */ \

   905 	for (i = (START); i < asdl_seq_LEN(seq); i++) { \

   906 		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \

   907 		if (!symtable_visit_ ## TYPE((ST), elt)) { \

   908 			symtable_exit_block((ST), (S)); \

   909 			return 0; \

   910 		} \

   911 	} \

   912 }

   913 

   914 static int

   915 symtable_new_tmpname(struct symtable *st)

   916 {

   917 	char tmpname[256];

   918 	identifier tmp;

   919 

   920 	PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",

   921 		      ++st->st_cur->ste_tmpname);

   922 	tmp = PyString_InternFromString(tmpname);

   923 	if (!tmp)

   924 		return 0;

   925 	if (!symtable_add_def(st, tmp, DEF_LOCAL))

   926 		return 0;

   927 	Py_DECREF(tmp);

   928 	return 1;

   929 }

   930 

   931 static int

   932 symtable_visit_stmt(struct symtable *st, stmt_ty s)

   933 {

   934 	switch (s->kind) {

   935         case FunctionDef_kind:

   936 		if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL))

   937 			return 0;

   938 		if (s->v.FunctionDef.args->defaults)

   939 			VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults);

   940 		if (s->v.FunctionDef.decorator_list)

   941 			VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list);

   942 		if (!symtable_enter_block(st, s->v.FunctionDef.name, 

   943 					  FunctionBlock, (void *)s, s->lineno))

   944 			return 0;

   945 		VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s);

   946 		VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s);

   947 		if (!symtable_exit_block(st, s))

   948 			return 0;

   949 		break;

   950         case ClassDef_kind: {

   951 		PyObject *tmp;

   952 		if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL))

   953 			return 0;

   954 		VISIT_SEQ(st, expr, s->v.ClassDef.bases);

   955 		if (s->v.ClassDef.decorator_list)

   956 			VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list);

   957 		if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock, 

   958 					  (void *)s, s->lineno))

   959 			return 0;

   960 		tmp = st->st_private;

   961 		st->st_private = s->v.ClassDef.name;

   962 		VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s);

   963 		st->st_private = tmp;

   964 		if (!symtable_exit_block(st, s))

   965 			return 0;

   966 		break;

   967 	}

   968         case Return_kind:

   969 		if (s->v.Return.value) {

   970 			VISIT(st, expr, s->v.Return.value);

   971 			st->st_cur->ste_returns_value = 1;

   972 			if (st->st_cur->ste_generator) {

   973 				PyErr_SetString(PyExc_SyntaxError,

   974 					RETURN_VAL_IN_GENERATOR);

   975 			        PyErr_SyntaxLocation(st->st_filename,

   976 				             s->lineno);

   977 				return 0;

   978 			}

   979 		}

   980 		break;

   981         case Delete_kind:

   982 		VISIT_SEQ(st, expr, s->v.Delete.targets);

   983 		break;

   984         case Assign_kind:

   985 		VISIT_SEQ(st, expr, s->v.Assign.targets);

   986 		VISIT(st, expr, s->v.Assign.value);

   987 		break;

   988         case AugAssign_kind:

   989 		VISIT(st, expr, s->v.AugAssign.target);

   990 		VISIT(st, expr, s->v.AugAssign.value);

   991 		break;

   992         case Print_kind:

   993 		if (s->v.Print.dest)

   994 			VISIT(st, expr, s->v.Print.dest);

   995 		VISIT_SEQ(st, expr, s->v.Print.values);

   996 		break;

   997         case For_kind:

   998 		VISIT(st, expr, s->v.For.target);

   999 		VISIT(st, expr, s->v.For.iter);

  1000 		VISIT_SEQ(st, stmt, s->v.For.body);

  1001 		if (s->v.For.orelse)

  1002 			VISIT_SEQ(st, stmt, s->v.For.orelse);

  1003 		break;

  1004         case While_kind:

  1005 		VISIT(st, expr, s->v.While.test);

  1006 		VISIT_SEQ(st, stmt, s->v.While.body);

  1007 		if (s->v.While.orelse)

  1008 			VISIT_SEQ(st, stmt, s->v.While.orelse);

  1009 		break;

  1010         case If_kind:

  1011 		/* XXX if 0: and lookup_yield() hacks */

  1012 		VISIT(st, expr, s->v.If.test);

  1013 		VISIT_SEQ(st, stmt, s->v.If.body);

  1014 		if (s->v.If.orelse)

  1015 			VISIT_SEQ(st, stmt, s->v.If.orelse);

  1016 		break;

  1017         case Raise_kind:

  1018 		if (s->v.Raise.type) {

  1019 			VISIT(st, expr, s->v.Raise.type);

  1020 			if (s->v.Raise.inst) {

  1021 				VISIT(st, expr, s->v.Raise.inst);

  1022 				if (s->v.Raise.tback)

  1023 					VISIT(st, expr, s->v.Raise.tback);

  1024 			}

  1025 		}

  1026 		break;

  1027         case TryExcept_kind:

  1028 		VISIT_SEQ(st, stmt, s->v.TryExcept.body);

  1029 		VISIT_SEQ(st, stmt, s->v.TryExcept.orelse);

  1030 		VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers);

  1031 		break;

  1032         case TryFinally_kind:

  1033 		VISIT_SEQ(st, stmt, s->v.TryFinally.body);

  1034 		VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody);

  1035 		break;

  1036         case Assert_kind:

  1037 		VISIT(st, expr, s->v.Assert.test);

  1038 		if (s->v.Assert.msg)

  1039 			VISIT(st, expr, s->v.Assert.msg);

  1040 		break;

  1041         case Import_kind:

  1042 		VISIT_SEQ(st, alias, s->v.Import.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 ImportFrom_kind:

  1049 		VISIT_SEQ(st, alias, s->v.ImportFrom.names);

  1050 		/* XXX Don't have the lineno available inside

  1051 		   visit_alias */

  1052 		if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)

  1053 			st->st_cur->ste_opt_lineno = s->lineno;

  1054 		break;

  1055         case Exec_kind:

  1056 		VISIT(st, expr, s->v.Exec.body);

  1057 		if (!st->st_cur->ste_opt_lineno)

  1058 			st->st_cur->ste_opt_lineno = s->lineno;

  1059 		if (s->v.Exec.globals) {

  1060 			st->st_cur->ste_unoptimized |= OPT_EXEC;

  1061 			VISIT(st, expr, s->v.Exec.globals);

  1062 			if (s->v.Exec.locals) 

  1063 				VISIT(st, expr, s->v.Exec.locals);

  1064 		} else {

  1065 			st->st_cur->ste_unoptimized |= OPT_BARE_EXEC;

  1066 		}

  1067 		break;

  1068         case Global_kind: {

  1069 		int i;

  1070 		asdl_seq *seq = s->v.Global.names;

  1071 		for (i = 0; i < asdl_seq_LEN(seq); i++) {

  1072 			identifier name = (identifier)asdl_seq_GET(seq, i);

  1073 			char *c_name = PyString_AS_STRING(name);

  1074 			long cur = symtable_lookup(st, name);

  1075 			if (cur < 0)

  1076 				return 0;

  1077 			if (cur & (DEF_LOCAL | USE)) {

  1078 				char buf[256];

  1079 				if (cur & DEF_LOCAL) 

  1080 					PyOS_snprintf(buf, sizeof(buf),

  1081 						      GLOBAL_AFTER_ASSIGN,

  1082 						      c_name);

  1083 				else

  1084 					PyOS_snprintf(buf, sizeof(buf),

  1085 						      GLOBAL_AFTER_USE,

  1086 						      c_name);

  1087 				if (!symtable_warn(st, buf, s->lineno))

  1088                                     return 0;

  1089 			}

  1090 			if (!symtable_add_def(st, name, DEF_GLOBAL))

  1091 				return 0;

  1092 		}

  1093 		break;

  1094 	}

  1095         case Expr_kind:

  1096 		VISIT(st, expr, s->v.Expr.value);

  1097 		break;

  1098         case Pass_kind:

  1099         case Break_kind:

  1100         case Continue_kind:

  1101 		/* nothing to do here */

  1102 		break;

  1103         case With_kind:

  1104 		if (!symtable_new_tmpname(st))

  1105 			return 0;

  1106                 VISIT(st, expr, s->v.With.context_expr);

  1107                 if (s->v.With.optional_vars) {

  1108 			if (!symtable_new_tmpname(st))

  1109 				return 0;

  1110                         VISIT(st, expr, s->v.With.optional_vars);

  1111                 }

  1112                 VISIT_SEQ(st, stmt, s->v.With.body);

  1113                 break;

  1114 	}

  1115 	return 1;

  1116 }

  1117 

  1118 static int 

  1119 symtable_visit_expr(struct symtable *st, expr_ty e)

  1120 {

  1121 	switch (e->kind) {

  1122         case BoolOp_kind:

  1123 		VISIT_SEQ(st, expr, e->v.BoolOp.values);

  1124 		break;

  1125         case BinOp_kind:

  1126 		VISIT(st, expr, e->v.BinOp.left);

  1127 		VISIT(st, expr, e->v.BinOp.right);

  1128 		break;

  1129         case UnaryOp_kind:

  1130 		VISIT(st, expr, e->v.UnaryOp.operand);

  1131 		break;

  1132         case Lambda_kind: {

  1133 		if (!GET_IDENTIFIER(lambda) ||

  1134 		    !symtable_add_def(st, lambda, DEF_LOCAL))

  1135 			return 0;