1. Workshop: Towards Highly Portable Software Jakarta, 21 – 23 January 2003 Diselenggarakan oleh Universitas IndonesiaUniversitas Indonesia Part 1 : Transformation Technique Dr. Ir. I.S.W.B. Prasetyawishnu@cs.uu.nl A. Azurat S.Kom.ade@cs.uu.nl Lecture 1: Attribute Grammar

2. 2 Plan Introduction AG Approach AG Tool Examples Conclusion

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

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

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

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

7. 7 Attribute Grammar Approach It is a formalism to abstractly describe semantic functions 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

8. 8 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 And Var y And x synthesized attribute inherited attribute

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

10. 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. 11 Defining countVar in AG SEM Form... | And p.x= @lhs.x q.x= @lhs.x lhs.result = @p.result + @q.result

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

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

16. 16 Writing Rename with AG { 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 ] imports { import List }

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

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

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

20. 20 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 | ] for generating new (normalized) name

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

22. 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. 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. 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. 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. 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. 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