diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGen.java b/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
index 57aeecc3..f24bb3fd 100644
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
@@ -55,6 +55,7 @@ public class BytecodeGen implements ASTVisitor {
@Override
public void visit(SourceFile sourceFile) {
for(ClassOrInterface cl : sourceFile.getClasses()) {
+ System.out.println("in Class: " + cl.getClassName().toString());
BytecodeGen classGen = new BytecodeGen(classFiles, resultSet);
cl.accept(classGen);
classGen.writeClass(cl.getClassName().toString());
@@ -183,7 +184,8 @@ public class BytecodeGen implements ASTVisitor {
System.out.println(sig);
NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
methDesc = meth.accept(new DescriptorToString(resultSet));
- MethodVisitor mv = cw.visitMethod(acc, method.getName(), methDesc, sig, null);
+ System.out.println(methDesc);
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
mv.visitCode();
diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
index c5480ac0..df714015 100644
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
@@ -43,30 +43,28 @@ public class BytecodeGenMethod implements StatementVisitor{
private MethodVisitor mv;
private HashMap<String, Integer> paramsAndLocals = new HashMap<>();
private String className;
- private int lamCounter;
+ private int lamCounter = -1;
private ClassWriter cw;
private ResultSet resultSet;
private boolean isInterface;
HashMap<String, String> genericsAndBoundsMethod;
private HashMap<String,String> genericsAndBounds;
+ private boolean isBinaryExp = false;
//for tests **
private String fieldName;
private String fieldDesc;
private Expression rightSideTemp;
-// private String where;
private boolean isRightSideALambda = false;
private KindOfLambda kindOfLambda;
private HashMap<String, byte[]> classFiles;
- private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface;
+ private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface = new ArrayList<>();;
public BytecodeGenMethod(String className,ResultSet resultSet, Method m, MethodVisitor mv,
HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod,
HashMap<String,String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles) {
-// this.where = "<<<<<< NORMAL METHOD >>>>>>";
-
this.className = className;
this.resultSet = resultSet;
this.m = m;
@@ -77,9 +75,6 @@ public class BytecodeGenMethod implements StatementVisitor{
this.genericsAndBounds = genericsAndBounds;
this.isInterface = isInterface;
this.classFiles = classFiles;
- this.lamCounter = -1;
-
- this.varsFunInterface = new ArrayList<>();
if(!isInterface)
this.m.block.accept(this);
@@ -89,13 +84,10 @@ public class BytecodeGenMethod implements StatementVisitor{
public BytecodeGenMethod(LambdaExpression lambdaExpression,ResultSet resultSet ,MethodVisitor mv,
int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles) {
-// this.where = "<<<<<< LAMBDA METHOD >>>>>>";
this.resultSet = resultSet;
this.mv = mv;
this.isInterface = isInterface;
this.classFiles = classFiles;
- this.lamCounter = -1;
- this.varsFunInterface = new ArrayList<>();
Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
int i = indexOfFirstParamLam;
@@ -124,50 +116,61 @@ public class BytecodeGenMethod implements StatementVisitor{
public void visit(SuperCall superCall) {
superCall.receiver.accept(this);
superCall.arglist.accept(this);
-// mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", superCall.name, desc,false);
mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Object.class), superCall.name, "()V",isInterface);
}
// ??
@Override
public void visit(LocalVar localVar) {
-// System.out.println("in Local Var: " + localVar.name);
mv.visitVarInsn(Opcodes.ALOAD, paramsAndLocals.get(localVar.name));
+ if(isBinaryExp) {
+ getVlaue(getResolvedType(localVar.getType()));
+ }
}
// ??
@Override
public void visit(LocalVarDecl localVarDecl) {
-// Integer i;
-// paramsAndLocals.put(localVarDecl.getName(), paramsAndLocals.size()+1);
-// System.out.println("In localVarDecl :: "+localVarDecl.getName());
+
}
@Override
public void visit(Assign assign) {
-// System.out.println("Assign : \nright = "+assign.rightSide + "\nLeft = " + assign.lefSide);
-
// if the right side is a lambda => the left side must be a functional interface
- if(assign.rightSide.getClass().equals(LambdaExpression.class)) {
+ if(assign.rightSide instanceof LambdaExpression) {
isRightSideALambda = true;
}else {
isRightSideALambda = false;
}
- if(assign.lefSide.getClass().equals(AssignToField.class)) {
+ if(assign.rightSide instanceof BinaryExpr)
+ isBinaryExp = true;
+
+ if(assign.lefSide instanceof AssignToField) {
// load_0, ldc or .. then putfield
this.rightSideTemp = assign.rightSide;
- assign.lefSide.accept(this);
}else {
assign.rightSide.accept(this);
- assign.lefSide.accept(this);
}
+ if(isBinaryExp) {
+ doAssign(getResolvedType(assign.lefSide.getType()));
+ isBinaryExp = false;
+ }
+ assign.lefSide.accept(this);
}
@Override
-
public void visit(BinaryExpr binary) {
- System.out.println("\t++ In Binary: ");
+ binary.lexpr.accept(this);
+ binary.rexpr.accept(this);
+ switch (binary.operation.toString()) {
+ case "ADD":
+ mv.visitInsn(Opcodes.IADD);
+ break;
+ default:
+ break;
+ }
+
}
@Override
@@ -236,7 +239,7 @@ public class BytecodeGenMethod implements StatementVisitor{
cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup",
Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL);
- generateBCForFunN(lambdaExpression,typeErasure);
+// generateBCForFunN(lambdaExpression,typeErasure);
}
private void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc) {
@@ -318,7 +321,7 @@ public class BytecodeGenMethod implements StatementVisitor{
@Override
public void visit(IfStmt ifStmt) {
-
+ System.out.println("If");
}
@Override
@@ -329,12 +332,6 @@ public class BytecodeGenMethod implements StatementVisitor{
@Override
public void visit(MethodCall methodCall) {
-// if(methodCall.receiver instanceof ExpressionReceiver){
-// System.out.print(((ExpressionReceiver) methodCall.receiver).expr + "\n");
-// }else{
-// System.out.print(((StaticClassName) methodCall.receiver).getType().toString() + "\n");
-// }
-
methodCall.receiver.accept(this);
methodCall.arglist.accept(this);
@@ -342,8 +339,6 @@ public class BytecodeGenMethod implements StatementVisitor{
genericsAndBoundsMethod,genericsAndBounds);
String mDesc = method.accept(new DescriptorToString(resultSet));
-// System.out.println("is Vars empty: "+varsFunInterface.isEmpty());
-
// is methodCall.receiver functional Interface)?
if(varsFunInterface.contains(methodCall.receiver.getType())) {
mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()),
@@ -360,8 +355,6 @@ public class BytecodeGenMethod implements StatementVisitor{
@Override
public void visit(NewClass methodCall) {
-// System.out.println("In NewClass: ");
-// System.out.println("\t\tname: " + methodCall.name + " *** " + "Receiver: " + methodCall.receiver);
mv.visitTypeInsn(Opcodes.NEW, methodCall.name.replace(".", "/"));
mv.visitInsn(Opcodes.DUP);
@@ -389,7 +382,7 @@ public class BytecodeGenMethod implements StatementVisitor{
@Override
public void visit(UnaryExpr unaryExpr) {
- throw new NotImplementedException();
+ System.out.println(unaryExpr.operation.toString());
}
@Override
@@ -435,7 +428,202 @@ public class BytecodeGenMethod implements StatementVisitor{
@Override
public void visit(Literal literal) {
- mv.visitLdcInsn(getResolvedType(literal.getType()));
+ Object value = literal.value;
+ String typeOfLiteral = resultSet.resolveType(literal.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+ if(this.isBinaryExp) {
+ getVlaue(typeOfLiteral);
+ }else {
+ doAssign(typeOfLiteral, value);
+ }
+
+
+ }
+
+ private void getVlaue(String typeOfLiteral) {
+ switch (typeOfLiteral) {
+ case "java/lang/String":
+ break;
+ case "java/lang/Boolean":
+ break;
+ case "java/lang/Byte":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf",
+ "(B)Ljava/lang/Byte;", false);
+ break;
+ case "java/lang/Short":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf",
+ "(S)Ljava/lang/Short;", false);
+ break;
+ case "java/lang/Integer":
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue",
+ "()I", false);
+ break;
+ case "java/lang/Long":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf",
+ "(J)Ljava/lang/Long;", false);
+ break;
+ case "java/lang/Float":
+ break;
+ case "java/lang/Double":
+ break;
+ case "java/lang/Character":
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void doAssign(String type, Object value) {
+ switch (type) {
+ case "java/lang/String":
+ mv.visitLdcInsn(String.valueOf(value));
+ break;
+ case "java/lang/Boolean":
+ visitBooleanLiteral((Boolean) value);
+ break;
+ case "java/lang/Byte":
+ visitByteLiteral(((Double) value).byteValue(),false);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf",
+ "(B)Ljava/lang/Byte;", false);
+ break;
+ case "java/lang/Short":
+ visitShortLiteral(((Double) value).shortValue(),false);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf",
+ "(S)Ljava/lang/Short;", false);
+ break;
+ case "java/lang/Integer":
+ //zweite Argument isLong
+ visitIntegerLiteral(((Double) value).intValue(), false);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf",
+ "(I)Ljava/lang/Integer;", false);
+ break;
+ case "java/lang/Long":
+ visitLongLiteral(((Double) value).longValue(), true);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf",
+ "(J)Ljava/lang/Long;", false);
+ break;
+ case "java/lang/Float":
+ visitFloatLiteral(((Double) value).floatValue());
+ break;
+ case "java/lang/Double":
+ visitDoubleLiteral((Double) value);
+ break;
+ case "java/lang/Character":
+ visitCharLiteral((Character) value);
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void doAssign(String type) {
+ switch (type) {
+ case "java/lang/String":
+ break;
+ case "java/lang/Boolean":
+ break;
+ case "java/lang/Byte":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf",
+ "(B)Ljava/lang/Byte;", false);
+ break;
+ case "java/lang/Short":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf",
+ "(S)Ljava/lang/Short;", false);
+ break;
+ case "java/lang/Integer":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf",
+ "(I)Ljava/lang/Integer;", false);
+ break;
+ case "java/lang/Long":
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf",
+ "(J)Ljava/lang/Long;", false);
+ break;
+ case "java/lang/Float":
+ break;
+ case "java/lang/Double":
+ break;
+ case "java/lang/Character":
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void visitCharLiteral(Character value) {
+ mv.visitIntInsn(Opcodes.BIPUSH, (int) value);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Character", "valueOf",
+ "(C)Ljava/lang/Character;", false);
+ }
+
+ private void visitDoubleLiteral(Double value) {
+ if(value == 0) {
+ mv.visitInsn(Opcodes.DCONST_0);
+ }else if(value == 1) {
+ mv.visitInsn(Opcodes.DCONST_1);
+ }else {
+ mv.visitLdcInsn(value);
+ }
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Double", "valueOf",
+ "(D)Ljava/lang/Double;", false);
+ }
+
+ private void visitFloatLiteral(Float value) {
+ if(value.intValue()>-1 && value.intValue() < 3) {
+ //Opcodes.FCONST_0 = 11, Opcodes.FCONST_1 = 12, usw
+ mv.visitInsn(value.intValue()+11);
+ }else {
+ mv.visitLdcInsn(value);
+ }
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Float", "valueOf",
+ "(F)Ljava/lang/Float;", false);
+ }
+
+ private void visitLongLiteral(Long value, boolean isLong) {
+ if(value<Math.pow(2, 15) || (value>=-Math.pow(2, 15))&&value<-128) {
+ visitShortLiteral(value.shortValue(),isLong);
+ }else {
+ mv.visitLdcInsn(value);
+ }
+ }
+
+ private void visitShortLiteral(Short value,boolean isLong) {
+ if(value< 128 || (value>-129 && value<-1)) {
+ visitByteLiteral(value.byteValue(), isLong);
+ }else if(value<Math.pow(2, 15) || (value>=-Math.pow(2, 15))&&value<-128) {
+ mv.visitIntInsn(Opcodes.SIPUSH, value);
+ }
+ }
+
+ private void visitByteLiteral(Byte value, boolean isLong) {
+
+ if(!isLong && value<6 && value>-1) {
+ //Opcodes.ICONST_0 = 3, Opcodes.ICONST_1 = 4, usw
+ mv.visitInsn(value+3);
+ }else if(isLong && value>-1 && value<2){
+ //Opcodes.LCONST_0 = 9, Opcodes.LCONST_1 = 10
+ mv.visitInsn(value+9);
+ }else {
+ mv.visitIntInsn(Opcodes.BIPUSH, value);
+ }
+
+ }
+
+ private void visitIntegerLiteral(Integer value, boolean isLong) {
+
+ if(value<Math.pow(2, 15) || (value>=-Math.pow(2, 15))&&value<-128) {
+ visitShortLiteral(value.shortValue(),isLong);
+ }else {
+ mv.visitLdcInsn(value);
+ }
+ }
+
+ private void visitBooleanLiteral(Boolean b) {
+ if(b) {
+ mv.visitInsn(Opcodes.ICONST_1);
+ }else {
+ mv.visitInsn(Opcodes.ICONST_0);
+ }
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Boolean", "valueOf",
+ "(Z)Ljava/lang/Boolean;", false);
}
@Override
diff --git a/src/de/dhbwstuttgart/bytecode/signature/Signature.java b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
index fc9e2191..f9bcb369 100644
--- a/src/de/dhbwstuttgart/bytecode/signature/Signature.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
@@ -132,9 +132,10 @@ public class Signature {
break;
case "TPH":
RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
- sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
+ if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH "))
+ sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
// sv.visitClassType(r.acceptTV(new TypeToSignature()));
-// System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+ System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
break;
default:
if(!isParameterType)
diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java
index 1586ba3f..5310d13b 100644
--- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java
+++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java
@@ -7,6 +7,7 @@ import de.dhbwstuttgart.parser.scope.GenericsRegistry;
import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.statement.*;
+import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr.Operation;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
@@ -278,13 +279,14 @@ public class StatementGenerator {
}
private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
- //TODO
- throw new NotImplementedException();
+ Expression argument = convert(stmt.unaryExpression());
+ Token offset = stmt.getStart();
+ return new UnaryExpr(UnaryExpr.Operation.PREINCREMENT, argument, TypePlaceholder.fresh(offset), offset);
}
- private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
- //TODO
- throw new NotImplementedException();
+ private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
+ return new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, convert(stmt.unaryExpression()),
+ TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
}
private Statement convert(Java8Parser.PostIncrementExpressionContext stmt) {
@@ -293,8 +295,8 @@ public class StatementGenerator {
}
private Statement convert(Java8Parser.PostDecrementExpressionContext stmt) {
- //TODO
- throw new NotImplementedException();
+ return new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, convert(stmt.postfixExpression()),
+ TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
}
private Statement convert(Java8Parser.AssignmentContext stmt) {
@@ -599,8 +601,31 @@ public class StatementGenerator {
}
private BinaryExpr.Operator convertBinaryOperator(String operator) {
-
- return null;
+ //return BinaryExpr.Operator.ADD;
+ if(operator.equals("+")) {
+ return BinaryExpr.Operator.ADD;
+ }else if(operator.equals("-")) {
+ return BinaryExpr.Operator.SUB;
+ }else if(operator.equals("*")) {
+ return BinaryExpr.Operator.MUL;
+ }else if(operator.equals("&")) {
+ return BinaryExpr.Operator.AND;
+ }else if(operator.equals("|")) {
+ return BinaryExpr.Operator.OR;
+ }else if(operator.equals("/")) {
+ return BinaryExpr.Operator.DIV;
+ }else if(operator.equals("<")) {
+ return BinaryExpr.Operator.LESSTHAN;
+ }else if(operator.equals(">")) {
+ return BinaryExpr.Operator.BIGGERTHAN;
+ }else if(operator.equals(">=")) {
+ return BinaryExpr.Operator.BIGGEREQUAL;
+ } else if(operator.equals("<=")) {
+ return BinaryExpr.Operator.LESSEQUAL;
+ } else {
+ throw new NotImplementedException();
+ }
+// throw new NotImplementedException();
}
private Expression convert(Java8Parser.ShiftExpressionContext expression) {
@@ -612,12 +637,15 @@ public class StatementGenerator {
}
private Expression convert(Java8Parser.AdditiveExpressionContext expression) {
- if(expression.additiveExpression() != null){
- return convert(expression.additiveExpression());
- }else if(expression.multiplicativeExpression() != null){
+
+ if(expression.additiveExpression() == null){
return convert(expression.multiplicativeExpression());
- }else{
- throw new NotImplementedException();
+ }else {
+ Expression leftSide = convert(expression.additiveExpression());
+ Expression rightSide = convert(expression.multiplicativeExpression());
+ BinaryExpr.Operator op = convertBinaryOperator(expression.getChild(1).getText());
+ Token offset = expression.getStart();
+ return new BinaryExpr(op, TypePlaceholder.fresh(expression.getStart()), leftSide, rightSide, offset);
}
}
@@ -625,7 +653,11 @@ public class StatementGenerator {
if(expression.multiplicativeExpression() == null){
return convert(expression.unaryExpression());
}else{
- throw new NotImplementedException();
+ Expression leftSide = convert(expression.multiplicativeExpression());
+ Expression rightSide = convert(expression.unaryExpression());
+ BinaryExpr.Operator op = convertBinaryOperator(expression.getChild(1).getText());
+ Token offset = expression.getStart();
+ return new BinaryExpr(op, TypePlaceholder.fresh(offset), leftSide, rightSide, offset);
}
}
@@ -793,7 +825,9 @@ public class StatementGenerator {
}else if(literal.CharacterLiteral() != null){
RefType type = new RefType(reg.getName("java.lang.Character"),literal.getStart());
return new Literal(type,
- literal.CharacterLiteral().getText().charAt(0),
+ // das gibt immer ' zurück, der Char befindet sich in Position 1
+ //literal.CharacterLiteral().getText().charAt(0),
+ literal.CharacterLiteral().getText().charAt(1),
literal.getStart());
}else if(literal.StringLiteral()!=null){
RefType type = new RefType(reg.getName("java.lang.String"),literal.getStart());
diff --git a/test/bytecode/AssignToLit.jav b/test/bytecode/AssignToLit.jav
new file mode 100644
index 00000000..873828ed
--- /dev/null
+++ b/test/bytecode/AssignToLit.jav
@@ -0,0 +1,30 @@
+import java.lang.Integer;
+import java.lang.Boolean;
+import java.lang.String;
+import java.lang.Byte;
+import java.lang.Short;
+import java.lang.Long;
+import java.lang.Float;
+import java.lang.Double;
+import java.lang.Character;
+
+class AssignToLit {
+ void m(){
+// String s = "Test";
+// Boolean b = false;
+// Byte byte1 = 5;
+// Byte byte2 = 55;
+// Short short1 = 5;
+// Short short2 = 55;
+// Integer int1 = 5;
+// Integer int2 = 8888888;
+// Long long1 = 1;
+// Long long2 = 5;
+// Long long3 = 89989898;
+// Float float1 = 1;
+// Float float2 = 55;
+// Double d1 = 1;
+// Double d2 = 55;
+ Character c = 'A';
+ }
+}
\ No newline at end of file
diff --git a/test/bytecode/AssignToLitTest.java b/test/bytecode/AssignToLitTest.java
new file mode 100644
index 00000000..dc5d397b
--- /dev/null
+++ b/test/bytecode/AssignToLitTest.java
@@ -0,0 +1,7 @@
+package bytecode;
+
+public class AssignToLitTest extends JavaTXCompilerTest {
+ public AssignToLitTest() {
+ this.fileName = "AssignToLit";
+ }
+}
diff --git a/test/bytecode/Example.jav b/test/bytecode/Example.jav
index 8fc7a0a7..b7455a3f 100644
--- a/test/bytecode/Example.jav
+++ b/test/bytecode/Example.jav
@@ -1,7 +1,9 @@
+import java.lang.String;
+
public class Example {
- public m(Integer x) {
-// String x = "X";
+ public m() {
+ String x = "X";
return x;
}
}
\ No newline at end of file
diff --git a/test/bytecode/For.jav b/test/bytecode/For.jav
index c93b34c4..c4bd6677 100644
--- a/test/bytecode/For.jav
+++ b/test/bytecode/For.jav
@@ -1,13 +1,30 @@
+import java.lang.Integer;
+import java.lang.Boolean;
+
class For{
- m(Integer x){
- Boolean b = true;
- while(x<2){
- x = x +1;
- b = false;
- }
- return x;
+ Integer m(Integer x){
+ var c = x + 2;
+// Boolean b = true;
+// c = 5;
+// c++;
+// ++c;
+// c--;
+// --c;
+// while(x<2){
+// x = x +1;
+// b = false;
+// }
+ return c;
// for(int i = 0;i<10;i++) {
// x = x + 5;
// }
}
+
+// m2(Integer x){
+// if(x<2) {
+// return 1;
+// }else {
+// return 2;
+// }
+// }
}
\ No newline at end of file
diff --git a/test/bytecode/ForTest.java b/test/bytecode/ForTest.java
index 7df68665..c95138d3 100644
--- a/test/bytecode/ForTest.java
+++ b/test/bytecode/ForTest.java
@@ -1,5 +1,7 @@
package bytecode;
+import org.objectweb.asm.Opcodes;
+
public class ForTest extends JavaTXCompilerTest {
public ForTest() {
diff --git a/test/bytecode/JavaTXCompilerTest.java b/test/bytecode/JavaTXCompilerTest.java
index 2f832962..623fc96e 100644
--- a/test/bytecode/JavaTXCompilerTest.java
+++ b/test/bytecode/JavaTXCompilerTest.java
@@ -67,7 +67,7 @@ public class JavaTXCompilerTest {
byte[] bytecode = classFiles.get(name);
try {
System.out.println("generating "+name+ ".class file ...");
- output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/examples/" +name+".class"));
+ output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
output.write(bytecode);
output.close();
System.out.println(name+".class file generated");
diff --git a/test/bytecode/LamAssign.jav b/test/bytecode/LamAssign.jav
index 4a4f4f73..82bb31b1 100644
--- a/test/bytecode/LamAssign.jav
+++ b/test/bytecode/LamAssign.jav
@@ -9,3 +9,7 @@ class LamAssign {
return lam1;
}
}
+
+interface Fun1<A,B>{
+ public A apply(B b);
+}
\ No newline at end of file
diff --git a/test/bytecode/Methods.jav b/test/bytecode/Methods.jav
new file mode 100644
index 00000000..3c46739d
--- /dev/null
+++ b/test/bytecode/Methods.jav
@@ -0,0 +1,14 @@
+import java.lang.Integer;
+
+class Methods {
+
+ m(a,b){
+ var c=a+b;
+ return c;
+ }
+
+ method2(x){
+ Integer i = this.m(x,2);
+ return i;
+ }
+}
\ No newline at end of file
diff --git a/test/bytecode/MethodsTest.java b/test/bytecode/MethodsTest.java
new file mode 100644
index 00000000..11195b71
--- /dev/null
+++ b/test/bytecode/MethodsTest.java
@@ -0,0 +1,7 @@
+package bytecode;
+
+public class MethodsTest extends JavaTXCompilerTest {
+ public MethodsTest() {
+ this.fileName = "Methods";
+ }
+}
diff --git a/test/bytecode/Op.jav b/test/bytecode/Op.jav
new file mode 100644
index 00000000..9c05b0a2
--- /dev/null
+++ b/test/bytecode/Op.jav
@@ -0,0 +1,12 @@
+import java.lang.Integer;
+
+class Op {
+ m(Integer a, Integer b) {
+ Integer c = a+b;
+// d = a-b;
+// e = a*b;
+// f = a/b;
+
+ return c;
+ }
+}
\ No newline at end of file
diff --git a/test/bytecode/OpTest.java b/test/bytecode/OpTest.java
new file mode 100644
index 00000000..cd8fee06
--- /dev/null
+++ b/test/bytecode/OpTest.java
@@ -0,0 +1,7 @@
+package bytecode;
+
+public class OpTest extends JavaTXCompilerTest {
+ public OpTest() {
+ this.fileName = "Op";
+ }
+}
diff --git a/test/parser/GeneralParserTest.java b/test/parser/GeneralParserTest.java
index c48e1320..b218347f 100644
--- a/test/parser/GeneralParserTest.java
+++ b/test/parser/GeneralParserTest.java
@@ -41,7 +41,8 @@ public class GeneralParserTest{
filenames.add("FieldVarTest.jav");
filenames.add("StructuralTypes.jav");
*/
- filenames.add("ExtendsTest.jav");
+// filenames.add("ExtendsTest.jav");
+ filenames.add("OpratorTest.jav");
try{
new JavaTXCompiler(filenames.stream().map(s -> new File(rootDirectory + s)).collect(Collectors.toList()));
}catch(Exception exc){
diff --git a/test/parser/OpratorTest.jav b/test/parser/OpratorTest.jav
new file mode 100644
index 00000000..2764adf4
--- /dev/null
+++ b/test/parser/OpratorTest.jav
@@ -0,0 +1,12 @@
+import java.lang.Integer;
+
+class OpratorTest {
+ m(Integer a, Integer b) {
+ c = a+b;
+// d = a-b;
+// e = a*b;
+// f = a/b;
+
+ return c;
+ }
+}
\ No newline at end of file