Prabhaker Mateti ACK: Assembled from many sources 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.

Attribute Grammars: Definition An attribute grammar G is a CFG (S, N, T, P) plus X0 is one of X1 ... Xn Xi from N U T S(X0) = f(I(X0), A(X1), ... , A(Xn)) synthesized attributes I(Xi) = g(A(X0), ... , 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(X0), A(X1), A(X2), …, A(Xn) ) G = (S, N, T, P), S start symbol, N non-terminals, T terminals, P productions

Example-1: Binary Numbers N ::= N 0 N ::= N 1 Recall CFGs do not provide semantics. CGGs provide only syntax, that too without context-sensitive details N.val := 0 N.val := 1 N.val := 2*N.rhs.val 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

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

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

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

Information Flow inherited computed available synthesized ... ... CS7100(PM)

Attribute Value Computation If all attributes were inherited, the tree could be decorated in top-down 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. CS7100(PM)

Example-2 done in Prolog type(n, int). type(x, real). type(+(E, F), T) :- type(E, T), type(F, T). type(+(E, F), real) :- type(E, T1), type(F, T2), T1 \= T2. Type Checking ?- type(+(n, x), real). Type Inference ?- type(+(n, x), T). Definite Clause Grammars CS7100(PM)

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

Ex4: Synthesized Attributes Only Binary Fractions, same grammar as before: F ::= . N N ::= 0 N ::= 1 N ::= 0 N 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) CS7100(PM)

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 ↑ id exp ↑ ids stm ↑ ids ↑ num CS7100(PM)

Example-5: Distinct Identifiers exp ::= var exp.ids = { var.id } exp ::= exp1 + exp2 exp.ids = exp1.ids U exp2.ids stm ::= var:= exp stm.ids = { var.id } U exp.ids stm.num = | stm.ids | stm ::= stm1;stm2 stm.ids = stm1.ids U stm2.ids stm.num = | stm.ids | CS7100(PM)

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

Example-5: Using Lists#2 exp ::= exp1 + exp2 ↓ envi ↓ envi ↓ envi ↑ envo ↑ envo ↑ envo ↑ dnum ↑ dnum ↑ dnum exp1.envi := exp.envi exp2.envi := exp1.envo exp.envo := exp2.envo exp.dnum := length(exp.envo) exp.envo = append-sans-duplicates(exp1.envo, exp2.envo ) CS7100(PM)

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. CS7100(PM)

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 non- terminal. Similarly, the synthesized attribute of the lhs non- terminal can depend on all the attributes associated with all the rhs symbols and the inherited attribute of the lhs non-terminal. CS7100(PM)

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 CS7100(PM)

LABC = { a^n b^n c^n | n > 0 } ls ::= as bs cs ExpNb(bs) := Na(as); ExpNc(cs) := Na(as) as ::= a | a as1 Na(as) := 1; Na(as) := Na(as1) + 1 bs ::= b | b bs1 cond(ExpNb(bs) = 1); ExpNb(bs1) := ExpNb(bs) - 1 cs ::= c | c cs1 Cond(ExpNc(cs) = 1); ExpNc(cs1) := ExpNc(cs) – 1 Na: synthesized by as ExpNb: inherited from bs ExpNc: inherited from cs CS7100(PM)

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 CS7100(PM)

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 CS7100(PM)

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 CS7100(PM)

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 CS7100(PM)