summaryrefslogtreecommitdiff
path: root/src/ast/nodes
diff options
context:
space:
mode:
Diffstat (limited to 'src/ast/nodes')
-rw-r--r--src/ast/nodes/ArglistNode.java29
-rw-r--r--src/ast/nodes/AssignmentNode.java16
-rw-r--r--src/ast/nodes/AtomNode.java43
-rw-r--r--src/ast/nodes/BlockNode.java26
-rw-r--r--src/ast/nodes/CompNode.java1
-rw-r--r--src/ast/nodes/CompoundNode.java4
-rw-r--r--src/ast/nodes/DottedNameNode.java6
-rw-r--r--src/ast/nodes/ExprNode.java66
-rw-r--r--src/ast/nodes/ForStmtNode.java4
-rw-r--r--src/ast/nodes/FuncdefNode.java24
-rw-r--r--src/ast/nodes/IfNode.java7
-rw-r--r--src/ast/nodes/ImportNode.java14
-rw-r--r--src/ast/nodes/Node.java75
-rw-r--r--src/ast/nodes/ParamdefNode.java18
-rw-r--r--src/ast/nodes/ParamlistNode.java5
-rw-r--r--src/ast/nodes/RootNode.java40
-rw-r--r--src/ast/nodes/SimpleStmtNode.java3
-rw-r--r--src/ast/nodes/SimpleStmtsNode.java3
-rw-r--r--src/ast/nodes/TrailerNode.java17
19 files changed, 338 insertions, 63 deletions
diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java
index f0c33e1..78b4ca7 100644
--- a/src/ast/nodes/ArglistNode.java
+++ b/src/ast/nodes/ArglistNode.java
@@ -1,15 +1,17 @@
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 `arglist` statement of the grammar.
*/
public class ArglistNode implements Node {
+
protected ArrayList<Node> arguments;
public ArglistNode(ArrayList<Node> arguments) {
@@ -21,12 +23,35 @@ public class ArglistNode implements Node {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
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 (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));
+ }
}
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 627e842..3d597ef 100644
--- a/src/ast/nodes/AssignmentNode.java
+++ b/src/ast/nodes/AssignmentNode.java
@@ -1,33 +1,35 @@
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 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<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
- 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..ceafc07 100644
--- a/src/ast/nodes/AtomNode.java
+++ b/src/ast/nodes/AtomNode.java
@@ -1,30 +1,63 @@
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) {
this.val = val;
}
+ public String getId() {
+ return this.val;
+ }
+
@Override
public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
- return new ArrayList<SemanticError>();
+ var errors = new ArrayList<SemanticError>();
+
+ if ((this.typeCheck() instanceof AtomType) && ST.nslookup(this.getId()) < 0) {
+ errors.add(new SemanticError("'" + this.getId() + "' is not defined."));
+ }
+
+ return errors;
}
- // FIXME: this type for atom
+ // ENHANCE: return more specific types
@Override
public Type typeCheck() {
- return new AtomType();
+ 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 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 {
+ return new VoidType(); // could be any type of data
+ }
}
// TODO: add code generation for atom node
diff --git a/src/ast/nodes/BlockNode.java b/src/ast/nodes/BlockNode.java
index 6b07f49..a38b4ea 100644
--- a/src/ast/nodes/BlockNode.java
+++ b/src/ast/nodes/BlockNode.java
@@ -3,17 +3,32 @@ package ast.nodes;
import java.util.ArrayList;
import ast.types.*;
+import semanticanalysis.SemanticError;
+import semanticanalysis.SymbolTable;
/**
* Node for `block` statement of the grammar.
* It extends the `RootNode`.
*/
public class BlockNode extends RootNode {
- public BlockNode(ArrayList<Node> stmts, ArrayList<Node> compoundStmts) {
- super(stmts, compoundStmts);
+ public BlockNode(ArrayList<Node> childs) {
+ super(childs);
}
@Override
+ public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+ ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+ // Check semantics for each child
+ for (Node child : childs) {
+ errors.addAll(child.checkSemantics(ST, _nesting));
+ }
+
+ return errors;
+ }
+
+
+ @Override
public Type typeCheck() {
return new VoidType();
}
@@ -23,11 +38,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/CompNode.java b/src/ast/nodes/CompNode.java
index 33976bf..8be6ea1 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) {
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/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<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+ 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 25c2016..1b20e2e 100644
--- a/src/ast/nodes/ExprNode.java
+++ b/src/ast/nodes/ExprNode.java
@@ -1,34 +1,84 @@
package ast.nodes;
+import ast.types.*;
import java.util.ArrayList;
+import java.util.Arrays;
+import semanticanalysis.STentry;
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<Node> exprs;
private ArrayList<Node> trailers;
public ExprNode(Node atom, Node compOp, ArrayList<Node> exprs, String op, ArrayList<Node> trailers) {
- this.atom = atom;
+ this.atom = (AtomNode) atom;
this.compOp = compOp;
this.exprs = exprs;
this.op = op;
this.trailers = trailers;
}
+ public String getId() {
+ if (atom != null) {
+ return ((AtomNode) this.atom).getId();
+ } else {
+ return null;
+ }
+ }
+
@Override
public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
- if (atom != null) {
+ // check if the atom is a built-in function
+ if (atom != null && !trailers.isEmpty()) {
+
+ 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()) {
+ 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 {
+ for (var trailer : trailers) {
+ errors.addAll(trailer.checkSemantics(ST, _nesting));
+ }
+ }
+ } else if (atom != null) {
errors.addAll(atom.checkSemantics(ST, _nesting));
}
@@ -40,16 +90,16 @@ public class ExprNode implements Node {
errors.addAll(expr.checkSemantics(ST, _nesting));
}
- for (var trailer : trailers) {
- errors.addAll(trailer.checkSemantics(ST, _nesting));
- }
-
return errors;
}
// 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/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<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+ 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/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java
index 67bc772..8985e08 100644
--- a/src/ast/nodes/FuncdefNode.java
+++ b/src/ast/nodes/FuncdefNode.java
@@ -1,7 +1,9 @@
package ast.nodes;
import java.util.ArrayList;
+import java.util.HashMap;
+import semanticanalysis.STentry;
import semanticanalysis.SemanticError;
import semanticanalysis.SymbolTable;
import ast.types.*;
@@ -11,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;
@@ -24,12 +27,29 @@ public class FuncdefNode implements Node {
@Override
public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+ int paramNumber = ((ParamlistNode) paramlist).getParamNumber();
+ Type returnType = this.block.typeCheck();
+ FunctionType ft = new FunctionType(paramNumber, returnType);
+
+ ST.insert(this.name.toString(), ft, _nesting, "");
+
+ HashMap<String, STentry> HM = new HashMap<String, STentry>();
+
+ ST.add(HM);
+
+ ST.insert(this.name.toString(), ft, _nesting + 1, "");
if (paramlist != null) {
- errors.addAll(paramlist.checkSemantics(ST, _nesting));
+ errors.addAll(paramlist.checkSemantics(ST, _nesting + 1));
}
- errors.addAll(block.checkSemantics(ST, _nesting));
+ // TODO: think to the fucking offset
+ // Offset is increased for the possible return value
+ ST.increaseoffset();
+
+ errors.addAll(block.checkSemantics(ST, _nesting + 1));
+
+ ST.remove();
return errors;
}
diff --git a/src/ast/nodes/IfNode.java b/src/ast/nodes/IfNode.java
index 50dde4a..f51d486 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.
@@ -42,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<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+ 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/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java
index 481282e..5164537 100644
--- a/src/ast/nodes/ParamdefNode.java
+++ b/src/ast/nodes/ParamdefNode.java
@@ -1,16 +1,34 @@
package ast.nodes;
import ast.types.*;
+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<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+ var errors = new ArrayList<SemanticError>();
+ 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 errors;
+ }
+
// 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..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<Node> params;
public ParamlistNode(ArrayList<Node> _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/RootNode.java b/src/ast/nodes/RootNode.java
index e0989e8..4b29e8d 100644
--- a/src/ast/nodes/RootNode.java
+++ b/src/ast/nodes/RootNode.java
@@ -1,36 +1,41 @@
package ast.nodes;
-import java.util.ArrayList;
-
-import semanticanalysis.SemanticError;
-import semanticanalysis.SymbolTable;
import ast.types.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import semanticanalysis.*;
/**
* 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<Node> stmts;
- protected ArrayList<Node> compoundStmts;
+ protected ArrayList<Node> childs;
- public RootNode(ArrayList<Node> stmts, ArrayList<Node> compoundStmts) {
- this.stmts = stmts;
- this.compoundStmts = compoundStmts;
+ public RootNode(ArrayList<Node> childs) {
+ this.childs = childs;
}
@Override
public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
- for (Node stmt : stmts) {
- errors.addAll(stmt.checkSemantics(ST, _nesting));
- }
- for (Node stmt : compoundStmts) {
- errors.addAll(stmt.checkSemantics(ST, _nesting));
+ // Create a new HashMap for the current scope
+ HashMap<String, STentry> HM = new HashMap<String, STentry>();
+
+ // Add the HashMap to the SymbolTable
+ ST.add(HM);
+
+ // 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;
}
@@ -51,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;
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..22e43a0 100644
--- a/src/ast/nodes/TrailerNode.java
+++ b/src/ast/nodes/TrailerNode.java
@@ -11,15 +11,18 @@ 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<Node> exprs;
private TerminalNode methodCall;
+ private boolean isParenthesis;
private boolean isEmpty;
- public TrailerNode(Node arglist, ArrayList<Node> exprs, TerminalNode methodCall) {
+ public TrailerNode(Node arglist, ArrayList<Node> 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);
}
@@ -39,6 +42,18 @@ public class TrailerNode implements Node {
return errors;
}
+ 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();
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-04-06 20:11:28 +0000