From 1851f5e76018ec1df3b55dce6cc9a64c9497bf7a Mon Sep 17 00:00:00 2001 From: bd-912 Date: Fri, 26 Apr 2024 15:50:38 -0600 Subject: Rearrange directory structure --- typecheck/TypeCheckSimp.java | 1097 +++++++++++++++++++++++++++++++ typecheck/library/TypeCheckSimp.java | 1097 ------------------------------- typecheck/tests/BinaryTree-error.java | 334 ---------- typecheck/tests/BinaryTree.java | 334 ---------- typecheck/tests/Branch-error.java | 11 - typecheck/tests/Branch.java | 11 - typecheck/tests/BubbleSort-error.java | 93 --- typecheck/tests/BubbleSort.java | 93 --- typecheck/tests/DeclareNone.java | 6 - typecheck/tests/Empty.java | 5 - typecheck/tests/Factorial-error.java | 16 - typecheck/tests/Factorial.java | 16 - typecheck/tests/FactorialEdit.java | 20 - typecheck/tests/IsPositive.java | 29 - typecheck/tests/LinearSearch-error.java | 99 --- typecheck/tests/LinearSearch.java | 99 --- typecheck/tests/LinkedList-error.java | 278 -------- typecheck/tests/LinkedList.java | 278 -------- typecheck/tests/MoreThan4-error.java | 29 - typecheck/tests/MoreThan4.java | 29 - typecheck/tests/NewNone.java | 9 - typecheck/tests/Operator.java | 15 - typecheck/tests/Printer-error.java | 5 - typecheck/tests/Printer.java | 5 - typecheck/tests/QuickSort-error.java | 112 ---- typecheck/tests/QuickSort.java | 112 ---- typecheck/tests/RetrieveInteger.java | 17 - typecheck/tests/SimpleArithmetic.java | 6 - typecheck/tests/SimpleArray-error.java | 6 - typecheck/tests/SimpleArray.java | 6 - typecheck/tests/TreeVisitor-error.java | 376 ----------- typecheck/tests/TreeVisitor.java | 374 ----------- 32 files changed, 1097 insertions(+), 3920 deletions(-) create mode 100644 typecheck/TypeCheckSimp.java delete mode 100644 typecheck/library/TypeCheckSimp.java delete mode 100644 typecheck/tests/BinaryTree-error.java delete mode 100644 typecheck/tests/BinaryTree.java delete mode 100644 typecheck/tests/Branch-error.java delete mode 100644 typecheck/tests/Branch.java delete mode 100644 typecheck/tests/BubbleSort-error.java delete mode 100644 typecheck/tests/BubbleSort.java delete mode 100644 typecheck/tests/DeclareNone.java delete mode 100644 typecheck/tests/Empty.java delete mode 100644 typecheck/tests/Factorial-error.java delete mode 100644 typecheck/tests/Factorial.java delete mode 100644 typecheck/tests/FactorialEdit.java delete mode 100644 typecheck/tests/IsPositive.java delete mode 100644 typecheck/tests/LinearSearch-error.java delete mode 100644 typecheck/tests/LinearSearch.java delete mode 100644 typecheck/tests/LinkedList-error.java delete mode 100644 typecheck/tests/LinkedList.java delete mode 100644 typecheck/tests/MoreThan4-error.java delete mode 100644 typecheck/tests/MoreThan4.java delete mode 100644 typecheck/tests/NewNone.java delete mode 100644 typecheck/tests/Operator.java delete mode 100644 typecheck/tests/Printer-error.java delete mode 100644 typecheck/tests/Printer.java delete mode 100644 typecheck/tests/QuickSort-error.java delete mode 100644 typecheck/tests/QuickSort.java delete mode 100644 typecheck/tests/RetrieveInteger.java delete mode 100644 typecheck/tests/SimpleArithmetic.java delete mode 100644 typecheck/tests/SimpleArray-error.java delete mode 100644 typecheck/tests/SimpleArray.java delete mode 100644 typecheck/tests/TreeVisitor-error.java delete mode 100644 typecheck/tests/TreeVisitor.java (limited to 'typecheck') diff --git a/typecheck/TypeCheckSimp.java b/typecheck/TypeCheckSimp.java new file mode 100644 index 0000000..99fa187 --- /dev/null +++ b/typecheck/TypeCheckSimp.java @@ -0,0 +1,1097 @@ +package typecheck; + +import syntaxtree.*; +import visitor.*; +import st.*; +import misc.*; +import java.util.*; + +/** + * Provides default methods which visit each node in the tree in depth-first + * order. Your visitors may extend this class. + */ +public class TypeCheckSimp extends GJDepthFirst { + + private int offset; + + private void printNode(Node n, SymbolTable symt, boolean enter, TypeEnum consensus) { + String str = ""; + for (int i=0; i < this.offset; ++i) + str += "."; + if (enter) + str += "Visiting "; + else + str += "Leaving "; + str += "n.getClass().getSimpleName()"; + if (!enter) { + if (consensus == TypeEnum.ERROR) + str += " did not type check."; + else + str += String.format(" found type %s", consensus); + } + MinimalLogger.info(str); + } + + public TypeInstance visit(NodeList n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = new TypeInstance(null, TypeEnum.CHECK); + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + TypeInstance node = e.nextElement().accept(this,symt); + e.nextElement().accept(this,symt); + if (node.getType() == TypeEnum.ERROR) + ret = node; + _count++; + } + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + public TypeInstance visit(NodeListOptional n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret; + if ( n.present() ) { + ret = new TypeInstance(null, TypeEnum.CHECK); + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + TypeInstance node = e.nextElement().accept(this,symt); + if (node.getType() == TypeEnum.ERROR) + ret = node; + _count++; + } + } + else + ret = new TypeInstance(null, TypeEnum.CHECK); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME + public TypeInstance visit(NodeOptional n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret; + + if ( n.present() ) + ret = n.node.accept(this,symt); + else + ret = new TypeInstance(null, TypeEnum.CHECK); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + public TypeInstance visit(NodeSequence n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = new TypeInstance(null, TypeEnum.CHECK); + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + TypeInstance node = e.nextElement().accept(this,symt); + if (node.getType() == TypeEnum.ERROR) + ret = node; + _count++; + } + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + public TypeInstance visit(NodeToken n, SymbolTable symt) { + // A fixed string token. '⌣' + String str = ""; + for (int i=0; i < this.offset; ++i) + str += "."; + MinimalLogger.info(String.format("%sLeaving %s => %s", + str, + n.getClass().getSimpleName(), + n.toString())); + return null; + } + + // + // User-generated visitor methods below + // + + /** + * f0 -> MainClass() + * f1 -> ( TypeDeclaration() )* + * f2 -> + */ + public TypeInstance visit(Goal n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + n.f1.accept(this, symt); + n.f2.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "class" + * f1 -> Identifier() + * f2 -> "{" + * f3 -> "public" + * f4 -> "static" + * f5 -> "void" + * f6 -> "main" + * f7 -> "(" + * f8 -> "String" + * f9 -> "[" + * f10 -> "]" + * f11 -> Identifier() + * f12 -> ")" + * f13 -> "{" + * f14 -> ( VarDeclaration() )* + * f15 -> ( Statement() )* + * f16 -> "}" + * f17 -> "}" + */ + public TypeInstance visit(MainClass n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance name = n.f1.accept(this, symt); + n.f2.accept(this, symt); + n.f3.accept(this, symt); + n.f4.accept(this, symt); + n.f5.accept(this, symt); + n.f6.accept(this, symt); + n.f7.accept(this, symt); + n.f8.accept(this, symt); + n.f9.accept(this, symt); + n.f10.accept(this, symt); + // TypeInstance args = n.f11.accept(this, symt); + n.f12.accept(this, symt); + n.f13.accept(this, symt); + TypeInstance var_dec = n.f14.accept(this, symt); + TypeInstance stmt = n.f15.accept(this, symt); + n.f16.accept(this, symt); + n.f17.accept(this, symt); + + this.printNode(n, symt, false, stmt.getType()); + --this.offset; + return stmt; + } + + /** + * f0 -> ClassDeclaration() + * | ClassExtendsDeclaration() + */ + public TypeInstance visit(TypeDeclaration n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "class" + * f1 -> Identifier() + * f2 -> "{" + * f3 -> ( VarDeclaration() )* + * f4 -> ( MethodDeclaration() )* + * f5 -> "}" + */ + public TypeInstance visit(ClassDeclaration n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance id = n.f1.accept(this, symt); + n.f2.accept(this, symt); + TypeInstance vars = n.f3.accept(this, symt); + TypeInstance mtds = n.f4.accept(this, symt); + n.f5.accept(this, symt); + TypeInstance ret = (vars.hasChecked() && + mtds.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "class" + * f1 -> Identifier() + * f2 -> "extends" + * f3 -> Identifier() + * f4 -> "{" + * f5 -> ( VarDeclaration() )* + * f6 -> ( MethodDeclaration() )* + * f7 -> "}" + */ + public TypeInstance visit(ClassExtendsDeclaration n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance id = n.f1.accept(this, symt); + n.f2.accept(this, symt); + TypeInstance ext = n.f3.accept(this, symt); + n.f4.accept(this, symt); + TypeInstance vars = n.f5.accept(this, symt); + TypeInstance mehs = n.f6.accept(this, symt); + n.f7.accept(this, symt); + TypeInstance ret = (id.getType() == TypeEnum.classname && + vars.hasChecked() && + mehs.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME (this may be ST-only) + /** + * f0 -> Type() + * f1 -> Identifier() + * f2 -> ";" + */ + public TypeInstance visit(VarDeclaration n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + n.f1.accept(this, symt); + n.f2.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME + /** + * [7.5]: Parameters identifiers are distinct, local vars are distinct, + * (vars in scope?), all statements type check + * + * f0 -> "public" + * f1 -> Type() + * f2 -> Identifier() + * f3 -> "(" + * f4 -> ( FormalParameterList() )? + * f5 -> ")" + * f6 -> "{" + * f7 -> ( VarDeclaration() )* + * f8 -> ( Statement() )* + * f9 -> "return" + * f10 -> Expression() + * f11 -> ";" + * f12 -> "}" + */ + public TypeInstance visit(MethodDeclaration n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + MethodInstance self = symt.getMethod(n.f2.f0.tokenImage); + n.f0.accept(this, symt); + TypeInstance ret_type = n.f1.accept(this, symt); + n.f2.accept(this, symt); + n.f3.accept(this, symt); + n.f4.accept(this, symt); + n.f5.accept(this, symt); + n.f6.accept(this, symt); + n.f7.accept(this, symt); + TypeInstance stmt = n.f8.accept(this, symt); + n.f9.accept(this, symt); + TypeInstance rtrn = n.f10.accept(this, symt); + n.f11.accept(this, symt); + n.f12.accept(this, symt); + TypeInstance ret = (self.getReturn() == rtrn.getType() && // FIXME I am checking that the rtrn matches the method's declared return type. Is this in the document? + stmt.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> FormalParameter() + * f1 -> ( FormalParameterRest() )* + */ + public TypeInstance visit(FormalParameterList n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance _ret=null; + TypeInstance para1 = n.f0.accept(this, symt); + TypeInstance parar = n.f1.accept(this, symt); + TypeInstance ret = (para1.hasChecked() && + parar.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> Type() + * f1 -> Identifier() + */ + public TypeInstance visit(FormalParameter n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + n.f1.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "," + * f1 -> FormalParameter() + */ + public TypeInstance visit(FormalParameterRest n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = n.f1.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> ArrayType() + * | BooleanType() + * | IntegerType() + * | Identifier() + */ + public TypeInstance visit(Type n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "int" + * f1 -> "[" + * f2 -> "]" + */ + public TypeInstance visit(ArrayType n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = new TypeInstance(null, TypeEnum.intarray); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "boolean" + */ + public TypeInstance visit(BooleanType n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = new TypeInstance(null, TypeEnum.bool); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "int" + */ + public TypeInstance visit(IntegerType n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = new TypeInstance(null, TypeEnum.integer); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> Block() + * | AssignmentStatement() + * | ArrayAssignmentStatement() + * | IfStatement() + * | WhileStatement() + * | PrintStatement() + */ + public TypeInstance visit(Statement n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "{" + * f1 -> ( Statement() )* + * f2 -> "}" + */ + public TypeInstance visit(Block n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = n.f1.accept(this, symt); + n.f2.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME FIXME FIXME + // Given we only have a few types, what is a subtype of what? + /** + * [23]: Expression is a subtype of identifier, and e typechecks* + * + * f0 -> Identifier() + * f1 -> "=" + * f2 -> Expression() + * f3 -> ";" + */ + public TypeInstance visit(AssignmentStatement n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance lhs = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance rhs = n.f2.accept(this, symt); + n.f3.accept(this, symt); + TypeInstance ret = (lhs.sameType(rhs)) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME (this may be done) + /** + * [24]: Identifier is an integer array, expressions are both integers + * + * f0 -> Identifier() + * f1 -> "[" + * f2 -> Expression() + * f3 -> "]" + * f4 -> "=" + * f5 -> Expression() + * f6 -> ";" + */ + public TypeInstance visit(ArrayAssignmentStatement n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance id = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance index = n.f2.accept(this, symt); + n.f3.accept(this, symt); + n.f4.accept(this, symt); + TypeInstance value = n.f5.accept(this, symt); + n.f6.accept(this, symt); + TypeInstance ret = (id.getType() == TypeEnum.intarray && + index.getType() == TypeEnum.integer && + value.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [25]: Expression is a bool, both statements type-check + * + * f0 -> "if" + * f1 -> "(" + * f2 -> Expression() + * f3 -> ")" + * f4 -> Statement() + * f5 -> "else" + * f6 -> Statement() + */ + public TypeInstance visit(IfStatement n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance expr = n.f2.accept(this, symt); + n.f3.accept(this, symt); + TypeInstance stmt1 = n.f4.accept(this, symt); + n.f5.accept(this, symt); + TypeInstance stmt2 = n.f6.accept(this, symt); + TypeInstance ret = (expr.getType() == TypeEnum.bool && + stmt1.getType() == stmt2.getType() && + stmt1.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + + } + + /** + * DONE [26]: Expression is a bool, statement type-checks + * + * f0 -> "while" + * f1 -> "(" + * f2 -> Expression() + * f3 -> ")" + * f4 -> Statement() + */ + public TypeInstance visit(WhileStatement n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance expr = n.f2.accept(this, symt); + n.f3.accept(this, symt); + TypeInstance stmt = n.f4.accept(this, symt); + TypeInstance ret = (expr.getType() == TypeEnum.bool && + stmt.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [27]: Expression is an integer + * + * f0 -> "System.out.println" + * f1 -> "(" + * f2 -> Expression() + * f3 -> ")" + * f4 -> ";" + */ + public TypeInstance visit(PrintStatement n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance ret = n.f2.accept(this, symt); + n.f3.accept(this, symt); + n.f4.accept(this, symt); + ret = (ret.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> AndExpression() + * | CompareExpression() + * | PlusExpression() + * | MinusExpression() + * | TimesExpression() + * | ArrayLookup() + * | ArrayLength() + * | MessageSend() + * | PrimaryExpression() + */ + public TypeInstance visit(Expression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [28]: If expressions are both booleans, return is a boolean + * + * f0 -> PrimaryExpression() + * f1 -> "&&" + * f2 -> PrimaryExpression() + */ + public TypeInstance visit(AndExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance oper1 = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance oper2 = n.f2.accept(this, symt); + TypeInstance ret = (oper1.getType() == TypeEnum.bool && + oper2.getType() == TypeEnum.bool) ? + new TypeInstance(null, TypeEnum.bool) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [29]: If expressions are both integers, return is a boolean + * + * f0 -> PrimaryExpression() + * f1 -> "<" + * f2 -> PrimaryExpression() + */ + public TypeInstance visit(CompareExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance oper1 = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance oper2 = n.f2.accept(this, symt); + TypeInstance ret = (oper1.getType() == TypeEnum.integer && + oper2.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.bool) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [30]: If expressions are both integers, return is an integer + * + * f0 -> PrimaryExpression() + * f1 -> "+" + * f2 -> PrimaryExpression() + */ + public TypeInstance visit(PlusExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance oper1 = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance oper2 = n.f2.accept(this, symt); + TypeInstance ret = (oper1.getType() == TypeEnum.integer && + oper2.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.integer) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [31]: If expressions are both integers, return is an integer + * + * f0 -> PrimaryExpression() + * f1 -> "-" + * f2 -> PrimaryExpression() + */ + public TypeInstance visit(MinusExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance oper1 = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance oper2 = n.f2.accept(this, symt); + TypeInstance ret = (oper1.getType() == TypeEnum.integer && + oper2.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.integer) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [32]: If expressions are both integers, return is an integer + * + * f0 -> PrimaryExpression() + * f1 -> "*" + * f2 -> PrimaryExpression() + */ + public TypeInstance visit(TimesExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance oper1 = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance oper2 = n.f2.accept(this, symt); + TypeInstance ret = (oper1.getType() == TypeEnum.integer && + oper2.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.integer) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [33]: If expr1 is an integer array and expr2 is an int, + * return is an int + * + * f0 -> PrimaryExpression() + * f1 -> "[" + * f2 -> PrimaryExpression() + * f3 -> "]" + */ + public TypeInstance visit(ArrayLookup n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance array = n.f0.accept(this, symt); + n.f1.accept(this, symt); + TypeInstance index = n.f2.accept(this, symt); + n.f3.accept(this, symt); + TypeInstance ret = (array.getType() == TypeEnum.intarray && + index.getType() == TypeEnum.integer) ? + new TypeInstance(null, TypeEnum.integer) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [34]: If expr1 is an integer array, return is an int + * + * f0 -> PrimaryExpression() + * f1 -> "." + * f2 -> "length" + */ + public TypeInstance visit(ArrayLength n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + n.f1.accept(this, symt); + n.f2.accept(this, symt); + ret = (ret.getType() == TypeEnum.intarray) ? new TypeInstance(null, TypeEnum.integer) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME FIXME FIXME + /** + * [35]: PrimaryExpr must be a classname, id must be a method name, expressionlist must be correct? + * + * f0 -> PrimaryExpression() + * f1 -> "." + * f2 -> Identifier() + * f3 -> "(" + * f4 -> ( ExpressionList() )? + * f5 -> ")" + */ + public TypeInstance visit(MessageSend n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + // this MUST be an instance of a class! + TypeInstance t = n.f0.accept(this, symt); + ClassInstance c = t.getClassInstance(); + n.f1.accept(this, symt); + n.f2.accept(this, symt); + MethodInstance m = symt.getMethod(n.f2.f0.tokenImage); + n.f3.accept(this, symt); + n.f4.accept(this, symt); + n.f5.accept(this, symt); + --this.offset; + return (true) ? + new TypeInstance(null, m.getReturn()) : + new TypeInstance(null, TypeEnum.ERROR); + } + + // FIXME + /** + * f0 -> Expression() + * f1 -> ( ExpressionRest() )* + */ + public TypeInstance visit(ExpressionList n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance expr1 = n.f0.accept(this, symt); + TypeInstance exprr = n.f1.accept(this, symt); + TypeInstance ret = (expr1.hasChecked() && + exprr.hasChecked()) ? + new TypeInstance(null, TypeEnum.CHECK) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> "," + * f1 -> Expression() + */ + public TypeInstance visit(ExpressionRest n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = n.f1.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * f0 -> IntegerLiteral() + * | TrueLiteral() + * | FalseLiteral() + * | Identifier() + * | ThisExpression() + * | ArrayAllocationExpression() + * | AllocationExpression() + * | NotExpression() + * | BracketExpression() + */ + public TypeInstance visit(PrimaryExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance ret = n.f0.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [36]: return is an int + * + * + * f0 -> + */ + public TypeInstance visit(IntegerLiteral n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + this.printNode(n, symt, false, TypeEnum.integer); + --this.offset; + return new TypeInstance(null, TypeEnum.integer); + } + + /** + * DONE [37]: return is a bool + * + * f0 -> "true" + */ + public TypeInstance visit(TrueLiteral n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + this.printNode(n, symt, false, TypeEnum.bool); + --this.offset; + return new TypeInstance(null, TypeEnum.bool); + } + + /** + * DONE [38]: return is a bool + * + * f0 -> "false" + */ + public TypeInstance visit(FalseLiteral n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + this.printNode(n, symt, false, TypeEnum.bool); + --this.offset; + return new TypeInstance(null, TypeEnum.bool); + } + + // FIXME + /** + * [39]: id is a symbol in the current domain, return is id's type + * + * f0 -> + */ + public TypeInstance visit(Identifier n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + TypeInstance type; + TypeInstance ret; + ClassInstance cls; + if ((cls = symt.getClass(n.f0.tokenImage)) != null) { + // covers "anonymous" instance + ret = new TypeInstance(cls.getName(), + TypeEnum.classname); + ret.addClassInstance(cls); + } else { + if ((type = symt.getType(n.f0.tokenImage)) != null) { + ret = new TypeInstance(type.getName(), + type.getType()); + ret.addClassInstance(type.getClassInstance()); + } else + ret = new TypeInstance(null, TypeEnum.ERROR); + } + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME FIXME FIXME + /** + * [40]: method exists? but where is the token? + * + * f0 -> "this" + */ + public TypeInstance visit(ThisExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = new TypeInstance(null, TypeEnum.CHECK); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * DONE [41]: if expression is an integer, return is an int array + * + * f0 -> "new" + * f1 -> "int" + * f2 -> "[" + * f3 -> Expression() + * f4 -> "]" + */ + public TypeInstance visit(ArrayAllocationExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + n.f1.accept(this, symt); + n.f2.accept(this, symt); + TypeInstance ret = n.f3.accept(this, symt); + n.f4.accept(this, symt); + ret = (ret.getType() == TypeEnum.integer) ? new TypeInstance(null, TypeEnum.intarray) : + new TypeInstance(null, TypeEnum.ERROR); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + // FIXME + /** + * [42]: + * + * f0 -> "new" + * f1 -> Identifier() + * f2 -> "(" + * f3 -> ")" + */ + public TypeInstance visit(AllocationExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = n.f1.accept(this, symt); + n.f2.accept(this, symt); + n.f3.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + + /** + * [43]: if expression is a boolean, return is a boolean + * + * f0 -> "!" + * f1 -> Expression() + */ + public TypeInstance visit(NotExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = n.f1.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return (ret.getType() == TypeEnum.bool) ? ret : new TypeInstance(null, TypeEnum.ERROR); + } + + /** + * [44]: if e is a type, return is that same type + * + * f0 -> "(" + * f1 -> Expression() + * f2 -> ")" + */ + public TypeInstance visit(BracketExpression n, SymbolTable symt) { + ++this.offset; + this.printNode(n, symt, true, null); + + n.f0.accept(this, symt); + TypeInstance ret = n.f1.accept(this, symt); + n.f2.accept(this, symt); + + this.printNode(n, symt, false, ret.getType()); + --this.offset; + return ret; + } + +} diff --git a/typecheck/library/TypeCheckSimp.java b/typecheck/library/TypeCheckSimp.java deleted file mode 100644 index b330c65..0000000 --- a/typecheck/library/TypeCheckSimp.java +++ /dev/null @@ -1,1097 +0,0 @@ -package typecheck.library; - -import syntaxtree.*; -import visitor.*; -import st.*; -import misc.*; -import java.util.*; - -/** - * Provides default methods which visit each node in the tree in depth-first - * order. Your visitors may extend this class. - */ -public class TypeCheckSimp extends GJDepthFirst { - - private int offset; - - private void printNode(Node n, SymbolTable symt, boolean enter, TypeEnum consensus) { - String str = ""; - for (int i=0; i < this.offset; ++i) - str += "."; - if (enter) - str += "Visiting "; - else - str += "Leaving "; - str += "n.getClass().getSimpleName()"; - if (!enter) { - if (consensus == TypeEnum.ERROR) - str += " did not type check."; - else - str += String.format(" found type %s", consensus); - } - MinimalLogger.info(str); - } - - public TypeInstance visit(NodeList n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = new TypeInstance(null, TypeEnum.CHECK); - int _count=0; - for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { - TypeInstance node = e.nextElement().accept(this,symt); - e.nextElement().accept(this,symt); - if (node.getType() == TypeEnum.ERROR) - ret = node; - _count++; - } - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - public TypeInstance visit(NodeListOptional n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret; - if ( n.present() ) { - ret = new TypeInstance(null, TypeEnum.CHECK); - int _count=0; - for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { - TypeInstance node = e.nextElement().accept(this,symt); - if (node.getType() == TypeEnum.ERROR) - ret = node; - _count++; - } - } - else - ret = new TypeInstance(null, TypeEnum.CHECK); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME - public TypeInstance visit(NodeOptional n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret; - - if ( n.present() ) - ret = n.node.accept(this,symt); - else - ret = new TypeInstance(null, TypeEnum.CHECK); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - public TypeInstance visit(NodeSequence n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = new TypeInstance(null, TypeEnum.CHECK); - int _count=0; - for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { - TypeInstance node = e.nextElement().accept(this,symt); - if (node.getType() == TypeEnum.ERROR) - ret = node; - _count++; - } - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - public TypeInstance visit(NodeToken n, SymbolTable symt) { - // A fixed string token. '⌣' - String str = ""; - for (int i=0; i < this.offset; ++i) - str += "."; - MinimalLogger.info(String.format("%sLeaving %s => %s", - str, - n.getClass().getSimpleName(), - n.toString())); - return null; - } - - // - // User-generated visitor methods below - // - - /** - * f0 -> MainClass() - * f1 -> ( TypeDeclaration() )* - * f2 -> - */ - public TypeInstance visit(Goal n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - n.f1.accept(this, symt); - n.f2.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "class" - * f1 -> Identifier() - * f2 -> "{" - * f3 -> "public" - * f4 -> "static" - * f5 -> "void" - * f6 -> "main" - * f7 -> "(" - * f8 -> "String" - * f9 -> "[" - * f10 -> "]" - * f11 -> Identifier() - * f12 -> ")" - * f13 -> "{" - * f14 -> ( VarDeclaration() )* - * f15 -> ( Statement() )* - * f16 -> "}" - * f17 -> "}" - */ - public TypeInstance visit(MainClass n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance name = n.f1.accept(this, symt); - n.f2.accept(this, symt); - n.f3.accept(this, symt); - n.f4.accept(this, symt); - n.f5.accept(this, symt); - n.f6.accept(this, symt); - n.f7.accept(this, symt); - n.f8.accept(this, symt); - n.f9.accept(this, symt); - n.f10.accept(this, symt); - // TypeInstance args = n.f11.accept(this, symt); - n.f12.accept(this, symt); - n.f13.accept(this, symt); - TypeInstance var_dec = n.f14.accept(this, symt); - TypeInstance stmt = n.f15.accept(this, symt); - n.f16.accept(this, symt); - n.f17.accept(this, symt); - - this.printNode(n, symt, false, stmt.getType()); - --this.offset; - return stmt; - } - - /** - * f0 -> ClassDeclaration() - * | ClassExtendsDeclaration() - */ - public TypeInstance visit(TypeDeclaration n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "class" - * f1 -> Identifier() - * f2 -> "{" - * f3 -> ( VarDeclaration() )* - * f4 -> ( MethodDeclaration() )* - * f5 -> "}" - */ - public TypeInstance visit(ClassDeclaration n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance id = n.f1.accept(this, symt); - n.f2.accept(this, symt); - TypeInstance vars = n.f3.accept(this, symt); - TypeInstance mtds = n.f4.accept(this, symt); - n.f5.accept(this, symt); - TypeInstance ret = (vars.hasChecked() && - mtds.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "class" - * f1 -> Identifier() - * f2 -> "extends" - * f3 -> Identifier() - * f4 -> "{" - * f5 -> ( VarDeclaration() )* - * f6 -> ( MethodDeclaration() )* - * f7 -> "}" - */ - public TypeInstance visit(ClassExtendsDeclaration n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance id = n.f1.accept(this, symt); - n.f2.accept(this, symt); - TypeInstance ext = n.f3.accept(this, symt); - n.f4.accept(this, symt); - TypeInstance vars = n.f5.accept(this, symt); - TypeInstance mehs = n.f6.accept(this, symt); - n.f7.accept(this, symt); - TypeInstance ret = (id.getType() == TypeEnum.classname && - vars.hasChecked() && - mehs.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME (this may be ST-only) - /** - * f0 -> Type() - * f1 -> Identifier() - * f2 -> ";" - */ - public TypeInstance visit(VarDeclaration n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - n.f1.accept(this, symt); - n.f2.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME - /** - * [7.5]: Parameters identifiers are distinct, local vars are distinct, - * (vars in scope?), all statements type check - * - * f0 -> "public" - * f1 -> Type() - * f2 -> Identifier() - * f3 -> "(" - * f4 -> ( FormalParameterList() )? - * f5 -> ")" - * f6 -> "{" - * f7 -> ( VarDeclaration() )* - * f8 -> ( Statement() )* - * f9 -> "return" - * f10 -> Expression() - * f11 -> ";" - * f12 -> "}" - */ - public TypeInstance visit(MethodDeclaration n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - MethodInstance self = symt.getMethod(n.f2.f0.tokenImage); - n.f0.accept(this, symt); - TypeInstance ret_type = n.f1.accept(this, symt); - n.f2.accept(this, symt); - n.f3.accept(this, symt); - n.f4.accept(this, symt); - n.f5.accept(this, symt); - n.f6.accept(this, symt); - n.f7.accept(this, symt); - TypeInstance stmt = n.f8.accept(this, symt); - n.f9.accept(this, symt); - TypeInstance rtrn = n.f10.accept(this, symt); - n.f11.accept(this, symt); - n.f12.accept(this, symt); - TypeInstance ret = (self.getReturn() == rtrn.getType() && // FIXME I am checking that the rtrn matches the method's declared return type. Is this in the document? - stmt.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> FormalParameter() - * f1 -> ( FormalParameterRest() )* - */ - public TypeInstance visit(FormalParameterList n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance _ret=null; - TypeInstance para1 = n.f0.accept(this, symt); - TypeInstance parar = n.f1.accept(this, symt); - TypeInstance ret = (para1.hasChecked() && - parar.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> Type() - * f1 -> Identifier() - */ - public TypeInstance visit(FormalParameter n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - n.f1.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "," - * f1 -> FormalParameter() - */ - public TypeInstance visit(FormalParameterRest n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = n.f1.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> ArrayType() - * | BooleanType() - * | IntegerType() - * | Identifier() - */ - public TypeInstance visit(Type n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "int" - * f1 -> "[" - * f2 -> "]" - */ - public TypeInstance visit(ArrayType n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = new TypeInstance(null, TypeEnum.intarray); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "boolean" - */ - public TypeInstance visit(BooleanType n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = new TypeInstance(null, TypeEnum.bool); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "int" - */ - public TypeInstance visit(IntegerType n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = new TypeInstance(null, TypeEnum.integer); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> Block() - * | AssignmentStatement() - * | ArrayAssignmentStatement() - * | IfStatement() - * | WhileStatement() - * | PrintStatement() - */ - public TypeInstance visit(Statement n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "{" - * f1 -> ( Statement() )* - * f2 -> "}" - */ - public TypeInstance visit(Block n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = n.f1.accept(this, symt); - n.f2.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME FIXME FIXME - // Given we only have a few types, what is a subtype of what? - /** - * [23]: Expression is a subtype of identifier, and e typechecks* - * - * f0 -> Identifier() - * f1 -> "=" - * f2 -> Expression() - * f3 -> ";" - */ - public TypeInstance visit(AssignmentStatement n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance lhs = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance rhs = n.f2.accept(this, symt); - n.f3.accept(this, symt); - TypeInstance ret = (lhs.sameType(rhs)) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME (this may be done) - /** - * [24]: Identifier is an integer array, expressions are both integers - * - * f0 -> Identifier() - * f1 -> "[" - * f2 -> Expression() - * f3 -> "]" - * f4 -> "=" - * f5 -> Expression() - * f6 -> ";" - */ - public TypeInstance visit(ArrayAssignmentStatement n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance id = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance index = n.f2.accept(this, symt); - n.f3.accept(this, symt); - n.f4.accept(this, symt); - TypeInstance value = n.f5.accept(this, symt); - n.f6.accept(this, symt); - TypeInstance ret = (id.getType() == TypeEnum.intarray && - index.getType() == TypeEnum.integer && - value.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [25]: Expression is a bool, both statements type-check - * - * f0 -> "if" - * f1 -> "(" - * f2 -> Expression() - * f3 -> ")" - * f4 -> Statement() - * f5 -> "else" - * f6 -> Statement() - */ - public TypeInstance visit(IfStatement n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance expr = n.f2.accept(this, symt); - n.f3.accept(this, symt); - TypeInstance stmt1 = n.f4.accept(this, symt); - n.f5.accept(this, symt); - TypeInstance stmt2 = n.f6.accept(this, symt); - TypeInstance ret = (expr.getType() == TypeEnum.bool && - stmt1.getType() == stmt2.getType() && - stmt1.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - - } - - /** - * DONE [26]: Expression is a bool, statement type-checks - * - * f0 -> "while" - * f1 -> "(" - * f2 -> Expression() - * f3 -> ")" - * f4 -> Statement() - */ - public TypeInstance visit(WhileStatement n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance expr = n.f2.accept(this, symt); - n.f3.accept(this, symt); - TypeInstance stmt = n.f4.accept(this, symt); - TypeInstance ret = (expr.getType() == TypeEnum.bool && - stmt.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [27]: Expression is an integer - * - * f0 -> "System.out.println" - * f1 -> "(" - * f2 -> Expression() - * f3 -> ")" - * f4 -> ";" - */ - public TypeInstance visit(PrintStatement n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance ret = n.f2.accept(this, symt); - n.f3.accept(this, symt); - n.f4.accept(this, symt); - ret = (ret.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> AndExpression() - * | CompareExpression() - * | PlusExpression() - * | MinusExpression() - * | TimesExpression() - * | ArrayLookup() - * | ArrayLength() - * | MessageSend() - * | PrimaryExpression() - */ - public TypeInstance visit(Expression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [28]: If expressions are both booleans, return is a boolean - * - * f0 -> PrimaryExpression() - * f1 -> "&&" - * f2 -> PrimaryExpression() - */ - public TypeInstance visit(AndExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance oper1 = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance oper2 = n.f2.accept(this, symt); - TypeInstance ret = (oper1.getType() == TypeEnum.bool && - oper2.getType() == TypeEnum.bool) ? - new TypeInstance(null, TypeEnum.bool) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [29]: If expressions are both integers, return is a boolean - * - * f0 -> PrimaryExpression() - * f1 -> "<" - * f2 -> PrimaryExpression() - */ - public TypeInstance visit(CompareExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance oper1 = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance oper2 = n.f2.accept(this, symt); - TypeInstance ret = (oper1.getType() == TypeEnum.integer && - oper2.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.bool) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [30]: If expressions are both integers, return is an integer - * - * f0 -> PrimaryExpression() - * f1 -> "+" - * f2 -> PrimaryExpression() - */ - public TypeInstance visit(PlusExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance oper1 = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance oper2 = n.f2.accept(this, symt); - TypeInstance ret = (oper1.getType() == TypeEnum.integer && - oper2.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.integer) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [31]: If expressions are both integers, return is an integer - * - * f0 -> PrimaryExpression() - * f1 -> "-" - * f2 -> PrimaryExpression() - */ - public TypeInstance visit(MinusExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance oper1 = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance oper2 = n.f2.accept(this, symt); - TypeInstance ret = (oper1.getType() == TypeEnum.integer && - oper2.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.integer) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [32]: If expressions are both integers, return is an integer - * - * f0 -> PrimaryExpression() - * f1 -> "*" - * f2 -> PrimaryExpression() - */ - public TypeInstance visit(TimesExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance oper1 = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance oper2 = n.f2.accept(this, symt); - TypeInstance ret = (oper1.getType() == TypeEnum.integer && - oper2.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.integer) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [33]: If expr1 is an integer array and expr2 is an int, - * return is an int - * - * f0 -> PrimaryExpression() - * f1 -> "[" - * f2 -> PrimaryExpression() - * f3 -> "]" - */ - public TypeInstance visit(ArrayLookup n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance array = n.f0.accept(this, symt); - n.f1.accept(this, symt); - TypeInstance index = n.f2.accept(this, symt); - n.f3.accept(this, symt); - TypeInstance ret = (array.getType() == TypeEnum.intarray && - index.getType() == TypeEnum.integer) ? - new TypeInstance(null, TypeEnum.integer) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [34]: If expr1 is an integer array, return is an int - * - * f0 -> PrimaryExpression() - * f1 -> "." - * f2 -> "length" - */ - public TypeInstance visit(ArrayLength n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - n.f1.accept(this, symt); - n.f2.accept(this, symt); - ret = (ret.getType() == TypeEnum.intarray) ? new TypeInstance(null, TypeEnum.integer) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME FIXME FIXME - /** - * [35]: PrimaryExpr must be a classname, id must be a method name, expressionlist must be correct? - * - * f0 -> PrimaryExpression() - * f1 -> "." - * f2 -> Identifier() - * f3 -> "(" - * f4 -> ( ExpressionList() )? - * f5 -> ")" - */ - public TypeInstance visit(MessageSend n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - // this MUST be an instance of a class! - TypeInstance t = n.f0.accept(this, symt); - ClassInstance c = t.getClassInstance(); - n.f1.accept(this, symt); - n.f2.accept(this, symt); - MethodInstance m = symt.getMethod(n.f2.f0.tokenImage); - n.f3.accept(this, symt); - n.f4.accept(this, symt); - n.f5.accept(this, symt); - --this.offset; - return (true) ? - new TypeInstance(null, m.getReturn()) : - new TypeInstance(null, TypeEnum.ERROR); - } - - // FIXME - /** - * f0 -> Expression() - * f1 -> ( ExpressionRest() )* - */ - public TypeInstance visit(ExpressionList n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance expr1 = n.f0.accept(this, symt); - TypeInstance exprr = n.f1.accept(this, symt); - TypeInstance ret = (expr1.hasChecked() && - exprr.hasChecked()) ? - new TypeInstance(null, TypeEnum.CHECK) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> "," - * f1 -> Expression() - */ - public TypeInstance visit(ExpressionRest n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = n.f1.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * f0 -> IntegerLiteral() - * | TrueLiteral() - * | FalseLiteral() - * | Identifier() - * | ThisExpression() - * | ArrayAllocationExpression() - * | AllocationExpression() - * | NotExpression() - * | BracketExpression() - */ - public TypeInstance visit(PrimaryExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance ret = n.f0.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [36]: return is an int - * - * - * f0 -> - */ - public TypeInstance visit(IntegerLiteral n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - this.printNode(n, symt, false, TypeEnum.integer); - --this.offset; - return new TypeInstance(null, TypeEnum.integer); - } - - /** - * DONE [37]: return is a bool - * - * f0 -> "true" - */ - public TypeInstance visit(TrueLiteral n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - this.printNode(n, symt, false, TypeEnum.bool); - --this.offset; - return new TypeInstance(null, TypeEnum.bool); - } - - /** - * DONE [38]: return is a bool - * - * f0 -> "false" - */ - public TypeInstance visit(FalseLiteral n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - this.printNode(n, symt, false, TypeEnum.bool); - --this.offset; - return new TypeInstance(null, TypeEnum.bool); - } - - // FIXME - /** - * [39]: id is a symbol in the current domain, return is id's type - * - * f0 -> - */ - public TypeInstance visit(Identifier n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - TypeInstance type; - TypeInstance ret; - ClassInstance cls; - if ((cls = symt.getClass(n.f0.tokenImage)) != null) { - // covers "anonymous" instance - ret = new TypeInstance(cls.getName(), - TypeEnum.classname); - ret.addClassInstance(cls); - } else { - if ((type = symt.getType(n.f0.tokenImage)) != null) { - ret = new TypeInstance(type.getName(), - type.getType()); - ret.addClassInstance(type.getClassInstance()); - } else - ret = new TypeInstance(null, TypeEnum.ERROR); - } - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME FIXME FIXME - /** - * [40]: method exists? but where is the token? - * - * f0 -> "this" - */ - public TypeInstance visit(ThisExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = new TypeInstance(null, TypeEnum.CHECK); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * DONE [41]: if expression is an integer, return is an int array - * - * f0 -> "new" - * f1 -> "int" - * f2 -> "[" - * f3 -> Expression() - * f4 -> "]" - */ - public TypeInstance visit(ArrayAllocationExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - n.f1.accept(this, symt); - n.f2.accept(this, symt); - TypeInstance ret = n.f3.accept(this, symt); - n.f4.accept(this, symt); - ret = (ret.getType() == TypeEnum.integer) ? new TypeInstance(null, TypeEnum.intarray) : - new TypeInstance(null, TypeEnum.ERROR); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - // FIXME - /** - * [42]: - * - * f0 -> "new" - * f1 -> Identifier() - * f2 -> "(" - * f3 -> ")" - */ - public TypeInstance visit(AllocationExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = n.f1.accept(this, symt); - n.f2.accept(this, symt); - n.f3.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - - /** - * [43]: if expression is a boolean, return is a boolean - * - * f0 -> "!" - * f1 -> Expression() - */ - public TypeInstance visit(NotExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = n.f1.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return (ret.getType() == TypeEnum.bool) ? ret : new TypeInstance(null, TypeEnum.ERROR); - } - - /** - * [44]: if e is a type, return is that same type - * - * f0 -> "(" - * f1 -> Expression() - * f2 -> ")" - */ - public TypeInstance visit(BracketExpression n, SymbolTable symt) { - ++this.offset; - this.printNode(n, symt, true, null); - - n.f0.accept(this, symt); - TypeInstance ret = n.f1.accept(this, symt); - n.f2.accept(this, symt); - - this.printNode(n, symt, false, ret.getType()); - --this.offset; - return ret; - } - -} diff --git a/typecheck/tests/BinaryTree-error.java b/typecheck/tests/BinaryTree-error.java deleted file mode 100644 index d9be857..0000000 --- a/typecheck/tests/BinaryTree-error.java +++ /dev/null @@ -1,334 +0,0 @@ -class BinaryTree{ - public static void main(String[] a){ - System.out.println(new BT().Start()); - } -} - - -// This class invokes the methods to create a tree, -// insert, delete and serach for elements on it -class BT { - - public int Start(){ - Tree root ; - boolean ntb ; - int nti ; - - root = new Tree(); - ntb = root.Init(16); - ntb = root.Print(); - System.out.println(100000000); - ntb = root.Insert(8) ; - ntb = root.Print(); - ntb = root.Insert(24) ; - ntb = root.Insert(4) ; - ntb = root.Insert(12) ; - ntb = root.Insert(20) ; - ntb = root.Insert(28) ; - ntb = root.Insert(14) ; - ntb = root.Print(); - System.out.println(root.Search(24)); - System.out.println(root.Search(12)); - System.out.println(root.Search(16)); - System.out.println(root.Search(50)); - System.out.println(root.Search(12)); - ntb = root.Delete(); // TE, should be Delete(12) - ntb = root.Print(); - System.out.println(root.Search(12)); - - return 0 ; - } - -} - -class Tree{ - Tree left ; - Tree right; - int key ; - boolean has_left ; - boolean has_right ; - Tree my_null ; - - // Initialize a node with a key value and no children - public boolean Init(int v_key){ - key = v_key ; - has_left = false ; - has_right = false ; - return true ; - } - - // Update the right child with rn - public boolean SetRight(Tree rn){ - right = rn ; - return true ; - } - - // Update the left child with ln - public boolean SetLeft(Tree ln){ - left = ln ; - return true ; - } - - public Tree GetRight(){ - return right ; - } - - public Tree GetLeft(){ - return left; - } - - public int GetKey(){ - return key ; - } - - public boolean SetKey(int v_key){ - key = v_key ; - return true ; - } - - public boolean GetHas_Right(){ - return has_right ; - } - - public boolean GetHas_Left(){ - return has_left ; - } - - public boolean SetHas_Left(boolean val){ - has_left = val ; - return true ; - } - - public boolean SetHas_Right(boolean val){ - has_right = val ; - return true ; - } - - // This method compares two integers and - // returns true if they are equal and false - // otherwise - public boolean Compare(int num1 , int num2){ - boolean ntb ; - int nti ; - - ntb = false ; - nti = num2 + 1 ; - if (num1 < num2) ntb = false ; - else if (!(num1 < nti)) ntb = false ; - else ntb = true ; - return ntb ; - } - - - // Insert a new element in the tree - public boolean Insert(int v_key){ - Tree new_node ; - boolean ntb ; - boolean cont ; - int key_aux ; - Tree current_node ; - - new_node = new Tree(); - ntb = new_node.Init(v_key) ; - current_node = this ; - cont = true ; - while (cont){ - key_aux = current_node.GetKey(); - if (v_key < key_aux){ - if (current_node.GetHas_Left()) - current_node = current_node.GetLeft() ; - else { - cont = false ; - ntb = current_node.SetHas_Left(true); - ntb = current_node.SetLeft(new_node); - } - } - else{ - if (current_node.GetHas_Right()) - current_node = current_node.GetRight() ; - else { - cont = false ; - ntb = current_node.SetHas_Right(true); - ntb = current_node.SetRight(new_node); - } - } - } - return true ; - } - - - // Delete an element from the tree - public boolean Delete(int v_key){ - Tree current_node ; - Tree parent_node ; - boolean cont ; - boolean found ; - boolean is_root ; - int key_aux ; - boolean ntb ; - - current_node = this ; - parent_node = this ; - cont = true ; - found = false ; - is_root = true ; - while (cont){ - key_aux = current_node.GetKey(); - if (v_key < key_aux) - if (current_node.GetHas_Left()){ - parent_node = current_node ; - current_node = current_node.GetLeft() ; - } - else cont = false ; - else - if (key_aux < v_key) - if (current_node.GetHas_Right()){ - parent_node = current_node ; - current_node = current_node.GetRight() ; - } - else cont = false ; - else { - if (is_root) - if ((!current_node.GetHas_Right()) && - (!current_node.GetHas_Left()) ) - ntb = true ; - else - ntb = this.Remove(parent_node,current_node); - else ntb = this.Remove(parent_node,current_node); - found = true ; - cont = false ; - } - is_root = false ; - } - return found ; - } - - - // Check if the element to be removed will use the - // righ or left subtree if one exists - public boolean Remove(Tree p_node, Tree c_node){ - boolean ntb ; - int auxkey1 ; - int auxkey2 ; - - if (c_node.GetHas_Left()) - ntb = this.RemoveLeft(p_node,c_node) ; - else - if (c_node.GetHas_Right()) - ntb = this.RemoveRight(p_node,c_node) ; - else { - auxkey1 = c_node.GetKey(); - //auxtree01 = p_node.GetLeft() ; - //auxkey2 = auxtree01.GetKey() ; - auxkey2 = (p_node.GetLeft()).GetKey() ; - if (this.Compare(auxkey1,auxkey2)) { - ntb = p_node.SetLeft(my_null); - ntb = p_node.SetHas_Left(false); - } - else { - ntb = p_node.SetRight(my_null); - ntb = p_node.SetHas_Right(false); - } - } - return true ; - } - - - // Copy the child key to the parent until a leaf is - // found and remove the leaf. This is done with the - // right subtree - public boolean RemoveRight(Tree p_node, Tree c_node){ - boolean ntb ; - - while (c_node.GetHas_Right()){ - //auxtree01 = c_node.GetRight() ; - //auxint02 = auxtree01.GetKey(); - //ntb = c_node.SetKey(auxint02); - ntb = c_node.SetKey((c_node.GetRight()).GetKey()); - p_node = c_node ; - c_node = c_node.GetRight() ; - } - ntb = p_node.SetRight(my_null); - ntb = p_node.SetHas_Right(false); - return true ; - } - - - // Copy the child key to the parent until a leaf is - // found and remove the leaf. This is done with the - // left subtree - public boolean RemoveLeft(Tree p_node, Tree c_node){ - boolean ntb ; - - while (c_node.GetHas_Left()){ - //auxtree01 = c_node.GetLeft() ; - //auxint02 = auxtree01.GetKey(); - //ntb = c_node.SetKey(auxint02); - ntb = c_node.SetKey((c_node.GetLeft()).GetKey()); - p_node = c_node ; - c_node = c_node.GetLeft() ; - } - ntb = p_node.SetLeft(my_null); - ntb = p_node.SetHas_Left(false); - return true ; - } - - // Search for an elemnt in the tree - public int Search(int v_key){ - boolean cont ; - int ifound ; - Tree current_node; - int key_aux ; - - current_node = this ; - cont = true ; - ifound = 0 ; - while (cont){ - key_aux = current_node.GetKey(); - if (v_key < key_aux) - if (current_node.GetHas_Left()) - current_node = current_node.GetLeft() ; - else cont = false ; - else - if (key_aux < v_key) - if (current_node.GetHas_Right()) - current_node = current_node.GetRight() ; - else cont = false ; - else { - ifound = 1 ; - cont = false ; - } - } - return ifound ; - } - - // Invoke the method to really print the tree elements - public boolean Print(){ - Tree current_node; - boolean ntb ; - - current_node = this ; - ntb = this.RecPrint(current_node); - return true ; - } - - // Print the elements of the tree - public boolean RecPrint(Tree node){ - boolean ntb ; - - if (node.GetHas_Left()){ - //auxtree01 = node.GetLeft() ; - //ntb = this.RecPrint(auxtree01); - ntb = this.RecPrint(node.GetLeft()); - } else ntb = true ; - System.out.println(node.GetKey()); - if (node.GetHas_Right()){ - //auxtree01 = node.GetRight() ; - //ntb = this.RecPrint(auxtree01); - ntb = this.RecPrint(node.GetRight()); - } else ntb = true ; - return true ; - } - -} - diff --git a/typecheck/tests/BinaryTree.java b/typecheck/tests/BinaryTree.java deleted file mode 100644 index 18d1464..0000000 --- a/typecheck/tests/BinaryTree.java +++ /dev/null @@ -1,334 +0,0 @@ -class BinaryTree{ - public static void main(String[] a){ - System.out.println(new BT().Start()); - } -} - - -// This class invokes the methods to create a tree, -// insert, delete and serach for elements on it -class BT { - - public int Start(){ - Tree root ; - boolean ntb ; - int nti ; - - root = new Tree(); - ntb = root.Init(16); - ntb = root.Print(); - System.out.println(100000000); - ntb = root.Insert(8) ; - ntb = root.Print(); - ntb = root.Insert(24) ; - ntb = root.Insert(4) ; - ntb = root.Insert(12) ; - ntb = root.Insert(20) ; - ntb = root.Insert(28) ; - ntb = root.Insert(14) ; - ntb = root.Print(); - System.out.println(root.Search(24)); - System.out.println(root.Search(12)); - System.out.println(root.Search(16)); - System.out.println(root.Search(50)); - System.out.println(root.Search(12)); - ntb = root.Delete(12); - ntb = root.Print(); - System.out.println(root.Search(12)); - - return 0 ; - } - -} - -class Tree{ - Tree left ; - Tree right; - int key ; - boolean has_left ; - boolean has_right ; - Tree my_null ; - - // Initialize a node with a key value and no children - public boolean Init(int v_key){ - key = v_key ; - has_left = false ; - has_right = false ; - return true ; - } - - // Update the right child with rn - public boolean SetRight(Tree rn){ - right = rn ; - return true ; - } - - // Update the left child with ln - public boolean SetLeft(Tree ln){ - left = ln ; - return true ; - } - - public Tree GetRight(){ - return right ; - } - - public Tree GetLeft(){ - return left; - } - - public int GetKey(){ - return key ; - } - - public boolean SetKey(int v_key){ - key = v_key ; - return true ; - } - - public boolean GetHas_Right(){ - return has_right ; - } - - public boolean GetHas_Left(){ - return has_left ; - } - - public boolean SetHas_Left(boolean val){ - has_left = val ; - return true ; - } - - public boolean SetHas_Right(boolean val){ - has_right = val ; - return true ; - } - - // This method compares two integers and - // returns true if they are equal and false - // otherwise - public boolean Compare(int num1 , int num2){ - boolean ntb ; - int nti ; - - ntb = false ; - nti = num2 + 1 ; - if (num1 < num2) ntb = false ; - else if (!(num1 < nti)) ntb = false ; - else ntb = true ; - return ntb ; - } - - - // Insert a new element in the tree - public boolean Insert(int v_key){ - Tree new_node ; - boolean ntb ; - boolean cont ; - int key_aux ; - Tree current_node ; - - new_node = new Tree(); - ntb = new_node.Init(v_key) ; - current_node = this ; - cont = true ; - while (cont){ - key_aux = current_node.GetKey(); - if (v_key < key_aux){ - if (current_node.GetHas_Left()) - current_node = current_node.GetLeft() ; - else { - cont = false ; - ntb = current_node.SetHas_Left(true); - ntb = current_node.SetLeft(new_node); - } - } - else{ - if (current_node.GetHas_Right()) - current_node = current_node.GetRight() ; - else { - cont = false ; - ntb = current_node.SetHas_Right(true); - ntb = current_node.SetRight(new_node); - } - } - } - return true ; - } - - - // Delete an element from the tree - public boolean Delete(int v_key){ - Tree current_node ; - Tree parent_node ; - boolean cont ; - boolean found ; - boolean is_root ; - int key_aux ; - boolean ntb ; - - current_node = this ; - parent_node = this ; - cont = true ; - found = false ; - is_root = true ; - while (cont){ - key_aux = current_node.GetKey(); - if (v_key < key_aux) - if (current_node.GetHas_Left()){ - parent_node = current_node ; - current_node = current_node.GetLeft() ; - } - else cont = false ; - else - if (key_aux < v_key) - if (current_node.GetHas_Right()){ - parent_node = current_node ; - current_node = current_node.GetRight() ; - } - else cont = false ; - else { - if (is_root) - if ((!current_node.GetHas_Right()) && - (!current_node.GetHas_Left()) ) - ntb = true ; - else - ntb = this.Remove(parent_node,current_node); - else ntb = this.Remove(parent_node,current_node); - found = true ; - cont = false ; - } - is_root = false ; - } - return found ; - } - - - // Check if the element to be removed will use the - // righ or left subtree if one exists - public boolean Remove(Tree p_node, Tree c_node){ - boolean ntb ; - int auxkey1 ; - int auxkey2 ; - - if (c_node.GetHas_Left()) - ntb = this.RemoveLeft(p_node,c_node) ; - else - if (c_node.GetHas_Right()) - ntb = this.RemoveRight(p_node,c_node) ; - else { - auxkey1 = c_node.GetKey(); - //auxtree01 = p_node.GetLeft() ; - //auxkey2 = auxtree01.GetKey() ; - auxkey2 = (p_node.GetLeft()).GetKey() ; - if (this.Compare(auxkey1,auxkey2)) { - ntb = p_node.SetLeft(my_null); - ntb = p_node.SetHas_Left(false); - } - else { - ntb = p_node.SetRight(my_null); - ntb = p_node.SetHas_Right(false); - } - } - return true ; - } - - - // Copy the child key to the parent until a leaf is - // found and remove the leaf. This is done with the - // right subtree - public boolean RemoveRight(Tree p_node, Tree c_node){ - boolean ntb ; - - while (c_node.GetHas_Right()){ - //auxtree01 = c_node.GetRight() ; - //auxint02 = auxtree01.GetKey(); - //ntb = c_node.SetKey(auxint02); - ntb = c_node.SetKey((c_node.GetRight()).GetKey()); - p_node = c_node ; - c_node = c_node.GetRight() ; - } - ntb = p_node.SetRight(my_null); - ntb = p_node.SetHas_Right(false); - return true ; - } - - - // Copy the child key to the parent until a leaf is - // found and remove the leaf. This is done with the - // left subtree - public boolean RemoveLeft(Tree p_node, Tree c_node){ - boolean ntb ; - - while (c_node.GetHas_Left()){ - //auxtree01 = c_node.GetLeft() ; - //auxint02 = auxtree01.GetKey(); - //ntb = c_node.SetKey(auxint02); - ntb = c_node.SetKey((c_node.GetLeft()).GetKey()); - p_node = c_node ; - c_node = c_node.GetLeft() ; - } - ntb = p_node.SetLeft(my_null); - ntb = p_node.SetHas_Left(false); - return true ; - } - - // Search for an elemnt in the tree - public int Search(int v_key){ - boolean cont ; - int ifound ; - Tree current_node; - int key_aux ; - - current_node = this ; - cont = true ; - ifound = 0 ; - while (cont){ - key_aux = current_node.GetKey(); - if (v_key < key_aux) - if (current_node.GetHas_Left()) - current_node = current_node.GetLeft() ; - else cont = false ; - else - if (key_aux < v_key) - if (current_node.GetHas_Right()) - current_node = current_node.GetRight() ; - else cont = false ; - else { - ifound = 1 ; - cont = false ; - } - } - return ifound ; - } - - // Invoke the method to really print the tree elements - public boolean Print(){ - Tree current_node; - boolean ntb ; - - current_node = this ; - ntb = this.RecPrint(current_node); - return true ; - } - - // Print the elements of the tree - public boolean RecPrint(Tree node){ - boolean ntb ; - - if (node.GetHas_Left()){ - //auxtree01 = node.GetLeft() ; - //ntb = this.RecPrint(auxtree01); - ntb = this.RecPrint(node.GetLeft()); - } else ntb = true ; - System.out.println(node.GetKey()); - if (node.GetHas_Right()){ - //auxtree01 = node.GetRight() ; - //ntb = this.RecPrint(auxtree01); - ntb = this.RecPrint(node.GetRight()); - } else ntb = true ; - return true ; - } - -} - diff --git a/typecheck/tests/Branch-error.java b/typecheck/tests/Branch-error.java deleted file mode 100644 index bc58ff4..0000000 --- a/typecheck/tests/Branch-error.java +++ /dev/null @@ -1,11 +0,0 @@ -class Branch { - public static void main(String[] a) { - int a ; - a = 3 ; - - if (a) - System.out.println(1) ; - else - System.out.println(2) ; - } -} diff --git a/typecheck/tests/Branch.java b/typecheck/tests/Branch.java deleted file mode 100644 index 43df01f..0000000 --- a/typecheck/tests/Branch.java +++ /dev/null @@ -1,11 +0,0 @@ -class Branch { - public static void main(String[] a) { - boolean b ; - b = false ; - - if (b) - System.out.println(1) ; - else - System.out.println(2) ; - } -} diff --git a/typecheck/tests/BubbleSort-error.java b/typecheck/tests/BubbleSort-error.java deleted file mode 100644 index 97a1c1d..0000000 --- a/typecheck/tests/BubbleSort-error.java +++ /dev/null @@ -1,93 +0,0 @@ -class BubbleSort{ - public static void main(String[] a){ - System.out.println(new BBS().Start(10)); - } -} - - -// This class contains the array of integers and -// methods to initialize, print and sort the array -// using Bublesort -class BBS{ - - int[] number ; - int size ; - - // Invoke the Initialization, Sort and Printing - // Methods - public int Start(int sz){ - int aux01 ; - aux01 = this.Init(sz); - aux01 = this.Print(); - System.out.println(99999); - aux01 = this.Sort(); - aux01 = this.Print(); - return 0 ; - } - - - // Sort array of integers using Bublesort method - public int Sort(){ - int nt ; - int i ; - int aux02 ; - int aux04 ; - int aux05 ; - int aux06 ; - int aux07 ; - int j ; - int t ; - i = size - 1 ; - aux02 = 0 - 1 ; - while (aux02 < i) { - j = 1 ; - //aux03 = i+1 ; - while (j < (i+1)){ - aux07 = j - 1 ; - aux04 = number[aux07] ; - aux05 = number[j] ; - if (aux05 < aux04) { - aux06 = j - 1 ; - t = number[aux06] ; - number[aux06] = number[j] ; - number[j] = t; - } - else nt = 0 ; - j = j + 1 ; - } - i = i - 1 ; - } - return 0 ; - } - - // Printing method - public int Print(){ - int j ; - j = 0 ; - while (j < (size)) { - System.out.println(number[j]); - j = j + 1 ; - } - return 0 ; - } - - // Initialize array of integers - public int Init(int sz){ - size = sz1 ; //TE - number = new int[sz] ; - - number[0] = 20 ; - number[1] = 7 ; - number[2] = 12 ; - number[3] = 18 ; - number[4] = 2 ; - number[5] = 11 ; - number[6] = 6 ; - number[7] = 9 ; - number[8] = 19 ; - number[9] = 5 ; - - return 0 ; - } - -} diff --git a/typecheck/tests/BubbleSort.java b/typecheck/tests/BubbleSort.java deleted file mode 100644 index e5645a9..0000000 --- a/typecheck/tests/BubbleSort.java +++ /dev/null @@ -1,93 +0,0 @@ -class BubbleSort{ - public static void main(String[] a){ - System.out.println(new BBS().Start(10)); - } -} - - -// This class contains the array of integers and -// methods to initialize, print and sort the array -// using Bublesort -class BBS{ - - int[] number ; - int size ; - - // Invoke the Initialization, Sort and Printing - // Methods - public int Start(int sz){ - int aux01 ; - aux01 = this.Init(sz); - aux01 = this.Print(); - System.out.println(99999); - aux01 = this.Sort(); - aux01 = this.Print(); - return 0 ; - } - - - // Sort array of integers using Bublesort method - public int Sort(){ - int nt ; - int i ; - int aux02 ; - int aux04 ; - int aux05 ; - int aux06 ; - int aux07 ; - int j ; - int t ; - i = size - 1 ; - aux02 = 0 - 1 ; - while (aux02 < i) { - j = 1 ; - //aux03 = i+1 ; - while (j < (i+1)){ - aux07 = j - 1 ; - aux04 = number[aux07] ; - aux05 = number[j] ; - if (aux05 < aux04) { - aux06 = j - 1 ; - t = number[aux06] ; - number[aux06] = number[j] ; - number[j] = t; - } - else nt = 0 ; - j = j + 1 ; - } - i = i - 1 ; - } - return 0 ; - } - - // Printing method - public int Print(){ - int j ; - j = 0 ; - while (j < (size)) { - System.out.println(number[j]); - j = j + 1 ; - } - return 0 ; - } - - // Initialize array of integers - public int Init(int sz){ - size = sz ; - number = new int[sz] ; - - number[0] = 20 ; - number[1] = 7 ; - number[2] = 12 ; - number[3] = 18 ; - number[4] = 2 ; - number[5] = 11 ; - number[6] = 6 ; - number[7] = 9 ; - number[8] = 19 ; - number[9] = 5 ; - - return 0 ; - } - -} diff --git a/typecheck/tests/DeclareNone.java b/typecheck/tests/DeclareNone.java deleted file mode 100644 index 0790056..0000000 --- a/typecheck/tests/DeclareNone.java +++ /dev/null @@ -1,6 +0,0 @@ -class DeclareNone{ - public static void main(String[] a){ - A a ; // 'A' does not exist - a = new A() ; - } -} diff --git a/typecheck/tests/Empty.java b/typecheck/tests/Empty.java deleted file mode 100644 index 975ac63..0000000 --- a/typecheck/tests/Empty.java +++ /dev/null @@ -1,5 +0,0 @@ -class Empty { - public static void main(String[] a) { - System.out.println(1); - } -} diff --git a/typecheck/tests/Factorial-error.java b/typecheck/tests/Factorial-error.java deleted file mode 100644 index 46ec59a..0000000 --- a/typecheck/tests/Factorial-error.java +++ /dev/null @@ -1,16 +0,0 @@ -class Factorial{ - public static void main(String[] a){ - System.out.println(new Fac().ComputeFac(10)); - } -} - -class Fac { - public boolean ComputeFac(int num){ //TE - int num_aux ; - if (num < 1) - num_aux = 1 ; - else - num_aux = num * (this.ComputeFac(num-1)) ; - return num_aux ; - } -} diff --git a/typecheck/tests/Factorial.java b/typecheck/tests/Factorial.java deleted file mode 100644 index d938bb6..0000000 --- a/typecheck/tests/Factorial.java +++ /dev/null @@ -1,16 +0,0 @@ -class Factorial{ - public static void main(String[] a){ - System.out.println(new Fac().ComputeFac(10)); - } -} - -class Fac { - public int ComputeFac(int num){ - int num_aux ; - if (num < 1) - num_aux = 1 ; - else - num_aux = num * (this.ComputeFac(num-1)) ; - return num_aux ; - } -} diff --git a/typecheck/tests/FactorialEdit.java b/typecheck/tests/FactorialEdit.java deleted file mode 100644 index 919ed82..0000000 --- a/typecheck/tests/FactorialEdit.java +++ /dev/null @@ -1,20 +0,0 @@ -class Factorial{ - public static void main(String[] a){ - System.out.println(new Fac().ComputeFac(10)); - } -} - -class Fac { - int[] useless_var ; - public int ComputeFac(int num){ - int num_aux ; - if (num < 1) - num_aux = 1 ; - else - num_aux = num * (this.ComputeFac(num-1)) ; - return num_aux ; - } -} - -class Fac2 extends Fac { -} diff --git a/typecheck/tests/IsPositive.java b/typecheck/tests/IsPositive.java deleted file mode 100644 index 09bcf1d..0000000 --- a/typecheck/tests/IsPositive.java +++ /dev/null @@ -1,29 +0,0 @@ -class IsPositive{ - public static void main(String[] a){ - System.out.println(new Positive().isPositive(10)); - } -} - -class Positive { - public boolean isPositive(int num){ - boolean positive ; - - if (0 < num) - positive = true ; - else - positive = false ; - return positive ; - } -} - -class Positive2 extends Positive { - public boolean isPositive(int num){ - boolean positive ; - - if (0 < num) - positive = true ; - else - positive = false ; - return positive ; - } -} diff --git a/typecheck/tests/LinearSearch-error.java b/typecheck/tests/LinearSearch-error.java deleted file mode 100644 index f8c48fe..0000000 --- a/typecheck/tests/LinearSearch-error.java +++ /dev/null @@ -1,99 +0,0 @@ -class LinearSearch{ - public static void main(String[] a){ - System.out.println(new LS().Start(10)); - } -} - - -// This class contains an array of integers and -// methods to initialize, print and search the array -// using Linear Search -class LS { - int number ; //TE - int size ; - - // Invoke methods to initialize, print and search - // for elements on the array - public int Start(int sz){ - int aux01 ; - int aux02 ; - - aux01 = this.Init(sz); - aux02 = this.Print(); - System.out.println(9999); - System.out.println(this.Search(8)); - System.out.println(this.Search(12)) ; - System.out.println(this.Search(17)) ; - System.out.println(this.Search(50)) ; - return 55 ; - } - - // Print array of integers - public int Print(){ - int j ; - - j = 1 ; - while (j < (size)) { - System.out.println(number[j]); - j = j + 1 ; - } - return 0 ; - } - - // Search for a specific value (num) using - // linear search - public int Search(int num){ - int j ; - boolean ls01 ; - int ifound ; - int aux01 ; - int aux02 ; - int nt ; - - j = 1 ; - ls01 = false ; - ifound = 0 ; - - //System.out.println(num); - while (j < (size)) { - aux01 = number[j] ; - aux02 = num + 1 ; - if (aux01 < num) nt = 0 ; - else if (!(aux01 < aux02)) nt = 0 ; - else { - ls01 = true ; - ifound = 1 ; - j = size ; - } - j = j + 1 ; - } - - return ifound ; - } - - - - // initialize array of integers with some - // some sequence - public int Init(int sz){ - int j ; - int k ; - int aux01 ; - int aux02 ; - - size = sz ; - number = new int[sz] ; - - j = 1 ; - k = size + 1 ; - while (j < (size)) { - aux01 = 2 * j ; - aux02 = k - 3 ; - number[j] = aux01 + aux02 ; - j = j + 1 ; - k = k - 1 ; - } - return 0 ; - } - -} diff --git a/typecheck/tests/LinearSearch.java b/typecheck/tests/LinearSearch.java deleted file mode 100644 index daddd94..0000000 --- a/typecheck/tests/LinearSearch.java +++ /dev/null @@ -1,99 +0,0 @@ -class LinearSearch{ - public static void main(String[] a){ - System.out.println(new LS().Start(10)); - } -} - - -// This class contains an array of integers and -// methods to initialize, print and search the array -// using Linear Search -class LS { - int[] number ; - int size ; - - // Invoke methods to initialize, print and search - // for elements on the array - public int Start(int sz){ - int aux01 ; - int aux02 ; - - aux01 = this.Init(sz); - aux02 = this.Print(); - System.out.println(9999); - System.out.println(this.Search(8)); - System.out.println(this.Search(12)) ; - System.out.println(this.Search(17)) ; - System.out.println(this.Search(50)) ; - return 55 ; - } - - // Print array of integers - public int Print(){ - int j ; - - j = 1 ; - while (j < (size)) { - System.out.println(number[j]); - j = j + 1 ; - } - return 0 ; - } - - // Search for a specific value (num) using - // linear search - public int Search(int num){ - int j ; - boolean ls01 ; - int ifound ; - int aux01 ; - int aux02 ; - int nt ; - - j = 1 ; - ls01 = false ; - ifound = 0 ; - - //System.out.println(num); - while (j < (size)) { - aux01 = number[j] ; - aux02 = num + 1 ; - if (aux01 < num) nt = 0 ; - else if (!(aux01 < aux02)) nt = 0 ; - else { - ls01 = true ; - ifound = 1 ; - j = size ; - } - j = j + 1 ; - } - - return ifound ; - } - - - - // initialize array of integers with some - // some sequence - public int Init(int sz){ - int j ; - int k ; - int aux01 ; - int aux02 ; - - size = sz ; - number = new int[sz] ; - - j = 1 ; - k = size + 1 ; - while (j < (size)) { - aux01 = 2 * j ; - aux02 = k - 3 ; - number[j] = aux01 + aux02 ; - j = j + 1 ; - k = k - 1 ; - } - return 0 ; - } - -} diff --git a/typecheck/tests/LinkedList-error.java b/typecheck/tests/LinkedList-error.java deleted file mode 100644 index 181b599..0000000 --- a/typecheck/tests/LinkedList-error.java +++ /dev/null @@ -1,278 +0,0 @@ -class LinkedList{ - public static void main(String[] a){ - System.out.println(new LL().Start()); - } -} - -class Element { - int Age ; - int Salary ; - boolean Married ; - - // Initialize some class variables - public boolean Init(int v_Age, int v_Salary, boolean v_Married){ - Age = v_Age ; - Salary = v_Salary ; - Married = v_Married ; - return true ; - } - - public int GetAge(){ - return Age ; - } - - public int GetSalary(){ - return Salary ; - } - - public boolean GetMarried(){ - return Married ; - } - - // This method returns true if the object "other" - // has the same values for age, salary and - public boolean Equal(Element other){ - boolean ret_val ; - int aux01 ; - int aux02 ; - int nt ; - ret_val = true ; - - aux01 = other.GetAge(); - if (!this.Compare(aux01,Age)) ret_val = false ; - else { - aux02 = other.GetSalary(); - if (!this.Compare(aux02,Salary)) ret_val = false ; - else - if (Married) - if (!other.GetMarried()) ret_val = false; - else nt = 0 ; - else - if (other.GetMarried()) ret_val = false; - else nt = 0 ; - } - - return ret_val ; - } - - // This method compares two integers and - // returns true if they are equal and false - // otherwise - public boolean Compare(int num1 , int num2){ - boolean retval ; - int aux02 ; - retval = false ; - aux02 = num2 + 1 ; - if (num1 < num2) retval = false ; - else if (!(num1 < aux02)) retval = false ; - else retval = true ; - return retval ; - } - -} - -class List{ - Element elem ; - List next ; - boolean end ; - - // Initialize the node list as the last node - public boolean Init(){ - end = true ; - return true ; - } - - // Initialize the values of a new node - public boolean InitNew(Element v_elem, List v_next, boolean v_end){ - end = v_end ; - elem = v_elem ; - next = v_next ; - return true ; - } - - // Insert a new node at the beginning of the list - public List Insert(Element new_elem){ - boolean ret_val ; - List aux03 ; - List aux02 ; - aux03 = this ; - aux02 = new List(); - ret_val = aux02.InitNew(new_elem,aux03,false); - return aux02 ; - } - - - // Update the the pointer to the next node - public boolean SetNext(List v_next){ - next = v_next ; - return 0 ; //TE - } - - // Delete an element e from the list - public List Delete(Element e){ - List my_head ; - boolean ret_val ; - boolean aux05; - List aux01 ; - List prev ; - boolean var_end ; - Element var_elem ; - int aux04 ; - int nt ; - - - my_head = this ; - ret_val = false ; - aux04 = 0 - 1 ; - aux01 = this ; - prev = this ; - var_end = end; - var_elem = elem ; - while ((!var_end) && (!ret_val)){ - if (e.Equal(var_elem)){ - ret_val = true ; - if (aux04 < 0) { - // delete first element - my_head = aux01.GetNext() ; - } - else{ // delete a non first element - System.out.println(0-555); - aux05 = prev.SetNext(aux01.GetNext()); - System.out.println(0-555); - - } - } else nt = 0 ; - if (!ret_val){ - prev = aux01 ; - aux01 = aux01.GetNext() ; - var_end = aux01.GetEnd(); - var_elem = aux01.GetElem(); - aux04 = 1 ; - } else nt = 0 ; - } - return my_head ; - } - - - // Search for an element e on the list - public int Search(Element e){ - int int_ret_val ; - List aux01 ; - Element var_elem ; - boolean var_end ; - int nt ; - - int_ret_val = 0 ; - aux01 = this ; - var_end = end; - var_elem = elem ; - while (!var_end){ - if (e.Equal(var_elem)){ - int_ret_val = 1 ; - } - else nt = 0 ; - aux01 = aux01.GetNext() ; - var_end = aux01.GetEnd(); - var_elem = aux01.GetElem(); - } - return int_ret_val ; - } - - public boolean GetEnd(){ - return end ; - } - - public Element GetElem(){ - return elem ; - } - - public List GetNext(){ - return next ; - } - - - // Print the linked list - public boolean Print(){ - List aux01 ; - boolean var_end ; - Element var_elem ; - - aux01 = this ; - var_end = end ; - var_elem = elem ; - while (!var_end){ - System.out.println(var_elem.GetAge()); - aux01 = aux01.GetNext() ; - var_end = aux01.GetEnd(); - var_elem = aux01.GetElem(); - } - - return true ; - } -} - - -// this class invokes the methods to insert, delete, -// search and print the linked list -class LL{ - - public int Start(){ - - List head ; - List last_elem ; - boolean aux01 ; - Element el01 ; - Element el02 ; - Element el03 ; - - last_elem = new List(); - aux01 = last_elem.Init(); - head = last_elem ; - aux01 = head.Init(); - aux01 = head.Print(); - - // inserting first element - el01 = new Element(); - aux01 = el01.Init(25,37000,false); - head = head.Insert(el01); - aux01 = head.Print(); - System.out.println(10000000); - // inserting second element - el01 = new Element(); - aux01 = el01.Init(39,42000,true); - el02 = el01 ; - head = head.Insert(el01); - aux01 = head.Print(); - System.out.println(10000000); - // inserting third element - el01 = new Element(); - aux01 = el01.Init(22,34000,false); - head = head.Insert(el01); - aux01 = head.Print(); - el03 = new Element(); - aux01 = el03.Init(27,34000,false); - System.out.println(head.Search(el02)); - System.out.println(head.Search(el03)); - System.out.println(10000000); - // inserting fourth element - el01 = new Element(); - aux01 = el01.Init(28,35000,false); - head = head.Insert(el01); - aux01 = head.Print(); - System.out.println(2220000); - - head = head.Delete(el02); - aux01 = head.Print(); - System.out.println(33300000); - - - head = head.Delete(el01); - aux01 = head.Print(); - System.out.println(44440000); - - return 0 ; - - - } - -} diff --git a/typecheck/tests/LinkedList.java b/typecheck/tests/LinkedList.java deleted file mode 100644 index 69adc33..0000000 --- a/typecheck/tests/LinkedList.java +++ /dev/null @@ -1,278 +0,0 @@ -class LinkedList{ - public static void main(String[] a){ - System.out.println(new LL().Start()); - } -} - -class Element { - int Age ; - int Salary ; - boolean Married ; - - // Initialize some class variables - public boolean Init(int v_Age, int v_Salary, boolean v_Married){ - Age = v_Age ; - Salary = v_Salary ; - Married = v_Married ; - return true ; - } - - public int GetAge(){ - return Age ; - } - - public int GetSalary(){ - return Salary ; - } - - public boolean GetMarried(){ - return Married ; - } - - // This method returns true if the object "other" - // has the same values for age, salary and - public boolean Equal(Element other){ - boolean ret_val ; - int aux01 ; - int aux02 ; - int nt ; - ret_val = true ; - - aux01 = other.GetAge(); - if (!this.Compare(aux01,Age)) ret_val = false ; - else { - aux02 = other.GetSalary(); - if (!this.Compare(aux02,Salary)) ret_val = false ; - else - if (Married) - if (!other.GetMarried()) ret_val = false; - else nt = 0 ; - else - if (other.GetMarried()) ret_val = false; - else nt = 0 ; - } - - return ret_val ; - } - - // This method compares two integers and - // returns true if they are equal and false - // otherwise - public boolean Compare(int num1 , int num2){ - boolean retval ; - int aux02 ; - retval = false ; - aux02 = num2 + 1 ; - if (num1 < num2) retval = false ; - else if (!(num1 < aux02)) retval = false ; - else retval = true ; - return retval ; - } - -} - -class List{ - Element elem ; - List next ; - boolean end ; - - // Initialize the node list as the last node - public boolean Init(){ - end = true ; - return true ; - } - - // Initialize the values of a new node - public boolean InitNew(Element v_elem, List v_next, boolean v_end){ - end = v_end ; - elem = v_elem ; - next = v_next ; - return true ; - } - - // Insert a new node at the beginning of the list - public List Insert(Element new_elem){ - boolean ret_val ; - List aux03 ; - List aux02 ; - aux03 = this ; - aux02 = new List(); - ret_val = aux02.InitNew(new_elem,aux03,false); - return aux02 ; - } - - - // Update the the pointer to the next node - public boolean SetNext(List v_next){ - next = v_next ; - return true ; - } - - // Delete an element e from the list - public List Delete(Element e){ - List my_head ; - boolean ret_val ; - boolean aux05; - List aux01 ; - List prev ; - boolean var_end ; - Element var_elem ; - int aux04 ; - int nt ; - - - my_head = this ; - ret_val = false ; - aux04 = 0 - 1 ; - aux01 = this ; - prev = this ; - var_end = end; - var_elem = elem ; - while ((!var_end) && (!ret_val)){ - if (e.Equal(var_elem)){ - ret_val = true ; - if (aux04 < 0) { - // delete first element - my_head = aux01.GetNext() ; - } - else{ // delete a non first element - System.out.println(0-555); - aux05 = prev.SetNext(aux01.GetNext()); - System.out.println(0-555); - - } - } else nt = 0 ; - if (!ret_val){ - prev = aux01 ; - aux01 = aux01.GetNext() ; - var_end = aux01.GetEnd(); - var_elem = aux01.GetElem(); - aux04 = 1 ; - } else nt = 0 ; - } - return my_head ; - } - - - // Search for an element e on the list - public int Search(Element e){ - int int_ret_val ; - List aux01 ; - Element var_elem ; - boolean var_end ; - int nt ; - - int_ret_val = 0 ; - aux01 = this ; - var_end = end; - var_elem = elem ; - while (!var_end){ - if (e.Equal(var_elem)){ - int_ret_val = 1 ; - } - else nt = 0 ; - aux01 = aux01.GetNext() ; - var_end = aux01.GetEnd(); - var_elem = aux01.GetElem(); - } - return int_ret_val ; - } - - public boolean GetEnd(){ - return end ; - } - - public Element GetElem(){ - return elem ; - } - - public List GetNext(){ - return next ; - } - - - // Print the linked list - public boolean Print(){ - List aux01 ; - boolean var_end ; - Element var_elem ; - - aux01 = this ; - var_end = end ; - var_elem = elem ; - while (!var_end){ - System.out.println(var_elem.GetAge()); - aux01 = aux01.GetNext() ; - var_end = aux01.GetEnd(); - var_elem = aux01.GetElem(); - } - - return true ; - } -} - - -// this class invokes the methods to insert, delete, -// search and print the linked list -class LL{ - - public int Start(){ - - List head ; - List last_elem ; - boolean aux01 ; - Element el01 ; - Element el02 ; - Element el03 ; - - last_elem = new List(); - aux01 = last_elem.Init(); - head = last_elem ; - aux01 = head.Init(); - aux01 = head.Print(); - - // inserting first element - el01 = new Element(); - aux01 = el01.Init(25,37000,false); - head = head.Insert(el01); - aux01 = head.Print(); - System.out.println(10000000); - // inserting second element - el01 = new Element(); - aux01 = el01.Init(39,42000,true); - el02 = el01 ; - head = head.Insert(el01); - aux01 = head.Print(); - System.out.println(10000000); - // inserting third element - el01 = new Element(); - aux01 = el01.Init(22,34000,false); - head = head.Insert(el01); - aux01 = head.Print(); - el03 = new Element(); - aux01 = el03.Init(27,34000,false); - System.out.println(head.Search(el02)); - System.out.println(head.Search(el03)); - System.out.println(10000000); - // inserting fourth element - el01 = new Element(); - aux01 = el01.Init(28,35000,false); - head = head.Insert(el01); - aux01 = head.Print(); - System.out.println(2220000); - - head = head.Delete(el02); - aux01 = head.Print(); - System.out.println(33300000); - - - head = head.Delete(el01); - aux01 = head.Print(); - System.out.println(44440000); - - return 0 ; - - - } - -} diff --git a/typecheck/tests/MoreThan4-error.java b/typecheck/tests/MoreThan4-error.java deleted file mode 100644 index 9e8f63e..0000000 --- a/typecheck/tests/MoreThan4-error.java +++ /dev/null @@ -1,29 +0,0 @@ -class MoreThan4{ - public static void main(String[] a){ - System.out.println(new MT4().Start(1,2,3,4,5,6)); - } -} - -class MT4 { - public int Start(int p1, int p2, int p3 , int p4, int p5, int p6){ - int aux ; - System.out.println(p1); - System.out.println(p2); - System.out.println(p3); - System.out.println(p4); - System.out.println(p5); - System.out.println(p6); - aux = this.Change(p6,p5,p4,p3,p2);//TE - return aux ; - } - - public int Change(int p1, int p2, int p3 , int p4, int p5, int p6){ - System.out.println(p1); - System.out.println(p2); - System.out.println(p3); - System.out.println(p4); - System.out.println(p5); - System.out.println(p6); - return 0 ; - } -} diff --git a/typecheck/tests/MoreThan4.java b/typecheck/tests/MoreThan4.java deleted file mode 100644 index 4960f01..0000000 --- a/typecheck/tests/MoreThan4.java +++ /dev/null @@ -1,29 +0,0 @@ -class MoreThan4{ - public static void main(String[] a){ - System.out.println(new MT4().Start(1,2,3,4,5,6)); - } -} - -class MT4 { - public int Start(int p1, int p2, int p3 , int p4, int p5, int p6){ - int aux ; - System.out.println(p1); - System.out.println(p2); - System.out.println(p3); - System.out.println(p4); - System.out.println(p5); - System.out.println(p6); - aux = this.Change(p6,p5,p4,p3,p2,p1); - return aux ; - } - - public int Change(int p1, int p2, int p3 , int p4, int p5, int p6){ - System.out.println(p1); - System.out.println(p2); - System.out.println(p3); - System.out.println(p4); - System.out.println(p5); - System.out.println(p6); - return 0 ; - } -} diff --git a/typecheck/tests/NewNone.java b/typecheck/tests/NewNone.java deleted file mode 100644 index 7858853..0000000 --- a/typecheck/tests/NewNone.java +++ /dev/null @@ -1,9 +0,0 @@ -class NewNone{ - public static void main(String[] a){ - A a ; - a = new A() ; - } -} - -class A { -} diff --git a/typecheck/tests/Operator.java b/typecheck/tests/Operator.java deleted file mode 100644 index 732c905..0000000 --- a/typecheck/tests/Operator.java +++ /dev/null @@ -1,15 +0,0 @@ -class test01{ - public static void main(String[] a){ - System.out.println(new Operator().compute()); - } -} - -class Operator{ - - boolean result; - - public int compute(){ - result = true && false; - return 0; - } -} diff --git a/typecheck/tests/Printer-error.java b/typecheck/tests/Printer-error.java deleted file mode 100644 index 3f6469f..0000000 --- a/typecheck/tests/Printer-error.java +++ /dev/null @@ -1,5 +0,0 @@ -class Printer{ - public static void main(String[] a){ - System.out.println(false); - } -} diff --git a/typecheck/tests/Printer.java b/typecheck/tests/Printer.java deleted file mode 100644 index 3c4fa2f..0000000 --- a/typecheck/tests/Printer.java +++ /dev/null @@ -1,5 +0,0 @@ -class Printer{ - public static void main(String[] a){ - // System.out.println(0); - } -} diff --git a/typecheck/tests/QuickSort-error.java b/typecheck/tests/QuickSort-error.java deleted file mode 100644 index ff4ea2e..0000000 --- a/typecheck/tests/QuickSort-error.java +++ /dev/null @@ -1,112 +0,0 @@ -class QuickSort{ - public static void main(String[] a){ - System.out.println(new QS().Start(10)); - } -} - - -// This class contains the array of integers and -// methods to initialize, print and sort the array -// using Quicksort -class QS{ - - int number ; //TE - int size ; - - // Invoke the Initialization, Sort and Printing - // Methods - public int Start(int sz){ - int aux01 ; - aux01 = this.Init(sz); - aux01 = this.Print(); - System.out.println(9999); - aux01 = size - 1 ; - aux01 = this.Sort(0,aux01); - aux01 = this.Print(); - return 0 ; - } - - - // Sort array of integers using Quicksort method - public int Sort(int left, int right){ - int v ; - int i ; - int j ; - int nt; - int t ; - boolean cont01; - boolean cont02; - int aux03 ; - t = 0 ; - if (left < right){ - v = number[right] ; - i = left - 1 ; - j = right ; - cont01 = true ; - while (cont01){ - cont02 = true ; - while (cont02){ - i = i + 1 ; - aux03 = number[i] ; - if (!(aux03