Attribute grammars Attribute grammars

Formal framework based on grammar and parse tree Aho, Sethi, & Ullman describe syntax-directed definitions. These are
just attribute grammars by another name.
Idea: “attribute” the tree
Attribute grammar
– can add attributes (fields) to each node
– generalization of context-free grammar
– specify equations to define values
– each grammar symbol has an associated set of attributes
– both inherited and synthesized attributes
– augment grammar with rules defining attribute values
– high-level specification, independent of evaluation scheme
Attribute grammars are very general. Can be used for • Note: translation scheme has evaluation order
– infix to postfix translation of arithmetic expressions (ASU p.34) Dependencies among attributes
– type checking (context-sensitive analysis) – values are computed from constants & other attributes
– construction of intermediate representation (AST) – synthesized attribute - value computed from children
– desk calculator (interpreter) – inherited attribute - value computed from siblings & parent
– code generation (compiler) – key notion: induced dependency graph

Attribute grammars Example attribute grammar

Note: A grammar to evaluate signed binary numbers
• terminals can be associated with values returned by the
scanner. These input values are associated with a
synthesized attribute.
• distinguished non-terminal (start symbol) cannot have
inherited attributes.
• synthesized attributes of a grammar symbol can depend
on inherited attributes of the same symbol.
• semantic rules are defined for each production separately
• semantic rules associated with a rule A ::= α have to
specify the values for all
– synthesized attributes for A (root)
– inherited attributes for grammar symbols in α (children)

1
Example Attribute grammars
The attribute dependency graph
• nodes represent attributes
• edges represent the flow of values
• graph is specific to parse tree
LIST0 pos
• size is related to parse tree's size
val • can be built alongside parse tree
The dependency graph must be acyclic
LIST1 BIT
pos pos
Evaluation order
val val
• Topological sort of the dependency graph to order
attributes
Note: • using this order, evaluate the rules
• semantic rules define a partial dependency graph
• structure can be used to derive characteristics of generated This order depends on both the grammar and the
total dependency graphs input string

Example attribute grammar Example grammar dependency graph

Example Parse tree for -101
0
NUM val
NUM val

pos
pos SIGN neg LIST0 val
SIGN neg LIST val
pos pos
pos pos
LIST1 val BIT2 val
LIST BIT • val and neg are synthesized attributes
val val
• pos is an inherited attribute
pos pos
LIST2 val
BIT1 val
pos pos LIST0.pos is an inherited attribute with
LIST val
BIT val an empty dependency set.
pos
BIT0 val
pos
BIT val

- 1 0 1
- 1 0 1

2
Attribute grammars Example grammar final result
A topological order for the example
0
1. SIGN.neg NUM val :-5

2. LIST0 .pos
pos: 0
3. LIST1 .pos SIGN neg : T LIST0 val: 5
4. LIST2 .pos Evaluate in this order
5. BIT0 .pos pos: 1 pos: 0
LIST1 BIT2
6. BIT1 .pos Yields NUM.val: -5 val: 4 val: 1

7. BIT2 .pos
pos: 2 pos: 1
8. BIT0 .val LIST2 val: 4 BIT1 val: 0
9. LIST2 .val
10. BIT1 .val
pos: 2
11. LIST1 .val BIT0 val: 4 The evaluation
12. BIT2 .val process is also called
13. LIST0 .val decorating the
- 1 0 1
14. NUM.val parse tree

Classification of evaluation methods Example: AST construction

(ASU's taxonomy) Abstract Syntax Tree (AST): Intermediate program representation.
Parse-tree methods (dynamic)
Syntax directed translation: Uses parser as a driver to compute
1. build the parse tree
context-sensitive information, to build intermediate representations, and/or
2. build the dependency graph
to generate code.
3. topological sort the graph
4. evaluate it (cyclic graph fails)
Rule-based methods (treewalk)
1. analyze rules at compiler-generation time
2. determine a static ordering at that time
3. evaluate nodes in that order at compile time
Ad-hoc methods (passes, dataflow)
1. ignore the parse tree and grammar +
2. choose a convenient order and use it
(forward-backward passes, alternating passes) + c
Problems
• circularity a+b+c
• best evaluation strategy is grammar dependent a b

3
Example: AST construction Example: AST construction
Semantic rules can be implemented as operations on the
stack.

• for each grammar symbol, entry in stack stores attribute values

• synthesized attributes can be evaluated during reduction step
• at time of evaluation, all dependent attribute values are somewhere in the
stack; in fact, position is exactly known since handle is unique. top is the stack pointer

Attribute types Evaluation Methods

Synthesized attributes • The most general method is to construct an ordering
derive value from constants and children from the parse tree itself
– S-attributed grammar: only synthesized attributes • Define a graph as follows:
– S-attributed grammars can be evaluated in one bottom-up pass – For each attribute E.a to be computed add a node in the graph.
– useful in many contexts (calculator, AS&U 281) – If E.a depends on E1.a1 ,...,En.an then add directed edges from
– S-attributed grammar is good match for LR parsing Ei .a i to E.a for 1 ≤ i ≤ n
• A topological sort of the graph is any ordering n 1 ,...,n k
Inherited attributes of the nodes such that edges of the graph are all from left-
derive value from constants, siblings, and parent to-right in the ordering; i.e., a node appears in the
– L-attributed grammar: Each inherited attribute of ordering after all of the nodes it depends on.
Xj , 1 ≤ j ≤ n, on the right side of A ::= X1X2 , . . . X n depends only on – A topological sort is a legal evaluation order of the
• attributes of X 1 , . . . X j-1, and attributes
• inherited attributes of A – Note: for the topological sort to make sense, there can be no cycles
– L-attributed grammars can be evaluated in a single DFS top- in the graph. Cyclically defined attributes are not legal.
down pass
S-attributed ⊂ L-attributed

4
Real World Evaluating S-attributed Definitions
• In practice, computing all of the attribute
dependencies from the tree is rarely, if ever, done • Bottom-up evaluation
• Instead, syntax-directed definitions are used • Keep a stack S parallel to parsing stack
where the attribute evaluation order can be – consider production A →XY with rule A.val = X.val + Y.val
determined from the actions – When reducing by A →XY the top of the S stack has X.val and
Y.val
– compute A.val
• The most important special case is S-attributed – pop X.val and Y.val from S, push A.val
grammars (grammars with only synthesized • Symmetric with reduce action on the parse stack
attributes)
– These attributes can be evaluated bottom-up during
• Tools like Bison/Flex support S-attributed definitions
parsing

DFS (depth first search) Translation schemes

• Semantic actions are inserted within the RHS of
procedure DFS(n: node) rules
begin • Actions are " dummy" terminals on RHS
for each child m of n, from left to right do begin
evaluate inherited attributes of m
• Evaluation order of semantic actions
DFS(m) based on DFS walk
end
evaluate synthesized attributes of n
End
This is the method used in your
compiler

5
Example translation schemes L-attributed grammars
AST construction example:
Restrictions for translation scheme to make sure that
attribute grammar is L-attributed:

1. An inherited attribute for a symbol on the RHS

of a rule must be computed in an action before
that symbol.
2. An action cannot refer to an attribute of a symbol
to the right of the action.
3. A synthesized attribute of the LHS can only be
computed after all attributes it refers to are
computed; place the action at the end of RHS
Are these translation
schemes correct?
of rule.

Example translation schemes Example: Simple compiler

Let's try again Assume a simple load/store architecture (RISC). The generated code
uses a new register for each computed value.

Evaluation of signed binary numbers:

– || is a concatenation operator
– addr(id) returns memory address of identifier id
What does the translation scheme look like?

6
 BU evaluation of inherited attributes Attribute grammars
Method to implement L-attributed definitions for
bottom-up parsing: Advantages
• Can handle all L-attributed definitions • clean formalism
corresponding to LL(1) grammars and some LR(1) • automatic generation of evaluator
(not all!). • high-level specification
• Basic idea:
1. Transform grammar so all embedded actions of
translation scheme occur at the end of RHS of some Disadvantages
production (i.e. at a reduction). This will make sure that
attribute values will be in the stack.
• evaluation strategy determines efficiency
2. Introduce copy rules if necessary to locate attribute values • increased space requirements
in the stack. • results distributed over tree
3. Note: modifications to input attribute grammar must not
change its LR-ness.