From Dependencies to Evaluation Strategies

Transcription

1 From Dependencies to Evlution Strtegies Possile strtegies: 1 let the user define the evlution order 2 utomtic strtegy sed on the dependencies: use locl dependencies to determine which ttriutes to compute f e * n suppose we require n[1] computing n[1] requires f[1] f[1] depends on n ttriute in the child, so descend f e E n compute ttriutes in psses compute dependency grph etween ttriutes (no go if cyclic) trverse AST once for ech ttriute; here three times, once for e, f, n f n compute one ttriute in ech pss e 3 consider fixed strtegy nd only llow n ttriute system tht cn e evluted using this strtegy 174 / 295

2 Liner Order from Dependency Prtil Order Possile utomtic strtegies: 1 demnd-driven evlution strt with the evlution of ny required ttriute if the eqution for this ttriute relies on s-of-yet unevluted ttriutes, compute these recursively visits the nodes of the syntx tree on demnd (following dependency on the prent requires pointer to the prent) 2 evlution in psses minimize the numer of visits to ech node orgnize the evlution of the tree in psses for ech pss, pre-compute strtegy to visit the nodes together with locl strtegy for evlution within ech node type consider exmple for demnd-driven evlution 175 / 295

3 Exmple: Demnd-Driven Evlution Compute next t leves 2, 3 nd 4 in the expression ( ) ( ): : next[1] := next[0] next[2] := next[0] : next[1] := first[2] (empty[2]? next[0]: ) next[2] := next[0]. n *. n 2 n e f n 0 1 e f n e f 3 4 n 176 / 295

4 Demnd-Driven Evlution Oservtions only required ttriutes re evluted the evlution sequence depends in generl on the ctul syntx tree the lgorithm must trck which ttriutes it hs lredy evluted the lgorithm my visit nodes more often thn necessry ech node must contin pointer to its prent the lgorithm is not locl pproch only eneficil in principle: evlution strtegy is dynmic: difficult to deug computtion of ll ttriutes is often cheper usully ll ttriutes in ll nodes re required perform evlution in psses 177 / 295

5 Evlution in Psses Ide: trverse the syntx tree severl times; ech time, evlute ll those equtions [i ] = f([i ],..., z[i z ]) whose rguments [i ],..., z[i z ] re known For strongly cyclic ttriute system: the locl dependencies in D i of the ith production N X 1... X n together the glol dependencies R(X i ) for ech X i define sequence in which ttriutes cn e evluted determine sequence in which the children re visited so tht s mny ttriutes s possile re evluted in ech pss t lest one new ttriute is evluted requires t most n psses for evluting n ttriutes since trversl strtegy exists for evluting one ttriute, it might e possile to find strtegy to evlute more ttriutes optimiztion prolem note: evluting ttriute set {[0],..., z[0]} for rule N... N... my evlute different ttriute set of its children up to 2 k 1 evlution functions for N... in the exmple: empty nd first cn e computed together next must e computed in seprte pss 178 / 295

6 Implementing Stte Prolem: In mny cses some sort of stte is required. Exmple: numering the lefs of syntx tree. * / 295

7 Implementing Numering of Lefs Ide: use helper ttriutes pre nd post in pre we pss the vlue of the lst lef down (inherited ttriute) in post we pss the vlue of the lst lef up (synthetic ttriute) root: pre[0] := 0 pre[1] := pre[0] post[0] := post[1] node: pre[1] := pre[0] pre[2] := post[1] post[0] := post[2] lef: post[0] := pre[0] / 295

8 The Locl Attriute Dependencies pre post pre post pre post pre post the ttriute system is pprently strongly cyclic ech node computes the inherited ttriutes efore descending into child node (corresponding to pre-order trversl) the synthetic ttriutes fter returning from child node (corresponding to post-order trversl) if ll ttriutes cn e computed in single depth-first trversl tht proceeds from left- to right (with pre- nd post-order evlution) then we cll this ttriute system L-ttriuted. 181 / 295

9 L-ttriuted Definition An ttriute system is L-ttriuted, if for ll productions s ::= s 1... s n every inherited ttriute of s j where 1 j n only depends on 1 the ttriutes of s 1, s 2,... s j 1 nd 2 the inherited ttriutes of s. Origin: the ttriutes of n L-ttriuted grmmr cn e evluted during prsing importnt if no syntx tree is required or if error messges should e emitted while prsing exmple: pocket clcultor L-ttriuted grmmrs hve fixed evlution strtegy: single depth-first trversl in generl: prtition ll ttriutes into A = A 1... A n such tht for ll ttriutes in A i the ttriute system is L-ttriuted perform depth-first trversl for ech ttriute set A i crft ttriute system in wy tht they cn e prtitioned into few L-ttriuted sets 182 / 295

10 Prcticl Applictions symol tles, type checking/inference, nd simple code genertion cn ll e specified using L-ttriuted grmmrs most pplictions nnotte syntx trees with dditionl informtion the nodes in syntx tree often hve different types tht depends on the non-terminl tht the node represents the different types of non-terminls re chrcterised y the set of ttriutes with which they re decorted exmple: sttement my hve two ttriutes contining vlid identifiers: one ingoing (inherited) set nd one outgoing (synthesised) set; in contrst, n expression only hs n ingoing set 183 / 295

11 Implementtion of Attriute Systems vi Visitor clss with method for every non-terminl in the grmmr pulic strct clss Regex { pulic strct void ccept(visitor v); } ttriute-evlution works vi pre-order / post-order cllcks pulic interfce Visitor { defult void pre(orex re) {} defult void pre(andex re) {}... defult void post(orex re) {} defult void post(andex re){} } we pre-define depth-first trversl of the syntx tree pulic clss OrEx extends Regex { Regex l,r; pulic void ccept(visitor v) { v.pre(this);l.ccept(v);v.inter(this); r.ccept(v); v.post(this); } } 184 / 295

12 Exmple: Lef Numering pulic strct clss AstrctVisitor implements Visitor { defult void pre(orex re) { pr(re); } defult void pre(andex re) { pr(re); }... defult void post(orex re) { po(re); } defult void post(andex re){ po(re); } strct void po(binex re); strct void in(binex re); strct void pr(binex re); } pulic clss LefNum extends Visitor { pulic LefNum(Regex r) { n.set(r,0);r.ccept(this);} pulic Mp<Regex,Integer> n = new HshMp<>(); pulic void pr(const r) { n.set(r, n.get(r)+1); } pulic void pr(binex r) { n.set(r.l,n.get(r)); } pulic void in(binex r) { n.set(r.r,n.get(r.l)); } pulic void po(binex r) { n.set(r,n.get(r.l)+n.get(r.r)); } } 185 / 295

13 Semntic Anlysis Chpter 2: Symol Tles 186 / 295

14 Symol Tles Consider the following Jv code: void foo() { int A; void r() { doule A; A = 0.5; write(a); } A = 2; r(); write(a); } within the ody of r the definition of A is shdowed y the locl definition ech declrtion of vrile v requires the compiler to set side some memory for v; in order to perform n ccess to v, we need to know to which declrtion the ccess is ound we consider only sttic lloction, where the memory is llocted while vrile is in scope inding is not visile within locl declrtion of the sme nme is in scope 187 / 295

15 Scope of Identifiers void foo() { } int A; void r() { doule A; A = 0.5; write(a); } A = 2; r(); write(a); scope of int A 188 / 295

16 Scope of Identifiers void foo() { int A; void r() { doule A; A = 0.5; write(a); } A = 2; r(); write(a); scope of doule A } dministrtion of identifiers cn e quite complicted / 295

17 Visiility Rules in Oject-Oriented Lnguges 1 pulic clss Foo { 2 int x = 17; 3 protected int y = 5; 4 privte int z = 42; 5 pulic int () { return 1; } 6 } 7 clss Br extends Foo { 8 protected doule y = 0.5; 9 pulic int (int ) 10 { return +x; } 11 } Oservtions: Modifier Clss Pckge Suclss World pulic protected no modifier privte privte memer z is only visile in methods of clss Foo protected memer y is visile in the sme pckge nd in su-clss Br, ut here it is shdowed y doule y Br does not compile if it is not in the sme pckge s Foo methods with the sme nme re different if their rguments differ sttic overloding 189 / 295

18 Dynmic Resolution of Functions 1 pulic clss Foo { 2 protected int foo() { return 1; } 3 } 4 clss Br extends Foo { 5 protected int foo() { return 2; } 6 pulic int test(oolen ) { 7 Foo x = ()? new Foo() : new Br(); 8 return x.foo(); 9 } 10 } Oservtions: the type of x is Foo or Br, depending on the vlue of x.foo() either clls foo in line 2 or in line 5 this decision is mde t run-time nd hs nothing to do with nme resolution 190 / 295

19 Resolving Identifiers Oservtion: ech identifier in the AST must e trnslted into memory ccess Prolem: for ech identifier, find out wht memory needs to e ccessed y providing rpid ccess to its declrtion Ide: 1 rpid ccess: replce every identifier y unique nme, nmely n integer integers s keys: comprisons of integers is fster replcing vrious identifiers with numer sves memory 2 link ech usge of vrile to the declrtion of tht vrile trck dt structures to distinguish declred vriles nd visile vriles for lnguges without explicit declrtions, crete declrtions when vrile is first encountered 191 / 295

20 (1) Replce ech Occurrence with Numer Rther thn hndling strings, we replce ech string with unique numer. Ide for Algorithm: Input: sequence of strings Output: 1 sequence of numers 2 tle tht llows to retrieve the string tht corresponds to numer Apply this lgorithm on ech identifier in the scnner. 192 / 295

21 Exmple for Applying this Algorithm Input: Peter Piper picked peck of pickled peppers If Peter Piper picked peck of pickled peppers wheres the peck of pickled peppers Peter Piper picked Output: nd 0 Peter 1 Piper 2 picked 3 4 peck 5 of 6 pickled 7 peppers 8 If 9 wheres 10 the 193 / 295

22 Implementing the Algorithm: Specifiction Ide: implement prtil mp: S : String int use counter vrile int count = 0; to trck the numer of different identifiers found so fr We thus define function int getindex(string w): int getindex(string w) { if (S (w) undefined) { S = S {w count}; return count++; else return S (w); } 194 / 295

23 Dt Structures for Prtil Mps possile dt structures: list of pirs (w, i) String int : insert: O(1) lookup: O(n) too expensive lnced trees : insert: O(log(n)) lookup: O(log(n)) hsh tles : insert: O(1) lookup: O(1) too expensive on verge cvet: we will see tht the hndling of scoping requires dditionl opertions tht re hrd to implement with hsh tles 195 / 295

24 An Implementtion using Hsh Tles llocted n rry M of sufficient size m choose hsh function H : String [0, m 1] with the following properties: H(w) is chep to compute H distriutes the occurring words eqully over [0, m 1] Possile choices ( x = x 0,... x r 1 ): H 0 ( x) = H 1 ( x) = H 1 ( x) = (x 0 + x r 1 ) % m ( r 1 i=0 x i p i ) % m (x 0 + p (x 1 + p (... + p x r 1 ))) % m for some prime numer p (e.g. 31) We store the pir (w, i) in linked list locted t M[H(w)] 196 / 295

25 Computing Hsh Tle for the Exmple With m = 7 nd H 0 we otin: 0 If 8 the Piper 1 Peter 0 6 pickled 6 peck 4 pickled 2 of 5 wheres 9 peppers 7 3 In order to find the index for the word w, we need to compre w with ll words x for which H(w) = H(x) 197 / 295

26 Resolving Identifiers: (2) Symol Tles Check for the correct usge of vriles: Trverse the syntx tree in suitle sequence, such tht ech definition is visited efore its use the currently visile definition is the lst one visited for ech identifier, we mnge stck of scopes if we visit declrtion of n identifier, we push it onto the stck upon leving the scope, we remove it from the stck if we visit usge of n identifier, we pick the top-most declrtion from its stck if the stck of the identifier is empty, we hve found n error 198 / 295

27 Exmple: A Tle of Stcks 1 { 2 int, ; // V, W 3 = 5; 4 if (>3) { 5 int, c; // X, Y 6 = 3; 7 c = + 1; 8 = c; 9 } else { 10 int c; // Z 11 c = + 1; 12 = c; 13 } 14 = + ; 15 } c c c c V W X, V W Y V W Z V W 199 / 295

28 Resolving: Rewriting the Syntx Tree 0 d int 1 d d declrtion node sic lock ssignment int 1 = 5 1 > 3 if 0 d int 2 d int { int, ; // V, W = 5; if (>3) { int, c; // X, Y = 3; c = + 1; = c; } else { int c; // Z c = + 1; = c; } = + ; } = d int = / 295

29 Resolving: Rewriting the Syntx Tree 0 d int 1 d d declrtion node sic lock ssignment int 1 = 5 1 > 3 if 0 d int 2 d int { int, ; // V, W = 5; if (>3) { int, c; // X, Y = 3; c = + 1; = c; } else { int c; // Z c = + 1; = c; } = + ; } = d int = / 295

30 Alterntive Resolution of Visiility resolving identifiers cn e done using n L-ttriuted grmmr eqution system for sic lock must dd nd remove identifiers when using list to store the symol tle, storing mrker indicting the old hed of the list is sufficient c c in front of if-sttement then-rnch else-rnch insted of lists of symols, it is possile to use list of hsh tles more efficient in lrge, shllow progrms more elegnt solution is to use persistent tree in which n updte returns new tree ut leves ll old references to the tree unchnged persistent tree t cn e pssed down into sic lock where new elements my e dded; fter exmining the sic lock, the nlysis proceeds with the unchnged t 201 / 295