From 71dd7c60daf4699af1f76c9ef0365084819d9a87 Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Wed, 22 Sep 2021 01:04:08 +1000 Subject: [PATCH 1/8] started on lexical analyser --- .../src/com/company/LexicalAnalyser.java | 175 ++++++++++-------- 1 file changed, 94 insertions(+), 81 deletions(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index 814b4d6..f13407e 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -1,93 +1,106 @@ package com.company; -import java.util.ArrayList; + import java.util.List; import java.util.Optional; import java.util.Collections; +import java.util.ArrayList; public class LexicalAnalyser { - public static List analyse(String sourceCode) throws LexicalException { - //Turn the input String into a list of Tokens! - return Collections.emptyList(); - } - - private static Optional tokenFromString(String t) { - Optional type = tokenTypeOf(t); - if (type.isPresent()) - return Optional.of(new Token(type.get(), t)); - return Optional.empty(); - } + public static List analyse(String sourceCode) throws LexicalException { + //Turn the input String into a list of Tokens! + ArrayList ARList = new ArrayList(); + String[] inputString = sourceCode.split(" "); - private static Optional tokenTypeOf(String t) { - switch (t) { - case "public": - return Optional.of(Token.TokenType.PUBLIC); - case "class": - return Optional.of(Token.TokenType.CLASS); - case "static": - return Optional.of(Token.TokenType.STATIC); - case "main": - return Optional.of(Token.TokenType.MAIN); - case "{": - return Optional.of(Token.TokenType.LBRACE); - case "void": - return Optional.of(Token.TokenType.VOID); - case "(": - return Optional.of(Token.TokenType.LPAREN); - case "String[]": - return Optional.of(Token.TokenType.STRINGARR); - case "args": - return Optional.of(Token.TokenType.ARGS); - case ")": - return Optional.of(Token.TokenType.RPAREN); - case "int": - case "char": - case "boolean": - return Optional.of(Token.TokenType.TYPE); - case "=": - return Optional.of(Token.TokenType.ASSIGN); - case ";": - return Optional.of(Token.TokenType.SEMICOLON); - case "if": - return Optional.of(Token.TokenType.IF); - case "for": - return Optional.of(Token.TokenType.FOR); - case "while": - return Optional.of(Token.TokenType.WHILE); - case "==": - return Optional.of(Token.TokenType.EQUAL); - case "+": - return Optional.of(Token.TokenType.PLUS); - case "-": - return Optional.of(Token.TokenType.MINUS); - case "*": - return Optional.of(Token.TokenType.TIMES); - case "/": - return Optional.of(Token.TokenType.DIVIDE); - case "%": - return Optional.of(Token.TokenType.MOD); - case "}": - return Optional.of(Token.TokenType.RBRACE); - case "else": - return Optional.of(Token.TokenType.ELSE); - case "System.out.println": - return Optional.of(Token.TokenType.PRINT); - case "||": - return Optional.of(Token.TokenType.OR); - case "&&": - return Optional.of(Token.TokenType.AND); - case "true": - return Optional.of(Token.TokenType.TRUE); - case "false": - return Optional.of(Token.TokenType.FALSE); + for(String input : inputString){ + //Optional inputToken = tokenFromString(input); + //if (inputToken != Optional.empty()){ + // Token validToken = Token(input); + // ARList.add(Token); + //} + addToken = new Token(); } - if (t.matches("\\d+")) - return Optional.of(Token.TokenType.NUM); - if (Character.isAlphabetic(t.charAt(0)) && t.matches("[\\d|\\w]+")) { - return Optional.of(Token.TokenType.ID); - } - return Optional.empty(); - } + return ARList; + } + + private static Optional tokenFromString(String t) { + Optional type = tokenTypeOf(t); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } + + private static Optional tokenTypeOf(String t) { + switch (t) { + case "public": + return Optional.of(Token.TokenType.PUBLIC); + case "class": + return Optional.of(Token.TokenType.CLASS); + case "static": + return Optional.of(Token.TokenType.STATIC); + case "main": + return Optional.of(Token.TokenType.MAIN); + case "{": + return Optional.of(Token.TokenType.LBRACE); + case "void": + return Optional.of(Token.TokenType.VOID); + case "(": + return Optional.of(Token.TokenType.LPAREN); + case "String[]": + return Optional.of(Token.TokenType.STRINGARR); + case "args": + return Optional.of(Token.TokenType.ARGS); + case ")": + return Optional.of(Token.TokenType.RPAREN); + case "int": + case "char": + case "boolean": + return Optional.of(Token.TokenType.TYPE); + case "=": + return Optional.of(Token.TokenType.ASSIGN); + case ";": + return Optional.of(Token.TokenType.SEMICOLON); + case "if": + return Optional.of(Token.TokenType.IF); + case "for": + return Optional.of(Token.TokenType.FOR); + case "while": + return Optional.of(Token.TokenType.WHILE); + case "==": + return Optional.of(Token.TokenType.EQUAL); + case "+": + return Optional.of(Token.TokenType.PLUS); + case "-": + return Optional.of(Token.TokenType.MINUS); + case "*": + return Optional.of(Token.TokenType.TIMES); + case "/": + return Optional.of(Token.TokenType.DIVIDE); + case "%": + return Optional.of(Token.TokenType.MOD); + case "}": + return Optional.of(Token.TokenType.RBRACE); + case "else": + return Optional.of(Token.TokenType.ELSE); + case "System.out.println": + return Optional.of(Token.TokenType.PRINT); + case "||": + return Optional.of(Token.TokenType.OR); + case "&&": + return Optional.of(Token.TokenType.AND); + case "true": + return Optional.of(Token.TokenType.TRUE); + case "false": + return Optional.of(Token.TokenType.FALSE); + } + + if (t.matches("\\d+")) + return Optional.of(Token.TokenType.NUM); + if (Character.isAlphabetic(t.charAt(0)) && t.matches("[\\d|\\w]+")) { + return Optional.of(Token.TokenType.ID); + } + return Optional.empty(); + } } From b7c3cf4b133f6eab6a4bce027773b1db555f9b6b Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Sun, 26 Sep 2021 19:57:00 +1000 Subject: [PATCH 2/8] completed lexical analyser token return function --- .../src/com/company/LexicalAnalyser.java | 77 +++++++++++++++---- 1 file changed, 64 insertions(+), 13 deletions(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index f13407e..78a778f 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -7,22 +7,73 @@ public class LexicalAnalyser { - public static List analyse(String sourceCode) throws LexicalException { - //Turn the input String into a list of Tokens! - ArrayList ARList = new ArrayList(); - String[] inputString = sourceCode.split(" "); + public static List analyse(String sourceCode) throws LexicalException { + // Turn the input String into a list of Tokens! + String[] splitList = sourceCode.split("\\s+"); + List furtherSplitList = new ArrayList(); + List tokenList = new ArrayList(); - for(String input : inputString){ - //Optional inputToken = tokenFromString(input); - //if (inputToken != Optional.empty()){ - // Token validToken = Token(input); - // ARList.add(Token); - //} - addToken = new Token(); + for (String word : splitList) { + String s = ""; + for (int i = 0; i < word.length(); i++) { + // System.out.println(word.charAt(i)); + String c = Character.toString(word.charAt(i)); + switch (c) { + case "(": + case ")": + case "{": + case "}": + case ";": + // System.out.println(s); + // System.out.println(c); + // if (s != null || s.length() > 0 || s != "") { + // System.out.println(s); + // furtherSplitList.add(s); + // } + furtherSplitList.add(s); + furtherSplitList.add(c); + s = ""; + break; + case " ": + i = word.length(); + break; + default: + s += c; + } + // if token exists, add s to split list, then add token + // clear string var + } + // if (s != null || s.length() > 0 || s != "") { + // System.out.println(s); + // furtherSplitList.add(s); + // } + furtherSplitList.add(s); } - return ARList; - } + System.out.println(furtherSplitList); + + + for(int j = 0; j < furtherSplitList.size(); j++){ + + } + + for (String s : furtherSplitList) { + + if(s.length() > 0){ + try { + tokenList.add(tokenFromString(s).get()); + } + catch (NoSuchElementException e) { + // tokenList.add(Optional.empty()); + } + } + //try { + // tokenList.add(LexicalAnalyser.tokenFromString().get()) + //} + } + return tokenList; + // return Collections.emptyList(); + } private static Optional tokenFromString(String t) { Optional type = tokenTypeOf(t); From d70cbb45211c6da00d4577b57ad41b6179946096 Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Sun, 17 Oct 2021 22:20:52 +1100 Subject: [PATCH 3/8] updated lexical analyser to fix merge problems --- .../src/com/company/LexicalAnalyser.java | 176 +++++++++++------- 1 file changed, 113 insertions(+), 63 deletions(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index 78a778f..ba1d72c 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -4,79 +4,116 @@ import java.util.Optional; import java.util.Collections; import java.util.ArrayList; +import java.util.Arrays; +import java.util.NoSuchElementException; public class LexicalAnalyser { - public static List analyse(String sourceCode) throws LexicalException { - // Turn the input String into a list of Tokens! - String[] splitList = sourceCode.split("\\s+"); - List furtherSplitList = new ArrayList(); - List tokenList = new ArrayList(); + public static List analyse(String sourceCode) throws LexicalException { + // Turn the input String into a list of Tokens! + // split source code by spaces into a list and initialize all other necessary lists + String[] splitList = sourceCode.split(" "); + List tokenCase = Arrays.asList(new String[]{ // list to check characters against + "\"", "\'", "(", ")", "{", "}", + ";", "+", "-", "*", "/", "%" + }); + List furtherSplitList = new ArrayList(); + List tokenList = new ArrayList(); - for (String word : splitList) { - String s = ""; - for (int i = 0; i < word.length(); i++) { - // System.out.println(word.charAt(i)); - String c = Character.toString(word.charAt(i)); - switch (c) { - case "(": - case ")": - case "{": - case "}": - case ";": - // System.out.println(s); - // System.out.println(c); - // if (s != null || s.length() > 0 || s != "") { - // System.out.println(s); - // furtherSplitList.add(s); - // } - furtherSplitList.add(s); - furtherSplitList.add(c); - s = ""; - break; - case " ": - i = word.length(); - break; - default: - s += c; - } - // if token exists, add s to split list, then add token - // clear string var - } - // if (s != null || s.length() > 0 || s != "") { - // System.out.println(s); - // furtherSplitList.add(s); - // } - furtherSplitList.add(s); - } + for (String word : splitList) { + String s = ""; + for (int i = 0; i < word.length(); i++) { // iterate through the word + // System.out.println(word.charAt(i)); + String c = Character.toString(word.charAt(i)); + if (tokenCase.contains(c)) { // check against list of tokens + furtherSplitList.add(s); // add whatever we have in the list + furtherSplitList.add(c); // add the last character as a separate token + s = ""; + } else { + s += c; // if character wasn't a separator keep adding to s + } + } + furtherSplitList.add(s); + } + // start adding tokens to the token list based on what we have in further split list + for (int i = 0; i < furtherSplitList.size(); i++) { + String s = furtherSplitList.get(i); + if (s.length() > 0) { + try { + if (i > 0 && furtherSplitList.get(i - 1).matches("\"")) { + tokenList.add(tokenTypeStringLit(s).get()); + } else if (i > 0 && furtherSplitList.get(i - 1).matches("\'")) { + tokenList.add(tokenTypeCharLit(s).get()); + } else if (i < furtherSplitList.size() - 1 && furtherSplitList.get(i).matches(".[=]$")) { + // System.out.println(furtherSplitList.get(i)); + if (furtherSplitList.get(i).matches("^[>].*")) { + tokenList.add(tokenTypeGE(s).get()); + } else if (furtherSplitList.get(i).matches("^[<].*")) { + tokenList.add(tokenTypeLE(s).get()); + } else if (furtherSplitList.get(i).matches("^[!].*")) { + tokenList.add(tokenTypeNE(s).get()); + } else if (furtherSplitList.get(i).matches("^[=].*")) { + tokenList.add(tokenTypeEqual(s).get()); + } else { + tokenList.add(tokenTypeEqual(s).get()); + } + } else { + tokenList.add(tokenFromString(s).get()); + } + } catch (NoSuchElementException e) { + System.out.print("Token not found: " + e + "\n"); + } catch (Exception e) { + System.out.print(e); + } + } + } + return tokenList; + } - System.out.println(furtherSplitList); + private static Optional tokenFromString(String t) { + Optional type = tokenTypeOf(t); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } + private static Optional tokenTypeStringLit(String t) { + Optional type = Optional.of(Token.TokenType.STRINGLIT); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } - for(int j = 0; j < furtherSplitList.size(); j++){ + private static Optional tokenTypeCharLit(String t) { + Optional type = Optional.of(Token.TokenType.CHARLIT); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } - } + private static Optional tokenTypeGE(String t) { + Optional type = Optional.of(Token.TokenType.GE); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } - for (String s : furtherSplitList) { + private static Optional tokenTypeLE(String t) { + Optional type = Optional.of(Token.TokenType.LE); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } - if(s.length() > 0){ - try { - tokenList.add(tokenFromString(s).get()); - } - catch (NoSuchElementException e) { - // tokenList.add(Optional.empty()); - } - } - //try { - // tokenList.add(LexicalAnalyser.tokenFromString().get()) - //} - } - return tokenList; - // return Collections.emptyList(); - } + private static Optional tokenTypeEqual(String t) { + Optional type = Optional.of(Token.TokenType.EQUAL); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } - private static Optional tokenFromString(String t) { - Optional type = tokenTypeOf(t); + private static Optional tokenTypeNE(String t) { + Optional type = Optional.of(Token.TokenType.NEQUAL); if (type.isPresent()) return Optional.of(new Token(type.get(), t)); return Optional.empty(); @@ -144,14 +181,27 @@ private static Optional tokenTypeOf(String t) { return Optional.of(Token.TokenType.TRUE); case "false": return Optional.of(Token.TokenType.FALSE); + case "<": + return Optional.of(Token.TokenType.LT); + case ">": + return Optional.of(Token.TokenType.GT); + // case "<=": + // return Optional.of(Token.TokenType.LE); + // case ">=": + // return Optional.of(Token.TokenType.GE); } + if (t.matches("\"{1}")) + return Optional.of(Token.TokenType.DQUOTE); + if (t.matches("\'{1}")) + return Optional.of(Token.TokenType.SQUOTE); if (t.matches("\\d+")) return Optional.of(Token.TokenType.NUM); if (Character.isAlphabetic(t.charAt(0)) && t.matches("[\\d|\\w]+")) { return Optional.of(Token.TokenType.ID); } + return Optional.empty(); } -} +} \ No newline at end of file From aa7e9f64ce89e001dab0f4f71bb0401b38c8173f Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Mon, 18 Oct 2021 16:15:22 +1100 Subject: [PATCH 4/8] Added finished parse table to github --- FirstSetTable.html | 1722 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1722 insertions(+) create mode 100644 FirstSetTable.html diff --git a/FirstSetTable.html b/FirstSetTable.html new file mode 100644 index 0000000..88fcdb3 --- /dev/null +++ b/FirstSetTable.html @@ -0,0 +1,1722 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
publicclassID{staticvoidmain(String[]args);while}forifelse=System.out.println(intcharboolean'Char==!=&&||truefalse<<=>>=+-*/%num"Stringlitε
Prog1−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Los−−2−−−−−−−−22322−−2222−−−−−−−−−−−−−−−−−−−−3
Stat−−7−−−−−−−−104−56−−9888−−−−−−−−−−−−−−−−−−−−−
While−−−−−−−−−−−−11−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
For−−−−−−−−−−−−−−12−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Forstart−−14−−−−−−−−15−−−−−−−131313−−−−−−−−−−−−−−−−−−−−15
Forarith−−16−−−−16−−17−−−−−−−−−−−−−−−−−−−−−−−−−−−−16−−17
If−−−−−−−−−−−−−−−18−−−−−−−−−−−−−−−−−−−−−−−−−−−
Elseif−−20−−−−−−−−202020202019−20202020−−−−−−−−−−−−−−−−−−−−20
ElseQif−−−−−−−−−−−−−−−21−−−−−−−−−−−−−−−−−−−−−−−−−−
Possif−−−23−−−−−−−−−−−22−−−−−−−−−−−−−−−−−−−−−−−−−−23
Assign−−24−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Decl−−−−−−−−−−−−−−−−−−−252525−−−−−−−−−−−−−−−−−−−−−
Possassign−−−−−−−−−−−27−−−−−26−−−−−−−−−−−−−−−−−−−−−−−−27
Print−−−−−−−−−−−−−−−−−−28−−−−−−−−−−−−−−−−−−−−−−−−
Type−−−−−−−−−−−−−−−−−−−293031−−−−−−−−−−−−−−−−−−−−−
Expr−−32−−−−32−−−−−−−−−−−−−−33−−−−−3232−−−−−−−−−32−−−
Charexpr−−−−−−−−−−−−−−−−−−−−−−34−−−−−−−−−−−−−−−−−−−−
Boolexpr−−−−−−−−−−3636−−−−−−−−−−−−35353535−−−−−−−−−−−−−−36
Boolop−−−−−−−−−−−−−−−−−−−−−−−−37373838−−−−−−−−−−−−−−−
Booleq−−−−−−−−−−−−−−−−−−−−−−−−3940−−−−−−−−−−−−−−−−−
Boollog−−−−−−−−−−−−−−−−−−−−−−−−−−4142−−−−−−−−−−−−−−−
Relexpr−−43−−−−43−−−−−−−−−−−−−−−−−−−−4445−−−−−−−−−43−−−
Relexpr2−−−−−−−−−−4747−−−−−−−−−−−−47474747−−46464646−−−−−−−−47
Relop−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−48495051−−−−−−−−−
Arithexpr−−52−−−−52−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−52−−−
Arithexpr2−−−−−−−−−−5555−−−−−−−−−−−−55555555−−555555555354−−−−−−55
Term−−56−−−−56−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−56−−−
Term2−−−−−−−−−−6060−−−−−−−−−−−−60606060−−606060606060575859−−−60
Factor−−62−−−−61−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−63−−−
Printexpr−−64−−−−64−−−−−−−−−−−−−−−−−−−−6464−−−−−−−−−6465−−
Variables−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−67−66−−67
Variable−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−68−−−
Operators−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−70−696970
Operator−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−7172−
+ From 7216591599678338886215e41556bdb49dc36442 Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Fri, 22 Oct 2021 13:07:01 +1100 Subject: [PATCH 5/8] filled in rules 2-20 --- .../src/com/company/SyntacticAnalyser.java | 237 +++++++++++++++++- 1 file changed, 236 insertions(+), 1 deletion(-) diff --git a/Assignment2/src/com/company/SyntacticAnalyser.java b/Assignment2/src/com/company/SyntacticAnalyser.java index 54709e6..04d7cc9 100644 --- a/Assignment2/src/com/company/SyntacticAnalyser.java +++ b/Assignment2/src/com/company/SyntacticAnalyser.java @@ -357,11 +357,246 @@ public static ParseTree parse(List tokens) throws SyntaxException { break; case 2: stack.pop(); - stack.push(new Pair<>(TreeNode.Label.stat, "")); stack.push(new Pair<>(TreeNode.Label.los, "")); + stack.push(new Pair<>(TreeNode.Label.stat, "")); break; case 3: stack.pop(); + //stack.push(new Pair, ""); + break; + case 4: + stack.pop(); + stack.push(new Pair, ""); + break; + case 5: + stack.pop(); + stack.push(new Pair, ""); + break; + case 6: + stack.pop(); + stack.push(new Pair, ""); + break; + case 7: + stack.pop(); + stack.push(new Pair, ""); + break; + case 8: + stack.pop(); + stack.push(new Pair, ""); + break; + case 9: + stack.pop(); + stack.push(new Pair, ""); + break; + case 10: + stack.pop(); + //stack.push(new Pair, ""); + break; + case 11: + stack.pop(); + stack.push(new Pair, "}"); + stack.push(new Pair, ""); + stack.push(new Pair, "{"); + stack.push(new Pair, ")"); + stack.push(new Pair, ""); + stack.push(new Pair, ""); + stack.push(new Pair, "("); + stack.push(new Pair, "while"); + break; + case 12: + stack.pop(); + stack.push(new Pair, "}"); + stack.push(new Pair, ""); + stack.push(new Pair, "{"); + stack.push(new Pair, ")"); + stack.push(new Pair, ""); + stack.push(new Pair, ";"); + stack.push(new Pair, ""); + stack.push(new Pair, ""); + stack.push(new Pair, ";"); + stack.push(new Pair, ""); + stack.push(new Pair, "("); + stack.push(new Pair, "if"); + break; + case 13: + stack.pop(); + stack.push(new Pair, ""); + break; + case 14: + stack.pop(); + stack.push(new Pair, ""); + break; + case 15: + stack.pop(); + //stack.push(new Pair, ""); + break; + case 16: + stack.pop(); + stack.push(new Pair, ""); + break; + case 17: + stack.pop(); + //stack.push(new Pair, ""); + break; + case 18: + stack.pop(); + stack.push(new Pair, ""); + stack.push(new Pair, "}"); + stack.push(new Pair, ""); + stack.push(new Pair, "{"); + stack.push(new Pair, ")"); + stack.push(new Pair, ""); + stack.push(new Pair, ""); + stack.push(new Pair, "("); + stack.push(new Pair, "if"); + break; + case 19: + stack.pop(); + stack.push(new Pair, ""); + stack.push(new Pair, "}"); + stack.push(new Pair, ""); + stack.push(new Pair, "{"); + stack.push(new Pair, ""); + break; + case 20: + stack.pop(); + + break; + case 21: + stack.pop(); + break; + case 22: + stack.pop(); + break; + case 23: + stack.pop(); + break; + case 24: + stack.pop(); + break; + case 25: + stack.pop(); + break; + case 26: + stack.pop(); + break; + case 27: + stack.pop(); + break; + case 28: + stack.pop(); + break; + case 29: + stack.pop(); + break; + case 30: + stack.pop(); + break; + case 31: + stack.pop(); + break; + case 32: + stack.pop(); + break; + case 33: + stack.pop(); + break; + case 34: + stack.pop(); + break; + case 35: + stack.pop(); + break; + case 36: + stack.pop(); + break; + case 37: + stack.pop(); + break; + case 38: + stack.pop(); + break; + case 39: + stack.pop(); + break; + case 40: + stack.pop(); + break; + case 41: + stack.pop(); + break; + case 42: + stack.pop(); + break; + case 43: + stack.pop(); + break; + case 44: + stack.pop(); + break; + case 45: + stack.pop(); + break; + case 46: + stack.pop(); + break; + case 47: + stack.pop(); + break; + case 48: + stack.pop(); + break; + case 49: + stack.pop(); + break; + case 50: + stack.pop(); + break; + case 51: + stack.pop(); + break; + case 52: + stack.pop(); + break; + case 53: + stack.pop(); + break; + case 54: + stack.pop(); + break; + case 55: + stack.pop(); + break; + case 56: + stack.pop(); + break; + case 57: + stack.pop(); + break; + case 58: + stack.pop(); + break; + case 59: + stack.pop(); + break; + case 60: + stack.pop(); + break; + case 61: + stack.pop(); + break; + case 62: + stack.pop(); + break; + case 63: + stack.pop(); + break; + case 64: + stack.pop(); + break; + case 65: + stack.pop(); + stack.push(); break; } } From ae503b2c66cb7d4ea5807c9a8b3dd4ae01b4bdbc Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Sat, 23 Oct 2021 02:25:39 +1100 Subject: [PATCH 6/8] copy pasted most updated code for syntactical analyser --- .../src/com/company/SyntacticAnalyser.java | 566 +++++++++--------- 1 file changed, 291 insertions(+), 275 deletions(-) diff --git a/Assignment2/src/com/company/SyntacticAnalyser.java b/Assignment2/src/com/company/SyntacticAnalyser.java index 04d7cc9..921a101 100644 --- a/Assignment2/src/com/company/SyntacticAnalyser.java +++ b/Assignment2/src/com/company/SyntacticAnalyser.java @@ -68,7 +68,7 @@ private static String tokenToString(Token token) { case ARGS: return "args"; case TYPE: - return token.getValue() + ""; + return "int"; case PRINT: return "System.out.println("; case WHILE: @@ -98,6 +98,13 @@ private static String tokenToString(Token token) { } + public static TreeNode createNode(TreeNode parent, TreeNode.Label childLabel) { + TreeNode newNode = new TreeNode(childLabel, parent); + parent.addChild(newNode); + return newNode; + } + + public static ParseTree parse(List tokens) throws SyntaxException { @@ -118,7 +125,7 @@ public static ParseTree parse(List tokens) throws SyntaxException { put("int", 2); put("char", 2); put("boolean", 2); - put("", 2); +// put("", 2); }}); parseTable.put(TreeNode.Label.stat, new HashMap() {{ put("ID", 7); @@ -315,291 +322,300 @@ public static ParseTree parse(List tokens) throws SyntaxException { put("\"", 65); }}); - Deque> stack = new ArrayDeque<>(); + Deque> stack = new ArrayDeque<>(); ParseTree tree = new ParseTree(); tree.setRoot(new TreeNode(TreeNode.Label.prog, null)); TreeNode currentNode = tree.getRoot(); - stack.push(new Pair<>(TreeNode.Label.prog, "")); + stack.push(new Pair<>(currentNode, "")); for (Token token : tokens) { - if (stack.getFirst().getKey() != currentNode.getLabel()) { - TreeNode newNode = new TreeNode(stack.getFirst().getKey(), currentNode); - currentNode.addChild(newNode); - currentNode = newNode; - } // ------------------------------------------------------------------------------------------------------- handles if it's a variable change - if (tokenToString(token).equals(stack.getFirst().getValue())) { // ----------------------------------------- handles if it's a terminal - currentNode.addChild(new TreeNode(stack.getFirst().getKey(), token, currentNode)); + currentNode.addChild(new TreeNode(stack.getFirst().getKey().getLabel(), token, currentNode)); stack.pop(); - } else { // ------------------------------------------------------------------------------------------------ handles if a rule goes with the variable - int ruleNum = (int) parseTable.get(currentNode.getLabel()).get(tokenToString(token)); - switch (ruleNum) { - case 1: - stack.pop(); - stack.push(new Pair<>(TreeNode.Label.prog, "}")); - stack.push(new Pair<>(TreeNode.Label.prog, "}")); - stack.push(new Pair<>(TreeNode.Label.los, "")); - stack.push(new Pair<>(TreeNode.Label.prog, "{")); - stack.push(new Pair<>(TreeNode.Label.prog, ")")); - stack.push(new Pair<>(TreeNode.Label.prog, "args")); - stack.push(new Pair<>(TreeNode.Label.prog, "String[]")); - stack.push(new Pair<>(TreeNode.Label.prog, "(")); - stack.push(new Pair<>(TreeNode.Label.prog, "main")); - stack.push(new Pair<>(TreeNode.Label.prog, "void")); - stack.push(new Pair<>(TreeNode.Label.prog, "static")); - stack.push(new Pair<>(TreeNode.Label.prog, "public")); - stack.push(new Pair<>(TreeNode.Label.prog, "{")); - stack.push(new Pair<>(TreeNode.Label.prog, "ID")); - stack.push(new Pair<>(TreeNode.Label.prog, "class")); - // stack.push("public"); -- this gets popped right away - break; - case 2: - stack.pop(); - stack.push(new Pair<>(TreeNode.Label.los, "")); - stack.push(new Pair<>(TreeNode.Label.stat, "")); - break; - case 3: - stack.pop(); - //stack.push(new Pair, ""); - break; - case 4: - stack.pop(); - stack.push(new Pair, ""); - break; - case 5: - stack.pop(); - stack.push(new Pair, ""); - break; - case 6: - stack.pop(); - stack.push(new Pair, ""); - break; - case 7: - stack.pop(); - stack.push(new Pair, ""); - break; - case 8: - stack.pop(); - stack.push(new Pair, ""); - break; - case 9: - stack.pop(); - stack.push(new Pair, ""); - break; - case 10: - stack.pop(); - //stack.push(new Pair, ""); - break; - case 11: - stack.pop(); - stack.push(new Pair, "}"); - stack.push(new Pair, ""); - stack.push(new Pair, "{"); - stack.push(new Pair, ")"); - stack.push(new Pair, ""); - stack.push(new Pair, ""); - stack.push(new Pair, "("); - stack.push(new Pair, "while"); - break; - case 12: - stack.pop(); - stack.push(new Pair, "}"); - stack.push(new Pair, ""); - stack.push(new Pair, "{"); - stack.push(new Pair, ")"); - stack.push(new Pair, ""); - stack.push(new Pair, ";"); - stack.push(new Pair, ""); - stack.push(new Pair, ""); - stack.push(new Pair, ";"); - stack.push(new Pair, ""); - stack.push(new Pair, "("); - stack.push(new Pair, "if"); - break; - case 13: - stack.pop(); - stack.push(new Pair, ""); - break; - case 14: - stack.pop(); - stack.push(new Pair, ""); - break; - case 15: - stack.pop(); - //stack.push(new Pair, ""); - break; - case 16: - stack.pop(); - stack.push(new Pair, ""); - break; - case 17: - stack.pop(); - //stack.push(new Pair, ""); - break; - case 18: - stack.pop(); - stack.push(new Pair, ""); - stack.push(new Pair, "}"); - stack.push(new Pair, ""); - stack.push(new Pair, "{"); - stack.push(new Pair, ")"); - stack.push(new Pair, ""); - stack.push(new Pair, ""); - stack.push(new Pair, "("); - stack.push(new Pair, "if"); - break; - case 19: - stack.pop(); - stack.push(new Pair, ""); - stack.push(new Pair, "}"); - stack.push(new Pair, ""); - stack.push(new Pair, "{"); - stack.push(new Pair, ""); - break; - case 20: - stack.pop(); + } else { + boolean terminalAvailable = false; + while (!terminalAvailable) { - break; - case 21: - stack.pop(); - break; - case 22: - stack.pop(); - break; - case 23: - stack.pop(); - break; - case 24: - stack.pop(); - break; - case 25: - stack.pop(); - break; - case 26: - stack.pop(); - break; - case 27: - stack.pop(); - break; - case 28: - stack.pop(); - break; - case 29: - stack.pop(); - break; - case 30: - stack.pop(); - break; - case 31: - stack.pop(); - break; - case 32: - stack.pop(); - break; - case 33: - stack.pop(); - break; - case 34: - stack.pop(); - break; - case 35: - stack.pop(); - break; - case 36: - stack.pop(); - break; - case 37: - stack.pop(); - break; - case 38: - stack.pop(); - break; - case 39: - stack.pop(); - break; - case 40: - stack.pop(); - break; - case 41: - stack.pop(); - break; - case 42: - stack.pop(); - break; - case 43: - stack.pop(); - break; - case 44: - stack.pop(); - break; - case 45: - stack.pop(); - break; - case 46: - stack.pop(); - break; - case 47: - stack.pop(); - break; - case 48: - stack.pop(); - break; - case 49: - stack.pop(); - break; - case 50: - stack.pop(); - break; - case 51: - stack.pop(); - break; - case 52: - stack.pop(); - break; - case 53: - stack.pop(); - break; - case 54: - stack.pop(); - break; - case 55: - stack.pop(); - break; - case 56: - stack.pop(); - break; - case 57: - stack.pop(); - break; - case 58: - stack.pop(); - break; - case 59: - stack.pop(); - break; - case 60: - stack.pop(); - break; - case 61: - stack.pop(); - break; - case 62: - stack.pop(); - break; - case 63: - stack.pop(); - break; - case 64: - stack.pop(); - break; - case 65: - stack.pop(); - stack.push(); - break; + if (!stack.getFirst().equals(currentNode)) { // -------------------------------------- handles if it's a variable change +// TreeNode newNode = new TreeNode(stack.getFirst().getKey(), currentNode); +// currentNode.addChild(newNode); + currentNode = stack.getFirst().getKey(); + } + + System.out.println("Current node label is: " + currentNode.getLabel().toString() + " and current token value is: " + tokenToString(token)); + int ruleNum = (int) parseTable.get(currentNode.getLabel()).get(tokenToString(token)); // ----------- handles if a rule goes with the variable + switch (ruleNum) { + case 1: + stack.pop(); + stack.push(new Pair<>(currentNode, "}")); + stack.push(new Pair<>(currentNode, "}")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.los), "")); + stack.push(new Pair<>(currentNode, "{")); + stack.push(new Pair<>(currentNode, ")")); + stack.push(new Pair<>(currentNode, "args")); + stack.push(new Pair<>(currentNode, "String[]")); + stack.push(new Pair<>(currentNode, "(")); + stack.push(new Pair<>(currentNode, "main")); + stack.push(new Pair<>(currentNode, "void")); + stack.push(new Pair<>(currentNode, "static")); + stack.push(new Pair<>(currentNode, "public")); + stack.push(new Pair<>(currentNode, "{")); + stack.push(new Pair<>(currentNode, "ID")); + stack.push(new Pair<>(currentNode, "class")); + // stack.push("public"); -- this gets popped right away + break; + case 2: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.los), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.stat), "")); + break; + case 3: + stack.pop(); + break; + case 4: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.whilestat), "")); + break; + case 5: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.forstat), "")); + break; + case 6: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.ifstat), "")); + break; + case 7: + stack.pop(); + stack.push(new Pair<>(currentNode, ";")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.assign), "")); + break; + case 8: + stack.pop(); + stack.push(new Pair<>(currentNode, ";")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.decl), "")); + break; + case 9: + stack.pop(); + stack.push(new Pair<>(currentNode, ";")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.print), "")); + break; + case 10: + stack.pop(); + //stack.push(new Pair, ""); + break; + case 11: + stack.pop(); + stack.push(new Pair<>(currentNode, "}")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.los), "")); + stack.push(new Pair<>(currentNode, "{")); + stack.push(new Pair<>(currentNode, ")")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); + stack.push(new Pair<>(currentNode, "(")); + stack.push(new Pair<>(currentNode, "while")); + break; + case 12: + stack.pop(); + stack.push(new Pair<>(currentNode, "}")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); + stack.push(new Pair<>(currentNode, "{")); + stack.push(new Pair<>(currentNode, ")")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.forarith), "")); + stack.push(new Pair<>(currentNode, ";")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.relexpr), "")); + stack.push(new Pair<>(currentNode, ";")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.forstart), "")); + stack.push(new Pair<>(currentNode, "(")); + stack.push(new Pair<>(currentNode, "if")); + break; + case 13: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.decl), "")); + break; + case 14: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.assign), "")); + break; + case 15: + stack.pop(); + //stack.push(new Pair, ""); + break; + case 16: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.arithexpr), "")); + break; + case 17: + stack.pop(); + //stack.push(new Pair, ""); + break; + case 18: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.elseifstat), "")); + stack.push(new Pair<>(currentNode, "}")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); + stack.push(new Pair<>(currentNode, "{")); + stack.push(new Pair<>(currentNode, ")")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); + stack.push(new Pair<>(currentNode, "(")); + stack.push(new Pair<>(currentNode, "if")); + break; + case 19: + stack.pop(); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.elseifstat), "")); + stack.push(new Pair<>(currentNode, "}")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); + stack.push(new Pair<>(currentNode, "{")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.elseorelseif), "")); + break; + case 20: + stack.pop(); + break; + case 21: + stack.pop(); + break; + case 22: + stack.pop(); + break; + case 23: + stack.pop(); + break; + case 24: + stack.pop(); + break; + case 25: + stack.pop(); + break; + case 26: + stack.pop(); + break; + case 27: + stack.pop(); + break; + case 28: + stack.pop(); + break; + case 29: + stack.pop(); + break; + case 30: + stack.pop(); + break; + case 31: + stack.pop(); + break; + case 32: + stack.pop(); + break; + case 33: + stack.pop(); + break; + case 34: + stack.pop(); + break; + case 35: + stack.pop(); + break; + case 36: + stack.pop(); + break; + case 37: + stack.pop(); + break; + case 38: + stack.pop(); + break; + case 39: + stack.pop(); + break; + case 40: + stack.pop(); + break; + case 41: + stack.pop(); + break; + case 42: + stack.pop(); + break; + case 43: + stack.pop(); + break; + case 44: + stack.pop(); + break; + case 45: + stack.pop(); + break; + case 46: + stack.pop(); + break; + case 47: + stack.pop(); + break; + case 48: + stack.pop(); + break; + case 49: + stack.pop(); + break; + case 50: + stack.pop(); + break; + case 51: + stack.pop(); + break; + case 52: + stack.pop(); + break; + case 53: + stack.pop(); + break; + case 54: + stack.pop(); + break; + case 55: + stack.pop(); + break; + case 56: + stack.pop(); + break; + case 57: + stack.pop(); + break; + case 58: + stack.pop(); + break; + case 59: + stack.pop(); + break; + case 60: + stack.pop(); + break; + case 61: + stack.pop(); + break; + case 62: + stack.pop(); + break; + case 63: + stack.pop(); + break; + case 64: + stack.pop(); + break; + case 65: + stack.pop(); + break; + } + if (!stack.getFirst().getValue().equals("")) + terminalAvailable = true; } + } + } From 1af15eda1b5d3975603274a1573e1f10157dad45 Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Sat, 23 Oct 2021 03:14:53 +1100 Subject: [PATCH 7/8] finished the rules for pushing elements to the stack --- .../src/com/company/SyntacticAnalyser.java | 86 ++++++++++++++++++- 1 file changed, 84 insertions(+), 2 deletions(-) diff --git a/Assignment2/src/com/company/SyntacticAnalyser.java b/Assignment2/src/com/company/SyntacticAnalyser.java index 921a101..59801e1 100644 --- a/Assignment2/src/com/company/SyntacticAnalyser.java +++ b/Assignment2/src/com/company/SyntacticAnalyser.java @@ -1,6 +1,6 @@ package com.company; -import apple.laf.JRSUIUtils; +//import apple.laf.JRSUIUtils; import com.company.ParseTree; import javafx.util.Pair; @@ -469,145 +469,227 @@ public static ParseTree parse(List tokens) throws SyntaxException { stack.push(new Pair<>(currentNode, "}")); stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.elseorelseif), "")); + stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.elseorelseif), "")); break; case 20: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 21: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.possif), "")); + stack.push(new Pair<>(currentNode, "else")); break; case 22: stack.pop(); + stack.push(new Pair<>(currentNode, ")")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); + stack.push(new Pair<>(currentNode, "(")); + stack.push(new Pair<>(currentNode, "if")); break; case 23: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 24: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.expr), "")); + stack.push(new Pair<>(currentNode, "=")); + stack.push(new Pair<>(currentNode, "ID")); break; case 25: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.possassign), "")); + stack.push(new Pair<>(currentNode, "ID")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.type), "")); break; case 26: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.expr), "")); + stack.push(new Pair<>(currentNode, "=")); break; case 27: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 28: stack.pop(); + stack.push(new Pair<>(currentNode, "System.out.println(")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.printexpr), "")); + stack.push(new Pair<>(currentNode, ")")); break; case 29: stack.pop(); + stack.push(new Pair<>(currentNode, "int")); break; case 30: stack.pop(); + stack.push(new Pair<>(currentNode, "char")); break; case 31: stack.pop(); + stack.push(new Pair<>(currentNode, "boolean")); break; case 32: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); break; case 33: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.charexpr), "")); break; case 34: stack.pop(); + stack.push(new Pair<>(currentNode, "'")); + stack.push(new Pair<>(currentNode, "Char")); + stack.push(new Pair<>(currentNode, "'")); break; case 35: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolop), "")); break; case 36: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 37: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.booleq), "")); break; case 38: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boollog), "")); break; case 39: stack.pop(); + stack.push(new Pair<>(currentNode, "==")); break; case 40: stack.pop(); + stack.push(new Pair<>(currentNode, "!=")); break; case 41: stack.pop(); + stack.push(new Pair<>(currentNode, "&&")); break; case 42: stack.pop(); + stack.push(new Pair<>(currentNode, "||")); break; case 43: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexprprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexpr), "")); break; case 44: stack.pop(); + stack.push(new Pair<>(currentNode, "true")); break; case 45: stack.pop(); + stack.push(new Pair<>(currentNode, "false")); break; case 46: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relop), "")); break; case 47: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 48: stack.pop(); + stack.push(new Pair<>(currentNode, "<")); break; case 49: stack.pop(); + stack.push(new Pair<>(currentNode, "<=")); break; case 50: stack.pop(); + stack.push(new Pair<>(currentNode, ">")); break; case 51: stack.pop(); + stack.push(new Pair<>(currentNode, ">=")); break; case 52: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexprprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.term), "")); break; case 53: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexprprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.term), "")); + stack.push(new Pair<>(currentNode, "+")); break; case 54: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexprprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.term), "")); + stack.push(new Pair<>(currentNode, "-")); break; case 55: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 56: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); break; case 57: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); + stack.push(new Pair<>(currentNode, "*")); break; case 58: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); + stack.push(new Pair<>(currentNode, "/")); break; case 59: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); + stack.push(new Pair<>(currentNode, "%")); break; case 60: stack.pop(); + //stack.push(new Pair<>(currentNode, "")); break; case 61: stack.pop(); + stack.push(new Pair<>(currentNode, ")")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexpr), "")); + stack.push(new Pair<>(currentNode, "(")); break; case 62: stack.pop(); + stack.push(new Pair<>(currentNode, "ID")); break; case 63: stack.pop(); + stack.push(new Pair<>(currentNode, "num")); break; case 64: stack.pop(); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); + stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); break; case 65: stack.pop(); + stack.push(new Pair<>(currentNode, "\"")); + stack.push(new Pair<>(currentNode, "StringLit")); + stack.push(new Pair<>(currentNode, "\"")); break; } if (!stack.getFirst().getValue().equals("")) From fc9c135eda298b7ea6115344143c7e4c52418191 Mon Sep 17 00:00:00 2001 From: tobywalsh1107 Date: Thu, 28 Oct 2021 15:41:13 +1100 Subject: [PATCH 8/8] changed syntacital analyser to be the most up to date version of our project --- .../src/com/company/SyntacticAnalyser.java | 989 +++++++++--------- 1 file changed, 494 insertions(+), 495 deletions(-) diff --git a/Assignment2/src/com/company/SyntacticAnalyser.java b/Assignment2/src/com/company/SyntacticAnalyser.java index 59801e1..bc0ec62 100644 --- a/Assignment2/src/com/company/SyntacticAnalyser.java +++ b/Assignment2/src/com/company/SyntacticAnalyser.java @@ -1,9 +1,4 @@ package com.company; - -//import apple.laf.JRSUIUtils; -import com.company.ParseTree; -import javafx.util.Pair; - import java.util.ArrayDeque; import java.util.Arrays; import java.util.Deque; @@ -13,710 +8,714 @@ public class SyntacticAnalyser { - private static String tokenToString(Token token) { - switch (token.getType()) { - case PLUS: - return "+"; - case MINUS: - return "-"; - case TIMES: - return "*"; - case DIVIDE: - return "/"; - case MOD: - return "%"; - case ASSIGN: - return "="; - case EQUAL: - return "=="; - case NEQUAL: - return "!="; - case LT: - return "<"; - case LE: - return "<="; - case GT: - return ">"; - case GE: - return ">="; - case LPAREN: - return "("; - case RPAREN: - return ")"; - case LBRACE: - return "{"; - case RBRACE: - return "}"; - case AND: - return "&&"; - case OR: - return "||"; - case SEMICOLON: - return ";"; - case PUBLIC: - return "public"; - case CLASS: - return "class"; - case STATIC: - return "static"; - case VOID: - return "void"; - case MAIN: - return "main"; - case STRINGARR: - return "String[]"; - case ARGS: - return "args"; - case TYPE: - return "int"; - case PRINT: - return "System.out.println("; - case WHILE: - return "while"; - case FOR: - return "for"; - case IF: - return "if"; - case ELSE: - return "else"; - case DQUOTE: - return "\""; - case SQUOTE: - return "'"; - case ID: - return "ID"; - case NUM: - return "num"; - case TRUE: - return "true"; - case FALSE: - return "false"; - case STRINGLIT: - return "Stringlit"; - } - return ""; - } + public static ParseTree parse(List tokens) throws SyntaxException { - public static TreeNode createNode(TreeNode parent, TreeNode.Label childLabel) { - TreeNode newNode = new TreeNode(childLabel, parent); - parent.addChild(newNode); - return newNode; - } + if (tokens.size() == 0) + throw new SyntaxException("Syntactical exception."); + HashMap> parseTable = createTable(); + Deque stack = new ArrayDeque<>(); + ParseTree tree = new ParseTree(); + NodeWrapper root = new NodeWrapper(null, TreeNode.Label.prog, ""); + root.setNode(new TreeNode(TreeNode.Label.prog, null)); + tree.setRoot(root.getNode()); + NodeWrapper currentNode = root; - public static ParseTree parse(List tokens) throws SyntaxException { + stack.push(currentNode); + for (Token token : tokens) { +// System.out.println(tree.toString()); - // Model Parsing table in a HashMap -- Marcell - HashMap parseTable = new HashMap<>(); - // add rows as the value of each key - parseTable.put(TreeNode.Label.prog, new HashMap() {{ - put("public", 1); - }}); - parseTable.put(TreeNode.Label.los, new HashMap() {{ - put("ID", 2); - put(";", 2); - put("while", 2); // + - put("}", 3); - put("for", 2); - put("if", 2); - put("System.out.println(", 2); - put("int", 2); - put("char", 2); - put("boolean", 2); -// put("", 2); - }}); - parseTable.put(TreeNode.Label.stat, new HashMap() {{ - put("ID", 7); - put(";", 10); - put("while", 4); - put("for", 5); - put("if", 6); - put("System.out.println(", 9); - put("int", 8); - put("char", 8); - put("boolean", 8); - }}); - parseTable.put(TreeNode.Label.whilestat, new HashMap() {{ - put("while", 11); - }}); - parseTable.put(TreeNode.Label.forstat, new HashMap() {{ - put("For", 12); - }}); - parseTable.put(TreeNode.Label.forstart, new HashMap() {{ - put("ID", 14); - put(";", 15); - put("int", 13); - put("char", 13); - put("boolean", 13); - put("", 15); - }}); - parseTable.put(TreeNode.Label.forarith, new HashMap() {{ - put("ID", 16); - put("(", 16); - put(")", 17); - put("num", 16); - put("", 17); - }}); - parseTable.put(TreeNode.Label.ifstat, new HashMap() {{ - put("if", 18); - }}); - parseTable.put(TreeNode.Label.elseifstat, new HashMap() {{ - put("ID", 20); - put(";", 20); - put("while", 20); - put("}", 20); // + - put("for", 20); - put("if", 20); - put("else", 19); - put("System.out.println(", 20); - put("int", 20); - put("char", 20); - put("boolean", 20); - put("", 20); - }}); - parseTable.put(TreeNode.Label.elseorelseif, new HashMap() {{ - put("else", 21); - }}); - parseTable.put(TreeNode.Label.possif, new HashMap() {{ - put("{", 23); - put("if", 22); // for -> if - put("", 23); - }}); - parseTable.put(TreeNode.Label.assign, new HashMap() {{ - put("ID", 24); - }}); - parseTable.put(TreeNode.Label.decl, new HashMap() {{ - put("int", 25); - put("char", 25); - put("boolean", 25); - }}); - parseTable.put(TreeNode.Label.possassign, new HashMap() {{ - put(";", 27); - put("=", 26); - put("", 27); - }}); - parseTable.put(TreeNode.Label.print, new HashMap() {{ - put("System.out.println(", 28); - }}); - parseTable.put(TreeNode.Label.type, new HashMap() {{ - put("int", 29); - put("char", 30); - put("boolean", 31); - }}); - parseTable.put(TreeNode.Label.expr, new HashMap() {{ - put("ID", 32); - put("(", 32); - put("'", 33); - put("true", 32); - put("false", 32); - put("num", 32); - }}); - parseTable.put(TreeNode.Label.charexpr, new HashMap() {{ - put("'", 34); - }}); - parseTable.put(TreeNode.Label.boolexpr, new HashMap() {{ - put(")", 36); - put(";", 36); - put("==", 35); - put("!=", 35); - put("&&", 35); - put("||", 35); - put("", 36); - }}); - parseTable.put(TreeNode.Label.boolop, new HashMap() {{ - put("==", 37); - put("!=", 37); - put("&&", 38); - put("||", 38); - }}); - parseTable.put(TreeNode.Label.booleq, new HashMap() {{ - put("==", 39); - put("!=", 40); - }}); - parseTable.put(TreeNode.Label.boollog, new HashMap() {{ - put("&&", 41); - put("||", 42); - }}); - parseTable.put(TreeNode.Label.relexpr, new HashMap() {{ - put("ID", 43); - put("(", 43); - put("true", 44); - put("false", 45); - put("num", 43); - }}); - parseTable.put(TreeNode.Label.relexprprime, new HashMap() {{ - put(")", 47); - put(";", 47); - put("==", 47); - put("!=", 47); - put("&&", 47); - put("||", 47); - put("<", 46); - put("<=", 46); - put(">", 46); - put(">=", 46); - put("", 47); - }}); - parseTable.put(TreeNode.Label.relop, new HashMap() {{ - put("<", 48); - put("<=", 49); - put(">", 50); - put(">=", 51); - }}); - parseTable.put(TreeNode.Label.arithexpr, new HashMap() {{ - put("ID", 52); - put("(", 52); - put("num", 52); - }}); - parseTable.put(TreeNode.Label.arithexprprime, new HashMap() {{ - put(")", 55); - put(";", 55); - put("==", 55); - put("!=", 55); - put("&&", 55); - put("||", 55); - put("<", 55); - put("<=", 55); - put(">", 55); - put(">=", 55); - put("+", 53); - put("-", 54); - put("", 55); - }}); - parseTable.put(TreeNode.Label.term, new HashMap() {{ - put("ID", 56); - put("(", 56); - put("num", 56); - }}); - parseTable.put(TreeNode.Label.termprime, new HashMap() {{ - put(")", 60); - put(";", 60); - put("==", 60); - put("!=", 60); - put("&&", 60); - put("||", 60); - put("<", 60); - put("<=", 60); - put(">", 60); - put(">=", 60); - put("+", 60); - put("-", 60); - put("*", 57); - put("/", 58); - put("%", 59); - put("", 60); - }}); - parseTable.put(TreeNode.Label.factor, new HashMap() {{ - put("ID", 62); - put("(", 61); - put("num", 63); - }}); - parseTable.put(TreeNode.Label.printexpr, new HashMap() {{ - put("ID", 64); - put("(", 64); - put("true", 64); - put("false", 64); - put("num", 64); - put("\"", 65); - }}); - - Deque> stack = new ArrayDeque<>(); - ParseTree tree = new ParseTree(); - tree.setRoot(new TreeNode(TreeNode.Label.prog, null)); - TreeNode currentNode = tree.getRoot(); - - stack.push(new Pair<>(currentNode, "")); - - for (Token token : tokens) { + boolean terminalAvailable = false; + while (!terminalAvailable) { // ---- makes sure that we don't go onto the next token until we process it as a terminal + if (stack.getFirst().getLabel().equals(TreeNode.Label.epsilon)) { + stack.getFirst().createNode(token); + stack.pop(); + } - if (tokenToString(token).equals(stack.getFirst().getValue())) { // ----------------------------------------- handles if it's a terminal - currentNode.addChild(new TreeNode(stack.getFirst().getKey().getLabel(), token, currentNode)); - stack.pop(); - } else { - boolean terminalAvailable = false; - while (!terminalAvailable) { + if (!stack.getFirst().getLabel().equals(TreeNode.Label.terminal)) { - if (!stack.getFirst().equals(currentNode)) { // -------------------------------------- handles if it's a variable change -// TreeNode newNode = new TreeNode(stack.getFirst().getKey(), currentNode); -// currentNode.addChild(newNode); - currentNode = stack.getFirst().getKey(); + if (!stack.getFirst().getLabel().equals(TreeNode.Label.prog)) { + stack.getFirst().createNode(token); + currentNode = stack.getFirst(); + } + int ruleNum = 0; + try { + ruleNum = (int) parseTable.get(currentNode.getNode().getLabel()).get(tokenToString(token)); // ----------- checks if a rule goes with the variable + } catch (NullPointerException e) { + throw new SyntaxException("Syntactical Exception."); } - - System.out.println("Current node label is: " + currentNode.getLabel().toString() + " and current token value is: " + tokenToString(token)); - int ruleNum = (int) parseTable.get(currentNode.getLabel()).get(tokenToString(token)); // ----------- handles if a rule goes with the variable switch (ruleNum) { case 1: stack.pop(); - stack.push(new Pair<>(currentNode, "}")); - stack.push(new Pair<>(currentNode, "}")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.los), "")); - stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(currentNode, ")")); - stack.push(new Pair<>(currentNode, "args")); - stack.push(new Pair<>(currentNode, "String[]")); - stack.push(new Pair<>(currentNode, "(")); - stack.push(new Pair<>(currentNode, "main")); - stack.push(new Pair<>(currentNode, "void")); - stack.push(new Pair<>(currentNode, "static")); - stack.push(new Pair<>(currentNode, "public")); - stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(currentNode, "ID")); - stack.push(new Pair<>(currentNode, "class")); - // stack.push("public"); -- this gets popped right away + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "}")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "}")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.los, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "{")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "args")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "String[]")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "main")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "void")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "static")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "public")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "{")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "ID")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "class")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "public")); break; case 2: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.los), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.stat), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.los, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.stat, "")); break; case 3: stack.pop(); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 4: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.whilestat), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.whilestat, "")); break; case 5: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.forstat), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.forstat, "")); break; case 6: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.ifstat), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.ifstat, "")); break; case 7: stack.pop(); - stack.push(new Pair<>(currentNode, ";")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.assign), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ";")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.assign, "")); break; case 8: stack.pop(); - stack.push(new Pair<>(currentNode, ";")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.decl), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ";")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.decl, "")); break; case 9: stack.pop(); - stack.push(new Pair<>(currentNode, ";")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.print), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ";")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.print, "")); break; case 10: stack.pop(); - //stack.push(new Pair, ""); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ";")); break; case 11: stack.pop(); - stack.push(new Pair<>(currentNode, "}")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.los), "")); - stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(currentNode, ")")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); - stack.push(new Pair<>(currentNode, "(")); - stack.push(new Pair<>(currentNode, "while")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "}")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.los, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "{")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "while")); break; case 12: stack.pop(); - stack.push(new Pair<>(currentNode, "}")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); - stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(currentNode, ")")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.forarith), "")); - stack.push(new Pair<>(currentNode, ";")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.relexpr), "")); - stack.push(new Pair<>(currentNode, ";")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.forstart), "")); - stack.push(new Pair<>(currentNode, "(")); - stack.push(new Pair<>(currentNode, "if")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "}")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.los, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "{")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.forarith, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ";")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ";")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.forstart, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "for")); break; case 13: stack.pop(); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.decl), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.decl, "")); break; case 14: stack.pop(); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.assign), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.assign, "")); break; case 15: stack.pop(); - //stack.push(new Pair, ""); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 16: stack.pop(); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.arithexpr), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexpr, "")); break; case 17: stack.pop(); - //stack.push(new Pair, ""); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 18: stack.pop(); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.elseifstat), "")); - stack.push(new Pair<>(currentNode, "}")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); - stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(currentNode, ")")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); - stack.push(new Pair<>(currentNode, "(")); - stack.push(new Pair<>(currentNode, "if")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.elseifstat, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "}")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.los, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "{")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "if")); break; case 19: stack.pop(); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.elseifstat), "")); - stack.push(new Pair<>(currentNode, "}")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.los), "")); - stack.push(new Pair<>(currentNode, "{")); - stack.push(new Pair<>(createNode(currentNode,TreeNode.Label.elseorelseif), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.elseifstat, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "}")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.los, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "{")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.elseorelseif, "")); break; case 20: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 21: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.possif), "")); - stack.push(new Pair<>(currentNode, "else")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.possif, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "else")); break; case 22: stack.pop(); - stack.push(new Pair<>(currentNode, ")")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); - stack.push(new Pair<>(currentNode, "(")); - stack.push(new Pair<>(currentNode, "if")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "if")); break; case 23: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 24: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.expr), "")); - stack.push(new Pair<>(currentNode, "=")); - stack.push(new Pair<>(currentNode, "ID")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.expr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "=")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "ID")); break; case 25: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.possassign), "")); - stack.push(new Pair<>(currentNode, "ID")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.type), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.possassign, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "ID")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.type, "")); break; case 26: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.expr), "")); - stack.push(new Pair<>(currentNode, "=")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.expr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "=")); break; case 27: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 28: stack.pop(); - stack.push(new Pair<>(currentNode, "System.out.println(")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.printexpr), "")); - stack.push(new Pair<>(currentNode, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.printexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "System.out.println")); break; case 29: stack.pop(); - stack.push(new Pair<>(currentNode, "int")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "int")); break; case 30: stack.pop(); - stack.push(new Pair<>(currentNode, "char")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "char")); break; case 31: stack.pop(); - stack.push(new Pair<>(currentNode, "boolean")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "boolean")); break; case 32: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); break; case 33: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.charexpr), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.charexpr, "")); break; case 34: stack.pop(); - stack.push(new Pair<>(currentNode, "'")); - stack.push(new Pair<>(currentNode, "Char")); - stack.push(new Pair<>(currentNode, "'")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "'")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "CharLit")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "'")); break; case 35: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolop), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolop, "")); break; case 36: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 37: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.booleq), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.booleq, "")); break; case 38: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boollog), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boollog, "")); break; case 39: stack.pop(); - stack.push(new Pair<>(currentNode, "==")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "==")); break; case 40: stack.pop(); - stack.push(new Pair<>(currentNode, "!=")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "!=")); break; case 41: stack.pop(); - stack.push(new Pair<>(currentNode, "&&")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "&&")); break; case 42: stack.pop(); - stack.push(new Pair<>(currentNode, "||")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "||")); break; case 43: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexprprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexpr), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexprprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexpr, "")); break; case 44: stack.pop(); - stack.push(new Pair<>(currentNode, "true")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "true")); break; case 45: stack.pop(); - stack.push(new Pair<>(currentNode, "false")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "false")); break; case 46: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relop), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relop, "")); break; case 47: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 48: stack.pop(); - stack.push(new Pair<>(currentNode, "<")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "<")); break; case 49: stack.pop(); - stack.push(new Pair<>(currentNode, "<=")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "<=")); break; case 50: stack.pop(); - stack.push(new Pair<>(currentNode, ">")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ">")); break; case 51: stack.pop(); - stack.push(new Pair<>(currentNode, ">=")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ">=")); break; case 52: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexprprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.term), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexprprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.term, "")); break; case 53: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexprprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.term), "")); - stack.push(new Pair<>(currentNode, "+")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexprprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.term, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "+")); break; case 54: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexprprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.term), "")); - stack.push(new Pair<>(currentNode, "-")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexprprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.term, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "-")); break; case 55: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 56: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.termprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.factor, "")); break; case 57: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); - stack.push(new Pair<>(currentNode, "*")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.termprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.factor, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "*")); break; case 58: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); - stack.push(new Pair<>(currentNode, "/")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.termprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.factor, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "/")); break; case 59: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.termprime), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.factor), "")); - stack.push(new Pair<>(currentNode, "%")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.termprime, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.factor, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "%")); break; case 60: stack.pop(); - //stack.push(new Pair<>(currentNode, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.epsilon, "")); break; case 61: stack.pop(); - stack.push(new Pair<>(currentNode, ")")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.arithexpr), "")); - stack.push(new Pair<>(currentNode, "(")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, ")")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.arithexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "(")); break; case 62: stack.pop(); - stack.push(new Pair<>(currentNode, "ID")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "ID")); break; case 63: stack.pop(); - stack.push(new Pair<>(currentNode, "num")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "num")); break; case 64: stack.pop(); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.boolexpr), "")); - stack.push(new Pair<>(createNode(currentNode, TreeNode.Label.relexpr), "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.boolexpr, "")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.relexpr, "")); break; case 65: stack.pop(); - stack.push(new Pair<>(currentNode, "\"")); - stack.push(new Pair<>(currentNode, "StringLit")); - stack.push(new Pair<>(currentNode, "\"")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "\"")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "StringLit")); + stack.push(new NodeWrapper(currentNode.getNode(), TreeNode.Label.terminal, "\"")); break; } - if (!stack.getFirst().getValue().equals("")) - terminalAvailable = true; + } else if (stack.getFirst().getLabel().equals(TreeNode.Label.terminal) && stack.getFirst().getValue().equals(tokenToString(token))) { + stack.getFirst().createNode(token); + stack.pop(); + terminalAvailable = true; + } else { + throw new SyntaxException("Syntactical Exception."); } - } } -// for (Token token : tokens) { -// -// if (parseTable.get(state).get(tokenToString(token)) == null) -// throw new SyntaxException("Rule not found for token and variable combination."); -// -// int ruleNum = (int) parseTable.get(state).get(tokenToString(token)); -// switch (ruleNum) { -// case 1: -// currentNode.addChild(new TreeNode(TreeNode.Label.terminal, token, currentNode)); -// stack.push(new Pair<>(currentNode, token)); -// } -// } - - //Turn the List of Tokens into a ParseTree. return tree; } + + public static HashMap> createTable() { + + // Model Parsing table in a HashMap -- Marcell + HashMap> parseTable = new HashMap<>(); + // add rows as the value of each key + parseTable.put(TreeNode.Label.prog, new HashMap() {{ + put("public", 1); + }}); + parseTable.put(TreeNode.Label.los, new HashMap() {{ + put("ID", 2); + put(";", 2); + put("while", 2); // + + put("}", 3); + put("for", 2); + put("if", 2); + put("System.out.println", 2); + put("int", 2); + put("char", 2); + put("boolean", 2); +// put("", 2); + }}); + parseTable.put(TreeNode.Label.stat, new HashMap() {{ + put("ID", 7); + put(";", 10); + put("while", 4); + put("for", 5); + put("if", 6); + put("System.out.println", 9); + put("int", 8); + put("char", 8); + put("boolean", 8); + }}); + parseTable.put(TreeNode.Label.whilestat, new HashMap() {{ + put("while", 11); + }}); + parseTable.put(TreeNode.Label.forstat, new HashMap() {{ + put("for", 12); + }}); + parseTable.put(TreeNode.Label.forstart, new HashMap() {{ + put("ID", 14); + put(";", 15); + put("int", 13); + put("char", 13); + put("boolean", 13); + put("", 15); + }}); + parseTable.put(TreeNode.Label.forarith, new HashMap() {{ + put("ID", 16); + put("(", 16); + put(")", 17); + put("num", 16); + put("", 17); + }}); + parseTable.put(TreeNode.Label.ifstat, new HashMap() {{ + put("if", 18); + }}); + parseTable.put(TreeNode.Label.elseifstat, new HashMap() {{ + put("ID", 20); + put(";", 20); + put("while", 20); + put("}", 20); // + + put("for", 20); + put("if", 20); + put("else", 19); + put("System.out.println", 20); + put("int", 20); + put("char", 20); + put("boolean", 20); + put("", 20); + }}); + parseTable.put(TreeNode.Label.elseorelseif, new HashMap() {{ + put("else", 21); + }}); + parseTable.put(TreeNode.Label.possif, new HashMap() {{ + put("{", 23); + put("if", 22); // for -> if + put("", 23); + }}); + parseTable.put(TreeNode.Label.assign, new HashMap() {{ + put("ID", 24); + }}); + parseTable.put(TreeNode.Label.decl, new HashMap() {{ + put("int", 25); + put("char", 25); + put("boolean", 25); + }}); + parseTable.put(TreeNode.Label.possassign, new HashMap() {{ + put(";", 27); + put("=", 26); + put("", 27); + }}); + parseTable.put(TreeNode.Label.print, new HashMap() {{ + put("System.out.println", 28); + }}); + parseTable.put(TreeNode.Label.type, new HashMap() {{ + put("int", 29); + put("char", 30); + put("boolean", 31); + }}); + parseTable.put(TreeNode.Label.expr, new HashMap() {{ + put("ID", 32); + put("(", 32); + put("'", 33); + put("true", 32); + put("false", 32); + put("num", 32); + }}); + parseTable.put(TreeNode.Label.charexpr, new HashMap() {{ + put("'", 34); + }}); + parseTable.put(TreeNode.Label.boolexpr, new HashMap() {{ + put(")", 36); + put(";", 36); + put("==", 35); + put("!=", 35); + put("&&", 35); + put("||", 35); + put("", 36); + }}); + parseTable.put(TreeNode.Label.boolop, new HashMap() {{ + put("==", 37); + put("!=", 37); + put("&&", 38); + put("||", 38); + }}); + parseTable.put(TreeNode.Label.booleq, new HashMap() {{ + put("==", 39); + put("!=", 40); + }}); + parseTable.put(TreeNode.Label.boollog, new HashMap() {{ + put("&&", 41); + put("||", 42); + }}); + parseTable.put(TreeNode.Label.relexpr, new HashMap() {{ + put("ID", 43); + put("(", 43); + put("true", 44); + put("false", 45); + put("num", 43); + }}); + parseTable.put(TreeNode.Label.relexprprime, new HashMap() {{ + put(")", 47); + put(";", 47); + put("==", 47); + put("!=", 47); + put("&&", 47); + put("||", 47); + put("<", 46); + put("<=", 46); + put(">", 46); + put(">=", 46); + put("", 47); + }}); + parseTable.put(TreeNode.Label.relop, new HashMap() {{ + put("<", 48); + put("<=", 49); + put(">", 50); + put(">=", 51); + }}); + parseTable.put(TreeNode.Label.arithexpr, new HashMap() {{ + put("ID", 52); + put("(", 52); + put("num", 52); + }}); + parseTable.put(TreeNode.Label.arithexprprime, new HashMap() {{ + put(")", 55); + put(";", 55); + put("==", 55); + put("!=", 55); + put("&&", 55); + put("||", 55); + put("<", 55); + put("<=", 55); + put(">", 55); + put(">=", 55); + put("+", 53); + put("-", 54); + put("", 55); + }}); + parseTable.put(TreeNode.Label.term, new HashMap() {{ + put("ID", 56); + put("(", 56); + put("num", 56); + }}); + parseTable.put(TreeNode.Label.termprime, new HashMap() {{ + put(")", 60); + put(";", 60); + put("==", 60); + put("!=", 60); + put("&&", 60); + put("||", 60); + put("<", 60); + put("<=", 60); + put(">", 60); + put(">=", 60); + put("+", 60); + put("-", 60); + put("*", 57); + put("/", 58); + put("%", 59); + put("", 60); + }}); + parseTable.put(TreeNode.Label.factor, new HashMap() {{ + put("ID", 62); + put("(", 61); + put("num", 63); + }}); + parseTable.put(TreeNode.Label.printexpr, new HashMap() {{ + put("ID", 64); + put("(", 64); + put("true", 64); + put("false", 64); + put("num", 64); + put("\"", 65); + }}); +// parseTable.put(TreeNode.Label.epsilon, new HashMap() {{ +// +// }}); + return parseTable; + + } + + private static String tokenToString(Token token) { + switch (token.getType()) { + case PLUS: + return "+"; + case MINUS: + return "-"; + case TIMES: + return "*"; + case DIVIDE: + return "/"; + case MOD: + return "%"; + case ASSIGN: + return "="; + case EQUAL: + return "=="; + case NEQUAL: + return "!="; + case LT: + return "<"; + case LE: + return "<="; + case GT: + return ">"; + case GE: + return ">="; + case LPAREN: + return "("; + case RPAREN: + return ")"; + case LBRACE: + return "{"; + case RBRACE: + return "}"; + case AND: + return "&&"; + case OR: + return "||"; + case SEMICOLON: + return ";"; + case PUBLIC: + return "public"; + case CLASS: + return "class"; + case STATIC: + return "static"; + case VOID: + return "void"; + case MAIN: + return "main"; + case STRINGARR: + return "String[]"; + case ARGS: + return "args"; + case TYPE: + return token.getValue().get(); + case PRINT: + return "System.out.println"; + case WHILE: + return "while"; + case FOR: + return "for"; + case IF: + return "if"; + case ELSE: + return "else"; + case DQUOTE: + return "\""; + case SQUOTE: + return "'"; + case ID: + return "ID"; + case NUM: + return "num"; + case TRUE: + return "true"; + case FALSE: + return "false"; + case STRINGLIT: + return "StringLit"; + case CHARLIT: + return "CharLit"; + } + return ""; + } }