Samenvatting hoorcolleges Vertalerbouw

Transcriptie

1 Samenvatting hoorcolleges Vertalerbouw J.H. Jongejan 7 juni 2010 LaTeX van Hedde Bosman en Jan Jongejan. 1

2 Inhoudsopgave 1 Voorbeeld van een vertaling Brontaal (source language) Doeltaal (object- of target-language) Fasen in een vertaler Symbol Table Scanner Parser Semantische analyse Genereratie tussencode Code optimalisatie Code generatie Assembly Talen en Automaten in het kort Reguliere expressies Lemma van Arden Omzetting reguliere grammatica in RE Automaten De structuur van een Reguliere Expressie Berekening van functiewaarden in de knopen Constructie accepterend programma Grammatica s Constructie van een equivalente gereduceerde grammatica Stapelautomaten 11 7 Implementatie van een topdown parser Topdown parser met expliciete stapel Implementatie recursive descent parser (zonder error recovery) Recursive descent parser met errorrecovery Hulpprocedures Foutafhandeling tijdens semantische analyse (geen tentamenstof) Bottom-up parser Het bepalen van de toestanden van de stapelautomaat Action en Goto table LR(1) sets of items Attributengrammatica s (géén tentamenstof) Code generatie Representatie codesegment van een procedure aanroep Code segment procedure declaratie Code bij een procedure aanroep Representatie AR van een (procedure) block Naamgeving binnen blocks (of hoofdprogramma) Naamgeving in een programma met procedures Geheugengebruik tijdens de activation van r Voorbeeld van gebruik van functies als parameters Formele procedure parameters Geheugengebruik in vb

3 1 Voorbeeld van een vertaling 1.1 Brontaal (source language) { N 0 } x := 0; while (x + 1) * (x + 1) <= N do x:= x + 1; { x 2 N < (x + 1) 2 } 1.2 Doeltaal (object- of target-language) M(x) := 0 lw: R0 := M(x) R0 := R0 + 1 R1 := R0 R1 := R1 * R0 cc := R1? N jmpgtr lew M(x) := R0 jmp lw lew: 2 Fasen in een vertaler frontend Analyse Bronprogramma Scanner Parser Semantische analyse Generatie tussencode Symbol table backend Synthese Code optimalisatie Code generatie Assembly Doelprogramma Alle fasen gebruiken een module voor de foutafhandeling. De fasen Semantische analyse en Generatie tussencode worden gezien als semantische acties. 3

4 2.1 Symbol Table De symbol table bevat: string table attribuutwaarden voor elke constante, type, variabele en procedure-identifier 2.2 Scanner De lexicale analyse. Invoer: Rij characters (letters, leestekens,...). Beschrijving: Reguliere Expressies (formeel). Uitvoer: Rij tokens Evt. foutmeldingen Taken: Groeperen van deelrijen characters in invoer tot tokens Signaleren van onjuiste characters Verwijderen van spaties en commentaar 2.3 Parser De contextvrije of syntactische analyse. Invoer: Rij tokens Beschrijving: Contextvrije Grammatica (CFG) (formeel). Uitvoer: Een syntax tree (semantische boom) of een parse tree Evt. foutmeldingen Taken: Bepalen van de structuur van de rij tokens (tree) Controleren van de invoer en signaleren van de fouten 2.4 Semantische analyse Invoer: Semantische boom of parsetree Beschrijving: of Contextvrije grammatica aangevuld met semantische routines of Attributengrammatica (formeel) of Natuurlijke taal Uitvoer: (Gewijzigde) Semantische boom Evt. foutmeldingen Taken: 4

5 Verwerken van declaraties Controleren of gebruikte identifiers gedeclareerd zijn Controleren of programma type correct is Identificeren van operatoren impliciete coërcies expliciet maken een programma voorbeeldje ( geeft een fout aan): PROGRAM vb; VAR s : SET OF [0.. 31] ; k,l : integer ; r1,r2 : real ; PROCEDURE p (f1: integer; VAR f2: integer) f2 := f1 * f1; END (* p *) k := m ; // m s := l ; // l geen set s := s * [8.. 15] ; // doorsnede r2 := 2 * r2 ; // coercie 2.0 p(k, 3, l) END (* vb *) // 2 params, 3 args 2.5 Genereratie tussencode Invoer: Semantische boom Beschrijving: of Attributen grammatica of Semantische routines Uitvoer: of Tussencode (3-adres instructies) of Register Transfers (zie 1.2) Taak: Omvormen van de semantische boom naar tussencode 5

6 2.6 Code optimalisatie Invoer: Tussencode Beschrijving:... Uitvoer: Tussencode (van dezelfde vorm als de invoer) Taak: Wijzigen van de tussencode zodanig dat het aantal operaties tijdens uitvoering van het vertaalde programma wordt teruggebracht 2.7 Code generatie Invoer: Tussencode Beschrijving:... Uitvoer: Rij (pseudo-) machine instructies Taken: Afbeelden van variabelen op het geheugen van de doelmachine Kiezen van de instructies (code selection) Peephole optimalisatie Register allocatie 2.8 Assembly Invoer: Rij (pseudo-) machine instructies Beschrijving:... Uitvoer: Tabellen met machine instructies en overige gegevens voor de linker/loader Taak: Instructies in het gewenste formaat coderen en wegschrijven 3 Talen en Automaten in het kort Een alfabet T is een niet lege eindige verzameling symbolen. Een rij a 1 a 2... a n van n symbolen a i, 1 i n uit een alfabet T wordt een string over het alfabet T genoemd. De lege string, notatie ε, is de string die geen symbolen bevat. De lengte van een string s = a 1 a 2... a n, notatie s is het aantal symbolen in de string s. ε = 0. T is de verzameling van alle strings over het alfabet T, inclusief de lege string. Op de verzameling T is de volgende binaire operatie gedefinieerd: De concatenatie van de strings u = a 1 a 2... a n T en v = b 1 b 2... b m T, notatie uv is de string uv = a 1 a 2... a n b 1 b 2... b m T Bovendien geldt voor alle u T : εu = uε = u. De concatenatie is een associatieve operatie. Zij x = uv met u, v T, dan noemen we u een prefix van x en v een suffix van x. Een taal L over een alfabet T is een deelverzameling van T. Het product (concatenatie van verzamelingen) van twee talen L 1 en L 2, notatie L 1.L 2, is de verzameling strings u 1 u 2 met u 1 L 1 en u 2 L 2 : notatie L 1.L 2. Dit product is associatief. Het eenheidselement is {ε}. De n de macht van een taal L (n 0) wordt gedefineerd door: L 0 = {ε} L n = L.L n 1 (n 1) De transitieve afsluiting L + van een taal L wordt gedefineerd door: L + = n=1 Ln 6

7 De star of de (Kleene) closure van een taal L, notatie L, wordt gedefineerd door: L = L 0 L + Een grammatica G is een 4-tupel (T, N, P, S) waarin: T het alfabet van eindsymbolen is (Terminals). N het alfabet van hulpsymbolen is (Nonterminals). (V = T N wordt het volledige alfabet of Vocabulaire genoemd) P een eindige verzameling producties is, dat wil zeggen expressies van de vorm ϕ ψ met ϕ (T N) + en ψ (T N). S het startsymbool van de grammatica G is. (S N). Zij G = (T, N, P, S) een grammatica. De string X heet direct afleidbaar van X, X leidt direct tot X, of X genereert X wanneer er strings σ, τ, ϕ en ψ (T N) zijn zodanig dat X = σϕτ en X = σψτ en ϕ ψ P. Notatie: X G X of X X. De relatie G (of ) op (T N) is de reflexieve transitieve afsluiting van de relatie G (of ) op (T N). Wanneer X G X zeggen we dat X afleidbaar is van X, of dat X leidt tot X, of dat X in nul of meer stappen X genereert. Een string ϕ (T N) heet een zinsvorm (sentential form) van de grammatica G wanneer S G ϕ. Bevat een zinsvorm ϕ uitsluitend eindsymbolen, ϕ T dan noemen we ϕ een zin (sentence) van G. De taal gegenereerd door de grammatica G, notatie L(G), is de verzameling zinnen van G. Twee grammatica s G 1 en G 2 zijn equivalent dan en slechts dan wanneer L(G 1 ) = L(G 2 ). 3.1 Reguliere expressies Een reguliere expressie (RE) over een alfabet T en de door deze RE beschreven taal worden als volgt gedefinieerd: 1. is een RE voor de taal en ε is een RE voor {ε} 2. a is een RE voor {a} als a T 3. Wanneer E 1 en E 2 RE s over T zijn die de talen L(E 1 ) en L(E 2 ) beschrijven dan is: (E 1 E 2 ) of (E 1 + E 2 ) een RE voor L(E 1 ) L(E 2 ), (E 1 E 2 ) een RE voor L(E 1 ).L(E 2 ) en (E 1 ) een RE voor L(E 1 ). Twee RE s E 1 en E 2 over een alfabet T zijn equivalent dan en slechts dan wanneer L(E 1 ) = L(E 2 ). Notatie: E 1 = E 2. Als E 1, E 2 en E 3 RE s over een alfabet T zijn, dan geldt: a) E 1 E 1 = E 1, E 1 = E 1 b) E 1 E 2 = E 2 E 1 c) (E 1 E 2 ) E 3 = E 1 (E 2 E 3 ) = E 1 E 2 E 3 d) (E 1 E 2 )E 3 = E 1 (E 2 E 3 ) = E 1 E 2 E 3 e) E 1 ε = εe 1 = E 1, E 1 = E 1 = f) (E 1 E 2 )E 3 = E 1 E 3 E 2 E 3 g) E 1 (E 2 E 3 ) = E 1 E 2 E 1 E 3 h) E 1 E 1 = E 1 i) (E 1 ) = E 1 7

8 j) E 1 E 1 = E 1 E 1, E 1 (E 2 E 1 ) = (E 1 E 2 ) E 1 k) ε E 1 E 1 = E 1 l) ε = ε, = ε m) (E 1 E 2 ) = (E 1 E 2 ) = (E 1 E 2 ) n) (E 1 E 2 ) E 1 = (E 1 E 2 ) o) (E 1 E 2 ) = (E 1 E 2 ) E 2 ε p) (E 1 E 2 ) = E 1 (E 1 E 2 ) ε Lemma van Arden E 1 = E 2 E 3 E 1 = E 2 E 1 E 3 en E 1 = E 2 E 1 E 3 ε L(E 2 ) E 1 = E 2 E Omzetting reguliere grammatica in RE De taal gegenereerd uit een symbool X V van een grammatica G is: L(X) = {u u T X G u} De reguliere grammatica wordt geschreven als een stelsel vergelijkingen in de onbekende nonterminals. Alle producties in G met dezelfde nonterminal als linkerlid worden samengevat in één vergelijking. Het stelsel vergelijkingen wordt opgelost door middel van een schoonveegproces. De RE voor het startsymbool van G is een beschrijving van de taal die door de grammatica gegenereerd wordt. 3.2 Automaten Een eindige automaat (FA) bestaat uit een invoerband, een leeskop en een besturingseenheid. rest van de invoer e e n s t r i n g Leeskop Invoerband Besturingseenheid Een (niet-deterministische) eindige automaat (NFA) is een 5-tupel (Q, Σ, δ, q 0, F ) met: Q het toestandsalfabet, Σ het invoeralfabet, δ de (totale) overgangsfunctie: δ : Q (Σ {ε}) 2 Q, Hierbij is 2 Q de verzameling van alle deelverzamelingen van Q. q 0 Q de begintoestand, F Q de verzameling accepterende toestanden. 8

9 Een configuratie van de NFA N = (Q, Σ, δ, q 0, F ) is een expressie van de vorm: qx met q Q en x Σ Op de verzameling configuraties van de NFA N wordt de relatie N (gaat in één stap over in) gedefinieerd door: qx N q x dan en slechts dan als q δ(q, ε) en qax N q x dan en slechts dan als q δ(q, a) voor a Σ, x Σ en q, q Q. ( N is de reflexieve transitieve afsluiting.) Een string x Σ wordt door de NFA N geaccepteerd dan en slechts dan wanneer (q : q F : q 0 x N q). L(N) = {x x Σ (q : q F : q 0 x N q)} is de geaccepteerde taal. Een NFA is een deterministische eindige automaat (DFA) dan en slechts dan als: (q : q Q : δ(q, ε) = ) (a, q : a Σ q Q : #(δ(q, a)) 1) Een voorspellende (deterministische) eindige automaat (PFA) is een 6-tupel (Q, Σ, δ, q 0, F, A) met: Q het toestandsalfabet, Σ het invoeralfabet ( Σ), δ de functie δ : Q (Σ { } Q A de (gedeeltelijke) overgangsfunctie, q 0 de begintoestand, q 0 Q, F Q de verzameling accepterende toestanden, A het alfabet {Read, Skip} (Actie-alfabet). De overgangsfunctie δ voldoet aan: (q, q : q, q Q : δ(q, ) (q, Read)). Een configuratie van de PFA is een expressie van de vorm: qx met q Q en x Σ. Op de verzameling configuraties van de PFA P wordt de relatie gedefinieerd door: P qax q x dan en slechts dan als δ(q, a) = (q, Read), en P qax P q ax dan en slechts dan als δ(q, a) = (q, Skip), en q P q dan en slechts dan als δ(q, ) = (q, Skip), voor a Σ, x Σ en q, q Q. P is de reflexieve transitieve afsluiting van P. Als duidelijk is uit de context wie P is laten we die P weg ( ). Een string x Σ wordt door de PFA geaccepteerd dan en slechts dan als (q : q F : q 0 x q ). De door PFA P geaccepteerde taal is L(P ) = {x x Σ (q : q F : q 0 x P q )}. 4 De structuur van een Reguliere Expressie Een reguliere expressie kunnen we representeren door middel van een boomstructuur op dezelfde wijze als we dat met rekenkundige ezpressies kunnen. 4.1 Berekening van functiewaarden in de knopen In knoop k worden nullable(k) en first(k) berekend aan de hand van de vorm van de knoop: knoop(k) nullable(k) ε true a (a Σ) false k 1 k 2 nullable(k 1 ) nullable(k 2 ) k 1 k 2 nullable(k 1 ) nullable(k 2 ) k 1 + k 1 true nullable(k 1 ) 9

10 knoop(k) first(k) ε a (a Σ) {a} k 1 k 2 first(k 1 ) first(k 2 ) k 1 k 2 k 1 k 1 + IF nullable(k 1 ) THEN first(k 1 ) first(k 2 ) ELSE first(k 1 ) first(k 1 ) first(k 1 ) In knoop k i wordt de functie follow berekend. Voor de wortel van de boom k 0 geldt: follow(k 0 ) =. Voor de overige knopen k i wordt de waarde berekend aan de hand van de ouderknoop k: knoop(k) follow(k i ) k 1 k 2 follow(k 1 ) := follow(k) ; follow(k 2 ) := follow(k) k 1 k 2 k 1 k 1 + IF nullable(k 2 ) THEN follow(k 1 ) := follow(k) first(k 2 ) ELSE follow(k 1 ) := first(k 2 ) ; follow(k 2 ) := follow(k) follow(k 1 ) := follow(k) first(k 1 ) follow(k 1 ) := follow(k) first(k 1 ) De functie LA wordt gedefinieerd door: LA(k) = IF nullable(k) THEN first(k) follow(k) ELSE first(k) 4.2 Constructie accepterend programma De afbeelding τ zet nu een knoop van de boom voor een RE om naar een accepterend programmafragment voor die knoop. τ(ε): (* SKIP *) τ(a): IF nextcl = a THEN getcl ELSE error τ(k 1 k 2 ): IF nextcl LA(k 1 ) THEN τ(k 1 ) ELSE τ(k 2 ) τ(k 1 k 2 ): τ(k 1 ) ; τ(k 2 ) τ(k 1 ): WHILE nextcl first(k 1 ) DO τ(k 1 ) τ(k 1 + ): REPEAT τ(k 1 ) UNTIL nextcl first(k 1 ) Hierbij zijn de characters in classes opgedeeld (alle digits, alle letters, etc.). De procedure getcl leest het volgende invoercharacter en bepaalt de waarde van de variabele nextcl. 10

11 5 Grammatica s Een grammatica is een 4-tupel (T, N, P, S), met V = T N, is gereduceerd dan en slechts dan wanneer: (X : X V : (u, v, x : u, v, x T : S uxv uxv)) Een symbool X V termineert dan en slechts dan wanneer: (x : x T : X x) Een symbool X V heet bereikbaar dan en slechts dan wanneer: (u, v : u, v T : S uxv) 5.1 Constructie van een equivalente gereduceerde grammatica Bepaal eerst de verzameling terminerende non-terminals in G. Verwijder alle overige non-terminals uit N en alle producties waarin niet-terminerende non-terminals voorkomen uit P. Resultaat: equivalente grammatica G = (T, N, P, S) Bepaal vervolgens in G de verzameling bereikbare symbolen. Verwijder alle niet bereikbare symbolen en de producties waarin de niet bereikbare symbolen voorkomen. Resultaat: equivalente gereduceerde grammatica G = (T, N, P, S) 6 Stapelautomaten a + b * c Leeskop Invoerband + Ṭ Lees/schrijfkop Besturingseenheid Stapel Een (niet-deterministische) stapelautomaat (NPDA) is een 7-tupel (Q, Σ, Γ, δ, q 0, Z, F ) met: Q het toestandsalfabet, Σ het invoeralfabet, Γ het stapelalfabet, δ de totale stapelfunctie, δ : Γ Q (Σ {ε}) 2 Γ Q, q 0 Q de begintoestand, Z Γ het startsymbool op de stapel, F Q de verzameling accepterende toestanden. Constructie van een NPDA corresponderend met een CFG (T, N, P, S): Kies: Σ = T Γ = T N (= V ) Q = {q 0 } Z = S F = {q 0 } δ wordt alsvolgt gedefinieerd: δ(a, q 0, a) = {(ε, q 0 )} voor a T δ(x, q 0, a) = voor a T, X V, a X δ(a, q 0, ε) = {(ϕ, q 0 ) A ϕ P } voor A N Een configuratie van een NPDA is een 3-tupel (γ, q, x) met γ Γ, q Q en x Σ. Op de verzameling configuraties van de NPDA N wordt de relatie (gaat in één stap over in) gedefinieerd door: N 11

12 (cα, q, ax) N (βα, q, x) dan en slechts dan als (β, q ) δ(c, q, a) en (cα, q, x) N (βα, q, x) dan en slechts dan als (β, q ) δ(c, q, ε). ( N is de reflexieve transitieve afsluiting van N.) Waar mogelijk laten we die N weg. Een string x Σ wordt door een NPDA geaccepteerd dan en slechts dan als: (Z, q 0, x) (ε, q, ε). De taal geaccepteerd door de NPDA N is: L(N) = {x x Σ (q : q Q : (Z, q 0, x) N (ε, q, ε))}. Een voorspellende stapelautomaat (PPDA) is een 5-tupel (Σ, Γ, δ, Z, A) met: Σ het invoeralfabet ( Σ), Γ het stapelalfabet ( Γ), δ de stapelfunctie, δ : Γ (Σ { }) 2 Γ A, Z Γ het startsymbool op de stapel, A (Action) het actie alfabet {Read, Skip}. De stapelfunctie voldoet aan: (c, γ : c Γ γ Γ : (γ, Read) δ(c, )) Een configuratie van een PPDA is een paar (γ, x ) met γ Γ en x Σ. Op de verzameling configuraties van de PPDA P wordt de relatie (gaat in één stap over in) gedefinieerd P door: (cγ, ax ) (βγ, x ) dan en slechts dan (β, Read) δ(c, a) P (cγ, ax ) P (βγ, ax ) dan en slechts dan (β, Skip) δ(c, a) (cγ, ) P (βγ, ) dan en slechts dan (β, Skip) δ(c, ) P is de reflexieve transitieve afsluiting van P.) Waar mogelijk laten we P weg. Een string x Σ wordt door een PPDA geaccepteerd dan en slechts dan als: (S, x ) (, ). De door PPDA P geaccepteerde taal is: L(P ) = {x x Σ (S, x ) P (, )}. Een PPDA is deterministisch dan en slechts dan als (c, a : c Γ a (Σ { }) : #(δ(c, a)) 1) We gaan in het vervolg uit van de uitgebreide grammatica G van grammatica G: G = (T { }, N Z, P {Z S }, Z). Als dat geen verwarring wekt zullen we ook in de uitgebreide grammatica spreken over T, N, S, P. De lookaheadset LA(A α) van een productie A α P is gelijk aan {a a T { } (w, y, ϕ : w T (y = ε y T.{ }) ϕ V : S waϕ wαϕ way). G G Die LA lijkt nogal lastig te bepalen. Verderop blijkt dit toch efficient te kunnen. L Constructie van een PPDA corresponderend met de uitgebreide grammatica van G: Kies: Σ = T Γ = T N Z = Z (startsymbool van G ) De stapelfunctie δ wordt gedefinieerd door: δ(a, a) = {(ε, Read)} voor a T δ(a, b) = voor a T, b T { }, b a δ(a, b) = {(α, Skip) A α P b LA(A α)} δ(a, b) = als geen van de voorgaande geldt De met G corresponderende PPDA is deterministisch dan en slechts dan als: (A α, A β P α β : LA(A α) LA(A β)= ) 12

13 Voor G worden de volgende functies gedefinieerd: first : V 2 T first(ϕ) = {b b T (σ : σ V : ϕ bσ)} G nullable : V Boolean nullable(ϕ) = ϕ ε G follow : N 2 T follow(a) = {b b T (B, σ, τ : B N σ V τ V : B + G σabτ) richters : P 2 T richters(a α) = IF nullable(α) THEN first(α) follow(a) ELSE first(α) FI Wanneer een grammatica gereduceerd is geldt voor elke productie A α P : richters(a α) = LA(A α) Een grammatica is LL(1) dan en slechts dan als voor elk tweetal producties A α en A β, met zelfde linkerlid A en α β, geldt: LA(A α) LA(A β) = Een LL(1) grammatica is niet ambigu. Wanneer een gereduceerde grammatica een linksrecursieve nonterminal bevat is deze grammatica zeker niet LL(1). 7 Implementatie van een topdown parser We gaan uit van een gereduceerde LL(1) grammatica. De eerste implementatie gebruikt een expliciete stapel datastructuur. 7.1 Topdown parser met expliciete stapel We implementeren een topdown parser voor de uitgebreide grammatica voor G E. De grammatica G E kent de volgende producties: E T X, T F Y, X +T X, X, Y F Y, Y, F a b c (E) 13

14 (* initialisaties *) nextsym ; (* initialisatie variabele sym *) initstack ; push( ); push(e); (* stack: E *) WHILE top DO CASE top OF a, b, c, (, ),, +: IF sym = top THEN pop; nextsym END ELSE error E: IF sym {a, b, c, (} THEN (* richters E T X *) pop; push(x); push(t ) END ELSE error T : IF sym {a, b, c, (} THEN pop; push(y ); push(f ) END ELSE error X: IF sym {+} THEN (* richters X +T X *) pop; push(x); push(t ); push(+) END ELSE IF sym {), } THEN (* richters X *) pop ELSE error... END (* CASE *) END (* WHILE *) IF sym THEN error; (* acceptatie *) END 7.2 Implementatie recursive descent parser (zonder error recovery) De tweede implementatie gebruikt een verzameling recursieve procedures: recursive descent. Voor het herkennen van een terminal: PROCEDURE match(fs : tsymbol); IF sym = fs THEN nextsym ELSE error END (* match *) Het hoofdprogramma corresponderend met extra product Z S : 14

15 (* initialisaties *) nextsym ; (* initialisatie sym *) ps; IF sym THEN error; (* acceptatie *) END Voor een string ϕ V worden de statements τ(ϕ) gegenereerd: (* SKIP *) als ϕ = ε match(a) pa τ(ψ) ; τ(x) als ϕ = a T als ϕ = A N als ϕ = ψx met ψ V + en X V Voor het herkennen van een A N met m 2 producties A ϕ 1, A ϕ 2,..., A ϕ m : PROCEDURE pa; IF sym LA(A ϕ 1 ) THEN τ(ϕ 1 ) END ELSE IF sym LA(A ϕ 2 ) THEN τ(ϕ 2 )... END ELSE IF sym LA(A ϕ m ) THEN τ(ϕ m ) END ELSE error END (* pa *); Voor het herkennen van A N die precies één productie A ϕ heeft: PROCEDURE pa; τ(ϕ) END (* pa *); We kunnen ons een test uitsparen met een simpele truc. Kies voor elke nonterminal A N één productieregel als default regel, en wel juuist die productie die het snelst termineert. Verwissel die productie nu met A ϕ m. Het nieuwe recept luidt dan alsvolgt: PROCEDURE pa; (* A ϕ m als default regel *) IF sym LA(A ϕ 1 ) THEN τ(ϕ 1 ) END ELSE IF sym LA(A ϕ 2 ) THEN τ(ϕ 2 )... END ELSE IF sym LA(A ϕ m 1 ) THEN τ(ϕ m 1 ) END ELSE τ(ϕ m ) END END (* pa *); 15

16 7.3 Recursive descent parser met errorrecovery Als we een fout hebben aangetroffen in de invoer is de parser in een geblokkeerde configuratie. Eerst wat hulpdefinities: Een string u T is een geldige prefix van de taal L(G) dan en slechts dan wanneer (v : v T : uv L(G)). Een string v T met uv L(G) wordt een voortzetting (continuation) van de geldige prefix u genoemd. Het symbool a T in de string xay (x, y T ) is het foutsymbool van deze string dan en slechts dan wanneer x een geldige prefix is en xa niet een geldige prefix is. Voor een bepaalde voortzetting v van een geldige prefix x wordt de verzameling anchors gedefinieerd door: anchors(v) = {a T (v p : v p T : v p is een prefix van v xv p a is een geldige prefix} Stel a T is het foutsymbool in xay en S L xϕ, met ϕ = X 1 X 2... X n (n 1, X i V, dan wordt de (geblokkeerde) configuratie (ϕ, ay) hersteld door de volgende acties uit te voeren: 1. Bepaal de voortzetting v = v 1 v 2... v n uit X 1 X 2... X n zodanig dat X i v i door uitsluitend default producties toe te passen. 2. Bepaal de verzameling keys, gedefineerd door keys = n i=1 first(x i). Deze keys zullen we gebruiken als implementatie van anchors(v). 3. Verwijder de vooroplopende symbolen van ay die niet tot de verzameling keys behoren. Geef voor elk verwijderd symbool een foutmelding. Rest van de invoer is ky (een suffix van ay) en k keys. 4. Wijzig de configuratie, te beginnen met (ϕ, ky ), zolang k niet geaccepteerd kan worden, door de stappen uit te voeren die corresponderen met het verwerken van een aantal vooroplopende symbolen (via default producties) van de voortzetting v. Geef voor elk toegevoegd symbool een foutmelding. Hierna laten we zien hoe dit geïmplemteerd kan worden Hulpprocedures PROCEDURE deletion; Verzorg foutmelding: sym deleted PROCEDURE insertion (fs : tsymbol); Verzorg foutmelding: fs inserted PROCEDURE delete (keys : tsymbolset); WHILE NOT (sym IN keys) DO deletion; nextsym END { POST sym keys } END (* delete *); Voor het herkennen van een terminal: 16

17 PROCEDURE match(fs : tsymbol; keys: tsymbolset); IF fs = sym THEN nextsym ELSE delete({f s} + keys); IF sym = fs THEN nextsym ELSE insertion(fs) END END (* match *) Hoofdprogramma corresponderend met de extra productie Z S : (* initialisaties *) nextsym (* initialisatie sym *) ps({ }); delete({ }); (* finalisatie *) END Voor een string ϕ V worden de statements τ(ϕ, keys) gegenereerd: τ(ϕ, keys) (* SKIP *) als ϕ = ε match(a, keys) pa(keys) τ(ψ, keys + first(x)); τ(x, keys) als ϕ = a T als ϕ = A N als ϕ = ψx met ψ V + en X V Voor het herkennen van een string uit L(A) voor A N met precies één productie A ϕ: PROCEDURE pa(keys : tsymbolset); τ(ϕ, keys) END (* pa *); Voor het herkennen van een string uit L(A) voor A N met m 2 producties A ϕ i (1 i m), waarbij A ϕ m de defaultproductie voor A is. (Alleen ϕ m is eventueel nullable!) PROCEDURE pa(keys : tsymbolset); delete(first(a) + keys); IF sym first(ϕ 1 ) THEN τ(ϕ 1, keys) END ELSE IF sym first(ϕ 2 ) THEN τ(ϕ 2, keys)... END ELSE IF sym first(ϕ m 1 ) THEN τ(ϕ m 1, keys) END ELSE τ(ϕ m, keys) END END (* pa *); 7.4 Foutafhandeling tijdens semantische analyse (geen tentamenstof) Statische semantische fouten worden ontdekt tijdens het berekenen van de attributen van de knopen van de abstract syntax tree (AST), en wel bij de controle of de attribuutwaarden aan bepaalde voorwaarden (de context conditions) voldoen. 17

18 Doel: Signaleren van meerdere semantische fouten in de programmatekst in één vertaalslag. Overbodige foutmeldingen moeten worden vermeden evenals niet terechte foutmeldingen (spurious errors). Herstelactie van een semantische fout moet eenvoudig uitgevoerd kunnen worden. In geen geval mag een foutief programma worden geaccepteerd. Uitgangspunt: Een syntactisch correct programma of daarmee corresponderende AST. Inventarisatie mogelijke semantische fouten: 1. Symbolen die door de parser zijn verwijderd (delete actie in error recovery). 2. Symbolen die door de parser zijn toegevoegd (insert actie in error recovery). 3. Niet gedeclareerde identifiers worden gebruikt. 4. Het gebruik van een identifier is niet consistent met de declaratie. 5. Dubbel gedeclareerde identifiers in een block 6. Bij typecontrole van expressies: het gebruik van een operator is niet consistent met de definitie. 8 Bottom-up parser We introduceren het begrip item: een productie met ergens in de rechterkant een., de voortgangswijzer, bijvoorbeeld E T. + E. De T is herkend, we verwachten nog een string afleidbaar uit +E. We leiden nu een bottom-up parser af bij de producties: 1) S asb 2) S A 3) A c 4) B bb 5) B c 8.1 Het bepalen van de toestanden van de stapelautomaat De closure berekening van een toestand van de stapelautomaat: C := "kernel"; repeat oldc := C; forall A α.bβ C do forall B γ P do C := C B.γ until oldc = C 18

19 1. Z S, 2 6. S as B, 7 S asb, 3 B bb, 8 S A, 4 B c, 9 A c, 5 7. S asb red 2. Z S acc 8. B b B, S a SB, 6 B bb, 8 S asb, 3 B c, 9 S A, 4 A c, 5 9. B c red 4. S A red 10. B bb red 5. A c red 8.2 Action en Goto table Een item van de vorm A α.tβ met t T geeft een shift aktie aan (lees t van de input). Een item van de vorm A α. geeft een reduce aktie aan, dat wil zeggen pas de productie A α in omgekeerde richting toe. Soms bevat een toestand zowel een shift als een reduce aktie. We noemen dat een shift/reduce conflict. Een tweede soort conflict is wanneer er in een toestand twee verschillende reducties mogelijk zijn: reduce/reduce conflict. Een voorbeeld: bij de grammatica G met productieregels 1) E E + T 2) E T 3) T T F 4) T F 5) F id 6) F (E) kunnen we opnieuw de toestanden van de herkennende automaat uitrekenen en daaruit de action en goto table construeren. We zien een shift/reduce conflict in de uitgerekende toestanden 2 en 9. We kunnen echter een keuze maken door gebruik te maken van follow(e). Kies voor reductie wanneer het inputsymbol in follow(e) zit en doe anders een shift. Dit alles vinden we terug in de Action en Goto table: id + * ( ) E T F 0 S S6 ACC 2 R2 S7! R2 R2 3 R4 R4 R4 R4 4 R5 R5 R5 R5 5 S4 S S4 S S4 S S6 S11 9 R1 S7! R1 R1 10 R3 R3 R3 R3 11 R6 R6 R6 R6 Om een keuze te maken uit twee reducties moet de doorsnede van de follow sets van beide linkerleden disjunct zijn. Wanneer we zo alle conflicten hebben kunnen oplossen heet de grammatica Simpel LR(1) (SLR(1)). Lukt dit niet met follow informatie dan hebben we een krachtiger parsing algoritme nodig. 19

20 8.3 LR(1) sets of items Een LR(1) item is een paar, bestaande uit een gewoon (LR(0)) item en een lookahead symbol, bijvoorbeeld (E T. + E, ) ). Als LR(1) voorbeeld nemen we de volgende producties: 1) Z S 2) S E = E 3) S f 4) E E + T 5) E T 6) T T + f 7) T f De LR(1) berekening van de closure van een toestand lijkt erg op die van LR(0): C := "kernel"; repeat oldc := C; forall (A α.bβ, a) C do forall B γ P do forall b f irst(βa) do C := C (B.γ, b) until oldc = C Voor de gegeven producties leidt dit tot de volgende toestanden: 1. Z S, {?} 8. S E = E, { } S E = E, { } E E +T, {, +} S f, { }, E T, {=, +} 9. E T, {, +} E E + T, {=, +} T T f, {, +, } T f, {=, +, }, T T f, {=, +, } 10. T f, {, +, }, 2. Z S, {?} 11. T f, {=, +, }, 3. S E = E, { } 12. E E + T, {=, +} E E +T, {=, +} T T f, {=, +, }, 4. E T, {=, +} 13. T T f, {=, +, } T T f, {=, +, }, 14. T T f, {=, +, } 5. S f, { }, T f, {=, +, } 15. E E + T, {, +} T f, {, +, } 6. S E = E, { } T T f, {, +, } E E + T, {, +}, E T, {, +} 16. E E + T, {, +} T f, {, +, } T T f, {, +, } T T f, {, +, }, 17. T T f, {, +, } 7. E E + T, {=, +}, T T f, {=, +, } 18. T T f, {, +, } T f, {=, +, }, We zien een shift/reduce conflict in toestanden 4, 8, 9, 12 en 16. Bovendien een reduce/reduce conflict in toestand 5. Hierbij is het conflict in toestand 5 niet oplosbaar met follow informatie, zodat deze grammatica 20

21 niet SLR(1) is. We zien dat alle conflicten wel opgelost worden met de LR(1) sets of items. Deze grammatica is daarom LR(1). Bij de grammatica G met productieregels 1) Z S 2) S A B A 3) A a A 4) A b 5) B B b 6) B vinden we: 1. Z S, {} 6. S AB A, { } S ABA, { } B B b, {a, b} A aa, {a, b} A aa, { } A b, {a, b} A b, { } 2. Z S, {} 7. A aa, {a, b} 3. S A BA, { } 8. S ABA, { } B Bb, {a, b} B, {a, b} 9. B Bb, {a.b} A b, { } 4. A a A, {a, b} A aa, {a, b} 10. A a A, { } A b, {a, b} A aa, { } A b, { } 5. A b, {a, b} 11. A b, { } 12. A aa, { } Meerdere toestanden zijn gelijk qua eerste component maar verschillen in de tweede component van ieder LR(1) item. Wat gebuert er wanneer we die toestanden mergen? Te mergen toestanden zijn: (4, 10), (5, 11), (7, 12). Mergen levert geen reduce/reduce conflicten op, dan noemen we de grammatica Lookahead LR(1) (LALR(1)). Opmerking bij toestand 9: niet SLR(1), wel LR(1). De Action en Goto tabel zijn nu: a b S A B 1 S4 S acc 3 R6 R6 R6 6 4* S4 S5 7 5* R4 R4 R4 6 S4 S9 8 7* R3 R3 R3 8 R2 R2 R2 9 R5 R5 R4! * = gemerged 9 Attributengrammatica s (géén tentamenstof) Grammatica: int denot : digit SEQUENCE, radix PACK { digit < radix and intdenot < 32767} radix : digit SEQUENCE { radix {2, 8, 10} } 21

22 Correcte zinnen: 1101(2), 1101(10), 776(8) Production Attribute Rule int denot : number { number.r := radix.r;, radix PACK int denot.v := number.v;. CHECK radix.r IN [2,8,10] } radix : digit { radix.r := digit.v } ; radix 1, digit { radix.r := 10 * radix 1.R + digit.v }. digit : { digit.v := } ; ; 9 { digit.v := 9 }. number : digit { number.v := digit.v; check digit.v < number.r } ; number 1, digit { number 1.R := number.r; number.v := number.r * number 1.V + digit.v;. CHECK digit.v < number.r AND number.v } NT attributen-types int denot V {syn} radix R{syn} digit V {syn} number V {syn}, R{inh} T: radnum/int denot number ( radix ) number digit digit digit CDG(T): V ( R V ) ( R V ) V V R V V = Val R = Rad 22

23 10 Code generatie 10.1 Representatie codesegment van een procedure aanroep Vertaling van de declaratie τ(proc p; block_p) en van de aanroep τ(p) moeten we zodanig op elkaar afstemmen dat: 1. het codesegment τ(proc p; block_p) één keer in het doelprogramma voorkomt, 2. tijdens de uitvoering van de instructies in τ(p) de regie wordt overgedragen aan τ(proc p; block_p), en 3. na de uitvoering van de instructies in τ(proc p; block_p) de regie wordt overgedragen aan de volgende instructie na de juiste aanroep τ(p) PROGRAM vb1; VAR a, i : INTEGER; PROCEDURE p (VAR x : INTEGER); VAR b, i : INTEGER;... i... a... b... p(b)... i... END... i... a... p(i)... END (* vb1 *) Tijdens de 2 e activation van p: Codesegment vb1 Aanroep p Codesegment p Aanroep p ra(1) ra(2) AR vb1 waarde a = A 0 waarde i = I 0 AR p (1) waarde x = I 0 waarde b = B 1 waarde i = I 1 AR p (2) waarde x = B 1 waarde b = B 2 waarde i = I 2 23

24 Code segment procedure declaratie τ(proc p; block p) : lab p: proc entry τ(block p) proc exit proc exit { dst := pop(returnstack) jump dst ; o.a. geheugenbeheer ; o.a. geheugenbeheer } return Code bij een procedure aanroep τ(p) : retlab: parameter prelude push(returnstack,retlab) jump lab p parameter postlude ; klaarzetten van de parameters } call lab p ; evt result parameters kopiëren 10.2 Representatie AR van een (procedure) block 1. plaats van variabele of parameter in AR, 2. toegang tot variabele in een levend AR, 3. instructies bij block entry/exit en bij proc entry/exit 4. geheugenbeheer 5. parameter overdracht en instructies in parameter prelude/postlude. Conventie: identifier (variabele identifier) om een variable in de programmatekst aan te geven. naam (variabele naam) om een variabele tijdens compilatie aan te geven. adres om een variabele tijdens de uitvoering van het vertaalde programma te vinden Naamgeving binnen blocks (of hoofdprogramma) Vb2: B 0 : DECLARE a, b, c : INTEGER;... B 1 : DECLARE d, e, f : INTEGER;... d... b... END B 1 ;... B 2 : DECLARE g, h : INTEGER;... h... c... END B 2 ; END B 0 ; 24

25 gereserveerd geheugen c b a f e d Activation B 1 h g Activation B 0 Activation B 2 tijd Plaats direct bereikbare identifiers namen (= adressen) B 0 a, b, c 0, 1, 2 B 1 a, b, c, d, e, f 0, 1, 2, 3, 4, 5 B 2 a, b, c, g, h 0, 1, 2, 3, 4 Naamgeving: Opeenvolgende identifiers in een block krijgen opeenvolgende namen. De eerste identifier in het buitenste block krijgt de naam 0 (nul). De eerste identifier in een binnenblock krijgt de naam 1+ naam van de laatste identifier uit het direct omvattende block Naamgeving in een programma met procedures PROGRAM vb3; VAR a, b, c : INTEGER; (* voorlopige namen: 0, 1, 2 *) PROCEDURE p; VAR d, e, f : INTEGER (* voorlopige namen: 0, 1, 2 *)... END (* p *) PROCEDURE q; VAR g, h : INTEGER (* voorlopige namen: 0, 1 *) PROCEDURE r; VAR i, j, k : INTEGER (* voorlopige namen 0, 1, 2 *)... p 2... r 2... END (* r *)... r 1... END (* q *)... p 1... q... END (* vb3 *) 25

26 gereserveerd geheugen f e d i p k 2 j r 2 f i e h r 1 d g c p 1 b a q vb3 k j tijd Plaats direct bereikbare identifiers verband tussen namen en adressen vb3 a, b, c adres = naam p 1 a, b, c adres = naam d, e, f adres = naam+3 q a, b, c adres = naam g, h adres = naam+3 r 1 a, b, c adres = naam g, h adres = naam+3 i, j, k adres = naam+5 p 2 a, b, c adres = naam d, e, f adres = naam+8 r 2 a, b, c adres = naam g, h adres = naam+3 i, j, k adres = naam+8 Dit gaan we verder in detail uitwerken. Een naam is nu een paar. We houden een functie display bij, zodanig dat de naam (x.pn,disp) wordt afgebeeld op adres(x) = display(x.pn) + disp. Implementatie van de functie display kan op drie manieren gerealiseerd worden: 1. Tijdens de uitvoering van de huidige procedure (curr) zijn de functiewaarden van display opgeslagen in de registers R.0 tot en met R.curr.PN (R.l = display(l)). Het assignment k := g (met name(k)=(2,2) en name(g)=(1,0)) wordt dan omgezet naar: M(R2+2) := M(R1+0) 2. Tijdens de uitvoering van de huidige procedure zijn de functiewaarden van display opgeslagen in een tabel in het geheugen. Als D0 het beginadres is van de tabel wordt het assignment k := g: R0 := M(D0+2); R1 := M(D0+1); M(R0+2) := M(R1+0) 3. Tijdens de uitvoering van de huidige procedure zijn een aantal functiewaarden van display in het geheugen opgeslagen. Deze opgeslagen waarden vormen een linked list: de statische keten (static chain). De overige functie-waarden zijn opgeslagen in registers; met name zit in register LNB (local name base) display(curr). Merk op dat k nu naam (2,3) heeft, omdat plaats (2,0) nu de start van de statische keten (static link (SL)) bevat. Het assignment k := g wordt nu: R0 := M(LNB); M(LNB+3) := M(R0+0) 4. We hebben nog geen rekening gehouden met het korrekt terugplaatsen van de oude LNB bij het verlaten van een procedure. Daarom passen we opnieuw de naamgeving aan, in r 2 beginnen de lokalen nu bij 2 (ipv. 0), en in p 2 bij 1 (ipv. 0). 26

27 Geheugengebruik tijdens de activation van r k j i old LNB 6 SL 3 k j i old LNB 3 SL 3 h g old LNB 0 c b a AR r 2 AR r 1 AR q AR vb3 Vertaling van k := g (in r): R 0 := M(LNB) M(LNB+4) := M(R 0 +1) 10.3 Voorbeeld van gebruik van functies als parameters PROGRAM form; VAR s1, s2 : INTEGER; FUNCTION kwadr(v: INTEGER) : INTEGER; kwadr := v*v END (* kwadr *); FUNCTION derdem(v: INTEGER) : INTEGER; derdem := v*v*v END (* derdem *); PROCEDURE sommeer(van, tot : INTEGER; FUNCTION f(i : INTEGER) : INTEGER; VAR som : INTEGER); VAR k : INTEGER; som := 0; for k := van TO tot DO som := som + f(k); END (* sommeer *) sommeer(0, 100, kwadr, s1); sommeer(0, 100, derdem, s2); END (* form *) Dit is duidelijk een verrijking van de brontaal! 27

28 Formele procedure parameters PROGRAM vb4; PROCEDURE a (PROCEDURE fp); PROCEDURE b;... fp... END (* b *);... b... END (* a *); PROCEDURE c; PROCEDURE d; PROCEDURE e;... END (* e *)... a(e)... END (* d *)... a 1 (d)... END (* c *);... c... END (* vb4 *) Geheugengebruik in vb4 Herinner je dat we in procedures met P N = 1 de namen van lokale variabelen bij 1 beginnen te nummeren en voor P N 2 bij 2 beginnen te nummeren. In de volgende figuur zien we het geheugengebruik op het moment dat e aangeroepen is. 28

29 . a 8 a 7 a 6 a 5 a 4 a 3 a 2 a 1 0 old LNB: SL: old LNB: SL: param fp: old LNB: old LNB: SL: old LNB: SL: old LNB: a 6 a 4 a 5 a 5 e a 4 a 3 a 1 a 2 a 2 0 AR e AR b AR a 2 AR d AR b AR a 1 old LNB: a 1 param fp: d AR c AR vb4 display(0..3) = (0,a 1,a 4,a 7 ) display(0..2) = (0,a 5,a 6 ) display(0..1) = (0,a 5 ) display(0..2) = (0,a 1,a 4 ) display(0..2) = (0,a 2,a 3 ) display(0..1) = (0,a 2 ) display(0..1) = (0,a 1 ) display(0..0) = (0) Procedure b weet niet wie procedure fp in werkelijkheid is. Als b de parameter aan wil roepen heeft hij de SL van fp nodig en zijn startadres. Een formele procedure parameter wordt dus op de stack gerepresenteerd door een paar (startadres,static link). 29