From 6d3e1f859e1fabd93b82a4e802473953e23fb1a6 Mon Sep 17 00:00:00 2001 From: i22007 Date: Thu, 4 Jul 2024 11:20:10 -0400 Subject: [PATCH] Increment/Decrement assign --- .../crementexpressions/DecrementNode.java | 7 +- .../crementexpressions/IncrementNode.java | 8 +- .../ChainedMethodNode.java | 5 - src/main/java/bytecode/ClassCodeGen.java | 2 +- src/main/java/bytecode/Mapper.java | 9 +- src/main/java/bytecode/MethodCodeGen.java | 258 ++++++++++++++---- .../java/bytecode/visitor/ClassVisitor.java | 1 - .../java/bytecode/visitor/MethodVisitor.java | 4 +- 8 files changed, 229 insertions(+), 65 deletions(-) diff --git a/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java b/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java index 8308e07..175c6f4 100644 --- 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); + } } diff --git a/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java b/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java index d736d3f..7e9240d 100644 --- 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); + } } diff --git a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java index ae01b85..1d2f0ab 100644 --- 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; diff --git a/src/main/java/bytecode/ClassCodeGen.java b/src/main/java/bytecode/ClassCodeGen.java index e7475f1..2173158 100644 --- 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; diff --git a/src/main/java/bytecode/Mapper.java b/src/main/java/bytecode/Mapper.java index 0c842ba..0ddd1af 100644 --- 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 parameters) { + public String generateMethodDescriptor(ITypeNode type, List 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; } diff --git a/src/main/java/bytecode/MethodCodeGen.java b/src/main/java/bytecode/MethodCodeGen.java index 2744732..83e53f4 100644 --- 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, "", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID),parameterNodes), false); - localVariables.add(newDeclarationNode.identifier); + methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "", 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 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); } } diff --git a/src/main/java/bytecode/visitor/ClassVisitor.java b/src/main/java/bytecode/visitor/ClassVisitor.java index af6af4b..3b39422 100644 --- 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); } diff --git a/src/main/java/bytecode/visitor/MethodVisitor.java b/src/main/java/bytecode/visitor/MethodVisitor.java index 89fbb64..f63400c 100644 --- 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);