From 8e748a7574fbfc630d7c70ed731306b62e92a236 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vanja=20Stojanovi=C4=87?= Date: Tue, 14 Mar 2023 22:31:49 +0100 Subject: [PATCH] I think i fixed some braces problem --- .vscode/launch.json | 2 +- TestsRunner/tests/2-parser.tst | 3 +- src/cli/ForwardingSet.java | 152 +++++++++++------------ src/cli/PINS.java | 211 ++++++++++++++++---------------- src/common/Report.java | 65 +++++----- src/common/RequireNonNull.java | 21 ++-- src/common/StringUtil.java | 41 ++++--- src/compiler/parser/Parser.java | 74 ++++++----- test3.pns | 10 +- 9 files changed, 300 insertions(+), 279 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index 43cd996..23fa8bb 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -24,7 +24,7 @@ "request": "launch", "mainClass": "Main", "projectName": "PINS-compiler_7d951449", - "args": "PINS --dump SYN test3.pns" + "args": "PINS --exec SYN --dump SYN test3.pns" } ] } \ No newline at end of file diff --git a/TestsRunner/tests/2-parser.tst b/TestsRunner/tests/2-parser.tst index 367edb6..9632d76 100644 --- a/TestsRunner/tests/2-parser.tst +++ b/TestsRunner/tests/2-parser.tst @@ -50,7 +50,7 @@ definitions_1 -> ε !name: Function Compare Statement !code: -fun id ( neki : integer ) : logical = neki == integer_const +fun id ( neki : integer ) : logical = neki == 99 !expected: source -> definitions definitions -> definition definitions_1 @@ -89,3 +89,4 @@ expression_1 -> ε definitions_1 -> ε !end + diff --git a/src/cli/ForwardingSet.java b/src/cli/ForwardingSet.java index 2a923ae..0dc282e 100644 --- a/src/cli/ForwardingSet.java +++ b/src/cli/ForwardingSet.java @@ -3,81 +3,81 @@ * @Description: Implementacija vmesnika `Set`. */ -package cli; + package cli; -import java.util.Collection; -import java.util.Iterator; -import java.util.Set; - -public class ForwardingSet implements Set { - private Set set; - - public ForwardingSet(Set set) { - this.set = set; - } - - @Override - public int size() { - return set.size(); - } - - @Override - public boolean isEmpty() { - return set.isEmpty(); - } - - @Override - public boolean contains(Object o) { - return set.contains(o); - } - - @Override - public Iterator iterator() { - return set.iterator(); - } - - @Override - public Object[] toArray() { - return set.toArray(); - } - - @Override - public R[] toArray(R[] a) { - return set.toArray(a); - } - - @Override - public boolean add(T e) { - return set.add(e); - } - - @Override - public boolean remove(Object o) { - return set.remove(o); - } - - @Override - public boolean containsAll(Collection c) { - return set.containsAll(c); - } + import java.util.Collection; + import java.util.Iterator; + import java.util.Set; + + public class ForwardingSet implements Set { + private Set set; + + public ForwardingSet(Set set) { + this.set = set; + } - @Override - public boolean addAll(Collection c) { - return set.addAll(c); - } - - @Override - public boolean retainAll(Collection c) { - return set.retainAll(c); - } - - @Override - public boolean removeAll(Collection c) { - return set.removeAll(c); - } - - @Override - public void clear() { - set.clear(); - } -} \ No newline at end of file + @Override + public int size() { + return set.size(); + } + + @Override + public boolean isEmpty() { + return set.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return set.contains(o); + } + + @Override + public Iterator iterator() { + return set.iterator(); + } + + @Override + public Object[] toArray() { + return set.toArray(); + } + + @Override + public R[] toArray(R[] a) { + return set.toArray(a); + } + + @Override + public boolean add(T e) { + return set.add(e); + } + + @Override + public boolean remove(Object o) { + return set.remove(o); + } + + @Override + public boolean containsAll(Collection c) { + return set.containsAll(c); + } + + @Override + public boolean addAll(Collection c) { + return set.addAll(c); + } + + @Override + public boolean retainAll(Collection c) { + return set.retainAll(c); + } + + @Override + public boolean removeAll(Collection c) { + return set.removeAll(c); + } + + @Override + public void clear() { + set.clear(); + } + } \ No newline at end of file diff --git a/src/cli/PINS.java b/src/cli/PINS.java index 142ec1e..02a629f 100644 --- a/src/cli/PINS.java +++ b/src/cli/PINS.java @@ -3,109 +3,110 @@ * @Description: Uporabniški vmesnik (CLI). */ -package cli; + package cli; -import java.util.EnumSet; - -import ArgPar.Annotation.ParsableArgument; -import ArgPar.Annotation.ParsableCommand; -import ArgPar.Annotation.ParsableOption; -import ArgPar.Exception.ParseException; -import ArgPar.Parser.ArgumentParser; - -@ParsableCommand(commandName = "PINS", description = "Prevajalnik za programski jezik PINS") -public class PINS { - /** - * Pot do izvorne datoteke. - */ - @ParsableArgument - public String sourceFile; - - /** - * Faze prevajanja, ki izpišejo vmesne rezultate. - */ - @ParsableOption(name = "--dump") - public PhasesEnumSet dumpPhases = PhasesEnumSet.empty(); - - /** - * Faza, ki se bo izvedla nazadnje. - */ - @ParsableOption(name = "--exec") - public Phase execPhase = Phase.LEX; - - @ParsableOption(name = "--memory") - public int memory = 1024; - - /** - * Razčleni argumente. - */ - public static PINS parse(String[] args) { - try { - var parser = new ArgumentParser(PINS.class); - return parser.parse(args); - } catch (ParseException __) { - System.exit(2); - return null; - } - } - - // -------------------------------------------------------------- - - /** - * Faze prevajanja. - */ - public static enum Phase { - LEX, SYN, AST, NAME, TYP, FRM, IMC, INT - } - - /** - * Razred, ki hrani faze prevajanja. - */ - public static class PhasesEnumSet extends ForwardingSet { - PhasesEnumSet(EnumSet set) { - super(set); - } - - /** - * Ustvari prazno možico. - */ - static PhasesEnumSet empty() { - return new PhasesEnumSet(EnumSet.noneOf(Phase.class)); - } - - /** - * Razčleni argument in kreira novo množico. - * - * @param arg Argument, ki ga metoda razčleni v množico faz. - */ - public static PhasesEnumSet valueOf(String arg) { - var split = arg.split(","); - var set = new PhasesEnumSet(EnumSet.noneOf(Phase.class)); - for (var s : split) { - var phase = Phase.valueOf(s.trim()); - if (phase == null) { - throw new IllegalArgumentException("Could not parse !"); - } - set.add(phase); - } - return set; - } - - @Override - public String toString() { - if (isEmpty()) { - return "{}"; - } - var sb = new StringBuilder(); - sb.append("{"); - for (var phase : Phase.values()) { - if (contains(phase)) { - sb.append(phase.toString() + ","); - } - } - sb.deleteCharAt(sb.length() - 1); - sb.append("}"); - return sb.toString(); - } - } -} + import java.util.EnumSet; + + import ArgPar.Annotation.ParsableArgument; + import ArgPar.Annotation.ParsableCommand; + import ArgPar.Annotation.ParsableOption; + import ArgPar.Exception.ParseException; + import ArgPar.Parser.ArgumentParser; + + @ParsableCommand(commandName = "PINS", description = "Prevajalnik za programski jezik PINS") + public class PINS { + /** + * Pot do izvorne datoteke. + */ + @ParsableArgument + public String sourceFile; + + /** + * Faze prevajanja, ki izpišejo vmesne rezultate. + */ + @ParsableOption(name = "--dump") + public PhasesEnumSet dumpPhases = PhasesEnumSet.empty(); + + /** + * Faza, ki se bo izvedla nazadnje. + */ + @ParsableOption(name = "--exec") + public Phase execPhase = Phase.LEX; + + @ParsableOption(name = "--memory") + public int memory = 1024; + + /** + * Razčleni argumente. + */ + public static PINS parse(String[] args) { + try { + var parser = new ArgumentParser(PINS.class); + return parser.parse(args); + } catch (ParseException __) { + System.exit(2); + return null; + } + } + + // -------------------------------------------------------------- + + /** + * Faze prevajanja. + */ + public static enum Phase { + LEX, SYN, AST, NAME, TYP, FRM, IMC, INT + } + + /** + * Razred, ki hrani faze prevajanja. + */ + public static class PhasesEnumSet extends ForwardingSet { + PhasesEnumSet(EnumSet set) { + super(set); + } + + /** + * Ustvari prazno možico. + */ + static PhasesEnumSet empty() { + return new PhasesEnumSet(EnumSet.noneOf(Phase.class)); + } + + /** + * Razčleni argument in kreira novo množico. + * + * @param arg Argument, ki ga metoda razčleni v množico faz. + */ + public static PhasesEnumSet valueOf(String arg) { + var split = arg.split(","); + var set = new PhasesEnumSet(EnumSet.noneOf(Phase.class)); + for (var s : split) { + var phase = Phase.valueOf(s.trim()); + if (phase == null) { + throw new IllegalArgumentException("Could not parse !"); + } + set.add(phase); + } + return set; + } + + @Override + public String toString() { + if (isEmpty()) { + return "{}"; + } + var sb = new StringBuilder(); + sb.append("{"); + for (var phase : Phase.values()) { + if (contains(phase)) { + sb.append(phase.toString() + ","); + } + } + sb.deleteCharAt(sb.length() - 1); + sb.append("}"); + return sb.toString(); + } + } + } + \ No newline at end of file diff --git a/src/common/Report.java b/src/common/Report.java index 5f62cbd..9a5f9bd 100644 --- a/src/common/Report.java +++ b/src/common/Report.java @@ -3,35 +3,36 @@ * @Description: Razred, namenjen obveščanju o poteku prevajanja. */ -package common; - -import java.io.PrintStream; - -import compiler.lexer.Position; - -/** - * Obveščanje o napakah. - */ -public class Report { - /** - * NE SPREMINJAJ! - */ - private static final int exitErrorCode = 99; - - /** - * Izhodni tok, kamor se izpišejo napake. - */ - public static PrintStream err = System.err; - - private Report() {} - - public static void error(String message) { - err.println(message); - System.exit(exitErrorCode); - } - - public static void error(Position position, String message) { - err.println(position.toString() + ": " + message); - System.exit(exitErrorCode); - } -} + package common; + + import java.io.PrintStream; + + import compiler.lexer.Position; + + /** + * Obveščanje o napakah. + */ + public class Report { + /** + * NE SPREMINJAJ! + */ + private static final int exitErrorCode = 99; + + /** + * Izhodni tok, kamor se izpišejo napake. + */ + public static PrintStream err = System.err; + + private Report() {} + + public static void error(String message) { + err.println(message); + System.exit(exitErrorCode); + } + + public static void error(Position position, String message) { + err.println(position.toString() + ": " + message); + System.exit(exitErrorCode); + } + } + \ No newline at end of file diff --git a/src/common/RequireNonNull.java b/src/common/RequireNonNull.java index 26ebd9d..e628186 100644 --- a/src/common/RequireNonNull.java +++ b/src/common/RequireNonNull.java @@ -3,14 +3,15 @@ * @ Description: */ -package common; + package common; -import java.util.Objects; - -public class RequireNonNull { - public static void requireNonNull(Object... objects) { - for (var obj : objects) { - Objects.requireNonNull(obj); - } - } -} + import java.util.Objects; + + public class RequireNonNull { + public static void requireNonNull(Object... objects) { + for (var obj : objects) { + Objects.requireNonNull(obj); + } + } + } + \ No newline at end of file diff --git a/src/common/StringUtil.java b/src/common/StringUtil.java index d216aba..91695ed 100644 --- a/src/common/StringUtil.java +++ b/src/common/StringUtil.java @@ -1,24 +1,25 @@ /** - * @Author: turk - * @Description: + * @ Author: turk + * @ Description: */ -package common; + package common; -import static common.RequireNonNull.requireNonNull; - -public class StringUtil { - /** - * Kreira nov indentiran niz. - */ - public static String indented(String str, int indent) { - requireNonNull(str); - if (indent < 0) { throw new IllegalArgumentException("Indent must be at least 0!"); } - var sb = new StringBuilder(indent); - for (int i = 0; i < indent; i++) { - sb.append(" "); - } - sb.append(str); - return sb.toString(); - } -} + import static common.RequireNonNull.requireNonNull; + + public class StringUtil { + /** + * Kreira nov indentiran niz. + */ + public static String indented(String str, int indent) { + requireNonNull(str); + if (indent < 0) { throw new IllegalArgumentException("Indent must be at least 0!"); } + var sb = new StringBuilder(indent); + for (int i = 0; i < indent; i++) { + sb.append(" "); + } + sb.append(str); + return sb.toString(); + } + } + \ No newline at end of file diff --git a/src/compiler/parser/Parser.java b/src/compiler/parser/Parser.java index f93bb58..a6d24b2 100644 --- a/src/compiler/parser/Parser.java +++ b/src/compiler/parser/Parser.java @@ -120,7 +120,7 @@ else if (currentLexicalSym.tokenType == TokenType.KW_ARR) { } private void parseFunDef(ListIterator lexicalSymbol) { - dump("function_definition -> fun id ( parameters ) : type = expression"); + dump("function_definition -> fun id \'(\' parameters \')\' \':\' type \'=\' expression"); Symbol currentLexicalSym = lexicalSymbol.next(); if (currentLexicalSym.tokenType != TokenType.IDENTIFIER) Report.error(currentLexicalSym.position, @@ -150,11 +150,13 @@ private void parseExpression(ListIterator lexicalSymbol) { dump("expression -> logical_ior_expression expression_1"); parseLogicalOrExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - dump("expression_1 -> { WHERE definitions } | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_LBRACE) + if (currentLexicalSym.tokenType == TokenType.OP_LBRACE) { + dump("expression_1 -> { WHERE definitions }"); parseExpression_1(lexicalSymbol); - else + } else { + dump("expression_1 -> ε"); lexicalSymbol.previous(); + } } private void parseExpression_1(ListIterator lexicalSymbol) { @@ -173,42 +175,50 @@ private void parseLogicalOrExpression(ListIterator lexicalSymbol) { dump("logical_ior_expression -> logical_and_expression logical_ior_expression_1"); parseLogicalAndExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - dump("logical_ior_expression_1 -> \'|\' logical_and_expression logical_ior_expression_1 | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_OR) + if (currentLexicalSym.tokenType == TokenType.OP_OR) { + dump("logical_ior_expression_1 -> \'|\' logical_and_expression logical_ior_expression_1"); parseLogicalOrExpression_1(lexicalSymbol); - else + } else { + dump("logical_ior_expression_1 -> ε"); lexicalSymbol.previous(); + } } private void parseLogicalOrExpression_1(ListIterator lexicalSymbol) { parseLogicalAndExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - dump("logical_ior_expression_1 -> \'|\' logical_and_expression logical_ior_expression_1 | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_OR) + if (currentLexicalSym.tokenType == TokenType.OP_OR) { + dump("logical_ior_expression_1 -> \'|\' logical_and_expression logical_ior_expression_1"); parseLogicalOrExpression_1(lexicalSymbol); - else + } else { + dump("logical_ior_expression_1 -> ε"); lexicalSymbol.previous(); + } } private void parseLogicalAndExpression(ListIterator lexicalSymbol) { dump("logical_and_expression -> compare_expression logical_and_expression_1"); parseCompareExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - dump("logical_and_expression_1 -> \'&\' compare_expression logical_and_expression_1 | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_AND) + if (currentLexicalSym.tokenType == TokenType.OP_AND) { + dump("logical_and_expression_1 -> \'&\' compare_expression logical_and_expression_1"); parseLogicalAndExpression_1(lexicalSymbol); - else + } else { + dump("logical_and_expression_1 -> ε"); lexicalSymbol.previous(); + } } private void parseLogicalAndExpression_1(ListIterator lexicalSymbol) { parseCompareExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - dump("logical_and_expression_1 -> \'&\' compare_expression logical_and_expression_1 | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_AND) + if (currentLexicalSym.tokenType == TokenType.OP_AND) { + dump("logical_and_expression_1 -> \'&\' compare_expression logical_and_expression_1"); parseLogicalAndExpression_1(lexicalSymbol); - else + } else { + dump("logical_and_expression_1 -> ε"); lexicalSymbol.previous(); + } } private void parseCompareExpression(ListIterator lexicalSymbol) { @@ -346,7 +356,7 @@ private void parsePostfixExpression(ListIterator lexicalSymbol) { lexicalSymbol.previous(); parsePostfixExpression_1(lexicalSymbol); } else { - dump("postfix_expression -> ε"); + dump("postfix_expression_1 -> ε"); lexicalSymbol.previous(); } } @@ -360,6 +370,7 @@ private void parsePostfixExpression_1(ListIterator lexicalSymbol) { if (currentLexicalSym.tokenType != TokenType.OP_RBRACKET) Report.error(currentLexicalSym.position, "Following expressions a right closing square bracket is required"); + lexicalSymbol.previous(); parsePostfixExpression(lexicalSymbol); } @@ -379,14 +390,14 @@ private void parseAtomExpression(ListIterator lexicalSymbol) { dump("atom_expression -> id atom_expression_id"); currentLexicalSym = lexicalSymbol.next(); if (currentLexicalSym.tokenType == TokenType.OP_LPARENT) { - dump("atom_expression_1 -> \'(\' expressions \')\'"); + dump("atom_expression_id -> \'(\' expressions \')\'"); parseExpressions(lexicalSymbol); currentLexicalSym = lexicalSymbol.next(); if (currentLexicalSym.tokenType != TokenType.OP_RPARENT) Report.error(currentLexicalSym.position, - "Expressions should be closed with a closing left paranthesis"); + "Expressions should be closed with a closing right paranthesis"); } else { - dump("atom_expression_1 -> ε"); + dump("atom_expression_id -> ε"); lexicalSymbol.previous(); } break; @@ -396,7 +407,7 @@ private void parseAtomExpression(ListIterator lexicalSymbol) { currentLexicalSym = lexicalSymbol.next(); if (currentLexicalSym.tokenType != TokenType.OP_RPARENT) Report.error(currentLexicalSym.position, - "Expressions should be closed with a closing left paranthesis"); + "Expressions should be closed with a closing right paranthesis"); break; case OP_LBRACE: dump("atom_expression -> \'{\' atom_expression_lbrace_1"); @@ -498,7 +509,7 @@ private void parseExpressions(ListIterator lexicalSymbol) { dump("expressions -> expression expressions_1"); parseExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - if(currentLexicalSym.tokenType == TokenType.OP_COMMA) { + if (currentLexicalSym.tokenType == TokenType.OP_COMMA) { dump("expressions_1 -> \',\' expression expressions_1"); parseExpressions_1(lexicalSymbol); } else { @@ -510,7 +521,7 @@ private void parseExpressions(ListIterator lexicalSymbol) { private void parseExpressions_1(ListIterator lexicalSymbol) { parseExpression(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - if(currentLexicalSym.tokenType == TokenType.OP_COMMA) { + if (currentLexicalSym.tokenType == TokenType.OP_COMMA) { dump("expressions_1 -> \',\' expression expressions_1"); parseExpressions_1(lexicalSymbol); } else { @@ -522,22 +533,19 @@ private void parseExpressions_1(ListIterator lexicalSymbol) { private void parseParams(ListIterator lexicalSymbol) { dump("parameters -> parameter parameters_1"); parseParam(lexicalSymbol); - Symbol currentLexicalSym = lexicalSymbol.next(); - dump("parameters_1 -> , parameter parameters_1 | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_COMMA) - parseParams_1(lexicalSymbol); - else - lexicalSymbol.previous(); + parseParams_1(lexicalSymbol); } private void parseParams_1(ListIterator lexicalSymbol) { - parseParam(lexicalSymbol); Symbol currentLexicalSym = lexicalSymbol.next(); - dump("parameters_1 -> , parameter parameters_1 | ε"); - if (currentLexicalSym.tokenType == TokenType.OP_COMMA) + if (currentLexicalSym.tokenType == TokenType.OP_COMMA) { + dump("parameters_1 -> , parameter parameters_1"); + parseParam(lexicalSymbol); parseParams_1(lexicalSymbol); - else + } else { + dump("parameters_1 -> ε"); lexicalSymbol.previous(); + } } private void parseParam(ListIterator lexicalSymbol) { diff --git a/test3.pns b/test3.pns index 43e94db..a8ecf69 100644 --- a/test3.pns +++ b/test3.pns @@ -1 +1,9 @@ -typ neki : string \ No newline at end of file +fun prestejCrke (i:integer): integer = { + while (i < j[100/2]): + { + for i = 10, i < 100, i + 1: + { + if i == 69 then print(i) + } + } +} \ No newline at end of file