diff options
Diffstat (limited to 'src/ast/nodes')
26 files changed, 532 insertions, 101 deletions
diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java index 5da7e2c..4b7b292 100644 --- a/src/ast/nodes/ArglistNode.java +++ b/src/ast/nodes/ArglistNode.java @@ -1,6 +1,7 @@ package ast.nodes; import ast.types.*; + import java.util.ArrayList; import java.util.Arrays; import semanticanalysis.SemanticError; @@ -27,7 +28,6 @@ public class ArglistNode implements Node { String argName = argExpr.getId(); errors.addAll(arg.checkSemantics(ST, _nesting, ft)); - // TODO: check IntType for params if (argName != null) { if (Arrays.asList(bif).contains(argName)) { continue; @@ -66,12 +66,26 @@ public class ArglistNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "ArglistNode\n"; prefix += " "; for (Node arg : arguments) { - str += arg.toPrint(prefix); + str += arg.printAST(prefix); + } + + return str; + } + + @Override + public String toPrint(String prefix) { + String str = prefix; + str += arguments.get(0).toPrint(""); + + if (arguments.size() > 1) { + for (int i = 1; i < arguments.size(); i++) { + str += ", " + arguments.get(i).toPrint(""); + } } return str; diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java index 13e7a33..688be76 100644 --- a/src/ast/nodes/AssignmentNode.java +++ b/src/ast/nodes/AssignmentNode.java @@ -16,15 +16,20 @@ public class AssignmentNode implements Node { private final Node assign; private final ExprListNode rhr; + private final int startIndex; + private final int endIndex; + // Useful for code gen private int offset; private boolean alreadyDef; - public AssignmentNode(Node lhr, Node assign, Node rhr) { + public AssignmentNode(Node lhr, Node assign, Node rhr, int startIndex, int endIndex) { this.lhr = (ExprListNode) lhr; this.assign = assign; this.rhr = (ExprListNode) rhr; this.alreadyDef = false; + this.startIndex = startIndex; + this.endIndex = endIndex; } @Override @@ -42,11 +47,10 @@ public class AssignmentNode implements Node { STentry e = ST.lookup(leftAtom.getId()); if (ft != null) { ft.addLocalVar(); - } else { - Label.addGlobalVar(); } if (e == null) { + Label.addGlobalVar(); ST.insert(leftAtom.getId(), new AtomType(), _nesting, ""); e = ST.lookup(leftAtom.getId()); } else { @@ -58,9 +62,9 @@ public class AssignmentNode implements Node { offset = e.getOffset(); } return errors; + } - // TODO: check it out for this type @Override public Type typeCheck() { return rhr.typeCheck(); @@ -92,9 +96,31 @@ public class AssignmentNode implements Node { } @Override + public String printAST(String prefix) { + return prefix + "Assignment\n" + lhr.printAST(prefix + " ") + assign.printAST(prefix + " ") + + rhr.printAST(prefix + " "); + } + + @Override public String toPrint(String prefix) { - return prefix + "Assignment\n" + lhr.toPrint(prefix + " ") + assign.toPrint(prefix + " ") - + rhr.toPrint(prefix + " "); + String str = prefix; + str += lhr.toPrint("") + " " + assign.toPrint("") + " " + rhr.toPrint(""); + return str; } + public ExprListNode getLhr() { + return lhr; + } + + public ExprListNode getRhr() { + return rhr; + } + + public int getLhrIndex() { + return this.startIndex; + } + + public int getRhrIndex() { + return this.endIndex; + } } diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java index ea99808..204c3b3 100644 --- a/src/ast/nodes/AtomNode.java +++ b/src/ast/nodes/AtomNode.java @@ -13,6 +13,8 @@ import semanticanalysis.SymbolTable; */ public class AtomNode implements Node { + private String prefix; + private String suffix; protected String val; protected TestlistCompNode exprlist; @@ -21,8 +23,14 @@ public class AtomNode implements Node { protected int offset; public AtomNode(String val, Node exprlist) { + this(val, exprlist, "", ""); + } + + public AtomNode(String val, Node exprlist, String prefix, String suffix) { this.val = val; this.exprlist = (TestlistCompNode) exprlist; + this.prefix = prefix; + this.suffix = suffix; } /** @@ -33,6 +41,10 @@ public class AtomNode implements Node { return val; } + public void setId(String id) { + this.val = id; + } + @Override public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting, FunctionType ft) { ArrayList<SemanticError> errors = new ArrayList<>(); @@ -134,13 +146,25 @@ public class AtomNode implements Node { } @Override - public String toPrint(String prefix) { - // FIXME: can be a testlist_comp with two expr and two atoms + public String printAST(String prefix) { if (val != null) { - return prefix + "Atom(" + val + ")\n"; + return prefix + "AtomNode: " + val + "\n"; + } else { + return prefix + "AtomNode\n" + exprlist.printAST(prefix + " "); } + } - return prefix + "Atom(null)\n"; + @Override + public String toPrint(String prefix) { + String str = prefix + this.prefix; + + if (val != null) { + str += val; + } else { + str += this.exprlist.toPrint(""); + } + str += this.suffix; + return str; } } diff --git a/src/ast/nodes/AugassignNode.java b/src/ast/nodes/AugassignNode.java index 906dcd7..8b07c67 100644 --- a/src/ast/nodes/AugassignNode.java +++ b/src/ast/nodes/AugassignNode.java @@ -36,7 +36,13 @@ public class AugassignNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { return prefix + "Augassign(" + val + ")\n"; } + + @Override + public String toPrint(String prefix) { + String str = prefix + val.toString(); + return str; + } } diff --git a/src/ast/nodes/BlockNode.java b/src/ast/nodes/BlockNode.java index 2ea0a47..86a0db6 100644 --- a/src/ast/nodes/BlockNode.java +++ b/src/ast/nodes/BlockNode.java @@ -43,15 +43,25 @@ public class BlockNode extends RootNode { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "Block\n"; prefix += " "; for (Node child : childs) { - str += child.toPrint(prefix); + str += child.printAST(prefix); } return str; } + @Override + public String toPrint(String prefix) { + String str = ""; + + for (Node child : childs) { + str += child.toPrint(prefix); + } + + return str; + } } diff --git a/src/ast/nodes/CompForNode.java b/src/ast/nodes/CompForNode.java index 1f51af5..df86a74 100644 --- a/src/ast/nodes/CompForNode.java +++ b/src/ast/nodes/CompForNode.java @@ -12,12 +12,12 @@ import semanticanalysis.SymbolTable; public class CompForNode implements Node { protected ExprListNode exprlist; - protected ExprNode single_expr; + protected ExprNode expr; protected CompIterNode comp_iter; - public CompForNode(Node exprlist, Node single_expr, Node comp_iter) { + public CompForNode(Node exprlist, Node expr, Node comp_iter) { this.exprlist = (ExprListNode) exprlist; - this.single_expr = (ExprNode) single_expr; + this.expr = (ExprNode) expr; this.comp_iter = (CompIterNode) comp_iter; } @@ -26,7 +26,7 @@ public class CompForNode implements Node { ArrayList<SemanticError> errors = new ArrayList<>(); errors.addAll(exprlist.checkSemantics(ST, _nesting, ft)); - errors.addAll(single_expr.checkSemantics(ST, _nesting, ft)); + errors.addAll(expr.checkSemantics(ST, _nesting, ft)); if (comp_iter != null) { errors.addAll(comp_iter.checkSemantics(ST, _nesting, ft)); } @@ -47,13 +47,27 @@ public class CompForNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "CompForNode\n"; prefix += " "; - str += exprlist.toPrint(prefix); - str += single_expr.toPrint(prefix); - str += comp_iter.toPrint(prefix); + str += exprlist.printAST(prefix); + str += expr.printAST(prefix); + str += comp_iter.printAST(prefix); + return str; + } + + @Override + public String toPrint(String prefix) { + String str = prefix + "for"; + + for (int i = 0; i < exprlist.getExprs().size(); i++) { + str += exprlist.getExprs().get(i).toPrint(""); + } + + str += " in " + expr.toPrint("") + "\n"; + str += comp_iter.toPrint(prefix + "\t"); + return str; } diff --git a/src/ast/nodes/CompIterNode.java b/src/ast/nodes/CompIterNode.java index de443fa..4f09ec5 100644 --- a/src/ast/nodes/CompIterNode.java +++ b/src/ast/nodes/CompIterNode.java @@ -40,10 +40,17 @@ public class CompIterNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "CompIterNode\n"; prefix += " "; + str += comp_for.printAST(prefix); + return str; + } + + @Override + public String toPrint(String prefix) { + String str = ""; str += comp_for.toPrint(prefix); return str; } diff --git a/src/ast/nodes/CompOpNode.java b/src/ast/nodes/CompOpNode.java index 7997052..761a49c 100644 --- a/src/ast/nodes/CompOpNode.java +++ b/src/ast/nodes/CompOpNode.java @@ -27,7 +27,6 @@ public class CompOpNode implements Node { return new ArrayList<>(); } - // TODO: it should be boolean, right? @Override public Type typeCheck() { return new VoidType(); @@ -42,7 +41,12 @@ public class CompOpNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { return prefix + "CompOpNode(" + op + ")\n"; } + + @Override + public String toPrint(String prefix) { + return prefix + op; + } } diff --git a/src/ast/nodes/CompoundNode.java b/src/ast/nodes/CompoundNode.java index f0f63f2..ad3420d 100644 --- a/src/ast/nodes/CompoundNode.java +++ b/src/ast/nodes/CompoundNode.java @@ -22,6 +22,7 @@ public class CompoundNode implements Node { this.whileStmt = whileStmt; } + @Override public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting, FunctionType ft) { ArrayList<SemanticError> errors = new ArrayList<>(); @@ -72,12 +73,35 @@ public class CompoundNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "CompoundNode\n"; prefix += " "; if (ifNode != null) { + str += ifNode.printAST(prefix); + } + + if (funcDef != null) { + str += funcDef.printAST(prefix); + } + + if (forStmt != null) { + str += forStmt.printAST(prefix); + } + + if (whileStmt != null) { + str += whileStmt.printAST(prefix); + } + + return str; + } + + @Override + public String toPrint(String prefix) { + String str = ""; + + if (ifNode != null) { str += ifNode.toPrint(prefix); } @@ -94,6 +118,22 @@ public class CompoundNode implements Node { } return str; + } + public Node getForStmt() { + return forStmt; + } + + public Node getFuncDef() { + return funcDef; + } + + public Node getIfNode() { + return ifNode; + } + + public Node getWhileStmt() { + return whileStmt; + } } diff --git a/src/ast/nodes/DottedNameNode.java b/src/ast/nodes/DottedNameNode.java index 827945a..ce00c00 100644 --- a/src/ast/nodes/DottedNameNode.java +++ b/src/ast/nodes/DottedNameNode.java @@ -44,7 +44,7 @@ public class DottedNameNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "DottedName\n"; prefix += " "; @@ -55,4 +55,15 @@ public class DottedNameNode implements Node { return str; } + @Override + public String toPrint(String prefix) { + String str = prefix + names.get(0); + + for (int i = 1; i < names.size(); ++i) { + str += "." + names.get(i); + } + + return str; + } + } diff --git a/src/ast/nodes/ExprListNode.java b/src/ast/nodes/ExprListNode.java index a3ac237..44feb6b 100644 --- a/src/ast/nodes/ExprListNode.java +++ b/src/ast/nodes/ExprListNode.java @@ -2,6 +2,8 @@ package ast.nodes; import ast.types.*; import java.util.ArrayList; +import java.util.List; + import semanticanalysis.SemanticError; import semanticanalysis.SymbolTable; @@ -10,9 +12,9 @@ import semanticanalysis.SymbolTable; */ public class ExprListNode implements Node { - private final ArrayList<Node> exprs; + private final List<Node> exprs; - public ExprListNode(ArrayList<Node> exprs) { + public ExprListNode(List<Node> exprs) { this.exprs = exprs; } @@ -59,15 +61,31 @@ public class ExprListNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "ExprList\n"; prefix += " "; for (var param : exprs) { - str += param.toPrint(prefix); + str += param.printAST(prefix); } return str; } + @Override + public String toPrint(String prefix) { + + String str = prefix + exprs.get(0).toPrint(""); + + for (int i = 1; i < exprs.size(); ++i) { + str += ", " + exprs.get(i).toPrint(""); + } + + return str; + } + + public List<Node> getExprs() { + return exprs; + } + } diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java index 3d05eea..a750768 100644 --- a/src/ast/nodes/ExprNode.java +++ b/src/ast/nodes/ExprNode.java @@ -43,6 +43,10 @@ public class ExprNode implements Node { return this.exprs.get(i); } + public void setExpr(int i, Node expr) { + this.exprs.set(i, expr); + } + /** * Returns the identifier of the `AtomNode` if it's not `null`, otherwise * returns `null`. @@ -55,6 +59,26 @@ public class ExprNode implements Node { } } + public Node getCompOp() { + return compOp; + } + + public String getOp() { + return op; + } + + public ArrayList<Node> getTrailers() { + return trailers; + } + + public ArrayList<Node> getExprs() { + return exprs; + } + + public AtomNode getAtom() { + return atom; + } + @Override public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting, FunctionType ft) { ArrayList<SemanticError> errors = new ArrayList<>(); @@ -69,7 +93,6 @@ public class ExprNode implements Node { 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)) { @@ -108,7 +131,6 @@ public class ExprNode implements Node { return errors; } - // FIXME: type for the expr @Override public Type typeCheck() { if (this.atom != null) { @@ -156,8 +178,8 @@ public class ExprNode implements Node { case "+": case "-": case "*": - // In real Python `/` is a float division but we'll consider the - // int division here below. + // In real Python `/` is a float division but we'll consider the + // int division here below. case "/": return intOpCodeGen(exprs.get(0), exprs.get(1), op); case "%": @@ -211,31 +233,55 @@ public class ExprNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "Expr\n"; prefix += " "; if (atom != null) { - str += atom.toPrint(prefix); - } - if (compOp != null) { - str += compOp.toPrint(prefix); - } + str += atom.printAST(prefix); - if (exprs != null) { - for (var expr : exprs) { - str += expr.toPrint(prefix); + for (var trailer : trailers) { + str += trailer.printAST(prefix); + } + } else { + if (compOp != null) { + str += compOp.printAST(prefix); } - } - if (trailers != null) { - for (var trailer : trailers) { - str += trailer.toPrint(prefix); + if (exprs != null) { + for (var expr : exprs) { + str += expr.printAST(prefix); + } + } + + if (op != null) { + str += prefix + "Op(" + op + ")\n"; } } - if (op != null) { - str += prefix + "Op(" + op + ")\n"; + return str; + } + + @Override + public String toPrint(String prefix) { + String str = prefix; + + if (atom != null) { + str += atom.toPrint(""); + for (var trailer : trailers) { + str += trailer.toPrint(""); + } + } else { + if (op == "+" || op == "-" || op == "~") { + str += prefix + op + exprs.get(0).toPrint(""); + } else { + str += prefix + exprs.get(0).toPrint("") + " "; + if (compOp != null) { + str += compOp.toPrint("") + " " + exprs.get(1).toPrint(""); + } else { + str += op + " " + exprs.get(1).toPrint(""); + } + } } return str; diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java index 507d314..629d67e 100644 --- a/src/ast/nodes/ForStmtNode.java +++ b/src/ast/nodes/ForStmtNode.java @@ -73,8 +73,23 @@ public class ForStmtNode implements Node { } @Override + public String printAST(String prefix) { + return prefix + "For\n" + exprList.printAST(prefix + " ") + block.printAST(prefix + " "); + } + + @Override public String toPrint(String prefix) { - return prefix + "For\n" + exprList.toPrint(prefix + " ") + block.toPrint(prefix + " "); + String str = prefix + "for "; + str += exprList.toPrint("") + ":\n"; + str += block.toPrint(prefix + "\t"); + return str; } + public Node getBlock() { + return block; + } + + public Node getExprList() { + return exprList; + } } diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java index c2671b2..e99f3a3 100644 --- a/src/ast/nodes/FuncdefNode.java +++ b/src/ast/nodes/FuncdefNode.java @@ -22,7 +22,11 @@ public class FuncdefNode implements Node { public FuncdefNode(TerminalNode name, Node paramlist, Node block) { this.name = name; - this.paramlist = paramlist; + if (paramlist != null) { + this.paramlist = paramlist; + } else { + this.paramlist = new ParamlistNode(new ArrayList<Node>()); + } this.block = block; this.funLabel = Label.newFun("FUN"); } @@ -62,7 +66,6 @@ public class FuncdefNode implements Node { return errors; } - // FIXME: this type must be the same of the return stmt variable @Override public Type typeCheck() { return new VoidType(); @@ -84,17 +87,29 @@ public class FuncdefNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "Funcdef(" + name + ")\n"; prefix += " "; if (paramlist != null) { - str += paramlist.toPrint(prefix); + str += paramlist.printAST(prefix); } - str += block.toPrint(prefix); + str += block.printAST(prefix); + + return str; + } + + @Override + public String toPrint(String prefix) { + String str = "\n" + prefix + "def " + this.name + '('; + if (paramlist != null) { + str += paramlist.toPrint(""); + } + str += "):\n"; + str += block.toPrint(prefix + "\t") + "\n"; return str; } diff --git a/src/ast/nodes/IfNode.java b/src/ast/nodes/IfNode.java index ca42b7a..fd878f8 100644 --- a/src/ast/nodes/IfNode.java +++ b/src/ast/nodes/IfNode.java @@ -34,7 +34,6 @@ public class IfNode implements Node { return errors; } - // FIXME: fix the if statement @Override public Type typeCheck() { if (guard.typeCheck() instanceof BoolType) { @@ -78,14 +77,26 @@ public class IfNode implements Node { } @Override - public String toPrint(String prefix) { - String str = prefix + "If\n" + guard.toPrint(prefix + " ") + thenBranch.toPrint(prefix + " "); + public String printAST(String prefix) { + String str = prefix + "If\n" + guard.printAST(prefix + " ") + thenBranch.printAST(prefix + " "); if (elseBranch != null) { - str += elseBranch.toPrint(prefix + " "); + str += elseBranch.printAST(prefix + " "); } return str; } + @Override + public String toPrint(String prefix) { + String str = prefix + "if "; + str += guard.toPrint("") + ":\n"; + str += thenBranch.toPrint(prefix + "\t") + "\n"; + if (elseBranch != null) { + str += prefix + "else:\n"; + str += elseBranch.toPrint(prefix + "\t") + "\n"; + } + return str; + } + } diff --git a/src/ast/nodes/ImportNode.java b/src/ast/nodes/ImportNode.java index 97e3404..1f797f8 100644 --- a/src/ast/nodes/ImportNode.java +++ b/src/ast/nodes/ImportNode.java @@ -58,14 +58,14 @@ public class ImportNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "Import\n"; prefix += " "; if (isFrom) { - str += prefix + " From\n" + dottedName.toPrint(prefix + " "); + str += prefix + " From\n" + dottedName.printAST(prefix + " "); } else { - str += dottedName.toPrint(prefix); + str += dottedName.printAST(prefix); } if (importAs) { @@ -88,4 +88,27 @@ public class ImportNode implements Node { return str; } + @Override + public String toPrint(String prefix) { + String str = prefix; + + if (isFrom) { + str += "from " + dottedName.toPrint("") + " import "; + if (importAll) { + str += "*"; + } else { + str += names.get(0); + for (int i = 1; i < names.size(); ++i) { + str += ", " + names.get(i); + } + } + } else { + str += "import " + dottedName.toPrint(""); + if (importAs) { + str += " as " + names.get(0); + } + } + return str; + } + } diff --git a/src/ast/nodes/Node.java b/src/ast/nodes/Node.java index 0e58093..5bf5a33 100644 --- a/src/ast/nodes/Node.java +++ b/src/ast/nodes/Node.java @@ -105,5 +105,11 @@ public interface Node { * Returns a string for a given node with a prefix. It used when an AST * wants to be visualized on screen. */ + String printAST(String prefix); + + /** + * Returns a string for a given node with a prefix. It used when the code + * 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 4bba772..b7786eb 100644 --- a/src/ast/nodes/ParamdefNode.java +++ b/src/ast/nodes/ParamdefNode.java @@ -29,14 +29,18 @@ public class ParamdefNode extends AtomNode { return errors; } - // FIXME: it should returns the param' type @Override public Type typeCheck() { return new VoidType(); } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { return prefix + "Paramdef(" + val + ")\n"; } + + @Override + public String toPrint(String prefix) { + return prefix + val; + } } diff --git a/src/ast/nodes/ParamlistNode.java b/src/ast/nodes/ParamlistNode.java index 9e8d75c..2cb6c89 100644 --- a/src/ast/nodes/ParamlistNode.java +++ b/src/ast/nodes/ParamlistNode.java @@ -42,15 +42,29 @@ public class ParamlistNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "Paramlist\n"; prefix += " "; - for (var param : params) { - str += param.toPrint(prefix); + for (Node param : params) { + str += param.printAST(prefix); } return str; } + @Override + public String toPrint(String prefix) { + String str = prefix; + + for (int i = 0; i < params.size(); i++) { + str += params.get(i).toPrint(""); + if (i != params.size() - 1) { + str += ", "; + } + } + + return str; + } + } diff --git a/src/ast/nodes/ReturnStmtNode.java b/src/ast/nodes/ReturnStmtNode.java index 15c8d69..1264fa9 100644 --- a/src/ast/nodes/ReturnStmtNode.java +++ b/src/ast/nodes/ReturnStmtNode.java @@ -63,15 +63,24 @@ public class ReturnStmtNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "ReturnStmt\n"; prefix += " "; if (this.exprList != null) { - str += this.exprList.toPrint(prefix); + str += this.exprList.printAST(prefix); } return str; } + @Override + public String toPrint(String prefix) { + String str = prefix + "return "; + if (this.exprList != null) { + str += this.exprList.toPrint(""); + } + return str + "\n"; + } + } diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java index 2c99164..ebb786a 100644 --- a/src/ast/nodes/RootNode.java +++ b/src/ast/nodes/RootNode.java @@ -54,7 +54,7 @@ public class RootNode implements Node { str += child.codeGeneration(); } - for (int i = 0; i < Label.getGlobalVarNum(); i++) { + for (int i = 0; i < Label.getGlobalVarNum() - 1; i++) { str += "pop\n"; } @@ -62,16 +62,32 @@ public class RootNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = "Root\n"; prefix += " "; for (Node child : childs) { - str += child.toPrint(prefix); + str += child.printAST(prefix); } return str; } + @Override + public String toPrint(String prefix) { + String str = prefix; + for (Node child : childs) { + str += child.toPrint(""); + } + return str; + } + + public ArrayList<Node> getChilds() { + return childs; + } + + public Node getChild(int i) { + return childs.get(i); + } } diff --git a/src/ast/nodes/SimpleStmtNode.java b/src/ast/nodes/SimpleStmtNode.java index 31a935f..3952242 100644 --- a/src/ast/nodes/SimpleStmtNode.java +++ b/src/ast/nodes/SimpleStmtNode.java @@ -73,28 +73,56 @@ public class SimpleStmtNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "SimpleStmt\n"; prefix += " "; if (assignment != null) { - str += assignment.toPrint(prefix); + str += assignment.printAST(prefix); + } else if (expr != null) { + str += expr.printAST(prefix); + } else if (returnStmt != null) { + str += returnStmt.printAST(prefix); + } else if (importStmt != null) { + str += importStmt.printAST(prefix); } - if (expr != null) { - str += expr.toPrint(prefix); - } + return str; + } - if (returnStmt != null) { - str += returnStmt.toPrint(prefix); - } + @Override + public String toPrint(String prefix) { + + String str = prefix; - if (importStmt != null) { - str += importStmt.toPrint(prefix); + if (assignment != null) { + str += assignment.toPrint(""); + } else if (expr != null) { + str += expr.toPrint(""); + } else if (returnStmt != null) { + str += returnStmt.toPrint(""); + } else if (importStmt != null) { + str += importStmt.toPrint(""); } return str; } + public Node getImportStmt() { + return importStmt; + } + + public Node getReturnStmt() { + return returnStmt; + } + + public Node getAssignment() { + return assignment; + } + + public Node getExpr() { + return expr; + } + } diff --git a/src/ast/nodes/SimpleStmtsNode.java b/src/ast/nodes/SimpleStmtsNode.java index 8e5c924..e7a5557 100644 --- a/src/ast/nodes/SimpleStmtsNode.java +++ b/src/ast/nodes/SimpleStmtsNode.java @@ -44,16 +44,31 @@ public class SimpleStmtsNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "SimpleStmts\n"; prefix += " "; for (Node stmt : stmts) { - str += stmt.toPrint(prefix); + str += stmt.printAST(prefix); + } + + return str; + } + + @Override + public String toPrint(String prefix) { + String str = ""; + + for (Node stmt : stmts) { + str += stmt.toPrint(prefix) + "\n"; } return str; } + public ArrayList<Node> getStmts() { + return stmts; + } + } diff --git a/src/ast/nodes/TestlistCompNode.java b/src/ast/nodes/TestlistCompNode.java index e55f854..024d742 100644 --- a/src/ast/nodes/TestlistCompNode.java +++ b/src/ast/nodes/TestlistCompNode.java @@ -72,12 +72,29 @@ public class TestlistCompNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "Testlist_comp\n"; prefix += " "; for (var param : exprs) { - str += param.toPrint(prefix); + str += param.printAST(prefix); + } + + return str; + } + + @Override + public String toPrint(String prefix) { + String str = prefix; + + str += exprs.get(0).toPrint(""); + + if (comp != null) { + str += comp.toPrint(""); + } else { + for (int i = 1; i < exprs.size(); i++) { + str += ", " + exprs.get(i).toPrint(""); + } } return str; diff --git a/src/ast/nodes/TrailerNode.java b/src/ast/nodes/TrailerNode.java index d70e962..27eb166 100644 --- a/src/ast/nodes/TrailerNode.java +++ b/src/ast/nodes/TrailerNode.java @@ -12,17 +12,19 @@ import org.antlr.v4.runtime.tree.TerminalNode; */ public class TrailerNode implements Node { + private String prefix; + private String suffix; private final Node arglist; private final ArrayList<Node> exprs; private final TerminalNode methodCall; - private final boolean isParenthesis; private final boolean isEmpty; - public TrailerNode(Node arglist, ArrayList<Node> exprs, TerminalNode methodCall, boolean isParenthesis) { + public TrailerNode(Node arglist, ArrayList<Node> exprs, TerminalNode methodCall, String prefix, String suffix){ this.arglist = arglist; this.exprs = exprs; this.methodCall = methodCall; - this.isParenthesis = isParenthesis; + this.prefix = prefix; + this.suffix = suffix; this.isEmpty = (this.arglist == null && this.exprs.isEmpty() && this.methodCall == null); } @@ -50,10 +52,6 @@ public class TrailerNode implements Node { return ((ArglistNode) arglist).getArgumentNumber(); } - public boolean isParenthesis() { - return this.isParenthesis; - } - @Override public Type typeCheck() { return new VoidType(); @@ -68,17 +66,17 @@ public class TrailerNode implements Node { } @Override - public String toPrint(String prefix) { + public String printAST(String prefix) { String str = prefix + "TrailerNode\n"; prefix += " "; if (arglist != null) { - str += arglist.toPrint(prefix); + str += arglist.printAST(prefix); } for (var expr : exprs) { - str += expr.toPrint(prefix); + str += expr.printAST(prefix); } if (methodCall != null) { @@ -92,4 +90,25 @@ public class TrailerNode implements Node { return str; } + @Override + public String toPrint(String prefix) { + String str = prefix + this.prefix; + + if (arglist != null) { + str += arglist.toPrint(""); + } else if (methodCall != null) { + str += methodCall.getText(); + } else { + for (var expr : exprs) { + str += expr.toPrint(""); + if (exprs.indexOf(expr) != exprs.size() - 1) { + str += ", "; + } + } + } + + str += this.suffix; + return str; + } + } diff --git a/src/ast/nodes/WhileStmtNode.java b/src/ast/nodes/WhileStmtNode.java index d371046..43bf5ff 100644 --- a/src/ast/nodes/WhileStmtNode.java +++ b/src/ast/nodes/WhileStmtNode.java @@ -33,14 +33,33 @@ public class WhileStmtNode implements Node { return new VoidType(); } - // TODO: add cgen per while (but it's not requested from the exercise) + /** + * NOTE: It is not a part for this project. + */ @Override public String codeGeneration() { return ""; } @Override + public String printAST(String prefix) { + return prefix + "While\n" + expr.printAST(prefix + " ") + block.printAST(prefix + " "); + } + + @Override public String toPrint(String prefix) { - return prefix + "While\n" + expr.toPrint(prefix + " ") + block.toPrint(prefix + " "); + String str = prefix + "while "; + str += expr.toPrint("") + ":\n"; + str += block.toPrint(prefix + "\t") + "\n"; + return str; + } + + public Node getBlock() { + return block; + } + + public Node getExpr() { + return expr; } + } |