Attribute Grammars Prabhaker Mateti ACK Assembled from many

Attribute Grammars Prabhaker Mateti ACK: Assembled from many sources

About Attribute Grammars • Attribute grammars (AGs) add semantic info on parse tree nodes • Used for semantic checking and other compile -time analyses, e. g. , type checking in a compiler • Used for translation, e. g. , parse tree to assembly code • A traversal of the parse tree and the computation of information. 2

Attribute Grammars: Definition • • An attribute grammar G is a CFG (S, N, T, P) plus X 0 is one of X 1. . . Xn Xi from N U T S(X 0) = f(I(X 0), A(X 1), . . . , A(Xn)) synthesized attributes I(Xi) = g(A(X 0), . . . , A(Xn)) inherited attributes • A(X) = S(X) ∪ I(X) • S(X) and I(X) are disjoint • Each rule has a set of predicates/ conditions to check for attribute consistency: P( A(X 0), A(X 1), A(X 2), …, A(Xn) ) • G = (S, N, T, P), S start symbol, N non-terminals, T terminals, P productions 3

Example-1: Binary Numbers 1. N : : = 0 2. N : : = 1 3. N : : = N 0 4. N : : = N 1 Recall • CFGs do not provide semantics. • CGGs provide only syntax, that too without context-sensitive details 1. N. val : = 0 2. N. val : = 1 3. N. val : = 2*N. rhs. val 4. N. val : = 2*N. rhs. val+1 • N. val is an attribute associated with node N of the parse tree • N. rhs is N of the rhs • Synthesized Attributes 4

Example-2: Type Checking 1. E : : = n 2. E : : = x 3. E : : = E 1 + E 2 4. E : : = E 1 * E 2 • Semantics to add – n is an int, x is a real. – op + returns an int if both the operands are int, otherwise a real. CS 7100(PM) 1. E. type : = int 2. E. type : = real 3. if E 1. type = E 2. type then E. type : = E 1. type else E. type : = real fi • Item 3 derived version of the semantics • Static semantics 5

Example-3: Assignment Arithmetic • stm : : = var : = exp | stm; stm • exp : : = var + var | var • var : : = A | B | C • exp : : = var 1 + var 2 –subscripts added • exp. actual-type : = var 1. actual-type • synthesized actual-type for var and exp • lookup (var. string) a helper function; gives the actualtype of A, B, C CS 7100(PM) • expected-type – from parent in the parse tree –inherited expected-type for exp • Predicates: – var 1. actual-type == var 2. actual-type – expected-type == exp. actual-type • var. actual-type : = lookup (var. string) 6

Inherited Attributes Example • Declaration and Use { int i, j, k; i : = i + j; } • assign : : = var : = exp – env: environment – var. env : = assign. env – exp. env : = assign. env CS 7100(PM) 7

Information Flow inherited computed available synthesized . . . CS 7100(PM) . . . 8

Attribute Value Computation • If all attributes were inherited, the tree could be decorated in topdown order. Inherited Attributes pass information – down the parse tree, or – from left siblings to the right siblings • If all attributes were synthesized, the tree could be decorated in bottom-up order. Synthesized Attributes pass information up the parse tree. • In many cases, both kinds of attributes are used, and it is some combination of top-down and bottom-up that must be used. • Initially, there are intrinsic attributes on the leaves. • If a condition in a tree evaluates to false, an error occurs. CS 7100(PM) 9

Example-2 done in Prolog 1. 2. 3. 4. type(n, int). type(x, real). type(+(E, F), T) : - type(E, T), type(F, T). type(+(E, F), real) : - type(E, T 1), type(F, T 2), T 1 = T 2. 5. Type Checking ? - type(+(n, x), real). 6. Type Inference ? - type(+(n, x), T). • Definite Clause Grammars CS 7100(PM) 10

Example-4: Fractions in Binary 1. 2. 3. 4. 5. • • F : : =. N N : : = 0 N : : = 1 N : : = 0 N N : : = 1 N Synthesized: val (value) Inherited: pow (# bits between left of a nonterminal and the binary point) • Nr: N-right, Nl: N-left CS 7100(PM) 1: 2: 3: 4: 4: 5: F. val: = N. val; N. pow: = 1 N. val : = 0 N. val : = (1/2^N. pow) Nl. val : = Nr. val Nr. pow : = 1 + Nl. pow Nl. Val : = Nr. val+(1/2^N. pow) 5: Nr. pow : = 1 + Nl. pow 11

Ex 4: Synthesized Attributes Only • Binary Fractions, same grammar as before: 1. F : : =. N 2. N : : = 0 3. N : : = 1 4. N : : = 0 N 5. N : : = 1 N • Alternate computation 1: F. val : = N. val / 2 2: N. val : = 0 3: N. val : = 1 4: N. val : = N. val / 2 5: N. val : = N. val / 2 + 1 (so that things do not look cluttered, . left and. right are unused) CS 7100(PM) 12

Example-5: Distinct Identifiers • Compute the number of distinct identifiers in a straight-line program. • Semantics specified in terms of sets of identifiers. • Attributes – var – exp – stm CS 7100(PM) ↑ ids ↑ num 13

Example-5: Distinct Identifiers • exp : : = var exp. ids = { var. id } • exp : : = exp 1 + exp 2 exp. ids = exp 1. ids U exp 2. ids • stm : : = var: = exp stm. ids = { var. id } U exp. ids • stm : : = stm 1; stm 2 CS 7100(PM) stm. num = | stm. ids = stm 1. ids U stm 2. ids stm. num = | stm. ids | 14

Example-5: Using Lists 1. Attributes 1. ↓ envi: list of vars in preceding context 2. ↑ envo: list of vars for following context 3. ↑ dnum: number of new variables 2. exp : : = var 3. exp. envo = if member(var. id, exp. envi) then exp. envi else cons(var. id, exp. envi) fi CS 7100(PM) 15

Example-5: Using Lists#2 • • • exp : : = exp 1 + exp 2 ↓ envi ↑ envo ↑ dnum exp 1. envi : = exp. envi exp 2. envi : = exp 1. envo exp. envo : = exp 2. envo exp. dnum : = length(exp. envo) exp. envo = append-sans-duplicates(exp 1. envo, exp 2. envo ) CS 7100(PM) 16

Complete Evaluation Rules • Synthesized attribute associated with N: – Each alternative in “N : : = …” should contain a rule for evaluating the Synthesized attribute. • Inherited attribute associated with N: – For every occurrence of N in “… : : = … N …” there must be a rule for evaluating the Inherited attribute. • Whenever you create an attribute grammar (in home work/ exams), make sure it satisfies these requirements. CS 7100(PM) 17

One Pass Attribute Computation • To enable one-pass top-down left-to-right computation of the attributes: – each inherited attribute of the rhs symbol can depend on all the attributes associated with preceding rhs symbols and the inherited attribute of the lhs nonterminal. – Similarly, the synthesized attribute of the lhs nonterminal can depend on all the attributes associated with all the rhs symbols and the inherited attribute of the lhs non-terminal. CS 7100(PM) 18

More than Context-Free Power • LABC = { a^nb^nc^n | n > 0 } – Unlike LAB = { a^nb^n | n > 0 }, here we need explicit counting of a’s, b’s and c’s • LWCW = { wcw | w ∈{a, b}* } – The “flavor” of checking whether identifiers are declared before their uses • LABC, LWCW cannot be defined with a CFG • LABC, LWCW can be defined with AG CS 7100(PM) 19

LABC = { a^n b^n c^n | n > 0 } • • ls : : = as bs cs Exp. Nb(bs) : = Na(as); Exp. Nc(cs) : = Na(as) as : : = a | a as 1 Na(as) : = 1; Na(as) : = Na(as 1) + 1 bs : : = b | b bs 1 cond(Exp. Nb(bs) = 1); Exp. Nb(bs 1) : = Exp. Nb(bs) - 1 cs : : = c | c cs 1 Cond(Exp. Nc(cs) = 1); Exp. Nc(cs 1) : = Exp. Nc(cs) – 1 Na: Exp. Nb: Exp. Nc: CS 7100(PM) synthesized by as inherited from bs inherited from cs 20

Uses of Attribute Grammars • Compiler Generation – Top-down Parsers (LL(1)) • FIRST sets, FOLLOW sets, etc – Code Generation Computations • Type, Storage determination, etc. • Databases – Optimizing Bottom-up Query Evaluation (Magic Sets) • Programming and Definitions CS 7100(PM) 21

Uses of Inherited Attributes • ex: 5. 0 + 2 – need to generate code to coerce int 2 to real 2. 0 • Determination of un-initialized variables • Determination of reachable non-terminals • Evaluation of an expression containing variables CS 7100(PM) 22

Use of Attribute Grammars • Useful for expressing arbitrary cycle-free computational walks over CFG derivation trees – Synthesized and inherited attributes – Conditions to reject invalid parse trees – Evaluation order depends on attribute dependencies • Realistic applications: – type checking – code generation • “Global” data structures must be passed around as attributes • Any container data structure (sets, etc. ) can be used • The evaluation rules can call auxiliary/helper functions but the functions cannot have side effects CS 7100(PM) 23

References • T. K. Prasad, Attribute Grammars and their Applications, In: Encyclopedia of Information Science and Technology, pp. 268 -273, 2008. Attribute-Grammars. pdf • PL Text Book Sections – Scott "PL Pragmatics" book, Chapter 4 – Pagan: 2. 1, 2. 2, 2. 3, 3. 2 – Stansifer: 2. 2, 2. 3 – Slonneger and Kurtz: 3. 1, 3. 2 CS 7100(PM) 24