.idea/misc.xml

@@ -6,7 +6,7 @@
         <PerGrammarGenerationSettings>
           <option name="fileName" value="$PROJECT_DIR$/src/main/java/parser/SimpleJava.g4" />
           <option name="autoGen" value="true" />
-          <option name="outputDir" value="C:\Users\ARB00075\Documents\DH\Compilerbau\NichtHaskell2.0\src\main\java" />
+          <option name="outputDir" value="C:\Users\Johannes\Documents\Github\JavaCompiler\src\main\java" />
           <option name="libDir" value="" />
           <option name="encoding" value="" />
           <option name="pkg" value="parser.generated" />

src/main/java/ast/ProgramNode.java

@@ -1,6 +1,5 @@
 package ast;
 
-import bytecode.visitor.ProgramVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 import visitor.Visitable;
@@ -19,9 +18,4 @@ public class ProgramNode implements ASTNode, Visitable {
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }
-
-    @Override
-    public void accept(ProgramVisitor programVisitor) {
-        programVisitor.visit(this);
-    }
 }

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

@@ -2,12 +2,10 @@ package ast.expressions.binaryexpressions;
 
 import ast.expressions.IExpressionNode;
 import ast.type.type.*;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import visitor.Visitable;
 
-public class BinaryNode implements IExpressionNode, Visitable {
+public class BinaryNode implements IExpressionNode {
 
     private ITypeNode typeNode;
 
@@ -25,9 +23,4 @@ public class BinaryNode implements IExpressionNode, Visitable {
     public void setType(ITypeNode type) {
         this.typeNode = type;
     }
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 }

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

@@ -1,7 +1,6 @@
 package ast.expressions.binaryexpressions;
 
 import ast.type.type.*;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -34,10 +33,4 @@ public class CalculationNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

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

@@ -1,7 +1,6 @@
 package ast.expressions.binaryexpressions;
 
 import ast.type.type.*;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -35,9 +34,4 @@ public class DotNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

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

@@ -4,7 +4,6 @@ import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 import ast.type.type.*;
 import ast.type.ValueNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -37,9 +36,4 @@ public class DotSubstractionNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

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

@@ -3,7 +3,6 @@ package ast.expressions.binaryexpressions;
 import ast.expressions.IExpressionNode;
 import ast.expressions.unaryexpressions.UnaryNode;
 import ast.type.type.*;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -43,9 +42,4 @@ public class NonCalculationNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java

@@ -1,7 +1,6 @@
 package ast.expressions.unaryexpressions;
 
 import ast.ASTNode;
-import bytecode.visitor.MethodVisitor;
 import ast.type.type.ITypeNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
@@ -24,10 +23,6 @@ public class MemberAccessNode implements ASTNode, Visitable {
     }
 
     @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-    
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }

src/main/java/ast/expressions/unaryexpressions/NotNode.java

@@ -2,26 +2,12 @@ package ast.expressions.unaryexpressions;
 
 import ast.ASTNode;
 import ast.expressions.IExpressionNode;
-import bytecode.visitor.MethodVisitor;
-import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
-import visitor.Visitable;
 
-public class NotNode implements ASTNode, Visitable {
+public class NotNode implements ASTNode {
     public IExpressionNode expression;
 
     public NotNode(IExpressionNode expression) {
         this.expression = expression;
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
-    @Override
-    public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
-    }
-
 }

src/main/java/ast/expressions/unaryexpressions/UnaryNode.java

@@ -4,7 +4,6 @@ import ast.expressions.IExpressionNode;
 import ast.statements.IStatementNode;
 import ast.type.type.*;
 import ast.type.ValueNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -62,9 +61,4 @@ public class UnaryNode implements IExpressionNode {
         this.type = type;
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

src/main/java/ast/literal/BooleanLiteralNode.java

@@ -1,11 +0,0 @@
-package ast.literal;
-
-public class BooleanLiteralNode {
-    private String value;
-
-    public BooleanLiteralNode(String value) {this.value = value;}
-
-    public String getValue() {
-        return value;
-    }
-}

src/main/java/ast/literal/CharLiteralNode.java

@@ -1,11 +0,0 @@
-package ast.literal;
-
-public class CharLiteralNode {
-    public String value;
-
-    public CharLiteralNode(String value) {this.value = value;}
-
-    public String getValue() {
-        return value;
-    }
-}

src/main/java/ast/literal/LiteralNode.java

@@ -1,31 +0,0 @@
-package ast.literal;
-
-import ast.expression.ExpressionNode;
-import ast.type.TypeNode;
-import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
-
-public class LiteralNode implements ExpressionNode {
-
-    public String value;
-    private TypeNode type;
-
-    public LiteralNode(String value, TypeNode type) {
-        this.value = value;
-        this.type = type;
-    }
-
-    public TypeNode getType() {
-        return type;
-    }
-
-    public void setType(TypeNode type) {
-        this.type = type;
-    }
-
-
-    @Override
-    public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
-    }
-}

src/main/java/ast/members/ConstructorNode.java

@@ -3,14 +3,12 @@ package ast.members;
 import ast.parameters.ParameterNode;
 import ast.statements.BlockNode;
 import ast.type.AccessModifierNode;
-import bytecode.visitor.MethodVisitor;
-import visitor.Visitable;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
-public class ConstructorNode extends MethodNode implements Visitable {
+public class ConstructorNode extends MethodNode  {
     public AccessModifierNode accessType;
     public String identifier;
     public List<ParameterNode> parameters = new ArrayList<>();
@@ -27,10 +25,6 @@ public class ConstructorNode extends MethodNode implements Visitable {
     }
 
     @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
     public boolean isSame(MethodNode methodNode) {
         if (!(Objects.equals(this.identifier, methodNode.getIdentifier()))
                 || getParameters().size() != methodNode.getParameters().size()) {

src/main/java/ast/members/FieldNode.java

@@ -2,8 +2,6 @@ package ast.members;
 
 import ast.type.AccessModifierNode;
 import ast.type.type.ITypeNode;
-import bytecode.visitor.ClassVisitor;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 import visitor.Visitable;
@@ -24,9 +22,4 @@ public class FieldNode implements MemberNode, Visitable {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(ClassVisitor classVisitor) {
-        classVisitor.visit(this);
-    }
-
 }

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

@@ -1,18 +1,10 @@
 package ast.members;
 
 import ast.statements.BlockNode;
-import bytecode.visitor.MethodVisitor;
-import visitor.Visitable;
 
-public class MainMethodNode extends MethodNode implements Visitable {
-    public BlockNode block;
+public class MainMethodNode extends MethodNode {
 
     public MainMethodNode(BlockNode block) {
         this.block = block;
     }
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 }

src/main/java/ast/members/MethodNode.java

@@ -21,8 +21,7 @@ public class MethodNode implements MemberNode, Visitable {
     public List<ParameterNode> parameters = new ArrayList<>();
     public BlockNode block;
 
-    public MethodNode() {
-    }
+    public MethodNode() {}
 
     public MethodNode(String accessModifier, ITypeNode type, Boolean voidType, String identifier, BlockNode block){
         this.accesModifier = new AccessModifierNode(accessModifier);

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

@@ -1,11 +0,0 @@
-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/AssignNode.java

@@ -1,7 +1,6 @@
 package ast.statementexpressions;
 
 import ast.expressions.IExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -19,9 +18,4 @@ public class AssignNode implements IStatementExpressionNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

src/main/java/ast/statementexpressions/NewDeclarationNode.java

@@ -1,7 +1,6 @@
 package ast.statementexpressions;
 
 import ast.expressions.IExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -25,9 +24,4 @@ public class NewDeclarationNode implements IStatementExpressionNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

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

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

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

@@ -2,7 +2,6 @@ package ast.statementexpressions.crementexpressions;
 
 import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.IStatementExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -20,9 +19,4 @@ public class IncrementNode implements IStatementExpressionNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

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

@@ -2,15 +2,11 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 
 import ast.ASTNode;
 import ast.expressions.IExpressionNode;
-import bytecode.visitor.MethodVisitor;
-import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
-import visitor.Visitable;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class ChainedMethodNode implements ASTNode, Visitable {
+public class ChainedMethodNode implements ASTNode {
     public String identifier;
     public List<IExpressionNode> expressions = new ArrayList<>();
 
@@ -21,14 +17,4 @@ public class ChainedMethodNode implements ASTNode, Visitable {
     public void addExpression(IExpressionNode expression) {
         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 bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -33,9 +32,4 @@ public class MethodCallNode implements IStatementNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

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

@@ -3,7 +3,6 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 import ast.ASTNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.statementexpressions.NewDeclarationNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 import visitor.Visitable;
@@ -31,10 +30,6 @@ public class TargetNode implements ASTNode, Visitable {
     }
 
     @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }

src/main/java/ast/statements/BlockStatementNode.java

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

src/main/java/ast/statements/ElseNode.java

@@ -1,5 +1,6 @@
 package ast.statements;
 
+import ast.ASTNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 

src/main/java/ast/statements/IfElseNode.java

@@ -1,5 +1,6 @@
 package ast.statements;
 
+import ast.ASTNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 

src/main/java/ast/statements/IfNode.java

@@ -1,5 +1,6 @@
 package ast.statements;
 
+import ast.ASTNode;
 import ast.expressions.IExpressionNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;

src/main/java/ast/statements/LocalVariableDeclarationNode.java

@@ -2,7 +2,6 @@ package ast.statements;
 
 import ast.expressions.IExpressionNode;
 import ast.type.type.*;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -24,9 +23,4 @@ public class LocalVariableDeclarationNode implements IStatementNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

src/main/java/ast/statements/ReturnNode.java

@@ -1,7 +1,6 @@
 package ast.statements;
 
 import ast.expressions.IExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
@@ -22,9 +21,4 @@ public class ReturnNode implements IStatementNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

src/main/java/ast/statements/WhileNode.java

@@ -1,5 +1,6 @@
 package ast.statements;
 
+import ast.ASTNode;
 import ast.expressions.IExpressionNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;

src/main/java/ast/type/ValueNode.java

@@ -1,7 +1,6 @@
 package ast.type;
 
 import ast.ASTNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 import visitor.Visitable;
@@ -15,10 +14,6 @@ public class ValueNode implements ASTNode, Visitable {
         this.value = value;
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {

src/main/java/bytecode/ByteCodeGenerator.java

@@ -2,78 +2,21 @@ package bytecode;
 
 import ast.ProgramNode;
 import ast.ClassNode;
-import ast.members.MainMethodNode;
-import ast.members.MemberNode;
 import bytecode.visitor.ProgramVisitor;
 
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.jar.JarOutputStream;
-import java.util.jar.Manifest;
-
 public class ByteCodeGenerator implements ProgramVisitor {
 
-    private JarOutputStream jarOutputStream;
-    private ByteArrayOutputStream byteArrayOutputStream;
-    private String outputDirectory;
+  private final String outputDirectoryPath;
 
-    public ByteCodeGenerator(String outputDirectory) {
-        this.outputDirectory = outputDirectory;
+  public ByteCodeGenerator(String outputDirectoryPath) {
+    this.outputDirectoryPath = outputDirectoryPath;
   }
 
   @Override
   public void visit(ProgramNode programNode) {
-        byteArrayOutputStream = new ByteArrayOutputStream();
-        try {
-            Manifest manifest = new Manifest();
-            manifest.getMainAttributes().putValue("Manifest-Version", "1.0");
-            boolean foundMainClass = false;
-            for (ClassNode classNode : programNode.classes) {
-                if (foundMainClass) {
-                    break;
-                }
-                for (MemberNode memberNode : classNode.members) {
-                    if (memberNode instanceof MainMethodNode) {
-                        manifest.getMainAttributes().putValue("Main-Class", classNode.identifier);
-                        foundMainClass = true;
-                        break;
-                    }
-                }
-            }
-
-
-            jarOutputStream = new JarOutputStream(byteArrayOutputStream, manifest);
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-
     for (ClassNode classDeclarationNode : programNode.classes) {
-            ClassCodeGen classCodeGen = new ClassCodeGen(jarOutputStream, outputDirectory);
-            classDeclarationNode.accept(classCodeGen);
-        }
-
-        try {
-            jarOutputStream.close();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-
-        saveJarFile(byteArrayOutputStream.toByteArray(), "output.jar");
-    }
-
-    private void saveJarFile(byte[] jarBytes, String jarFileName) {
-        File directory = new File(outputDirectory);
-        if (!directory.exists()) {
-            directory.mkdirs();
-        }
-
-        File jarFile = new File(directory, jarFileName);
-        try (FileOutputStream fos = new FileOutputStream(jarFile)) {
-            fos.write(jarBytes);
-        } catch (IOException e) {
-            e.printStackTrace();
+//      ClassCodeGen classCodeGen = new ClassCodeGen();
+//      classDeclarationNode.accept(classCodeGen);
     }
   }
 }

src/main/java/bytecode/ClassCodeGen.java

@@ -10,31 +10,26 @@ import bytecode.visitor.ClassVisitor;
 import java.io.File;
 
 import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Opcodes;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.util.jar.JarEntry;
-import java.util.jar.JarOutputStream;
 
 
 public class ClassCodeGen implements ClassVisitor {
     private Mapper mapper;
     private ClassWriter classWriter;
-    private JarOutputStream jarOutputStream;
-    private String outputDirectory;
+    private final String outputDirectoryPath;
 
-    public ClassCodeGen(JarOutputStream jarOutputStream, String outputDirectory) {
+    public ClassCodeGen(String outputDirectoryPath) {
+        this.outputDirectoryPath = outputDirectoryPath;
         mapper = new Mapper();
-        this.jarOutputStream = jarOutputStream;
-        this.outputDirectory = outputDirectory;
     }
 
     @Override
     public void visit(ClassNode classNode) {
         classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
-        classWriter.visit(Opcodes.V1_5, mapper.mapAccessTypeToOpcode(classNode.accessType), classNode.identifier, null,
-                "java/lang/Object", null);
+//        classWriter.visit(Opcodes.V1_5, mapper.mapAccessTypeToOpcode(classNode.accessType), classNode.identifier, null,
+//                "java/lang/Object", null);
 
         for (MemberNode memberNode : classNode.members) {
             if (memberNode instanceof FieldNode) {
@@ -46,27 +41,28 @@ public class ClassCodeGen implements ClassVisitor {
         }
 
         classWriter.visitEnd();
-        writeToJar(classWriter.toByteArray(), classNode.identifier);
-        printIntoClassFile(classWriter.toByteArray(), classNode.identifier, outputDirectory);
+        printIntoClassFile(classWriter.toByteArray(), classNode.identifier);
 
         classWriter.visitEnd();
     }
 
     @Override
     public void visit(FieldNode fieldNode) {
-        if (fieldNode.type instanceof BaseType) {
-            classWriter.visitField(mapper.mapAccessTypeToOpcode(fieldNode.accessTypeNode), fieldNode.identifier, mapper.getTypeChar((BaseType) fieldNode.type), null, null);
+        if(fieldNode.type instanceof BaseType baseTypeNode){
+//            classWriter.visitField(mapper.mapAccessTypeToOpcode(fieldNode.accessTypeNode), fieldNode.identifier, mapper.getTypeChar(baseTypeNode.enumType), null, null );
         }
         classWriter.visitEnd();
     }
 
-    private void printIntoClassFile(byte[] byteCode, String name, String outputDirectory) {
-        File directory = new File(outputDirectory);
+    private void printIntoClassFile(byte[] byteCode, String name) {
+        // String outputDirectoryPath = "src/main/resources/output";
+        // System.out.println("Output directory path: " + outputDirectoryPath);
+        File directory = new File(outputDirectoryPath);
         if (!directory.exists()) {
             directory.mkdirs();
         }
 
-        String filePath = outputDirectory + "/" + name + ".class";
+        String filePath = outputDirectoryPath + "/" + name + ".class";
         try {
             FileOutputStream fileOutputStream = new FileOutputStream(filePath);
             fileOutputStream.write(byteCode);
@@ -75,15 +71,4 @@ public class ClassCodeGen implements ClassVisitor {
             e.printStackTrace();
         }
     }
-
-    private void writeToJar(byte[] byteCode, String className) {
-        try {
-            JarEntry jarEntry = new JarEntry(className + ".class");
-            jarOutputStream.putNextEntry(jarEntry);
-            jarOutputStream.write(byteCode);
-            jarOutputStream.closeEntry();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
 }

src/main/java/bytecode/Mapper.java

@@ -1,60 +1,41 @@
 package bytecode;
 
-import ast.parameters.ParameterNode;
 import ast.type.*;
-import ast.type.type.BaseType;
-import ast.type.type.ReferenceType;
-import ast.type.type.TypeEnum;
-import org.objectweb.asm.Opcodes;
-
-import java.util.List;
 
 public class Mapper {
-    public int mapAccessTypeToOpcode(AccessModifierNode accessModifierNode) {
-        switch (accessModifierNode.accessType) {
-            case EnumAccessModifierNode.PUBLIC:
-                return Opcodes.ACC_PUBLIC;
-            case EnumAccessModifierNode.PRIVATE:
-                return Opcodes.ACC_PRIVATE;
-            case EnumAccessModifierNode.PUBLIC_STATIC:
-                return Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC;
-            case EnumAccessModifierNode.PRIVATE_STATIC:
-                return Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC;
-        }
-        return 0;
-    }
+//    public int mapAccessTypeToOpcode(AccessModifierNode type) {
+//        switch (type.enumAccessTypeNode) {
+//            case EnumAccessTypeNode.PUBLIC:
+//                return Opcodes.ACC_PUBLIC;
+//            case EnumAccessTypeNode.PRIVATE:
+//                return Opcodes.ACC_PRIVATE;
+//        }
+//        return 0;
+//    }
 
-    public String generateMethodDescriptor(BaseType type, List<ParameterNode> parameters) {
-        String descriptor = "(";
-        for (ParameterNode parameterNode : parameters) {
-            descriptor += getTypeChar((BaseType) parameterNode.type);
-        }
-        descriptor += ")";
-        descriptor += getTypeChar(type);
-        return descriptor;
-    }
+//    public String generateMethodDescriptor(BaseTypeNode baseTypeNode, ParameterListNode parameterListNode) {
+//        String descriptor = "(";
+//        for(ParameterNode parameterNode : parameterListNode.parameters) {
+//            descriptor += getTypeChar(EnumTypeNode.INT);
+//        }
+//        descriptor += ")";
+//        descriptor += getTypeChar(baseTypeNode.enumType);
+//        return descriptor;
+//    }
 
-    public String generateMethodDescriptor(ReferenceType type, List<ParameterNode> parameters) {
-        String descriptor = "()V";
-        return descriptor;
-    }
-
-    public String getTypeChar(BaseType type) {
-        String typeChar = "";
-        switch (type.getTypeEnum()) {
-            case TypeEnum.INT:
-                typeChar = "I";
-                break;
-            case TypeEnum.CHAR:
-                typeChar = "C";
-                break;
-            case TypeEnum.BOOL:
-                typeChar = "Z";
-                break;
-            case TypeEnum.VOID:
-                typeChar = "V";
-                break;
-        }
-        return typeChar;
-    }
+//    public String getTypeChar(TypeEnum enumTypeNode) {
+//        String typeChar = "";
+//        switch (enumTypeNode) {
+//            case TypeEnum.INT:
+//                typeChar = "I";
+//                break;
+//            case TypeEnum.CHAR:
+//                typeChar = "C";
+//                break;
+//            case TypeEnum.BOOLEAN:
+//                typeChar = "Z";
+//                break;
+//        }
+//        return typeChar;
+//    }
 }

src/main/java/bytecode/MethodCodeGen.java

@@ -1,28 +1,9 @@
 package bytecode;
 
-import ast.expressions.binaryexpressions.*;
-import ast.expressions.unaryexpressions.MemberAccessNode;
-import ast.expressions.unaryexpressions.NotNode;
-import ast.expressions.unaryexpressions.UnaryNode;
 import ast.members.ConstructorNode;
-import ast.members.MainMethodNode;
 import ast.members.MethodNode;
-import ast.parameters.ParameterNode;
-import ast.statementexpressions.AssignNode;
-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.*;
-import ast.type.ValueNode;
-import ast.type.type.BaseType;
-import ast.type.type.TypeEnum;
 import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -44,433 +25,70 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         localVaribales = new ArrayList<>();
     }
 
-
-    // Method nodes
-
     @Override
     public void visit(ConstructorNode constructorNode) {
-        methodVisitor =
-                classWriter.visitMethod(mapper.mapAccessTypeToOpcode(constructorNode.accessType),
-                        "<init>",
-                        mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID), constructorNode.parameters),
-                        null,
-                        null);
-
+//        methodVisitor =
+//                classWriter.visitMethod(mapper.mapAccessTypeToOpcode(constructorNode.visibility),
+//                        "<init>",
+//                        "()V",
+//                        null,
+//                        null);
         methodVisitor.visitCode();
-        localVaribales.add("this");
-        // Add all method parameters to localVariables
-        for (ParameterNode parameterNode : constructorNode.parameters) {
-            localVaribales.add(parameterNode.identifier);
-        }
-
         methodVisitor.visitVarInsn(ALOAD, 0);
         methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
-
-        // Visit all statements
-        for (IStatementNode statementNode : constructorNode.block.statements) {
-            statementNode.accept(this);
-        }
-
-        methodVisitor.visitMaxs(0, 0);
-        methodVisitor.visitEnd();
-    }
-
-    @Override
-    public void visit(MainMethodNode mainMethodNode) {
-        methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(mainMethodNode.accesModifier),
-                mainMethodNode.getIdentifier(),
-                "([Ljava/lang/String;)V",
-                null,
-                null);
-
-        methodVisitor.visitCode();
-        localVaribales.add("this");
-        localVaribales.add("args");
-
-        // Visit all statements
-        for (IStatementNode statementNode : mainMethodNode.block.statements) {
-            statementNode.accept(this);
-        }
-
-        methodVisitor.visitMaxs(0, 0);
+        methodVisitor.visitInsn(RETURN);
+        methodVisitor.visitMaxs(1, 1);
         methodVisitor.visitEnd();
     }
 
     @Override
     public void visit(MethodNode methodNode) {
-        methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(methodNode.accesModifier),
-                methodNode.getIdentifier(),
-                mapper.generateMethodDescriptor((BaseType) methodNode.getType(), methodNode.parameters),
-                null,
-                null);
+//        if (methodNode.type instanceof BaseTypeNode baseTypeNode) {
+//            methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(methodNode.visibility),
+//                    methodNode.identifier,
+//                    mapper.generateMethodDescriptor(baseTypeNode, methodNode.parameters),
+//                    null,
+//                    null);
 
             methodVisitor.visitCode();
             localVaribales.add("this");
-        // Add all method parameters to localVariables
-        for (ParameterNode parameterNode : methodNode.parameters) {
-            localVaribales.add(parameterNode.identifier);
-        }
+//            for (ParameterNode parameterNode : methodNode.parameters.parameters) {
+//                localVaribales.add(parameterNode.identifier);
+//            }
 
-        // Visit all statements
-        for (IStatementNode statementNode : methodNode.block.statements) {
-            statementNode.accept(this);
-        }
-
-        methodVisitor.visitMaxs(0, 0);
+            //test();
+            methodVisitor.visitMaxs(1, localVaribales.size());
             methodVisitor.visitEnd();
+//        }
     }
 
-
-    // Binary expressions
-
-    @Override
-    public void visit(BinaryNode binaryNode) {
-        binaryNode.accept(this);
-    }
-
-    @Override
-    public void visit(CalculationNode calculationNode) {
-        calculationNode.dotExpression.accept(this);
-        calculationNode.calculationExpression.accept(this);
-        switch (calculationNode.operator) {
-            case PLUS:
-                methodVisitor.visitInsn(IADD);
-                break;
-            case MINUS:
-                methodVisitor.visitInsn(ISUB);
-                break;
-        }
-    }
-
-    @Override
-    public void visit(DotNode dotNode) {
-        dotNode.dotExpression.accept(this);
-        dotNode.dotSubstractionExpression.accept(this);
-        switch (dotNode.operator) {
-            case DIV:
-                methodVisitor.visitInsn(IDIV);
-                break;
-            case MULT:
-                methodVisitor.visitInsn(IMUL);
-                break;
-            case MOD:
-                methodVisitor.visitInsn(IREM);
-                break;
-        }
-    }
-
-    @Override
-    public void visit(DotSubstractionNode dotSubstractionNode) {
-        if (dotSubstractionNode.value != null) {
-            dotSubstractionNode.value.accept(this);
-        } else if (dotSubstractionNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVaribales.indexOf(dotSubstractionNode.identifier));
-        } else if (dotSubstractionNode.memberAccess != null) {
-            dotSubstractionNode.memberAccess.accept(this);
-        } else if (dotSubstractionNode.methodCall != null) {
-            dotSubstractionNode.methodCall.accept(this);
-        } else if (dotSubstractionNode.calculationExpression != null) {
-            dotSubstractionNode.calculationExpression.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(NonCalculationNode nonCalculationNode) {
-        Label labelFalse = new Label();
-        Label labelTrue = new Label();
-        switch (nonCalculationNode.operator) {
-            case AND:
-                nonCalculationNode.unaryExpression.accept(this);
-                methodVisitor.visitJumpInsn(IFEQ, labelFalse); // Value compared to 0 (false)
-                nonCalculationNode.expression.accept(this);
-                methodVisitor.visitJumpInsn(IFEQ, labelFalse);
-                break;
-            case OR:
-                nonCalculationNode.unaryExpression.accept(this);
-                methodVisitor.visitJumpInsn(IFNE, labelTrue);
-                nonCalculationNode.expression.accept(this);
-                methodVisitor.visitJumpInsn(IFEQ, labelFalse);
-                break;
-            case GREATER:
-                nonCalculationNode.unaryExpression.accept(this);
-                nonCalculationNode.expression.accept(this);
-                methodVisitor.visitJumpInsn(IF_ICMPLE, labelFalse);
-                break;
-            case LESS:
-                nonCalculationNode.unaryExpression.accept(this);
-                nonCalculationNode.expression.accept(this);
-                methodVisitor.visitJumpInsn(IF_ICMPGE, labelFalse);
-                break;
-            case GREATER_EQUAL:
-                nonCalculationNode.unaryExpression.accept(this);
-                nonCalculationNode.expression.accept(this);
-                methodVisitor.visitJumpInsn(IF_ICMPLT, labelFalse);
-                break;
-            case LESS_EQUAL:
-                nonCalculationNode.unaryExpression.accept(this);
-                nonCalculationNode.expression.accept(this);
-                methodVisitor.visitJumpInsn(IF_ICMPGT, labelFalse);
-                break;
-            case EQUAL:
-                nonCalculationNode.unaryExpression.accept(this);
-                nonCalculationNode.expression.accept(this);
-                if (nonCalculationNode.unaryExpression.getType() instanceof BaseType && nonCalculationNode.expression.getType() instanceof BaseType) {
-                    methodVisitor.visitJumpInsn(IF_ICMPNE, labelFalse);
-                } else {
-                    methodVisitor.visitJumpInsn(IF_ACMPNE, labelFalse);
-                }
-                break;
-            case NOT_EQUAL:
-                nonCalculationNode.unaryExpression.accept(this);
-                nonCalculationNode.expression.accept(this);
-                if (nonCalculationNode.unaryExpression.getType() instanceof BaseType && nonCalculationNode.expression.getType() instanceof BaseType) {
-                    methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
-                } else {
-                    methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
-                }
-                break;
-        }
-
-        Label labelEndLogicalExpression = new Label();
-
-        methodVisitor.visitLabel(labelTrue);
-        methodVisitor.visitInsn(ICONST_1); // true
-        methodVisitor.visitJumpInsn(GOTO, labelEndLogicalExpression);
-
-        methodVisitor.visitLabel(labelFalse);
-        methodVisitor.visitInsn(ICONST_0); // false
-
-        methodVisitor.visitLabel(labelEndLogicalExpression);
-    }
-
-
-    // Unary expressions
-
-    @Override
-    public void visit(MemberAccessNode memberAccessNode) {
-        if (memberAccessNode.thisExpr) {
-            //methodVisitor.visitFieldInsn(PUTFIELD);
-        }
-    }
-
-    @Override
-    public void visit(NotNode notNode) {
-        Label labelFalse = new Label();
-        Label labelTrue = new Label();
-
-        notNode.expression.accept(this);
-        methodVisitor.visitJumpInsn(Opcodes.IFNE, labelFalse); // false if value is true (value != 0)
-
-        Label labelEndLogicalExpression = new Label();
-
-        methodVisitor.visitLabel(labelTrue);
-        methodVisitor.visitInsn(ICONST_1); // true
-        methodVisitor.visitJumpInsn(GOTO, labelEndLogicalExpression);
-
-        methodVisitor.visitLabel(labelFalse);
-        methodVisitor.visitInsn(ICONST_0); // false
-
-        methodVisitor.visitLabel(labelEndLogicalExpression);
-    }
-
-    @Override
-    public void visit(UnaryNode unaryNode) {
-
-    }
-
-
-    // Statements
-
-    @Override
-    public void visit(IfElseNode ifElseNode) {
-        Label elseLabel = new Label();
-
-        Label[] elseIfLabels = new Label[ifElseNode.elseIfStatements.size()];
-        for(int i = 0; i < ifElseNode.elseIfStatements.size(); i++) {
-            elseIfLabels[i] = new Label();
-        }
-
-        ifElseNode.ifStatement.expression.accept(this);
-        if (ifElseNode.elseIfStatements.isEmpty()) {
-            // No else if
-            methodVisitor.visitJumpInsn(IFEQ, elseLabel);
-        } else {
-            // else if statements
-            methodVisitor.visitJumpInsn(IFEQ, elseIfLabels[0]);
-        }
-        ifElseNode.ifStatement.block.accept(this); // accept if block
-
-        Label endLabel = new Label();
-        methodVisitor.visitJumpInsn(GOTO, endLabel);
-
-        for(int i = 0; i < ifElseNode.elseIfStatements.size(); i++) {
-            methodVisitor.visitLabel(elseIfLabels[i]);
-            ifElseNode.elseIfStatements.get(i).expression.accept(this);
-            if(i + 1 < elseIfLabels.length) {
-                // at least one more else if
-                methodVisitor.visitJumpInsn(IFEQ, elseIfLabels[i+1]);
-            } else {
-                methodVisitor.visitJumpInsn(IFEQ, elseLabel);
-            }
-            ifElseNode.elseIfStatements.get(i).block.accept(this);
-            methodVisitor.visitJumpInsn(GOTO, endLabel);
-        }
-
-        if(ifElseNode.elseStatement != null) {
-            methodVisitor.visitLabel(elseLabel);
-            ifElseNode.elseStatement.block.accept(this);
-        }
-
-        methodVisitor.visitLabel(endLabel);
-    }
-
-    @Override
-    public void visit(LocalVariableDeclarationNode localVariableDeclarationNode) {
-        // Process expression
-        localVariableDeclarationNode.expression.accept(this);
-        // Store result of expression in variable
-        methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
-    }
-
-    @Override
-    public void visit(AssignNode assignNode) {
-        // Process expression
-        assignNode.expression.accept(this);
-        // Store result of expression in variable
-        if (assignNode.assignable.memberAccess.thisExpr) {
-            // Global var
-            // /methodVisitor.visitFieldInsn(PUTFIELD, identifierExpressionNode.name, identifierExpressionNode1.name, mapper.getTypeChar(((BaseTypeNode) type).enumType));
-        } else {
-            // Local var
-            methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(assignNode.assignable.identifier));
-        }
-    }
-
-    @Override
-    public void visit(NewDeclarationNode newDeclarationNode) {
-
-    }
-
-    @Override
-    public void visit(ValueNode valueNode) {
-        switch (valueNode.valueType) {
-            case INT_VALUE:
-                int intValue = Integer.parseInt(valueNode.value);
-                if (intValue >= Byte.MIN_VALUE && intValue <= Byte.MAX_VALUE) { // load int as byte
-                    methodVisitor.visitIntInsn(BIPUSH, intValue);
-                } else if (intValue >= Short.MIN_VALUE && intValue <= Short.MAX_VALUE) { // load int as short
-                    methodVisitor.visitIntInsn(SIPUSH, intValue);
-                } else { // load int as const
-                    methodVisitor.visitLdcInsn(intValue);
-                }
-                break;
-            case BOOLEAN_VALUE:
-                if (valueNode.value.equals("true")) {
-                    methodVisitor.visitInsn(ICONST_1);
-                } else {
-                    methodVisitor.visitInsn(ICONST_0);
-                }
-                break;
-            case CHAR_VALUE:
-                char charValue = valueNode.value.charAt(0);
-                if (charValue <= Byte.MAX_VALUE) { // load char as byte
-                    methodVisitor.visitIntInsn(BIPUSH, charValue);
-                } else if (charValue <= Short.MAX_VALUE) { // load char as short
-                    methodVisitor.visitIntInsn(SIPUSH, charValue);
-                } else { // load char as const
-                    methodVisitor.visitLdcInsn(charValue);
-                }
-                break;
-            case NULL_VALUE:
-                methodVisitor.visitInsn(ACONST_NULL);
-                break;
-        }
-    }
-
-    @Override
-    public void visit(ReturnNode returnNode) {
-        if (returnNode.voidReturn) { // Return nothing
-            methodVisitor.visitInsn(RETURN);
-        } else { // Return something
-            // Process expression
-            returnNode.expression.accept(this);
-            // Return result of expression
-            methodVisitor.visitInsn(IRETURN);
-        }
-    }
-
-
-    @Override
-    public void visit(WhileNode whileNode) {
-        Label loopLabel = new Label();
-        Label endOfLoopLabel = new Label();
-
-        methodVisitor.visitLabel(loopLabel);
-        // while loop
-        whileNode.expression.accept(this);
-        methodVisitor.visitJumpInsn(IFEQ, endOfLoopLabel); // if condition is false, jump out of loop
-
-        whileNode.block.accept(this);
-        methodVisitor.visitJumpInsn(GOTO, loopLabel);
-
-        methodVisitor.visitLabel(endOfLoopLabel);
-    }
-
-    @Override
-    public void visit(DecrementNode decrementNode) {
-        switch (decrementNode.crementType) {
-            case PREFIX: // --i
-                if (decrementNode.assignableExpression.memberAccess == null) { // local Var
-                    methodVisitor.visitIincInsn(localVaribales.indexOf(decrementNode.assignableExpression.identifier), -1);
-                } else { // Field or var from other object
-
-                }
-                break;
-            case SUFFIX: // i--
-                if (decrementNode.assignableExpression.memberAccess == null) { // local Var
-                    methodVisitor.visitIincInsn(localVaribales.indexOf(decrementNode.assignableExpression.identifier), -1);
-                } else { // Field or var from other object
-
-                }
-                break;
-        }
-    }
-
-    @Override
-    public void visit(IncrementNode incrementNode) {
-        switch (incrementNode.crementType) {
-            case PREFIX: // ++i
-                if (incrementNode.assignableExpression.memberAccess == null) { // local Var
-                    methodVisitor.visitIincInsn(localVaribales.indexOf(incrementNode.assignableExpression.identifier), 1);
-                    methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(incrementNode.assignableExpression.identifier));
-
-                } else { // Field or var from other object
-
-                }
-                break;
-            case SUFFIX: // i++
-                if (incrementNode.assignableExpression.memberAccess == null) { // local Var
-                    methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(incrementNode.assignableExpression.identifier));
-                    methodVisitor.visitIincInsn(localVaribales.indexOf(incrementNode.assignableExpression.identifier), 1);
-                } else { // Field or var from other object
-
-                }
-                break;
-        }
-    }
-
-    @Override
-    public void visit(ChainedMethodNode chainedMethodNode) {
-
-    }
-
-    @Override
-    public void visit(MethodCallNode methodCallNode) {
-
-    }
-
-    @Override
-    public void visit(TargetNode targetNode) {
-
-    }
+//    public void test() {
+//        Label start = new Label();
+//        Label loop = new Label();
+//        Label end = new Label();
+//        methodVisitor.visitLabel(start);
+//        //methodVisitor.visitVarInsn(Opcodes.ICONST_M1, 99);
+//        //methodVisitor.visitInsn(Opcodes.ICONST_5);
+//        methodVisitor.visitLdcInsn(99);
+//        // methodVisitor.visitInsn(Opcodes.ICONST_0);
+//        //methodVisitor.visitVarInsn(Opcodes.ILOAD, 2);
+//        methodVisitor.visitVarInsn(Opcodes.ISTORE, 1);
+//        methodVisitor.visitLabel(loop);
+//        methodVisitor.visitVarInsn(Opcodes.ILOAD, 1);
+//        methodVisitor.visitInsn(Opcodes.ICONST_5);
+//        methodVisitor.visitJumpInsn(Opcodes.IF_ICMPGE, end);
+//        methodVisitor.visitFieldInsn(Opcodes.GETSTATIC,
+//                "java/lang/System", "out",
+//                "Ljava/io/PrintStream;");
+//        methodVisitor.visitLdcInsn("Bytecode");
+//        methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL,
+//                "java/io/PrintStream", "println",
+//                "(Ljava/lang/String;)V", false);
+//        methodVisitor.visitIincInsn(1, 1);
+//        methodVisitor.visitJumpInsn(Opcodes.GOTO, loop);
+//        methodVisitor.visitLabel(end);
+//        methodVisitor.visitVarInsn(Opcodes.ILOAD, 1);
+//        methodVisitor.visitInsn(Opcodes.IRETURN);
+//        methodVisitor.visitEnd();
+//    }
 }

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

@@ -1,60 +1,9 @@
 package bytecode.visitor;
 
-import ast.expressions.binaryexpressions.*;
-import ast.expressions.unaryexpressions.MemberAccessNode;
-import ast.expressions.unaryexpressions.NotNode;
-import ast.expressions.unaryexpressions.UnaryNode;
 import ast.members.ConstructorNode;
-import ast.members.MainMethodNode;
 import ast.members.MethodNode;
-import ast.statementexpressions.AssignNode;
-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.*;
-import ast.type.ValueNode;
 
 public interface MethodVisitor {
-    // members
     void visit(ConstructorNode constructorNode);
     void visit(MethodNode methodNode);
-    void visit(MainMethodNode mainMethodNode);
-
-    // Binary expressions
-    void visit(BinaryNode binaryNode);
-    void visit(CalculationNode calculationNode);
-    void visit(DotNode dotNode);
-    void visit(DotSubstractionNode dotSubstractionNode);
-    void visit(NonCalculationNode nonCalculationNode);
-
-    // Unary expressions
-    void visit(MemberAccessNode memberAccessNode);
-    void visit(NotNode notExpressionNode);
-    void visit(UnaryNode unaryExpressionNode);
-
-    // statements
-    void visit(IfElseNode ifElseNode);
-
-    void visit(LocalVariableDeclarationNode localVariableDeclarationNode);
-    void visit(ReturnNode returnNode);
-    void visit(WhileNode whileNode);
-
-    // statement expression
-    void visit(DecrementNode decrementNode);
-    void visit(IncrementNode incrementNode);
-
-    void visit(ChainedMethodNode chainedMethodNode);
-    void visit(MethodCallNode methodCallNode);
-    void visit(TargetNode targetNode);
-
-    void visit(AssignNode assignNode);
-    void visit(NewDeclarationNode newDeclarationNode);
-
-    // type
-    void visit(ValueNode valueNode);
-
 }

src/test/resources/input/AllFeaturesClassExample.java

@@ -9,25 +9,42 @@ public class AllFeaturesClassExample {
         this.b = b;
         this.c = c;
     }
+    private class InnerClass {
+        void innerMethod() {
+            System.out.println("Inner class method");
+        }
+    }
 
     // Methode zur Demonstration von Kontrollstrukturen
     void controlStructures() {
         // if-else Anweisung
         if (a > 10) {
-           // System.out.println("a ist größer als 10");
+            System.out.println("a ist größer als 10");
         } else {
-           // System.out.println("a ist nicht größer als 10");
+            System.out.println("a ist nicht größer als 10");
         }
 
         // while Schleife
         while (a > 0) {
-          //  System.out.println("a ist " + a);
+            System.out.println("a ist " + a);
             a--;
         }
 
         // for Schleife
         for (int i = 0; i < 5; i++) {
-           // System.out.println("for Schleife Iteration: " + i);
+            System.out.println("for Schleife Iteration: " + i);
+        }
+
+        // switch Anweisung
+        switch (c) {
+            case 'a':
+                System.out.println("c ist ein 'a'");
+                break;
+            case 'b':
+                System.out.println("c ist ein 'b'");
+                break;
+            default:
+                System.out.println("c ist nicht 'a' oder 'b'");
         }
     }
 
@@ -35,28 +52,15 @@ public class AllFeaturesClassExample {
     void logicalOperations() {
         // Logische UND-Operation
         if (b && a > 5) {
-          //  System.out.println("a ist größer als 5 und b ist wahr");
+            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");
+            System.out.println("b ist wahr oder a ist kleiner als 5");
         }
     }
 
-    void mathOperations() {
-        // Addition
-        int sum = a + 5;
-        // Subtraktion
-        int difference = a - 5;
-        // Multiplikation
-        int product = a * 5;
-        // Division
-        int quotient = a / 5;
-        // Modulo
-        int remainder = a % 5;
-    }
-
     public static void main(String[] args) {
         AllFeaturesClassExample obj = new AllFeaturesClassExample(12, true, 'a');
         obj.controlStructures();