Merge remote-tracking branch 'origin/johns-branch' into parser

 Conflicts:

	.idea/misc.xml

	src/main/java/Main.java

	src/main/java/ast/expression/ExpressionNode.java

	src/main/java/ast/member/ConstructorNode.java

	src/main/java/ast/member/FieldNode.java

	src/main/java/ast/member/MemberNode.java

	src/main/java/ast/member/MethodNode.java

	src/main/java/ast/parameter/ParameterNode.java

	src/main/java/ast/statement/AssignmentStatementNode.java

	src/main/java/ast/statement/StatementNode.java

	src/main/java/ast/type/AccessTypeNode.java

	src/main/java/ast/type/TypeNode.java

	src/main/java/bytecode/ClassCodeGen.java

	src/main/java/bytecode/FieldCodeGen.java

	src/main/java/bytecode/Mapper.java

	src/main/java/bytecode/MethodCodeGen.java

	src/main/java/classFileOutput/Example.class

	src/main/java/parser/ASTBuilder.java

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

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

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

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

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

	src/main/java/parser/generated/SimpleJavaParser.java

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

	src/main/java/semantic/SemanticAnalyzer.java

src/main/java/Main.java

@@ -1,11 +1,10 @@
-import ast.ClassNode;
 import ast.ProgramNode;
 import bytecode.ByteCodeGenerator;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.tree.ParseTree;
-import parser.ASTBuilder;
+import parser.astBuilder.ASTBuilder;
 import parser.generated.SimpleJavaLexer;
 import parser.generated.SimpleJavaParser;
 import semantic.SemanticAnalyzer;

src/main/java/ast/IdentifierNode.java

@@ -0,0 +1,27 @@
+package ast;
+
+public class IdentifierNode {
+
+    private String name;
+
+    public IdentifierNode(String name){
+        this.name = name;
+    }
+
+    public String getName(){
+        return name;
+    }
+
+    public boolean equals(Object obj) {
+        if(obj instanceof IdentifierNode){
+            IdentifierNode identifier = (IdentifierNode) obj;
+            if(name.equals(identifier.getName())){
+                return true;
+            } else {
+                return false;
+            }
+        }
+        return super.equals(obj);
+    }
+
+}

src/main/java/ast/expression/BinaryExpressionNode.java

@@ -3,7 +3,7 @@ package ast.expression;
 public class BinaryExpressionNode extends ExpressionNode {
     public ExpressionNode left;
     public ExpressionNode right;
-    public String operator;  // Stores the operator as a string (e.g., "+", "-", "&&")
+    public String operator;
 
     public BinaryExpressionNode(ExpressionNode left, ExpressionNode right, String operator) {
         this.left = left;

src/main/java/ast/expression/UnaryExpressionNode.java

@@ -2,7 +2,7 @@ package ast.expression;
 
 public class UnaryExpressionNode extends ExpressionNode {
     public ExpressionNode expression;
-    public String operator;  // Stores the operator (e.g., "-", "!")
+    public String operator;
 
     public UnaryExpressionNode(ExpressionNode expression, String operator) {
         this.expression = expression;

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

@@ -1,4 +1,4 @@
-package parser;
+package parser.astBuilder;
 
 import ast.*;
 import ast.expression.BinaryExpressionNode;

src/main/java/parser/astBuilder/ClassVisitor.java

@@ -0,0 +1,46 @@
+package parser.astBuilder;
+
+import ast.*;
+import ast.member.*;
+import ast.type.*;
+import parser.generated.SimpleJavaBaseVisitor;
+import parser.generated.SimpleJavaParser;
+
+public class ClassVisitor extends SimpleJavaBaseVisitor<ASTNode> {
+    @Override
+    public ASTNode visitClassDeclaration(SimpleJavaParser.ClassDeclarationContext ctx) {
+        ClassNode classNode = new ClassNode((AccessTypeNode) visit(ctx.accessType()), ctx.IDENTIFIER().getText());
+        classNode.identifier = ctx.IDENTIFIER().getText();
+        for (SimpleJavaParser.MemberDeclarationContext member : ctx.memberDeclaration()) {
+            classNode.addMember((MemberNode) visit(member));
+        }
+        classNode.ensureConstructor();
+        return classNode;
+    }
+
+    @Override
+    public ASTNode visitFieldDeclaration(SimpleJavaParser.FieldDeclarationContext ctx) {
+        AccessTypeNode accessType = (AccessTypeNode) visit(ctx.accessType());
+        TypeNode type = (TypeNode) visit(ctx.type());
+        String identifier = ctx.IDENTIFIER().getText();
+        return new FieldNode(accessType, type, identifier);
+    }
+
+    @Override
+    public ASTNode visitMethodDeclaration(SimpleJavaParser.MethodDeclarationContext ctx) {
+        return new MethodVisitor().visitMethodDeclaration(ctx);
+    }
+
+    @Override
+    public ASTNode visitAccessType(SimpleJavaParser.AccessTypeContext ctx) {
+        String typeStr = ctx.getText();
+        switch (typeStr) {
+            case "public":
+                return new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+            case "private":
+                return new AccessTypeNode(EnumAccessTypeNode.PRIVATE);
+            default:
+                throw new IllegalArgumentException("Unsupported type: " + typeStr);
+        }
+    }
+}

src/main/java/parser/astBuilder/ExpressionVisitor.java

@@ -0,0 +1,38 @@
+package parser.astBuilder;
+
+import ast.ASTNode;
+import ast.expression.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+import parser.generated.SimpleJavaBaseVisitor;
+import parser.generated.SimpleJavaParser;
+
+public class ExpressionVisitor extends SimpleJavaBaseVisitor<ASTNode> {
+    @Override
+    public ASTNode visitExpression(SimpleJavaParser.ExpressionContext ctx) {
+        // Handle binary operations
+        if (ctx.getChildCount() == 3 && ctx.getChild(1) instanceof TerminalNode) {
+            ExpressionNode left = (ExpressionNode) visit(ctx.expression(0));
+            ExpressionNode right = (ExpressionNode) visit(ctx.expression(1));
+            String operator = ctx.getChild(1).getText();
+            return new BinaryExpressionNode(left, right, operator);
+        }
+        // Handle unary operations
+        else if (ctx.getChildCount() == 2) {
+            String operator = ctx.getChild(0).getText();
+            ExpressionNode expression = (ExpressionNode) visit(ctx.expression(0));
+            return new UnaryExpressionNode(expression, operator);
+        }
+        // Handle parentheses
+        else if (ctx.getChildCount() == 3 && ctx.getChild(0).getText().equals("(")) {
+            return visit(ctx.expression(0));  // Simply return the inner expression
+        }
+        // Handle literals and identifiers
+        else if (ctx.literal() != null) {
+            return visit(ctx.literal());
+        } else if (ctx.IDENTIFIER() != null) {
+            return new IdentifierExpressionNode(ctx.IDENTIFIER().getText());
+        }
+
+        return null;  // Return null or throw an exception if no valid expression found
+    }
+}

src/main/java/parser/astBuilder/MethodVisitor.java

@@ -0,0 +1,44 @@
+package parser.astBuilder;
+
+import ast.*;
+import ast.member.MethodNode;
+import ast.parameter.*;
+import ast.statement.*;
+import ast.type.*;
+import parser.generated.SimpleJavaBaseVisitor;
+import parser.generated.SimpleJavaParser;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MethodVisitor extends SimpleJavaBaseVisitor<ASTNode> {
+    @Override
+    public ASTNode visitMethodDeclaration(SimpleJavaParser.MethodDeclarationContext ctx) {
+        AccessTypeNode accessType = (AccessTypeNode) visit(ctx.accessType());
+        TypeNode returnType = (TypeNode) visit(ctx.type());
+        String methodName = ctx.IDENTIFIER().getText();
+        ParameterListNode parameterListNode = (ParameterListNode) visit(ctx.parameterList());
+        List<StatementNode> statements = new ArrayList<>();
+        for (SimpleJavaParser.StatementContext stmtCtx : ctx.statement()) {
+            statements.add((StatementNode) visit(stmtCtx));
+        }
+
+        return new MethodNode(accessType, returnType, methodName, parameterListNode, statements);
+    }
+
+    @Override
+    public ASTNode visitParameterList(SimpleJavaParser.ParameterListContext ctx) {
+        List<ParameterNode> parameters = new ArrayList<>();
+        for (SimpleJavaParser.ParameterContext paramCtx : ctx.parameter()) {
+            parameters.add((ParameterNode) visitParameter(paramCtx));
+        }
+        return new ParameterListNode(parameters);
+    }
+
+    @Override
+    public ASTNode visitParameter(SimpleJavaParser.ParameterContext ctx) {
+        TypeNode type = (TypeNode) visit(ctx.type());
+        String identifier = ctx.IDENTIFIER().getText();
+        return new ParameterNode(type, identifier);
+    }
+}

src/main/java/parser/astBuilder/StatementVisitor.java

@@ -0,0 +1,72 @@
+package parser.astBuilder;
+
+import ast.*;
+import ast.statement.*;
+import ast.expression.*;
+import ast.type.*;
+import parser.generated.SimpleJavaBaseVisitor;
+import parser.generated.SimpleJavaParser;
+
+public class StatementVisitor extends SimpleJavaBaseVisitor<ASTNode> {
+    @Override
+    public ASTNode visitStatement(SimpleJavaParser.StatementContext ctx) {
+        if (ctx.variableDeclarationStatement() != null) {
+            return visitVariableDeclarationStatement(ctx.variableDeclarationStatement());
+        } else if (ctx.assignmentStatement() != null) {
+            return visitAssignmentStatement(ctx.assignmentStatement());
+        } else if (ctx.ifStatement() != null) {
+            return visitIfStatement(ctx.ifStatement());
+        } else if (ctx.whileStatement() != null) {
+            return visitWhileStatement(ctx.whileStatement());
+        } else if (ctx.returnStatement() != null) {
+            return visitReturnStatement(ctx.returnStatement());
+        }
+
+        return null;
+    }
+
+    @Override
+    public ASTNode visitVariableDeclarationStatement(SimpleJavaParser.VariableDeclarationStatementContext ctx) {
+        TypeNode type = (TypeNode) visit(ctx.type());
+        String identifier = ctx.IDENTIFIER().getText();
+        ExpressionNode expression = null;
+        if (ctx.expression() != null) {
+            expression = (ExpressionNode) visit(ctx.expression());
+        }
+        return new VariableDeclarationStatementNode(type, identifier, expression);
+    }
+
+    @Override
+    public ASTNode visitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx) {
+        VarNode identifier = (VarNode) visit(ctx.var());
+        ExpressionNode expression = (ExpressionNode) visit(ctx.expression());
+        return new AssignmentStatementNode(identifier, expression);
+    }
+
+    @Override
+    public ASTNode visitIfStatement(SimpleJavaParser.IfStatementContext ctx) {
+        ExpressionNode condition = (ExpressionNode) visit(ctx.expression());
+        StatementNode thenStatement = (StatementNode) visit(ctx.statement(0)); // The 'then' branch
+        StatementNode elseStatement = null;
+        if (ctx.statement().size() > 1) {
+            elseStatement = (StatementNode) visit(ctx.statement(1)); // The 'else' branch, if present
+        }
+        return new IfStatementNode(condition, thenStatement, elseStatement);
+    }
+
+    @Override
+    public ASTNode visitWhileStatement(SimpleJavaParser.WhileStatementContext ctx) {
+        ExpressionNode condition = (ExpressionNode) visit(ctx.expression());  // Visit the condition part of the while statement
+        StatementNode body = (StatementNode) visit(ctx.statement());  // Visit the body part of the while statement
+        return new WhileStatementNode(condition, body);
+    }
+
+    @Override
+    public ASTNode visitReturnStatement(SimpleJavaParser.ReturnStatementContext ctx) {
+        ExpressionNode expression = null;
+        if (ctx.expression() != null) {
+            expression = (ExpressionNode) visit(ctx.expression());  // Visit the expression part of the return statement, if it exists
+        }
+        return new ReturnStatementNode(expression);
+    }
+}