Outline of Class 10: Attribute Grammars, Continued

Held: Monday, February 9, 1998

Administrivia

• At noon today, Randy Smith of Torrent Systems, Inc., a "Parallel Software Infrastructure Company", will give a talk entitled The Programming They Don't Teach You In College.
• Barry McKeown and Charlotte Abe of Towers Perrin will speak on "What Does An Actuary Actually Do" Thursday, February 12, 4:30 p.m. in Science 2413. Refreshments at 4:15.
• Our Convocation speaker, Prof. Doris Schattschneider, will be having lunch with students at Grinnell House on Wednesday, February 25. Please send a note to Prof. Herman if you would like to join her for lunch.
• Will we have a quiz today? I'm still deciding.

An Attribute Grammar for Typing Variables

• What else do we do when working with programs? Often, we need to assign types to variables.
• Since variables don't float freely within a parse tree, what we really want to do is pass around a table that associates a type with each variable (identifier).
• What attributes do we need?
  • This "association table".
  • A type name should be associated with each Type.
  • More as we determine appropriate things.
• Since we haven't written a full grammar for Pascal programs, I'll be introducing new rules as we go.
• We might define a Pascal program as

  Program ::= 'program' id ( IdList ) ; DeclarationList CompoundStatement '.'
  

• The DeclarationList generate the association table and the CompoundStatement will use it.

  Program ::= 'program' id ( IdList ) ; DeclarationList CompoundStatement '.'
    CompoundStatement.types = DeclarationList.types
  

• What does DeclarationList look like? It is a sequence of individual Declarations.

  DeclarationList ::= Declaration ';' DeclarationList
  

• It may also be empty.

  DeclarationList ::= // nothing
  

• What type assignments should we generate in each case? In the first, we want to add the type declaration for the new variable to the other declarations. In the second, we want an empty association.

  DeclarationList_0 ::= Declaration ';' DeclarationList_1
    DeclarationList_0.types =
      Declaration.types union DeclarationList_1.types
  DeclarationList ::= // nothing
    DeclarationList.types = empty_set
  

• What does a declaration look like? The keyword var followed by a list of identifiers and a type.

  Declaration ::= 'var' VarList : Type
  

• How should we use this to compute types for variables? A standard mechanism is to pass the type into the variable list and get type assignments out of the variable list.

  Declaration ::= 'var' VarList : Type
    VarList.type = Type.type
    Declaration.types = VarList.types
  

• How do we generate the type attribute of Type? By the base rules

  Type ::= 'integer'
    Type.type = int
  Type ::= 'real'
    Type.type= real
  

• How do we build the type assignments from the variable list? Similarly to the declaration list. However, we also need to pass the type down into each sublist.

  VarList_0 ::= id ',' VarList_1
    VarList_1.type = VarList_0.type
    VarList_0.types =
      (id: VarList_0.type) union VarList_1.types
  VarList ::= id
    VarList.types = (id: VarList.type)
  

• As we work on examples, you may observe that the computation of attributes passes up and down the tree.