Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- compilerbau:erweiterung:start [2021/10/28 21:23] – [Erweiterung des Lexers] Martin Pabst
+++ compilerbau:erweiterung:start [2021/10/28 21:30] – [Test des Parsers] Martin Pabst
@@ Zeile 196: / Zeile 196: @@
   * naechsteAnweisung: Die Anweisung, die auf die Zuweisung folgt.
+===== Erweiterung des Parsers =====
+Die Klasse Parser wird um Methoden zum Parsen von
+  * einer Aussage
+  * einer Wiederholung
+  * einer Zuweisung
+  * einer Print-Anweisung
+  * einer Anweisung (d.h. eine beliebige der drei vorhergehenden)
+  * einer Sequenz (d.h. einer beliebig langen Abfolge von Anweisungen)
+erweitert:
+<code java>
+public class Parser {
+...
+	/**
+	 * Parst die dem Konstruktor übergebene Liste von Tokens und gibt einen
+	 * Parse-Baum (Abstract Syntax Tree) zurück.
+	 *
+	 * @return Parse-Baum (Abstract Syntax Tree)
+	 *             Falls die Liste der Tokens nicht der Syntax entspricht
+	 */
+  	public Knoten parse() {
+    		wurzel = sequenz();
+    		return wurzel;
+  	}
+	/**
+	 * Parst eine Reihe von Anweisungen.
+	 *
+	 * @return
+	 */
+  	private Knoten sequenz() {
+    		Knoten knoten = null;
+    		Knoten ersteAnweisung = null;
+    		do {
+      			Knoten letzterKnoten = knoten;
+      			knoten = anweisung();
+      			if(letzterKnoten != null) {
+        				letzterKnoten.setNaechsteAnweisung(knoten);
+        				if(ersteAnweisung == null) {
+          					ersteAnweisung = letzterKnoten;
+        				}
+      			}
+    		} while(knoten != null);
+    		return ersteAnweisung;
+  	}
+	/**
+	 * Parst eine Anweisung, d.h. eine Wiederholung, eine Print-Anweisung oder
+	 * eine Zuweisung.
+	 *
+	 * @return
+	 */
+  	private Knoten anweisung() {
+    		if(peek() == null) {
+      			return null;
+    		}
+		/**
+		 * Eine Anweisung beginnt mit whileKeyword, printKeyword oder text:
+		 */
+    		switch(peek()) {
+       		case whileKeyword :
+         			return wiederholung();
+       		case printKeyword :
+         			return parsePrint();
+       		case text :
+         			return zuweisung();
+       		default :
+         			return null;
+    		}
+  	}
+	/**
+	 * Die Methode geht davon aus, dass das nächste Token vom Typ printKeyword
+	 * ist.
+	 *
+	 * @return
+	 */
+  	private Knoten parsePrint() {
+    		Knoten knoten = new Knoten(erwarte(TokenType.printKeyword));
+    		erwarte(TokenType.klammerAuf);
+    		Knoten aussage = aussage();
+    		erwarte(TokenType.klammerZu);
+    		erwarte(TokenType.strichpunkt);
+    		knoten.setLinks(aussage);
+    		return knoten;
+  	}
+	/**
+	 * Die Methode geht davon aus, dass das nächste Token vom Typ whileKeyword
+	 * ist.
+	 *
+	 * @return
+	 */
+  	private Knoten wiederholung() {
+    		Knoten knoten = new Knoten(erwarte(TokenType.whileKeyword));
+    		erwarte(TokenType.klammerAuf);
+    		Knoten aussage = aussage();
+    		erwarte(TokenType.klammerZu);
+    		erwarte(TokenType.geschweifteKlammerAuf);
+    		Knoten anweisungen = sequenz();
+    		erwarte(TokenType.geschweifteKlammerZu);
+    		knoten.setLinks(aussage);
+    		knoten.setRechts(anweisungen);
+    		return knoten;
+  	}
+	/**
+	 * Die Methode geht davon aus, dass das nächste Token vom Typ text ist.
+	 *
+	 * @return
+	 */
+  	private Knoten zuweisung() {
+    		Knoten linkeSeite = new Knoten(nextToken());
+    		Knoten knoten = new Knoten(erwarte(TokenType.zuweisung));
+    		Knoten rechteSeite = aussage();
+    		erwarte(TokenType.strichpunkt);
+    		knoten.setLinks(linkeSeite);
+    		knoten.setRechts(rechteSeite);
+    		return knoten;
+  	}
+	/**
+	 * Versucht, eine Aussage im Programmtext zu parsen. Weiteres: siehe Methode
+	 * SummeDifferenz.
+	 *
+	 * @return Geparster Teilbaum
+	 */
+  	private Knoten aussage() {
+    		Knoten linkerOperand = summeDifferenz(); // Versuche, eine
+													// Summe/Differenz zu finden
+    		while(peek() == TokenType.identisch || peek() == TokenType.ungleich
+        				|| peek() == TokenType.kleiner || peek() == TokenType.groesser
+        				|| peek() == TokenType.kleinergleich
+        				|| peek() == TokenType.groessergleich) {
+      			Token operator = nextToken();
+      			Knoten rechterOperand = summeDifferenz();
+      			Knoten neuerKnoten = new Knoten(operator, linkerOperand,
+       					rechterOperand);
+      			linkerOperand = neuerKnoten;
+    		}
+    		return linkerOperand;
+  	}
+...
+}
+</code>
+Ansonsten muss nichts am Parser geändert werden.
+===== Test des Parsers =====
+Der Parser lässt sich wieder mit der Klasse ''ParserTest'' testen. Den Programmtext oben konvertiert er in folgenden Baum:
+<code>
+Eingabetext:
+a = 1;
+b = 2;
+while(a < 10){
+  a = a + 1;
+  b = b * 2;
+  print(b);
+}
+Tokens:
+text[a] zuweisung zahl[1.0] strichpunkt text[b] zuweisung zahl[2.0] strichpunkt whileKeyword klammerAuf text[a] kleiner zahl[10.0] klammerZu geschweifteKlammerAuf text[a] zuweisung text[a] plus zahl[1.0] strichpunkt text[b] zuweisung text[b] mal zahl[2.0] strichpunkt printKeyword klammerAuf text[b] klammerZu strichpunkt geschweifteKlammerZu
+Syntaxbaum (AST):
+zuweisung
+   l:text[a]
+   r:zahl[1.0]
+   n:zuweisung
+      l:text[b]
+      r:zahl[2.0]
+      n:whileKeyword
+         l:kleiner
+            l:text[a]
+            r:zahl[10.0]
+         r:zuweisung
+            l:text[a]
+            r:plus
+               l:text[a]
+               r:zahl[1.0]
+            n:zuweisung
+               l:text[b]
+               r:mal
+                  l:text[b]
+                  r:zahl[2.0]
+               n:printKeyword
+                  l:text[b]
+</code>
+Nachfolgend noch in grafischer Form. Die mit "n" bezeichneten Kanten entsprechen dem Wert des Attributs ''naechsteAnweisung'' im Knoten.
+{{ :compilerbau:erweiterung:pasted:20211028-212546.png?700 }}
+===== Erweiterung des Interpreters ======
+===== Mehrere Datentypen =====