Relax the rules for using 'from ... import *' and exec in the presence

of nested functions.  Either is allowed in a function if it contains
no defs or lambdas or the defs and lambdas it contains have no free
variables.  If a function is itself nested and has free variables,
either is illegal.

Revise the symtable to use a PySymtableEntryObject, which holds all
the revelent information for a scope, rather than using a bunch of
st_cur_XXX pointers in the symtable struct.  The changes simplify the
internal management of the current symtable scope and of the stack.

Added new C source file: Python/symtable.c.  (Does the Windows build
process need to be updated?)

As part of these changes, the initial _symtable module interface
introduced in 2.1a2 is replaced.  A dictionary of
PySymtableEntryObjects are returned.

Include/symtable.h

@@ -14,61 +14,51 @@ extern "C" {
    block; the integer values are used to store several flags,
    e.g. DEF_PARAM indicates that a variable is a parameter to a
    function. 
-
-   The slots st_cur_XXX pointers always refer to the current code
-   block.  The st_cur slot is the symbol dictionary.  The st_cur_id
-   slot is the id is the key in st_symbols.  The st_cur_name slot is
-   the name of the current scope. The st_cur_type slot is one of
-   TYPE_FUNCTION, TYPE_CLASS, or TYPE_MODULE.  The st_cur_children is
-   a list of the ids of the current node's children.
-
-   The st_symbols slot is a dictionary that maps code block ids to
-   symbol dictionaries.  The keys are generated by a counter that is
-   incremented each time a new code block is found.  The counter is
-   identifies a specific scope, because both passes walk the parse
-   tree in the same order.
-
-   The st_varnames slot is a dictionary that maps code block ids to
-   parameter lists.  The st_global slot always refers to the symbol 
-   dictionary for the module.
-
-   The st_children slot is a dictionary that maps ids to a list
-   containing the ids of its children.
-
-   If st_keep is true then the namespace info pushed on st_stack will
-   also be stored in st_scopes.  This is useful if the symbol table is
-   being passed to something other than the compiler.
 */
 
+struct _symtable_entry;
+
 struct symtable {
 	int st_pass;             /* pass == 1 or 2 */
-	int st_keep;             /* true if symtable will be returned */
 	char *st_filename;       /* name of file being compiled */
-	PyObject *st_symbols;    /* dictionary of symbol tables */
-	PyObject *st_varnames;   /* dictionary of parameter lists */
+	struct _symtable_entry *st_cur; /* current symbol table entry */
+	PyObject *st_symbols;    /* dictionary of symbol table entries */
         PyObject *st_stack;      /* stack of namespace info */
-	PyObject *st_scopes;     /* dictionary of namespace info */
-	PyObject *st_children;   /* dictionary (id=[ids]) */
-	PyObject *st_cur;        /* borrowed ref to dict in st_symbols */
-	PyObject *st_cur_name;   /* string, name of current scope */
-	PyObject *st_cur_id;     /* int id of current code block */
-	PyObject *st_cur_children; /* ref to current children list */
-	int st_cur_type;         /* type of current scope */ 
-	int st_cur_lineno;       /* line number where current scope begins */
 	PyObject *st_global;     /* borrowed ref to MODULE in st_symbols */
 	int st_nscopes;          /* number of scopes */
 	int st_errors;           /* number of errors */
 	char *st_private;        /* name of current class or NULL */
 	int st_tmpname;          /* temporary name counter */
-	int st_nested;           /* bool (true if nested scope) */
 };
 
+typedef struct _symtable_entry {
+	PyObject_HEAD
+	PyObject *ste_id;        /* int: key in st_symbols) */
+	PyObject *ste_symbols;   /* dict: name to flags) */
+	PyObject *ste_name;      /* string: name of scope */
+	PyObject *ste_varnames;  /* list of variable names */
+	PyObject *ste_children;  /* list of child ids */
+	int ste_type;            /* module, class, or function */
+	int ste_lineno;          /* first line of scope */
+	int ste_optimized;       /* true if namespace is optimized */
+	int ste_nested;          /* true if scope is nested */
+	int ste_child_free;      /* true if a child scope has free variables,
+				    including free refs to globals */
+	struct symtable *ste_table;
+} PySymtableEntryObject;
+
+extern DL_IMPORT(PyTypeObject) PySymtableEntry_Type;
+
+#define PySymtableEntry_Check(op) ((op)->ob_type == &PySymtableEntry_Type)
+
+extern DL_IMPORT(PyObject *) PySymtableEntry_New(struct symtable *,
+						 char *, int, int);
+
 DL_IMPORT(struct symtable *) PyNode_CompileSymtable(struct _node *, char *);
 DL_IMPORT(void) PySymtable_Free(struct symtable *);
 
 
 #define TOP "global"
-#define NOOPT ".noopt"
 
 /* Flags for def-use information */
 

Makefile.pre.in

@@ -228,6 +228,7 @@ PYTHON_OBJS=	\
 		Python/pystate.o \
 		Python/pythonrun.o \
 		Python/structmember.o \
+		Python/symtable.o \
 		Python/sysmodule.o \
 		Python/traceback.o \
 		Python/getopt.o \

Modules/symtablemodule.c

@@ -31,7 +31,7 @@ symtable_symtable(PyObject *self, PyObject *args)
 	st = Py_SymtableString(str, filename, start);
 	if (st == NULL)
 		return NULL;
-	t = Py_BuildValue("OO", st->st_symbols, st->st_scopes);
+	t = Py_BuildValue("O", st->st_symbols);
 	PySymtable_Free(st);
 	return t;
 }

Python/symtable.c

+#include "Python.h"
+#include "symtable.h"
+#include "graminit.h"
+#include "structmember.h"
+
+PyObject *
+PySymtableEntry_New(struct symtable *st, char *name, int type, int lineno)
+{
+	PySymtableEntryObject *ste = NULL;
+	PyObject *k, *v;
+
+	k = PyInt_FromLong(st->st_nscopes++);
+	if (k == NULL)
+		goto fail;
+	v = PyDict_GetItem(st->st_symbols, k);
+	if (v) /* XXX could check that name, type, lineno match */
+	    return v;
+	
+	ste = (PySymtableEntryObject *)PyObject_New(PySymtableEntryObject,
+						    &PySymtableEntry_Type);
+	ste->ste_table = st;
+	ste->ste_id = k;
+
+	v = PyString_FromString(name);
+	if (v == NULL)
+		goto fail;
+	ste->ste_name = v;
+	
+	v = PyDict_New();
+	if (v == NULL)
+	    goto fail;
+	ste->ste_symbols = v;
+
+	v = PyList_New(0);
+	if (v == NULL)
+	    goto fail;
+	ste->ste_varnames = v;
+
+	v = PyList_New(0);
+	if (v == NULL)
+	    goto fail;
+	ste->ste_children = v;
+
+	ste->ste_optimized = 1;
+	ste->ste_lineno = lineno;
+	switch (type) {
+	case funcdef:
+	case lambdef:
+		ste->ste_type = TYPE_FUNCTION;
+		break;
+	case classdef:
+		ste->ste_type = TYPE_CLASS;
+		break;
+	case single_input:
+	case eval_input:
+	case file_input:
+		ste->ste_type = TYPE_MODULE;
+		break;
+	}
+
+	if (st->st_cur == NULL)
+		ste->ste_nested = 0;
+	else if (st->st_cur->ste_nested 
+		 || st->st_cur->ste_type == TYPE_FUNCTION)
+		ste->ste_nested = 1;
+	else
+		ste->ste_nested = 0;
+	ste->ste_child_free = 0;
+
+	if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0)
+	    goto fail;
+
+	return (PyObject *)ste;
+ fail:
+	Py_XDECREF(ste);
+	return NULL;
+}
+
+static PyObject *
+ste_repr(PySymtableEntryObject *ste)
+{
+	char buf[256];
+
+	sprintf(buf, "<symtable entry %.100s(%ld), line %d>",
+		PyString_AS_STRING(ste->ste_name),
+		PyInt_AS_LONG(ste->ste_id),
+		ste->ste_lineno);
+	return PyString_FromString(buf);
+}
+
+static void
+ste_dealloc(PySymtableEntryObject *ste)
+{
+	ste->ste_table = NULL;
+	Py_XDECREF(ste->ste_id);
+	Py_XDECREF(ste->ste_name);
+	Py_XDECREF(ste->ste_symbols);
+	Py_XDECREF(ste->ste_varnames);
+	Py_XDECREF(ste->ste_children);
+	PyObject_Del(ste);
+}
+
+#define OFF(x) offsetof(PySymtableEntryObject, x)
+
+static struct memberlist ste_memberlist[] = {
+	{"id",       T_OBJECT, OFF(ste_id), READONLY},
+	{"name",     T_OBJECT, OFF(ste_name), READONLY},
+	{"symbols",  T_OBJECT, OFF(ste_symbols), READONLY},
+	{"varnames", T_OBJECT, OFF(ste_varnames), READONLY},
+	{"children", T_OBJECT, OFF(ste_children), READONLY},
+	{"type",     T_INT,    OFF(ste_type), READONLY},
+	{"lineno",   T_INT,    OFF(ste_lineno), READONLY},
+	{"optimized",T_INT,    OFF(ste_optimized), READONLY},
+	{"nested",   T_INT,    OFF(ste_nested), READONLY},
+	{NULL}
+};
+
+static PyObject *
+ste_getattr(PySymtableEntryObject *ste, char *name)
+{
+	return PyMember_Get((char *)ste, ste_memberlist, name);
+}
+
+PyTypeObject PySymtableEntry_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,
+	"symtable entry",
+	sizeof(PySymtableEntryObject),
+	0,
+	(destructor)ste_dealloc,                /* tp_dealloc */
+	0,                                      /* tp_print */
+	(getattrfunc)ste_getattr,               /* tp_getattr */
+	0,					/* tp_setattr */
+	0,			                /* tp_compare */
+	(reprfunc)ste_repr,			/* tp_repr */
+	0,					/* tp_as_number */
+	0,			                /* tp_as_sequence */
+	0,					/* tp_as_mapping */
+	0,					/* tp_hash */
+	0,					/* tp_call */
+	0,					/* tp_str */
+	0,					/* tp_getattro */
+	0,					/* tp_setattro */
+	0,					/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+ 	0,					/* tp_doc */
+};