Block Structure and Symbol Table Organization

Block Structure and Symbol Table Organization

1. First, recall the rules of nested block structure.
   • A scope is a subsection of a program's text typically corresponding to a procedure/function/method/class or a block of statements.
   • An identifier can have only one definition in a given scope.
   • An identifier can be used in a scope as long as it is either defined in the scope or in a containing scope. (Note: Sometimes forward references are not allowed.)
   • Many programming languages allow arbitrary nesting of scopes.
     • Pascal functions/procedures
     • Java inner classes
     • ML let constructs
   • Any use of an identifier refers to the declarations of the identifier occurring in the smallest enclosing scope.
     • Textual nesting of scopes forms a tree.
2. For example, consider the interpretation of identifier references in the program whose skeleton is shown in Figure *. The tree of scopes corresponding to this program text is shown in Figure *.

   class	Program {
   	int W;
   	int X;
   	class A {
   		int W;
   		int Y;
   		int Z;
   		void B() { int X ; . . . }
   		void C() { int X; int Y ; . . . }
   		. . .
   	} // end of A
   	void D() { int Z ; . . . }
   }

   A class definition skeleton illustrating nested declarations
    

   

   Tree of scopes corresponding to Figure *
    

3. The organization of many compiler symbol tables is fairly complex as a result of the need to support the scope rules associated with block structure. The standard approach to explaining symbol table organization, however, adds additional complexity by failing to properly distinguish the role of the scanner in building the symbol table from that of the semantic analysis routines in completing it.

4. Many compiler texts describe the symbol table as a dictionary, typically implemented using a hash table or a search tree.

   • In my (somewhat odd) view, the symbol table is simply a collection of objects/structures in which the attributes of identifiers are stored. The hash table (or whatever else is used) is simply a mechanism that enables the scanner to associate symbol table entries with the character string form of identifiers it processes.

   • Once the program has been transformed into a syntax tree, the semantic analyzer has direct access to symbol table entries through pointers stored in the tree. The hash table used by the scanner is not needed. Thus, it seems wrong to me to talk about the hash table as if it were the symbol table.

5. In the "symbol table is a hash table" view of a compiler, detecting undeclared and multiply declared identifiers becomes a task split between the scanner, parser and symbol table routines.

   • The symbol table interface provides (at least) two functions:

     1. A function find which takes an identifier name and returns either a pointer to the associated symbol table entry or an error return code indicating that the identifier was not found.

     2. A function enter which takes an identifier name and either creates a new entry for the identifier and returns a pointer to it or raises an error if an entry already exists.

   • The syntax analyzer has to somehow tell the scanner whether it is currently processing a declaration or a use. Things get even worse if block structure is involved.

6. A cleaner separation of function can be arranged. Only one search function is needed:

   • A function lookup which takes an identifier, searches for an associated entry (creating a new one if necessary) and returns a pointer to the associated entry.
   The errors that would have been raised by find and enter can instead be recognized during semantic analysis.

   • Each symbol table entry would include a boolean `defined' attribute.

   • When the semantic routines process a declaration, they would check to see if it had already been defined and raise an error if appropriate.

   • Similarly, a use of an undefined identifier would cause an error.
7. The basic idea is to let the syntactic analyzer simply process all references to an identifier by mapping them to a pointer to the symbol table entry for the identifier. The semantic analysis phase then distinguishes declarations from uses by either putting information into or taking information out of the symbol table entry.

Block Structure and Symbol Table Organization