1 / 23

Attribute Grammars

Attribute Grammars. Attribute Grammar is a Framework for specifying semantics and enables Modular specification. http://knoesis.wright.edu/tkprasad/papers/Attribute-Grammars.pdf. “ Correct ” Programs ( no run-time errors ). S*. Regular ( lexer ). Context-free ( parser ).

feo
Download Presentation

Attribute Grammars

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Attribute Grammars Attribute Grammar is a Frameworkfor specifying semantics and enables Modularspecification. http://knoesis.wright.edu/tkprasad/papers/Attribute-Grammars.pdf L16-7AG

  2. “Correct” Programs (no run-time errors) S* Regular (lexer) Context-free (parser) Context-sensitive (type-checker) L16-7AG

  3. Number 46 (if base 2) 101110 (if base 10) Fraction 23/64 Unary encoding “13” ASCII Character “.” Switch positions ON-OFF-ON-… Binary string “0101110” Semantics of Bit Pattern : 0101110 L16-7AG

  4. Motivation for Precise Specification • Capture subtly different semantics for the same syntax in various languages. • Arrays and strings. • Parameter passing mechanisms. • Scoping rules. • Primitive types vs Composite types. • Type equivalence. L16-7AG

  5. Attribute Grammars Formalism for specifying semantics based on context-free grammars (BNF) • Static semantics (context-sensitive aspects) • Type checking and type inference • Compatibility between procedure definition and call • Scope rules • Dynamic semantics • Associate attributes with terminals and non-terminals • Associate attribute computation rules with productions L16-7AG

  6. N -> 0 N -> 1 N -> N 0 N -> N 1 N . val:= 0 N . val:= 1 N . val:= 2* N. val N . val:= 2* N. val+ 1 Synthesized Attributes L16-7AG

  7. Derivation Tree N N 0 N 1 110 ~> 6 1 L16-7AG

  8. N -> 0 N -> 1 N -> 0 N N -> 1 N N . val:= 0 N . len:= 1 N . val:= 1 N . len:= 1 N . val:= N. val N . len:= N. len + 1 N . val:= N. val+ 2^ N. len N . len:= N. len + 1 Synthesized Attributes L16-7AG

  9. Inherited Attributes • Declaration and Use { inti, j, k; i := i + j + j; } <assign-stm> -> <var> := <expr> <var>.env := <assign-stm>.env <expr>.env:= <assign-stm>.env L16-7AG

  10. Inherited Attributes • Coercion Code Generation 5.0 + 2 ­ coerce_int_to_real • Determination of un-initialized variables • Determination of reachable non-terminals • Evaluation of an expression containing variables L16-7AG

  11. Attributes A(X) • Synthesized S(X) • Inherited I(X) • Attribute computation rules(Semantic functions) X0 -> X1 X2 … Xn S(X0) = f( I(X0), A(X1), A(X2), …, A(Xn) ) I(Xj) = Gj( I(X0), A(X1), A(X2), …, A(Xj-1)) for allj in1..n P( A(X0), A(X1), A(X2), …, A(Xn) ) L16-7AG

  12. Information Flow inherited computed available synthesized ... ... L16-7AG

  13. Synthesized Attributes Pass information up the parse tree • Inherited Attributes Pass information down the parse tree or from left siblings to the right siblings • Attribute values assumed to be available from the context. • Attribute values computed using the semantic rules provided. The constraints on the attribute evaluation rules permit top-down left-to-right (one-pass) traversal of the parse tree to compute the meaning. L16-7AG

  14. E -> n | m E -> x | y E -> E1 + E2 E -> E1 * E2 E.type := int E.type := real if E1.type= E2.type then E.type:=E1.type else E.type:= real Static Semantics L16-7AG

  15. Executable Specification in Prolog type(i,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(+(i,x),real). • Type Inference ?- type(+(x,x),T). L16-7AG

  16. E -> n | m E -> p | q E -> if E0 then E1 else E2 E.type := int E.type := bool if ( E0.type= bool ) Ù ( E1.type = E2.type ) then E.type:=E1.type elsetypeerror Static Semantics L16-7AG

  17. F -> . N N -> 0 N -> 1 N -> 0 N N -> 1 N F.val:= N.val N.pow:= 1 N.val:= 0 N.val:= (1/2^N.pow) N.pow:= 1 + N.pow N.val:= N.val N.pow:= 1 + N.pow N.val:= N.val + (1/2^N.pow) Fractions L16-7AG

  18. F -> . N N -> 0 N -> 1 N -> 0 N N -> 1 N F.val:= N.val/ 2 N.val:= 0 N.val:= 1 N.val:= N.val/ 2 N.val:= N.val/ 2 + 1 Fractions (Alternate solution) L16-7AG

  19. Applications 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 L16-7AG

  20. An Extended Example • Distinct identifiers in a straight-line program. BNF <exp> ::= <var> | <exp> + <exp> <stm> ::= <var> := <exp> | <stm> ; <stm> Attributes <var>  id <exp>  ids <stm>  ids  num • Semantics specified in terms of sets (of identifiers). L16-7AG

  21. <exp> ::= <var> <exp>.ids = {<var>.id } <exp> ::= <exp1> + <exp2> <exp>.ids = <exp>.idsU<exp>.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 | L16-7AG

  22. Alternate approach : Using lists • Attributes  envi : list of vars in preceding context  envo : list of vars for following context  dnum : number of new variables <exp> ::= <var> <exp>.envo = ifmember(<var>.id,<exp>.envi) then <exp>.envi elsecons(<var>.id,<exp>.envi) L16-7AG

  23. Attribute Computation Rules <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) L16-7AG

More Related