Java für Fortgeschrittene Proseminar im Sommersemester 2009 Compilertechnik - Parser, Scanner & Co.

Transkript

1 Java für Fortgeschrittene Proseminar im Sommersemester 2009 Compilertechnik - Parser, Scanner & Co. Andrea Cuno Technische Universität München Zusammenfassung Reguläre Ausdrücke in Java bieten die Möglichkeit, Strings unter bestimmten Aspekten zu betrachten. Je nach Absicht können Zeichen eines Strings erlaubt, erzwungen, eine bestimmte Reihenfolge oder Anzahl festgelegt werden. Für komplexere Ausdrücke reichen die von Java angebotenen Mittel und Möglichkeiten mitunter nicht. Stattdessen kann es für spezifische Problemstellungen sinnvoll sein, mit Hilfsprogrammen passende Scanner und Parser zu erstellen. Die beiden Programme CUP und JFlex stellen solche Hilfsprogramme dar, die auch im Compilerbau eingesetzt werden. Die generierten Parser und Scanner bestehen aus Java-Code und dienen der Bearbeitung und Auswertung von regulären Ausdrücken. 1 Einleitung Das Ziel dieser Arbeit ist es, dem Leser einen Überblick über die wichtigsten Mittel und Möglichkeiten im Umgang mit regulären Ausdrücken, Parsern und Scannern zu geben. In den folgenden Kapiteln werden zunächst reguläre Ausdrücke in Java behandelt, gefolgt von einem Überblick über die Funktionsweise eines Compilers, sowie weitergehenden Erläuterungen zu den Themen Scanner und Parser. Reguläre Ausdrücke benötigt man in der Informatik häufig, um Eingaben differenziert auszuwerten und zu bearbeiten. Allerdings werden Java-Programme zur Auswertung von komplexen regulären Ausdrücken schnell unübersichtlich und somit fehleranfällig. An dieser Stelle können Scanner generiert werden, die dann die Auswertung beziehungsweise Bearbeitung der regulären Ausdrücke übernehmen. In einem Kapitel zur lexikalischen Analyse wird die Aufgabe eines Scanners näher erläutert. In diesem Zusammenhang wird anschließend der Umgang mit JFlex (Fast Scanner Generator for Java) [4] kurz vorgestellt. Scanner und Parser arbeiten in der Form zusammen, dass der Scanner die erfassten Zeichenfolgen, sogenannte Tokens, an den Parser übergibt, die dieser dann weitergehend behandelt. Parser sind generell eine 1

2 Stufe mächtiger als Scanner, denn sie erlauben die Erkennung mächtigerer Sprachmittel. Das heißt, beispielsweise bei geklammerten Ausdrücken, dass der Parser die offenen und geschlossenen Klammern zählt und so die zusammengehörenden Klammern entsprechend erfasst werden. Nach einer Einführung in die semantische Analyse, die Aufgabe des Parsers, folgt ein Kapitel zu dem Programm CUP (Constructor of Useful Parsers) [3], das der Erstellung von Parsern dient. 2 Reguläre Ausdrücke Reguläre Ausdrücke stellen eine Möglichkeit dar, um Muster von Zeichenketten zu beschreiben. Sie werden unter anderem zum Suchen von und in Strings und zum Definieren von formalen Sprachen verwendet. Die nachfolgende Tabelle enthält einige grundlegende Regeln für reguläre Ausdrücke. Eine ausführlichere Liste ist unter [6] zu finden. Regulärer Ausdruck Bedeutung [abc] a, b, oder c [ˆabc] jedes Zeichen außer a, b, oder c ( ˆ= Negation) [a-d[m-p]] a bis d oder m bis p: [a-dm-p] ( ˆ= Vereinigung) [a-z&&[def]] d, e, oder f ( ˆ= Schnitt) [a-z&&[ˆbc]] a bis z außer b und c: [ad-z] ( ˆ= Subtraktion) [a-z&&[ˆm-p]] a bis z, aber nicht m bis p; entspricht [a-lq-z]. ein beliebiges Zeichen a* kein oder beliebig viele a a? kein oder ein a a+ ein oder beliebig viele a a{n,m} a mindestens n und höchstens m-mal a{n} a genau n-mal a{n,} a mindestens n-mal (hallo) fasst die Buchstaben h,a,l,l,o zu einer Einheit zusammen (Capturing-Group) ˆ Anfang einer Zeile $ Ende einer Zeile Tabelle 1: Reguläre Ausdrücke Im Folgenden werden einige Regeln zu regulären Ausdrücken ausführlicher beschrieben. Innerhalb der eckigen Klammern können verschiedene Mengen von Zeichen zusammengefasst, oder Teilmengen ausgeschlossen werden. Demzufolge bedeutet [a-dm-p] (siehe Tabelle 1), dass Buchstaben von a bis d und von m bis p erlaubt sind. Bei Zahlenangaben ist bei dieser Schreibweise darauf zu achten, dass der Ausdruck [1-12] nicht etwa Zahlen von eins bis zwölf erlaubt. 2

3 Der Ausdruck muss stattdessen so interpretiert werden, dass Zahlen von eins bis eins und die Ziffer zwei zu der Menge der zugelassenen Zahlen gehören. Die Zahlen von eins bis zwölf könnte man so darstellen: ([1 9] )$. Eine andere Variante wäre ([1 9] (1[0 2]))$. Die Schnittmenge zweier Mengen lässt sich ebenfalls darstellen. Ein Beispiel hierfür ist [a z&&[d f]]. Der Ausdruck entspricht einer Menge mit den Buchstaben d, e und f. Mit ˆ kann ein Zeichen oder eine Zeichengruppe negiert werden. [a z&&[ˆd f]] beschreibt dementsprechend eine Menge, in der die Buchstaben a bis z außer d, e und f, erlaubt sind. Das Sonderzeichen ˆ hat außerdem eine weitere Funktion, die im Folgenden deutlich wird: Der Ausdruck [ˆabc] bedeutet, dass a, b und c nicht auftreten dürfen. Schreibt man dagegen ˆ[abc], heißt das, dass a, b oder c am Anfang einer Zeile stehen muss. $ ist das entsprechende Zeichen für das Ende einer Zeile. ˆa$ würde folglich bedeuten, dass eine Zeile nur aus einem einzelnen a bestehen darf. Alternative reguläre Ausdrücke werden durch das Sonderzeichen getrennt. Die Funktion von Sonderzeichen, wie ˆ und, wird aufgehoben, sobald der escape-character für reguläre Ausdrücke, ein Backslash, davor steht. Um festzulegen, wie oft ein Zeichen oder eine Zeichenfolge hintereinander auftreten darf, gibt es die sogenannten Quantifiers +, * und?. Das Plus- Zeichen bedeutet, dass der davor stehende Ausdruck beliebig oft auftreten darf, jedoch mindestens einmal. Im Gegensatz dazu, erlaubt * zusätzlich, dass der Ausdruck nicht erscheint. Wenn gewünscht ist, dass ein Ausdruck nicht oder höchstens einmal auftritt, ist ein anschließendes Fragezeichen zweckgemäß. Um speziellere Mengenangaben festzulegen, können dem Ausdruck geschweifte Klammern mit der zulässigen Mindest- und Höchstanzahl folgen. X{3,4} verlangt, dass das Zeichen X genau drei- oder viermal auftritt. Bei regulären Ausdrücken lässt sich das gleiche Muster oft durch verschiedene Varianten ausdrücken. Beispielsweise ist der Ausdruck xxx?x? nur eine andere Schreibweise für x{2,4}, da die ersten beiden x-zeichen, denen kein Fragezeichen folgt, in jedem Fall auftreten müssen, die beiden anderen jedoch jeweils einmal oder gar nicht. In Java werden für die Anwendung von regulären Ausdrücken Patternund Matcher-Objekte zur Verfügung gestellt (siehe Tabellen 2, 3). 3

4 Pattern Rückgabewert Methodenname Beschreibung Pattern compile(string regex) Compiles the given regular expression into a pattern. Matcher matcher(charsequence input) boolean matches(string regex, CharSequence input) Creates a matcher that will match the given input against this pattern. Compiles the given regular expression and attempts to match the given input against it. String pattern() Returns the regular expression from which this pattern was compiled. Tabelle 2: Pattern Matcher Rückgabewert Methodenname Beschreibung boolean matches() Attempts to match the entire region against the pattern. Pattern pattern() Returns the pattern that is interpreted by this matcher. String replaceall(string replacement) Replaces every subsequence of the input sequence that matches the pattern with the given replacement string. Matcher reset() Resets this matcher. int start() Returns the start index of the previous match. String group(int group) Returns the input subsequence captured by the given group during the previous match operation. Tabelle 3: Matcher 4

5 Mit Hilfe des Pattern-Objekts wird der reguläre Ausdruck definiert, wie das folgende Beispiel zeigt. final Pattern carpattern = Pattern.compile("[A-Z]+[ ][A-Z]+[ ][0-9]+"); Die Methode compile() übersetzt den String in ein entsprechendes Pattern- Objekt. In diesem Fall würde jedes (Euro-) Auto-Kennzeichen dem dargestellten regulären Ausdruck entsprechen. Allerdings genügen diesem Ausdruck auch andere Zeichenketten, die keine korrekten Auto-Kennzeichen sind, da beliebig viele Großbuchstaben, ein Leerzeichen, erneut Großbuchstaben und ein Leerzeichen, gefolgt von beliebig vielen Zahlen in dem Ausdruck vorkommen dürfen. Um den regulären Ausdruck weiter zu präzisieren, könnte man beispielsweise die Anzahl der Ziffern festlegen. Es muss mindestens eine Ziffer enthalten sein, jedoch sind höchstens vier Ziffern zugelassen. Folgender Ausdruck ist also wesentlich präziser: "[A-Z]{1,3}[ ][A-Z]{1,2}[ ][0-9]{1,4}" Wenn ein Pattern-Objekt erstellt wurde, kann darauf aufbauend mit Matcher- Objekten weitergearbeitet werden. Ein Matcher bezieht sich auf einen konkreten Textstring und bietet unter anderem eine Methode an, um den Eingabe-String mit dem regulären Ausdruck abzugleichen. Matcher m=carpattern.matcher("m XY 123"); boolean b = m.matches(); Runde Klammern fassen Zeichengruppen zu einer Einheit zusammen, sogenannte Capturing-Groups. Auf den Teil des Eingabestrings, der mit der Capturing- Group übereinstimmt, kann mithilfe des Befehls group(int i) zugegriffen werden. Pattern p = Pattern.compile("([A-Z]{1,3})[ ]([A-Z]{1,2})[ ]([0-9]{1,4})"); Matcher m; m = p.matcher("m XY 123"); System.out.println(m.matches()); //true System.out.println(m.group(1)); // M System.out.println(m.group(2)); // XY System.out.println(m.group(3)); // Compiler Ein Compiler, (dt. Übersetzer), ist ein Programm, das Programme aus einer Sprache in eine andere Sprache übersetzt. Im sogenannten Frontend des Compilers erfolgen die analytischen Aufgaben des Compilers. Dazu zählen die lexikalische, syntaktische und semantische Analyse. In diesem Bereich sind Scanner und Parser angesiedelt. Der Scanner ist für die 5

6 lexikalische Analyse zuständig, der Parser übernimmt die syntaktische Analyse. Im Backend wird aus den Ergebnissen des Frontends in der Regel zuerst ein sogenannter Zwischencode erzeugt. Daraufhin erfolgt eine Optimierung des Codes und schließlich wird der Zielcode erzeugt. Abbildung 1: Aufbau eines Compilers Für die Generierung von Parsern und Scannern, können die Programme JFlex und CUP verwendet werden. Sie sind aufeinander abgestimmt und erstellen Java-Dateien. Beim Zusammenwirken der beiden Programme entstehen drei Java-Klassen, ein Parser, ein Scanner und eine weitere Klasse für die Tokens beziehungsweise Terminale oder Symbole. Mit Hilfe dieser Tokenfolgen überliefert der Scanner die Eingabe auf strukturierte Weise an den Parser, der diese weiterverarbeitet. 6

7 Abbildung 2: Zusammenhang: Java, JFlex, CUP 3.1 Lexikalische Analyse - Scanner Die grundlegende Aufgabe der lexikalischen Analyse ist die Zerlegung einer Eingabe in Zeichen oder Zeichenketten, sogenannte Tokens. Die Regeln für die Zerlegung werden als Liste von regulären Ausdrücken festgelegt. Ein lexikalischer Scanner, auch Lexer genannt, ist ein Computerprogramm, das für die lexikalische Analyse im Compiliervorgang zuständig ist. Typische Tokens sind Operatoren, Bezeichner, Konstanten und bestimmte Schlüsselwörter, die mit ihrem jeweiligen Typ an den Parser weitergeleitet werden. Zu den Aufgaben eines Scanners gehört auch die Erkennung unzulässiger Zeichen oder Zeichenketten. Im Scanner erfolgt also zum Beispiel die Erkennung von Ziffernfolgen oder Buchstabenfolgen als Zahlen beziehungsweise Wörter. 7

8 Abbildung 3: Zerlegung einer Schleife durch einen Scanner in Token JFlex - The Fast Scanner Generator for Java JFlex [4] ist ein Programm, um lexikalische Scanner zu erstellen. JFlex wurde für die Programmiersprache Java geschrieben und wird häufig zusammen mit CUP verwendet (siehe Codebeispiel 1, Zeile 4). JFlex benötigt eine Input-Datei mit der Endung.jflex, um daraus einen Scanner in Form einer Java-Klasse zu erstellen. Die Syntax von JFlex weist Ähnlichkeiten mit der Java-Syntax auf, unterscheidet sich jedoch in einigen grundlegenden Merkmalen. Zunächst wird ein kurzer Überblick über die Syntax der JFlex-Datei gegeben, anschließend folgt ein Code-Beispiel mit weiteren Erläuterungen. Eine JFlex-Datei besteht aus drei Teilbereichen, die jeweils durch eine Zeile getrennt werden, die die Zeichen %% enthält. Der erste Bereich wird UserCode genannt. Hier finden die package-deklaration und Importe statt. Darunter folgt der Abschnitt für Optionen und Deklarationen, der zum Beispiel die Zeile %cup enthält, wenn JFlex mit CUP zusammen genutzt werden soll. Des weiteren ist hier Platz für (Variablen-)Deklarationen, sowie den Konstruktor der Scanner-Klasse (siehe Codebeispiel 1, Zeilen 7-10). Der dritte und letzte Abschnitt enthält die lexikalischen Regeln, also eine Auflistung von regulären Ausdrücken mit Aktionen. Alle Zeichenmuster, die in den auszuwertenden Ausdrücken enthalten sein dürfen, müssen hier aufgeführt werden. Das ist mit Hilfe von regulären Ausdrücken möglich (siehe Codebeispiel 1, Zeile 14-20). Die lexikalischen Regeln sind nach dem Muster "Zeichen oder Zeichenfolge" { Aktionen für Zeichen/Zeichenfolge } oder regulärer Ausdruck { Aktionen für regulären Ausdruck } aufgebaut. Für jedes zugelassene Token werden in den nachfolgenden geschweif- 8

9 ten Klammern die Aktionen festgelegt. Wenn keine Aktionen definiert sind, wird das Zeichen beim Scannen ignoriert. Es sind in diesem Bereich Anweisungen in Form von Java-Code, wie beispielsweise System.out.println(yytext()); oder System.err.println("Illegal character": + yytext()); (siehe Codebeispiel 1, Zeile 20) möglich. Mit yytext() kann auf das aktuelle Token zugegriffen werden. In der Regel wird jedoch in den geschweiften Klammern als Aktion ein Token erzeugt und per return-anweisung an den Parser weitergegeben. Dabei wird dem Token sein Typ zugewiesen, zum Beispiel SEMI (siehe Zeile 14). Bei der Auflistung der Zeichen und Ausdrücke mit ihren Aktionen gibt es einen Unterschied zwischen statischen Zeichen oder Zeichenketten (wie ; ) und variablen regulären Ausdrücken, die in jeder Eingabe unterschiedlich ausfallen können (wie [0-9]+). Bei letzterem wird der genaue Inhalt, also zum Beispiel die Eingabe 99, gespeichert, so dass man im Parser über Labels auf diesen Inhalt zugreifen kann (siehe Kapitel 3.2.1). Bei der Reihenfolge in der Auflistung von regulären Ausdrücke mit ihren Aktionen sollte man auf folgende Prinzipien von JFlex achten. Beim Scannen wird die Eingabe mit der Liste der regulären Ausdrücke von oben nach unten abgeglichen. Das bedeutet, wenn beispielsweise in der ersten Zeile das Token [a-z] eingeführt wird und in der zweiten das Token a, dann wird bei der Eingabe a die erste Zeile als passender regulärer Ausdruck erkannt und die zweite Zeile wird nie zu einer Aktion führen. Wenn dem Buchstaben a in diesem Beispiel also eine besondere Funktion zukommen soll, muss das Zeichen a mit dem entsprechenden Aktionsbereich, vor [a-z] eingeführt werden. Das zweite Prinzip ist das Prinzip des longest match. In einem Beispiel wird sowohl das Zeichen + (in der ersten Zeile) als auch das Zeichen ++ (in der zweiten Zeile) als Token spezifiziert. Bei einer Eingabe ++ erkennt der Scanner, dass die Eingabe zu dem in der ersten Zeile spezifizierten Plus passt, schaut jedoch weiter, ob ein längerer Treffer existiert. Da das Token ++ einen längeren Treffer ermöglicht, wird in diesem Fallbeispiel nicht zweimal das Token + zurückgegeben, sondern einmal das Token ++, da der Scanner nach dem längsten Treffer sucht. 1 package packagename; 2 import java_cup.runtime.symbolfactory; 3 %% 4 %cup 5 %class Scanner 6 %{ 7 public Scanner(java.io.InputStream r, SymbolFactory sf){ 8 this(r); 9 this.sf=sf; 10 } 11 private SymbolFactory sf; 12 %} 9

10 13 %% 14 ";" { return sf.newsymbol("semicolon",sym.semi); } 15 "+" { return sf.newsymbol("plus",sym.plus); } 16 "-" { return sf.newsymbol("minus",sym.minus); } 17 [0-9]+ { return sf.newsymbol("integral Number",sym.NUMBER, 18 new Integer(yytext())); } 19 [ \t\r\n\f] { /* ignore white space. */ } 20. { System.err.println("Illegal character: " + yytext()); } Codebeispiel 1: JFlex In diesem Code-Beispiel ist eine vollständige JFlex-Datei zu sehen. Es werden neben Zahlen nur Semikola, Plus- und Minuszeichen als gültige Eingabe vom Scanner erlaubt. Eine solche Eingabe wäre beispielsweise 8+33; oder 11 ;. Allerdings wären auch 11+ oder ;8 lexikalisch korrekt. Die syntaktische Richtigkeit zu prüfen, ist Aufgabe des Parsers (siehe Kapitel 3.2.1). In den geschweiften Klammern wird in der return-anweisung das neue Symbol benannt und gegebenfalls ein Typ für das Symbol festgelegt. Mit yytext() kann auf das aktuelle Token zugegriffen werden (siehe Zeile 20), beispielsweise um ein neues Objekt vom Typ Integer zu erstellen (siehe Zeile 18). Um weitere Informationen einzufordern, gibt es neben yytext() noch yylength() und yyline() für die Länge, beziehungsweise die Zeile des aktuellen Tokens. Mit return wird das Token weitergereicht. Gegebenfalls kann vor der return- Anweisung weiterer (Java-)Code stehen, wie System.out.print(yytext()). In Zeile 19 wird ersichtlich, dass alle Leerzeichen, sowie Tabstopps und Leerzeilen in diesem Beispiel ignoriert werden sollen, das heißt, sie lösen keine Fehlermeldung aus, werden aber vom Scanner auch nicht weitergegeben. Die anderen spezifizierten Symbole werden hingegen vom Scanner als Tokens an den Parser übergeben, wo sie weiter behandelt werden können. In der letzten Zeile wird festgelegt, dass bei der Eingabe von allen Zeichen, außer der vorher behandelten, die Fehlermeldung Illegal character: ausgegeben wird. JFlex bietet auch die Möglichkeit, verschiedene Zustände, sogenannte States, zu verwalten. Standardmäßig wird der YYINITIAL-Zustand verwendet, der auch immer den anfänglichen Zustand darstellt. Allerdings gibt es Situationen, in denen es sinnvoll ist, nicht nur den Standardzustand zu verwenden. Nachfolgendes Beispiel soll veranschaulichen, wann und warum Zustände nötig sein können. Einem Bezeichner soll ein String zugewiesen werden und diese Anweisung soll außerdem mit einem Semikolon abgeschlossen werden. Allerdings soll der String neben verschiedenen Zeichen auch Semikola enthalten dürfen. Eine mögliche Eingabe ist also zum Beispiel x=";"; An dieser Stelle ist der Einsatz von unterschiedlichen Zuständen sinnvoll, da das Semikolon manchmal nur Bestandteil eines Strings ist und manchmal eine andere, besondere Funktion erfüllen soll. Mit unterschiedlichen Zuständen können Semikola in diesen beiden Kontexten unterschiedlich behandelt werden. 10

11 Neben dem standardmäßigen Zustand YYINITIAL können weitere Zustände definiert werden, wie zum Beispiel der state STRING. Von einem Zustand in einen anderen zu wechseln, erfolgt mit der Methode yybegin(). Mit yybegin(string) wechselt man zum Beispiel in den String-Zustand. Als sinnvolle Lösung für die oben beschriebene Problemstellung könnte man folgenden Code verwenden: 1 StringBuffer text = new StringBuffer(); <YYINITIAL> { 4 "\"" { text.setlength(0); yybegin(string); } 5 ";" { return sf.newsymbol("semikolon",sym.semi); } } 8 9 <STRING> { 10 "\"" { yybegin(yyinitial); return symbol(sym.stringliteral, 11 text.tostring()); } 12 [^\n\r\"\]+ { text.append(yytext()); } 13 } 14. { System.err.println("Illegal character: "+yytext());} Codebeispiel 2: States in JFlex Im Beispiel bewirken die Anführungsstriche einen Statewechsel (siehe Codebeispiel 2, Zeilen 4, 10). Wenn sich der Scanner im YYINITIAL-State befindet, leiten Anführungsstriche einen String ein und somit wird im auszuführenden Code der State zu STRING gewechselt (siehe Zeile 4). Wenn sich im Eingabetext keine Anführungszeichen befinden, bleibt der Scanner im YYINITIAL-Zustand und die dafür erlaubten Zeichen werden wie gewohnt behandelt (siehe Zeile 5). Befindet sich der Scanner im STRING-Zustand, werden alle Zeichen außer Zeilenumbrüche und Anführungsstrichen dem String text angehängt (siehe Zeile 12). Tritt ein Anführungszeichen auf, wird der Zustand gewechselt und der String text, der beliebig viele Zeichen enthalten kann, wird zurückgegeben (siehe Zeilen 10,11). 3.2 Syntaktische Analyse - Parser Die Hauptaufgabe des Parsers ist die Überführung der Tokens in eine strukturierte Darstellung, zum Beispiel einen Syntaxbaum. Des weiteren sorgt der Parser für die Erkennung von syntaktischen Fehlern und ihres Entstehungsorts. 11

12 3.2.1 CUP - Constructor of Useful Parsers Das Programm CUP ist in Java geschrieben und der von CUP erstellte Code ist ebenfalls Java-Code. Ähnlich wie JFlex benötigt CUP eine Datei mit der Endung.cup, um eine entsprechende Java-Klasse zu erstellen - den Parser. Im Folgenden sind einige wesentliche Bestandteile einer CUP-Datei beschrieben. 1 package packagename; 2 import java_cup.runtime.*;... 3 terminal SEMI, PLUS, MINUS; 4 terminal Integer NUMBER; 5 non terminal Integer expr;... 6 expr::= NUMBER:n {: RESULT=n; :} 7 expr:l PLUS expr:r {: RESULT=(l+r); :} 9 expr:l MINUS expr:r {: RESULT=(l-r); :} 10 ; Codebeispiel 3: CUP Die Zuordnung zum zugehörigen Paket, sowie die Importe von Klassen und Paketen sind genauso gehalten wie in Java. Im Programm sind vor allem die Deklaration der Terminale und Nonterminale, sowie die Definition der Produktionen typisch. Bei der Deklaration der (Non-)Terminale können Java- Typenbezeichnungen vor dem Namen des (Non-)Terminals stehen (siehe Zeilen 4, 5). Das Nonterminal expr ist beispielsweise vom Wert Integer (siehe Zeile 5). Typenbezeichnungen für Terminale und Nonterminale sind aber nicht zwingend notwendig (siehe Zeile 3). In der Grammatik ist die Definition für jedes Nonterminal nach dem Muster beispiel::= BSP1:i1 BSP2:i2... {: //Action :}... ; aufgebaut. Im Folgenden wird die linke und rechte Seite, wie sie im Muster zu sehen ist, als LeftHandSide(LHS), beziehungsweise RightHandSide(RHS) bezeichnet. Die LeftHandSide (LHS) enthält das zu spezifizierende Nonterminal. Die Right- HandSide(RHS) ist wie folgt aufgebaut: Eine RHS kann durch mehrere mögliche Varianten repräsentiert werden (siehe Zeilen 6-10). Diese Varianten werden durch getrennt. Für jedes Terminal oder Nonterminal, das in der RHS auftritt, können Labels vergeben werden, also zum Beispiel n bei NUMBER. Mithilfe des Labels kann in den semantischen Aktionen beim Abarbeiten einer Regel auf den Inhalt des Terminals oder Nonterminals zugegriffen werden. Die semantischen Aktionen entsprechen Java-Code und sind von Doppelpunkten und geschweiften Klammern umgeben. Über die Variable RESULT wird das Ergebnis, auf das eine Regel reduziert wird, zurückgeliefert. RESULT ist immer vom selben Typ wie 12

13 das entsprechende Nonterminal auf der LeftHandSide. In dem behandelten Beispiel ist RESULT (siehe Zeilen 6-9) daher vom Typ Integer, da das nonterminal expr auf der LHS ebenfalls den Typ Integer hat. Das Nonterminal expr repräsentiert mehrere Ausdrücke. Eine einzelne Zahl (NUMBER:n) ist zum Beispiel ein gültiger Ausdruck. Ebenso möglich sind Additionen (expr:l PLUS expr:r), Subtraktionen (expr:l MINUS expr:r) oder eine Schachtelung dieser Ausdrücke. Semantische Aktionen sind optional, das heißt, die folgende Grammatik ohne semantische Aktionen für das Beispiel wäre wie folgt: expr ::= NUMBER expr PLUS expr expr MINUS expr ; Das Nonterminal auf der LeftHandSide kann auch in der RightHandSide rekursiv als Bestandteil einer oder mehrerer Varianten auftreten. Bei der Eingabe 1-5 greift zum Beispiel zunächst die Regel expr:l MINUS expr:r. Für expr:l und expr:r muss jeweils erneut eine passende Variante von expr ausgewählt werden, was in diesem Fall zweimal NUMBER:n ist. Abbildung 4: Beispielbaum(1) 13

14 Abbildung 5: Beispielbaum(2) Wenn Regeln für den Parser nicht völlig eindeutig definiert sind, kann es zu sogenannten Shift/Reduce- beziehungsweise Reduce/Reduce-Konflikten kommen. Häufig tritt der Shift/Reduce-Konflikt zum Beispiel im Zusammenhang mit geschachtelten if-then-else-anweisungen auf, wenn unklar ist, welches else zu welchem if gehört. Auch wenn man das expr-beispiel um die Funktion Multiplikation erweitern würde, tritt ein solcher Konflikt auf. Bei der Eingabe 4*2+3 kann der Parser dann nicht erkennen, welche Regel zuerst greifen soll (expr PLUS expr oder expr TIMES expr). Es entsteht ein Shift/Reduce-Conflict, der mit Hilfe von sogenannten precedences gelöst werden kann. Um beispielsweise der Multiplikation eine höhere Priorität als der Addition und Subtraktion zu geben, schreibt man: precedence left PLUS; precedence left MINUS; precedence left TIMES; Hier ist die Reihenfolge der Auflistung von Bedeutung. Der untersten Zeile wird hierbei die höchste Prioriät zugewiesen. Die Festlegung der precedences erfolgt in der CUP-Datei nach der Deklaration der Terminals und Nonterminals. Neben dem Shift/Reduce-Conflict, gibt es außerdem den Reduce/Reduce- Conflict. Dieser Konflikt entsteht, wenn für ein und dasselbe Token zwei Regeln angewendet werden können. Der Scanner weiß in einem solchen Fall nicht, mit welcher Regel er den Ausdruck auf ein Ergebnis reduzieren soll. Bei der Auswertung der Tokenfolgen im Parser, gibt es generell zwei unterschiedliche Herangehensweisen. Man kann, wie im Beispiel, die Ausdrücke 14

15 direkt auswerten. Das funktioniert bei Beispiel-Projekten kleineren Umfangs recht gut, ist aber bei komplexeren Aufgaben nicht üblich. Die bessere und elegantere Form der Auswertung ist es, vom Parser einen Syntaxbaum erstellen zu lassen. Dafür müssen entsprechende Klassen definiert werden, die den Syntaxbaum abbilden. Bei der Auswertung der Tokens werden dann vom Parser Objekte dieser Token-Klassen erstellt und in den Syntaxbaum eingetragen. Im Kapitel 5 wird ein Projekt erläutert, in dem diese Vorgehensweise angewendet wurde. 4 Demoprojekt Das Ziel meines Projektes ist die Generierung eines Scanners und eines Parsers zur Auswertung arithmetischer Ausdrücke. Auf dieser Grundlage soll schließlich eine grafische Darstellung der eingegebenen arithmetischen Ausdrücke realisiert werden. Um komplexe arithmetische Ausdrücke, das heißt Ausdrücke mit Variablen, auswerten zu können, soll vom Parser eine baumartige Struktur erstellt werden. So kann beispielsweise die unterschiedliche Priorität von Multiplikation und Addition berücksichtigt werden. Abbildung 6: Beispiel für einen Baum 15

16 Die Erstellung eines Syntaxbaumes wird dadurch erreicht, dass im Action-Code über Result jeweils Instanzen von entsprechenden Klassen zurückgegeben werden. Die Tokenklassen Add, Mult, Div aus dem Beispielbaum (siehe Abbildung 6) sind Teil der Klassenhierarchie, wie sie in Abbildung 7 dargestellt ist. terminal Integer NUMBER; non terminal Expr expr; expr ::= NUMBER:n {: RESULT=new Const(n); :} expr:l PLUS expr:r {: RESULT=new Add(l,r)); :} expr:l MINUS expr:r {: RESULT=new Sub(l,r)); :} ; Add und Sub sind Klassen, die von der abstrakten Klasse Expr erben. Der Typ des Nonterminals expr ist Expr. Im Gegensatz zur Vorgehensweise der direkten Auswertung ist mit der Erstellung eines Syntaxbaumes auch der Umgang mit Variablen problemlos möglich. Eine Variable wird über RESULT=new Ident(String i) in den Baum eingetragen. Abbildung 7: Überblick über das Demoprojekt Als Grundlage für eine graphische Darstellung einer Funktion dient die Auswertung des Ausdrucks mit vielen verschiedenen x-werten. Diese Auswertung findet in der Klasse Evaluator (siehe Abbildung 7) statt, die dafür die Main-Methode des Parsers aufruft und den fertigen Syntaxbaum vom Parser anfordert. Im Evaluator wird außerdem überprüft, ob es sich um eine einfache Berechnung handelt oder ob eine Variable enthalten ist: Pattern p = Pattern.compile(".*?([A-Za-z][A-Za-z0-9]*).*"); String string = expr.intostring(); Matcher m; boolean b = false; 16

17 m = p.matcher(string); b = m.matches(); Zusammengefasst wird mit dem Demoprojekt für eingegebene arithmetische Ausdrücke eine entsprechende graphische Darstellung erstellt. 5 Schluss Reguläre Ausdrücke in Java werden gern vermieden, da sie schnell zu komplex und fehleranfällig werden können. Es entsteht viel Code, der ungünstig zu ändern und zu warten ist. Die Verwendung von CUP und JFlex ist im Vergleich zu einer Implementierung in Java mit Pattern, Matcher und If-Anweisungen eine wesentlich elegantere Variante. Man erreicht eine vergleichsweise gute Übersichtlichkeit. Nachträgliche Änderungen sind leichter zu ergänzen und für Außenstehende ist die Logik des Programms verständlicher. Literatur [1] Lesson: Regular Expressions, [2] Andrew W. Appel. Modern Compiler Implementation in Java, [3] Scott E. Hudson. CUP User s Manual, [4] Gerwin Klein. JFlex User s Manual, [5] Martin Knobloch. JLex & CUP. berlin.de/ kunert/lehre/ss2003-compilergeneratoren/ JLex CUP/JLex CUP-short.pdf. [6] Sun Microsystems. Java API,