Class 18: Semantic Actions

Held Friday, March 2, 2001

Summary

Assignments

• Project, Phase 2: Parser.

Overview

Attributes

• As you know, the parse tree is only one step on the way to compilation of a source text.
• What do we do next? Typically, we add attributes to the nodes of the parse tree.
• An attribute is a computed value associated with a node in the parse tree.
• What can attributes be computed from? Typically values of ``neighboring'' nodes (children, parent, siblings).
• How are they computed? Using a rule that is associated with a production in the language.
• Grammars augmented with rules are called attribute grammars.
• What kinds of attributes can be computed? A wide variety. We typically compute
  • symbol tables to use in type checking and correctness analysis;
  • values of expressions (typically in building interpreters);
  • abstract syntax trees that correspond to the structure underlying the parse tree. Such ASTs help eliminate problems of parse trees introduced by changes to the syntax required by parsing techniques;
  • some compilers use attributes to compute code for the parse tree.
• How are the rules applied? In the abstract, one can say that a topological sort of the dependencies is done and the rules are applied in order.
  • If you don't know what a topological sort is, don't worry.
• In practice, a rule is applied when the corresponding production is ``executed'' by the parser.
  • This limits the types of rules that are allowed.
  • In an LR parser, attributes must by synthesized: computed from the attributes of the children or earlier symbols.
  • In an LL parser, attributes can also be inherited: computed from attributes of the children or left siblings.
• In practice, rules can also do things other than compute values. This means that the behavior of the parser depends on the order in which the rules are applied. This is a bad thing, and you should not write rules that have such side effects.

An Attribute Grammar for Evaluating Expressions

• Let's consider how we might compute a value and type type of arithmetic expressions as they are parsed.
• What attributes will we need?
  • A value attribute (associated with expressions, terms, factors, and numbers) is clearly necessary.
  • In order to compute the values of variables (identifiers), we'll need to look them up in a symbol table. We'll leave that as a subject for future research.
• Some rules are fairly trivial, as they only involve copying attributes

  Exp ::= Term
    Exp.value = Term.value
    Exp.type = Term.type
  Term ::= Factor
    Term.value = Factor.value
    Term.type = Factor.type
  Factor ::= OPEN Exp CLOSE
    Factor.value = Exp.value
    Facator.type = Exp.type
  

• For the base case of numbers, we simply get the value of the number (we assume that this is computed during the lexical analysis phase)

  Factor ::= NUMBER
    Factor.value = NUMBER.value
    Factor.type = NUMBER.type
  

• If all that we have for tokens is the ``string representation'', we will need to convert it

  Factor ::= NUMBER
    Factor.value = stringToNumber(NUMBER.string)
  

• Similarly, for the base case of identifiers, we simply get the type of the identifier. (We may not get a value.)

  Factor ::= ID
    Factor.type = lookupType(symbols,ID)
  

• Addition and subtraction are also fairly easy

  Exp_0 ::= Exp_1 + Term
    Exp_0.value = Exp_1.value + Term.value
    Exp_0.type = mostGeneral(Exp1.type,Term,type)
  Exp_0 ::= Exp_1 - Term
    Exp_0.value = Exp_1.value - Term.value
    Exp_0.type = mostGeneral(Exp1.type,Term,type)
  

• If we use yacc or bison and pay attention to only values, the rules will look like

  exp ::= exp PLUS exp    { $$ = $1 + $3; }
  exp ::= exp MINUS exp   { $$ = $1 - $3; }
  

• If we treat MULTIPLY and DIVIDE as tokens, we might write something like

  MulOp ::= MULTIPLY
    MulOp.fun = (lambda (x y) (* x y))
  MulOp ::= DIVIDE
    MulOp.fun = (lambda (x y) (/ x y))
  

• We can then add a rule for terms

  Term_0 ::= Term_1 MulOp Factor
    Term_0.value = MulOp.fun(Term_1.value, Factor.value)
    Term_0.type = mostGeneral(Term1.type,Factor,type)
  

Symbol Tables

• We may find that symbol tables behave differently.
• (Sorry no time for detailed notes.)