Evaluation of Orders for SDD's.

• Dependency Graphs allow us to calculate the order of evaluation for attributes instances in a parse tree.
• Are represented as an arc from a source for a value to the destination of a value.
  • For each node in a parse tree, the dependency graph has a node fro each attribute associated with the node.
  • For a production A → X: A.syn = f(X.c), where syn is a synthesized attribute, there is an arc from X.c to A.syn
    • At every node N labeled A where production p is applied, create an edge to attribute b at N, from the attribute c at the child of N corresponding to this instance of the symbol X in the body of the production.
  • For a production A→ αBβ: B.inh = X.a add an arc from the definition of X.a to B.inh.
    For each node N labeled B that corresponds to an occurrence of this b in the body of a production, create an edge to attribute c at N from attribute a at node M that corresponds to this occurrence of X. M is either a parent or sibling of N.
  • Consider E → E₁ + T: E.val = E₁.val + T.val
  • The parse tree:
    • 
    • Note, edges are drawn as dashed lines.
    • 
  • Consider 3*5 with the grammar on page 308
    • Draw the parse tree.
    • 
    • Add in the dependency graph.
    • 
• Ordering the Evaluation of Attributes
  • Cycle Detection in a graph: Perform a DFS
  • If a back edge exists, then there is a cycle
  • A back edge is an edge from a node to one of it's ancestors.
  • Discovery time of a node is after discovery time of the node's ancestor but before the close time of the node's ancestor.
  • Ordering of a the evaluation of attributes:
  • Perform a topological sort.

    TOPOLOGICAL_SORT(G=(V,E))
    
     call DFS(G) to compute f[v] for each vertex v ∈ V
     as each vertex is finished, insert it into the front of a linked list
     Return the linked list.
    
    	

  • IF there are no cycles, there must be at least one topological sort.
    • There must be at least one vertex in the graph that has no incoming edges.
    • If this was not the case, then there would be a cycle.
    • Find this node and make it the first in the sort, remove it and repeat.
• S-Attributed Definitions
  • (Only involve synthesized attributes)
  • A post-order traversal will work

    POST_ORDER(T)
    
     for c in T.children() do
         POST_ORDER(c)
     T.evaluate
    
    	

  • This assumes T.children() returns the children in order (left to right)
  • Since bottom up parsing will construct the tree in this order, evaluation is simple.
• L-Attributed Definitions.
  • A SDD is L-Attributed if all attributes are
    1. Synthesized
    2. Inhered but for A → X₁X2X₃ ... X_n, X_i.inh is computed only
       1. Inherited attributes associated with A.
       2. Either inherited or synthesized attributes associated with X₁ ... X_i-1
    3. Inherited from X_i, but only if this creates no cycles in the dependency graph.
  • In other words, all arcs in the dependency graph go from left to right.
  • Look at the rules on page 308.
    • T → FT': T'.inh = F.val, T.val = T'.syn
    • 
    • T' → *FT'₁: T'₁.inh = T'.inh × F.val, T'.syn = T'₁.syn
    • 
    • T' → ε
    • 
  • Consider

    A → B C      A.s = B.b
                      B.inh = f(C.c, A.s)
    	

  • 
  • The location of C means it is not L-Attributed
  • B.i means is is not S-Attributed.
• Semantic Rules with controlled Side Effect
  • Controlling Side effect
    • Permit incidental side effects that do not constrain attribute evaluation.
      • Permit side effects when attribute evaluation on any topological sort of the dependency graph produces a "correct " translation
      • Print
    • Constrain the allowable evaluation orders to that the same translation is produced for any allowable order
      • "Add" implicit edges to the dependency graph.
  • Consider L → E n: print(E.val)
  • Add an arc from E.val to print
• Example:

  D → T L        L.inh = T.type
  T → int        T.type = int
  T → float      T.type = float
  L → L1, id     L1.inh = L.inh
                 addType(id.entry, L.inh)
  L → id         addType(id.entry, L.inh) 
  	 

  • This represents a declaration of a variables.
  • Derive the parse tree for float a,b,c
  • 
  • Add the dependency graph
  • 
• do 5.2.2.a
• Do 5.2.3 a-d
• Do 5.2.4