1 / 27

Part 1 : Transformation Technique

Part 1 : Transformation Technique. Lecture 1: Attribute Grammar. Dr. Ir. I.S.W.B. Prasetya wishnu@cs.uu.nl A. Azurat S.Kom. ade@cs.uu.nl. Plan. Introduction AG Approach AG Tool Examples Conclusion. Transformation. transformation. result. sentence. "abba". semantic function.

garth
Download Presentation

Part 1 : Transformation Technique

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. Part 1 : Transformation Technique Lecture 1: Attribute Grammar Dr. Ir. I.S.W.B. Prasetya wishnu@cs.uu.nl A. Azurat S.Kom. ade@cs.uu.nl

  2. Plan • Introduction • AG Approach • AG Tool • Examples • Conclusion

  3. Transformation transformation result sentence "abba" semantic function parser P parse tree A A P B P B a b b a

  4. Example data Form = Form `AND` Form | Form `IMP` Form | Var String | Const Bool Example:(Var "a" `AND` Var "b") `IMP` Var "a"

  5. Example simp (Var a) = Var a simp (Const c) = Const c For every semantic function, you have to code the recursion by hand. simp (p `AND` q) = case (simp p, simp q) of ... (Const True , q') -> q' (p' , Const True) -> p' otherwise -> Nothing

  6. a computation on tree Composite Semantic Function • In composition: sequencing computations can be subtle • Upgrading a computation: may introduce various intermediate administrative data stucture whose relation can be quite subtle repmin t = replace (minT t) t

  7. AG tool AG description sem. function • repmin • simplifier • type checker • compiler • test generator • ... • in the same class as compiler compiler (YACC) compiler generator • example AG tool: LRC, AG Attribute Grammar Approach It is a formalism to abstractly describe semantic functions

  8. x inherited attribute And And Var y Attributes countVar (Const _) x = 0 countVar (Var y) x = if x==y then 1 else 0 countVar (And p q) x = countVar p x + countVar q x synthesized attribute

  9. Defining countVar in AG DATA Form | Const Bool | Var String | And p,q: Form

  10. Defining countVar in AG ATTR Form [ x : String | | result : Int ] SEM Form | Const lhs .result = 0 | Var lhs .result = if @lhs.x == @string then 1 else 0

  11. Defining countVar in AG SEM Form ... | And p .x = @lhs.x q .x = @lhs.x lhs .result = @p.result + @q.result

  12. Generating the Sem Function • Write AG source in file-name.ag • file-name must begin with CAPITAL letter • c:/app/hugs/runhugs -98 –mdcfs file-name • Will generate file-name.hs • Set the buffered number of lines in your DOS-window to 200 ...

  13. Result data Form = And (Form) (Form) | Const (Bool) | Var (String) sem_Form ((And (_p) (_q))) = ... ... sem_Form_Const (_bool) (_lhs_x) = 0 sem_Form (And (Var "x") (Var "y") ) "x" = 1

  14. cryptic notation ? currently ... each AG description only generate 1 sem-function per data structure. Hurdles SEM ... | Var lhs .result = if @lhs.x == @string then 1 else 0 ... sem_Form ((And (_p) (_q))) = ... ...

  15. substitution list Example: Renaming rename [ x  a, y  b ] x /\ y /\ z = a /\ b /\ z

  16. Writing Rename with AG imports { import List } { type SubsList = [ ( String, String ) ] subst :: String -> SubsList -> String subst x s = case find (\(y,z)-> y==x) s of Just (_,z) -> z otherwise -> x } ATTR Form [ subs : SubsList | | result : Form ]

  17. can be omitted  copy rule Writing Rename with AG SEM Form | Const lhs .result = Const @bool | Var lhs .result = Var (subst @string @lhs.subs) | And lhs .result = And @p.result @q.result p .subs = @lhs.subs q .subs = @lhs.subs

  18. Example: Normalizing Names normalizeNames x /\ c /\ z = a /\ b /\ c

  19. PASS 1: compute subs-list first ... [ (x, a), (c, b), (z, c) ] PASS 2: rename Strategy normalizeNames x /\ c /\ z = a /\ b /\ c

  20. for generating new (normalized) name Writing Pass 1 with AG { alreadyIn :: String -> SubsList -> Bool x `alreadyIn` s = find (\(y,k)-> y==x) s /= Nothing } ATTR Form [ | cntVar : Int nsubs : SubsList | ]

  21. can be omitted  copy rule cntVar, nsubs cntVar, nsubs Const b Pass 1 SEM Form | Const lhs .nsubs = @lhs.nsubs .cntVar = @lhs.cntVar

  22. Pass 1 SEM Form ... | Var loc .seen = @string `alreadyIn` @lhs.nsubs .nsubs' = @lhs.nsubs ++ [(@string, [chr(ord 'a' + @lhs.cntVar)])] .cntVar' = @lhs.cntVar + 1 lhs .nsubs = if @seen then @lhs.nsubs else @nsubs' .cntVar = if @seen then @lhs.cntVar else @cntVar'

  23. Can be omitted  copy rule ! Pass 1 SEM Form ... | And p .cntVar = @lhs.cntVar .nsubs = @lhs.nsubs q .cntVar = @p.cntVar .nsubs = @p.nsubs lhs .cntVar = @q.cntVar .nsubs = @q.nsubs

  24. Pass or Aspect ? • Rather than sequencing passes, we will combine aspects ! • Each SEM computation may consist of several aspects, rather than passes DATA Root | Root f : Form ATTR Root [ | | result : Form ]

  25. no imperative sequencing of passes! copy rule! Combining Aspects SEM Root | Root f .cntVar = 0 .nsubs = [ ] .subs = @f.nsubs lhs .result = @f.result

  26. Resulting AG Code ... SEM Form | Const lhs.result = Const @bool | Var lhs.result = Var (subst @string @lhs.subs) | And lhs.result = And @p.result @q.result SEM Form | Var loc .seen = @string `alreadyIn` @lhs.nsubs .nsubs' = @lhs.nsubs ++ [(@string, [chr(ord 'a' + @lhs.cntVar)])] .cntVar' = @lhs.cntVar + 1 lhs .nsubs = if @seen then @lhs.nsubs else @nsubs' .cntVar = if @seen then @lhs.cntVar else @cntVar' SEM Root | Root f .cntVar = 0 .nsubs = [] .subs = @f.nsubs

  27. Conclusion • Abstract • recursion is generated • copying and chaining information is generated • sequencing passes is automatic • Highly compositional • computation can be split in aspects • Highly extensible • extending a computation is just adding a new aspect

More Related