LL-Parser
# LL-Parser

Im Compilerbau ist ein LL-Parser ein Top-Down-Parser, der die Eingabe von Links nach rechts abarbeitet, um eine Linksableitung der Eingabe zu berechnen.

Ein LL-Parser heißt LL(k)-Parser, wenn er während des Parsens k Tokens vorausschauen kann und im Gegensatz zum LF-Parser den Kellerinhalt benutzt. k wird dabei als Lookahead bezeichnet. Diesem Parsertyp liegen die LL(k)-Grammatiken zu Grunde.

Obwohl die LL(k)-Grammatiken relativ eingeschränkt sind, werden LL(k)-Parser oft benutzt. Die Entscheidung, nach welcher Regel expandiert wird, kann allein durch Analyse des Lookahead getroffen werden. Eine einfache Möglichkeit zur Implementierung dieser Parsertechnik bietet die Methode des rekursiven Abstiegs.

## Funktionsweise

Ausgangspunkt ist eine Grammatik $G=(N,\Sigma ,P,S)$. Der Parser arbeitet mit einer Zustandsmenge $Q=(N\cup \Sigma )^{*}\times \Sigma ^{*}\times \mathbb {N} ^{*}$, wobei sich ein Zustand $q=(k,w,z)\in Q$ so zusammensetzt:

* $k$ ist der aktuelle Inhalt eines Laufzeitkellers, der für die Speicherung der aktuellen Symbole verwendet wird. $k$ kann sowohl Terminal- als auch Nichtterminalsymbole beinhalten.
* $w$ ist der Teil der Eingabe, der noch nicht gelesen wurde.
* $z$ ist die Ausgabe, eine Folge natürlicher Zahlen, die die Nummern der Regeln der Linksableitung enthält.

Der nichtdeterministische Automat für die LL(k)-Analyse ist dann:

* ${\mathcal {A}}=(Q,\delta ,q_{0},F)$
* $q_{0}=(S,w,\epsilon )$ (Anfangszustand)
* $F=(\epsilon ,\epsilon ,z)$ (Endzustand)

Dabei ist $S$ das Startsymbol der zugrundeliegenden Grammatik und $z$ die Linksanalyse der Eingabe $w$.

Die Transitionen $\delta$ setzen sich so zusammen:

* $(a\alpha ,aw,z)\vdash (\alpha ,w,z)$ (Shift- oder Verschiebeschritt)
* $(A\beta ,w,z)\vdash (\alpha \beta ,w,zi)$ (Expansions- oder Ableitungsschritt), wobei die Regel $A\rightarrow \alpha$ in der Regelmenge $P$ enthalten sein muss und $i$ die Nummer dieser Regel ist.

## LL(1)-Parser

Dieser Parsertyp verwendet einen Lookahead von einem Zeichen. Auf Grund dieser Einschränkung kann einfach ein deterministischer Parser erstellt werden.

Die oben genannten nichtdeterministischen Schritte werden dabei durch den Lookahead determiniert.

### Beispiel Implementierung in Python

In einem Beispiel soll ein LL(1) Parser die folgende einfache Grammatik abbilden:

Die folgende Python-Implementierung des LL(1)-Parsers zu dieser Grammatik wird auf den Eingabestring ((n+n)+n) angewendet:

Die Ausgabe des Skripts ergibt bei korrekter Syntax direkt den serialisierten Syntax-Baum:

