parser can finally treat the brackets correctly

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");
         }