Kapitel 3 Syntaktische Analyse

(1)

Kapitel 3

Syntaktische Analyse

(2)

Kapitel 3: Syntaktische Analyse

1 Einbettung

2 Theoretische Grundlage: Kontextfreie Grammatiken Konkrete und abstrakte Syntax

Abstrakte Syntax als abstrakte Algebra Sonderfälle

Semantische Aktionen Kellerautomaten

3 LL- und SLL-Grammatiken 4 LR-,SLR-Grammatiken

LALR-Konstruktion Parsergeneratoren

Bison

Optimierungen und Komplexität 5 Fehlerbehandlung

6 Earley Parser

Syntaktische Analyse Sommersemester 2012 2 / 178

(3)

Syntaktische Analyse

vorgegeben:

Tokenstrom

kontextfreie Grammatik (deterministisch?) Aufgaben

syntaktische Struktur bestimmen

syntaktische Fehler melden, korrigieren (?)

Ausgabe (immer): abstrakte Syntax (Rechts-/Linksableitung), Symbole (Bezeichner, Konstanten, usw.)

(4)

Eingliederung in den Übersetzer

Lexer Parser Semantische

Analyse

Fehlerbehandlung Stringtabelle

Text Tokenstrom AST

(5)

ADT Parser

gelieferte Operationen:

parse() : AST benötigte Operationen:

Lexer/Tokenstrom:

next_token() : Token Fehlerbehandlung:

add_error(nr, pos) für Aufbau Strukturbaum:

production(nr),symbol(value)

(6)

Aufgabe des Parsers, formal

Gegeben:GrammatikG = (T,N,P,Z)mit

T Alphabet, N Nichtterminale, P Produktionen, Z Zielsymbol Gesucht:Entscheidung gehört Tokenstrom s zur SpracheL(G),

wenn ja, Produktionenfolge für Links-/Rechtsableitung wenn nein, Fehlerbehandlung zur Korrektur des Tokenstroms Unterscheide konkrete SyntaxGk und abstrakte SyntaxGa:

(7)

Annahmen für das Parsen

Syntax ist kontextfrei

eigentlich ist sie kontext-sensitiv

aber kontext-sensitive Grammatiken nicht in linearer Zeit parsbar (Kontextfreiheit ist selbsterfüllende Prophezeiung) der über die kontextfreie Grammatik hinausgehende Teil der Syntax heißt im Übersetzerbau statische Semantik

Syntax ist deterministisch kontextfrei

keine wesentliche Einschränkung, da auch vom menschlichen Leser erwünscht

keine Rückkopplung zur lexikalischen Analyse

sonst gäbe es mehrere Grundzustände des Lexers, gesteuert vom Parser

keine Rückkopplung semantische Analyse – syntaktische Analyse typunabhängige Syntaktische Analyse: Zustände des Parsers unabhängig von der Namens- und Typanalyse

(8)

Fragen

Wie wird Sprache erkannt?

Wie wird abstrakter Strukturbaum aufgebaut?

Was geschieht bei Fehlern?

(9)

Historie, kf Grammatiken + Verarbeitung

1955 Definition und Klassifikation (Chomsky und Bar Hillel) 1957–1959 Kellerautomaten (Bauer&Samelson, sequentielle For-

melübersetzung, 1959)

1961 formaler Zusammenhang kfG-Kellerautomat (Öttin- ger)

1958–1966 kfGs und BNF setzen sich für die Syntax von Program- miersprachen durch (Algol 58, Algol 60, . . . )

1960–1972 Verfahren des rekursiven Abstiegs (Glennie) und dessen theoretische Fundierung als LL-Grammatiken (auch heute noch oft neu erfunden!)

1963–1969 deterministische kfGs: beschränkte Operatorpräze- denz, LR,SLR,LALR, . . .

seit 1972 nichts wesentlich Neues außer Optimierung, Fehlerbe- handlung

(10)

Kapitel 3: Syntaktische Analyse

1 Einbettung

Bison

6 Earley Parser

(11)

Grundbegriffe

Kontextfreie Grammatik

Eine GrammatikG = (T,N,P,Z) heißt kontextfrei, wenn für jede ProduktionA → α gilt: A∈N.

Im Folgenden istV =T ∪N.

SpracheL(G) einer GrammatikG

L(G) ={ω ∈T^∗|Z ⇒^∗_G ω}ist die Menge aller in der Grammatik ableitbaren Wörter.

Linksableitung (⇒_L)

Es wird stets das linkeste Nichtterminal ersetzt.

Rechtsableitung (⇒_R)

Es wird stets das rechteste Nichtterminal ersetzt.

(12)

Beispiel

G= (T,N,P,Z) mit

T = {id,+,∗,(,)}

N = {Z,E,T,F}

P = {Z →E,E →T,T →F,F →id, E →E+T,T →T ∗F,F →(E)}

ist eine kontextfreie Grammatik.id steht für die Menge aller Bezeichner (engl. Identifier).

Linksableitungfür a+(b+c):

E ⇒ E+T ⇒T+T ⇒ F+T ⇒ a+T ⇒a+(E) ⇒ a+(E+T) ⇒ a+(T+T) ⇒ a+(F+T) ⇒a+(b+T) ⇒ a+(b+F) ⇒ a+(b+c)

Rechtsableitungfür a+(b+c):

E ⇒ E+T ⇒E+F ⇒ E+(E) ⇒ E+(E+T) ⇒ E+(E+F) ⇒ E+(E+c) ⇒ E+(T+c) ⇒E+(F+c) ⇒ E+(b+c) ⇒

T+(b+c) ⇒ F+(b+c) ⇒ a+(b+c)

(13)

Reduzierte Grammatiken

Ein NichtterminalAheißt erreichbar, wenn Z ⇒^∗µAχ µ, χ∈V^∗

Ein Grammatik heißtreduziert, wenn alle Nichtterminale erreichbar sind. Beispiel für nicht-reduziert:

Z →a A→a|

Entfernen aller unerreichbaren Nichtterminale einer GrammatikG ergibt reduzierte GrammatikG⁰. DaL(G) =L(G⁰) gehen wir im Folgenden davon aus, dassalle Grammatiken reduziertsind.

(14)

Schreibweise der Produktionen

in der Theorie:A→x|y|. . .,A∈N,x,y ∈V^∗ praktisch: Backus-Naur-Form (BNF)

Nichtterminale in spitzen Klammern,

Terminale als Symbole oder wie Nichtterminale ::= statt→

Rechnereingabe: Erweiterte Backus-Naur-Form (EBNF) wie BNF, aber Bezeichner oft ohne spitze Klammern

|(oder), .(Abschluß),()(Gruppierung), [] (optional),∗ (Wiederholung, auch 0-mal),+ (Wiederholung, mindestens einmal) als Beschreibungssymbole

Terminale durch Apostrophs o. ä. ausgezeichnet Ausdruck ::= Term (’+’ Term)∗.

Fortran-, Cobol-, Java-Beschreibung: Abarten von EBNF

(15)

Grammar Engineering (1/3)

Forderungen:

deterministische Grammatik: zu einer Eingabe existiert höchstens ein Syntaxbaum

Operatorprioritäten: Grammatik erzeugt Syntaxbaum gemäß Prioritäten

Gegenbeispiel:

E →E+E |E∗E |id|(E)

x*y+zhat 2 Syntaxbäume – sogar einen, der „Punkt vor Strich“

ignoriert.

E

E * E

E + E

x

y z

E

E + E

E * E

x y

z

(16)

Grammar Engineering (2/3)

Weiteres Gegenbeispiel: „Dangling Else“

S → ifE then S

| ifE then S elseS

if A then if B then C else D hat 2 verschiedene Syntaxbäume.

B C

A

if E then S

D

if E then S else S

S

B C D

A

if E then S else S

if E then S

S

(17)

Grammar Engineering (3/3)

if A then if B then C else D hat 2 verschiedene Syntaxbäume.

B C

A

if E then S

D

if E then S else S

S

B C D

A

if E then S else S

if E then S

S

In der Praxis gehört einelseaber immer zum letztenif.

Parsergeneratoren erkennen Mehrdeutigkeiten

aber in Grammatiken mit hunderten Produktionen sind Mehrdeutigkeiten schwer zu beheben

(18)

Faustregeln

ein Nichtterminal pro Prioritätsebene

nicht zweimal dasselbe Nichtterminal auf der rechten Seite Links- oder Rechtsassoziaitivität von Operatoren wird durch links- bzw. rechtsrekursive Regeln ausgedrückt

(19)

Beispielgrammatik

Ausdrücke:

(0)Z →E (1)E →T (2)T →F (3)F →id

(4)E →E+T (5)T →T ∗F (6)F →(E) EBNF:

(0) Z ::= E.

(1) E ::= T ( ’+’ T)∗.

(2) T ::= F ( ’∗’ F)∗.

(3) F ::= id | ’(’ E ’)’.

Ausdruck a+ (b+c) Konkreter Strukturbaum:

ida + ( idb + idc )

F F F

T

E T

T E

F

E T

E Z

(20)

Beseitigung von ε-Produktionen

Satz:

Für jede kfGG mit ε-Produktionen gibt es eine kfGG⁰ ohne ε- Produktionen mitL(G)\ {ε}=L(G⁰) und umgekehrt.

Technik dazu:ε-Abschluß

Einsetzen von Ableitungen der FormA→ε in alle rechten Seiten der FormX →αAβ, mitα, β ∈(T ∪N)^∗

(21)

Beispiel zur Beseitigung von ε-Produktionen

(1)Z → aS (2)S → aS |ε

Einsetzen vonS → εauf den rechten Seiten führt zu (1)Z → aS |a

(2)S → aS |a ohneε-Produktionen.

(22)

Linksfaktorisierung

ProduktionenX →Yb |Yc mit gleicher LS und gemeinsamem Anfang Y kann man nicht mit rekursivem Abstieg verarbeiten, wenn Länge|y|,Y ⇒^∗ y, unbeschränkt, |y| ≥0.

Lösung:den gemeinsamen Anfang ausklammern ErsetzeX →Yb |Yc durch X →YX⁰,X⁰→b |c

Analog kann man bei LR-Analyse rechtsfaktorisieren (seltener benötigt).

(23)

Beispiel zur Linksfaktorisierung

Die Produktionen S → ifE then S endif S → ifE then S elseS endif

haben gemeinsamen Anfang ifE then S.

Linksfaktorisierung ergibt:

S → ifE then S X X → endif | else S endif

(24)

Konkrete und abstrakte Syntax

Prinzip der abstrakten Syntax: nur die für die Semantik wichtige Struktur behalten:E →E +E|E∗E|id

ida + ( idb + idc )

F F F

T

E T

T E

F

E T

E Z

ida + idb + idc

E E

E

(25)

Konkrete und abstrakte Syntax

Prinzip der abstrakten Syntax: nur die für die Semantik wichtige Struktur behalten:E →E +E|E∗E|id

ida + ( idb + idc )

F F F

T

E T

T E

F

E T

E Z

Ida Idb Idc

Kantorowitsch- Baum

E E

+ E

+

(26)

Übergang: Konkrete und abstrakte Syntax (1/2)

Konkrete SyntaxG_k der zu übersetzenden Sprache (Datenstruktur:

Tokenstrom)

1 explizite Strukturinformation( ),begin end, etc.

2 Ketten- und Verteilerproduktionen A→B bzw.

A→B|C |...

3 Schlüsselwörter

Abstrakte SyntaxGa des Strukturbaums (Datenstruktur: Baum, AST)

1 Klammerung durch AST bereits eindeutig

2 Kettenproduktionen überflüssig, wenn keine semantische Bedeutung

3 Schlüsselwörter dienten dem eindeutigen Parsen, jetzt immer überflüssig, werden weggelassen.

(27)

Übergang: Konkrete und abstrakte Syntax (2/2)

Abbildung konkrete auf abstrakte Syntax durch Parser (Verarbeitung von semantischen Aktionen), ggf. weitere Transformation während semantischer Analyse

Produktionsnummer wird Knotentyp

Operatoren als Attribute des Knotens für den Ausdruck

(28)

Abstrakte Syntax als abstrakte Algebra

Heute fasst man eine abstrakte Syntax als Signatur einer ordnungssortierten Termalgebra auf, und einen AST als Term gemäß dieser Signatur.

Klassen der abstrakten Syntax entsprechen Sorten der Algebra innere Baumknoten entsprechen Operatoren

(Funktionssymbolen) der Algebra inkl. Signatur.

Beispiel: abstrakte Syntax für Expressions und Statements

IfElseStmt :: Expr Stmt Stmt WhileStmt :: Expr Stmt

Block :: Decls StmtList StmtList :: Stmt + Assignment :: Var Expr

Var = Id|. . .

Expr = Addop |MultOp|Var |. . . Addop :: Expr Expr

Multop :: Expr Expr

(29)

Abstrakte Syntax als abstrakte Algebra

Entsprechende Bäume können auch als Terme dargestellt werden.

Schreibweise zur Konstruktion von Termen z.B.

Beispiele

Addop(Id(hinz),Id(kunz))

IfStmt(Id(test),Assignment(Id(x),Addop(Id(x),Id(y)))) Block(Decls(. . .),StmtList(s1,s2, . . . ,s42))

Assoziativitäten/Präzedenzen werden durch Termstruktur dargestellt

Achtung: Die abstrakte Syntax enthält keine semantischen Bedingungen z.B. „Typ einerIf-Expression muss boolesch sein“

(30)

Implementierung abstrakte Syntax

Objektorientiert:

je 1 Klasse pro syntaktische Kategorie Alternativregeln

X =X1 |X2 |. . . werden zu Unterklassen:

classX {/∗ ...∗/ }

classX1 extendsX {/∗ ...∗/ } classX2 extendsX {/∗ ...∗/ } Baumaufbauregeln

X ::Y1 Y2 werden zu Konstruktorfunktionen:

classX {

public X(Y1 y1, Y2 y2) {/∗ ...∗/ } }

(31)

Sonderfälle in abstrakter Syntax

Bezeichner:

E →idist Kettenproduktion, soll aber wegen semantischer Analyse erhalten bleiben

Klammern in Fortran:

Information eigentlich bereits in der Baumstruktur aberKlammern sind bindend (kein Umordnen erlaubt)

sonst gilt eventuell Assoziativgesetz (Umordnen möglicherweise erlaubt)

müssen als Operator gespeichert werden Anweisungslisten in C:

sind Verteilersymbole

aberStrichpunkt-Operator legt Auswertungsfolge fest (auch ohne Datenabhängigkeiten), Code-Verschiebung verboten?

(32)

Abstrakte Syntax II

abstrakte Syntax quellsprachenunabhängig?

Programmstruktur in semantischer Analyse aufgearbeitet, danach nur noch Prozeduren interessant

Prozeduraufrufe nur bezüglich Parameterübergabe unterschiedlich

Ablaufsteuerung identisch, eventuelle Ausnahme: Zählschleifen Ausnahmebehandlung in allen modernen Sprachen identisch Zuweisung, Ausdrucksoperatoren, usw.: identisch, manchmal vielleicht Ergänzungen erforderlich

Konsequenz: weitere Verarbeitung (Transformation,

Optimierung, Codegenerierung) weitgehend unabhängig von der Quellsprache

Systeme: UNCOL, ANDF, Dotnet

Dotnet kann als Postfixcodierung von UNCOL angesehen werden

(33)

Typunabhängiges Parsen

Parsen ohne Kenntnis über Typen von Symbolen ist üblich, aber nicht immer ausreichend

Typabhängiges Parsen Bsp: ADA a.first(2)

.

a [ ]

first 2

.

[ ]

a 2

first

(34)

Typabhängiges Parsen

Beispiel: Formate in FORTRAN print(r 20, real_const)

r 20 ist Format und muss anders behandelt werden, sonst r Bezeichner und 20 ganze Zahl

Parser umschaltbar, um Formate zu bearbeiten D.h., es gibt zwei verschiedene Parser

Erst semantische Analyse erkennt Bezeichner print Umschaltung also semantik- (oder typ-) gesteuert Ähnliche Probleme in ABAP/4

(35)

Semantische Aktionen

%Ausgabe

Nach Erkennen des vorgehenden (Nicht-)Terminals ausgeführt Für AST: Konstruktor des entsprechenden Knotens im

Ableitungsbaum für Ga aufrufen

&Ausgabe

Wird ausgeführt, wenn Symbol erkannt aber noch nicht fortgeschaltet wurde

Für AST: Konstruktoren werden gegebenenfalls Merkmale von Symbolen übergeben

Beachte:

Semantische Aktionen basieren auf Seiteneffekt beim Parsen Symbole werden in der Reihenfolge abgenommen, in der sie in der Symbolfolge erscheinen

(36)

Ausgabe von Postfixform

Ausgaberoutinen:

addop mulop bezeichner merke bez_aus

gib ’+’ aus gib ’*’ aus gibidaus merkeid

gib gemerkte idaus, falls vorhanden Postfixform, d.h. abstrakter Syntaxbaum als Rechtsableitung:

1 E ::=T ( ⁰+⁰ T %addop)^∗

2 T ::=F ( ⁰∗⁰ F %mulop )^∗

3 F ::=id&bezeichner|⁰(⁰ E ⁰)⁰

(37)

Beispiel Postfixform

1 E ::=T ( ⁰+⁰ T %addop)^∗

2 T ::=F ( ⁰∗⁰ F %mulop )^∗

3 F ::=id&bezeichner|⁰(⁰ E ⁰)⁰

Ableitung für x∗y+z E

⇒ T + T

⇒ F∗ F + T

⇒ x∗F + T

⇒ x∗y + T

⇒ x∗y + F

⇒ x∗y + z

Ausgabe

x xy∗

xy∗

xy∗z+

(38)

Kellerautomaten

KellerautomatA= (T,Q,R,q₀,F,S,s₀) T Eingabealphabet (Tokens)

Q Zustandsmenge

R Menge von Regelnsqx →s⁰q⁰x⁰,s,s⁰∈S^∗,q,q⁰ ∈Q, x,x⁰,x⁰⁰∈T^∗,x =x⁰⁰x⁰

q₀Anfangszustand

F ⊆Q Menge von Endzuständen S Kelleralphabet

s0∈S Anfangszeichen im Keller

Konfiguration: sqx,s vollständiger Kellerinhalt, x restliche Eingabe

Anfangskonfiguration: s0q0y,y vollständige Eingabe Regel sqx →s⁰q⁰x⁰ anwendbar, wenns =s⁰s,x =x x⁰ Folgekonfiguration: s⁰s⁰q⁰x⁰x⁰

Halt bei Konfiguration sq, q∈F, Eingabe vollständig gelesen praktisch Endezeichen # erforderlich, Halt beisq#

(39)

Beispiel: Kellerautomat für Palindrome

KellerautomatA= (T,Q,R,q₀,F,S,s₀) mit Q ={q₀,q1,q2}

R ={q₀t→tq0|t ∈T} ∪ {q₀t →q1 |t ∈

T ∪ {ε}} ∪ {tq₁t →q₁ |t∈T} ∪ {s₀q₁#→q₂#}

F ={q₂} S =T ∪ {s₀}

Abarbeitung vonotto:

Keller s₀ s0o s₀ot s₀ot s0o s₀

Zustand q0

q₀ q₀ q1

q₁ q₁ q2

Eingabe otto#

tto#

to#

o#

#

(40)

Kontextfreie Grammatik und Kellerautomaten

Satz:

Für jede kontextfreie GrammatikG gibt es einen

(nichtdeterministischen) KellerautomatenAmit L(A) =L(G).

⇒das Akzeptionsproblem für kontextfreie Sprachen ist entscheidbar

Aber:Aufwand i.a.O(n³)

⇒praktisch nur Teilklassen mit linearem Aufwand brauchbar, dazu Grammatik-Umformungen erforderlich

Aber:Sprachinklusion und Gleichheit nicht entscheidbar

⇒keine eindeutige Normalform

(41)

Kapitel 3: Syntaktische Analyse

1 Einbettung

Bison

6 Earley Parser

(42)

Systematische Parserkonstruktion

Es gibt weit mehr als 25 verschiedene Techniken zur

Parserkonstruktion, vgl. Aho&Ullman, The Theory of Parsing and Compiling, 2 Bde, 1972

Nur zwei Techniken , LL undLR, haben die Eigenschaften:

Der Parser liest die Quelleeinmalvonlinks nach rechts und baut dabei dieLinks- bzw.Rechtsableitung auf (daher die 2 Buchstaben).

Der Parser erkennt einen Fehler beim ersten Token t, das nicht zu einem Satz der Sprache gehören kann. t heißt

parserdefinierte Fehlerstelle(parser defined error): Wenn x 6∈L(G)und der Parser erkennt den Fehler beim Tokent, x =x⁰tx⁰⁰, so gibt es einen Satz y ∈L(G)mity =x⁰y⁰. Alternative: Erkennen des Fehlers einige Token später, keine syntaktische Fehlerlokalisierung möglich.

(43)

Herleitung der LL- und LR-Parser

gegeben Grammatik G = (T,N,P,Z),V =T ∪N, konstruiere indeterministischen Kellerautomat mit genau einem Zustandq, angesetzt auf Eingabex

Für LL: (prädiktiv) tqt →q,t ∈T Xq →xn. . .x1q, X →x₁. . .x_n∈P

Für LR: (reduzierend) qt →tq,t ∈T x1. . .xnq →Xq, X →x₁. . .x_n∈P mache Kellerautomat deterministisch durch Hinzunahme Rechtskontext, also Vorhersage Xqx⁰ →x_n. . .x₁qx⁰ bzw.

Reduktion x1. . .xnqx⁰ →Xqx⁰

x⁰ Anfang des unverarbeiteten Eingaberests

deterministisch machen geht nur für eingeschränkte Grammatikklassen

(44)

Nichtdeterministische LL- und LR-Parser

Für LL: (prädiktiv) Vergleich (compare):

tqt →q,t ∈T Vorhersage (produce):

Xq →x_n. . .x₁q, X →x₁. . .x_n∈P

Für LR: (reduzierend) Shift:

qt →tq,t ∈T Reduktion (reduce):

x₁. . .x_nq →Xq, X →x₁. . .x_n∈P

top-down Parser

vom Startsymbol zum Wort

bottom-up Parser

vom Wort zum Startsymbol Anmerkung: Der Zustandq ist noch bedeutungslos, er wird später beim deterministisch Machen benötigt.

(45)

Textmengen

k:x

k:x=x# fallsx =x₁. . .x_m∧m<k k:x=x₁. . .x_k fallsx =x₁. . .x_m∧m≥k

Anf_k(x)={u | ∃y ∈T^∗:x ⇒^∗ y∧u=k:y} in der Literatur auchFirst_k(x) genannt

A⇒_R⁰α gdw. A⇒_R α∧@B∈N :A⇒_R Bα⇒α Anf⁰_k(x)={u ∈Anf_k(x)| ∃y ∈T^∗ :x ⇒_R⁰ uy}

in der Literatur auchEFF_k(x) genannt (ε-freeFirst) Folge_k(x)={u | ∃m,y ∈V^∗ :Z ⇒^∗mxy ∧u ∈Anf_k(y)}

in der Literatur auchFollow_k(x) genannt

(46)

Berechnung von Anf

1

und Folge

₁

Anf₁

1 Wenn γ ∈T^∗, so 1:γ ∈Anf₁(γ)

2 Wenn X →α∈P, so Anf₁(α)⊆Anf₁(X)

3 Anf₁(α)\ {#} ⊆Anf₁(αβ)

4 Wenn α⇒^∗ ε, so Anf₁(β)⊆Anf₁(αβ) Folge₁

1 Wenn X →αYβ ∈P, so Anf₁(β)⊆Folge₁(Y)

2 Wenn X →α∈P, so Folge₁(X)⊆Folge₁(α)

3 Folge₁(αβ)⊆Folge₁(β)

4 Wenn β ⇒^∗ ε, so Folge₁(αβ)⊆Folge₁(α)

Diese Regeln werden wiederholt angewendet, bisAnf₁ bzw.Folge₁ stabil sind (Fixpunktiteration).

Übung:Geben Sie die allgemeinen Formeln für Anf_k und Folge_k an. Verwenden Sie dazuAnf_k−1 bzw.Folge_k−1.

(47)

LL(k )-Grammatiken

Fürk ≥1 heißt eine kfG G = (T,N,P,Z) eineLL(k)-Grammatik, wenn für alle Paare von Ableitungen

Z ⇒^∗_LµAχ⇒µνχ⇒^∗µγ µ, γ ∈T^∗;ν, χ∈V^∗,A∈N Z ⇒^∗_LµAχ⁰ ⇒µωχ⁰⇒^∗µγ⁰ γ⁰ ∈T^∗;ω, χ⁰ ∈V^∗

gilt:

(k :γ =k :γ⁰)⇒ν=ω

Also: Aus den nächstenk Token kann unter Berücksichtigung des Kellerinhalts die nächste anzuwendende Produktion eindeutig vorhergesagt werden.

Diek Token können aus der Produktion resultieren oder ganz oder teilweise dem Folgetext angehören, z.B. beiε-Produktionen.

(48)

Beispiele von LL-Grammatiken, Anf - und Folge-Mengen

Grammatik:

E → TE’

E’ → ε| +TE’

T →FT’

T’ → ε|∗FT’

F → id | (E)

Anf₁(E) =Anf₁(T) =Anf₁(F) ={id,(}

Anf₁(E⁰) ={ε,+} Anf₁(T⁰) ={ε,*}

Folge₁(E) =Folge₁(E⁰) ={ε,)}

Folge₁(T) =Folge₁(T⁰) ={ε,),+}

Folge₁(F) ={ε,),+,*}

(49)

Beispiele von LL-Grammatiken, LL-Definition

Grammatik:

E → TE’

E’ → ε| +TE’

T →FT’

T’ → ε|∗FT’

F → id | (E)

Grammatik istLL(1)nach Definition. Betrachte etwa E ⇒T E⁰ ⇒^∗_Lµ+T E⁰χ⇒^∗ µγ (hier istν =+T E⁰) E ⇒T E⁰ ⇒^∗_Lµεχ⁰ ⇒^∗ µγ⁰ (hier ist ω=ε)

k:γ =k :γ⁰ bedeutet: beide fangen mit+ an. Dann kommt die 2. Möglichkeit nicht in Frage, da+∈/ Folge₁(E). Deshalb ist ν=ω. Für die anderen Produktionen wird analog argumentiert.

Bemerkung:

In der Praxis verwendet man stets dasSLL-Kriterium (s.u.)

(50)

Beispiele von LL-Grammatiken, LL(2)

Grammatik

Z → aAab | bAbb A → ε| a

Anf₁(A) ={a},Folge₁(A) ={a,b}, also nichtLL(1) da A⇒^∗ε.

ProbiereLL(2):

Anf₂(εFolge₂(A)) ={ab,bb}

Anf₂(aFolge₂(A)) ={aa,ab}

also nichtSLL(2) (s.u.) aberLL(2):

Z ⇒aAab⇒aab,Z ⇒aAab⇒aaab

2:ab6=2:aab, deshalbLL(2) Kriterium nicht verletzt; analog Z ⇒bAbb⇒bbb,Z ⇒bAbb⇒babb

Man beachte, dass die „Vergangenheit“ (gewählte Z-Produktion) bekannt sein muss. Falls diese nicht bekannt ist, kann trotz 2 Token Vorausschau nicht entschieden werden, welche

A-Produktion verwendet werden muss!

(51)

Beispiele von LL-Grammatiken, weitere Beispiele

Z → X, X → Y | bYa, Y →c | ca ist LL(3).

Z → X, X → Yc | Yd, Y →a | bY ist für kein k LL(k);

aber Linksfaktorisieren macht daraus LL(1).

Anweisungen, die mit Schlüsselwort while, if, case, usw.

beginnen, sind mit LL(1)-Technik vorhersagbar. Bei Beginn mit Bezeichner sind Linksfaktorisierungen nötig.

(52)

Satz über Linksrekursion

Satz:

Eine linksrekursive kfG ist für keink LL(k).

Beweisidee:

Seien A → Ax und A → y linksrekursive bzw. terminierende Regeln. Jeder k-Anfang der terminierenden Regel ist auch k-Anfang der linksrekursiven Regel.

(53)

Elimination von Linksrekursion (1/2)

Satz:

Für jede kfGG mit linksrekursiven Produktionen gibt es eine kfG G⁰ ohne Linksrekursion mitL(G) =L(G⁰).

(54)

Elimination von Linksrekursion (2/2)

Konstruktion:

Nummeriere Nichtterminale beliebig X1, . . . ,Xn

Für i =1, . . . ,n

Fürj =1, . . . ,i−1 ersetzeXi →Xjx durch

{Xi →yjx |Xj →yj ∈P}(danachi≤j, wennXi →Xjx ∈P) Ersetze die Produktionenmengen

{Xi →Xix} ∪ {Xi →z |z 6=Xiz⁰} durch{Yi→xYi |Xi → Xix ∈P} ∪ {Yi →ε} ∪ {Xi →zYi |Xi →z ∈P∧z 6=Xiz⁰} mit einem neuen NichtterminalYi. (Nummerierung derYi mit n+1,n+2, . . .)

Ergebnis: i <j, wennX_i →X_jx ∈P

Beachte: in Schritt 2 Ersetzung durch{Y_i →x,Yi →xYi |Xi → X_ix ∈P} ∪ {X_i →z,X_i →zY_i |X_i →z ∈P ∧z 6=X_iz⁰} ohne ε-Produktionen möglich, wenn x nicht mit X_j,j ≤i, beginnt.

(55)

Beispiel

E → T | E + T , T → F | T ∗F, F → id | ( E ) ist linksrekursiv

Ersetzung: Schritt 1 leer, Schritt 2: E → T | E + T durch E → T E’, E’ → ε| + T E’ ersetzen; T → F | T∗ F analog. Dies entspricht der EBNF E ::= T (’+’ T)^∗, T ::= F (’∗’ F)^∗, F ::= id | ’(’ E ’)’.

Andere mögliche Ersetzung: E → T | T E’, E’ → + T | + T E’

Vorsicht: Die Ersetzung durch E → T | T + E ist semantisch unzulässig! Sie transformiert Links- in Rechtsassoziativität, verändert also die semantisch bedeutungsvolle Struktur.

Beseitigung von Linksrekursion beiLL(k)-Analyse nötig für alle Anweisungen, die mit <Bezeichner> <Operator>

anfangen können (Zuweisungen, Ausdrücke)

(56)

SLL(k )-Grammatiken

Fürk≥1 heißt eine kfGG = (T,N,P,Z)eineSLL(k)-Grammatik (starkeLL-Grammatik), wenn für alle Paare von Ableitungen

Z ⇒_LµAχ⇒µνχ⇒^∗µγ µ, γ∈T^∗;ν, χ∈V^∗,A∈N Z ⇒_Lµ⁰Aχ⁰ ⇒µ⁰ωχ⁰ ⇒^∗ µ⁰γ⁰ µ⁰, γ⁰∈T^∗;ω, χ⁰ ∈V^∗

gilt:

(k :γ =k :γ⁰)⇒ν=ω

Also: Aus den nächstenk Token kann ohne Berücksichtigung des Kellerinhalts die nächste anzuwendende Produktion eindeutig vorhergesagt werden.

(57)

SLL-Bedingung

Satz:

Eine Grammatik ist genau dann eineSLL(k)-Grammatik, wenn für alle Paare von Produktionen A → x | x’,x 6=x⁰, die

SLL(k)-Bedingunggilt:

Anf_k(xFolge_k(A))∩Anf_k(x⁰Folge_k(A)) =∅ Beweis: trivial

Also: SLL(k)-Eigenschaft durch Berechnung vonAnf_k- und Folge_k- Mengen einfach nachzuprüfen.

Wenn aus x,x⁰ nur terminale Tokenreihen mit mindestens k Token ableitbar sind, trägt Folge_k(A) nichts zum Ergebnis bei und kann entfallen.

wichtiger Spezialfall: k =1,x 6⇒^∗ε,x⁰ 6⇒^∗ε. Dann muss Anf_k(x)∩Anf_k(x⁰) =∅

gelten. Falls x⇒^∗ε, so muss außerdem gelten:

Folge_k(A)∩Anf_k(x⁰) =∅

(58)

LL(1) und SLL(1)

Satz:Jede SLL(k)-Grammatik ist auch eine LL(k)-Grammatik.

Satz:Jede LL(1)-Grammatik ist eine SLL(1)-Grammatik.

Beweis (indirekt):

Angenommen,G istLL(1), aber die SLL(1)-Bedingung ist nicht erfüllt. Dann gibt es ProduktionenA →x |x⁰,x6=x⁰, und ein Token

t ∈Anf₁(xFolge₁(A))∩Anf₁(x⁰Folge₁(A)).

Fallt ∈Anf₁(x),t ∈Anf₁(x⁰)verstößt gegen die LL(1)-Definition, da wegenx=ν,t ∈Anf₁(νχ) und x⁰ =ω,t ∈Anf₁(ωχ⁰) gilt:

1:γ =1:γ⁰, jedoch ν 6=ω. Widerspruch.

Andere Fälle analog.

Satz nicht auf k > 1 verallgemeinerbar:

Z → aAab | bAbb, A → ε| a ist LL(2), aber nicht SLL(2).

(59)

Konstruktion der LL(1)-Tabelle

LL[X,a] = {X →X₁. . .X_n∈P |

a∈Anf₁(X1. . .XnFolge₁(X))}

Es muss gelten|LL[X,a]|=1 für alleX,a, sonst ist die Grammatik nichtLL(1).

(60)

Parsertabelle

Grammatik:

E → T E⁰ E⁰ → + T E⁰ |ε

T → F T⁰ T⁰ → * F T⁰ |ε

F → ( E )|id

Nichtterminal Anf1 Folge₁ Eingabesymbol

id + * ( ) #

E (,id ), ε E→TE⁰ E→TE⁰

E⁰ +, ε ), ε E⁰→+TE⁰ E⁰→ε E⁰→ε

T (,id +, ε T→FT⁰ T→FT⁰

T⁰ *, ε +, ε T⁰→ε T⁰→*FT⁰ T⁰→ε T⁰→ε

F (,id +,*, ε F→id F→(E)

Abbildung:Parsertabelle

(61)

Parsertabelle

Grammatik:

S → iE tS Z |a Z → e S |ε E → b

Parsertabelle:

Nichtterminal Anf₁ Folge₁ Eingabesymbol

a b e i t #

S i,a e, ε S→a S→iEtSS⁰

Z e, ε e, ε Z→eS Z→ε

E b t E⁰→b

Nach Definition istLL[S⁰,e] ={S⁰→eS,S⁰→ε} und somit die Grammatik nichtLL(1). Zur Auflösung des Konfliktes wird die zweite Produktion manuell aus dem Tabelleneintrag entfernt.

Dadurch gehört eineimmer zum letzten i.

(62)

Modell eines tabellengesteuerten LL-Parsers

a + b #

Eingabe

LL-Parser- programm X

Y Z

# Stack

Parsertabelle M

Ausgabe

(63)

Verhalten eines LL-Parsers

Übereinstimmung Stack Eingabe Aktion E# id+id*id#

TE⁰# id+id*id# Ausgabe von E→TE⁰ FT⁰E⁰# id+id*id# Ausgabe von T →FT⁰ idT⁰E⁰# id+id*id# Ausgabe von F→id id T⁰E⁰# +id*id# Übereinstimmung mitid

id E⁰# +id*id# Ausgabe von T⁰→ε

id +TE⁰# +id*id# Ausgabe von E⁰ →+TE⁰

id+ TE⁰# id*id# Übereinstimmung mit+

id+ FT⁰E⁰# id*id# Ausgabe von T →FT⁰ id+ idT⁰E⁰# id*id# Ausgabe von F→id id+id T⁰E⁰# *id# Übereinstimmung mitid id+id *FT⁰E⁰# *id# Ausgabe von T⁰→*FT⁰ id+id* FT⁰E⁰# id# Übereinstimmung mit* id+id* idT⁰E⁰# id# Ausgabe von F→id id+id*id T⁰E⁰# # Übereinstimmung mitid

id+id*id E⁰# # Ausgabe von T⁰→ε

id+id*id # # Ausgabe von E⁰ →ε

(64)

LL(1)-Parseralgorithmus

push(’#’); push(Z); t = next_token();

while(t != ’#’) {

if(stackEmpty()) { error("superfluous tokens found"); } else if (top()∈T) {

if(top() == t) {

pop(); t = next_token();

} else{ error(top() + " expected"); pop(); } } else if(LL[top(), t]== ⊥) {

error("illegal Symbol " + t); t = next_token();

} else{

(X →X1. . .Xn)=LL[top(), t];

pop();

for(i = n; i >= 1;−−i) push(Xi);

} }

if(top() != ’#’)

error("unexpected end of input");

(65)

LL(1)-Parser mit rekursivem Abstieg

1 Definiere Prozedur X für alle Nichtterminale X

2 Für alternative Produktionen X → X₁ |. . . |X_n sei Rumpf von X

switcht {

caseAnf₁(X₁Folge₁(X)): Code fürX₁; . . .

caseAnf₁(X_nFolge₁(X)): Code für X_n; default: add_error(. . .);

}

3 Für rechte Seite X_i = Y₁ . . . Y_m erzeuge:

C₁;. . .;C_m;return;

Es gilt C_i =

1 if(t ==Yi) t = next_token()elseadd_error(. . .);

wennYi∈T

2 Yi();

wennYi∈N

(66)

Parser aus Grammatik in EBNF

Nichtterminal Terminal

X t

X();

if (token == t)

token = next_token();

else add_error(. . .);

Option Iteration

[X] X⁺

if (token∈Anf₁(X))X();

do X();

while (token∈Anf₁(X));

X^∗ while (token∈Anf₁(X)) X();

Liste X||d

X();

while (token∈Anf₁(d)) { d(); X(); } semantische

Aktion

t&Y

if (token == t)

{ Y(); token = next_token(); } else add_error(. . .);

%Z Z();

(67)

Beispielgrammatik

Beispielgrammatik in EBNF-Notation zum Parser auf der nächsten Folie:

1 Z ::=E

2 E ::= T (’+’T)^∗

3 T ::=F (’∗’F)^∗

4 F ::=id | ’(’E’)’

(68)

Parser für Beispielgrammatik (1/2)

AST parse() { t = next_token();returnZ(); } AST Z() {returnE(); }

AST E() {

AST res = T();// merke 1. Operand while (t == ’+’) {

t = next_token();

AST res1 = new AST(plus);

res1.left = res;

res1.right = T();

res = res1;

}

returnres;

}

T()// analog E

Hinweis:Additionen/Multiplikationen werden im AST linksassoziativ interpretiert.

(69)

Parser für Beispielgrammatik (2/2)

AST F() {

AST res = null;

if(t == id) {

res = new AST(t); t=next_token();

}

else if(t == ’(’) {

t = next_token(); res = E();

if (t == ’)’)

t = next_token();

else

add_error(missing_closing_parenthesis, t.pos);

} else

add_error(invalid_token, t.pos);

returnres;

}

(70)

Praxis des rekursiven Abstiegs

Einfügung von semantischen Aktionen:

Semantische Aktion formal wie Produktion A → ε behandeln, statt der Prozedur für ein Nichtterminal Adie Ausgabeprozedur aufrufen.

Rekursiver Abstieg baut Linksableitung auf.

Vorteil: beim Aufbau bereits erste Berechnungen von semantischen Attributen möglich(s. Kapitel “Semantische Analyse“).

Problem: Durch die Handprogrammierung können leicht während der Wartung syntaktische Eigenschaften

eingeschleust werden, die die Systematik der Syntax und die Unabhängigkeit Syntax-Semantik zerstören. Negativbeispiel:

ABAP 4

Rekursiver Abstieg kann auchtabellengesteuertimplementiert werden! Parser wird Interpretierer der Tabelle.

Vorteile: Vermeidung von Prozeduraufrufen, einfachere Fehlerbehandlung. Nachteil: nicht von Hand programmierbar.

(71)

Situationen (Items)

Ziel: bei Prüfung der Anwendbarkeit von Regeln sqx → s’q’x’

Z

Kellerinhalt und Zustand sq miteinemZustandssymbol codieren (Prüfung mehrerer Einträge im Keller vermeiden)

Lösungsidee:

bei LL und LR ists rechte bzw. linke Seite einer Produktion X → x₁. . .x_n

Übergänge tqt → q (beiLL) bzw.qt → tq (bei LR) sind nur zulässig, wenn in der Produktion ein Terminalzeichen t ansteht,x₁. . .x_n=x⁰tx⁰⁰⁰, wobei x⁰⁰:=tx⁰⁰⁰

also: ersetze sqx durch Situation[X → x⁰ ·x⁰⁰;x], die durch den Punkt anzeigt, wie weit die Produktion abgearbeitet ist.

Situationen [X → ·x⁰⁰;x] oder [X → x⁰ ·;x] sind erlaubt und notwendig.

Verwende Situationen als Zustände und als Kellersymbole.

Situationen heißen englisch items.

(72)

Formale Konstruktion LL(k )-Automat

Z

1 InitialQ ={q₀}und R =∅, mitq₀= [Z → ·S;#].

Anfangszustand und erster Kellerzustand q0. Hinweis:Folge_k(Z) ={#}.

2 Sei q = [X →µ·ν; Ω]∈Q und noch nicht betrachtet.

3 Wenn ν =εsetzeR :=R∪ {qε→ε}

Auskellern q⁰q →q⁰ mit beliebigemq⁰.

4 Wenn ν =tγ mitt ∈T und γ ∈V^∗, setze q⁰ = [X →γt·γ; Ω]. SetzeQ :=Q∪ {q⁰} und R :=R∪ {qt →q⁰}.

5 Wenn ν =Bγ mitB∈N und γ ∈V^∗, setze q⁰ = [X →γB·γ; Ω]und

H ={[B→ ·β_i;Anf_k(γΩ)]|B→βi ∈P}.

Hinweis: 1≤i ≤m, wenn es m Produktionen mit linker Seite B gibt. SetzeQ :=Q∪ {q⁰} ∪H und

R :=R∪ {qτ_i →q⁰hiτi |hi ∈H, τi ∈Anf_k(βiγΩ)}.

6 Wenn alleq ∈Q betrachtet wurden, stop. Sonst, gehe zu 2.