parser is now matching to the lexer.java pattern for decimals

expressions.txt

-40.2+3*x
+(5*2-(5^2)+3*(201.01-15))
\ No newline at end of file

src/Application.java

@@ -12,10 +12,10 @@ public class Application {
         List<String> expressions = new LinkedList<>();
         //Reads the file "expressions.txt" and adds its values to a list
         BufferedReader reader;
-        String datapath = "expressions.txt";
+        String dataPath = "expressions.txt";
         try {
             System.out.println("Reading the file...\n");
-            reader = new BufferedReader(new FileReader(datapath));
+            reader = new BufferedReader(new FileReader(dataPath));
             String line = reader.readLine();
             while(line != null) {
                 expressions.add(line);
@@ -39,8 +39,8 @@ public class Application {
             }
             Parser parser = new Parser();
             try {
-                parser.parse(tokens);
-                System.out.println();
+                Parser.Expression exp = parser.parse(tokens);
+                System.out.println(exp.toString());
             }
             catch (ParserException e) {
                 System.out.println(e.getMessage());

src/Lexer.java

@@ -43,14 +43,14 @@ public class Lexer {
             //checks if a character is a digit, then creates a token with one or multiple numbers
             //with TokenType=NUMBER
             if(Character.isDigit(current)) {
-                int endIndex = index+1;
+                int endIndex = index;
                 if(endIndex<input.length()) {
                     while(Character.isDigit(input.charAt(endIndex)) && endIndex<input.length()) {
                         endIndex += 1;
                         if(endIndex==input.length()) {
                             break;
                         }
-                        if(Character.compare(input.charAt(endIndex),'.')==0) {
+                        if(input.charAt(endIndex) == '.') {
                             endIndex+=1;
                         }
                     }

src/Parser.java

@@ -3,10 +3,10 @@ import java.util.List;
 
 public class Parser {
 
-    private abstract class Expression {
-        boolean capsuled;
-        public Expression(boolean capsuled) {
-            this.capsuled = capsuled;
+    public static class Expression {
+        @Override
+        public String toString() {
+            return "";
         }
     }
 
@@ -14,45 +14,60 @@ public class Parser {
         Expression leftExpression;
         String operator;
         Expression rightExpression;
-        public BinaryOperation(Expression leftExpression, String operator, Expression rightExpression, boolean capsuled) {
-            super(capsuled);
+        Boolean capsuled;
+        public BinaryOperation(Expression leftExpression, String operator, Expression rightExpression, Boolean capsuled) {
             this.leftExpression = leftExpression;
             this.operator = operator;
             this.rightExpression = rightExpression;
+            this.capsuled = capsuled;
+        }
+        @Override
+        public String toString() {
+            if(capsuled) {
+                return "("+ leftExpression.toString() + operator + rightExpression.toString() + ")";
+            }
+            return leftExpression.toString() + operator + rightExpression.toString();
         }
     }
 
     private class Variable extends Expression {
         String variableName;
         public Variable(String i, Boolean capsuled) {
-            super(capsuled);
             this.variableName = i;
         }
+        @Override
+        public String toString() {
+            return variableName;
+        }
     }
 
     private abstract class Value extends Expression {
-        public Value(boolean capsuled) {
-            super(capsuled);
-        }
+
     }
 
     private class Number extends Value {
         public String digits;
-        public Number(String i, boolean capsuled) {
-            super(capsuled);
+        public Number(String i) {
             this.digits = i;
         }
+        @Override
+        public String toString() {
+            return digits;
+        }
     }
 
     private class Decimal extends Value {
         public Number beforeDot;
         public Number afterDot;
 
-        public Decimal(Number i1, Number i2, boolean capsuled) {
-            super(capsuled);
+        public Decimal(Number i1, Number i2) {
             this.beforeDot = i1;
             this.afterDot = i2;
         }
+        @Override
+        public String toString() {
+            return beforeDot.toString() + "." + afterDot.toString();
+        }
     }
 
     //starting method of the parser
@@ -193,64 +208,55 @@ public class Parser {
         if (ts.get(0).getType() != Lexer.TokenType.NUMBER) {
             return null;
         }
-        String data = ts.get(0).getData();
+        String data = ts.remove(0).getData();
         if (data.isEmpty()) {
             throw new ParserException("SyntaxError: empty token");
         }
 
-        Value value = null;
-        if (ts.size()>1) {
-            //if the next token is of TokenType.SPECIAL, check if it's a comma
-            //if it is, create a decimal
-            if(ts.get(1).getType() == Lexer.TokenType.SPECIAL) {
-                if(parseComma(ts)) {
-                    value = parseDecimal(ts);
-                }
-            }
-        }
-        if(value==null) {
-            value = parseNumber(ts.remove(0).getData());
+        if(data.contains(".")) {
+            return parseDecimal(data);
         }
-        return value;
+        return parseNumber(data, false);
     }
 
     //called by method parseValue(...)
     //parses a decimal of a list of tokens & a string
-    private Decimal parseDecimal(List<Lexer.Token> ts) throws ParserException {
-        String data = ts.remove(0).getData();
+    private Decimal parseDecimal(String data) throws ParserException {
         if(data.isEmpty()) {
             throw new ParserException("SyntaxError: empty data");
         }
-        if(ts.size()==0) {
-            throw new ParserException("SyntaxError: no tokens left to create Decimal");
-        }
-        Number beforeDot = (Number) parseNumber(data);
-        ts.remove(0);
-        data = ts.remove(0).getData();
-        Number afterDot = (Number) parseNumber(data);
-        return new Decimal(beforeDot, afterDot, false);
+        int dot = data.indexOf('.');
+        String number1 = data.substring(0,dot);
+        String number2 = data.substring(dot+1);
+        Number beforeDot = (Number) parseNumber(number1, true);
+        Number afterDot = (Number) parseNumber(number2, false);
+        return new Decimal(beforeDot, afterDot);
     }
 
     //called by method parseValue(...)
     //parses a String into a number
-    private Number parseNumber(String data) throws ParserException{
+    private Number parseNumber(String data, boolean afterDot) throws ParserException{
         if (data.isEmpty()) {
             throw new ParserException("RuntimeException: empty token");
         }
 
         if (data.startsWith("0") && data.length() == 1) {
-            return new Number(data, false);
+            return new Number(data);
         }
-
-        parseDigitWithoutZero(data.substring(0,1));
-        parseDigit(data.substring(1));
-        return new Number(data, false);
+        if(afterDot) {
+            parseDigitWithoutZero(data.substring(0,1));
+            parseDigit(data.substring(1));
+        }
+        else {
+            parseDigit(data);
+        }
+        return new Number(data);
     }
 
     //called by method parseNumber(...)
     //checks if a String only contains numbers(including zero) with parseCharacter(...)
     private void parseDigit(String data) throws ParserException {
-        for(int index=1; index<data.length(); index++) {
+        for(int index=0; index<data.length(); index++) {
             String character = Character.toString(data.charAt(index));
             if(!parseCharacter(character, "0123456789")) {
                 throw new ParserException("SyntaxError: unexpected character: " + character);
@@ -261,7 +267,7 @@ public class Parser {
     //called by method parseNumber(...)
     //checks if a String only contains numbers(excluding zero) with parseCharacter(...)
     private void parseDigitWithoutZero(String data) throws ParserException {
-        for(int index=1; index<data.length(); index++) {
+        for(int index=0; index<data.length(); index++) {
             String character = Character.toString(data.charAt(index));
             if(!parseCharacter(character, "123456789")) {
                 throw new ParserException("SyntaxError: unexpected character: " + character);
@@ -269,17 +275,6 @@ public class Parser {
         }
     }
 
-    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) {
-                throw new ParserException("SyntaxError: no number after comma");
-            }
-            return true;
-        }
-        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 {