Chapter 7 Penguraian LR

Pendahuluan Komponennya: Input Output Program driver Tabel penguraian (action, goto) Perbedaan dengan penguraian bawah-atas (bottom-up) lainnya terletak pada tabel penguraian.

(soX1s1X2 …Xmsm , aiai+1 …an $) Pendahuluan (Cont’d) Konfigurasi pengurai LR adalah suatu pasangan yang komponen pertamanya adalah isi stack, komponen keduanya adalah string input: (soX1s1X2 …Xmsm , aiai+1 …an $)

Langkah-langkah dalam proses LR Misalkan ai simbol input pertama, sm adalah simbol pada puncak stack. Salah satu berikut, merupakan langkah dalam proses penguraian LR. action[sm, ai] = shift s, ai dipindahkan ke stack, begitu juga (setelah ai) s. Hal ini menghasilkan konfigurasi baru: soX1s1X2s2 …Xmsmai s, ai+1 …an action[sm, ai] = reduksi A  β, maka parser melakukan reduksi dan menghasilkan konfigurasi soX1s1 …Xm-rsm-rA s,aiai+1 …an

Langkah-langkah dalam proses LR (Cont’d) dimana s = goto[sm-r,A] dan r adalah panjang dari string β. Pada awalnya, 2r simbol dipop dari stack (r simbol state dan r simbol grammar). Kemudian A dipush ke stack, lalu s dipush ke stack. β = Xm-r+1 … Xm Action [sm,, ai] = accept, proses selesai Action [sm , ai] = error, terjadi kesalahan, rutin pengendali kesalahan bisa dipanggil.

Algoritma penguraian LR Input: string input w, tabel penguraian LR yang terdiri dari fungsi action dan goto (berdasarkan grammar G). Output: uraian bawah-atas (bottom-up parsing dari w jika w Є L(G), jika tidak  error. Metoda: pada awalnya, so ada di puncak stack (so = state awal) dan w$ merupakan input. Dalam proses parser akan mengeksekusi program berikut.

Algoritma penguraian LR (Cont’d) ip menunjuk pada simbol pertama w$ repeat forever begin misalkan S adalah state di puncak stack, dan a adalah simbol yang ditunjuk oleh ip if action[s,a] = shift s' then begin push a ke dalam stack, lalu s' ke dalam stack ip menunjuk pada simbol input berikutnya end else if action[s,a] = reduksi A  β then begin pop simbol sebanyak 2*|β| dari stack; misalkan s’ adalah state di puncak stack push A lalu goto[s’,A] ke dalam stack; tampilkan output berupa A  β else if action[s,a] = accept then return else error()

Contoh Algoritma penguraian LR Perhatikan grammar ekspresi aritmetik, dengan operator biner + dan *: E  E+T E  T T  T*F T  F F  (E) F  id

Tabel penguraiannya : state action goto si = shift state i ke stack 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 si = shift state i ke stack rj = reduksi dengan produksi nomo r j Acc = accept Blank = error

Stack Input Aksi 1 id*id+id$ Shift 5 2 0id5 *id+id$ id*id+id$ Shift 5 2 0id5 *id+id$ reduksi oleh F  id 3 0F3 reduksi oleh T  F 4 0T2 Shift 7 5 0T2*7 id+id$ 6 0T2*7id5 +id$ reduksi oleh F  Id 7 0T2*7F10 reduksi oleh T  T*F 8 reduksi oleh E  T 9 0E1 Shift 6 10 0E1+6 id$ 11 0E1+6id5 $ 12 0E1+6F3 13 0E1+6T9 reduksi oleh E  E+T 14 accept

Pembuatan Tabel Penguraian LR Metoda simple LR (SLR), paling mudah dan paling buruk Metoda LR kanonik, paling baik dan paling mahal Metoda Look-Ahead LR (LALR), kemampuan + cost diantara SLR dan LR kanonik

Pembuatan Tabel Penguraian LR (Cont’d) Untuk membuat tabel ini diperlukan beberapa definisi: item LR(0) atau item saja. closure(I), dimana I adalah himpunan item. goto(I,X), dimana I adalah himpunan item dan X adalah simbol grammar. koleksi kanonik dari item LR(0).

Pembuatan Tabel Penguraian LR (Cont’d) item LR(0) atau item dari suatu grammar G adalah suatu produksi dari G dengan suatu dot (.) muncul pada sisi kanan produksi itu. Contoh: produksi A  XYZ memberikan empat item: A  .XYZ A  X.YZ A  XY.Z A  XYZ.

Pembuatan Tabel Penguraian LR (Cont’d) Closure(I), dimana I adalah himpunan item untuk G, adalah himpunan item yang dibuat dari I oleh aturan berikut: Setiap item di dalam I, juga anggota closure(I). Jika A  α.Bβ anggota closure(I) dan B  γ adalah suatu produksi, maka tambahkan B  . γ ke dalam closure(I).

Pembuatan Tabel Penguraian LR (Cont’d) begin J := I; repeat for masing-masing item A  α.Bβ di dalam J, dan produksi B  γ dari G sedemikian rupa sehingga B  . γ tidak di dalam J do tambahkan B  . γ ke dalam J until tidak ada item yang dapat ditambahkan ke J. return J end

Pembuatan Tabel Penguraian LR (Cont’d) Contoh: Perhatikan grammar G' E'  E E  E+T | T T  T*F | F F  (E) | id

Pembuatan Tabel Penguraian LR (Cont’d) Jika I adalah himpunan satu item {[E‘ .E]}, maka closure(I) memuat item: E'  .E E  .E+T E  .T T  .T*F T  .F F  .(E) F  .id

Pembuatan Tabel Penguraian LR (Cont’d) goto(I,X) adalah closure dari himpunan semua item [A  αX.β ] sedemikisan rupa sehingga A  α.X β ada di dalam I. Contoh: jika I adalah himpunan dua item {[E'  E.], [E  E.+T]} maka goto (I,+) memuat: E  E+.T T  .T*F T  .F F  .(E) F  .id

Pembuatan Tabel Penguraian LR (Cont’d) Algoritma untuk membuat C (koleksi kanonik dari himpunan item LR(0) berdasarkan grammar G'). procedure items(G') begin C := {closure({[S'  .S]}; repeat for masing-masing himpunan item I dalam C dan masing-masing simbol grammar X dimana goto(I,X) tidak kosong dan tidak di dalam C do tambahkan goto(I,X) ke dalam C until tidak ada himpunan item yang dapat ditambahkan ke C. end.

Pembuatan Tabel Penguraian LR (Cont’d) Contoh: untuk grammar E'  E E  E+T | T T  T*F | F F  (E) | id

Pembuatan Tabel Penguraian LR (Cont’d) koleksi kanoniknya adalah : I0 : E'  .E E  .E+T E  .T T  .T*F T  .F F  .(E) F  .id I1=goto(I0,E): E'  E. E  E.+T I2 = goto(I0,T): E  T. T  T.*F

Pembuatan Tabel Penguraian LR (Cont’d) I3 = goto(I0,F) : T  F. I5 = goto(I0,id): F  id . I4 = goto(I0,(): F  (.E) E  .E+T E  .T T  .T*F T  .F F  .(E) F  .id

Pembuatan Tabel Penguraian LR (Cont’d) I6 = goto(I1,+): E  E+.T T  .T*F T  .F F  .(E) F  .id I7 = goto(I2,*): T  T*.F F  .(E) F  id I8 = goto(I4,E): F  (E.) E  E.+T

Pembuatan Tabel Penguraian LR (Cont’d) I9 = goto(I6,T): E  E+T. T  T.*F I10 = goto(I7,F): T  T*F. I11 = goto(I8,)): F  (E).

Pembuatan Tabel Penguraian LR (Cont’d) Fungsi goto dari himpunan item yang lalu, digambarkan sebagai diagram transisi dari Deterministic Finite Automata (DFA). DFA ini mengenal prefik viabel dari grammarnya. Ada suatu transisi dari A  α.Xβ ke A  α X.β dengan label X, ada juga transisi A  α.Bβ ke B  .γ dengan label Є.

Algoritma pembentukan tabel penguraian SLR Input: grammar G' Output: Fungsi action dan goto untuk tabel penguraian SLR. Metoda: Buat C = {I0, I1, …, In}, yang merupakan koleksi himpunan item LR(0) untuk G'. Buat state i dari Ii. Aksi penguraian untuk state i ditentukan sebagai berikut: Jika [A  α.a ] anggota Ii, dan goto(Ii , a) = Ij , maka action[i,a] = shift j dimana a harus merupakan terminal.

Algoritma pembentukan tabel penguraian SLR (Cont’d) Jika [A  α.] anggota Ii, maka action[i,a] = reduksi A  , a anggota FOLLOW(A). A tidak harus = S'. Jika [S’  S .] anggota Ii, maka action [i,$] = accept. Jika terjadi konflik, proses gagal, grammarnya bukan SLR(1). Dengan melihat DFAnya, transisi pada state i dapat ditentukan untuk nonterminal A; Jika goto(Ii, A) = Ij , maka goto[i,A] = j. Semua entri yang tidak terdenisi oleh (2) dan (3) adalah error. State awal pengurai (parser) adalah state yang dibuat dari himpunan item yang memuat [s'  .s]

Algoritma pembentukan tabel penguraian SLR (Cont’d) Contoh: perhatikan contoh yang lalu dimana C = {I0, I1, …, I11}. Pada I0 himpunan itemnya sebagai berikut: E'  .E E  .E+T E  .T T  .T*F T  .F F  .(E) F  .id

Algoritma pembentukan tabel penguraian SLR (Cont’d) item F  .(E) mengakibatkan action [0,(] = shift 4, item F  .id mengakibatkan action [0,id] = shift 5, item lainnya tak menghasilkan action. I1: E'  E. E  E.+T E'  E. mengakibatkan action [1, $] = accept, E  E.+T mengakibatkan action [1, +] = shift 6

Algoritma pembentukan tabel penguraian SLR (Cont’d) E  T. T  T.*F karena FOLLOW(E) = {$, +, )} : E  T. mengakibatkan action [2, $] = action [2, +] = action [2, )] = reduksi oleh E  T. T  T.*F mengakibatkan action [2, *] = shift 7. ... lalu ... LANJUTKAN SENDIRI ... !