Ambiguity Ambiguous Grammar: Bazi sentence lar icin birden fazla parse tree ureten grammarlere denir. Ambiguous Grammar ler bazi sentence lari birden fazla.

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 9/7/2018 Formal Diller

Regular Expression vs. Context-Free Grammars
RE ile ifade edilebilen her bir dil CFG ile de ifade edilebilir. A0  aA0 | bA0 | aA1 A1  bA2 A2  bA3 A3  (a|b)*abb 9/7/2018 Formal Diller

NFA to CFG (a|b)*abb a a/b 1 2 3 start b A0  aA0 | bA0 | aA1 A1  bA2 A2  bA3 A3   NFA daki her bir state icin bir nonterminal olustur. Eger state i den state j ye a sembolu ile gecis varsa Ai  aAj bir turetimdir. Eger i start state ise Ai dilin start semboludur. 9/7/2018 Formal Diller

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. 9/7/2018 Formal Diller

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 9/7/2018 Formal Diller

Ornek S  (S)S | S den uretilen her bir string balanced?
Tume varim: Basis step: tek turetimle elde edilebilen tek string  (balanced). Assumption: n stepten daha az sayida turetimle 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 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 parantezleri olan en kisa prefixi oldugunu dusunelim. w, (x)y olarak yazilabilir. 9/7/2018 Formal Diller

Ambiguity nin Elimine Edilmesi
dangling-else stmt  if expr then stmt | if expr then stmt else stmt | other 9/7/2018 Formal Diller

if E1 then if E2 then S1 else S2
stmt if expr E1 then else S2 E2 S1 stmt expr if then E1 E2 else S1 S2 Iki farkli parse tree 9/7/2018 Formal Diller

stmt  if expr then stmt | if expr then stmt else stmt | other
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 9/7/2018 Formal Diller

Left Recursion Asagidaki verilen ozellige sahip grammar e left recursive denir. A+ A turetimine imkan veren bir nonterminale sahip. left recursion elimination A  A’ A’  A’ |  AA |  9/7/2018 Formal Diller

A  A1 | A2 | …… | Am | 1 | 2 | …… |n
Immediate left recursion elimination A  1A’ | 2A’ | …… | nA’ A’  1A’ | 2A’ | …… | mA’ |  9/7/2018 Formal Diller

E  E + T | T T  T * F | F F  (E ) | id E  T E’ E’  +TE’ | 
T  FT’ T’  * FT’ |  F  ( E ) | id 9/7/2018 Formal Diller

Left recursive, immediately left recursive değil S  Aa  Sda
S  Aa | b A  Ac | Sd |  Left recursive, immediately left recursive değil S  Aa  Sda 9/7/2018 Formal Diller

Left recursion elimination
Eğer grammar de cycle yoksa (A+ A yok) veya -production yoksa Input: Grammar G (cycle yok veya -production yok) Output: Eşdeğer grammar (no left recursion) 9/7/2018 Formal Diller

Nonterminalleri A1, A2, ……, An olarak düzenle.
for i:=1 to n do begin for j:= 1 to i-1 do begin Ai  Aj  şeklindeki her bir production i Ai  1  | 2  | …… | k  ile yerdeğiştir. Burada Aj  1 | 2 | …… | k bütün mevcut Aj production lardır. end Ai production larindaki immediate left recursion i elimine et. end 9/7/2018 Formal Diller

i=2 icin ASd production i AAad | bd |  ile yer yer değiştirilir.
S  Aa | b A  Ac | Sd |  Non-terminal sırası: S, A S-productionlarda no immediate left recursion i=2 icin ASd production i AAad | bd |  ile yer yer değiştirilir. S  Aa | b A  bdA’ | A’ A’  cA’ | adA’ |  S  Aa | b A  Ac | Aad | bd |  9/7/2018 Formal Diller

Left Factoring Predictive Parser larda kullanilir.
stmt  if expr then stmt else stmt | if expr then stmt A  A’ A’  1 | 2 Left factoring A  1 | 2 9/7/2018 Formal Diller

Left Factoring Input. Grammar G
Output. An equivalent left-factored grammar Method. Her bir nonterminal A için iki veya daha çok alternatifdeki en uzun prefix  yi bul. Eger   dan farklı ise A  1 | 2 | …… n |  ( Burada   ile başlamayan tüm alternatifleri gösterir) yi aşağıdaki türetimlerle yer değiştir. A  A’ |  A’  1 | 2 | …… | n 9/7/2018 Formal Diller

stmt  if expr then stmt else stmt | if expr then stmt | a expr  b
Left factoring stmt  if expr then stmt stmt ’ | a stmt ’  else stmt |  expr  b 9/7/2018 Formal Diller

Top-down Parsing Giriş string i için bir leftmost derivation bulma anlamına gelir Aynı zamanda root dan başlayarak tree nin node larını preorder sırada bulmak suretiyle bir parse tree üretmek anlamına gelir 9/7/2018 Formal Diller

Recursive descend parsing
Top-down parsing in genel halidir. Backtracking e ihtiyaç duyulabilir 9/7/2018 Formal Diller

S  cAd A  ab | a Input string w=cad S c A d a b S c A d S S c A d a
backtracking S S c A d a 9/7/2018 Formal Diller

Predictive Parser Predictive parser with no backtracking
Eliminating left recursion Left factoring Verilen her bir input sembol için yalnız bir alternatif türetim vardır. stmt  if expr then stmt else stmt | while expr do stmt | begin stmt_list end 9/7/2018 Formal Diller

Predictive Parsing Program
Predictive Parser a + b $ Input Predictive Parsing Program Output X Y Z $ Stack Parsing Table M 9/7/2018 Formal Diller

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. 9/7/2018 Formal Diller

else error( ) else /* X nonterminal */
Başlangıçta $S stackte ve w$ giriş bufferında. 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 Y1Y2 ……Yk then begin pop X from the stack; push Yk,Yk-1, …… , Y1 onto stack ( Y1 en ustte olacak sekilde); output the production X Y1Y2 ……Yk end else error( ) until X = $ /* stack is empty */ 9/7/2018 Formal Diller

Predictive Parsing Program
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. 9/7/2018 Formal Diller

Stack Input Output 1 $ E id + id * id $ 2 $ E’ T E  T E’ 3 $ E’ T’ F
T  F T’ 4 $ E’ T’ id F  id 5 $ E’ T’ + id * id $ 6 $ E’ T’   7 $ E’ T + E’  + T E’ 8 id * id $ 9 T F T’ 10 11 * id $ 12 $ E’ T’ F * T’  * FT’ 13 id $ 14 15 $ 16 17 E’   9/7/2018 Formal Diller

FIRST and FOLLOW Predictive Parser in Tablosunu doldurmak için kullanılır FIRST Eğer  gramer sembollerinden oluşan bir string ise FIRST()  dan türeyen stringlerin başındaki terminallerin kümesi Eğer  *  ise, FIRST(),  yi içerir. FOLLOW Nonterminal A için FOLLOW(A) sentential formdaki A’nın hemen sağında bulunan terminallerin kümesi Eğer S *  A a  ise, FOLLOW(A) a yi içerir 9/7/2018 Formal Diller

FIRST Algoritması Eğer X bir terminal ise, FIRST(X) = {X}
Eğer X  ise,  yi FIRST(X) e ekle Eğer X Y1 Y2 …… Yk ise, ve bazı i için FIRST(Yi) a yi içeriyor ve FIRST(Y1), FIRST(Y2), ……, FIRST(Yi-1)  yi içeriyorsa, a yi FIRST(X) e ekle. 9/7/2018 Formal Diller

FOLLOW Algoritması Nonterminal A için FOLLOW(A) aşağıdaki gibi hesaplanır. 1. S start sembolü ise FOLLOW(S) $ yi içerir. Eğer A B ise,  hariç FIRST() deki her şeyi FOLLOW(B) içerir 3. Eğer A B, veya A B ve FIRST()  yi içerirse FOLLOW(A)’daki her şeyi FOLLOW(B) içerir 9/7/2018 Formal Diller

T  FT’ T’  *FT’ |  F  ( E ) | id
E  TE’ E’  +TE’ |  T  FT’ T’  *FT’ |  F  ( E ) | id FIRST(E) = FIRST(T) = FIRST(F) = { (,id } FIRST(E’) = { +, } FIRST(T’) ={ *, } FOLLOW(E) = FOLLOW(E’) = { ), $ } FOLLOW(T) = FOLLOW(T’) = { +, ), $ } FOLLOW(F) = { +, *, ), $ } 9/7/2018 Formal Diller

Predictive Parser Tablosu Oluşturma
Input: Grammar G Output: Parsing table M 1. Her bir kural A  için 2. ve 3. adımları yap 2. First()’daki her bir terminal a için M[A,a] A  dir 3. Eğer  FIRST() da ise, FOLLOW(A)’daki her bir terminal b için M[A,b] A  dir 4. M’nin geri kalan entry lerini error olarak işaretle 9/7/2018 Formal Diller

T  FT’ T’  *FT’ |  F  ( E ) | id
E  TE’ E’  +TE’ |  T  FT’ T’  *FT’ |  F  ( E ) | id FIRST(E) = FIRST(T) = FIRST(F) = { (,id } FIRST(E’) = { +, } FIRST(T’) ={ *, } FOLLOW(E) = FOLLOW(E’) = { ), $ } FOLLOW(T) = FOLLOW(T’) = { +, ), $ } FOLLOW(F) = { +, *, ), $ } Nonter minal Input Symbol id + * ( ) $ E ETE’ E’ E’+TE’ E’  E’   T TFT’ T’ T’  T’*FT’ T’   F Fid F(E) 9/7/2018 Formal Diller

S  iE tSS’ | a S’  eS |  E  b Nonterminal Input Symbol
$ S S  a S  iE tSS’ S’ S’  eS S’   S’   E E  b FOLLOW(S’) = {e, $} 9/7/2018 Formal Diller

LL(1) Gramerler LL(1): İlk L, inputun soldan sağa doğru tarandığını ifade eder. İkinci L ise leftmost türetiminin uygulandığını ve (1), lookahead sembol sayısını gösterir. 9/7/2018 Formal Diller

LL(1) Grammars Ambiguous veya left recursive gramerler LL(1) olamaz
Gramer G, LL(1) dir ancak ve ancak eğer A  |  iki farklı türedim ise aşağıdaki koşulları sağlamalıdır.  ve  aynı terminal a ile başlayan stringler türetmemeli. En fazla  ve  dan biri  (empty string) türetebilir. Eğer  *  ise,  FOLLOW(A) bulunan herhangi bir terminal ile başlayan bir string türetmemeli. 9/7/2018 Formal Diller

BOTTOM-UP PARSING Shift-reduce parsing bottom-up parsing in genel bir şeklidir. Operator-precedence shift-reduce parsing in özel bir hali Parse tree leaves (yapraklar) dan başlanıp root (köke) doğru dizayn edilir. Giriş stringi w gramerin başlangıç sembolü S’ye reduce (indirgenir) 9/7/2018 Formal Diller

abbcde aAbcde aAde aABe
S  aABe A  Abc | b B  d w = abbcde abbcde aAbcde aAde aABe S S rm aABe rm aAde rm aAbcde rm abbcde 9/7/2018 Formal Diller

Handles Bir stringin handle’i aşağıdaki koşulu sağlayan substringe denir. Bir production in sağ tarafı ile uyuşması ve o production in solundaki nonterminale indirgenmesi rightmost derivation in tersinin bir adımını göstermesi. (Informal) Bir başka deyimle S * rm  Aw rmw ve A ise, A w stringinde  dan sonraki pozisyonda bir handle dir. (Formal) 9/7/2018 Formal Diller

S rm aABe rm aAde rm aAbcde rm abbcde
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. 9/7/2018 Formal Diller

(1) E  E + E (2) E  E * E (3) E  ( E ) (4) E  id
E rm E * E rm E * id3 rm E + E * id3 rm E + id2 * id3 rm id1 + id2 * id3 E rm E + E rm E + E * E rm E + E * id3 rm E + id2 * id3 rm id1 + id2 * id3 id3 , E + E * id3 un bir handle dir E + E, E + E * id3 un bir handle dir 9/7/2018 Formal Diller

(1) E  E + E (2) E  E * E (3) E  ( E ) (4) E  id
id1 + id2 * id3 Right sentential form handle Reducing production id1 + id2 * id3 id1 E  id E + id2 * id3 id2 E + E * id3 id3 E + E * E E * E E  E * E E + E E  E + E E 9/7/2018 Formal Diller

Shift Reduce Parsing in Stack le Gerceklestirilmesi
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 $ $ 9/7/2018 Formal Diller

(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 * id3 rm E + id2 * id3 rm id1 + id2 * id3 (1) E  E + E (2) E  E * E (3) E  ( E ) (4) E  id id1 + id2 * id3 stack input action (1) $ id1 + id2 * id3 $ shift (2) $ id1 + id2 * id3 $ Reduce by E id (3) $ E (4) $ E + id2 * id3 $ (5) $ E + id2 * id3 $ reduce by E id (6) $ E + E (7) $ E + E * id3 $ (8) $ E + E * id3 (9) $ E + E * E reduce by E  E *E (10) reduce by E  E +E (11) accept 9/7/2018 Formal Diller

Shift-reduce Actionlari
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. 9/7/2018 Formal Diller

Operator-precedence parsing (Operatör Öncelikli Parsing)
LR gramerler shift-reduce parsing yöntemiyle gerçekleştirilen en geniş gramer grubudur. Operator-precedence parsing Elle shift-reduce parsing yöntemiyle kolayca gerçekleştirilebilirler Genellilikle expressionlar için gerçekleştirilirler Temel özellikleri Herhangi bir taretimin sağında  veya yan yana iki nonterminal bulunmaz 9/7/2018 Formal Diller

E  E +E | E –E | E *E | E /E | E E |(E ) | -E | id
E  EAE | (E ) | -E | id A  + | - | * | / | Operator grammar değil E  E +E | E –E | E *E | E /E | E E |(E ) | -E | id 9/7/2018 Formal Diller

Bu ilişkiler handleların seçiminde kullanılırlar
Terminaller arasında üç disjoint precedence relations (ilişkiler) tanımlanır Bu ilişkiler handleların seçiminde kullanılırlar ilişki anlamı a <. b a’nın önceliği b’den sonra gelir a =. b a ile b ayni önceliğe sahip a .> b a, b den daha önceliklidir 9/7/2018 Formal Diller

Bu ilişkiler aritmetik ilişkilere ( <, >, =) benziyor gibi gözükebilir. Ama gerçekte anlamları oldukça farklıdır. Ayni dil için a <. b ve a .> b olabilir a <. b , a .> b , a =. b den hiç biri olmayabilir İki nonterminal arasında hangi bir ilişkinin olması gerektiğine karar vermek için başlıca iki yöntem vardır Operatorlerin associativity (birleşme) ve precedence (öncelik) durumları Eğer * , + dan öncelikli ise + <. * ve * .> + Ambiguity nin çözümlenmesi 9/7/2018 Formal Diller

$ <. id .> + <. id .> * <. id .> $
$ E + <. id .> * <. id .> $ $ E + E * <. id .> $ $ E + E * E $ $ <. + <. * .> $ $ <. + .> $ 9/7/2018 Formal Diller

Operator-precedence Algorithm
Input: input string w ve precedence relation larin tablosu Output: Eğer w gramer tarafından kabul edilirse parse tree, aksi durumda hata mesajı. Başlangıçta stack $ içerir ve input buffer da w$ var. ip yi w$ nin ilk sembolünü gösterecek şekilde ayarla repeat forever if $ stack in üstünde ve ip, $’a işaret ediyorsa then return else begin a, stack in üstündeki terminali ve b,ip tarafından işaret edilen sembolü göstersin if a <. b veya a =. b then begin /* shift */ b’yi stack e it (push); ip’yi bir sonraki sembolü gösterecek şekilde düzenle end else if a >. b then /* reduce */ repeat stack te pop işlemi yap until stack in üstündeki nonterminal <. en son stack den çekilen nonterminal else error() 9/7/2018 Formal Diller

Operator Associativity (Birleşme) ve Precedence (Öncelik) Kuralları
Eğer 1 , 2 den daha öncelikli ise 1 .> 2 ve 2 <. 1 Örnek: * , + dan daha öncelikli ise, * .> + ve + <. * ( E+ E * E + E ) Eğer 1 , 2 eşit öncelikli ise (1 ve 2 ayni operator olabilir ): 1 .> 2 ve 2 >. 1 (eğer 1 , 2 left-associative ise); 1 <. 2 ve 2 <. 1 (eğer 1 , 2 right-associative ise). ( E – E + E ) Örnek: + ve – left associative ise + .> +, + .> - , - .> - , - .> + dir. Eğer  right associative ise <.  dir. Her bir operator  icin,  <. id, id .> ,  <. ( , ( <.  , ) .>  ,  .> ) ,  .> $, ve $ <.  dir. Aynı zamanda, ( =. ) $ <. ( $ <. id ( <. ( id .> $ ) .> $ ( <. id id .> ) ) .> ) 9/7/2018 Formal Diller

E  E +E | E –E | E *E | E /E | E E |(E ) | -E | id
, en yüksek önceliğe sahip ve right-associative * ve /, sonraki en yüksek önceliğe sahip ve left-associative + ve –, en düşük önceliğe sahip ve left associative + - * /  id ( ) $ .> <. =. 9/7/2018 Formal Diller

Stack input 9/7/2018 Formal Diller (1) $ id * ( id  id ) – id / id $
(2) $ id * ( id  id ) – id / id $ (3) (4) $ * ( id  id ) – id / id $ (5) $ * ( id  id ) – id / id $ (6) $ * ( id  id ) – id / id $ (7) (8) $ * ( id ) – id / id $ (9) $ * ( id ) – id / id $ (10) ) – id / id $ (11) (12) $ * ( ) – id / id $ (13) (14) (15) $ - id / id $ (16) $ - id / id $ (17) (18) $ - / id $ (19) $ - / id (20) (21) (22) 9/7/2018 Formal Diller

Precedence Functions (Öncelik Fonksiyonları)
Operator-precedence parser kullanan derleyiciler öncelik ilişkisi tablosunu tutmalarına gerek yoktur. Çoğu kez terminal sembollerinden tamsayılara tanımlı f ve g öncelik fonksiyonları ile yukarıda belirtilen tablo kodlanabilir. f ve g’yi aşağıdaki özellikleri sağlayacak şekilde seçebiliriz f(a) < g(b) eğer a <. b ise f(a) = g(b) eğer a =. b ise f(a) > g(b) eğer a .> b ise a ve b terminalleri arasındaki öncelik ilişkisi f(a) ve f(b)’nin kıyaslanmasıyla elde edilir. 9/7/2018 Formal Diller

* <. id dolayısıyla f(*) =4 < g(id) = 5
+ - * /  id ( ) $ .> <. =. + - * /  ( ) id $ f 2 4 6 g 1 3 5 * <. id dolayısıyla f(*) =4 < g(id) = 5 9/7/2018 Formal Diller

Precedence (Öncelik) Fonksiyonların Elde Edilmesi Input: Operator precedence matrix Output: input matrisi temsil eden öncelik fonksiyonları veya öncelik fonksiyonların bulunamayacağının ifadesi Her bir terminal a veya $ için fa ve ga olmak üzere iki sembol oluştur. Eğer a =. b ise fa ve fb ayni grupta olmak şartıyla sembolleri maksimum sayıda gruba ayır. Düğümleri 2. adımda bulunan gruplar olan bir yönlü graf oluştur. a ve b için eğer a < . b ise gb’nin bulunduğu gruptan fa’nın bulunduğa gruba bir kenar var. Eğer a >. b ise fa’nın bulunduğu gruptan gb’nin bulunduğu gruba bir kenar var. Eğer elde edilen graf bir cycle (döngü) oluşturuyorsa, precedence fonk siyonlari bulunamaz (yoktur). Aksi takdirde f(a) grup fa dan baslayan en uzun path (longest path) in uzunlugudur, g(a) grup ga dan baslayan en uzun path in uzunlugudur. 9/7/2018 Formal Diller

Precedence fonksiyonlari
id + * $ .> <. f* g+ f$ gid fid g* f+ g$ + * id $ f 2 4 g 1 3 5 Precedence fonksiyonlari Precedence fonksiyonlarini gosteren graph 9/7/2018 Formal Diller

LR PARSERS Efficient bottom-up parsing tekniği
En genel hali LR(k): L: left to right scanning of the input, R: rightmost derivation in reverse, k: parsing kararında lookahead için gerekli sembol sayısı LR parser lar context-free gramerlerle ifade edilebilen hemen hemen tüm diller için kullanılabilirler LR parsing yöntemi bilinen en genel nonbactracking shift-reduce parsing metodudur LR parserlarla parse edilebilen dillerin kümesi predictive parser larla parse edilebilen diller kümesinin bir supersetidir. LR parserların elle gerçekleştirilmesi zordur LR parser generators yacc (yet another compiler compiler) : verilen context free grammar a göre otomatik olarak LR –parser üretir 9/7/2018 Formal Diller

LR Parsers SLR (simple LR) Canonical LR LALR (lookahead LR)
En kolay implemet edilebilen LR’dir En az güçlü Canonical LR En güçlü olanı En zor implement (gerçekleştirilebilen) LR’dir LALR (lookahead LR) Gücü ve implementation zorluğu SLR ile Canonical LR arasında Çoğu programlama dilleri küçük değişikliklerle LALR parserlariyle parse edilebilirler 9/7/2018 Formal Diller

LR Parsing LR Parsing Program action goto a1 a2 …… ai an $ Input stack
sm Xm sm-1 Xm-1 …… s0 action goto 9/7/2018 Formal Diller

LR Parsing LR parsing 5 kısımdan oluşur Input buffer Output Stack
s0X1s1X2s2 …… Xmsm, sm stackin en üstünde. Xi’ler gramer sembol (terminal veya nonterminal), si’ler ise stateleri gösterir Stackin en üstündeki state ve input sembol kullanılarak parsing table indekslenir ve indekslenen tablonun elemanına göre shift/reduce parsing kararı verilir Driver program Otomatik olarak üretilir (verilen context free grammar göre) Parsing table 9/7/2018 Formal Diller

Parsing table İki bolümden oluşur action[sm,ai] goto
Parsing action fonksiyonu Goto fonksiyonu action[sm,ai] Shift s, öyleki s bir state’dir Reduce (A   ) Accept Error goto State ve gramer sembolü giriş olarak alır ve buna göre sonraki state i verir 9/7/2018 Formal Diller

LR Parsing Algorithm Input: input string w ve gramer için LR parsing table Output: Eğer w L(G)’nin elemanı ise w için bottom-up parse tree, aksi durumda error 9/7/2018 Formal Diller

LR Parsing Algoritması
ip’yi w$’nin ilk sembolünü işaret edecek şekilde düzenle repeat forever begin s, stackin en üstündeki state ve a, ip tarafından işaret edilen sembol olsun if action[s,a] = shift s’ then begin önce a’yi sonra s’ yi stacke push et; ip’yi sonraki sembole işaret edilecek şekilde ilerlet end else if action[s,a] = reduce A  then begin 2*|| sembolü stackten pop et s’ stack in üstündeki state olsun önce A’yi sonra goto[s’,A] yi stacke push et output production A  end else if action[s,a] = accept then return else error() end 9/7/2018 Formal Diller

E  E + T E  T T  T * F T  F F  (E) F  id State action goto id +
$ E T F s5 s4 1 2 3 s6 acc r2 s7 r4 4 8 5 r6 6 9 7 10 s11 r1 r3 11 r5 E  E + T E  T T  T * F T  F F  (E) F  id 9/7/2018 Formal Diller

Stack Input Action (1) id * id + id $ shift (2) 0 id 5 * id + id $
id * id + id $ shift (2) 0 id 5 * id + id $ reduce F  id (3) 0 F 3 reduce T  F (4) 0 T 2 (5) 0 T 2 * 7 id + id $ (6) 0 T 2 * 7 id 5 + id $ (7) 0 T 2 * 7 F 10 reduce T  T * F (8) reduce E  T (9) 0 E 1 (10) 0 E 1 + 6 id $ (11) 0 E id 5 $ (12) 0 E F 3 (13) 0 E T 9 reduce E  E + T (14) accept 9/7/2018 Formal Diller

LL Parsers versus LR Parsers
LL ile LR arasında önemli bir fark var Bir gramerin LR(k) olabilmesi için, Bir production in sağ tarafının türedimde kullanıldığını anlayabilmemiz gerekir (bu, sağ taraftan k lookahead sembolü kullanılarak türetilebilecek tüm stringlerin görülmesi) Bir gramerin LL(k) olabilmesi için Bir production in sağ tarafının türedimde kullanıldığını anlayabilmemiz gerekli (bu production in sağ tarafının türettiği stringin sadece ilk k sembolünün görülmesiyle belirlenmesi) LR gramerler LL gramerlerden daha fazla dil tanırlar 9/7/2018 Formal Diller

SLR Parsing Tables LR(0) item: Gramer G’nin LR(0) itemi (item) G’nin productionlarının birinin sağ tarafının herhangi bir pozisyonuna nokta (.) eklenmiş hali AXYZ bir production ise: A.XYZ, AX.YZ, AXY.Z ve AXYZ. nin her biri G’nin bir itemidir. A ε, yalnızca A. Productionini üretir. Item bir çift tamsayı ile temsil edilir Production in numarası Nokta(.) nın production daki pozisyonu 9/7/2018 Formal Diller

Augmented Grammar Eğer G start sembolü S olan bir gramer ise, G’, G nin augmented grameridir ve G’ nin start sembolü S’ olmak üzere production lari S’ S G nin tüm productionları 9/7/2018 Formal Diller

Closure İşlemi Eğer I, gramer G’nin bir itemi ise, closure(I) aşağıdaki iki kuralla elde edilir I’daki her item closure(I)’ya eklenir Eğer A.B closure(I)’nın elemanı ve B ise B. closure(I)’da değilse ona eklenir. Bu işlem closure(I)’ya yeni bir item eklenemeyene kadar tekrarlanır. 9/7/2018 Formal Diller

Closure(I) = { E’.E, E.E+T, E.T, T.T*F, T.F F.(E), F.id}
E E + T | T TT * F | F F (E) | id 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} 9/7/2018 Formal Diller

function closure(I) begin J:= I; repeat
for J’deki her bir item A.B ve her bir production B için, eğer B., J de yoksa, B. yi J’ye ekle until yeni bir item J’ye eklenemeyene kadar return J end 9/7/2018 Formal Diller

Goto İşlemi I item ler kümesi ve X gramer sembolü olmak üzere, goto(I,X) = closure({AX.}) öyleki A.X I’nın bir elemanıdır 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} 9/7/2018 Formal Diller

İtem Kümelerinin Bulunması
procedure items(G’) begin C:={closure({S’S})}; repeat for C’deki her bir item kümesi I ve gramer sembol X için öyleki goto(I,X) boş olmayıp C’de değilse do goto(I,X)’i C’ye ekle until C ye yeni itemlar kümesi eklenemeyene kadar end 9/7/2018 Formal Diller

Canonical LR(0) item kümeleri
E’ E E E + T | T TT * F | F F (E) | id I0: E’  .E E  .E+T E  .T T  .T*F T  .F F  .(E) F  .id I3: T  F. I6: E  E+.T T  .T*F T  .F F  .(E) F  .id I9: E  E+T. T  T.* F I4: F  (.E) E  .E+T E  .T T  .T*F T  .F F  .(E) F  .id I10: T  T*F. I7: T  T*.F F  .(E) F  .id I11: F  (E). I1: E’  E. E  E.+T I5: F  id. I2: E  T. T  T.* F I8: F  (E.) E  E.+ T Canonical LR(0) item kümeleri 9/7/2018 Formal Diller

E + T I0 * I1 I6 I9 I7 id F ( I5 I3 I4 T I2 * F I10 I7 ( id F I3 I4 I5
) I4 I8 I11 T id I2 + I6 F id I5 9/7/2018 Formal Diller I3

SLR Parsing Tablosunun Elde Edilmesi
Input: Augmented grammar G’ Output: SLR parse tablosu action’ları, goto’ları 1. LR(0) itemlerinin setlerinin koleksiyonu C={I0, I1, ……, In} yi bul. 2. State i, Ii den elde edilir a) Eğer A.a , Ii nin elemanı ve goto(Ii ,a) =Ij ise action[i,a]=shift j, burada a terminaldır. b) Eğer A., Ii nın elemanı ise action[i,a] = reduce A’dir (FOLLOW(A) daki her bir terminal a için ve A, S’ den farklı) c) Eğer S’  S. Ii nın elemanı ise action[i,$] = “accept” 3. State i için goto geçişleri tüm nonterminaller A’lar için : Eğer goto(Ii,A) = Ij ise goto[i,A] =j dir ve 3. kuralla tanımlanmayan tablonun geri kalan tüm elemanları “error” olarak işaretlenir 5. Parser in başlangıç state i S’.S nin closure undan elde edilen state dir. 9/7/2018 Formal Diller

E  E + T E  T T  T * F T  F F  (E) F  id State action goto id +
$ E T F s5 s4 1 2 3 s6 acc r2 s7 r4 4 8 5 r6 6 9 7 10 s11 r1 r3 11 r5 E  E + T E  T T  T * F T  F F  (E) F  id 9/7/2018 Formal Diller

SLR(1) Tablosu Önceki slidedaki algoritmaya göre üretilen tabloya SLR(1) tablosu denir Eğer SLR tablosu çatışan (conflict) actionlara sahipse ilgili gramerin SLR(1) olmadığı söylenir. Gramer G için üretilen SLR(1) tablosunu kullanan parsera G için SLR(1) parser denir SLR(1) deki (1) lookahead (karar verirken ileriye yönelik gerekli sembol) sayısını gösterir Eğer ihmal edilirse (SLR’de olduğu gibi), lookahead sayısının 1 olduğu varsayılır 9/7/2018 Formal Diller

I0: S’->.S S->.L=R S->.R
(0) S’->S (1) S->L=R (2) S->R (3) L->*R (4) L->id (6) R->L I1 I0: S’->.S S->.L=R S->.R L->.*R L->.id R->.L I4: L->*.R R->.L L->.*R L->.id S R I0 I3 L id I2 I5: L->id. * * I6: S->L=.R R->.L L->.*R L->.id I1: S’->S. R id I7 I4 I5 = I2: S->L.=R R->L. * id L I7: L->*R. R I9 I3: S->R. I6 L I8: R->*L. I8 I9: S->L=R. 9/7/2018 Formal Diller

action goto id = * $ S L R 1 2 S6,r6 3 4 5 6 7 8 9
State action goto id = * $ S L R 1 2 S6,r6 3 4 5 6 7 8 9 shift/reduce conflict 9/7/2018 Formal Diller

Ambiguity, SLR(1) Gramer
Her SLR(1) grameri unambiguous dur. Her unambiguous gramer SLR(1) değildir Önceki örneğimizde gramer unambiguous, fakat SLR(1) değil Shift/reduce conflict SLR(1) tablosunun herhangi bir gözüne hem shift hem de reduce tekabul etmesi SLR(1) gramer shift/reduce conflicti giderecek kadar güçlü değil 9/7/2018 Formal Diller

=, Follow(R) nin elemanı (reduce, r6)
(0) S’->S (1) S->L=R (2) S->R (3) L->*R (4) L->id (6) R->L I6: S->L=.R R->.L L->.*R L->.id =, s6 I2: S->L.=R R->L. =, Follow(R) nin elemanı (reduce, r6) …R = … (mantıksal böyle bir right sentential form yok). I2 iken = için reduction yapmak yanlış olacaktır. Bu LRS parserın productionın sol tarafını yeterince hatırlayamamasından kaynaklanmaktadır. 9/7/2018 Formal Diller

Canonical LR Parsing Tablosu
Bazı geçersiz reductionlari (A->) yok etmek için statelere ekstra bilgi konabilir Gerekli olduğunda state leri bölmek suretiyle hangi input sembolleri bir handle i izleyebilir, ve hangi handle için muhtemel bir reduction olduğuna karar verilebilir Genel olarak item şekli: [A-> ., a] A-> bir production, a bir terminal veya $ 9/7/2018 Formal Diller

LR(1) item (1) itemdaki ikinci bileşenin uzunluğunu gösterir (lookahead of the item) [A-> ., a] Lookahead in etkisi yok, eğer [A-> ., a] oyleki , ε den farklı Lookahead etkisi var, eğer [A-> ., a] Reduction sadece sonraki input sembolü a iken uygulanır. 9/7/2018 Formal Diller

function closure(I) begin repeat for each item [A-> .B, a] in I,
each production B->  in G’, and each terminal b in FIRST(a) such that [B->. , b] is not in I do add [B->. , b] to I ; until no more items can be added to I return I end 9/7/2018 Formal Diller

function goto(I,X) begin. let J be set of items [A-> X
function goto(I,X) begin let J be set of items [A-> X., a] such that [A-> .X, a] is in I ; return closure(J) end 9/7/2018 Formal Diller

add goto (I,X) to C until no more sets of items can be added to C end
procedure items(G’ ) begin C:={closure({[S’->.S, $ ]})}; repeat for each set of items I in C and each grammar symbol X such that goto(I,X) is not empty and not in C do add goto (I,X) to C until no more sets of items can be added to C end Grammar G’ den LR(1) item kümelerinin elde edilmesi 9/7/2018 Formal Diller

(0) S’->S (1) S->CC (2) C->cC (3) C->d
S->.CC, $ C->.cC, c/d C->.d, c/d I0 (0) S’->S (1) S->CC (2) C->cC (3) C->d S’->S. , $ I1 S C S->C.C, $ C->.cC, $ C->.d, $ I2 S->CC.,$ I5 C c c c C->c.C, $ C->.cC, $ C->.d, $ I6 C->cC.,$ I9 C d d c C->c.C, c/d C->.cC, c/d C->.d, c/d I3 d C->cC.,c/d I8 C C->d.,$ I7 d C->d.,c/d I4 9/7/2018 Formal Diller

Canonical LR Parsing Tablosunun Elde Edilmesi
Input: Augmented grammar G’ Output: Canonical LR parsing table functions action, goto 1. LR(1) item lerinin kümeler koleksiyonu C={I0, I1, ……, In} yi bul. 2. State i Ii den elde edilir a) Eğer [A.a ,b] Ii nin elemanı ve goto(Ii ,a) =Ij ise action[i,a]=shift j burada a terminaldir. b) Eğer [A.,a] Ii nin elemanı ve A, S’ den farklı ise action[i,a] = reduce A dir c) Eğer [S’  S.,$] Ii nin elemanı ise action[i,$] = “accept” 3. State i için goto geçişleri tüm nonterminaller A icin : Eğer goto(Ii,A) = Ij ise goto[i,A] =j dir ve 3. kuralla tanımlanmayan tablonun geri kalan tüm elemanları “error” olarak işaretlenir 5. Parser in başlangıç state i [S’.S, $] nin closure undan elde edilen state dir. 9/7/2018 Formal Diller

Canonical Parsing Table (LR(1) Parsing Table)
STATE action goto c d $ S C s3 s4 1 2 acc s6 s7 5 3 8 4 r3 r1 6 9 7 r2 9/7/2018 Formal Diller

(0) S’  S (1) S  L=R (2) S  R (3) R  L
(4) L  id (5) L  *R I4 I3 SL=.R , $ R.L , $ L .*R , $ L .id , $ S’ L.=R. , $ R L , $ = I2 S’ S. , $ S L L I5 S’.S , $ S.L=R , $ S.R , $ L .*R , = L .id , = R .L ,$ S R. , $ id R R I1 I7 R L. , $ S L.=R. , $ I9 * id I8 L L id. , = L*.R= , $ R.L , $ L .*R , $ L .id , $ * * id id I11 L id. , $ I13 L *.R , = R .L , = L .*R , = L .id , = I6 R R L *R. , = I10 L *R. , $ I14 L R L. , = I12 * 9/7/2018 Formal Diller

LR(1) Parsing Table State action goto id * = $ S R L 1 s8 s6 g2 g5 g3
acc. 3 s4 r3 4 s11 s13 g9 g7 5 r2 6 g10 g12 7 8 r4 9 r1 10 r5 11 12 13 g14 14 9/7/2018 Formal Diller

LALR(1) Parsing LR(1) parsing tablosu çok büyük olabilir (çok sayıda durum barındırabilir) Tablo, itemları aynı fakat lookahead kümeleri farklı olan iki kümenin birleştirilmesiyle küçültülebilir Tablosu bu şekilde elde edilen parsera LALR(1) denir. 9/7/2018 Formal Diller

6 ile 13; 7 ile 12; 8 ile 11; 10 ile 14 birleştirilebilir.
LALR(1)Tablosu LR(1) Tablosu x * = $ S R L 1 s8 s6 g2 g5 g3 2 acc. 3 s4 r3 4 s11 s13 g9 g7 5 r2 6 g10 g12 7 8 r4 9 r1 10 r5 11 12 13 g14 14 x * = $ S R L 1 s8 s6 g2 g5 g3 2 acc. 3 s4 r3 4 g9 g7 5 r2 6 g10 7 8 r4 9 r1 10 r5 6 ile 13; 7 ile 12; 8 ile 11; 10 ile 14 birleştirilebilir. 9/7/2018 Formal Diller

Ambiguity Ambiguous Grammar: Bazi sentence lar icin birden fazla parse tree ureten grammarlere denir. Ambiguous Grammar ler bazi sentence lari birden fazla.

Benzer bir sunumlar

... konulu sunumlar: "Ambiguity Ambiguous Grammar: Bazi sentence lar icin birden fazla parse tree ureten grammarlere denir. Ambiguous Grammar ler bazi sentence lari birden fazla."— Sunum transkripti:

Benzer bir sunumlar

Proje hakkında

Geri bildirim

Giriş

Sosyal ağ üzerinden giriş yapmak:

Ambiguity Ambiguous Grammar: Bazi sentence lar icin birden fazla parse tree ureten grammarlere denir. Ambiguous Grammar ler bazi sentence lari birden fazla.

Benzer bir sunumlar

... konulu sunumlar: "Ambiguity Ambiguous Grammar: Bazi sentence lar icin birden fazla parse tree ureten grammarlere denir. Ambiguous Grammar ler bazi sentence lari birden fazla."— Sunum transkripti:

Benzer bir sunumlar

Proje hakkında

Geri bildirim