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

This reverts commit 721e1caa79, reversing changes made to 6d3e1f859e.
Revert "Add typenode again"
2024-07-04 13:59:20 -04:00 · 2024-07-04 13:59:12 -04:00 · 2024-07-04 13:58:53 -04:00 · 2024-07-04 12:29:23 -04:00 · 2024-07-04 11:31:21 -04:00 · 2024-07-04 11:30:54 -04:00
8 changed files with 229 additions and 65 deletions
--- a/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java
+++ b/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);
+    }
 }
--- a/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java
+++ b/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);
+    }
 }
--- a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java
+++ b/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;
--- a/src/main/java/bytecode/ClassCodeGen.java
+++ b/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;
--- a/src/main/java/bytecode/Mapper.java
+++ b/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;
    }

--- a/src/main/java/bytecode/MethodCodeGen.java
+++ b/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);
    }
 }
--- a/src/main/java/bytecode/visitor/ClassVisitor.java
+++ b/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);
 }
--- a/src/main/java/bytecode/visitor/MethodVisitor.java
+++ b/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);
Author	SHA1	Message	Date
i22007	4f688474a2	Revert "Merge remote-tracking branch 'origin/Endabgabe' into code-generator" Some checks failed Gitea Actions Demo / Explore-Gitea-Actions (push) Has been cancelled Details This reverts commit `721e1caa79`, reversing changes made to `6d3e1f859e`.	2024-07-04 13:59:20 -04:00
i22007	5fc3927c5d	Revert "Add typenode again" Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details This reverts commit `fbff03c3d7`.	2024-07-04 13:59:12 -04:00
i22007	a4d08aacb8	Revert "Some changes" Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details This reverts commit `8eba420d48`.	2024-07-04 13:58:53 -04:00
i22007	8eba420d48	Some changes Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 12:29:23 -04:00
i22007	fbff03c3d7	Add typenode again Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 11:31:21 -04:00
i22007	721e1caa79	Merge remote-tracking branch 'origin/Endabgabe' into code-generator	2024-07-04 11:30:54 -04:00
i22007	6d3e1f859e	Increment/Decrement assign Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 11:20:10 -04:00
i22035	f6b34bf70b	readme.md gelöscht Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 15:16:39 +00:00
i22035	430d551f7d	README.md aktualisiert Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 15:08:02 +00:00
i22035	8e0d627505	Readme fixed Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 17:06:49 +02:00
i22035	6b6051cad8	Readme fixed Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 17:04:48 +02:00
i22035	1f8e045b1e	Readme	2024-07-04 17:03:49 +02:00
i22035	ceb1231632	Fixed Renaming Errors Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 17:02:02 +02:00
Maximilian Stahl	31929878b0	Merge remote-tracking branch 'origin/Endabgabe' into Endabgabe Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details # Conflicts: # src/main/java/semantic/SemanticAnalyzer.java # src/test/java/semantic/SemanticTest.java	2024-07-04 16:55:15 +02:00
Lucas	ea97f34398	Merge remote-tracking branch 'origin/Endabgabe' into Endabgabe Some checks are pending Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run Details	2024-07-04 16:49:27 +02:00
Lucas	2f7b310254	refactoring, readme	2024-07-04 16:49:14 +02:00
entep01	4775c3f47e	Fixes and changed For Builder	2024-07-04 16:30:19 +02:00