Test für Methodenparameter erstellt

- Mehrere Klassen in einer jav Datei möglich
- OLTest läuft

.settings/org.eclipse.core.resources.prefs

@@ -1,5 +1,7 @@
 eclipse.preferences.version=1
 encoding//src/de/dhbwstuttgart/core/MyCompiler.java=UTF-8
 encoding//src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java=UTF-8
-encoding//src/de/dhbwstuttgart/typeinference/SingleConstraint.java=UTF-8
 encoding//src/de/dhbwstuttgart/typeinference/UndConstraint.java=UTF-8
+encoding//src/de/dhbwstuttgart/typeinference/UnifySingleConstraint.java=UTF-8
+encoding//src/de/dhbwstuttgart/typeinference/UnifyUndConstraint.java=UTF-8
+encoding/<project>=UTF-8

BCEL/bcelifier/IfStatement.java

@@ -0,0 +1,12 @@
+package bcelifier;
+
+class IfStatement{
+	Integer methode(Boolean b){
+		if(b){
+			return 1;
+		}else{
+			return 2;
+		}
+	}
+
+}

BCEL/bcelifier/IfStatementCreator.java

@@ -0,0 +1,71 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.MethodGenerator;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
+
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class IfStatementCreator {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGenerator           _cg;
+
+  public IfStatementCreator() {
+	  
+	TypeinferenceResults typeinferenceResults = null;
+	_cg = new ClassGenerator("bcelifier.IfStatement", new RefType("java.lang.Object", null, 0), "IfStatement.java", Const.ACC_SUPER, new String[] {  }, typeinferenceResults);
+
+    _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 MethodGenerator(0, Type.VOID, new Type[] { new ObjectType("java.lang.Boolean") }, new String[] { "arg0" }, "<init>", "bcelifier.IfStatement", 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, Const.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGenerator(0, new ObjectType("java.lang.Integer"), new Type[] { new ObjectType("java.lang.Boolean") }, new String[] { "arg0" }, "methode", "bcelifier.IfStatement", il, _cp);
+
+    il.append(InstructionFactory.createLoad(Type.OBJECT, 1));
+    il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", Type.BOOLEAN, Type.NO_ARGS, Const.INVOKEVIRTUAL));
+    BranchInstruction ifeq_4 = InstructionFactory.createBranchInstruction(Const.IFEQ, null);
+    il.append(ifeq_4);
+    il.append(new PUSH(_cp, 1));
+    il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Const.INVOKESTATIC));
+    il.append(InstructionFactory.createReturn(Type.OBJECT));
+    InstructionHandle ih_12 = il.append(new PUSH(_cp, 2));
+    il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Const.INVOKESTATIC));
+    il.append(InstructionFactory.createReturn(Type.OBJECT));
+    ifeq_4.setTarget(ih_12);
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.IfStatementCreator creator = new bcelifier.IfStatementCreator();
+    creator.create(new FileOutputStream("bcelifier.IfStatement.class"));
+    
+    System.out.println("bcelifier.IfStatement.class");
+  }
+}

BCEL/bcelifier/JavaToBCEL.java

@@ -24,16 +24,16 @@ public class 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();
-			new BCELifier(new ClassParser(rootDirectory+"FieldDeclaration.class").parse(), new FileOutputStream(new File(rootDirectory+"FieldDeclarationCreator.java"))).start();
-			new BCELifier(new ClassParser(rootDirectory+"Null.class").parse(), new FileOutputStream(new File(rootDirectory+"NullCreator.java"))).start();
-			new BCELifier(new ClassParser(rootDirectory+"LocalVarAccess.class").parse(), new FileOutputStream(new File(rootDirectory+"LocalVarAccessCreator.java"))).start();
-			new BCELifier(new ClassParser(rootDirectory+"Wildcard.class").parse(), new FileOutputStream(new File(rootDirectory+"WildcardCreator.java"))).start();
-			new BCELifier(new ClassParser(rootDirectory+"BooleanValue.class").parse(), new FileOutputStream(new File(rootDirectory+"BooleanValueCreator.java"))).start();
-			new BCELifier(new ClassParser(rootDirectory+"NewClass.class").parse(), new FileOutputStream(new File(rootDirectory+"NewClassCreator.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();
+			//new BCELifier(new ClassParser(rootDirectory+"FieldDeclaration.class").parse(), new FileOutputStream(new File(rootDirectory+"FieldDeclarationCreator.java"))).start();
+			//new BCELifier(new ClassParser(rootDirectory+"Null.class").parse(), new FileOutputStream(new File(rootDirectory+"NullCreator.java"))).start();
+			//new BCELifier(new ClassParser(rootDirectory+"LocalVarAccess.class").parse(), new FileOutputStream(new File(rootDirectory+"LocalVarAccessCreator.java"))).start();
+			//new BCELifier(new ClassParser(rootDirectory+"Wildcard.class").parse(), new FileOutputStream(new File(rootDirectory+"WildcardCreator.java"))).start();
+			//new BCELifier(new ClassParser(rootDirectory+"BooleanValue.class").parse(), new FileOutputStream(new File(rootDirectory+"BooleanValueCreator.java"))).start();
+			//new BCELifier(new ClassParser(rootDirectory+"NewClass.class").parse(), new FileOutputStream(new File(rootDirectory+"NewClassCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"IfStatement.class").parse(), new FileOutputStream(new File(rootDirectory+"IfStatementCreator.java"))).start();
 		} catch (ClassFormatException | IOException e) {
 			e.printStackTrace();
 		}

notizen/stan/lambdaBytecode/Notizen.md

@@ -35,3 +35,9 @@
 # TODO:
 * Matrix Beispiel muss funktionieren (verschachtelter Lambda Ausdruck)
 * Automatisch Bytecode generieren, wenn alle Typen eingesetzt sind
+
+## StackMapTable
+* Attribute für Codeattribut
+* Wird für Sprünge im Bytecode benötigt
+* Quelle: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.4
+

notizen/stan/lambdaBytecode/cat

@@ -1,104 +0,0 @@
-Classfile /home/janulrich/Development/eclipseworkspace/JavaCompilerCore/notizen/stan/lambdaBytecode/Lambda1.class
-  Last modified 20.08.2015; size 903 bytes
-  MD5 checksum acb53c553588f3c919f2b0e6359bbd94
-class Lambda1
-  InnerClasses:
-       public static final #46= #45 of #49; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
-  BootstrapMethods:
-    0: #18 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
-      Method arguments:
-        #19 ()V
-        #20 invokestatic Lambda1.lambda$methode$0:()V
-        #19 ()V
-  minor version: 0
-  major version: 52
-  flags: ACC_SUPER
-Constant pool:
-   #1 = Methodref          #8.#16         //  java/lang/Object."<init>":()V
-   #2 = InvokeDynamic      #0:#21         //  #0:run:()Ljava/lang/Runnable;
-   #3 = Methodref          #7.#22         //  Lambda1.methode:()Ljava/lang/Runnable;
-   #4 = InterfaceMethodref #23.#24        //  java/lang/Runnable.run:()V
-   #5 = Fieldref           #25.#26        //  java/lang/System.out:Ljava/io/PrintStream;
-   #6 = Methodref          #27.#28        //  java/io/PrintStream.println:()V
-   #7 = Class              #29            //  Lambda1
-   #8 = Class              #30            //  java/lang/Object
-   #9 = Utf8               <init>
-  #10 = Utf8               ()V
-  #11 = Utf8               Code
-  #12 = Utf8               methode
-  #13 = Utf8               ()Ljava/lang/Runnable;
-  #14 = Utf8               methode2
-  #15 = Utf8               lambda$methode$0
-  #16 = NameAndType        #9:#10         //  "<init>":()V
-  #17 = Utf8               BootstrapMethods
-  #18 = MethodHandle       #6:#31         //  invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
-  #19 = MethodType         #10            //  ()V
-  #20 = MethodHandle       #6:#32         //  invokestatic Lambda1.lambda$methode$0:()V
-  #21 = NameAndType        #33:#13        //  run:()Ljava/lang/Runnable;
-  #22 = NameAndType        #12:#13        //  methode:()Ljava/lang/Runnable;
-  #23 = Class              #34            //  java/lang/Runnable
-  #24 = NameAndType        #33:#10        //  run:()V
-  #25 = Class              #35            //  java/lang/System
-  #26 = NameAndType        #36:#37        //  out:Ljava/io/PrintStream;
-  #27 = Class              #38            //  java/io/PrintStream
-  #28 = NameAndType        #39:#10        //  println:()V
-  #29 = Utf8               Lambda1
-  #30 = Utf8               java/lang/Object
-  #31 = Methodref          #40.#41        //  java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
-  #32 = Methodref          #7.#42         //  Lambda1.lambda$methode$0:()V
-  #33 = Utf8               run
-  #34 = Utf8               java/lang/Runnable
-  #35 = Utf8               java/lang/System
-  #36 = Utf8               out
-  #37 = Utf8               Ljava/io/PrintStream;
-  #38 = Utf8               java/io/PrintStream
-  #39 = Utf8               println
-  #40 = Class              #43            //  java/lang/invoke/LambdaMetafactory
-  #41 = NameAndType        #44:#48        //  metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
-  #42 = NameAndType        #15:#10        //  lambda$methode$0:()V
-  #43 = Utf8               java/lang/invoke/LambdaMetafactory
-  #44 = Utf8               metafactory
-  #45 = Class              #50            //  java/lang/invoke/MethodHandles$Lookup
-  #46 = Utf8               Lookup
-  #47 = Utf8               InnerClasses
-  #48 = Utf8               (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
-  #49 = Class              #51            //  java/lang/invoke/MethodHandles
-  #50 = Utf8               java/lang/invoke/MethodHandles$Lookup
-  #51 = Utf8               java/lang/invoke/MethodHandles
-{
-  Lambda1();
-    Signature: ()V
-    flags: 
-    Code:
-      stack=1, locals=1, args_size=1
-         0: aload_0       
-         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
-         4: return        
-
-  java.lang.Runnable methode();
-    Signature: ()Ljava/lang/Runnable;
-    flags: 
-    Code:
-      stack=1, locals=1, args_size=1
-         0: invokedynamic #2,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
-         5: areturn       
-
-  void methode2();
-    Signature: ()V
-    flags: 
-    Code:
-      stack=1, locals=1, args_size=1
-         0: aload_0       
-         1: invokevirtual #3                  // Method methode:()Ljava/lang/Runnable;
-         4: invokeinterface #4,  1            // InterfaceMethod java/lang/Runnable.run:()V
-         9: return        
-
-  private static void lambda$methode$0();
-    Signature: ()V
-    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
-    Code:
-      stack=1, locals=0, args_size=0
-         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
-         3: invokevirtual #6                  // Method java/io/PrintStream.println:()V
-         6: return        
-}

notizen/stan/stackmaptable/IfElseStatement.java

@@ -0,0 +1,9 @@
+class IfElseStatement{
+	Integer method(Boolean flag){
+		if(flag){
+			return 0;
+		}else{
+			return 1;
+		}
+	}
+}

notizen/stan/stackmaptable/Notizen.md

@@ -0,0 +1,21 @@
+# StackMapTable
+* Attribute für Codeattribut
+* Wird für Sprünge im Bytecode benötigt
+* Quelle: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.4
+
+## Generierung
+* StackMapTable könnte generiert werden, indem im bytecode geschaut wird, wo Sprünge vorliegen.
+* https://stackoverflow.com/questions/24927993/what-kind-of-java-code-requires-stackmap-frames#24930521
+	* It is illegal to have code after an unconditional branch without a stack map frame being provided for it.
+
+## BCEL Patch
+https://issues.apache.org/jira/browse/BCEL-268
+* Submitting patch: https://commons.apache.org/patches.html
+### Änderungen im BCEL-Projekt
+* Neue Datei StackMapTableGen
+* Testen TODO:
+	* Mittels BCELifier Code generieren lassen, welcher Methoden erstellt, die Branches enthalten
+	* Dies dann dem StackMapTableGen übergeben und auf das erstellen von StackMapEntries abprüfen
+
+# Literatur
+* Zu JVM allgemein: http://blog.jamesdbloom.com/JVMInternals.html

notizen/stan/stackmaptable/StackMapTest.java

@@ -0,0 +1,6 @@
+class StackMapTest{
+
+void methode(){
+while(true){}
+}
+}

notizen/stan/stackmaptable/StackMapTest2.java

@@ -0,0 +1,8 @@
+class StackMapTest2{
+
+void methode(){
+Integer i = 1;
+while(System.out == null){
+i+=1;}
+}
+}

notizen/stan/stackmaptable/StackMapTest3.java

@@ -0,0 +1,14 @@
+class StackMapTest3{
+
+void methode(){
+Integer i = 1;
+while(System.out == null){
+i+=1;
+}
+System.out.println(i);
+StackMapTest3 o = new StackMapTest3();
+while(i<0){
+i++;
+}
+}
+}

notizen/stan/stackmaptable/StackMapTest4.java

@@ -0,0 +1,17 @@
+class StackMapTest4{
+
+int test = 1;
+
+void methode(){
+Integer i = 1;
+while(System.out == null){
+i+=test;
+}
+Runnable r = ()->System.out.println("");
+System.out.println(i);
+StackMapTest3 o = new StackMapTest3();
+while(i<0){
+i++;
+}
+}
+}

notizen/stan/stackmaptable/StackMapTest5.java

@@ -0,0 +1,12 @@
+class StackMapTest5{
+
+void methode(){
+int i = 0;
+while(System.out == null){
+i+=1;
+while(true){
+String s = "2";
+}
+}
+}
+}

notizen/stf/Notes

@@ -13,4 +13,38 @@
 - Wie kommen die Mengen des Unify-Algorithmus zustande? Siehe test: 		
 		/*
 		 * Test b <. a, a <. b
-		 */
+		 */
+	
+- 
+	
+		 
+- Transitiven Abschluss von FC bilden um schneller Subtypen bestimmen zu k<>nnen	 
+		 	 - Problem: 2 FCs  f<>r Pairs und MPairs durch das Mapping
+- Equals der Typen schreiben um instanceof Pr<50>fungen zu vermeiden
+
+- Refactoring der Klassen Menge und Pair erlaubt?
+++++++++++++++++++++++++++++++++++++++++++++++
+
+
+Instanceof wird verwendet da:
+	-> Entscheidung f<>r diese L<>sung, da 2-Fach-Visitor oder DoubleDispatch Pattern
+	enorm viele <20>berladene Methoden zur folge h<>tten, nicht intuitiv w<>ren und die rules in die Typen verschoben h<>tten.
+	
+Gilt reduce f<>r alle Typen oder nur f<>r simple und tphs? (Vermutlich nur s und tph sonst br<62>uchte  man keine upLow regel)
+
++++++++++++++++++++++++++++++++++++++++++++++++
+
+HashCode implementierungen testen (type paramerte mit einbeziehen, hashcodes cachen -> da immutable)
+
+
++++++++++++++++++++++++++++++++++++++++++++++++
+- Typen sind anhand ihres identifiers durchg<68>ngig identifizierbar
+
+- ReduceEq nur auf SimpleTypes oder auf alles anwenden? (Momentan alles)
+- ReduceEq Permutation?
+
+EED UP
+	- Anwendungsreihenfolge der Regeln (wahrscheinlichste zuerst, evtl ist nach regel 1 regel 2 nie m<>glich etc...)
+		- Erase vor Reduce
+		- Rechenarm vor rechenintensiv
+		

src/de/dhbwstuttgart/bytecode/ClassGenerator.java

@@ -1,8 +1,12 @@
 package de.dhbwstuttgart.bytecode;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
+import java.util.Vector;
 
 import org.apache.commons.bcel6.classfile.BootstrapMethod;
 import org.apache.commons.bcel6.classfile.BootstrapMethods;
@@ -10,6 +14,7 @@ import org.apache.commons.bcel6.classfile.ConstantPool;
 import org.apache.commons.bcel6.classfile.InnerClass;
 import org.apache.commons.bcel6.classfile.InnerClasses;
 import org.apache.commons.bcel6.classfile.JavaClass;
+import org.apache.commons.bcel6.classfile.Method;
 import org.apache.commons.bcel6.classfile.Signature;
 import org.apache.commons.bcel6.generic.ClassGen;
 import org.apache.commons.bcel6.generic.ConstantPoolGen;
@@ -34,6 +39,8 @@ public class ClassGenerator extends ClassGen{
 	private Menge<TypePlaceholder> usedTPHs = new Menge<>();
 	
 	private Map<String, ClassGenerator> extraClasses = new HashMap<>();
+	private List<String> methodsNamesAndTypes = new LinkedList<>();
+	private MethodGenerator methodGenerator;
 
 	public ClassGenerator(String name, Type superClass, String string, short accessflags, String[] strings, TypeinferenceResults typeinferenceResults) {
 		super(name,superClass.get_Name(),string,accessflags,strings, new DHBWConstantPoolGen());
@@ -47,7 +54,7 @@ public class ClassGenerator extends ClassGen{
 	}
 
 	public DHBWInstructionFactory getInstructionFactory() {
-		return factory ;
+		return factory;
 	}
 
 	/**
@@ -62,20 +69,12 @@ public class ClassGenerator extends ClassGen{
 			//return getNearestType((TypePlaceholder) t);
 			return new TypePlaceholderType((TypePlaceholder) t);
 		}else{
-			return t.getBytecodeType(this);
+			return t.getBytecodeType(this, getTypeinferenceResults().getTypeReconstructions().get(0));
 		}
 	}
 	public org.apache.commons.bcel6.generic.Type getNearestUsedType(TypePlaceholder toTPH){
 		return this.getNearestUsedType(toTPH, null);
 	}
-	
-	public Type resolveTPH(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex) {
-		return resolveTPH(typePlaceholder, typeinferenceResultSetIndex, null);
-	}
-	
-	public Type resolveTPH(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex, Menge<TypePlaceholder> toOneOfTheseTypes) {
-		return tiResult.getTypeOfPlaceholder(typePlaceholder, typeinferenceResultSetIndex, toOneOfTheseTypes);
-	}
 
 	public String createLambdaMethodName() {
 		return "lambda$methode$"+(lambdaMethodeNr++);
@@ -103,7 +102,7 @@ public class ClassGenerator extends ClassGen{
 		int innerClassesUTF8 = this.getConstantPool().addUtf8("InnerClasses");
 		this.addAttribute(new InnerClasses(innerClassesUTF8,numberOfInnerClasses*8+2,innerClasses,this.getConstantPool().getConstantPool()));
 	}
-
+	
 	public int addBootstrapMethod(BootstrapMethod bMethod) {
 		int numberOfBootstrapMethods = 1;
 		int name_index = this.getConstantPool().addUtf8("BootstrapMethods");
@@ -134,7 +133,7 @@ public class ClassGenerator extends ClassGen{
 		
 		//Signatur setzen:
 		String typeParameters = this.generateParameterSignature();
-		String superClassSignature = this.superClass.getBytecodeSignature(this);
+		String superClassSignature = this.superClass.getBytecodeSignature(this, null);
     	String classSignature = typeParameters + superClassSignature;
     	if(classSignature.length()>0){
     		this.addAttribute(new Signature(cp.addUtf8("Signature"),2,cp.addUtf8(classSignature),cp.getConstantPool()));
@@ -152,7 +151,7 @@ public class ClassGenerator extends ClassGen{
 				TypePlaceholder tph = it.next();
 				//ret += tph.getBytecodeMethodSignature(this);
 				//ret += ":";
-				ret += tph.getClassSignature(this);
+				ret += tph.getClassSignature(this, getTypeinferenceResults().getTypeReconstructions().get(0));
 			}
 			ret += ">";
 		}
@@ -170,7 +169,26 @@ public class ClassGenerator extends ClassGen{
 	public TypeinferenceResults getTypeinferenceResults() {
 		return tiResult;
 	}
-	
-	
-	
+
+	@Override
+	public void addMethod(Method m) {
+		String methodNameAndTypes = m.getReturnType().toString()+m.getName()+Arrays.toString(m.getArgumentTypes());
+		
+		if(methodsNamesAndTypes.contains(methodNameAndTypes)){
+			return;
+		}
+
+		methodsNamesAndTypes.add(methodNameAndTypes);
+		super.addMethod(m);
+	}
+
+	public void setMethodeGenerator(MethodGenerator methodGenerator) {
+		this.methodGenerator = methodGenerator;
+	}
+
+	public MethodGenerator getMethodGenerator() {
+		return methodGenerator;
+	}
+
+
 }

src/de/dhbwstuttgart/bytecode/DHBWInstructionFactory.java

@@ -2,6 +2,8 @@ package de.dhbwstuttgart.bytecode;
 
 import java.awt.List;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.apache.commons.bcel6.Constants;
 import org.apache.commons.bcel6.classfile.Attribute;
@@ -26,11 +28,13 @@ import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Return;
 import de.dhbwstuttgart.syntaxtree.type.FunN;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 
 public class DHBWInstructionFactory extends InstructionFactory{
 
 	private DHBWConstantPoolGen cp;
 	private ClassGenerator cg;
+	private static Map<String, Integer> storeIndexes = new HashMap<>();
 	
 	public DHBWInstructionFactory(ClassGenerator cg, DHBWConstantPoolGen cp) {
 		super(cg, cp);
@@ -46,7 +50,7 @@ public class DHBWInstructionFactory extends InstructionFactory{
 	 * @param lambdaMethod
 	 * @return
 	 */
-	public INVOKEDYNAMIC createInvokeDynamic( String interfaceMethodName, String invokeDynamicMethodType, FunN interfaceMethodType, MethodGen lambdaMethod ) {
+	public INVOKEDYNAMIC createInvokeDynamic( String interfaceMethodName, String invokeDynamicMethodType, FunN interfaceMethodType, MethodGen lambdaMethod, TypeinferenceResultSet rs) {
 		//Zuerst die Bootstrap-Methode erstellen: Diese müssen dann in ein BootstrapMethods-Attribut zusammengefasst und dem Classfile hinzugefügt werden
 		//this.cp.addMethodref(lambdaMethod);
 		
@@ -67,7 +71,7 @@ public class DHBWInstructionFactory extends InstructionFactory{
 		
 		String lambdaTypeParameterList = "()";
 		ConstantMethodType lambdaMethodType1 = new ConstantMethodType(this.cp.addUtf8(interfaceMethodType.getBytecodeInvokeDynamicSignatureUpperBound(cg))); //TODO: Hier den Grund finden, warum Object stehen muss.
-		ConstantMethodType lambdaMethodType = new ConstantMethodType(this.cp.addUtf8(interfaceMethodType.getBytecodeInvokeDynamicSignature(cg)));
+		ConstantMethodType lambdaMethodType = new ConstantMethodType(this.cp.addUtf8(interfaceMethodType.getBytecodeInvokeDynamicSignature(cg, rs)));
 		int implMethodKind = 7; // 7 = InvokeSpecial @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.5
 		ConstantMethodHandle implMethod = new ConstantMethodHandle(implMethodKind,cg.getConstantPool().addMethodref(lambdaMethod)); //Das zweite Argument ist der MethodRef zur LambdaMethode
 		
@@ -96,7 +100,7 @@ public class DHBWInstructionFactory extends InstructionFactory{
 		for(int i = 0; i<arguments.size();i++){
 			argumentsArray[i] = arguments.get(i);
 		}
-		BootstrapMethod bMethod = new BootstrapMethod(lambdaMetafactoryHandle, arguments.size(), argumentsArray);
+		BootstrapMethod bMethod = new BootstrapMethod(lambdaMetafactoryHandle, argumentsArray);
 		
         int index;
         
@@ -135,11 +139,6 @@ public class DHBWInstructionFactory extends InstructionFactory{
         return new INVOKEDYNAMIC(index);
 	}
 
-	public LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
-		int index = 1; //TODO: Hier muss ein Logger her, welcher aufzeichnet, an welcher Position welche Variable liegt.
-		return InstructionFactory.createLoad(bytecodeType, index);
-	}
-
 	public static Type createObjectType() {
 		return new org.apache.commons.bcel6.generic.ObjectType("java.lang.Object");
 	}

src/de/dhbwstuttgart/bytecode/MethodGenerator.java

@@ -1,36 +1,74 @@
 package de.dhbwstuttgart.bytecode;
 
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
+
+import org.apache.commons.bcel6.classfile.Attribute;
+import org.apache.commons.bcel6.classfile.ConstantPool;
+import org.apache.commons.bcel6.classfile.ConstantUtf8;
 import org.apache.commons.bcel6.classfile.Method;
 import org.apache.commons.bcel6.classfile.Signature;
+import org.apache.commons.bcel6.classfile.StackMap;
+import org.apache.commons.bcel6.classfile.StackMapEntry;
+import org.apache.commons.bcel6.classfile.Visitor;
+import org.apache.commons.bcel6.generic.BranchInstruction;
 import org.apache.commons.bcel6.generic.ConstantPoolGen;
+import org.apache.commons.bcel6.generic.Instruction;
+import org.apache.commons.bcel6.generic.InstructionFactory;
 import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.LocalVariableInstruction;
 import org.apache.commons.bcel6.generic.MethodGen;
+import org.apache.commons.bcel6.generic.StackMapTableGen;
 import org.apache.commons.bcel6.generic.Type;
 
+import org.apache.commons.bcel6.Const;
+
+import de.dhbwstuttgart.bytecode.stackmaptable.CodeHelper;
+import de.dhbwstuttgart.logger.Logger;
+import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 
 public class MethodGenerator extends MethodGen{
 
+	private Map<String, Integer> storeIndexes = new HashMap<>();
+
 	public MethodGenerator(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name,
-			String class_name, InstructionList il, ConstantPoolGen cp) {
+			String class_name, InstructionList il, ConstantPoolGen cp) {		
 		super(access_flags, return_type, arg_types, arg_names, method_name, class_name, il, cp);
+		
+		for(String name: arg_names){
+			getStoreIndex(name);
+		}
 	}
 	
-	public Method createMethod(ClassGenerator cg, ParameterList parameter, de.dhbwstuttgart.syntaxtree.type.Type retType, Block block){
+	public Method createMethod(ClassGenerator cg, ParameterList parameter, de.dhbwstuttgart.syntaxtree.type.Type retType, Block block, TypeinferenceResultSet rs){
 		MethodGen method = this;
 		DHBWInstructionFactory factory = cg.getInstructionFactory();
 		
-		InstructionList blockInstructions = block.genByteCode(cg);
+		InstructionList blockInstructions = block.genByteCode(cg, rs);
 		InstructionList il = this.getInstructionList();
 		
 		il.append(blockInstructions);//Die vom Block generierten Instructions an die InstructionList der Methode anfügen
 		//Ein return Statement anfügen, falls nicht vorhanden:
+		//TODO: Das ist schlecht! Der Parser oder der Typinferenzalgorithmus muss dafür sorgen, dass sich in jeder Methode ein Return befindet.
 		if (block.get_Statement().size() == 0) { il.append(factory.createReturn( org.apache.commons.bcel6.generic.Type.VOID)); }
 		else {
-				if (!(block.get_Statement().lastElement() instanceof Return)) { il.append(factory.createReturn( org.apache.commons.bcel6.generic.Type.VOID)); }
+				if (!(block.get_Statement().lastElement() instanceof Return) &&
+						this.getType().equals(org.apache.commons.bcel6.generic.Type.VOID)) {
+						il.append(factory.createReturn( org.apache.commons.bcel6.generic.Type.VOID));
+					}
 		}
 		
 		method.stripAttributes(true);
@@ -39,13 +77,38 @@ public class MethodGenerator extends MethodGen{
 		//Die korrekte Signatur für die Methode anhängen. Hier sind dann auch die Parameter von RefTypes enthalten:
 		String paramTypesSig = "(";
 		for(FormalParameter p : parameter){
-			paramTypesSig += p.getType().getBytecodeSignature(cg);
+			paramTypesSig += p.getType().getBytecodeSignature(cg, rs);
+			
+			Logger.getLogger("MethodGenerator").error(paramTypesSig, Section.CODEGEN);
 		}
 		paramTypesSig += ")";
-		String retTypeSig = retType.getBytecodeSignature(cg);
+		String retTypeSig = retType.getBytecodeSignature(cg, rs);
+		
 		method.addAttribute(factory.createSignatureAttribute(paramTypesSig+retTypeSig));
 		
+		StackMap stackMap = new StackMapTableGen(this, cp).getStackMap();
+		if(stackMap != null)method.addCodeAttribute(stackMap);
+		
 		return method.getMethod();
 	}
 	
+	public LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
+		return InstructionFactory.createLoad(bytecodeType, getStoreIndex(variableName));
+	}
+	
+	public LocalVariableInstruction createStore(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
+		return InstructionFactory.createStore(bytecodeType, getStoreIndex(variableName));
+	}
+	
+	public Integer getStoreIndex(String variableName) {
+		if(storeIndexes.get(variableName) == null){
+			Integer index = storeIndexes.size()+1;
+			storeIndexes.put(variableName, index);
+		}
+		
+		return storeIndexes.get(variableName);
+	}
+	
+		
 }
+

src/de/dhbwstuttgart/bytecode/stackmaptable/CodeHelper.java

@@ -0,0 +1,710 @@
+package de.dhbwstuttgart.bytecode.stackmaptable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Stack;
+
+import org.apache.commons.bcel6.generic.ALOAD;
+import org.apache.commons.bcel6.generic.ASTORE;
+import org.apache.commons.bcel6.generic.ArrayType;
+import org.apache.commons.bcel6.generic.BasicType;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.ConstantPoolGen;
+import org.apache.commons.bcel6.generic.DSTORE;
+import org.apache.commons.bcel6.generic.GETFIELD;
+import org.apache.commons.bcel6.generic.GotoInstruction;
+import org.apache.commons.bcel6.generic.IINC;
+import org.apache.commons.bcel6.generic.INVOKEDYNAMIC;
+import org.apache.commons.bcel6.generic.INVOKEINTERFACE;
+import org.apache.commons.bcel6.generic.Instruction;
+import org.apache.commons.bcel6.generic.InstructionHandle;
+import org.apache.commons.bcel6.Const;
+import org.apache.commons.bcel6.classfile.ConstantPool;
+import org.apache.commons.bcel6.classfile.StackMapEntry;
+import org.apache.commons.bcel6.classfile.StackMapType;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.InstructionTargeter;
+import org.apache.commons.bcel6.generic.InvokeInstruction;
+import org.apache.commons.bcel6.generic.LDC;
+import org.apache.commons.bcel6.generic.NEW;
+import org.apache.commons.bcel6.generic.ObjectType;
+import org.apache.commons.bcel6.generic.PUTFIELD;
+import org.apache.commons.bcel6.generic.ReferenceType;
+import org.apache.commons.bcel6.generic.StoreInstruction;
+import org.apache.commons.bcel6.generic.Type;
+
+import de.dhbwstuttgart.bytecode.MethodGenerator;
+import de.dhbwstuttgart.typeinference.Menge;
+
+class JVMState{
+	
+	HashMap<Integer, StackItem> localVars = new HashMap<>();
+	Stack<StackItem> stack = new Stack();
+	
+	public StackItem getLocalType(int index) {
+		return localVars.get(index);
+	}
+
+	public void set(int index, StackItem objectRef) {
+		localVars.put(index, objectRef);
+	}
+	
+	public void push(StackItem si){
+		
+	}
+	
+	void pop(int i){
+		
+	}
+
+	public StackItem pop() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	public Menge<StackMapType> getStackTypes(ConstantPoolGen cp){
+		Menge<StackMapType> ret = new Menge<StackMapType>();
+		for(StackItem si : stack){
+			ret.add(si.getType(cp));
+		}
+		return ret;
+	}
+
+	public Menge<StackMapType> getLocalTypes(ConstantPoolGen cp) {
+		Menge<StackMapType> ret = new Menge<StackMapType>();
+		//TODO
+		return ret;
+	}
+
+	
+}
+
+interface StackItem{
+	public static final StackItem NULL = new StackItemNull();
+	public static final StackItem INTEGER = new StackItemType(BasicType.INT);
+	public static final StackItem FLOAT = new StackItemType(BasicType.FLOAT);
+	public static final StackItem LONG = new StackItemType(BasicType.LONG);
+	public static final StackItem DOUBLE = new StackItemType(BasicType.DOUBLE);
+	public static final StackItem TOP = new StackItemTop();
+	
+	StackMapType getType(ConstantPoolGen cp);
+}
+
+class StackItemNull implements StackItem{
+
+	@Override
+	public StackMapType getType(ConstantPoolGen cp) {
+		return new StackMapType(Const.ITEM_Null, 0, cp.getConstantPool());
+	}
+}
+class StackItemType implements StackItem{
+
+	Type t = null;
+	
+	//TODO: BasicType kann auch Void sein, dann ändert sich nichts am Stack
+	public StackItemType(BasicType b){
+		t=b;
+	}
+	public StackItemType(ReferenceType r){
+		t=r;
+	}
+	public StackItemType(Type t){
+		t=t;
+	}
+	@Override
+	public StackMapType getType(ConstantPoolGen cp) {
+		if(t instanceof BasicType){
+			return null;//TODO
+		}else if(t instanceof ObjectType){
+			int classInfo = cp.addClass(((ObjectType)t));
+			return new StackMapType(Const.ITEM_Object,classInfo,cp.getConstantPool());
+		}else if(t instanceof ArrayType){
+			return null; //TODO
+		}else{
+			return null;
+		}
+	}
+}
+class StackItemTop implements StackItem{
+
+	@Override
+	public StackMapType getType(ConstantPoolGen cp) {
+		return new StackMapType(Const.ITEM_Bogus,0,cp.getConstantPool());
+	}
+	
+}
+class StackItemUninitialized implements StackItem{
+	private NEW newIns;
+	private InstructionHandle handle;
+	public StackItemUninitialized(NEW newInstruction, InstructionHandle instructionHandle){
+		newIns = newInstruction;
+		handle = instructionHandle;
+	}
+	
+	@Override
+	public StackMapType getType(ConstantPoolGen cp) {
+		return new StackMapType(Const.ITEM_NewObject,handle.getPosition(),cp.getConstantPool());
+	}
+	
+}
+/*
+class StackItemObject implements StackItem{
+	public StackItemObject(String objName){
+		
+	}
+}
+*/
+public class CodeHelper {
+	
+	private ArrayList<Integer> outputStack = new ArrayList<>();
+	
+    /**
+     * Generiert die StackMapEntrys zu einer gegebenen Methode
+     * @param forCode
+     * @return
+     */
+    public static Menge<StackMapEntry> getStackMapEntries(InstructionList forCode, ConstantPoolGen cp){
+    	Menge<StackMapEntry> ret = new Menge<>();
+    	JVMState state = new JVMState();
+    	if(forCode.isEmpty())return new Menge<>();
+    	forCode.setPositions(); //Otherwise InstructionHandle positions are wrong
+    	Instruction[] instructions = forCode.getInstructions();
+    	InstructionHandle[] instructionHandles = forCode.getInstructionHandles();
+    	int lastPosition = 0;
+    	
+    	for(InstructionHandle ih : forCode.getInstructionHandles()){
+    		getOutput(ih, state, cp);
+    		if(isFrameEndpoint(ih, forCode)){
+    			if(!state.stack.isEmpty()){
+    				StackMapEntry entry = generateFullFrame(ih.getPosition(),state, cp);
+        			ret.add(entry);
+    			}else{
+    				int offset = ih.getPosition()-lastPosition;
+    				ret.add(new StackMapEntry(Const.SAME_FRAME + offset, 0, null, null, cp.getConstantPool()));
+    			}
+    			lastPosition = ih.getPosition()+1;
+    		}
+    	}
+    	return ret;
+    }
+    
+    public static StackMapEntry generateFullFrame(int bytecodeOffset, JVMState state, ConstantPoolGen cp){
+    	Menge<StackMapType> stackTypes = state.getStackTypes(cp);
+    	Menge<StackMapType> localTypes = state.getLocalTypes(cp);
+    	StackMapType[] st = null;
+    	StackMapType[] lt = null;
+    	if(!stackTypes.isEmpty())st = stackTypes.toArray();
+    	if(!localTypes.isEmpty())lt = localTypes.toArray();
+    	StackMapEntry ret = new StackMapEntry(Const.FULL_FRAME,bytecodeOffset, lt, st, cp.getConstantPool());
+    	return ret;
+    }
+    
+    /**
+     * Ein Frame hört bei einem unconditionalBranch auf bzw. fängt bei dem Sprungziel eines Branches an.
+     * @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.1
+     * @param position
+     * @param inCode
+     * @return
+     */
+    private static boolean isFrameEndpoint(InstructionHandle position, InstructionList inCode){
+    	if(position.getInstruction() instanceof GotoInstruction){
+    		//Falls Instruktion ein unconditional Branch ist:
+    		return true;
+    	}
+    	for(InstructionHandle i : inCode.getInstructionHandles()){
+    		if(i.hasTargeters()){
+    			for(InstructionTargeter target : i.getTargeters()){
+    				if(target.containsTarget(position))return true;
+    			}
+    		}
+    		/*
+    		if(i instanceof BranchInstruction){
+    			inCode.getInstructionHandles()[1].getTargeters()
+    			if(((BranchInstruction) i).containsTarget(position)){
+    				return true;
+    			}
+    		}
+    		*/
+    	}
+    	return false;
+    }
+    
+    static void getOutput(InstructionHandle instructionHandle, JVMState ret, ConstantPoolGen cp){
+    	/*
+    	 * TODO:
+    	 * Berechnet den Output auf den Stack und ändert den LocalVarState und den StackState je nach Instruktion ab
+    	 */
+    	Instruction ins = instructionHandle.getInstruction();
+    	int opcode = ins.getOpcode();
+    	StackItem t1,t2,t3,t4;
+        switch (opcode) {
+        case Const.NOP:
+        case Const.INEG:
+        case Const.LNEG:
+        case Const.FNEG:
+        case Const.DNEG:
+        case Const.I2B:
+        case Const.I2C:
+        case Const.I2S:
+        case Const.GOTO:
+        case Const.RETURN:
+            break;
+        case Const.ACONST_NULL:
+        	ret.push(StackItem.NULL);
+            break;
+        case Const.ICONST_M1:
+        case Const.ICONST_0:
+        case Const.ICONST_1:
+        case Const.ICONST_2:
+        case Const.ICONST_3:
+        case Const.ICONST_4:
+        case Const.ICONST_5:
+        case Const.BIPUSH:
+        case Const.SIPUSH:
+        case Const.ILOAD:
+        	ret.push(StackItem.INTEGER);
+            break;
+        case Const.LCONST_0:
+        case Const.LCONST_1:
+        case Const.LLOAD:
+            ret.push(StackItem.LONG);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.FCONST_0:
+        case Const.FCONST_1:
+        case Const.FCONST_2:
+        case Const.FLOAD:
+        	ret.push(StackItem.FLOAT);
+            break;
+        case Const.DCONST_0:
+        case Const.DCONST_1:
+        case Const.DLOAD:
+        	ret.push(StackItem.DOUBLE);
+        	ret.push(StackItem.TOP);
+            break;
+        case Const.LDC:
+        	LDC ldcIns = (LDC) ins;
+        	Type t = ldcIns.getType(cp);
+        	if(t.equals(Type.STRING)){
+        		ret.push(new StackItemType(Type.STRING));
+        	}else if(t.equals(Type.INT)){
+        		ret.push(StackItem.INTEGER);
+        	}else if(t.equals(Type.FLOAT)){
+        		ret.push(StackItem.FLOAT);
+        	}else if(t.equals(Type.DOUBLE)){
+        		ret.push(StackItem.DOUBLE);
+                ret.push(StackItem.TOP);
+        	}else if(t.equals(Type.FLOAT)){
+        		ret.push(StackItem.LONG);
+                ret.push(StackItem.TOP);
+        	}else if(t.equals(Type.CLASS)){
+        		ret.push(new StackItemType(Type.CLASS));
+        	}
+        	/*
+            switch (item.type) {
+            case ClassWriter.INT:
+                ret.push(StackItem.INTEGER);
+                break;
+            case ClassWriter.StackItem.LONG:
+                ret.push(StackItem.LONG);
+                ret.push(StackItem.TOP);
+                break;
+            case ClassWriter.StackItem.FLOAT:
+                ret.push(StackItem.FLOAT);
+                break;
+            case ClassWriter.StackItem.DOUBLE:
+                ret.push(StackItem.DOUBLE);
+                ret.push(StackItem.TOP);
+                break;
+            case ClassWriter.CLASS:
+                ret.push(new StackItemOBJECT("java/lang/Class"));
+                break;
+            case ClassWriter.STR:
+            	ret.push(new StackItemOBJECT("java/lang/String"));
+            	break;
+            case ClassWriter.MTYPE:
+            	ret.push(new StackItemOBJECT("java/lang/invoke/MethodType"));
+            	break;
+            // case ClassWriter.HANDLE_BASE + [1..9]:
+            default:
+            	ret.push(new StackItemOBJECT("java/lang/invoke/MethodHandle"));
+            	break;
+            }
+            */
+            break;
+        case Const.ALOAD:
+        	ALOAD aloadIns = (ALOAD) ins;
+        	ret.push(ret.getLocalType(aloadIns.getIndex()));
+            break;
+        case Const.IALOAD:
+        case Const.BALOAD:
+        case Const.CALOAD:
+        case Const.SALOAD:
+            ret.pop(2);
+            ret.push(StackItem.INTEGER);
+            break;
+        case Const.LALOAD:
+        case Const.D2L:
+            ret.pop(2);
+            ret.push(StackItem.LONG);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.FALOAD:
+            ret.pop(2);
+            ret.push(StackItem.FLOAT);
+            break;
+        case Const.DALOAD:
+        case Const.L2D:
+            ret.pop(2);
+            ret.push(StackItem.DOUBLE);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.AALOAD:
+            ret.pop(1);
+            StackItem arrayReference = ret.pop();
+            ret.push(arrayReference); //TODO: Fixen, es darf nicht die ArrayReference sonder der Typ eines Elements des Arrays auf den Stack
+            //ret.push(ELEMENT_OF + t1);
+            break;
+        case Const.ISTORE:
+        case Const.FSTORE:
+        case Const.ASTORE:
+        	StoreInstruction storeIns = (StoreInstruction)ins;
+            t1 = ret.pop();
+            ret.set(storeIns.getIndex(), t1);
+            if (storeIns.getIndex() > 0) {
+                t2 = ret.getLocalType(storeIns.getIndex() - 1);
+                // if t2 is of kind STACK or LOCAL we cannot know its size!
+                if (t2 == StackItem.LONG || t2 == StackItem.DOUBLE) {
+                    ret.set(storeIns.getIndex() - 1, StackItem.TOP);
+                } 
+                //TODO:
+                /*else if ((t2 & KIND) != BASE) {
+                    set(arg - 1, t2 | StackItem.TOP_IF_StackItem.LONG_OR_StackItem.DOUBLE);
+                }*/
+            }
+            break;
+        case Const.LSTORE:
+        case Const.DSTORE:
+        	StoreInstruction largeStoreIns = (StoreInstruction)ins;
+            ret.pop(1);
+            t1 = ret.pop();
+            ret.set(largeStoreIns.getIndex(), t1);
+            ret.set(largeStoreIns.getIndex() + 1, StackItem.TOP);
+            if (largeStoreIns.getIndex() > 0) {
+                t2 = ret.getLocalType(largeStoreIns.getIndex() - 1);
+                // if t2 is of kind STACK or LOCAL we cannot know its size!
+                if (t2 == StackItem.LONG || t2 == StackItem.DOUBLE) {
+                    ret.set(largeStoreIns.getIndex() - 1, StackItem.TOP);
+                } //TODO:
+                /*else if ((t2 & KIND) != BASE) {
+                    set(arg - 1, t2 | StackItem.TOP_IF_StackItem.LONG_OR_StackItem.DOUBLE);
+                }*/
+            }
+            break;
+        case Const.IASTORE:
+        case Const.BASTORE:
+        case Const.CASTORE:
+        case Const.SASTORE:
+        case Const.FASTORE:
+        case Const.AASTORE:
+            ret.pop(3);
+            break;
+        case Const.LASTORE:
+        case Const.DASTORE:
+            ret.pop(4);
+            break;
+        case Const.POP:
+        case Const.IFEQ:
+        case Const.IFNE:
+        case Const.IFLT:
+        case Const.IFGE:
+        case Const.IFGT:
+        case Const.IFLE:
+        case Const.IRETURN:
+        case Const.FRETURN:
+        case Const.ARETURN:
+        case Const.TABLESWITCH:
+        case Const.LOOKUPSWITCH:
+        case Const.ATHROW:
+        case Const.MONITORENTER:
+        case Const.MONITOREXIT:
+        case Const.IFNULL:
+        case Const.IFNONNULL:
+            ret.pop(1);
+            break;
+        case Const.POP2:
+        case Const.IF_ICMPEQ:
+        case Const.IF_ICMPNE:
+        case Const.IF_ICMPLT:
+        case Const.IF_ICMPGE:
+        case Const.IF_ICMPGT:
+        case Const.IF_ICMPLE:
+        case Const.IF_ACMPEQ:
+        case Const.IF_ACMPNE:
+        case Const.LRETURN:
+        case Const.DRETURN:
+            ret.pop(2);
+            break;
+        case Const.DUP:
+            t1 = ret.pop();
+            ret.push(t1);
+            ret.push(t1);
+            break;
+        case Const.DUP_X1:
+            t1 = ret.pop();
+            t2 = ret.pop();
+            ret.push(t1);
+            ret.push(t2);
+            ret.push(t1);
+            break;
+        case Const.DUP_X2:
+            t1 = ret.pop();
+            t2 = ret.pop();
+            t3 = ret.pop();
+            ret.push(t1);
+            ret.push(t3);
+            ret.push(t2);
+            ret.push(t1);
+            break;
+        case Const.DUP2:
+            t1 = ret.pop();
+            t2 = ret.pop();
+            ret.push(t2);
+            ret.push(t1);
+            ret.push(t2);
+            ret.push(t1);
+            break;
+        case Const.DUP2_X1:
+            t1 = ret.pop();
+            t2 = ret.pop();
+            t3 = ret.pop();
+            ret.push(t2);
+            ret.push(t1);
+            ret.push(t3);
+            ret.push(t2);
+            ret.push(t1);
+            break;
+        case Const.DUP2_X2:
+            t1 = ret.pop();
+            t2 = ret.pop();
+            t3 = ret.pop();
+            t4 = ret.pop();
+            ret.push(t2);
+            ret.push(t1);
+            ret.push(t4);
+            ret.push(t3);
+            ret.push(t2);
+            ret.push(t1);
+            break;
+        case Const.SWAP:
+            t1 = ret.pop();
+            t2 = ret.pop();
+            ret.push(t1);
+            ret.push(t2);
+            break;
+        case Const.IADD:
+        case Const.ISUB:
+        case Const.IMUL:
+        case Const.IDIV:
+        case Const.IREM:
+        case Const.IAND:
+        case Const.IOR:
+        case Const.IXOR:
+        case Const.ISHL:
+        case Const.ISHR:
+        case Const.IUSHR:
+        case Const.L2I:
+        case Const.D2I:
+        case Const.FCMPL:
+        case Const.FCMPG:
+            ret.pop(2);
+            ret.push(StackItem.INTEGER);
+            break;
+        case Const.LADD:
+        case Const.LSUB:
+        case Const.LMUL:
+        case Const.LDIV:
+        case Const.LREM:
+        case Const.LAND:
+        case Const.LOR:
+        case Const.LXOR:
+            ret.pop(4);
+            ret.push(StackItem.LONG);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.FADD:
+        case Const.FSUB:
+        case Const.FMUL:
+        case Const.FDIV:
+        case Const.FREM:
+        case Const.L2F:
+        case Const.D2F:
+            ret.pop(2);
+            ret.push(StackItem.FLOAT);
+            break;
+        case Const.DADD:
+        case Const.DSUB:
+        case Const.DMUL:
+        case Const.DDIV:
+        case Const.DREM:
+            ret.pop(4);
+            ret.push(StackItem.DOUBLE);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.LSHL:
+        case Const.LSHR:
+        case Const.LUSHR:
+            ret.pop(3);
+            ret.push(StackItem.LONG);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.IINC:
+            ret.set(((IINC)ins).getIndex(), StackItem.INTEGER);
+            break;
+        case Const.I2L:
+        case Const.F2L:
+            ret.pop(1);
+            ret.push(StackItem.LONG);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.I2F:
+            ret.pop(1);
+            ret.push(StackItem.FLOAT);
+            break;
+        case Const.I2D:
+        case Const.F2D:
+            ret.pop(1);
+            ret.push(StackItem.DOUBLE);
+            ret.push(StackItem.TOP);
+            break;
+        case Const.F2I:
+        case Const.ARRAYLENGTH:
+        case Const.INSTANCEOF:
+            ret.pop(1);
+            ret.push(StackItem.INTEGER);
+            break;
+        case Const.LCMP:
+        case Const.DCMPL:
+        case Const.DCMPG:
+            ret.pop(4);
+            ret.push(StackItem.INTEGER);
+            break;
+        case Const.JSR:
+        case Const.RET:
+            throw new RuntimeException(
+                    "JSR/RET are not supported with computeFrames option"); //TODO: Fehlermeldung anpassen
+        case Const.GETSTATIC:
+            //ret.push(cw, item.strVal3); //TODO
+            break;
+        case Const.PUTSTATIC:
+            //ret.pop(item.strVal3); //TODO
+            break;
+        case Const.GETFIELD:
+        	GETFIELD getfieldIns = (GETFIELD) ins;
+            ret.pop(1);
+            ret.push(new StackItemType(getfieldIns.getFieldType(cp)));
+            break;
+        case Const.PUTFIELD:
+        	PUTFIELD putfieldIns = (PUTFIELD) ins;
+            ret.pop(putfieldIns.consumeStack(cp));
+            break;
+        case Const.INVOKEVIRTUAL:
+        case Const.INVOKESPECIAL:
+        case Const.INVOKESTATIC:
+        case Const.INVOKEINTERFACE:
+        case Const.INVOKEDYNAMIC:
+        	InvokeInstruction invokeIns = (InvokeInstruction) ins;
+        	ret.pop(invokeIns.consumeStack(cp));
+        	/*
+        	 * TODO:
+        	 * Hier return new StackItemOBJECT(returnTypeDerMethode);
+        	 * returnTypeDerMethode bestimmen indem man im ConstantPool nach dem Argument für die Instruktion nachsieht.
+        	 * Wie kann man bestimmen, ob es sich um Object oder primären Datentyp handelt. bcel-Typen verwenden? Müsste dann weiter oben auch gepatcht werden.
+        	 */
+            /*
+             ret.pop(item.strVal3);
+            
+            if (opcode != Const.INVOKESTATIC) {
+                t1 = ret.pop();
+                if (opcode == Const.INVOKESPECIAL
+                        && item.strVal2.charAt(0) == '<') {
+                    init(t1);
+                }
+            }
+            
+            ret.push(cw, item.strVal3);
+            */
+        	Type retType = invokeIns.getReturnType(cp);
+        	if(retType instanceof BasicType){
+        		ret.push(new StackItemType((BasicType)retType));
+        	}else if(retType instanceof ArrayType){
+        		//TODO
+        	}else if(retType instanceof ReferenceType){
+        		ret.push(new StackItemType((ReferenceType) retType));
+        	}
+            break;
+        case Const.NEW:
+        	NEW newIns = (NEW) ins;
+            ret.push(new StackItemUninitialized(newIns, instructionHandle));
+        	//ret.push(UNINITIALIZED | cw.addUninitializedType(item.strVal1, arg));
+            break;
+            /*
+        case Const.NEWARRAY:
+            ret.pop();
+            switch (arg) {
+            case Const.T_BOOLEAN:
+                ret.push(ARRAY_OF | BOOLEAN);
+                break;
+            case Const.T_CHAR:
+                ret.push(ARRAY_OF | CHAR);
+                break;
+            case Const.T_BYTE:
+                ret.push(ARRAY_OF | BYTE);
+                break;
+            case Const.T_SHORT:
+                ret.push(ARRAY_OF | SHORT);
+                break;
+            case Const.T_INT:
+                ret.push(ARRAY_OF | StackItem.INTEGER);
+                break;
+            case Const.T_StackItem.FLOAT:
+                ret.push(ARRAY_OF | StackItem.FLOAT);
+                break;
+            case Const.T_StackItem.DOUBLE:
+                ret.push(ARRAY_OF | StackItem.DOUBLE);
+                break;
+            // case Const.T_StackItem.LONG:
+            default:
+                ret.push(ARRAY_OF | StackItem.LONG);
+                break;
+            }
+            break;
+        case Const.ANEWARRAY:
+            String s = item.strVal1;
+            ret.pop();
+            if (s.charAt(0) == '[') {
+                ret.push(cw, '[' + s);
+            } else {
+                ret.push(ARRAY_OF | OBJECT | cw.addType(s));
+            }
+            break;
+        case Const.CHECKCAST:
+            s = item.strVal1;
+            ret.pop();
+            if (s.charAt(0) == '[') {
+                ret.push(cw, s);
+            } else {
+                ret.push(OBJECT | cw.addType(s));
+            }
+            break;
+        // case Const.MULTIANEWARRAY:
+        default:
+            ret.pop(arg);
+            ret.push(cw, item.strVal1);
+            break;
+        */
+        }
+    }
+
+
+}

src/de/dhbwstuttgart/core/MyCompiler.java

@@ -159,11 +159,11 @@ public class MyCompiler implements MyCompilerAPI{
 			FunNInterface funN = new FunNInterface(i);
 			ret.add(funN.getPublicFieldAssumptions());
 		}
-		for(int i = 0; i<6; i++){
-			FunVoidNInterface funN = new FunVoidNInterface(i);
-			ret.add(funN.getPublicFieldAssumptions());
-		}
-		
+		//Keine FunVoidInterfaces in den Assumptions.
+		//for(int i = 0; i<6; i++){
+		//	FunVoidNInterface funN = new FunVoidNInterface(i);
+		//	ret.add(funN.getPublicFieldAssumptions());
+		//}
 		
 		return ret;
 	}
@@ -209,43 +209,6 @@ public class MyCompiler implements MyCompilerAPI{
         return OutputDir;
     }
     
-    /**
-     * @author Arne Lüdtke
-     * Ersetzt alle GTVs durch TPHs mit gleichem Namen. Arbeitet Rekursiv.
-     * ACHTUNG: BACKDOOR CREATE!!! Nur für Testzwecke verwenden.
-     * @param T - Typ, bei welchem die GTVs ersetzt werden sollen.
-     */
-    public static Type makeGenericTypeVars2TypePlaceHolders(Type T)
-    {
-    	if(T instanceof RefType)
-    	{
-    		RefType refT = (RefType)T;
-    		if(refT.get_ParaList() != null)
-    		{
-    			Menge<Type> paras = refT.get_ParaList();
-    			for(int i = 0; i<paras.size();i++)
-    			{
-    				Type tt = paras.elementAt(i);
-    				if(tt instanceof GenericTypeVar)
-    				{
-    					GenericTypeVar gtv = (GenericTypeVar)tt;
-    					paras.set(i,TypePlaceholder.backdoorCreate(gtv.getName().toString()));
-    				}
-    				else
-    				{
-    					makeGenericTypeVars2TypePlaceHolders(tt);
-    				}
-    			}
-    		}
-    	}
-    	else if(T instanceof IMatchable)
-    	{
-    		Type TT = ((IMatchable)T).getMatchType();
-    		makeGenericTypeVars2TypePlaceHolders(TT);
-    	}
-    	return T;
-    }
-
     /**
      * Parst den Inhalt einer Datei zu einem Syntaxbaum.
      */
@@ -328,3 +291,4 @@ public class MyCompiler implements MyCompilerAPI{
 		return ret;
 	}
 }
+

src/de/dhbwstuttgart/logger/Logger.java

@@ -94,6 +94,7 @@ public class Logger {
 
 	public static String getWholeLog(){
 		String ret = "";
+		LOG_HISTORY.removeIf((logLine)->logLine==null);
 		Logger.LOG_HISTORY.sort((log1, log2)->log1.timestamp.compareTo(log2.timestamp));
 		ret += Logger.LOG_HISTORY.toString();
 		return ret;
@@ -127,11 +128,11 @@ class LogHistory extends ArrayList<LogLine>{
 	
 	@Override
 	public String toString(){
-		String ret = "";
+		StringBuilder ret = new StringBuilder();
 		for(LogLine l : this){
-			ret += l.toString() + "\n";
+			ret.append(l.toString() + "\n");
 		}
-		return ret;
+		return ret.toString();
 	}
 }
 

src/de/dhbwstuttgart/myexception/NotImplementedException.java

@@ -2,6 +2,14 @@ package de.dhbwstuttgart.myexception;
 
 public class NotImplementedException extends RuntimeException {
 
+	public NotImplementedException(String message) {
+		super(message);
+	}
+	
+	public NotImplementedException() {
+		super("Nicht implementiert");
+	}
+
 	/**
 	 * 
 	 */

src/de/dhbwstuttgart/parser/JavaParser.java

@@ -2298,7 +2298,7 @@ case 199:
   {
 						de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1!\n", Section.PARSER);
 						Assign Ass = new Assign(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
-						LocalOrFieldVar LOFV = new LocalOrFieldVar(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
+						LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
 						LOFV.set_UsedId(((UsedId)yyVals[-2+yyTop]));
 						/*auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());*/
 						/*auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());*/
@@ -2324,7 +2324,7 @@ case 200:
 					// line 1718 "./../src/de/dhbwstuttgart/parser/JavaParser.jay"
   {
 						Assign Ass =new Assign(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
-						LocalOrFieldVar LOFV = new LocalOrFieldVar(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
+						LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
 						LOFV.set_UsedId(((UsedId)yyVals[-2+yyTop]));
 						/*auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());*/
 						/*auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());*/
@@ -2561,7 +2561,7 @@ case 228:
 						    rec = new Receiver(INSTVA);
 						}
 						else if (((UsedId)yyVals[-2+yyTop]).get_Name().size() == 2) {
-						    LocalOrFieldVar LOFV = new LocalOrFieldVar(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
+						    LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname(((UsedId)yyVals[-2+yyTop]).getOffset(),((UsedId)yyVals[-2+yyTop]).getVariableLength());
 						    ((UsedId)yyVals[-2+yyTop]).removeLast();
 						    LOFV.set_UsedId(((UsedId)yyVals[-2+yyTop]));
 						    /*auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());*/
@@ -2593,7 +2593,7 @@ case 229:
 						    rec = new Receiver(INSTVA);
 						}
 						else if (((UsedId)yyVals[-3+yyTop]).get_Name().size() == 2) {
-						    LocalOrFieldVar LOFV = new LocalOrFieldVar(((UsedId)yyVals[-3+yyTop]).getOffset(),((UsedId)yyVals[-3+yyTop]).getVariableLength());
+						    LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname(((UsedId)yyVals[-3+yyTop]).getOffset(),((UsedId)yyVals[-3+yyTop]).getVariableLength());
 						    ((UsedId)yyVals[-3+yyTop]).removeLast();
 						    LOFV.set_UsedId(((UsedId)yyVals[-3+yyTop]));
 						    /*auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());*/
@@ -2744,7 +2744,7 @@ case 242:
 						    yyVal = INSTVA;
 						}
 						else {
-						    LocalOrFieldVar Postincexpr = new LocalOrFieldVar(((UsedId)yyVals[0+yyTop]).getOffset(),((UsedId)yyVals[0+yyTop]).getVariableLength());
+						    LocalOrFieldVarOrClassname Postincexpr = new LocalOrFieldVarOrClassname(((UsedId)yyVals[0+yyTop]).getOffset(),((UsedId)yyVals[0+yyTop]).getVariableLength());
 						    Postincexpr.set_UsedId(((UsedId)yyVals[0+yyTop]));
 						    /*auskommentiert von Andreas Stadelmeier (a10023) Postincexpr.setType(TypePlaceholder.fresh());*/
 						    yyVal=Postincexpr;

src/de/dhbwstuttgart/parser/JavaParser.jay

@@ -1693,7 +1693,7 @@ assignment                       :lefthandside assignmentoperator assignmentexpr
 					{
 						de.dhbwstuttgart.logger.Logger.getLogger("parser").debug("\nParser --> Zuweisung1!\n", Section.PARSER);
 						Assign Ass = new Assign($1.getOffset(),$1.getVariableLength());
-						LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
+						LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname($1.getOffset(),$1.getVariableLength());
 						LOFV.set_UsedId($1);
 						//auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
 						//auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());
@@ -1717,7 +1717,7 @@ assignment                       :lefthandside assignmentoperator assignmentexpr
 				 | lefthandside assignmentoperator classinstancecreationexpression
 					{
 						Assign Ass =new Assign($1.getOffset(),$1.getVariableLength());
-						LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
+						LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname($1.getOffset(),$1.getVariableLength());
 						LOFV.set_UsedId($1);
 						//auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
 						//auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());
@@ -1939,7 +1939,7 @@ methodinvocation:
 						    rec = new Receiver(INSTVA);
 						}
 						else if ($1.get_Name().size() == 2) {
-						    LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
+						    LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname($1.getOffset(),$1.getVariableLength());
 						    $1.removeLast();
 						    LOFV.set_UsedId($1);
 						    //auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
@@ -1969,7 +1969,7 @@ methodinvocation:
 						    rec = new Receiver(INSTVA);
 						}
 						else if ($1.get_Name().size() == 2) {
-						    LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
+						    LocalOrFieldVarOrClassname LOFV = new LocalOrFieldVarOrClassname($1.getOffset(),$1.getVariableLength());
 						    $1.removeLast();
 						    LOFV.set_UsedId($1);
 						    //auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
@@ -2105,7 +2105,7 @@ postfixexpression              :primary
 						    $$ = INSTVA;
 						}
 						else {
-						    LocalOrFieldVar Postincexpr = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
+						    LocalOrFieldVarOrClassname Postincexpr = new LocalOrFieldVarOrClassname($1.getOffset(),$1.getVariableLength());
 						    Postincexpr.set_UsedId($1);
 						    //auskommentiert von Andreas Stadelmeier (a10023) Postincexpr.setType(TypePlaceholder.fresh());
 						    $$=Postincexpr;

src/de/dhbwstuttgart/syntaxtree/Class.java

@@ -7,6 +7,8 @@ import java.util.Collection;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
 
 import javax.lang.model.element.Modifier;
 
@@ -47,8 +49,7 @@ import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
-import de.dhbwstuttgart.typeinference.unify.FC_TTO;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 import  org.apache.commons.bcel6.generic.*;
 import  org.apache.commons.bcel6.classfile.*;
@@ -106,11 +107,11 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
         }
     	//Zuerst die Methoden und Felder abarbeiten:
     	for(Method m : methods){
-    		m.genByteCode(_cg);
+    		m.genByteCode(_cg, this);
     	}
     	InstructionList fieldInitializations = new InstructionList();
     	for(FieldDeclaration f : fieldDeclarations){
-    		fieldInitializations.append(f.genByteCode(_cg));
+    		fieldInitializations.append(f.genByteCode(_cg, typeinferenceResults.getTypeReconstructions().get(0)));
     	}
     	//Die Konstruktoren müssen die Feld initialisierungswerte beinhalten:
     	for(Constructor c : constructors){
@@ -168,59 +169,30 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     {
         this.superif = superif;
     }
-	
-    // ino.attribute.superclassid.23014.decldescription type=line
-    // private Status      status;
-    // ino.end
-    // ino.attribute.superclassid.23014.declaration 
-    public UsedId      superclassid = (SourceFile.READ_OBJECT_SUPERCLASSES_FROM_JRE?UsedId.createFromQualifiedName("Object",-1):null);
-    // ino.end
-    // ino.attribute.class_block.23020.decldescription type=line
-    // private Class       java;
-    // ino.end
-    // ino.attribute.class_block.23020.declaration 
-    private Block       class_block;
-    // ino.end
-    // ino.attribute.paralist.23023.declaration 
-    //private Menge<Type>      paralist = new Menge<Type>();    // Parameterliste 'class xy<para1, para2,...>{}' wird gespeichert
-    // ino.end
-    // ino.attribute.parahash.23026.declaration 
-    private Hashtable<String,String>   parahash = new Hashtable<String,String>();  // parametrisierten Attrib. werden mit den Paramet.aus paralist verk.
-    // ino.end
-    // ino.attribute.isFirstLocalVarDecl.23029.declaration 
-    public static boolean isFirstLocalVarDecl; //Hilfsvariable fuer Offsets, hoth
-    // ino.end
 
-    //private Menge<GenericTypeVar> genericClassParameters=new Menge<GenericTypeVar>();
-    
-    // ino.attribute.containedTypes.23032.decldescription type=line
+    public UsedId      superclassid = (SourceFile.READ_OBJECT_SUPERCLASSES_FROM_JRE?UsedId.createFromQualifiedName("Object",-1):null);
+
+    private Block       class_block;
+
+    private Hashtable<String,String>   parahash = new Hashtable<String,String>();  // parametrisierten Attrib. werden mit den Paramet.aus paralist verk.
+
+    public static boolean isFirstLocalVarDecl; //Hilfsvariable fuer Offsets, hoth
     // PL 05-07-30 eingefuegt. Vektor aller Typdeklarationen, die in der Klasse        
     // vorkommen. Wird in der Studienarbeit von Andreas Stadelmeier nur für Verifizierung der Tests eingesetzt.
-    // ino.end
-    // ino.attribute.containedTypes.23032.declaration 
     private Menge<Type> containedTypes = new Menge<Type>();
-    // ino.end
-    // ino.attribute.usedIdsToCheck.23035.declaration 
     private Menge<UsedId> usedIdsToCheck = new Menge<UsedId>();
-    // ino.end
 
     private TypeAssumptions typeAssumptions = null;//muss mit null Initialisiert werden. Darf nur über getTypeAssumptions abgerufen werden.
     
-    // ino.attribute.parserlog.23038.declaration 
-    //protected Logger parselog  = Logger.getLogger("parser");
-    // ino.end
 	protected Logger typinferenzLog = Logger.getLogger(Class.class.getName());
 	private SyntaxTreeNode parent;
 	private Menge<Field> fielddecl = new Menge<Field>();
 	private GenericDeclarationList genericClassParameters;
 	private int offset;
-	private Type superClass;
+	private RefType superClass;
 
     
-    // ino.method.Class.23041.definition 
     public Class(String name, int offset)
-    // ino.end
-    // ino.method.Class.23041.body 
     {
         this.name = name;
         if(name.equals("java.lang.Object")){
@@ -240,7 +212,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
      * @param modifiers
      * @param supertypeGenPara - Eine Liste von Namen, welche die Generischen Parameter der Klasse darstellen.
      */
-    public Class(String name, Type superClass, Modifiers modifiers, Menge supertypeGenPara) {
+    public Class(String name, RefType superClass, Modifiers modifiers, Menge<String> supertypeGenPara) {
 		this(name,superClass,modifiers,0);
 		if(supertypeGenPara == null)return;
 		Menge<GenericTypeVar> gtvs = new Menge<>();
@@ -261,7 +233,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
 		this.setGenericParameter(new GenericDeclarationList(gtvs,0));
 	}
     
-    public Class(String name, Type superClass, Modifiers mod, int offset){
+    public Class(String name, RefType superClass, Modifiers mod, int offset){
     	this(name,mod,offset);
     	if(superClass == null)this.superClass = new Class("java.lang.Object",-1).getType();
     	else this.superClass = superClass;
@@ -293,14 +265,14 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
 	public Class(String name2, Modifiers object, ClassBody classBody,
 			Menge<Type> containedTypes2, Menge<Type> typeMenge,
 			Menge<Type> paraMenge, int offset2) {
-		this(name2, object, classBody, containedTypes2,(Type)null, typeMenge, paraMenge, offset2);
+		this(name2, object, classBody, containedTypes2,(RefType)null, typeMenge, paraMenge, offset2);
 	}
     private static Menge<Type> usedIdToRefType(Menge<UsedId> superif2) {
 		Menge<Type> ret = new Menge<>();
 		for(UsedId id : superif2)ret.add(usedIdToRefType(id));
 		return ret;
 	}
-	private static Type usedIdToRefType(UsedId superclass2) {
+	private static RefType usedIdToRefType(UsedId superclass2) {
 		RefType ret = new RefType(superclass2.getSimpleName(), null, superclass2.getOffset());
 		ret.set_ParaList(superclass2.get_ParaList());
 		return ret;
@@ -314,7 +286,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     // ino.end
     // ino.method.Class.23047.definition 
     public Class(String name, Modifiers mod, ClassBody cb, Menge<Type> ct,
-            Type superclass, Menge<Type> Menge, Menge<? extends Type> paralist, int offset)
+            RefType superclass, Menge<Type> Menge, Menge<? extends Type> paralist, int offset)
     // ino.end
 // ino.method.Class.23047.body 
 {
@@ -582,7 +554,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
 	*/
     
     // ino.method.get_ParaList.23101.definition 
-    public Menge<? extends Type> get_ParaList()
+    public List<? extends Type> get_ParaList()
     // ino.end
     // ino.method.get_ParaList.23101.body 
     {
@@ -625,7 +597,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
      */
     // ino.end
     // ino.method.TRProg.23110.definition 
-    public ConstraintsSet typeReconstruction(FC_TTO supportData, TypeAssumptions globalAssumptions)
+    public ConstraintsSet typeReconstruction(TypeAssumptions globalAssumptions)
     // ino.end
     // ino.method.TRProg.23110.body 
     {
@@ -637,8 +609,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
         //////////////////////////////
         inferencelog.info("Rufe TRStart()...", Section.TYPEINFERENCE);
 
-		typinferenzLog.debug("Erstellte FiniteClosure: "+supportData, Section.TYPEINFERENCE);
-        //////////////////////////////
+		//////////////////////////////
         //  Ab hier ...
         //  @author A10023 - Andreas Stadelmeier:
         //////////////////////////////
@@ -671,7 +642,8 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
         
         //ConstraintsSet oderConstraints = this.TYPE(this.getMethodList(), fieldInitializers, assumptions);
         
-		this.superClass = this.superClass.TYPE(assumptions, this);
+		//Gibt es hier eine ClassCastException stimmt etwas grundsätzlich nicht!
+		this.superClass = (RefType)this.superClass.TYPE(assumptions, this);
 		
         for(Field f:this.getFields()){
         	oderConstraints.add(f.TYPE(assumptions));
@@ -1028,7 +1000,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
 	 * Die Super Klasse dieser Klasse.
 	 * @return null für Klasse Object
 	 */
-	public Type getSuperClass(){
+	public RefType getSuperClass(){
 		return this.superClass;
 	}
 	@Override

src/de/dhbwstuttgart/syntaxtree/ClassBody.java

@@ -85,64 +85,6 @@ Paratyp gesetzt.");         }
     fielddecl.addElement(i);
     }
     
-// ino.method.is_declared.23188.defdescription type=line
-//                                                                                 
-// ********************************************************************************************
-// 
-// ino.end
-
-// ino.method.is_declared.23188.definition 
-public boolean is_declared(Type t, Menge<Class> classlist)
-throws SCClassBodyException
-// ino.end
-// ino.method.is_declared.23188.body 
-{
-    boolean flag=false;
-    for(Enumeration<Class> e = classlist.elements();e.hasMoreElements();)
-    {
-        flag = false;
-        Class c = e.nextElement();
-
-//      System.out.println("is_init:  vergleiche "+t.get_Type_()+" mit "+c.getName());
-        if(c.getName().equals(t.getName())){
-//      System.out.println("Klasse "+t.get_Type()+"im Menge classlist gefunden.");
-        flag = true;
-        break;
-        }
-    }
-
-    if( t instanceof RefType && ((RefType)t).get_ParaList()!=null)
-    {
-        if( ((RefType)t).get_ParaList().size() > 0 )
-        {
-            for(Enumeration e1 = ((RefType)t).get_ParaList().elements(); e1.hasMoreElements(); )
-            {
-                try
-                {
-                    is_declared((Type)e1.nextElement(),classlist);
-                }
-                catch(SCClassBodyException ex)
-                {
-                    throw ex;
-                }
-            }
-        }
-    }
-
-    if(flag)
-        return true;
-    else
-    {
-        SCClassBodyException ex = new SCClassBodyException();
-        SCExcept e = new SCExcept();
-        e.set_error("unbekannte Klasse "+t.getName()+".");
-        e.set_function("complete_parahashtable() --> is_declared()");
-        e.set_statement(t.getName().toString());
-        ex.addException(e);
-        throw ex;
-    }
-}
-// ino.end
 
 // ino.method.string_rec.23191.definition 
 static String string_rec(Hashtable ht)

src/de/dhbwstuttgart/syntaxtree/Constructor.java

@@ -28,7 +28,7 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
@@ -65,8 +65,8 @@ public class Constructor extends Method {
 		DHBWConstantPoolGen _cp = cg.getConstantPool();
 		InstructionList il = new InstructionList(); //sollte nicht new sein sondern aus Block kommen
 		Class parentClass = this.getParentClass();
-				
-		MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, this.getType().getBytecodeType(cg),  org.apache.commons.bcel6.generic.Type.NO_ARGS , new String[] {  }, "<init>", parentClass.name, il, _cp);
+		
+		MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, this.getType().getBytecodeType(cg, null),  this.parameterlist.getBytecodeTypeList(cg,null) , this.parameterlist.getParameterNameArray(), "<init>", parentClass.name, il, _cp);
 		
 		//FieldInitializations an Block anfügen
 		Block block = this.get_Block();
@@ -78,7 +78,7 @@ public class Constructor extends Method {
 		
 		//method.setMaxStack(); //Die Stack Größe automatisch berechnen lassen (erst nach dem alle Instructions angehängt wurden)
 		
-		cg.addMethod(method.createMethod(cg, getParameterList(), this.getType(), get_Block()));
+		cg.addMethod(method.createMethod(cg, getParameterList(), this.getType(), get_Block(), null));
 	}
 	
 	/**
@@ -91,13 +91,13 @@ public class Constructor extends Method {
 			il = toInsert;
 		}
 		@Override
-		public InstructionList genByteCode(ClassGenerator cg){
+		public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs){
 			return il;
 		}
 	}
 	
 	@Override
-	public void genByteCode(ClassGenerator cg) {
+	public void genByteCode(ClassGenerator cg, Class classObj) {
 		this.genByteCode(cg, new InstructionList());
 	}
 	// super statement muss drin sein

src/de/dhbwstuttgart/syntaxtree/Field.java

@@ -16,6 +16,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeInsertable;
 import de.dhbwstuttgart.typeinference.Typeable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
 

src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java

@@ -21,7 +21,8 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@@ -147,13 +148,13 @@ public class FieldDeclaration extends Field{
 		}
 		*/
 		
-		SingleConstraint c1 = new SingleConstraint(thisType, thisType);
+		UndConstraint c1 = ConstraintsSet.createSingleConstraint(thisType, thisType);
 		ret.add(c1); //Damit die TypVariable des Felds in den Constraints auftaucht
 		
 		if(this.wert!=null){
 			//Falls bei der Deklaration ein Wert zugewiesen wird, verhält sich das Constraintserzeugen wie bei dem Assign-Statement:
 			ret.add(this.wert.TYPEExpr(localAssumptions));
-			ret.add(new SingleConstraint(this.wert.getType().TYPE(localAssumptions,this), thisType));
+			ret.add(ConstraintsSet.createSingleConstraint(this.wert.getType().TYPE(localAssumptions,this), thisType));
 		}
 		return ret;
 	}
@@ -170,23 +171,27 @@ public class FieldDeclaration extends Field{
 	 * @param cg
 	 * @return - Die InstructionList, welche das Feld initialisiert
 	 */
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		//Das Feld an die Klasse anfügen:
-		FieldGen field = new FieldGen(0, this.getType().getBytecodeType(cg), this.getDescription(), cg.getConstantPool());
-		field.addAttribute(cg.getInstructionFactory().createSignatureAttribute(this.getType().getBytecodeSignature(cg)));
+		FieldGen field = new FieldGen(0, this.getType().getBytecodeType(cg, rs), this.getDescription(), cg.getConstantPool());
+		field.addAttribute(cg.getInstructionFactory().createSignatureAttribute(this.getType().getBytecodeSignature(cg, rs)));
 	    cg.addField(field.getField());
 		
 	    //Die Felddekleration an den Konstruktor anhängen:
 	    InstructionList il = new InstructionList();
-	    il.append(new This(this).genByteCode(cg));
-	    il.append(this.wert.genByteCode(cg));
+	    il.append(new This(this).genByteCode(cg, rs));
+	    
+	    if(wert != null){
+	    	il.append(this.wert.genByteCode(cg, rs));
+	    }
+	    
 	    FieldInstruction putFieldInstruction = 
 	    		cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(), 
-	    				this.getDescription(), this.getType().getBytecodeType(cg), Constants.PUTFIELD);
+	    				this.getDescription(), this.getType().getBytecodeType(cg, rs), Constants.PUTFIELD);
 		il.append(putFieldInstruction );
 	    return il;
 	}
-
+	
 	/*@Override
 	public void genByteCode(ClassGen cg) {
 		// TODO Auto-generated method stub

src/de/dhbwstuttgart/syntaxtree/FormalParameter.java

@@ -4,7 +4,7 @@ package de.dhbwstuttgart.syntaxtree;
 
 // ino.module.FormalParameter.8561.import 
 import de.dhbwstuttgart.typeinference.Menge;
-
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.logger.Logger;
 
 import de.dhbwstuttgart.syntaxtree.misc.DeclId;
@@ -14,6 +14,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeInsertable;
 import de.dhbwstuttgart.typeinference.Typeable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
@@ -233,10 +234,10 @@ public class FormalParameter extends SyntaxTreeNode implements Typeable, TypeIns
 	}
 
 	@Override
-	public String getDescription() {
+	public String getDescription(){
 		String ret = "";
 		if(this.getType() != null && !(this.getType() instanceof TypePlaceholder)){
-			ret += this.getType().getBytecodeSignature(null);
+			ret += this.getType().toString();//getBytecodeSignature(null, null);
 		}
 		return ret+this.getIdentifier();
 	}

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -1,11 +1,13 @@
 // ino.module.Method.8564.package 
 package de.dhbwstuttgart.syntaxtree;
 
-// ino.end
-// ino.module.Method.8564.import 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
 
 import  org.apache.commons.bcel6.Constants;
 import org.apache.commons.bcel6.classfile.Signature;
@@ -17,7 +19,9 @@ import  org.apache.commons.bcel6.generic.InstructionList;
 import  org.apache.commons.bcel6.generic.MethodGen;
 
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.Menge.Equal;
 import de.dhbwstuttgart.logger.Logger;
+import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.bytecode.DHBWConstantPoolGen;
 import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
@@ -41,8 +45,9 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
 import de.dhbwstuttgart.typeinference.TypeInsertable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
@@ -59,62 +64,26 @@ import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
  *
  */
 public class Method extends Field implements IItemWithOffset, TypeInsertable
-// ino.end
-// ino.class.Method.23482.body
 {
-	// ino.attribute.block.23488.declaration
 	private Block block;
-	// ino.end
-	// ino.attribute.parameterlist.23491.declaration
 	public ParameterList parameterlist = new ParameterList();
-	// ino.end
-	// ino.attribute.exceptionlist.23494.declaration
 	private ExceptionList exceptionlist;
-	// ino.end
-	// ino.attribute.returntype.23497.declaration
 	private Type returntype;
-	// ino.end
-	
-	// ino.attribute.genericMethodParameters.23500.decldescription type=javadoc
-	/**
-	 * HOTI 4.5.06 Dieser Vektor beinhaltet alle Generischen Typen und v.a. die
-	 * F-Bounded-Generics, die die Methode besitzt size()==0, falls es keine
-	 * gibt
-	 */
-	// ino.end
-	// ino.attribute.genericMethodParameters.23500.declaration
-	// private Menge<GenericTypeVar> genericMethodParameters=new
-	// Menge<GenericTypeVar>();
-	// ino.end
 
-	// ino.attribute.overloadedID.23503.declaration
 	private int overloadedID;
-	// ino.end
-	// ino.attribute.isAbstract.23506.declaration
 	private boolean isAbstract = false;
-	// ino.end
-	// ino.attribute.types_in_parameterlist.23509.declaration
 	private Menge<String> types_in_parameterlist = new Menge<String>();
-	// ino.end
-	// ino.attribute.m_LineNumber.23512.declaration
 	private int m_LineNumber = MyCompiler.NO_LINENUMBER;
-	// ino.end
 	private int m_Offset = -1; // hinzugef�gt hoth: 07.04.2006
 	private Modifiers modifiers;
-	// ino.attribute.inferencelog.23515.declaration
 	protected static Logger inferencelog = Logger.getLogger("inference");
-	// ino.end
-	// ino.attribute.parserlog.23518.declaration
 	protected static Logger parserlog = Logger.getLogger("parser");
 
-	// ino.end
-
 	public Method(int offset) {
 		super(offset);
 	}
 
-	public Method(String name, Type returnType, ParameterList parameterList,
-			Block block, GenericDeclarationList gtvDeclarations, int offset) {
+	public Method(String name, Type returnType, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, int offset) {
 		this(offset);
 		/*
 		 * if(parameterList != null)parameterList.parserPostProcessing(this);
@@ -128,51 +97,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		this.setReturnType(returnType);
 	}
 
-	/*
-	 * // ino.method.setGenericMethodParameters.23521.definition public void
-	 * setGenericMethodParameters(Menge<GenericTypeVar> genericMethodParameters)
-	 * // ino.end // ino.method.setGenericMethodParameters.23521.body {
-	 * this.genericMethodParameters=genericMethodParameters; } // ino.end //
-	 * ino.method.getGenericMethodParameters.23524.definition public
-	 * Menge<GenericTypeVar> getGenericMethodParameters() // ino.end //
-	 * ino.method.getGenericMethodParameters.23524.body {
-	 * return(genericMethodParameters); } // ino.end
-	 */
-	/*
-	 * // ino.method.sc_init_parameterlist.23530.definition public void
-	 * sc_init_parameterlist(boolean ext) // ino.end //
-	 * ino.method.sc_init_parameterlist.23530.body { DeclId hilf=null;
-	 * Menge<FormalParameter> list; FormalParameter para; String typeofpara; int
-	 * i=1; if(this.getParameterList()!=null) //es gibt Parameter, dann: {
-	 * hilf=declid.elementAt(0); if(ext)
-	 * parserlog.debug("Semantik-Check hat in Methode "
-	 * +hilf.get_Name()+" bergabewerte gefunden:");
-	 * list=this.getParameterList().sc_get_Formalparalist(); //Menge
-	 * Formalparalist aus FormalParameterList wird zwischen gesichert
-	 * for(Enumeration<FormalParameter> el2=list.elements();
-	 * el2.hasMoreElements();) { para=el2.nextElement();
-	 * typeofpara=para.getTypeName(); if(ext)
-	 * parserlog.debug("       "+i+". Parameter hat Typ "+typeofpara);
-	 * types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden
-	 * im Menge abgelegt i++; } } else //keine Parameter vorhanden: { if(ext) {
-	 * hilf=declid.elementAt(0);
-	 * parserlog.debug("Semantik-Check hat in Methode "
-	 * +hilf.get_Name()+" keine bergabewerte gefunden."); } } if(ext) {
-	 * parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" "+
-	 * types_in_parameterlist.size()+" bergabeparameter gefunden.");
-	 * parserlog.debug
-	 * ("             namentlich: "+types_in_parameterlist.toString()); } } //
-	 * ino.end
-	 */
-	// ino.method.getTypeName.23533.defdescription type=line
-	// Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die
-	// get_ReturnType() auf eigene Gefahr lschen.
-	// ino.end
-
-	// ino.method.getTypeName.23533.definition
 	public JavaClassName getTypeName()
-	// ino.end
-	// ino.method.getTypeName.23533.body
 	{
 		if (this.getType() == null)
 			return null;
@@ -180,101 +105,58 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 			return this.getType().getName();
 	}
 
-	// ino.end
 
-	// ino.method.get_Block.23536.definition
 	public Block get_Block()
-	// ino.end
-	// ino.method.get_Block.23536.body
 	{
 		return block;
 	}
 
-	// ino.end
 
-	// ino.method.setReturnType.23539.defdescription type=javadoc
 	/**
 	 * <br/>
 	 * Author: Jrg Buerle
 	 * 
 	 * @param type
 	 */
-	// ino.end
-	// ino.method.setReturnType.23539.definition
 	private void setReturnType(Type type)
-	// ino.end
-	// ino.method.setReturnType.23539.body
 	{
 		this.returntype = type;
 	}
 
-	// ino.end
-
-	// ino.method.set_Block.23542.definition
 	public void set_Block(Block blo)
-	// ino.end
-	// ino.method.set_Block.23542.body
 	{
 		if (blo.getType() == null)
 			blo.setType(this.returntype);
 		this.block = blo;
 	}
 
-	// ino.end
-
-	// ino.method.set_Modifiers.23545.definition
 	public void set_Modifiers(Modifiers modif)
-	// ino.end
-	// ino.method.set_Modifiers.23545.body
 	{
 		declid.firstElement().set_Modifiers(modif);
 		this.modifiers = modif;
 	}
 
-	// ino.end
-
-	// ino.method.set_ExceptionList.23548.definition
 	public void set_ExceptionList(ExceptionList exlist)
-	// ino.end
-	// ino.method.set_ExceptionList.23548.body
 	{
 		this.exceptionlist = exlist;
 	}
 
-	// ino.end
-
-	// ino.method.setParameterList.23551.definition
 	public void setParameterList(ParameterList paralist)
-	// ino.end
-	// ino.method.setParameterList.23551.body
 	{
 		this.parameterlist = paralist;
 	}
 
-	// ino.end
-
-	// ino.method.getParameterList.23554.definition
 	public ParameterList getParameterList()
-	// ino.end
-	// ino.method.getParameterList.23554.body
 	{
-		// otth: gibt die Parameterliste zurueck
 		return this.parameterlist;
 	}
 
-	// ino.end
-
-	// ino.method.getParameterCount.23557.defdescription type=javadoc
 	/**
 	 * Author: Jrg Buerle<br/>
 	 * 
 	 * @return Die Anzahl der Methoden-Paramater
 	 */
-	// ino.end
-	// ino.method.getParameterCount.23557.definition
 	public int getParameterCount()
-	// ino.end
-	// ino.method.getParameterCount.23557.body
 	{
 		if (this.getParameterList() == null)
 			return 0;
@@ -282,215 +164,100 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 			return this.getParameterList().getParameterCount();
 	}
 
-	// ino.end
-
-	// ino.method.get_ExceptionList.23560.definition
 	public ExceptionList get_ExceptionList()
-	// ino.end
-	// ino.method.get_ExceptionList.23560.body
 	{
 		// otth: gibt die Exceptionliste zurueck
 		return this.exceptionlist;
 	}
 
-	// ino.end
-
-	// ino.method.getOverloadedID.23563.definition
 	public int getOverloadedID()
-	// ino.end
-	// ino.method.getOverloadedID.23563.body
 	{
 		return (overloadedID);
 	}
 
-	// ino.end
 
-	// ino.method.setOverloadedID.23566.definition
 	public void setOverloadedID(int overloadedID)
-	// ino.end
-	// ino.method.setOverloadedID.23566.body
 	{
 		this.overloadedID = overloadedID;
 	}
 
-	// ino.end
-
-	// ino.method.get_Method_Name.23575.definition
 	public String get_Method_Name()
-	// ino.end
-	// ino.method.get_Method_Name.23575.body
 	{
 		DeclId hilf = declid.elementAt(0);
 		return hilf.get_Name();
 	}
 
-	// ino.end
-
-	// ino.method.get_Type_Paralist.23578.definition
 	public Menge get_Type_Paralist()
-	// ino.end
-	// ino.method.get_Type_Paralist.23578.body
 	{
 		return types_in_parameterlist;
 	}
 
-	// ino.end
-
-	// ino.method.getLineNumber.23584.definition
 	public int getLineNumber()
-	// ino.end
-	// ino.method.getLineNumber.23584.body
 	{
 		return m_LineNumber;
 	}
-
-	// ino.end
-
-	// ino.method.setLineNumber.23587.definition
+	
 	public void setLineNumber(int lineNumber)
-	// ino.end
-	// ino.method.setLineNumber.23587.body
 	{
 		m_LineNumber = lineNumber;
 	}
-
-	// ino.end
-
-	// ino.method.getOffset.23590.defdescription type=line
-	// hinzugef�gt hoth: 07.04.2006
-	// ino.end
-	// ino.method.getOffset.23590.definition
+	
 	public int getOffset()
-	// ino.end
-	// ino.method.getOffset.23590.body
 	{
 		return m_Offset;
 	}
 
-	// ino.end
-
-	// ino.method.getVariableLength.23593.definition
 	public int getVariableLength()
-	// ino.end
-	// ino.method.getVariableLength.23593.body
 	{
 		return get_Method_Name().length();
 	}
 
-	// ino.end
-
-	// ino.method.setOffset.23596.defdescription type=line
-	// hinzugef�gt hoth: 07.04.2006
-	// ino.end
-	// ino.method.setOffset.23596.definition
 	public void setOffset(int Offset)
-	// ino.end
-	// ino.method.setOffset.23596.body
 	{
 		m_Offset = Offset;
 	}
 
-	// ino.end
-
-	// ino.method.getTypeLineNumber.23602.defdescription type=javadoc
 	/**
 	 * <br>
 	 * Author: Jrg Buerle
 	 * 
 	 * @return
 	 */
-	// ino.end
-	// ino.method.getTypeLineNumber.23602.definition
 	public int getTypeLineNumber()
-	// ino.end
-	// ino.method.getTypeLineNumber.23602.body
 	{
 		return this.getLineNumber();
 	}
-
-	// ino.end
-
-	// ino.method.toString.23605.defdescription type=javadoc
+	
 	/**
 	 * <br/>
 	 * Author: Martin Pl�micke
 	 * 
 	 * @return
 	 */
-	// ino.end
-	// ino.method.toString.23605.definition
 	public String toString()
-	// ino.end
-	// ino.method.toString.23605.body
 	{
 		return this.getType() + " " + this.get_Name() + ((block != null) ? block.toString() : "");
 	}
 
-	// ino.end
-
-	// ino.method.setAbstract.23608.defdescription type=javadoc
 	/**
 	 * Legt fuer die ByteCodeGen fest, ob Bytecode innerhalb der Methode
 	 * generiert wird.
 	 */
-	// ino.end
-	// ino.method.setAbstract.23608.definition
 	public void setAbstract(boolean b)
-	// ino.end
-	// ino.method.setAbstract.23608.body
 	{
 		isAbstract = b;
 	}
-
-	// ino.end
-
-	// ino.method.isAbstract.23611.defdescription type=javadoc
+	
 	/**
 	 * Gibt zurueck, ob ByteCode innerhabl der Methode generiert wird.
 	 */
-	// ino.end
-	// ino.method.isAbstract.23611.definition
 	public boolean isAbstract()
-	// ino.end
-	// ino.method.isAbstract.23611.body
 	{
 		return isAbstract;
 	}
 
 	@Override
-	public void wandleRefTypeAttributes2GenericAttributes(
-			Menge<Type> classParalist) {
-		/*
-		 * Menge<Type> paralist = new Menge<Type>();//Mit den Generischen Typen
-		 * der Methode paralist.addAll(classParalist);
-		 * paralist.addAll(this.genericMethodParameters);
-		 * 
-		 * // Zuerst Returntype untersuchen Type returnType=getType(); Type
-		 * pendantReturnType = null; if(returnType instanceof
-		 * RefType)pendantReturnType =
-		 * ((RefType)returnType).findGenericType(paralist, new
-		 * Menge<GenericTypeVar>()); //GenericTypeVar
-		 * pendantReturnType=ClassHelper.findGenericType(returnType,
-		 * paralist,genericMethodParameters); if(pendantReturnType!=null){
-		 * //Wenn generisch, dann modifizieren setReturnType(pendantReturnType);
-		 * }
-		 * 
-		 * // Dann parameterlist untersuchen for(int
-		 * par=0;par<getParameterCount();par++){ FormalParameter
-		 * fp=parameterlist.formalparameter.get(par); Type fpType=fp.getType();
-		 * // Nur wenn es sich um ein RefType-Field handelt Type pendantPara =
-		 * null; if(fpType instanceof RefType)pendantPara =
-		 * ((RefType)fpType).findGenericType(paralist, new
-		 * Menge<GenericTypeVar>()); //GenericTypeVar
-		 * pendantPara=ClassHelper.findGenericType
-		 * (fpType,paralist,genericMethodParameters); if(pendantPara!=null){
-		 * //Wenn generisch, dann modifizieren fp.setType(pendantPara); } }
-		 * 
-		 * // Zuletzt alle Lokalen Variablendeklarationen durchgehen
-		 * if(block!=null){
-		 * block.wandleRefTypeAttributes2GenericAttributes(paralist
-		 * ,genericMethodParameters); }
-		 */
+	public void wandleRefTypeAttributes2GenericAttributes(Menge<Type> classParalist) {
 	}
 
 	public void set_Method_Name(String string) {
@@ -513,36 +280,17 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 
 		// TypeCheck, falls es sich um einen RefType handelt:
 		this.returntype = this.returntype.checkTYPE(localAss, this);
-		/*
-		 * if(this.returntype!=null && (this.returntype instanceof RefType)&&
-		 * !(this.returntype instanceof mycompiler.mytype.Void)){//Sonderfall
-		 * der Methode: Ihr Typ darf Void definiert werden. Type replaceType =
-		 * null; replaceType = ass.getTypeFor((RefType)this.returntype);
-		 * if(replaceType == null)throw new
-		 * TypeinferenceException("Der Typ "+this
-		 * .getType().getName()+" ist nicht korrekt",this); this.returntype =
-		 * replaceType; }
-		 */
 		// Die Parameter zu den Assumptions hinzufügen:
 		if (this.parameterlist != null)
 			for (FormalParameter param : this.parameterlist) {
 
 				param.setType(param.getType().checkTYPE(localAss, this));
-				/*
-				 * if(param.getType() instanceof RefType) { Type replaceType =
-				 * null; replaceType = ass.getTypeFor((RefType)param.getType());
-				 * if(replaceType == null) throw new
-				 * TypeinferenceException("Der Typ "
-				 * +param.getType().getName()+" ist nicht korrekt",param);
-				 * param.setType(replaceType); }
-				 */
-
 				localAss.addAssumption(new ParameterAssumption(param));
 			}
 		ret.add(this.block.TYPEStmt(localAss));
 		// eine Verknüpfung mit der Type Assumption aus dem Assumption Set
 		// und dem ermittelten Typ der Methode:
-		ret.add(new SingleConstraint(this.block.getType().TYPE(localAss, this), this.returntype.TYPE(localAss, this)));
+		ret.add(ConstraintsSet.createSingleConstraint(this.block.getType().TYPE(localAss, this), this.returntype.TYPE(localAss, this)));
 		return ret;
 	}
 
@@ -580,107 +328,15 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		TypeAssumptions ret = new TypeAssumptions();
 		ret.addAssumption(new MethodAssumption(this, parentClass));
 		return ret;
-		/*
-		 * TypeAssumptions assumptions = new TypeAssumptions(); this.assumedType
-		 * = null; //if((this.get_Method_Name().equals(classmember.getName()) ||
-		 * this.get_Method_Name().equals("<init>")) &&
-		 * ((this.getType().equals(new mycompiler.mytype.Void(0))) ||
-		 * this.getType() instanceof TypePlaceholder)){
-		 * if((this.get_Method_Name().equals(classmember.getName()) ||
-		 * this.get_Method_Name().equals("<init>"))) {
-		 * this.set_Method_Name("<init>"); this.assumedType = new
-		 * RefType(classmember.getName(),0);
-		 * this.setReturnType(this.assumedType); this.assumedType = new
-		 * RefType("void",0); //Return constructorReturnStatement = new
-		 * Return(0,0); //constructorReturnStatement.retexpr =
-		 * //this.block.statements.add(constructorReturnStatement); } //hoth:
-		 * 06.04.2006 //durchlaufe Block und suche nach Objektvariablen fuer
-		 * Offset-Markierung Iterator<CTypeAssumption> fieldVarIterator =
-		 * assumptions.iterator(); while (fieldVarIterator.hasNext()) { //Wenn
-		 * ObjektVariable CTypeAssumption dieAssum = fieldVarIterator.next();
-		 * if(dieAssum instanceof CInstVarTypeAssumption) {
-		 * Class.isFirstLocalVarDecl=false; if(this.get_Block() != null)
-		 * this.get_Block
-		 * ().addOffsetsToAssumption(dieAssum,dieAssum.getIdentifier(),true); }
-		 * }
-		 * 
-		 * //methodList.addElement(method);
-		 * 
-		 * //F�r V_fields_methods: CMethodTypeAssumption methodAssum
-		 * = new CMethodTypeAssumption(classmember.getType(),
-		 * this.get_Method_Name(), this.getType(),
-		 * this.getParameterCount(),this.getLineNumber(),this.getOffset(),new
-		 * Menge<Integer>(),this.getGenericMethodParameters()); // Typannahme
-		 * bauen...
-		 * 
-		 * 
-		 * //Methode in V_Fields_methods ablegen //Dabei wird die
-		 * OverloadedMethodID ermittelt !! //=> Method setzenuct
-		 * 
-		 * 
-		 * assumptions.add(methodAssum);
-		 * this.setOverloadedID(methodAssum.getHashSetKey
-		 * ().getOverloadedMethodID());
-		 * 
-		 * 
-		 * //F�r die V_i: CTypeAssumptionSet localAssum = new
-		 * CTypeAssumptionSet();
-		 * 
-		 * //Bauen... ParameterList parameterList = this.getParameterList();
-		 * if(parameterList!=null){ for(int i=0;
-		 * i<parameterList.sc_get_Formalparalist().size(); i++){ FormalParameter
-		 * para = parameterList.sc_get_Formalparalist().elementAt(i); //
-		 * F�r V_fields_methods: CParaTypeAssumption paraAssum = new
-		 * CParaTypeAssumption(classmember.getName(), this.get_Method_Name(),
-		 * this.getParameterCount(), this.getOverloadedID(),para.get_Name(),
-		 * para.getType(), para.getLineNumber(),para.getOffset(),new
-		 * Menge<Integer>()); //fuege Offsets fuer Parameter hinzu, hoth:
-		 * 06.04.2006 Class.isFirstLocalVarDecl=false;
-		 * 
-		 * if(this.get_Block() != null)
-		 * this.get_Block().addOffsetsToAssumption(paraAssum
-		 * ,paraAssum.getIdentifier(),true);
-		 * 
-		 * methodAssum.addParaAssumption(paraAssum);
-		 * 
-		 * // F�r die V_i: CLocalVarTypeAssumption varAssum = new
-		 * CLocalVarTypeAssumption(classmember.getName(),
-		 * this.get_Method_Name(), this.getParameterCount(),
-		 * this.getOverloadedID(),"1", para.get_Name(),para.getType(),
-		 * para.getLineNumber(),para.getOffset(),new Menge<Integer>());
-		 * localAssum.addElement(varAssum);
-		 * //rememberLocals.addElement(varAssum); } } //...und
-		 * hinzuf�gen:
-		 * 
-		 * assumptions.add(localAssum);//Assumptions für lokale Variablen den
-		 * Assumptions hinzufügen
-		 * 
-		 * //Hier wird der Typ der als Assumption eingetragen wird in die
-		 * Variable assumedType dieser Klasse geschrieben: if(this.assumedType
-		 * == null) // Falls der Typ nicht schon gesetzt ist. Das ist der Fall,
-		 * falls die Methode ein Konstruktor ist this.assumedType =
-		 * methodAssum.getAssumedType();
-		 * 
-		 * return assumptions;
-		 */
 	}
 
 	@Override
 	public void parserPostProcessing(SyntaxTreeNode parent) {
 		if (this.getType() == null)
 			this.setType(TypePlaceholder.fresh(this));
-		// Bei dem Elterntyp der Methode darf es sich nur um eine Klasse
-		// handeln, daher Cast ohne Prüfung:
-		// Class parentClass = (Class)parent;
 		if (this.returntype == null)
 			this.returntype = TypePlaceholder.fresh(this);
 		super.parserPostProcessing(parent);
-		/*
-		 * this.returntype.parserPostProcessing(this); if(this.parameterlist !=
-		 * null){ for(FormalParameter fp : this.parameterlist){
-		 * fp.parserPostProcessing(this); } } for(GenericTypeVar gtv :
-		 * this.getGenericParameter()){ gtv.parserPostProcessing(this); }
-		 */
 	}
 
 	@Override
@@ -721,7 +377,6 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		DImethod.set_Name(withSignature);
 		ret.set_DeclId(DImethod);
 		Block tempBlock = new Block();
-		// tempBlock.setType(new RefType(parent.getName(),0));
 		ret.set_Block(tempBlock);
 		ret.parserPostProcessing(parent);
 		return ret;
@@ -744,41 +399,42 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		return super.equals(obj);
 	}
 
-	public void genByteCode(ClassGenerator cg) {
-		for(int t = 0; t < cg.getTypeinferenceResults().getTypeReconstructions().size(); t++){			
-			DHBWConstantPoolGen _cp = cg.getConstantPool();
-			DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, _cp);
-			InstructionList il = new InstructionList();
-			Class parentClass = this.getParentClass();
+	public void genByteCode(ClassGenerator cg, Class classObj) {
+		List<TypeinferenceResultSet> typeInterferenceResults = cg.getTypeinferenceResults().getTypeReconstructions(this, cg);
+		DHBWInstructionFactory _factory = cg.getInstructionFactory();
 		
-			//Die Argumentliste generieren:
-			 org.apache.commons.bcel6.generic.Type[] argumentTypes =  org.apache.commons.bcel6.generic.Type.NO_ARGS;
-			String[] argumentNames = new String[]{};
-			if(this.parameterlist != null &&
-					this.parameterlist.size() > 0){
-				argumentTypes = new org.apache.commons.bcel6.generic.Type[this.parameterlist.size()];
-				argumentNames = new String[this.parameterlist.size()];
-				int i = 0;
-				for(FormalParameter parameter : this.parameterlist){
-					if(parameter.getType() instanceof TypePlaceholder){
-						argumentTypes[i] = ((TypePlaceholder) parameter.getType()).getBytecodeType(cg, t);
-					}else{
-						argumentTypes[i] = parameter.getType().getBytecodeType(cg);
-					}
-					argumentNames[i] = parameter.getIdentifier();
-					i++;
-				}
-			}
-			
-			short constants = Constants.ACC_PUBLIC; //Per Definition ist jede Methode public
-	    	if(this.modifiers != null && this.modifiers.includesModifier(new Static())) constants += Constants.ACC_STATIC;
-			//Methode generieren:
-			MethodGenerator method = new MethodGenerator(constants, this.getType().getBytecodeType(cg), argumentTypes , argumentNames, this.get_Method_Name(), parentClass.name, il, _cp);
-			
-			//Methode generieren und anfügen:
-			cg.addMethod(method.createMethod(cg, getParameterList(), getType(), get_Block()));
+		for(TypeinferenceResultSet t: typeInterferenceResults){
+			addMethodToClassGenerator(cg, _factory, t);
 		}
 	}
 
+	private void addMethodToClassGenerator(ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t) {
+		DHBWConstantPoolGen _cp = cg.getConstantPool();
+		InstructionList il = new InstructionList();
+		
+		ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes = new ArrayList<org.apache.commons.bcel6.generic.Type>();
+		ArrayList<String> argumentNames = new ArrayList<String>();
+		
+		if(this.parameterlist != null && this.parameterlist.size() > 0){
+			generateArgumentList(argumentTypes, argumentNames, cg, t);
+		}
+		
+		short constants = Constants.ACC_PUBLIC;
+		if(this.modifiers != null && this.modifiers.includesModifier(new Static())) constants += Constants.ACC_STATIC;
+		
+		Type returnType = this.getType();
+		
+		MethodGenerator method = new MethodGenerator(constants, returnType.getBytecodeType(cg, t), argumentTypes.toArray(new org.apache.commons.bcel6.generic.Type[parameterlist.size()]) , argumentNames.toArray(new String[parameterlist.size()]), this.get_Method_Name(), getParentClass().name, il, _cp);
+		
+		cg.setMethodeGenerator(method);
+		
+		cg.addMethod(method.createMethod(cg, getParameterList(), returnType, get_Block(), t));
+	}
+
+	private void generateArgumentList(ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes, ArrayList<String> argumentNames, ClassGenerator cg, TypeinferenceResultSet t) {
+		for(FormalParameter parameter : this.parameterlist){
+			argumentTypes.add(parameter.getType().getBytecodeType(cg, t));
+			argumentNames.add(parameter.getIdentifier());
+		}
+	}
 }
-// ino.end

src/de/dhbwstuttgart/syntaxtree/NullSyntaxTreeNode.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.syntaxtree;
+
+import de.dhbwstuttgart.typeinference.Menge;
+
+/**
+ * Dieser SyntaxTreeNode kann anstelle von null in einem Syntaxbaum eingesetzt werden.
+ * Vorsicht: Als Offset wird dann immer 0 zurück gegeben.
+ */
+public class NullSyntaxTreeNode extends SyntaxTreeNode {
+
+	@Override
+	public int getOffset() {
+		return 0;
+	}
+
+	@Override
+	public int getVariableLength() {
+		return 0;
+	}
+
+	@Override
+	public Menge<? extends SyntaxTreeNode> getChildren() {
+		return new Menge<>();
+	}
+
+}

src/de/dhbwstuttgart/syntaxtree/ParameterList.java

@@ -11,6 +11,7 @@ import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 
 // ino.end
 
@@ -145,11 +146,11 @@ public class ParameterList extends SyntaxTreeNode implements Iterable<FormalPara
 		return this.formalparameter.size();
 	}
 	
-	public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg){
+	public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg, TypeinferenceResultSet rs){
 		org.apache.commons.bcel6.generic.Type[] ret = new org.apache.commons.bcel6.generic.Type[formalparameter.size()];
 		int i = 0;
 		for(FormalParameter f : formalparameter){
-			ret[i] = f.getType().getBytecodeType(cg);
+			ret[i] = f.getType().getBytecodeType(cg, rs);
 			i++;
 		}
 		return ret;

src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java

@@ -3,6 +3,7 @@ package de.dhbwstuttgart.syntaxtree;
 import  org.apache.commons.bcel6.generic.ClassGen;
 
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.Type;
@@ -10,6 +11,7 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeInsertable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.typedeployment.GenericTypeInsertPoint;
@@ -53,6 +55,8 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
 	
 	/**
 	 * Eine Beschreibung/Name des SyntaxTree-Nodes
+	 * Hat nichts mit der Description im Bytecode zu tun,
+	 * wird für die Anzeige des AST im Plugin verwendet
 	 * @return
 	 */
 	public String getDescription(){

src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java

@@ -55,7 +55,7 @@ public class ASTFactory {
 		return new Constructor(method, superClass);
 	}
 
-	public static Class createClass(String className, Type type, Modifiers modifiers, Menge supertypeGenPara, SourceFile parent) {
+	public static Class createClass(String className, RefType type, Modifiers modifiers, Menge supertypeGenPara, SourceFile parent) {
 		// TODO bytecode createClass
 		//String name, RefType superClass, Modifiers modifiers, Menge<String> supertypeGenPara
 		Class generatedClass = new Class(className, type, modifiers, supertypeGenPara);		

src/de/dhbwstuttgart/syntaxtree/factory/UnifyPairMengenBuilder.java

@@ -3,7 +3,7 @@ package de.dhbwstuttgart.syntaxtree.factory;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.Pair.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 
 public class UnifyPairMengenBuilder {
 	

src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java

@@ -1,43 +1,223 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
-import de.dhbwstuttgart.syntaxtree.type.Type;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.syntaxtree.type.WildcardType;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.logging.Logger;
+
+import de.dhbwstuttgart.myexception.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.NullSyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.FunN;
+import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.ObjectType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.Void;
+import de.dhbwstuttgart.syntaxtree.type.WildcardType;
+import de.dhbwstuttgart.typeinference.ConstraintsSet;
+import de.dhbwstuttgart.typeinference.EinzelElement;
+import de.dhbwstuttgart.typeinference.KomplexeMenge;
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.OderConstraint;
+import de.dhbwstuttgart.typeinference.OderMenge;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.Pair.PairOperator;
+import de.dhbwstuttgart.typeinference.UndConstraint;
+import de.dhbwstuttgart.typeinference.UndMenge;
+import de.dhbwstuttgart.typeinference.UnifyConstraintsSet;
+import de.dhbwstuttgart.typeinference.UnifyOderConstraint;
+import de.dhbwstuttgart.typeinference.UnifyUndConstraint;
+import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
+import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
+import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
+import de.dhbwstuttgart.typeinference.unify.model.SuperType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+
 
 public class UnifyTypeFactory {
 	
-	public RefType GetSimpleType(String name, Type... parameters) {
-		if(parameters.length == 0)	
-			return new RefType(name, null, 0);
-		
-		Menge<Type> typeParams = new Menge<Type>();
-		
-		for(Type t : parameters)
-			typeParams.add(t);
-		
-		return new RefType(name, typeParams, null, 0);
+	private final static NullSyntaxTreeNode NULL_NODE = new NullSyntaxTreeNode();
+	
+	public static FiniteClosure generateFC(TypeAssumptions fromAss){
+		HashSet<UnifyPair> pairs = new HashSet<>();
+		for(ClassAssumption cAss : fromAss.getClassAssumptions()){
+			UnifyType tl = UnifyTypeFactory.convert(cAss.getAssumedClass().getType());
+			RefType superClass = cAss.getAssumedClass().getSuperClass();
+			if(superClass != null){
+				UnifyType tr = UnifyTypeFactory.convert(superClass);
+				pairs.add(generateSmallerPair(tl, tr));
+			}
+		}
+		return new FiniteClosure(pairs);
+	}
+
+	public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr){
+		return new UnifyPair(tl, tr, PairOperator.SMALLER);
 	}
 	
-	public ExtendsWildcardType GetExtendsType(ObjectType extendedType) {
-		return new ExtendsWildcardType(extendedType);
+	public static UnifyPair generateSmallerDotPair(UnifyType tl, UnifyType tr){
+		return new UnifyPair(tl, tr, PairOperator.SMALLERDOT);
 	}
 	
-	public SuperWildcardType GetSuperType(ObjectType superedType) {
-		return new SuperWildcardType(superedType);
+	public static UnifyType convert(Type t){
+		//Es wurde versucht ein Typ umzuwandeln, welcher noch nicht von der Factory abgedeckt ist
+		if(t instanceof GenericTypeVar){
+			return UnifyTypeFactory.convert((GenericTypeVar)t);
+		}else if(t instanceof FunN){
+			return UnifyTypeFactory.convert((FunN)t);
+		}else if(t instanceof TypePlaceholder){
+			return UnifyTypeFactory.convert((TypePlaceholder)t);
+		}else if(t instanceof ExtendsWildcardType){
+			return UnifyTypeFactory.convert((ExtendsWildcardType)t);
+		}else if(t instanceof SuperWildcardType){
+			return UnifyTypeFactory.convert((SuperWildcardType)t);
+		}else if(t instanceof RefType){
+			return UnifyTypeFactory.convert((RefType)t);
+		}
+		throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
+	}
+
+	public static UnifyType convert(RefType t){
+		UnifyType ret;
+		if(t.getParaList() != null && t.getParaList().size() > 0){
+			Menge<UnifyType> params = new Menge<>();
+			for(Type pT : t.getParaList()){
+				params.add(UnifyTypeFactory.convert(pT));
+			}
+			ret = new ReferenceType(t.get_Name(),new TypeParams(params));
+		}else{
+			ret = new ReferenceType(t.get_Name());
+		}
+		return ret;
+	}
+
+	public static UnifyType convert(FunN t){
+		UnifyType ret;
+		Menge<UnifyType> params = new Menge<>();
+		if(t.getParaList() != null && t.getParaList().size() > 0){
+			for(Type pT : t.getParaList()){
+				params.add(UnifyTypeFactory.convert(pT));
+			}
+		}
+		ret = FunNType.getFunNType(new TypeParams(params));
+		return ret;
 	}
 	
-	public WildcardType GetWildcardType() {
-		return new WildcardType(null, null, 0);
+	public static UnifyType convert(TypePlaceholder tph){
+		return new PlaceholderType(tph.get_Name());
 	}
 	
-	public TypePlaceholder GetTypePlaceholder(String name) {
-		return TypePlaceholder.backdoorCreate(name);
+	public static UnifyType convert(ExtendsWildcardType t){
+		return new ExtendsType(UnifyTypeFactory.convert(t.get_ExtendsType()));
 	}
+
+	public static UnifyType convert(SuperWildcardType t){
+		return new SuperType(UnifyTypeFactory.convert(t.get_SuperType()));
+	}
+	
+	public static UnifyType convert(GenericTypeVar t){
+		//return new PlaceholderType(t.get_Name());
+		return new ReferenceType(t.get_Name());
+	}
+
+	public static UnifyConstraintsSet convert(ConstraintsSet constraints) {
+		UnifyConstraintsSet ret = new UnifyConstraintsSet();
+		for(OderConstraint oC : constraints.getOderConstraints()){
+			ret.add(UnifyTypeFactory.convert(oC));
+		}
+		return ret;
+	}
+
+	public static UnifyOderConstraint convert(OderConstraint set) {
+		UnifyOderConstraint ret = new UnifyOderConstraint();
+		for(UndConstraint oC : set.getUndConstraints()){
+			ret.addConstraint(UnifyTypeFactory.convert(oC));
+		}
+		return ret;
+	}
+	
+	public static UnifyUndConstraint convert(UndConstraint set) {
+		UnifyUndConstraint ret = new UnifyUndConstraint();
+		for(EinzelElement<Pair> oC : set.getPairs()){
+			ret.add(UnifyTypeFactory.convert(oC));
+		}
+		return ret;
+	}
+
+	public static UnifyPair convert(EinzelElement<Pair> p) {
+		return convert(p.getItem());
+	}	
+	
+	public static UnifyPair convert(Pair p) {
+		if(!p.OperatorSmaller())throw new NotImplementedException();
+		UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
+					, UnifyTypeFactory.convert(p.TA2));
+		return ret;
+	}
+
+	public static Pair convert(UnifyPair mp) {
+		Type tl = UnifyTypeFactory.convert(mp.getLhsType());
+		Type tr = UnifyTypeFactory.convert(mp.getRhsType());
+		return new Pair(tl, tr, mp.getPairOp());
+	}
+
+	public static Type convert(ReferenceType t) {
+		//TODO: Hier kann man die GTVs extrahieren
+		if(t.getName().toString().equals(Void.VOID_NAME))return new Void(NULL_NODE, 0);
+		RefType ret = new RefType(t.getName(),null,0);
+		ret.set_ParaList(convert(t.getTypeParams()));
+		return ret;
+	}
+	
+	public static Type convert(FunNType t) {
+		RefType ret = new RefType(t.getName(),null,0);
+		ret.set_ParaList(convert(t.getTypeParams()));
+		return ret;
+	}
+	
+	public static Type convert(SuperType t) {
+		RefType innerType = new RefType(t.getSuperedType().getName(),NULL_NODE,0);
+		return new SuperWildcardType(innerType);
+	}
+	
+	public static Type convert(ExtendsType t) {
+		RefType innerType = new RefType(t.getExtendedType().getName(),NULL_NODE,0);
+		return new ExtendsWildcardType(innerType);
+	}
+	
+	public static Type convert(PlaceholderType t) {
+		TypePlaceholder ret = TypePlaceholder.getInstance(t.getName());
+		if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
+			ret = TypePlaceholder.fresh(NULL_NODE);
+		}
+		return ret;
+	}
+	
+	public static Type convert(UnifyType t) {
+		if(t instanceof FunNType)return convert((FunNType) t);
+		if(t instanceof ReferenceType)return convert((ReferenceType) t);
+		if(t instanceof SuperType)return convert((SuperType) t);
+		if(t instanceof ExtendsType)return convert((ExtendsType) t);
+		if(t instanceof PlaceholderType)return convert((PlaceholderType) t);
+		throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
+	}
+	
+	private static List<Type> convert(TypeParams typeParams) {
+		List<Type> ret = new ArrayList<>();
+		for(UnifyType uT : typeParams){
+			Type toAdd = convert(uT);
+			ret.add(toAdd);
+		}
+		return ret;
+	}
+
 }

src/de/dhbwstuttgart/syntaxtree/factory/Unify_FC_TTO_Builder.java

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.syntaxtree.factory;
 
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.unify.FC_TTO;
 import de.dhbwstuttgart.syntaxtree.Class;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
@@ -14,18 +13,16 @@ public class Unify_FC_TTO_Builder {
 	
 	public void AddInheritance(Type t1, Type t2) {
 		if(t1 instanceof RefType)
-			classes.add(new Class(t1.get_Name(), t1.getOffset()));
+			if(!classes.stream().anyMatch(x -> x.getName().equals(t1.getName())))
+				classes.add(new Class(t1.get_Name(), t1.getOffset()));
 		
 		if(t2 instanceof RefType)
-			classes.add(new Class(t2.get_Name(), t2.getOffset()));
-		
+			if(!classes.stream().anyMatch(x -> x.getName().equals(t2.getName())))
+				classes.add(new Class(t2.get_Name(), t2.getOffset()));
+
 		fc.add(new Pair(t1, t2));
 	}
 	
-	public FC_TTO Get_FC_TTO() {
-		return new FC_TTO(fc, (Menge<?>) fc.clone(), classes);
-	}
-	
 	public void clear() {
 		fc = new Menge<Pair>();
 		classes = new Menge<Class>();

src/de/dhbwstuttgart/syntaxtree/misc/DeclId.java

@@ -16,7 +16,7 @@ import de.dhbwstuttgart.syntaxtree.statement.Assign;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
 import de.dhbwstuttgart.syntaxtree.statement.ExprStmt;
 import de.dhbwstuttgart.syntaxtree.statement.InstVar;
-import de.dhbwstuttgart.syntaxtree.statement.LocalOrFieldVar;
+import de.dhbwstuttgart.syntaxtree.statement.LocalOrFieldVarOrClassname;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 

src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java

@@ -5,20 +5,36 @@ package de.dhbwstuttgart.syntaxtree.operator;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.DUP;
+import org.apache.commons.bcel6.generic.IADD;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.InvokeInstruction;
+import org.apache.commons.bcel6.generic.ObjectType;
+
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
+import de.dhbwstuttgart.typeinference.exceptions.DebugException;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 
 
 
@@ -62,5 +78,86 @@ public abstract class AddOp extends Operator
 		return ret;
 	}
     
+	@Override
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
+		/*
+		 0: aload_1
+        1: invokevirtual #2                  // Method java/lang/Integer.intValue:()I
+        4: aload_1
+        5: invokevirtual #2                  // Method java/lang/Integer.intValue:()I
+        8: iadd
+        9: invokestatic  #3                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
+       12: areturn
+		 */
+		
+		String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2(), rs);
+		
+		if(returnType.equals("java.lang.String")){
+			DHBWInstructionFactory _factory = _cg.getInstructionFactory();
+			
+			ObjectType objectType = new ObjectType("java.lang.StringBuilder");
+			
+			InstructionList il = new InstructionList();
+			il.append(_factory.createNew("java.lang.StringBuilder"));
+			il.append(new DUP());
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "<init>", org.apache.commons.bcel6.generic.Type.VOID, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKESPECIAL));
+			
+			il.append(operator.get_Expr1().genByteCode(_cg, rs));
+			
+			
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "append", objectType, new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.STRING}, Constants.INVOKEVIRTUAL));
+			
+			il.append(operator.get_Expr2().genByteCode(_cg, rs));
+			
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "append", objectType, new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.STRING}, Constants.INVOKEVIRTUAL));
+			
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.StringBuilder", "toString", new ObjectType("java.lang.String"), new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+			
+			return il;
+		}else{
+			DHBWInstructionFactory _factory = _cg.getInstructionFactory();
+			
+			InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
+			
+			il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
+			
+			il.append(getOperator(returnType));
+			
+			il.append(convertValueToObject(_factory, returnType));
+			return il;
+		}
+	}
+
+	private String getReturnType(Expr expr1, Expr expr2, TypeinferenceResultSet rs) {
+		Type type = expr1.getType();
+		if(type instanceof TypePlaceholder){
+			Type tphType = rs.getTypeOfPlaceholder((TypePlaceholder) expr1.getType());
+			if(tphType instanceof ExtendsWildcardType){
+				return ((ExtendsWildcardType) tphType).get_ExtendsType().get_Name();
+			}else if(tphType instanceof SuperWildcardType){
+				return ((SuperWildcardType) tphType).get_SuperType().get_Name();
+			}else{
+				return tphType.getName().toString();
+			}
+		}else{
+			return type.get_Name();
+		}
+	}
+
+	abstract ArithmeticInstruction getOperator(String returnType);
+	
+	private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
+		if(returnType.equals("java.lang.Integer")){
+			return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
+		}else if(returnType.equals("java.lang.Double")){
+			return _factory.createInvoke("java.lang.Double", "valueOf", new ObjectType("java.lang.Double"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.DOUBLE}, Constants.INVOKESTATIC);
+		}else if(returnType.equals("java.lang.Float")){
+			return _factory.createInvoke("java.lang.Float", "valueOf", new ObjectType("java.lang.Float"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.FLOAT}, Constants.INVOKESTATIC);
+		}else if(returnType.equals("java.lang.Long")){
+			return _factory.createInvoke("java.lang.Long", "valueOf", new ObjectType("java.lang.Long"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.LONG}, Constants.INVOKESTATIC);
+		}else{
+			throw new NotImplementedException();
+		}
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java

@@ -3,11 +3,15 @@ package de.dhbwstuttgart.syntaxtree.operator;
 
 import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.generic.InstructionList;
+
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 
 // ino.class.AndOp.24101.declaration 
@@ -25,6 +29,12 @@ public class AndOp extends LogOp
     }
     // ino.end
 
+	@Override
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
     
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java

@@ -3,6 +3,17 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.end
 // ino.module.DivideOp.8596.import 
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
+
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.DADD;
+import org.apache.commons.bcel6.generic.DDIV;
+import org.apache.commons.bcel6.generic.FADD;
+import org.apache.commons.bcel6.generic.FDIV;
+import org.apache.commons.bcel6.generic.IADD;
+import org.apache.commons.bcel6.generic.IDIV;
+import org.apache.commons.bcel6.generic.LADD;
+import org.apache.commons.bcel6.generic.LDIV;
 
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
@@ -25,9 +36,19 @@ public class DivideOp extends MulOp
         super(offset,variableLength);
     }
     // ino.end
-
-
-    
-    
+	
+	ArithmeticInstruction getOperator(String returnType) {
+		if(returnType.equals("java.lang.Integer")){
+			return new IDIV();
+		}else if(returnType.equals("java.lang.Double")){
+			return new DDIV();
+		}else if(returnType.equals("java.lang.Float")){
+			return new FDIV();
+		}else if(returnType.equals("java.lang.Long")){
+			return new LDIV();
+		}else{
+			throw new NotImplementedException();
+		}
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java

@@ -3,17 +3,31 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.end
 // ino.module.EqualOp.8597.import 
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.GOTO;
+import org.apache.commons.bcel6.generic.IF_ICMPNE;
+import org.apache.commons.bcel6.generic.InstructionConstants;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.NOP;
+import org.apache.commons.bcel6.generic.ObjectType;
+
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
+import de.dhbwstuttgart.parser.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
 import de.dhbwstuttgart.syntaxtree.statement.Null;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 
 
 
@@ -31,6 +45,11 @@ public class EqualOp extends RelOp
         super(offset, variableLength);
     }
     // ino.end
+
+	@Override
+	BranchInstruction getOperator() {
+		return new IF_ICMPNE(null);
+	}
     
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java

@@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.module.GreaterEquOp.8598.import 
 import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.IF_ICMPLT;
+
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
@@ -25,6 +28,11 @@ public class GreaterEquOp extends RelOp
         super(offset,variableLength);
     }
     // ino.end
+
+	@Override
+	BranchInstruction getOperator() {
+		return new IF_ICMPLT(null);
+	}
     
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java

@@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.module.GreaterOp.8599.import 
 import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.IF_ICMPLE;
+
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
@@ -25,5 +28,10 @@ public class GreaterOp extends RelOp
     }
    // ino.end
 
+	@Override
+	BranchInstruction getOperator() {
+		return new IF_ICMPLE(null);
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java

@@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.module.LessEquOp.8600.import 
 import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.IF_ICMPGT;
+
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
@@ -25,5 +28,10 @@ public class LessEquOp extends RelOp
     }
     // ino.end
 
+	@Override
+	BranchInstruction getOperator() {
+		return new IF_ICMPGT(null);
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java

@@ -3,6 +3,8 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.end
 // ino.module.LessOp.8601.import 
 import de.dhbwstuttgart.typeinference.Menge;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.IF_ICMPGE;
 
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
@@ -25,5 +27,10 @@ public class LessOp extends RelOp
     }
     // ino.end
 
+	@Override
+	BranchInstruction getOperator() {
+		return new IF_ICMPGE(null);
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java

@@ -18,10 +18,9 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 

src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java

@@ -4,6 +4,10 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.module.MinusOp.8603.import 
 import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.IADD;
+import org.apache.commons.bcel6.generic.ISUB;
+
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
@@ -25,6 +29,8 @@ public class MinusOp extends AddOp
     }
     // ino.end
 
-
+	ArithmeticInstruction getOperator(String returnType) {
+		return new ISUB();
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java

@@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.module.ModuloOp.8604.import 
 import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.IREM;
+
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
@@ -25,5 +28,10 @@ public class ModuloOp extends MulOp
     }
     // ino.end
 
+	@Override
+	ArithmeticInstruction getOperator(String returnType) {
+		return new IREM();
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java

@@ -6,16 +6,30 @@ package de.dhbwstuttgart.syntaxtree.operator;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.InvokeInstruction;
+import org.apache.commons.bcel6.generic.ObjectType;
+
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
+import de.dhbwstuttgart.syntaxtree.statement.Expr;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.Pair;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 
 // ino.class.MulOp.24231.declaration 
 public abstract class MulOp extends Operator
@@ -50,6 +64,62 @@ public abstract class MulOp extends Operator
 		return ret;
 	}
 
-    
+	@Override
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
+		// TODO Plus Operator ist bis jetzt nur für Integer implementiert
+		/*
+		 0: aload_1
+        1: invokevirtual #2                  // Method java/lang/Integer.intValue:()I
+        4: aload_1
+        5: invokevirtual #2                  // Method java/lang/Integer.intValue:()I
+        8: imul
+        9: invokestatic  #3                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
+       12: areturn
+		 */
+		DHBWInstructionFactory _factory = _cg.getInstructionFactory();
+		
+		String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2(), rs);
+			
+		InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
+		
+		il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
+		
+		il.append(getOperator(returnType));
+		
+		il.append(convertValueToObject(_factory, returnType));
+		return il;
+	}
+
+	private String getReturnType(Expr expr1, Expr expr2, TypeinferenceResultSet rs) {
+		Type type = expr1.getType();
+		if(type instanceof TypePlaceholder){
+			Type tphType = rs.getTypeOfPlaceholder((TypePlaceholder) expr1.getType());
+			if(tphType instanceof ExtendsWildcardType){
+				return ((ExtendsWildcardType) tphType).get_ExtendsType().get_Name();
+			}else if(tphType instanceof SuperWildcardType){
+				return ((SuperWildcardType) tphType).get_SuperType().get_Name();
+			}else{
+				return tphType.getName().toString();
+			}
+		}else{
+			return type.get_Name();
+		}
+	}
+
+	abstract ArithmeticInstruction getOperator(String returnType);
+	
+	private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
+		if(returnType.equals("java.lang.Integer")){
+			return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
+		}else if(returnType.equals("java.lang.Double")){
+			return _factory.createInvoke("java.lang.Double", "valueOf", new ObjectType("java.lang.Double"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.DOUBLE}, Constants.INVOKESTATIC);
+		}else if(returnType.equals("java.lang.Float")){
+			return _factory.createInvoke("java.lang.Float", "valueOf", new ObjectType("java.lang.Float"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.FLOAT}, Constants.INVOKESTATIC);
+		}else if(returnType.equals("java.lang.Long")){
+			return _factory.createInvoke("java.lang.Long", "valueOf", new ObjectType("java.lang.Long"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.LONG}, Constants.INVOKESTATIC);
+		}else{
+			throw new NotImplementedException();
+		}
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.end
 // ino.module.NotEqualOp.8606.import 
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -12,7 +11,10 @@ import de.dhbwstuttgart.syntaxtree.statement.Expr;
 import de.dhbwstuttgart.syntaxtree.statement.Null;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.IF_ACMPEQ;
+
 
 // ino.class.NotEqualOp.24241.declaration 
 public class NotEqualOp extends RelOp
@@ -28,5 +30,10 @@ public class NotEqualOp extends RelOp
     }
     // ino.end
 
+	@Override
+	BranchInstruction getOperator() {
+		return new IF_ACMPEQ(null);
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/Operator.java

@@ -5,8 +5,16 @@ package de.dhbwstuttgart.syntaxtree.operator;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.DADD;
+import org.apache.commons.bcel6.generic.FADD;
+import org.apache.commons.bcel6.generic.IADD;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.LADD;
+
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -19,54 +27,34 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
-
-// ino.class.Operator.24257.declaration 
 public abstract class Operator extends SyntaxTreeNode
-// ino.end
-// ino.class.Operator.24257.body
 {
     
-    // ino.attribute.offset.24261.declaration 
     private int offset;
-    // ino.end
-    // ino.attribute.variableLength.24264.declaration 
     private int variableLength;
-    // ino.end
-    
-    // ino.method.Operator.24267.definition 
     public Operator(int offset,int variableLength)
-    // ino.end
-    // ino.method.Operator.24267.body 
     {
         this.offset=offset;
         this.variableLength=variableLength;
     }
-    // ino.end
     
-    // ino.method.getOffset.24270.definition 
     public int getOffset()
-    // ino.end
-    // ino.method.getOffset.24270.body 
     {
         return offset;
     }
-    // ino.end
     
-    // ino.method.getVariableLength.24273.definition 
     public int getVariableLength()
-    // ino.end
-    // ino.method.getVariableLength.24273.body 
     {
         return variableLength;
     }
-    // ino.end
     
   
     /**
@@ -85,11 +73,33 @@ public abstract class Operator extends SyntaxTreeNode
 	 * @return
 	 */
 	public abstract HashMap<Type,Type> getReturnTypes(TypeAssumptions ass);
+	
+	public abstract InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator);
 
 	
 	@Override
 	public Menge<SyntaxTreeNode> getChildren() {
 		return new Menge<>();
 	}
+	
+	
+	protected InstructionList getInstructionListForOperand(ClassGenerator _cg, TypeinferenceResultSet rs, Expr operand, String returnType){
+		InstructionList il = new InstructionList();
+		il.append(operand.genByteCode(_cg, rs));
+		if(returnType.equals("java.lang.Integer")){
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.Integer", "intValue", org.apache.commons.bcel6.generic.Type.INT, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+		}else if(returnType.equals("java.lang.Double")){
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.Double", "doubleValue", org.apache.commons.bcel6.generic.Type.DOUBLE, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+		}else if(returnType.equals("java.lang.Float")){
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.Float", "floatValue", org.apache.commons.bcel6.generic.Type.FLOAT, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+		}else if(returnType.equals("java.lang.Long")){
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.Long", "longValue", org.apache.commons.bcel6.generic.Type.LONG, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+		}else if(returnType.equals("java.lang.String")){
+			
+		}else{
+			throw new NotImplementedException(returnType);
+		}
+		return il;
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java

@@ -2,6 +2,19 @@
 package de.dhbwstuttgart.syntaxtree.operator;
 // ino.end
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.GOTO;
+import org.apache.commons.bcel6.generic.IFEQ;
+import org.apache.commons.bcel6.generic.IFNE;
+import org.apache.commons.bcel6.generic.InstructionConstants;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.ObjectType;
+
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
+import de.dhbwstuttgart.syntaxtree.statement.Binary;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 
 // ino.class.OrOp.24282.declaration 
 public class OrOp extends LogOp
@@ -17,6 +30,47 @@ public class OrOp extends LogOp
         super(offset,variableLength);
     }
     // ino.end
+
+	@Override
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
+		/*
+        0: aload_1
+        1: invokevirtual #2                  // Method java/lang/Boolean.booleanValue:()Z
+        4: ifne          14
+        7: aload_2
+        8: invokevirtual #2                  // Method java/lang/Boolean.booleanValue:()Z
+       11: ifeq          18
+       14: iconst_1
+       15: goto          19
+       18: iconst_0
+       19: invokestatic  #3                  // Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
+       22: areturn
+       */
+		DHBWInstructionFactory _factory = _cg.getInstructionFactory();
+		
+		InstructionList il = operator.get_Expr1().genByteCode(_cg, rs);
+		il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+		
+		BranchInstruction firstTest = new IFNE(null);
+		il.append(firstTest);
+		
+		il.append(operator.get_Expr2().genByteCode(_cg, rs));
+		il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
+		
+		BranchInstruction secondTest = new IFEQ(null);
+		il.append(secondTest);
+		
+		firstTest.setTarget(il.append(InstructionConstants.ICONST_1));
+		
+		BranchInstruction gotoInstruction = new GOTO(null);
+		il.append(gotoInstruction);
+		
+		secondTest.setTarget(il.append(InstructionConstants.ICONST_0));
+		
+		gotoInstruction.setTarget(il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.BOOLEAN}, Constants.INVOKESTATIC)));
+		
+		return il;
+	}
     
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java

@@ -3,10 +3,30 @@ package de.dhbwstuttgart.syntaxtree.operator;
 // ino.end
 // ino.module.PlusOp.8609.import 
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.DADD;
+import org.apache.commons.bcel6.generic.FADD;
+import org.apache.commons.bcel6.generic.GOTO;
+import org.apache.commons.bcel6.generic.IADD;
+import org.apache.commons.bcel6.generic.IFEQ;
+import org.apache.commons.bcel6.generic.IFNE;
+import org.apache.commons.bcel6.generic.InstructionConstants;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.InvokeInstruction;
+import org.apache.commons.bcel6.generic.LADD;
+import org.apache.commons.bcel6.generic.ObjectType;
+
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
+import de.dhbwstuttgart.syntaxtree.type.Type;
 
 
 
@@ -24,6 +44,19 @@ public class PlusOp extends AddOp
         super(offset,variableLength);
     }
     // ino.end
-
+    
+	ArithmeticInstruction getOperator(String returnType) {
+		if(returnType.equals("java.lang.Integer")){
+			return new IADD();
+		}else if(returnType.equals("java.lang.Double")){
+			return new DADD();
+		}else if(returnType.equals("java.lang.Float")){
+			return new FADD();
+		}else if(returnType.equals("java.lang.Long")){
+			return new LADD();
+		}else{
+			throw new NotImplementedException();
+		}
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java

@@ -6,17 +6,27 @@ package de.dhbwstuttgart.syntaxtree.operator;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.commons.bcel6.Constants;
+import org.apache.commons.bcel6.generic.BranchInstruction;
+import org.apache.commons.bcel6.generic.GOTO;
+import org.apache.commons.bcel6.generic.InstructionConstants;
+import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.ObjectType;
+
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.Pair;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 // ino.class.RelOp.24299.declaration 
 public abstract class RelOp extends Operator
 // ino.end
@@ -54,6 +64,45 @@ public abstract class RelOp extends Operator
 		return ret;
 	}
 
+
+	@Override
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
+		/*
+        0: aload_1
+        1: invokevirtual #3                  // Method java/lang/Integer.intValue:()I
+        4: aload_2
+        5: invokevirtual #3                  // Method java/lang/Integer.intValue:()I
+        8: if_icmplt     15
+       11: iconst_1
+       12: goto          16
+       15: iconst_0
+       16: invokestatic  #2                  // Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
+       19: areturn
+       */
+		
+		DHBWInstructionFactory _factory = _cg.getInstructionFactory();
+			
+		InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), "java.lang.Boolean");
+		
+		il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), "java.lang.Boolean"));
+		
+		BranchInstruction operatorBranchInstruction = getOperator();
+		
+		il.append(operatorBranchInstruction);
+		
+		il.append(InstructionConstants.ICONST_1);
+		
+		BranchInstruction gotoInstruction = new GOTO(null);
+		
+		il.append(gotoInstruction);
+		
+		operatorBranchInstruction.setTarget(il.append(InstructionConstants.ICONST_0));
+		gotoInstruction.setTarget(il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new  org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.BOOLEAN}, Constants.INVOKESTATIC)));
+
+		return il;
+	}
+	
+	abstract BranchInstruction getOperator();    
     
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java

@@ -4,6 +4,13 @@ package de.dhbwstuttgart.syntaxtree.operator;
 
 // ino.module.TimesOp.8611.import 
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
+
+import org.apache.commons.bcel6.generic.ArithmeticInstruction;
+import org.apache.commons.bcel6.generic.DMUL;
+import org.apache.commons.bcel6.generic.FMUL;
+import org.apache.commons.bcel6.generic.IMUL;
+import org.apache.commons.bcel6.generic.LMUL;
 
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.statement.Binary;
@@ -22,6 +29,20 @@ public class TimesOp extends MulOp
         super(offset,variableLength);
     }
     // ino.end
+	
+	ArithmeticInstruction getOperator(String returnType) {
+		if(returnType.equals("java.lang.Integer")){
+			return new IMUL();
+		}else if(returnType.equals("java.lang.Double")){
+			return new DMUL();
+		}else if(returnType.equals("java.lang.Float")){
+			return new FMUL();
+		}else if(returnType.equals("java.lang.Long")){
+			return new LMUL();
+		}else{
+			throw new NotImplementedException();
+		}
+	}
 
 }
 // ino.end

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

@@ -11,6 +11,7 @@ import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 
 public class ArgumentList extends SyntaxTreeNode
 {
@@ -81,19 +82,19 @@ public class ArgumentList extends SyntaxTreeNode
 		return expr;
 	}
 	
-	public InstructionList generateBytecode(ClassGenerator cg){
+	public InstructionList generateBytecode(ClassGenerator cg, TypeinferenceResultSet rs){
 		InstructionList ret = new InstructionList();
 		for(Expr e : expr){
-			ret.append(e.genByteCode(cg));
+			ret.append(e.genByteCode(cg, rs));
 		}
 		return ret;
 	}
 	
-	public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg){
+	public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg, TypeinferenceResultSet rs){
 		org.apache.commons.bcel6.generic.Type[] ret = new org.apache.commons.bcel6.generic.Type[expr.size()];
 		int i = 0;
 		for(Expr e : expr){
-			ret[i] = e.getType().getBytecodeType(cg);
+			ret[i] = e.getType().getBytecodeType(cg, rs);
 			i++;
 		}
 		return ret;

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

@@ -17,6 +17,7 @@ import  org.apache.commons.bcel6.generic.LSTORE;
 
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -33,9 +34,9 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -106,8 +107,8 @@ public class Assign extends Expr
 		ret.add(expr2.TYPEExpr(assumptions));
 		//this.setTypeVariable( TypePlaceholder.fresh(this));
 		this.setType(TypePlaceholder.fresh(this));
-		ret.add(new SingleConstraint(expr2.getType().TYPE(assumptions, this), expr1.getType().TYPE(assumptions, this))); //expr2.type <. expr1.type
-		ret.add(new SingleConstraint(expr1.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this))); 
+		ret.add(ConstraintsSet.createSingleConstraint(expr2.getType().TYPE(assumptions, this), expr1.getType().TYPE(assumptions, this))); //expr2.type <. expr1.type
+		ret.add(ConstraintsSet.createSingleConstraint(expr1.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this))); 
 		return ret;
 	}
 	
@@ -175,17 +176,10 @@ public class Assign extends Expr
 		return ret;
 	}
 
-
-	public static int counterAssign = 0; //Zaehlvariable f<>r ISTORE
-
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
-		// TODO Auto-generated method stub
-			InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
-			InstructionList il = expr2.genByteCode(cg);//expr2 rechte expr
-			
-			
-			
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
+			DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, cg.getConstantPool());
+			InstructionList il = expr2.genByteCode(cg, rs);//expr2 rechte expr			
 			
 			/*
 			String expr2Type = expr2.getType().get_Name().toString();
@@ -212,10 +206,7 @@ public class Assign extends Expr
 			}
 			*/
 			//Es wird momentan immer von RefType ausgegangen:
-			il.append(new ASTORE(counterAssign));
-			
-			//TODO: ^^
-			counterAssign++; //macht STORE f<>r meherere Variable nutzbar (nicht nur ISTORE_1, ISTORE_2, etc.)
+			il.append(cg.getMethodGenerator().createStore(expr2.getType().getBytecodeType(cg, rs), expr1.get_Name()));
 			
 			return il;
 	}

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

@@ -38,11 +38,10 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -227,28 +226,8 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
-		InstructionList linkeSeite = this.expr1.genByteCode(_cg);
-		InstructionList rechteSeite = this.expr2.genByteCode(_cg);
-		if(this.getReturnType().getName().equals(new JavaClassName("String"))){
-			throw new TypeinferenceException("Zeichenketten zusammenfügen ist noch nicht unterstützt",this);
-		}
-		
-		linkeSeite.append(rechteSeite);
-		
-		//TODO: bytecode (Bis jetzt wird jeder Condition als EQUALS behandelt)
-		//TODO: bytecode autoboxing
-
-		BranchInstruction if_icmpneInstruction = new IF_ICMPNE(null);
-		linkeSeite.append(if_icmpneInstruction);
-		linkeSeite.append(InstructionConstants.ICONST_1);
-		
-		BranchInstruction gotoInstruction = new GOTO(null);
-		
-		linkeSeite.append(gotoInstruction);
-		if_icmpneInstruction.setTarget(linkeSeite.append(InstructionConstants.ICONST_0));
-		gotoInstruction.setTarget(linkeSeite.append(new NOP()));
-		return linkeSeite;
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
+		return op.genByteCode(_cg, rs, this);
 	}
     
 }

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

@@ -32,11 +32,10 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -187,8 +186,8 @@ public class Block extends Statement
 					}
 					else {
 						TypePlaceholder tph = TypePlaceholder.fresh(this);
-						ret.add(new SingleConstraint(this.getType().TYPE(assumptions, this), tph));
-						ret.add(new SingleConstraint(stmt.getType().TYPE(assumptions, this), tph));
+						ret.add(ConstraintsSet.createSingleConstraint(this.getType().TYPE(assumptions, this), tph));
+						ret.add(ConstraintsSet.createSingleConstraint(stmt.getType().TYPE(assumptions, this), tph));
 						this.setType(tph);
 					}
 			}
@@ -256,12 +255,12 @@ public class Block extends Statement
 	}
 	
 	@Override
-    public InstructionList genByteCode(ClassGenerator cg) {
+    public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		//ConstantPoolGen _cp = cg.getConstantPool();
 		InstructionList il = new InstructionList();
 		
 		for(Statement stmt : this.get_Statement()){
-			il.append(stmt.genByteCode(cg));
+			il.append(stmt.genByteCode(cg, rs));
 		}
 		//il.dispose();
 		

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

@@ -22,8 +22,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -130,7 +130,7 @@ public class BoolLiteral extends Literal
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		

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

@@ -23,8 +23,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -123,7 +123,7 @@ public class CastExpr extends UnaryExpr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -22,8 +22,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -125,7 +125,7 @@ public class CharLiteral extends Literal
 
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		il.append(new BIPUSH((byte) get_Char()));	

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

@@ -25,8 +25,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -145,7 +145,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}*/
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		ConstantPoolGen cp = _cg.getConstantPool();
 		//InstructionFactory _factory = new InstructionFactory(cg, cp);
 		InstructionList il = new InstructionList();

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

@@ -19,9 +19,9 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -89,7 +89,7 @@ public class EmptyStmt extends Statement
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -12,7 +12,7 @@ import de.dhbwstuttgart.core.MyCompiler;
 import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.Pair;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 // ino.class.ExprStmt.25265.declaration 
 public abstract class ExprStmt extends Statement

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

@@ -23,6 +23,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 
 
@@ -133,7 +134,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		ConstantPoolGen cp = _cg.getConstantPool();
 		InstructionList il = new InstructionList();
 		

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

@@ -33,14 +33,10 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
-import de.dhbwstuttgart.typeinference.unify.Unify;
-
-
-
-
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 public class ForStmt extends Statement
 {
@@ -133,7 +129,7 @@ public class ForStmt extends Statement
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		/*
 		 0: iconst_0
          1: istore_1
@@ -147,16 +143,16 @@ public class ForStmt extends Statement
 		
 		InstructionList il = new InstructionList();
 		
-		il.append(head_Initializer.genByteCode(_cg));
+		il.append(head_Initializer.genByteCode(_cg, rs));
 		
-		InstructionHandle ih = il.append(head_Condition.genByteCode(_cg));
+		InstructionHandle ih = il.append(head_Condition.genByteCode(_cg, rs));
 		
 		BranchInstruction branch = new IF_ICMPGE(null);
 		il.append(branch);
 		
-		il.append(body_Loop_block.genByteCode(_cg));
+		il.append(body_Loop_block.genByteCode(_cg, rs));
 		
-		il.append(head_Loop_expr.genByteCode(_cg));
+		il.append(head_Loop_expr.genByteCode(_cg, rs));
 		
 		il.append(new GOTO(ih));
 		

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

@@ -44,11 +44,10 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
-import de.dhbwstuttgart.typeinference.unify.MUB;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -141,10 +140,10 @@ public class IfStmt extends Statement
 		ret.add(this.then_block.TYPEStmt(assumptions));
 		if(else_block!=null){
 			ret.add(this.else_block.TYPEStmt(assumptions));
-			if(!(else_block.getType() instanceof Void))ret.add(new SingleConstraint(else_block.getType().TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));
+			if(!(else_block.getType() instanceof Void))ret.add(ConstraintsSet.createSingleConstraint(else_block.getType().TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));
 		}
-		ret.add(new SingleConstraint(expr.getType().TYPE(assumptions, this),new RefType("Boolean",this,0).TYPE(assumptions, this))); //(expressionDesIfStmt)<.boolean
-		if(!(then_block.getType() instanceof Void))ret.add(new SingleConstraint(then_block.getType().TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));
+		ret.add(ConstraintsSet.createSingleConstraint(expr.getType().TYPE(assumptions, this),new RefType("Boolean",this,0).TYPE(assumptions, this))); //(expressionDesIfStmt)<.boolean
+		if(!(then_block.getType() instanceof Void))ret.add(ConstraintsSet.createSingleConstraint(then_block.getType().TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));
 		if(then_block.getType() instanceof Void && 
 				(else_block == null || else_block.getType() instanceof Void))this.setType(new Void(this,this.getOffset()));
 		return ret;
@@ -178,22 +177,22 @@ public class IfStmt extends Statement
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = _cg.getInstructionFactory();
 		InstructionList il = new InstructionList();
 		IfInstruction ifInstruction = new IFEQ(null);
 		
-		il.append(expr.genByteCode(_cg));
+		il.append(expr.genByteCode(_cg, rs));
 		//Anmerkung: expr ist vom Typ java.lang.Boolean (per Definition)
 		il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, org.apache.commons.bcel6.generic.Type.NO_ARGS, Constants.INVOKEVIRTUAL));
 		il.append(ifInstruction);
-		il.append(then_block.genByteCode(_cg));
+		il.append(then_block.genByteCode(_cg, rs));
 		
 		if(else_block != null && !(else_block instanceof EmptyStmt)){
-			GotoInstruction gotoInstruction = new GOTO(null);
-			il.append(gotoInstruction);
-			ifInstruction.setTarget(il.append(else_block.genByteCode(_cg)));
-			gotoInstruction.setTarget(il.append(new NOP()));
+			//GotoInstruction gotoInstruction = new GOTO(null);
+			//il.append(gotoInstruction);
+			ifInstruction.setTarget(il.append(else_block.genByteCode(_cg, rs)));
+			//gotoInstruction.setTarget(il.append(new NOP()));
 		}else{
 			ifInstruction.setTarget(il.append(new NOP()));
 		}

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

@@ -31,7 +31,7 @@ import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -93,7 +93,7 @@ public class InstVar extends Expr
     {
         super(offset,variableLength);
         Iterator namen = ui.get_Name().iterator();
-        LocalOrFieldVar innerLOFV = new LocalOrFieldVar((String)namen.next(),getOffset());
+        LocalOrFieldVarOrClassname innerLOFV = new LocalOrFieldVarOrClassname((String)namen.next(),getOffset());
         //innerLOFV.setType(TypePlaceholder.fresh(this));
         InstVar INSTVA = new InstVar(innerLOFV, (String)namen.next(),offset);
         //INSTVA.setType(TypePlaceholder.fresh(this));
@@ -166,25 +166,16 @@ public class InstVar extends Expr
      * <br/>Author: Martin Pl�micke
      * @return
      */
-    // ino.end
-    // ino.method.toString.25441.definition 
     public String toString()
-    // ino.end
-    // ino.method.toString.25441.body 
     {
     	String superType = "";
     	if(super.type != null)superType += super.type.toString();
         return superType + " " + usedid.toString();
     }
-    // ino.end
     
-    // ino.method.wandleRefTypeAttributes2GenericAttributes.25444.definition 
     public void wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)
-    // ino.end
-    // ino.method.wandleRefTypeAttributes2GenericAttributes.25444.body 
     {
     }
-    // ino.end
     
 	@Override
 	public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) {
@@ -220,7 +211,7 @@ public class InstVar extends Expr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -23,6 +23,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 
 
@@ -119,7 +120,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -26,8 +26,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -139,7 +139,7 @@ public class IntLiteral extends Literal
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		

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

@@ -41,12 +41,11 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
 import de.dhbwstuttgart.typeinference.Typeable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 /**
  * @author A10023 - Andreas Stadelmeier
@@ -165,40 +164,15 @@ public class LambdaExpression extends Expr{
 		ret.add(method_body.TYPEStmt(ArgumentAssumptions.add(assumptions))); //Es gibt die LambdaExpression nur mit einem Block als Method Body, nicht mit einer einzelnen Expression
 		
 		//Die Constraints für ParameterTypen und Ret Typ erstellen:
-		Menge<Type> modifiedParamTypes = new Menge<>();
-		for(Type pT : paramTypes){
-			if(pT instanceof WildcardType){
-				//Auf Typfehler kontrollieren. Siehe Bug #12 Kommentar 3
-				if(pT instanceof ExtendsWildcardType){
-					throw new TypeinferenceException("Typfehler von Parametertyp "+pT,this);
-				}else{
-					modifiedParamTypes.add(pT);
-				}
-			}else{
-				modifiedParamTypes.add(new SuperWildcardType((ObjectType) pT));
-			}
-		}
+		
 		Type retType = method_body.getType();
-		// PN < TPH PN
-		if(retType instanceof WildcardType){
-			//Auf Typfehler kontrollieren. Siehe Bug #12 Kommentar 3
-				if(retType instanceof SuperWildcardType){
-					throw new TypeinferenceException("Typfehler von Parametertyp "+retType,this);
-				}else{
-					//retType bleibt unverändert
-				}
-			}else{
-				//Die LambdaExpression kann zu diesem Zeit schon feststellen, ob der Return-Type Void ist (Kein Return-Statement):
-				if(!typeIsVoid(retType)){ //Nur, wenn es nicht void ist, kann der ExtendsWildcardType gebildet werden.
-					retType = new ExtendsWildcardType((ObjectType) retType);
-				}
-		}
+		
 		if(typeIsVoid(retType)){//In diesem Fall, muss der Typ des LambdaAusdrucks FunVoid sein
-			this.lambdaType = new FunVoidN(modifiedParamTypes);
+			this.lambdaType = new FunVoidN(paramTypes);
 		}else{
-			this.lambdaType = new FunN(retType, modifiedParamTypes);
+			this.lambdaType = new FunN(retType, paramTypes);
 		}
-		ret.add(new SingleConstraint(lambdaType.TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));
+		ret.add(ConstraintsSet.createSingleConstraint(lambdaType.TYPE(assumptions, this),this.getType().TYPE(assumptions, this)));
 		
 		return ret;
 	}
@@ -238,12 +212,12 @@ public class LambdaExpression extends Expr{
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		ConstantPoolGen cp = cg.getConstantPool();
 		InstructionList il = new InstructionList();
 		
-		org.apache.commons.bcel6.generic.Type[] paramTypes = params.getBytecodeTypeList(cg);
-		org.apache.commons.bcel6.generic.Type retType = method_body.getType().getBytecodeType(cg);
+		org.apache.commons.bcel6.generic.Type[] paramTypes = params.getBytecodeTypeList(cg, rs);
+		org.apache.commons.bcel6.generic.Type retType = method_body.getType().getBytecodeType(cg, rs);
 		
 		MethodGenerator lambdaMethod = new MethodGenerator(0, retType,
 				paramTypes, params.getParameterNameArray(), cg.createLambdaMethodName(),
@@ -255,18 +229,18 @@ public class LambdaExpression extends Expr{
 		
 		String interfaceMethodName = "apply"; //Das ist ein Hack, funktioniert momentan, da nur FunN Interfaces für LambdaAusdrücke funktionieren
 		il.append(InstructionFactory.createLoad( org.apache.commons.bcel6.generic.Type.OBJECT, 0));
-		il.append(cg.getInstructionFactory().createInvokeDynamic(interfaceMethodName,this.getLambdaSignature(cg),lambdaType,lambdaMethod));
+		il.append(cg.getInstructionFactory().createInvokeDynamic(interfaceMethodName,this.getLambdaSignature(cg, rs),lambdaType,lambdaMethod, rs));
 		
-		cg.addMethod(lambdaMethod.createMethod(cg, params, method_body.getType(), method_body));
+		cg.addMethod(lambdaMethod.createMethod(cg, params, method_body.getType(), method_body, rs));
 		
 		return il;
 	}
 
-	private String getLambdaSignature(ClassGenerator cg){
+	private String getLambdaSignature(ClassGenerator cg, TypeinferenceResultSet rs){
 		String typeSignature = "(";
-		typeSignature+=this.getParentClass().getType().getBytecodeType(cg).getSignature();
+		typeSignature+=this.getParentClass().getType().getBytecodeType(cg, rs).getSignature();
 		typeSignature += ")";
-		typeSignature += this.lambdaType.getBytecodeType(cg).getSignature();
+		typeSignature += this.lambdaType.getBytecodeType(cg, rs).getSignature();
 		return typeSignature;
 	}
 }

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

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 
 import de.dhbwstuttgart.myexception.JVMCodeException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 // ino.class.Literal.25490.declaration 
 public abstract class Literal extends Expr

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

@@ -28,17 +28,17 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
 
 // ino.class.LocalOrFieldVar.25503.declaration 
-public class LocalOrFieldVar extends Expr
+public class LocalOrFieldVarOrClassname extends Expr
 // ino.end
 // ino.class.LocalOrFieldVar.25503.body
 {
@@ -47,9 +47,10 @@ public class LocalOrFieldVar extends Expr
     protected static Logger parserlog = Logger.getLogger("parser");
     // ino.end
 	private boolean isFieldAccess = false;
+	private boolean isClassAccess = false;
 
     // ino.method.LocalOrFieldVar.25510.definition 
-    public LocalOrFieldVar(int offset, int variableLength)
+    public LocalOrFieldVarOrClassname(int offset, int variableLength)
     // ino.end
     // ino.method.LocalOrFieldVar.25510.body 
     {
@@ -58,7 +59,7 @@ public class LocalOrFieldVar extends Expr
     // ino.end
 
     // ino.method.LocalOrFieldVar.25513.definition 
-    public LocalOrFieldVar(String n, int offset)
+    public LocalOrFieldVarOrClassname(String n, int offset)
     // ino.end
     // ino.method.LocalOrFieldVar.25513.body 
     {
@@ -120,14 +121,23 @@ public class LocalOrFieldVar extends Expr
 		ConstraintsSet ret = new ConstraintsSet();
 		//gibt es eine Assumption für den die LocalOrFieldVar-Variablen, dann folgendes ausführen:
 		Type thisTypeAssumption = assumptions.getVarType(this.get_Name(), this.getParentClass());
-		if(thisTypeAssumption == null)throw new TypeinferenceException("Eine Variable "+this.get_Name()+" ist in den Assumptions nicht vorhanden",this);
-		Type thisType = thisTypeAssumption.checkTYPE(assumptions, this);
-		this.setType(thisType);
-		//ret.add(new Constraint(thisTypeAssumption, this.getTypeVariable()));
-		//Rausfinden, ob es Feld oder Locale Variable ist:
-		for(FieldAssumption fAss : assumptions.getFieldVars(this.get_Name())){
-			if(this.getParentClass().equals(fAss.getParentClass()))this.isFieldAccess = true;
-		};
+		if(thisTypeAssumption == null){//Es ist keine Variable oder Feld
+			//Testen ob es ein Klassenname ist:
+			ClassAssumption cAss = assumptions.getClass(this.get_Name());
+			if(cAss == null)throw new TypeinferenceException("Weder eine Variable noch eine Klasse "+this.get_Name()+" ist in den Assumptions nicht vorhanden",this);
+			
+			thisTypeAssumption = cAss.getAssumedClass().getType();
+			this.set_Type(thisTypeAssumption);
+			this.isClassAccess = true;
+		}else{
+			Type thisType = thisTypeAssumption.checkTYPE(assumptions, this);
+			this.setType(thisType);
+			//ret.add(new Constraint(thisTypeAssumption, this.getTypeVariable()));
+			//Rausfinden, ob es Feld oder Locale Variable ist:
+			for(FieldAssumption fAss : assumptions.getFieldVars(this.get_Name())){
+				if(this.getParentClass().equals(fAss.getParentClass()))this.isFieldAccess = true;
+			};
+		}
 		
 		return ret;
 	}
@@ -148,18 +158,18 @@ public class LocalOrFieldVar extends Expr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		InstructionList il = new InstructionList();
 		if(this.isFieldAccess){
-			il.append(cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(), this.get_Name(), this.getType().getBytecodeType(cg), Constants.GETFIELD));
+			il.append(cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(), this.get_Name(), this.getType().getBytecodeType(cg, rs), Constants.GETFIELD));
 		}
 
 		Type type = this.getType();
-		org.apache.commons.bcel6.generic.Type byteCodeType = type.getBytecodeType(cg);
+		org.apache.commons.bcel6.generic.Type byteCodeType = type.getBytecodeType(cg, rs);
 		
 		String name = this.get_Name();
 		
-		il.append(cg.getInstructionFactory().createLoad(byteCodeType, name));
+		il.append(cg.getMethodGenerator().createLoad(byteCodeType, name));
 		return il;
 	}
 

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

@@ -27,14 +27,13 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
 import de.dhbwstuttgart.typeinference.TypeInsertable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.LocalVarAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -100,59 +99,6 @@ public class LocalVarDecl extends Statement implements TypeInsertable
     }
     // ino.end
     
-    // ino.method.is_declared.25587.definition 
-    public void is_declared(Type t, Menge<Class> classlist)
-    throws SCStatementException
-    // ino.end
-    // ino.method.is_declared.25587.body 
-    {
-    boolean flag=false;
-    for(Enumeration<Class> e = classlist.elements();e.hasMoreElements();){
-        flag = false;   
-        Class c = e.nextElement();
-        
-    //      System.out.println("is_init:  vergleiche "+t.get_Type_()+" mit "+c.get_classname());
-        if(c.getName().equals(t.getName())){
-    //      System.out.println("Klasse "+t.get_Type()+" im Menge classlist gefunden.");
-        flag = true;
-        break;
-        }
-    }
-    
-    if ( t instanceof RefType  )
-    {
-        if(((RefType)t).get_ParaList()!=null)
-        {
-            if( ((RefType)t).get_ParaList().size()>0)
-            {
-                for(Enumeration e1 = ((RefType)t).get_ParaList().elements();e1.hasMoreElements();)
-                {
-                try
-                {
-                    is_declared((Type)e1.nextElement(),classlist);
-                }
-                catch(SCStatementException ex)
-                {
-                    throw ex;
-                }
-                }
-            }
-        }
-    }
-    
-    if(!flag)
-    {
-        SCStatementException ex = new SCStatementException();
-        SCExcept e = new SCExcept();
-        e.set_error("unbekannte Klasse "+t.getName()+".");
-        e.set_function("complete_parahashtable() --> is_declared()");
-        e.set_statement(t.getName().toString());
-        ex.addException(e);
-        throw ex;
-    }
-    }
-    // ino.end
-    
     /*
     // ino.method.check_anz.25590.definition 
     public void check_anz(Type type, Menge paralist, Menge<Class> classlist)
@@ -371,14 +317,14 @@ public class LocalVarDecl extends Statement implements TypeInsertable
 		}
 		assumptions.addAssumption(new LocalVarAssumption(this, this.getType())); //Bevor der Typ auf Void gesetzt wird.
 		//if(this.getType() == null)throw new DebugException("Parser Post Processing nicht aufgerufen");
-		ret.add(new SingleConstraint(this.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this)));
+		ret.add(ConstraintsSet.createSingleConstraint(this.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this)));
 		//assumptions.remove(null); // falls Variable mit diesem Namen bereits vorhanden.
 		this.setReturnType(new Void(this,0)); //Return typ einer Variablendeklaration ist Void
 		return ret;
 	}
 
 	@Override
-	public String getDescription() {
+	public String getDescription(){
     	if(this.getType() == null)return "no type " + declid.toString(); 
     	if(this.getType() instanceof TypePlaceholder)return declid.toString();
         return  this.getType().toString() + " " + declid.toString();
@@ -429,8 +375,8 @@ public class LocalVarDecl extends Statement implements TypeInsertable
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
-		// TODO Auto-generated method stub
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
+		_cg.getMethodGenerator().getStoreIndex(get_Name());
 		return new InstructionList();
 	}
 }

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

@@ -22,8 +22,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -129,7 +129,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		ConstantPoolGen cp = _cg.getConstantPool();
 		//InstructionFactory _factory = new InstructionFactory(cg, cp);
 		InstructionList il = new InstructionList();

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

@@ -12,6 +12,7 @@ import  org.apache.commons.bcel6.generic.InstructionList;
 
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -25,6 +26,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
@@ -321,15 +323,15 @@ public class MethodCall extends Expr
 	 */
 	
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		InstructionList il = new InstructionList();
-		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
+		DHBWInstructionFactory _factory = cg.getInstructionFactory();
 		
-		il.append(receiver.get_Expr().genByteCode(cg));
+		il.append(receiver.get_Expr().genByteCode(cg, rs));
 		
 		//Herausfinden, ob eine Methode oder ein Interface aufgerufen wird:
 		Type receiverType = this.receiver.get_Expr().getType();
-		de.dhbwstuttgart.syntaxtree.Class receiverClass = this.receiver.getReceiverClass(cg);
+		de.dhbwstuttgart.syntaxtree.Class receiverClass = this.receiver.getReceiverClass(cg, rs);
 		short kind = 0;
 		if(receiverClass.isInterface()){
 			kind = Constants.INVOKEINTERFACE;
@@ -342,15 +344,17 @@ public class MethodCall extends Expr
 			argumentTypen = new  org.apache.commons.bcel6.generic.Type[this.getArgumentList().size()];
 			int i = 0;
 			for(Expr argument : this.arglist.expr){
-				argumentTypen[i] = argument.getType().getBytecodeType(cg);
+				cg.getMethodGenerator().getStoreIndex(argument.get_Name());
+				
+				argumentTypen[i] = argument.getType().getBytecodeType(cg, rs);
 				//Das Argument auf den Stack legen:
-				il.append(argument.genByteCode(cg));
+				il.append(argument.genByteCode(cg, rs));
 				i++;
 			}
 		}
 		
-		 org.apache.commons.bcel6.generic.Type returnType = this.getType().getBytecodeType(cg);
-		il.append(_factory.createInvoke(receiver.getReceiverClass(cg).getName().toString(), this.get_Name(), returnType , argumentTypen, kind));
+		 org.apache.commons.bcel6.generic.Type returnType = this.getType().getBytecodeType(cg, rs);
+		il.append(_factory.createInvoke(receiver.getReceiverClass(cg, rs).getName().toString(), this.get_Name(), returnType , argumentTypen, kind));
 		return il;
 	}
 	

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

@@ -26,9 +26,9 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -112,7 +112,7 @@ public class NegativeExpr extends UnaryExpr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -20,8 +20,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -147,11 +147,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		
-		il.append(expr.elementAt(0).genByteCode(_cg));
+		il.append(expr.elementAt(0).genByteCode(_cg, rs));
 		il.append(_factory.createNewArray( org.apache.commons.bcel6.generic.Type.getType(getTypeName()), (short)1));
 	
 		

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

@@ -34,12 +34,11 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -193,15 +192,22 @@ public class NewClass extends Expr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionList il = new InstructionList();
+		//il.append(_cg.getInstructionFactory().createNew(get_Name()));
+		il.append(_cg.getInstructionFactory().createNew(this.getType().getBytecodeType(_cg, rs).toString()));
+		il.append(InstructionConstants.DUP);
+		
+		String signature = getType().getBytecodeSignature(_cg, rs);
+		String description =  signature.substring(1, signature.length()-1);
+		
 		if(arglist!=null){
-			il.append(arglist.generateBytecode(_cg));
-			il.append(_cg.getInstructionFactory().createInvoke(this.get_Name(), "<init>", 
+			il.append(arglist.generateBytecode(_cg, rs));
+			il.append(_cg.getInstructionFactory().createInvoke(description, "<init>", 
 					org.apache.commons.bcel6.generic.Type.VOID,
-						this.arglist.getBytecodeTypeList(_cg), Constants.INVOKESPECIAL));
+						this.arglist.getBytecodeTypeList(_cg, rs), Constants.INVOKESPECIAL));
 		}else{
-			il.append(_cg.getInstructionFactory().createInvoke(this.get_Name(), "<init>", 
+			il.append(_cg.getInstructionFactory().createInvoke(description, "<init>", 
 					org.apache.commons.bcel6.generic.Type.VOID,
 						new org.apache.commons.bcel6.generic.Type[]{}, Constants.INVOKESPECIAL));
 		}

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

@@ -26,9 +26,9 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -136,7 +136,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -22,8 +22,8 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -95,7 +95,7 @@ public class Null extends Literal
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		

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

@@ -20,8 +20,8 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -120,7 +120,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -26,9 +26,9 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -93,7 +93,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -30,10 +30,10 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.OderConstraint;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -103,7 +103,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	public static int counterPostInc = 0;
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(_cg, _cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		counterPostInc++;

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

@@ -26,9 +26,9 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -92,7 +92,7 @@ public class PreDecExpr extends UnaryExpr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -26,9 +26,9 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -94,7 +94,7 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		// TODO Bytecode
 		throw new NotImplementedException();
 	}

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

@@ -18,6 +18,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@@ -101,15 +102,17 @@ public class Receiver
     }
     */
     
-    public Class getReceiverClass(ClassGenerator cg){
+    public Class getReceiverClass(ClassGenerator cg, TypeinferenceResultSet rs){
     	de.dhbwstuttgart.syntaxtree.type.Type receiverType = this.get_Expr().getType();
     	if(receiverType instanceof TypePlaceholder){
-    		receiverType = cg.resolveTPH((TypePlaceholder)receiverType);
+    		receiverType = rs.getTypeOfPlaceholder((TypePlaceholder)receiverType);
     	}
     	if(!(receiverType instanceof RefType)){
     		throw new TypeinferenceException("Typ des Receivers nicht eindeutig",this.get_Expr());
     	}
     	ClassAssumption receiverClassAssumption = typeAssumptions.getClassAssumptionFor((RefType)receiverType);
+    	if(receiverClassAssumption == null)
+    		throw new TypeinferenceException("Die Klasse für den Typ "+receiverType+" ist nicht in den Assumptions vorhanden", receiverType);
     	de.dhbwstuttgart.syntaxtree.Class receiverCl = receiverClassAssumption.getAssumedClass();
 		return receiverCl;
     }

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

@@ -24,9 +24,8 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -95,7 +94,7 @@ public class Return extends Statement
 		ret.add(this.retexpr.TYPEExpr(assumptions));
 		//this.setTypeVariable(TypePlaceholder.fresh("Return Type"));
 		this.setType(TypePlaceholder.fresh(this));
-		ret.add(new SingleConstraint(retexpr.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this)));
+		ret.add(ConstraintsSet.createSingleConstraint(retexpr.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this)));
 		return ret;
 	}
 	
@@ -134,12 +133,12 @@ public class Return extends Statement
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
-		InstructionList il = retexpr.genByteCode(cg);
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
+		InstructionList il = retexpr.genByteCode(cg, rs);
 		
 		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 		
-		org.apache.commons.bcel6.generic.Type retType = this.getReturnType().getBytecodeType(cg);//retexpr.getType().getBytecodeType();
+		org.apache.commons.bcel6.generic.Type retType = this.getReturnType().getBytecodeType(cg, rs);//retexpr.getType().getBytecodeType();
 		il.append(_factory.createReturn(retType ));
 		
 		return il;

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

@@ -26,6 +26,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.Typeable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 
 
@@ -130,7 +131,7 @@ public abstract class Statement extends SyntaxTreeNode implements IItemWithOffse
 	}
 	
 
-	public abstract InstructionList genByteCode(ClassGenerator _cg);
+	public abstract InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs);
 	
 }	
 		

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

@@ -28,6 +28,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 
 
@@ -123,7 +124,7 @@ public class StringLiteral extends Literal
 	    }
 	//public static int counterString = 0;
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		ConstantPoolGen cp = cg.getConstantPool();
 		InstructionFactory _factory = new InstructionFactory(cg, cp);
 		InstructionList il = new InstructionList();

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

@@ -28,10 +28,10 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -92,7 +92,7 @@ public class SuperCall extends ThisCall
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator cg) {
+	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 		InstructionList il = new InstructionList();
 		Type superClass = this.getParentClass().getSuperClass();

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

@@ -28,10 +28,10 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 
@@ -149,7 +149,7 @@ public class This extends Expr
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
 		InstructionList il = new InstructionList();
 	    il.append(InstructionFactory.createLoad( org.apache.commons.bcel6.generic.Type.OBJECT, 0));
 	    return il;

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

@@ -24,7 +24,6 @@ import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
 
 
 

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

@@ -6,7 +6,11 @@ import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
 
+import org.apache.commons.bcel6.generic.BranchInstruction;
 import  org.apache.commons.bcel6.generic.ClassGen;
+import org.apache.commons.bcel6.generic.DUP;
+import org.apache.commons.bcel6.generic.GOTO;
+import org.apache.commons.bcel6.generic.IFEQ;
 import org.apache.commons.bcel6.generic.InstructionList;
 
 import de.dhbwstuttgart.typeinference.Menge;
@@ -28,11 +32,11 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
-import de.dhbwstuttgart.typeinference.unify.CSubstitutionSet;
-import de.dhbwstuttgart.typeinference.unify.Unify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 
 
 
@@ -112,7 +116,7 @@ public class WhileStmt extends Statement
 	public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) {
 		ConstraintsSet ret = new ConstraintsSet();
 		ret.add(expr.TYPEExpr(assumptions));
-		SingleConstraint exprMustBeBool = new SingleConstraint(expr.getType().TYPE(assumptions, this), new RefType("Boolean",this, 0).TYPE(assumptions, this)); // while(expr){}; expr <. boolean
+		UndConstraint exprMustBeBool = ConstraintsSet.createSingleConstraint(expr.getType().TYPE(assumptions, this), new RefType("Boolean",this, 0).TYPE(assumptions, this)); // while(expr){}; expr <. boolean
 		ret.add(exprMustBeBool);
 		ret.add(this.loop_block.TYPEStmt(assumptions));
 		this.setType(loop_block.getType());
@@ -137,9 +141,21 @@ public class WhileStmt extends Statement
 	}
 
 	@Override
-	public InstructionList genByteCode(ClassGenerator _cg) {
-		// TODO Bytecode
-		throw new NotImplementedException();
+	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
+		//TOD: while Statement
+		InstructionList il = expr.genByteCode(_cg, rs);
+		
+		BranchInstruction ifeq = new IFEQ(null);
+		il.append(ifeq);
+		
+		il.append(loop_block.genByteCode(_cg, rs));
+		
+		il.append(new GOTO(il.getStart()));
+		
+		ifeq.setTarget(il.append(new DUP()));
+		
+		
+		return il;
 	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java

@@ -9,7 +9,6 @@ import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.syntaxtree.Class;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
-import de.dhbwstuttgart.typeinference.SingleConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;