Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Martin Schneider, 25.05.2000 Folien von Prof. H.-P. Gumm Martin Schneider, 25.05.2000 Folien von Prof. H.-P. Gumm Parsen.

Ähnliche Präsentationen


Präsentation zum Thema: "Martin Schneider, 25.05.2000 Folien von Prof. H.-P. Gumm Martin Schneider, 25.05.2000 Folien von Prof. H.-P. Gumm Parsen."—  Präsentation transkript:

1 Martin Schneider, Folien von Prof. H.-P. Gumm Martin Schneider, Folien von Prof. H.-P. Gumm Parsen

2 Der zweistufige Aufbau von Sprachen Richtige Sprachen ( Deutsch, Englisch, Prolog, Pascal,... ) lassen sich in zwei Stufen beschreiben : Aus einem Zeichenalphabet (etwa = {a, b,...,z, A,B,...,Z} wird der lexikalische Anteil der Sprache aufgebaut, die Menge aller Wörter der Sprache. Dies ist eine Teilmenge von *, also eine Sprache. 1. Stufe Worte, die eine gleichartige Rolle spielen, wie etwa Bezeichner oder Integerzahlen werden zu Klassen zusammengefaßt. Jede solche Klasse wird durch einen Stellvertreter (token) repräsentiert. PASCAL-token sind z.B. : Identifier, IntegerConstant, RealConstant, BoolConstant,... IF, THEN, :=,...

3 Der zweistufige Aufbau von Sprachen Aus einem Alphabet der Token (etwa = {id, intConst, addop, assign, IF, THEN, VAR, INTEGER,...} wird der syntaktische Anteil der Sprache aufgebaut, die Menge aller möglichen Sätze der Sprache. Dies ist eine Teilmenge von *, also eine Sprache über. 2. Stufe Letztere Sprache ist i.A. nicht mehr regulär, man benutzt zu ihrer Beschreibung entweder kontextfreie Grammatiken, BNF (Backus-Naur-Form) oder Syntaxdiagramme. Beispiel in Pascal : VarDecl ::= VAR id (, id)* colon Type Type ::= INTEGER, BOOLEAN, RECORD Fields END Fields ::=...

4 Sprachen und Grammatiken Eine Grammatik ist ein mathematisches Hilfsmittel, um Sprachen zu beschreiben. Eine Grammatik ist eine Menge von Regeln mit deren Hilfe Worte (Sätze) der Sprache konstruiert werden können. Mit Hilfe der Grammatik kann man Sätze einer Sprache erzeugen. Die zu der Grammatik G gehörende Sprache, L(G), besteht aus allen Sätzen die man mit der Grammatik erzeugen kann. Erzeugen Ist ein Satz gegeben, so möchte man evtl. feststellen, ob dieser Satz zu der Sprache L(G) gehört oder nicht. Diese Aufgabe nennt man Parsen. Dabei wird auch die Struktur des Satzes erkannt. Parsen

5 Syntax - Semantik Eine Grammatik beschreibt die Struktur ( Syntax ) von Sätzen, nicht aber deren Bedeutung (Semantik). Obwohl die Bedeutung eines Satzes auch von seiner Struktur abhängt, kann man leicht syntaktisch richtige Sätze bilden, die bedeutungslos sind. gestohlen der hat Gans Fuchs die. Syntaktisch falscher Satz der Gans hat die Fuchs gestohlen. Syntaktisch richtiger, semantisch falscher Satz der Fuchs hat die Gans gestohlen. Syntaktisch und semantisch richtiger Satz

6 Syntax - Semantik in PASCAL Test Program. i for 1 do n ; to n+1 := n Syntaktisch falsches Programm Program Test ; Var i : Real; Begin For i := 1 To n Do i := n+1 End. Syntaktisch richtiges, semantisch falsches Programm Syntaktisch und semantisch richtiges Programm Program Test ; Var i,n : Integer; Begin For i := 1 To n Do n := i+1 End.

7 Parsen Parsen ist der Prozeß, ein gegebenes Wort w L(G) in seine grammatikalischen Bestandteile zu zerlegen und einen Herleitungsbaum zu finden. if x < 0 then y := y+1 else Inc(z) if then x 0<:= + y y 1else ( )Inc z if Bexpr then Expr RelOp Expr id num Stmt else Stmt id := Expr id + num id ( ) Expr id x0 < y y 1 Inc z Stmt Beispiel:

8 Bottom Up Parsing Beim Parsen wird der zu analysierende Satz von links nach rechts gelesen und gleichzeitig analysiert. Dabei wird der Syntaxbaum von den Blättern zur Wurzel (bottom-up) aufgebaut. if then else Inc ( z ) x>0 Bexpr y+1y:= Expr Stmt Expr id Expr num id num Lesepointer

9 Top Down Parsing Beim top down parsing beginnt man an der Wurzel des Baumes und baut ihn von oben nach unten auf. Dabei gibt das jeweils am weitesten rechts stehende Blatt an, was man im Input zu sehen wünscht. if then y := y + 1 else Inc ( z ) Stmt Bexpr Expr x>0 num Expr id Stmt

10 Shift-Reduce Parser Shift-Reduce Parser sind "bottom-up parser", d.h. sie bauen den Syntaxbaum von den Blättern her auf. Die Aktionen sind : Lese ein weiteres Zeichen aus dem Input Die rechte Seite einer Produktion wurde im Input erkannt. Ersetze sie durch die linke Seite. Der Input kann dabei eine beliebige Satzform sein. Shift Reduce

11 Shift-Reduce - Parsing Der gegenwärtige String besteht aus der Satzform if Bexpr then id := Expr das nächste Token (lookahead) ist ein else. Der gegenwärtige String besteht aus der Satzform if Bexpr then id := Expr das nächste Token (lookahead) ist ein else. if then else ??? ? ? ? x>0 Bexpr y+1y:= Expr id Expr num id num Lesepointer Lese nächstes Token Shift Ersetze id := Expr durch Stmt. Reduce Wegen des Lookahead Tokens else ist ein Reduce angebracht. Wäre das lookahead ein `+`, so müßte geshiftet werden.

12 Shift-Reduce - Parsing if then else ??? ? ? ? x>0 Bexpr y+1y := Expr id Expr num id num Lesepointer Lese nächstes Token Shift Ersetze if Bexpr then Stmt durch Stmt. Reduce Wegen des Lookahead Tokens else ist ein Shift angebracht. Wäre das lookahead ein `;` oder ein `end`, so müßte geshiftet werden. Der gegenwärtige String besteht aus der Satzform if Bexpr then Stmt das nächste Token (lookahead) ist ein else. Der gegenwärtige String besteht aus der Satzform if Bexpr then Stmt das nächste Token (lookahead) ist ein else. Stmt

13 Shift/Reduce Parsing S Stmt eof Stmt if Expr then Stmt | if Expr then Stmt else Stmt | id := Expr Expr Expr + Term | Term Term num | id | ( Expr ) S Stmt eof Stmt if Expr then Stmt | if Expr then Stmt else Stmt | id := Expr Expr Expr + Term | Term Term num | id | ( Expr ) Wir parsen den Input IF id THEN id := num + id eof Wir parsen den Input IF id THEN id := num + id eof Erkannt : lookahead Aktion IF id shift IF id THEN red(6) IF Term THEN red(5) IF Expr THEN shift IF Expr THEN id shift IF Expr THEN id := shift IF Expr THEN id := num shift IF Expr THEN id := num + red(6) IF Expr THEN id := Term + red(5) IF Expr THEN id := Expr + shift IF Expr THEN id := Expr + id shift IF Expr THEN id := Expr + id eof red(7) IF Expr THEN id := Expr + Term eof red(4) IF Expr THEN id := Expr eof red(3) IF Expr THEN Stmt eof red(1) Stmt eof red(0) S eof accept Erkannt : lookahead Aktion IF id shift IF id THEN red(6) IF Term THEN red(5) IF Expr THEN shift IF Expr THEN id shift IF Expr THEN id := shift IF Expr THEN id := num shift IF Expr THEN id := num + red(6) IF Expr THEN id := Term + red(5) IF Expr THEN id := Expr + shift IF Expr THEN id := Expr + id shift IF Expr THEN id := Expr + id eof red(7) IF Expr THEN id := Expr + Term eof red(4) IF Expr THEN id := Expr eof red(3) IF Expr THEN Stmt eof red(1) Stmt eof red(0) S eof accept Grammatik

14 Zustände Ein Shift/Reduce Parser kann i.a. nicht allein anhand des lookahead tokens entscheiden, was als nächstes zu tun ist. Zu diesem Zweck muß man noch Zustände einführen, die besagen, was der Parser gerade zu erkennen versucht. Ein Shift/Reduce Parser kann i.a. nicht allein anhand des lookahead tokens entscheiden, was als nächstes zu tun ist. Zu diesem Zweck muß man noch Zustände einführen, die besagen, was der Parser gerade zu erkennen versucht. Erkannt : lookahead Aktion... THEN id := Term + red(5) THEN id := Expr + Term + red(4) Erkannt : lookahead Aktion... THEN id := Term + red(5) THEN id := Expr + Term + red(4) Expr Expr + Term | Term Expr Expr + Term | Term Anhand dieser Grammatik und allein aus der Tatsache, daß zuletzt ein Term gesehen wurde und das lookahead + ist, ist nicht ersichtlich, ob gemäß der Regel 4 oder der Regel 5 reduziert werden muß : Eine Reduktion mit Regel 5 ( red(5) ) würde im zweiten Falle in eine Sackgasse führen !!!

15 LR(0)- items *) Zur korrekten Entscheidungsfindung des Parsers sind Zustände notwendig. Ein Zustand drückt aus, - Welches Nonterminal der Parser gerade erkennen will - Mit welcher Regel er dies versucht und - Wieviel von der rechten Seite der Regel er bereits erkannt hat. Zur korrekten Entscheidungsfindung des Parsers sind Zustände notwendig. Ein Zustand drückt aus, - Welches Nonterminal der Parser gerade erkennen will - Mit welcher Regel er dies versucht und - Wieviel von der rechten Seite der Regel er bereits erkannt hat. Sei A eine Produktion. Ein item ist eine Produktion zusammen mit einer Position in. Diese Position wird durch einen Punkt markiert. Beispiel: Aus der Produktion Expr Expr + Term gewinnt man folgende items mit den Bedeutungen : Bei dem Versuch ein Expr zu finden erwarte ein Expr + Term... Expr gesehen, erwarte + Term... Expr + gesehen, erwarte Term... Expr + Term gesehen Expr Expr + Term *) LR - steht für Left-Right, gemeint ist die Abarbeitung des Inputs von Links nach rechts

16 Der Automat einer Grammatik Ein item drückt den jeweiligen Zustand des Parsers beim Erkennen eines Nonterminals aus. Mit dem Lesen des nächsten Tokens geht der Parser in den nächsten Zustand über. Es gibt zwei mögliche Übergänge : Ein item drückt den jeweiligen Zustand des Parsers beim Erkennen eines Nonterminals aus. Mit dem Lesen des nächsten Tokens geht der Parser in den nächsten Zustand über. Es gibt zwei mögliche Übergänge : Expr Expr + Term + im Input Expr Expr + Term Term ( Expr ) Term id Term num Dies definiert einen nichtdeterministischen Automaten: N(G).

17 N(G) : Automat zu einer Grammatik G Gegeben eine Grammatik G=(V,T,P,S), mit Startsymbol S, dann definieren wir einen NFA mit den items als Zustandsmenge und den Terminalen und Nonterminalen der Grammatik als Alphabet : S = Menge aller items = V T s 0 = S T = { X X P } Gegeben eine Grammatik G=(V,T,P,S), mit Startsymbol S, dann definieren wir einen NFA mit den items als Zustandsmenge und den Terminalen und Nonterminalen der Grammatik als Alphabet : S = Menge aller items = V T s 0 = S T = { X X P } Start Term Term Term Factor | Factor Factor id | ( Term ) Start Term Term Term Factor | Factor Factor id | ( Term ) (Y X, ) = { X | X P } (Y u, u) = { Y u } für u V T Für die Grammatik ergibt sich : S T T T T F F T F F id F ( T ) ( F id T ) id Alle unbeschrifteten Pfeile sind -Transitionen T F S T F T

18 Vom NFA zum DFA S T T T T F F T F F id F ( T ) ( F id T ) id Alle unbeschrifteten Pfeile sind -Transitionen E H J K A = { S T, T T F, T F, F ( T ), F id } B = { S T, T T F } C = { T F } D = { F ( T ), T T F, T F, F ( T ), F id } E = { F id } F = { } G = { T T F, F ( T ), F id } H = { F ( T ), T T F } J = { T T F } K = { F ( T ) } A B C F G T F F ( id T F D ( ( ) Aus dem NFA gewinnen wir die Zustände des DFA, den wir D(G) nennen wollen: alle übrigen Pfeile auf F Der DFA D(G) ist : Der DFA D(G) ist : T F S T F T

19 Goto In der Compilerliteratur nennt man die Tabelle des Automaten D(G) auch Goto-Tabelle. E H J K A B C F G T F F ( id T F D ( ( ) alle übrigen Pfeile auf F Goto-Tabelle : (Die leeren Positionen entsprechen Fehlerzuständen) Gotoid()*TF AEDBC BG DEDHC GEDJ HKG

20 Die Notwendigkeit eines Stacks Angenommen der Parser ist in einem Zustand (mit dem item) er muß nun also in einen Zustand springen, der das item enthält. Nach Abarbeitung dieses items kommt er in den Zustand : Nun muß er sich aber erinnern, daß er zurückspringen muß in den Zustand Offensichtlich muß bei jedem Sprung der alte Zustand auf einem Stack aufbewahrt werden und bei der Beendigung des items zurückgesprungen werden, verbunden mit einem POP des Stacks. Angenommen der Parser ist in einem Zustand (mit dem item) er muß nun also in einen Zustand springen, der das item enthält. Nach Abarbeitung dieses items kommt er in den Zustand : Nun muß er sich aber erinnern, daß er zurückspringen muß in den Zustand Offensichtlich muß bei jedem Sprung der alte Zustand auf einem Stack aufbewahrt werden und bei der Beendigung des items zurückgesprungen werden, verbunden mit einem POP des Stacks. Expr Expr + Term Term ( Expr ) Expr Expr + Term Term ( Expr )

21 shift items / reduce items Ein shift item hat die Form A u, mit u T. Ein shift item hat die Form A u, mit u T. Ein reduce item hat die Form A. Ein reduce item hat die Form A. Das shift item drückt aus, daß wir als nächstes ein u erwarten können. Sind wir in einem Zustand Y = {..., A u... } und ist das lookahead tatsächlich u, so wird es konsumiert und der nächste Zustand Z = Goto(Y,u) = {..., A u... } auf den Stack gepusht. Es drückt aus, daß wir gerade erfolgreich ein A erkannt haben. Auf dem Stack sollte gefälligst ein Zustand Y = {..., X A... } liegen, darüber | | weitere Zustände. Wir poppen also | | viele Zustände und ersetzen sie durch Goto(Y,A) = {..., X A... }. shift push reduce pop

22 Der Stack beim Parsen von ( id id ) ( id id ) eof A A D A D E A D C A D H A D H G A D H G E A D H G J A D H A = { S T, T T F, T F, F ( T ), F id } B = { S T, T T F } C = { T F } D = { F ( T ), T T F, T F, F ( T ), F id } E = { F id } F = { } G = { T T F, F ( T ), F id } H = { F ( T ), T T F } J = { T T F } K = { F ( T ) } A D H K A C A ( id F T id F ) T F T Die Shift-Aktionen entsprechen einer Traversierung des DFA(G) A B

23 Shift-Zustände - Reduce Zustände Ein reduce-Zustand ist ein Zustand, der ein reduce item enthält. Ein shift-Zustand ist ein Zustand, der ein shift item enthält. Ein accept-Zustand ist ein reduce-Zustand der Form Start Ein reduce-Zustand ist ein Zustand, der ein reduce item enthält. Ein shift-Zustand ist ein Zustand, der ein shift item enthält. Ein accept-Zustand ist ein reduce-Zustand der Form Start A = { S T, T T F, T F, F ( T ), F id } B = { S T, T T F } C = { T F } D = { F ( T ), T T F, T F, F ( T ), F id } E = { F id } F = { } G = { T T F, F ( T ), F id } H = { F ( T ), T T F } J = { T T F } K = { F ( T ) } Beispiel : Für die Zustände des vorigen Automaten hat man Shift Zustände : A, B, D, G, H Reduce Zustände : B, C, E, J, K Accept Zustand: B Überlegen Sie sich : Falls L(X) für alle X V, dann enthält jeder nichtleere Zustand ein shift item oder ein reduce item. Der Zustand, der der leeren Menge von items entspricht, kann immer als Fehlerzustand interpretiert werden.

24 Shift-Reduce Konflikte Enthält ein Zustand Z sowohl ein shift item als auch ein reduce item, so muß evtl. das lookahead entscheiden, was zu tun ist : Z = {..., A u,...,B,... } lookahead = u shift, lookahead Follow(B) reduce Falls u Follow(B) gibt es einen Konflikt ! Man sagt dann: Z hat einen Shift-Reduce Konflikt für u. Pragmatik: Meistens entscheidet man sich bei einem Shift-Reduce Konflikt zugunsten eines shift.

25 Reduce-Reduce Konflikte Ein Reduce Konflikt kommt zustande, wenn ein Zustand mehrere Reduce items mit nicht disjunkten Follow-Mengen enthält : Z = {..., A,...,B,... } lookahead Follow(A) reduce mit A lookahead Follow(B) reduce mit B Falls u Follow(A) Follow(B), gibt es einen Konflikt ! Man sagt dann: Z hat einen Reduce-Reduce Konflikt für u. Pragmatik: Reduce-Reduce Konflikte sind unangenehm. Notfalls muß man die Grammatik ändern.

26 Syntaxfehler Ein Syntaxfehler im Input ist beim LR-Parsen immer zum frühestmöglichen Zeitpunkt erkennbar : Angenommen der Parser ist in Zustand Z und das lookahead ist a. Ein Syntaxfehler liegt vor, wenn Z kein shift item A a enthält und für alle reduce items B in Z gilt : a Follow(B) Beispiel : A = { A T, T T F, T F, F ( T ), F id } B = { A T, T T F } In Zustand A gibt es den möglichen Syntaxfehler : id or ( expected In Zustand B gibt es den möglichen Syntaxfehler : * or end-of-file expected

27 Präzedenz und Assoziativität Sowohl Präzedenz, als auch durch Assoziativität bedingte Mehrdeutigkeit der Grammatik führt zu Shift-Reduce-Konflikten. E E + E E E E S E E E + E | E E | ( E ) | id S E E E + E | E E | ( E ) | id erzeugt u.a. die Zustände E E E E E + E E E E I7I7 I8I8 shift-reduce Konflikt für + und für. shift-reduce Konflikt für + und für. E E + E E E E E E + E E E E für shift ( garantiert Präzedenz von * über ) für + reduce ( bewirkt Links-Klammerung von + ) für reduce (bewirkt Links-Klammerung von ) für + reduce (garantiert Präzedenz von * über ) I7I7 I8I8 Wie sind diese Konflikte zu lösen ?

28 Parsertabelle In einer Tabelle kann die Aktion des Parsers festgehalten werden. Links steht immer der Zustand und oben ein Terminal oder ein Nonterminal a Q P Ein Eintrag bedeutet: im Zustand Q bei lookahead a shift und gehe in Zustand P a Q r k Ein Eintrag bedeutet: im Zustand Q bei lookahead a reduce mit Grammatikregel k Die Reduktion mit der Startregel, A T wird mit Accept bezeichnet. Für ein Reduce mit der Regel A ist nur interessant : | | - weil soviele Stackelemente gepoppt werden A - weil anschließend mit Goto(top(stack),A) geshiftet wird.

29 Parsertabelle Die komplette Information über die Grammatik steckt in der Parsertabelle: (0) A Term (1) Term Term Factor (2) | Factor (3) Factor id (4) | ( Term ) (0) A Term (1) Term Term Factor (2) | Factor (3) Factor id (4) | ( Term ) Actionid()*TFeof AEDBC BGAccept Cr 2r 2r 2 DEDHC Er 3r 3r 3 F GEDJ HKG Jr 1r 1r 1 Kr 4r 4r 4 Grammatik Parser tabelle

30 LR(0) Parsing id()*TFeof AEDBC BGAccept Cr 2r 2r 2 DEDHC Er 3r 3r 3 F GEDJ HKG Jr 1r 1r 1 Kr 4r 4r 4 (0) A T (1) T T F (2) | F (3) F id (4) | ( T ) (0) A T (1) T T F (2) | F (3) F id (4) | ( T ) ( id id ) eof A A D A D E A D C A D H A D H G A D H G E A D H G J A D H A D H K A C A ( id F T id F ) T F T A B

31 yacc Yacc ist ein Parser Generator. Aus einer kontextfreien Grammatik erzeugt er automatisch einen LALR(1) Parser (mächtiger als LR(0)). Der Parser ist ein ausführbares Programm und liegt als C-Funktion yyparse() vor. Typischerweise arbeitet yacc mit mit lex zusammen. lex erkennt die Token, während yacc für die darauf aufbauende Grammatik verantwortlich ist. Yacc ist ein Parser Generator. Aus einer kontextfreien Grammatik erzeugt er automatisch einen LALR(1) Parser (mächtiger als LR(0)). Der Parser ist ein ausführbares Programm und liegt als C-Funktion yyparse() vor. Typischerweise arbeitet yacc mit mit lex zusammen. lex erkennt die Token, während yacc für die darauf aufbauende Grammatik verantwortlich ist. # yacc Input File für Baby Deutsch %start Satz %Token ARTIKEL NAME HAUPTWORT AUX VERB PUNKT % Satz :Subjekt Praedikat Objekt PUNKT | Subjekt Praedikat PUNKT ; Subjekt: ARTIKEL HAUPTWORT |NAME ; Objekt:Subjekt ; Praedikat:AUX VERB ; |VERB |error{Verb erwartet} ; # yacc Input File für Baby Deutsch %start Satz %Token ARTIKEL NAME HAUPTWORT AUX VERB PUNKT % Satz :Subjekt Praedikat Objekt PUNKT | Subjekt Praedikat PUNKT ; Subjekt: ARTIKEL HAUPTWORT |NAME ; Objekt:Subjekt ; Praedikat:AUX VERB ; |VERB |error{Verb erwartet} ; Startsymbol Für diese Token ist lex verantwortlich Aktionen werden wie Terminalsymbole behandelt

32 Das Duo : lex und yacc yacc erzeugt die Funktion yyparse(), lex die Funktion yylex(). yylex() liefert die Nummer des Tokens. Der String aus dem dieses besteht ist immer in der (globalen) Variablen yytext vorhanden. yacc erzeugt die Funktion yyparse(), lex die Funktion yylex(). yylex() liefert die Nummer des Tokens. Der String aus dem dieses besteht ist immer in der (globalen) Variablen yytext vorhanden. Fig. nach: T.Mason, D. Brown: lex & yacc OReilly & Associates, Inc. main() yyparse() yylex() Input yytext 0 falls gültig 1 sonst Token Nummer, 0 falls eof verlange nächstes token lese nächstes Zeichen

33 Beispiel: Ein Compiler für Expressions Wir wollen einen Compiler bauen, der algebraische Ausdrücke in Postfix-Notation verwandelt. Wir gehen aus von der einfachen Grammatik Expr Expr + Expr | Expr - Expr | Expr * Expr | Expr / Expr | ( Expr ) | id | num Expr Expr + Expr | Expr - Expr | Expr * Expr | Expr / Expr | ( Expr ) | id | num Als erstes spezifizieren wir die Token durch ein lex file. Eine Umwandlung, z.B. zur Beseitigung der Linksrekursion, oder zur Erzwingung der Präzedenzen oder der Linksassoziativität ist nicht nötig.

34 Das lex file Das lex-file infix_postfix.l. Wir benutzen die Konvertierungsfunktion sscanf der Sprache C, um den (aus Ziffern bestehenden) String yytext in den entsprechenden Zahlenwert zu verwandeln. Diesen speichern wir in der globalen Variablen yylval. Die Integerkonstanten PLUS,MINUS,TIMES,QUOT werden wir in dem zugehörigen yacc-file spezifizieren. Das lex-file infix_postfix.l. Wir benutzen die Konvertierungsfunktion sscanf der Sprache C, um den (aus Ziffern bestehenden) String yytext in den entsprechenden Zahlenwert zu verwandeln. Diesen speichern wir in der globalen Variablen yylval. Die Integerkonstanten PLUS,MINUS,TIMES,QUOT werden wir in dem zugehörigen yacc-file spezifizieren. letter[a-zA-Z] digit[0-9] % [ \t]+; + { return(PLUS) } - { return(MINUS) } * { return(TIMES) } / { return(QUOT) } {digit}+{ sscanf(yytext,%d, &yylval); return(NUM)} {letter}({letter}|{digit})* {return(ID)} % letter[a-zA-Z] digit[0-9] % [ \t]+; + { return(PLUS) } - { return(MINUS) } * { return(TIMES) } / { return(QUOT) } {digit}+{ sscanf(yytext,%d, &yylval); return(NUM)} {letter}({letter}|{digit})* {return(ID)} %

35 Das yacc file In dem yacc file werden zunächst die token ID, NUM und PLUS, MINUS, TIMES, QUOT deklariert. Die letzteren werden als links-assoziative Operatoren spezifiziert, was den Parser zur richtigen Auflösung der entstehenden shift- reduce Konflikte veranlaßt. Die Reihenfolge (zunächst PLUS, MINUS, danach TIMES, QUOT ) bewirkt die gewünschte Präzedenz. Über yylval und yytext kann auf Attribute der Token NUM und ID zugegriffen werden. In dem yacc file werden zunächst die token ID, NUM und PLUS, MINUS, TIMES, QUOT deklariert. Die letzteren werden als links-assoziative Operatoren spezifiziert, was den Parser zur richtigen Auflösung der entstehenden shift- reduce Konflikte veranlaßt. Die Reihenfolge (zunächst PLUS, MINUS, danach TIMES, QUOT ) bewirkt die gewünschte Präzedenz. Über yylval und yytext kann auf Attribute der Token NUM und ID zugegriffen werden. %token ID, NUM %left PLUS, MINUS %left TIMES, QUOT %start expr % expr : expr PLUS expr { printf(add ); } | expr MINUS expr { printf(sub ); } | expr TIMES expr { printf(mult ); } | expr QUOT expr { printf(div ); } | NUM { printf("%d ",yylval);} | ID { printf("%s ",yytext);} ; % #include "lex.yy.c" int main(){ printf(Bitte geben Sie einen Ausdruck ein :\n); yyparse(); } %token ID, NUM %left PLUS, MINUS %left TIMES, QUOT %start expr % expr : expr PLUS expr { printf(add ); } | expr MINUS expr { printf(sub ); } | expr TIMES expr { printf(mult ); } | expr QUOT expr { printf(div ); } | NUM { printf("%d ",yylval);} | ID { printf("%s ",yytext);} ; % #include "lex.yy.c" int main(){ printf(Bitte geben Sie einen Ausdruck ein :\n); yyparse(); } Das von lex erzeugte C-Programm wird hier eingefügt.

36 Das fertige C-Programm Aus dem lex file infix_postfix.l erzeugt lex ein C-File lex.yy.c. Das Kommando lautet hier : lex infix_postfix.l Über zusätzliche Optionen (-v,..) können auch diagnostische Informationen hinzugefügt werden. Aus dem yacc file infix.y erzeugt yacc ein C-File y.tab.c. Das Kommando hierzu ist : yacc infix.y Der C-Compiler erzeugt aus y.tab.c das ausführbare Programm. Hierzu werden beim Linken gewisse Bibliotheksroutinen für lex ( -ll ) und für yacc ( -ly ) benötigt. Wenn das fertige Programm in2post heißen soll, lautet das Kommando : cc -o in2post y.tab.c -ll -ly Aus dem lex file infix_postfix.l erzeugt lex ein C-File lex.yy.c. Das Kommando lautet hier : lex infix_postfix.l Über zusätzliche Optionen (-v,..) können auch diagnostische Informationen hinzugefügt werden. Aus dem yacc file infix.y erzeugt yacc ein C-File y.tab.c. Das Kommando hierzu ist : yacc infix.y Der C-Compiler erzeugt aus y.tab.c das ausführbare Programm. Hierzu werden beim Linken gewisse Bibliotheksroutinen für lex ( -ll ) und für yacc ( -ly ) benötigt. Wenn das fertige Programm in2post heißen soll, lautet das Kommando : cc -o in2post y.tab.c -ll -ly

37 Das Zusammenspiel von lex & yacc lex yacc lex Spezifikation lex Spezifikation yacc Spezifikation yacc Spezifikation yylex( ) yyparse( ) Zusätzl. C-Routinen Zusätzl. C-Routinen cc UNIX Bibliotheken UNIX Bibliotheken fertiges Programm Fig. nach: T.Mason, D. Brown: lex & yacc OReilly & Associates, Inc. *.l *.y lex.yy.c y.tab.c *.c

38 Der Aufbau eines Syntaxprüfers Die Arbeitsweise eines Syntaxprüfers geschieht in 2 Phasen. Diese Phasen können in ihrem Ablauf zeitlich verschachtelt sein. Der Scanner zerlegt das inputfile anhand regulärer Definitionen in eine Reihe von Token. Scanner b e t r a g := b e t r a g * ( 1 + zi n s ) idassign intConst + id* ( ) File of char: File of token: Phase 1: Scannen Phase 1: Scannen

39 Der Aufbau eines Syntaxprüfers DerParser versucht die Reihe der Token zu einem Herleitungsbaum zu gruppieren Parser id assign intConst + id * ( ) File of token: id assign * id + intConst id ( ) Parse Tree : Phase 2: Parsen Phase 2: Parsen

40 Symboltabelle Ein Compiler besteht aus einem Syntaxprüfer und einer weiteren Stufe, dem Codeerzeuger. Um aus einem Syntaxbaum Code erzeugen zu können, muß aber die Identität einiger Token bekannt sein. Etwa, welche Bezeichner identisch sind, welchen Wert eine intConst hat, etc. Der Scanner legt diese Information in einer Symboltabelle ab und reicht dem Parser nicht nur die Token, sondern auch Zeiger in diese Tabelle weiter. Ein Compiler besteht aus einem Syntaxprüfer und einer weiteren Stufe, dem Codeerzeuger. Um aus einem Syntaxbaum Code erzeugen zu können, muß aber die Identität einiger Token bekannt sein. Etwa, welche Bezeichner identisch sind, welchen Wert eine intConst hat, etc. Der Scanner legt diese Information in einer Symboltabelle ab und reicht dem Parser nicht nur die Token, sondern auch Zeiger in diese Tabelle weiter. betrag zins x test Real Integer Boolean Name Typ 17F4 17F8 201C C011 Sp.Platz Scanner b e t r a g := b e t r a g * ( 1 + zi n s ) nl idassign intConst + id* ( ) 1

41 Symboltabelle Gewisse Token im Syntaxbaum haben einen Link in die Symboltabelle assign * + intConst ( ) Parse Tree : betrag zins x test Real Integer Boolean Name Typ 17F4 17F8 201C C011 Sp.Platz id id id 1

42 Stackprozessor Aus einem Programmtext gilt es, Code für eine einfache Maschine (einen Prozessor) zu erzeugen. Ein einfaches Maschinenmodell ist ein Stackprozessor. Wir denken uns eine Maschine, die im wesentlichen aus einem Stack besteht und damit folgende Operationen ausführen kann : PUSH LOAD STORE ADD MULT PUSH LOAD STORE ADD MULT Lege den Zahlenwert auf dem Stack ab Lege den Inhalt von Adresse auf dem Stack ab Speichere den Top des Stacks an Adresse. Der Stack wird dabei gepopped. Speichere den Top des Stacks an Adresse. Der Stack wird dabei gepopped. Ersetze das oberste Element des Stacks durch die Summe der beiden obersten Ersetze das oberste Element des Stacks durch die Summe der beiden obersten Ersetze das oberste Element des Stacks durch das Produkt der beiden obersten Ersetze das oberste Element des Stacks durch das Produkt der beiden obersten

43 Code-Erzeugung Aus dem Syntaxbaum kann leicht Code erzeugt werden, etwa für einen Stackprozessor : assign * + intConst ( ) Parse Tree : betrag zins x test Real Integer Boolean Name Typ 17F4 17F8 201C C011 Sp.Platz id id id 1 LOAD 17F4 PUSH 1 LOAD 17f8 ADD MULT STORE 17F4 LOAD 17F4 PUSH 1 LOAD 17f8 ADD MULT STORE 17F4 Code für einen Stackprozessor

44 Code Erzeugung aus dem Parser Die Ausgabe des Codes kann als semantische Aktion vom Parser veranlaßt werden, die erweiterte Syntax würde etwa lauten : %{ int* loc }% expr : expr + expr { printf("ADD \n"); } | expr * expr { printf("MULT\n"); } | intConst { printf("PUSH "); printf("%d\n",yylval);} | ID { printf("LOAD "); printf(lookup(yytext));} ; stmt : ID { loc=lookup(yytext);} ASSIGN expr { printf("STORE "); printf(&loc); } |... etc.... % #include lex.yy.c... %{ int* loc }% expr : expr + expr { printf("ADD \n"); } | expr * expr { printf("MULT\n"); } | intConst { printf("PUSH "); printf("%d\n",yylval);} | ID { printf("LOAD "); printf(lookup(yytext));} ; stmt : ID { loc=lookup(yytext);} ASSIGN expr { printf("STORE "); printf(&loc); } |... etc.... % #include lex.yy.c...


Herunterladen ppt "Martin Schneider, 25.05.2000 Folien von Prof. H.-P. Gumm Martin Schneider, 25.05.2000 Folien von Prof. H.-P. Gumm Parsen."

Ähnliche Präsentationen


Google-Anzeigen