diff --git a/Aufgabe4/Ast.java b/Aufgabe4/Ast.java
index 1de8c119aeddab744c2f9db5db25bcd943618438..b2b34883c6e80cfa9ebb24bf8374b4dd0dde8400 100644
--- a/Aufgabe4/Ast.java
+++ b/Aufgabe4/Ast.java
@@ -1,4 +1,3 @@
-import java.beans.Expression;
import java.util.ArrayList;
public abstract class Ast {
@@ -20,26 +19,29 @@ class AstExpression extends Ast {
class AstBinaryOp extends Ast {
- Ast[] binaryOp = new Ast[3];
+ AstExpression astExpression1;
+ AstExpression astExpression2;
+ AstOperator astOperator;
+
}
class AstValue extends Ast {
AstNumber astNumber;
- AstValue astValue;
+ AstDecimal astDecimal;
boolean isVariable;
}
class AstNumber extends Ast {
- AstDigitWoz astDigitWoz;
+ AstDigitWoZ astDigitWoz;
ArrayList<AstDigit> astDigits = new ArrayList<>();
}
-class AstDigitWoz extends Ast {
+class AstDigitWoZ extends Ast {
int astDigitWozContent;
@@ -47,14 +49,15 @@ class AstDigitWoz extends Ast {
class AstDigit extends Ast {
+ AstDigitWoZ astDigitWoZ;
int astDigit;
}
class AstDecimal extends Ast {
- AstDigit astDigitBeforeComma;
- AstDigit astDigitAfterComma;
+ AstNumber astDigitBeforeComma;
+ AstNumber astDigitAfterComma;
}
diff --git a/Aufgabe4/Parser.java b/Aufgabe4/Parser.java
index fe1ccee59d60883315d71fc3daaa95ded2d8bd1c..57c8728b9eb5caa7491730eb5b610a47755ea61e 100644
--- a/Aufgabe4/Parser.java
+++ b/Aufgabe4/Parser.java
@@ -1,7 +1,6 @@
-import java.io.IOError;
-import java.sql.SQLSyntaxErrorException;
+import java.sql.Array;
+import java.sql.SQLOutput;
import java.util.ArrayList;
-import java.util.Collections;
public class Parser {
@@ -9,80 +8,99 @@ public class Parser {
AstExpression root;
- root = (AstExpression) parseAstExpression(tokenList);
+ root = parseAstExpression(tokenList);
return root;
}
- private Ast parseAstExpression (ArrayList<Token> tokenList) {
+ private AstExpression parseAstExpression (ArrayList<Token> tokenList) {
- if(tokenList.size() == 1) {
- AstValue astValue = new AstValue();
- astValue.astNumber = new AstNumber();
- astValue.astNumber.astDigitWoz = new AstDigitWoz();
+ AstExpression toReturn = new AstExpression();
+
+ // If tokenList contains one item: Expression is a value
+
+
+ boolean isValue = false;
+
+ if(tokenList.size() == 1 ) {
+
+ toReturn.astValue = parseValue(tokenList);
+ //return toReturn;
+ isValue = true;
- astValue.astNumber.astDigitWoz.astDigitWozContent = Integer.parseInt(tokenList.get(0).getTokenString());
- return astValue;
}
- AstExpression astExpression = new AstExpression();
+ for (Token t : tokenList) {
- ArrayList<Token> tokensPos3 = new ArrayList<>();
- tokenList.forEach(token -> {
- if(token != tokenList.get(0) && token != tokenList.get(1)) {
- tokensPos3.add(token);
+ if(t.getTokenString().equals(".")) {
+ isValue = true;
}
- });
- astExpression.astBinaryOp = parseBinaryOp(tokenList.get(0), tokenList.get(1), tokensPos3);
+ if(t.getTokenString().equals("+") || t.getTokenString().equals("-") || t.getTokenString().equals("*") || t.getTokenString().equals("/")) {
+ isValue = false;
+ break;
+ }
- return astExpression;
+ }
- }
- private AstBinaryOp parseBinaryOp (Token expression1, Token operator, ArrayList<Token> expression2) {
+ if(isValue) {
+ toReturn.astValue = parseValue(tokenList);
+ return toReturn;
+ }
+ // If tokenList only contains more than one item: Expression must be expression in brackets or binary operation
+ // ( 3+4 ) * 5
- AstBinaryOp astBinaryOp = new AstBinaryOp();
+ toReturn.astBinaryOp = parseBinaryOp(tokenList);
- AstValue exp1;
+ return toReturn;
- ArrayList<Token> exp1ArrayList = new ArrayList<>();
- exp1ArrayList.add(expression1);
- exp1 = (AstValue) parseAstExpression(exp1ArrayList);
+ }
- astBinaryOp.binaryOp[0] = exp1;
+ private AstBinaryOp parseBinaryOp (ArrayList<Token> tokenList) {
- astBinaryOp.binaryOp[1] = parseOperator(operator);
+ AstBinaryOp toReturn = new AstBinaryOp();
+ int positionOfFirstTopLevelOperator = 0;
+ int numberOfBrackets = 0;
+ int i = 0;
+ String lastBracket = ")";
- // ( 2 + 3 ) + 3
+ for(Token t : tokenList) {
- if (expression2.size() > 2) {
+ if(t.getTokenString().equals("(") || t.getTokenString().equals(")")) {
+ numberOfBrackets++;
+ lastBracket = t.tokenString;
+ }
- astBinaryOp.binaryOp[2] = parseAstExpression(expression2);
+ if( ((t.getTokenString().equals("+") || t.getTokenString().equals("-") || t.getTokenString().equals("*")
+ || t.getTokenString().equals("/")) && (numberOfBrackets % 2 == 0) ) && lastBracket.equals((")") )) {
- } else {
+ positionOfFirstTopLevelOperator = i;
+ break;
- AstValue exp2 = new AstValue();
+ }
+ i++;
- ArrayList<Token> exp2ArrayList = new ArrayList<>();
- exp2ArrayList.add(expression2.get(0));
- exp2 = (AstValue) parseAstExpression(exp2ArrayList);
+ }
- astBinaryOp.binaryOp[2] = exp2;
+ // Make two Token lists before and after the expression, parse each as expression
- }
+ toReturn.astExpression1 = parseAstExpression(new ArrayList<>(tokenList.subList(0, positionOfFirstTopLevelOperator)));
+ toReturn.astOperator = parseOperator(tokenList.get(positionOfFirstTopLevelOperator));
+ toReturn.astExpression2 = parseAstExpression(new ArrayList<>(tokenList.subList(positionOfFirstTopLevelOperator + 1, tokenList.size())));
- return astBinaryOp ;
+
+ return toReturn ;
}
private AstOperator parseOperator (Token operator) {
@@ -93,7 +111,153 @@ public class Parser {
return astOperator;
}
+ private AstValue parseValue (ArrayList<Token> valueTokens) {
+
+ AstValue toReturn = new AstValue();
+
+ boolean containsSpecialToken = false;
+
+ for(Token t : valueTokens) {
+
+ if(t.getTokenType().equals(TokenType.special)) {
+
+ containsSpecialToken = true;
+
+ }
+
+ }
+
+ if(containsSpecialToken) {
+
+ toReturn.astDecimal = parseDecimal(valueTokens);
+
+ } else {
+
+ toReturn.astNumber = parseNumber(valueTokens);
+
+ }
+ return toReturn;
+ }
+
+ private AstDecimal parseDecimal (ArrayList<Token> decimalTokens) {
+
+ AstDecimal toReturn = new AstDecimal();
+
+ int i = 0;
+ int positionOfDecimalPoint = -1;
+
+ for(Token t : decimalTokens) {
+
+ if(t.getTokenType().equals(TokenType.special)) {
+ positionOfDecimalPoint = i;
+ break;
+ }
+
+ i++;
+
+ }
+
+ // parse digits before comma as list and save it into toReturn.before
+
+
+
+ if (positionOfDecimalPoint == 1) {
+
+ ArrayList<Token> temp = new ArrayList<>();
+ temp.add(decimalTokens.get(0));
+ toReturn.astDigitBeforeComma = parseNumber(temp);
+
+ } else {
+
+ toReturn.astDigitBeforeComma = parseNumber(new ArrayList<> (decimalTokens.subList(0, positionOfDecimalPoint - 1)));
+ }
+
+
+ if (positionOfDecimalPoint + 1 - decimalTokens.size() == 0) {
+
+ ArrayList<Token> temp = new ArrayList<>();
+ temp.add(decimalTokens.get(decimalTokens.size() - 1));
+ toReturn.astDigitAfterComma = parseNumber(temp);
+
+ } else {
+
+ toReturn.astDigitAfterComma = parseNumber(new ArrayList<> (decimalTokens.subList(positionOfDecimalPoint + 1, decimalTokens.size())));
+
+ }
+
+
+
+
+ return toReturn;
+ }
+
+ private AstNumber parseNumber (ArrayList<Token> numberTokens) {
+
+ AstNumber toReturn = new AstNumber();
+
+ // take first Token from list and parse as digit without zero
+
+ toReturn.astDigitWoz = parseDigitWoZ(numberTokens.get(0));
+
+ if(numberTokens.size() == 1) {
+ return toReturn;
+ }
+
+ numberTokens.stream()
+ .skip(1)
+ .forEach(token -> {
+ AstDigit temp = parseAstDigit(token);
+ toReturn.astDigits.add(temp);
+ });
+
+ return toReturn;
+ }
+
+ private AstDigitWoZ parseDigitWoZ (Token digitWoZ) {
+
+ AstDigitWoZ toReturn = new AstDigitWoZ();
+
+ int tokenContentAsString;
+
+ try {
+ tokenContentAsString = Integer.parseInt(digitWoZ.tokenString);
+ } catch (NumberFormatException error) {
+ System.out.println("Can't parse string in AstDigitWoZ");
+ throw error;
+ }
+
+
+ toReturn.astDigitWozContent = tokenContentAsString;
+
+ return toReturn;
+ }
+
+ private AstDigit parseAstDigit (Token digit) {
+
+ AstDigit toReturn = new AstDigit();
+
+ int tokenContentAsString;
+
+
+ try {
+ tokenContentAsString = Integer.parseInt(digit.tokenString);
+ } catch (NumberFormatException error) {
+ System.out.println("Can't parse string in AstDigit");
+ throw error;
+ }
+
+
+
+ if(tokenContentAsString == 0) {
+ toReturn.astDigit = 0;
+ return toReturn;
+ }
+
+ toReturn.astDigitWoZ = parseDigitWoZ(digit);
+
+ return toReturn;
+ }
}
diff --git a/Aufgabe4/main.java b/Aufgabe4/main.java
index c31295b9c6bf407a2f92629e1c6b7d76a73bb6bd..935ae503a1c3d0896e2330eea377c7f87ea542d3 100644
--- a/Aufgabe4/main.java
+++ b/Aufgabe4/main.java
@@ -4,35 +4,60 @@ public class main {
public static void main(String[] args){
- // 23, x, +, (,0, 5, x,), ^, 2, -, 1
- String ausdruck = "230lkjhx +(2 5x) ^2,jhff 3−1gf ";
- String ausdruck2 = "0x +(2 5x) ^2−1f ";
+
+ // values above integer space will produce errors
+
+ String ausdruck = "3.5 * 2.5 + 2.1";
Lexer lexer = new Lexer();
+
// [23x] + [0,5x^2 - 1]
- //lexer.lex(ausdruck).forEach(token -> System.out.println(token.getTokenString()));
+ lexer.lex(ausdruck).forEach(token -> {
+ System.out.println(token.getTokenString());
+ System.out.println(token.getTokenType());
+ });
+
Parser p = new Parser();
AstExpression result = p.parse(lexer.lex(ausdruck));
+
+
do {
- System.out.println( ((AstValue) result.astBinaryOp.binaryOp[0]).astNumber.astDigitWoz.astDigitWozContent );
- System.out.println( ((AstOperator) result.astBinaryOp.binaryOp[1]).astOperator );
+ try {
+ System.out.println(result.astBinaryOp.astExpression1.astValue.astNumber.astDigitWoz.astDigitWozContent);
+ } catch (NullPointerException n) {
+
+ System.out.println(result.astBinaryOp.astExpression1.astValue.astDecimal.astDigitBeforeComma.astDigitWoz.astDigitWozContent
+ + "."
+ + result.astBinaryOp.astExpression1.astValue.astDecimal.astDigitAfterComma.astDigitWoz.astDigitWozContent);
+ }
+
+ System.out.println(result.astBinaryOp.astOperator.astOperator);
+
+ if(result.astBinaryOp.astExpression2.astValue != null) {
+
+ try {
+ System.out.println(result.astBinaryOp.astExpression2.astValue.astNumber.astDigitWoz.astDigitWozContent);
+ } catch (NullPointerException n) {
+
+ System.out.println(result.astBinaryOp.astExpression2.astValue.astDecimal.astDigitBeforeComma.astDigitWoz.astDigitWozContent
+ + "."
+ + result.astBinaryOp.astExpression2.astValue.astDecimal.astDigitAfterComma.astDigitWoz.astDigitWozContent);
+ }
- if(result.astBinaryOp.binaryOp[2].getClass() == AstValue.class) {
- System.out.println( ((AstValue) result.astBinaryOp.binaryOp[2]).astNumber.astDigitWoz.astDigitWozContent );
break;
} else {
- result = (AstExpression) result.astBinaryOp.binaryOp[2];
+ result = result.astBinaryOp.astExpression2;
}
@@ -40,7 +65,6 @@ public class main {
} while ( true );
-
/*
System.out.println( ((AstValue) result.astBinaryOp.binaryOp[0]).astNumber.astDigitWoz.astDigitWozContent );
@@ -71,5 +95,12 @@ public class main {
*/
}
-}
+ /*
+ void printAst (AstExpression astE) {
+ if(astE.)
+
+ }
+
+ */
+}
diff --git a/Aufgabe4/test.java b/Aufgabe4/test.java
new file mode 100644
index 0000000000000000000000000000000000000000..91a6c9baaebc9562e69919247e4a9dc7e71da76d
--- /dev/null
+++ b/Aufgabe4/test.java
@@ -0,0 +1,83 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class test {
+ public static void main(String[] args) {
+
+ String ausdruck = "((3 * 5 * ( 4 + 3)) + ((5 + 4 ( 4*4 )) + 4))";
+
+ Lexer lexer = new Lexer();
+
+
+ // [23x] + [0,5x^2 - 1]
+
+
+
+
+
+ Parser p = new Parser();
+
+ ArrayList<Token> tokenList = lexer.lex(ausdruck);
+
+
+ int positionOfFirstOperator = 0;
+ int numberOfBrackets = 0;
+ int i = 0;
+ String lastBracket = ")";
+
+ for(Token t : tokenList) {
+
+ if(t.getTokenString().equals("(") || t.getTokenString().equals(")")) {
+ numberOfBrackets++;
+ lastBracket = t.tokenString;
+ }
+
+ if( ((t.getTokenString().equals("+") || t.getTokenString().equals("-") || t.getTokenString().equals("*")
+ || t.getTokenString().equals("/")) && (numberOfBrackets % 2 == 0) ) && lastBracket.equals((")") )) {
+
+ positionOfFirstOperator = i;
+ break;
+
+ }
+ i++;
+
+ }
+
+ int j = 0;
+
+ System.out.println(positionOfFirstOperator);
+
+ for(Token t : tokenList) {
+ System.out.print(t.getTokenString() + " index=");
+ System.out.println(j);
+ j++;
+ }
+
+
+
+ List<Token> davor;
+
+ List<Token> danach;
+
+ davor = tokenList.subList(0, positionOfFirstOperator);
+ danach = tokenList.subList(positionOfFirstOperator + 1 , tokenList.size());
+
+
+ for(Token t : davor) {
+ System.out.println(t.getTokenString());
+ }
+
+ System.out.println("---------------------------------");
+
+ for(Token t : danach) {
+ System.out.println(t.getTokenString());
+ }
+
+
+
+
+
+ }
+}
+
diff --git a/out/production/inf3_git/main.class b/out/production/inf3_git/main.class
index 34f015961d234aada263f437f97ce1152c741a42..a8d74f180113e2cc6f580bdfdbf5bb8c5d6f4518 100644
Binary files a/out/production/inf3_git/main.class and b/out/production/inf3_git/main.class differ