Revert "Merge remote-tracking branch 'origin/Endabgabe' into code-generator"

This reverts commit 721e1caa79, reversing
changes made to 6d3e1f859e.

.gitignore

@@ -77,10 +77,10 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 /target
-src/main/resources/logs/miniCompilerLog.log
+src/main/resources/logs/RaupenLog.log
 src/main/resources/output/CompilerInput.class
 src/test/resources/output/javac/CompilerInput$Test.class
 src/test/resources/output/javac/CompilerInput.class
-src/test/resources/output/miniCompiler/CompilerInput.class
-src/test/resources/output/miniCompiler/CompilerInput$Test.class
+src/test/resources/output/raupenpiler/CompilerInput.class
+src/test/resources/output/raupenpiler/CompilerInput$Test.class
 .idea/inspectionProfiles/Project_Default.xml

readme.md

@@ -1,6 +1,6 @@
 # "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 Stuttgart (Horb).
+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.
 
@@ -62,39 +62,7 @@ test/
 
 
 ## How to run the compiler
-### Possibilities
-### 1. Start miniCompiler using make:
-Make needs to be installed
-```bash
-cd .\src\test\ ; make clean compile-miniCompiler
-```
 
-### 2. Start miniCompiler using jar:
-If you do not have the .jar, download it [here](https://gitea.hb.dhbw-stuttgart.de/i22005/NichtHaskell2.0/src/branch/Endabgabe/src) or compile it using mvn package or make first
-```
-java.exe -DgenJar=bool -DgenClass=bool -jar path_to_jar\jarName.jar 'path_to_input_file.java' 'path_to_output_directory'
-```
+## Download
 
-Example (jar needs to be in the target directory)
-```bash
- java.exe -DgenJar=true -DgenClass=true -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output'
-```
-
-- set DgenJar true, to generate the jar, false for no jar
-
-```
- DgenJar=true
-```
-
-- set DgenClass true, to generate class files, false for no class files
-
-```
- DgenClass=true
- ```
-
-## How to run tests
-
-```bash
-mvn test
-```
-Or start them manually in your IDE
+```bash

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 {
+public class DecrementNode implements IStatementExpressionNode, Visitable {
     public CrementType crementType;
     public AssignableNode assignableExpression;
 
@@ -20,4 +20,9 @@ public class DecrementNode implements IStatementExpressionNode {
     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,8 +5,9 @@ import ast.statementexpressions.IStatementExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
-public class IncrementNode implements IStatementExpressionNode {
+public class IncrementNode implements IStatementExpressionNode, Visitable {
     public CrementType crementType;
     public AssignableNode assignableExpression;
 
@@ -19,4 +20,9 @@ public class IncrementNode implements IStatementExpressionNode {
     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,11 +22,6 @@ 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/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) {
-        mapper = new Mapper();
+        this.mapper = new Mapper();
         this.jarOutputStream = jarOutputStream;
         this.outputDirectory = outputDirectory;
         this.generateJar = generateJar;

src/main/java/bytecode/Mapper.java

@@ -3,6 +3,7 @@ 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;
@@ -24,7 +25,7 @@ public class Mapper {
         return 0;
     }
 
-    public String generateMethodDescriptor(BaseType type, List<ParameterNode> parameters) {
+    public String generateMethodDescriptor(ITypeNode type, List<ParameterNode> parameters) {
         String descriptor = "(";
         for (ParameterNode parameterNode : parameters) {
             if(parameterNode.type instanceof BaseType) {
@@ -35,7 +36,11 @@ public class Mapper {
             }
         }
         descriptor += ")";
-        descriptor += getTypeChar(type);
+        if(type instanceof BaseType) {
+            descriptor += getTypeChar((BaseType) type);
+        } else if(type instanceof ReferenceType) {
+            descriptor += "L" + ((ReferenceType) type).getIdentifier() +";";
+        }
         return descriptor;
     }
 

src/main/java/bytecode/MethodCodeGen.java

@@ -14,9 +14,7 @@ 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;
@@ -71,9 +69,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
         // Visit all statements
         for (IStatementNode statementNode : constructorNode.block.statements) {
-            if (statementNode != null) {
-                statementNode.accept(this);
-            }
+            statementNode.accept(this);
         }
 
         methodVisitor.visitMaxs(0, 0);
@@ -105,7 +101,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(MethodNode methodNode) {
         methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(methodNode.accesModifier),
                 methodNode.getIdentifier(),
-                mapper.generateMethodDescriptor((BaseType) methodNode.getType(), methodNode.parameters),
+                mapper.generateMethodDescriptor(methodNode.getType(), methodNode.parameters),
                 null,
                 null);
 
@@ -241,7 +237,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_ACMPEQ, labelFalse);
+                    methodVisitor.visitJumpInsn(IF_ICMPEQ, labelFalse);
                 } else {
                     methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
                 }
@@ -266,9 +262,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     @Override
     public void visit(MemberAccessNode memberAccessNode) {
         // Only used to get, not to put
-        if (memberAccessNode.thisExpr) { // Field
-            // methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
-        } else { // Object Attribut
+        int localVarIndex = localVariables.indexOf("memberAccessNode.identifier"); // TODO
+        if (localVarIndex >= 0) { // local var object
+            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
+        } 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() + ";");
         }
     }
 
@@ -331,6 +335,7 @@ 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();
@@ -362,22 +367,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (localVariableDeclarationNode.expression != null) {
             // Process expression
             localVariableDeclarationNode.expression.accept(this);
-            // Store result of expression in variable
-            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 {
+            // add local var to list if not in list
+            if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
                 localVariables.add(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));
-                }
+            }
+            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 {
+            // Local var declaration
             if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
                 localVariables.add(localVariableDeclarationNode.identifier);
             }
@@ -386,40 +386,106 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(AssignNode assignNode) {
-        // Process expression
+        if (assignNode.assignable.memberAccess != null) { // this / object
+            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
-                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
-                assign(assignNode);
-            } else if (incrementNode.crementType.equals(CrementType.SUFFIX)) { // Suffix: i++
-                assign(assignNode);
-                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
+                incrementNode.accept(this);
+                assignLocalVar(assignNode);
+            } else { // i++
+                loadBeforeCrement(assignNode);
+                assignLocalVar(assignNode);
+                incrementNode.accept(this);
             }
         } else if (assignNode.expression instanceof DecrementNode) {
             DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
-                assign(assignNode);
-            } else if (decrementNode.crementType.equals(CrementType.SUFFIX)) {
-                assign(assignNode);
-                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), 1);
+                decrementNode.accept(this);
+                assignLocalVar(assignNode);
+            } else {
+                loadBeforeCrement(assignNode);
+                assignLocalVar(assignNode);
+                decrementNode.accept(this);
             }
-        } else {
-            assignNode.expression.accept(this);
-            assign(assignNode);
         }
     }
 
-    private void assign(AssignNode assignNode) {
-        if (assignNode.assignable.memberAccess.thisExpr) {
-            assignField(assignNode);
+    private void fieldOrObjectVarPrefixCrementAssign(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 {
-            assignLocalVar(assignNode);
+            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() + ";");
+        }
+    }
+
+    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) {
@@ -427,12 +493,105 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         }
     }
 
-    private void assignField(AssignNode assignNode) {
+    private void assignFieldOrObjectVar(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);
         }
     }
 
@@ -445,8 +604,7 @@ 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);
-        localVariables.add(newDeclarationNode.identifier);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID), parameterNodes), false);
     }
 
     @Override
@@ -518,19 +676,13 @@ 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(), ""));
         }
-        // TODO: Klassenname und Returntype
-        //methodVisitor.visitMethodInsn(INVOKEVIRTUAL, classname, methodCallNode.identifier, mapper.generateMethodDescriptor(returntype, parameterNodes), false);
+        methodVisitor.visitMethodInsn(INVOKEVIRTUAL, methodCallNode.target.memberAccess.identifiers.get(0), methodCallNode.identifier, mapper.generateMethodDescriptor(methodCallNode.type, parameterNodes), false);
     }
 }

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

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

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

@@ -39,12 +39,14 @@ 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

@@ -17,10 +17,10 @@ import java.util.Optional;
 
 
 /**
- * Start miniCompiler using make:
+ * Start Raupenpiler using make:
  * <p> <code> cd .\src\test\ </code>
- * <p> <code> make clean compile-miniCompiler </code>
- * <p> Start miniCompiler using jar:
+ * <p> <code> make clean compile-raupenpiler </code>
+ * <p> Start Raupenpiler using jar:
  * <p> <code> java.exe -DgenJar=true_OR_false -DgenClass=true_OR_false -jar path_to_jar\JavaCompiler-1.0-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
  * <p> Example (jar needs to be in the target directory, compile with make or mvn package first):
  * <code> java.exe -DgenJar=true -DgenClass=true -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
@@ -40,6 +40,16 @@ public class Main {
                 System.err.println("Error reading the file: " + e.getMessage());
             }
         }
+        /*        !!! Else Branch (main ohne args starten) ist nicht zur Verwendung vorgesehen, immer mit args starten !!!
+        else {
+            try {
+                CharStream codeCharStream = CharStreams.fromPath(Paths.get("src/main/resources/input/CompilerInput.java"));
+                compileFile(codeCharStream);
+            } catch (IOException e) {
+                System.err.println("Error reading the file: " + e.getMessage());
+            }
+        }
+        */
     }
 
     /**
@@ -56,7 +66,7 @@ public class Main {
      */
     static void compileFile(CharStream inputCharStream, String outputDirectoryPath) {
         // Initialize the logger
-        new MiniCompilerLogger();
+        new RaupenLogger();
 
         /* ------------------------- Scanner -> tokens ------------------------- */
         // Use the SimpleJavaLexer to tokenize the input CharStream
@@ -64,27 +74,27 @@ public class Main {
         CommonTokenStream tokenStream = new CommonTokenStream(lexer);
         tokenStream.fill();
         // Log the tokens
-        MiniCompilerLogger.logScanner(tokenStream);
+        RaupenLogger.logScanner(tokenStream);
 
         /*------------------------- Parser -> Parsetree -------------------------*/
         // Use the SimpleJavaParser to parse the tokens and generate a ParseTree
         SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
         ParseTree parseTree = parser.program(); // parse the input
         // Log the ParseTree
-        MiniCompilerLogger.logParser(parseTree, parser);
+        RaupenLogger.logParser(parseTree, parser);
 
         /*------------------------- AST builder -> AST -------------------------*/
         // Use the ASTBuilder to visit the ParseTree and generate an Abstract Syntax Tree (AST)
         ASTBuilder astBuilder = new ASTBuilder();
         ASTNode abstractSyntaxTree = astBuilder.visit(parseTree);
         // Log the AST
-        MiniCompilerLogger.logAST(abstractSyntaxTree);
+        RaupenLogger.logAST(abstractSyntaxTree);
 
         /*------------------------- Semantic Analyzer -> typed AST -------------------------*/
         // Use the SemanticAnalyzer to generate a typed AST
         ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
         // Log the typed AST
-        MiniCompilerLogger.logSemanticAnalyzer(typedAst);
+        RaupenLogger.logSemanticAnalyzer(typedAst);
 
         if(SemanticAnalyzer.errors.isEmpty()){
             /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
@@ -97,7 +107,7 @@ public class Main {
             assert typedAst != null;
             byteCodeGenerator.visit((ProgramNode) typedAst);
             // Log the bytecode generation
-            MiniCompilerLogger.logBytecodeGenerator();
+            RaupenLogger.logBytecodeGenerator();
         } else {
             for(Exception exception : SemanticAnalyzer.errors){
                 exception.printStackTrace();

src/main/java/main/RaupenLogger.java

@@ -29,11 +29,11 @@ import java.util.logging.*;
  * <code>consoleHandler.setLevel(Level.OFF);</code>
  * <code>fileHandler.setLevel(Level.ALL);</code>
  */
-public class MiniCompilerLogger {
+public class RaupenLogger {
 
-    static Logger logger = Logger.getLogger("miniCompilerLogs");
+    static Logger logger = Logger.getLogger("RaupenLogs");
 
-    public MiniCompilerLogger() {
+    public RaupenLogger() {
         // ------------------------- Logging -------------------------
         logger.setLevel(Level.ALL);
         logger.getParent().getHandlers()[0].setLevel(Level.ALL);
@@ -66,7 +66,7 @@ public class MiniCompilerLogger {
             logger.addHandler(consoleHandler);
 
             // Configure file handler
-            Handler fileHandler = new FileHandler("src/main/resources/logs/miniCompiler.log");
+            Handler fileHandler = new FileHandler("src/main/resources/logs/RaupenLog.log");
             // Toggle file logging on/off
             fileHandler.setLevel(Level.ALL);
             fileHandler.setFormatter(new CustomFormatter());
@@ -117,7 +117,7 @@ public class MiniCompilerLogger {
     public static void logBytecodeGenerator() {
         // Printing the bytecode
         logger.info("-------------------- Bytecode Generator -> Bytecode  --------------------");
-        logger.info("Bytecode generated without errors.");
+        logger.info("Bytecode generated");
         logger.info("\n");
     }
 

src/test/Makefile

@@ -2,17 +2,17 @@
 ### IntelliJs play buttons do not work. Run in "src/test" folder with "make" command to run all
 ### Or run only parts with "make compile-javac", "make clean" etc.
 
-all: compile-javac compile-miniCompiler
+all: compile-javac compile-raupenpiler
 
 compile-javac:
 	javac -d .\resources\output\javac .\resources\input\CompilerInput.java
 
-compile-miniCompiler:
+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/miniCompiler
+	# cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
 
-test-miniCompiler:
+test-raupenpiler:
 	# move the compiled class to the test/main folder
 	mv ../main/resources/output/CompilerInput.class .java/main/
 	# compile the test class
@@ -28,8 +28,8 @@ clean:
 	rm -f ../main/resources/output/*.jar
 	# clean resources output folders
 	rm -f ./resources/output/javac/*.class
-	rm -f ./resources/output/miniCompiler/*.class
-	rm -f ./resources/output/miniCompiler/*.jar
+	rm -f ./resources/output/raupenpiler/*.class
+	rm -f ./resources/output/raupenpiler/*.jar
 	# clean logs
 	rm -f ../main/resources/logs/*
 	# clean test/java/main folders from .class files for End-to-End tests

src/test/java/main/EndToEndTester.java

@@ -11,6 +11,8 @@ package main;
  * Wenn unser Compiler funktioniert, sollten keine Errors kommen (sondern nur die Ausgaben, die wir in der CompilerInput.java Datei gemacht haben,
  * oder Methoden, die wir hier aufrufen).</p>
  *
+ * <p><strong>PROBLEM:</strong> Hier kommen Errors, was eigentlich heißt, dass der Compiler nicht funktioniert, der Test sollte eigentlich passen.
+ * <br><strong>DENN:</strong> Wenn ich statt unserem CompilerInput.class die CompilerInput.class von javac verwende (aus  <code> src/test/resources/output/javac </code>), dann funktioniert es.</p>
  */
 public class EndToEndTester {
     public static void main(String[] args) {