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.
diff --git a/Include/symtable.h b/Include/symtable.h
index beea9f5..f96ed0c 100644
--- a/Include/symtable.h
+++ b/Include/symtable.h
@@ -14,61 +14,51 @@
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 */