Merge branch 'ParserAlterStand' into NewParser

pom.xml

@@ -23,24 +23,6 @@
             <version>5.11.0-M2</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-suite-engine</artifactId>
-            <version>1.11.0-M2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>5.11.0-M2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13.1</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.antlr</groupId>
             <artifactId>antlr4-runtime</artifactId>
@@ -62,6 +44,18 @@
             <version>3.26.0</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.11.0-M2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.11.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -71,11 +65,6 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>3.0.0-M5</version> <!-- Change the version as needed -->
-                <configuration>
-                    <includes>
-                        <include>**/*Test.java</include>
-                    </includes>
-                </configuration>
             </plugin>
             <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>

readme.md

@@ -1,68 +0,0 @@
-# "Nicht Haskel 2.0" Java Compiler
-
-Realisation of a subset of the Java Standard Compiler in the course Compiler Construction of the 4th semester Computer Science at the Duale Hochschule Suttgart (Horb).
-
-This project aims to provide a simplified version of the Java compiler, focusing on key language features and demonstrating the principles of compiler construction.
-
-## Realised Java syntax
-
-- **Data types**: `int`, `boolean`, `char`
-- **Access modifier**: `public`, `protected`, `private`
-- **Operators**: `=` `+` `-` `*` `%` `/` `>` `<` `>=` `<=` `==` `!=` `!` `&&` `||` `++` `--`
-- **Keywords**: `class`, `this`, `while`, `do`, `if`, `else`, `for`, `return`, `new`, `switch`, `case`, `break`, `default`, `:`
-- **Statements**:
-    - `if` ... `if else` ... `else`;
-    - `while` ... ;
-    - `do` ... `while`;
-    - `for`;
-    - `switch` ... `case` ... ;
-- **Comments**:
-    - Single line: `// comment`
-    - Multi-line: `/* comment */`
-- **Further functions**:
-    - All methods are overloadable
-    - High maintainability and expandability through implementation of the visitor pattern
-    - Logging Input and Outputs
-    - Error Handling in the Semantic Check
-
-## Project Structure
-
-```plain
-src/
-└── main/
-    ├── java/
-    │   ├── ast/              -> Defining the structure of the AST
-    │   ├── bytecode/         -> Generate Java bytecode
-    │   ├── main/             -> Running the compiler
-    │   ├── parser/
-    │   │   ├── astBuilder/   -> Builder creating the AST
-    │   │   ├── generated/    -> Antlr generated grammar
-    │   │   └── grammar/      -> Antlr grammar
-    │   ├── semantic/         -> Running the semantic check
-    │   └── visitor/          -> Visitor interface
-    └── resources/
-test/
-└── java/
-│   ├── main/                 -> MainTest, E2ETests, UtilityTests
-│   ├── parser/               -> Performs tests on the parser
-│   └── semantic/             -> Performs tests on the semantic check
-└── resources/                -> Ressources for running the Tests
-```
-
-## Class-Diagramm AST
-
-![AST Diagramm](ast.png)
-
-## Used Tools
-
-- [Maven 4.0](https://maven.apache.org/index.html)
-    - Used for automating the build process and managing dependencies.
-- [ANTLR4 v.13.1](https://www.antlr.org/)
-    - Used to parse the input Java code into the Abstract Syntax Tree.
-
-
-## How to run the compiler
-
-## Download
-
-```bash

src/main/java/ast/ASTNode.java

@@ -8,6 +8,7 @@ public interface ASTNode {
 
     //Todo: @BruderJohn & @i22007 Interface anwenden + geeignetetn Methodename.
 
+
     /*
     Typecheck:
     public TypeCheckResult acceptType(SemanticVisitor visitor);

src/main/java/ast/ClassNode.java

@@ -1,7 +1,6 @@
 package ast;
 
 import ast.type.AccessModifierNode;
-import ast.members.ConstructorNode;
 import ast.members.MemberNode;
 import ast.members.MethodNode;
 import bytecode.visitor.ClassVisitor;

src/main/java/ast/expressions/binaryexpressions/CalculationNode.java

@@ -9,6 +9,7 @@ public class CalculationNode extends BinaryNode {
     public CalculationNode calculationExpression;
     public EnumLineOperator operator;
     public DotNode dotExpression;
+    private ITypeNode typeNode;
 
     public CalculationNode(CalculationNode calculationExpression, String operator, DotNode dotExpression) {
         this.calculationExpression = calculationExpression;
@@ -21,12 +22,10 @@ public class CalculationNode extends BinaryNode {
     }
 
     private void setOperator(String operator) {
-        if(operator != null) {
+        if(operator.equals("+")) {
-            if(operator.equals("+")) {
+            this.operator = EnumLineOperator.PLUS;
-                this.operator = EnumLineOperator.PLUS;
+        } else if(operator.equals("-")) {
-            } else if(operator.equals("-")) {
+            this.operator = EnumLineOperator.MINUS;
-                this.operator = EnumLineOperator.MINUS;
-            }
         }
     }
 
@@ -41,4 +40,4 @@ public class CalculationNode extends BinaryNode {
         methodVisitor.visit(this);
     }
 
-}
+}

src/main/java/ast/members/MainMethodNode.java

@@ -5,6 +5,7 @@ import bytecode.visitor.MethodVisitor;
 import visitor.Visitable;
 
 public class MainMethodNode extends MethodNode implements Visitable {
+    public BlockNode block;
 
     public MainMethodNode(BlockNode block) {
         this.block = block;

src/main/java/ast/statement/BlockStatementNode.java

@@ -0,0 +1,11 @@
+package ast.statement;
+
+import ast.statements.IStatementNode;
+
+import java.util.List;
+
+public class BlockStatementNode {
+    List<IStatementNode> statements;
+
+    public BlockStatementNode(List<IStatementNode> statements) {this.statements = statements;}
+}

src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java

@@ -7,7 +7,7 @@ import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
-public class DecrementNode implements IStatementExpressionNode, Visitable {
+public class DecrementNode implements IStatementExpressionNode {
     public CrementType crementType;
     public AssignableNode assignableExpression;
 
@@ -20,9 +20,4 @@ public class DecrementNode implements IStatementExpressionNode, Visitable {
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 }

src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java

@@ -5,9 +5,8 @@ import ast.statementexpressions.IStatementExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import visitor.Visitable;
 
-public class IncrementNode implements IStatementExpressionNode, Visitable {
+public class IncrementNode implements IStatementExpressionNode {
     public CrementType crementType;
     public AssignableNode assignableExpression;
 
@@ -20,9 +19,4 @@ public class IncrementNode implements IStatementExpressionNode, Visitable {
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 }

src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java

@@ -22,6 +22,11 @@ public class ChainedMethodNode implements ASTNode, Visitable {
         expressions.add(expression);
     }
 
+    @Override
+    public void accept(MethodVisitor methodVisitor) {
+        methodVisitor.visit(this);
+    }
+
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return null;

src/main/java/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java

@@ -2,7 +2,6 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 
 import ast.expressions.IExpressionNode;
 import ast.statements.IStatementNode;
-import ast.type.type.ITypeNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
@@ -12,7 +11,6 @@ import java.util.List;
 
 public class MethodCallNode implements IStatementNode {
     public TargetNode target;
-    public ITypeNode type;
     public List<ChainedMethodNode> chainedMethods = new ArrayList<>();
     public String identifier;
     public List<IExpressionNode> parameters = new ArrayList<>();

src/main/java/bytecode/ClassCodeGen.java

@@ -27,7 +27,7 @@ public class ClassCodeGen implements ClassVisitor {
     private boolean generateClassFiles;
 
     public ClassCodeGen(JarOutputStream jarOutputStream, String outputDirectory, boolean generateJar, boolean generateClassFiles) {
-        this.mapper = new Mapper();
+        mapper = new Mapper();
         this.jarOutputStream = jarOutputStream;
         this.outputDirectory = outputDirectory;
         this.generateJar = generateJar;

src/main/java/bytecode/Mapper.java

@@ -3,7 +3,6 @@ package bytecode;
 import ast.parameters.ParameterNode;
 import ast.type.*;
 import ast.type.type.BaseType;
-import ast.type.type.ITypeNode;
 import ast.type.type.ReferenceType;
 import ast.type.type.TypeEnum;
 import org.objectweb.asm.Opcodes;
@@ -25,7 +24,7 @@ public class Mapper {
         return 0;
     }
 
-    public String generateMethodDescriptor(ITypeNode type, List<ParameterNode> parameters) {
+    public String generateMethodDescriptor(BaseType type, List<ParameterNode> parameters) {
         String descriptor = "(";
         for (ParameterNode parameterNode : parameters) {
             if(parameterNode.type instanceof BaseType) {
@@ -36,11 +35,7 @@ public class Mapper {
             }
         }
         descriptor += ")";
-        if(type instanceof BaseType) {
+        descriptor += getTypeChar(type);
-            descriptor += getTypeChar((BaseType) type);
-        } else if(type instanceof ReferenceType) {
-            descriptor += "L" + ((ReferenceType) type).getIdentifier() +";";
-        }
         return descriptor;
     }
 

src/main/java/bytecode/MethodCodeGen.java

@@ -14,7 +14,9 @@ import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.crementexpressions.CrementType;
 import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
+import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
 import ast.type.ValueNode;
 import ast.type.type.BaseType;
@@ -69,7 +71,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
         // Visit all statements
         for (IStatementNode statementNode : constructorNode.block.statements) {
-            statementNode.accept(this);
+            if (statementNode != null) {
+                statementNode.accept(this);
+            }
         }
 
         methodVisitor.visitMaxs(0, 0);
@@ -101,7 +105,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(MethodNode methodNode) {
         methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(methodNode.accesModifier),
                 methodNode.getIdentifier(),
-                mapper.generateMethodDescriptor(methodNode.getType(), methodNode.parameters),
+                mapper.generateMethodDescriptor((BaseType) methodNode.getType(), methodNode.parameters),
                 null,
                 null);
 
@@ -237,7 +241,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 nonCalculationNode.unaryExpression.accept(this);
                 nonCalculationNode.expression.accept(this);
                 if (nonCalculationNode.unaryExpression.getType() instanceof BaseType && nonCalculationNode.expression.getType() instanceof BaseType) {
-                    methodVisitor.visitJumpInsn(IF_ICMPEQ, labelFalse);
+                    methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
                 } else {
                     methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
                 }
@@ -262,17 +266,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     @Override
     public void visit(MemberAccessNode memberAccessNode) {
         // Only used to get, not to put
-        int localVarIndex = localVariables.indexOf("memberAccessNode.identifier"); // TODO
+        if (memberAccessNode.thisExpr) { // Field
-        if (localVarIndex >= 0) { // local var object
+            // methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
+        } else { // Object Attribut
-        } else { // this field
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        }
-
-        if (memberAccessNode.getTypeNode() instanceof BaseType) {
-            methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), mapper.getTypeChar((BaseType) memberAccessNode.getTypeNode()));
-        } else if (memberAccessNode.getTypeNode() instanceof ReferenceType) {
-            methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), "L" + ((ReferenceType) memberAccessNode.getTypeNode()).getIdentifier() + ";");
         }
     }
 
@@ -335,7 +331,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             // else if statements
             methodVisitor.visitJumpInsn(IFEQ, elseIfLabels[0]);
         }
-
         ifElseNode.ifStatement.block.accept(this); // accept if block
 
         Label endLabel = new Label();
@@ -367,17 +362,22 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (localVariableDeclarationNode.expression != null) {
             // Process expression
             localVariableDeclarationNode.expression.accept(this);
-            // add local var to list if not in list
+            // Store result of expression in variable
-            if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
+            if (localVariables.contains(localVariableDeclarationNode.identifier)) {
+                if (localVariableDeclarationNode.type instanceof BaseType) {
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                }
+            } else {
                 localVariables.add(localVariableDeclarationNode.identifier);
-            }
+                if (localVariableDeclarationNode.type instanceof BaseType) {
-            if (localVariableDeclarationNode.type instanceof BaseType) {
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
-                methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
-            } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
-                methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                }
             }
         } else {
-            // Local var declaration
             if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
                 localVariables.add(localVariableDeclarationNode.identifier);
             }
@@ -386,106 +386,40 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(AssignNode assignNode) {
-        if (assignNode.assignable.memberAccess != null) { // this / object
+        // Process expression
-            if (assignNode.expression instanceof IncrementNode) {
-                if (((IncrementNode) assignNode.expression).crementType.equals(CrementType.PREFIX)) { // ++i
-                    fieldOrObjectVarPrefixCrementAssign(assignNode);
-                } else { // i++
-                    fieldOrObjectVarSuffixCrementAssign(assignNode);
-                }
-            } else if (assignNode.expression instanceof DecrementNode) {
-                if (((DecrementNode) assignNode.expression).crementType.equals(CrementType.PREFIX)) {
-                    fieldOrObjectVarPrefixCrementAssign(assignNode);
-                } else {
-                    fieldOrObjectVarSuffixCrementAssign(assignNode);
-                }
-            } else {
-                assignFieldOrObjectVar(assignNode);
-            }
-        } else { // local var
-            if (assignNode.expression instanceof IncrementNode || assignNode.expression instanceof DecrementNode) {
-                localVarCrementAssign(assignNode);
-            } else {
-                assignNode.expression.accept(this);
-                assignLocalVar(assignNode);
-            }
-        }
-    }
-
-    private void localVarCrementAssign(AssignNode assignNode) {
         if (assignNode.expression instanceof IncrementNode) {
             IncrementNode incrementNode = (IncrementNode) assignNode.expression;
             if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i
-                incrementNode.accept(this);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
-                assignLocalVar(assignNode);
+                assign(assignNode);
-            } else { // i++
+            } else if (incrementNode.crementType.equals(CrementType.SUFFIX)) { // Suffix: i++
-                loadBeforeCrement(assignNode);
+                assign(assignNode);
-                assignLocalVar(assignNode);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
-                incrementNode.accept(this);
             }
         } else if (assignNode.expression instanceof DecrementNode) {
             DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                decrementNode.accept(this);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
-                assignLocalVar(assignNode);
+                assign(assignNode);
-            } else {
+            } else if (decrementNode.crementType.equals(CrementType.SUFFIX)) {
-                loadBeforeCrement(assignNode);
+                assign(assignNode);
-                assignLocalVar(assignNode);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), 1);
-                decrementNode.accept(this);
             }
+        } else {
+            assignNode.expression.accept(this);
+            assign(assignNode);
         }
     }
 
-    private void fieldOrObjectVarPrefixCrementAssign(AssignNode assignNode) {
+    private void assign(AssignNode assignNode) {
-        int localVarIndex = localVariables.indexOf(assignNode.assignable.identifier);
+        if (assignNode.assignable.memberAccess.thisExpr) {
-        if(localVarIndex >= 0) { // object
+            assignField(assignNode);
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else if(assignNode.assignable.memberAccess.thisExpr) { // field
-            methodVisitor.visitVarInsn(ALOAD, 0);
         } else {
-            localVariables.add(assignNode.assignable.identifier);
+            assignLocalVar(assignNode);
-            methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
         }
-
-        assignNode.expression.accept(this);
-        methodVisitor.visitInsn(DUP_X1);
-
-        if (assignNode.expression instanceof BaseType) {
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
-        } else if (assignNode.expression instanceof ReferenceType) {
-            ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L" + referenceType.getIdentifier() + ";");
-        }
-    }
-
-    private void fieldOrObjectVarSuffixCrementAssign(AssignNode assignNode) {
-        int localVarIndex = localVariables.indexOf(assignNode.assignable.identifier);
-        if(localVarIndex >= 0) { // object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else if(assignNode.assignable.memberAccess.thisExpr) { // field
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        } else {
-            localVariables.add(assignNode.assignable.identifier);
-            methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-        }
-
-        loadBeforeCrement(assignNode);
-        
-        if (assignNode.expression instanceof BaseType) {
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
-        } else if (assignNode.expression instanceof ReferenceType) {
-            ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L" + referenceType.getIdentifier() + ";");
-        }
-
-        assignNode.expression.accept(this);
     }
 
     private void assignLocalVar(AssignNode assignNode) {
-        methodVisitor.visitInsn(DUP);
-        if (!localVariables.contains(assignNode.assignable.identifier)) {
-            localVariables.add(assignNode.assignable.identifier);
-        }
         if (assignNode.expression instanceof BaseType) {
             methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(assignNode.assignable.identifier));
         } else if (assignNode.expression instanceof ReferenceType) {
@@ -493,105 +427,12 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         }
     }
 
-    private void assignFieldOrObjectVar(AssignNode assignNode) {
+    private void assignField(AssignNode assignNode) {
-        int localVarIndex = localVariables.indexOf(assignNode.assignable.identifier);
-        if (localVarIndex >= 0) { // object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else if (assignNode.assignable.memberAccess.thisExpr) { // this
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        } else {
-            localVariables.add(assignNode.assignable.identifier);
-            methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-        }
-
-        assignNode.expression.accept(this);
-        methodVisitor.visitInsn(DUP_X1);
-
         if (assignNode.expression instanceof BaseType) {
             methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
         } else if (assignNode.expression instanceof ReferenceType) {
             ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L" + referenceType.getIdentifier() + ";");
+            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L"+referenceType.getIdentifier()+";");
-        }
-    }
-
-    private void loadBeforeCrement(AssignNode assignNode) {
-        if(assignNode.expression instanceof IncrementNode) {
-            IncrementNode incrementNode = (IncrementNode) assignNode.expression;
-            if(incrementNode.assignableExpression.memberAccess != null) {
-                incrementNode.assignableExpression.memberAccess.accept(this);
-            } else {
-                if(assignNode.assignable.getTypeNode() instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                } else if(assignNode.assignable.getTypeNode() instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                }
-            }
-        } else if(assignNode.expression instanceof DecrementNode) {
-            DecrementNode decrementNode = (DecrementNode) assignNode.expression;
-            if(decrementNode.assignableExpression.memberAccess != null) {
-                decrementNode.assignableExpression.memberAccess.accept(this);
-            } else {
-                if(assignNode.assignable.getTypeNode() instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                } else if(assignNode.assignable.getTypeNode() instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                }
-            }
-        }
-    }
-
-    @Override
-    public void visit(IncrementNode incrementNode) {
-        if (incrementNode.assignableExpression.memberAccess != null) { // Object var / field
-            int localVarIndex = localVariables.indexOf(incrementNode.assignableExpression.identifier);
-            if (localVarIndex >= 0) { // object
-                methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-            } else { // this
-                methodVisitor.visitVarInsn(ALOAD, 0);
-            }
-            if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(GETFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) incrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(GETFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) incrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-            methodVisitor.visitInsn(DUP);
-            methodVisitor.visitInsn(ICONST_1);
-            methodVisitor.visitInsn(IADD);
-            if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) incrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) incrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-        } else { // local var
-            methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
-        }
-    }
-
-    @Override
-    public void visit(DecrementNode decrementNode) {
-        if (decrementNode.assignableExpression.memberAccess != null) { // Object var / field
-            int localVarIndex = localVariables.indexOf(decrementNode.assignableExpression.identifier);
-            if (localVarIndex >= 0) { // object
-                methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-            } else { // this
-                methodVisitor.visitVarInsn(ALOAD, 0);
-            }
-            methodVisitor.visitInsn(DUP);
-            if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(GETFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) decrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(GETFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) decrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-            methodVisitor.visitInsn(ICONST_1);
-            methodVisitor.visitInsn(ISUB);
-            if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) decrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) decrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-        } else { // local var
-            methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
         }
     }
 
@@ -604,7 +445,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             expressionNode.accept(this);
             parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID), parameterNodes), false);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID),parameterNodes), false);
+        localVariables.add(newDeclarationNode.identifier);
     }
 
     @Override
@@ -676,13 +518,19 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         methodVisitor.visitLabel(endOfLoopLabel);
     }
 
+    @Override
+    public void visit(ChainedMethodNode chainedMethodNode) {
+        // TODO: Erstmal abwarten
+    }
+
     @Override
     public void visit(MethodCallNode methodCallNode) {
         List<ParameterNode> parameterNodes = new ArrayList<>();
-        for (IExpressionNode expressionNode : methodCallNode.parameters) {
+        for(IExpressionNode expressionNode : methodCallNode.parameters) {
             expressionNode.accept(this);
             parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        methodVisitor.visitMethodInsn(INVOKEVIRTUAL, methodCallNode.target.memberAccess.identifiers.get(0), methodCallNode.identifier, mapper.generateMethodDescriptor(methodCallNode.type, parameterNodes), false);
+        // TODO: Klassenname und Returntype
+        //methodVisitor.visitMethodInsn(INVOKEVIRTUAL, classname, methodCallNode.identifier, mapper.generateMethodDescriptor(returntype, parameterNodes), false);
     }
 }

src/main/java/bytecode/visitor/ClassVisitor.java

@@ -5,5 +5,6 @@ import ast.members.FieldNode;
 
 public interface ClassVisitor {
     void visit(ClassNode classNode);
+
     void visit(FieldNode fieldNode);
 }

src/main/java/bytecode/visitor/MethodVisitor.java

@@ -39,14 +39,12 @@ public interface MethodVisitor {
     // statements
     void visit(IfElseNode ifElseNode);
 
-    void visit(IncrementNode incrementNode);
-    void visit(DecrementNode decrementNode);
-
     void visit(LocalVariableDeclarationNode localVariableDeclarationNode);
     void visit(ReturnNode returnNode);
     void visit(WhileNode whileNode);
 
     // statement expression
+    void visit(ChainedMethodNode chainedMethodNode);
     void visit(MethodCallNode methodCallNode);
 
     void visit(AssignNode assignNode);

src/main/java/main/Main.java

@@ -96,24 +96,16 @@ public class Main {
         // Log the typed AST
         RaupenLogger.logSemanticAnalyzer(typedAst);
 
-        if(SemanticAnalyzer.errors.isEmpty()){
+        /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
-            /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
+        // Use the ByteCodeGenerator to generate bytecode from the typed AST and output it to the specified directory
-            // Use the ByteCodeGenerator to generate bytecode from the typed AST and output it to the specified directory
-
-            final boolean genJar = Optional.ofNullable(System.getProperty("genJar")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
-            final boolean genClass = Optional.ofNullable(System.getProperty("genClass")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
-
-            ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator(outputDirectoryPath, genJar, genClass);
-            assert typedAst != null;
-            byteCodeGenerator.visit((ProgramNode) typedAst);
-            // Log the bytecode generation
-            RaupenLogger.logBytecodeGenerator();
-        } else {
-            for(Exception exception : SemanticAnalyzer.errors){
-                exception.printStackTrace();
-            }
-        }
 
+        final boolean genJar = Optional.ofNullable(System.getProperty("genJar")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
+        final boolean genClass = Optional.ofNullable(System.getProperty("genClass")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
 
+        ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator(outputDirectoryPath, genJar, genClass);
+        assert typedAst != null;
+        byteCodeGenerator.visit((ProgramNode) typedAst);
+        // Log the bytecode generation
+        RaupenLogger.logBytecodeGenerator();
     }
 }

src/main/java/parser/astBuilder/ASTBuilder.java

@@ -3,7 +3,10 @@ package parser.astBuilder;
 import ast.*;
 
 import ast.expressions.IExpressionNode;
-import ast.expressions.binaryexpressions.*;
+import ast.expressions.binaryexpressions.CalculationNode;
+import ast.expressions.binaryexpressions.DotNode;
+import ast.expressions.binaryexpressions.DotSubstractionNode;
+import ast.expressions.binaryexpressions.NonCalculationNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.NotNode;
 import ast.expressions.unaryexpressions.UnaryNode;
@@ -11,7 +14,6 @@ import ast.members.*;
 import ast.parameters.ParameterNode;
 import ast.statementexpressions.AssignNode;
 import ast.statementexpressions.AssignableNode;
-import ast.statementexpressions.IStatementExpressionNode;
 import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.crementexpressions.CrementType;
 import ast.statementexpressions.crementexpressions.DecrementNode;
@@ -73,12 +75,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitConstructorDeclaration(SimpleJavaParser.ConstructorDeclarationContext ctx) {
-        ConstructorNode constructorNode;
+        ConstructorNode constructorNode = new ConstructorNode(ctx.AccessModifier().getText(), ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
-        if(ctx.AccessModifier() != null) {
-            constructorNode = new ConstructorNode(ctx.AccessModifier().getText(), ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
-        } else {
-            constructorNode = new ConstructorNode("public", ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
-        }
         if(ctx.parameterList() != null) {
             for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
                 constructorNode.addParameter((ParameterNode) visit(parameter));
@@ -167,8 +164,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
             return visitForStatement(ctx.forStatement());
         } else if(ctx.ifElseStatement() != null) {
             return visitIfElseStatement(ctx.ifElseStatement());
-        } else if(ctx.switchStatement() != null) {
-            return visitSwitchStatement(ctx.switchStatement());
         } else if(ctx.statementExpression() != null) {
             return visitStatementExpression(ctx.statementExpression());
         }
@@ -182,12 +177,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitLocalVariableDeclaration(SimpleJavaParser.LocalVariableDeclarationContext ctx) {
-        if(ctx.Assign() != null) {
+        return new LocalVariableDeclarationNode(createTypeNode(ctx.type().getText()), ctx.Identifier().getText(), ctx.Assign().getText(), (IExpressionNode) visit(ctx.expression()));
-            return new LocalVariableDeclarationNode(createTypeNode(ctx.type().getText()), ctx.Identifier().getText(), ctx.Assign().getText(), (IExpressionNode) visit(ctx.expression()));
-        } else {
-            return new LocalVariableDeclarationNode(createTypeNode(ctx.type().getText()), ctx.Identifier().getText(), null, null);
-        }
-
     }
 
     @Override
@@ -219,60 +209,46 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitForStatement(SimpleJavaParser.ForStatementContext ctx) {
+
         List<IStatementNode> statements = new ArrayList<>();
 
-        // Initialisierung
+        //init
         int i = 0;
-        if (ctx.localVariableDeclaration() != null) {
+        if(ctx.localVariableDeclaration() != null) {
             statements.add((IStatementNode) visit(ctx.localVariableDeclaration()));
-        } else if (ctx.statementExpression(i) != null) {
+        } else if(ctx.statementExpression(i) != null){
             statements.add((IStatementNode) visit(ctx.statementExpression(i)));
             i++;
         }
 
-        // Bedingung
+        //condition
         IExpressionNode condition = (IExpressionNode) visit(ctx.expression());
 
-        // Inkrement
+        //ink
-        IStatementExpressionNode crement = null;
+        IStatementNode crement = null;
-        boolean isPrefix = false;
+        if(ctx.statementExpression(i) != null){
-        if (ctx.statementExpression(i) != null) {
+            crement = (IStatementNode) visit(ctx.statementExpression(i));
-            crement = (IStatementExpressionNode) visit(ctx.statementExpression(i));
-
-            if (crement instanceof IncrementNode) {
-                isPrefix = ((IncrementNode) crement).crementType == CrementType.PREFIX;
-            } else if (crement instanceof DecrementNode) {
-                isPrefix = ((DecrementNode) crement).crementType == CrementType.PREFIX;
-            }
         }
 
-        BlockNode forBlock = (BlockNode) visit(ctx.blockStatement());
+        BlockNode forBlock = new BlockNode();
 
-        // While-Schleife
+        BlockNode forStatements = (BlockNode) visit(ctx.blockStatement());
-        BlockNode whileBody = new BlockNode();
+        if(forStatements != null) {
-
+            forBlock.addStatement((IStatementNode) forStatements);
-        // Prä-Inkrement: Das Inkrement kommt vor dem Block
-        if (crement != null && isPrefix) {
-            whileBody.addStatement((IStatementNode) crement);
         }
 
-        // Block Statements der For-Schleife in den While-Block kopieren
+        if(crement != null){
-        for (IStatementNode statement : forBlock.statements) {
+            BlockNode forCrement = new BlockNode();
-            whileBody.addStatement(statement);
+            forCrement.addStatement((crement));
+            forBlock.addStatement(forCrement);
         }
 
-        // Post-Inkrement: Das Inkrement kommt nach dem Block
+        WhileNode While = new WhileNode(condition, forBlock);
-        if (crement != null && !isPrefix) {
-            whileBody.addStatement((IStatementNode) crement);
-        }
 
-        // Bedingung der While-Schleife
+        statements.add(While);
-        WhileNode whileNode = new WhileNode(condition, whileBody);
-
-        statements.add(whileNode);
 
         BlockNode resultBlock = new BlockNode();
-        for (IStatementNode statement : statements) {
+        for(IStatementNode statement : statements) {
             resultBlock.addStatement((IStatementNode) statement);
         }
 
@@ -281,13 +257,8 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitIfElseStatement(SimpleJavaParser.IfElseStatementContext ctx) {
-        IfElseNode ifElseStatementNode;
+        IfElseNode ifElseStatementNode =  new IfElseNode((IfNode) visit(ctx.ifStatement()),
-        if(ctx.elseStatement() != null) {
+                (ElseNode) visit(ctx.elseStatement()));
-            ifElseStatementNode =  new IfElseNode((IfNode) visit(ctx.ifStatement()),
-                    (ElseNode) visit(ctx.elseStatement()));
-        } else {
-            ifElseStatementNode =  new IfElseNode((IfNode) visit(ctx.ifStatement()), null);
-        }
 
         for (SimpleJavaParser.ElseIfStatementContext elseIf : ctx.elseIfStatement()){
             ifElseStatementNode.addElseIfStatement(((IfNode) visit(elseIf)));
@@ -325,49 +296,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    @Override
-    public ASTNode visitSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx) {
-        UnaryNode switchExpression = (UnaryNode) visit(ctx.expression());
-
-        List<IfNode> ifNodes = new ArrayList<>();
-
-        for (SimpleJavaParser.CaseStatementContext caseCtx : ctx.caseStatement()) {
-            IExpressionNode caseExpression = (IExpressionNode) visit(caseCtx.value());
-
-            // Condition as NonCalculationNode -> Equals Expression
-            NonCalculationNode condition = new NonCalculationNode(switchExpression, "==", caseExpression);
-
-            BlockNode caseBlock = new BlockNode();
-            for (SimpleJavaParser.StatementContext stmtCtx : caseCtx.statement()) {
-                caseBlock.addStatement((IStatementNode) visit(stmtCtx));
-            }
-
-            // Each case as if
-            IfNode ifNode = new IfNode(condition, caseBlock);
-            ifNodes.add(ifNode);
-        }
-
-        // Check if has Default
-        ElseNode defaulElseNode = null;
-        if (ctx.defaultStatement() != null) {
-            BlockNode defaultBlock = new BlockNode();
-            for (SimpleJavaParser.StatementContext stmtCtx : ctx.defaultStatement().statement()) {
-                defaultBlock.addStatement((IStatementNode) visit(stmtCtx));
-            }
-            // Default als letztes Else Statement
-            defaulElseNode = new ElseNode(defaultBlock);
-        }
-
-        IfElseNode ifElseNode = new IfElseNode(ifNodes.getFirst(),defaulElseNode);
-        ifNodes.removeFirst();
-
-        for (IfNode ifNode : ifNodes){
-            ifElseNode.addElseIfStatement(ifNode);
-        }
-
-        return ifElseNode;
-    }
-
     @Override
     public ASTNode visitAssign(SimpleJavaParser.AssignContext ctx) {
         return new AssignNode((AssignableNode) visit(ctx.assignableExpression()), (IExpressionNode) visit(ctx.expression()));
@@ -604,4 +532,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
             default -> new ReferenceType(identifier);
         };
     }
-}
+
+}
+

src/main/java/parser/generated/SimpleJava.tokens

@@ -41,18 +41,14 @@ Else=40
 For=41
 Return=42
 New=43
-Switch=44
+CharValue=44
-Case=45
+IntValue=45
-Default=46
+BooleanValue=46
-Colon=47
+NullValue=47
-CharValue=48
+Identifier=48
-IntValue=49
+WS=49
-BooleanValue=50
+InlineComment=50
-NullValue=51
+MultilineComment=51
-Identifier=52
-WS=53
-InlineComment=54
-MultilineComment=55
 '++'=1
 '--'=2
 'void'=3
@@ -91,8 +87,4 @@ MultilineComment=55
 'for'=41
 'return'=42
 'new'=43
-'switch'=44
+'null'=47
-'case'=45
-'default'=46
-':'=47
-'null'=51

src/main/java/parser/generated/SimpleJavaBaseListener.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 
 import org.antlr.v4.runtime.ParserRuleContext;
@@ -252,42 +252,6 @@ public class SimpleJavaBaseListener implements SimpleJavaListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitElseStatement(SimpleJavaParser.ElseStatementContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterCaseStatement(SimpleJavaParser.CaseStatementContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitCaseStatement(SimpleJavaParser.CaseStatementContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterDefaultStatement(SimpleJavaParser.DefaultStatementContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitDefaultStatement(SimpleJavaParser.DefaultStatementContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *

src/main/java/parser/generated/SimpleJavaBaseVisitor.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 
@@ -152,27 +152,6 @@ public class SimpleJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> implem
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
 	@Override public T visitElseStatement(SimpleJavaParser.ElseStatementContext ctx) { return visitChildren(ctx); }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation returns the result of calling
-	 * {@link #visitChildren} on {@code ctx}.</p>
-	 */
-	@Override public T visitSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx) { return visitChildren(ctx); }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation returns the result of calling
-	 * {@link #visitChildren} on {@code ctx}.</p>
-	 */
-	@Override public T visitCaseStatement(SimpleJavaParser.CaseStatementContext ctx) { return visitChildren(ctx); }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation returns the result of calling
-	 * {@link #visitChildren} on {@code ctx}.</p>
-	 */
-	@Override public T visitDefaultStatement(SimpleJavaParser.DefaultStatementContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *

src/main/java/parser/generated/SimpleJavaLexer.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.CharStream;
@@ -23,9 +23,9 @@ public class SimpleJavaLexer extends Lexer {
 		Less=20, GreaterEqual=21, LessEqual=22, Equal=23, NotEqual=24, Not=25, 
 		And=26, Or=27, Dot=28, OpenRoundBracket=29, ClosedRoundBracket=30, OpenCurlyBracket=31, 
 		ClosedCurlyBracket=32, Semicolon=33, Comma=34, Class=35, This=36, While=37, 
-		Do=38, If=39, Else=40, For=41, Return=42, New=43, Switch=44, Case=45, 
+		Do=38, If=39, Else=40, For=41, Return=42, New=43, CharValue=44, IntValue=45, 
-		Default=46, Colon=47, CharValue=48, IntValue=49, BooleanValue=50, NullValue=51, 
+		BooleanValue=46, NullValue=47, Identifier=48, WS=49, InlineComment=50, 
-		Identifier=52, WS=53, InlineComment=54, MultilineComment=55;
+		MultilineComment=51;
 	public static String[] channelNames = {
 		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
 	};
@@ -42,10 +42,9 @@ public class SimpleJavaLexer extends Lexer {
 			"GreaterEqual", "LessEqual", "Equal", "NotEqual", "Not", "And", "Or", 
 			"Dot", "OpenRoundBracket", "ClosedRoundBracket", "OpenCurlyBracket", 
 			"ClosedCurlyBracket", "Semicolon", "Comma", "Class", "This", "While", 
-			"Do", "If", "Else", "For", "Return", "New", "Switch", "Case", "Default", 
+			"Do", "If", "Else", "For", "Return", "New", "CharValue", "IntValue", 
-			"Colon", "CharValue", "IntValue", "BooleanValue", "NullValue", "Alphabetic", 
+			"BooleanValue", "NullValue", "Alphabetic", "Numeric", "ValidIdentSymbols", 
-			"Numeric", "ValidIdentSymbols", "Identifier", "WS", "InlineComment", 
+			"Identifier", "WS", "InlineComment", "MultilineComment"
-			"MultilineComment"
 		};
 	}
 	public static final String[] ruleNames = makeRuleNames();
@@ -57,8 +56,7 @@ public class SimpleJavaLexer extends Lexer {
 			"'+'", "'-'", "'*'", "'%'", "'/'", "'>'", "'<'", "'>='", "'<='", "'=='", 
 			"'!='", "'!'", "'&&'", "'||'", "'.'", "'('", "')'", "'{'", "'}'", "';'", 
 			"','", "'class'", "'this'", "'while'", "'do'", "'if'", "'else'", "'for'", 
-			"'return'", "'new'", "'switch'", "'case'", "'default'", "':'", null, 
+			"'return'", "'new'", null, null, null, "'null'"
-			null, null, "'null'"
 		};
 	}
 	private static final String[] _LITERAL_NAMES = makeLiteralNames();
@@ -70,9 +68,9 @@ public class SimpleJavaLexer extends Lexer {
 			"Greater", "Less", "GreaterEqual", "LessEqual", "Equal", "NotEqual", 
 			"Not", "And", "Or", "Dot", "OpenRoundBracket", "ClosedRoundBracket", 
 			"OpenCurlyBracket", "ClosedCurlyBracket", "Semicolon", "Comma", "Class", 
-			"This", "While", "Do", "If", "Else", "For", "Return", "New", "Switch", 
+			"This", "While", "Do", "If", "Else", "For", "Return", "New", "CharValue", 
-			"Case", "Default", "Colon", "CharValue", "IntValue", "BooleanValue", 
+			"IntValue", "BooleanValue", "NullValue", "Identifier", "WS", "InlineComment", 
-			"NullValue", "Identifier", "WS", "InlineComment", "MultilineComment"
+			"MultilineComment"
 		};
 	}
 	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
@@ -134,7 +132,7 @@ public class SimpleJavaLexer extends Lexer {
 	public ATN getATN() { return _ATN; }
 
 	public static final String _serializedATN =
-		"\u0004\u00007\u01bb\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+
+		"\u0004\u00003\u019d\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+
 		"\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004"+
 		"\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007"+
 		"\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b"+
@@ -149,263 +147,245 @@ public class SimpleJavaLexer extends Lexer {
 		"&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007"+
 		"+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u0007"+
 		"0\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u0007"+
-		"5\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0001\u0000"+
+		"5\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001"+
-		"\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002"+
+		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003"+
-		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+
 		"\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
-		"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005"+
+		"\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
-		"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006"+
+		"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006"+
 		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
 		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
 		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
 		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
 		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
 		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
-		"\u0001\u0006\u0003\u0006\u00ba\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007"+
+		"\u0001\u0006\u0001\u0006\u0003\u0006\u00b2\b\u0006\u0001\u0007\u0001\u0007"+
 		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
 		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
 		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
 		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
 		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
 		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
-		"\u0001\b\u0001\b\u0001\b\u0003\b\u00e6\b\b\u0001\t\u0001\t\u0003\t\u00ea"+
+		"\u0001\u0007\u0001\b\u0001\b\u0001\b\u0003\b\u00de\b\b\u0001\t\u0001\t"+
-		"\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u00f2\b\n"+
+		"\u0003\t\u00e2\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003"+
-		"\u0001\u000b\u0001\u000b\u0003\u000b\u00f6\b\u000b\u0001\f\u0001\f\u0001"+
+		"\n\u00ea\b\n\u0001\u000b\u0001\u000b\u0003\u000b\u00ee\b\u000b\u0001\f"+
-		"\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010"+
+		"\u0001\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f"+
-		"\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013"+
+		"\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012"+
-		"\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015"+
+		"\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015"+
-		"\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017"+
+		"\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017"+
-		"\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019"+
+		"\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019"+
-		"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001c"+
+		"\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b"+
-		"\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001f"+
+		"\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e"+
-		"\u0001\u001f\u0001 \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001"+
+		"\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001"+
-		"\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001"+
+		"\"\u0001\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001"+
-		"$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001"+
+		"$\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001&\u0001&\u0001"+
-		"\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001)"+
+		"&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001("+
-		"\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001"+
+		"\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001"+
-		"*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001,\u0001,\u0001"+
+		"*\u0001*\u0001+\u0001+\u0005+\u014f\b+\n+\f+\u0152\t+\u0001+\u0001+\u0001"+
-		",\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001"+
+		",\u0003,\u0157\b,\u0001,\u0004,\u015a\b,\u000b,\f,\u015b\u0001-\u0001"+
-		"-\u0001.\u0001.\u0001/\u0001/\u0005/\u016d\b/\n/\f/\u0170\t/\u0001/\u0001"+
+		"-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0003-\u0167\b-\u0001"+
-		"/\u00010\u00030\u0175\b0\u00010\u00040\u0178\b0\u000b0\f0\u0179\u0001"+
+		".\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u00010\u00010\u00011\u0001"+
-		"1\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00031\u0185"+
+		"1\u00011\u00031\u0175\b1\u00012\u00012\u00052\u0179\b2\n2\f2\u017c\t2"+
-		"\b1\u00012\u00012\u00012\u00012\u00012\u00013\u00013\u00014\u00014\u0001"+
+		"\u00013\u00043\u017f\b3\u000b3\f3\u0180\u00013\u00013\u00014\u00014\u0001"+
-		"5\u00015\u00015\u00035\u0193\b5\u00016\u00016\u00056\u0197\b6\n6\f6\u019a"+
+		"4\u00014\u00054\u0189\b4\n4\f4\u018c\t4\u00014\u00014\u00015\u00015\u0001"+
-		"\t6\u00017\u00047\u019d\b7\u000b7\f7\u019e\u00017\u00017\u00018\u0001"+
+		"5\u00015\u00055\u0194\b5\n5\f5\u0197\t5\u00015\u00015\u00015\u00015\u0001"+
-		"8\u00018\u00018\u00058\u01a7\b8\n8\f8\u01aa\t8\u00018\u00018\u00019\u0001"+
+		"5\u0001\u0195\u00006\u0001\u0001\u0003\u0002\u0005\u0003\u0007\u0004\t"+
-		"9\u00019\u00019\u00059\u01b2\b9\n9\f9\u01b5\t9\u00019\u00019\u00019\u0001"+
+		"\u0005\u000b\u0006\r\u0007\u000f\b\u0011\t\u0013\n\u0015\u000b\u0017\f"+
-		"9\u00019\u0001\u01b3\u0000:\u0001\u0001\u0003\u0002\u0005\u0003\u0007"+
+		"\u0019\r\u001b\u000e\u001d\u000f\u001f\u0010!\u0011#\u0012%\u0013\'\u0014"+
-		"\u0004\t\u0005\u000b\u0006\r\u0007\u000f\b\u0011\t\u0013\n\u0015\u000b"+
+		")\u0015+\u0016-\u0017/\u00181\u00193\u001a5\u001b7\u001c9\u001d;\u001e"+
-		"\u0017\f\u0019\r\u001b\u000e\u001d\u000f\u001f\u0010!\u0011#\u0012%\u0013"+
+		"=\u001f? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_\u0000a\u0000c\u0000e0g1i2k"+
-		"\'\u0014)\u0015+\u0016-\u0017/\u00181\u00193\u001a5\u001b7\u001c9\u001d"+
+		"3\u0001\u0000\u0005\u0002\u0000\n\n\r\r\u0002\u0000AZaz\u0001\u000009"+
-		";\u001e=\u001f? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_0a1c2e3g\u0000i\u0000"+
+		"\u0002\u0000$$__\u0003\u0000\t\n\r\r  \u01af\u0000\u0001\u0001\u0000\u0000"+
-		"k\u0000m4o5q6s7\u0001\u0000\u0005\u0002\u0000\n\n\r\r\u0002\u0000AZaz"+
+		"\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000"+
-		"\u0001\u000009\u0002\u0000$$__\u0003\u0000\t\n\r\r  \u01cd\u0000\u0001"+
+		"\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000"+
-		"\u0001\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005"+
+		"\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000"+
-		"\u0001\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001"+
+		"\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000"+
+		"\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000"+
+		"\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000"+
+		"\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000"+
+		"\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001"+
-		"\u0000\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000"+
+		"\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000"+
-		"\u0000\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000"+
+		"\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000"+
+		"\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000\u00001"+
-		"\'\u0001\u0000\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001"+
+		"\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u00005\u0001\u0000"+
-		"\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000"+
+		"\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000"+
-		"\u0000\u00001\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u0000"+
+		"\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?"+
-		"5\u0001\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001"+
+		"\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000"+
-		"\u0000\u0000\u0000\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000"+
+		"\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000?\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000"+
+		"\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M"+
-		"C\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001"+
+		"\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000"+
-		"\u0000\u0000\u0000\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000"+
+		"\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000"+
+		"\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000["+
-		"Q\u0001\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001"+
+		"\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000e\u0001\u0000"+
-		"\u0000\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000"+
+		"\u0000\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000"+
+		"\u0000k\u0001\u0000\u0000\u0000\u0001m\u0001\u0000\u0000\u0000\u0003p"+
-		"_\u0001\u0000\u0000\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001"+
+		"\u0001\u0000\u0000\u0000\u0005s\u0001\u0000\u0000\u0000\u0007x\u0001\u0000"+
-		"\u0000\u0000\u0000\u0000e\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000"+
+		"\u0000\u0000\t\u0080\u0001\u0000\u0000\u0000\u000b\u0085\u0001\u0000\u0000"+
-		"\u0000\u0000o\u0001\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000"+
+		"\u0000\r\u00b1\u0001\u0000\u0000\u0000\u000f\u00b3\u0001\u0000\u0000\u0000"+
-		"s\u0001\u0000\u0000\u0000\u0001u\u0001\u0000\u0000\u0000\u0003x\u0001"+
+		"\u0011\u00dd\u0001\u0000\u0000\u0000\u0013\u00e1\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u0005{\u0001\u0000\u0000\u0000\u0007\u0080\u0001\u0000"+
+		"\u0015\u00e9\u0001\u0000\u0000\u0000\u0017\u00ed\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000\t\u0088\u0001\u0000\u0000\u0000\u000b\u008d\u0001\u0000\u0000"+
+		"\u0019\u00ef\u0001\u0000\u0000\u0000\u001b\u00f1\u0001\u0000\u0000\u0000"+
-		"\u0000\r\u00b9\u0001\u0000\u0000\u0000\u000f\u00bb\u0001\u0000\u0000\u0000"+
+		"\u001d\u00f3\u0001\u0000\u0000\u0000\u001f\u00f5\u0001\u0000\u0000\u0000"+
-		"\u0011\u00e5\u0001\u0000\u0000\u0000\u0013\u00e9\u0001\u0000\u0000\u0000"+
+		"!\u00f7\u0001\u0000\u0000\u0000#\u00f9\u0001\u0000\u0000\u0000%\u00fb"+
-		"\u0015\u00f1\u0001\u0000\u0000\u0000\u0017\u00f5\u0001\u0000\u0000\u0000"+
+		"\u0001\u0000\u0000\u0000\'\u00fd\u0001\u0000\u0000\u0000)\u00ff\u0001"+
-		"\u0019\u00f7\u0001\u0000\u0000\u0000\u001b\u00f9\u0001\u0000\u0000\u0000"+
+		"\u0000\u0000\u0000+\u0102\u0001\u0000\u0000\u0000-\u0105\u0001\u0000\u0000"+
-		"\u001d\u00fb\u0001\u0000\u0000\u0000\u001f\u00fd\u0001\u0000\u0000\u0000"+
+		"\u0000/\u0108\u0001\u0000\u0000\u00001\u010b\u0001\u0000\u0000\u00003"+
-		"!\u00ff\u0001\u0000\u0000\u0000#\u0101\u0001\u0000\u0000\u0000%\u0103"+
+		"\u010d\u0001\u0000\u0000\u00005\u0110\u0001\u0000\u0000\u00007\u0113\u0001"+
-		"\u0001\u0000\u0000\u0000\'\u0105\u0001\u0000\u0000\u0000)\u0107\u0001"+
+		"\u0000\u0000\u00009\u0115\u0001\u0000\u0000\u0000;\u0117\u0001\u0000\u0000"+
-		"\u0000\u0000\u0000+\u010a\u0001\u0000\u0000\u0000-\u010d\u0001\u0000\u0000"+
+		"\u0000=\u0119\u0001\u0000\u0000\u0000?\u011b\u0001\u0000\u0000\u0000A"+
-		"\u0000/\u0110\u0001\u0000\u0000\u00001\u0113\u0001\u0000\u0000\u00003"+
+		"\u011d\u0001\u0000\u0000\u0000C\u011f\u0001\u0000\u0000\u0000E\u0121\u0001"+
-		"\u0115\u0001\u0000\u0000\u00005\u0118\u0001\u0000\u0000\u00007\u011b\u0001"+
+		"\u0000\u0000\u0000G\u0127\u0001\u0000\u0000\u0000I\u012c\u0001\u0000\u0000"+
-		"\u0000\u0000\u00009\u011d\u0001\u0000\u0000\u0000;\u011f\u0001\u0000\u0000"+
+		"\u0000K\u0132\u0001\u0000\u0000\u0000M\u0135\u0001\u0000\u0000\u0000O"+
-		"\u0000=\u0121\u0001\u0000\u0000\u0000?\u0123\u0001\u0000\u0000\u0000A"+
+		"\u0138\u0001\u0000\u0000\u0000Q\u013d\u0001\u0000\u0000\u0000S\u0141\u0001"+
-		"\u0125\u0001\u0000\u0000\u0000C\u0127\u0001\u0000\u0000\u0000E\u0129\u0001"+
+		"\u0000\u0000\u0000U\u0148\u0001\u0000\u0000\u0000W\u014c\u0001\u0000\u0000"+
-		"\u0000\u0000\u0000G\u012f\u0001\u0000\u0000\u0000I\u0134\u0001\u0000\u0000"+
+		"\u0000Y\u0156\u0001\u0000\u0000\u0000[\u0166\u0001\u0000\u0000\u0000]"+
-		"\u0000K\u013a\u0001\u0000\u0000\u0000M\u013d\u0001\u0000\u0000\u0000O"+
+		"\u0168\u0001\u0000\u0000\u0000_\u016d\u0001\u0000\u0000\u0000a\u016f\u0001"+
-		"\u0140\u0001\u0000\u0000\u0000Q\u0145\u0001\u0000\u0000\u0000S\u0149\u0001"+
+		"\u0000\u0000\u0000c\u0174\u0001\u0000\u0000\u0000e\u0176\u0001\u0000\u0000"+
-		"\u0000\u0000\u0000U\u0150\u0001\u0000\u0000\u0000W\u0154\u0001\u0000\u0000"+
+		"\u0000g\u017e\u0001\u0000\u0000\u0000i\u0184\u0001\u0000\u0000\u0000k"+
-		"\u0000Y\u015b\u0001\u0000\u0000\u0000[\u0160\u0001\u0000\u0000\u0000]"+
+		"\u018f\u0001\u0000\u0000\u0000mn\u0005+\u0000\u0000no\u0005+\u0000\u0000"+
-		"\u0168\u0001\u0000\u0000\u0000_\u016a\u0001\u0000\u0000\u0000a\u0174\u0001"+
+		"o\u0002\u0001\u0000\u0000\u0000pq\u0005-\u0000\u0000qr\u0005-\u0000\u0000"+
-		"\u0000\u0000\u0000c\u0184\u0001\u0000\u0000\u0000e\u0186\u0001\u0000\u0000"+
+		"r\u0004\u0001\u0000\u0000\u0000st\u0005v\u0000\u0000tu\u0005o\u0000\u0000"+
-		"\u0000g\u018b\u0001\u0000\u0000\u0000i\u018d\u0001\u0000\u0000\u0000k"+
+		"uv\u0005i\u0000\u0000vw\u0005d\u0000\u0000w\u0006\u0001\u0000\u0000\u0000"+
-		"\u0192\u0001\u0000\u0000\u0000m\u0194\u0001\u0000\u0000\u0000o\u019c\u0001"+
+		"xy\u0005b\u0000\u0000yz\u0005o\u0000\u0000z{\u0005o\u0000\u0000{|\u0005"+
-		"\u0000\u0000\u0000q\u01a2\u0001\u0000\u0000\u0000s\u01ad\u0001\u0000\u0000"+
+		"l\u0000\u0000|}\u0005e\u0000\u0000}~\u0005a\u0000\u0000~\u007f\u0005n"+
-		"\u0000uv\u0005+\u0000\u0000vw\u0005+\u0000\u0000w\u0002\u0001\u0000\u0000"+
+		"\u0000\u0000\u007f\b\u0001\u0000\u0000\u0000\u0080\u0081\u0005c\u0000"+
-		"\u0000xy\u0005-\u0000\u0000yz\u0005-\u0000\u0000z\u0004\u0001\u0000\u0000"+
+		"\u0000\u0081\u0082\u0005h\u0000\u0000\u0082\u0083\u0005a\u0000\u0000\u0083"+
-		"\u0000{|\u0005v\u0000\u0000|}\u0005o\u0000\u0000}~\u0005i\u0000\u0000"+
+		"\u0084\u0005r\u0000\u0000\u0084\n\u0001\u0000\u0000\u0000\u0085\u0086"+
-		"~\u007f\u0005d\u0000\u0000\u007f\u0006\u0001\u0000\u0000\u0000\u0080\u0081"+
+		"\u0005i\u0000\u0000\u0086\u0087\u0005n\u0000\u0000\u0087\u0088\u0005t"+
-		"\u0005b\u0000\u0000\u0081\u0082\u0005o\u0000\u0000\u0082\u0083\u0005o"+
+		"\u0000\u0000\u0088\f\u0001\u0000\u0000\u0000\u0089\u008a\u0005p\u0000"+
-		"\u0000\u0000\u0083\u0084\u0005l\u0000\u0000\u0084\u0085\u0005e\u0000\u0000"+
+		"\u0000\u008a\u008b\u0005u\u0000\u0000\u008b\u008c\u0005b\u0000\u0000\u008c"+
-		"\u0085\u0086\u0005a\u0000\u0000\u0086\u0087\u0005n\u0000\u0000\u0087\b"+
+		"\u008d\u0005l\u0000\u0000\u008d\u008e\u0005i\u0000\u0000\u008e\u00b2\u0005"+
-		"\u0001\u0000\u0000\u0000\u0088\u0089\u0005c\u0000\u0000\u0089\u008a\u0005"+
+		"c\u0000\u0000\u008f\u0090\u0005p\u0000\u0000\u0090\u0091\u0005r\u0000"+
-		"h\u0000\u0000\u008a\u008b\u0005a\u0000\u0000\u008b\u008c\u0005r\u0000"+
+		"\u0000\u0091\u0092\u0005i\u0000\u0000\u0092\u0093\u0005v\u0000\u0000\u0093"+
-		"\u0000\u008c\n\u0001\u0000\u0000\u0000\u008d\u008e\u0005i\u0000\u0000"+
+		"\u0094\u0005a\u0000\u0000\u0094\u0095\u0005t\u0000\u0000\u0095\u00b2\u0005"+
-		"\u008e\u008f\u0005n\u0000\u0000\u008f\u0090\u0005t\u0000\u0000\u0090\f"+
+		"e\u0000\u0000\u0096\u0097\u0005p\u0000\u0000\u0097\u0098\u0005u\u0000"+
-		"\u0001\u0000\u0000\u0000\u0091\u0092\u0005p\u0000\u0000\u0092\u0093\u0005"+
+		"\u0000\u0098\u0099\u0005b\u0000\u0000\u0099\u009a\u0005l\u0000\u0000\u009a"+
-		"u\u0000\u0000\u0093\u0094\u0005b\u0000\u0000\u0094\u0095\u0005l\u0000"+
+		"\u009b\u0005i\u0000\u0000\u009b\u009c\u0005c\u0000\u0000\u009c\u009d\u0005"+
-		"\u0000\u0095\u0096\u0005i\u0000\u0000\u0096\u00ba\u0005c\u0000\u0000\u0097"+
+		" \u0000\u0000\u009d\u009e\u0005s\u0000\u0000\u009e\u009f\u0005t\u0000"+
-		"\u0098\u0005p\u0000\u0000\u0098\u0099\u0005r\u0000\u0000\u0099\u009a\u0005"+
+		"\u0000\u009f\u00a0\u0005a\u0000\u0000\u00a0\u00a1\u0005t\u0000\u0000\u00a1"+
-		"i\u0000\u0000\u009a\u009b\u0005v\u0000\u0000\u009b\u009c\u0005a\u0000"+
+		"\u00a2\u0005i\u0000\u0000\u00a2\u00b2\u0005c\u0000\u0000\u00a3\u00a4\u0005"+
-		"\u0000\u009c\u009d\u0005t\u0000\u0000\u009d\u00ba\u0005e\u0000\u0000\u009e"+
+		"p\u0000\u0000\u00a4\u00a5\u0005r\u0000\u0000\u00a5\u00a6\u0005i\u0000"+
-		"\u009f\u0005p\u0000\u0000\u009f\u00a0\u0005u\u0000\u0000\u00a0\u00a1\u0005"+
+		"\u0000\u00a6\u00a7\u0005v\u0000\u0000\u00a7\u00a8\u0005a\u0000\u0000\u00a8"+
-		"b\u0000\u0000\u00a1\u00a2\u0005l\u0000\u0000\u00a2\u00a3\u0005i\u0000"+
+		"\u00a9\u0005t\u0000\u0000\u00a9\u00aa\u0005e\u0000\u0000\u00aa\u00ab\u0005"+
-		"\u0000\u00a3\u00a4\u0005c\u0000\u0000\u00a4\u00a5\u0005 \u0000\u0000\u00a5"+
+		" \u0000\u0000\u00ab\u00ac\u0005s\u0000\u0000\u00ac\u00ad\u0005t\u0000"+
-		"\u00a6\u0005s\u0000\u0000\u00a6\u00a7\u0005t\u0000\u0000\u00a7\u00a8\u0005"+
+		"\u0000\u00ad\u00ae\u0005a\u0000\u0000\u00ae\u00af\u0005t\u0000\u0000\u00af"+
-		"a\u0000\u0000\u00a8\u00a9\u0005t\u0000\u0000\u00a9\u00aa\u0005i\u0000"+
+		"\u00b0\u0005i\u0000\u0000\u00b0\u00b2\u0005c\u0000\u0000\u00b1\u0089\u0001"+
-		"\u0000\u00aa\u00ba\u0005c\u0000\u0000\u00ab\u00ac\u0005p\u0000\u0000\u00ac"+
+		"\u0000\u0000\u0000\u00b1\u008f\u0001\u0000\u0000\u0000\u00b1\u0096\u0001"+
-		"\u00ad\u0005r\u0000\u0000\u00ad\u00ae\u0005i\u0000\u0000\u00ae\u00af\u0005"+
+		"\u0000\u0000\u0000\u00b1\u00a3\u0001\u0000\u0000\u0000\u00b2\u000e\u0001"+
-		"v\u0000\u0000\u00af\u00b0\u0005a\u0000\u0000\u00b0\u00b1\u0005t\u0000"+
+		"\u0000\u0000\u0000\u00b3\u00b4\u0005p\u0000\u0000\u00b4\u00b5\u0005u\u0000"+
-		"\u0000\u00b1\u00b2\u0005e\u0000\u0000\u00b2\u00b3\u0005 \u0000\u0000\u00b3"+
+		"\u0000\u00b5\u00b6\u0005b\u0000\u0000\u00b6\u00b7\u0005l\u0000\u0000\u00b7"+
-		"\u00b4\u0005s\u0000\u0000\u00b4\u00b5\u0005t\u0000\u0000\u00b5\u00b6\u0005"+
+		"\u00b8\u0005i\u0000\u0000\u00b8\u00b9\u0005c\u0000\u0000\u00b9\u00ba\u0005"+
-		"a\u0000\u0000\u00b6\u00b7\u0005t\u0000\u0000\u00b7\u00b8\u0005i\u0000"+
+		" \u0000\u0000\u00ba\u00bb\u0005s\u0000\u0000\u00bb\u00bc\u0005t\u0000"+
-		"\u0000\u00b8\u00ba\u0005c\u0000\u0000\u00b9\u0091\u0001\u0000\u0000\u0000"+
+		"\u0000\u00bc\u00bd\u0005a\u0000\u0000\u00bd\u00be\u0005t\u0000\u0000\u00be"+
-		"\u00b9\u0097\u0001\u0000\u0000\u0000\u00b9\u009e\u0001\u0000\u0000\u0000"+
+		"\u00bf\u0005i\u0000\u0000\u00bf\u00c0\u0005c\u0000\u0000\u00c0\u00c1\u0005"+
-		"\u00b9\u00ab\u0001\u0000\u0000\u0000\u00ba\u000e\u0001\u0000\u0000\u0000"+
+		" \u0000\u0000\u00c1\u00c2\u0005v\u0000\u0000\u00c2\u00c3\u0005o\u0000"+
-		"\u00bb\u00bc\u0005p\u0000\u0000\u00bc\u00bd\u0005u\u0000\u0000\u00bd\u00be"+
+		"\u0000\u00c3\u00c4\u0005i\u0000\u0000\u00c4\u00c5\u0005d\u0000\u0000\u00c5"+
-		"\u0005b\u0000\u0000\u00be\u00bf\u0005l\u0000\u0000\u00bf\u00c0\u0005i"+
+		"\u00c6\u0005 \u0000\u0000\u00c6\u00c7\u0005m\u0000\u0000\u00c7\u00c8\u0005"+
-		"\u0000\u0000\u00c0\u00c1\u0005c\u0000\u0000\u00c1\u00c2\u0005 \u0000\u0000"+
+		"a\u0000\u0000\u00c8\u00c9\u0005i\u0000\u0000\u00c9\u00ca\u0005n\u0000"+
-		"\u00c2\u00c3\u0005s\u0000\u0000\u00c3\u00c4\u0005t\u0000\u0000\u00c4\u00c5"+
+		"\u0000\u00ca\u00cb\u0005(\u0000\u0000\u00cb\u00cc\u0005S\u0000\u0000\u00cc"+
-		"\u0005a\u0000\u0000\u00c5\u00c6\u0005t\u0000\u0000\u00c6\u00c7\u0005i"+
+		"\u00cd\u0005t\u0000\u0000\u00cd\u00ce\u0005r\u0000\u0000\u00ce\u00cf\u0005"+
-		"\u0000\u0000\u00c7\u00c8\u0005c\u0000\u0000\u00c8\u00c9\u0005 \u0000\u0000"+
+		"i\u0000\u0000\u00cf\u00d0\u0005n\u0000\u0000\u00d0\u00d1\u0005g\u0000"+
-		"\u00c9\u00ca\u0005v\u0000\u0000\u00ca\u00cb\u0005o\u0000\u0000\u00cb\u00cc"+
+		"\u0000\u00d1\u00d2\u0005[\u0000\u0000\u00d2\u00d3\u0005]\u0000\u0000\u00d3"+
-		"\u0005i\u0000\u0000\u00cc\u00cd\u0005d\u0000\u0000\u00cd\u00ce\u0005 "+
+		"\u00d4\u0005 \u0000\u0000\u00d4\u00d5\u0005a\u0000\u0000\u00d5\u00d6\u0005"+
-		"\u0000\u0000\u00ce\u00cf\u0005m\u0000\u0000\u00cf\u00d0\u0005a\u0000\u0000"+
+		"r\u0000\u0000\u00d6\u00d7\u0005g\u0000\u0000\u00d7\u00d8\u0005s\u0000"+
-		"\u00d0\u00d1\u0005i\u0000\u0000\u00d1\u00d2\u0005n\u0000\u0000\u00d2\u00d3"+
+		"\u0000\u00d8\u00d9\u0005)\u0000\u0000\u00d9\u0010\u0001\u0000\u0000\u0000"+
-		"\u0005(\u0000\u0000\u00d3\u00d4\u0005S\u0000\u0000\u00d4\u00d5\u0005t"+
+		"\u00da\u00de\u0003\u001f\u000f\u0000\u00db\u00de\u0003#\u0011\u0000\u00dc"+
-		"\u0000\u0000\u00d5\u00d6\u0005r\u0000\u0000\u00d6\u00d7\u0005i\u0000\u0000"+
+		"\u00de\u0003!\u0010\u0000\u00dd\u00da\u0001\u0000\u0000\u0000\u00dd\u00db"+
-		"\u00d7\u00d8\u0005n\u0000\u0000\u00d8\u00d9\u0005g\u0000\u0000\u00d9\u00da"+
+		"\u0001\u0000\u0000\u0000\u00dd\u00dc\u0001\u0000\u0000\u0000\u00de\u0012"+
-		"\u0005[\u0000\u0000\u00da\u00db\u0005]\u0000\u0000\u00db\u00dc\u0005 "+
+		"\u0001\u0000\u0000\u0000\u00df\u00e2\u0003\u001b\r\u0000\u00e0\u00e2\u0003"+
-		"\u0000\u0000\u00dc\u00dd\u0005a\u0000\u0000\u00dd\u00de\u0005r\u0000\u0000"+
+		"\u001d\u000e\u0000\u00e1\u00df\u0001\u0000\u0000\u0000\u00e1\u00e0\u0001"+
-		"\u00de\u00df\u0005g\u0000\u0000\u00df\u00e0\u0005s\u0000\u0000\u00e0\u00e1"+
+		"\u0000\u0000\u0000\u00e2\u0014\u0001\u0000\u0000\u0000\u00e3\u00ea\u0003"+
-		"\u0005)\u0000\u0000\u00e1\u0010\u0001\u0000\u0000\u0000\u00e2\u00e6\u0003"+
+		"%\u0012\u0000\u00e4\u00ea\u0003\'\u0013\u0000\u00e5\u00ea\u0003)\u0014"+
-		"\u001f\u000f\u0000\u00e3\u00e6\u0003#\u0011\u0000\u00e4\u00e6\u0003!\u0010"+
+		"\u0000\u00e6\u00ea\u0003+\u0015\u0000\u00e7\u00ea\u0003-\u0016\u0000\u00e8"+
-		"\u0000\u00e5\u00e2\u0001\u0000\u0000\u0000\u00e5\u00e3\u0001\u0000\u0000"+
+		"\u00ea\u0003/\u0017\u0000\u00e9\u00e3\u0001\u0000\u0000\u0000\u00e9\u00e4"+
-		"\u0000\u00e5\u00e4\u0001\u0000\u0000\u0000\u00e6\u0012\u0001\u0000\u0000"+
+		"\u0001\u0000\u0000\u0000\u00e9\u00e5\u0001\u0000\u0000\u0000\u00e9\u00e6"+
-		"\u0000\u00e7\u00ea\u0003\u001b\r\u0000\u00e8\u00ea\u0003\u001d\u000e\u0000"+
+		"\u0001\u0000\u0000\u0000\u00e9\u00e7\u0001\u0000\u0000\u0000\u00e9\u00e8"+
-		"\u00e9\u00e7\u0001\u0000\u0000\u0000\u00e9\u00e8\u0001\u0000\u0000\u0000"+
+		"\u0001\u0000\u0000\u0000\u00ea\u0016\u0001\u0000\u0000\u0000\u00eb\u00ee"+
-		"\u00ea\u0014\u0001\u0000\u0000\u0000\u00eb\u00f2\u0003%\u0012\u0000\u00ec"+
+		"\u00033\u0019\u0000\u00ec\u00ee\u00035\u001a\u0000\u00ed\u00eb\u0001\u0000"+
-		"\u00f2\u0003\'\u0013\u0000\u00ed\u00f2\u0003)\u0014\u0000\u00ee\u00f2"+
+		"\u0000\u0000\u00ed\u00ec\u0001\u0000\u0000\u0000\u00ee\u0018\u0001\u0000"+
-		"\u0003+\u0015\u0000\u00ef\u00f2\u0003-\u0016\u0000\u00f0\u00f2\u0003/"+
+		"\u0000\u0000\u00ef\u00f0\u0005=\u0000\u0000\u00f0\u001a\u0001\u0000\u0000"+
-		"\u0017\u0000\u00f1\u00eb\u0001\u0000\u0000\u0000\u00f1\u00ec\u0001\u0000"+
+		"\u0000\u00f1\u00f2\u0005+\u0000\u0000\u00f2\u001c\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000\u00f1\u00ed\u0001\u0000\u0000\u0000\u00f1\u00ee\u0001\u0000"+
+		"\u00f3\u00f4\u0005-\u0000\u0000\u00f4\u001e\u0001\u0000\u0000\u0000\u00f5"+
-		"\u0000\u0000\u00f1\u00ef\u0001\u0000\u0000\u0000\u00f1\u00f0\u0001\u0000"+
+		"\u00f6\u0005*\u0000\u0000\u00f6 \u0001\u0000\u0000\u0000\u00f7\u00f8\u0005"+
-		"\u0000\u0000\u00f2\u0016\u0001\u0000\u0000\u0000\u00f3\u00f6\u00033\u0019"+
+		"%\u0000\u0000\u00f8\"\u0001\u0000\u0000\u0000\u00f9\u00fa\u0005/\u0000"+
-		"\u0000\u00f4\u00f6\u00035\u001a\u0000\u00f5\u00f3\u0001\u0000\u0000\u0000"+
+		"\u0000\u00fa$\u0001\u0000\u0000\u0000\u00fb\u00fc\u0005>\u0000\u0000\u00fc"+
-		"\u00f5\u00f4\u0001\u0000\u0000\u0000\u00f6\u0018\u0001\u0000\u0000\u0000"+
+		"&\u0001\u0000\u0000\u0000\u00fd\u00fe\u0005<\u0000\u0000\u00fe(\u0001"+
-		"\u00f7\u00f8\u0005=\u0000\u0000\u00f8\u001a\u0001\u0000\u0000\u0000\u00f9"+
+		"\u0000\u0000\u0000\u00ff\u0100\u0005>\u0000\u0000\u0100\u0101\u0005=\u0000"+
-		"\u00fa\u0005+\u0000\u0000\u00fa\u001c\u0001\u0000\u0000\u0000\u00fb\u00fc"+
+		"\u0000\u0101*\u0001\u0000\u0000\u0000\u0102\u0103\u0005<\u0000\u0000\u0103"+
-		"\u0005-\u0000\u0000\u00fc\u001e\u0001\u0000\u0000\u0000\u00fd\u00fe\u0005"+
+		"\u0104\u0005=\u0000\u0000\u0104,\u0001\u0000\u0000\u0000\u0105\u0106\u0005"+
-		"*\u0000\u0000\u00fe \u0001\u0000\u0000\u0000\u00ff\u0100\u0005%\u0000"+
+		"=\u0000\u0000\u0106\u0107\u0005=\u0000\u0000\u0107.\u0001\u0000\u0000"+
-		"\u0000\u0100\"\u0001\u0000\u0000\u0000\u0101\u0102\u0005/\u0000\u0000"+
+		"\u0000\u0108\u0109\u0005!\u0000\u0000\u0109\u010a\u0005=\u0000\u0000\u010a"+
-		"\u0102$\u0001\u0000\u0000\u0000\u0103\u0104\u0005>\u0000\u0000\u0104&"+
+		"0\u0001\u0000\u0000\u0000\u010b\u010c\u0005!\u0000\u0000\u010c2\u0001"+
-		"\u0001\u0000\u0000\u0000\u0105\u0106\u0005<\u0000\u0000\u0106(\u0001\u0000"+
+		"\u0000\u0000\u0000\u010d\u010e\u0005&\u0000\u0000\u010e\u010f\u0005&\u0000"+
-		"\u0000\u0000\u0107\u0108\u0005>\u0000\u0000\u0108\u0109\u0005=\u0000\u0000"+
+		"\u0000\u010f4\u0001\u0000\u0000\u0000\u0110\u0111\u0005|\u0000\u0000\u0111"+
-		"\u0109*\u0001\u0000\u0000\u0000\u010a\u010b\u0005<\u0000\u0000\u010b\u010c"+
+		"\u0112\u0005|\u0000\u0000\u01126\u0001\u0000\u0000\u0000\u0113\u0114\u0005"+
-		"\u0005=\u0000\u0000\u010c,\u0001\u0000\u0000\u0000\u010d\u010e\u0005="+
+		".\u0000\u0000\u01148\u0001\u0000\u0000\u0000\u0115\u0116\u0005(\u0000"+
-		"\u0000\u0000\u010e\u010f\u0005=\u0000\u0000\u010f.\u0001\u0000\u0000\u0000"+
+		"\u0000\u0116:\u0001\u0000\u0000\u0000\u0117\u0118\u0005)\u0000\u0000\u0118"+
-		"\u0110\u0111\u0005!\u0000\u0000\u0111\u0112\u0005=\u0000\u0000\u01120"+
+		"<\u0001\u0000\u0000\u0000\u0119\u011a\u0005{\u0000\u0000\u011a>\u0001"+
-		"\u0001\u0000\u0000\u0000\u0113\u0114\u0005!\u0000\u0000\u01142\u0001\u0000"+
+		"\u0000\u0000\u0000\u011b\u011c\u0005}\u0000\u0000\u011c@\u0001\u0000\u0000"+
-		"\u0000\u0000\u0115\u0116\u0005&\u0000\u0000\u0116\u0117\u0005&\u0000\u0000"+
+		"\u0000\u011d\u011e\u0005;\u0000\u0000\u011eB\u0001\u0000\u0000\u0000\u011f"+
-		"\u01174\u0001\u0000\u0000\u0000\u0118\u0119\u0005|\u0000\u0000\u0119\u011a"+
+		"\u0120\u0005,\u0000\u0000\u0120D\u0001\u0000\u0000\u0000\u0121\u0122\u0005"+
-		"\u0005|\u0000\u0000\u011a6\u0001\u0000\u0000\u0000\u011b\u011c\u0005."+
+		"c\u0000\u0000\u0122\u0123\u0005l\u0000\u0000\u0123\u0124\u0005a\u0000"+
-		"\u0000\u0000\u011c8\u0001\u0000\u0000\u0000\u011d\u011e\u0005(\u0000\u0000"+
+		"\u0000\u0124\u0125\u0005s\u0000\u0000\u0125\u0126\u0005s\u0000\u0000\u0126"+
-		"\u011e:\u0001\u0000\u0000\u0000\u011f\u0120\u0005)\u0000\u0000\u0120<"+
+		"F\u0001\u0000\u0000\u0000\u0127\u0128\u0005t\u0000\u0000\u0128\u0129\u0005"+
-		"\u0001\u0000\u0000\u0000\u0121\u0122\u0005{\u0000\u0000\u0122>\u0001\u0000"+
+		"h\u0000\u0000\u0129\u012a\u0005i\u0000\u0000\u012a\u012b\u0005s\u0000"+
-		"\u0000\u0000\u0123\u0124\u0005}\u0000\u0000\u0124@\u0001\u0000\u0000\u0000"+
+		"\u0000\u012bH\u0001\u0000\u0000\u0000\u012c\u012d\u0005w\u0000\u0000\u012d"+
-		"\u0125\u0126\u0005;\u0000\u0000\u0126B\u0001\u0000\u0000\u0000\u0127\u0128"+
+		"\u012e\u0005h\u0000\u0000\u012e\u012f\u0005i\u0000\u0000\u012f\u0130\u0005"+
-		"\u0005,\u0000\u0000\u0128D\u0001\u0000\u0000\u0000\u0129\u012a\u0005c"+
+		"l\u0000\u0000\u0130\u0131\u0005e\u0000\u0000\u0131J\u0001\u0000\u0000"+
-		"\u0000\u0000\u012a\u012b\u0005l\u0000\u0000\u012b\u012c\u0005a\u0000\u0000"+
+		"\u0000\u0132\u0133\u0005d\u0000\u0000\u0133\u0134\u0005o\u0000\u0000\u0134"+
-		"\u012c\u012d\u0005s\u0000\u0000\u012d\u012e\u0005s\u0000\u0000\u012eF"+
+		"L\u0001\u0000\u0000\u0000\u0135\u0136\u0005i\u0000\u0000\u0136\u0137\u0005"+
-		"\u0001\u0000\u0000\u0000\u012f\u0130\u0005t\u0000\u0000\u0130\u0131\u0005"+
+		"f\u0000\u0000\u0137N\u0001\u0000\u0000\u0000\u0138\u0139\u0005e\u0000"+
-		"h\u0000\u0000\u0131\u0132\u0005i\u0000\u0000\u0132\u0133\u0005s\u0000"+
+		"\u0000\u0139\u013a\u0005l\u0000\u0000\u013a\u013b\u0005s\u0000\u0000\u013b"+
-		"\u0000\u0133H\u0001\u0000\u0000\u0000\u0134\u0135\u0005w\u0000\u0000\u0135"+
+		"\u013c\u0005e\u0000\u0000\u013cP\u0001\u0000\u0000\u0000\u013d\u013e\u0005"+
-		"\u0136\u0005h\u0000\u0000\u0136\u0137\u0005i\u0000\u0000\u0137\u0138\u0005"+
+		"f\u0000\u0000\u013e\u013f\u0005o\u0000\u0000\u013f\u0140\u0005r\u0000"+
-		"l\u0000\u0000\u0138\u0139\u0005e\u0000\u0000\u0139J\u0001\u0000\u0000"+
+		"\u0000\u0140R\u0001\u0000\u0000\u0000\u0141\u0142\u0005r\u0000\u0000\u0142"+
-		"\u0000\u013a\u013b\u0005d\u0000\u0000\u013b\u013c\u0005o\u0000\u0000\u013c"+
+		"\u0143\u0005e\u0000\u0000\u0143\u0144\u0005t\u0000\u0000\u0144\u0145\u0005"+
-		"L\u0001\u0000\u0000\u0000\u013d\u013e\u0005i\u0000\u0000\u013e\u013f\u0005"+
+		"u\u0000\u0000\u0145\u0146\u0005r\u0000\u0000\u0146\u0147\u0005n\u0000"+
-		"f\u0000\u0000\u013fN\u0001\u0000\u0000\u0000\u0140\u0141\u0005e\u0000"+
+		"\u0000\u0147T\u0001\u0000\u0000\u0000\u0148\u0149\u0005n\u0000\u0000\u0149"+
-		"\u0000\u0141\u0142\u0005l\u0000\u0000\u0142\u0143\u0005s\u0000\u0000\u0143"+
+		"\u014a\u0005e\u0000\u0000\u014a\u014b\u0005w\u0000\u0000\u014bV\u0001"+
-		"\u0144\u0005e\u0000\u0000\u0144P\u0001\u0000\u0000\u0000\u0145\u0146\u0005"+
+		"\u0000\u0000\u0000\u014c\u0150\u0005\'\u0000\u0000\u014d\u014f\b\u0000"+
-		"f\u0000\u0000\u0146\u0147\u0005o\u0000\u0000\u0147\u0148\u0005r\u0000"+
+		"\u0000\u0000\u014e\u014d\u0001\u0000\u0000\u0000\u014f\u0152\u0001\u0000"+
-		"\u0000\u0148R\u0001\u0000\u0000\u0000\u0149\u014a\u0005r\u0000\u0000\u014a"+
+		"\u0000\u0000\u0150\u014e\u0001\u0000\u0000\u0000\u0150\u0151\u0001\u0000"+
-		"\u014b\u0005e\u0000\u0000\u014b\u014c\u0005t\u0000\u0000\u014c\u014d\u0005"+
+		"\u0000\u0000\u0151\u0153\u0001\u0000\u0000\u0000\u0152\u0150\u0001\u0000"+
-		"u\u0000\u0000\u014d\u014e\u0005r\u0000\u0000\u014e\u014f\u0005n\u0000"+
+		"\u0000\u0000\u0153\u0154\u0005\'\u0000\u0000\u0154X\u0001\u0000\u0000"+
-		"\u0000\u014fT\u0001\u0000\u0000\u0000\u0150\u0151\u0005n\u0000\u0000\u0151"+
+		"\u0000\u0155\u0157\u0003\u001d\u000e\u0000\u0156\u0155\u0001\u0000\u0000"+
-		"\u0152\u0005e\u0000\u0000\u0152\u0153\u0005w\u0000\u0000\u0153V\u0001"+
+		"\u0000\u0156\u0157\u0001\u0000\u0000\u0000\u0157\u0159\u0001\u0000\u0000"+
-		"\u0000\u0000\u0000\u0154\u0155\u0005s\u0000\u0000\u0155\u0156\u0005w\u0000"+
+		"\u0000\u0158\u015a\u0003a0\u0000\u0159\u0158\u0001\u0000\u0000\u0000\u015a"+
-		"\u0000\u0156\u0157\u0005i\u0000\u0000\u0157\u0158\u0005t\u0000\u0000\u0158"+
+		"\u015b\u0001\u0000\u0000\u0000\u015b\u0159\u0001\u0000\u0000\u0000\u015b"+
-		"\u0159\u0005c\u0000\u0000\u0159\u015a\u0005h\u0000\u0000\u015aX\u0001"+
+		"\u015c\u0001\u0000\u0000\u0000\u015cZ\u0001\u0000\u0000\u0000\u015d\u015e"+
-		"\u0000\u0000\u0000\u015b\u015c\u0005c\u0000\u0000\u015c\u015d\u0005a\u0000"+
+		"\u0005t\u0000\u0000\u015e\u015f\u0005r\u0000\u0000\u015f\u0160\u0005u"+
-		"\u0000\u015d\u015e\u0005s\u0000\u0000\u015e\u015f\u0005e\u0000\u0000\u015f"+
+		"\u0000\u0000\u0160\u0167\u0005e\u0000\u0000\u0161\u0162\u0005f\u0000\u0000"+
-		"Z\u0001\u0000\u0000\u0000\u0160\u0161\u0005d\u0000\u0000\u0161\u0162\u0005"+
+		"\u0162\u0163\u0005a\u0000\u0000\u0163\u0164\u0005l\u0000\u0000\u0164\u0165"+
-		"e\u0000\u0000\u0162\u0163\u0005f\u0000\u0000\u0163\u0164\u0005a\u0000"+
+		"\u0005s\u0000\u0000\u0165\u0167\u0005e\u0000\u0000\u0166\u015d\u0001\u0000"+
-		"\u0000\u0164\u0165\u0005u\u0000\u0000\u0165\u0166\u0005l\u0000\u0000\u0166"+
+		"\u0000\u0000\u0166\u0161\u0001\u0000\u0000\u0000\u0167\\\u0001\u0000\u0000"+
-		"\u0167\u0005t\u0000\u0000\u0167\\\u0001\u0000\u0000\u0000\u0168\u0169"+
+		"\u0000\u0168\u0169\u0005n\u0000\u0000\u0169\u016a\u0005u\u0000\u0000\u016a"+
-		"\u0005:\u0000\u0000\u0169^\u0001\u0000\u0000\u0000\u016a\u016e\u0005\'"+
+		"\u016b\u0005l\u0000\u0000\u016b\u016c\u0005l\u0000\u0000\u016c^\u0001"+
-		"\u0000\u0000\u016b\u016d\b\u0000\u0000\u0000\u016c\u016b\u0001\u0000\u0000"+
+		"\u0000\u0000\u0000\u016d\u016e\u0007\u0001\u0000\u0000\u016e`\u0001\u0000"+
-		"\u0000\u016d\u0170\u0001\u0000\u0000\u0000\u016e\u016c\u0001\u0000\u0000"+
+		"\u0000\u0000\u016f\u0170\u0007\u0002\u0000\u0000\u0170b\u0001\u0000\u0000"+
-		"\u0000\u016e\u016f\u0001\u0000\u0000\u0000\u016f\u0171\u0001\u0000\u0000"+
+		"\u0000\u0171\u0175\u0003_/\u0000\u0172\u0175\u0003a0\u0000\u0173\u0175"+
-		"\u0000\u0170\u016e\u0001\u0000\u0000\u0000\u0171\u0172\u0005\'\u0000\u0000"+
+		"\u0007\u0003\u0000\u0000\u0174\u0171\u0001\u0000\u0000\u0000\u0174\u0172"+
-		"\u0172`\u0001\u0000\u0000\u0000\u0173\u0175\u0003\u001d\u000e\u0000\u0174"+
+		"\u0001\u0000\u0000\u0000\u0174\u0173\u0001\u0000\u0000\u0000\u0175d\u0001"+
-		"\u0173\u0001\u0000\u0000\u0000\u0174\u0175\u0001\u0000\u0000\u0000\u0175"+
+		"\u0000\u0000\u0000\u0176\u017a\u0003_/\u0000\u0177\u0179\u0003c1\u0000"+
-		"\u0177\u0001\u0000\u0000\u0000\u0176\u0178\u0003i4\u0000\u0177\u0176\u0001"+
+		"\u0178\u0177\u0001\u0000\u0000\u0000\u0179\u017c\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u0178\u0179\u0001\u0000\u0000\u0000\u0179\u0177\u0001"+
+		"\u017a\u0178\u0001\u0000\u0000\u0000\u017a\u017b\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000\u0000\u0179\u017a\u0001\u0000\u0000\u0000\u017ab\u0001\u0000"+
+		"\u017bf\u0001\u0000\u0000\u0000\u017c\u017a\u0001\u0000\u0000\u0000\u017d"+
-		"\u0000\u0000\u017b\u017c\u0005t\u0000\u0000\u017c\u017d\u0005r\u0000\u0000"+
+		"\u017f\u0007\u0004\u0000\u0000\u017e\u017d\u0001\u0000\u0000\u0000\u017f"+
-		"\u017d\u017e\u0005u\u0000\u0000\u017e\u0185\u0005e\u0000\u0000\u017f\u0180"+
+		"\u0180\u0001\u0000\u0000\u0000\u0180\u017e\u0001\u0000\u0000\u0000\u0180"+
-		"\u0005f\u0000\u0000\u0180\u0181\u0005a\u0000\u0000\u0181\u0182\u0005l"+
+		"\u0181\u0001\u0000\u0000\u0000\u0181\u0182\u0001\u0000\u0000\u0000\u0182"+
-		"\u0000\u0000\u0182\u0183\u0005s\u0000\u0000\u0183\u0185\u0005e\u0000\u0000"+
+		"\u0183\u00063\u0000\u0000\u0183h\u0001\u0000\u0000\u0000\u0184\u0185\u0005"+
-		"\u0184\u017b\u0001\u0000\u0000\u0000\u0184\u017f\u0001\u0000\u0000\u0000"+
+		"/\u0000\u0000\u0185\u0186\u0005/\u0000\u0000\u0186\u018a\u0001\u0000\u0000"+
-		"\u0185d\u0001\u0000\u0000\u0000\u0186\u0187\u0005n\u0000\u0000\u0187\u0188"+
+		"\u0000\u0187\u0189\b\u0000\u0000\u0000\u0188\u0187\u0001\u0000\u0000\u0000"+
-		"\u0005u\u0000\u0000\u0188\u0189\u0005l\u0000\u0000\u0189\u018a\u0005l"+
+		"\u0189\u018c\u0001\u0000\u0000\u0000\u018a\u0188\u0001\u0000\u0000\u0000"+
-		"\u0000\u0000\u018af\u0001\u0000\u0000\u0000\u018b\u018c\u0007\u0001\u0000"+
+		"\u018a\u018b\u0001\u0000\u0000\u0000\u018b\u018d\u0001\u0000\u0000\u0000"+
-		"\u0000\u018ch\u0001\u0000\u0000\u0000\u018d\u018e\u0007\u0002\u0000\u0000"+
+		"\u018c\u018a\u0001\u0000\u0000\u0000\u018d\u018e\u00064\u0000\u0000\u018e"+
-		"\u018ej\u0001\u0000\u0000\u0000\u018f\u0193\u0003g3\u0000\u0190\u0193"+
+		"j\u0001\u0000\u0000\u0000\u018f\u0190\u0005/\u0000\u0000\u0190\u0191\u0005"+
-		"\u0003i4\u0000\u0191\u0193\u0007\u0003\u0000\u0000\u0192\u018f\u0001\u0000"+
+		"*\u0000\u0000\u0191\u0195\u0001\u0000\u0000\u0000\u0192\u0194\t\u0000"+
-		"\u0000\u0000\u0192\u0190\u0001\u0000\u0000\u0000\u0192\u0191\u0001\u0000"+
+		"\u0000\u0000\u0193\u0192\u0001\u0000\u0000\u0000\u0194\u0197\u0001\u0000"+
-		"\u0000\u0000\u0193l\u0001\u0000\u0000\u0000\u0194\u0198\u0003g3\u0000"+
+		"\u0000\u0000\u0195\u0196\u0001\u0000\u0000\u0000\u0195\u0193\u0001\u0000"+
-		"\u0195\u0197\u0003k5\u0000\u0196\u0195\u0001\u0000\u0000\u0000\u0197\u019a"+
+		"\u0000\u0000\u0196\u0198\u0001\u0000\u0000\u0000\u0197\u0195\u0001\u0000"+
-		"\u0001\u0000\u0000\u0000\u0198\u0196\u0001\u0000\u0000\u0000\u0198\u0199"+
+		"\u0000\u0000\u0198\u0199\u0005*\u0000\u0000\u0199\u019a\u0005/\u0000\u0000"+
-		"\u0001\u0000\u0000\u0000\u0199n\u0001\u0000\u0000\u0000\u019a\u0198\u0001"+
+		"\u019a\u019b\u0001\u0000\u0000\u0000\u019b\u019c\u00065\u0000\u0000\u019c"+
-		"\u0000\u0000\u0000\u019b\u019d\u0007\u0004\u0000\u0000\u019c\u019b\u0001"+
+		"l\u0001\u0000\u0000\u0000\u000f\u0000\u00b1\u00dd\u00e1\u00e9\u00ed\u0150"+
-		"\u0000\u0000\u0000\u019d\u019e\u0001\u0000\u0000\u0000\u019e\u019c\u0001"+
+		"\u0156\u015b\u0166\u0174\u017a\u0180\u018a\u0195\u0001\u0006\u0000\u0000";
-		"\u0000\u0000\u0000\u019e\u019f\u0001\u0000\u0000\u0000\u019f\u01a0\u0001"+
-		"\u0000\u0000\u0000\u01a0\u01a1\u00067\u0000\u0000\u01a1p\u0001\u0000\u0000"+
-		"\u0000\u01a2\u01a3\u0005/\u0000\u0000\u01a3\u01a4\u0005/\u0000\u0000\u01a4"+
-		"\u01a8\u0001\u0000\u0000\u0000\u01a5\u01a7\b\u0000\u0000\u0000\u01a6\u01a5"+
-		"\u0001\u0000\u0000\u0000\u01a7\u01aa\u0001\u0000\u0000\u0000\u01a8\u01a6"+
-		"\u0001\u0000\u0000\u0000\u01a8\u01a9\u0001\u0000\u0000\u0000\u01a9\u01ab"+
-		"\u0001\u0000\u0000\u0000\u01aa\u01a8\u0001\u0000\u0000\u0000\u01ab\u01ac"+
-		"\u00068\u0000\u0000\u01acr\u0001\u0000\u0000\u0000\u01ad\u01ae\u0005/"+
-		"\u0000\u0000\u01ae\u01af\u0005*\u0000\u0000\u01af\u01b3\u0001\u0000\u0000"+
-		"\u0000\u01b0\u01b2\t\u0000\u0000\u0000\u01b1\u01b0\u0001\u0000\u0000\u0000"+
-		"\u01b2\u01b5\u0001\u0000\u0000\u0000\u01b3\u01b4\u0001\u0000\u0000\u0000"+
-		"\u01b3\u01b1\u0001\u0000\u0000\u0000\u01b4\u01b6\u0001\u0000\u0000\u0000"+
-		"\u01b5\u01b3\u0001\u0000\u0000\u0000\u01b6\u01b7\u0005*\u0000\u0000\u01b7"+
-		"\u01b8\u0005/\u0000\u0000\u01b8\u01b9\u0001\u0000\u0000\u0000\u01b9\u01ba"+
-		"\u00069\u0000\u0000\u01bat\u0001\u0000\u0000\u0000\u000f\u0000\u00b9\u00e5"+
-		"\u00e9\u00f1\u00f5\u016e\u0174\u0179\u0184\u0192\u0198\u019e\u01a8\u01b3"+
-		"\u0001\u0006\u0000\u0000";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {

src/main/java/parser/generated/SimpleJavaLexer.tokens

@@ -41,18 +41,14 @@ Else=40
 For=41
 Return=42
 New=43
-Switch=44
+CharValue=44
-Case=45
+IntValue=45
-Default=46
+BooleanValue=46
-Colon=47
+NullValue=47
-CharValue=48
+Identifier=48
-IntValue=49
+WS=49
-BooleanValue=50
+InlineComment=50
-NullValue=51
+MultilineComment=51
-Identifier=52
-WS=53
-InlineComment=54
-MultilineComment=55
 '++'=1
 '--'=2
 'void'=3
@@ -91,8 +87,4 @@ MultilineComment=55
 'for'=41
 'return'=42
 'new'=43
-'switch'=44
+'null'=47
-'case'=45
-'default'=46
-':'=47
-'null'=51

src/main/java/parser/generated/SimpleJavaListener.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 
@@ -207,36 +207,6 @@ public interface SimpleJavaListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitElseStatement(SimpleJavaParser.ElseStatementContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link SimpleJavaParser#switchStatement}.
-	 * @param ctx the parse tree
-	 */
-	void enterSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link SimpleJavaParser#switchStatement}.
-	 * @param ctx the parse tree
-	 */
-	void exitSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link SimpleJavaParser#caseStatement}.
-	 * @param ctx the parse tree
-	 */
-	void enterCaseStatement(SimpleJavaParser.CaseStatementContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link SimpleJavaParser#caseStatement}.
-	 * @param ctx the parse tree
-	 */
-	void exitCaseStatement(SimpleJavaParser.CaseStatementContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link SimpleJavaParser#defaultStatement}.
-	 * @param ctx the parse tree
-	 */
-	void enterDefaultStatement(SimpleJavaParser.DefaultStatementContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link SimpleJavaParser#defaultStatement}.
-	 * @param ctx the parse tree
-	 */
-	void exitDefaultStatement(SimpleJavaParser.DefaultStatementContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link SimpleJavaParser#statementExpression}.
 	 * @param ctx the parse tree

src/main/java/parser/generated/SimpleJavaVisitor.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
@@ -130,24 +130,6 @@ public interface SimpleJavaVisitor<T> extends ParseTreeVisitor<T> {
 	 * @return the visitor result
 	 */
 	T visitElseStatement(SimpleJavaParser.ElseStatementContext ctx);
-	/**
-	 * Visit a parse tree produced by {@link SimpleJavaParser#switchStatement}.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	T visitSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx);
-	/**
-	 * Visit a parse tree produced by {@link SimpleJavaParser#caseStatement}.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	T visitCaseStatement(SimpleJavaParser.CaseStatementContext ctx);
-	/**
-	 * Visit a parse tree produced by {@link SimpleJavaParser#defaultStatement}.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	T visitDefaultStatement(SimpleJavaParser.DefaultStatementContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link SimpleJavaParser#statementExpression}.
 	 * @param ctx the parse tree

src/main/java/parser/grammar/SimpleJava.g4

@@ -7,7 +7,7 @@ classDeclaration: AccessModifier? 'class' Identifier OpenCurlyBracket memberDecl
 memberDeclaration: constructorDeclaration | fieldDeclaration | methodDeclaration;
 
 constructorDeclaration: AccessModifier? Identifier OpenRoundBracket parameterList? ClosedRoundBracket blockStatement;
-fieldDeclaration: AccessModifier? type Identifier (Assign expression)? Semicolon;
+fieldDeclaration: AccessModifier? type Identifier Semicolon;
 methodDeclaration: MainMethodDeclaration blockStatement | AccessModifier? (type | Void) Identifier OpenRoundBracket parameterList? ClosedRoundBracket blockStatement;
 
 parameterList: parameter (Comma parameter)*;
@@ -22,7 +22,6 @@ statement: returnStatement Semicolon
          | doWhileStatement
          | forStatement
          | ifElseStatement
-         | switchStatement
          | statementExpression Semicolon;
 
 blockStatement: OpenCurlyBracket statement* ClosedCurlyBracket;
@@ -39,10 +38,6 @@ ifStatement: If OpenRoundBracket expression ClosedRoundBracket blockStatement;
 elseIfStatement: Else If OpenRoundBracket expression ClosedRoundBracket blockStatement;
 elseStatement: Else blockStatement;
 
-switchStatement: Switch OpenRoundBracket expression ClosedRoundBracket OpenCurlyBracket caseStatement+ defaultStatement? ClosedCurlyBracket;
-caseStatement: Case value Colon statement*;
-defaultStatement: Default Colon statement*;
-
 statementExpression: assign | newDeclaration | methodCall | crementExpression;
 assign: assignableExpression Assign expression;
 newDeclaration: New Identifier OpenRoundBracket argumentList ClosedRoundBracket;
@@ -158,10 +153,6 @@ Else: 'else';
 For: 'for';
 Return: 'return';
 New: 'new';
-Switch: 'switch';
-Case: 'case';
-Default: 'default';
-Colon: ':';
 
 // Werte
 CharValue: '\'' ~[\r\n]* '\'';

src/main/java/semantic/SemanticAnalyzer.java

@@ -21,7 +21,6 @@ import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
-import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
@@ -30,7 +29,6 @@ import ast.type.EnumAccessModifierNode;
 import ast.type.ValueNode;
 import ast.type.type.*;
 import com.sun.jdi.IntegerType;
-import semantic.context.ClassContext;
 import semantic.context.Context;
 import semantic.exceptions.*;
 import typechecker.TypeCheckResult;
@@ -165,11 +163,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(FieldNode toCheck) {
-        if (toCheck.type instanceof ReferenceType referenceType) {
-            if (!context.containsClass(referenceType.getIdentifier())) {
-                errors.add(new NotDeclaredException(referenceType.getIdentifier() + " not declared"));
-            }
-        }
         if (currentFields.get(toCheck.identifier) != null) {
             errors.add(new AlreadyDeclaredException("Already declared " + toCheck.identifier));
             return new TypeCheckResult(false, null);
@@ -177,8 +170,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
             currentFields.put(toCheck.identifier, toCheck.type);
         }
         return new TypeCheckResult(true, null);
-
-
     }
 
     @Override
@@ -233,7 +224,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
         }
         for (IStatementNode statementNode : blockNode.statements) {
             var result = statementNode.accept(this);
-            if (!(statementNode instanceof IncrementNode) && !(statementNode instanceof DecrementNode)) {
+            if(!(statementNode instanceof IncrementNode) && !(statementNode instanceof DecrementNode)){
                 if (result.getType() != null) {
                     if (blockReturnType == null) {
                         blockReturnType = result.getType();
@@ -253,16 +244,11 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (toCheck.memberAccess != null) {
             var result = toCheck.memberAccess.accept(this);
-            toCheck.identifier = toCheck.memberAccess.identifiers.getLast();
             toCheck.setTypeNode(result.getType());
             return result;
         } else {
             if (currentFields.get(toCheck.identifier) != null) {
                 var type = currentFields.get(toCheck.identifier);
-                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
-                memberAccessNode.identifiers.add(currentClass.identifier);
-                memberAccessNode.identifiers.add(toCheck.identifier);
-                toCheck.memberAccess = memberAccessNode;
                 toCheck.setTypeNode(type);
                 return new TypeCheckResult(true, type);
             } else if (currentScope.getLocalVar(toCheck.identifier) != null) {
@@ -289,6 +275,13 @@ public class SemanticAnalyzer implements SemanticVisitor {
         currentNullType = oldNullType;
         var valid = true;
 
+        // This check currently handles things like :
+        /**
+         * private int i;
+         * void foo(int i){
+         * i = i;
+         * }
+         */
         if (assignable.equals(rExpression)) {
             errors.add(new TypeMismatchException("Cannot assign to self"));
             valid = false;
@@ -317,84 +310,41 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(IfElseNode toCheck) {
         var resultIf = toCheck.ifStatement.accept(this);
-        if(toCheck.elseStatement != null){
+        var resultElse = toCheck.elseStatement.accept(this);
-            var resultElse = toCheck.elseStatement.accept(this);
-            return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
-        }
 
-
+        return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
-        return new TypeCheckResult(resultIf.isValid(), new BaseType(TypeEnum.VOID));
     }
 
     @Override
     public TypeCheckResult analyze(MethodCallNode toCheck) {
 
-        if (toCheck.target != null) {
+        if (toCheck.target.identifier != null) {
-            if(toCheck.target.memberAccess == null){
+            var targetType = currentScope.getLocalVar(toCheck.target.identifier);
-                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
+            if (targetType == null) {
-                memberAccessNode.identifiers.add(currentClass.identifier);
+                targetType = currentFields.get(toCheck.target.identifier);
-                memberAccessNode.identifiers.add(toCheck.target.identifier);
-                toCheck.target.memberAccess = memberAccessNode;
             }
-            if (toCheck.target.identifier != null) {
+            if (targetType instanceof ReferenceType reference) {
-                var targetType = currentScope.getLocalVar(toCheck.target.identifier);
+                var type = getTypeFromMethod(toCheck, reference);
-                if (targetType == null) {
+                if (type != null) {
-                    targetType = currentFields.get(toCheck.target.identifier);
+                    return new TypeCheckResult(true, type);
-                }
-                if (targetType instanceof ReferenceType reference) {
-                    if (!toCheck.chainedMethods.isEmpty()) {
-                        for (ChainedMethodNode chainedMethod : toCheck.chainedMethods) {
-                            var type = getTypeFromMethod(chainedMethod, reference);
-                            if (type instanceof ReferenceType referenceType)
-                                reference = referenceType;
-                            else
-                                errors.add(new TypeMismatchException("Ein Basetyp hat keine funktionen"));
-                        }
-                    }
-                    var type = getTypeFromMethod(toCheck, reference);
-                    if (type != null) {
-                        return new TypeCheckResult(true, type);
-                    } else {
-                        return new TypeCheckResult(false, null);
-                    }
-
-                }
-            } else {
-                if (toCheck.target.thisTar != null) {
-                    if (toCheck.target.thisTar) {
-                        var type = getTypeFromMethod(toCheck, new ReferenceType(currentClass.identifier));
-                        if (type != null) {
-                            return new TypeCheckResult(true, type);
-                        }
-                    }
                 } else {
-                    var result = toCheck.target.accept(this);
+                    return new TypeCheckResult(false, null);
-                    if (result.getType() instanceof ReferenceType reference) {
-                        return new TypeCheckResult(true, getTypeFromMethod(toCheck, reference));
-                    }
                 }
+
             }
         } else {
-
+            if (toCheck.target.thisTar) {
-            ReferenceType reference = new ReferenceType(currentClass.identifier);
+                var type = getTypeFromMethod(toCheck, new ReferenceType(currentClass.identifier));
-            if (!toCheck.chainedMethods.isEmpty()) {
+                if (type != null) {
-                for (ChainedMethodNode chainedMethod : toCheck.chainedMethods) {
+                    return new TypeCheckResult(true, type);
-                    var type = getTypeFromMethod(chainedMethod, reference);
+                }
-                    if (type instanceof ReferenceType referenceType)
+            } else {
-                        reference = referenceType;
+                var result = toCheck.target.accept(this);
-                    else
+                if (result.getType() instanceof ReferenceType reference) {
-                        errors.add(new TypeMismatchException("Ein Basetyp hat keine funktionen"));
+                    return new TypeCheckResult(true, getTypeFromMethod(toCheck, reference));
                 }
             }
-            var type = getTypeFromMethod(toCheck, reference);
-            if (type != null) {
-                return new TypeCheckResult(true, type);
-            } else {
-                return new TypeCheckResult(false, null);
-            }
-
         }
-
         return new TypeCheckResult(false, null);
     }
 
@@ -433,9 +383,9 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (context.containsClass(toCheck.identifier)) {
             return new TypeCheckResult(true, new ReferenceType(toCheck.identifier));
-        } else {
-            throw new RuntimeException("Cannot find class " + toCheck.identifier);
         }
+
+        return null;
     }
 
     @Override
@@ -459,7 +409,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
                     case PLUS, MINUS:
                         if (calcRes.getType() instanceof BaseType calcType && dotRes.getType() instanceof BaseType dotType &&
                                 calcType.getTypeEnum().equals(TypeEnum.INT) && dotType.getTypeEnum().equals(TypeEnum.INT)) {
-                            calcNode.setType(new BaseType(TypeEnum.INT));
                             return new TypeCheckResult(true, new BaseType(TypeEnum.INT));
                         }
                         break;
@@ -467,12 +416,10 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 }
 
             } else {
-                calcNode.setType(calcNode.getType());
                 return new TypeCheckResult(calcRes.isValid(), calcRes.getType());
             }
         } else if (calcNode.dotExpression != null) {
             var dotRes = calcNode.dotExpression.accept(this);
-            calcNode.setType(dotRes.getType());
             return new TypeCheckResult(dotRes.isValid(), dotRes.getType());
         }
         return new TypeCheckResult(false, null);
@@ -481,9 +428,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(DotNode toCheck) {
         if (toCheck.dotSubstractionExpression != null) {
-            var result = toCheck.dotSubstractionExpression.accept(this);
+            return toCheck.dotSubstractionExpression.accept(this);
-            toCheck.setType(result.getType());
-            return result;
         }
         return new TypeCheckResult(false, null);
     }
@@ -491,35 +436,19 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(DotSubstractionNode toCheck) {
         if (toCheck.value != null) {
-            var result = toCheck.value.accept(this);
+            return toCheck.value.accept(this);
-            toCheck.setType(result.getType());
-            return result;
         } else if (toCheck.memberAccess != null) {
-            var result = toCheck.memberAccess.accept(this);
+            return toCheck.memberAccess.accept(this);
-            toCheck.setType(result.getType());
-            return result;
         } else if (toCheck.methodCall != null) {
-            var result = toCheck.methodCall.accept(this);
+            return toCheck.methodCall.accept(this);
-            toCheck.setType(result.getType());
-            return result;
         } else if (toCheck.identifier != null) {
             if (currentScope.contains(toCheck.identifier)) {
-                var type = currentScope.getLocalVar(toCheck.identifier);
+                return new TypeCheckResult(true, currentScope.getLocalVar(toCheck.identifier));
-                toCheck.setType(type);
-                return new TypeCheckResult(true, type);
             } else if (currentFields.get(toCheck.identifier) != null) {
-                var type = currentFields.get(toCheck.identifier);
+                return new TypeCheckResult(true, currentFields.get(toCheck.identifier));
-                toCheck.setType(type);
-                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
-                memberAccessNode.identifiers.add(currentClass.identifier);
-                memberAccessNode.identifiers.add(toCheck.identifier);
-                toCheck.memberAccess = memberAccessNode;
-                return new TypeCheckResult(true, type);
             }
         } else if (toCheck.calculationExpression != null) {
-            var result = toCheck.calculationExpression.accept(this);
+            return toCheck.calculationExpression.accept(this);
-            toCheck.setType(result.getType());
-            return result;
         }
         return null;
     }
@@ -539,8 +468,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 }
                 break;
             case OR, AND:
-                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.BOOL) &&
+                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.INT) &&
-                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.BOOL)) {
+                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.INT)) {
                     return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
                 } else {
                     errors.add(new TypeMismatchException("Both types must be Boolean"));
@@ -564,17 +493,9 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (unary.identifier != null) {
             if (currentScope.contains(unary.identifier)) {
-                var type = currentScope.getLocalVar(unary.identifier);
+                return new TypeCheckResult(valid, currentScope.getLocalVar(unary.identifier));
-                unary.setType(type);
-                return new TypeCheckResult(valid, type);
             } else if (currentFields.get(unary.identifier) != null) {
-                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
+                return new TypeCheckResult(valid, currentFields.get(unary.identifier));
-                memberAccessNode.identifiers.add(currentClass.identifier);
-                memberAccessNode.identifiers.add(unary.identifier);
-                unary.memberAccess = memberAccessNode;
-                var type = currentFields.get(unary.identifier);
-                unary.setType(type);
-                return new TypeCheckResult(valid,type );
             } else if (unary.statement != null) {
                 var result = unary.statement.accept(this);
                 unary.setType(result.getType());
@@ -584,19 +505,15 @@ public class SemanticAnalyzer implements SemanticVisitor {
             }
         } else if (unary.statement != null) {
             var result = unary.statement.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         } else if (unary.value != null) {
             var result = unary.value.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         } else if (unary.memberAccess != null) {
             var result = unary.memberAccess.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         } else if (unary.expression != null) {
             var result = unary.expression.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         }
 
@@ -607,20 +524,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
     public TypeCheckResult analyze(MemberAccessNode memberAccessNode) {
 
         ITypeNode currentType = null;
-        int start = 0;
-        if(!memberAccessNode.identifiers.isEmpty()){
-            if(currentFields.get(memberAccessNode.identifiers.getFirst()) != null){
-                memberAccessNode.identifiers.addFirst(currentClass.identifier);
-                start++;
-            }
-        }
-        if(context.getClasses().get(memberAccessNode.identifiers.getFirst()) == null){
-            memberAccessNode.identifiers.addFirst(currentClass.identifier);
-            start++;
-        }
-        for (int i = start; i < memberAccessNode.identifiers.size(); i++) {
 
-            String s = memberAccessNode.identifiers.get(i);
+        for (String s : memberAccessNode.identifiers) {
             if (currentType == null) {
                 if (currentScope.getLocalVar(s) != null) {
                     currentType = currentScope.getLocalVar(s);
@@ -635,8 +540,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
             } else {
                 if (currentType instanceof ReferenceType reference) {
                     var currentTypeClass = context.getClass(reference.getIdentifier());
-                    memberAccessNode.identifiers.add(i, reference.getIdentifier());
+
-                    i++;
                     var currentField = currentTypeClass.getField(s);
                     if (currentField.getAccessModifier().accessType == EnumAccessModifierNode.PUBLIC) {
                         currentType = currentField.getType();
@@ -657,11 +561,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (targetNode.memberAccess != null) {
             return targetNode.memberAccess.accept(this);
-        } else if(targetNode.identifier != null) {
-            MemberAccessNode memberAccessNode = new MemberAccessNode(false);
-            memberAccessNode.identifiers.add(currentClass.identifier);
-            memberAccessNode.identifiers.add(targetNode.identifier);
-            targetNode.memberAccess = memberAccessNode;
         }
         return null;
     }
@@ -721,37 +620,4 @@ public class SemanticAnalyzer implements SemanticVisitor {
         return null;
     }
 
-    private ITypeNode getTypeFromMethod(ChainedMethodNode toCheck, ReferenceType reference) {
-        var classContext = context.getClass(reference.getIdentifier());
-
-        var methods = classContext.getMethods();
-        for (var method : methods) {
-            if (toCheck.identifier.equals(method.getIdentifier())) {
-                if (method.getParameters().size() == toCheck.expressions.size() && !(method instanceof ConstructorNode)) {
-                    boolean same = true;
-                    for (int i = 0; i < method.getParameters().size(); i++) {
-                        var result1 = method.getParameters().get(i).accept(this);
-                        var result2 = toCheck.expressions.get(i).accept(this);
-                        if (!Objects.equals(result1.getType(), result2.getType())) {
-                            same = false;
-                        }
-                    }
-                    if (same) {
-                        if (method.accesModifier.accessType == EnumAccessModifierNode.PUBLIC) {
-                            if (method.getType() == null) {
-                                return new BaseType(TypeEnum.VOID);
-                            }
-                            return method.getType();
-                        } else {
-                            errors.add(new NotVisibleException("This Method is not Visible"));
-                        }
-
-                    }
-                }
-            }
-        }
-
-        return null;
-    }
-
 }

src/main/java/semantic/context/Context.java

@@ -21,10 +21,6 @@ public class Context {
     return classes.get(identifier);
   }
 
-  public HashMap<String, ClassContext> getClasses() {
-    return classes;
-  }
-
   public boolean containsClass(String identifier) {
     return classes.containsKey(identifier);
   }

src/main/resources/META-INF/MANIFEST.MF

@@ -1,3 +0,0 @@
-Manifest-Version: 1.0
-Main-Class: main.Main
-

src/main/resources/input/CompilerInput.java

@@ -8,6 +8,7 @@ public class Node {
     public void main() {
         Compiler compiler = new Compiler();
         int i = compiler.add(5, 8);
+        return i;
     }
 }
 

src/test/Makefile

@@ -10,7 +10,13 @@ compile-javac:
 compile-raupenpiler:
 	cd ../.. ; mvn -DskipTests install
 	cd ../.. ; mvn exec:java -DgenJar=true -DgenClass=true -Dexec.mainClass="main.Main"  -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output'"
-	# cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
+	cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
+
+test: compile-javac compile-raupenpiler test-javac test-raupenpiler
+
+test-javac:
+	# gleich wie bei raupenpiler, kann ich ohne funktionierenden Compiler nicht testen
+
 
 test-raupenpiler:
 	# move the compiled class to the test/main folder
@@ -23,19 +29,17 @@ test-raupenpiler:
 
 
 clean:
-	# clean main output folders
+	# clean output folders
 	rm -f ../main/resources/output/*.class
 	rm -f ../main/resources/output/*.jar
-	# clean resources output folders
 	rm -f ./resources/output/javac/*.class
 	rm -f ./resources/output/raupenpiler/*.class
-	rm -f ./resources/output/raupenpiler/*.jar
 	# clean logs
-	rm -f ../main/resources/logs/*
+	rm -f ../main/resources/logs/*.log
 	# clean test/java/main folders from .class files for End-to-End tests
 	rm -f ./java/main/*.class
-	# clean javac output from every folder
+	# clean javac output from combinedFeatureTests
-	rm -f ./resources/input/*/*.class
+	rm -f ./resources/input/combinedFeatureTests/*.class
-	# clean test results from maven surefire plugin
+	rm -f ./resources/input/singleFeatureTests/*.class
-	rm -f ../../target/surefire-reports/*.txt
+	rm -f ./resources/input/typedAstFeatureTests/*.class
 

src/test/java/main/InputFilesTest.java

@@ -1,6 +1,5 @@
 package main;
 
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import javax.tools.JavaCompiler;
@@ -27,17 +26,13 @@ public class InputFilesTest {
         // Assert that the compiler is available
         assertNotNull(javac, "Java Compiler is not available");
 
-        File combinedFeatureTests = new File("src/test/resources/input/combinedFeatureTests");
+        File folder1 = new File("src/test/resources/input/combinedFeatureTests");
-        File endabgabeTests = new File("src/test/resources/input/endabgabeTests");
+        File folder2 = new File("src/test/resources/input/singleFeatureTests");
-        File singleFeatureSemanticTests = new File("src/test/resources/input/singleFeatureSemanticTests");
+        File folder3 = new File("src/test/resources/input/typedAstFeatureTests");
-        File singleFeatureTests = new File("src/test/resources/input/singleFeatureTests");
-        File typedAstFeatureTests = new File("src/test/resources/input/typedAstFeatureTests");
 
-        List<File> files = getJavaFilesFromDirectory(combinedFeatureTests);
+        List<File> files = getJavaFilesFromDirectory(folder1);
-        // files.addAll(getJavaFilesFromDirectory(endabgabeTests));
+        files.addAll(getJavaFilesFromDirectory(folder2));
-        // files.addAll(getJavaFilesFromDirectory(singleFeatureSemanticTests));
+        files.addAll(getJavaFilesFromDirectory(folder3));
-        files.addAll(getJavaFilesFromDirectory(singleFeatureTests));
-        // files.addAll(getJavaFilesFromDirectory(typedAstFeatureTests));
 
         if (!files.isEmpty()) {
             for (File file : files) {
@@ -52,133 +47,6 @@ public class InputFilesTest {
         }
     }
 
-    @Test
-    public void areCombinedFeatureTestsValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File combinedFeatureTests = new File("src/test/resources/input/combinedFeatureTests");
-
-        List<File> files = getJavaFilesFromDirectory(combinedFeatureTests);
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-    @Test
-    @Disabled
-    public void areEndabgabeTestsActuallyValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File endabgabeTests = new File("src/test/resources/input/endabgabeTests");
-
-        List<File> files = getJavaFilesFromDirectory(endabgabeTests);
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-    @Test
-    @Disabled
-    public void areSingleFeatureSemanticTestsActuallyValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File singleFeatureSemanticTests = new File("src/test/resources/input/singleFeatureSemanticTests");
-
-        List<File> files = getJavaFilesFromDirectory(singleFeatureSemanticTests);
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-
-    @Test
-    public void areSingleFeatureTestsActuallyValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File singleFeatureTests = new File("src/test/resources/input/singleFeatureTests");
-
-        List<File> files = getJavaFilesFromDirectory(singleFeatureTests);
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-
-    @Test
-    @Disabled
-    public void areTypedAstFeatureTestsActuallyValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File typedAstFeatureTests = new File("src/test/resources/input/typedAstFeatureTests");
-
-        List<File> files = getJavaFilesFromDirectory(typedAstFeatureTests);
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-
-
 
     /**
      * This test method checks if invalid Java files fail to compile as expected.

src/test/java/main/MainTest.java

@@ -1,25 +1,23 @@
 package main;
 
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
-import org.junit.runners.Suite;
+import org.antlr.v4.runtime.CharStream;
-import parser.ParserTest;
+import org.antlr.v4.runtime.CharStreams;
-import parser.ScannerTest;
+
-import semantic.EndToTypedAstTest;
+import java.io.IOException;
-import semantic.SemanticTest;
+import java.nio.file.Paths;
+
 
 /**
- * This class is a test suite that runs all the test classes in the project.
+ * run every test: mvn test
- * <p> run: <code> mvn test </code>
+ * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
- * <p> check results in console or <code> target/surefire-reports </code>
  */
-@RunWith(Suite.class)
+@Deprecated
-@Suite.SuiteClasses({
-        InputFilesTest.class,
-        ScannerTest.class,
-        ParserTest.class,
-        SemanticTest.class,
-        EndToTypedAstTest.class
-})
 public class MainTest {
-    // This class remains empty, it is used only as a holder for the above annotations
+    @Test
+    void test() {
+        System.out.println("MainTest");
+    }
 }
+
+

src/test/java/main/ReflectionsTest.java

@@ -0,0 +1,145 @@
+package main;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+import org.antlr.v4.runtime.CharStream;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@Deprecated
+public class ReflectionsTest {
+
+    @Test
+    public void testSimpleJavaLexerClass() throws ClassNotFoundException, NoSuchMethodException {
+        Class<?> clazz = Class.forName("parser.generated.SimpleJavaLexer");
+
+        // Class Name
+        assertEquals("parser.generated.SimpleJavaLexer", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] actualConstructors = clazz.getDeclaredConstructors();
+        assertTrue(actualConstructors.length > 0, "No constructors found");
+
+        Constructor<?> expectedConstructor = clazz.getConstructor(CharStream.class);
+
+        boolean constructorFound = false;
+        for (Constructor<?> constructor : actualConstructors) {
+            if (constructor.equals(expectedConstructor)) {
+                constructorFound = true;
+                break;
+            }
+        }
+        assertTrue(constructorFound, "Expected constructor not found in actual constructors");
+
+
+
+        // Methods
+        Method[] actualMethodNames = clazz.getDeclaredMethods();
+        assertTrue(actualMethodNames.length > 0);
+        Arrays.stream(actualMethodNames).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        List<String> expectedMethodNames = Arrays.asList(
+                "getTokenNames",
+                "getVocabulary",
+                "getGrammarFileName",
+                "getRuleNames",
+                "getSerializedATN",
+                "getChannelNames",
+                "getModeNames",
+                "getATN",
+                "makeRuleNames",
+                "makeLiteralNames",
+                "makeSymbolicNames"
+        );
+
+        for (Method method : actualMethodNames) {
+            assertTrue(expectedMethodNames.contains(method.getName()));
+        }
+
+        for (String expectedMethodName : expectedMethodNames) {
+            boolean methodFound = false;
+            for (Method method : actualMethodNames) {
+                if (method.getName().equals(expectedMethodName)) {
+                    methodFound = true;
+                    break;
+                }
+            }
+            assertTrue(methodFound, "Expected method " + expectedMethodName + " not found in actual methods");
+        }
+
+
+        // Fields
+        Field[] actualFieldNames = clazz.getDeclaredFields();
+        assertTrue(actualFieldNames.length > 0);
+        Arrays.stream(actualFieldNames).forEach(field -> System.out.println("Field: " + field.getName()));
+
+        List<String> expectedFieldNames = Arrays.asList(
+                "_decisionToDFA",
+                "_sharedContextCache",
+                "channelNames",
+                "modeNames",
+                "ruleNames",
+                "_LITERAL_NAMES",
+                "_SYMBOLIC_NAMES",
+                "VOCABULARY",
+                "tokenNames",
+                "_serializedATN",
+                "_ATN"
+        );
+
+        for (Field field : actualFieldNames) {
+            assertTrue(expectedFieldNames.contains(field.getName()));
+        }
+    }
+
+    @Test
+    public void testSimpleJavaParserClass() throws ClassNotFoundException {
+        Class<?> clazz = Class.forName("parser.generated.SimpleJavaParser");
+
+        // Class Name
+        assertEquals("parser.generated.SimpleJavaParser", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+        assertTrue(constructors.length > 0);
+
+        // Methods
+        Method[] methods = clazz.getDeclaredMethods();
+        assertTrue(methods.length > 0);
+        Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        // Fields
+        Field[] fields = clazz.getDeclaredFields();
+        assertTrue(fields.length > 0);
+        Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
+    }
+
+    @Test
+    public void testASTBuilderClass() throws ClassNotFoundException {
+        Class<?> clazz = Class.forName("parser.astBuilder.ASTBuilder");
+
+        // Class Name
+        assertEquals("parser.astBuilder.ASTBuilder", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+        assertTrue(constructors.length > 0);
+
+        // Methods
+        Method[] methods = clazz.getDeclaredMethods();
+        assertTrue(methods.length > 0);
+        Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        // Fields
+        Field[] fields = clazz.getDeclaredFields();
+        assertTrue(fields.length > 0);
+        Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
+    }
+
+    // Similarly, you can add tests for SemanticAnalyzer and ByteCodeGenerator
+}

src/test/java/parser/AstBuilderTest.java

@@ -1,31 +1,25 @@
 package parser;
 
+
 import ast.ASTNode;
 import ast.ClassNode;
 import ast.ProgramNode;
 import ast.expressions.IExpressionNode;
-import ast.expressions.binaryexpressions.CalculationNode;
-import ast.expressions.binaryexpressions.DotNode;
-import ast.expressions.binaryexpressions.DotSubstractionNode;
-import ast.expressions.binaryexpressions.NonCalculationNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
-import ast.members.*;
+import ast.members.ConstructorNode;
+import ast.members.FieldNode;
+import ast.members.MethodNode;
 import ast.parameters.ParameterNode;
 import ast.statementexpressions.AssignNode;
 import ast.statementexpressions.AssignableNode;
-import ast.statementexpressions.NewDeclarationNode;
-import ast.statementexpressions.crementexpressions.CrementType;
-import ast.statementexpressions.crementexpressions.DecrementNode;
-import ast.statementexpressions.crementexpressions.IncrementNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
-import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
+import ast.statements.BlockNode;
-import ast.statements.*;
+import ast.statements.ReturnNode;
 import ast.type.AccessModifierNode;
 import ast.type.EnumValueNode;
 import ast.type.ValueNode;
 import ast.type.type.BaseType;
-import ast.type.type.ReferenceType;
 import ast.type.type.TypeEnum;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -322,7 +316,7 @@ class AstBuilderTest {
         ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon);
 
         ClassNode class1 = new ClassNode("public", "Null");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new ReferenceType("Null"), "a"));
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
@@ -333,360 +327,68 @@ class AstBuilderTest {
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
-    @Test
-    @DisplayName("If Test")
-    public void ifTest() {
-        BlockNode block = new BlockNode();
-        block.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "intValue", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))));
-
-        BlockNode ifBlock = new BlockNode();
-        ifBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
-        block.addStatement(new IfElseNode(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))), ifBlock), null));
-
-        block.addStatement(new ReturnNode(null));
-
-        ConstructorNode constructor = new ConstructorNode("public", "If", block);
-
-        ClassNode class1 = new ClassNode("public", "If");
-        class1.addMember(constructor);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "If.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-    }
-
-    @Test
-    @DisplayName("If Else Test")
-    public void ifElseTest() {
-        BlockNode block = new BlockNode();
-        block.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "intValue", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))));
-
-        BlockNode ifBlock = new BlockNode();
-        ifBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
-        BlockNode elseBlock = new BlockNode();
-        elseBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
-        block.addStatement(new IfElseNode(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))), ifBlock), new ElseNode(elseBlock)));
-
-        block.addStatement(new ReturnNode(null));
-
-        ConstructorNode constructor = new ConstructorNode("public", "IfElse", block);
-
-        ClassNode class1 = new ClassNode("public", "IfElse");
-        class1.addMember(constructor);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "IfElse.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-    }
-
-    @Test
-    @DisplayName("If Else If ElseTest")
-    public void ifElseIfElseTest() {
-        BlockNode block = new BlockNode();
-        block.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "intValue", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))));
-
-        BlockNode ifBlock = new BlockNode();
-        ifBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
-        BlockNode elseBlock = new BlockNode();
-        elseBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
-
-        IfElseNode ifElseStatement = new IfElseNode(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))), ifBlock), new ElseNode(elseBlock));
-
-        BlockNode ifElseBlock = new BlockNode();
-        ifElseBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
-        ifElseStatement.addElseIfStatement(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "4"))), ifElseBlock));
-
-        block.addStatement(ifElseStatement);
-
-        block.addStatement(new ReturnNode(null));
-
-        ConstructorNode constructor = new ConstructorNode("public", "IfElseIfElse", block);
-
-        ClassNode class1 = new ClassNode("public", "IfElseIfElse");
-        class1.addMember(constructor);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "IfElseIfElse.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-    }
-
     @Test
     @DisplayName("Self Reference Test")
-    public void selfReferneceTest(){
+    public void selfReferenceTest() {
 
-        ClassNode testClass = Helper.generateEmptyClass("SelfReference");
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-
-        MemberNode testClassObject = new FieldNode(new AccessModifierNode("public"), new ReferenceType("SelfReference"),"selfReference");
-
-        BlockNode testMethod1Block = new BlockNode();
-        testMethod1Block.addStatement(new ReturnNode(new UnaryNode(new MethodCallNode(new TargetNode(true), "testMethod2"))));
-        MethodNode testMethod1 = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod1", testMethod1Block);
-
-        BlockNode testMethod2Block = new BlockNode();
-        testMethod2Block.addStatement(new ReturnNode(new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE,"1"))));
-        MethodNode testMethod2 = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod2", testMethod2Block);
-
-        BlockNode testMethod3Block = new BlockNode();
-        testMethod3Block.addStatement(new LocalVariableDeclarationNode(new ReferenceType("SelfReference"),"selfReference1", "=", new UnaryNode(new NewDeclarationNode("SelfReference")))); // Assing einfach "=" ?
-        MemberAccessNode methodAccess = new MemberAccessNode(false);
-        methodAccess.addIdentifier("selfReference1");
-        methodAccess.addIdentifier("selfReference");
-        TargetNode methodTarget = new TargetNode(methodAccess);
-        testMethod3Block.addStatement(new ReturnNode(new UnaryNode(new MethodCallNode(methodTarget,"testMethod1"))));
-        MethodNode testMethod3 = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod3", testMethod3Block);
-
-        testClass.addMember(testClassObject);
-        testClass.addMember(testMethod1);
-        testClass.addMember(testMethod2);
-        testClass.addMember(testMethod3);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(testClass);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "SelfReference.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Variable Compare Test")
-    public void variableCompareTest(){
+    public void variableCompareTest() {
-        ClassNode class1 = Helper.generateEmptyClass("VariableCompare");
-        UnaryNode trueValue = new UnaryNode(new ValueNode(EnumValueNode.BOOLEAN_VALUE,"true"));
-        UnaryNode falseValue = new UnaryNode(new ValueNode(EnumValueNode.BOOLEAN_VALUE,"false"));
 
-        BlockNode trueBlock = new BlockNode();
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-        trueBlock.addStatement(new ReturnNode(trueValue));
-        MethodNode trueMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueMethod", trueBlock);
-
-        BlockNode falseBlock = new BlockNode();
-        falseBlock.addStatement(new ReturnNode(falseValue));
-        MethodNode falseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "falseMethod", falseBlock);
-
-        BlockNode trueAndTrueBlock = new BlockNode();
-        trueAndTrueBlock.addStatement(new ReturnNode(new NonCalculationNode(trueValue, "&&", trueValue)));
-        MethodNode trueAndTrueMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueAndTrueMethod", trueAndTrueBlock);
-
-        BlockNode trueAndFalseBlock = new BlockNode();
-        trueAndFalseBlock.addStatement(new ReturnNode(new NonCalculationNode(trueValue, "&&", falseValue)));
-        MethodNode trueAndFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueAndFalseMethod", trueAndFalseBlock);
-
-        BlockNode falseAndFalseBlock = new BlockNode();
-        falseAndFalseBlock.addStatement(new ReturnNode(new NonCalculationNode(falseValue, "&&", falseValue)));
-        MethodNode falseAndFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "falseAndFalseMethod", falseAndFalseBlock);
-
-        BlockNode trueOrTrueBlock = new BlockNode();
-        trueOrTrueBlock.addStatement(new ReturnNode(new NonCalculationNode(trueValue, "||", trueValue)));
-        MethodNode trueOrFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueOrTrueMethod", trueOrTrueBlock);
-
-        BlockNode falseOrFalseBlock = new BlockNode();
-        falseOrFalseBlock.addStatement(new ReturnNode(new NonCalculationNode(falseValue, "||", falseValue)));
-        MethodNode falseOrFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "falseOrFalseMethod", falseOrFalseBlock);
-
-        class1.addMember(trueMethod);
-        class1.addMember(falseMethod);
-        class1.addMember(trueAndTrueMethod);
-        class1.addMember(trueAndFalseMethod);
-        class1.addMember(falseAndFalseMethod);
-        class1.addMember(trueOrFalseMethod);
-        class1.addMember(falseOrFalseMethod);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "VariableCompare.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Variable Calculation Test")
-    public void variableCalculationTest(){
+    public void variableCalculationTest() {
-        ClassNode class1 = Helper.generateEmptyClass("VariableCalculation");
 
-        BlockNode aPlusBBlock = new BlockNode();
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-        aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "+", new DotNode(new DotSubstractionNode("b")))));
-        MethodNode aPlusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aPlusB", aPlusBBlock);
-        aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode aMinusBBlock = new BlockNode();
-        aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "-", new DotNode(new DotSubstractionNode("b")))));
-        MethodNode aMinusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aMinusB", aMinusBBlock);
-        aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode aTimeBBlock = new BlockNode();
-        aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")))));
-        MethodNode aTimeBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aTimeB", aTimeBBlock);
-        aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode aDivBBlock = new BlockNode();
-        aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "/", new DotSubstractionNode("b")))));
-        MethodNode aDivBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aDivB", aDivBBlock);
-        aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode complexCalcBlock = new BlockNode();
-        complexCalcBlock.addStatement(new ReturnNode(new CalculationNode(null, null, new DotNode(new DotNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")), "/", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3"))))));
-        MethodNode complexCalcMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "complexCalc", complexCalcBlock);
-        complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode aSmallerBBlock = new BlockNode();
-        aSmallerBBlock.addStatement(new ReturnNode(new NonCalculationNode(new UnaryNode("a"), "<", new UnaryNode("b"))));
-        MethodNode aSmallerBMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "aSmallerB", aSmallerBBlock);
-        aSmallerBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aSmallerBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode aGreaterBBlock = new BlockNode();
-        aGreaterBBlock.addStatement(new ReturnNode(new NonCalculationNode(new UnaryNode("a"), ">", new UnaryNode("b"))));
-        MethodNode aGreaterBMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "aGreaterB", aGreaterBBlock);
-        aGreaterBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aGreaterBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        BlockNode aEqualsBBlock = new BlockNode();
-        aEqualsBBlock.addStatement(new ReturnNode(new NonCalculationNode(new UnaryNode("a"), "==", new UnaryNode("b"))));
-        MethodNode aEqualsBMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "aEqualsB", aEqualsBBlock);
-        aEqualsBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        aEqualsBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        class1.addMember(aPlusBMethod);
-        class1.addMember(aMinusBMethod);
-        class1.addMember(aTimeBMethod);
-        class1.addMember(aDivBMethod);
-        class1.addMember(complexCalcMethod);
-        class1.addMember(aSmallerBMethod);
-        class1.addMember(aGreaterBMethod);
-        class1.addMember(aEqualsBMethod);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "VariableCalculation.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Main Method Test")
-    public void mainMethodTest(){
+    public void mainMethodTest() {
-        ClassNode class1 = Helper.generateEmptyClass("MainMethod");
 
-        BlockNode block = new BlockNode();
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-        block.addStatement(new ReturnNode(null));
-
-        class1.addMember(new MainMethodNode(block));
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "MainMethod.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("While Test")
-    public void whileTest(){
+    public void whileTest() {
-        NonCalculationNode condition = new NonCalculationNode(new UnaryNode("i"), ">", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0")));
 
-        BlockNode whileBlock = new BlockNode();
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-        whileBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("i")));
-
-        WhileNode whileStatement = new WhileNode(condition, whileBlock);
-
-        BlockNode blockCon = new BlockNode();
-        blockCon.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10"))));
-        blockCon.addStatement(whileStatement);
-        blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
-
-        ClassNode class1 = new ClassNode("public", "While");
-        class1.addMember(constructor);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "While.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Do While Test")
-    public void doWhileTest(){
+    public void doWhileTest() {
-        NonCalculationNode condition = new NonCalculationNode(new UnaryNode("i"), "<", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10")));
 
-        BlockNode whileBlock = new BlockNode();
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-        whileBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("i")));
-
-        WhileNode whileStatement = new WhileNode(condition, whileBlock);
-
-        BlockNode blockDoWhile = new BlockNode();
-        blockDoWhile.addStatement(whileBlock);
-        blockDoWhile.addStatement(whileStatement);
-
-        BlockNode blockCon = new BlockNode();
-        blockCon.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0"))));
-        blockCon.addStatement(blockDoWhile);
-        blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
-
-        ClassNode class1 = new ClassNode("public", "DoWhile");
-        class1.addMember(constructor);
-
-        ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "DoWhile.java");
-
-        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("For Test")
-    public void forTest(){
+    public void forTest() {
-        LocalVariableDeclarationNode forDeclaration = new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0")));
 
-        AssignableNode assignable = new AssignableNode("i");
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
-        IncrementNode increment = new IncrementNode(CrementType.SUFFIX, assignable);
+    }
 
-        LocalVariableDeclarationNode declaration = new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "a", null, null);
+    //Noch nicht speziell Increment nur zum Development Testen per Debug
-
+    @Test
-        BlockNode whileBlock = new BlockNode();
+    @DisplayName("Increment Test")
-        whileBlock.addStatement(declaration);
+    public void incrementTest() {
-        whileBlock.addStatement(increment);
+        ClassNode classNode = Helper.generateEmptyClass("Increment");
-
+        classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-        WhileNode whileStatement = new WhileNode(new NonCalculationNode(new UnaryNode("i"), "<", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10"))), whileBlock);
-
-        BlockNode forStatement = new BlockNode();
-        forStatement.addStatement(forDeclaration);
-        forStatement.addStatement(whileStatement);
-
-        BlockNode blockCon = new BlockNode();
-        blockCon.addStatement(forStatement);
-        blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
-
-        ClassNode class1 = new ClassNode("public", "For");
-        class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
-        expected.addClass(class1);
+        expected.addClass(classNode);
-
-        ASTNode actual = Helper.generateAST(directoryPath + "For.java");
 
+        ASTNode actual = Helper.generateAST(directoryPath + "Increment.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
+
+
 }

src/test/java/semantic/BeginnToTAST.java

@@ -0,0 +1,45 @@
+package semantic;
+
+import ast.ProgramNode;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.junit.jupiter.api.Test;
+import parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BeginnToTAST {
+
+    @Test
+    public void FieldTests() {
+        SemanticAnalyzer.clearAnalyzer();
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/johnsTests/FieldTests.java"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program(); // parse the input
+
+        /* ------------------------- AST builder -> AST ------------------------- */
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+        var result = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+    }
+
+}

src/test/java/semantic/EndToTypedAstTest.java

@@ -26,8 +26,6 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.junit.jupiter.api.Test;
-import semantic.exceptions.*;
-import semantic.exceptions.NotDeclaredException;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -154,200 +152,6 @@ public class EndToTypedAstTest {
         }
     }
 
-    /*
-    @Test
-    public void notDeclared() {
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/NotDeclared.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotDeclaredException));
-    }*/
-
-    @Test
-    public void typeMismatchTest() {
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/TypeMismatchIntBool.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
-    }
-
-    @Test
-    public void parameterAlreadyDecleared() {
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/ParameterAlreadyDecleared.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof AlreadyDeclaredException));
-    }
-
-    @Test
-    public void fieldAlreadyDecleared(){
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/FieldAlreadyDecleared.java");
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof AlreadyDeclaredException));
-
-    }
-
-    @Test
-    public void typeMismatchRefType(){
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/TypeMismatchRefType.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
-    }
-
-    @Test
-    public void correctRetType(){
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/CorrectRetType.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-    }
-
-    @Test
-    public void retTypeMismatch(){
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/RetTypeMismatch.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
-    }
-
-    @Test
-    public void multipleRetType(){
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/MultipleRetTypes.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof MultipleReturnTypes));
-    }
-
-    @Test
-    public void BothTypesMustBeSameGreaterSmallerEqual(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/BothTypesMustBeSame.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
-
-    }
-
-    @Test
-    public void NoSuchType(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/ClassNotDeclared.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotDeclaredException));
-
-    }
-
-    @Test
-    public void FieldIsNotVisible(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/FieldIsNotVisible.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotVisibleException));
-
-    }
-
-    @Test
-    public void ChainedMethods(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/ChainedMethods.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void VariableCompare(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/VariableCompare.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void IfExpressionInt(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/IfExpressionInt.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void SelectWrongMethodCauseParameter(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/SelectWrongMethodCauseParameter.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void SelectRightMethodCauseParameter(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/SelectRightMethodCauseParameter.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void VariableCalculation(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/VariableCalculation.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void Expression(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/Expression.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
 
     // ------------------ Helpers ------------------
 

src/test/java/semantic/SemanticHelper.java

@@ -1,35 +0,0 @@
-package semantic;
-
-import ast.ASTNode;
-import ast.ProgramNode;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.tree.ParseTree;
-import parser.astBuilder.ASTBuilder;
-import parser.generated.SimpleJavaLexer;
-import parser.generated.SimpleJavaParser;
-
-import java.io.IOException;
-
-public class SemanticHelper {
-    public static ASTNode generateTypedASTFrom(String filePath) {
-
-        SemanticAnalyzer.clearAnalyzer();
-
-        CharStream testFile = null;
-        try {
-            testFile = CharStreams.fromFileName(filePath);
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(testFile);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-        tokenStream.fill();
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-        ASTBuilder astBuilder = new ASTBuilder();
-
-        return (ProgramNode) astBuilder.visit(parseTree);
-    }
-}

src/test/java/semantic/SemanticTest.java

@@ -30,6 +30,8 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class SemanticTest {
 
+    private final static String directoryPath = "src/test/resources/input/singleFeatureTests/";
+
     @BeforeEach
     public void setUp() {
         SemanticAnalyzer.clearAnalyzer();

src/test/resources/input/endabgabeTests/Car.java

@@ -1,25 +0,0 @@
-public class Main {
-    public static void main(String[] args) {
-        Car myCar = new Car(2020);
-        int tires = 0;
-        int year = myCar.getYear();
-
-        if (year == 2020) {
-            tires = 4;
-        } else {
-            tires = 2;
-        }
-    }
-}
-
-class Car {
-    private int year;
-
-    public Car(int year) {
-        this.year = year;
-    }
-
-    public int getYear() {
-        return this.year;
-    }
-}

src/test/resources/input/endabgabeTests/ControlStructures.java

@@ -1,36 +0,0 @@
-public class ControlStructures {
-
-    public int sum(int a, int b) {
-        return a + b;
-    }
-
-    public cahr checkNumber(int num) {
-        if (num > 0) {
-            return "p";
-        } else if (num < 0) {
-            return "n";
-        } else {
-            return "z";
-        }
-    }
-
-    public void printNumbersUpTo(int limit) {
-        int even = 0;
-        int uneven = 0;
-        int i = 0;
-        while (i < limit) {
-            if (i % 2 == 0) {
-                even++;
-            } else {
-                uneven = uneven + 1;
-            }
-            i++;
-        }
-    }
-
-    public static void main(String[] args) {
-        ControlStructures cs = new ControlStructures();
-        cs.printNumbersUpTo(5);
-        int result = cs.sum(5, 5);
-    }
-}

src/test/resources/input/endabgabeTests/Person.java

@@ -1,11 +0,0 @@
-public class Person {
-    private int age;
-
-    public Person(int age) {
-        this.age = age;
-    }
-
-    public int getAge() {
-        return this.age;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/ChainedMethods.java

@@ -1,29 +0,0 @@
-public class Test {
-
-    public House h;
-
-    public int test(House h){
-        return h.getW().getSize();
-    }
-
-
-}
-
-public class House {
-
-    private Window w;
-
-    public Window getW(){
-        return w;
-    }
-
-}
-
-public class Window{
-
-    private int size;
-
-    public int getSize() {
-        return size;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/ClassNotDeclared.java

@@ -1,7 +0,0 @@
-// @expected: NotDeclaredException
-public class Test {
-
-    public House1 h;
-
-
-}

src/test/resources/input/singleFeatureSemanticTests/CorrectRetType.java

@@ -1,5 +0,0 @@
-public class CorrectRetType {
-    public static int testMethod(int x){
-        return x;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/Expression.java

@@ -1,10 +0,0 @@
-class VariableCompare{
-
-    void trueMethod(boolean a, int c) {
-        if(a && c == 10){
-
-        }
-    }
-
-
-}

src/test/resources/input/singleFeatureSemanticTests/FieldAlreadyDecleared.java

@@ -1,4 +0,0 @@
-public class FieldAlreadyDecleared {
-    public int a;
-    public int a;
-}

src/test/resources/input/singleFeatureSemanticTests/MultipleRetTypes.java

@@ -1,6 +0,0 @@
-public class MultipleRetTypes {
-    public static int testMethod(int x, char c){
-        return x;
-        return c;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/NotDeclared.java

@@ -1,5 +0,0 @@
-public class NotDeclared {
-    public void Method() {
-        i = 10;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/ParameterAlreadyDecleared.java

@@ -1,3 +0,0 @@
-public class ParameterAlreadyDecleared {
-    public void Method(int a, int a) {}
-}

src/test/resources/input/singleFeatureSemanticTests/RetTypeMismatch.java

@@ -1,5 +0,0 @@
-public class Example {
-    public static int testMethod(char x){
-        return x;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/SelectRightMethodCauseParameter.java

@@ -1,22 +0,0 @@
-// @expected: TypeMismatchException
-public class Test{
-
-    public int i;
-    public boolean b;
-
-    public int test(){
-
-        return test(b);
-
-    }
-
-    public void test(int a){
-
-    }
-
-    public int test(boolean bool){
-        int ret = 1;
-        return ret;
-    }
-
-}

src/test/resources/input/singleFeatureSemanticTests/TypeMismatchIntBool.java

@@ -1,6 +0,0 @@
-public class TypeMismatchIntBool {
-    public void Method() {
-        int intVariable;
-        intVariable = true;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/TypeMismatchRefType.java

@@ -1,13 +0,0 @@
-public class TypeMismatchRefType {
-    public static int Methode(Class1 class1, Class2 class2){
-        class1 = class2;
-    }
-}
-
-public class Class1{
-    public int a;
-}
-
-public class Class2{
-    public boolean a;
-}

src/test/resources/input/singleFeatureSemanticTests/VariableCalculation.java

@@ -1,34 +0,0 @@
-class VariableCalculation{
-
-    int aPlusB(int a, int b){
-        return a + b;
-    }
-
-    int aMinusB(int a, int b){
-        return a - b;
-    }
-
-    int aTimeB(int a, int b){
-        return a * b;
-    }
-
-    int aDivB(int a, int b){
-        return a / b;
-    }
-
-    int complexCalc (int a, int b){
-        return a * b / 1 * 3;
-    }
-
-    boolean aSmallerB (int a, int b){
-        return a < b;
-    }
-
-    boolean aGreaterB (int a, int b){
-        return a > b;
-    }
-
-    boolean aEqualsB (int a, int b){
-        return a == b;
-    }
-}

src/test/resources/input/singleFeatureSemanticTests/VariableCompare.java

@@ -1,30 +0,0 @@
-class VariableCompare{
-
-    boolean trueMethod() {
-        return true;
-    }
-
-    boolean falseMethod(){
-        return false;
-    }
-
-    boolean trueAndTrueMethod(){
-        return true && true;
-    }
-
-    boolean trueAndFalseMethod(){
-        return true && false;
-    }
-
-    boolean falseAndFalseMethod(){
-        return false && false;
-    }
-
-    boolean trueOrTrueMethod(){
-        return true || true;
-    }
-
-    boolean falseOrFalseMethod(){
-        return false || false;
-    }
-}

src/test/resources/input/singleFeatureTests/If.java

@@ -1,8 +0,0 @@
-public class If {
-    public If() {
-        int intValue = 5;
-        if(intValue == 5) {
-            intValue--;
-        }
-    }
-}

src/test/resources/input/singleFeatureTests/IfElse.java

@@ -1,10 +0,0 @@
-public class IfElse {
-    public IfElse() {
-        int intValue = 5;
-        if(intValue == 5) {
-            intValue--;
-        } else {
-            intValue++;
-        }
-    }
-}

src/test/resources/input/singleFeatureTests/IfElseIfElse.java

@@ -1,12 +0,0 @@
-public class IfElseIfElse {
-    public IfElseIfElse() {
-        int intValue = 5;
-        if(intValue == 5) {
-            intValue--;
-        } else if(intValue ==4) {
-            intValue++;
-        } else {
-            intValue++;
-        }
-    }
-}

src/test/resources/input/singleFeatureTests/Null.java

@@ -1,8 +1,8 @@
 class Null{
 
-    Null a;
+    int a;
 
     public Null(){
-      this.a = null;
+      //  this.a = null;
     }
 }

src/test/resources/input/singleFeatureTests/SelfReference.java

@@ -10,7 +10,7 @@ class SelfReference{
         return 1;
     }
 
-    int testMethod3(){
+    int testMehtod3(){
         SelfReference selfReference1 = new SelfReference();
         return selfReference1.selfReference.testMethod1();
     }

src/test/resources/input/singleFeatureTests/VariableCalculationTest.java

@@ -1,4 +1,4 @@
-class VariableCalculation{
+class VariableCalculationTest{
 
     int aPlusB(int a, int b){
         return a + b;
@@ -16,8 +16,8 @@ class VariableCalculation{
         return a / b;
     }
 
-    int complexCalc (int a, int b){
+    int colmplexCalc (int a, int b){
-        return a * b / 1 * 3;
+        return a * (b / 1);
     }
 
     boolean aSmallerB (int a, int b){

src/test/resources/input/singleFeatureTests/VariableCompare.java

@@ -1,30 +0,0 @@
-class VariableCompare{
-
-    boolean trueMethod() {
-        return true;
-    }
-
-    boolean falseMethod(){
-        return false;
-    }
-
-    boolean trueAndTrueMethod(){
-        return true && true;
-    }
-
-    boolean trueAndFalseMethod(){
-        return true && false;
-    }
-
-    boolean falseAndFalseMethod(){
-        return false && false;
-    }
-
-    boolean trueOrTrueMethod(){
-        return true || true;
-    }
-
-    boolean falseOrFalseMethod(){
-        return false || false;
-    }
-}

src/test/resources/input/singleFeatureTests/VariableCompareTest.java

@@ -0,0 +1,30 @@
+class VariableCompareTest{
+
+    boolean trueMethod(){
+        return true;
+    }
+
+    boolean falseMethod(){
+        return false;
+    }
+
+    boolean trueAndTrue(){
+        return trueMethod() && trueMethod();
+    }
+
+    boolean trueAndFalse(){
+        return trueMethod() && falseMethod();
+    }
+
+    boolean falseAndFalse(){
+        return falseMethod() && falseMethod();
+    }
+
+    boolean trueOrFalse(){
+        return trueMethod() || falseMethod();
+    }
+
+    boolean falseOrFalse(){
+        return falseMethod() || falseMethod();
+    }
+}

src/test/resources/input/typedAstExceptionsTests/BothTypesMustBeSame1.java

@@ -5,18 +5,5 @@ public class AllFeaturesClassExample {
         while (a > bool) {
             a--;
         }
-
-        if (a == bool) {
-
-        } else {
-
-        }
-
-        if (a < bool) {
-
-        } else {
-
-        }
-
     }
 }

src/test/resources/input/typedAstExceptionsTests/CompareBoolInt.java

@@ -0,0 +1,13 @@
+// @expected: TypeMismatchException
+public class Test{
+
+    public void test(boolean b){
+        if(b == 2){
+
+        } else {
+
+        }
+
+    }
+
+}

src/test/resources/input/typedAstExceptionsTests/IfExpressionInt.java

@@ -1,3 +1,4 @@
+// @expected: TypeMismatchException
 public class Test{
 
     public void test(int x){

src/test/resources/input/typedAstExceptionsTests/MissingOverloadingParameter.java

@@ -0,0 +1,19 @@
+// @expected: WrongOverloading
+public class Test{
+
+    public void test(int x){
+
+        if(this.get()){
+
+        } else {
+
+        }
+
+    }
+    public boolean b;
+
+    public boolean get(int c){
+        return b;
+    }
+
+}

src/test/resources/input/typedAstExceptionsTests/SelectWrongMethodCauseParameter.java

@@ -6,7 +6,7 @@ public class Test{
 
     public int test(){
 
-        return test(i);
+        return this.test(i);
 
     }
 
@@ -19,4 +19,4 @@ public class Test{
         return ret;
     }
 
-}
+}

src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt.java

@@ -3,10 +3,10 @@ public class CallMethodFromObjekt {
     public int firstInt;
     public Car ca;
 
-    public int speed() {
+    public int speed(){
         return ca.getSpeed();
     }
-}
+
 
 public class Car{
 
@@ -16,4 +16,5 @@ public class Car{
         return speed;
     }
 
+}
 }

src/test/resources/input/typedAstFeatureTests/CorrectMemberAccess.java

@@ -1,12 +1,11 @@
-public class CorrectMemberAccess {
+public class CorrectMemberAccess{
 
     public Car c;
 
-    public int test() {
+    public int test(){
         return c.getSpeed();
     }
 
-}
 
 private class Car{
 
@@ -16,4 +15,5 @@ private class Car{
         return speed;
     }
 
+}
 }

src/test/resources/input/typedAstFeatureTests/CorrectTest.java

@@ -1,16 +1,21 @@
-public class Compiler {
+public class CorrectTest {
-    Node node;
+    int a;
-    public int add(int i, int j) {
+    boolean b;
-        node = new Node();
+    char c;
-        node.x = 1;
+
-        return i+j;
+    public void controlStructures(int adf, boolean bool) {
+        if (a > (10 + 8)) {
+        } else {
+        }
+
+
+        while (a > adf) {
+            a--;
+        }
+
+        for (int i = 0; i < 5; i++) {
+        }
+
+
     }
 }
-
-public class Node {
-    public int x;
-    public void main() {
-        Compiler compiler = new Compiler();
-        int i = compiler.add(5, 8);
-    }
-}

src/test/resources/input/typedAstFeatureTests/FullTest.java

@@ -17,8 +17,25 @@ public class FullTest {
         for (int i = 0; i < 5; i++) {
         }
 
-    }
 
+
+
+//    void logicalOperations() {
+//        // Logische UND-Operation
+//        if (b && a > 5) {
+////            System.out.println("a ist größer als 5 und b ist wahr");
+//        }
+//
+//        // Logische ODER-Operation
+//        if (b || a < 5) {
+////            System.out.println("b ist wahr oder a ist kleiner als 5");
+//        }
+//    }
+
+//    public static void main(String[] args) {
+//        AllFeaturesClassExample obj = new AllFeaturesClassExample(12, true, 'a');
+//        obj.controlStructures();
+//    }
 }
 
 public class Test {
@@ -43,5 +60,6 @@ public class Car {
         return speed;
     }
 
+}
 
 }

src/test/resources/input/typedAstFeaturesTests/CorrectTest.java

@@ -0,0 +1,38 @@
+public class AllFeaturesClassExample {
+    int a;
+    boolean b;
+    char c;
+
+    public void controlStructures(int adf, boolean bool) {
+        if (a > (10 + 8)) {
+        } else {
+        }
+
+
+        while (a > adf) {
+            a--;
+        }
+
+        for (int i = 0; i < 5; i++) {
+        }
+
+
+    }
+
+//    void logicalOperations() {
+        // Logische UND-Operation
+//        if (b && a > 5) {
+//            System.out.println("a ist größer als 5 und b ist wahr");
+//        }
+
+        // Logische ODER-Operation
+//        if (b || a < 5) {
+//            System.out.println("b ist wahr oder a ist kleiner als 5");
+//        }
+//    }
+
+//    public static void main(String[] args) {
+//        AllFeaturesClassExample obj = new AllFeaturesClassExample(12, true, 'a');
+//        obj.controlStructures();
+//    }
+}