ICS 142 Klefstad

Syntax-Directed Translation Outline Syntax-Directed Translation (SDT) Examples of Semantic Actions Syntax-Directed Definitions (SDD) Two Varieties of Attributes Attribute Evaluation Intermediate Forms for SDT Two example intermediate representations Syntax Trees for Expressions S-Attribute Definitions L-Attribute Definitions Conversion of L-attribute to S-attribute Recursive Evaluators

Syntax-Directed Translation (SDT)

translation of a language guided by a context-free grammar
certain attributes are attached to each grammar symbol
values for attributes are computed via semantic actions
attributes needed for translation are defined as record structures with fields for items like name, type, offset, etc.

Examples of Semantic Actions

store and/or retrieve info in the symbol table
construct entity descriptors for various language constructs
perform consistency checks, EG type checking, parameter checking
issue error messages
build syntax trees
generate intermediate or actual target code

Syntax-Directed Definitions (SDD)

a generalized context-free grammar that attaches attributes to each grammar symbol
attribute values are defined by the semantic actions associated with each production, EG page 281 of text
annotated parse tree
- a parse tree containing attributes and their values at each node (see page 282)
attribute grammar
- an SDD where functions in semantic actions have no side effects

Two Varieties of Attributes

inherited attributes
- computed from attributes of parent or siblings
synthesized attributes
- computed from attributes of children
EG consider a production X --> ALPHA B BETA
- X.a is considered synthesized if
```
X.a = f (attributes of ALPHA, BETA, and/or B)
```
- B.a is considered inherited if
```
B.a = f (attributes of ALPHA, BETA, and/or X)
```

Attribute Evaluation

unrestricted syntax-directed definition
- no restrictions on attribute dependency
- perform topological sort on attribute dependency graph
- evaluate in order of dependency
- costly to evaluate
S-attribute definition
- restricted to synthesized attributes only
- attributes may be evaluated bottom-up
- can be evaluated very efficiently
L-attribute definition
- allows both synthesized and some inherited attributes
- restricted to inherit attributes from the Left siblings
- attributes may be evaluated by depth-first, left-to-right
it is possible to rewrite any L-attribute SDD to be S-attributed

Intermediate Forms for SDT

allows translation to be decoupled from parsing
alleviates some problems
- sometimes grammars do not reflect natural program structure
- information may not be available when needed
- optimizations may depend on context

Two example intermediate representations

postfix is a common intermediate representation for expressions
- E --> E
- E1 op E2 --> E1' E2' op
- (E) --> E' EG a+(b-x)*c-d --> abx-c*+d-
abstract syntax tree
- a condensed form of parse tree
- abstract away unnecessary terminals and non-terminals
- EG
```
if-else-stmt
 /  |  \ 
C   S1   S2
```

Syntax Trees for Expressions

representation
- each node is a record
  - one field identifies the operator
  - the others contain pointers to operand trees
useful operations
- make_node (operator, left_operand, right_operand)
- make_leaf (IDENTIFIER, symbol_table_entry)
- make_leaf (NUMBER, value)

EG a-4+c

make_node ('+', make_node ('-', make_leaf (IDENTIFIER, entry_for_a)
            make_leaf (NUMBER, 4)),
            make_leaf (IDENTIFIER, entry_for_c));

DAGs for expressions
- Directed Acyclic Graphs
- common subexpressions share expression trees
- EG (a + b) * (a + b)

S-Attribute Definitions

S stands for synthesized attributes
all semantic actions follow RHS of a grammar rule
- values of synthesized attributes are stored on a stack
- Bison uses a value stack that parallels the LR parser's state stack
- when a reduction is made
  - attributes of children are on the stack
  - compute values for synthesized attributes
  - pop children's attributes and push synthesized attributes

EG constructing a symbol for a subprogram spec

subprogram_spec:
  Procedure Identifier formal_parameter_list_OPTION
  { $$ = new_procedure_symbol($2, $3); } ;

L-Attribute Definitions

L stands for Left, because attributes may be inherited from the Left
semantic actions may be placed throughout RHS of a grammar rule
a practical use of inherited attributes
- stmt --> DECLARE decl_list BEGIN stmt_list END ';'
- statements in stmt_list must reference declarations made in decl_list

EG translates infix to postfix

E --> T R
R --> ADDOP T {print(ADDOP.lexeme);} R
  | EPSILON
T --> NUMBER {print(NUMBER.value);}

Conversion of L-attribute to S-attribute

any L-attribute definition may be converted to an equivalent S-attribute definition
replace grammar rules containing L-actions, such as,
```
A --> B {print("hi");} C
```
with two rules
- introduce a new non-terminal which goes to EPSILON followed by the L-action
- replace the L-action in the old rule with the new non-terminal

A --> B M C
M --> EPSILON {print("hi");}

Recursive Evaluators

a multi-pass approach to evaluating attributes
build a parse tree in pass 1
make a pass over the parse tree to evaluate the attributes
allows more control over order of evaluation and passing attributes
necessary for certain complicated languages
EG
- distinguishing between array refs and function calls in Ada
- performing type checking between public and private sections in C++ class declarations