1 / 30

Chapter 7 Penguraian LR

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. Pendahuluan (Cont’d).

laddie
Download Presentation

Chapter 7 Penguraian LR

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Chapter 7Penguraian LR

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

  3. 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 $)

  4. 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

  5. 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.

  6. 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.

  7. 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  β end else if action[s,a] = accept then return else error() end

  8. 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

  9. Tabel penguraiannya : si = shift state i ke stack rj = reduksi dengan produksi nomo r j Acc = accept Blank = error

  10. 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

  11. 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).

  12. 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.

  13. 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).

  14. 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

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

  16. 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

  17. 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

  18. 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.

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

  20. 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

  21. 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

  22. 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

  23. 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).

  24. 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 Є.

  25. 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.

  26. 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]

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

  28. 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

  29. Algoritma pembentukan tabel penguraian SLR (Cont’d) I2: 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 ... !

More Related