Algoritma LL 1

L : left to ritht penelusuran string input

L: left to rught , symbol non terminalyang akan diturunkan adalah symbol nonterminal (huruf besar)
terkiri dulu

A  BdCe

Yang diturunkan B dulu

Angka 1 : nyontek 1 simbol terminal berikutnya dari inputnya (look ahead)

Efisien Karen apenulusurannya maju terus tanpa ada proses backtracking

LL 1 xyyyyyz

A-> xB-> xyB-> xyyB->xyyyB->xyyyyB->xyyyyyB->xyyyyyz

Efisiensinya O(n) karena proses yang dilakukan sebanyak symbol

Jika B -> yzB

LL1 belum bisa menghandle jika terdapat rule dengan “contekan” yang sama jadi buat contekan lagi

A->xB->xyB ->

First(yB) irisan first (yzB) = {y} bukan {} sehingga grammar tersebut tidak bisa diselesaikan menggunakan
LL(1)

Kelemnahan : tidak bisa menghandle grammar yang memiliki symbol awal yang sama.

Soulisi : brammarnya di ubah sehingga bisa dilakukan algoritma LL tanpa mengubah bahsanya. Sebelum
erubah grammer kit aharus mengetahui karakter grammer yang bisa dilakukan algoritma LL1.

1. Jika dalam sebuah grammar ada rule dengan format seperti ini.
Jika A -> string 1 |string2|string 3|…|string n
Maka syaratnya adalah : FIRST (symbol terminal terkiiri yang bisa di temukan dari sebuah
aturan) (string-1 irisan string j ) = himpunan kosong (), untuk semua i,j : 1..N dimana i<>j
2. Jika sebuah symbol non terminal bisa emnghasilkan epsilon dari rule maka First (B) irisan
follow(B) = {}. Tapi jika tidak menghasilkan epsilon maka first b dan

Missal symbol non terminal {A,B}

Symbol terminal {x}

Symbol awal : A

Rume : A-> Bx
B->x

B-> epsilon

First (B) = {epsilon,x}

Follow (B) = {y}

First (B) irisan follow(B) = {}

Coba turunkan string x diterima

ABx (karna contekannya x maka cocok menjadi x) xx (tidak diterima) harsunya di terima

Ll 1 :

, efektif

Implementasinya mudah

A->xB

B->z

B->yC

C->zD

C->B

D->B

D->eps

Xyyz

Keuntungan LL1

1. Efektif : kompleksitas O(n)

2. Implementasi mudah (rekursif : program yg punya prosedur atau fingsi yang memanggil dirinya
sendiri)
Program rekursif LL1;

Begin (cek symbol awal)

Sym = getsym(); #mengambil simbol dr file program simbol tsb masuk ke var sym

SIMBOLaWAL();

Printf(“string diterima”);

End

Diketahui grammar

Bagaimana mengimplementasikan grammar tersebut dalam sebuah program?

Missal ada grammar dengan symbol awal adalah A dan rulenya sbb :

<A> -> <B>.

<B> -> x|(<C>)|[<B>]|eps

<C> -> <B><D>

<D> -> {+B} #pengulangan

Missal ingin check apakah x. diterima ?

Cara prosedur :

1. Semua symbol non terminal akan menjadi sebuah prosedur dari symbol non terminal tsb yang
isinya “ruas kanan dari symbol non terminal tersebut”
2. Ruas kanan dari aturan grammar tergantung isi ruas kanannya
a. Kemungkinan pertama ruas kanannya adalah : sebuah symbol terminal saja. Maka panggil
prosedur parse(terminal)
b. Kemungkinan kedua adalah sebuah symbol non terminal saja.
Panggil prosedur dengan naman symbol non terminal itu.
c. Kemungkinan ketiga symbol terminal dan non terminal (concatenation). Panggil satu satu
jika symbol terminal panggil parse(terminal) jika non terminal panggil prosedur non
terminalnya.
d. Kemungkinan ke empat ruas kananya ada atau (|).
Isinya case sym(contekan) of parse terminal :
First alpha 1 = parse alpha 1
First alpha 2 = parse alpha 2
 …
First
( Jika ada epsilon maka follow (s) yakni do nothing )
e. Jika extended bnf ada kurawal (perulangan)
While sym = first alpha do parse alpha end

Main ();{
Getsym();
S();
Print(“String diterima”);}