📄 parser.java
字号:
return javaCode;
}
/**
* Accessormethode für den Vector mit den sich im Verlauf der
* Kompilierung angesammelten Fehlern und Fehlermeldungen.
*
* @return Vector
*/
public Vector getErrors() {
return errorVector;
}
/**
* Methode dient dem Verhindern von Zuweisungen an die Indexvariable innerhalb
* einer Forschleife. Das ist nämlich gemäß der Definition von
* Ries nicht erlaubt.
*
* @param Token
* @return boolean
*/
private boolean istErlaubterLinkerWert(Token token) {
for (int i = 0; i < forVector.size(); i++) {
if (((Token)forVector.elementAt(i)).toString().equals(token.toString())){
return false;
}
}
return true;
}
/**
* Parst eine Ries-Bedingung und gibt den Java-Code zurück.
*
* @return Java-Code der Bedingung.
* @exception ParserException
*/
private String parseBedingung() throws ParserException {
String ergebnis = ""; // Ergebnis von parseBedingung
/* Der n鋍hste Token wird abgeholt und gepr黤t, ob es sich um eine
* "(" handelt.
* .1: Falls es sich um eine "(" handelt, so kann die Bedingung eine
* logische Verkn黳fung mit "and" bzw. "or" oder ein Vergleich mit
* "<", ">", "<=", ">=", "=", "!=" sein.
* .2: Falls es sich um ein "not" handelt, so kommt eine Negation.
* .3: Ansonsten trat ein Token auf, das hier nicht hingeh鰎t.
*/
aktuellerToken = scanner.getNextToken(); // Token abholen
if (aktuellerToken.equals("(")) { // Token ist (
/* Der Fall .1 trat ein. Er besteht aus den Schritten
* .1-1, .1-2 und .1-3.
*
* .1 : Bedingung mit logischer Verkn黳fung oder Vergleich
* --
* .1-1 : (
* .1-2 : logische Verkn黳fung oder Vergleich
* .1-3 : )
* ----
*/
/* .1-1: "(" ist schon getestet, wird nun geschrieben
*/
ergebnis += "("; // ( in den bisher erstellten Java-Code schreiben
/* .1-2.2 : Es handelt sich um log. Verkn黳fung oder um Vergleich
* ----
* .1-2.1: Falls eine zweite Klammer getoucht wird, so handelt es
* sich um eine logische Verkn黳fung.
* .1-2.2: Ansonsten handelt es sich um einen Vergleich.
*/
if (this.isLogisch()) {
/* Der Fall .1-2.1 trat ein, es handelt sich um eine
* logische Verkn黳fung.
* Eine logische Verkn黳fung ist wie folgt aufgebaut:
* .1-2.1 : logische Verkn黳fung
* ------
* .1-2.1-1: Bedingung
* .1-2.1-2: and bzw. or
* .1-2.1-3: Bedingung
* Wir haben die erste Klammer verarbeitet und uns die Klammer
* der Bedingung angesehen.
*/
/* .1-2.1-1 Es handelt sich um eine Bedingung => parsen
*/
ergebnis += parseBedingung(); // Bed. schreiben
/* .1-2.1-2 : ist abzuarbeiten. Das n鋍hste Token sollte ein
* "and" oder ein "or" sein. Token wird abgeholt.
* --------
* .1-2.1-2.1: "and"
* .1-2.1-2.2: "or"
* .1-2.1-2.3: falsches Token
*/
aktuellerToken = scanner.getNextToken(); // Token abholen
if (aktuellerToken.equals("and")) {
/* .1-2.1-2.1: Es handelt sich um ein "and".
*/
ergebnis += " && "; // and schreiben
}
else if (aktuellerToken.equals("or")) {
/* .1-2.1-2.2 Es handelt sich um ein "or".
*/
ergebnis += " || "; // or schreiben
}
else {
/* .1-2.1-2.3 Es handelt sich um ein falsches Token.
*/
throw new ParserException("Schl黶selw鰎ter 'and' oder"
+" 'or' erwartet in Zeile "
+aktuellerToken.getLineNumber(),
aktuellerToken);
} // end .1-2.1-2
/* .1-2.1-3 Es handelt sich um eine Bedingung => parsen
*/
ergebnis += parseBedingung(); // Bedingung schreiben
} // end .1-2.1
else {
/* Der Fall .1-2.2 trat ein, es handelt sich um einen
* Vergleich.
* Ein Vergleich ist wie folgt aufgebaut:
* .1-2.2 : Vergleich
* ------
* .1-2.2-1: Wertausdruck
* .1-2.2-2: "<",">","<=",">=","=","!=",
* .1-2.2-3: Wertausdruck
*/
/* .1-2.2-1: Es handelt sich um einen Wertausdruck => parsen
*/
ergebnis += parseWertausdruck(); // Wertausdr. schreiben
/* .1-2.2-2: Es handelt sich um eine Vergleichsart
* ------
* .1-2.2-2.1: <
* .1-2.2-2.2: >
* .1-2.2-2.3: <=
* .1-2.2-2.4: >=
* .1-2.2-2.5: =
* .1-2.2-2.6: !=
* .1-2.2-2.7: falsches Token
*/
aktuellerToken = scanner.getNextToken(); // Token abholen
if (aktuellerToken.equals("<")) {
/* .1-2.2-2.1 Es handelt sich um ein <
*/
ergebnis += ".lt(";
}
else if (aktuellerToken.equals(">")) {
/* .1-2.2-2.2 Es handelt sich um ein >
*/
ergebnis += ".gt(";
}
else if (aktuellerToken.equals("<=")) {
/* .1-2.2-2.3 Es handelt sich um ein <=
*/
ergebnis += ".le(";
}
else if (aktuellerToken.equals(">=")) {
/* .1-2.2-2.4 Es handelt sich um ein >=
*/
ergebnis += ".ge(";
}
else if (aktuellerToken.equals("=")) {
/* .1-2.2-2.5 Es handelt sich um ein =
*/
ergebnis += ".eq(";
}
else if (aktuellerToken.equals("!=")) {
/* .1-2.2-2.6 Es handelt sich um ein !=
*/
ergebnis += ".ne(";
}
else {
/* .1-2.2-2.7 Es handelt sich um ein falsches Token.
*/
throw new ParserException("Vergleichsoperator erwartet"
+" in Zeile "
+aktuellerToken.getLineNumber(),
aktuellerToken);
} // end .1-2.2-2
/* .1-2.2-3: Es handelt sich um einen Wertausdruck => parsen
*/
ergebnis += parseWertausdruck()+")"; // Wertausdr. schreiben
} // end .1-2.2
/* .1-3 : Es sollte eine ")" folgen.
* .1-3.1 : ")"
* .1-3.2 : falsches Token
*/
aktuellerToken = scanner.getNextToken(); // Token abholen
if (aktuellerToken.equals(")")) { // bei )
/* .1-3.1: Es handelt sich um eine "(".
*/
ergebnis += ")"; // ) schreiben
}
else {
/* .1-3.2: Es handelt sich um ein falsches Token.
*/
throw new ParserException("Zum Abschluss eines" +
" Bedingungsausdrucks ')' erwartet"
+" in Zeile "
+aktuellerToken.getLineNumber(),
aktuellerToken);
} // end .1-3
} // end .1
/* Der Fall .1 trat nicht ein, d.h. es kam am Anfang keine "(".
* Vielleicht ist das Token aber ein not und somit eine Negation.
*
* .2 : Negation
* --
* .2-1: not
* .2-2: (
* .2-3: Bedingung
* .2-4: )
*/
else if (aktuellerToken.equals("not")) {
/* Der Fall .2 trat ein. Es handelt sich um eine Negation.
*/
/* .2-1: not-Token wurde schon abgeholt, wird jetzt geschrieben.
* Die "(" dient dazu, dass alle 黚ersetzten Bedingungen in
* Klammern stehen. Die ")" wird in .2-4 angeh鋘gt.
*/
ergebnis += "(!"; // ! schreiben
/* .2-2 : Es sollte sich um eine "(" handeln
* ----
* .2-2.1: (
* .2-2.2: falsches Token
*/
aktuellerToken = scanner.getNextToken(); // Token abholen
if (aktuellerToken.equals("(")) {
/* Der Fall .2-2.1 trat ein. "(" wird in Java nicht ben鰐igt,
* da jede 黚ersetzte Bedingung in Klammern steht. (.2-1)
*/
}
else {
/* .2-2.2 Es handelt sich um ein falsches Token.
*/
throw new ParserException("Nach 'not' runde Klammer '('"
+" erwartet in Zeile "
+aktuellerToken.getLineNumber(),
aktuellerToken);
} // end .2-2
/* .2-3: Es handelt sich um eine Bedingung.
*/
ergebnis += parseBedingung(); // Bed. schreiben
/* .2-4 : Es sollte sich um eine ")" handeln.
* ----
* .2-4.1: )
* .2-4.2: falsches Token
*/
aktuellerToken = scanner.getNextToken(); // Token abholen
if(aktuellerToken.equals(")")) {
/* Der Fall .2-4.1 trat ein. ")" wird geschrieben, damit
* jede 黚ersetzte Bedingung in Klammern steht.
*/
ergebnis += ")";
}
else {
/* .2-4.2: Es handelt sich um ein falsches Token.
*/
throw new ParserException("Zum Abschluss einer negierten"
+" Bedingung ')' erwartet in Zeile "
+aktuellerToken.getLineNumber(),
aktuellerToken);
} // end .2-4
} // end .2
else {
/* Weder .1 noch .2 trat ein. Damit tritt der Fall .3 ein.
* Es handelt sich um ein falsches Token.
*/
throw new ParserException("Bedingungsausdruck erwartet"
+" in Zeile "
+aktuellerToken.getLineNumber(),
aktuellerToken);
}
return ergebnis; // gebe Java-Code zur點k
} // end parseBedingung
/**
* Parst eine Funktion.
*
* @return Java-Code der Funktion
*/
private String parseFunktion() {
String ergebnis = ""; // Ergebnis von parseFunktion
Vector parameterVector = new Vector(); // Vector mit Parameternamen
/* 躡ersetzungstabellen der Variablen bzw. Arraynamen von
* RiesName -> JavaName
* Dies ist notwendig, um in Ries erlaubte, aber in Java
* reservierte Namen (wie return) verwenden zu k鰊nen.
*/
varTrans = new TransHash("variable");
arrayTrans = new TransHash("array");
/* parseFunktion f鋘gt die IndexOutOfBoundsExceptions ab, die geworfen
* werden, wenn der Scanner keine weiteren Tokens mehr besitzt.
* Werden diese innerhalb einer Funktion geworfen, so gibt es schon
* vor deren Ende keine Tokens mehr. Es folgt eine Fehlermeldung.
* .1: Funktionsanweisung in Ries wird abgearbeitet, bei Fehler .2
* .2: Parser Fehler gefunden.
* .3: W鋒ren⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -