diff --git a/src/Parser.java b/src/Parser.java
index 3ed712932826d1928422376f4b977d8879db25a1..ed584c4e8046e6fcffc6c80af8ab8ed26d5a2219 100644
--- a/src/Parser.java
+++ b/src/Parser.java
@@ -4,36 +4,42 @@ import java.util.List;
public class Parser {
private abstract class Expression {
-
+ boolean capsuled;
+ public Expression(boolean capsuled) {
+ this.capsuled = capsuled;
+ }
}
private class BinaryOperation extends Expression {
Expression leftExpression;
String operator;
Expression rightExpression;
- Boolean capseled;
- public BinaryOperation(Expression leftExpression, String operator, Expression rightExpression, Boolean capseled) {
+ public BinaryOperation(Expression leftExpression, String operator, Expression rightExpression, boolean capsuled) {
+ super(capsuled);
this.leftExpression = leftExpression;
this.operator = operator;
this.rightExpression = rightExpression;
- this.capseled = capseled;
}
}
private class Variable extends Expression {
String variableName;
- public Variable(String i) {
+ public Variable(String i, Boolean capsuled) {
+ super(capsuled);
this.variableName = i;
}
}
private abstract class Value extends Expression {
-
+ public Value(boolean capsuled) {
+ super(capsuled);
+ }
}
private class Number extends Value {
public String digits;
- public Number(String i) {
+ public Number(String i, boolean capsuled) {
+ super(capsuled);
this.digits = i;
}
}
@@ -42,7 +48,8 @@ public class Parser {
public Number beforeDot;
public Number afterDot;
- public Decimal(Number i1, Number i2) {
+ public Decimal(Number i1, Number i2, boolean capsuled) {
+ super(capsuled);
this.beforeDot = i1;
this.afterDot = i2;
}
@@ -59,7 +66,7 @@ public class Parser {
Expression ast = parseExpression(ts);
if(!ts.isEmpty()) {
- throw new ParserException("RuntimeError: " + ts.size() + " token(s) left");
+ throw new ParserException("SyntaxError: " + ts.size() + " token(s) left");
}
return ast;
}
@@ -70,22 +77,21 @@ public class Parser {
if(ts.isEmpty()) {
throw new ParserException("SyntaxError: empty token list");
}
- Expression ast;
- ast = parseBinaryOperation(ts);
- if(ast==null) {
- ast = parseVariable(ts);
+ Expression ast = parseBinaryOperation(ts);
if(ast==null) {
- ast = parseValue(ts);
- }
- if(ast==null) {
- throw new ParserException("SyntaxError: invalid character");
+ ast = parseVariable(ts);
+ if(ast==null) {
+ ast = parseValue(ts);
+ }
+ if(ast==null) {
+ throw new ParserException("SyntaxError: invalid character");
+ }
}
- }
return ast;
}
//checks if a String only contains an allowed operator with parseCharacter(...)
- private Boolean parseOperator(String operator) throws ParserException {
+ private boolean parseOperator(String operator) throws ParserException {
if(operator.length()>1) {
throw new ParserException("SyntaxError: invalid length for an operator: " + operator);
}
@@ -95,6 +101,35 @@ public class Parser {
return true;
}
+ private int parseBrackets(List<Lexer.Token> ts) throws ParserException{
+ if(parseCharacter(ts.get(0).getData(), "(")) {
+ int index;
+ int lBrackets = 0;
+ int rBrackets = 0;
+ boolean found = false;
+ for(index=1; index<ts.size(); index++) {
+ if(parseCharacter(ts.get(index).getData(), "(")) {
+ lBrackets += 1;
+ }
+ else if(parseCharacter(ts.get(index).getData(), ")")) {
+ rBrackets += 1;
+ if(rBrackets>lBrackets) {
+ found = true;
+ break;
+ }
+ }
+ }
+ if(!found) {
+ throw new ParserException("SyntaxError: brackets never got closed");
+ }
+ if(index==1) {
+ throw new ParserException("SyntaxError: no value inside brackets");
+ }
+ return index;
+ }
+ return -1;
+ }
+
private BinaryOperation parseBinaryOperation(List<Lexer.Token> ts) throws ParserException {
if(ts.isEmpty()) {
throw new ParserException("SyntaxError: empty token list");
@@ -102,26 +137,32 @@ public class Parser {
if(ts.size()==1) {
return null;
}
- int index;
- for(index=0; index<ts.size(); index++) {
- if(ts.get(index).getType()== Lexer.TokenType.SPECIAL) {
- if(!parseCharacter(ts.get(index).getData(), ".")) {
- break;
- }
- }
+ int index = 0;
+ int tokensInBracket = parseBrackets(ts);
+ boolean capsuled;
+ if(tokensInBracket+1==ts.size()) {
+ ts.remove(tokensInBracket);
+ ts.remove(0);
+ capsuled = true;
+ index = 1;
}
- if(index==ts.size()) {
- return null;
+ else if (tokensInBracket==-1) {
+ capsuled = false;
+ parseOperator(ts.get(1).getData());
+ index = 1;
+ }
+ else {
+ capsuled = false;
+ index = tokensInBracket+1;
}
List<Lexer.Token> leftList = new LinkedList<>();
- for(int i=0; i<index; i++) {
+ for(int iterator = 0; iterator<index; iterator++) {
leftList.add(ts.remove(0));
}
Expression leftExpression = parseExpression(leftList);
String operator = ts.remove(0).getData();
- parseOperator(operator);
Expression rightExpression = parseExpression(ts);
- return new BinaryOperation(leftExpression, operator, rightExpression, false);
+ return new BinaryOperation(leftExpression, operator, rightExpression, capsuled);
}
private Variable parseVariable(List<Lexer.Token> ts) throws ParserException {
@@ -140,7 +181,7 @@ public class Parser {
if(!parseCharacter(data,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")) {
throw new ParserException("Invalid variable character: " + data);
}
- return new Variable(data);
+ return new Variable(data, false);
}
//called by method parseException(...)
@@ -187,7 +228,7 @@ public class Parser {
ts.remove(0);
data = ts.remove(0).getData();
Number afterDot = (Number) parseNumber(data);
- return new Decimal(beforeDot, afterDot);
+ return new Decimal(beforeDot, afterDot, false);
}
//called by method parseValue(...)
@@ -198,12 +239,12 @@ public class Parser {
}
if (data.startsWith("0") && data.length() == 1) {
- return new Number(data);
+ return new Number(data, false);
}
parseDigitWithoutZero(data.substring(0,1));
parseDigit(data.substring(1));
- return new Number(data);
+ return new Number(data, false);
}
//called by method parseNumber(...)
@@ -228,7 +269,7 @@ public class Parser {
}
}
- private Boolean parseComma(List<Lexer.Token> ts) throws ParserException {
+ private boolean parseComma(List<Lexer.Token> ts) throws ParserException {
String data = ts.get(1).getData();
if(parseCharacter(data, ".")) {
if(ts.get(2).getType()!= Lexer.TokenType.NUMBER) {
@@ -239,19 +280,9 @@ public class Parser {
return false;
}
- private Boolean parseBracket(List<Lexer.Token> ts) throws ParserException {
- String data = ts.get(0).getData();
- if(parseCharacter(data, "(")) {
- return true;
- }
- else {
- return false;
- }
- }
-
//called by methods parseOperator(...), parseDigit(...), parseDigitWithoutZero(...)
//checks if a certain string can be found in a string of allowed character
- private Boolean parseCharacter(String data, String allowedCharacters) throws ParserException {
+ private boolean parseCharacter(String data, String allowedCharacters) throws ParserException {
if(data.isEmpty()) {
throw new ParserException("RuntimeError: empty String");
}