diff --git a/.gitignore b/.gitignore index 8ad5607a..13bec8df 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,8 @@ bin .classpath *.iml .idea/ +/target/ .DS_Store .project .settings/ + diff --git a/src/de/dhbwstuttgart/.DS_Store b/src/de/dhbwstuttgart/.DS_Store new file mode 100644 index 00000000..f20299e8 Binary files /dev/null and b/src/de/dhbwstuttgart/.DS_Store differ diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGenLambda.java b/src/de/dhbwstuttgart/bytecode/BytecodeGenLambda.java new file mode 100644 index 00000000..4b1557b0 --- /dev/null +++ b/src/de/dhbwstuttgart/bytecode/BytecodeGenLambda.java @@ -0,0 +1,227 @@ +package de.dhbwstuttgart.bytecode; + +import org.objectweb.asm.MethodVisitor; + +import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal; +import de.dhbwstuttgart.syntaxtree.StatementVisitor; +import de.dhbwstuttgart.syntaxtree.statement.ArgumentList; +import de.dhbwstuttgart.syntaxtree.statement.Assign; +import de.dhbwstuttgart.syntaxtree.statement.AssignToField; +import de.dhbwstuttgart.syntaxtree.statement.Binary; +import de.dhbwstuttgart.syntaxtree.statement.Block; +import de.dhbwstuttgart.syntaxtree.statement.CastExpr; +import de.dhbwstuttgart.syntaxtree.statement.DoStmt; +import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt; +import de.dhbwstuttgart.syntaxtree.statement.FieldVar; +import de.dhbwstuttgart.syntaxtree.statement.ForStmt; +import de.dhbwstuttgart.syntaxtree.statement.IfStmt; +import de.dhbwstuttgart.syntaxtree.statement.InstanceOf; +import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression; +import de.dhbwstuttgart.syntaxtree.statement.LocalVar; +import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl; +import de.dhbwstuttgart.syntaxtree.statement.MethodCall; +import de.dhbwstuttgart.syntaxtree.statement.NewArray; +import de.dhbwstuttgart.syntaxtree.statement.NewClass; +import de.dhbwstuttgart.syntaxtree.statement.Receiver; +import de.dhbwstuttgart.syntaxtree.statement.Return; +import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid; +import de.dhbwstuttgart.syntaxtree.statement.StaticClassName; +import de.dhbwstuttgart.syntaxtree.statement.Super; +import de.dhbwstuttgart.syntaxtree.statement.SuperCall; +import de.dhbwstuttgart.syntaxtree.statement.This; +import de.dhbwstuttgart.syntaxtree.statement.UnaryPlus; +import de.dhbwstuttgart.syntaxtree.statement.WhileStmt; +import de.dhbwstuttgart.syntaxtree.statement.literal.Literal; +import de.dhbwstuttgart.syntaxtree.statement.literal.Null; + +public class BytecodeGenLambda implements StatementVisitor{ + private LambdaExpression lambdaExpression; + private MethodVisitor mv; + + public BytecodeGenLambda(LambdaExpression lambdaExpression, MethodVisitor mv) { + this.lambdaExpression = lambdaExpression; + this.mv = mv; + + + } + + @Override + public void visit(ArgumentList argumentList) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(LambdaExpression lambdaExpression) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Assign assign) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Binary binary) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Block block) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(CastExpr castExpr) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(EmptyStmt emptyStmt) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(FieldVar fieldVar) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(ForStmt forStmt) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(IfStmt ifStmt) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(InstanceOf instanceOf) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(LocalVar localVar) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(LocalVarDecl localVarDecl) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(MethodCall methodCall) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(NewClass methodCall) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(NewArray newArray) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Receiver receiver) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Return aReturn) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(ReturnVoid aReturn) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(StaticClassName staticClassName) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Super aSuper) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(This aThis) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(UnaryPlus unaryPlus) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(WhileStmt whileStmt) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(DoStmt whileStmt) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Null aNull) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(Literal literal) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(AssignToField assignLeftSide) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(AssignToLocal assignLeftSide) { + // TODO Auto-generated method stub + + } + + @Override + public void visit(SuperCall superCall) { + // TODO Auto-generated method stub + + } +} diff --git a/src/de/dhbwstuttgart/bytecode/ClassFile.java b/src/de/dhbwstuttgart/bytecode/ClassFile.java new file mode 100644 index 00000000..fcbad90b --- /dev/null +++ b/src/de/dhbwstuttgart/bytecode/ClassFile.java @@ -0,0 +1,14 @@ +package de.dhbwstuttgart.bytecode; + +public class ClassFile { + + String name; + byte[] bytecode; + + public ClassFile(String name, byte[] bytecode) { + this.name = name; + this.bytecode = bytecode; + } + + +} diff --git a/src/de/dhbwstuttgart/bytecode/Test.java b/src/de/dhbwstuttgart/bytecode/Test.java index baa707e7..333ec41f 100644 --- a/src/de/dhbwstuttgart/bytecode/Test.java +++ b/src/de/dhbwstuttgart/bytecode/Test.java @@ -5,8 +5,10 @@ import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.lang.invoke.CallSite; +import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; +import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; @@ -18,103 +20,122 @@ import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; + public class Test { - private static final String rootDirectory = System.getProperty("user.dir")+"/bin/de/dhbwstuttgart/bytecode/"; - protected static ClassLoader getClassLoader() throws Exception{ + private static final String rootDirectory = System.getProperty("user.dir") + "/bin/de/dhbwstuttgart/bytecode/"; + + protected static ClassLoader getClassLoader() throws Exception { File file = new File(rootDirectory); - URL url = file.toURI().toURL(); - URL[] urls = new URL[]{url}; - System.out.println(urls[0]); - return new URLClassLoader(urls); + URL url = file.toURI().toURL(); + URL[] urls = new URL[] { url }; + System.out.println(urls[0]); + return new URLClassLoader(urls); } - + public static void main(String[] args) { // Test Lambda - ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_MAXS); - cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_SUPER, "TestClass", null, "java/lang/Object", null); - - // Create Constructor - MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "(Ljava/lang/Boolean;)V", null, null); - mv.visitVarInsn(Opcodes.ALOAD, 0); - - mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V"); - -// mv.visitMethodInsn(INVOKEDYNAMIC, "#0", "run", "()Ljava/lang/Runnable"); - - MethodType mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, - String.class, MethodType.class); - - Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", - "metafactory", mt.toMethodDescriptorString()); - - mv.visitInvokeDynamicInsn("run", "()Ljava/lang/Runnable;", bootstrap); - - mv.visitVarInsn(Opcodes.ASTORE, 1); - mv.visitVarInsn(Opcodes.ALOAD, 1); - mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/lang/Runnable", "run", "()V"); - mv.visitInsn(Opcodes.RETURN); - mv.visitMaxs(1, 2); - mv.visitEnd(); - - cw.visitEnd(); - - byte[] b = cw.toByteArray(); - - -// Test if statement -/* ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS); - - cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_SUPER, "TestIf", null, "java/lang/Object", null); - MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "(Ljava/lang/Boolean;)V", null, null); - mv.visitCode(); - -// Label l0 = new Label(); -// mv.visitLabel(l0); - - mv.visitVarInsn(Opcodes.ALOAD, 0); - - mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V"); - -// Label l1 = new Label(); -// mv.visitLabel(l1); - mv.visitVarInsn(Opcodes.ALOAD, 1); - mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z"); - - Label label = new Label(); - mv.visitJumpInsn(Opcodes.IFEQ, label); - - mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); - mv.visitLdcInsn("1"); - mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"); - - Label endLabel = new Label(); - mv.visitJumpInsn(Opcodes.GOTO, endLabel); - - mv.visitLabel(label); - mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); - mv.visitLdcInsn("0"); - mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"); - - + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "TestClass", null, "java/lang/Object", null); - mv.visitLabel(endLabel); + cw.visitSource("TestClass.java", null); + + // Create Constructor + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V"); + + // mv.visitMethodInsn(INVOKEDYNAMIC, "#0", "run", "()Ljava/lang/Runnable"); + //Call site, which, when invoked, returns an instance of the functional interface to which + //the lambda is being converted + MethodType mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, + MethodType.class, MethodType.class, MethodHandle.class, MethodType.class); + + Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", "metafactory", + mt.toMethodDescriptorString()); + Handle arg2 = new Handle(Opcodes.H_INVOKESTATIC, "TestClass", "lambda$0", "()V"); + + mv.visitInvokeDynamicInsn("run", "()Ljava/lang/Runnable;", bootstrap, + Type.getMethodType("()V"), arg2, + Type.getMethodType("()V")); + + mv.visitVarInsn(Opcodes.ASTORE, 1); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/lang/Runnable", "run", "()V"); mv.visitInsn(Opcodes.RETURN); -// Label l2 = new Label(); -// mv.visitLabel(l2); + // creates bridge method, contains lambdas body + MethodVisitor mvl = cw.visitMethod(Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC + Opcodes.ACC_SYNTHETIC, "lambda$0", + "()V", null, null); + mvl.visitCode(); + mvl.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); + mvl.visitLdcInsn("lambda"); + mvl.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"); + mvl.visitInsn(Opcodes.RETURN); + mvl.visitMaxs(2, 0); + mvl.visitEnd(); -// mv.visitLocalVariable("this", "LTestIf;", null, l0, l2, 0); -// mv.visitLocalVariable("b", "Ljava/lang/Boolean;", null, l0, l2, 1); - mv.visitMaxs(2, 2); + mv.visitMaxs(1, 2); mv.visitEnd(); + + cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup", + Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL); cw.visitEnd(); + byte[] b = cw.toByteArray(); -*/ + + // Test if statement + /* + * ClassWriter cw = new + * ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS); + * + * cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_SUPER, "TestIf", null, + * "java/lang/Object", null); MethodVisitor mv = + * cw.visitMethod(Opcodes.ACC_PUBLIC, "", "(Ljava/lang/Boolean;)V", null, + * null); mv.visitCode(); + * + * // Label l0 = new Label(); // mv.visitLabel(l0); + * + * mv.visitVarInsn(Opcodes.ALOAD, 0); + * + * mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", + * "()V"); + * + * // Label l1 = new Label(); // mv.visitLabel(l1); + * mv.visitVarInsn(Opcodes.ALOAD, 1); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, + * "java/lang/Boolean", "booleanValue", "()Z"); + * + * Label label = new Label(); mv.visitJumpInsn(Opcodes.IFEQ, label); + * + * mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", + * "Ljava/io/PrintStream;"); mv.visitLdcInsn("1"); + * mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", + * "(Ljava/lang/String;)V"); + * + * Label endLabel = new Label(); mv.visitJumpInsn(Opcodes.GOTO, endLabel); + * + * mv.visitLabel(label); mv.visitFieldInsn(Opcodes.GETSTATIC, + * "java/lang/System", "out", "Ljava/io/PrintStream;"); mv.visitLdcInsn("0"); + * mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", + * "(Ljava/lang/String;)V"); + * + * + * + * mv.visitLabel(endLabel); mv.visitInsn(Opcodes.RETURN); + * + * // Label l2 = new Label(); // mv.visitLabel(l2); + * + * // mv.visitLocalVariable("this", "LTestIf;", null, l0, l2, 0); // + * mv.visitLocalVariable("b", "Ljava/lang/Boolean;", null, l0, l2, 1); + * mv.visitMaxs(2, 2); mv.visitEnd(); + * + * cw.visitEnd(); byte[] b = cw.toByteArray(); + */ FileOutputStream output; - + try { - output = new FileOutputStream(new File(System.getProperty("user.dir")+"/testBytecode/TestClass.class")); + output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/TestClass.class")); output.write(b); output.close(); } catch (FileNotFoundException e) { @@ -124,6 +145,6 @@ public class Test { // TODO Auto-generated catch block e.printStackTrace(); } - - } + + } } diff --git a/src/de/dhbwstuttgart/bytecode/TestFields.java b/src/de/dhbwstuttgart/bytecode/TestFields.java new file mode 100644 index 00000000..652b8d19 --- /dev/null +++ b/src/de/dhbwstuttgart/bytecode/TestFields.java @@ -0,0 +1,59 @@ +package de.dhbwstuttgart.bytecode; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; + +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.Type; + +public class TestFields { + private static final String rootDirectory = System.getProperty("user.dir") + "/bin/de/dhbwstuttgart/bytecode/"; + + public static void main(String[] args) { + // TODO Auto-generated method stub + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "TetsF", null, "java/lang/Object", null); + + cw.visitSource("TetsF.java", null); + + FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, "z", Type.INT_TYPE.getDescriptor(), null, null); + fv.visitEnd(); + + FieldVisitor fvS = cw.visitField(Opcodes.ACC_PUBLIC, "s", "Ljava/lang/String;", null, null); + fvS.visitEnd(); + // Create Constructor + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "()V", null, null); + mv.visitCode(); + + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V"); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitLdcInsn(""); + mv.visitFieldInsn(Opcodes.PUTFIELD, "TetsF", "s", "Ljava/lang/String;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(2, 1); + mv.visitEnd(); + + byte[] b = cw.toByteArray(); + + FileOutputStream output; + + try { + output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/TetsF.class")); + output.write(b); + output.close(); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/src/de/dhbwstuttgart/bytecode/TestMeth.java b/src/de/dhbwstuttgart/bytecode/TestMeth.java new file mode 100644 index 00000000..51223ea1 --- /dev/null +++ b/src/de/dhbwstuttgart/bytecode/TestMeth.java @@ -0,0 +1,18 @@ +package de.dhbwstuttgart.bytecode; + +public class TestMeth { + private int z; + public String s; + public TestMeth(int temp) { + this.z = temp; + } + public void m1(int a, int b) { + int y = m2(1,2,3,4); + } + + public int m2(int a, int b, int x, int y) { + Integer c = 55; + Integer g; + return a+b+y+c; + } +} diff --git a/src/de/dhbwstuttgart/bytecode/TetsF.java b/src/de/dhbwstuttgart/bytecode/TetsF.java new file mode 100644 index 00000000..af72a8d3 --- /dev/null +++ b/src/de/dhbwstuttgart/bytecode/TetsF.java @@ -0,0 +1,6 @@ +package de.dhbwstuttgart.bytecode; + +public class TetsF { + private int z; + public String s = ""; +} diff --git a/src/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/de/dhbwstuttgart/core/JavaTXCompiler.java index 034ca37d..adc160fc 100644 --- a/src/de/dhbwstuttgart/core/JavaTXCompiler.java +++ b/src/de/dhbwstuttgart/core/JavaTXCompiler.java @@ -1,7 +1,7 @@ package de.dhbwstuttgart.core; + import de.dhbwstuttgart.environment.CompilationEnvironment; -import de.dhbwstuttgart.environment.PackageCrawler; import de.dhbwstuttgart.parser.JavaTXParser; import de.dhbwstuttgart.parser.scope.GenericsRegistry; import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator; @@ -99,5 +99,5 @@ public class JavaTXCompiler { SourceFile ret = generator.convert(tree); return ret; } - + } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java b/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java index c4b8367d..ed5a082b 100644 --- a/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java @@ -21,6 +21,7 @@ public class ArgumentList extends SyntaxTreeNode return expr; } + @Override public void accept(ASTVisitor visitor) { visitor.visit(this); diff --git a/test/bytecode/JavaTXCompilerTest.java b/test/bytecode/JavaTXCompilerTest.java index fbbea261..9ca91abb 100644 --- a/test/bytecode/JavaTXCompilerTest.java +++ b/test/bytecode/JavaTXCompilerTest.java @@ -2,7 +2,6 @@ package bytecode; import de.dhbwstuttgart.bytecode.BytecodeGen; import de.dhbwstuttgart.core.JavaTXCompiler; -import de.dhbwstuttgart.exceptions.DebugException; import de.dhbwstuttgart.syntaxtree.SourceFile; import org.junit.Test; @@ -17,7 +16,6 @@ import java.nio.file.Paths; import java.util.ArrayList; import java.util.HashMap; import java.util.List; -import java.util.Set; import static org.junit.Assert.*; @@ -28,8 +26,10 @@ public class JavaTXCompilerTest { @Test public void test() throws IOException, java.lang.ClassNotFoundException { + System.out.println(rootDirectory); filesToTest.add(new File(rootDirectory+"EmptyClass.jav")); JavaTXCompiler compiler = new JavaTXCompiler(filesToTest); + System.out.println("test"); for(File f : filesToTest){ String content = readFile(f.getPath(), StandardCharsets.UTF_8); HashMap bytecode = this.getBytecode(compiler.sourceFiles.get(f)); diff --git a/test/javFiles/EmptyClass.jav b/test/javFiles/EmptyClass.jav index e69de29b..8160d7da 100644 --- a/test/javFiles/EmptyClass.jav +++ b/test/javFiles/EmptyClass.jav @@ -0,0 +1,3 @@ +public class EmptyClass{ + +} \ No newline at end of file diff --git a/test/javFiles/EmptyMethod.jav b/test/javFiles/EmptyMethod.jav new file mode 100644 index 00000000..dd28fc69 --- /dev/null +++ b/test/javFiles/EmptyMethod.jav @@ -0,0 +1,37 @@ +public class EmptyMethod{ + static String s1 =""; + String s2; + public void m1(){ + //String s = ""; + System.out.println("test"); + //Integer ab = Math.abs(1); + //Math.abs(1); + //String lV = "local"; + //s1 = "1"; + //s1.concat("2"); + s2 = s1; + //m2(); + Clazz i = new Clazz(); + Integer i = new Integer(1); + } + + public void m2(){} +} + +class Clazz{} +/* +public class EmptyMethod2{ + public static test = "5"; + public void m1(Integer i, String j, Boolean b){ + //String s = ""; + EmptyMethod em = new EmptyMethod(); + em.m1(); + em.s1 = ""; + //Integer ab = Math.abs(1); + //Math.abs(1); + //String lV = "local"; + //s1 = "1"; + //s1.concat("2"); + //s2 = s1; + } +}*/ \ No newline at end of file diff --git a/test/javFiles/Op1.jav b/test/javFiles/Op1.jav new file mode 100644 index 00000000..800f58b8 --- /dev/null +++ b/test/javFiles/Op1.jav @@ -0,0 +1,11 @@ +public class Op1{ + public Op1() { + + Runnable lam = () -> { + String test = ""; + String b = "b"; + test = b; + System.out.println(test);}; + //lam.run(); + } +} \ No newline at end of file diff --git a/test/javFiles/Subclass.jav b/test/javFiles/Subclass.jav new file mode 100644 index 00000000..fe6e9208 --- /dev/null +++ b/test/javFiles/Subclass.jav @@ -0,0 +1,6 @@ +public class Subclass extends Superclass { + + public void printMethod() { + super.printMethod(); + } +} \ No newline at end of file diff --git a/test/javFiles/Superclass.jav b/test/javFiles/Superclass.jav new file mode 100644 index 00000000..d58089de --- /dev/null +++ b/test/javFiles/Superclass.jav @@ -0,0 +1,6 @@ +public class Superclass { + + public void printMethod() { + System.out.println("Printed in Superclass."); + } +} diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index b44a710b..4b79b8c5 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -36,6 +36,7 @@ public class JavaTXCompilerTest { //filesToTest.add(new File(rootDirectory+"Faculty.jav")); //filesToTest.add(new File(rootDirectory+"mathStruc.jav")); //filesToTest.add(new File(rootDirectory+"test.jav")); + filesToTest.add(new File(rootDirectory+"EmptyMethod.jav")); //filesToTest.add(new File(rootDirectory+"Lambda.jav")); //filesToTest.add(new File(rootDirectory+"Lambda2.jav")); //filesToTest.add(new File(rootDirectory+"Lambda3.jav")); diff --git a/testBytecode/Field.java b/testBytecode/Field.java new file mode 100644 index 00000000..50002082 --- /dev/null +++ b/testBytecode/Field.java @@ -0,0 +1,6 @@ +public class Field{ + public void m(){ + MethFieldVar mF = new MethFieldVar(); + mF.s1 = "Field S1"; + } +} diff --git a/testBytecode/Import.java b/testBytecode/Import.java new file mode 100644 index 00000000..f3519acb --- /dev/null +++ b/testBytecode/Import.java @@ -0,0 +1,8 @@ +import java.util.Vector; + +class Import { + void methode(){ + Vector v = new Vector(); + v.add(v); + } +} diff --git a/testBytecode/Lam1.java b/testBytecode/Lam1.java new file mode 100644 index 00000000..142feed2 --- /dev/null +++ b/testBytecode/Lam1.java @@ -0,0 +1,10 @@ +import java.util.function.Function; +public class Lam1{ + public Lam1() { + Function fun = (x) -> x+"1"; + fun.apply("2"); + + Runnable lam = () -> System.out.println("lambda"); + lam.run(); + } +} diff --git a/testBytecode/LamRun.java b/testBytecode/LamRun.java new file mode 100644 index 00000000..f4920700 --- /dev/null +++ b/testBytecode/LamRun.java @@ -0,0 +1,8 @@ +public class LamRun{ + + public LamRun(){ + + Runnable lam = () -> System.out.println("lambda"); + lam.run(); + } +} diff --git a/testBytecode/MethFieldVar.java b/testBytecode/MethFieldVar.java new file mode 100644 index 00000000..74086a01 --- /dev/null +++ b/testBytecode/MethFieldVar.java @@ -0,0 +1,38 @@ +public class MethFieldVar{ + String s1;// = ""; + String s2; + +/* public void meth(Integer i, String j, Boolean b){ + //String local = "a"; + //int localL = local.length(); + //int l = s.length(); + String s = null; + //s = ""; + //return s.length();//l+localL; + } +*/ + public void mm(){ +// return "mm"; + } + public void m2(){ + System.out.println(""); + // Math.abs(1); + // String lV = "local"; + // s1 = "1"; + // s1.concat("2"); + s2 = s1; + + mm(); + + Clazz i = new Clazz(); + + Runnable lam = ()->{ + String test = ""; + String b = "b"; + test = b; + System.out.println(test); + }; + } +} + +class Clazz{} diff --git a/testBytecode/Subclass.java b/testBytecode/Subclass.java new file mode 100644 index 00000000..3e8b5853 --- /dev/null +++ b/testBytecode/Subclass.java @@ -0,0 +1,6 @@ +public class Subclass extends Superclass { + + public void printMethod() { + super.printMethod(); + } +} diff --git a/testBytecode/SuperTest.java b/testBytecode/SuperTest.java new file mode 100644 index 00000000..1b6ac268 --- /dev/null +++ b/testBytecode/SuperTest.java @@ -0,0 +1,14 @@ +public class Superclass { + + public void printMethod() { + System.out.println("Printed in Superclass."); + } +} + +public class Subclass extends Superclass { + + public void printMethod() { + super.printMethod(); + + } +} diff --git a/testBytecode/Superclass.java b/testBytecode/Superclass.java new file mode 100644 index 00000000..d58089de --- /dev/null +++ b/testBytecode/Superclass.java @@ -0,0 +1,6 @@ +public class Superclass { + + public void printMethod() { + System.out.println("Printed in Superclass."); + } +} diff --git a/testBytecode/TestMyTest.java b/testBytecode/TestMyTest.java new file mode 100644 index 00000000..1b3db588 --- /dev/null +++ b/testBytecode/TestMyTest.java @@ -0,0 +1,10 @@ +class TestMyTest{ +public static void main(String[] a){ + //test1 + //new TestClass(); + //test if statement + //new TestIf(new Boolean(true)); + // test lambda + new TestClass(); +} +} diff --git a/testBytecode/public b/testBytecode/public new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/testBytecode/public @@ -0,0 +1 @@ + diff --git a/testBytecode/testF.java b/testBytecode/testF.java new file mode 100644 index 00000000..fa4a50b7 --- /dev/null +++ b/testBytecode/testF.java @@ -0,0 +1,5 @@ +public class testTets(){ + public static void main(String[] args){ + new tetsF(); + } +} diff --git a/testBytecode/testTets.java b/testBytecode/testTets.java new file mode 100644 index 00000000..4f95cbc0 --- /dev/null +++ b/testBytecode/testTets.java @@ -0,0 +1,5 @@ +public class testTets{ + public static void main(String[] args){ + new TetsF(); + } +} diff --git a/testBytecode/testTetsF.java b/testBytecode/testTetsF.java new file mode 100644 index 00000000..fa4a50b7 --- /dev/null +++ b/testBytecode/testTetsF.java @@ -0,0 +1,5 @@ +public class testTets(){ + public static void main(String[] args){ + new tetsF(); + } +}