Bytecode erweitert

BCEL/bcelifier/IntLiteral.java

@@ -0,0 +1,7 @@
+package bcelifier;
+
+public class IntLiteral {
+	Integer methode(){
+		return 50000;
+	}
+}

BCEL/bcelifier/IntLiteralCreator.java

@@ -0,0 +1,56 @@
+package bcelifier;
+
+import org.apache.bcel.generic.*;
+import org.apache.bcel.classfile.*;
+import org.apache.bcel.*;
+import java.io.*;
+
+public class IntLiteralCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public IntLiteralCreator() {
+    _cg = new ClassGen("bcelifier.IntLiteral", "java.lang.Object", "IntLiteral.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.IntLiteral", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("java.lang.Integer"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.IntLiteral", il, _cp);
+
+    InstructionHandle ih_0 = il.append(new PUSH(_cp, 50000));
+    il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
+    InstructionHandle ih_5 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.IntLiteralCreator creator = new bcelifier.IntLiteralCreator();
+    creator.create(new FileOutputStream("bcelifier.IntLiteral.class"));
+  }
+}

BCEL/bcelifier/JavaToBCEL.java

@@ -0,0 +1,37 @@
+package bcelifier;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+
+import org.apache.bcel.classfile.ClassFormatException;
+import org.apache.bcel.classfile.ClassParser;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.util.BCELifier;
+
+public class JavaToBCEL {
+
+	public final static String rootDirectory = System.getProperty("user.dir")+"/BCEL/bcelifier/";
+	
+	public static void main(String args[]){
+		new JavaToBCEL();
+	}
+	
+	public JavaToBCEL(){
+		try {
+			new BCELifier(new ClassParser(rootDirectory+"Lambda1.class").parse(), new FileOutputStream(new File(rootDirectory+"Lambda1Creator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"This.class").parse(), new FileOutputStream(new File(rootDirectory+"ThisCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"IntLiteral.class").parse(), new FileOutputStream(new File(rootDirectory+"IntLiteralCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"MethodCall.class").parse(), new FileOutputStream(new File(rootDirectory+"MethodCallCreator.java"))).start();
+			
+		} catch (ClassFormatException | IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	
+}

BCEL/bcelifier/Lambda1.java

@@ -0,0 +1,8 @@
+package bcelifier;
+
+public class Lambda1 {
+
+	Runnable methode(){
+		return ()->System.out.println(this);
+	}
+}

BCEL/bcelifier/Lambda1Creator.java

@@ -0,0 +1,70 @@
+package bcelifier;
+
+import org.apache.bcel.generic.*;
+import org.apache.bcel.classfile.*;
+import org.apache.bcel.*;
+import java.io.*;
+
+public class Lambda1Creator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public Lambda1Creator() {
+    _cg = new ClassGen("bcelifier.Lambda1", "java.lang.Object", "Lambda1.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    createMethod_2();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.Lambda1", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("java.lang.Runnable"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.Lambda1", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    InstructionHandle ih_1 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_2() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PRIVATE | ACC_SYNTHETIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "lambda$methode$0", "bcelifier.Lambda1", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createFieldAccess("java.lang.System", "out", new ObjectType("java.io.PrintStream"), Constants.GETSTATIC));
+    il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.io.PrintStream", "println", Type.VOID, new Type[] { Type.OBJECT }, Constants.INVOKEVIRTUAL));
+    InstructionHandle ih_7 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.Lambda1Creator creator = new bcelifier.Lambda1Creator();
+    creator.create(new FileOutputStream("bcelifier.Lambda1.class"));
+  }
+}

BCEL/bcelifier/MethodCall.java

@@ -0,0 +1,12 @@
+package bcelifier;
+
+public class MethodCall {
+	void methode(){
+	}
+	
+	void methode2(Runnable r){
+		methode();
+		r.run();
+	}
+}
+

BCEL/bcelifier/MethodCallCreator.java

@@ -0,0 +1,70 @@
+package bcelifier;
+
+import org.apache.bcel.generic.*;
+import org.apache.bcel.classfile.*;
+import org.apache.bcel.*;
+import java.io.*;
+
+public class MethodCallCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public MethodCallCreator() {
+    _cg = new ClassGen("bcelifier.MethodCall", "java.lang.Object", "MethodCall.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    createMethod_2();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.MethodCall", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, Type.VOID, Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.MethodCall", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_2() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, Type.VOID, new Type[] { new ObjectType("java.lang.Runnable") }, new String[] { "arg0" }, "methode2", "bcelifier.MethodCall", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("bcelifier.MethodCall", "methode", Type.VOID, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
+    InstructionHandle ih_4 = il.append(_factory.createLoad(Type.OBJECT, 1));
+    il.append(_factory.createInvoke("java.lang.Runnable", "run", Type.VOID, Type.NO_ARGS, Constants.INVOKEINTERFACE));
+    InstructionHandle ih_10 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.MethodCallCreator creator = new bcelifier.MethodCallCreator();
+    creator.create(new FileOutputStream("bcelifier.MethodCall.class"));
+  }
+}

BCEL/bcelifier/This.java

@@ -0,0 +1,8 @@
+package bcelifier;
+
+public class This {
+
+	This methode(){
+		return this;
+	}
+}

BCEL/bcelifier/ThisCreator.java

@@ -0,0 +1,55 @@
+package bcelifier;
+
+import org.apache.bcel.generic.*;
+import org.apache.bcel.classfile.*;
+import org.apache.bcel.*;
+import java.io.*;
+
+public class ThisCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public ThisCreator() {
+    _cg = new ClassGen("bcelifier.This", "java.lang.Object", "<Unknown>", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.This", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("bcelifier.This"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.This", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    InstructionHandle ih_1 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.ThisCreator creator = new bcelifier.ThisCreator();
+    creator.create(new FileOutputStream("bcelifier.This.class"));
+  }
+}

src/de/dhbwstuttgart/bytecode/DHBWInstructionFactory.java

@@ -0,0 +1,80 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.awt.List;
+import java.util.ArrayList;
+
+import org.apache.bcel.classfile.BootstrapMethod;
+import org.apache.bcel.classfile.ConstantInvokeDynamic;
+import org.apache.bcel.classfile.Method;
+import org.apache.bcel.generic.ClassGen;
+import org.apache.bcel.generic.ConstantPoolGen;
+import org.apache.bcel.generic.INVOKEDYNAMIC;
+import org.apache.bcel.generic.InstructionFactory;
+import org.apache.bcel.generic.MethodGen;
+import org.apache.bcel.generic.Type;
+
+public class DHBWInstructionFactory extends InstructionFactory{
+
+	public DHBWInstructionFactory(ClassGen cg, ConstantPoolGen cp) {
+		super(cg, cp);
+	}
+	
+	private BootstrapMethod createBootstrapMethod(){
+		//TODO
+		return null;
+	}
+	
+	public INVOKEDYNAMIC createInvokeDynamic( MethodGen lambdaMethod ) {
+		//Zuerst die Bootstrap-Methode erstellen: Diese müssen dann in ein BootstrapMethods-Attribut zusammengefasst und dem Classfile hinzugefügt werden
+		int lambdaMethodIndex = this.cp.addMethodref(lambdaMethod);
+		
+		ArrayList arguments = new ArrayList<Integer>();
+		
+		BootstrapMethod bMethod = new BootstrapMethod(lambdaMethodIndex, arguments.size(), (int[])arguments.toArray());
+		
+		final short opcode = 186;
+        int index;
+        /*
+        int nargs = 0;
+        String signature = Type.getMethodSignature(ret_type, arg_types);
+        for (int i = 0; i < arg_types.length; i++) {
+            nargs += arg_types[i].getSize();
+        }
+      	*/
+        
+        //index = cp.addInvokeDynamic(bootstrap_index, name, signature);
+        //Adding invokeDynamic to Constant_Pool:
+        
+        /*
+         * Spezifikation: @see https://docs.oracle.com/javase/specs/jvms/se8/html/index.html
+         * 
+         * CONSTANT_InvokeDynamic_info structure:
+         * - a symbolic reference to a method handle (bootstrap_method_attr_index)
+         * - a method name and a method descriptor (name_and_type_index)
+         * 
+         * @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.4.10
+         */
+        
+        /*
+         * 
+         * TODO: Rausfinden, was es mit der Inneren Klasse auf sich hat
+         * (public static final #48= #47 of #51; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
+         * 
+         * TODO: Rausfinden was es mit dem NameAndType Eintrag in der InvokeDynamic_info Struktur auf sich hat:
+         * Für ein Runnable ()->{}; ist es: run:(LLambda3;)Ljava/lang/Runnable;
+         * 
+         * TODO: bootstrap_methode den Klassenattributen hinzufügen
+         * 
+         */
+        
+        int bootstrap_method_attr_index = bMethod.getBootstrapMethodRef();
+        int name_and_type_index = cp.addNameAndType(lambdaMethod.getName(), lambdaMethod.getType().getSignature());
+		
+        ConstantInvokeDynamic cInvokeDynamic = new ConstantInvokeDynamic(bootstrap_method_attr_index, name_and_type_index);
+        
+        index = cp.addConstant(cInvokeDynamic, cp);
+        
+        return new INVOKEDYNAMIC(opcode, index);
+	}
+
+}

src/de/dhbwstuttgart/core/MyCompiler.java

@@ -855,22 +855,14 @@ public class MyCompiler implements MyCompilerAPI
 	}
 
 	@Override
-	public ByteCodeResult generateBytecode() {
+	public Menge<ByteCodeResult> generateBytecode() {
-		/*
+		//SourceFile parsedFile = this.m_AbstractSyntaxTree.firstElement();
-		 * TODO Für das Bytecode-Team:
+		//Class parsedClass = parsedFile.KlassenVektor.firstElement();
-		 * - generateBytecode-Methode implementieren
+		Menge<ByteCodeResult> ret = new Menge<>();
-         *             - Sich einen passenden Container für den Bytecode überlegen
+		for(SourceFile sf : this.m_AbstractSyntaxTree){
-         *              - Dieser wird von generateBytecode zurückgeliefert und sollte die Möglichkeit zum schreiben von Bytecode in eine Datei bieten.
+			ret.addAll(sf.generateBytecode());
-		 * - wird der Rückgabetyp von generateBytecode in MyCompiler geändert, so muss auch der Rückgabetyp im Interface MyCompilerAPI geändert werden
-		 */
-		try {
-			SourceFile parsedFile = this.m_AbstractSyntaxTree.firstElement();
-			Class parsedClass = parsedFile.KlassenVektor.firstElement();
-			return parsedClass.genByteCode();
-		} catch (IOException e) {
-			e.printStackTrace();
-			return null;
 		}
+		return ret;
 	}
 }
 // ino.end

src/de/dhbwstuttgart/core/MyCompilerAPI.java

@@ -122,6 +122,11 @@ public interface MyCompilerAPI
 	 */
 	public SourceFile parse(String sourceCode) throws ParserError;
 	
-	public ByteCodeResult generateBytecode();
+	/**
+	 * Generiert für jede geparste Klasse im SourceFile ein ByteCodeResult.
+	 * Dafür müssen die Schritte Parsen und typeReconstruction ausgeführt werden.
+	 * @return
+	 */
+	public Menge<ByteCodeResult> generateBytecode();
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/Class.java

@@ -72,13 +72,13 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     private ClassGen           _cg;
     
     //Method created with BCEL to generate ByteCode
-    public ByteCodeResult genByteCode() throws IOException {
+    public ByteCodeResult genByteCode() {
     	    	
     	SectionLogger logger = Logger.getSectionLogger(this.getClass().getName(), Section.CODEGEN);
     	logger.debug("Test");
     	
     	if(pkgName != null)throw new NotImplementedException();
-    	_cg = new ClassGen(name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  }); //new String necessary?
+    	_cg = new ClassGen(name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  }); //letzter Parameter sind implementierte Interfaces
         _cp = _cg.getConstantPool();
         _factory = new InstructionFactory(_cg, _cp);
         
@@ -88,12 +88,6 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     	
 	    ByteCodeResult code = new ByteCodeResult(_cg);
         return code;
-        
-    	//ByteCodeResult bc = new ByteCodeResult();
-    	//_cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  });
-    //_cg zur<EFBFBD>ckgeben
-    	//bc.append(BCELByteCodeOutput);
-    	//return _cg;
     }
 
     private Menge<Type> superif = new Menge<Type>();
@@ -477,7 +471,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     			 */
     			if(m.get_Method_Name().equals("<init>"))throw new TypeinferenceException("<init> ist kein gültiger Methodenname", m);
     			if((m.get_Method_Name().equals(this.getName()))) {
-    				Constructor constructor = new Constructor(m);
+    				Constructor constructor = new Constructor(m, this);
     				tempFields.add(constructor); //Den Konstruktor anstatt der Methode anfügen
     			}else{
     				//Handelt es sich um keinen Konstruktor, dann die Methode unverändert den Feldern hinzufügen:
@@ -1251,7 +1245,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
 		if(!constructorVorhanden){//Falls kein Konstruktor vorhanden ist, muss noch der Standardkonstruktor angefügt werden:
 			Block konstruktorBlock = new Block();
 			konstruktorBlock.statements.add(new SuperCall(konstruktorBlock));
-			Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(konstruktorBlock,this.getName().toString(), this));
+			Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(konstruktorBlock,this.getName().toString(), this), this);
 			//Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(this.getName().toString(), this));
 			
 			this.addField(standardKonstruktor);

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -746,7 +746,23 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		InstructionList il = new InstructionList();
 		Class parentClass = this.getParentClass();
 	
-		MethodGen method = new MethodGen(Constants.ACC_PUBLIC, this.getType().getBytecodeType(), org.apache.bcel.generic.Type.NO_ARGS , new String[] {  }, this.get_Method_Name(), parentClass.name, il, _cp);
+		//Die Argumentliste generieren:
+		org.apache.bcel.generic.Type[] argumentTypes = org.apache.bcel.generic.Type.NO_ARGS;
+		String[] argumentNames = new String[]{};
+		if(this.parameterlist != null &&
+				this.parameterlist.size() > 0){
+			argumentTypes = new org.apache.bcel.generic.Type[this.parameterlist.size()];
+			argumentNames = new String[this.parameterlist.size()];
+			int i = 0;
+			for(FormalParameter parameter : this.parameterlist){
+				argumentTypes[i] = parameter.getType().getBytecodeType();
+				argumentNames[i] = parameter.getIdentifier();
+				i++;
+			}
+		}
+		
+		//Methode generieren:
+		MethodGen method = new MethodGen(Constants.ACC_PUBLIC, this.getType().getBytecodeType(), argumentTypes , argumentNames, this.get_Method_Name(), parentClass.name, il, _cp);
 		
 		Block block = this.get_Block();
 		InstructionList blockInstructions = block.genByteCode(cg);
@@ -759,7 +775,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		}
 		
 		method.setMaxStack(); //Die Stack Größe automatisch berechnen lassen (erst nach dem alle Instructions angehängt wurden)
-		
+		method.setMaxLocals();
 		cg.addMethod(method.getMethod());
 		
 	}

src/de/dhbwstuttgart/syntaxtree/ParameterList.java

@@ -139,6 +139,10 @@ public class ParameterList extends SyntaxTreeNode implements Iterable<FormalPara
 	public Menge<? extends SyntaxTreeNode> getChildren() {
 		return formalparameter;
 	}
+
+	public int size() {
+		return this.formalparameter.size();
+	}
 	
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -3,12 +3,15 @@ package de.dhbwstuttgart.syntaxtree;
 // ino.end
 
 // ino.module.SourceFile.8722.import 
+import java.io.IOException;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
+
 import de.dhbwstuttgart.typeinference.Menge;
+
 import java.util.stream.Stream;
 
 import de.dhbwstuttgart.logger.Logger;
@@ -29,6 +32,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.Void;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.FunN;
 import de.dhbwstuttgart.typeinference.FunNInterface;
@@ -1368,7 +1372,7 @@ public class SourceFile
                     }
                     //basicAssumptions.addMethodIntersectionType(new CIntersectionType(constructor));
                     constructorMethod.parameterlist = paraList;
-                    Constructor constructor = new Constructor(constructorMethod);
+                    Constructor constructor = new Constructor(constructorMethod, parentClass);
                     constructor.parserPostProcessing(parentClass);
                     parentClass.addField(constructor);
                 }
@@ -1825,5 +1829,17 @@ public class SourceFile
 		return 0;
 	}
 
+	/**
+	 * Bisher wird nur der Bytecode der Klassen generiert. Nicht der Interfaces.
+	 * @return
+	 */
+	public Collection<? extends ByteCodeResult> generateBytecode() {
+		Menge<ByteCodeResult> ret = new Menge<>();
+		for(Class cl : this.KlassenVektor){
+			ret.add(cl.genByteCode());
+		}
+		return ret;
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java

@@ -4,10 +4,14 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.IntLiteral.8635.import 
 import java.util.Hashtable;
 
+import org.apache.bcel.Constants;
 import org.apache.bcel.generic.BIPUSH;
 import org.apache.bcel.generic.ClassGen;
 import org.apache.bcel.generic.InstructionFactory;
+import org.apache.bcel.generic.InstructionHandle;
 import org.apache.bcel.generic.InstructionList;
+import org.apache.bcel.generic.ObjectType;
+import org.apache.bcel.generic.PUSH;
 
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
@@ -137,8 +141,14 @@ public class IntLiteral extends Literal
 	public InstructionList genByteCode(ClassGen cg) {
 		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 		InstructionList il = new InstructionList();
-		il.append(new BIPUSH(new Integer(get_Int()).byteValue()));	
+		
-		return il;
+		/*
+		 * Der jetzige Compiler kann keine primitiven Typen. Ein int-Literal ist daher eine Instanz von java.lang.Integer
+		 */
+		il.append(new PUSH(cg.getConstantPool(), this.get_Int()));
+	    il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new org.apache.bcel.generic.Type[] { org.apache.bcel.generic.Type.INT }, Constants.INVOKESTATIC));
+		
+	    return il;
 	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java

@@ -308,7 +308,8 @@ public class MethodCall extends Expr
 	
 	@Override
 	public InstructionList genByteCode(ClassGen _cg) {
-		// TODO Auto-generated method stub
+		//Herausfinden, ob eine Methode oder ein Interface aufgerufen wird:
+		//this.receiver.get_Expr().getType()
 		
 	}
 	

src/de/dhbwstuttgart/syntaxtree/statement/Return.java

@@ -138,10 +138,7 @@ public class Return extends Statement
 		
 		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 		
-		//Stimmt das VOID hier eigentlich? --> Wie wäre es mit getReturnType o.ä.? + evtl. von Type zu bcelType casten?
+		il.append(_factory.createReturn(retexpr.getType().getBytecodeType()));
-		il.append(_factory.createReturn(org.apache.bcel.generic.Type.VOID));
-		
-		
 		
 		return il;
 	}

test/bytecode/AssignTest.java

@@ -20,26 +20,15 @@ import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
 
-public class Assign {
+public class AssignTest {
 	
 	public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
 	public final static String testFile = "Assign.jav";
-	public final static String outputFile = "AssignTest.class";
+	public final static String outputFile = "Assign.class";
 	
 	@Test
 	public void test() {
-		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
-		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
-		try {
-			compiler.parse(new File(rootDirectory + testFile));
-			compiler.typeReconstruction();
-			ByteCodeResult bytecode = compiler.generateBytecode();
-			System.out.println(bytecode);
-			bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile));
-		} catch (IOException | yyException e) {
-			e.printStackTrace();
-			TestCase.fail();
-		}
 	}
 
 }

test/bytecode/BoolLitTest.java

@@ -28,18 +28,7 @@ public class BoolLitTest {
 	
 	@Test
 	public void test() {
-		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
-		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
-		try {
-			compiler.parse(new File(rootDirectory + testFile));
-			compiler.typeReconstruction();
-			ByteCodeResult bytecode = compiler.generateBytecode();
-			System.out.println(bytecode);
-			bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile));
-		} catch (IOException | yyException e) {
-			e.printStackTrace();
-			TestCase.fail();
-		}
 	}
 
 }

test/bytecode/CharLitTest.java

@@ -28,18 +28,7 @@ public class CharLitTest {
 	
 	@Test
 	public void test() {
-		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
-		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
-		try {
-			compiler.parse(new File(rootDirectory + testFile));
-			compiler.typeReconstruction();
-			ByteCodeResult bytecode = compiler.generateBytecode();
-			System.out.println(bytecode);
-			bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile));
-		} catch (IOException | yyException e) {
-			e.printStackTrace();
-			TestCase.fail();
-		}
 	}
 
 }

test/bytecode/EmptyClassTest.java

@@ -28,18 +28,7 @@ public class EmptyClassTest {
 	
 	@Test
 	public void test() {
-		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
-		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
-		try {
-			compiler.parse(new File(rootDirectory + testFile));
-			compiler.typeReconstruction();
-			ByteCodeResult bytecode = compiler.generateBytecode();
-			System.out.println(bytecode);
-			bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile));
-		} catch (IOException | yyException e) {
-			e.printStackTrace();
-			TestCase.fail();
-		}
 	}
 
 }

test/bytecode/MethodCall.jav

@@ -0,0 +1,9 @@
+class Assign{
+
+void method() {
+method();
+}
+
+void method2(){}
+
+}

test/bytecode/MethodCallTest.java

@@ -0,0 +1,34 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import plugindevelopment.TypeInsertTester;
+import de.dhbwstuttgart.core.MyCompiler;
+import de.dhbwstuttgart.core.MyCompilerAPI;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
+
+public class MethodCallTest {
+	
+	public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
+	public final static String testFile = "MethodCall.jav";
+	public final static String outputFile = "MethodCall.class";
+	
+	@Test
+	public void test() {
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
+	}
+
+}

test/bytecode/Return.jav

@@ -1,10 +1,7 @@
-class Assign{
+class Return{
 
-method() {a;
+Integer method() {
-	a = 20;
+	return 5;
-	b;
-	b=59;
-	return a + b;
 	}
 
 

test/bytecode/ReturnTest.java

@@ -20,26 +20,15 @@ import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
 
-public class Return {
+public class ReturnTest {
 	
 	public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
-	public final static String testFile = "Assign.jav";
+	public final static String testFile = "Return.jav";
-	public final static String outputFile = "Assign.class";
+	public final static String outputFile = "Return.class";
 	
 	@Test
 	public void test() {
-		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputFile);
-		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
-		try {
-			compiler.parse(new File(rootDirectory + testFile));
-			compiler.typeReconstruction();
-			ByteCodeResult bytecode = compiler.generateBytecode();
-			System.out.println(bytecode);
-			bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile));
-		} catch (IOException | yyException e) {
-			e.printStackTrace();
-			TestCase.fail();
-		}
 	}
 
 }

test/bytecode/SingleClassTester.java

@@ -0,0 +1,32 @@
+package bytecode;
+
+import java.io.File;
+import java.io.IOException;
+
+import junit.framework.TestCase;
+import de.dhbwstuttgart.core.MyCompiler;
+import de.dhbwstuttgart.core.MyCompilerAPI;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import de.dhbwstuttgart.typeinference.Menge;
+
+public class SingleClassTester {
+
+	public static void compileToBytecode(String inputFile, String outputFile){
+		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
+		try {
+			compiler.parse(new File(inputFile));
+			compiler.typeReconstruction();
+			Menge<ByteCodeResult> bytecode = compiler.generateBytecode();
+			System.out.println(bytecode);
+			bytecode.firstElement().getByteCode().getJavaClass().dump(new File(outputFile));
+		} catch (IOException | yyException e) {
+			e.printStackTrace();
+			TestCase.fail();
+		}
+	}
+	
+}

test/bytecode/Test.java

@@ -4,7 +4,7 @@
 class Test{
 public static void main(String[] args){
 	new EmptyClass();
-	new AssignTest();
+	new Assign();
-	
+	System.out.println(new Return().method());
 }
 }