[Python-checkins] CVS: python/dist/src/Include symtable.h,2.2,2.3

[Jeremy Hylton]

Update of /cvsroot/python/python/dist/src/Include
In directory usw-pr-cvs1:/tmp/cvs-serv13672/Include

Modified Files:
	symtable.h 
Log Message:
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.



Index: symtable.h
===================================================================
RCS file: /cvsroot/python/python/dist/src/Include/symtable.h,v
retrieving revision 2.2
retrieving revision 2.3
diff -C2 -r2.2 -r2.3
*** symtable.h	2001/02/02 20:01:09	2.2
--- symtable.h	2001/02/09 22:22:18	2.3
***************
*** 15,59 ****
     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 {
  	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 */
          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 */
--- 15,28 ----
     e.g. DEF_PARAM indicates that a variable is a parameter to a
     function. 
  */
  
+ struct _symtable_entry;
+ 
  struct symtable {
  	int st_pass;             /* pass == 1 or 2 */
  	char *st_filename;       /* name of file being compiled */
! 	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_global;     /* borrowed ref to MODULE in st_symbols */
  	int st_nscopes;          /* number of scopes */
***************
*** 61,67 ****
  	char *st_private;        /* name of current class or NULL */
  	int st_tmpname;          /* temporary name counter */
- 	int st_nested;           /* bool (true if nested scope) */
  };
  
  DL_IMPORT(struct symtable *) PyNode_CompileSymtable(struct _node *, char *);
  DL_IMPORT(void) PySymtable_Free(struct symtable *);
--- 30,58 ----
  	char *st_private;        /* name of current class or NULL */
  	int st_tmpname;          /* temporary name counter */
  };
  
+ 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 *);
***************
*** 69,73 ****
  
  #define TOP "global"
- #define NOOPT ".noopt"
  
  /* Flags for def-use information */
--- 60,63 ----