Pascal Interpreter

[dvdlly]

Hallo,
Ich möchte einen interpreter für eine untermenge von pascal schreiben, ich bin jetzt beim recursive descent parser und für die eingabe ( 1 + 2 * (2+3 )) wirft mein code einen parser fehler (selbst erzeugt). Kann mir jemand sagen wo der Fehler ist? Die eingelesene Datei enthält wie gesagt nur die zeile ( 1 + 2 * (2+3 )).

[CODE lang="java" title="Lexer Klasse"]import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Scanner;

public class Lexer {
Scanner scanner;
private HashMap<String,Command> reservedKeywords = new HashMap<>();
BufferedReader reader;
int c;
char currentChar;
int lineNo = 0;
int colNo = 0;

public Lexer(File sourcecode) {
try {
reader = new BufferedReader(new InputStreamReader
(new FileInputStream(sourcecode), StandardCharsets.UTF_8));
scanner = new Scanner(new FileReader(sourcecode));
reservedKeywords.put("VAR", () -> new Token(Type.VARIABLE,"VAR"));
reservedKeywords.put("BEGIN", () -> new Token(Type.BEGIN,"BEGIN"));
reservedKeywords.put("END", () -> new Token(Type.END,"END"));
reservedKeywords.put("PROGRAM", () -> new Token(Type.PROGRAM,"PROGRAM"));
/*
reservedKeywords.put("+", () -> new Token(Type.PLUS,"+"));
reservedKeywords.put("-", () -> new Token(Type.MINUS,"-"));
reservedKeywords.put("*", () -> new Token(Type.MUL,"*"));
reservedKeywords.put("/", () -> new Token(Type.DIV, "/"));

*/
advance();
}
catch (Exception e) {
e.printStackTrace();
}
}

public void advance() {
try {
c = reader.read();
if (c == -1) {
throw new IllegalArgumentException("Error while reading input file in line " + lineNo + " column " + colNo);
}
currentChar = (char) c;
if (currentChar == '\n') {
lineNo++;
colNo = 0;
}
else {
colNo++;
}
}
catch (Exception e) {
e.printStackTrace();
}
}

public void skipWhitespaces() {
while (currentChar == ' ') {
advance();
}
}

public Token parseNumber(){
StringBuilder result = new StringBuilder();
while (Character.isDigit(currentChar)) {
result.append(currentChar);
advance();
}
if (currentChar == '.') {
result.append(currentChar);
advance();
while (Character.isDigit(currentChar)) {
result.append(currentChar);
advance();
}
return new Token(Type.DOUBLE,Double.parseDouble(result.toString()));
}
return new Token(Type.INTEGER,Integer.parseInt(result.toString()));
}

public Token parseAlphabetic() {
StringBuilder result = new StringBuilder();
while (Character.isLetter(currentChar)) {
result.append(currentChar);
advance();
}
if (reservedKeywords.containsKey(result))
return reservedKeywords.get(result).runCommand();
return new Token(Type.VARIABLE,result.toString());
}


public Token nextToken() {
if (currentChar == ' ')
skipWhitespaces();
if (Character.isDigit(currentChar))
return parseNumber();
if (Character.isLetter(currentChar))
return parseAlphabetic();
if (currentChar == '(') {
advance();
return new Token(Type.LPAREN, '(');
}
if (currentChar == ')') {
advance();
return new Token(Type.RPAREN, ')');
}
if (currentChar == '*') {
advance();
return new Token(Type.MUL, '*');
}
if (currentChar == '/') {
advance();
return new Token(Type.DIV, '/');
}
if (currentChar == '+') {
advance();
return new Token(Type.PLUS, '+');
}
if (currentChar == '-') {
advance();
return new Token(Type.MINUS, '-');
}

return new Token(Type.EOF,"");
}
}
[/CODE]
[CODE lang="java" title="Parser Klasse"]import java.io.File;

public class Parser {
private Lexer lexer;
private Token currentToken;
public Parser(File input) {
this.lexer = new Lexer(input);
this.currentToken = lexer.nextToken();
}
public void eat(Type type) {
if (!(currentToken.type == type)) {
throw new IllegalArgumentException("Error parsing input, expected "
+ type + " in line " + lexer.lineNo + " column " + lexer.colNo);
}
currentToken = lexer.nextToken();
}

public AST parseProgram() {
return parseExpression();
}


public AST parseExpression() {
System.out.println("Calling parseExpression() | token : " + currentToken.type + " value : " + currentToken.value);
AST node = parseTerm();
while (currentToken.type == Type.PLUS || currentToken.type == Type.MINUS) {
Token current = currentToken;
if (currentToken.type == Type.PLUS) {
eat(Type.PLUS);
}
if (currentToken.type == Type.MINUS) {
eat(Type.MINUS);
}
node = new BinaryOp(node,parseFactor(),current);
}
return node;
}

public AST parseTerm() {
System.out.println("calling parseTerm() | token type : " + currentToken.type + " value : " + currentToken.value);
AST node = parseFactor();
while (currentToken.type == Type.MUL || currentToken.type == Type.DIV) {
Token current = currentToken;
if (currentToken.type == Type.MUL)
eat(Type.MUL);
if (currentToken.type == Type.DIV)
eat(Type.DIV);
node = new BinaryOp(node,parseFactor(),current);
}
return node;
}

public AST parseFactor() {
System.out.println("calling parseFactor() | token type : " + currentToken.type + " value : " + currentToken.value);
Token token = currentToken;
if (token.type == Type.INTEGER) {
eat(Type.INTEGER);
return new Numerical(token);
}
else if (token.type == Type.LPAREN) {
eat(Type.LPAREN);
AST expression = parseExpression();
eat(Type.RPAREN);
return expression;
}
// TODO: MAYBE TEST IF THIS LINE IS EVER REACHED
return new AST();
}

public static void main(String[] args) {
File sourcecode = new File("/home/max/Developement/Java/PascalInterpreter/pascal.pas");
Parser testparser = new Parser(sourcecode);
Lexer testlexer = new Lexer(sourcecode);
/*
Token current = testlexer.nextToken();
while (current.type != Type.EOF){
System.out.println("Type:"+current.type + " Value:"+current.value);
current = testlexer.nextToken();
}

*/
AST ast = testparser.parseProgram();
ast.print();
}
}
[/CODE]
[CODE lang="java" title="Token Klasse"]enum Type {
VARIABLE,
PLUS,
MINUS,
MUL,
DIV,
INTEGER,
DOUBLE,
BEGIN,
END,
PROGRAM,
SEMI,
DOT,
LPAREN,
RPAREN,
EOF
// TBC...
}

public class Token {
Type type;
Object value;

public Token(Type type, Object value) {
this.type = type;
this.value = value;
}
}
[/CODE]

 

[mihe7]

wirft mein code einen parser fehler (selbst erzeugt)

Der da wäre?

 

[dvdlly]

Hat sich erledigt