LL analyzátor

LL analyzátor je stůl-založený vrchol-dole analyzátor pro podmnožinu kontext-uvolnit gramatiky. To rozebere vstup od Left spravit, a pojmy Leftmost původ věty (od této doby LL, vyrovnat se LR analyzátoru). Třída gramatik, které jsou parsable v této cestě je známá jako LL gramatiky. Starší programovací jazyky někdy používají LL gramatiky, protože to jde snadno vytvořit analyzátory pro je po ruce - používání jeden stůl-založená metoda popsala tady, nebo rekurzivní generační analyzátor.

LL analyzátor je nazýván LL (k) analyzátor jestliže to používá k tokenss pohledu-dopředu když rozebere větu. Jestliže takový analyzátor existuje pro jistou gramatiku a to může rozložit věty této gramatiky bez ústupku pak to je nazýváno LL (k) gramatika. Těchto gramatik LL (1) gramatiky, ačkoli docela omezující, být velmi populární protože korespondenční LL analyzátory jen potřebují se dívat na příští známku dělat jejich rozebrat rozhodnutí.

Tabulka s obsahem

1 architektura LL analyzátoru
2 budovat LL (1) rozebrat stůl
3 budovat LL (k) rozebrat stůl

Architektura LL analyzátoru

Stůl-založený vrchol-dole analyzátor může být schématicky představován jak v čísle 1.

        + -- - + -- - + -- - + -- - + -- - + -- - + Vstup: | (| 1 | + | 1 |) | $ | + -- - + -- - + -- - + -- - + -- - + -- - + ^ | Stack: | + -- -- -- -- -- + + -- - + | | | + |  Výstup + -- - + | | | S | + -- -- -- -- -- + + -- - + ^ |) | | + -- - + | | $ | + -- -- -- -- -- + + -- - + | Rozebrat | | stůl | + -- -- -- -- -- +

 Číslo 1. architektura stolu-založený vrchol-dole analyzátor

Analyzátor má vstupní buffer, hromada na kterém to tají symboly před gramatikou, rozebrat stůl který řekne tomu jaké mluvnické pravidlo k použití daný symboly na vrcholu jeho zásobníku a jeho vstupu nahrávají. Vysvětlit to jeho workings my budeme používat následující malou gramatiku:

(1) S -> F

(2) S -> ( S + F )

(3) F -> 1

Rozebrat stůl pro toto gramatika dívá se takto:

	(	)	1	+	$
S	2	-	1	-	-
F	-	-	3	-	-

Poznamenat, že tam je také sloupec pro zvláštní terminál $ to je používáno ukázat konec potoku vstupu.

Když analyzátor začne to vždy začne s jeho hromadou s

[ S, $ ]

kde $ je zvláštní terminál ukázat dno zásobníku a konec potoku vstupu, a S je začátek symbol gramatiky. Analyzátor bude pokoušet se přepsat obsah tohoto zásobníku k čemu to vidí na potoku vstupu. Nicméně, to jen si drží hromadu co ještě potřebuje být přepsán. Například, nechal nás předpokládat, že vstup je “(1 + 1)”. Když analyzátor čte první “(#rquote to ví, že to má k přepsání S k “(S + F)” a píše množství tohoto pravidla k výstupu. Hromada pak se stojí:

[ (, S, +, F, ), $ ]

V příštím kroku to odstraní ' (' od jeho potoku vstupu a od jeho hromady:

[ S, +, F, ), $ ]

Nyní analyzátor vidí ' 1 ' na jeho potoku vstupu tak to ví, že to musí použít pravidlo (1) a pak vládnout (3) od gramatiky a psát jejich číslo potoku výstupu. Toto vyústí v následující hromady:

[ F, +, F, ), $ ]
[ 1, +, F, ), $ ]

V další dva kroky analyzátor čte ' 1 ' a ' + ' od potoku vstupu a také odstraní je ze zásobníku, končit:

[ F, ), $ ]

V další tři kroky ' F ' bude být nahrazen na hromadě s ' 1 ', číslo 3 bude být psán k potoku výstupu a pak ' 1 ' a ') ' bude být odstraněn od hromady a potoku vstupu. Tak analyzátor končí oběma ' $ ' na jeho hromadě a na jeho páře vstupu. V tomto případě to bude hlásit, že to přijímalo řetězec vstupu a na výstupním potoku to psalo seznam čísel [2, 1, 3, 3] který je opravdu rightmost původ řetězce vstupu opačně.

Jak moci být viděn od příkladu analyzátor vykonává tři druhy kroků spoléhat se na zda vrchol zásobníku je nonterminal, terminál nebo zvláštní symbol $:

Jestliže vrchol je nonterminal pak to se zlepšuje v rozebrat stůl na východisku pro toto nonterminal a symbol na vstupu rozdělí které pravidlo gramatiky to by mělo používat nahradit to s na hromadě. Množství pravidla je psáno k potoku výstupu. Jestliže rozebrat stůl ukáže, že není tam žádné takové pravidlo pak to ohlásí chybu a zastaví se.
Jestliže vrchol je terminál pak to přirovnává to k symbolu na potoku vstupu a jestliže oni jsou se rovnat oni jsou oba vzdálení. Jestliže oni nejsou se rovnat analyzátoru ohlásí chybu a zastaví se.
Jestliže vrchol je $ a na vstupu potok tam je také $ pak analyzátor hlásí, že to úspěšně rozebralo vstup, jinak to ohlásí chybu. V obou případech analyzátor se zastaví.

Tyto kroky jsou opakovány až do zastávek analyzátoru a pak to bude mít jeden kompletně rozebral vstup a psaný leftmost původ k potoku výstupu nebo to bude mít hlásila chyba.

Budovat LL (1) rozebrat stůl

Aby se plnil rozebrat stůl my musíme založit jaké mluvnické pravidlo analyzátor by měl vybrat si jestliže to vidí nonterminal na vrcholu jeho zásobníku a symbolu na jeho potoku vstupu. To jde snadno vidět to takový pravidlo by mělo být od - > w a to jazyk dopisovat si s w should mít přinejmenším jeden řetězec začínat . Pro tento účel my vymezíme Nejprve-soubor w, psaný tady jako Fi(w), jako terminály s kterým řetězce, které patří k w odstartovat plus a epsilon; jestliže prázdné řetězce také patří k w. Daný gramatika s pravidly ₁ - > w₁,..., _n - > w_n my můžeme vypočítat Fi(w_i) a Fi(_i) pro každé pravidlo takto:

inicializovat každý Fi(w_i) a Fi(_i) s prázdnou množinou
přidat Fi(w_i) k Fi(w_i) pro každé pravidlo _i - > w_i kde Fi je definován takto:
- Fi( w ' ) = { } pro každý terminál
- Fi( w ' ) = Fi() pro každý nonterminal s a epsilon; ne v Fi()
- Fi( w ' ) = Fi() \ \ {a epsilon;} a pohár; Fi(w ' ) pro každý nonterminal s a epsilon; v Fi()
- Fi(a epsilon;) = {a epsilon;}
přidat Fi(w_i) k Fi(i) pro každé pravidlo _i - > w_i
opakují kroky 2 a 3 až do všech Fi soubory zůstanou stejné.

Bohužel první-soubory jsou nedostatečné vypočítat rozebrat stůl. Toto je protože pravá strana w pravidlo by mohlo nakonec být přepsáno k prázdnému řetězci. Tak analyzátor by měl také používat pravidlo - > w jestliže a epsilon; je v Fi(w) a to vidí na vstupu rozdělit symbol, který mohl následovat . Proto my také potřebujeme Následovat-soubor , psaný jako Fo() tady, který je definován jako soubor terminálů takový že tam je řetězec symbolů a alpha; Aa a beta; to může být odvozeno ze symbolu začátku. Práce na počítači následovat-soubory pro nonterminals v gramatické plechovce jsou dělány takto:

inicializovat každý Fo(_i) s prázdnou množinou
jestliže tam je pravidlo formy _j -> _iw' pak
- jestliže terminál je v Fi(w ' ) pak sčítat k Fo(_i)
- jestliže a epsilon; je v Fi(w ' ) pak přidat Fo(_j) k Fo(_i)
opakovat krok 2 až do všech Fo soubory zůstanou stejné.

Teď my můžeme vymezit přesně která pravidla budou obsahovaná kde v rozebrat stůl. Jestliže T[, ] naznačuje záznam ve stolu pro nonterminal a terminál pak

T[,] obsahuje pravidlo - > w iff

je v Fi(w) nebo

a epsilon; je v Fi(w) a je v Fo().

Jestliže stůl bude obsahovat u většiny jednoho pravidla v každém jeho buňek pak analyzátor bude vždy znát kterého rozhodnout, že to musí používat a moci proto rozebrat řetězce bez ústupku. To je přesně v tomto případě že gramatika je volána LL (1) gramatika.

Budovat LL (k) rozebrat stůl

... přesto být psán...