Merged revisions 65715,65724,65726,65732,65736-65739,65775 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r65715 | benjamin.peterson | 2008-08-16 16:04:16 -0500 (Sat, 16 Aug 2008) | 1 line

  add some documentation for symtable
........
  r65724 | benjamin.peterson | 2008-08-16 17:11:33 -0500 (Sat, 16 Aug 2008) | 2 lines

  include filename and line number in SyntaxError
........
  r65726 | georg.brandl | 2008-08-16 17:37:05 -0500 (Sat, 16 Aug 2008) | 2 lines

  Review symtable docs.
........
  r65732 | benjamin.peterson | 2008-08-16 18:29:40 -0500 (Sat, 16 Aug 2008) | 1 line

  PySTEntry's constructor is static; there's no point in a fancy API name
........
  r65736 | benjamin.peterson | 2008-08-16 20:09:17 -0500 (Sat, 16 Aug 2008) | 1 line

  expose PySTEntry.nested so the symtable module will work
........
  r65737 | benjamin.peterson | 2008-08-16 20:17:15 -0500 (Sat, 16 Aug 2008) | 1 line

  a few improvements
........
  r65738 | benjamin.peterson | 2008-08-16 20:27:30 -0500 (Sat, 16 Aug 2008) | 1 line

  fix compile errors
........
  r65739 | benjamin.peterson | 2008-08-16 21:23:43 -0500 (Sat, 16 Aug 2008) | 1 line

  uhh PySTEntry->ste_unoptimized has to be exposed too
........
  r65775 | benjamin.peterson | 2008-08-17 12:13:26 -0500 (Sun, 17 Aug 2008) | 5 lines

  get the symtable module back in working order
  - Fix broken functions
  - Add (hopefully) extensive tests
  - Modernize a little
........

Author: benjaminp

Doc/library/language.rst

@@ -16,6 +16,7 @@ These modules include:
 
    parser.rst
    ast.rst
+   symtable.rst
    symbol.rst
    token.rst
    keyword.rst

Doc/library/symtable.rst

@@ -0,0 +1,187 @@
+:mod:`symtable` --- Access to the compiler's symbol tables
+==========================================================
+
+.. module:: symtable
+   :synopsis: Interface to the compiler's internal symbol tables.
+
+.. moduleauthor:: Jeremy Hylton <jeremy@alum.mit.edu>
+.. sectionauthor:: Benjamin Peterson
+
+
+Symbol tables are generated by the compiler from AST just before bytecode is
+generated.  The symbol table is responsible for calculating the scope of every
+identifier in the code.  :mod:`symtable` provides an interface to examine these
+tables.
+
+
+Generating Symbol Tables
+------------------------
+
+.. function:: symtable(code, filename, compile_type)
+
+   Return the toplevel :class:`SymbolTable` for the Python source *code*.
+   *filename* is the name of the file containing the code.  *compile_type* is
+   like the *mode* argument to :func:`compile`.
+
+
+Examining Symbol Tables
+-----------------------
+
+.. class:: SymbolTable
+
+   A namespace table for a block.  The constructor is not public.
+
+   .. method:: get_type()
+
+      Return the type of the symbol table.  Possible values are ``'class'``,
+      ``'module'``, and ``'function'``.
+
+   .. method:: get_id()
+
+      Return the table's identifier.
+
+   .. method:: get_name()
+
+      Return the table's name.  This is the name of the class if the table is
+      for a class, the name of the function if the table is for a function, or
+      ``'top'`` if the table is global (:meth:`get_type` returns ``'module'``).
+
+   .. method:: get_lineno()
+
+      Return the number of the first line in the block this table represents.
+
+   .. method:: is_optimized()
+
+      Return ``True`` if the locals in this table can be optimized.
+
+   .. method:: is_nested()
+
+      Return ``True`` if the block is a nested class or function.
+
+   .. method:: has_children()
+
+      Return ``True`` if the block has nested namespaces within it.  These can
+      be obtained with :meth:`get_children`.
+
+   .. method:: has_exec()
+
+      Return ``True`` if the block uses ``exec``.
+
+   .. method:: has_import_start()
+
+      Return ``True`` if the block uses a starred from-import.
+
+   .. method:: get_identifiers()
+
+      Return a list of names of symbols in this table.
+
+   .. method:: lookup(name)
+
+      Lookup *name* in the table and return a :class:`Symbol` instance.
+
+   .. method:: get_symbols()
+
+      Return a list of :class:`Symbol` instances for names in the table.
+
+   .. method:: get_children()
+
+      Return a list of the nested symbol tables.
+
+
+.. class:: Function
+
+   A namespace for a function or method.  This class inherits
+   :class:`SymbolTable`.
+
+   .. method:: get_parameters()
+
+      Return a tuple containing names of parameters to this function.
+
+   .. method:: get_locals()
+
+      Return a tuple containing names of locals in this function.
+
+   .. method:: get_globals()
+
+      Return a tuple containing names of globals in this function.
+
+   .. method:: get_frees()
+
+      Return a tuple containing names of free variables in this function.
+
+
+.. class:: Class
+
+   A namespace of a class.  This class inherits :class:`SymbolTable`.
+
+   .. method:: get_methods()
+
+      Return a tuple containing the names of methods declared in the class.
+
+
+.. class:: Symbol
+
+   An entry in a :class:`SymbolTable` corresponding to an identifier in the
+   source.  The constructor is not public.
+
+   .. method:: get_name()
+
+      Return the symbol's name.
+
+   .. method:: is_referenced()
+
+      Return ``True`` if the symbol is used in its block.
+
+   .. method:: is_imported()
+
+      Return ``True`` if the symbol is created from an import statement.
+
+   .. method:: is_parameter()
+
+      Return ``True`` if the symbol is a parameter.
+
+   .. method:: is_global()
+
+      Return ``True`` if the symbol is global.
+
+   .. method:: is_vararg()
+
+      Return ``True`` if the symbol is a star arg (receives varargs).
+
+   .. method:: is_kewordarg()
+
+      Return ``True`` if the symbol is a two-star arg (receives keyword
+      arguments).
+
+   .. method:: is_local()
+
+      Return ``True`` if the symbol is local to its block.
+
+   .. method:: is_free()
+
+      Return ``True`` if the symbol is referenced in its block, but not assigned
+      to.
+
+   .. method:: is_assigned()
+
+      Return ``True`` if the symbol is assigned to in its block.
+
+   .. method:: is_namespace()
+
+      Return ``True`` if name binding introduces new namespace.
+
+      If the name is used as the target of a function or class statement, this
+      will be true.
+
+      Note that a single name can be bound to multiple objects.  If the result
+      is ``True``, the name may also be bound to other objects, like an int or
+      list, that does not introduce a new namespace.
+
+   .. method:: get_namespaces()
+
+      Return a list of namespaces bound to this name.
+
+   .. method:: get_namespace()
+
+      Return the namespace bound to this name.  If more than one namespace is
+      bound, a :exc:`ValueError` is raised.

Include/symtable.h

@@ -36,7 +36,7 @@ typedef struct _symtable_entry {
 	PyObject *ste_children;  /* list of child blocks */
 	_Py_block_ty ste_type;   /* module, class, or function */
 	int ste_unoptimized;     /* false if namespace is optimized */
-	unsigned ste_nested : 1;      /* true if block is nested */
+	int ste_nested;      /* true if block is nested */
 	unsigned ste_free : 1;        /* true if block has free variables */
 	unsigned ste_child_free : 1;  /* true if a child block has free vars,
 				         including free refs to globals */

Lib/symtable.py

@@ -1,10 +1,11 @@
 """Interface to the compiler's internal symbol tables"""
 
 import _symtable
-from _symtable import USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, \
-     DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, \
-     DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, \
-     OPT_IMPORT_STAR
+from _symtable import (USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM,
+     DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE,
+     DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND,
+     OPT_IMPORT_STAR, SCOPE_OFF, SCOPE_MASK, FREE,
+     GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
 
 import weakref
 
@@ -38,15 +39,9 @@ def __call__(self, table, filename):
 
 newSymbolTable = SymbolTableFactory()
 
-def is_free(flags):
-    if (flags & (USE | DEF_FREE)) \
-       and (flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)):
-        return True
-    if flags & DEF_FREE_CLASS:
-        return True
-    return False
 
-class SymbolTable:
+class SymbolTable(object):
+
     def __init__(self, raw_table, filename):
         self._table = raw_table
         self._filename = filename
@@ -59,10 +54,11 @@ def __repr__(self):
             kind = "%s " % self.__class__.__name__
 
         if self._table.name == "global":
-            return "<%sSymbolTable for module %s>" % (kind, self._filename)
+            return "<{0}SymbolTable for module {1}>".format(kind, self._filename)
         else:
-            return "<%sSymbolTable for %s in %s>" % (kind, self._table.name,
-                                                     self._filename)
+            return "<{0}SymbolTable for {1} in {2}>".format(kind,
+                                                            self._table.name,
+                                                            self._filename)
 
     def get_type(self):
         if self._table.type == _symtable.TYPE_MODULE:
@@ -72,7 +68,7 @@ def get_type(self):
         if self._table.type == _symtable.TYPE_CLASS:
             return "class"
         assert self._table.type in (1, 2, 3), \
-               "unexpected type: %s" % self._table.type
+               "unexpected type: {0}".format(self._table.type)
 
     def get_id(self):
         return self._table.id
@@ -124,6 +120,7 @@ def get_children(self):
         return [newSymbolTable(st, self._filename)
                 for st in self._table.children]
 
+
 class Function(SymbolTable):
 
     # Default values for instance variables
@@ -148,15 +145,18 @@ def get_locals(self):
 
     def get_globals(self):
         if self.__globals is None:
-            glob = DEF_GLOBAL | DEF_FREE_GLOBAL
-            self.__globals = self.__idents_matching(lambda x:x & glob)
+            glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
+            test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
+            self.__globals = self.__idents_matching(test)
         return self.__globals
 
     def get_frees(self):
         if self.__frees is None:
+            is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE
             self.__frees = self.__idents_matching(is_free)
         return self.__frees
 
+
 class Class(SymbolTable):
 
     __methods = None
@@ -169,14 +169,17 @@ def get_methods(self):
             self.__methods = tuple(d)
         return self.__methods
 
-class Symbol:
+
+class Symbol(object):
+
     def __init__(self, name, flags, namespaces=None):
         self.__name = name
         self.__flags = flags
+        self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()
         self.__namespaces = namespaces or ()
 
     def __repr__(self):
-        return "<symbol '%s'>" % self.__name
+        return "<symbol {0!r}>".format(self.__name)
 
     def get_name(self):
         return self.__name
@@ -188,8 +191,7 @@ def is_parameter(self):
         return bool(self.__flags & DEF_PARAM)
 
     def is_global(self):
-        return bool((self.__flags & DEF_GLOBAL)
-                    or (self.__flags & DEF_FREE_GLOBAL))
+        return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))
 
     def is_vararg(self):
         return bool(self.__flags & DEF_STAR)
@@ -201,12 +203,7 @@ def is_local(self):
         return bool(self.__flags & DEF_BOUND)
 
     def is_free(self):
-        if (self.__flags & (USE | DEF_FREE)) \
-            and (self.__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)):
-            return True
-        if self.__flags & DEF_FREE_CLASS:
-            return True
-        return False
+        return bool(self.__scope == FREE)
 
     def is_imported(self):
         return bool(self.__flags & DEF_IMPORT)