Syntax-directed Translation

• We looked at attaching attributes to grammar symbols in chapter 2
  • A syntax directed definition specifies the values of attributes by associating semantic rules with productions.
  • E → E₁ + T is associated with E.code = E₁.code || T.code || '+'
  • This is from the infix-to-postfix translator
  • And we expect each non-terminal to have associated code.
  • So the new code for E is formed by concatenating the code for E₁, T and '+'
• We also discussed attaching semantic actions
  • E → E₁ + T {print '+'}
  • {} enclose the action.
  • Position determines order in which the actions are executed.
  • You are seeing this in your current homework.
• He notes that syntax directed definitions are more readable, and used for specification
• But translation schemes are more useful in implementations.
• Syntax-Directed translation
  • Build a parse or syntax tree
  • Perform a traversal of the tree computing the values at each node.
  • But sometimes we don't need the tree.
  • "L-attribute translations"
    • Left to right
    • Can be done during parsing
    • Encompass nearly all translations that can be done during parsing
  • "S-attributed translations"
    • Synthesized
    • Work with bottom up parsing.

5.1

• A SDD - syntax directed definition
  • A context free grammar
  • attributes - associated with grammar symbols
  • and rule - associated with productions.
  • X.a, X is a symbol and a is an associated attribute
  • attributes may be anything, numbers, strings, types, table references
  • or even long sequences of code.
• Inherited and Synthesized Attributes
  • A synthesized attribute for a non terminal A at a parse tree node N
    • Defined by a semantic rule associated with the production at N.
    • The production is in the form A → α
    • Only defined in terms of attribute values at the children of N and at N.
  • A inherited attribute for a non-terminal B at a parse-tree node N
    • Is defined by a semantic rule associated with the production at the parent of N.
    • In the form A → αBβ
    • Only defined in terms of attribute values of N's parent, N or N's siblings.
  • Inherited attributes are not defined by N's children.
  • Synthesized values can be defined in terms of inherited values
  • Terminals have synthesized attributes, but not inherited attributes
    • Attributes for terminals are supplied by the lexical analyzer
    • There are no semantic rules in the SDD for computing the values of an attribute for a terminal.
  • An example:

    • L → E n
      E → E1 + T | T
      T → T1 * F | F
      F → (E) | digit
      	    

    • Note the termination character n.
    • Each non-terminal has a single synthesized value val.
    • digit has a synthesized attribute lexval, an integer returned by the lexical analyzer.

    • Production	Semantic Rule
      L → E n	L.val = E.val
      E → E1 + T	E.val = E1.val + T.val
      E → T	E.val = T.val
      T → T1 * F	T.val = T1.val * F.val
      T → F	T.val = F.val
      F → (E)	F.val = E.val
      F → digit	F.val = digit.lexval

    • Rule 1, L → E n produces the final numerical value of the entire expression
    • Rule 2, E → E₁ + T
      • computes the attribute val for E
      • At any parse tree node that matches this rule
      • val is computed by adding the values of the children nodes.
  • A SDD that only involves synthesized attributes is called S-attributed
  • That is the case for the above SDD.
  • For now, they will not allow semantic rules to have side effects
    • Printing
    • Interacting with the symbol table.
  • This restriction will eventually be removed.
  • An S-attributed SDD can be implemented in conjunction with an LR parser.
• Evaluating an SDD at the nodes of a parse tree
• He states that it is helpful to build parse trees while we are working through these examples
• Even if you don't need to build a parse tree in the end.
• If a parse tree contains values of attributes is called an annotated parse tree
• The order of evaluation of the parse tree depends on the type of attributes involved.
• If they are all synthetic, then any bottom up order will do.
  • post-order.
• If their are inherited and synthesized attributes there is no guarantee that any order will do.
• Consider

  • A → B        A.s = B.i
                      B.i = A.s + 1
    	    

• Finding if a set of rules is circular can not be done with a polynomial time algorithm ever, even if P = NP.
• There is a subset of SDDs in which the evaluation can be guaranteed.
• He gives an example of parsing 3*5+4n with the previous grammar and rules.
  • look at the tree on page 308
• Inherited attributes are useful when the structure of the parse tree does not match the abstract syntax of the source code.
• He provides an example with Inherited attributes

  • Production	Semantic Rule
    T → FT'	T'.inh = F.val
    	T'.val = T'.syn
    T' → *FT'1	T'1.inh = T'.inh × F.val
    	T'.syn = T'1.syn
    T' → ε	T'.syn = T'.inh
    F → digit	T.val = digit.lexval

  • Synthesized attributes T.val, F.val digit.lexval, T'.syn
  • Inherited attributes F'.inh
  • Based on the idea that the left operand of * is inherited.
    • T' → * F T'₁ inherits the left operand of * in the production body.
    • Given x * y * z
    • The root of the subtree for *y * z inherits x
    • The root of the subtree for *z inherits x*y
    • Look at the tree on page 309
      • The left most values are easy, they come from the lexer or from rule 3.
      • The Top T' gets the 3 as an inherited value from above.
      • The F and digit in this sub tree are as before.
      • The Second T' again inherits the value
      • And passes it up the tree.
    • Try 2*5*3