Symbol Tables. Introduction

Transcription

1 Symbol Tables Introduction A compiler needs to collect and use information about the names appearing in the source program. This information is entered into a data structure called a symbol table. The information collected about a name includes:- 1- The string of characters by which it is denoted. 2- It's type (e.g. integer, real, string). 3- It's form (e.g. a simple variable, a structure). 4- It's location in memory. 5- Other attributes depending on the language. Each entry in the symbol table is a pair of the form (name, information). Each time a name is encountered, the symbol table is searched to see whether that name has been seen previously. If the name is new, it is entered into the table. Information about that name is entered into the table during lexical and syntactic analysis. The information collected in the symbol table is used during several stages in the compilation process. It is used in semantic analysis, that is, in checking that uses of names are consistent with their implicit or explicit declarations. It is also used during code generation. Then we need to know how much and what kind of run-time storage must be allocated to a name. There are also a number of ways in which the symbol table can be used to aid in error detection and correction. For example, we can record whether an error message such as "variable A undefined" has been printed out before, and reject from doing so more than once. Additionally, space in the symbol table

2 can be used for code-optimization purposes, such as to flag temporaries that are used more than once. The primary issues in symbol table design are the format of the entries, the method of access, and the place where they are stored (primary or secondary storage). Block-structured languages impose another problem in that the same identifier can be used to represent distinct names with nested scopes. In compilers for such languages, the symbol table mechanism must make sure that the inner most occurrence of an identifier is always found first, and that names are removed from the active portion of the symbol table when they are no longer active. The Contents of a Symbol Table A simple table is a table with two fields, a name field and information field. We require several capabilities of the symbol table. We need to be able to:- 1- Determine whether a given name is in the table. 2- Add a new name to the table. 3- Access the information, associated with a given name. 4- Add new information for a given name. 5- Delete a name or group of names from the table. In a compiler, the names in the symbol table denote objects of various sorts. There may be separate tables for variable names, labels, procedure names, constants, and other types of names depending on the language. Depending on how lexical analysis is performed, it may be useful to enter keywords into the symbol table initially. If the languages does not reserve keywords (forbid the use of keywords as identifiers), then it is essential that keywords be entered into the symbol table and that they have associated information warning of their possible use as a keyword.

3 Basic Implementation Techniques The first consideration of symbol table implementation is how entering and find, store and search for names. Depending on the number of names we wish to accommodate and the performance we desire, a wide variety of implementations is possible:- Unordered List Use of an unordered list is the simplest possible storage mechanism. The only data structure required is an array, with insertions being performed by adding new names in the next available location. Of course, a linked list may be used to avoid the limitations imposed by a fixed array size. Searching is simple using an iterative searching algorithm, but it is impractically slow except for very small tables (no more than 20 items). Ordered List If a list of names in an array is kept ordered, it may be searched using binary searched, which requires O (log (n)) time for a list of n entries. However, each new entry must be inserted in the array in the appropriate location. Insertion in an ordered array is relatively expensive operation. Thus ordered lists are typically used only when the entire set of names in a table is known in advance. They are useful therefore for tables of reserved words.

4 Binary Search Trees Binary search trees are a data structure designed to combine the size flexibility and insertion efficiency of a linked data structure with the search speed provided by a binary search. On average, entering or searching for a name in a binary search tree built from random inputs requires O(log(n))time. One compelling argument in favor of binary search trees is their simple, widely known implementation. This implementation simplicity and the common perception of good average case performance make binary search trees a popular technique for implementing symbol tables. Hash Tables Hash tables are probably the most common means of implementing symbol tables in production compilers and other system software. With a large enough table, a good hash function, and the appropriate collision-handling technique, Searching can be done in essentially constant time regardless of the number of entries in the table. -Binary Search Trees The algorithm for implementing a simple binary search trees can be found in fig (31). (1) While P nil do (2) If NAME = NAME (P) then /* Name found, take action on success */ (3) Else if NAME< NAME (P) then P:= LEFT (P) /* visit left child */ (4) Else /* NAME (P) < NAME */ P:= RIGHT (P) /* visit right child*/ /* if we fall through the loop, we have failed to find NAME */ Fig (31) binary search tree routine.

5 Of greater concern is how acceptable performance can be ensured using a binary search tree symbol table implementation. If a binary tree is perfectly balanced, the expected search time is O(log(n)). A tree built from random inputs also has an expected search time that is proportional to the log of the number of items in the tree. However, the worst case performance is O (n) and actual occurrence of this worst case is not improbable. For example, entering names in alphabetic order (A, B, C, D, E) results in a tree that is really a liner list, and even random-looking sequences of names can produce the same result (A, E, B, D, C, for example). This problem can be overcome by using an insertion algorithm that keeps the tree approximately balanced. Tree-balancing algorithms are based on the idea of keeping the height of each sub tree rooted at a node within 1 of the height of its sibling subtree. Entire sub tree are moved to different root node when an insertion would unbalanced a node. The fact that rebalancing can be done by moving sub trees rather than individual nodes keep the insertion cost at O(log(n)). One significant advantage of binary trees for implementing symbol tables is that their space overhead, for storing the pointers that define the tree, is directly proportional to the number of nodes in the tree. In contrast, hash tables has have a fixed space overhead, storage for the hash table itself, regardless of the number of names that have been entered. One implementation technique is to use many symbol tables to represent various program, components, rather than using one global table.

6