From 6bdf1fc6c1b7afe18ffcae05f8fb11eca0f51258 Mon Sep 17 00:00:00 2001 From: Santo Cariotti Date: Tue, 25 Jun 2024 11:33:41 +0200 Subject: wip --- progs/test.py | 19 +++---------------- src/ast/nodes/AssignmentNode.java | 12 +++++++----- src/ast/nodes/AtomNode.java | 22 ++++++++++++++++++++-- src/ast/nodes/ExprNode.java | 9 ++++++++- src/ast/nodes/FuncdefNode.java | 12 +++++++++++- src/ast/nodes/ParamdefNode.java | 7 +++++++ src/ast/nodes/ParamlistNode.java | 2 +- src/ast/nodes/RootNode.java | 12 ++++++++++-- src/semanticanalysis/SymbolTable.java | 9 +++++---- 9 files changed, 72 insertions(+), 32 deletions(-) diff --git a/progs/test.py b/progs/test.py index 718885d..ab0901a 100644 --- a/progs/test.py +++ b/progs/test.py @@ -1,17 +1,4 @@ -import math -from re import f4, r3 +x = 1 -from abs import * - - -def find_first_duplicate(nums, x): - num_set = set() - no_duplicate = -1 - - for i in range(len(nums)): - if nums[i] in num_set: - return nums[i] - else: - num_set.add(nums[i]) - - return no_duplicate +if x == 1: + print("a") diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index 627e842..b0310b5 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -10,24 +10,26 @@ import ast.types.*; * Node for the `assignment` statement of the grammar. */ public class AssignmentNode implements Node { - private Node lhr; + private ExprNode lhr; private Node assign; - private Node rhr; + private ExprNode rhr; public AssignmentNode(Node lhr, Node assign, Node rhr) { - this.lhr = lhr; + this.lhr = (ExprNode) lhr; this.assign = assign; - this.rhr = rhr; + this.rhr = (ExprNode) rhr; } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - errors.addAll(lhr.checkSemantics(ST, _nesting)); + // errors.addAll(lhr.checkSemantics(ST, _nesting)); errors.addAll(assign.checkSemantics(ST, _nesting)); errors.addAll(rhr.checkSemantics(ST, _nesting)); + ST.insert(lhr.getId(), rhr.typeCheck(), _nesting, ""); + return errors; } diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 4dcb926..7dc38fb 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -16,15 +16,33 @@ public class AtomNode implements Node { this.val = val; } + public String getId() { + return this.val; + } + @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - return new ArrayList(); + var errors = new ArrayList(); + System.out.println(getId() + " " + _nesting + " " + ST.nslookup(getId())); + if (!(this.typeCheck() instanceof IntType) && !ST.top_lookup(this.getId())) { + System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); + errors.add(new SemanticError("Undefined name `" + this.getId() + "`")); + } + + return errors; } // FIXME: this type for atom @Override public Type typeCheck() { - return new AtomType(); + try { + Integer.parseInt(this.val); + System.out.println(this.val + " is int"); + return new IntType(); + } catch (NumberFormatException e) { + System.out.println(this.val + " is atom"); + return new AtomType(); + } } // TODO: add code generation for atom node diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 25c2016..39f397e 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -24,10 +24,13 @@ public class ExprNode implements Node { this.trailers = trailers; } + public String getId() { + return ((AtomNode) this.atom).getId(); + } + @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - if (atom != null) { errors.addAll(atom.checkSemantics(ST, _nesting)); } @@ -50,6 +53,10 @@ public class ExprNode implements Node { // FIXME: type for the expr @Override public Type typeCheck() { + if (this.atom != null) { + return this.atom.typeCheck(); + } + return new VoidType(); } diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index 67bc772..e50e35c 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -1,6 +1,7 @@ package ast.nodes; import java.util.ArrayList; +import java.util.HashMap; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -24,11 +25,20 @@ public class FuncdefNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + ST.insert(this.name.toString(), this.block.typeCheck(), _nesting, ""); + + HashMap HM = new HashMap(); + ArrayList partypes = new ArrayList(); + + ST.add(HM); if (paramlist != null) { - errors.addAll(paramlist.checkSemantics(ST, _nesting)); + errors.addAll(paramlist.checkSemantics(ST, _nesting + 1)); } + // Offset is increased for the possible return value + ST.increaseoffset(); + errors.addAll(block.checkSemantics(ST, _nesting)); return errors; diff --git a/src/ast/nodes/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java index 481282e..3ad82dd 100644 --- a/src/ast/nodes/ParamdefNode.java +++ b/src/ast/nodes/ParamdefNode.java @@ -11,6 +11,13 @@ public class ParamdefNode extends AtomNode { super(val); } + @Override + public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + ST.insert(this.getId(), this.typeCheck(), _nesting, ""); + + return new ArrayList(); + } + // FIXME: it should returns the param' type @Override public Type typeCheck() { diff --git a/src/ast/nodes/ParamlistNode.java b/src/ast/nodes/ParamlistNode.java index 144eb13..a097c19 100644 --- a/src/ast/nodes/ParamlistNode.java +++ b/src/ast/nodes/ParamlistNode.java @@ -21,7 +21,7 @@ public class ParamlistNode implements Node { ArrayList errors = new ArrayList(); for (var param : params) { - errors.addAll(param.checkSemantics(ST, _nesting)); + errors.addAll(param.checkSemantics(ST, _nesting + 1)); } return errors; diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java index e0989e8..fd33e30 100644 --- a/src/ast/nodes/RootNode.java +++ b/src/ast/nodes/RootNode.java @@ -1,6 +1,7 @@ package ast.nodes; import java.util.ArrayList; +import java.util.HashMap; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -24,13 +25,20 @@ public class RootNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - for (Node stmt : stmts) { + HashMap HM = new HashMap(); + + ST.add(HM); + + for (Node stmt : compoundStmts) { errors.addAll(stmt.checkSemantics(ST, _nesting)); } - for (Node stmt : compoundStmts) { + + for (Node stmt : stmts) { errors.addAll(stmt.checkSemantics(ST, _nesting)); } + ST.remove(); + return errors; } diff --git a/src/semanticanalysis/SymbolTable.java b/src/semanticanalysis/SymbolTable.java index f2876db..8193d5e 100644 --- a/src/semanticanalysis/SymbolTable.java +++ b/src/semanticanalysis/SymbolTable.java @@ -40,8 +40,8 @@ public class SymbolTable { HashMap H = this.symbolTable.get(n); T = H.get(id); if (T != null) { - found = true; - }else { + found = true; + } else { n = n - 1; } } @@ -60,8 +60,8 @@ public class SymbolTable { while ((n >= 0) && !found) { HashMap H = this.symbolTable.get(n); if (H.get(id) != null) { - found = true; - }else { + found = true; + } else { n = n - 1; } } @@ -125,6 +125,7 @@ public class SymbolTable { // We always increment the offset by 1 otherwise we need ad-hoc bytecode // operations + // FIXME: wtf is that? if (type.getClass().equals((new BoolType()).getClass())) { offs = offs + 1; } else if (type.getClass().equals((new IntType()).getClass())) { -- cgit v1.2.3-18-g5258 From da554f4281da45a22f7101f26cfdf274149c7966 Mon Sep 17 00:00:00 2001 From: L0P0P Date: Tue, 25 Jun 2024 11:41:32 +0200 Subject: Fixed import problems --- src/ast/nodes/FuncdefNode.java | 2 +- src/ast/nodes/ParamdefNode.java | 3 +++ src/ast/nodes/RootNode.java | 3 +-- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index e50e35c..341a28d 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -3,6 +3,7 @@ package ast.nodes; import java.util.ArrayList; import java.util.HashMap; +import semanticanalysis.STentry; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; import ast.types.*; @@ -28,7 +29,6 @@ public class FuncdefNode implements Node { ST.insert(this.name.toString(), this.block.typeCheck(), _nesting, ""); HashMap HM = new HashMap(); - ArrayList partypes = new ArrayList(); ST.add(HM); diff --git a/src/ast/nodes/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java index 3ad82dd..265b6b6 100644 --- a/src/ast/nodes/ParamdefNode.java +++ b/src/ast/nodes/ParamdefNode.java @@ -1,6 +1,9 @@ package ast.nodes; +import java.util.ArrayList; + import ast.types.*; +import semanticanalysis.*; /** * Node for the `paramdef` statement of the grammar. Extends the `AtomNode` diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java index fd33e30..4b7e579 100644 --- a/src/ast/nodes/RootNode.java +++ b/src/ast/nodes/RootNode.java @@ -3,8 +3,7 @@ package ast.nodes; import java.util.ArrayList; import java.util.HashMap; -import semanticanalysis.SemanticError; -import semanticanalysis.SymbolTable; +import semanticanalysis.*; import ast.types.*; /** -- cgit v1.2.3-18-g5258 From b12c01732860f9727626829e0b25a273de5fe5c7 Mon Sep 17 00:00:00 2001 From: geno Date: Tue, 25 Jun 2024 16:04:07 +0200 Subject: check semantic of defined and undefined variables implemented do not check for built-in function works on the example --- src/Main.java | 2 +- src/ast/nodes/AtomNode.java | 31 +++++---- src/ast/nodes/ExprNode.java | 121 ++++++++++++++++++++++++++++------ src/ast/nodes/RootNode.java | 8 +-- src/ast/types/VoidType.java | 6 ++ src/semanticanalysis/SymbolTable.java | 17 +++-- 6 files changed, 140 insertions(+), 45 deletions(-) diff --git a/src/Main.java b/src/Main.java index 3987bad..bfc21e3 100644 --- a/src/Main.java +++ b/src/Main.java @@ -60,7 +60,7 @@ public class Main { Node ast = visitor.visit(tree); ArrayList errors = ast.checkSemantics(ST, 0); if (errors.size() > 0) { - System.out.println("You had: " + errors.size() + " errors:"); + System.out.println("You had " + errors.size() + " errors:"); for (SemanticError e : errors) { System.out.println("\t" + e); } diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 7dc38fb..4c9a807 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -1,15 +1,17 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - +import java.util.regex.Matcher; +import java.util.regex.Pattern; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `atom` statement of the grammar. */ public class AtomNode implements Node { + protected String val; public AtomNode(String val) { @@ -23,25 +25,28 @@ public class AtomNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { var errors = new ArrayList(); - System.out.println(getId() + " " + _nesting + " " + ST.nslookup(getId())); - if (!(this.typeCheck() instanceof IntType) && !ST.top_lookup(this.getId())) { - System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); + // System.out.println("[ATOM] id: " + getId() + " ns: " + _nesting + " top_lookup" + ST.top_lookup(this.getId())); + if ((this.typeCheck() instanceof AtomType) && !ST.top_lookup(this.getId())) { + // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); errors.add(new SemanticError("Undefined name `" + this.getId() + "`")); } return errors; } - // FIXME: this type for atom + // ENHANCE: return more specific types @Override public Type typeCheck() { - try { - Integer.parseInt(this.val); - System.out.println(this.val + " is int"); - return new IntType(); - } catch (NumberFormatException e) { - System.out.println(this.val + " is atom"); - return new AtomType(); + // this regex should match every possible atom name written in this format: CHAR (CHAR | DIGIT)* + Pattern pattern = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]*$", Pattern.CASE_INSENSITIVE); + Matcher matcher = pattern.matcher(this.val); + boolean matchFound = matcher.find(); + if (matchFound) { + // System.out.println("Match found for " + this.val); + return new AtomType(); // could be a variable or a fuction + } else { + // System.out.println("Match not found for " + this.val); + return new VoidType(); // could be any type of data } } diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 39f397e..13b6619 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -1,23 +1,96 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - +import java.util.Arrays; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `expr` statement of the grammar. */ public class ExprNode implements Node { - private Node atom; + + private AtomNode atom; private Node compOp; private String op; private ArrayList exprs; private ArrayList trailers; + private static final String[] bif = {"abs", + "aiter", + "all", + "anext", + "any", + "ascii", + "bin", + "bool", + "breakpoint", + "bytearray", + "bytes", + "callable", + "chr", + "classmethod", + "compile", + "complex", + "delattr", + "dict", + "dir", + "divmod", + "enumerate", + "eval", + "exec", + "filter", + "float", + "format", + "frozenset", + "getattr", + "globals", + "hasattr", + "hash", + "help", + "hex", + "id", + "input", + "int", + "isinstance", + "issubclass", + "iter", + "len", + "list", + "locals", + "map", + "max", + "memoryview", + "min", + "next", + "object", + "oct", + "open", + "ord", + "pow", + "print", + "property", + "range", + "repr", + "reversed", + "round", + "set", + "setattr", + "slice", + "sorted", + "staticmethod", + "str", + "sum", + "super", + "tuple", + "type", + "vars", + "zip", + "__import__"}; + public ExprNode(Node atom, Node compOp, ArrayList exprs, String op, ArrayList trailers) { - this.atom = atom; + this.atom = (AtomNode) atom; this.compOp = compOp; this.exprs = exprs; this.op = op; @@ -31,20 +104,28 @@ public class ExprNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - if (atom != null) { - errors.addAll(atom.checkSemantics(ST, _nesting)); - } - - if (compOp != null) { - errors.addAll(compOp.checkSemantics(ST, _nesting)); - } - - for (var expr : exprs) { - errors.addAll(expr.checkSemantics(ST, _nesting)); - } - - for (var trailer : trailers) { - errors.addAll(trailer.checkSemantics(ST, _nesting)); + if (atom != null && !trailers.isEmpty()) { + // function call + if (!Arrays.asList(bif).contains(atom.getId())) { + errors.addAll(atom.checkSemantics(ST, _nesting)); + } + } else { + // butto tutto quello che c'era prima nell'else così non rischio di perdere niente di utile + if (atom != null) { + errors.addAll(atom.checkSemantics(ST, _nesting)); + } + + if (compOp != null) { + errors.addAll(compOp.checkSemantics(ST, _nesting)); + } + + for (var expr : exprs) { + errors.addAll(expr.checkSemantics(ST, _nesting)); + } + + for (var trailer : trailers) { + errors.addAll(trailer.checkSemantics(ST, _nesting)); + } } return errors; @@ -81,11 +162,11 @@ public class ExprNode implements Node { for (var expr : exprs) { str += expr.toPrint(prefix); - } + } for (var trailer : trailers) { str += trailer.toPrint(prefix); - } + } if (op != null) { str += prefix + "Op(" + op + ")\n"; diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java index 4b7e579..45d20db 100644 --- a/src/ast/nodes/RootNode.java +++ b/src/ast/nodes/RootNode.java @@ -1,15 +1,15 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; import java.util.HashMap; - import semanticanalysis.*; -import ast.types.*; /** * Node for the `root` statement of the grammar. */ public class RootNode implements Node { + // stms and compundStmts are protected because they are reused for a // BlockNode protected ArrayList stmts; @@ -28,11 +28,11 @@ public class RootNode implements Node { ST.add(HM); - for (Node stmt : compoundStmts) { + for (Node stmt : stmts) { errors.addAll(stmt.checkSemantics(ST, _nesting)); } - for (Node stmt : stmts) { + for (Node stmt : compoundStmts) { errors.addAll(stmt.checkSemantics(ST, _nesting)); } diff --git a/src/ast/types/VoidType.java b/src/ast/types/VoidType.java index d15933f..8e3f9b2 100644 --- a/src/ast/types/VoidType.java +++ b/src/ast/types/VoidType.java @@ -4,7 +4,13 @@ package ast.types; * A void type. Voids return nothing. */ public class VoidType extends Type { + public String toPrint(String prefix) { return prefix + "Void\n"; } + + @Override + public String toString() { + return "Void"; + } } diff --git a/src/semanticanalysis/SymbolTable.java b/src/semanticanalysis/SymbolTable.java index 8193d5e..617b48a 100644 --- a/src/semanticanalysis/SymbolTable.java +++ b/src/semanticanalysis/SymbolTable.java @@ -126,15 +126,18 @@ public class SymbolTable { // We always increment the offset by 1 otherwise we need ad-hoc bytecode // operations // FIXME: wtf is that? - if (type.getClass().equals((new BoolType()).getClass())) { - offs = offs + 1; - } else if (type.getClass().equals((new IntType()).getClass())) { - offs = offs + 1; - } else { - offs = offs + 1; - } + // if (type.getClass().equals((new BoolType()).getClass())) { + // offs = offs + 1; + // } else if (type.getClass().equals((new IntType()).getClass())) { + // offs = offs + 1; + // } else { + // offs = offs + 1; + // } + offs = offs + 1; this.offset.add(offs); + + // System.out.println("Insert " + id + " of type " + type.toString() + " with nesting " + String.valueOf(_nesting)); } /** -- cgit v1.2.3-18-g5258 From 9bb71e36feb60d886f1eb04f03daaa7bcf343355 Mon Sep 17 00:00:00 2001 From: L0P0P Date: Wed, 26 Jun 2024 09:36:33 +0200 Subject: Ignored .antlr folder --- .gitignore | 3 +- src/parser/.antlr/Python3Lexer.interp | 253 --------------- src/parser/.antlr/Python3Lexer.java | 574 ---------------------------------- src/parser/.antlr/Python3Lexer.tokens | 142 --------- 4 files changed, 2 insertions(+), 970 deletions(-) delete mode 100644 src/parser/.antlr/Python3Lexer.interp delete mode 100644 src/parser/.antlr/Python3Lexer.java delete mode 100644 src/parser/.antlr/Python3Lexer.tokens diff --git a/.gitignore b/.gitignore index 29ba4ac..2b49698 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ out/ trees/ .project -.vscode/ \ No newline at end of file +.vscode/ +src/parser/.antlr/ \ No newline at end of file diff --git a/src/parser/.antlr/Python3Lexer.interp b/src/parser/.antlr/Python3Lexer.interp deleted file mode 100644 index 1f4208b..0000000 --- a/src/parser/.antlr/Python3Lexer.interp +++ /dev/null @@ -1,253 +0,0 @@ -token literal names: -null -null -null -null -null -'and' -'as' -'def' -'elif' -'else' -'False' -'for' -'from' -'if' -'import' -'in' -'is' -'None' -'not' -'or' -'return' -'True' -'_' -'while' -null -null -null -null -'.' -'...' -'*' -'(' -')' -',' -':' -';' -'**' -'=' -'[' -']' -'|' -'^' -'&' -'<<' -'>>' -'+' -'-' -'/' -'%' -'//' -'~' -'{' -'}' -'<' -'>' -'==' -'>=' -'<=' -'<>' -'!=' -'@' -'->' -'+=' -'-=' -'*=' -'@=' -'/=' -'%=' -'&=' -'|=' -'^=' -'<<=' -'>>=' -'**=' -'//=' -null -null - -token symbolic names: -null -INDENT -DEDENT -STRING -NUMBER -AND -AS -DEF -ELIF -ELSE -FALSE -FOR -FROM -IF -IMPORT -IN -IS -NONE -NOT -OR -RETURN -TRUE -UNDERSCORE -WHILE -NEWLINE -NAME -DECIMAL_INTEGER -FLOAT_NUMBER -DOT -ELLIPSIS -STAR -OPEN_PAREN -CLOSE_PAREN -COMMA -COLON -SEMI_COLON -POWER -ASSIGN -OPEN_BRACK -CLOSE_BRACK -OR_OP -XOR -AND_OP -LEFT_SHIFT -RIGHT_SHIFT -ADD -MINUS -DIV -MOD -IDIV -NOT_OP -OPEN_BRACE -CLOSE_BRACE -LESS_THAN -GREATER_THAN -EQUALS -GT_EQ -LT_EQ -NOT_EQ_1 -NOT_EQ_2 -AT -ARROW -ADD_ASSIGN -SUB_ASSIGN -MULT_ASSIGN -AT_ASSIGN -DIV_ASSIGN -MOD_ASSIGN -AND_ASSIGN -OR_ASSIGN -XOR_ASSIGN -LEFT_SHIFT_ASSIGN -RIGHT_SHIFT_ASSIGN -POWER_ASSIGN -IDIV_ASSIGN -SKIP_ -UNKNOWN_CHAR - -rule names: -STRING -NUMBER -AND -AS -DEF -ELIF -ELSE -FALSE -FOR -FROM -IF -IMPORT -IN -IS -NONE -NOT -OR -RETURN -TRUE -UNDERSCORE -WHILE -NEWLINE -NAME -DECIMAL_INTEGER -FLOAT_NUMBER -DOT -ELLIPSIS -STAR -OPEN_PAREN -CLOSE_PAREN -COMMA -COLON -SEMI_COLON -POWER -ASSIGN -OPEN_BRACK -CLOSE_BRACK -OR_OP -XOR -AND_OP -LEFT_SHIFT -RIGHT_SHIFT -ADD -MINUS -DIV -MOD -IDIV -NOT_OP -OPEN_BRACE -CLOSE_BRACE -LESS_THAN -GREATER_THAN -EQUALS -GT_EQ -LT_EQ -NOT_EQ_1 -NOT_EQ_2 -AT -ARROW -ADD_ASSIGN -SUB_ASSIGN -MULT_ASSIGN -AT_ASSIGN -DIV_ASSIGN -MOD_ASSIGN -AND_ASSIGN -OR_ASSIGN -XOR_ASSIGN -LEFT_SHIFT_ASSIGN -RIGHT_SHIFT_ASSIGN -POWER_ASSIGN -IDIV_ASSIGN -SKIP_ -UNKNOWN_CHAR -STRING_ESCAPE_SEQ -NON_ZERO_DIGIT -DIGIT -POINT_FLOAT -EXPONENT_FLOAT -INT_PART -EXPONENT -SPACES -COMMENT -LINE_JOINING - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN - -mode names: -DEFAULT_MODE - -atn: -[4, 0, 76, 523, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 1, 0, 1, 0, 1, 0, 5, 0, 173, 8, 0, 10, 0, 12, 0, 176, 9, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 182, 8, 0, 10, 0, 12, 0, 185, 9, 0, 1, 0, 3, 0, 188, 8, 0, 1, 1, 1, 1, 3, 1, 192, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 3, 21, 281, 8, 21, 1, 21, 1, 21, 3, 21, 285, 8, 21, 1, 21, 3, 21, 288, 8, 21, 3, 21, 290, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 5, 22, 296, 8, 22, 10, 22, 12, 22, 299, 9, 22, 1, 23, 1, 23, 5, 23, 303, 8, 23, 10, 23, 12, 23, 306, 9, 23, 1, 23, 4, 23, 309, 8, 23, 11, 23, 12, 23, 310, 3, 23, 313, 8, 23, 1, 24, 1, 24, 3, 24, 317, 8, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 3, 72, 451, 8, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 461, 8, 74, 1, 75, 1, 75, 1, 76, 1, 76, 1, 77, 3, 77, 468, 8, 77, 1, 77, 1, 77, 4, 77, 472, 8, 77, 11, 77, 12, 77, 473, 1, 77, 1, 77, 1, 77, 3, 77, 479, 8, 77, 1, 78, 1, 78, 3, 78, 483, 8, 78, 1, 78, 1, 78, 1, 79, 4, 79, 488, 8, 79, 11, 79, 12, 79, 489, 1, 80, 1, 80, 3, 80, 494, 8, 80, 1, 80, 4, 80, 497, 8, 80, 11, 80, 12, 80, 498, 1, 81, 4, 81, 502, 8, 81, 11, 81, 12, 81, 503, 1, 82, 1, 82, 5, 82, 508, 8, 82, 10, 82, 12, 82, 511, 9, 82, 1, 83, 1, 83, 3, 83, 515, 8, 83, 1, 83, 3, 83, 518, 8, 83, 1, 83, 1, 83, 3, 83, 522, 8, 83, 0, 0, 84, 1, 3, 3, 4, 5, 5, 7, 6, 9, 7, 11, 8, 13, 9, 15, 10, 17, 11, 19, 12, 21, 13, 23, 14, 25, 15, 27, 16, 29, 17, 31, 18, 33, 19, 35, 20, 37, 21, 39, 22, 41, 23, 43, 24, 45, 25, 47, 26, 49, 27, 51, 28, 53, 29, 55, 30, 57, 31, 59, 32, 61, 33, 63, 34, 65, 35, 67, 36, 69, 37, 71, 38, 73, 39, 75, 40, 77, 41, 79, 42, 81, 43, 83, 44, 85, 45, 87, 46, 89, 47, 91, 48, 93, 49, 95, 50, 97, 51, 99, 52, 101, 53, 103, 54, 105, 55, 107, 56, 109, 57, 111, 58, 113, 59, 115, 60, 117, 61, 119, 62, 121, 63, 123, 64, 125, 65, 127, 66, 129, 67, 131, 68, 133, 69, 135, 70, 137, 71, 139, 72, 141, 73, 143, 74, 145, 75, 147, 76, 149, 0, 151, 0, 153, 0, 155, 0, 157, 0, 159, 0, 161, 0, 163, 0, 165, 0, 167, 0, 1, 0, 10, 4, 0, 10, 10, 12, 13, 39, 39, 92, 92, 4, 0, 10, 10, 12, 13, 34, 34, 92, 92, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1, 0, 49, 57, 1, 0, 48, 57, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 9, 9, 32, 32, 2, 0, 10, 10, 12, 13, 542, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 1, 187, 1, 0, 0, 0, 3, 191, 1, 0, 0, 0, 5, 193, 1, 0, 0, 0, 7, 197, 1, 0, 0, 0, 9, 200, 1, 0, 0, 0, 11, 204, 1, 0, 0, 0, 13, 209, 1, 0, 0, 0, 15, 214, 1, 0, 0, 0, 17, 220, 1, 0, 0, 0, 19, 224, 1, 0, 0, 0, 21, 229, 1, 0, 0, 0, 23, 232, 1, 0, 0, 0, 25, 239, 1, 0, 0, 0, 27, 242, 1, 0, 0, 0, 29, 245, 1, 0, 0, 0, 31, 250, 1, 0, 0, 0, 33, 254, 1, 0, 0, 0, 35, 257, 1, 0, 0, 0, 37, 264, 1, 0, 0, 0, 39, 269, 1, 0, 0, 0, 41, 271, 1, 0, 0, 0, 43, 289, 1, 0, 0, 0, 45, 293, 1, 0, 0, 0, 47, 312, 1, 0, 0, 0, 49, 316, 1, 0, 0, 0, 51, 318, 1, 0, 0, 0, 53, 320, 1, 0, 0, 0, 55, 324, 1, 0, 0, 0, 57, 326, 1, 0, 0, 0, 59, 329, 1, 0, 0, 0, 61, 332, 1, 0, 0, 0, 63, 334, 1, 0, 0, 0, 65, 336, 1, 0, 0, 0, 67, 338, 1, 0, 0, 0, 69, 341, 1, 0, 0, 0, 71, 343, 1, 0, 0, 0, 73, 346, 1, 0, 0, 0, 75, 349, 1, 0, 0, 0, 77, 351, 1, 0, 0, 0, 79, 353, 1, 0, 0, 0, 81, 355, 1, 0, 0, 0, 83, 358, 1, 0, 0, 0, 85, 361, 1, 0, 0, 0, 87, 363, 1, 0, 0, 0, 89, 365, 1, 0, 0, 0, 91, 367, 1, 0, 0, 0, 93, 369, 1, 0, 0, 0, 95, 372, 1, 0, 0, 0, 97, 374, 1, 0, 0, 0, 99, 377, 1, 0, 0, 0, 101, 380, 1, 0, 0, 0, 103, 382, 1, 0, 0, 0, 105, 384, 1, 0, 0, 0, 107, 387, 1, 0, 0, 0, 109, 390, 1, 0, 0, 0, 111, 393, 1, 0, 0, 0, 113, 396, 1, 0, 0, 0, 115, 399, 1, 0, 0, 0, 117, 401, 1, 0, 0, 0, 119, 404, 1, 0, 0, 0, 121, 407, 1, 0, 0, 0, 123, 410, 1, 0, 0, 0, 125, 413, 1, 0, 0, 0, 127, 416, 1, 0, 0, 0, 129, 419, 1, 0, 0, 0, 131, 422, 1, 0, 0, 0, 133, 425, 1, 0, 0, 0, 135, 428, 1, 0, 0, 0, 137, 431, 1, 0, 0, 0, 139, 435, 1, 0, 0, 0, 141, 439, 1, 0, 0, 0, 143, 443, 1, 0, 0, 0, 145, 450, 1, 0, 0, 0, 147, 454, 1, 0, 0, 0, 149, 460, 1, 0, 0, 0, 151, 462, 1, 0, 0, 0, 153, 464, 1, 0, 0, 0, 155, 478, 1, 0, 0, 0, 157, 482, 1, 0, 0, 0, 159, 487, 1, 0, 0, 0, 161, 491, 1, 0, 0, 0, 163, 501, 1, 0, 0, 0, 165, 505, 1, 0, 0, 0, 167, 512, 1, 0, 0, 0, 169, 174, 5, 39, 0, 0, 170, 173, 3, 149, 74, 0, 171, 173, 8, 0, 0, 0, 172, 170, 1, 0, 0, 0, 172, 171, 1, 0, 0, 0, 173, 176, 1, 0, 0, 0, 174, 172, 1, 0, 0, 0, 174, 175, 1, 0, 0, 0, 175, 177, 1, 0, 0, 0, 176, 174, 1, 0, 0, 0, 177, 188, 5, 39, 0, 0, 178, 183, 5, 34, 0, 0, 179, 182, 3, 149, 74, 0, 180, 182, 8, 1, 0, 0, 181, 179, 1, 0, 0, 0, 181, 180, 1, 0, 0, 0, 182, 185, 1, 0, 0, 0, 183, 181, 1, 0, 0, 0, 183, 184, 1, 0, 0, 0, 184, 186, 1, 0, 0, 0, 185, 183, 1, 0, 0, 0, 186, 188, 5, 34, 0, 0, 187, 169, 1, 0, 0, 0, 187, 178, 1, 0, 0, 0, 188, 2, 1, 0, 0, 0, 189, 192, 3, 47, 23, 0, 190, 192, 3, 49, 24, 0, 191, 189, 1, 0, 0, 0, 191, 190, 1, 0, 0, 0, 192, 4, 1, 0, 0, 0, 193, 194, 5, 97, 0, 0, 194, 195, 5, 110, 0, 0, 195, 196, 5, 100, 0, 0, 196, 6, 1, 0, 0, 0, 197, 198, 5, 97, 0, 0, 198, 199, 5, 115, 0, 0, 199, 8, 1, 0, 0, 0, 200, 201, 5, 100, 0, 0, 201, 202, 5, 101, 0, 0, 202, 203, 5, 102, 0, 0, 203, 10, 1, 0, 0, 0, 204, 205, 5, 101, 0, 0, 205, 206, 5, 108, 0, 0, 206, 207, 5, 105, 0, 0, 207, 208, 5, 102, 0, 0, 208, 12, 1, 0, 0, 0, 209, 210, 5, 101, 0, 0, 210, 211, 5, 108, 0, 0, 211, 212, 5, 115, 0, 0, 212, 213, 5, 101, 0, 0, 213, 14, 1, 0, 0, 0, 214, 215, 5, 70, 0, 0, 215, 216, 5, 97, 0, 0, 216, 217, 5, 108, 0, 0, 217, 218, 5, 115, 0, 0, 218, 219, 5, 101, 0, 0, 219, 16, 1, 0, 0, 0, 220, 221, 5, 102, 0, 0, 221, 222, 5, 111, 0, 0, 222, 223, 5, 114, 0, 0, 223, 18, 1, 0, 0, 0, 224, 225, 5, 102, 0, 0, 225, 226, 5, 114, 0, 0, 226, 227, 5, 111, 0, 0, 227, 228, 5, 109, 0, 0, 228, 20, 1, 0, 0, 0, 229, 230, 5, 105, 0, 0, 230, 231, 5, 102, 0, 0, 231, 22, 1, 0, 0, 0, 232, 233, 5, 105, 0, 0, 233, 234, 5, 109, 0, 0, 234, 235, 5, 112, 0, 0, 235, 236, 5, 111, 0, 0, 236, 237, 5, 114, 0, 0, 237, 238, 5, 116, 0, 0, 238, 24, 1, 0, 0, 0, 239, 240, 5, 105, 0, 0, 240, 241, 5, 110, 0, 0, 241, 26, 1, 0, 0, 0, 242, 243, 5, 105, 0, 0, 243, 244, 5, 115, 0, 0, 244, 28, 1, 0, 0, 0, 245, 246, 5, 78, 0, 0, 246, 247, 5, 111, 0, 0, 247, 248, 5, 110, 0, 0, 248, 249, 5, 101, 0, 0, 249, 30, 1, 0, 0, 0, 250, 251, 5, 110, 0, 0, 251, 252, 5, 111, 0, 0, 252, 253, 5, 116, 0, 0, 253, 32, 1, 0, 0, 0, 254, 255, 5, 111, 0, 0, 255, 256, 5, 114, 0, 0, 256, 34, 1, 0, 0, 0, 257, 258, 5, 114, 0, 0, 258, 259, 5, 101, 0, 0, 259, 260, 5, 116, 0, 0, 260, 261, 5, 117, 0, 0, 261, 262, 5, 114, 0, 0, 262, 263, 5, 110, 0, 0, 263, 36, 1, 0, 0, 0, 264, 265, 5, 84, 0, 0, 265, 266, 5, 114, 0, 0, 266, 267, 5, 117, 0, 0, 267, 268, 5, 101, 0, 0, 268, 38, 1, 0, 0, 0, 269, 270, 5, 95, 0, 0, 270, 40, 1, 0, 0, 0, 271, 272, 5, 119, 0, 0, 272, 273, 5, 104, 0, 0, 273, 274, 5, 105, 0, 0, 274, 275, 5, 108, 0, 0, 275, 276, 5, 101, 0, 0, 276, 42, 1, 0, 0, 0, 277, 278, 4, 21, 0, 0, 278, 290, 3, 163, 81, 0, 279, 281, 5, 13, 0, 0, 280, 279, 1, 0, 0, 0, 280, 281, 1, 0, 0, 0, 281, 282, 1, 0, 0, 0, 282, 285, 5, 10, 0, 0, 283, 285, 2, 12, 13, 0, 284, 280, 1, 0, 0, 0, 284, 283, 1, 0, 0, 0, 285, 287, 1, 0, 0, 0, 286, 288, 3, 163, 81, 0, 287, 286, 1, 0, 0, 0, 287, 288, 1, 0, 0, 0, 288, 290, 1, 0, 0, 0, 289, 277, 1, 0, 0, 0, 289, 284, 1, 0, 0, 0, 290, 291, 1, 0, 0, 0, 291, 292, 6, 21, 0, 0, 292, 44, 1, 0, 0, 0, 293, 297, 7, 2, 0, 0, 294, 296, 7, 3, 0, 0, 295, 294, 1, 0, 0, 0, 296, 299, 1, 0, 0, 0, 297, 295, 1, 0, 0, 0, 297, 298, 1, 0, 0, 0, 298, 46, 1, 0, 0, 0, 299, 297, 1, 0, 0, 0, 300, 304, 3, 151, 75, 0, 301, 303, 3, 153, 76, 0, 302, 301, 1, 0, 0, 0, 303, 306, 1, 0, 0, 0, 304, 302, 1, 0, 0, 0, 304, 305, 1, 0, 0, 0, 305, 313, 1, 0, 0, 0, 306, 304, 1, 0, 0, 0, 307, 309, 5, 48, 0, 0, 308, 307, 1, 0, 0, 0, 309, 310, 1, 0, 0, 0, 310, 308, 1, 0, 0, 0, 310, 311, 1, 0, 0, 0, 311, 313, 1, 0, 0, 0, 312, 300, 1, 0, 0, 0, 312, 308, 1, 0, 0, 0, 313, 48, 1, 0, 0, 0, 314, 317, 3, 155, 77, 0, 315, 317, 3, 157, 78, 0, 316, 314, 1, 0, 0, 0, 316, 315, 1, 0, 0, 0, 317, 50, 1, 0, 0, 0, 318, 319, 5, 46, 0, 0, 319, 52, 1, 0, 0, 0, 320, 321, 5, 46, 0, 0, 321, 322, 5, 46, 0, 0, 322, 323, 5, 46, 0, 0, 323, 54, 1, 0, 0, 0, 324, 325, 5, 42, 0, 0, 325, 56, 1, 0, 0, 0, 326, 327, 5, 40, 0, 0, 327, 328, 6, 28, 1, 0, 328, 58, 1, 0, 0, 0, 329, 330, 5, 41, 0, 0, 330, 331, 6, 29, 2, 0, 331, 60, 1, 0, 0, 0, 332, 333, 5, 44, 0, 0, 333, 62, 1, 0, 0, 0, 334, 335, 5, 58, 0, 0, 335, 64, 1, 0, 0, 0, 336, 337, 5, 59, 0, 0, 337, 66, 1, 0, 0, 0, 338, 339, 5, 42, 0, 0, 339, 340, 5, 42, 0, 0, 340, 68, 1, 0, 0, 0, 341, 342, 5, 61, 0, 0, 342, 70, 1, 0, 0, 0, 343, 344, 5, 91, 0, 0, 344, 345, 6, 35, 3, 0, 345, 72, 1, 0, 0, 0, 346, 347, 5, 93, 0, 0, 347, 348, 6, 36, 4, 0, 348, 74, 1, 0, 0, 0, 349, 350, 5, 124, 0, 0, 350, 76, 1, 0, 0, 0, 351, 352, 5, 94, 0, 0, 352, 78, 1, 0, 0, 0, 353, 354, 5, 38, 0, 0, 354, 80, 1, 0, 0, 0, 355, 356, 5, 60, 0, 0, 356, 357, 5, 60, 0, 0, 357, 82, 1, 0, 0, 0, 358, 359, 5, 62, 0, 0, 359, 360, 5, 62, 0, 0, 360, 84, 1, 0, 0, 0, 361, 362, 5, 43, 0, 0, 362, 86, 1, 0, 0, 0, 363, 364, 5, 45, 0, 0, 364, 88, 1, 0, 0, 0, 365, 366, 5, 47, 0, 0, 366, 90, 1, 0, 0, 0, 367, 368, 5, 37, 0, 0, 368, 92, 1, 0, 0, 0, 369, 370, 5, 47, 0, 0, 370, 371, 5, 47, 0, 0, 371, 94, 1, 0, 0, 0, 372, 373, 5, 126, 0, 0, 373, 96, 1, 0, 0, 0, 374, 375, 5, 123, 0, 0, 375, 376, 6, 48, 5, 0, 376, 98, 1, 0, 0, 0, 377, 378, 5, 125, 0, 0, 378, 379, 6, 49, 6, 0, 379, 100, 1, 0, 0, 0, 380, 381, 5, 60, 0, 0, 381, 102, 1, 0, 0, 0, 382, 383, 5, 62, 0, 0, 383, 104, 1, 0, 0, 0, 384, 385, 5, 61, 0, 0, 385, 386, 5, 61, 0, 0, 386, 106, 1, 0, 0, 0, 387, 388, 5, 62, 0, 0, 388, 389, 5, 61, 0, 0, 389, 108, 1, 0, 0, 0, 390, 391, 5, 60, 0, 0, 391, 392, 5, 61, 0, 0, 392, 110, 1, 0, 0, 0, 393, 394, 5, 60, 0, 0, 394, 395, 5, 62, 0, 0, 395, 112, 1, 0, 0, 0, 396, 397, 5, 33, 0, 0, 397, 398, 5, 61, 0, 0, 398, 114, 1, 0, 0, 0, 399, 400, 5, 64, 0, 0, 400, 116, 1, 0, 0, 0, 401, 402, 5, 45, 0, 0, 402, 403, 5, 62, 0, 0, 403, 118, 1, 0, 0, 0, 404, 405, 5, 43, 0, 0, 405, 406, 5, 61, 0, 0, 406, 120, 1, 0, 0, 0, 407, 408, 5, 45, 0, 0, 408, 409, 5, 61, 0, 0, 409, 122, 1, 0, 0, 0, 410, 411, 5, 42, 0, 0, 411, 412, 5, 61, 0, 0, 412, 124, 1, 0, 0, 0, 413, 414, 5, 64, 0, 0, 414, 415, 5, 61, 0, 0, 415, 126, 1, 0, 0, 0, 416, 417, 5, 47, 0, 0, 417, 418, 5, 61, 0, 0, 418, 128, 1, 0, 0, 0, 419, 420, 5, 37, 0, 0, 420, 421, 5, 61, 0, 0, 421, 130, 1, 0, 0, 0, 422, 423, 5, 38, 0, 0, 423, 424, 5, 61, 0, 0, 424, 132, 1, 0, 0, 0, 425, 426, 5, 124, 0, 0, 426, 427, 5, 61, 0, 0, 427, 134, 1, 0, 0, 0, 428, 429, 5, 94, 0, 0, 429, 430, 5, 61, 0, 0, 430, 136, 1, 0, 0, 0, 431, 432, 5, 60, 0, 0, 432, 433, 5, 60, 0, 0, 433, 434, 5, 61, 0, 0, 434, 138, 1, 0, 0, 0, 435, 436, 5, 62, 0, 0, 436, 437, 5, 62, 0, 0, 437, 438, 5, 61, 0, 0, 438, 140, 1, 0, 0, 0, 439, 440, 5, 42, 0, 0, 440, 441, 5, 42, 0, 0, 441, 442, 5, 61, 0, 0, 442, 142, 1, 0, 0, 0, 443, 444, 5, 47, 0, 0, 444, 445, 5, 47, 0, 0, 445, 446, 5, 61, 0, 0, 446, 144, 1, 0, 0, 0, 447, 451, 3, 163, 81, 0, 448, 451, 3, 165, 82, 0, 449, 451, 3, 167, 83, 0, 450, 447, 1, 0, 0, 0, 450, 448, 1, 0, 0, 0, 450, 449, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 453, 6, 72, 7, 0, 453, 146, 1, 0, 0, 0, 454, 455, 9, 0, 0, 0, 455, 148, 1, 0, 0, 0, 456, 457, 5, 92, 0, 0, 457, 461, 9, 0, 0, 0, 458, 459, 5, 92, 0, 0, 459, 461, 3, 43, 21, 0, 460, 456, 1, 0, 0, 0, 460, 458, 1, 0, 0, 0, 461, 150, 1, 0, 0, 0, 462, 463, 7, 4, 0, 0, 463, 152, 1, 0, 0, 0, 464, 465, 7, 5, 0, 0, 465, 154, 1, 0, 0, 0, 466, 468, 3, 159, 79, 0, 467, 466, 1, 0, 0, 0, 467, 468, 1, 0, 0, 0, 468, 469, 1, 0, 0, 0, 469, 471, 5, 46, 0, 0, 470, 472, 3, 153, 76, 0, 471, 470, 1, 0, 0, 0, 472, 473, 1, 0, 0, 0, 473, 471, 1, 0, 0, 0, 473, 474, 1, 0, 0, 0, 474, 479, 1, 0, 0, 0, 475, 476, 3, 159, 79, 0, 476, 477, 5, 46, 0, 0, 477, 479, 1, 0, 0, 0, 478, 467, 1, 0, 0, 0, 478, 475, 1, 0, 0, 0, 479, 156, 1, 0, 0, 0, 480, 483, 3, 159, 79, 0, 481, 483, 3, 155, 77, 0, 482, 480, 1, 0, 0, 0, 482, 481, 1, 0, 0, 0, 483, 484, 1, 0, 0, 0, 484, 485, 3, 161, 80, 0, 485, 158, 1, 0, 0, 0, 486, 488, 3, 153, 76, 0, 487, 486, 1, 0, 0, 0, 488, 489, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 160, 1, 0, 0, 0, 491, 493, 7, 6, 0, 0, 492, 494, 7, 7, 0, 0, 493, 492, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494, 496, 1, 0, 0, 0, 495, 497, 3, 153, 76, 0, 496, 495, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 496, 1, 0, 0, 0, 498, 499, 1, 0, 0, 0, 499, 162, 1, 0, 0, 0, 500, 502, 7, 8, 0, 0, 501, 500, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 501, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 164, 1, 0, 0, 0, 505, 509, 5, 35, 0, 0, 506, 508, 8, 9, 0, 0, 507, 506, 1, 0, 0, 0, 508, 511, 1, 0, 0, 0, 509, 507, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 166, 1, 0, 0, 0, 511, 509, 1, 0, 0, 0, 512, 514, 5, 92, 0, 0, 513, 515, 3, 163, 81, 0, 514, 513, 1, 0, 0, 0, 514, 515, 1, 0, 0, 0, 515, 521, 1, 0, 0, 0, 516, 518, 5, 13, 0, 0, 517, 516, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 519, 1, 0, 0, 0, 519, 522, 5, 10, 0, 0, 520, 522, 2, 12, 13, 0, 521, 517, 1, 0, 0, 0, 521, 520, 1, 0, 0, 0, 522, 168, 1, 0, 0, 0, 30, 0, 172, 174, 181, 183, 187, 191, 280, 284, 287, 289, 297, 304, 310, 312, 316, 450, 460, 467, 473, 478, 482, 489, 493, 498, 503, 509, 514, 517, 521, 8, 1, 21, 0, 1, 28, 1, 1, 29, 2, 1, 35, 3, 1, 36, 4, 1, 48, 5, 1, 49, 6, 6, 0, 0] \ No newline at end of file diff --git a/src/parser/.antlr/Python3Lexer.java b/src/parser/.antlr/Python3Lexer.java deleted file mode 100644 index 5a11975..0000000 --- a/src/parser/.antlr/Python3Lexer.java +++ /dev/null @@ -1,574 +0,0 @@ -// Generated from /home/geno/Desktop/uni/clp/clp_project/src/parser/Python3Lexer.g4 by ANTLR 4.13.1 -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.atn.*; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.*; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) -public class Python3Lexer extends Python3LexerBase { - static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - INDENT=1, DEDENT=2, STRING=3, NUMBER=4, AND=5, AS=6, DEF=7, ELIF=8, ELSE=9, - FALSE=10, FOR=11, FROM=12, IF=13, IMPORT=14, IN=15, IS=16, NONE=17, NOT=18, - OR=19, RETURN=20, TRUE=21, UNDERSCORE=22, WHILE=23, NEWLINE=24, NAME=25, - DECIMAL_INTEGER=26, FLOAT_NUMBER=27, DOT=28, ELLIPSIS=29, STAR=30, OPEN_PAREN=31, - CLOSE_PAREN=32, COMMA=33, COLON=34, SEMI_COLON=35, POWER=36, ASSIGN=37, - OPEN_BRACK=38, CLOSE_BRACK=39, OR_OP=40, XOR=41, AND_OP=42, LEFT_SHIFT=43, - RIGHT_SHIFT=44, ADD=45, MINUS=46, DIV=47, MOD=48, IDIV=49, NOT_OP=50, - OPEN_BRACE=51, CLOSE_BRACE=52, LESS_THAN=53, GREATER_THAN=54, EQUALS=55, - GT_EQ=56, LT_EQ=57, NOT_EQ_1=58, NOT_EQ_2=59, AT=60, ARROW=61, ADD_ASSIGN=62, - SUB_ASSIGN=63, MULT_ASSIGN=64, AT_ASSIGN=65, DIV_ASSIGN=66, MOD_ASSIGN=67, - AND_ASSIGN=68, OR_ASSIGN=69, XOR_ASSIGN=70, LEFT_SHIFT_ASSIGN=71, RIGHT_SHIFT_ASSIGN=72, - POWER_ASSIGN=73, IDIV_ASSIGN=74, SKIP_=75, UNKNOWN_CHAR=76; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; - - public static String[] modeNames = { - "DEFAULT_MODE" - }; - - private static String[] makeRuleNames() { - return new String[] { - "STRING", "NUMBER", "AND", "AS", "DEF", "ELIF", "ELSE", "FALSE", "FOR", - "FROM", "IF", "IMPORT", "IN", "IS", "NONE", "NOT", "OR", "RETURN", "TRUE", - "UNDERSCORE", "WHILE", "NEWLINE", "NAME", "DECIMAL_INTEGER", "FLOAT_NUMBER", - "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN", "COMMA", "COLON", - "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", "CLOSE_BRACK", "OR_OP", - "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", "DIV", - "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", "LESS_THAN", "GREATER_THAN", - "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", - "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", - "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", - "POWER_ASSIGN", "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR", "STRING_ESCAPE_SEQ", - "NON_ZERO_DIGIT", "DIGIT", "POINT_FLOAT", "EXPONENT_FLOAT", "INT_PART", - "EXPONENT", "SPACES", "COMMENT", "LINE_JOINING" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, null, null, null, null, "'and'", "'as'", "'def'", "'elif'", "'else'", - "'False'", "'for'", "'from'", "'if'", "'import'", "'in'", "'is'", "'None'", - "'not'", "'or'", "'return'", "'True'", "'_'", "'while'", null, null, - null, null, "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'", - "'**'", "'='", "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", - "'-'", "'/'", "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", - "'>='", "'<='", "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", - "'@='", "'/='", "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", - "'//='" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "INDENT", "DEDENT", "STRING", "NUMBER", "AND", "AS", "DEF", "ELIF", - "ELSE", "FALSE", "FOR", "FROM", "IF", "IMPORT", "IN", "IS", "NONE", "NOT", - "OR", "RETURN", "TRUE", "UNDERSCORE", "WHILE", "NEWLINE", "NAME", "DECIMAL_INTEGER", - "FLOAT_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN", - "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", "CLOSE_BRACK", - "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", - "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", "LESS_THAN", - "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", "NOT_EQ_2", "AT", - "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN", - "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "LEFT_SHIFT_ASSIGN", - "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - - public Python3Lexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - @Override - public String getGrammarFileName() { return "Python3Lexer.g4"; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String getSerializedATN() { return _serializedATN; } - - @Override - public String[] getChannelNames() { return channelNames; } - - @Override - public String[] getModeNames() { return modeNames; } - - @Override - public ATN getATN() { return _ATN; } - - @Override - public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { - switch (ruleIndex) { - case 21: - NEWLINE_action((RuleContext)_localctx, actionIndex); - break; - case 28: - OPEN_PAREN_action((RuleContext)_localctx, actionIndex); - break; - case 29: - CLOSE_PAREN_action((RuleContext)_localctx, actionIndex); - break; - case 35: - OPEN_BRACK_action((RuleContext)_localctx, actionIndex); - break; - case 36: - CLOSE_BRACK_action((RuleContext)_localctx, actionIndex); - break; - case 48: - OPEN_BRACE_action((RuleContext)_localctx, actionIndex); - break; - case 49: - CLOSE_BRACE_action((RuleContext)_localctx, actionIndex); - break; - } - } - private void NEWLINE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 0: - this.onNewLine(); - break; - } - } - private void OPEN_PAREN_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 1: - this.openBrace(); - break; - } - } - private void CLOSE_PAREN_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 2: - this.closeBrace(); - break; - } - } - private void OPEN_BRACK_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 3: - this.openBrace(); - break; - } - } - private void CLOSE_BRACK_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 4: - this.closeBrace(); - break; - } - } - private void OPEN_BRACE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 5: - this.openBrace(); - break; - } - } - private void CLOSE_BRACE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 6: - this.closeBrace(); - break; - } - } - @Override - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 21: - return NEWLINE_sempred((RuleContext)_localctx, predIndex); - } - return true; - } - private boolean NEWLINE_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return this.atStartOfInput(); - } - return true; - } - - public static final String _serializedATN = - "\u0004\u0000L\u020b\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+ - "\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004"+ - "\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007"+ - "\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b"+ - "\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002"+ - "\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002"+ - "\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002"+ - "\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002"+ - "\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002"+ - "\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002"+ - "\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007"+ - "!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007"+ - "&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007"+ - "+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u0007"+ - "0\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u0007"+ - "5\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007"+ - ":\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007"+ - "?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007"+ - "D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007"+ - "I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007"+ - "N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007"+ - "S\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000\u00ad\b\u0000\n\u0000"+ - "\f\u0000\u00b0\t\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+ - "\u0005\u0000\u00b6\b\u0000\n\u0000\f\u0000\u00b9\t\u0000\u0001\u0000\u0003"+ - "\u0000\u00bc\b\u0000\u0001\u0001\u0001\u0001\u0003\u0001\u00c0\b\u0001"+ - "\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+ - "\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005"+ - "\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006"+ - "\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007"+ - "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\u000b"+ - "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ - "\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e"+ - "\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+ - "\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011"+ - "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012"+ - "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013"+ - "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ - "\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u0119\b\u0015\u0001\u0015"+ - "\u0001\u0015\u0003\u0015\u011d\b\u0015\u0001\u0015\u0003\u0015\u0120\b"+ - "\u0015\u0003\u0015\u0122\b\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+ - "\u0016\u0005\u0016\u0128\b\u0016\n\u0016\f\u0016\u012b\t\u0016\u0001\u0017"+ - "\u0001\u0017\u0005\u0017\u012f\b\u0017\n\u0017\f\u0017\u0132\t\u0017\u0001"+ - "\u0017\u0004\u0017\u0135\b\u0017\u000b\u0017\f\u0017\u0136\u0003\u0017"+ - "\u0139\b\u0017\u0001\u0018\u0001\u0018\u0003\u0018\u013d\b\u0018\u0001"+ - "\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001"+ - "\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001"+ - " \u0001 \u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001"+ - "$\u0001$\u0001$\u0001%\u0001%\u0001&\u0001&\u0001\'\u0001\'\u0001(\u0001"+ - "(\u0001(\u0001)\u0001)\u0001)\u0001*\u0001*\u0001+\u0001+\u0001,\u0001"+ - ",\u0001-\u0001-\u0001.\u0001.\u0001.\u0001/\u0001/\u00010\u00010\u0001"+ - "0\u00011\u00011\u00011\u00012\u00012\u00013\u00013\u00014\u00014\u0001"+ - "4\u00015\u00015\u00015\u00016\u00016\u00016\u00017\u00017\u00017\u0001"+ - "8\u00018\u00018\u00019\u00019\u0001:\u0001:\u0001:\u0001;\u0001;\u0001"+ - ";\u0001<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001"+ - "?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001B\u0001"+ - "B\u0001B\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001E\u0001"+ - "E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001G\u0001"+ - "G\u0001H\u0001H\u0001H\u0003H\u01c3\bH\u0001H\u0001H\u0001I\u0001I\u0001"+ - "J\u0001J\u0001J\u0001J\u0003J\u01cd\bJ\u0001K\u0001K\u0001L\u0001L\u0001"+ - "M\u0003M\u01d4\bM\u0001M\u0001M\u0004M\u01d8\bM\u000bM\fM\u01d9\u0001"+ - "M\u0001M\u0001M\u0003M\u01df\bM\u0001N\u0001N\u0003N\u01e3\bN\u0001N\u0001"+ - "N\u0001O\u0004O\u01e8\bO\u000bO\fO\u01e9\u0001P\u0001P\u0003P\u01ee\b"+ - "P\u0001P\u0004P\u01f1\bP\u000bP\fP\u01f2\u0001Q\u0004Q\u01f6\bQ\u000b"+ - "Q\fQ\u01f7\u0001R\u0001R\u0005R\u01fc\bR\nR\fR\u01ff\tR\u0001S\u0001S"+ - "\u0003S\u0203\bS\u0001S\u0003S\u0206\bS\u0001S\u0001S\u0003S\u020a\bS"+ - "\u0000\u0000T\u0001\u0003\u0003\u0004\u0005\u0005\u0007\u0006\t\u0007"+ - "\u000b\b\r\t\u000f\n\u0011\u000b\u0013\f\u0015\r\u0017\u000e\u0019\u000f"+ - "\u001b\u0010\u001d\u0011\u001f\u0012!\u0013#\u0014%\u0015\'\u0016)\u0017"+ - "+\u0018-\u0019/\u001a1\u001b3\u001c5\u001d7\u001e9\u001f; =!?\"A#C$E%"+ - "G&I\'K(M)O*Q+S,U-W.Y/[0]1_2a3c4e5g6i7k8m9o:q;sy?{@}A\u007fB\u0081"+ - "C\u0083D\u0085E\u0087F\u0089G\u008bH\u008dI\u008fJ\u0091K\u0093L\u0095"+ - "\u0000\u0097\u0000\u0099\u0000\u009b\u0000\u009d\u0000\u009f\u0000\u00a1"+ - "\u0000\u00a3\u0000\u00a5\u0000\u00a7\u0000\u0001\u0000\n\u0004\u0000\n"+ - "\n\f\r\'\'\\\\\u0004\u0000\n\n\f\r\"\"\\\\\u0003\u0000AZ__az\u0004\u0000"+ - "09AZ__az\u0001\u000019\u0001\u000009\u0002\u0000EEee\u0002\u0000++--\u0002"+ - "\u0000\t\t \u0002\u0000\n\n\f\r\u021e\u0000\u0001\u0001\u0000\u0000\u0000"+ - "\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000\u0000"+ - "\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000"+ - "\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f"+ - "\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013"+ - "\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017"+ - "\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b"+ - "\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f"+ - "\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000"+ - "\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000"+ - "\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000"+ - "-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001"+ - "\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000"+ - "\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000"+ - ";\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001"+ - "\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000"+ - "\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000"+ - "I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001"+ - "\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000"+ - "\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000"+ - "W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001"+ - "\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000"+ - "\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000"+ - "e\u0001\u0000\u0000\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001"+ - "\u0000\u0000\u0000\u0000k\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000"+ - "\u0000\u0000o\u0001\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000"+ - "s\u0001\u0000\u0000\u0000\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001"+ - "\u0000\u0000\u0000\u0000y\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000"+ - "\u0000\u0000}\u0001\u0000\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000"+ - "\u0000\u0081\u0001\u0000\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000"+ - "\u0000\u0085\u0001\u0000\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000"+ - "\u0000\u0089\u0001\u0000\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000"+ - "\u0000\u008d\u0001\u0000\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000"+ - "\u0000\u0091\u0001\u0000\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000"+ - "\u0001\u00bb\u0001\u0000\u0000\u0000\u0003\u00bf\u0001\u0000\u0000\u0000"+ - "\u0005\u00c1\u0001\u0000\u0000\u0000\u0007\u00c5\u0001\u0000\u0000\u0000"+ - "\t\u00c8\u0001\u0000\u0000\u0000\u000b\u00cc\u0001\u0000\u0000\u0000\r"+ - "\u00d1\u0001\u0000\u0000\u0000\u000f\u00d6\u0001\u0000\u0000\u0000\u0011"+ - "\u00dc\u0001\u0000\u0000\u0000\u0013\u00e0\u0001\u0000\u0000\u0000\u0015"+ - "\u00e5\u0001\u0000\u0000\u0000\u0017\u00e8\u0001\u0000\u0000\u0000\u0019"+ - "\u00ef\u0001\u0000\u0000\u0000\u001b\u00f2\u0001\u0000\u0000\u0000\u001d"+ - "\u00f5\u0001\u0000\u0000\u0000\u001f\u00fa\u0001\u0000\u0000\u0000!\u00fe"+ - "\u0001\u0000\u0000\u0000#\u0101\u0001\u0000\u0000\u0000%\u0108\u0001\u0000"+ - "\u0000\u0000\'\u010d\u0001\u0000\u0000\u0000)\u010f\u0001\u0000\u0000"+ - "\u0000+\u0121\u0001\u0000\u0000\u0000-\u0125\u0001\u0000\u0000\u0000/"+ - "\u0138\u0001\u0000\u0000\u00001\u013c\u0001\u0000\u0000\u00003\u013e\u0001"+ - "\u0000\u0000\u00005\u0140\u0001\u0000\u0000\u00007\u0144\u0001\u0000\u0000"+ - "\u00009\u0146\u0001\u0000\u0000\u0000;\u0149\u0001\u0000\u0000\u0000="+ - "\u014c\u0001\u0000\u0000\u0000?\u014e\u0001\u0000\u0000\u0000A\u0150\u0001"+ - "\u0000\u0000\u0000C\u0152\u0001\u0000\u0000\u0000E\u0155\u0001\u0000\u0000"+ - "\u0000G\u0157\u0001\u0000\u0000\u0000I\u015a\u0001\u0000\u0000\u0000K"+ - "\u015d\u0001\u0000\u0000\u0000M\u015f\u0001\u0000\u0000\u0000O\u0161\u0001"+ - "\u0000\u0000\u0000Q\u0163\u0001\u0000\u0000\u0000S\u0166\u0001\u0000\u0000"+ - "\u0000U\u0169\u0001\u0000\u0000\u0000W\u016b\u0001\u0000\u0000\u0000Y"+ - "\u016d\u0001\u0000\u0000\u0000[\u016f\u0001\u0000\u0000\u0000]\u0171\u0001"+ - "\u0000\u0000\u0000_\u0174\u0001\u0000\u0000\u0000a\u0176\u0001\u0000\u0000"+ - "\u0000c\u0179\u0001\u0000\u0000\u0000e\u017c\u0001\u0000\u0000\u0000g"+ - "\u017e\u0001\u0000\u0000\u0000i\u0180\u0001\u0000\u0000\u0000k\u0183\u0001"+ - "\u0000\u0000\u0000m\u0186\u0001\u0000\u0000\u0000o\u0189\u0001\u0000\u0000"+ - "\u0000q\u018c\u0001\u0000\u0000\u0000s\u018f\u0001\u0000\u0000\u0000u"+ - "\u0191\u0001\u0000\u0000\u0000w\u0194\u0001\u0000\u0000\u0000y\u0197\u0001"+ - "\u0000\u0000\u0000{\u019a\u0001\u0000\u0000\u0000}\u019d\u0001\u0000\u0000"+ - "\u0000\u007f\u01a0\u0001\u0000\u0000\u0000\u0081\u01a3\u0001\u0000\u0000"+ - "\u0000\u0083\u01a6\u0001\u0000\u0000\u0000\u0085\u01a9\u0001\u0000\u0000"+ - "\u0000\u0087\u01ac\u0001\u0000\u0000\u0000\u0089\u01af\u0001\u0000\u0000"+ - "\u0000\u008b\u01b3\u0001\u0000\u0000\u0000\u008d\u01b7\u0001\u0000\u0000"+ - "\u0000\u008f\u01bb\u0001\u0000\u0000\u0000\u0091\u01c2\u0001\u0000\u0000"+ - "\u0000\u0093\u01c6\u0001\u0000\u0000\u0000\u0095\u01cc\u0001\u0000\u0000"+ - "\u0000\u0097\u01ce\u0001\u0000\u0000\u0000\u0099\u01d0\u0001\u0000\u0000"+ - "\u0000\u009b\u01de\u0001\u0000\u0000\u0000\u009d\u01e2\u0001\u0000\u0000"+ - "\u0000\u009f\u01e7\u0001\u0000\u0000\u0000\u00a1\u01eb\u0001\u0000\u0000"+ - "\u0000\u00a3\u01f5\u0001\u0000\u0000\u0000\u00a5\u01f9\u0001\u0000\u0000"+ - "\u0000\u00a7\u0200\u0001\u0000\u0000\u0000\u00a9\u00ae\u0005\'\u0000\u0000"+ - "\u00aa\u00ad\u0003\u0095J\u0000\u00ab\u00ad\b\u0000\u0000\u0000\u00ac"+ - "\u00aa\u0001\u0000\u0000\u0000\u00ac\u00ab\u0001\u0000\u0000\u0000\u00ad"+ - "\u00b0\u0001\u0000\u0000\u0000\u00ae\u00ac\u0001\u0000\u0000\u0000\u00ae"+ - "\u00af\u0001\u0000\u0000\u0000\u00af\u00b1\u0001\u0000\u0000\u0000\u00b0"+ - "\u00ae\u0001\u0000\u0000\u0000\u00b1\u00bc\u0005\'\u0000\u0000\u00b2\u00b7"+ - "\u0005\"\u0000\u0000\u00b3\u00b6\u0003\u0095J\u0000\u00b4\u00b6\b\u0001"+ - "\u0000\u0000\u00b5\u00b3\u0001\u0000\u0000\u0000\u00b5\u00b4\u0001\u0000"+ - "\u0000\u0000\u00b6\u00b9\u0001\u0000\u0000\u0000\u00b7\u00b5\u0001\u0000"+ - "\u0000\u0000\u00b7\u00b8\u0001\u0000\u0000\u0000\u00b8\u00ba\u0001\u0000"+ - "\u0000\u0000\u00b9\u00b7\u0001\u0000\u0000\u0000\u00ba\u00bc\u0005\"\u0000"+ - "\u0000\u00bb\u00a9\u0001\u0000\u0000\u0000\u00bb\u00b2\u0001\u0000\u0000"+ - "\u0000\u00bc\u0002\u0001\u0000\u0000\u0000\u00bd\u00c0\u0003/\u0017\u0000"+ - "\u00be\u00c0\u00031\u0018\u0000\u00bf\u00bd\u0001\u0000\u0000\u0000\u00bf"+ - "\u00be\u0001\u0000\u0000\u0000\u00c0\u0004\u0001\u0000\u0000\u0000\u00c1"+ - "\u00c2\u0005a\u0000\u0000\u00c2\u00c3\u0005n\u0000\u0000\u00c3\u00c4\u0005"+ - "d\u0000\u0000\u00c4\u0006\u0001\u0000\u0000\u0000\u00c5\u00c6\u0005a\u0000"+ - "\u0000\u00c6\u00c7\u0005s\u0000\u0000\u00c7\b\u0001\u0000\u0000\u0000"+ - "\u00c8\u00c9\u0005d\u0000\u0000\u00c9\u00ca\u0005e\u0000\u0000\u00ca\u00cb"+ - "\u0005f\u0000\u0000\u00cb\n\u0001\u0000\u0000\u0000\u00cc\u00cd\u0005"+ - "e\u0000\u0000\u00cd\u00ce\u0005l\u0000\u0000\u00ce\u00cf\u0005i\u0000"+ - "\u0000\u00cf\u00d0\u0005f\u0000\u0000\u00d0\f\u0001\u0000\u0000\u0000"+ - "\u00d1\u00d2\u0005e\u0000\u0000\u00d2\u00d3\u0005l\u0000\u0000\u00d3\u00d4"+ - "\u0005s\u0000\u0000\u00d4\u00d5\u0005e\u0000\u0000\u00d5\u000e\u0001\u0000"+ - "\u0000\u0000\u00d6\u00d7\u0005F\u0000\u0000\u00d7\u00d8\u0005a\u0000\u0000"+ - "\u00d8\u00d9\u0005l\u0000\u0000\u00d9\u00da\u0005s\u0000\u0000\u00da\u00db"+ - "\u0005e\u0000\u0000\u00db\u0010\u0001\u0000\u0000\u0000\u00dc\u00dd\u0005"+ - "f\u0000\u0000\u00dd\u00de\u0005o\u0000\u0000\u00de\u00df\u0005r\u0000"+ - "\u0000\u00df\u0012\u0001\u0000\u0000\u0000\u00e0\u00e1\u0005f\u0000\u0000"+ - "\u00e1\u00e2\u0005r\u0000\u0000\u00e2\u00e3\u0005o\u0000\u0000\u00e3\u00e4"+ - "\u0005m\u0000\u0000\u00e4\u0014\u0001\u0000\u0000\u0000\u00e5\u00e6\u0005"+ - "i\u0000\u0000\u00e6\u00e7\u0005f\u0000\u0000\u00e7\u0016\u0001\u0000\u0000"+ - "\u0000\u00e8\u00e9\u0005i\u0000\u0000\u00e9\u00ea\u0005m\u0000\u0000\u00ea"+ - "\u00eb\u0005p\u0000\u0000\u00eb\u00ec\u0005o\u0000\u0000\u00ec\u00ed\u0005"+ - "r\u0000\u0000\u00ed\u00ee\u0005t\u0000\u0000\u00ee\u0018\u0001\u0000\u0000"+ - "\u0000\u00ef\u00f0\u0005i\u0000\u0000\u00f0\u00f1\u0005n\u0000\u0000\u00f1"+ - "\u001a\u0001\u0000\u0000\u0000\u00f2\u00f3\u0005i\u0000\u0000\u00f3\u00f4"+ - "\u0005s\u0000\u0000\u00f4\u001c\u0001\u0000\u0000\u0000\u00f5\u00f6\u0005"+ - "N\u0000\u0000\u00f6\u00f7\u0005o\u0000\u0000\u00f7\u00f8\u0005n\u0000"+ - "\u0000\u00f8\u00f9\u0005e\u0000\u0000\u00f9\u001e\u0001\u0000\u0000\u0000"+ - "\u00fa\u00fb\u0005n\u0000\u0000\u00fb\u00fc\u0005o\u0000\u0000\u00fc\u00fd"+ - "\u0005t\u0000\u0000\u00fd \u0001\u0000\u0000\u0000\u00fe\u00ff\u0005o"+ - "\u0000\u0000\u00ff\u0100\u0005r\u0000\u0000\u0100\"\u0001\u0000\u0000"+ - "\u0000\u0101\u0102\u0005r\u0000\u0000\u0102\u0103\u0005e\u0000\u0000\u0103"+ - "\u0104\u0005t\u0000\u0000\u0104\u0105\u0005u\u0000\u0000\u0105\u0106\u0005"+ - "r\u0000\u0000\u0106\u0107\u0005n\u0000\u0000\u0107$\u0001\u0000\u0000"+ - "\u0000\u0108\u0109\u0005T\u0000\u0000\u0109\u010a\u0005r\u0000\u0000\u010a"+ - "\u010b\u0005u\u0000\u0000\u010b\u010c\u0005e\u0000\u0000\u010c&\u0001"+ - "\u0000\u0000\u0000\u010d\u010e\u0005_\u0000\u0000\u010e(\u0001\u0000\u0000"+ - "\u0000\u010f\u0110\u0005w\u0000\u0000\u0110\u0111\u0005h\u0000\u0000\u0111"+ - "\u0112\u0005i\u0000\u0000\u0112\u0113\u0005l\u0000\u0000\u0113\u0114\u0005"+ - "e\u0000\u0000\u0114*\u0001\u0000\u0000\u0000\u0115\u0116\u0004\u0015\u0000"+ - "\u0000\u0116\u0122\u0003\u00a3Q\u0000\u0117\u0119\u0005\r\u0000\u0000"+ - "\u0118\u0117\u0001\u0000\u0000\u0000\u0118\u0119\u0001\u0000\u0000\u0000"+ - "\u0119\u011a\u0001\u0000\u0000\u0000\u011a\u011d\u0005\n\u0000\u0000\u011b"+ - "\u011d\u0002\f\r\u0000\u011c\u0118\u0001\u0000\u0000\u0000\u011c\u011b"+ - "\u0001\u0000\u0000\u0000\u011d\u011f\u0001\u0000\u0000\u0000\u011e\u0120"+ - "\u0003\u00a3Q\u0000\u011f\u011e\u0001\u0000\u0000\u0000\u011f\u0120\u0001"+ - "\u0000\u0000\u0000\u0120\u0122\u0001\u0000\u0000\u0000\u0121\u0115\u0001"+ - "\u0000\u0000\u0000\u0121\u011c\u0001\u0000\u0000\u0000\u0122\u0123\u0001"+ - "\u0000\u0000\u0000\u0123\u0124\u0006\u0015\u0000\u0000\u0124,\u0001\u0000"+ - "\u0000\u0000\u0125\u0129\u0007\u0002\u0000\u0000\u0126\u0128\u0007\u0003"+ - "\u0000\u0000\u0127\u0126\u0001\u0000\u0000\u0000\u0128\u012b\u0001\u0000"+ - "\u0000\u0000\u0129\u0127\u0001\u0000\u0000\u0000\u0129\u012a\u0001\u0000"+ - "\u0000\u0000\u012a.\u0001\u0000\u0000\u0000\u012b\u0129\u0001\u0000\u0000"+ - "\u0000\u012c\u0130\u0003\u0097K\u0000\u012d\u012f\u0003\u0099L\u0000\u012e"+ - "\u012d\u0001\u0000\u0000\u0000\u012f\u0132\u0001\u0000\u0000\u0000\u0130"+ - "\u012e\u0001\u0000\u0000\u0000\u0130\u0131\u0001\u0000\u0000\u0000\u0131"+ - "\u0139\u0001\u0000\u0000\u0000\u0132\u0130\u0001\u0000\u0000\u0000\u0133"+ - "\u0135\u00050\u0000\u0000\u0134\u0133\u0001\u0000\u0000\u0000\u0135\u0136"+ - "\u0001\u0000\u0000\u0000\u0136\u0134\u0001\u0000\u0000\u0000\u0136\u0137"+ - "\u0001\u0000\u0000\u0000\u0137\u0139\u0001\u0000\u0000\u0000\u0138\u012c"+ - "\u0001\u0000\u0000\u0000\u0138\u0134\u0001\u0000\u0000\u0000\u01390\u0001"+ - "\u0000\u0000\u0000\u013a\u013d\u0003\u009bM\u0000\u013b\u013d\u0003\u009d"+ - "N\u0000\u013c\u013a\u0001\u0000\u0000\u0000\u013c\u013b\u0001\u0000\u0000"+ - "\u0000\u013d2\u0001\u0000\u0000\u0000\u013e\u013f\u0005.\u0000\u0000\u013f"+ - "4\u0001\u0000\u0000\u0000\u0140\u0141\u0005.\u0000\u0000\u0141\u0142\u0005"+ - ".\u0000\u0000\u0142\u0143\u0005.\u0000\u0000\u01436\u0001\u0000\u0000"+ - "\u0000\u0144\u0145\u0005*\u0000\u0000\u01458\u0001\u0000\u0000\u0000\u0146"+ - "\u0147\u0005(\u0000\u0000\u0147\u0148\u0006\u001c\u0001\u0000\u0148:\u0001"+ - "\u0000\u0000\u0000\u0149\u014a\u0005)\u0000\u0000\u014a\u014b\u0006\u001d"+ - "\u0002\u0000\u014b<\u0001\u0000\u0000\u0000\u014c\u014d\u0005,\u0000\u0000"+ - "\u014d>\u0001\u0000\u0000\u0000\u014e\u014f\u0005:\u0000\u0000\u014f@"+ - "\u0001\u0000\u0000\u0000\u0150\u0151\u0005;\u0000\u0000\u0151B\u0001\u0000"+ - "\u0000\u0000\u0152\u0153\u0005*\u0000\u0000\u0153\u0154\u0005*\u0000\u0000"+ - "\u0154D\u0001\u0000\u0000\u0000\u0155\u0156\u0005=\u0000\u0000\u0156F"+ - "\u0001\u0000\u0000\u0000\u0157\u0158\u0005[\u0000\u0000\u0158\u0159\u0006"+ - "#\u0003\u0000\u0159H\u0001\u0000\u0000\u0000\u015a\u015b\u0005]\u0000"+ - "\u0000\u015b\u015c\u0006$\u0004\u0000\u015cJ\u0001\u0000\u0000\u0000\u015d"+ - "\u015e\u0005|\u0000\u0000\u015eL\u0001\u0000\u0000\u0000\u015f\u0160\u0005"+ - "^\u0000\u0000\u0160N\u0001\u0000\u0000\u0000\u0161\u0162\u0005&\u0000"+ - "\u0000\u0162P\u0001\u0000\u0000\u0000\u0163\u0164\u0005<\u0000\u0000\u0164"+ - "\u0165\u0005<\u0000\u0000\u0165R\u0001\u0000\u0000\u0000\u0166\u0167\u0005"+ - ">\u0000\u0000\u0167\u0168\u0005>\u0000\u0000\u0168T\u0001\u0000\u0000"+ - "\u0000\u0169\u016a\u0005+\u0000\u0000\u016aV\u0001\u0000\u0000\u0000\u016b"+ - "\u016c\u0005-\u0000\u0000\u016cX\u0001\u0000\u0000\u0000\u016d\u016e\u0005"+ - "/\u0000\u0000\u016eZ\u0001\u0000\u0000\u0000\u016f\u0170\u0005%\u0000"+ - "\u0000\u0170\\\u0001\u0000\u0000\u0000\u0171\u0172\u0005/\u0000\u0000"+ - "\u0172\u0173\u0005/\u0000\u0000\u0173^\u0001\u0000\u0000\u0000\u0174\u0175"+ - "\u0005~\u0000\u0000\u0175`\u0001\u0000\u0000\u0000\u0176\u0177\u0005{"+ - "\u0000\u0000\u0177\u0178\u00060\u0005\u0000\u0178b\u0001\u0000\u0000\u0000"+ - "\u0179\u017a\u0005}\u0000\u0000\u017a\u017b\u00061\u0006\u0000\u017bd"+ - "\u0001\u0000\u0000\u0000\u017c\u017d\u0005<\u0000\u0000\u017df\u0001\u0000"+ - "\u0000\u0000\u017e\u017f\u0005>\u0000\u0000\u017fh\u0001\u0000\u0000\u0000"+ - "\u0180\u0181\u0005=\u0000\u0000\u0181\u0182\u0005=\u0000\u0000\u0182j"+ - "\u0001\u0000\u0000\u0000\u0183\u0184\u0005>\u0000\u0000\u0184\u0185\u0005"+ - "=\u0000\u0000\u0185l\u0001\u0000\u0000\u0000\u0186\u0187\u0005<\u0000"+ - "\u0000\u0187\u0188\u0005=\u0000\u0000\u0188n\u0001\u0000\u0000\u0000\u0189"+ - "\u018a\u0005<\u0000\u0000\u018a\u018b\u0005>\u0000\u0000\u018bp\u0001"+ - "\u0000\u0000\u0000\u018c\u018d\u0005!\u0000\u0000\u018d\u018e\u0005=\u0000"+ - "\u0000\u018er\u0001\u0000\u0000\u0000\u018f\u0190\u0005@\u0000\u0000\u0190"+ - "t\u0001\u0000\u0000\u0000\u0191\u0192\u0005-\u0000\u0000\u0192\u0193\u0005"+ - ">\u0000\u0000\u0193v\u0001\u0000\u0000\u0000\u0194\u0195\u0005+\u0000"+ - "\u0000\u0195\u0196\u0005=\u0000\u0000\u0196x\u0001\u0000\u0000\u0000\u0197"+ - "\u0198\u0005-\u0000\u0000\u0198\u0199\u0005=\u0000\u0000\u0199z\u0001"+ - "\u0000\u0000\u0000\u019a\u019b\u0005*\u0000\u0000\u019b\u019c\u0005=\u0000"+ - "\u0000\u019c|\u0001\u0000\u0000\u0000\u019d\u019e\u0005@\u0000\u0000\u019e"+ - "\u019f\u0005=\u0000\u0000\u019f~\u0001\u0000\u0000\u0000\u01a0\u01a1\u0005"+ - "/\u0000\u0000\u01a1\u01a2\u0005=\u0000\u0000\u01a2\u0080\u0001\u0000\u0000"+ - "\u0000\u01a3\u01a4\u0005%\u0000\u0000\u01a4\u01a5\u0005=\u0000\u0000\u01a5"+ - "\u0082\u0001\u0000\u0000\u0000\u01a6\u01a7\u0005&\u0000\u0000\u01a7\u01a8"+ - "\u0005=\u0000\u0000\u01a8\u0084\u0001\u0000\u0000\u0000\u01a9\u01aa\u0005"+ - "|\u0000\u0000\u01aa\u01ab\u0005=\u0000\u0000\u01ab\u0086\u0001\u0000\u0000"+ - "\u0000\u01ac\u01ad\u0005^\u0000\u0000\u01ad\u01ae\u0005=\u0000\u0000\u01ae"+ - "\u0088\u0001\u0000\u0000\u0000\u01af\u01b0\u0005<\u0000\u0000\u01b0\u01b1"+ - "\u0005<\u0000\u0000\u01b1\u01b2\u0005=\u0000\u0000\u01b2\u008a\u0001\u0000"+ - "\u0000\u0000\u01b3\u01b4\u0005>\u0000\u0000\u01b4\u01b5\u0005>\u0000\u0000"+ - "\u01b5\u01b6\u0005=\u0000\u0000\u01b6\u008c\u0001\u0000\u0000\u0000\u01b7"+ - "\u01b8\u0005*\u0000\u0000\u01b8\u01b9\u0005*\u0000\u0000\u01b9\u01ba\u0005"+ - "=\u0000\u0000\u01ba\u008e\u0001\u0000\u0000\u0000\u01bb\u01bc\u0005/\u0000"+ - "\u0000\u01bc\u01bd\u0005/\u0000\u0000\u01bd\u01be\u0005=\u0000\u0000\u01be"+ - "\u0090\u0001\u0000\u0000\u0000\u01bf\u01c3\u0003\u00a3Q\u0000\u01c0\u01c3"+ - "\u0003\u00a5R\u0000\u01c1\u01c3\u0003\u00a7S\u0000\u01c2\u01bf\u0001\u0000"+ - "\u0000\u0000\u01c2\u01c0\u0001\u0000\u0000\u0000\u01c2\u01c1\u0001\u0000"+ - "\u0000\u0000\u01c3\u01c4\u0001\u0000\u0000\u0000\u01c4\u01c5\u0006H\u0007"+ - "\u0000\u01c5\u0092\u0001\u0000\u0000\u0000\u01c6\u01c7\t\u0000\u0000\u0000"+ - "\u01c7\u0094\u0001\u0000\u0000\u0000\u01c8\u01c9\u0005\\\u0000\u0000\u01c9"+ - "\u01cd\t\u0000\u0000\u0000\u01ca\u01cb\u0005\\\u0000\u0000\u01cb\u01cd"+ - "\u0003+\u0015\u0000\u01cc\u01c8\u0001\u0000\u0000\u0000\u01cc\u01ca\u0001"+ - "\u0000\u0000\u0000\u01cd\u0096\u0001\u0000\u0000\u0000\u01ce\u01cf\u0007"+ - "\u0004\u0000\u0000\u01cf\u0098\u0001\u0000\u0000\u0000\u01d0\u01d1\u0007"+ - "\u0005\u0000\u0000\u01d1\u009a\u0001\u0000\u0000\u0000\u01d2\u01d4\u0003"+ - "\u009fO\u0000\u01d3\u01d2\u0001\u0000\u0000\u0000\u01d3\u01d4\u0001\u0000"+ - "\u0000\u0000\u01d4\u01d5\u0001\u0000\u0000\u0000\u01d5\u01d7\u0005.\u0000"+ - "\u0000\u01d6\u01d8\u0003\u0099L\u0000\u01d7\u01d6\u0001\u0000\u0000\u0000"+ - "\u01d8\u01d9\u0001\u0000\u0000\u0000\u01d9\u01d7\u0001\u0000\u0000\u0000"+ - "\u01d9\u01da\u0001\u0000\u0000\u0000\u01da\u01df\u0001\u0000\u0000\u0000"+ - "\u01db\u01dc\u0003\u009fO\u0000\u01dc\u01dd\u0005.\u0000\u0000\u01dd\u01df"+ - "\u0001\u0000\u0000\u0000\u01de\u01d3\u0001\u0000\u0000\u0000\u01de\u01db"+ - "\u0001\u0000\u0000\u0000\u01df\u009c\u0001\u0000\u0000\u0000\u01e0\u01e3"+ - "\u0003\u009fO\u0000\u01e1\u01e3\u0003\u009bM\u0000\u01e2\u01e0\u0001\u0000"+ - "\u0000\u0000\u01e2\u01e1\u0001\u0000\u0000\u0000\u01e3\u01e4\u0001\u0000"+ - "\u0000\u0000\u01e4\u01e5\u0003\u00a1P\u0000\u01e5\u009e\u0001\u0000\u0000"+ - "\u0000\u01e6\u01e8\u0003\u0099L\u0000\u01e7\u01e6\u0001\u0000\u0000\u0000"+ - "\u01e8\u01e9\u0001\u0000\u0000\u0000\u01e9\u01e7\u0001\u0000\u0000\u0000"+ - "\u01e9\u01ea\u0001\u0000\u0000\u0000\u01ea\u00a0\u0001\u0000\u0000\u0000"+ - "\u01eb\u01ed\u0007\u0006\u0000\u0000\u01ec\u01ee\u0007\u0007\u0000\u0000"+ - "\u01ed\u01ec\u0001\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000\u0000\u0000"+ - "\u01ee\u01f0\u0001\u0000\u0000\u0000\u01ef\u01f1\u0003\u0099L\u0000\u01f0"+ - "\u01ef\u0001\u0000\u0000\u0000\u01f1\u01f2\u0001\u0000\u0000\u0000\u01f2"+ - "\u01f0\u0001\u0000\u0000\u0000\u01f2\u01f3\u0001\u0000\u0000\u0000\u01f3"+ - "\u00a2\u0001\u0000\u0000\u0000\u01f4\u01f6\u0007\b\u0000\u0000\u01f5\u01f4"+ - "\u0001\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000\u01f7\u01f5"+ - "\u0001\u0000\u0000\u0000\u01f7\u01f8\u0001\u0000\u0000\u0000\u01f8\u00a4"+ - "\u0001\u0000\u0000\u0000\u01f9\u01fd\u0005#\u0000\u0000\u01fa\u01fc\b"+ - "\t\u0000\u0000\u01fb\u01fa\u0001\u0000\u0000\u0000\u01fc\u01ff\u0001\u0000"+ - "\u0000\u0000\u01fd\u01fb\u0001\u0000\u0000\u0000\u01fd\u01fe\u0001\u0000"+ - "\u0000\u0000\u01fe\u00a6\u0001\u0000\u0000\u0000\u01ff\u01fd\u0001\u0000"+ - "\u0000\u0000\u0200\u0202\u0005\\\u0000\u0000\u0201\u0203\u0003\u00a3Q"+ - "\u0000\u0202\u0201\u0001\u0000\u0000\u0000\u0202\u0203\u0001\u0000\u0000"+ - "\u0000\u0203\u0209\u0001\u0000\u0000\u0000\u0204\u0206\u0005\r\u0000\u0000"+ - "\u0205\u0204\u0001\u0000\u0000\u0000\u0205\u0206\u0001\u0000\u0000\u0000"+ - "\u0206\u0207\u0001\u0000\u0000\u0000\u0207\u020a\u0005\n\u0000\u0000\u0208"+ - "\u020a\u0002\f\r\u0000\u0209\u0205\u0001\u0000\u0000\u0000\u0209\u0208"+ - "\u0001\u0000\u0000\u0000\u020a\u00a8\u0001\u0000\u0000\u0000\u001e\u0000"+ - "\u00ac\u00ae\u00b5\u00b7\u00bb\u00bf\u0118\u011c\u011f\u0121\u0129\u0130"+ - "\u0136\u0138\u013c\u01c2\u01cc\u01d3\u01d9\u01de\u01e2\u01e9\u01ed\u01f2"+ - "\u01f7\u01fd\u0202\u0205\u0209\b\u0001\u0015\u0000\u0001\u001c\u0001\u0001"+ - "\u001d\u0002\u0001#\u0003\u0001$\u0004\u00010\u0005\u00011\u0006\u0006"+ - "\u0000\u0000"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/parser/.antlr/Python3Lexer.tokens b/src/parser/.antlr/Python3Lexer.tokens deleted file mode 100644 index 0f817cc..0000000 --- a/src/parser/.antlr/Python3Lexer.tokens +++ /dev/null @@ -1,142 +0,0 @@ -INDENT=1 -DEDENT=2 -STRING=3 -NUMBER=4 -AND=5 -AS=6 -DEF=7 -ELIF=8 -ELSE=9 -FALSE=10 -FOR=11 -FROM=12 -IF=13 -IMPORT=14 -IN=15 -IS=16 -NONE=17 -NOT=18 -OR=19 -RETURN=20 -TRUE=21 -UNDERSCORE=22 -WHILE=23 -NEWLINE=24 -NAME=25 -DECIMAL_INTEGER=26 -FLOAT_NUMBER=27 -DOT=28 -ELLIPSIS=29 -STAR=30 -OPEN_PAREN=31 -CLOSE_PAREN=32 -COMMA=33 -COLON=34 -SEMI_COLON=35 -POWER=36 -ASSIGN=37 -OPEN_BRACK=38 -CLOSE_BRACK=39 -OR_OP=40 -XOR=41 -AND_OP=42 -LEFT_SHIFT=43 -RIGHT_SHIFT=44 -ADD=45 -MINUS=46 -DIV=47 -MOD=48 -IDIV=49 -NOT_OP=50 -OPEN_BRACE=51 -CLOSE_BRACE=52 -LESS_THAN=53 -GREATER_THAN=54 -EQUALS=55 -GT_EQ=56 -LT_EQ=57 -NOT_EQ_1=58 -NOT_EQ_2=59 -AT=60 -ARROW=61 -ADD_ASSIGN=62 -SUB_ASSIGN=63 -MULT_ASSIGN=64 -AT_ASSIGN=65 -DIV_ASSIGN=66 -MOD_ASSIGN=67 -AND_ASSIGN=68 -OR_ASSIGN=69 -XOR_ASSIGN=70 -LEFT_SHIFT_ASSIGN=71 -RIGHT_SHIFT_ASSIGN=72 -POWER_ASSIGN=73 -IDIV_ASSIGN=74 -SKIP_=75 -UNKNOWN_CHAR=76 -'and'=5 -'as'=6 -'def'=7 -'elif'=8 -'else'=9 -'False'=10 -'for'=11 -'from'=12 -'if'=13 -'import'=14 -'in'=15 -'is'=16 -'None'=17 -'not'=18 -'or'=19 -'return'=20 -'True'=21 -'_'=22 -'while'=23 -'.'=28 -'...'=29 -'*'=30 -'('=31 -')'=32 -','=33 -':'=34 -';'=35 -'**'=36 -'='=37 -'['=38 -']'=39 -'|'=40 -'^'=41 -'&'=42 -'<<'=43 -'>>'=44 -'+'=45 -'-'=46 -'/'=47 -'%'=48 -'//'=49 -'~'=50 -'{'=51 -'}'=52 -'<'=53 -'>'=54 -'=='=55 -'>='=56 -'<='=57 -'<>'=58 -'!='=59 -'@'=60 -'->'=61 -'+='=62 -'-='=63 -'*='=64 -'@='=65 -'/='=66 -'%='=67 -'&='=68 -'|='=69 -'^='=70 -'<<='=71 -'>>='=72 -'**='=73 -'//='=74 -- cgit v1.2.3-18-g5258 From fc712f94a7ed8554d8d44f4965be367354a7e670 Mon Sep 17 00:00:00 2001 From: L0P0P Date: Wed, 26 Jun 2024 10:06:12 +0200 Subject: Using child --- progs/test.py | 8 ++++---- src/ast/Python3VisitorImpl.java | 40 ++++++++++++++++++++++------------------ src/ast/nodes/AtomNode.java | 2 +- src/ast/nodes/BlockNode.java | 11 ++++------- src/ast/nodes/ExprNode.java | 4 +++- src/ast/nodes/FuncdefNode.java | 1 + src/ast/nodes/RootNode.java | 27 +++++++++++---------------- 7 files changed, 46 insertions(+), 47 deletions(-) diff --git a/progs/test.py b/progs/test.py index ab0901a..72729e1 100644 --- a/progs/test.py +++ b/progs/test.py @@ -1,4 +1,4 @@ -x = 1 - -if x == 1: - print("a") +def unibo(a): + print("u") + +unibo(a) diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index 604c8d2..f5b369d 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -21,17 +21,19 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * ``` */ public Node visitRoot(RootContext ctx) { - ArrayList stmts = new ArrayList(); - ArrayList compStmts = new ArrayList(); - - for (Simple_stmtsContext stm : ctx.simple_stmts()) { - stmts.add(visit(stm)); - } - for (Compound_stmtContext stm : ctx.compound_stmt()) { - compStmts.add(visit(stm)); + ArrayList childs = new ArrayList(); + + for (int i = 0; i < ctx.getChildCount(); i++){ + var child = ctx.getChild(i); + + if (child instanceof Simple_stmtsContext) { + childs.add(visit((Simple_stmtsContext) child)); + } else if (child instanceof Compound_stmtContext) { + childs.add(visit((Compound_stmtContext) child)); + } } - return new RootNode(stmts, compStmts); + return new RootNode(childs); } /** @@ -331,17 +333,19 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * ``` */ public Node visitBlock(BlockContext ctx) { - ArrayList stmts = new ArrayList(); - ArrayList compStmts = new ArrayList(); - - for (Simple_stmtsContext s : ctx.simple_stmts()) { - stmts.add(visit(s)); - } - for (Compound_stmtContext s : ctx.compound_stmt()) { - compStmts.add(visit(s)); + ArrayList childs = new ArrayList(); + + for (int i = 0; i < ctx.getChildCount(); i++){ + var child = ctx.getChild(i); + + if (child instanceof Simple_stmtsContext) { + childs.add(visit((Simple_stmtsContext) child)); + } else if (child instanceof Compound_stmtContext) { + childs.add(visit((Compound_stmtContext) child)); + } } - return new BlockNode(stmts, compStmts); + return new BlockNode(childs); } /** diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 4c9a807..0a3c765 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -26,7 +26,7 @@ public class AtomNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { var errors = new ArrayList(); // System.out.println("[ATOM] id: " + getId() + " ns: " + _nesting + " top_lookup" + ST.top_lookup(this.getId())); - if ((this.typeCheck() instanceof AtomType) && !ST.top_lookup(this.getId())) { + if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); errors.add(new SemanticError("Undefined name `" + this.getId() + "`")); } diff --git a/src/ast/nodes/BlockNode.java b/src/ast/nodes/BlockNode.java index 6b07f49..2c85025 100644 --- a/src/ast/nodes/BlockNode.java +++ b/src/ast/nodes/BlockNode.java @@ -9,8 +9,8 @@ import ast.types.*; * It extends the `RootNode`. */ public class BlockNode extends RootNode { - public BlockNode(ArrayList stmts, ArrayList compoundStmts) { - super(stmts, compoundStmts); + public BlockNode(ArrayList childs) { + super(childs); } @Override @@ -23,11 +23,8 @@ public class BlockNode extends RootNode { String str = prefix + "Block\n"; prefix += " "; - for (Node stmt : stmts) { - str += stmt.toPrint(prefix); - } - for (Node stmt : compoundStmts) { - str += stmt.toPrint(prefix); + for (Node child : childs) { + str += child.toPrint(prefix); } return str; diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 13b6619..344f3c0 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -17,7 +17,9 @@ public class ExprNode implements Node { private ArrayList exprs; private ArrayList trailers; - private static final String[] bif = {"abs", + // built-in functions + private static final String[] bif = { + "abs", "aiter", "all", "anext", diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index 341a28d..742f670 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -26,6 +26,7 @@ public class FuncdefNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + ST.insert(this.name.toString(), this.block.typeCheck(), _nesting, ""); HashMap HM = new HashMap(); diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java index 45d20db..4b29e8d 100644 --- a/src/ast/nodes/RootNode.java +++ b/src/ast/nodes/RootNode.java @@ -12,30 +12,28 @@ public class RootNode implements Node { // stms and compundStmts are protected because they are reused for a // BlockNode - protected ArrayList stmts; - protected ArrayList compoundStmts; + protected ArrayList childs; - public RootNode(ArrayList stmts, ArrayList compoundStmts) { - this.stmts = stmts; - this.compoundStmts = compoundStmts; + public RootNode(ArrayList childs) { + this.childs = childs; } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + // Create a new HashMap for the current scope HashMap HM = new HashMap(); + // Add the HashMap to the SymbolTable ST.add(HM); - for (Node stmt : stmts) { - errors.addAll(stmt.checkSemantics(ST, _nesting)); - } - - for (Node stmt : compoundStmts) { - errors.addAll(stmt.checkSemantics(ST, _nesting)); + // Check semantics for each child + for (Node child : childs) { + errors.addAll(child.checkSemantics(ST, _nesting)); } + // Remove the HashMap from the SymbolTable ST.remove(); return errors; @@ -58,11 +56,8 @@ public class RootNode implements Node { prefix += " "; - for (Node stmt : stmts) { - str += stmt.toPrint(prefix); - } - for (Node stmt : compoundStmts) { - str += stmt.toPrint(prefix); + for (Node child : childs) { + str += child.toPrint(prefix); } return str; -- cgit v1.2.3-18-g5258 From 9e6c17cb44bc165e315ec039a0e09183716d2037 Mon Sep 17 00:00:00 2001 From: L0P0P Date: Wed, 26 Jun 2024 11:44:58 +0200 Subject: Semantic check for function declaration and function invocation --- progs/test.py | 4 +++- src/ast/nodes/ArglistNode.java | 14 ++++++++++++-- src/ast/nodes/AtomNode.java | 9 ++++++--- src/ast/nodes/ExprNode.java | 31 ++++++++++++------------------- src/ast/nodes/FuncdefNode.java | 5 ++++- src/ast/nodes/ParamlistNode.java | 2 +- src/semanticanalysis/STentry.java | 6 ++++++ src/semanticanalysis/SymbolTable.java | 15 +++++++++++++++ 8 files changed, 59 insertions(+), 27 deletions(-) diff --git a/progs/test.py b/progs/test.py index 72729e1..97e316f 100644 --- a/progs/test.py +++ b/progs/test.py @@ -1,4 +1,6 @@ def unibo(a): - print("u") + if a == 3: + print("UNIBO") +a = 3 unibo(a) diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index f0c33e1..71bcdce 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -19,9 +19,19 @@ public class ArglistNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - + for (var arg : arguments) { - errors.addAll(arg.checkSemantics(ST, _nesting)); + ExprNode argExpr = (ExprNode) arg; + String argName = argExpr.getId(); + + // TODO: check fucking IntType for params + // TODO: remove fucking comments + if (!ST.top_lookup(argName) && argExpr.typeCheck() instanceof AtomType){ + // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); + errors.add(new SemanticError("'" + argName + "' is not defined.")); + } else { + errors.addAll(arg.checkSemantics(ST, _nesting)); + } } return errors; diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 0a3c765..0704bc4 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -25,10 +25,13 @@ public class AtomNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { var errors = new ArrayList(); - // System.out.println("[ATOM] id: " + getId() + " ns: " + _nesting + " top_lookup" + ST.top_lookup(this.getId())); - if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { + + // Print the symbol table + System.out.println(ST); + + if ((this.typeCheck() instanceof AtomType) && !ST.top_lookup(this.getId())/*ST.nslookup(this.getId()) < 0*/) { // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); - errors.add(new SemanticError("Undefined name `" + this.getId() + "`")); + errors.add(new SemanticError("'" + this.getId() + "' is not defined.")); } return errors; diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 344f3c0..4bb67f7 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -106,30 +106,23 @@ public class ExprNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - if (atom != null && !trailers.isEmpty()) { - // function call - if (!Arrays.asList(bif).contains(atom.getId())) { - errors.addAll(atom.checkSemantics(ST, _nesting)); - } - } else { - // butto tutto quello che c'era prima nell'else così non rischio di perdere niente di utile - if (atom != null) { - errors.addAll(atom.checkSemantics(ST, _nesting)); - } - - if (compOp != null) { - errors.addAll(compOp.checkSemantics(ST, _nesting)); - } - - for (var expr : exprs) { - errors.addAll(expr.checkSemantics(ST, _nesting)); - } - + + if (atom != null && !Arrays.asList(bif).contains(atom.getId())) { + errors.addAll(atom.checkSemantics(ST, _nesting)); + for (var trailer : trailers) { errors.addAll(trailer.checkSemantics(ST, _nesting)); } } + + if (compOp != null) { + errors.addAll(compOp.checkSemantics(ST, _nesting)); + } + for (var expr : exprs) { + errors.addAll(expr.checkSemantics(ST, _nesting)); + } + return errors; } diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index 742f670..f3be1d9 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -37,10 +37,13 @@ public class FuncdefNode implements Node { errors.addAll(paramlist.checkSemantics(ST, _nesting + 1)); } + // TODO: think to the fucking offset // Offset is increased for the possible return value ST.increaseoffset(); - errors.addAll(block.checkSemantics(ST, _nesting)); + errors.addAll(block.checkSemantics(ST, _nesting + 1)); + + ST.remove(); return errors; } diff --git a/src/ast/nodes/ParamlistNode.java b/src/ast/nodes/ParamlistNode.java index a097c19..144eb13 100644 --- a/src/ast/nodes/ParamlistNode.java +++ b/src/ast/nodes/ParamlistNode.java @@ -21,7 +21,7 @@ public class ParamlistNode implements Node { ArrayList errors = new ArrayList(); for (var param : params) { - errors.addAll(param.checkSemantics(ST, _nesting + 1)); + errors.addAll(param.checkSemantics(ST, _nesting)); } return errors; diff --git a/src/semanticanalysis/STentry.java b/src/semanticanalysis/STentry.java index 0e4b00e..07b62c8 100644 --- a/src/semanticanalysis/STentry.java +++ b/src/semanticanalysis/STentry.java @@ -52,4 +52,10 @@ public class STentry { return label; } + @Override + public String toString() { + // Print all the fields of the STentry + return "Type: " + type + ", Offset: " + offset + ", Nesting: " + nesting + ", Label: " + label; + } + } diff --git a/src/semanticanalysis/SymbolTable.java b/src/semanticanalysis/SymbolTable.java index 617b48a..6756ec4 100644 --- a/src/semanticanalysis/SymbolTable.java +++ b/src/semanticanalysis/SymbolTable.java @@ -153,4 +153,19 @@ public class SymbolTable { this.offset.add(offs); } + @Override + public String toString() { + // Print the symbol table + String str = ""; + for (int i = 0; i < this.symbolTable.size(); i++) { + str += "Level " + i + "\n"; + HashMap H = this.symbolTable.get(i); + for (String key : H.keySet()) { + STentry T = H.get(key); + str += key + " -> " + T.toString() + "\n"; + } + } + return str; + } + } -- cgit v1.2.3-18-g5258 From e09358f3648445bbf9747f40497af6221d933a99 Mon Sep 17 00:00:00 2001 From: L0P0P Date: Wed, 26 Jun 2024 11:54:57 +0200 Subject: Introduction to recursive function --- progs/test.py | 6 +----- src/ast/nodes/BlockNode.java | 15 +++++++++++++++ src/ast/nodes/FuncdefNode.java | 2 ++ 3 files changed, 18 insertions(+), 5 deletions(-) diff --git a/progs/test.py b/progs/test.py index 97e316f..f9140c6 100644 --- a/progs/test.py +++ b/progs/test.py @@ -1,6 +1,2 @@ def unibo(a): - if a == 3: - print("UNIBO") - -a = 3 -unibo(a) + unibo(a) diff --git a/src/ast/nodes/BlockNode.java b/src/ast/nodes/BlockNode.java index 2c85025..a38b4ea 100644 --- a/src/ast/nodes/BlockNode.java +++ b/src/ast/nodes/BlockNode.java @@ -3,6 +3,8 @@ package ast.nodes; import java.util.ArrayList; import ast.types.*; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; /** * Node for `block` statement of the grammar. @@ -13,6 +15,19 @@ public class BlockNode extends RootNode { super(childs); } + @Override + public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + ArrayList errors = new ArrayList(); + + // Check semantics for each child + for (Node child : childs) { + errors.addAll(child.checkSemantics(ST, _nesting)); + } + + return errors; + } + + @Override public Type typeCheck() { return new VoidType(); diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index f3be1d9..4c8f92f 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -33,6 +33,8 @@ public class FuncdefNode implements Node { ST.add(HM); + ST.insert(this.name.toString(), this.block.typeCheck(), _nesting + 1, ""); + if (paramlist != null) { errors.addAll(paramlist.checkSemantics(ST, _nesting + 1)); } -- cgit v1.2.3-18-g5258 From 06671f5aed68753435a762bc3be43e83094156d1 Mon Sep 17 00:00:00 2001 From: geno Date: Wed, 26 Jun 2024 14:53:05 +0200 Subject: exercise 1 completed 1.b now works 1.c implened error for "function takes N positional arguments but M were given" --- progs/test2.py | 9 +++++--- src/Main.java | 2 +- src/ast/nodes/ArglistNode.java | 12 ++++++---- src/ast/nodes/AssignmentNode.java | 4 ++-- src/ast/nodes/AtomNode.java | 6 ++--- src/ast/nodes/CompNode.java | 2 ++ src/ast/nodes/CompoundNode.java | 4 ++-- src/ast/nodes/ExprNode.java | 45 +++++++++++++++++++++++++++----------- src/ast/nodes/FuncdefNode.java | 10 ++++++--- src/ast/nodes/IfNode.java | 3 +-- src/ast/nodes/ParamdefNode.java | 18 ++++++++++----- src/ast/nodes/ParamlistNode.java | 5 +++++ src/ast/nodes/SimpleStmtNode.java | 3 +-- src/ast/nodes/SimpleStmtsNode.java | 3 +-- src/ast/nodes/TrailerNode.java | 5 +++++ src/ast/types/FunctionType.java | 27 +++++++++++++++++++++++ 16 files changed, 116 insertions(+), 42 deletions(-) create mode 100644 src/ast/types/FunctionType.java diff --git a/progs/test2.py b/progs/test2.py index c62d44a..9c1318d 100644 --- a/progs/test2.py +++ b/progs/test2.py @@ -1,3 +1,6 @@ -x = 1 -if y == 1: - print("a") +x = 2 ; y = 3 + +def f(x, y): + return x+y + +print(f(5,3,1)+ x + y) diff --git a/src/Main.java b/src/Main.java index bfc21e3..121d3d1 100644 --- a/src/Main.java +++ b/src/Main.java @@ -20,7 +20,7 @@ public class Main { try { // String fileStr = file.getPath(); // FIXME: use the fileStr above - String fileStr = "./progs/test.py"; + String fileStr = "./progs/test2.py"; System.out.println(fileStr); System.out.println(readFile(fileStr)); CharStream cs = CharStreams.fromFileName(fileStr); diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index 71bcdce..cd1a403 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -1,15 +1,15 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `arglist` statement of the grammar. */ public class ArglistNode implements Node { + protected ArrayList arguments; public ArglistNode(ArrayList arguments) { @@ -19,14 +19,14 @@ public class ArglistNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - + for (var arg : arguments) { ExprNode argExpr = (ExprNode) arg; String argName = argExpr.getId(); // TODO: check fucking IntType for params // TODO: remove fucking comments - if (!ST.top_lookup(argName) && argExpr.typeCheck() instanceof AtomType){ + if (argName != null && !ST.top_lookup(argName) && argExpr.typeCheck() instanceof AtomType) { // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); errors.add(new SemanticError("'" + argName + "' is not defined.")); } else { @@ -37,6 +37,10 @@ public class ArglistNode implements Node { return errors; } + public int getArgumentNumber() { + return arguments.size(); + } + @Override public Type typeCheck() { return new VoidType(); diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index b0310b5..3d597ef 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -1,15 +1,15 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `assignment` statement of the grammar. */ public class AssignmentNode implements Node { + private ExprNode lhr; private Node assign; private ExprNode rhr; diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 0704bc4..96132d8 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -25,11 +25,11 @@ public class AtomNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { var errors = new ArrayList(); - + // Print the symbol table - System.out.println(ST); + // System.out.println(ST); - if ((this.typeCheck() instanceof AtomType) && !ST.top_lookup(this.getId())/*ST.nslookup(this.getId()) < 0*/) { + if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); errors.add(new SemanticError("'" + this.getId() + "' is not defined.")); } diff --git a/src/ast/nodes/CompNode.java b/src/ast/nodes/CompNode.java index 33976bf..f167bf9 100644 --- a/src/ast/nodes/CompNode.java +++ b/src/ast/nodes/CompNode.java @@ -11,6 +11,7 @@ import org.antlr.v4.runtime.tree.TerminalNode; * Node for the `comp_op` statement of the grammar. */ public class CompNode implements Node { + private TerminalNode op; public CompNode(TerminalNode op) { @@ -19,6 +20,7 @@ public class CompNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + System.out.println("Comp node"); return new ArrayList(); } diff --git a/src/ast/nodes/CompoundNode.java b/src/ast/nodes/CompoundNode.java index e64be9e..d21c2c7 100644 --- a/src/ast/nodes/CompoundNode.java +++ b/src/ast/nodes/CompoundNode.java @@ -1,15 +1,15 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `compound_node` statement of the grammar. */ public class CompoundNode implements Node { + private Node ifNode; private Node funcDef; private Node forStmt; diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 4bb67f7..eea69f8 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -3,6 +3,7 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; import java.util.Arrays; +import semanticanalysis.STentry; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -100,29 +101,47 @@ public class ExprNode implements Node { } public String getId() { - return ((AtomNode) this.atom).getId(); + if (atom != null) { + return ((AtomNode) this.atom).getId(); + } else { + return null; + } } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - - if (atom != null && !Arrays.asList(bif).contains(atom.getId())) { - errors.addAll(atom.checkSemantics(ST, _nesting)); - - for (var trailer : trailers) { - errors.addAll(trailer.checkSemantics(ST, _nesting)); - } + + if (atom != null && !trailers.isEmpty()) { + // function call + if (!Arrays.asList(bif).contains(atom.getId())) { + errors.addAll(atom.checkSemantics(ST, _nesting)); + Node trailer = trailers.get(0); + String funName = atom.getId(); + STentry s = ST.lookup(funName); + if (s != null) { + FunctionType ft = (FunctionType) s.getType(); + int paramNumber = ft.getParamNumber(); + int argNumber = ((TrailerNode) trailer).getArgumentNumber(); + if (paramNumber != argNumber) { + errors.add(new SemanticError(funName + "() takes " + String.valueOf(paramNumber) + " positional arguments but " + String.valueOf(argNumber) + " were given")); + } + } + } else { + for (var trailer : trailers) { + errors.addAll(trailer.checkSemantics(ST, _nesting)); + } + } } - + if (compOp != null) { errors.addAll(compOp.checkSemantics(ST, _nesting)); } for (var expr : exprs) { errors.addAll(expr.checkSemantics(ST, _nesting)); - } - + } + return errors; } @@ -157,11 +176,11 @@ public class ExprNode implements Node { for (var expr : exprs) { str += expr.toPrint(prefix); - } + } for (var trailer : trailers) { str += trailer.toPrint(prefix); - } + } if (op != null) { str += prefix + "Op(" + op + ")\n"; diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index 4c8f92f..8985e08 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -13,6 +13,7 @@ import org.antlr.v4.runtime.tree.TerminalNode; * Node for the `funcdef` statement of the grammar. */ public class FuncdefNode implements Node { + private TerminalNode name; private Node paramlist; private Node block; @@ -26,14 +27,17 @@ public class FuncdefNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - - ST.insert(this.name.toString(), this.block.typeCheck(), _nesting, ""); + int paramNumber = ((ParamlistNode) paramlist).getParamNumber(); + Type returnType = this.block.typeCheck(); + FunctionType ft = new FunctionType(paramNumber, returnType); + + ST.insert(this.name.toString(), ft, _nesting, ""); HashMap HM = new HashMap(); ST.add(HM); - ST.insert(this.name.toString(), this.block.typeCheck(), _nesting + 1, ""); + ST.insert(this.name.toString(), ft, _nesting + 1, ""); if (paramlist != null) { errors.addAll(paramlist.checkSemantics(ST, _nesting + 1)); diff --git a/src/ast/nodes/IfNode.java b/src/ast/nodes/IfNode.java index 50dde4a..772041b 100644 --- a/src/ast/nodes/IfNode.java +++ b/src/ast/nodes/IfNode.java @@ -1,10 +1,9 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `if` statement of the grammar. diff --git a/src/ast/nodes/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java index 265b6b6..5164537 100644 --- a/src/ast/nodes/ParamdefNode.java +++ b/src/ast/nodes/ParamdefNode.java @@ -1,24 +1,32 @@ package ast.nodes; -import java.util.ArrayList; - import ast.types.*; -import semanticanalysis.*; +import java.util.ArrayList; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; /** * Node for the `paramdef` statement of the grammar. Extends the `AtomNode` * class. */ public class ParamdefNode extends AtomNode { + public ParamdefNode(String val) { super(val); } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ST.insert(this.getId(), this.typeCheck(), _nesting, ""); + var errors = new ArrayList(); + String paramName = this.getId(); + + if (!ST.top_lookup(paramName)) { + ST.insert(paramName, this.typeCheck(), _nesting, ""); + } else { + errors.add(new SemanticError("Duplicate argument '" + paramName + "' in function definition.")); + } - return new ArrayList(); + return errors; } // FIXME: it should returns the param' type diff --git a/src/ast/nodes/ParamlistNode.java b/src/ast/nodes/ParamlistNode.java index 144eb13..0a9696f 100644 --- a/src/ast/nodes/ParamlistNode.java +++ b/src/ast/nodes/ParamlistNode.java @@ -10,6 +10,7 @@ import ast.types.*; * Node for the `param_list` statement of the grammar. */ public class ParamlistNode implements Node { + private ArrayList params; public ParamlistNode(ArrayList _params) { @@ -27,6 +28,10 @@ public class ParamlistNode implements Node { return errors; } + public int getParamNumber() { + return params.size(); + } + @Override public Type typeCheck() { return new VoidType(); diff --git a/src/ast/nodes/SimpleStmtNode.java b/src/ast/nodes/SimpleStmtNode.java index 5f844cb..b7e5455 100644 --- a/src/ast/nodes/SimpleStmtNode.java +++ b/src/ast/nodes/SimpleStmtNode.java @@ -1,10 +1,9 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `simple_stmt` statement of the grammar. diff --git a/src/ast/nodes/SimpleStmtsNode.java b/src/ast/nodes/SimpleStmtsNode.java index 66c8e2c..97bffff 100644 --- a/src/ast/nodes/SimpleStmtsNode.java +++ b/src/ast/nodes/SimpleStmtsNode.java @@ -1,10 +1,9 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `simple_stmts` statement of the grammar. diff --git a/src/ast/nodes/TrailerNode.java b/src/ast/nodes/TrailerNode.java index b0a0ee7..850b8e8 100644 --- a/src/ast/nodes/TrailerNode.java +++ b/src/ast/nodes/TrailerNode.java @@ -11,6 +11,7 @@ import org.antlr.v4.runtime.tree.TerminalNode; * Node for the `trailer` statement of the grammar. */ public class TrailerNode implements Node { + private Node arglist; private ArrayList exprs; private TerminalNode methodCall; @@ -39,6 +40,10 @@ public class TrailerNode implements Node { return errors; } + public int getArgumentNumber() { + return ((ArglistNode) arglist).getArgumentNumber(); + } + @Override public Type typeCheck() { return new VoidType(); diff --git a/src/ast/types/FunctionType.java b/src/ast/types/FunctionType.java new file mode 100644 index 0000000..464bb9c --- /dev/null +++ b/src/ast/types/FunctionType.java @@ -0,0 +1,27 @@ +package ast.types; + +/** + * An tom type. TODO: do I need to use this one? + */ +public class FunctionType extends Type { + + private final int paramNumber; + private final Type returnType; + + public FunctionType(int paramNumber, Type returnType) { + this.paramNumber = paramNumber; + this.returnType = returnType; + } + + public int getParamNumber() { + return paramNumber; + } + + public Type getReturnType() { + return returnType; + } + + public String toPrint(String prefix) { + return prefix + "Atom\n"; + } +} -- cgit v1.2.3-18-g5258 From fb89b8c0885ee4e289cfb577bbabf0ee66b05024 Mon Sep 17 00:00:00 2001 From: geno Date: Wed, 26 Jun 2024 18:23:05 +0200 Subject: test dir added, fix bug in ExprNode (added by myself obv) --- progs/test.py | 2 -- progs/test2.py | 6 ------ src/Main.java | 2 +- src/ast/nodes/ExprNode.java | 2 ++ test/1a.py | 8 ++++++++ test/1b.py | 6 ++++++ test/1c.py | 5 +++++ 7 files changed, 22 insertions(+), 9 deletions(-) delete mode 100644 progs/test.py delete mode 100644 progs/test2.py create mode 100644 test/1a.py create mode 100644 test/1b.py create mode 100644 test/1c.py diff --git a/progs/test.py b/progs/test.py deleted file mode 100644 index f9140c6..0000000 --- a/progs/test.py +++ /dev/null @@ -1,2 +0,0 @@ -def unibo(a): - unibo(a) diff --git a/progs/test2.py b/progs/test2.py deleted file mode 100644 index 9c1318d..0000000 --- a/progs/test2.py +++ /dev/null @@ -1,6 +0,0 @@ -x = 2 ; y = 3 - -def f(x, y): - return x+y - -print(f(5,3,1)+ x + y) diff --git a/src/Main.java b/src/Main.java index 121d3d1..21645db 100644 --- a/src/Main.java +++ b/src/Main.java @@ -20,7 +20,7 @@ public class Main { try { // String fileStr = file.getPath(); // FIXME: use the fileStr above - String fileStr = "./progs/test2.py"; + String fileStr = "./test/1a.py"; System.out.println(fileStr); System.out.println(readFile(fileStr)); CharStream cs = CharStreams.fromFileName(fileStr); diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index eea69f8..4fbe166 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -132,6 +132,8 @@ public class ExprNode implements Node { errors.addAll(trailer.checkSemantics(ST, _nesting)); } } + } else if (atom != null) { + errors.addAll(atom.checkSemantics(ST, _nesting)); } if (compOp != null) { diff --git a/test/1a.py b/test/1a.py new file mode 100644 index 0000000..69b3dc5 --- /dev/null +++ b/test/1a.py @@ -0,0 +1,8 @@ + +x = 2 +y = z + +def f(x, y): + return x + y + +print(f(5, 3) + x + y) diff --git a/test/1b.py b/test/1b.py new file mode 100644 index 0000000..a8324a0 --- /dev/null +++ b/test/1b.py @@ -0,0 +1,6 @@ +x = 2 ; y = 3 + +def f(x, x): + return x+y + +print(f(5,3)+ x + y) diff --git a/test/1c.py b/test/1c.py new file mode 100644 index 0000000..59e51e5 --- /dev/null +++ b/test/1c.py @@ -0,0 +1,5 @@ + +def mult(a, b): + return a * b + +print(mult(3, 2, 4)) -- cgit v1.2.3-18-g5258 From 3c4229fc9e0ec6da9a7f60b57b9e93c49d1b6b6c Mon Sep 17 00:00:00 2001 From: L0P0P Date: Thu, 27 Jun 2024 12:02:35 +0200 Subject: Fixed a lot of problems from all the progs we need to parse --- progs/a284.py | 24 +++---- progs/a339.py | 51 ++++++++------- progs/a394.py | 46 +++++++------- progs/a403.py | 2 +- progs/a52.py | 14 +++-- progs/a641.py | 12 ++-- progs/a745.py | 32 +++++----- src/Main.java | 4 +- src/ParseAll.java | 75 ++++++---------------- src/ast/Python3VisitorImpl.java | 30 ++++++++- src/ast/nodes/ArglistNode.java | 17 ++++- src/ast/nodes/AtomNode.java | 27 +++++--- src/ast/nodes/CompNode.java | 1 - src/ast/nodes/DottedNameNode.java | 6 +- src/ast/nodes/ExprNode.java | 114 +++++++++------------------------- src/ast/nodes/ForStmtNode.java | 4 ++ src/ast/nodes/IfNode.java | 4 +- src/ast/nodes/ImportNode.java | 14 ++++- src/ast/nodes/Node.java | 75 ++++++++++++++++++++++ src/ast/nodes/TrailerNode.java | 12 +++- src/ast/types/ContinueBreakType.java | 10 +++ src/ast/types/ImportType.java | 11 ++++ src/semanticanalysis/SymbolTable.java | 1 - 23 files changed, 336 insertions(+), 250 deletions(-) create mode 100644 src/ast/types/ContinueBreakType.java create mode 100644 src/ast/types/ImportType.java diff --git a/progs/a284.py b/progs/a284.py index b69395b..cfd429d 100644 --- a/progs/a284.py +++ b/progs/a284.py @@ -1,11 +1,13 @@ -def is_Isomorphic(str1,str2): - dict_str1 = {} - dict_str2 = {} - for i, value in enumerate(str1): - dict_str1[value] = dict_str1.get(value,[]) + [i] - for j, value in enumerate(str2): - dict_str2[value] = dict_str2.get(value,[]) + [j] - if sorted(dict_str1.values()) == sorted(dict_str2.values()): - return True - else: - return False \ No newline at end of file +# FIXME: multiple variable assignment in for loop +# +# def is_Isomorphic(str1,str2): +# dict_str1 = {} +# dict_str2 = {} +# for i, value in enumerate(str1): +# dict_str1[value] = dict_str1.get(value,[]) + [i] +# for j, value in enumerate(str2): +# dict_str2[value] = dict_str2.get(value,[]) + [j] +# if sorted(dict_str1.values()) == sorted(dict_str2.values()): +# return True +# else: +# return False \ No newline at end of file diff --git a/progs/a339.py b/progs/a339.py index 9a57403..95724d2 100644 --- a/progs/a339.py +++ b/progs/a339.py @@ -1,25 +1,28 @@ -def heap_sort(arr): - heapify(arr) - end = len(arr) - 1 - while end > 0: - arr[end], arr[0] = arr[0], arr[end] - shift_down(arr, 0, end - 1) - end -= 1 - return arr +# FIXME: chiamata a funzione definita dopo +# +# def heap_sort(arr): +# heapify(arr) +# end = len(arr) - 1 +# while end > 0: +# arr[end], arr[0] = arr[0], arr[end] +# shift_down(arr, 0, end - 1) +# end -= 1 +# return arr -def heapify(arr): - start = len(arr) // 2 - while start >= 0: - shift_down(arr, start, len(arr) - 1) - start -= 1 -def shift_down(arr, start, end): - root = start - while root * 2 + 1 <= end: - child = root * 2 + 1 - if child + 1 <= end and arr[child] < arr[child + 1]: - child += 1 - if child <= end and arr[root] < arr[child]: - arr[root], arr[child] = arr[child], arr[root] - root = child - else: - return +# def heapify(arr): +# start = len(arr) // 2 +# while start >= 0: +# shift_down(arr, start, len(arr) - 1) +# start -= 1 + +# def shift_down(arr, start, end): +# root = start +# while root * 2 + 1 <= end: +# child = root * 2 + 1 +# if child + 1 <= end and arr[child] < arr[child + 1]: +# child += 1 +# if child <= end and arr[root] < arr[child]: +# arr[root], arr[child] = arr[child], arr[root] +# root = child +# else: +# return diff --git a/progs/a394.py b/progs/a394.py index 4fe6e47..25f8f3e 100644 --- a/progs/a394.py +++ b/progs/a394.py @@ -1,22 +1,24 @@ -def func(nums, k): - import collections - d = collections.defaultdict(int) - for row in nums: - for i in row: - d[i] += 1 - temp = [] - import heapq - for key, v in d.items(): - if len(temp) < k: - temp.append((v, key)) - if len(temp) == k: - heapq.heapify(temp) - else: - if v > temp[0][0]: - heapq.heappop(temp) - heapq.heappush(temp, (v, key)) - result = [] - while temp: - v, key = heapq.heappop(temp) - result.append(key) - return result \ No newline at end of file +# FIXME: multiple variable assignment in for loop +# +# def func(nums, k): +# import collections +# d = collections.defaultdict(int) +# for row in nums: +# for i in row: +# d[i] += 1 +# temp = [] +# import heapq +# for key, v in d.items(): +# if len(temp) < k: +# temp.append((v, key)) +# if len(temp) == k: +# heapq.heapify(temp) +# else: +# if v > temp[0][0]: +# heapq.heappop(temp) +# heapq.heappush(temp, (v, key)) +# result = [] +# while temp: +# v, key = heapq.heappop(temp) +# result.append(key) +# return result \ No newline at end of file diff --git a/progs/a403.py b/progs/a403.py index 18c84b2..ee1bdd7 100644 --- a/progs/a403.py +++ b/progs/a403.py @@ -2,4 +2,4 @@ from collections import Counter from itertools import chain def freq_element(nums): result = Counter(chain.from_iterable(nums)) - return result \ No newline at end of file + return result diff --git a/progs/a52.py b/progs/a52.py index 4a0b33a..1d116bc 100644 --- a/progs/a52.py +++ b/progs/a52.py @@ -1,6 +1,8 @@ -from collections import defaultdict -def grouping_dictionary(l): - d = defaultdict(list) - for k, v in l: - d[k].append(v) - return d \ No newline at end of file +# FIXME: multiple variable assignment in for loop +# +# from collections import defaultdict +# def grouping_dictionary(l): +# d = defaultdict(list) +# for k, v in l: +# d[k].append(v) +# return d \ No newline at end of file diff --git a/progs/a641.py b/progs/a641.py index 51393cd..52b0f6a 100644 --- a/progs/a641.py +++ b/progs/a641.py @@ -1,5 +1,7 @@ -def count_first_elements(test_tup): - for count, ele in enumerate(test_tup): - if isinstance(ele, tuple): - break - return (count) \ No newline at end of file +# FIXME: multiple variable assignment in for loop +# +# def count_first_elements(test_tup): +# for count, ele in enumerate(test_tup): +# if isinstance(ele, tuple): +# break +# return (count) \ No newline at end of file diff --git a/progs/a745.py b/progs/a745.py index 9a21dfa..e8ad671 100644 --- a/progs/a745.py +++ b/progs/a745.py @@ -1,15 +1,17 @@ -def find_rotation_count(A): - (left, right) = (0, len(A) - 1) - while left <= right: - if A[left] <= A[right]: - return left - mid = (left + right) // 2 - next = (mid + 1) % len(A) - prev = (mid - 1 + len(A)) % len(A) - if A[mid] <= A[next] and A[mid] <= A[prev]: - return mid - elif A[mid] <= A[right]: - right = mid - 1 - elif A[mid] >= A[left]: - left = mid + 1 - return -1 \ No newline at end of file +# FIXME: unpacking assignment +# +# def find_rotation_count(A): +# (left, right) = (0, len(A) - 1) +# while left <= right: +# if A[left] <= A[right]: +# return left +# mid = (left + right) // 2 +# next = (mid + 1) % len(A) +# prev = (mid - 1 + len(A)) % len(A) +# if A[mid] <= A[next] and A[mid] <= A[prev]: +# return mid +# elif A[mid] <= A[right]: +# right = mid - 1 +# elif A[mid] >= A[left]: +# left = mid + 1 +# return -1 \ No newline at end of file diff --git a/src/Main.java b/src/Main.java index 21645db..c3c1cdd 100644 --- a/src/Main.java +++ b/src/Main.java @@ -20,7 +20,7 @@ public class Main { try { // String fileStr = file.getPath(); // FIXME: use the fileStr above - String fileStr = "./test/1a.py"; + String fileStr = "./progs/a600.py"; System.out.println(fileStr); System.out.println(readFile(fileStr)); CharStream cs = CharStreams.fromFileName(fileStr); @@ -41,7 +41,7 @@ public class Main { JPanel panel = new JPanel(); TreeViewer viewer = new TreeViewer(Arrays.asList(parser.getRuleNames()), tree); - viewer.setScale(1.5); // Zoom factor + viewer.setScale(1); // Zoom factor panel.add(viewer); frame.add(panel); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); diff --git a/src/ParseAll.java b/src/ParseAll.java index 3e5d868..87b4ca3 100644 --- a/src/ParseAll.java +++ b/src/ParseAll.java @@ -1,14 +1,14 @@ -import java.io.BufferedReader; import java.io.File; -import java.io.FileReader; -import java.io.IOException; -import java.util.Arrays; +import java.util.ArrayList; import java.util.Objects; -import javax.swing.*; -import org.antlr.v4.gui.TreeViewer; import org.antlr.v4.runtime.*; -import parser.*; +import ast.Python3VisitorImpl; +import ast.nodes.*; +import parser.Python3Lexer; +import parser.Python3Parser; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; public class ParseAll { @SuppressWarnings("unused") @@ -22,12 +22,8 @@ public class ParseAll { if (!file.isFile() || !getExtension(file.getName()).equals("py")) { System.err.println("Wont parse: " + fileStr); continue; - } else { - System.out.println(fileStr); } - // System.out.println(readFile(fileStr)); - CharStream cs = CharStreams.fromFileName(fileStr); Python3Lexer lexer = new Python3Lexer(cs); CommonTokenStream tokenStream = new CommonTokenStream(lexer); @@ -37,11 +33,17 @@ public class ParseAll { String treeStr = tree.toStringTree(); // System.out.println(treeStr); - TreeViewer viewer = new TreeViewer(Arrays.asList(parser.getRuleNames()), tree); - viewer.setScale(1.5); - saveTree(viewer, "./trees/" + removeExtension(file.getName()) + ".png"); - if (parser.getNumberOfSyntaxErrors() != 0) { - System.err.println("Parse errors: " + fileStr); + Python3VisitorImpl visitor = new Python3VisitorImpl(); + SymbolTable ST = new SymbolTable(); + Node ast = visitor.visit(tree); + ArrayList errors = ast.checkSemantics(ST, 0); + if (errors.size() > 0) { + System.out.println(); + System.out.println(fileStr); + System.out.println("You had " + errors.size() + " errors:"); + for (SemanticError e : errors) { + System.out.println("\t" + e); + } } } catch (Exception e) { @@ -51,47 +53,6 @@ public class ParseAll { } } - @SuppressWarnings("unused") - private static String readFile(String filePath) throws IOException { - StringBuilder content = new StringBuilder(); - try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) { - String line; - while ((line = reader.readLine()) != null) { - content.append(line).append("\n"); - } - } - return content.toString(); - } - - @SuppressWarnings("unused") - private static void showTree(TreeViewer viewer) { - JFrame frame = new JFrame("Parse Tree"); - JPanel panel = new JPanel(); - panel.add(viewer); - frame.add(panel); - frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - frame.setSize(800, 600); - frame.setVisible(true); - } - - private static void saveTree(TreeViewer viewer, String name) { - try { - viewer.save(name); - } catch (Exception e) { - System.err.println(name); - e.printStackTrace(); - } - } - - public static String removeExtension(String fileName) { - int extensionIndex = fileName.lastIndexOf('.'); - if (extensionIndex == -1) { - return fileName; - } else { - return fileName.substring(0, extensionIndex); - } - } - public static String getExtension(String fileName) { int extensionIndex = fileName.lastIndexOf('.'); if (extensionIndex == -1) { diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index f5b369d..d4b4fbf 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -264,10 +264,28 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { x = new AugassignNode(ctx.SUB_ASSIGN()); } else if (ctx.MULT_ASSIGN() != null) { x = new AugassignNode(ctx.MULT_ASSIGN()); + } else if (ctx.AT_ASSIGN() != null) { + x = new AugassignNode(ctx.AT_ASSIGN()); } else if (ctx.DIV_ASSIGN() != null) { x = new AugassignNode(ctx.DIV_ASSIGN()); + } else if (ctx.MOD_ASSIGN() != null) { + x = new AugassignNode(ctx.MOD_ASSIGN()); + } else if (ctx.AND_ASSIGN() != null) { + x = new AugassignNode(ctx.AND_ASSIGN()); + } else if (ctx.OR_ASSIGN() != null) { + x = new AugassignNode(ctx.OR_ASSIGN()); + } else if (ctx.XOR_ASSIGN() != null) { + x = new AugassignNode(ctx.XOR_ASSIGN()); + } else if (ctx.LEFT_SHIFT_ASSIGN() != null) { + x = new AugassignNode(ctx.LEFT_SHIFT_ASSIGN()); + } else if (ctx.RIGHT_SHIFT_ASSIGN() != null) { + x = new AugassignNode(ctx.RIGHT_SHIFT_ASSIGN()); + } else if (ctx.POWER_ASSIGN() != null) { + x = new AugassignNode(ctx.POWER_ASSIGN()); + } else if (ctx.IDIV_ASSIGN() != null) { + x = new AugassignNode(ctx.IDIV_ASSIGN()); } - + return x; } @@ -495,7 +513,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { methodCall = ctx.NAME(); } - return new TrailerNode(arglist, exprs, methodCall); + return new TrailerNode(arglist, exprs, methodCall, ctx.OPEN_PAREN() != null); } /** @@ -507,7 +525,13 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * ``` */ public Node visitExprlist(ExprlistContext ctx) { - Node exp = visit(ctx.expr(0)); + Node exp; + + if (ctx.expr(0).expr(0) != null){ + exp = visit(ctx.expr(0).expr(0)); + } else { + exp = visit(ctx.expr(0)); + } return exp; } diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index cd1a403..78b4ca7 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -2,6 +2,8 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; +import java.util.Arrays; + import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -26,9 +28,18 @@ public class ArglistNode implements Node { // TODO: check fucking IntType for params // TODO: remove fucking comments - if (argName != null && !ST.top_lookup(argName) && argExpr.typeCheck() instanceof AtomType) { - // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); - errors.add(new SemanticError("'" + argName + "' is not defined.")); + if (argName != null) { + if (Arrays.asList(bif).contains(argName)) { + continue; + } + + if (ST.lookup(argName) != null && ST.lookup(argName).getType() instanceof ImportType) { + continue; + } + + if (!ST.top_lookup(argName) && argExpr.typeCheck() instanceof AtomType) { + errors.add(new SemanticError("'" + argName + "' is not defined.")); + } } else { errors.addAll(arg.checkSemantics(ST, _nesting)); } diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 96132d8..ceafc07 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -26,11 +26,7 @@ public class AtomNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { var errors = new ArrayList(); - // Print the symbol table - // System.out.println(ST); - if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { - // System.out.println(!(this.typeCheck() instanceof IntType) + " " + !ST.top_lookup(this.getId())); errors.add(new SemanticError("'" + this.getId() + "' is not defined.")); } @@ -40,15 +36,26 @@ public class AtomNode implements Node { // ENHANCE: return more specific types @Override public Type typeCheck() { + Pattern booleanVariable = Pattern.compile("^(True|False)$"); + Pattern continueBreakVariable = Pattern.compile("^(continue|break)$"); // this regex should match every possible atom name written in this format: CHAR (CHAR | DIGIT)* - Pattern pattern = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]*$", Pattern.CASE_INSENSITIVE); - Matcher matcher = pattern.matcher(this.val); - boolean matchFound = matcher.find(); - if (matchFound) { - // System.out.println("Match found for " + this.val); + Pattern simpleVariable = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]*$", Pattern.CASE_INSENSITIVE); + + Matcher booleanVariableMatcher = booleanVariable.matcher(this.val); + Matcher continueBreakVariableMatcher = continueBreakVariable.matcher(this.val); + Matcher simpleVariableMatcher = simpleVariable.matcher(this.val); + + boolean matchFoundBoolean = booleanVariableMatcher.find(); + boolean matchFoundContinueBreak = continueBreakVariableMatcher.find(); + boolean matchFoundSimpleVariable = simpleVariableMatcher.find(); + + if (matchFoundBoolean) { + return new BoolType(); + } else if (matchFoundContinueBreak) { + return new ContinueBreakType(); + } else if (matchFoundSimpleVariable) { return new AtomType(); // could be a variable or a fuction } else { - // System.out.println("Match not found for " + this.val); return new VoidType(); // could be any type of data } } diff --git a/src/ast/nodes/CompNode.java b/src/ast/nodes/CompNode.java index f167bf9..8be6ea1 100644 --- a/src/ast/nodes/CompNode.java +++ b/src/ast/nodes/CompNode.java @@ -20,7 +20,6 @@ public class CompNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - System.out.println("Comp node"); return new ArrayList(); } diff --git a/src/ast/nodes/DottedNameNode.java b/src/ast/nodes/DottedNameNode.java index 46d1b61..df86c99 100644 --- a/src/ast/nodes/DottedNameNode.java +++ b/src/ast/nodes/DottedNameNode.java @@ -21,12 +21,16 @@ public class DottedNameNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + for (int i = 0; i < names.size(); ++i) { + ST.insert(names.get(i).toString(), this.typeCheck(), _nesting, null); + } + return errors; } @Override public Type typeCheck() { - return new VoidType(); + return new ImportType(); } // NOTE: we do not provide code generation for this node in the same way diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 4fbe166..1b20e2e 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -3,6 +3,7 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; import java.util.Arrays; + import semanticanalysis.STentry; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -18,80 +19,6 @@ public class ExprNode implements Node { private ArrayList exprs; private ArrayList trailers; - // built-in functions - private static final String[] bif = { - "abs", - "aiter", - "all", - "anext", - "any", - "ascii", - "bin", - "bool", - "breakpoint", - "bytearray", - "bytes", - "callable", - "chr", - "classmethod", - "compile", - "complex", - "delattr", - "dict", - "dir", - "divmod", - "enumerate", - "eval", - "exec", - "filter", - "float", - "format", - "frozenset", - "getattr", - "globals", - "hasattr", - "hash", - "help", - "hex", - "id", - "input", - "int", - "isinstance", - "issubclass", - "iter", - "len", - "list", - "locals", - "map", - "max", - "memoryview", - "min", - "next", - "object", - "oct", - "open", - "ord", - "pow", - "print", - "property", - "range", - "repr", - "reversed", - "round", - "set", - "setattr", - "slice", - "sorted", - "staticmethod", - "str", - "sum", - "super", - "tuple", - "type", - "vars", - "zip", - "__import__"}; - public ExprNode(Node atom, Node compOp, ArrayList exprs, String op, ArrayList trailers) { this.atom = (AtomNode) atom; this.compOp = compOp; @@ -112,19 +39,38 @@ public class ExprNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + // check if the atom is a built-in function if (atom != null && !trailers.isEmpty()) { - // function call + if (!Arrays.asList(bif).contains(atom.getId())) { + errors.addAll(atom.checkSemantics(ST, _nesting)); - Node trailer = trailers.get(0); + + TrailerNode trailer = (TrailerNode) trailers.get(0); String funName = atom.getId(); - STentry s = ST.lookup(funName); - if (s != null) { - FunctionType ft = (FunctionType) s.getType(); - int paramNumber = ft.getParamNumber(); - int argNumber = ((TrailerNode) trailer).getArgumentNumber(); - if (paramNumber != argNumber) { - errors.add(new SemanticError(funName + "() takes " + String.valueOf(paramNumber) + " positional arguments but " + String.valueOf(argNumber) + " were given")); + + // TODO: it isnt a function, it could be a variable + STentry fun = ST.lookup(funName); + + + + if (fun != null && !(fun.getType() instanceof ImportType)) { + if (!(fun.getType() instanceof FunctionType)) { + if (trailer.isParenthesis()) { + errors.add(new SemanticError("'" + funName + "' is not a function.")); + } else { + for (var t : trailers) { + errors.addAll(t.checkSemantics(ST, _nesting)); + } + } + } else { + FunctionType ft = (FunctionType) fun.getType(); + int paramNumber = ft.getParamNumber(); + int argNumber = trailer.getArgumentNumber(); + + if (paramNumber != argNumber) { + errors.add(new SemanticError(funName + "() takes " + String.valueOf(paramNumber) + " positional arguments but " + String.valueOf(argNumber) + " were given.")); + } } } } else { @@ -150,7 +96,7 @@ public class ExprNode implements Node { // FIXME: type for the expr @Override public Type typeCheck() { - if (this.atom != null) { + if (this.atom != null ) { return this.atom.typeCheck(); } diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java index 6d94bb2..28fe783 100644 --- a/src/ast/nodes/ForStmtNode.java +++ b/src/ast/nodes/ForStmtNode.java @@ -22,6 +22,10 @@ public class ForStmtNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + ExprNode expr = (ExprNode) exprList; + + ST.insert(expr.getId(), expr.typeCheck(), _nesting, ""); + errors.addAll(exprList.checkSemantics(ST, _nesting)); errors.addAll(block.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/IfNode.java b/src/ast/nodes/IfNode.java index 772041b..f51d486 100644 --- a/src/ast/nodes/IfNode.java +++ b/src/ast/nodes/IfNode.java @@ -41,11 +41,11 @@ public class IfNode implements Node { if (thenexp.getClass().equals(elseexp.getClass())) return thenexp; else { - System.out.println("Type Error: incompatible types in then and else branches"); + System.out.println("Type Error: incompatible types in then and else branches."); return new ErrorType(); } } else { - System.out.println("Type Error: non boolean condition in if"); + System.out.println("Type Error: non boolean condition in if."); return new ErrorType(); } } diff --git a/src/ast/nodes/ImportNode.java b/src/ast/nodes/ImportNode.java index e264c99..900a909 100644 --- a/src/ast/nodes/ImportNode.java +++ b/src/ast/nodes/ImportNode.java @@ -29,12 +29,24 @@ public class ImportNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + if (isFrom) { + for (int i = 0; i < names.size(); ++i) { + ST.insert(names.get(i), this.typeCheck(), _nesting, null); + } + } else { + errors.addAll(dottedName.checkSemantics(ST, _nesting)); + } + + if (importAs) { + ST.insert(names.get(names.size() - 1), this.typeCheck(), _nesting, null); + } + return errors; } @Override public Type typeCheck() { - return new VoidType(); + return new ImportType(); } // NOTE: we do not want to provide a code generation for this statement diff --git a/src/ast/nodes/Node.java b/src/ast/nodes/Node.java index 949531e..77ba669 100644 --- a/src/ast/nodes/Node.java +++ b/src/ast/nodes/Node.java @@ -10,6 +10,81 @@ import ast.types.*; * Base interface for a Node. */ public interface Node { + + static final String[] bif = { + "abs", + "aiter", + "all", + "anext", + "any", + "ascii", + "bin", + "bool", + "breakpoint", + "bytearray", + "bytes", + "callable", + "chr", + "classmethod", + "compile", + "complex", + "delattr", + "dict", + "dir", + "divmod", + "enumerate", + "eval", + "exec", + "exit", + "filter", + "float", + "format", + "frozenset", + "getattr", + "globals", + "hasattr", + "hash", + "help", + "hex", + "id", + "input", + "int", + "isinstance", + "issubclass", + "iter", + "len", + "list", + "locals", + "map", + "max", + "memoryview", + "min", + "next", + "object", + "oct", + "open", + "ord", + "pow", + "print", + "property", + "range", + "repr", + "reversed", + "round", + "set", + "setattr", + "slice", + "sorted", + "staticmethod", + "str", + "sum", + "super", + "tuple", + "type", + "vars", + "zip", + "__import__"}; + /** * Checks semantics for a given node for a SymbolTable ST and a level of * nesting. diff --git a/src/ast/nodes/TrailerNode.java b/src/ast/nodes/TrailerNode.java index 850b8e8..22e43a0 100644 --- a/src/ast/nodes/TrailerNode.java +++ b/src/ast/nodes/TrailerNode.java @@ -15,12 +15,14 @@ public class TrailerNode implements Node { private Node arglist; private ArrayList exprs; private TerminalNode methodCall; + private boolean isParenthesis; private boolean isEmpty; - public TrailerNode(Node arglist, ArrayList exprs, TerminalNode methodCall) { + public TrailerNode(Node arglist, ArrayList exprs, TerminalNode methodCall, boolean isParenthesis) { this.arglist = arglist; this.exprs = exprs; this.methodCall = methodCall; + this.isParenthesis = isParenthesis; this.isEmpty = (this.arglist == null && this.exprs.size() == 0 && this.methodCall == null); } @@ -41,9 +43,17 @@ public class TrailerNode implements Node { } public int getArgumentNumber() { + if (arglist == null) { + return 0; + } + return ((ArglistNode) arglist).getArgumentNumber(); } + public boolean isParenthesis() { + return this.isParenthesis; + } + @Override public Type typeCheck() { return new VoidType(); diff --git a/src/ast/types/ContinueBreakType.java b/src/ast/types/ContinueBreakType.java new file mode 100644 index 0000000..dfcf1f2 --- /dev/null +++ b/src/ast/types/ContinueBreakType.java @@ -0,0 +1,10 @@ +package ast.types; + +/** + * A type for the continue and break statements. + */ +public class ContinueBreakType extends Type { + public String toPrint(String prefix) { + return prefix + "ContinueBreak\n"; + } +} diff --git a/src/ast/types/ImportType.java b/src/ast/types/ImportType.java new file mode 100644 index 0000000..6852bfa --- /dev/null +++ b/src/ast/types/ImportType.java @@ -0,0 +1,11 @@ +package ast.types; + +/** + * A type for the imported names. + */ +public class ImportType extends Type { + public String toPrint(String prefix) { + return prefix + "Import\n"; + } +} + diff --git a/src/semanticanalysis/SymbolTable.java b/src/semanticanalysis/SymbolTable.java index 6756ec4..db9649c 100644 --- a/src/semanticanalysis/SymbolTable.java +++ b/src/semanticanalysis/SymbolTable.java @@ -137,7 +137,6 @@ public class SymbolTable { this.offset.add(offs); - // System.out.println("Insert " + id + " of type " + type.toString() + " with nesting " + String.valueOf(_nesting)); } /** -- cgit v1.2.3-18-g5258 From 673117132daa9c4fdd103189b5cd9a32a3731f5a Mon Sep 17 00:00:00 2001 From: geno Date: Thu, 27 Jun 2024 13:08:54 +0200 Subject: remove duplicates --- src/Main.java | 5 ++++- src/ParseAll.java | 6 +++++- src/ast/nodes/AtomNode.java | 2 +- src/semanticanalysis/Share.java | 37 +++++++++++++++++++++++++++++++++++++ 4 files changed, 47 insertions(+), 3 deletions(-) create mode 100644 src/semanticanalysis/Share.java diff --git a/src/Main.java b/src/Main.java index 24f4c4e..04f7183 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,3 +1,4 @@ + import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; @@ -11,6 +12,7 @@ import ast.*; import ast.nodes.*; import parser.*; import semanticanalysis.*; +import semanticanalysis.Share; public class Main { @@ -53,7 +55,8 @@ public class Main { Python3VisitorImpl visitor = new Python3VisitorImpl(); SymbolTable ST = new SymbolTable(); Node ast = visitor.visit(tree); - ArrayList errors = ast.checkSemantics(ST, 0); + ArrayList errorsWithDup = ast.checkSemantics(ST, 0); + ArrayList errors = Share.removeDuplicates(errorsWithDup); if (errors.size() > 0) { System.out.println("You had " + errors.size() + " errors:"); for (SemanticError e : errors) { diff --git a/src/ParseAll.java b/src/ParseAll.java index 87b4ca3..2662a85 100644 --- a/src/ParseAll.java +++ b/src/ParseAll.java @@ -1,3 +1,4 @@ + import java.io.File; import java.util.ArrayList; import java.util.Objects; @@ -9,8 +10,10 @@ import parser.Python3Lexer; import parser.Python3Parser; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; +import semanticanalysis.Share; public class ParseAll { + @SuppressWarnings("unused") public static void main(String[] args) { new File("./trees/").mkdirs(); @@ -36,7 +39,8 @@ public class ParseAll { Python3VisitorImpl visitor = new Python3VisitorImpl(); SymbolTable ST = new SymbolTable(); Node ast = visitor.visit(tree); - ArrayList errors = ast.checkSemantics(ST, 0); + ArrayList errorsWithDup = ast.checkSemantics(ST, 0); + ArrayList errors = Share.removeDuplicates(errorsWithDup); if (errors.size() > 0) { System.out.println(); System.out.println(fileStr); diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index ceafc07..58cd7f9 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -27,7 +27,7 @@ public class AtomNode implements Node { var errors = new ArrayList(); if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { - errors.add(new SemanticError("'" + this.getId() + "' is not defined.")); + errors.add(new SemanticError("name '" + this.getId() + "' is not defined.")); } return errors; diff --git a/src/semanticanalysis/Share.java b/src/semanticanalysis/Share.java new file mode 100644 index 0000000..c1f03c2 --- /dev/null +++ b/src/semanticanalysis/Share.java @@ -0,0 +1,37 @@ +package semanticanalysis; + +import java.util.ArrayList; + +public class Share { + + public static ArrayList removeDuplicates(ArrayList list) { + ArrayList newList = new ArrayList(); + + for (T element : list) { + if (!customContains(newList, element)) { + newList.add(element); + } + } + return newList; + } + + public static boolean customContains(ArrayList list, T e) { + String e1 = e.toString(); + for (T element : list) { + String e2 = element.toString(); + if (e2.equals(e1)) { + return true; + } + } + return false; + } + + public static String getExtension(String fileName) { + int extensionIndex = fileName.lastIndexOf('.'); + if (extensionIndex == -1) { + return fileName; + } else { + return fileName.substring(extensionIndex + 1); + } + } +} -- cgit v1.2.3-18-g5258 From 095a2cb4e9abb88805aac3271874bc512108ff96 Mon Sep 17 00:00:00 2001 From: geno Date: Thu, 27 Jun 2024 18:19:27 +0200 Subject: minor changes --- src/ast/nodes/ArglistNode.java | 5 ++--- src/ast/nodes/AtomNode.java | 6 ++++-- src/ast/nodes/ExprNode.java | 12 +++++------- 3 files changed, 11 insertions(+), 12 deletions(-) diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index 78b4ca7..983d150 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -3,7 +3,6 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; import java.util.Arrays; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -37,8 +36,8 @@ public class ArglistNode implements Node { continue; } - if (!ST.top_lookup(argName) && argExpr.typeCheck() instanceof AtomType) { - errors.add(new SemanticError("'" + argName + "' is not defined.")); + if (ST.nslookup(argName) < 0 && argExpr.typeCheck() instanceof AtomType) { + errors.add(new SemanticError("name '" + argName + "' is not defined.")); } } else { errors.addAll(arg.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 58cd7f9..3c2b1eb 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -28,6 +28,8 @@ public class AtomNode implements Node { if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { errors.add(new SemanticError("name '" + this.getId() + "' is not defined.")); + } else { + // System.out.println("exist " + this.getId()); } return errors; @@ -40,11 +42,11 @@ public class AtomNode implements Node { Pattern continueBreakVariable = Pattern.compile("^(continue|break)$"); // this regex should match every possible atom name written in this format: CHAR (CHAR | DIGIT)* Pattern simpleVariable = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]*$", Pattern.CASE_INSENSITIVE); - + Matcher booleanVariableMatcher = booleanVariable.matcher(this.val); Matcher continueBreakVariableMatcher = continueBreakVariable.matcher(this.val); Matcher simpleVariableMatcher = simpleVariable.matcher(this.val); - + boolean matchFoundBoolean = booleanVariableMatcher.find(); boolean matchFoundContinueBreak = continueBreakVariableMatcher.find(); boolean matchFoundSimpleVariable = simpleVariableMatcher.find(); diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 1b20e2e..62b3a94 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -3,7 +3,6 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; import java.util.Arrays; - import semanticanalysis.STentry; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -39,21 +38,20 @@ public class ExprNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - // check if the atom is a built-in function + // check if the atom is a function if (atom != null && !trailers.isEmpty()) { + // check if the atom is not a built-in function if (!Arrays.asList(bif).contains(atom.getId())) { - + errors.addAll(atom.checkSemantics(ST, _nesting)); - + TrailerNode trailer = (TrailerNode) trailers.get(0); String funName = atom.getId(); // TODO: it isnt a function, it could be a variable STentry fun = ST.lookup(funName); - - if (fun != null && !(fun.getType() instanceof ImportType)) { if (!(fun.getType() instanceof FunctionType)) { if (trailer.isParenthesis()) { @@ -96,7 +94,7 @@ public class ExprNode implements Node { // FIXME: type for the expr @Override public Type typeCheck() { - if (this.atom != null ) { + if (this.atom != null) { return this.atom.typeCheck(); } -- cgit v1.2.3-18-g5258 From eb7fb04d2dfadd004fa86f28da42681e0038df06 Mon Sep 17 00:00:00 2001 From: geno Date: Thu, 27 Jun 2024 18:20:34 +0200 Subject: left, right = 1, 2 assignment covered sfaccimm ho fatto refactoring dell exprlist --- src/ast/Python3VisitorImpl.java | 192 +++++++++++++++++------------------- src/ast/nodes/AssignmentNode.java | 21 +++- src/ast/nodes/AtomNode.java | 22 ++++- src/ast/nodes/ExprListNode.java | 61 ++++++++++++ src/ast/nodes/ForStmtNode.java | 12 +-- src/ast/nodes/ParamdefNode.java | 2 +- src/ast/nodes/TestlistCompNode.java | 61 ++++++++++++ test/trailers.py | 13 +++ 8 files changed, 262 insertions(+), 122 deletions(-) create mode 100644 src/ast/nodes/ExprListNode.java create mode 100644 src/ast/nodes/TestlistCompNode.java create mode 100644 test/trailers.py diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index d4b4fbf..5b812ea 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -12,20 +12,19 @@ import org.antlr.v4.runtime.tree.TerminalNode; * Overrides each `visitNODE` method from the base class. */ public class Python3VisitorImpl extends Python3ParserBaseVisitor { + /** * Since a root can be a simple_stmts or a compound_stmt, this method * returns a new `RootNode` with a list of them. * - * ``` - * root : NEWLINE* (simple_stmts | compound_stmt)* EOF; - * ``` + * ``` root : NEWLINE* (simple_stmts | compound_stmt)* EOF; ``` */ public Node visitRoot(RootContext ctx) { ArrayList childs = new ArrayList(); - - for (int i = 0; i < ctx.getChildCount(); i++){ + + for (int i = 0; i < ctx.getChildCount(); i++) { var child = ctx.getChild(i); - + if (child instanceof Simple_stmtsContext) { childs.add(visit((Simple_stmtsContext) child)); } else if (child instanceof Compound_stmtContext) { @@ -39,9 +38,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `SimpleStmtsNode`, made by an array of SimpleStmtNode * - * ``` - * simple_stmts : simple_stmt (';' simple_stmt)* ';'? NEWLINE ; - * ``` + * ``` simple_stmts : simple_stmt (';' simple_stmt)* ';'? NEWLINE ; ``` */ public Node visitSimple_stmts(Simple_stmtsContext ctx) { ArrayList stmts = new ArrayList(); @@ -57,9 +54,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns a `CompoundNode`. It can be built by a different kind of * statements, so only one of theme won't be null. * - * ``` - * compound_stmt : if_stmt | while_stmt | for_stmt | funcdef ; - * ``` + * ``` compound_stmt : if_stmt | while_stmt | for_stmt | funcdef ; ``` */ public Node visitCompound_stmt(Compound_stmtContext ctx) { Node ifStmt = null; @@ -90,9 +85,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns a `SimpleStmtNode`. It can be built by a different kind of * statements, so only one of theme won't be null. * - * ``` - * simple_stmt : assignment | expr | return_stmt | import_stm ; - * ``` + * ``` simple_stmt : assignment | expr | return_stmt | import_stm ; ``` */ public Node visitSimple_stmt(Simple_stmtContext ctx) { Node assignment = null; @@ -122,10 +115,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns an `AssignmentNode`. It's made by left side, an assignment and a * right side. - * - * ``` - * assignment : exprlist augassign exprlist ; - * ``` + * + * ``` assignment : exprlist augassign exprlist ; ``` */ public Node visitAssignment(AssignmentContext ctx) { Node lhr = visit(ctx.exprlist(0)); @@ -138,9 +129,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `ReturnStmtNode`. The returned exprlist can be null. * - * ``` - * return_stmt : 'return' exprlist? ; - * ``` + * ``` return_stmt : 'return' exprlist? ; ``` */ public Node visitReturn_stmt(Return_stmtContext ctx) { Node exprList = null; @@ -155,10 +144,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns a `ImportNode`. An import can be made in different ways so we * check the way in a module is imported (by from, by alias or by star). * - * ``` - * import_stm : 'import' dotted_name ('as' NAME)? - * | 'from' dotted_name 'import' (NAME (',' NAME)* | '*') ; - * ``` + * ``` import_stm : 'import' dotted_name ('as' NAME)? | 'from' dotted_name + * 'import' (NAME (',' NAME)* | '*') ; ``` */ public Node visitImport_stm(Import_stmContext ctx) { boolean isFrom = ctx.FROM() != null; @@ -179,9 +166,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `DottedNameNode` used in `import_stm`. * - * ``` - * dotted_name : NAME ('.' NAME)* ; - * ``` + * ``` dotted_name : NAME ('.' NAME)* ; ``` */ public Node visitDotted_name(Dotted_nameContext ctx) { ArrayList names = new ArrayList(); @@ -196,9 +181,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `FuncdefNode`. A paramlist can be null. * - * ``` - * funcdef : 'def' NAME '(' paramlist? ')' ':' block ; - * ``` + * ``` funcdef : 'def' NAME '(' paramlist? ')' ':' block ; ``` */ public Node visitFuncdef(FuncdefContext ctx) { Node paramlist = null; @@ -216,9 +199,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns a `ParamlistNode`. We ignore the paramdef with default values * (eg: is_used=False) because there is no test which uses this feature. * - * ``` - * paramlist : paramdef ('=' expr)? (',' paramdef ('=' expr)?)* ; - * + * ``` paramlist : paramdef ('=' expr)? (',' paramdef ('=' expr)?)* ; + * * ``` */ public Node visitParamlist(ParamlistContext ctx) { @@ -235,9 +217,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns a `ParamdefNode`. We ignore the paramdef with type annotation * (eg: x : int) because there is no test which uses this feature. * - * ``` - * paramdef : NAME (':' expr)? ; - * ``` + * ``` paramdef : NAME (':' expr)? ; ``` */ public Node visitParamdef(ParamdefContext ctx) { return new ParamdefNode(ctx.NAME().toString()); @@ -247,11 +227,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns an `AugassignNode`. We don't provide all kinds of assignment * below. * - * ``` - * augassign : '=' | '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | - * '^=' | '<<=' | '>>=' | '**=' | '//=' - * ; - * ``` + * ``` augassign : '=' | '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | + * '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=' ; ``` */ public Node visitAugassign(AugassignContext ctx) { Node x = null; @@ -285,17 +262,15 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { } else if (ctx.IDIV_ASSIGN() != null) { x = new AugassignNode(ctx.IDIV_ASSIGN()); } - + return x; } /** - * Returns a `IfNode`. - * FIXME: add support for elif statement. + * Returns a `IfNode`. FIXME: add support for elif statement. * - * ``` - * if_stmt : 'if' expr ':' block ('elif' expr ':' block)* ('else' ':' block)? ; - * ``` + * ``` if_stmt : 'if' expr ':' block ('elif' expr ':' block)* ('else' ':' + * block)? ; ``` */ public Node visitIf_stmt(If_stmtContext ctx) { var blocks = ctx.block(); @@ -312,9 +287,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `WhileStmtNode`. We do not provide 'else' branch. * - * ``` - * while_stmt : 'while' expr ':' block ('else' ':' block)? ; - * ``` + * ``` while_stmt : 'while' expr ':' block ('else' ':' block)? ; ``` */ public Node visitWhile_stmt(While_stmtContext ctx) { Node expr = visit(ctx.expr()); @@ -328,9 +301,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `ForSmtNode`. We do not provide 'else' branch. * - * ``` - * for_stmt : 'for' exprlist ':' block ('else' ':' block)? ; - * ``` + * ``` for_stmt : 'for' exprlist ':' block ('else' ':' block)? ; ``` */ public Node visitFor_stmt(For_stmtContext ctx) { Node exprList = visit(ctx.exprlist()); @@ -345,17 +316,15 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns a `BlockNode`. A block can be be a simple_stmts or a list of * simple_stms and/or compound_stmt, so we just use a list for each kind. * - * ``` - * block : simple_stmts - * | NEWLINE INDENT (simple_stmts | compound_stmt)+ DEDENT ; - * ``` + * ``` block : simple_stmts | NEWLINE INDENT (simple_stmts | compound_stmt)+ + * DEDENT ; ``` */ public Node visitBlock(BlockContext ctx) { ArrayList childs = new ArrayList(); - for (int i = 0; i < ctx.getChildCount(); i++){ + for (int i = 0; i < ctx.getChildCount(); i++) { var child = ctx.getChild(i); - + if (child instanceof Simple_stmtsContext) { childs.add(visit((Simple_stmtsContext) child)); } else if (child instanceof Compound_stmtContext) { @@ -369,10 +338,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { /** * Returns a `CompNode`. It should never be null. * - * ``` - * comp_op : '<' | '>' | '==' | '>=' | '<=' | '<>' | '!=' | 'in' | 'not' 'in' | - * 'is' | 'is' 'not' ; - * ``` + * ``` comp_op : '<' | '>' | '==' | '>=' | '<=' | '<>' | '!=' | 'in' | 'not' + * 'in' | 'is' | 'is' 'not' ; ``` */ public Node visitComp_op(Comp_opContext ctx) { Node comp = null; @@ -404,13 +371,11 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * Returns an `ExprNode`. An expession can be a different kind of * sub-expression. We do not provide all kinds of expr(s). * - * ``` - * expr : atom trailer* | expr '**' expr | ('+' | '-' | '~')+ expr | expr ('*' | - * '@' | '/' | '%' | '//') expr | expr ('+' | '-') expr | expr ('<<' | '>>') - * expr | expr '&' expr | expr '^' expr | expr '|' expr | 'not' expr | expr - * comp_op expr | expr 'and' expr | expr 'or' expr | expr 'if' expr 'else' expr - * ; - * ``` + * ``` expr : atom trailer* | expr '**' expr | ('+' | '-' | '~')+ expr | + * expr ('*' | '@' | '/' | '%' | '//') expr | expr ('+' | '-') expr | expr + * ('<<' | '>>') expr | expr '&' expr | expr '^' expr | expr '|' expr | + * 'not' expr | expr comp_op expr | expr 'and' expr | expr 'or' expr | expr + * 'if' expr 'else' expr ; ``` */ public Node visitExpr(ExprContext ctx) { Node atom = null; @@ -459,42 +424,52 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { } /** - * Returns an `AtomNode`. - * FIXME: add support for testlist_comp + * Returns an `AtomNode`. FIXME: add support for testlist_comp * - * ``` - * atom : '(' testlist_comp? ')' | '[' testlist_comp? ']' | '{' testlist_comp? - * '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False' ; - * ``` + * ``` atom : '(' testlist_comp? ')' | '[' testlist_comp? ']' | '{' + * testlist_comp? '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | + * 'False' ; ``` */ public Node visitAtom(AtomContext ctx) { + Testlist_compContext tlc = ctx.testlist_comp(); if (ctx.NUMBER() != null) { - return new AtomNode(ctx.NUMBER().toString()); + return new AtomNode(ctx.NUMBER().toString(), null); } else if (ctx.TRUE() != null) { - return new AtomNode(ctx.TRUE().toString()); + return new AtomNode(ctx.TRUE().toString(), null); } else if (ctx.FALSE() != null) { - return new AtomNode(ctx.FALSE().toString()); + return new AtomNode(ctx.FALSE().toString(), null); } else if (ctx.NAME() != null) { - return new AtomNode(ctx.NAME().toString()); - } else if (ctx.STRING() != null) { - + return new AtomNode(ctx.NAME().toString(), null); + } else if (!ctx.STRING().isEmpty()) { var varName = ""; for (var x : ctx.STRING()) { varName += x; } + return new AtomNode(varName, null); + } else if (ctx.OPEN_BRACE() != null && ctx.CLOSE_BRACE() != null) { + return manageTlc(tlc); + } else if (ctx.OPEN_BRACK() != null && ctx.CLOSE_BRACK() != null) { + return manageTlc(tlc); + } else if (ctx.OPEN_PAREN() != null && ctx.CLOSE_PAREN() != null) { + return manageTlc(tlc); + } + return new AtomNode(ctx.NONE().toString(), null); + } - return new AtomNode(varName); + public AtomNode manageTlc(Testlist_compContext tlc) { + if (tlc != null) { + Node testlist_comp = visit(tlc); + return new AtomNode(null, testlist_comp); + } else { + return new AtomNode(null, null); } - return new AtomNode(ctx.NONE().toString()); } /** * Returns an `TrailerNode`. * - * ``` - * trailer : '(' arglist? ')' | '[' expr (',' expr)* ','? ']' | '.' NAME | '[' - * expr? ':' expr? (':' expr? )? ']' ; - * ``` + * ``` trailer : '(' arglist? ')' | '[' expr (',' expr)* ','? ']' | '.' NAME + * | '[' expr? ':' expr? (':' expr? )? ']' ; ``` */ public Node visitTrailer(TrailerContext ctx) { Node arglist = null; @@ -517,31 +492,24 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { } /** - * Returns a `Node`. - * FIXME: what to do in case of list?? + * Returns a `Node`. FIXME: what to do in case of list?? * - * ``` - * exprlist : expr (',' expr )* ','? ; - * ``` + * ``` exprlist : expr (',' expr )* ','? ; ``` */ public Node visitExprlist(ExprlistContext ctx) { - Node exp; + ArrayList exprlist = new ArrayList(); - if (ctx.expr(0).expr(0) != null){ - exp = visit(ctx.expr(0).expr(0)); - } else { - exp = visit(ctx.expr(0)); + for (ExprContext c : ctx.expr()) { + exprlist.add(visit(c)); } - return exp; + return new ExprListNode(exprlist); } /** * Returns a `ArglistNode`. * - * ``` - * arglist : argument (',' argument)* ','? ; - * ``` + * ``` arglist : argument (',' argument)* ','? ; ``` */ public Node visitArglist(ArglistContext ctx) { ArrayList arguments = new ArrayList(); @@ -552,4 +520,20 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { return new ArglistNode(arguments); } + + /** + * Returns a `TestlistCompNode`. + * + * ``` testlist_comp : expr (comp_for | (',' expr)* ','?) ; ``` + */ + public Node visitTestlist_comp(Testlist_compContext ctx) { + // TODO: implement comp_for + ArrayList exprlist = new ArrayList(); + + for (ExprContext c : ctx.expr()) { + exprlist.add(visit(c)); + } + + return new TestlistCompNode(exprlist); + } } diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index 3d597ef..07966c3 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -10,14 +10,14 @@ import semanticanalysis.SymbolTable; */ public class AssignmentNode implements Node { - private ExprNode lhr; + private ExprListNode lhr; private Node assign; - private ExprNode rhr; + private ExprListNode rhr; public AssignmentNode(Node lhr, Node assign, Node rhr) { - this.lhr = (ExprNode) lhr; + this.lhr = (ExprListNode) lhr; this.assign = assign; - this.rhr = (ExprNode) rhr; + this.rhr = (ExprListNode) rhr; } @Override @@ -28,7 +28,18 @@ public class AssignmentNode implements Node { errors.addAll(assign.checkSemantics(ST, _nesting)); errors.addAll(rhr.checkSemantics(ST, _nesting)); - ST.insert(lhr.getId(), rhr.typeCheck(), _nesting, ""); + int lsize = lhr.getSize(); + int rsize = rhr.getSize(); + + if (lsize == rsize) { + for (int i = 0; i < lsize; i++) { + ExprNode latom = (ExprNode) lhr.getElem(i); + ExprNode ratom = (ExprNode) rhr.getElem(i); + ST.insert(latom.getId(), ratom.typeCheck(), _nesting, ""); + } + } else { + errors.add(new SemanticError("ValueError: different size of left or right side assignment")); + } return errors; } diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 3c2b1eb..592aac4 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -13,9 +13,11 @@ import semanticanalysis.SymbolTable; public class AtomNode implements Node { protected String val; + protected TestlistCompNode exprlist; - public AtomNode(String val) { + public AtomNode(String val, Node exprlist) { this.val = val; + this.exprlist = (TestlistCompNode) exprlist; } public String getId() { @@ -26,10 +28,16 @@ public class AtomNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { var errors = new ArrayList(); - if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { - errors.add(new SemanticError("name '" + this.getId() + "' is not defined.")); - } else { - // System.out.println("exist " + this.getId()); + if (val != null) { + if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { + errors.add(new SemanticError("name '" + this.getId() + "' is not defined.")); + } else { + // System.out.println("exist " + this.typeCheck()); + } + } + + if (exprlist != null) { + errors.addAll(exprlist.checkSemantics(ST, _nesting)); } return errors; @@ -38,6 +46,10 @@ public class AtomNode implements Node { // ENHANCE: return more specific types @Override public Type typeCheck() { + if (this.val == null) { + return new VoidType(); + } + Pattern booleanVariable = Pattern.compile("^(True|False)$"); Pattern continueBreakVariable = Pattern.compile("^(continue|break)$"); // this regex should match every possible atom name written in this format: CHAR (CHAR | DIGIT)* diff --git a/src/ast/nodes/ExprListNode.java b/src/ast/nodes/ExprListNode.java new file mode 100644 index 0000000..c1a2ebc --- /dev/null +++ b/src/ast/nodes/ExprListNode.java @@ -0,0 +1,61 @@ +package ast.nodes; + +import ast.types.*; +import java.util.ArrayList; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; + +/** + * Node for the `expr_list` statement of the grammar. + */ +public class ExprListNode implements Node { + + private final ArrayList exprs; + + public ExprListNode(ArrayList _exprs) { + this.exprs = _exprs; + } + + @Override + public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + ArrayList errors = new ArrayList(); + + for (var param : exprs) { + errors.addAll(param.checkSemantics(ST, _nesting)); + } + + return errors; + } + + public int getSize() { + return exprs.size(); + } + + public Node getElem(int i) { + return exprs.get(i); + } + + @Override + public Type typeCheck() { + return new VoidType(); + } + + // TODO: code generation for expr list + @Override + public String codeGeneration() { + return ""; + } + + @Override + public String toPrint(String prefix) { + String str = prefix + "Paramlist\n"; + + prefix += " "; + for (var param : exprs) { + str += param.toPrint(prefix); + } + + return str; + } + +} diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java index 28fe783..610d0a0 100644 --- a/src/ast/nodes/ForStmtNode.java +++ b/src/ast/nodes/ForStmtNode.java @@ -1,20 +1,20 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `for_stmt` statement of the grammar. */ public class ForStmtNode implements Node { - private Node exprList; + + private ExprListNode exprList; private Node block; public ForStmtNode(Node exprList, Node block) { - this.exprList = exprList; + this.exprList = (ExprListNode) exprList; this.block = block; } @@ -22,9 +22,7 @@ public class ForStmtNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - ExprNode expr = (ExprNode) exprList; - - ST.insert(expr.getId(), expr.typeCheck(), _nesting, ""); + // ST.insert(expr.getId(), expr.typeCheck(s), _nesting, ""); errors.addAll(exprList.checkSemantics(ST, _nesting)); errors.addAll(block.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java index 5164537..adadf72 100644 --- a/src/ast/nodes/ParamdefNode.java +++ b/src/ast/nodes/ParamdefNode.java @@ -12,7 +12,7 @@ import semanticanalysis.SymbolTable; public class ParamdefNode extends AtomNode { public ParamdefNode(String val) { - super(val); + super(val, null); } @Override diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java new file mode 100644 index 0000000..070b1a1 --- /dev/null +++ b/src/ast/nodes/TestlistCompNode.java @@ -0,0 +1,61 @@ +package ast.nodes; + +import ast.types.*; +import java.util.ArrayList; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; + +/** + * Node for the `testlist_comp` statement of the grammar. + */ +public class TestlistCompNode implements Node { + + private final ArrayList exprs; + + public TestlistCompNode(ArrayList _exprs) { + this.exprs = _exprs; + } + + @Override + public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + ArrayList errors = new ArrayList(); + + for (var param : exprs) { + errors.addAll(param.checkSemantics(ST, _nesting)); + } + + return errors; + } + + public int getSize() { + return exprs.size(); + } + + public Node getElem(int i) { + return exprs.get(i); + } + + @Override + public Type typeCheck() { + return new VoidType(); + } + + // TODO: code generation for expr list + @Override + public String codeGeneration() { + return ""; + } + + @Override + public String toPrint(String prefix) { + String str = prefix + "Testlist_comp\n"; + + prefix += " "; + for (var param : exprs) { + str += param.toPrint(prefix); + } + + return str; + } + +} diff --git a/test/trailers.py b/test/trailers.py new file mode 100644 index 0000000..278a2d4 --- /dev/null +++ b/test/trailers.py @@ -0,0 +1,13 @@ + +def mult(nums): + ret = [] + for a, b in nums: + ret.append(a * b) + return ret + +print(mult([(2, 4), (5, 2)])) + + +# left, right = 1, 2 +# print(left) +# print(right) -- cgit v1.2.3-18-g5258 From 4898724edf343650ffb80792caf9e242e5843059 Mon Sep 17 00:00:00 2001 From: Santo Cariotti Date: Thu, 27 Jun 2024 19:47:05 +0200 Subject: Fix `for` loop for 1+ params --- src/ast/nodes/ExprListNode.java | 8 ++++---- src/ast/nodes/ExprNode.java | 11 ++++++++++- src/ast/nodes/ForStmtNode.java | 14 +++++++++++--- 3 files changed, 25 insertions(+), 8 deletions(-) diff --git a/src/ast/nodes/ExprListNode.java b/src/ast/nodes/ExprListNode.java index c1a2ebc..acdf679 100644 --- a/src/ast/nodes/ExprListNode.java +++ b/src/ast/nodes/ExprListNode.java @@ -12,16 +12,16 @@ public class ExprListNode implements Node { private final ArrayList exprs; - public ExprListNode(ArrayList _exprs) { - this.exprs = _exprs; + public ExprListNode(ArrayList exprs) { + this.exprs = exprs; } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - for (var param : exprs) { - errors.addAll(param.checkSemantics(ST, _nesting)); + for (var expr : exprs) { + errors.addAll(expr.checkSemantics(ST, _nesting)); } return errors; diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 62b3a94..781cc76 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -26,6 +26,14 @@ public class ExprNode implements Node { this.trailers = trailers; } + public Node getExpr(int i) { + if (i >= this.exprs.size()) { + return null; + } + + return this.exprs.get(i); + } + public String getId() { if (atom != null) { return ((AtomNode) this.atom).getId(); @@ -67,7 +75,8 @@ public class ExprNode implements Node { int argNumber = trailer.getArgumentNumber(); if (paramNumber != argNumber) { - errors.add(new SemanticError(funName + "() takes " + String.valueOf(paramNumber) + " positional arguments but " + String.valueOf(argNumber) + " were given.")); + errors.add(new SemanticError(funName + "() takes " + String.valueOf(paramNumber) + + " positional arguments but " + String.valueOf(argNumber) + " were given.")); } } } diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java index 610d0a0..c5301ee 100644 --- a/src/ast/nodes/ForStmtNode.java +++ b/src/ast/nodes/ForStmtNode.java @@ -10,11 +10,11 @@ import semanticanalysis.SymbolTable; */ public class ForStmtNode implements Node { - private ExprListNode exprList; + private Node exprList; private Node block; public ForStmtNode(Node exprList, Node block) { - this.exprList = (ExprListNode) exprList; + this.exprList = exprList; this.block = block; } @@ -22,7 +22,15 @@ public class ForStmtNode implements Node { public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - // ST.insert(expr.getId(), expr.typeCheck(s), _nesting, ""); + var l = (ExprListNode) exprList; + for (int i = 0; i < l.getSize() - 1; ++i) { + var e = (ExprNode) l.getElem(i); + ST.insert(e.getId(), e.typeCheck(), _nesting, ""); + } + + var left = (ExprNode) l.getElem(l.getSize() - 1); + var atomLeft = (ExprNode) left.getExpr(0); + ST.insert(atomLeft.getId(), atomLeft.typeCheck(), _nesting, ""); errors.addAll(exprList.checkSemantics(ST, _nesting)); errors.addAll(block.checkSemantics(ST, _nesting)); -- cgit v1.2.3-18-g5258 From fd85e9980c0305c6dfb91aaeb199430a89163c3e Mon Sep 17 00:00:00 2001 From: geno Date: Thu, 27 Jun 2024 20:49:56 +0200 Subject: fixed comp_for and added reseved word type --- src/ast/Python3VisitorImpl.java | 44 +++++++++++++++++++++++++-- src/ast/nodes/ArglistNode.java | 38 ++++++++++++----------- src/ast/nodes/AtomNode.java | 13 +++++--- src/ast/nodes/CompForNode.java | 59 ++++++++++++++++++++++++++++++++++++ src/ast/nodes/CompIterNode.java | 50 ++++++++++++++++++++++++++++++ src/ast/nodes/TestlistCompNode.java | 19 +++++++++--- src/ast/types/ContinueBreakType.java | 10 ------ src/ast/types/NoneType.java | 16 ++++++++++ src/ast/types/ReservedWordsType.java | 10 ++++++ 9 files changed, 221 insertions(+), 38 deletions(-) create mode 100644 src/ast/nodes/CompForNode.java create mode 100644 src/ast/nodes/CompIterNode.java delete mode 100644 src/ast/types/ContinueBreakType.java create mode 100644 src/ast/types/NoneType.java create mode 100644 src/ast/types/ReservedWordsType.java diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index 5b812ea..c5f1bfa 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -434,6 +434,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { Testlist_compContext tlc = ctx.testlist_comp(); if (ctx.NUMBER() != null) { return new AtomNode(ctx.NUMBER().toString(), null); + } else if (ctx.NONE() != null) { + return new AtomNode(ctx.NONE().toString(), null); } else if (ctx.TRUE() != null) { return new AtomNode(ctx.TRUE().toString(), null); } else if (ctx.FALSE() != null) { @@ -453,7 +455,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { } else if (ctx.OPEN_PAREN() != null && ctx.CLOSE_PAREN() != null) { return manageTlc(tlc); } - return new AtomNode(ctx.NONE().toString(), null); + return new AtomNode(null, null); } public AtomNode manageTlc(Testlist_compContext tlc) { @@ -533,7 +535,45 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { for (ExprContext c : ctx.expr()) { exprlist.add(visit(c)); } + Comp_forContext cfc = ctx.comp_for(); + if (cfc != null) { + Node comp = visit(ctx.comp_for()); + return new TestlistCompNode(exprlist, comp); + } + return new TestlistCompNode(exprlist, null); + } + + /** + * Returns a `CompForNode`. + * + * ``` comp_for : 'for' exprlist 'in' expr comp_iter? ;``` + */ + public Node visitComp_for(Comp_forContext ctx) { + Node exprlist = visit(ctx.exprlist()); + Node expr = visit(ctx.expr()); + Comp_iterContext cic = ctx.comp_iter(); - return new TestlistCompNode(exprlist); + if (cic != null) { + Node comp = visit(ctx.comp_iter()); + return new CompForNode(exprlist, expr, comp); + } + return new CompForNode(exprlist, expr, null); + } + + /** + * Returns a `CompIterNode`. + * + * ``` comp_iter : comp_for | comp_if ; ;``` + */ + public Node visitComp_iter(Comp_iterContext ctx) { + // TODO: Implement comp_if + // Node iter = visit(ctx.comp_if()); + Comp_forContext cfc = ctx.comp_for(); + if (cfc != null) { + Node forNode = visit(ctx.comp_for()); + return new CompIterNode(forNode); + + } + return new CompIterNode(null); } } diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index 983d150..c29a4e0 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -22,25 +22,27 @@ public class ArglistNode implements Node { ArrayList errors = new ArrayList(); for (var arg : arguments) { - ExprNode argExpr = (ExprNode) arg; - String argName = argExpr.getId(); - - // TODO: check fucking IntType for params - // TODO: remove fucking comments - if (argName != null) { - if (Arrays.asList(bif).contains(argName)) { - continue; + if (arg instanceof ExprNode) { + ExprNode argExpr = (ExprNode) arg; + String argName = argExpr.getId(); + + // TODO: check fucking IntType for params + // TODO: remove fucking comments + if (argName != null) { + if (Arrays.asList(bif).contains(argName)) { + continue; + } + + if (ST.lookup(argName) != null && ST.lookup(argName).getType() instanceof ImportType) { + continue; + } + + if (ST.nslookup(argName) < 0 && argExpr.typeCheck() instanceof AtomType) { + errors.add(new SemanticError("name '" + argName + "' is not defined.")); + } + } else { + errors.addAll(arg.checkSemantics(ST, _nesting)); } - - if (ST.lookup(argName) != null && ST.lookup(argName).getType() instanceof ImportType) { - continue; - } - - if (ST.nslookup(argName) < 0 && argExpr.typeCheck() instanceof AtomType) { - errors.add(new SemanticError("name '" + argName + "' is not defined.")); - } - } else { - errors.addAll(arg.checkSemantics(ST, _nesting)); } } diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 592aac4..16281d6 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -50,23 +50,28 @@ public class AtomNode implements Node { return new VoidType(); } + Pattern noneVariable = Pattern.compile("^(None)$"); Pattern booleanVariable = Pattern.compile("^(True|False)$"); - Pattern continueBreakVariable = Pattern.compile("^(continue|break)$"); + Pattern reservedWords = Pattern.compile("^(continue|break|int|float)$"); // this regex should match every possible atom name written in this format: CHAR (CHAR | DIGIT)* Pattern simpleVariable = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]*$", Pattern.CASE_INSENSITIVE); + Matcher noneVariableMatcher = noneVariable.matcher(this.val); Matcher booleanVariableMatcher = booleanVariable.matcher(this.val); - Matcher continueBreakVariableMatcher = continueBreakVariable.matcher(this.val); + Matcher reservedWordsMatcher = reservedWords.matcher(this.val); Matcher simpleVariableMatcher = simpleVariable.matcher(this.val); + boolean matchFoundNone = noneVariableMatcher.find(); boolean matchFoundBoolean = booleanVariableMatcher.find(); - boolean matchFoundContinueBreak = continueBreakVariableMatcher.find(); + boolean matchFoundContinueBreak = reservedWordsMatcher.find(); boolean matchFoundSimpleVariable = simpleVariableMatcher.find(); if (matchFoundBoolean) { return new BoolType(); } else if (matchFoundContinueBreak) { - return new ContinueBreakType(); + return new ReservedWordsType(); + } else if (matchFoundNone) { + return new NoneType(); } else if (matchFoundSimpleVariable) { return new AtomType(); // could be a variable or a fuction } else { diff --git a/src/ast/nodes/CompForNode.java b/src/ast/nodes/CompForNode.java new file mode 100644 index 0000000..d5c50d6 --- /dev/null +++ b/src/ast/nodes/CompForNode.java @@ -0,0 +1,59 @@ +package ast.nodes; + +import ast.types.*; +import java.util.ArrayList; +import java.util.Arrays; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; + +/** + * Node for the `comp_for` statement of the grammar. 'for' exprlist 'in' expr + * comp_iter? + */ +public class CompForNode implements Node { + + protected ExprListNode exprlist; + protected ExprNode single_expr; + protected CompIterNode comp_iter; + + public CompForNode(Node exprlist, Node single_expr, Node comp_iter) { + this.exprlist = (ExprListNode) exprlist; + this.single_expr = (ExprNode) single_expr; + this.comp_iter = (CompIterNode) comp_iter; + } + + @Override + public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + ArrayList errors = new ArrayList(); + + errors.addAll(exprlist.checkSemantics(ST, _nesting)); + errors.addAll(single_expr.checkSemantics(ST, _nesting)); + if (comp_iter != null) { + errors.addAll(comp_iter.checkSemantics(ST, _nesting)); + } + return errors; + } + + @Override + public Type typeCheck() { + return new VoidType(); + } + + // TODO: add code generation for arglist node + @Override + public String codeGeneration() { + return ""; + } + + @Override + public String toPrint(String prefix) { + String str = prefix + "CompForNode\n"; + + prefix += " "; + str += exprlist.toPrint(prefix); + str += single_expr.toPrint(prefix); + str += comp_iter.toPrint(prefix); + return str; + } + +} diff --git a/src/ast/nodes/CompIterNode.java b/src/ast/nodes/CompIterNode.java new file mode 100644 index 0000000..6704bd7 --- /dev/null +++ b/src/ast/nodes/CompIterNode.java @@ -0,0 +1,50 @@ +package ast.nodes; + +import ast.types.*; +import java.util.ArrayList; +import semanticanalysis.SemanticError; +import semanticanalysis.SymbolTable; + +/** + * Node for the `comp_iter` statement of the grammar. + */ +public class CompIterNode implements Node { + + protected CompForNode comp_for; + // protected CompIfNode compIfNode; + + public CompIterNode(Node comp_for) { + this.comp_for = (CompForNode) comp_for; + } + + @Override + public ArrayList checkSemantics(SymbolTable ST, int _nesting) { + ArrayList errors = new ArrayList(); + + if (comp_for != null) { + errors.addAll(comp_for.checkSemantics(ST, _nesting)); + } + return errors; + } + + @Override + public Type typeCheck() { + return new VoidType(); + } + + // TODO: add code generation for arglist node + @Override + public String codeGeneration() { + return ""; + } + + @Override + public String toPrint(String prefix) { + String str = prefix + "CompIterNode\n"; + + prefix += " "; + str += comp_for.toPrint(prefix); + return str; + } + +} diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java index 070b1a1..bcaca83 100644 --- a/src/ast/nodes/TestlistCompNode.java +++ b/src/ast/nodes/TestlistCompNode.java @@ -11,17 +11,28 @@ import semanticanalysis.SymbolTable; public class TestlistCompNode implements Node { private final ArrayList exprs; + private final CompForNode comp; - public TestlistCompNode(ArrayList _exprs) { - this.exprs = _exprs; + public TestlistCompNode(ArrayList exprs, Node comp) { + this.exprs = exprs; + this.comp = (CompForNode) comp; } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); - for (var param : exprs) { - errors.addAll(param.checkSemantics(ST, _nesting)); + if (comp != null) { + // if comp is set, then we save the atom in the ST (we assume the first expr is an atom) + String id = ((ExprNode) exprs.get(0)).getId(); + Type t = ((ExprNode) exprs.get(0)).typeCheck(); + ST.insert(id, t, _nesting, ""); + // errors.addAll(comp.checkSemantics(ST, _nesting)); + } else { + // if comp is not set, then exprs is a list of 1 or more element + for (var param : exprs) { + errors.addAll(param.checkSemantics(ST, _nesting)); + } } return errors; diff --git a/src/ast/types/ContinueBreakType.java b/src/ast/types/ContinueBreakType.java deleted file mode 100644 index dfcf1f2..0000000 --- a/src/ast/types/ContinueBreakType.java +++ /dev/null @@ -1,10 +0,0 @@ -package ast.types; - -/** - * A type for the continue and break statements. - */ -public class ContinueBreakType extends Type { - public String toPrint(String prefix) { - return prefix + "ContinueBreak\n"; - } -} diff --git a/src/ast/types/NoneType.java b/src/ast/types/NoneType.java new file mode 100644 index 0000000..42f7fd7 --- /dev/null +++ b/src/ast/types/NoneType.java @@ -0,0 +1,16 @@ +package ast.types; + +/** + * A none type. None return unit. + */ +public class NoneType extends Type { + + public String toPrint(String prefix) { + return prefix + "None\n"; + } + + @Override + public String toString() { + return "None"; + } +} diff --git a/src/ast/types/ReservedWordsType.java b/src/ast/types/ReservedWordsType.java new file mode 100644 index 0000000..f5f7ac5 --- /dev/null +++ b/src/ast/types/ReservedWordsType.java @@ -0,0 +1,10 @@ +package ast.types; + +/** + * A type for the continue and break statements. + */ +public class ReservedWordsType extends Type { + public String toPrint(String prefix) { + return prefix + "ReservedWords\n"; + } +} -- cgit v1.2.3-18-g5258 From 4516c901ccbabfba9115c87237996dc9acdc7590 Mon Sep 17 00:00:00 2001 From: geno Date: Thu, 27 Jun 2024 20:58:29 +0200 Subject: fix additional useless errors --- src/ast/nodes/AssignmentNode.java | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index 07966c3..35c47b3 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -31,15 +31,16 @@ public class AssignmentNode implements Node { int lsize = lhr.getSize(); int rsize = rhr.getSize(); - if (lsize == rsize) { - for (int i = 0; i < lsize; i++) { - ExprNode latom = (ExprNode) lhr.getElem(i); - ExprNode ratom = (ExprNode) rhr.getElem(i); - ST.insert(latom.getId(), ratom.typeCheck(), _nesting, ""); - } - } else { - errors.add(new SemanticError("ValueError: different size of left or right side assignment")); + // if (lsize == rsize) { + for (int i = 0; i < lsize; i++) { + ExprNode latom = (ExprNode) lhr.getElem(i); + ST.insert(latom.getId(), new AtomType(), _nesting, ""); + // ExprNode ratom = (ExprNode) rhr.getElem(i); } + // } else { + // FIX: sgravata da più problemi che altro + // errors.add(new SemanticError("ValueError: different size of left or right side assignment")); + // } return errors; } -- cgit v1.2.3-18-g5258 From 3f29e5101d9c6e670dd05715297f2060707dc6c7 Mon Sep 17 00:00:00 2001 From: Santo Cariotti Date: Thu, 27 Jun 2024 22:18:55 +0200 Subject: Fix trailer with parentheeses `for (key, val) in ...` Resolves test `a228.py` --- src/ast/nodes/TestlistCompNode.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java index bcaca83..4ae77c9 100644 --- a/src/ast/nodes/TestlistCompNode.java +++ b/src/ast/nodes/TestlistCompNode.java @@ -23,7 +23,8 @@ public class TestlistCompNode implements Node { ArrayList errors = new ArrayList(); if (comp != null) { - // if comp is set, then we save the atom in the ST (we assume the first expr is an atom) + // if comp is set, then we save the atom in the ST (we assume the first expr is + // an atom) String id = ((ExprNode) exprs.get(0)).getId(); Type t = ((ExprNode) exprs.get(0)).typeCheck(); ST.insert(id, t, _nesting, ""); @@ -31,6 +32,8 @@ public class TestlistCompNode implements Node { } else { // if comp is not set, then exprs is a list of 1 or more element for (var param : exprs) { + var exp = (ExprNode) param; + ST.insert(exp.getId(), exp.typeCheck(), _nesting, ""); errors.addAll(param.checkSemantics(ST, _nesting)); } } -- cgit v1.2.3-18-g5258 From 259580d38338ef53e6f98b2b279d1d4aa8ecff04 Mon Sep 17 00:00:00 2001 From: Santo Cariotti Date: Thu, 27 Jun 2024 22:24:43 +0200 Subject: Remove semantic error for `'x' is not a function` It's useless --- src/ast/nodes/ExprNode.java | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 781cc76..591ee37 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -62,12 +62,8 @@ public class ExprNode implements Node { if (fun != null && !(fun.getType() instanceof ImportType)) { if (!(fun.getType() instanceof FunctionType)) { - if (trailer.isParenthesis()) { - errors.add(new SemanticError("'" + funName + "' is not a function.")); - } else { - for (var t : trailers) { - errors.addAll(t.checkSemantics(ST, _nesting)); - } + for (var t : trailers) { + errors.addAll(t.checkSemantics(ST, _nesting)); } } else { FunctionType ft = (FunctionType) fun.getType(); -- cgit v1.2.3-18-g5258 From d653d3598d71fea30d45d118e3d046a3aed53ac1 Mon Sep 17 00:00:00 2001 From: Santo Cariotti Date: Thu, 27 Jun 2024 22:39:22 +0200 Subject: Uncommented test files --- progs/a284.py | 24 ++++++++++----------- progs/a339.py | 52 ++++++++++++++++++++++----------------------- progs/a394.py | 46 +++++++++++++++++++-------------------- progs/a52.py | 16 +++++++------- progs/a641.py | 12 +++++------ progs/a679.py | 2 +- progs/a745.py | 32 +++++++++++++--------------- src/ast/nodes/AtomNode.java | 4 +++- 8 files changed, 91 insertions(+), 97 deletions(-) diff --git a/progs/a284.py b/progs/a284.py index cfd429d..41d2914 100644 --- a/progs/a284.py +++ b/progs/a284.py @@ -1,13 +1,11 @@ -# FIXME: multiple variable assignment in for loop -# -# def is_Isomorphic(str1,str2): -# dict_str1 = {} -# dict_str2 = {} -# for i, value in enumerate(str1): -# dict_str1[value] = dict_str1.get(value,[]) + [i] -# for j, value in enumerate(str2): -# dict_str2[value] = dict_str2.get(value,[]) + [j] -# if sorted(dict_str1.values()) == sorted(dict_str2.values()): -# return True -# else: -# return False \ No newline at end of file +def is_Isomorphic(str1, str2): + dict_str1 = {} + dict_str2 = {} + for i, value in enumerate(str1): + dict_str1[value] = dict_str1.get(value, []) + [i] + for j, value in enumerate(str2): + dict_str2[value] = dict_str2.get(value, []) + [j] + if sorted(dict_str1.values()) == sorted(dict_str2.values()): + return True + else: + return False diff --git a/progs/a339.py b/progs/a339.py index 95724d2..53fcb7e 100644 --- a/progs/a339.py +++ b/progs/a339.py @@ -1,28 +1,28 @@ -# FIXME: chiamata a funzione definita dopo -# -# def heap_sort(arr): -# heapify(arr) -# end = len(arr) - 1 -# while end > 0: -# arr[end], arr[0] = arr[0], arr[end] -# shift_down(arr, 0, end - 1) -# end -= 1 -# return arr +def heap_sort(arr): + heapify(arr) + end = len(arr) - 1 + while end > 0: + arr[end], arr[0] = arr[0], arr[end] + shift_down(arr, 0, end - 1) + end -= 1 + return arr -# def heapify(arr): -# start = len(arr) // 2 -# while start >= 0: -# shift_down(arr, start, len(arr) - 1) -# start -= 1 -# def shift_down(arr, start, end): -# root = start -# while root * 2 + 1 <= end: -# child = root * 2 + 1 -# if child + 1 <= end and arr[child] < arr[child + 1]: -# child += 1 -# if child <= end and arr[root] < arr[child]: -# arr[root], arr[child] = arr[child], arr[root] -# root = child -# else: -# return +def heapify(arr): + start = len(arr) // 2 + while start >= 0: + shift_down(arr, start, len(arr) - 1) + start -= 1 + + +def shift_down(arr, start, end): + root = start + while root * 2 + 1 <= end: + child = root * 2 + 1 + if child + 1 <= end and arr[child] < arr[child + 1]: + child += 1 + if child <= end and arr[root] < arr[child]: + arr[root], arr[child] = arr[child], arr[root] + root = child + else: + return diff --git a/progs/a394.py b/progs/a394.py index 25f8f3e..d977184 100644 --- a/progs/a394.py +++ b/progs/a394.py @@ -1,24 +1,22 @@ -# FIXME: multiple variable assignment in for loop -# -# def func(nums, k): -# import collections -# d = collections.defaultdict(int) -# for row in nums: -# for i in row: -# d[i] += 1 -# temp = [] -# import heapq -# for key, v in d.items(): -# if len(temp) < k: -# temp.append((v, key)) -# if len(temp) == k: -# heapq.heapify(temp) -# else: -# if v > temp[0][0]: -# heapq.heappop(temp) -# heapq.heappush(temp, (v, key)) -# result = [] -# while temp: -# v, key = heapq.heappop(temp) -# result.append(key) -# return result \ No newline at end of file +def func(nums, k): + import collections + d = collections.defaultdict(int) + for row in nums: + for i in row: + d[i] += 1 + temp = [] + import heapq + for key, v in d.items(): + if len(temp) < k: + temp.append((v, key)) + if len(temp) == k: + heapq.heapify(temp) + else: + if v > temp[0][0]: + heapq.heappop(temp) + heapq.heappush(temp, (v, key)) + result = [] + while temp: + v, key = heapq.heappop(temp) + result.append(key) + return result diff --git a/progs/a52.py b/progs/a52.py index 1d116bc..131af01 100644 --- a/progs/a52.py +++ b/progs/a52.py @@ -1,8 +1,8 @@ -# FIXME: multiple variable assignment in for loop -# -# from collections import defaultdict -# def grouping_dictionary(l): -# d = defaultdict(list) -# for k, v in l: -# d[k].append(v) -# return d \ No newline at end of file +from collections import defaultdict + + +def grouping_dictionary(l): + d = defaultdict(list) + for k, v in l: + d[k].append(v) + return d diff --git a/progs/a641.py b/progs/a641.py index 52b0f6a..1b7e4bb 100644 --- a/progs/a641.py +++ b/progs/a641.py @@ -1,7 +1,5 @@ -# FIXME: multiple variable assignment in for loop -# -# def count_first_elements(test_tup): -# for count, ele in enumerate(test_tup): -# if isinstance(ele, tuple): -# break -# return (count) \ No newline at end of file +def count_first_elements(test_tup): + for count, ele in enumerate(test_tup): + if isinstance(ele, tuple): + break + return count diff --git a/progs/a679.py b/progs/a679.py index 97472a6..6f1d11c 100644 --- a/progs/a679.py +++ b/progs/a679.py @@ -10,4 +10,4 @@ def find_last_occurrence(A, x): right = mid - 1 else: left = mid + 1 - return result \ No newline at end of file + return result diff --git a/progs/a745.py b/progs/a745.py index e8ad671..1d9fe80 100644 --- a/progs/a745.py +++ b/progs/a745.py @@ -1,17 +1,15 @@ -# FIXME: unpacking assignment -# -# def find_rotation_count(A): -# (left, right) = (0, len(A) - 1) -# while left <= right: -# if A[left] <= A[right]: -# return left -# mid = (left + right) // 2 -# next = (mid + 1) % len(A) -# prev = (mid - 1 + len(A)) % len(A) -# if A[mid] <= A[next] and A[mid] <= A[prev]: -# return mid -# elif A[mid] <= A[right]: -# right = mid - 1 -# elif A[mid] >= A[left]: -# left = mid + 1 -# return -1 \ No newline at end of file +def find_rotation_count(A): + (left, right) = (0, len(A) - 1) + while left <= right: + if A[left] <= A[right]: + return left + mid = (left + right) // 2 + next = (mid + 1) % len(A) + prev = (mid - 1 + len(A)) % len(A) + if A[mid] <= A[next] and A[mid] <= A[prev]: + return mid + elif A[mid] <= A[right]: + right = mid - 1 + elif A[mid] >= A[left]: + left = mid + 1 + return -1 diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index 16281d6..cea617f 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -53,7 +53,8 @@ public class AtomNode implements Node { Pattern noneVariable = Pattern.compile("^(None)$"); Pattern booleanVariable = Pattern.compile("^(True|False)$"); Pattern reservedWords = Pattern.compile("^(continue|break|int|float)$"); - // this regex should match every possible atom name written in this format: CHAR (CHAR | DIGIT)* + // this regex should match every possible atom name written in this format: CHAR + // (CHAR | DIGIT)* Pattern simpleVariable = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]*$", Pattern.CASE_INSENSITIVE); Matcher noneVariableMatcher = noneVariable.matcher(this.val); @@ -87,6 +88,7 @@ public class AtomNode implements Node { @Override public String toPrint(String prefix) { + // FIXME: can be a testlist_comp with two expr and two atoms if (val != null) { return prefix + "Atom(" + val + ")\n"; } -- cgit v1.2.3-18-g5258 From 49357616859faaf9e53468ce71d6cd99bda4fb4a Mon Sep 17 00:00:00 2001 From: Santo Cariotti Date: Thu, 27 Jun 2024 22:41:06 +0200 Subject: Restore progs folder --- progs/a284.py | 8 ++++---- progs/a339.py | 5 +---- progs/a394.py | 2 +- progs/a403.py | 2 +- progs/a52.py | 4 +--- progs/a641.py | 8 ++++---- progs/a679.py | 2 +- progs/a745.py | 2 +- progs/test.py | 17 +++++++++++++++++ progs/test2.py | 3 +++ 10 files changed, 34 insertions(+), 19 deletions(-) create mode 100644 progs/test.py create mode 100644 progs/test2.py diff --git a/progs/a284.py b/progs/a284.py index 41d2914..b69395b 100644 --- a/progs/a284.py +++ b/progs/a284.py @@ -1,11 +1,11 @@ -def is_Isomorphic(str1, str2): +def is_Isomorphic(str1,str2): dict_str1 = {} dict_str2 = {} for i, value in enumerate(str1): - dict_str1[value] = dict_str1.get(value, []) + [i] + dict_str1[value] = dict_str1.get(value,[]) + [i] for j, value in enumerate(str2): - dict_str2[value] = dict_str2.get(value, []) + [j] + dict_str2[value] = dict_str2.get(value,[]) + [j] if sorted(dict_str1.values()) == sorted(dict_str2.values()): return True else: - return False + return False \ No newline at end of file diff --git a/progs/a339.py b/progs/a339.py index 53fcb7e..9a57403 100644 --- a/progs/a339.py +++ b/progs/a339.py @@ -1,5 +1,5 @@ def heap_sort(arr): - heapify(arr) + heapify(arr) end = len(arr) - 1 while end > 0: arr[end], arr[0] = arr[0], arr[end] @@ -7,14 +7,11 @@ def heap_sort(arr): end -= 1 return arr - def heapify(arr): start = len(arr) // 2 while start >= 0: shift_down(arr, start, len(arr) - 1) start -= 1 - - def shift_down(arr, start, end): root = start while root * 2 + 1 <= end: diff --git a/progs/a394.py b/progs/a394.py index d977184..4fe6e47 100644 --- a/progs/a394.py +++ b/progs/a394.py @@ -19,4 +19,4 @@ def func(nums, k): while temp: v, key = heapq.heappop(temp) result.append(key) - return result + return result \ No newline at end of file diff --git a/progs/a403.py b/progs/a403.py index ee1bdd7..18c84b2 100644 --- a/progs/a403.py +++ b/progs/a403.py @@ -2,4 +2,4 @@ from collections import Counter from itertools import chain def freq_element(nums): result = Counter(chain.from_iterable(nums)) - return result + return result \ No newline at end of file diff --git a/progs/a52.py b/progs/a52.py index 131af01..4a0b33a 100644 --- a/progs/a52.py +++ b/progs/a52.py @@ -1,8 +1,6 @@ from collections import defaultdict - - def grouping_dictionary(l): d = defaultdict(list) for k, v in l: d[k].append(v) - return d + return d \ No newline at end of file diff --git a/progs/a641.py b/progs/a641.py index 1b7e4bb..51393cd 100644 --- a/progs/a641.py +++ b/progs/a641.py @@ -1,5 +1,5 @@ def count_first_elements(test_tup): - for count, ele in enumerate(test_tup): - if isinstance(ele, tuple): - break - return count + for count, ele in enumerate(test_tup): + if isinstance(ele, tuple): + break + return (count) \ No newline at end of file diff --git a/progs/a679.py b/progs/a679.py index 6f1d11c..97472a6 100644 --- a/progs/a679.py +++ b/progs/a679.py @@ -10,4 +10,4 @@ def find_last_occurrence(A, x): right = mid - 1 else: left = mid + 1 - return result + return result \ No newline at end of file diff --git a/progs/a745.py b/progs/a745.py index 1d9fe80..9a21dfa 100644 --- a/progs/a745.py +++ b/progs/a745.py @@ -12,4 +12,4 @@ def find_rotation_count(A): right = mid - 1 elif A[mid] >= A[left]: left = mid + 1 - return -1 + return -1 \ No newline at end of file diff --git a/progs/test.py b/progs/test.py new file mode 100644 index 0000000..718885d --- /dev/null +++ b/progs/test.py @@ -0,0 +1,17 @@ +import math +from re import f4, r3 + +from abs import * + + +def find_first_duplicate(nums, x): + num_set = set() + no_duplicate = -1 + + for i in range(len(nums)): + if nums[i] in num_set: + return nums[i] + else: + num_set.add(nums[i]) + + return no_duplicate diff --git a/progs/test2.py b/progs/test2.py new file mode 100644 index 0000000..c62d44a --- /dev/null +++ b/progs/test2.py @@ -0,0 +1,3 @@ +x = 1 +if y == 1: + print("a") -- cgit v1.2.3-18-g5258 From 089787db950056a35eb1a5930b5b919c45523863 Mon Sep 17 00:00:00 2001 From: Geno <48206120+gabrielegenovese@users.noreply.github.com> Date: Fri, 28 Jun 2024 11:20:17 +0200 Subject: Update src/ast/Python3VisitorImpl.java suggested by santo Co-authored-by: Santo Cariotti --- src/ast/Python3VisitorImpl.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index c5f1bfa..bef75cf 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -536,11 +536,11 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { exprlist.add(visit(c)); } Comp_forContext cfc = ctx.comp_for(); + Node comp = null; if (cfc != null) { - Node comp = visit(ctx.comp_for()); - return new TestlistCompNode(exprlist, comp); + comp = visit(ctx.comp_for()); } - return new TestlistCompNode(exprlist, null); + return new TestlistCompNode(exprlist, comp); } /** -- cgit v1.2.3-18-g5258 From 1d5c4862e136419ab1ed3fcf8d8edaa0ee5fda10 Mon Sep 17 00:00:00 2001 From: Geno <48206120+gabrielegenovese@users.noreply.github.com> Date: Fri, 28 Jun 2024 11:21:12 +0200 Subject: Update src/ast/Python3VisitorImpl.java suggested by santo Co-authored-by: Santo Cariotti --- src/ast/Python3VisitorImpl.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index bef75cf..42e2537 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -569,11 +569,10 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { // TODO: Implement comp_if // Node iter = visit(ctx.comp_if()); Comp_forContext cfc = ctx.comp_for(); + Node forNode = null; if (cfc != null) { - Node forNode = visit(ctx.comp_for()); - return new CompIterNode(forNode); - + forNode = visit(ctx.comp_for()); } - return new CompIterNode(null); + return new CompIterNode(forNode); } } -- cgit v1.2.3-18-g5258 From 37665fb6d0bc1eb29396ae949354cf7d6f9d54ca Mon Sep 17 00:00:00 2001 From: geno Date: Fri, 28 Jun 2024 12:23:28 +0200 Subject: resolving all the comments santo made --- src/Main.java | 15 +-------------- src/ParseAll.java | 11 +---------- src/ast/Python3VisitorImpl.java | 19 +++++++++++-------- src/ast/nodes/AtomNode.java | 4 ++++ src/ast/nodes/ExprListNode.java | 9 ++++++++- src/ast/nodes/ExprNode.java | 14 ++++++++++++-- src/ast/nodes/ForStmtNode.java | 20 ++++++++++++++++++++ src/ast/nodes/TestlistCompNode.java | 11 +++++++++-- src/ast/types/FunctionType.java | 9 +++++---- src/semanticanalysis/Share.java | 33 +++++++++++++++++++++++++++------ 10 files changed, 98 insertions(+), 47 deletions(-) diff --git a/src/Main.java b/src/Main.java index 04f7183..4f5d45f 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,7 +1,4 @@ -import java.io.BufferedReader; -import java.io.FileReader; -import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import javax.swing.*; @@ -27,7 +24,7 @@ public class Main { try { String fileStr = args[0]; System.out.println(fileStr); - System.out.println(readFile(fileStr)); + System.out.println(Share.readFile(fileStr)); CharStream cs = CharStreams.fromFileName(fileStr); Python3Lexer lexer = new Python3Lexer(cs); CommonTokenStream tokens = new CommonTokenStream(lexer); @@ -71,14 +68,4 @@ public class Main { } } - private static String readFile(String filePath) throws IOException { - StringBuilder content = new StringBuilder(); - try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) { - String line; - while ((line = reader.readLine()) != null) { - content.append(line).append("\n"); - } - } - return content.toString(); - } } diff --git a/src/ParseAll.java b/src/ParseAll.java index 2662a85..568c89c 100644 --- a/src/ParseAll.java +++ b/src/ParseAll.java @@ -22,7 +22,7 @@ public class ParseAll { // fileStr = "./progs/wrong.py"; try { - if (!file.isFile() || !getExtension(file.getName()).equals("py")) { + if (!file.isFile() || !Share.getExtension(file.getName()).equals("py")) { System.err.println("Wont parse: " + fileStr); continue; } @@ -56,13 +56,4 @@ public class ParseAll { } } } - - public static String getExtension(String fileName) { - int extensionIndex = fileName.lastIndexOf('.'); - if (extensionIndex == -1) { - return fileName; - } else { - return fileName.substring(extensionIndex + 1); - } - } } diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java index 42e2537..1cf15b7 100644 --- a/src/ast/Python3VisitorImpl.java +++ b/src/ast/Python3VisitorImpl.java @@ -424,7 +424,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { } /** - * Returns an `AtomNode`. FIXME: add support for testlist_comp + * Returns an `AtomNode`. * * ``` atom : '(' testlist_comp? ')' | '[' testlist_comp? ']' | '{' * testlist_comp? '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | @@ -449,22 +449,26 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { } return new AtomNode(varName, null); } else if (ctx.OPEN_BRACE() != null && ctx.CLOSE_BRACE() != null) { - return manageTlc(tlc); + return manageCompListContext(tlc); } else if (ctx.OPEN_BRACK() != null && ctx.CLOSE_BRACK() != null) { - return manageTlc(tlc); + return manageCompListContext(tlc); } else if (ctx.OPEN_PAREN() != null && ctx.CLOSE_PAREN() != null) { - return manageTlc(tlc); + return manageCompListContext(tlc); } return new AtomNode(null, null); } - public AtomNode manageTlc(Testlist_compContext tlc) { + /** + * Supporting function for `visitAtom`. Returns an `AtomNode` with + * `testlist_comp` set if the context is not null. Otherwise, returns an + * `AtomNode` with nulls. + */ + public AtomNode manageCompListContext(Testlist_compContext tlc) { if (tlc != null) { Node testlist_comp = visit(tlc); return new AtomNode(null, testlist_comp); - } else { - return new AtomNode(null, null); } + return new AtomNode(null, null); } /** @@ -529,7 +533,6 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor { * ``` testlist_comp : expr (comp_for | (',' expr)* ','?) ; ``` */ public Node visitTestlist_comp(Testlist_compContext ctx) { - // TODO: implement comp_for ArrayList exprlist = new ArrayList(); for (ExprContext c : ctx.expr()) { diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index cea617f..fef72ec 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -20,6 +20,10 @@ public class AtomNode implements Node { this.exprlist = (TestlistCompNode) exprlist; } + /** + * Returns the identifier of the `AtomNode` if it's not `null`, otherwise + * returns `null`. + */ public String getId() { return this.val; } diff --git a/src/ast/nodes/ExprListNode.java b/src/ast/nodes/ExprListNode.java index acdf679..800f4be 100644 --- a/src/ast/nodes/ExprListNode.java +++ b/src/ast/nodes/ExprListNode.java @@ -31,7 +31,14 @@ public class ExprListNode implements Node { return exprs.size(); } + /** + * Returns the i-th expressions of `exprs` field. If the index is greater or + * equals than the size return `null`. + */ public Node getElem(int i) { + if (i >= this.exprs.size()) { + return null; + } return exprs.get(i); } @@ -48,7 +55,7 @@ public class ExprListNode implements Node { @Override public String toPrint(String prefix) { - String str = prefix + "Paramlist\n"; + String str = prefix + "ExprList\n"; prefix += " "; for (var param : exprs) { diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 591ee37..8e3b896 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -26,6 +26,10 @@ public class ExprNode implements Node { this.trailers = trailers; } + /** + * Returns the i-th expressions of `exprs` field. If the index is greater or + * equals than the size return `null`. + */ public Node getExpr(int i) { if (i >= this.exprs.size()) { return null; @@ -34,6 +38,10 @@ public class ExprNode implements Node { return this.exprs.get(i); } + /** + * Returns the identifier of the `AtomNode` if it's not `null`, otherwise + * returns `null`. + */ public String getId() { if (atom != null) { return ((AtomNode) this.atom).getId(); @@ -65,6 +73,7 @@ public class ExprNode implements Node { for (var t : trailers) { errors.addAll(t.checkSemantics(ST, _nesting)); } + } else { FunctionType ft = (FunctionType) fun.getType(); int paramNumber = ft.getParamNumber(); @@ -80,6 +89,7 @@ public class ExprNode implements Node { for (var trailer : trailers) { errors.addAll(trailer.checkSemantics(ST, _nesting)); } + } } else if (atom != null) { errors.addAll(atom.checkSemantics(ST, _nesting)); @@ -126,11 +136,11 @@ public class ExprNode implements Node { } for (var expr : exprs) { - str += expr.toPrint(prefix); + str = expr.toPrint(prefix); } for (var trailer : trailers) { - str += trailer.toPrint(prefix); + str = trailer.toPrint(prefix); } if (op != null) { diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java index c5301ee..d4c5e56 100644 --- a/src/ast/nodes/ForStmtNode.java +++ b/src/ast/nodes/ForStmtNode.java @@ -18,18 +18,38 @@ public class ForStmtNode implements Node { this.block = block; } + /** + * This methods check the semantics of the operation `for i in list: block`. + * + * After the `for` keyword, it's parsed as a list of expression. We verified + * that the last expression is always gonna be `expr comp_op expr`. We + * comp_op must be the `in` keyword. `i` could be of any lenght (e.g. `a, b, + * c`). + * + * In this function we define the following approch: we save in the + * SymbolTable every atom until the last expression in the expression's + * list. For the last element, we know that is in the `expr comp_op expr` + * format, so we take the left element and save it in the SymbolicTable as + * an atom. + */ @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { ArrayList errors = new ArrayList(); + // Save every atom in the expression's list, except the last one var l = (ExprListNode) exprList; for (int i = 0; i < l.getSize() - 1; ++i) { var e = (ExprNode) l.getElem(i); ST.insert(e.getId(), e.typeCheck(), _nesting, ""); } + // Manage the last expression of expression's list + // Get the ExprNode var left = (ExprNode) l.getElem(l.getSize() - 1); + // Get the left side expression of the operation, that + // corresponds to the first element of the expression list. var atomLeft = (ExprNode) left.getExpr(0); + // ENHANCE: check that the comp_op is the `in` keyword ST.insert(atomLeft.getId(), atomLeft.typeCheck(), _nesting, ""); errors.addAll(exprList.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java index 4ae77c9..244f4ef 100644 --- a/src/ast/nodes/TestlistCompNode.java +++ b/src/ast/nodes/TestlistCompNode.java @@ -10,8 +10,8 @@ import semanticanalysis.SymbolTable; */ public class TestlistCompNode implements Node { - private final ArrayList exprs; - private final CompForNode comp; + private ArrayList exprs; + private CompForNode comp; public TestlistCompNode(ArrayList exprs, Node comp) { this.exprs = exprs; @@ -45,7 +45,14 @@ public class TestlistCompNode implements Node { return exprs.size(); } + /** + * Returns the i-th expressions of `exprs` field. If the index is greater or + * equals than the size return `null`. + */ public Node getElem(int i) { + if (i >= this.exprs.size()) { + return null; + } return exprs.get(i); } diff --git a/src/ast/types/FunctionType.java b/src/ast/types/FunctionType.java index 464bb9c..ef50641 100644 --- a/src/ast/types/FunctionType.java +++ b/src/ast/types/FunctionType.java @@ -1,18 +1,19 @@ package ast.types; /** - * An tom type. TODO: do I need to use this one? + * A Function type. */ public class FunctionType extends Type { - private final int paramNumber; - private final Type returnType; + private int paramNumber; + private Type returnType; public FunctionType(int paramNumber, Type returnType) { this.paramNumber = paramNumber; this.returnType = returnType; } + // Return the length of the parameters public int getParamNumber() { return paramNumber; } @@ -22,6 +23,6 @@ public class FunctionType extends Type { } public String toPrint(String prefix) { - return prefix + "Atom\n"; + return prefix + "Function\n"; } } diff --git a/src/semanticanalysis/Share.java b/src/semanticanalysis/Share.java index c1f03c2..c98fc53 100644 --- a/src/semanticanalysis/Share.java +++ b/src/semanticanalysis/Share.java @@ -1,13 +1,18 @@ package semanticanalysis; -import java.util.ArrayList; +import java.util.*; +import java.io.*; public class Share { - public static ArrayList removeDuplicates(ArrayList list) { - ArrayList newList = new ArrayList(); + /** + * Removes the duplicate elements in a list of Semantic Errors. It's not + * generic because it's used a custom contains function. + */ + public static ArrayList removeDuplicates(ArrayList list) { + ArrayList newList = new ArrayList(); - for (T element : list) { + for (SemanticError element : list) { if (!customContains(newList, element)) { newList.add(element); } @@ -15,9 +20,14 @@ public class Share { return newList; } - public static boolean customContains(ArrayList list, T e) { + /** + * Normal contains did not work, so we made a custom contains function. + * Returns `true` if the String rappresentation of an object in the list is + * equal to the element given in input. + */ + private static boolean customContains(ArrayList list, SemanticError e) { String e1 = e.toString(); - for (T element : list) { + for (SemanticError element : list) { String e2 = element.toString(); if (e2.equals(e1)) { return true; @@ -34,4 +44,15 @@ public class Share { return fileName.substring(extensionIndex + 1); } } + + public static String readFile(String filePath) throws IOException { + StringBuilder content = new StringBuilder(); + try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) { + String line; + while ((line = reader.readLine()) != null) { + content.append(line).append("\n"); + } + } + return content.toString(); + } } -- cgit v1.2.3-18-g5258 From aaa97e2e41c0aa17a6f99099dd39bb73a935fe02 Mon Sep 17 00:00:00 2001 From: L0P0P Date: Sat, 29 Jun 2024 09:54:08 +0200 Subject: Fixed some warnings --- src/ast/nodes/AssignmentNode.java | 4 +++- src/ast/nodes/CompForNode.java | 1 - src/ast/nodes/ExprListNode.java | 2 +- src/ast/nodes/TestlistCompNode.java | 2 +- 4 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index 35c47b3..74d7283 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -29,7 +29,9 @@ public class AssignmentNode implements Node { errors.addAll(rhr.checkSemantics(ST, _nesting)); int lsize = lhr.getSize(); - int rsize = rhr.getSize(); + + // FIXME: unused variable + // int rsize = rhr.getSize(); // if (lsize == rsize) { for (int i = 0; i < lsize; i++) { diff --git a/src/ast/nodes/CompForNode.java b/src/ast/nodes/CompForNode.java index d5c50d6..06c7aee 100644 --- a/src/ast/nodes/CompForNode.java +++ b/src/ast/nodes/CompForNode.java @@ -2,7 +2,6 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; -import java.util.Arrays; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; diff --git a/src/ast/nodes/ExprListNode.java b/src/ast/nodes/ExprListNode.java index 800f4be..4760db8 100644 --- a/src/ast/nodes/ExprListNode.java +++ b/src/ast/nodes/ExprListNode.java @@ -18,7 +18,7 @@ public class ExprListNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList<>(); for (var expr : exprs) { errors.addAll(expr.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java index 244f4ef..cba056c 100644 --- a/src/ast/nodes/TestlistCompNode.java +++ b/src/ast/nodes/TestlistCompNode.java @@ -20,7 +20,7 @@ public class TestlistCompNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList<>(); if (comp != null) { // if comp is set, then we save the atom in the ST (we assume the first expr is -- cgit v1.2.3-18-g5258 From afff6a80cd58f7787efa1398f7c8cbdce8989323 Mon Sep 17 00:00:00 2001 From: geno Date: Sun, 30 Jun 2024 13:36:37 +0200 Subject: fixed warnings, better formatting, final added where possible --- src/Main.java | 2 +- src/ParseAll.java | 2 +- src/ast/nodes/ArglistNode.java | 5 ++--- src/ast/nodes/AssignmentNode.java | 13 ++++++------- src/ast/nodes/AtomNode.java | 2 +- src/ast/nodes/AugassignNode.java | 5 +++-- src/ast/nodes/BlockNode.java | 10 ++++------ src/ast/nodes/CompForNode.java | 2 +- src/ast/nodes/CompIterNode.java | 2 +- src/ast/nodes/CompNode.java | 4 ++-- src/ast/nodes/CompoundNode.java | 10 +++++----- src/ast/nodes/DottedNameNode.java | 3 ++- src/ast/nodes/ExprNode.java | 12 ++++++------ src/ast/nodes/ForStmtNode.java | 6 +++--- src/ast/nodes/FuncdefNode.java | 11 ++++++----- src/ast/nodes/IfNode.java | 15 ++++++++------- src/ast/nodes/ImportNode.java | 19 ++++++++++--------- src/ast/nodes/Node.java | 10 ++++------ src/ast/nodes/ParamdefNode.java | 2 +- src/ast/nodes/ParamlistNode.java | 7 +++---- src/ast/nodes/ReturnStmtNode.java | 8 ++++---- src/ast/nodes/RootNode.java | 4 ++-- src/ast/nodes/SimpleStmtNode.java | 11 ++++++----- src/ast/nodes/SimpleStmtsNode.java | 5 +++-- src/ast/nodes/TestlistCompNode.java | 4 ++-- src/ast/nodes/TrailerNode.java | 14 +++++++------- src/ast/nodes/WhileStmtNode.java | 10 +++++----- src/ast/types/AtomType.java | 3 ++- src/ast/types/BoolType.java | 2 ++ src/ast/types/ErrorType.java | 2 ++ src/ast/types/FunctionType.java | 5 +++-- src/ast/types/ImportType.java | 3 ++- src/ast/types/IntType.java | 2 ++ src/ast/types/NoneType.java | 1 + src/ast/types/ReservedWordsType.java | 2 ++ src/ast/types/Type.java | 11 +++++------ src/ast/types/VoidType.java | 1 + src/semanticanalysis/STentry.java | 7 ++++--- src/semanticanalysis/SemanticError.java | 4 +++- src/semanticanalysis/Share.java | 4 ++-- src/semanticanalysis/SymbolTable.java | 20 ++++++-------------- 41 files changed, 136 insertions(+), 129 deletions(-) diff --git a/src/Main.java b/src/Main.java index 4f5d45f..f53b410 100644 --- a/src/Main.java +++ b/src/Main.java @@ -54,7 +54,7 @@ public class Main { Node ast = visitor.visit(tree); ArrayList errorsWithDup = ast.checkSemantics(ST, 0); ArrayList errors = Share.removeDuplicates(errorsWithDup); - if (errors.size() > 0) { + if (!errors.isEmpty()) { System.out.println("You had " + errors.size() + " errors:"); for (SemanticError e : errors) { System.out.println("\t" + e); diff --git a/src/ParseAll.java b/src/ParseAll.java index 568c89c..7def6f4 100644 --- a/src/ParseAll.java +++ b/src/ParseAll.java @@ -41,7 +41,7 @@ public class ParseAll { Node ast = visitor.visit(tree); ArrayList errorsWithDup = ast.checkSemantics(ST, 0); ArrayList errors = Share.removeDuplicates(errorsWithDup); - if (errors.size() > 0) { + if (!errors.isEmpty()) { System.out.println(); System.out.println(fileStr); System.out.println("You had " + errors.size() + " errors:"); diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index c29a4e0..55a568d 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -19,11 +19,10 @@ public class ArglistNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); for (var arg : arguments) { - if (arg instanceof ExprNode) { - ExprNode argExpr = (ExprNode) arg; + if (arg instanceof ExprNode argExpr) { String argName = argExpr.getId(); // TODO: check fucking IntType for params diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index 74d7283..558e392 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -10,9 +10,9 @@ import semanticanalysis.SymbolTable; */ public class AssignmentNode implements Node { - private ExprListNode lhr; - private Node assign; - private ExprListNode rhr; + private final ExprListNode lhr; + private final Node assign; + private final ExprListNode rhr; public AssignmentNode(Node lhr, Node assign, Node rhr) { this.lhr = (ExprListNode) lhr; @@ -22,7 +22,7 @@ public class AssignmentNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); // errors.addAll(lhr.checkSemantics(ST, _nesting)); errors.addAll(assign.checkSemantics(ST, _nesting)); @@ -32,7 +32,6 @@ public class AssignmentNode implements Node { // FIXME: unused variable // int rsize = rhr.getSize(); - // if (lsize == rsize) { for (int i = 0; i < lsize; i++) { ExprNode latom = (ExprNode) lhr.getElem(i); @@ -40,8 +39,8 @@ public class AssignmentNode implements Node { // ExprNode ratom = (ExprNode) rhr.getElem(i); } // } else { - // FIX: sgravata da più problemi che altro - // errors.add(new SemanticError("ValueError: different size of left or right side assignment")); + // FIX: sgravata da più problemi che altro + // errors.add(new SemanticError("ValueError: different size of left or right side assignment")); // } return errors; diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index fef72ec..47a15d7 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -30,7 +30,7 @@ public class AtomNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - var errors = new ArrayList(); + var errors = new ArrayList(); if (val != null) { if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) { diff --git a/src/ast/nodes/AugassignNode.java b/src/ast/nodes/AugassignNode.java index 629fbcd..7ced63e 100644 --- a/src/ast/nodes/AugassignNode.java +++ b/src/ast/nodes/AugassignNode.java @@ -12,7 +12,8 @@ import org.antlr.v4.runtime.tree.TerminalNode; * Node for the `augassign` statement of the grammar. */ public class AugassignNode implements Node { - private TerminalNode val; + + private final TerminalNode val; public AugassignNode(TerminalNode val) { this.val = val; @@ -20,7 +21,7 @@ public class AugassignNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - return new ArrayList(); + return new ArrayList(); } // FIXME: use the right type diff --git a/src/ast/nodes/BlockNode.java b/src/ast/nodes/BlockNode.java index a38b4ea..d9a151d 100644 --- a/src/ast/nodes/BlockNode.java +++ b/src/ast/nodes/BlockNode.java @@ -1,23 +1,22 @@ package ast.nodes; -import java.util.ArrayList; - import ast.types.*; +import java.util.ArrayList; import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; /** - * Node for `block` statement of the grammar. - * It extends the `RootNode`. + * Node for `block` statement of the grammar. It extends the `RootNode`. */ public class BlockNode extends RootNode { + public BlockNode(ArrayList childs) { super(childs); } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); // Check semantics for each child for (Node child : childs) { @@ -27,7 +26,6 @@ public class BlockNode extends RootNode { return errors; } - @Override public Type typeCheck() { return new VoidType(); diff --git a/src/ast/nodes/CompForNode.java b/src/ast/nodes/CompForNode.java index 06c7aee..b7c6924 100644 --- a/src/ast/nodes/CompForNode.java +++ b/src/ast/nodes/CompForNode.java @@ -23,7 +23,7 @@ public class CompForNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); errors.addAll(exprlist.checkSemantics(ST, _nesting)); errors.addAll(single_expr.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/CompIterNode.java b/src/ast/nodes/CompIterNode.java index 6704bd7..8de9f2f 100644 --- a/src/ast/nodes/CompIterNode.java +++ b/src/ast/nodes/CompIterNode.java @@ -19,7 +19,7 @@ public class CompIterNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); if (comp_for != null) { errors.addAll(comp_for.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/CompNode.java b/src/ast/nodes/CompNode.java index 8be6ea1..22906df 100644 --- a/src/ast/nodes/CompNode.java +++ b/src/ast/nodes/CompNode.java @@ -12,7 +12,7 @@ import org.antlr.v4.runtime.tree.TerminalNode; */ public class CompNode implements Node { - private TerminalNode op; + private final TerminalNode op; public CompNode(TerminalNode op) { this.op = op; @@ -20,7 +20,7 @@ public class CompNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - return new ArrayList(); + return new ArrayList(); } // TODO: it should be boolean, right? diff --git a/src/ast/nodes/CompoundNode.java b/src/ast/nodes/CompoundNode.java index d21c2c7..845f05e 100644 --- a/src/ast/nodes/CompoundNode.java +++ b/src/ast/nodes/CompoundNode.java @@ -10,10 +10,10 @@ import semanticanalysis.SymbolTable; */ public class CompoundNode implements Node { - private Node ifNode; - private Node funcDef; - private Node forStmt; - private Node whileStmt; + private final Node ifNode; + private final Node funcDef; + private final Node forStmt; + private final Node whileStmt; public CompoundNode(Node ifNode, Node funcDef, Node forStmt, Node whileStmt) { this.ifNode = ifNode; @@ -24,7 +24,7 @@ public class CompoundNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); if (ifNode != null) { errors.addAll(ifNode.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/DottedNameNode.java b/src/ast/nodes/DottedNameNode.java index df86c99..23f14c1 100644 --- a/src/ast/nodes/DottedNameNode.java +++ b/src/ast/nodes/DottedNameNode.java @@ -11,6 +11,7 @@ import org.antlr.v4.runtime.tree.TerminalNode; * Node for the `dooted_name` statement of the grammar. */ public class DottedNameNode implements Node { + protected ArrayList names; public DottedNameNode(ArrayList names) { @@ -19,7 +20,7 @@ public class DottedNameNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); for (int i = 0; i < names.size(); ++i) { ST.insert(names.get(i).toString(), this.typeCheck(), _nesting, null); diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 8e3b896..873d537 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -12,11 +12,11 @@ import semanticanalysis.SymbolTable; */ public class ExprNode implements Node { - private AtomNode atom; - private Node compOp; - private String op; - private ArrayList exprs; - private ArrayList trailers; + private final AtomNode atom; + private final Node compOp; + private final String op; + private final ArrayList exprs; + private final ArrayList trailers; public ExprNode(Node atom, Node compOp, ArrayList exprs, String op, ArrayList trailers) { this.atom = (AtomNode) atom; @@ -52,7 +52,7 @@ public class ExprNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); // check if the atom is a function if (atom != null && !trailers.isEmpty()) { diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java index d4c5e56..74c6ffc 100644 --- a/src/ast/nodes/ForStmtNode.java +++ b/src/ast/nodes/ForStmtNode.java @@ -10,8 +10,8 @@ import semanticanalysis.SymbolTable; */ public class ForStmtNode implements Node { - private Node exprList; - private Node block; + private final Node exprList; + private final Node block; public ForStmtNode(Node exprList, Node block) { this.exprList = exprList; @@ -34,7 +34,7 @@ public class ForStmtNode implements Node { */ @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); // Save every atom in the expression's list, except the last one var l = (ExprListNode) exprList; diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index 8985e08..c4f5846 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -14,9 +14,9 @@ import org.antlr.v4.runtime.tree.TerminalNode; */ public class FuncdefNode implements Node { - private TerminalNode name; - private Node paramlist; - private Node block; + private final TerminalNode name; + private final Node paramlist; + private final Node block; public FuncdefNode(TerminalNode name, Node paramlist, Node block) { this.name = name; @@ -26,14 +26,14 @@ public class FuncdefNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); int paramNumber = ((ParamlistNode) paramlist).getParamNumber(); Type returnType = this.block.typeCheck(); FunctionType ft = new FunctionType(paramNumber, returnType); ST.insert(this.name.toString(), ft, _nesting, ""); - HashMap HM = new HashMap(); + HashMap HM = new HashMap(); ST.add(HM); @@ -66,6 +66,7 @@ public class FuncdefNode implements Node { return ""; } + @Override public String toPrint(String prefix) { String str = prefix + "Funcdef(" + name + ")\n"; diff --git a/src/ast/nodes/IfNode.java b/src/ast/nodes/IfNode.java index f51d486..b0e1ddb 100644 --- a/src/ast/nodes/IfNode.java +++ b/src/ast/nodes/IfNode.java @@ -9,9 +9,10 @@ import semanticanalysis.SymbolTable; * Node for the `if` statement of the grammar. */ public class IfNode implements Node { - private Node guard; - private Node thenbranch; - private Node elsebranch; + + private final Node guard; + private final Node thenbranch; + private final Node elsebranch; public IfNode(Node guard, Node thenbranch, Node elsebranch) { this.guard = guard; @@ -21,7 +22,7 @@ public class IfNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); errors.addAll(guard.checkSemantics(ST, _nesting)); errors.addAll(thenbranch.checkSemantics(ST, _nesting)); @@ -38,9 +39,9 @@ public class IfNode implements Node { if (guard.typeCheck() instanceof BoolType) { Type thenexp = thenbranch.typeCheck(); Type elseexp = elsebranch.typeCheck(); - if (thenexp.getClass().equals(elseexp.getClass())) - return thenexp; - else { + if (thenexp.getClass().equals(elseexp.getClass())) { + return thenexp; + }else { System.out.println("Type Error: incompatible types in then and else branches."); return new ErrorType(); } diff --git a/src/ast/nodes/ImportNode.java b/src/ast/nodes/ImportNode.java index 900a909..7e95ee3 100644 --- a/src/ast/nodes/ImportNode.java +++ b/src/ast/nodes/ImportNode.java @@ -1,20 +1,20 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `import_stmt` statement of the grammar. */ public class ImportNode implements Node { - private Node dottedName; - private boolean isFrom; - private boolean importAs; - private boolean importAll; - private ArrayList names; + + private final Node dottedName; + private final boolean isFrom; + private final boolean importAs; + private final boolean importAll; + private final ArrayList names; public ImportNode(Node dottedName, boolean isFrom, boolean importAs, boolean importAll, ArrayList names) { @@ -27,7 +27,7 @@ public class ImportNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); if (isFrom) { for (int i = 0; i < names.size(); ++i) { @@ -75,8 +75,9 @@ public class ImportNode implements Node { } for (int i = 0; i < names.size(); ++i) { - if (i == 0 && importAs) + if (i == 0 && importAs) { continue; + } str += prefix + names.get(i) + "\n"; } diff --git a/src/ast/nodes/Node.java b/src/ast/nodes/Node.java index 77ba669..9fb58b8 100644 --- a/src/ast/nodes/Node.java +++ b/src/ast/nodes/Node.java @@ -1,10 +1,9 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Base interface for a Node. @@ -87,8 +86,7 @@ public interface Node { /** * Checks semantics for a given node for a SymbolTable ST and a level of - * nesting. - * Returns a list of `SemanticError`. + * nesting. Returns a list of `SemanticError`. */ ArrayList checkSemantics(SymbolTable ST, int _nesting); @@ -104,8 +102,8 @@ public interface Node { String codeGeneration(); /** - * Returns a string for a given node with a prefix. - * It used when an AST wants to be visualized on screen. + * Returns a string for a given node with a prefix. It used when an AST + * wants to be visualized on screen. */ String toPrint(String prefix); } diff --git a/src/ast/nodes/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java index adadf72..6cdb2d0 100644 --- a/src/ast/nodes/ParamdefNode.java +++ b/src/ast/nodes/ParamdefNode.java @@ -17,7 +17,7 @@ public class ParamdefNode extends AtomNode { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - var errors = new ArrayList(); + var errors = new ArrayList(); String paramName = this.getId(); if (!ST.top_lookup(paramName)) { diff --git a/src/ast/nodes/ParamlistNode.java b/src/ast/nodes/ParamlistNode.java index 0a9696f..cf75d08 100644 --- a/src/ast/nodes/ParamlistNode.java +++ b/src/ast/nodes/ParamlistNode.java @@ -1,17 +1,16 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `param_list` statement of the grammar. */ public class ParamlistNode implements Node { - private ArrayList params; + private final ArrayList params; public ParamlistNode(ArrayList _params) { params = _params; @@ -19,7 +18,7 @@ public class ParamlistNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); for (var param : params) { errors.addAll(param.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/ReturnStmtNode.java b/src/ast/nodes/ReturnStmtNode.java index 0f2dd74..8e34813 100644 --- a/src/ast/nodes/ReturnStmtNode.java +++ b/src/ast/nodes/ReturnStmtNode.java @@ -1,16 +1,16 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `return_stmt` statement of the grammar. */ public class ReturnStmtNode implements Node { - private Node exprList; + + private final Node exprList; public ReturnStmtNode(Node exprList) { this.exprList = exprList; @@ -18,7 +18,7 @@ public class ReturnStmtNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); if (this.exprList != null) { errors.addAll(this.exprList.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java index 4b29e8d..5bbce8c 100644 --- a/src/ast/nodes/RootNode.java +++ b/src/ast/nodes/RootNode.java @@ -20,10 +20,10 @@ public class RootNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); // Create a new HashMap for the current scope - HashMap HM = new HashMap(); + HashMap HM = new HashMap(); // Add the HashMap to the SymbolTable ST.add(HM); diff --git a/src/ast/nodes/SimpleStmtNode.java b/src/ast/nodes/SimpleStmtNode.java index b7e5455..b2bc880 100644 --- a/src/ast/nodes/SimpleStmtNode.java +++ b/src/ast/nodes/SimpleStmtNode.java @@ -9,10 +9,11 @@ import semanticanalysis.SymbolTable; * Node for the `simple_stmt` statement of the grammar. */ public class SimpleStmtNode implements Node { - private Node assignment; - private Node expr; - private Node returnStmt; - private Node importStmt; + + private final Node assignment; + private final Node expr; + private final Node returnStmt; + private final Node importStmt; public SimpleStmtNode(Node assignment, Node expr, Node returnStmt, Node importStmt) { this.assignment = assignment; @@ -23,7 +24,7 @@ public class SimpleStmtNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); if (assignment != null) { errors.addAll(assignment.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/SimpleStmtsNode.java b/src/ast/nodes/SimpleStmtsNode.java index 97bffff..ae1044b 100644 --- a/src/ast/nodes/SimpleStmtsNode.java +++ b/src/ast/nodes/SimpleStmtsNode.java @@ -9,7 +9,8 @@ import semanticanalysis.SymbolTable; * Node for the `simple_stmts` statement of the grammar. */ public class SimpleStmtsNode implements Node { - private ArrayList stmts; + + private final ArrayList stmts; public SimpleStmtsNode(ArrayList stmts) { this.stmts = stmts; @@ -17,7 +18,7 @@ public class SimpleStmtsNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); for (Node stmt : stmts) { errors.addAll(stmt.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java index cba056c..32049f5 100644 --- a/src/ast/nodes/TestlistCompNode.java +++ b/src/ast/nodes/TestlistCompNode.java @@ -10,8 +10,8 @@ import semanticanalysis.SymbolTable; */ public class TestlistCompNode implements Node { - private ArrayList exprs; - private CompForNode comp; + private final ArrayList exprs; + private final CompForNode comp; public TestlistCompNode(ArrayList exprs, Node comp) { this.exprs = exprs; diff --git a/src/ast/nodes/TrailerNode.java b/src/ast/nodes/TrailerNode.java index 22e43a0..aaa72f3 100644 --- a/src/ast/nodes/TrailerNode.java +++ b/src/ast/nodes/TrailerNode.java @@ -12,11 +12,11 @@ import org.antlr.v4.runtime.tree.TerminalNode; */ public class TrailerNode implements Node { - private Node arglist; - private ArrayList exprs; - private TerminalNode methodCall; - private boolean isParenthesis; - private boolean isEmpty; + private final Node arglist; + private final ArrayList exprs; + private final TerminalNode methodCall; + private final boolean isParenthesis; + private final boolean isEmpty; public TrailerNode(Node arglist, ArrayList exprs, TerminalNode methodCall, boolean isParenthesis) { this.arglist = arglist; @@ -24,12 +24,12 @@ public class TrailerNode implements Node { this.methodCall = methodCall; this.isParenthesis = isParenthesis; - this.isEmpty = (this.arglist == null && this.exprs.size() == 0 && this.methodCall == null); + this.isEmpty = (this.arglist == null && this.exprs.isEmpty() && this.methodCall == null); } @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); if (arglist != null) { errors.addAll(arglist.checkSemantics(ST, _nesting)); diff --git a/src/ast/nodes/WhileStmtNode.java b/src/ast/nodes/WhileStmtNode.java index 6353ec1..1db01ea 100644 --- a/src/ast/nodes/WhileStmtNode.java +++ b/src/ast/nodes/WhileStmtNode.java @@ -1,17 +1,17 @@ package ast.nodes; +import ast.types.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.types.*; /** * Node for the `while_stmt` statement of the grammar. */ public class WhileStmtNode implements Node { - private Node expr; - private Node block; + + private final Node expr; + private final Node block; public WhileStmtNode(Node expr, Node block) { this.expr = expr; @@ -20,7 +20,7 @@ public class WhileStmtNode implements Node { @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { - ArrayList errors = new ArrayList(); + ArrayList errors = new ArrayList(); errors.addAll(expr.checkSemantics(ST, _nesting)); errors.addAll(block.checkSemantics(ST, _nesting)); diff --git a/src/ast/types/AtomType.java b/src/ast/types/AtomType.java index 0387ec1..fc1c69e 100644 --- a/src/ast/types/AtomType.java +++ b/src/ast/types/AtomType.java @@ -2,9 +2,10 @@ package ast.types; /** * An tom type. - * TODO: do I need to use this one? */ public class AtomType extends Type { + + @Override public String toPrint(String prefix) { return prefix + "Atom\n"; } diff --git a/src/ast/types/BoolType.java b/src/ast/types/BoolType.java index 20c2750..01e2cd5 100644 --- a/src/ast/types/BoolType.java +++ b/src/ast/types/BoolType.java @@ -4,6 +4,8 @@ package ast.types; * A boolean type. A bool is True or False. */ public class BoolType extends Type { + + @Override public String toPrint(String prefix) { return prefix + "Bool\n"; } diff --git a/src/ast/types/ErrorType.java b/src/ast/types/ErrorType.java index 4a7a0cf..71176d1 100644 --- a/src/ast/types/ErrorType.java +++ b/src/ast/types/ErrorType.java @@ -4,6 +4,8 @@ package ast.types; * Error type. */ public class ErrorType extends Type { + + @Override public String toPrint(String prefix) { return prefix + "Error\n"; } diff --git a/src/ast/types/FunctionType.java b/src/ast/types/FunctionType.java index ef50641..5e6adaa 100644 --- a/src/ast/types/FunctionType.java +++ b/src/ast/types/FunctionType.java @@ -5,8 +5,8 @@ package ast.types; */ public class FunctionType extends Type { - private int paramNumber; - private Type returnType; + private final int paramNumber; + private final Type returnType; public FunctionType(int paramNumber, Type returnType) { this.paramNumber = paramNumber; @@ -22,6 +22,7 @@ public class FunctionType extends Type { return returnType; } + @Override public String toPrint(String prefix) { return prefix + "Function\n"; } diff --git a/src/ast/types/ImportType.java b/src/ast/types/ImportType.java index 6852bfa..892de10 100644 --- a/src/ast/types/ImportType.java +++ b/src/ast/types/ImportType.java @@ -4,8 +4,9 @@ package ast.types; * A type for the imported names. */ public class ImportType extends Type { + + @Override public String toPrint(String prefix) { return prefix + "Import\n"; } } - diff --git a/src/ast/types/IntType.java b/src/ast/types/IntType.java index a29518b..6483d93 100644 --- a/src/ast/types/IntType.java +++ b/src/ast/types/IntType.java @@ -4,6 +4,8 @@ package ast.types; * An integer type. */ public class IntType extends Type { + + @Override public String toPrint(String prefix) { return prefix + "Int\n"; } diff --git a/src/ast/types/NoneType.java b/src/ast/types/NoneType.java index 42f7fd7..730add9 100644 --- a/src/ast/types/NoneType.java +++ b/src/ast/types/NoneType.java @@ -5,6 +5,7 @@ package ast.types; */ public class NoneType extends Type { + @Override public String toPrint(String prefix) { return prefix + "None\n"; } diff --git a/src/ast/types/ReservedWordsType.java b/src/ast/types/ReservedWordsType.java index f5f7ac5..da72890 100644 --- a/src/ast/types/ReservedWordsType.java +++ b/src/ast/types/ReservedWordsType.java @@ -4,6 +4,8 @@ package ast.types; * A type for the continue and break statements. */ public class ReservedWordsType extends Type { + + @Override public String toPrint(String prefix) { return prefix + "ReservedWords\n"; } diff --git a/src/ast/types/Type.java b/src/ast/types/Type.java index 6bff8b9..6190106 100644 --- a/src/ast/types/Type.java +++ b/src/ast/types/Type.java @@ -1,26 +1,25 @@ package ast.types; +import ast.nodes.*; import java.util.ArrayList; - import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; -import ast.nodes.*; /** * A node which represents a type class. */ public class Type implements Node { + public boolean isEqual(Type A, Type B) { - if (A.getClass().equals(B.getClass())) - return true; - else - return false; + return A.getClass().equals(B.getClass()); } + @Override public String toPrint(String s) { return s; } + @Override public ArrayList checkSemantics(SymbolTable ST, int _nesting) { // It is never invoked return null; diff --git a/src/ast/types/VoidType.java b/src/ast/types/VoidType.java index 8e3f9b2..2d21da6 100644 --- a/src/ast/types/VoidType.java +++ b/src/ast/types/VoidType.java @@ -5,6 +5,7 @@ package ast.types; */ public class VoidType extends Type { + @Override public String toPrint(String prefix) { return prefix + "Void\n"; } diff --git a/src/semanticanalysis/STentry.java b/src/semanticanalysis/STentry.java index 07b62c8..51fb109 100644 --- a/src/semanticanalysis/STentry.java +++ b/src/semanticanalysis/STentry.java @@ -6,9 +6,10 @@ import ast.types.Type; * Entry class for the symbol table. */ public class STentry { - private Type type; - private int offset; - private int nesting; + + private final Type type; + private final int offset; + private final int nesting; private String label; public STentry(Type type, int offset, int nesting) { diff --git a/src/semanticanalysis/SemanticError.java b/src/semanticanalysis/SemanticError.java index 745e3fb..ac2dc4c 100644 --- a/src/semanticanalysis/SemanticError.java +++ b/src/semanticanalysis/SemanticError.java @@ -4,12 +4,14 @@ package semanticanalysis; * Class respresents a semantic error. */ public class SemanticError { - private String msg; + + private final String msg; public SemanticError(String msg) { this.msg = msg; } + @Override public String toString() { return msg; } diff --git a/src/semanticanalysis/Share.java b/src/semanticanalysis/Share.java index c98fc53..7542cf7 100644 --- a/src/semanticanalysis/Share.java +++ b/src/semanticanalysis/Share.java @@ -1,7 +1,7 @@ package semanticanalysis; -import java.util.*; import java.io.*; +import java.util.*; public class Share { @@ -10,7 +10,7 @@ public class Share { * generic because it's used a custom contains function. */ public static ArrayList removeDuplicates(ArrayList list) { - ArrayList newList = new ArrayList(); + ArrayList newList = new ArrayList(); for (SemanticError element : list) { if (!customContains(newList, element)) { diff --git a/src/semanticanalysis/SymbolTable.java b/src/semanticanalysis/SymbolTable.java index db9649c..b620af7 100644 --- a/src/semanticanalysis/SymbolTable.java +++ b/src/semanticanalysis/SymbolTable.java @@ -1,8 +1,8 @@ package semanticanalysis; +import ast.types.*; import java.util.ArrayList; import java.util.HashMap; -import ast.types.*; /** * Class representing a symbol table. It's a list of hash table symbol table. We @@ -11,12 +11,12 @@ import ast.types.*; */ public class SymbolTable { - private ArrayList> symbolTable; - private ArrayList offset; + private final ArrayList> symbolTable; + private final ArrayList offset; public SymbolTable() { - this.symbolTable = new ArrayList>(); - this.offset = new ArrayList(); + this.symbolTable = new ArrayList(); + this.offset = new ArrayList(); } /** @@ -96,7 +96,7 @@ public class SymbolTable { */ public boolean top_lookup(String id) { int n = symbolTable.size() - 1; - STentry T = null; + STentry T; HashMap H = symbolTable.get(n); T = H.get(id); return (T != null); @@ -125,14 +125,6 @@ public class SymbolTable { // We always increment the offset by 1 otherwise we need ad-hoc bytecode // operations - // FIXME: wtf is that? - // if (type.getClass().equals((new BoolType()).getClass())) { - // offs = offs + 1; - // } else if (type.getClass().equals((new IntType()).getClass())) { - // offs = offs + 1; - // } else { - // offs = offs + 1; - // } offs = offs + 1; this.offset.add(offs); -- cgit v1.2.3-18-g5258 From 06d7c8dee25c065b1a569337f34d3cd5e892a31d Mon Sep 17 00:00:00 2001 From: geno Date: Sun, 30 Jun 2024 13:43:46 +0200 Subject: fix build error in CI --- src/ast/nodes/ArglistNode.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index 55a568d..425e4c6 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -22,7 +22,8 @@ public class ArglistNode implements Node { ArrayList errors = new ArrayList(); for (var arg : arguments) { - if (arg instanceof ExprNode argExpr) { + if (arg instanceof ExprNode) { + ExprNode argExpr = (ExprNode) arg; String argName = argExpr.getId(); // TODO: check fucking IntType for params -- cgit v1.2.3-18-g5258