Homework 4 Solution

Question 1:

The following productions need to be added to the base grammar:

typedef → TYPEDEF TUPLE ID ID DOT
type → ID
varDeclList → varDeclList typedef

The first production permits typedefs to be used with tuple types. The second production permits a declaration that uses a new type name. The third production permits a typedef to occur anywhere that a local variable declaration can occur.

Question 2:

Each symbol table entry should include "kind" (variable, function, tuple,or typedef) information, as well as "type" information. For a typedef, the "type" information is the built-in type or tuple type for which the typedef defines a new name. (Note: It is also possible to let the "type" field be a typedef name, but that complicates type checking. Note also that if the "kind" field is not needed for type checking, then it is OK just to have a flag that says whether or not this is a typedef name.)
To process typedef T xxx:
- If T is an ID (rather than a built-in type or a tuple type), then do a global lookup on T. If it is not found, or its "kind" is not "typedef", then give an error message.
- Do a local lookup on xxx. If found, give an error message (multiply declared name).
- If no errors, add the name xxx to the current symbol table with "kind" = "typedef". If T is a built-in or tuple type, then use that type for the "type" field of the symbol-table entry; otherwise, use the value from the "type" field of T's symbol-table entry.
Processing a variable/function/parameter declaration T xxx is the same as processing typedef T xxx except that when xxx is added to the symbol table, its kind is var/function/parameter (as appropriate) instead of "typedef".
To process a use of name xxx in a statement:
- Do a global lookup of xxx as usual.
- If not found: error (use of undeclared name).
- If found and "kind" = "typedef": error (note: this step could be omitted here, and this kind of error could be handled as part of type checking).
- If no errors, link use to corresponding declaration (as usual).

Here is the symbol table after processing the given declarations:

Name	Kind	Type
MonthDayYear	tuple	-
date	typedef	tuple MonthDayYear
today	variable	tuple MonthDayYear
dollars	typedef	integer
salary	variable	integer
moreDollars	typedef	integer
md	variable	integer
d	variable	integer

Question 3:

If the name-analysis phase handles uses of names as described above, then no changes need to be made to the type-checking phase.

If the name-analysis phase processes a use of a name in a statement by simply doing a global lookup and linking the use to the corresponding symbol-table entry, then the type-checking phase must ensure that a typedef name is not used where a variable, parameter, or function name is expected. That simply involves checking the "kind" field of the symbol-table entry linked to each ID node, and giving an error message if the kind is "typedef".