From 73752feba89006d460689e21e920b3147007ddc0 Mon Sep 17 00:00:00 2001 From: colindelotavo <60180147+colindelotavo@users.noreply.github.com> Date: Thu, 7 Oct 2021 17:31:05 +1100 Subject: [PATCH 1/6] Update LexicalAnalyser.java Fix NotEqual Case --- Assignment2/src/com/company/LexicalAnalyser.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index ec3f9bf..54274d6 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -1,4 +1,4 @@ -package com.company; +// package com.company; import java.util.List; import java.util.Optional; import java.util.Collections; @@ -50,6 +50,8 @@ public static List analyse(String sourceCode) throws LexicalException { tokenList.add(tokenTypeLE(s).get()); } else if (furtherSplitList.get(i).matches("^[=].*")) { tokenList.add(tokenTypeEqual(s).get()); + } else if (furtherSplitList.get(i).matches("^[!].*")) { + tokenList.add(tokenTypeNotEqual(s).get()); } else { tokenList.add(tokenTypeEqual(s).get()); } @@ -110,6 +112,13 @@ private static Optional tokenTypeEqual(String t) { return Optional.empty(); } + private static Optional tokenTypeNotEqual(String t) { + Optional type = Optional.of(Token.TokenType.NEQUAL); + if (type.isPresent()) + return Optional.of(new Token(type.get(), t)); + return Optional.empty(); + } + private static Optional tokenTypeOf(String t) { switch (t) { case "public": From 0c6320f5056fc87d1ac8410e048edca9b0d894bb Mon Sep 17 00:00:00 2001 From: colindelotavo <60180147+colindelotavo@users.noreply.github.com> Date: Sun, 17 Oct 2021 22:21:17 +1100 Subject: [PATCH 2/6] Update SyntacticAnalyser.java --- .../src/com/company/SyntacticAnalyser.java | 238 ++++++++++++++++++ 1 file changed, 238 insertions(+) diff --git a/Assignment2/src/com/company/SyntacticAnalyser.java b/Assignment2/src/com/company/SyntacticAnalyser.java index 8f4cb31..2cefc41 100644 --- a/Assignment2/src/com/company/SyntacticAnalyser.java +++ b/Assignment2/src/com/company/SyntacticAnalyser.java @@ -11,6 +11,244 @@ public class SyntacticAnalyser { public static ParseTree parse(List tokens) throws SyntaxException { + + // Model Parsing table in a HashMap -- Marcell + HashMap parseTable = new HashMap<>(); + // add rows as the value of each key + parseTable.put("Prog", new HashMap() {{ + put("public",1); + }}); + parseTable.put("Los", new HashMap() {{ + put("ID",2); + put("}}",3); + 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("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("While", new HashMap() {{ + put("while",11); + }}); + parseTable.put("For", new HashMap() {{ + put("For",12); + }}); + parseTable.put("Forstart", new HashMap() {{ + put("ID",14); + put(";",15); + put("int",13); + put("char",13); + put("boolean",13); + put("",15); + }}); + parseTable.put("Forarith", new HashMap() {{ + put("ID",16); + put("(",16); + put(")",17); + put("num",16); + put("",17); + }}); + parseTable.put("If", new HashMap() {{ + put("if",18); + }}); + parseTable.put("Elseif", new HashMap() {{ + put("ID",20); + put("}}",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("ElseQif", new HashMap() {{ + put("else",21); + }}); + parseTable.put("Possif", new HashMap() {{ + put("{",23); + put("if",22); // for -> if + put("",23); + }}); + parseTable.put("Assign", new HashMap() {{ + put("ID",24); + }}); + parseTable.put("Decl", new HashMap() {{ + put("int",25); + put("char",25); + put("boolean",25); + }}); + parseTable.put("Possassign", new HashMap() {{ + put(";",27); + put("=",26); + put("",27); + }}); + parseTable.put("Print", new HashMap() {{ + put("System.out.println(",28); + }}); + parseTable.put("Type", new HashMap() {{ + put("int",29); + put("char",30); + put("boolean",31); + }}); + parseTable.put("Expr", new HashMap() {{ + put("ID",32); + put("(",32); + put("'",33); + put("true",32); + put("false",32); + put("num",32); + }}); + parseTable.put("Charexpr", new HashMap() {{ + put("'",34); + }}); + parseTable.put("Boolexpr", new HashMap() {{ + put(")",36); + put(";",36); + put("==",35); + put("!=",35); + put("&&",35); + put("||",35); + put("",36); + }}); + parseTable.put("Boolop", new HashMap() {{ + put("==",37); + put("!=",37); + put("&&",38); + put("||",38); + }}); + parseTable.put("Booleq", new HashMap() {{ + put("==",39); + put("!=",40); + }}); + parseTable.put("Boollog", new HashMap() {{ + put("&&",41); + put("||",42); + }}); + parseTable.put("Relexpr", new HashMap() {{ + put("ID",43); + put("(",43); + put("true",44); + put("false",45); + put("num",43); + }}); + parseTable.put("Relexpr2", 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("Relop", new HashMap() {{ + put("<",48); + put("<=",49); + put(">",50); + put(">=",51); + }}); + parseTable.put("Arithexpr", new HashMap() {{ + put("ID",52); + put("(",52); + put("num",52); + }}); + parseTable.put("Arithexpr2", 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("Term", new HashMap() {{ + put("ID",56); + put("(",56); + put("num",56); + }}); + parseTable.put("Term2", 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("Factor", new HashMap() {{ + put("ID",62); + put("(",61); + put("num",63); + }}); + parseTable.put("Printexpr", new HashMap() {{ + put("ID",64); + put("(",64); + put("true",64); + put("false",64); + put("num",64); + put("\"",65); + }}); + parseTable.put("Variables", new HashMap() {{ + put("/",67); + put("num",66); + put("",67); + }}); + parseTable.put("Variable", new HashMap() {{ + put("num",68); + }}); + parseTable.put("Operators", new HashMap() {{ + put("%",70); + put("\"",69); + put("Stringlit",69); + put("",70); + }}); + parseTable.put("Operator", new HashMap() {{ + put("\"",71); + put("Stringlit",72); + }}); + + + + //Turn the List of Tokens into a ParseTree. return new ParseTree(); } From 06e635bcd2816813ca214b9db7207878d7a17d4b Mon Sep 17 00:00:00 2001 From: colindelotavo <60180147+colindelotavo@users.noreply.github.com> Date: Wed, 20 Oct 2021 19:48:07 +1100 Subject: [PATCH 3/6] Update SyntacticAnalyser.java --- .../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 2cefc41..89d4d6d 100644 --- a/Assignment2/src/com/company/SyntacticAnalyser.java +++ b/Assignment2/src/com/company/SyntacticAnalyser.java @@ -10,6 +10,90 @@ 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 token.getValue() + ""; + 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 { // Model Parsing table in a HashMap -- Marcell @@ -20,7 +104,6 @@ public static ParseTree parse(List tokens) throws SyntaxException { }}); parseTable.put("Los", new HashMap() {{ put("ID",2); - put("}}",3); put(";",2); put("while",2); // + put("}",3); @@ -69,7 +152,6 @@ public static ParseTree parse(List tokens) throws SyntaxException { }}); parseTable.put("Elseif", new HashMap() {{ put("ID",20); - put("}}",20); put(";",20); put("while",20); put("}",20); // + From c75abb976b6fd29071f74f12f40a4cc06546b3e0 Mon Sep 17 00:00:00 2001 From: colindelotavo <60180147+colindelotavo@users.noreply.github.com> Date: Fri, 22 Oct 2021 18:08:31 +1100 Subject: [PATCH 4/6] Update LexicalAnalyser.java Cleaned up code --- .../src/com/company/LexicalAnalyser.java | 91 ++++++++----------- 1 file changed, 40 insertions(+), 51 deletions(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index 54274d6..52204c6 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -1,4 +1,3 @@ -// package com.company; import java.util.List; import java.util.Optional; import java.util.Collections; @@ -8,21 +7,21 @@ public class LexicalAnalyser { - public static List analyse(String sourceCode) throws LexicalException { - // Turn the input String into a list of Tokens! - String[] splitList = sourceCode.split(" "); + public static List analyse(String sourceCode) throws LexicalException { + // Turn the input String into a list of Tokens! + String[] splitList = sourceCode.split(" "); List tokenCase = Arrays.asList(new String[]{ - "\"", "\'", "(", ")", "{", "}", - ";", "+", "-", "*", "/", "%" + "\"", "'", "(", ")", "{", "}", + ";", "+", "-", "*", "/", "%" }); - List furtherSplitList = new ArrayList(); - List tokenList = new ArrayList(); + 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)); + 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)); if (tokenCase.contains(c)) { furtherSplitList.add(s); furtherSplitList.add(c); @@ -30,45 +29,40 @@ public static List analyse(String sourceCode) throws LexicalException { } else { s += c; } - } - furtherSplitList.add(s); - } - // System.out.println(furtherSplitList); + } + furtherSplitList.add(s); + } + // System.out.println(furtherSplitList); 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("\"")) { + 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("\'")) { + } else if (i > 0 && furtherSplitList.get(i - 1).matches("'")) { tokenList.add(tokenTypeCharLit(s).get()); - } else if (i < furtherSplitList.size()-1 && furtherSplitList.get(i).matches(".[=]$")) { + } else if (i < furtherSplitList.size() - 1 && furtherSplitList.get(i).matches(".[=]$")) { // System.out.println(furtherSplitList.get(i)); - if (furtherSplitList.get(i).matches("^[>].*")) { + if (furtherSplitList.get(i).matches("^[>].*")) { tokenList.add(tokenTypeGE(s).get()); - } else if (furtherSplitList.get(i).matches("^[<].*")) { + } else if (furtherSplitList.get(i).matches("^[<].*")) { tokenList.add(tokenTypeLE(s).get()); - } else if (furtherSplitList.get(i).matches("^[=].*")) { - tokenList.add(tokenTypeEqual(s).get()); } else if (furtherSplitList.get(i).matches("^[!].*")) { - tokenList.add(tokenTypeNotEqual(s).get()); - } else { + tokenList.add(tokenTypeNE(s).get()); + } else if (furtherSplitList.get(i).matches("^[=].*")) { tokenList.add(tokenTypeEqual(s).get()); - } - } - else { tokenList.add(tokenFromString(s).get()); } - } - catch (NoSuchElementException e) { - // tokenList.add(Optional.empty()); + } else { tokenList.add(tokenTypeEqual(s).get()); } + } else {tokenList.add(tokenFromString(s).get()); } + } catch (NoSuchElementException e) { + // tokenList.add(Optional.empty()); System.out.print("Token not found: " + e + "\n"); - } - catch (Exception e) { + } catch (Exception e) { System.out.print(e); } - } - } - return tokenList; - } + } + } + return tokenList; + } private static Optional tokenFromString(String t) { Optional type = tokenTypeOf(t); @@ -111,8 +105,8 @@ private static Optional tokenTypeEqual(String t) { return Optional.of(new Token(type.get(), t)); return Optional.empty(); } - - private static Optional tokenTypeNotEqual(String 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)); @@ -185,22 +179,17 @@ private static Optional tokenTypeOf(String t) { 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); + case "\"": + return Optional.of(Token.TokenType.DQUOTE); + case "'": + return Optional.of(Token.TokenType.SQUOTE); } - 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(); } From 06d0724b8e8aad5ad31cc39870b4a22eefd88e68 Mon Sep 17 00:00:00 2001 From: colindelotavo <60180147+colindelotavo@users.noreply.github.com> Date: Wed, 27 Oct 2021 19:28:29 +1100 Subject: [PATCH 5/6] Update LexicalAnalyser.java Throws LexicalException --- Assignment2/src/com/company/LexicalAnalyser.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index 52204c6..f94c907 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -37,6 +37,7 @@ public static List analyse(String sourceCode) throws LexicalException { String s = furtherSplitList.get(i); if (s.length() > 0) { try { + System.out.println(s); if (i > 0 && furtherSplitList.get(i - 1).matches("\"")) { tokenList.add(tokenTypeStringLit(s).get()); } else if (i > 0 && furtherSplitList.get(i - 1).matches("'")) { @@ -55,7 +56,8 @@ public static List analyse(String sourceCode) throws LexicalException { } else {tokenList.add(tokenFromString(s).get()); } } catch (NoSuchElementException e) { // tokenList.add(Optional.empty()); - System.out.print("Token not found: " + e + "\n"); + // System.out.print("Token not found: " + e + "\n"); + throw new LexicalException("Token not found: " + e); } catch (Exception e) { System.out.print(e); } From ca90b3836d5c8d86ce450706665dfb896239c06f Mon Sep 17 00:00:00 2001 From: colindelotavo <60180147+colindelotavo@users.noreply.github.com> Date: Wed, 27 Oct 2021 19:38:01 +1100 Subject: [PATCH 6/6] Update LexicalAnalyser.java --- Assignment2/src/com/company/LexicalAnalyser.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Assignment2/src/com/company/LexicalAnalyser.java b/Assignment2/src/com/company/LexicalAnalyser.java index f94c907..e73b2b6 100644 --- a/Assignment2/src/com/company/LexicalAnalyser.java +++ b/Assignment2/src/com/company/LexicalAnalyser.java @@ -37,7 +37,7 @@ public static List analyse(String sourceCode) throws LexicalException { String s = furtherSplitList.get(i); if (s.length() > 0) { try { - System.out.println(s); +// System.out.println(s); if (i > 0 && furtherSplitList.get(i - 1).matches("\"")) { tokenList.add(tokenTypeStringLit(s).get()); } else if (i > 0 && furtherSplitList.get(i - 1).matches("'")) {