part 1 : transformation technique

Workshop: Towards Highly Portable SoftwareJakarta, 21 – 23 January 2003

Diselenggarakan oleh Universitas Indonesia

Part 1 : Transformation Technique

Dr. Ir. I.S.W.B. Prasetya wishnu@cs.uu.nlA. Azurat S.Kom. ade@cs.uu.nl

Lecture 1: Attribute Grammar

2

Plan

• Introduction• AG Approach• AG Tool• Examples• Conclusion

3

Transformation

sentencetransformation result

"abba"

P

A P A

PB B

a ab b

parse tree

parser semantic function

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 asimp (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

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

Attribute Grammar Approach

It is a formalism to abstractly describe semantic functions

AG toolAG 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

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 yAnd

xsynthesized attribute

inherited 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

| Varlhs .result = if @lhs.x == @string then 1 else 0

11

Defining countVar in AG

SEM Form

...

| Andp

.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

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

substitution list

Example: Renaming

rename

[ x a, y b ]

x /\ y /\ z

=

a /\ b /\ z

16

Writing Rename with AG

{type SubsList = [ ( String, String ) ]

subst :: String -> SubsList -> Stringsubst 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

Writing Rename with AG

SEM Form

| Const lhs .result = Const @bool

| Andlhs .result = And @p.result @q.result

| Varlhs .result = Var (subst @string @lhs.subs)

p .subs = @lhs.subsq .subs = @lhs.subs

can be omitted copy rule

18

Example: Normalizing Names

normalizeNames

x /\ c /\ z

=

a /\ b /\ c

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

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

can be omitted copy rule

Pass 1

SEM Form

| Const lhs

.nsubs = @lhs.nsubs

.cntVar = @lhs.cntVar

Const b

cntVar, nsubs cntVar, nsubs

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 omittedcopy 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

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