rij karakters scanner rij tokens parser ontleedboom (filteren separatoren) (niet expliciet geconstrueerd) (+ add. inform.) (contextvrije analyse)

Transcriptie

1 scanning and parsing 1/57 rij karakters scanner (filteren separatoren) rij tokens (+ add. inform.) (niet expliciet geconstrueerd) parser (contextvrije analyse) ontleedboom (parse tree) representeert syntactische structuur programma

2 concrete versus abstracte syntax 2/57 concrete syntax if B then S t else S e fi als B dan S t anders S e sla abstracte syntax (boom) (AST ) if 2 (AST(B), AST(S t ), AST(S e )) if 2 B S t S e

3 beschrijving syntactische structuur 3/57 reguliere expressies niet geschikt geen nesting ( n id) n klasse van programma s (n > 0) [ var a n : int read(a n ) ] niet regulier contextvrije grammatica s grotere klasse van talen nesting klasse van programma s (n > 0) [ var a n : int read(a n ); write(a n ) ] niet contextvrij

4 contextvrije ontleding (parsing) 4/57 contextvrije grammatica G acceptor: nondeterministische stapelautomaat (hoge mate van nondeterminisme) algemene ontleedmetode Earley s algoritme tijd: O(N 3 ) geheugen (tabel): O(N 2 G ) eisen aan grammatica/taal deterministische stapelautomaat LALR(1) (meeste programmeertalen) LL(1) (stringenter, eenvoudiger parser)

5 LL(1)-grammatica/taal 5/57 LL(1)-grammatica/taal acceptor: recursive descent parser (stelsel recursieve procedures corresponderend met productieregels) parse tree expliciet opgebouwd (als synthesized attribuut) nog geen contextcondities

6 contextvrije grammatica 6/57 contextvrije grammatica G = (N, Σ, P, S) N eindige, niet lege verzameling (nonterminals) Σ eindige, niet lege verzameling (terminals) N Σ = P N (N Σ), P eindig (productieregels) (A, α) P notatie: A α S N, start symbol vocabulaire grammtica: V = N Σ

7 afleidingen en taal contextvrije grammatica 7/57 G ( leidt af in 1 stap ) α β als G α = δ 1 Cδ 2 en β = δ 1 γδ 2 met δ 1, δ 2 V en C γ P leidt af in 0 of meer stappen G + G leidt af in 1 of meer stappen afleiding (derivation) met lengte k α 0 α 1 α 2 α k verzameling terminal strings afleidbaar uit α V L(α) = {x Σ α x} G taal gegenereerd door contextvrije grammatica G L(G) = L(S) = {x Σ S x} G

8 voorbeeld contextvrije grammatica en afleidingen 8/57 G = ({EXPR, OP}, {p, q, (, ), +, }, P, EXPR) P : EXPR p OP + EXPR q OP EXPR (EXPR OP EXPR) verkorte notatie EXPR p q (EXPR OP EXPR) OP + EXPR (EXPR OP EXPR ) ( EXPR OP (EXPR OP EXPR)) (p OP ( EXPR OP EXPR)) (p OP (q OP EXPR)) (p OP (q EXPR )) (p OP (q p)) (p + (q p)) EXPR ( + ) (p + (q p))

9 voorbeeld linkspreferente afleiding/taal 9/57 linkspreferente afleiding (uniek) EXPR p q (EXPR OP EXPR) OP + taal EXPR ( EXPR OP EXPR) (p OP EXPR) (p + EXPR ) (p + ( EXPR OP EXPR)) (p + (q OP EXPR)) (p + (q EXPR )) (p + (q p)) L(G) = L(S) = {p, q, (p + q), (p q), (p + p), (p p),..., (p + (q p)),...}

10 voorbeeld bouwstenen concrete syntaxboom 10/57 A u 1 u 2... u n A u 1 u 2... u n A ε A ε

11 voorbeeld concrete syntaxboom 11/57 EXPR ( EXPR OP EXPR ) p + ( EXPR OP EXPR ) EXPR p q (EXPR OP EXPR) q p OP +

12 voorbeeld goedgehaakte rijen 12/57 S B S ε B (S) linkspreferente afleiding S B S ( S )S () S () B S ()( S )S ()() S ()() niet links- of rechtspreferente afleiding S B S B B S B(S) S B (S) ( S )(S) ()( S ) ()() dezelfde afleidingsboom S B S ( S ) B S ε ( S ) ε ε

13 dangling else (ambigue grammatica) 13/57 S if b then S else S S if b then S S a if b then if b then a else a 2 afleidingsbomen S S if b then S if b then S else S if b then S else S if b then S a a a a

14 2 afleidingsbomen/geen betekenisverschil 14/57 E p q E + E E E p + q + q E E E + E E + E E + E q p E + E p q q q (p + q) + q p + (q + q) 2 afleidingsbomen, geen verschil in betekenis

15 2 afleidingsbomen/betekenisverschil 15/57 E p q E + E E E p q + q E E E + E E E E E q p E + E p q q q (p q) + q p (q + q) (gebruikelijke prioriteiten) (ongebruikelijk) + p q q p + q q p q q + p q q + 2 afleidingsbomen, wel betekenis -verschil

16 prioriteiten 16/57 hogere prioriteit dan + E:expressie (som van termen) T :term (product van factoren) F :factor F F } {{ } T + F F } {{ } T + + F F } {{ } T } {{ } E T + T + T + T = ((T + T ) + T ) + T F F F F = ((F F ) F ) F E E + T (linksassociativiteit) E T T T F T F F p F q F (E) (doorbreken prioriteiten)

17 prioriteiten (vervolg) 17/57 E E + T T T T F F F p q (E) p q + q wordt ontleed als (p q) + q E E + T BINEXPR T F BINEXPR + VAREXPR q T F q VAREXPR p VAREXPR q F q p

18 syntax / acceptor / parser 18/57 beschrijving syntax programmeertaal: contextvrije grammatica G = (N, Σ, P, S) acceptor voor L(G): beslist voor x Σ of x L(G) (ja/nee-antwoord) parser voor L(G) (nuttiger): beslist voor x Σ of x L(G) en levert, als het antwoord ja is, een afleidingsboom van x S (te construeren) x 1 x 2 x m

19 constructie parser 19/57 1. stapelautomaten contextvrije grammatica G stapelautomaat (LL(0)) (nondeterministisch) 2. dominospel stapelautomaat (LL(1)) ((minder non)determ.) recursive descent parsing procedures implementatie indien determ.

20 syntactisch dominospel (beginsituatie/dominostenen) 20/57 beginsituatie (invoer x 1 x 2... x m ) bovenkant S onderkant boven dominostenen x 1 x 2 x m onder A u 1 u 2... u n flexibel A boven u 1 u 2 u n onder vaste volgorde A ε A ε

21 syntactisch dominospel (spelregels/doel) 21/57 aanleggen stenen goede oriëntatie geen kruisende verbindingen gelijk gelabelde vlakke kanten tegen elkaar doel bord volleggen volgens regels zodat er geen vlakke kanten meer over zijn (indien mogelijk)

22 syntactisch dominospel (voorbeeld) 22/57 S S B S BS ε B (S) invoerstring: ()() B S ε ( ) S

23 syntactisch dominospel (voorbeeld) 22/57 S S B S BS ε B (S) invoerstring: ()() B S ε ( ) S S S B B S S S S B B S S ε S S ε ( ( ) ) ( ε ) ( )

24 strategie dominospel 23/57 geen backtracking ( eenmaal gelegd blijft gelegd ) aansluiten legrichting horizontaal: links rechts legrichting verticaal: van boven naar beneden (top-down, LL-strategie) strategie behandel steeds de meest linkse, vrije, vlakke onderkant

25 LL(1)-strategie 24/57 S S v 1 v 2 v l x 1 x 1 x n x n y 1 y k y m meest linkse vrije vlakke onderkant ( ) v 1 Σ: v1 = y 1 : vlakke kanten samenvoegen v 1 y 1 : afbreken (foutmelding) v 1 N: plaats tegen deze onderkant een domino met een bovenkant gelabeld v 1 welke domino? gebruik k invoersymbolen lookahead LL(k)-strategie (k 1) (hier LL(1)-strategie)

26 uitgebreide grammatica 25/57 nieuwe symbolen S en uitgebreide grammatica G G = (N {S }, Σ { }, P {S S }, S ) S S S S v 1 v 2 v l x 1 x 1 x n x n y 1 y k y m meest linkse vrije vlakke onderkant ( )

27 dominoselectie 26/57 S Aβ x y aaneengesloten stuk S S xaβ rij vrije onderkanten v 1 v 2 v l = Aβ rij vrije bovenkanten y 1 y 2 y m = y Aβ αβ spelen A α spel is te voltooien y noodzakelijke voorwaarde: el 1 (y ) is 1e element van een eindproductie van αβ criterium dominoselectie: kies een domino A α zodat el 1 (y ) 1e element van een eindproductie van αβ is (β te specifiek)

28 lookaheadset/selectiecriterium domino 27/57 S S xaβ xαβ xy strings x en β specifiek voor deze afleiding lookaheadset productieregel A α LA(A α) = {a Σ { } ( w, γ, δ : w Σ γ, aδ V : S S waγ wαγ waδ)} selectiecriterium el 1 (y ) LA(A α)

29 berekening lookaheadsets 28/57 S S waγ wαγ waδ α ε? First(α) = {a Σ { } ( β : β V : α aβ)} Follow(A) = {a Σ { } ( α, β : α, β V : S αaaβ)} LA(A α) { = Follow(A) als α ε First(α) als (α ε) lookaheadsets eenvoudige grammatica s kunnen bepalen

30 transitive closure / Warshall s algorithm (1) 29/57 R : V V B binary relation on V U V xr + y there is a non-empty directed path from x to y with all intermediate nodes on the path in V (x, y V ) xr U y there is a non-empty directed path from x to y with all intermediate nodes on the path in U (x, y V ) R = R R V = R +

31 transitive closure / Warshall s algorithm (2) 30/57 v V \ U xr U+{v} y xr U y (xr U v vr U y) xr U+{v} v {property R U+{v} } xr U v (xr U v vr U v) {absorption} xr U v vr U+{v} y vr U y

32 transitive closure / Warshall s algorithm (3) 31/57 [ var r : array(v V )of bool; U : set of V U : = ; for x, y : x, y V do r[x, y] : = xry od; { invariant: U V r = R U } do U V [ var v : V ; v : v V \ U; for x, y : x, y V do r[x, y] : = r[x, y] (r[x, v] r[v, y]) od; { r = R U+{v} } U : = U + {v} ] od { r = R V = R + } ]

33 transitive closure / Warshall s algorithm (4) 32/57 f R (x) = {y V xry} (x V ) f RU+{v} (x) { } = definition fru+{v} {y V xr U+{v} y} = {property R U+{v} } {y V xr U y (xr U v vr U y)} = {set calculus} {y V xr U y} {y V xr U v vr U y} = {definition f RU } f RU (x) {y V (v f RU (x)) vr U y} = {set calculus, definition f RU } { fru (v) if v f f RU (x) RU (x) if v / f RU (x) f RU+{v} (v) = f RU (v)

34 transitive closure / Warshall s algorithm (5) 33/57 [ var fr : array(v )of set of V for x : x V do fr[x] : = ; for y : v V do if xry fr[x] : = fr[x] {y} [] (xry) skip fi od od; { fr = f R } for v : v V do for x : x V do if v fr[x] fr[x] : = fr[x] fr[v] [] v / fr[x] skip fi od od { fr = f R + } ]

35 First as reflexive and transitive closure 34/57 for all x, y V xfy α, β : α, β V : x αyβ P α ε xf y β : β V : x yβ for all x V First 1 (x) = {y V α, β : α, β V : x αyβ P α ε } First(x) = {y V β : β V : x yβ }

36 voorbeeld lookaheadsets (1) 35/57 S S S BS ε B (S) FOLLOW (S) = { ), } symbool ) uit regel B (S) symbool uit regel S S regel S BS levert geen bijdrage LA(S S ) = First(S ) = { (, } LA(S BS) = First(BS) = { ( } (BS ε) LA(S ε) = Follow(S) = { ), } LA(B (S)) = First( (S) ) = { ( } LA(S BS) en LA(S ε) zijn disjunct

37 voorbeeld lookaheadsets (2) 36/57 S E E E + T E T T T F T F F p F q F (E) LA(S E ) = { p, q, ( } LA(E E + T ) = { p, q, ( } LA(E T ) = { p, q, ( } laatste 2 lookaheadsets zijn niet disjunct

38 LL(1)-strategie / LL(1)-voorwaarde 37/57 rij vrije onderkanten v 1 v 2 v l rij vrije bovenkanten y 1 y 2 y m meest linkse vrije onderkant v 1 v1 Σ v 1 = y 1 : voeg samen v 1 = A N: speel A α met y 1 LA(A α) v 1 = = y 1 : voeg samen en klaar anders blokkade blokkade invoer / L(G) verkeerde domino gespeeld geen verkeerde keuze te spelen domino LL(1)-voorwaarde voor alle A α P, A β P en α β geldt LA(A α) LA(A β) =

39 implementatie LL(1)-strategie 38/57 stelsel recursieve procedures symbool X V = N Σ procedure P X construeert een parse tree met wortel X voor een prefix van de resterende invoer X X w (NB als X Σ, dan X = w) w

40 tokens en terminals 39/57 STAT ifsym EXPR thensym STATS elsesym STATS fisym STAT if EXPR then STATS else STATS fi STAT idsym becomessym EXPR STAT ID := EXPR ID n voor alle n L(e idsym ) ID pseudoterminal

41 recursive descent parsing procedures (terminals) 40/57 a Σ proc P a = (if sym = a voeg a en sym samen ;NEXTSYM fi ) huidige token sym: meest linkse vrije bovenkant meest recente aanroep parsing procedure: meest linkse vrije onderkant

42 recursive descent parsing procedures (nonterminals) 41/57 A N met productieregels A α 1, A α 2,..., A α k proc P A = (if sym LA(A α 1 ) speel A α 1 ; Q α1 [] sym LA(A α 2 ) speel A α 2 ; Q α2. [] sym LA(A α k ) speel A α k ; Q αk fi ) waarin Q v1 v 2 v n = P v1 ; P v2 ; ; P vn

43 analyse van invoerstring x 42/57 NEXTSYM { sym = el 1 (x ) } ; speel S S ;P S ;if sym = voeg en fi samen (NB geen procedure P : na volgen geen symbolen meer) abortie (blokkade): x / L(G) beëindiging: x L(G) parse tree: - expliciet construeren (als uitvoerparameter parsing procedures) - stapel actieve recursieve procedure-aanroepen wortelpad in parse tree

44 voorbeeld recursive descent parsing procedures (1) 43/57 lookaheadset S S {a, b, c} S asa {a} S bsb {b} S cx {c} X ε {a, b, } X cx {c} proc P S = (if sym {a} P a ; P S ; P a [] sym {b} P b ; P S ; P b [] sym {c} P c ; P X fi) proc P X = (if sym {c} P c ; P X [] sym {a, b, } skip fi) proc P a = (if sym = a NEXTSYM fi) proc P b = (if sym = b NEXTSYM fi) proc P c = (if sym = c NEXTSYM fi)

45 voorbeeld recursive descent parsing procedures (2) 44/57 lookaheadset S S {(, } S BS {(} S ε {), } B (S) {(} proc P S = (if sym {(} P B ; P S [] sym {), } skip fi) proc P B = (if sym {(} P ( ; P S ; P ) fi) proc P ( = (if sym = ( NEXTSYM fi) proc P ) = (if sym =) NEXTSYM fi)

46 vereenvoudiging recursive descent parsing procedures (1) 45/57 proc P a = (if sym = a NEXTSYM fi) (a Σ) TERM(a) met proc TERM = ( a : Σ if sym = a NEXTSYM fi) A α enige regel met A in linkerlid proc P A = (if sym LA(A α) Q α fi) proc P A = (Q α )

47 vereenvoudiging recursive descent parsing procedures (2) 46/57 A α 1,..., A α k, A ε alle regels met A in linkerlid proc P A = (if sym LA(A α 1 ) Q α1 [] sym LA(A α 2 ) Q α2. [] sym LA(A α k ) Q αk [] sym / ( i : 1 i k : LA(A α i )) skip fi)

48 staartrecursie 47/57 A βa A ε LA(A βa) = LA(A ε) = Follow(A) First(β) (β ε) First(β) First(A) Follow(A) LL(1)-conditie leidt tot de eisen (β ε) First(β) Follow(A) = proc P A = (if sym First(β) Q β ; P A [] sym / First(β) skip fi) equivalente procedure (β bevat geen A) proc P A = (do sym First(β) Q β od) andere notatie productieregels A {β} β ε

49 ambigu 48/57 STATS STAT STATS STATS; STATS STATS STATS STATS STATS STATS STATS STATS STATS STATS STATS STAT ; STAT ; STAT STAT ; STAT ; STAT

50 niet ambigu, niet LL(1) 49/57 STATS STATS ; STAT STATS STAT STATS STATS; STAT STATS ; STAT ; STAT STATS STAT ; STATS STATS STAT STATS STAT ; STATS STAT ; STATS STAT ;

51 expressies en prioriteiten 50/57 ambigu E E + E E E E 2 afleidingsbomen E (E) E 3 niet ambigu (prioriteiten) E T (E T {+T }) E E + T T F (T F { F }) T T F F (E) F 3 algemeen (prioriteiten) E i E i+1 (1 i < i MAX ) E i E i OP i E i+1 E imax ID NUMBER (E 1 )

52 factoriseren naar LL(1)-vorm 51/57 A αβ LA(A αβ) = First(αβ)... A αγ LA(A αβ) = First(αγ)... factoriseren A αa A β A γ nieuwe LL(1)-conditie (α ε) niet disjunct als First(α) LA(A β) LA(A γ) =

53 voorbeeld factoriseren 52/57 STATS STAT α = STAT β = ε STATS STAT ; STATS γ =; STATS STATS STAT RSTATS First(STAT ) RSTATS ε Follow(STATS) RSTATS ; STATS { semicolonsym } LL(1)-conditie: {semicolonsym} Follow(STATS) = alternatief RSTATS ; STAT RSTATS eenvoudiger: STATS STAT { ; STAT } proc P STATS = (P STAT ; do sym = semicolonsym NEXTSYM; P STAT od)

54 eliminatie linksrecursie (1) 53/57 A γ LA(A γ) = First(γ)... A Aβ LA(A Aβ) = First(Aβ)... First(γ) First(Aβ) niet disjunt als First(γ) γββ A A β A γ β (γβ)β (linksassociatief)

55 eliminatie linksrecursie (2) 54/57 A γa A γa A γ{β} A ε A {β} A βa LL(1)-conditie: (β ε) First(β) Follow(A ) = (Follow(A ) = Follow(A)) γββ A γ A γ(ββ) β A β A ε

56 eliminatie linksrecursie (3) 55/57 A t γ A γ γ A t β A β A β A γ t β A β t : A A β β A γ ε

57 array variabelen (1) 56/57 a[i + j][2 k] interpretatie: (a[i + j]) [2 k] VAR ID VAR VAR [ EXPR ] LA(VAR ID) = {idsym} LA(VAR VAR [ EXPR ]) = {idsym} LL(1)-vorm VAR ID RVAR RVAR ε RVAR [ EXPR ] RVAR LA(RVAR ε) = Follow(VAR) LA(RVAR [ EXPR ] RVAR) = {lsqbrsym} LL(1)-conditie: lsqbrsym / Follow(VAR)

58 array variabelen (2) 57/57 compacter VAR ID { [ EXPR ] } P VAR = (P ID ; do sym = lsqbrsym NEXTSYM; P EXPR ; TERM(rsqbrsym) od)