Regular Expression vs. Context-Free Grammars. Ambiguity. NFA to CFG. Neden RE ler kullanilir?

Transkript

1 Ambiguity Ambiguous Grammar: Bazi sentence lar icin birden fazla parse tree ureten grammarlere denir. Ambiguous Grammar ler bazi sentence lari birden fazla leftmost/rightmost derivation larla utetirler. Cogu parser lar ambiguity elimine etmeye calisirlar Regular Expression vs. Context-Free Grammars - RE ile ifade edilebilen her bir dil CFG ile de ifade edilebilir. (a b)*abb A 0 aa 0 ba 0 aa 1 A 1 ba 2 A 2 ba 3 A 3 5/24/2004 Formal Diller 5.1 5/24/2004 Formal Diller 5.2 start (a b)*abb a/b 0 a 1 2 A 0 aa 0 ba 0 aa 1 A 1 ba 2 A 2 ba 3 A 3 b NFA to CFG b 3 NFA daki her bir state icin bir nonterminal olustur. Eger state i den state j ye a sembolu ile gecis varsa A i aa j bir turetimdir. Eger i start state ise A i dilin start semboludur. Neden RE ler kullanilir? Her RE ile ifade edilebilen dil, CFG ile ifade edilebiliyorsa neden RE lar dilin lexical syntax ini ifadede kullanilir? Lexical rules (kurallar) oldukca basit, dolayisiyle onlari tanimlamak icin grammar ler gibi guclu notasyonlara ihtiyacimiz yoktur. RE genellikle daha kolay anlasililir compact notasyonlar kullanir. Lexical analyzer lar RE lerden daha etkin bir sekilde otomatik olarak olusturulabilirler. Compiler design da basitlik saglanir Dilin syntactic yapisi lexical ve nonlexical bolumlere ayrilmak suretiyle compilerin front end kismi modulerize olmus olur. 5/24/2004 Formal Diller 5.3 5/24/2004 Formal Diller 5.4

2 CFG le Uretilen Dilin Ispati Grammar G nin L language ni olusturdugunu ispatlamak icin asagidaki iki seyi gostermemiz gerekir G nin urettigi her string in L de oldugunu gostermemiz L nin her bir stringi G tarafindan uretilebilir 5/24/2004 Formal Diller 5.5 S den uretilen her bir string balanced? Tume varim: Basis step: tek turetimle elde edilebilen tek string (balanced). Assumption: n stepten daha az sayida turtimle elde edilen tum stringler balanced olsun. S (S)S (x)s (x)y x ve y nin turetimi n den daha az steple oldugundan, x,y balanced Ornek S (S)S Her bir balanced string S den turetilebilinir mi? Tume varim: Basis step: S den turetilebilir. Assumption: boyu 2n (n >=1) den kucuk olan her string S den turetilebilsin ve w nun boyu 2n olsun. (x) in w nin esit sayida sol ve sag parantzleri olan en kisa prefixi oldugunu dusunelim. w (x)y olarak yazilabilir. 5/24/2004 Formal Diller 5.6 Ambiguity nin Elimine Edilmesi dangling-else if E 1 then if E 2 then S 1 else S 2 stmt if expr then stmt if expr then stmt else stmt other if stmt expr then stmt stmt if expr then stmt else stmt E 1 if expr then stmt else stmt E 1 if expr then stmt S 2 E 2 S 1 S 2 E 2 S 1 5/24/2004 Formal Diller 5.7 Iki farkli parse tree 5/24/2004 Formal Diller 5.8

3 Left Recursion stmt if expr then stmt if expr then stmt else stmt other Asagidaki verilen ozellige sahip grammar e left recursive denir. A + A turetimine imkan veren bir nonterminale sahip. stmt matched_stmt unmatched_stmt matched_stmt if expr then matched_stmt else matched_stmt other unmatched_stmt if expr then stmt if expr then matched_stmt else unmatched_stmt A A left recursion elimination A A A A 5/24/2004 Formal Diller 5.9 5/24/2004 Formal Diller 5.10 A A 1 A 2 A m 1 2 n Immediate left recursion elimination E E + T T T T * F F F (E ) id A 1 A 2 A n A A 1 A 2 A m A 5/24/2004 Formal Diller 5.11 E TE E +TE T FT T * FT F ( E ) id 5/24/2004 Formal Diller 5.12

4 S Aa b A Ac Sd S Aa Sda Left recursive, immediately left recursive degil Left recursion elimination Eger grammar de cycle yoksa (A + A yok) veya -production yok Input: Grammar G (no cycles veya -production ) Output: Esdeger grammar (no left recursion) 5/24/2004 Formal Diller /24/2004 Formal Diller Nonterminalleri A 1, A 2,, A n olarak duzenle. 2. for i:=1 to n do begin for j:= 1 to i-1 do begin A i A j seklindeki her bir production i A j 1 2 k ile yerdegistir. Burada A j 1 2 k original gram mardaki productionlardir. end A i productionlarindaki immediate left recursioni elimine et. end 5/24/2004 Formal Diller 5.15 S Aa b A Ac Sd Non-terminal sirasi: S, A S-productionlarda no immediate left recursion i=2 icin A Sd production i A Aad bd ile yer yer degistirilir. S Aa b A Ac Aad bd S Aa b A bda A A ca ada 5/24/2004 Formal Diller 5.16

5 Left factoring Left Factoring Predictive Parser larda kullanilir. stmt if expr then stmt else stmt if expr then stmt A 1 2 Left factoring A A A 1 2 5/24/2004 Formal Diller 5.17 Left Factoring Input. Grammar G Output. An equivalent left-factored grammar Method. Her bir nonterminal A icin iki veya daha cok alternatifindeki en uzun prefix yi bul. Eger dan farkli ise A ( Burada ile baslamayan tum alternatifleri gosterir) yi asagidaki turetimlerle yer degistir. A A A 1 2 n 5/24/2004 Formal Diller 5.18 Top-down Parsing stmt if expr then stmt else stmt if expr then stmt a expr b Giris stringi icin bir leftmost derivation bulma anlamina gelir Ayni zamanda root dan baslayarak treenin node larini preorder sirada bulmak suretiyle bir parse tree uretmek anlamina gelir stmt if expr then stmt stmt a stmt else stmt expr b 5/24/2004 Formal Diller /24/2004 Formal Diller 5.20

6 Recursive descend parsing Top-down parsing in genel halidir. Backtracking e ihtiyac duyulabilir S S cad A ab a Input string w=cad c S A d backtracking c c a S A S A d b d 5/24/2004 Formal Diller /24/2004 Formal Diller 5.22 a Predictive Parser Predictive Parser Predictive parser with no backtracking Eliminating left recursion Left factoring Verilen her bir input sembol icin yalniz bir alternatif turetim vardir. Stack X Y Input a + b Predictive Parsing Program Output Z stmt if expr then stmt else stmt while expr do stmt begin stmt_list end Parsing Table M 5/24/2004 Formal Diller /24/2004 Formal Diller 5.24

7 4 kisimdan olusur Input buffer: Parserin inputunu icerir. Buffer in sonuna input string in sonunu gosteren eklenir. Stack: Grammar sembollerini icerir. Stack in dibinde (stackin dibi oldugunu gosteren) sembolu bulunur. Baslangicta stack de sadece vardir. Parsing Table: Iki boyutlu bir dizidir. Dizininin herbir elemani M[A,a] (A nonterminal, a ise terminal veya dir) seklindedir. Output: Eger input verilen grammar tarafindan taninirsa cikis, girisin leftmost derivation i, aksi halde error. 5/24/2004 Formal Diller 5.25 Baslangicta S stackte ve w giris bufferinda. ip w nin ilk sembolune isaret ediyor repeat X stack in ustundeki sembol ve ip a yi isaret ediyor; if X bir terminal veya then if X = a then pop X from the stack ve ip i sonraki sembolu gosterecek sekilde ilerlet else error( ) else /* X nonterminal */ if M[X,a] = X Y 1 Y 2 Y k then begin pop X from the stack; push Y k,y k-1,, Y 1 onto stack ( Y 1 en ustte olacak sekilde); output the production X Y 1 Y 2 Y k end else error( ) until X = /* stack is empty */ 5/24/2004 Formal Diller 5.26 Predictive Parsing Program E TE E +TE T FT T *FT F ( E ) id Input: Giris stringi w ve grammar G icin parsing table M Output: Eger w L(G) nin bir elemani ise, cikis w nin bir leftmost derivation i, aksi halde error. Nonter minal E E T T F id E TE T FT F id + E +TE T Input Symbol * ( E TE T FT T *FT F (E) ) E T E T 5/24/2004 Formal Diller /24/2004 Formal Diller 5.28

8 Stack E E T E T F E T id E T E E T + E T E T F E T id E T E T F * E T F E T id E T E Input id + id * id id + id * id id + id * id id + id * id + id * id + id * id + id * id id * id id * id id * id * id * id id id Output E T E T F T F id T E + T E T F T F id T * FT F id T E FIRST and FOLLOW Predictive Parser in Table ini doldurmak icin kullanilir FIRST Eger grammar sembollerinden olusan bir string ise FIRST( ) dan tureyen stringlerin basindaki nonterminallerin kumesi Eger * ise, FIRST( ) yi icerir. FOLLOW Nonterminal A icin FOLLOW(A) sentential formdaki A nin hemen saginda bulunan terminallerin kumesi Eger S * A a ise, FOLLOW(A) a yi icerir 5/24/2004 Formal Diller /24/2004 Formal Diller 5.30 Algorithm for FIRST Algorithm for FOLLOW 1. Eger X bir terminal ise, FIRST(X) = {X} 2. Eger X ise, yi FIRST(X) e ekle 3. Eger X Y 1 Y 2 Y k ise, ve bazi i icin FIRST(Y i ) a yi iceriyor ve FIRST(Y 1 ), FIRST(Y 2 ),, FIRST(Y i-1 ) yi iceriyorsa, a yi FIRST(X) e ekle. Nonterminal A icin FOLLOW(A) asagidaki gibi hesaplanir. 1. S start sembolu ise FOLLOW(S) yi icerir. 2. Eger A B ise, haric FIRST( ) deki her seyi FOLLOW(B) icerir 3. Eger A B, veya A B ve FIRST( ) yi icerirse FOLLOW(A) daki her seyi FOLLOW(B) icerir 5/24/2004 Formal Diller /24/2004 Formal Diller 5.32

9 E TE E +TE T FT T *FT F ( E ) id Algorithm for Predictive Parsing Table FIRST(E) = FIRST(T) = FIRST(F) = { (,id } FIRST(E ) = { +, } FIRST(T ) ={ *, } FOLLOW(E) = FOLLOW(E ) = { ), } FOLLOW(T) = FOLLOW(T ) = { +, ), } FOLLOW(F) = { +, *, ), } Input: Grammar G Output: Parsing table M 1. Her bir kural A icin 2. ve 3. adimlari yap 2. First( ) daki her bir nonterminal a icin M[A,a] A dir 3. Eger FIRST( ) da ise, FOLLOW(A) daki her bir nonterminal b icin M[A,b] A dir 4. M nin geri kalan entry lerini error olarak isaretle 5/24/2004 Formal Diller /24/2004 Formal Diller 5.34 Nonter minal E E T T F E TE E +TE T FT T *FT F ( E ) id id E TE T FT F id FIRST(E) = FIRST(T) = FIRST(F) = { (,id } FIRST(E ) = { +, } FIRST(T ) ={ *, } FOLLOW(E) = FOLLOW(E ) = { ), } FOLLOW(T) = FOLLOW(T ) = { +, ), } FOLLOW(F) = { +, *, ), } + E +TE T Input Symbol * T *FT ( E TE T FT F (E) ) E T E T S ie tss a S es E b Nonter minal S S E a S a b E b Input Symbol e S es S i S ie tss t S 5/24/2004 Formal Diller 5.35 FOLLOW(S ) = {e, } 5/24/2004 Formal Diller 5.36

10 LL(1) Grammars LL(1): ilk L inputun soldan saga dogru tarandigini ifade eder. Ikinci L leftmost turetiminin uygulandigini ve (1) lookahead symbol sayisini gosterir. LL(1) Grammars Ambiguous veya left recursive grammar ler LL(1) olamaz Grammar G LL(1) dir ancak ve ancak eger A iki farkli turetim ise asagidaki kosullari saglamalidir. ve ayni nonterminal a ile baslayan stringler turetmemeli. En fazla ve dan biri (empty string) turetebilir. Eger * ise, FOLLOW(A) bulunan herhangi bir nonterminal ile baslayan bir string turetmemeli. 5/24/2004 Formal Diller /24/2004 Formal Diller 5.38 BOTTOM-UP PARSING Shift-reduce parsing bottom-up parsing in genel bir seklidir. Operator-precedence shift-reduce parsing in ozel bir hali Parse tree leaves (yapraklar) dan baslanip root (koke) dogru design edilir. Giris stringi w grammar in baslangic sembolu S ye reduce (indirgenir) S aabe A Abc b B d abbcde aabcde aade aabe S w = abbcde S rm aabe rm aade rm aabcde rm abbcde 5/24/2004 Formal Diller /24/2004 Formal Diller 5.40

11 Handles Bir string in handle i asagidaki kosulu saglayan substring e denir. Bir production in sag tarafi ile uyusmasi ve o production in solundaki nonterminale indirgenmesi rightmost derivation in tersinin bir adimini gostermesi. (Informal) Bir baska deyimle S * rm Aw rm w ve A ise, A w stringinde dan sonraki pozisyonda bir handle dir. (Formal) S aabe A Abc b B d w = abbcde S rm aabe rm aade rm aabcde rm abbcde abbcde bir right-sentential form dur ve handle i 2. pozisyondaki A b dir. 5/24/2004 Formal Diller /24/2004 Formal Diller 5.42 (1) E E + E (2) E E * E (3) E ( E ) (4) E id E rm E + E rm E + E * E rm E + E * id 3 rm E + id 2 * id 3 rm id 1 + id 2 * id 3 id 3, E + E * id 3 un bir handle dir E rm E * E rm E * id 3 rm E + E * id 3 rm E + id 2 * id 3 rm id 1 + id 2 * id 3 E + E, E + E * id 3 un bir handle dir 5/24/2004 Formal Diller 5.43 (1) E E + E (2) E E * E (3) E ( E ) (4) E id Right sentential form id 1 + id 2 * id 3 E + id 2 *id 3 id 1 + id 2 * id 3 E + E * id 3 E + E * E E + E E handle id 1 id 2 id 3 E * E E + E Reducingproduction E id E id E id E E * E E E + E 5/24/2004 Formal Diller 5.44

12 Shift Reduce Parsing in Stack le Gerceklestirilmesi (1) E E + E (2) E E * E (3) E ( E ) (4) E id id 1 + id 2 * id 3 E rm E + E rm E + E * E rm E + E * id 3 rm E + id 2 * id 3 rm id 1 + id 2 * id 3 Stack grammar sembollerini tutmak icin kullanir. Input buffer ise giris stringi w yu tutmak icin kullanilir. stack in dibini isaretlemek ve giris stringinin sonunu gostermek icin kullanilir. baslangic: stack input w bitis: stack input 5/24/2004 Formal Diller 5.45 stack input action (1) id 1 + id 2 * id 3 shift (2) id 1 + id 2 * id 3 Reduce by E id (3) E + id 2 * id 3 shift (4) E + id 2 * id 3 shift (5) E + id 2 * id 3 reduce by E id (6) E + E * id 3 shift (7) E + E * id 3 shift (8) E + E * id 3 reduce by E id (9) E + E * E reduce by E E *E (10) E + E reduce by E E +E (11) E accept 5/24/2004 Formal Diller 5.46 Shift-reduce Actionlari Shift Bir sonraki giris sembolu stack e itilir Reduce Handle in sagi stack in ustunde. Stack de handle nin soluna komsu nonterminal tespit edilir. Daha sonra belirlenen handle sag tarafi ile yer degistirilir. Accept Parsing isleminin basarili oldugu karari verilir Error Syntax error un olduguna karar verilir ve error recovery routine i cagrilip parsing islemi sonlandirilir. Operator-precedence parsing LR grammar ler shift-reduce parsing yontemiyle gerceklestirilen en genis grammar grubudur. Operator-precedence parsing Elle shift-reduce parsing yontemiyle kolayca gerceklestirilebilirler Genellilkle expression lar icin gerceklestirilirler Temel ozellikleri Herhangi bir turetimin saginda veya yanyana iki nonterminal bulunmaz 5/24/2004 Formal Diller /24/2004 Formal Diller 5.48

13 E EAE (E ) -E id A + - * / m Operator grammar degil Nonterminaller arasinda uc disjoint precedence relations tanimlanir Bu relationlar handle larin seciminde kullanilirlar E E +E E E E *E E /E E me (E ) -E id relation a b a =. b a b anlami a nin onceligi b den sonra gelir a ile b ayni oncelige sahip a, b den daha onceliklidir 5/24/2004 Formal Diller /24/2004 Formal Diller 5.50 Bu relation lar aritmetik relation lara ( <, >, =) benziyor gibi gozukebilir. Ama gercekte anlmalari oldukca farklidir. Ayni dil icin a b ve a b olabilir a b, a b, a =. b den hic biri olmayabilir Iki nonterminal arasinda hangi iliskinin olmasi gerektigine karar vermek icin baslica iki yontem vardir Operatorlerin associativity ve precedence (oncelik) durumlari Eger *, + dan oncelikli ise + * ve * + Ambiguity nin cozumlenmesi 5/24/2004 Formal Diller 5.51 id + * id + * id + id * id id + id * id E + id * id E + E * id E + E * E + * + 5/24/2004 Formal Diller 5.52

14 Operator-precedence Algorithm Associativity ve Operator Precedence Kurallari Input: input string w ve precedence relation larin tablosu Output: Eger w grammar tarafindan kabul edilirse parse tree, aksi durumda hata messaji. Baslangicta stack icerir ve input buffer da w var. ip yi w nin ilk sembolunu gosterecek sekilde set et repeat forever if stack in usunde ve ip a isaret ediyorsa then return else begin a stack in ustundeki terminali ve b ip tarafindan isaret edilen sembolu gostersin if a b veya a =. b then begin /* shift */ b yi stack e it (push); ip yi bir sonraki sembolu gosterecek sekilde duzenle end else if a >. b then /* reduce */ repeat stack te pop islemi yap until stack in ustundeki nonterminal en son stack den cekilen nonterminal else error() end 5/24/2004 Formal Diller Eger 1, 2 den daha oncelikli ise 1 2 ve 2 1 Ornek: *, + dan daha oncelikli ise, * + ve + * ( E+ E * E + E ) 2. Eger 1, 2 esit oncelikli ise ( 1 ve 2 ayni operator olabilir ), 1 2 ve 2 >. 1 (eger 1, 2 left-associative ise), 1 2 ve 2 1 (eger 1, 2 right-associative ise). ( E E + E ) Ornek: + ve left associative ise + +, + -, - -, - + dir. Eger m right associative ise m m dir. 3. Her bir operator icin, id, id, (, (, ), ),, ve dir. Ayni zamanda, ( =. ) ( id ( ( id ) ( 5/24/2004 id id ) ) ) Formal Diller * / m id ( ) E E +E E E E *E E /E E me (E ) -E id 1. m en yuksek oncelige sahip ve right-associative 2. * ve / sonraki en yuksek oncelige sahip ve left-associative 3. + ve en dusuk oncelige sahip ve left associative + - * / m 5/24/2004 Formal Diller 5.55 id ( ) =. Stack input (1) id * ( id m id ) id / id (2) id * ( id m id ) id / id (3) * ( id m id ) id / id (4) * ( id m id ) id / id (5) * ( idm id ) id / id (6) * ( id m id ) id / id (7) * ( m id ) id / id (8) * ( m id ) id / id (9) * ( m id ) id / id (10) * ( m ) id / id (11) * ( ) id / id (12) * ( ) id/ id (13) * id/ id (14) id/ id (15) - id / id (16) - id / id (17) - / id (18) - / id (19) - / id (20) - / (21) - (22) 5/24/2004 Formal Diller 5.56

15 Precedence Functions Operator-precedence parser kullanan compiler lar precedence relationlarin tablosunu tutmalarina gerek yoktur. Cogu kez terminal sembolerinden integerlara tanimli f ve g precedence fonksiyonlari yukarida belirtilen tabloyu kodlanabilir. f ve g yi asagidaki ozellikleri saglayacak sekilde secebiliriz f(a) < g(b) eger a b ise f(a) = g(b) eger a =. b ise f(a) > g(b) eger a b ise a ve b terminalleri arasindaki precedence iliskisi f(a) ve f(b) nin kiyaslanmasiyla elde edilir. 5/24/2004 Formal Diller * / m id ( ) + - * / m id ( =. ) + - * / m ( ) id f g * id dolayisiyle f(*) =4 < g(id) = 5 5/24/2004 Formal Diller 5.58 Precedence fonksiyonlarin elde edilmesi Input: Operator precedence matrix Output: input matrixi temsil eden precedence fonksiyonlari veya precedence fonksiyonlarin bulunamayacaginin ifadesi id + * id + * 1. Her bir terminal a veya icin f a ve g a olmak uzere iki sembol olustur. 2. Eger a =. b ise f a ve f b ayni grupta olmak sartiyla sembolleri maximum sayida gruba ayir. 3. Node lari 2. adimda bulunan gruplar olan bir directed graph olustur. a ve b icin eger a <. b ise g b nin bulundugu gruptan f a nin bulunduga gruba bir edge var. Eger a >. b ise f a nin bulundugu gruptan g b nin bulundugu gruba bir edge var. 4. Eger elde edilen graph bir cycle olusturuyorsa, precedence fonk siyonlari bulunamaz (yoktur). Aksi takdirde f(a) grup f a dan baslayan en uzun path (longest path) in uzunlugudur, g(a) grup g a dan baslayan en uzun path in uzunlugudur. 5/24/2004 Formal Diller 5.59 g id f id f * g * g + f + f g + * id f g Precedence fonksiyonlari Precedence fonksiyonlarini gosteren graph 5/24/2004 Formal Diller 5.60

16 LR PARSERS Efficient bottom-up parsing technique En genel hali LR(k): L: left to right scanning of the input, R: rightmost derivation in reverse, k: parsing kararinda lookahead icin gerekli sembol sayisi LR parser lar context-free grammar lerle ifade edilebilen hemen hemen tum diller icin kullanilabilirler LR parsing yontemi bilinen en genel nonbactracking shift-reduce parsing methodudur LR parser larla parse edilebilen dillein kumesi predictive parser larla parse edilebilen diller kumesinin bir supersetidir. LR parser larin elle gerceklestirilmesi zordur LR parser generators Yacc (yet another compiler compiler) : verilen context free grammar a gore otomatik olarak LR parser uretir 5/24/2004 Formal Diller 5.61 LR Parsers SLR (simple LR) En kolay implemet edilebilen LR dir En az guclu Canonical LR En guclu olani En zor implement (gerceklestirilebilen) LR dir LALR (lookahead LR) Gucu ve implementation zorlugu SLR ile Canoniical LR arasinda Cogu programlama dilleri kucuk degisikliklerle LALR parserlariyle parse edilebilirler 5/24/2004 Formal Diller 5.62 LR Parsing LR Parsing stack s m X m s m-1 X m-1 s 0 a 1 a 2 a i a n LR Parsing Program action goto Input LR parsing 5 kisimdan olusur Input buffer Output Stack s 0 X 1 s 1 X 2 s 2 X m s m, s m stackin en ustunde. X i ler grammar sembol (terminal veya nonterminal), s i ler ise stateleri gosterir Stack en ustundeki state ve input symbol kullanilarak parsing table indekslenir ve indeklenen tablonun elemanina gore shift/reduce parsing karari verilir Driver program Otomatik olarak uretilir (verilen context free grammar gore) Parsing table 5/24/2004 Formal Diller /24/2004 Formal Diller 5.64

17 Parsing table Iki bolumden olusur Parsing action fonksiyonu Goto fonksiyonu action[s m,a i ] Shift s, oyleki s bir state dir Reduce (A ) Accept Error goto State i ve grammar sembolu giris olarak alir ve buna gore sonraki state i verir LR Parsing Algorithm Input: input string w ve grammar icin LR parsing table Output: Eger w L(G) nin elemani ise w icin bottom-up parse tree, aksi durumda error 5/24/2004 Formal Diller /24/2004 Formal Diller 5.66 LR Parsing Algorithm ip yi w nin ilk sembolu isaret edecek sekilde duzenle repeat forever begin s stack in en ustundeki state ve a ip tarafindan isaret edilen sembol olsun if action[s,a] = shift s then begin once a yi sonra s ni stacke push et; ip yi sonraki sembole isaret edilecek sekilde ilerlet end else if action[s,a] = reduce A then begin 2* sembolu stack ten pop et s stack in ustundeki state olsun once A yi sonra goto[s,a] yi stack e push et output production A end else if action[s,a] = accept then return else error() end 5/24/2004 Formal Diller 5.67 action goto (1) E E + T State id + * ( ) E T F (2) E T 0 s5 s s6 acc (3) T T * F 2 r2 s7 r2 r2 (4) T F 3 r4 r4 r4 r4 (5) F (E) 4 s5 s (6) F id 5 r6 r6 r6 r6 6 s5 s s5 s s6 s11 9 r1 s7 r1 r1 10 r3 r3 r3 r3 11 r5 r5 r5 r5 5/24/2004 Formal Diller 5.68

18 (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) Stack 0 0 id 5 0 F 3 0 T 2 0 T 2 * 7 0 T 2 * 7 id 5 0 T 2 * 7 F 10 0 T 2 0 E 1 0 E E id 5 0 E F 3 0 E T 9 0 E 1 Input id * id + id * id + id * id + id * id + id id + id + id + id + id + id id Action shift reduce F id reduce T F shift shift reduce F id reduce T T * F reduce E T shift shift reduce F id Reduce T F E E + T accept LL Parsers versus LR Parsers LL ile LR arasinda onemli bir fark var Bir grammar in LR(k) olabilmesi icin, Bir production in sag tarafininin turetimde kullanildigini anlayabilmemiz gerekir (bu sag taraftan k lookahead sembolu kullanilarak turetilebilecek tum stringlerin gorulmesi ) Bir grammar in LL(k) olabilmesi icin Bir production in sag tarafinin turetimde kullanildigini anlayabilmemiz gerekli (bu production in sag tarafinin turettigi stringin sadece ilk k sembolunun gorulmesiyle belirlenmesi) LR grammar lar LL grammar lerden daha fazla dil tanimlarlar 5/24/2004 Formal Diller /24/2004 Formal Diller 5.70 SLR Parsing Tables LR(0) item: Grammar G nin LR(0) item i (item) G nin production larindan birinin sag tarafinin herhangi bir pozisyonuna dot (.) eklenmis hali A XYZ bir production ise: A.XYZ, A X.YZ, A XY.Z ve A XYZ. nin her biri G nin bir item idir. A yalnizca A. Production ini uretir. Item bir cift integerla represent edilir Production in numarasi Dot (.) nin production daki pozisyonu Augmented Grammar Eger G start sembolu S olan bir grammar ise, G G nin augmented grammar idir ve G nin start sembolu S olmak uzere production lari S S G nin tum productionlari 5/24/2004 Formal Diller /24/2004 Formal Diller 5.72

19 Closure Operation Eger I, grammar G nin bir item i ise, closure(i) asagidaki iki kuralla elde edilir I daki her item closure(i) ya eklenir Eger A.B closure(i) nin elemani ve B ise B. closure(i) da degilse buna eklenir. Bu islem closure(i) ya yeni bir item eklenemeyene kadar tekrarlanir. E E + T T T T * F F F (E) id E E E E + T T T T * F F F (E) id Augmented grammar I= {E E} ise Closure(I) = { E.E, E.E+T, E.T, T.T*F, T.F F.(E), F.id} 5/24/2004 Formal Diller /24/2004 Formal Diller 5.74 Goto Operation function closure(i) begin J:= I; repeat for J deki her bir item A.B ve her bir production B icin, eger B. J de yoksa, B. yi J ye ekle until yeni bir item J ye eklenemeyene kadar return J end goto(i,x) (I item ler kumesi ve X grammar sembol) closure{a X. } oyleki A.X I nin bir elemanidir E E E E + T T T T * F F F (E) id I={E E., E E.+T} ise goto(i,+)= {E E+.T, T.T*F, T.F, F.(E), F.id} 5/24/2004 Formal Diller /24/2004 Formal Diller 5.76

20 Sets-of-items larin bulunmasi E E E E + T T T T * F F F (E) id procedure items(g ) begin C:={closure({S S})}; repeat for C deki her bir item kumesi I ve grammar sembol X icin oyleki goto(i,x) bos olmayip C de degilse do goto(i,x) i C ye ekle until C ye yeni itemlar kumesi eklenemeyene kadar end I 0 : E.E E.E+T E.T T.T*F T.F F.(E) F.id I 1 : E E. E E.+T I 2 : E T. T T.* F I 3 : T F. I 4 : F (.E) E.E+T E.T T.T*F T.F F.(E) F.id I 5 : F id. I 6 : I 7 : I 8 : E E+.T T.T*F T.F F.(E) F.id T T*.F F.(E) F.id F (E.) E E.* T I 9 : E E+T. T T.* F I 10 :T T*F. I 11 :F (E). Canonical LR(0) items setleri 5/24/2004 Formal Diller /24/2004 Formal Diller 5.78 SLR Parsing Table nin Elde Edilmesi E + T I * 0 I I I I Input: Augmented grammar G id F ( Output: SLR parsing table functions actions, goto I 5 I I 4 3 T I * F 1. LR(0) item lerinin setlerinin kolleksiyonu C={I 2 I I 0, I 1,, I n } yi bul State i I i den elde edilir id ( a) Eger A.a I i nin elemani ve goto(i i,a) =I j ise action[i,a]=shift j F burada a terminaldir. I 3 I I 5 4 b) Eger A. I i nin elemani ise action[i,a] = reduce A dir (FOLLOW(A) daki her bir terminal a icin, A S den farkli) ( c) Eger S S. I i nin elemani ise action[i,] = accept ( E ) 3. State i icin goto transitionlari tum nonterminaller A icin : I 4 I 8 I 11 Eger goto(i i,a) = I j ise goto[i,a] =j dir T Ve 3. Kuralla tanimlanmayan tablonun tum elemanlari error olarak id I 2 + I 6 isaretlenir id F I 5. Parser in baslangic state i S.S nin closure undan elde edilen state dir. 5 5/24/2004 I Formal Diller /24/2004 Formal Diller

21 (1) E E + T (2) E T (3) T T * F (4) T F (5) F (E) (6) F id State id s5 s5 s5 s5 + s6 r2 r4 r6 s6 r1 r3 * s7 r4 r6 s7 r3 action 11 r5 r5 r5 r5 5/24/2004 Formal Diller 5.81 ( s4 s4 s4 s4 ) r2 r4 r6 s11 r1 r3 acc r2 r4 r6 r1 r3 E 1 8 goto T F