From 5a3e3f53e0389c44b993e001a07576290edc2e9f Mon Sep 17 00:00:00 2001
From: niklasBr <104077966+bretzNiklas@users.noreply.github.com>
Date: Wed, 4 Jan 2023 19:19:14 +0100
Subject: [PATCH] Added print while to main to print whole ausdruck
---
Aufgabe4/Ast.java | 17 +-
Aufgabe4/Parser.java | 242 ++++++++++++++++++++++++-----
Aufgabe4/main.java | 53 +++++--
Aufgabe4/test.java | 83 ++++++++++
out/production/inf3_git/main.class | Bin 1419 -> 2976 bytes
5 files changed, 338 insertions(+), 57 deletions(-)
create mode 100644 Aufgabe4/test.java
diff --git a/Aufgabe4/Ast.java b/Aufgabe4/Ast.java
index 1de8c11..b2b3488 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 fe1ccee..57c8728 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 c31295b..935ae50 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 0000000..91a6c9b
--- /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
GIT binary patch
literal 2976
zcmcImS#uOs6#j0uP9_b+gs`a)AYc|?SVScQXb8ashXhRwvWVVHI!TkB?xDK}6F}S*
z_YD>IUECF%3RPff@#2H!kMP|$AFWdSZud-PhT+L7YpQPFd-n64bMD+<|GDrJfEY3n
zl%ZThg^o&83Dg~uM`YBJ_E@xk_>htC1*$fiw&`ybC~s*Usz$ZIoDFL>Hnlaa=i1J7
zorZ`&W!#uF+z4t=u9jIkW@8SOEMrojwI!Z6Jm9;gJr-*XNon7-qMfcQr{bpP$Lbl@
zH9G3iK+iIfFj5R*NlT&dXxdKrrejCD9NSAL4L24+Bj#zCuVVog3N!@1iVX{BqmJ7x
z6XOC+*=PcZQfsY48m^`H-O}|`MvGKNi?CS75;QT<l%fl)EVPnOpf%p<`Q4K#*YG?B
z8LPoEEZ5MiV+B?g0X#6}`9_iuIcetD7{XyX(cOf{CrE}&Qo9AM8rpQUW0k<HBHIGB
z((|{OwsfcZQ{*bwxg%BAAgW=lj&)d1(E^^pY%1o1T*sQ0gx!K0b!@~<0@V~Al2)2Y
zN0eBwr~O;7NkfOuHrh;~97CXn@_p&#u;J3JQV0*!*os><+@_-w+bA}}2@~0Fj+y=*
z=V&&O>~SB}wxe6a4js3nCrl*A6R4-JoFe<dH*8`ldL!70J2b>~>_T6zBZ{$QN2C<e
zmMu`x(yOYzTVQd%Py5oAwcDYD;dW1|Mr1iv(s$_?z#y?uu8oA5l$L<5^30wX@euZC
zxJSoc1x+N+Vko(Qw;60mqsvJqrIO#T<A4&LNvLy_jstc*1P<!B5BCeqPs#}@*$L_I
zG5v8h0=~3;Pheh4Z*O)?g89vknL=V%!H{5&U2P19RHGO=MllxFp+9A~(sx+AprLX{
zW@X}#h6yFgj8#MBcnrIAz?EHFhoic$xZl=Ca2T!zPlt~*M{3ZSFj$7!V}>7W!`KDp
z<_5nwqr-SW$0Vi*dro6;D#iAkMft#hI`UfBiDN4D<5#2}UTrZ|@)In6Qktp<x||W3
zm=iZ`BW&0~Ic$+qA9oVc8j`N5&RJrGKW-BAs<={)DfIW3BG5X-UZm-!0@l^Kiux7O
z9izR5t5{J3nD$28bYg-~@jg{^rNx8$mYRZ-UmXuGD;}$O@uV#d!K?vaCMI^tR1mR-
zlNw$rzJG#yn1Yr}4v)xYl}Ynjwrfj>A@QL<KP-)wrI9`0q}_zE!&KPRD5W)OW@vhw
z<M^KM%G55yA9qH)IaPQ&f_Lz)hWB*5j}HWv<;TmkkI-~99yq6l9F+-n9gA9<EIj>I
z*tA)t&_R#1M=Zl@jyujoIu$DbIotaMlp@8TJN^?hbXn-C)NtVtX1QI`vIb1wh}GdZ
zQTaH62l0uHS8=Kir${&x!RPow!<TBxzY=IJfho)=9Q++Qpick)&}5M;Y|GsAlma-D
zW;MRy|C(4MIHA3^&3nv}o@aO(z86?glHAqGso`AFZCr$Nw(@HJg4$y#0WIUx0VwBX
z$)^n0hj@zeEBLK!I}dS|n=(AiRk4-mBV6@R0FUA^o@#IckCQ@W@h2s!_^qwi;ule~
z_dIHMt!kf!egSpBH0EB!A`-9bTOClRaeYU{IV@dRk--fatj=IV1~+H0C4;VM^q#@i
zj>;?9cV=*RC{d(E^1hIK0rx6bGOsw2!8i$7`6Rvkf`fUsA{4vrD|8#OOWe+ouW)+?
zbvZ{J6=yCtpCy3p=td9v@ezK+&-|7LkoKX0@I`piQOoz+0{)u#Y-;EGr<<>s9xUf|
zyn-ON;S^R;J4*eHw6GSJupWQ$pY?D40cw02L?DCG^gyG|COm;BS<_21JC+1b;iM{|
zsK(Q<Sg=}F^cg(M_?qwsp2PEuq#eKG1=_B_i<DiCs>>u*YIsS*%NlAlEYcVm4ru7_
zIL2j*UKdeA8P=cAjk2IO8i{V(G*V$1xH~e9qxoi<O;2F<5zOVUv7o6M@fu!NQQ{4*
iWjKvD`K{;fEz&+D2A|?Hy7(I3k{;piJDkN2Sokln*cjIU
literal 1419
zcmZuxU2_vv7=BLkakA-RA*E;qYOIP`N{Oabu|c#HD%EXM4W?rKI!Slp!Zw@P-7u{e
z&UopKqa(jTu5~hD24)zp{Y%b>&)IFDEhIC0@_s$<^S<ZV{PW-ahXAT@@)$u%B5fjr
ztiaKm>b5F-s?#plnm3(RB#^!6cHHQaK&oUla>xlBuM}sCbH$nBJkJZo*-EiEGbfQ3
z$k@(~6XaoN%p<H_S3#&9CQ{ma)Wk6q2<16D0#?a>+O8f2Zl_(f5?3#Bz4BrZs9oC)
zqpAitZeju_*rTg41<veMA4;|C#W1?M(+!+3bp1}%z)P5vc-h2BoH{UIeK(ApZIbbO
z9CIRR?E2+(5{XF1QQNGZ!YdL*6R%=g;K%`Nfl(Dkm)(vEc57Wmb?c$Y(%12Z#2FKB
zqQumFF@aq3NmX`JmsKUs(#>BD<@Fo`7S5TN#d!fkh0$7XyXgc((YcAi25;eQiHeCi
z%rostB;j?%ZM)Hi|KlF7p~<p$@t(v56Ypao;Wdm26xeHME%}|u>2Nh-C69~vK;n{#
z5Al(}czkUKS0y03dU0MyAYEFq8WNWi^jg;mROAN+7IDSIRV*h2hkkZ_RtLJ{HQjE7
zSMxlbG_-O*HDP0wduuz<lBdFu+)8^AibWhdx!W2^Z7WxETk^N4o-y0)ILRWftENX!
z!S-9qYpB50_MS5x{ooQbYwO~wz=_i4vs|qPVO7x9-JcUCJ=F`hf?n$u)l22;i<EZ!
zst{68IXOFdQD|l<+@8m+j~x;+@39`K)~!|5jmb%DNHh;BI(~-)@^!x#w47yE&t+)p
z=k<+I!)sic{)~WBkmYloR+*>ZnK^q8;;%UT8J{`~r0_YPW|Dw9uG2D5!x!|hSj;mc
zL*Jc(v>(8@aSx-b4`A|qVQu!@%m8Bpj4!1B#*35bK2G=XTB`C0Rv$Bcl>2yRfa<<j
znz6+`mInBEn4YN&@JYe?6Vv<hGKVqlV&ZARBTOx%?>_!j&ys?krNRk-9IZS?`6o2a
z?-c(U7BI;vPNIp^_=%pMF^%6)!XLO6&pn^ah6Xlbtl#k^mO1$-e!&fV#YK*@W)oi%
oc?!4j4ZcMh-!b<TQjh7%NPI7$Bn$~t(t&@`JVt~Tb4IZBKeP=(!T<mO
--
GitLab