Tree traversals

• Pseudocode for tree traversal

  visit(n) {
      for each child c of node n from left to right do {
          visit(c)
      }
  }

• We start visiting the whole tree by calling visit(root).

• This corresponds to a depth-first search of the tree, starting from root.

Terms

• Attributes: inherited vs synthesized
• postfix notation for unary & binary operations: 95+3-
• prefix, infix notations
• Expressions in infix notation can be ambiguous, but ones in prefix or postfix notation are always unambiguous.

Syntax-directed translation

• A Syntax-directed Definition associates

1. with each grammar symbol, a set of attributes
   
2. with each production, a set of semantic rules for computing the values of the attributes associated with the symbols appearing in the production,
   e.g.

    productions               semantic rules
  
  expr → expr1 + term     expr.t = expr1.t || term.1 || '+'
  expr → expr1 - term     expr.t = expr1.t || term.1 || '-'
  expr → term             expr.t = term.t
  term → 0                term.t = '0'
  term → 1                term.t = '1'
  term → 2                term.t = '2'
  term → 3                term.t = '3'
  term → 4                term.t = '4'
  term → 5                term.t = '5'
  term → 6                term.t = '6'
  term → 7                term.t = '7'
  term → 8                term.t = '8'
  term → 9                term.t = '9'

• Simple Syntax-directed Definitions means the strings representing the translation of the nonterminal at the head of each production is the concatenation of the translations of the nonterminals in the production body, in the same order as in the production, with some optional additional strings interleaved.

Syntax-directed translation scheme

• For grammars with simple syntax-directed definitions, we can implement their translators using a method called Syntax-directed Translation Scheme.

• Example translation scheme:

     expr → expr + term { print('+') }
     expr → expr - term { print('-') }
     expr → term
     term → 0 { print('0') }
     term → 1 { print('1') }
     term → 2 { print('2') }
     term → 3 { print('3') }
     term → 4 { print('4') }
     term → 5 { print('5') }
     term → 6 { print('6') }
     term → 7 { print('7') }
     term → 8 { print('8') }
     term → 9 { print('9') }

• The stuff in braces, called semantic actions are program fragments to be executed while the parse tree is visited.

• Draw the parse tree for a translation scheme of 9-5+2 and demonstrate how it gets translated to 95-2+.