diff --git a/CharArgument.class b/CharArgument.class
deleted file mode 100644
index cc8c57d..0000000
Binary files a/CharArgument.class and /dev/null differ
diff --git a/ClassFields.class b/ClassFields.class
deleted file mode 100644
index 9f70823..0000000
Binary files a/ClassFields.class and /dev/null differ
diff --git a/ClassOne.class b/ClassOne.class
deleted file mode 100644
index 6c40c2f..0000000
Binary files a/ClassOne.class and /dev/null differ
diff --git a/ClassTwo.class b/ClassTwo.class
deleted file mode 100644
index b943fe7..0000000
Binary files a/ClassTwo.class and /dev/null differ
diff --git a/ConstructorParams.class b/ConstructorParams.class
deleted file mode 100644
index 7c2a9ec..0000000
Binary files a/ConstructorParams.class and /dev/null differ
diff --git a/ConstructorThisDot.class b/ConstructorThisDot.class
deleted file mode 100644
index 402b19a..0000000
Binary files a/ConstructorThisDot.class and /dev/null differ
diff --git a/DivMethod.class b/DivMethod.class
deleted file mode 100644
index e11ee7f..0000000
Binary files a/DivMethod.class and /dev/null differ
diff --git a/Fakultaet.class b/Fakultaet.class
deleted file mode 100644
index 117327b..0000000
Binary files a/Fakultaet.class and /dev/null differ
diff --git a/FieldVar.class b/FieldVar.class
deleted file mode 100644
index 5844709..0000000
Binary files a/FieldVar.class and /dev/null differ
diff --git a/FieldWithExpr.class b/FieldWithExpr.class
deleted file mode 100644
index aa8d31f..0000000
Binary files a/FieldWithExpr.class and /dev/null differ
diff --git a/GetterFunction.class b/GetterFunction.class
deleted file mode 100644
index 05a02e8..0000000
Binary files a/GetterFunction.class and /dev/null differ
diff --git a/Grammatik.txt b/Grammatik.txt
deleted file mode 100644
index 91c85f5..0000000
--- a/Grammatik.txt
+++ /dev/null
@@ -1,166 +0,0 @@
-Grammatik:
-
-1. Ausdrücke
-
-Primary:
- Literal
- Variable
- IncDecExpression
- ( Expression )
- MethodInvocation
-
-Variable:
- Identifier { [ Expression ] }
-
-Identifier:
- [ Identifier . ] Name
-
-IncDecExpression:
- Variable IncDec
- IncDec Variable
-
-IncDec:
- ++ | --
-
-Expression:
- UnaryExpression
- BinaryExpression
- AssignmentExpression
- MethodInvocation
- CreationExpression
-
-UnaryExpression:
- Primary
- UnaryExpression
- UnaryOperator
- + | - | ! | ...
-
-BinaryExpression:
- Expression BinaryOperator Expression
-
-BinaryOperator:
- == | + | - | * | / | & | && | | | || |
-
-
-AssignmentExpression:
- Variable = Expression
-
-MethodInvocation:
- Method ( [ ActualArguments ] )
-
-Method:
- Identifier
-
-ActualArguments:
- Expression { , Expression }
-
-CreationExpression:
- new ClassIdentifier ( [ ActualArguments ] )
-
-
-
-2. Anweisungen
-
-Statement:
- SimpleStatement
- CompositeStatement
- Label : Statement
-
-SimpleStatement:
- EmptyStatement
- StatementExpression
- EmptyStatement ;
- ReturnStatement
-
-StatementExpression:
- AssignmentExpression
- IncDecExpression
- MethodInvocation
- CreationExpression
-
-ContinueStatement:
- continue [ Name ] ;
-
-ReturnStatement.
- return [ Expression ] ;
-
-
-CompositeStatement:
- Block
- CaseStatement
-
-Block:
- "{" { VariableDeclaration | Statement } "}"
-
-VariableDeclaration:
- Type VariableDeclarator ;
-
-VariableDeclarator:
- Name [ = Expression ]
-
-Type:
- Name # konkrete Typen hinzufügen
- Identifier
-
-CaseStatement: # Andere CaseStatements heraussuchen. Assign, MethodCall,
- ConditionalStatement
- WhileStatement
-
-
-ConditionalStatement:
- if ( Expression ) Statement [ else Statement ]
-
-ConstantExpression:
- Expression
-
-WhileStatement:
- while ( Expression ) Statement
-
-Initialization:
- StatementExpression { , StatementExpression }
- VariableDeclaration
-
-
-3. Methoden
-
-MethodDeclaration:
- MethodHeader Block
-
-MethodHeader:
- { Modifier } ResultType MethodDeclarator
-
-Modifier:
- public | static | ...
-
-ResultType:
- Type | void
-
-MethodDeclarator:
- Identifier "(" [ FormalArguments ] ")"
-
-FormalArguments:
- FormalArgument { , FormalArgument }
-
-FormalArgument:
- Type Name
-
-
-
-4. Klassen
-
-Start:
- ClassDeclaration {ClassDeclaration}
-
-ClassDeclaration:
- [ public ] class Name ClassBody
-
-ClassBody:
- "{" { { Modifier } Declaration } "}"
-
-Declaration:
- VariableDeclaration
- MethodDeclaration
- ConstructorDeclaration
-
-ConstructorDeclaration:
- [ public ] Name ( [ FormalArguments ] ) Block
diff --git a/IfElseIfStatement.class b/IfElseIfStatement.class
deleted file mode 100644
index 34c23f7..0000000
Binary files a/IfElseIfStatement.class and /dev/null differ
diff --git a/IfElseIfStatementWithOneReturn.class b/IfElseIfStatementWithOneReturn.class
deleted file mode 100644
index f178e46..0000000
Binary files a/IfElseIfStatementWithOneReturn.class and /dev/null differ
diff --git a/NichtHaskell.iml b/NichtHaskell.iml
deleted file mode 100644
index fbfe57d..0000000
--- a/NichtHaskell.iml
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/classWithMain.class b/classWithMain.class
deleted file mode 100644
index 225b708..0000000
Binary files a/classWithMain.class and /dev/null differ
diff --git a/emptyClass.class b/emptyClass.class
deleted file mode 100644
index 04d67f5..0000000
Binary files a/emptyClass.class and /dev/null differ
diff --git a/getI.class b/getI.class
deleted file mode 100644
index 2e0ab59..0000000
Binary files a/getI.class and /dev/null differ
diff --git a/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java b/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java
index 2c241c2..f0ca7e4 100644
--- a/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java
+++ b/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java
@@ -140,7 +140,7 @@ public class BlockStatement extends AbstractType implements IStatement {
&& Objects.equals(statements, blockStatement.statements
/*&& (Objects.equals(localVars, blockStatement.localVars)*/
);
- System.out.println("In ParameterList: " + result);
+ System.out.println("In BlockStatement: " + result);
return result;
}
diff --git a/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java b/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java
index 7190bf8..77a4b62 100644
--- a/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java
+++ b/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java
@@ -71,7 +71,7 @@ public class ReturnStatement extends AbstractType implements IStatement{
boolean result = (Objects.equals(expression, returnStatement.expression)
&& Objects.equals(expression.getTypeCheckResult(), returnStatement.expression.getTypeCheckResult())
);
- System.out.println("In PrintStatement: " + result);
+ System.out.println("In ReturnStatement: " + result);
return result;
}
diff --git a/src/test/java/AST/testAll.java b/src/test/java/AST/testAll.java
index 91923e4..72cee70 100644
--- a/src/test/java/AST/testAll.java
+++ b/src/test/java/AST/testAll.java
@@ -12,12 +12,47 @@ public class testAll {
}
+ @Test
+ public void testAssignWrongType(){
+ Program ast = AssignWrongTypeAST.getProgram();
+ String pathToCode = "failTests/AssignWrongType.java";
+ testAst(ast, pathToCode);
+ }
+
+ @Test
+ public void testCharArgument(){
+ Program ast = CharArgumentAST.getProgram();
+ String pathToCode = "SimpleTests/CharArgument.java";
+ testAst(ast, pathToCode);
+ }
+
@Test
public void testClassWithMain(){
Program ast = ClassWithMainAST.getProgram();
String pathToCode = "basicClasses/classWithMain.java";
testAst(ast, pathToCode);
}
+
+ @Test
+ public void testConstructorThisDot(){
+ Program ast = ConstructorThisDotAST.getProgram();
+ String pathToCode = "SimpleTests/ConstructorThisDot.java";
+ testAst(ast, pathToCode);
+ }
+
+ @Test
+ public void testConstructorParams(){
+ Program ast = ConstructorParamsAST.getProgram();
+ String pathToCode = "SimpleTests/ConstructorParams.java";
+ testAst(ast, pathToCode);
+ }
+
+ @Test
+ public void testDivideByZero(){
+ Program ast = DivideByZeroAST.getProgram();
+ String pathToCode = "failTests/DivideByzero.java";
+ testAst(ast, pathToCode);
+ }
@Test
public void testEmptyClass(){
Program ast = emptyClassAST.getEmptyProgramm();
@@ -40,24 +75,16 @@ public class testAll {
}
@Test
- public void testAssignWrongType(){
- Program ast = AssignWrongTypeAST.getProgram();
- String pathToCode = "failTests/AssignWrongType.java";
- testAst(ast, pathToCode);
- }
-
-
- @Test
- public void testDivideByZero(){
- Program ast = DivideByZeroAST.getProgram();
- String pathToCode = "failTests/DivideByzero.java";
+ public void testFieldVariable(){
+ Program ast = FieldVarAST.getProgram();
+ String pathToCode = "SimpleTests/FieldVar.java";
testAst(ast, pathToCode);
}
@Test
- public void testcharArgument(){
- Program ast = CharArgumentAST.getProgram();
- String pathToCode = "SimpleTests/CharArgument.java";
+ public void testIfElseIfStatementWithOneReturne(){
+ Program ast = IfElseIfStatementWithOneReturnAST.getProgram();
+ String pathToCode = "SimpleTests/IfElseIfStatementWithOneReturn.java";
testAst(ast, pathToCode);
}
diff --git a/src/test/java/ASTs/ConstructorParamsAST.java b/src/test/java/ASTs/ConstructorParamsAST.java
new file mode 100644
index 0000000..f1a2554
--- /dev/null
+++ b/src/test/java/ASTs/ConstructorParamsAST.java
@@ -0,0 +1,45 @@
+package ASTs;
+
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Parameter.Parameter;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+import abstractSyntaxTree.Statement.BlockStatement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConstructorParamsAST {
+
+ public static Program getProgram() {
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(getRefType());
+ Program program = new Program(refTypeList);
+
+ return program;
+ }
+
+ public static RefType getRefType() {
+
+ List fieldDeclList = new ArrayList<>();
+ List methodDeclList = new ArrayList<>();
+ methodDeclList.add(method0());
+ RefType refType = new RefType("ConstructorParams", fieldDeclList, methodDeclList, false);
+ return refType;
+ }
+
+ public static MethodDecl method0() {
+
+ Parameter parameter0 = new Parameter("int", "i");
+ List parameterList = new ArrayList<>();
+ parameterList.add(parameter0);
+ ParameterList parameterListObj = new ParameterList(parameterList);
+ BlockStatement blockStatement = new BlockStatement(new ArrayList<>(), null);
+ MethodDecl methodDecl = new MethodDecl("ConstructorParams", null, "ConstructorParams",
+ parameterListObj, blockStatement);
+
+ return methodDecl;
+ }
+}
diff --git a/src/test/java/ASTs/ConstructorParamsASTTyped.java b/src/test/java/ASTs/ConstructorParamsASTTyped.java
new file mode 100644
index 0000000..17c7490
--- /dev/null
+++ b/src/test/java/ASTs/ConstructorParamsASTTyped.java
@@ -0,0 +1,59 @@
+package ASTs;
+
+import Typecheck.TypingHelper;
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Parameter.Parameter;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+import abstractSyntaxTree.Statement.BlockStatement;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ConstructorParamsASTTyped {
+ public static Program getProgram() {
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(getRefType());
+ Program program = new Program(refTypeList);
+ addTyping(program);
+
+ return program;
+ }
+
+ public static RefType getRefType() {
+
+ List fieldDeclList = new ArrayList<>();
+ List methodDeclList = new ArrayList<>();
+ methodDeclList.add(method0());
+ RefType refType = new RefType("ConstructorParams", fieldDeclList, methodDeclList, false);
+ return refType;
+ }
+
+ public static MethodDecl method0() {
+
+ Parameter parameter0 = new Parameter("int", "i");
+ List parameterList = new ArrayList<>();
+ parameterList.add(parameter0);
+ ParameterList parameterListObj = new ParameterList(parameterList);
+ BlockStatement blockStatement = new BlockStatement(new ArrayList<>(), "void");
+ MethodDecl methodDecl = new MethodDecl("ConstructorParams", null, "ConstructorParams",
+ parameterListObj, blockStatement);
+
+ return methodDecl;
+ }
+
+ public static void addTyping(Program program){
+ // TypeContext
+ TypingHelper.addTypeContext(program, "ConstructorParams", new HashMap<>());
+
+ // MethodContext
+ HashMap method0 = new HashMap<>();
+ //method0.put("void", new ParameterList(new ArrayList<>()));
+ HashMap> methods = new HashMap<>();
+ //methods.put("main", method0);
+ TypingHelper.addMethodContext(program, "ConstructorParams", methods);
+ }
+}
diff --git a/src/test/java/ASTs/ConstructorThisDotAST.java b/src/test/java/ASTs/ConstructorThisDotAST.java
new file mode 100644
index 0000000..df734a8
--- /dev/null
+++ b/src/test/java/ASTs/ConstructorThisDotAST.java
@@ -0,0 +1,60 @@
+package ASTs;
+
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Expression.InstVarExpression;
+import abstractSyntaxTree.Expression.IntConstantExpression;
+import abstractSyntaxTree.Expression.SubReceiver;
+import abstractSyntaxTree.Parameter.Parameter;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+import abstractSyntaxTree.Statement.BlockStatement;
+import abstractSyntaxTree.Statement.IStatement;
+import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConstructorThisDotAST {
+ public static Program getProgram() {
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(getRefType());
+ Program program = new Program(refTypeList);
+
+ return program;
+ }
+
+ public static RefType getRefType() {
+
+ List fieldDeclList = new ArrayList<>();
+ fieldDeclList.add(new FieldDecl("int", "i", null));
+ List methodDeclList = new ArrayList<>();
+ methodDeclList.add(method0());
+ RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false);
+ return refType;
+ }
+
+ public static MethodDecl method0() {
+
+ List parameterList = new ArrayList<>();
+ ParameterList parameterListObj = new ParameterList(parameterList);
+ List iStatementList = new ArrayList<>();
+
+ SubReceiver subReceiver = new SubReceiver(true);
+ List subReceiverList = new ArrayList<>();
+ subReceiverList.add(subReceiver);
+ InstVarExpression instVarExpressionLeft = new InstVarExpression(subReceiverList, new ArrayList<>(), "i");
+
+
+ IntConstantExpression intConstantExpression = new IntConstantExpression(5);
+ AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", instVarExpressionLeft, intConstantExpression);
+
+ iStatementList.add(assignStatementExpression);
+ BlockStatement blockStatement = new BlockStatement(iStatementList, null);
+ MethodDecl methodDecl = new MethodDecl("ConstructorThisDot", null, "ConstructorThisDot",
+ parameterListObj, blockStatement);
+
+ return methodDecl;
+ }
+}
diff --git a/src/test/java/ASTs/ConstructorThisDotASTTyped.java b/src/test/java/ASTs/ConstructorThisDotASTTyped.java
new file mode 100644
index 0000000..cbfa2f6
--- /dev/null
+++ b/src/test/java/ASTs/ConstructorThisDotASTTyped.java
@@ -0,0 +1,77 @@
+package ASTs;
+
+import Typecheck.TypingHelper;
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Expression.InstVarExpression;
+import abstractSyntaxTree.Expression.IntConstantExpression;
+import abstractSyntaxTree.Expression.SubReceiver;
+import abstractSyntaxTree.Parameter.Parameter;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+import abstractSyntaxTree.Statement.BlockStatement;
+import abstractSyntaxTree.Statement.IStatement;
+import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ConstructorThisDotASTTyped {
+ public static Program getProgram() {
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(getRefType());
+ Program program = new Program(refTypeList);
+ addTyping(program);
+
+ return program;
+ }
+
+ public static RefType getRefType() {
+
+ List fieldDeclList = new ArrayList<>();
+ fieldDeclList.add(new FieldDecl("int", "i", null));
+ List methodDeclList = new ArrayList<>();
+ methodDeclList.add(method0());
+ RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false);
+ return refType;
+ }
+
+ public static MethodDecl method0() {
+
+ List parameterList = new ArrayList<>();
+ ParameterList parameterListObj = new ParameterList(parameterList);
+ List iStatementList = new ArrayList<>();
+
+ SubReceiver subReceiver = new SubReceiver(true);
+ List subReceiverList = new ArrayList<>();
+ subReceiverList.add(subReceiver);
+ InstVarExpression instVarExpressionLeft = new InstVarExpression(subReceiverList, new ArrayList<>(), "i");
+ instVarExpressionLeft.thisClass = "ConstructorThisDot";
+
+ IntConstantExpression intConstantExpression = new IntConstantExpression(5);
+ AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", instVarExpressionLeft, intConstantExpression);
+
+ iStatementList.add(assignStatementExpression);
+ BlockStatement blockStatement = new BlockStatement(iStatementList, "void");
+ MethodDecl methodDecl = new MethodDecl("ConstructorThisDot", null, "ConstructorThisDot",
+ parameterListObj, blockStatement);
+
+ return methodDecl;
+ }
+
+ public static void addTyping(Program program){
+ // TypeContext
+ HashMap typeContextMap = new HashMap<>();
+ typeContextMap.put("i", "int");
+ TypingHelper.addTypeContext(program, "ConstructorThisDot", typeContextMap);
+
+ // MethodContext
+ HashMap method0 = new HashMap<>();
+ //method0.put("void", new ParameterList(new ArrayList<>()));
+ HashMap> methods = new HashMap<>();
+ //methods.put("main", method0);
+ TypingHelper.addMethodContext(program, "ConstructorThisDot", methods);
+ }
+}
diff --git a/src/test/java/ASTs/FieldVarAST.java b/src/test/java/ASTs/FieldVarAST.java
new file mode 100644
index 0000000..71b344f
--- /dev/null
+++ b/src/test/java/ASTs/FieldVarAST.java
@@ -0,0 +1,24 @@
+package ASTs;
+
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Program;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FieldVarAST {
+ public static Program getProgram() {
+ // int variable
+ FieldDecl fieldDecl = new FieldDecl("int", "variable", null);
+
+ List fieldDeclList = new ArrayList<>();
+ List methodDeclList = new ArrayList<>();
+ fieldDeclList.add(fieldDecl);
+ RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false);
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(class0);
+ return new Program(refTypeList);
+ }
+}
diff --git a/src/test/java/ASTs/FieldVarASTTyped.java b/src/test/java/ASTs/FieldVarASTTyped.java
new file mode 100644
index 0000000..7bd6aac
--- /dev/null
+++ b/src/test/java/ASTs/FieldVarASTTyped.java
@@ -0,0 +1,43 @@
+package ASTs;
+
+import Typecheck.TypingHelper;
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class FieldVarASTTyped {
+ public static Program getProgram() {
+ // int variable
+ FieldDecl fieldDecl = new FieldDecl("int", "variable", null);
+
+ List fieldDeclList = new ArrayList<>();
+ List methodDeclList = new ArrayList<>();
+ fieldDeclList.add(fieldDecl);
+ RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false);
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(class0);
+ Program program = new Program(refTypeList);
+ addTyping(program);
+ return program;
+ }
+
+ public static void addTyping(Program program){
+ // TypeContext
+ HashMap typeContextMap = new HashMap<>();
+ typeContextMap.put("variable", "int");
+ TypingHelper.addTypeContext(program, "FieldVar", typeContextMap);
+
+ // MethodContext
+ HashMap method0 = new HashMap<>();
+ //method0.put("void", new ParameterList(new ArrayList<>()));
+ HashMap> methods = new HashMap<>();
+ //methods.put("main", method0);
+ TypingHelper.addMethodContext(program, "FieldVar", methods);
+ }
+}
diff --git a/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java b/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java
new file mode 100644
index 0000000..eee31a6
--- /dev/null
+++ b/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java
@@ -0,0 +1,104 @@
+package ASTs;
+
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Expression.BinaryExpression;
+import abstractSyntaxTree.Expression.IntConstantExpression;
+import abstractSyntaxTree.Expression.LocalVarIdentifier;
+import abstractSyntaxTree.Parameter.Parameter;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+import abstractSyntaxTree.Statement.*;
+import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IfElseIfStatementWithOneReturnAST {
+ public static Program getProgram() {
+
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(getRefType());
+ Program program = new Program(refTypeList);
+
+ return program;
+ }
+
+ public static RefType getRefType() {
+
+ List fieldDeclList = new ArrayList<>();
+ List methodDeclList = new ArrayList<>();
+ methodDeclList.add(method0());
+ RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false);
+
+ return refType;
+ }
+
+ public static MethodDecl method0() {
+
+ List parameterList = new ArrayList<>();
+ parameterList.add(new Parameter("int", "i"));
+ ParameterList parameterListObj = new ParameterList(parameterList);
+
+ List iStatementList = new ArrayList<>();
+ iStatementList.add(statement00());
+ iStatementList.add(statement01());
+ iStatementList.add(statement02());
+ BlockStatement blockStatement0 = new BlockStatement(iStatementList, null);
+ MethodDecl methodDecl = new MethodDecl("IfElseIfStatementWithOneReturn", "int", "foo", parameterListObj, blockStatement0);
+
+ return methodDecl;
+ }
+
+ public static LocalVarDecl statement00() {
+ LocalVarDecl localVarDecl = new LocalVarDecl("int", "result", null);
+ return localVarDecl;
+ }
+
+ public static IfElseStatement statement01() {
+
+ LocalVarIdentifier conditionLeft = new LocalVarIdentifier("i");
+ BinaryExpression condition = new BinaryExpression("==", conditionLeft, new IntConstantExpression(1));
+
+ LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
+ List ifStatementList = new ArrayList<>();
+ ifStatementList.add(new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10)));
+ BlockStatement ifStatement = new BlockStatement(ifStatementList, null);
+
+ IfElseStatement elseStatement = statement010();
+
+ IfElseStatement ifElseStatement = new IfElseStatement(condition, ifStatement, elseStatement);
+
+ return ifElseStatement;
+ }
+
+ public static IfElseStatement statement010() {
+ LocalVarIdentifier identifieri = new LocalVarIdentifier("i");
+ BinaryExpression condition0 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
+
+ List iStatementList = new ArrayList<>();
+ LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
+ AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10));
+ iStatementList.add(assignStatementExpression);
+ BlockStatement ifStatement = new BlockStatement(iStatementList, null);
+
+ BinaryExpression condition1 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
+ List iStatementList1 = new ArrayList<>();
+ iStatementList1.add(new ReturnStatement(new IntConstantExpression(20)));
+ BlockStatement blockStatementIf = new BlockStatement(iStatementList1, null);
+ List iStatementList2 = new ArrayList<>();
+ AssignStatementExpression assignStatementExpression1 = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(30));
+ iStatementList2.add(assignStatementExpression1);
+ BlockStatement blockStatementElse = new BlockStatement(iStatementList2, null);
+ IfElseStatement ifElseStatement = new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
+
+ return new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
+ }
+
+ public static ReturnStatement statement02() {
+ LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
+ return new ReturnStatement(identifierResult);
+ }
+
+}
diff --git a/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java b/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java
new file mode 100644
index 0000000..1a3bbac
--- /dev/null
+++ b/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java
@@ -0,0 +1,135 @@
+package ASTs;
+
+import TypeCheck.TypeCheckResult;
+import Typecheck.TypingHelper;
+import abstractSyntaxTree.Class.FieldDecl;
+import abstractSyntaxTree.Class.MethodDecl;
+import abstractSyntaxTree.Class.RefType;
+import abstractSyntaxTree.Expression.BinaryExpression;
+import abstractSyntaxTree.Expression.IntConstantExpression;
+import abstractSyntaxTree.Expression.LocalVarIdentifier;
+import abstractSyntaxTree.Parameter.Parameter;
+import abstractSyntaxTree.Parameter.ParameterList;
+import abstractSyntaxTree.Program;
+import abstractSyntaxTree.Statement.*;
+import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class IfElseIfStatementWithOneReturnASTTyped {
+
+ public static Program getProgram() {
+
+ List refTypeList = new ArrayList<>();
+ refTypeList.add(getRefType());
+ Program program = new Program(refTypeList);
+ addTyping(program);
+
+ return program;
+ }
+
+ public static RefType getRefType() {
+
+ List fieldDeclList = new ArrayList<>();
+ List methodDeclList = new ArrayList<>();
+ methodDeclList.add(method0());
+ RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false);
+
+ return refType;
+ }
+
+ public static MethodDecl method0() {
+
+ List parameterList = new ArrayList<>();
+ parameterList.add(new Parameter("int", "i"));
+ ParameterList parameterListObj = new ParameterList(parameterList);
+
+ List iStatementList = new ArrayList<>();
+ iStatementList.add(statement00());
+ iStatementList.add(statement01());
+ iStatementList.add(statement02());
+ BlockStatement blockStatement0 = new BlockStatement(iStatementList, "int");
+ MethodDecl methodDecl = new MethodDecl("IfElseIfStatementWithOneReturn", "int", "foo", parameterListObj, blockStatement0);
+
+ return methodDecl;
+ }
+
+ public static LocalVarDecl statement00() {
+ LocalVarDecl localVarDecl = new LocalVarDecl("int", "result", null);
+ return localVarDecl;
+ }
+
+ public static IfElseStatement statement01() {
+
+ LocalVarIdentifier conditionLeft = new LocalVarIdentifier("i");
+ conditionLeft.setTypeCheckResult(new TypeCheckResult("int"));
+ BinaryExpression condition = new BinaryExpression("==", conditionLeft, new IntConstantExpression(1));
+ condition.setTypeCheckResult(new TypeCheckResult("boolean"));
+
+ LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
+ identifierResult.setTypeCheckResult(new TypeCheckResult("int"));
+ List ifStatementList = new ArrayList<>();
+ ifStatementList.add(new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10)));
+ BlockStatement ifStatement = new BlockStatement(ifStatementList, "void");
+
+ IfElseStatement elseStatement = statement010();
+
+ IfElseStatement ifElseStatement = new IfElseStatement(condition, ifStatement, elseStatement);
+
+ return ifElseStatement;
+ }
+
+ public static IfElseStatement statement010() {
+ LocalVarIdentifier identifieri = new LocalVarIdentifier("i");
+ identifieri.setTypeCheckResult(new TypeCheckResult("int"));
+ BinaryExpression condition0 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
+ condition0.setTypeCheckResult(new TypeCheckResult("boolean"));
+
+ List iStatementList = new ArrayList<>();
+ LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
+ identifierResult.setTypeCheckResult(new TypeCheckResult("int"));
+ AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10));
+ iStatementList.add(assignStatementExpression);
+ BlockStatement ifStatement = new BlockStatement(iStatementList, "void");
+
+ BinaryExpression condition1 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
+ condition1.setTypeCheckResult(new TypeCheckResult("boolean"));
+ List iStatementList1 = new ArrayList<>();
+ IntConstantExpression intConstantExpression20 = new IntConstantExpression(20);
+ intConstantExpression20.setTypeCheckResult(new TypeCheckResult("int"));
+ ReturnStatement return20 = new ReturnStatement(intConstantExpression20);
+ return20.setTypeCheckResult(new TypeCheckResult("int"));
+ iStatementList1.add(return20);
+ BlockStatement blockStatementIf = new BlockStatement(iStatementList1, "int");
+ List iStatementList2 = new ArrayList<>();
+ AssignStatementExpression assignStatementExpression1 = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(30));
+ iStatementList2.add(assignStatementExpression1);
+ BlockStatement blockStatementElse = new BlockStatement(iStatementList2, "void");
+ IfElseStatement ifElseStatement = new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
+
+ return new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
+ }
+
+ public static ReturnStatement statement02() {
+ LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
+ identifierResult.setTypeCheckResult(new TypeCheckResult("int"));
+ return new ReturnStatement(identifierResult);
+ }
+
+ public static void addTyping(Program program){
+ // TypeContext
+ TypingHelper.addTypeContext(program, "IfElseIfStatementWithOneReturn", new HashMap<>());
+
+ // MethodContext
+ HashMap method0 = new HashMap<>();
+ List parameterList = new ArrayList<>();
+ parameterList.add(new Parameter("int", "i"));
+ ParameterList parameterListObj = new ParameterList(parameterList);
+ method0.put("int", parameterListObj);
+ HashMap> methods = new HashMap<>();
+ methods.put("foo", method0);
+ TypingHelper.addMethodContext(program, "IfElseIfStatementWithOneReturn", methods);
+ }
+}
diff --git a/src/test/java/ByteCode/ByteCodeTester.java b/src/test/java/ByteCode/ByteCodeTester.java
index e374316..9128e7c 100644
--- a/src/test/java/ByteCode/ByteCodeTester.java
+++ b/src/test/java/ByteCode/ByteCodeTester.java
@@ -77,7 +77,6 @@ public class ByteCodeTester {
private Program generateAST(String pathToJavaFile){
String content = "";
try {
- System.out.println("Classpath: " + Path.of(pathToJavaFile));
content = Files.readString(Path.of(pathToJavaFile));
} catch (IOException e) {
System.out.println("File not found!");
@@ -115,7 +114,6 @@ public class ByteCodeTester {
public void compareJarFilesFromScratch(String javaCodePath, String jarPath, String[] classNames){
String content = "";
try {
- System.out.println("Classpath: " + Path.of(javaCodePath));
content = Files.readString(Path.of(javaCodePath));
} catch (IOException e) {
System.out.println("File not found!");
diff --git a/src/test/java/ByteCode/CompareByteCodeBehaviour.java b/src/test/java/ByteCode/CompareByteCodeBehaviour.java
index c5584db..c5f5b28 100644
--- a/src/test/java/ByteCode/CompareByteCodeBehaviour.java
+++ b/src/test/java/ByteCode/CompareByteCodeBehaviour.java
@@ -98,7 +98,7 @@ public class CompareByteCodeBehaviour {
Method method1 = methods1[i];
Method method2 = methods2[i];
- System.out.println(method1);
+ System.out.println("\n" + method1);
System.out.println(method2);
method1.setAccessible(true);
@@ -108,7 +108,7 @@ public class CompareByteCodeBehaviour {
// Test with some sample inputs
Object[] testInputs = getTestInputs(method1.getParameterTypes());
for(int j = 0; j < testInputs.length; j++){
- System.out.println("TestInput: " + testInputs[j]);
+ System.out.println("Parameter[" + i + "]: " + testInputs[j]);
}
Object result1 = method1.invoke(obj1, testInputs);
diff --git a/src/test/java/ByteCode/TestAll.java b/src/test/java/ByteCode/TestAll.java
index 24a70cf..e60a0d6 100644
--- a/src/test/java/ByteCode/TestAll.java
+++ b/src/test/java/ByteCode/TestAll.java
@@ -35,11 +35,11 @@ public class TestAll {
@Test
public void testFakultaet() {
String classPath = "src/test/resources/basicClasses/Fakultaet.class";
- Program ast = FakultaetASTTyped.getProgram();
+ Program ast = FakultaetAST.getProgram();
String className = "Fakultaet";
String javacode = "src/test/resources/basicClasses/Fakultaet.java";
- //byteCodeTester.testByteCodeFromTypedAst(classPath, ast ,className);
- byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
+ byteCodeTester.testByteCodeFromAst(classPath, ast ,className);
+ //byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@Test
@@ -98,7 +98,7 @@ public class TestAll {
//Program ast = ClassWithMainASTTyped.getProgram();
String className = "DivMethod";
String javacode = "src/test/resources/SimpleTests/DivMethod.java";
- //testByteCodeFromAst(classPath, ast ,className);
+ //byteCodeTester.testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@@ -118,10 +118,10 @@ public class TestAll {
@Test
public void testFieldVar() {
String classPath = "src/test/resources/SimpleTests/FieldVar.class";
- //Program ast = ClassWithMainASTTyped.getProgram();
+ Program ast = FieldVarASTTyped.getProgram();
String className = "FieldVar";
String javacode = "src/test/resources/SimpleTests/FieldVar.java";
- //testByteCodeFromAst(classPath, ast ,className);
+ byteCodeTester.testByteCodeFromTypedAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@@ -135,6 +135,7 @@ public class TestAll {
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
+
@Test
public void testGetterFunction() {
String classPath = "src/test/resources/SimpleTests/GetterFunction.class";
@@ -158,10 +159,10 @@ public class TestAll {
@Test
public void testIfElseIfStatementWithOneReturn() {
String classPath = "src/test/resources/SimpleTests/IfElseIfStatementWithOneReturn.class";
- //Program ast = ClassWithMainASTTyped.getProgram();
+ Program ast = IfElseIfStatementWithOneReturnAST.getProgram();
String className = "IfElseIfStatementWithOneReturn";
String javacode = "src/test/resources/SimpleTests/IfElseIfStatementWithOneReturn.java";
- //testByteCodeFromAst(classPath, ast ,className);
+ byteCodeTester.testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@@ -185,17 +186,6 @@ public class TestAll {
byteCodeTester.compareJarFilesFromScratch(javacode, jarPath, classNames);
}
- /*
- @Test
- public void testDijkstra() {
- String jarPath = "src/test/resources/Integration/Dijkstra.jar";
- //Program ast = ClassWithMainASTTyped.getProgram();
- String[] classNames = {"FourClasses", "Test", "Test2", "Test3"};
- String javacode = "src/test/resources/Integration/Dijkstra.java";
- byteCodeTester.compareJarFilesFromScratch(javacode, jarPath, classNames);
- }
- */
-
diff --git a/src/test/java/Typecheck/TestAll.java b/src/test/java/Typecheck/TestAll.java
index 9ee8040..686f8b5 100644
--- a/src/test/java/Typecheck/TestAll.java
+++ b/src/test/java/Typecheck/TestAll.java
@@ -21,44 +21,44 @@ public class TestAll {
@Test
public void testClassWithMain() {
- Program emptyClassAst = ClassWithMainAST.getProgram();
+ Program astToBeTested = ClassWithMainAST.getProgram();
Program correctAST = ClassWithMainASTTyped.getProgram();
boolean expectedResult = true;
- testTypeCheck(emptyClassAst, correctAST, expectedResult);
+ testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClass() {
- Program emptyClassAst = emptyClassAST.getEmptyProgramm();
+ Program astToBeTested = emptyClassAST.getEmptyProgramm();
Program correctAST = emptyClassASTTyped.getEmptyProgramm();
boolean expectedResult = false;
- testTypeCheck(emptyClassAst, correctAST, expectedResult);
+ testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClassWM() {
- Program emptyClassAst = emptyClassAST.getEmptyProgramm();
+ Program astToBeTested = emptyClassAST.getEmptyProgramm();
Program correctAST = emptyClassASTTyped.getEmptyProgramm();
boolean expectedResult = true;
- testTypeCheckWM(emptyClassAst, correctAST, expectedResult);
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClassWithConstructor(){
- Program abstractSyntaxTree = EmptyClassWithConstructorAST.getProgram();
+ Program astToBeTested = EmptyClassWithConstructorAST.getProgram();
Program correctAST = EmptyClassWithConstructorASTTyped.getProgram();
boolean expectedResult = false;
- testTypeCheck(abstractSyntaxTree, correctAST, expectedResult);
+ testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClassWithConstructorWM(){
- Program abstractSyntaxTree = EmptyClassWithConstructorAST.getProgram();
+ Program astToBeTested = EmptyClassWithConstructorAST.getProgram();
Program correctAST = EmptyClassWithConstructorASTTyped.getProgram();
boolean expectedResult = true;
- testTypeCheckWM(abstractSyntaxTree, correctAST, expectedResult);
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
/*
@@ -79,44 +79,78 @@ public class TestAll {
@Test
public void testAssignWrongType(){
- Program assignWrongType = AssignWrongTypeAST.getProgram();
+ Program astToBeTested = AssignWrongTypeAST.getProgram();
Program correctAST = AssignWrongTypeASTTyped.getProgram();
boolean expectedResult = false;
- testTypeCheck(assignWrongType, correctAST,expectedResult);
+ testTypeCheck(astToBeTested, correctAST,expectedResult);
}
@Test
public void testAssignWrongTypeWM(){
- Program assignWrongType = AssignWrongTypeAST.getProgram();
+ Program astToBeTested = AssignWrongTypeAST.getProgram();
Program correctAST = AssignWrongTypeASTTyped.getProgram();
boolean expectedResult = false;
- testTypeCheckWM(assignWrongType, correctAST, expectedResult);
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testFakultaet(){
- Program fakultaet = FakultaetAST.getProgram();
+ Program astToBeTested = FakultaetAST.getProgram();
Program correctAST = FakultaetASTTyped.getProgram();
boolean expectedResult = true;
- testTypeCheck(fakultaet, correctAST, expectedResult);
+ testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testDivideByZero(){
- Program fakultaet = DivideByZeroAST.getProgram();
+ Program astToBeTested = DivideByZeroAST.getProgram();
Program correctAST = DivideByZeroASTTyped.getProgram();
boolean expectedResult = true;
- testTypeCheck(fakultaet, correctAST, expectedResult);
+ testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testCharArgument(){
- Program fakultaet = CharArgumentAST.getProgram();
+ Program astToBeTested = CharArgumentAST.getProgram();
Program correctAST = CharArgumentASTTyped.getProgram();
boolean expectedResult = true;
- testTypeCheckWOM(fakultaet, correctAST, expectedResult);
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
+ @Test
+ public void testFieldVar(){
+ Program astToBeTested = FieldVarAST.getProgram();
+ Program correctAST = FieldVarASTTyped.getProgram();
+ boolean expectedResult = true;
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
+ }
+
+ @Test
+ public void testConstructorParams(){
+ Program astToBeTested = ConstructorParamsAST.getProgram();
+ Program correctAST = ConstructorParamsASTTyped.getProgram();
+ boolean expectedResult = true;
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
+ }
+
+ @Test
+ public void testConstructorThisDot(){
+ Program astToBeTested = ConstructorThisDotAST.getProgram();
+ Program correctAST = ConstructorThisDotASTTyped.getProgram();
+ boolean expectedResult = true;
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
+ }
+
+ @Test
+ public void testIfElseIfStatementWithOneReturn(){
+ Program astToBeTested = IfElseIfStatementWithOneReturnAST.getProgram();
+ Program correctAST = IfElseIfStatementWithOneReturnASTTyped.getProgram();
+ boolean expectedResult = true;
+ testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
+ }
+
+
+
public void testTypeCheckWOM(Program abstractSyntaxTree, Program correctAST, boolean expectedResult) {
try {
diff --git a/src/test/resources/SimpleTests/FieldVar.java b/src/test/resources/SimpleTests/FieldVar.java
index 4c83a9c..2265a3f 100644
--- a/src/test/resources/SimpleTests/FieldVar.java
+++ b/src/test/resources/SimpleTests/FieldVar.java
@@ -1,5 +1,5 @@
class FieldVar {
- int field;
+ int variable;
}
diff --git a/src/test/resources/SimpleTests/FieldVar.tokens b/src/test/resources/SimpleTests/FieldVar.tokens
index c051299..ef2cd13 100644
--- a/src/test/resources/SimpleTests/FieldVar.tokens
+++ b/src/test/resources/SimpleTests/FieldVar.tokens
@@ -2,7 +2,7 @@ Class: "class"
Identifier: "FieldVar"
OpenCurlyBracket: "{"
Int: "int"
-Identifier: "field"
+Identifier: "variable"
Semicolon: ";"
ClosedCurlyBracket: "}"
EOF: ""
\ No newline at end of file