Fehler durch Änderung von Unify beheben. Merge mit bytecode

ASTFacotry überarbeitet

BCEL/bcelifier/JavaToBCEL.java

@@ -23,7 +23,7 @@ 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+"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();
@@ -32,6 +32,7 @@ public class JavaToBCEL {
 			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();
 			
 		} catch (ClassFormatException | IOException e) {
 			e.printStackTrace();

BCEL/bcelifier/Lambda1Creator.java

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

BCEL/bcelifier/NewClass.java

@@ -0,0 +1,10 @@
+package bcelifier;
+
+
+public class NewClass {
+	public NewClass(Integer i){}
+	void methode2(){
+		new NewClass(1);
+	}
+}
+

BCEL/bcelifier/NewClassCreator.java

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

BCEL/bcelifier/ThisCreator.java

@@ -11,7 +11,7 @@ public class ThisCreator implements Constants {
   private ClassGen           _cg;
 
   public ThisCreator() {
-    _cg = new ClassGen("bcelifier.This", "java.lang.Object", "<Unknown>", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+    _cg = new ClassGen("bcelifier.This", "java.lang.Object", "This.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
 
     _cp = _cg.getConstantPool();
     _factory = new InstructionFactory(_cg, _cp);

notizen/stf/Notes

@@ -0,0 +1,16 @@
+- Was sind / wof<6F>r brauch man TTO und Classes
+- Unify l<>st auch zirkul<75>re Abh<62>ngigkeiten a <. b <. c <. a
+	- Tests dazu?
+	- Pr<50>fung im Builder?
+	
+- Unterschied Wildcard und FreshWildcard, ExtendsWildcard und FreshExtendsWildcard etc...
+	- FreshWildcard = TPH f<>r Wildcards?
+
+- Warum ist result von unify = Menge<Menge<Pair>> und nicht Menge<Pair>
+
+- Menge Equals <20>berarbeiten (Momentan Reihenfolgensensitiv)
+
+- Wie kommen die Mengen des Unify-Algorithmus zustande? Siehe test: 		
+		/*
+		 * Test b <. a, a <. b
+		 */

src/de/dhbwstuttgart/bytecode/ClassGenerator.java

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.bytecode;
 
+import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Map;
 
 import org.apache.commons.bcel6.classfile.BootstrapMethod;
 import org.apache.commons.bcel6.classfile.BootstrapMethods;
@@ -18,22 +20,24 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 
 public class ClassGenerator extends ClassGen{
 
 	private DHBWConstantPoolGen cp;
 	private DHBWInstructionFactory factory;
-	private TypeinferenceResultSet tiResult;
+	private TypeinferenceResults tiResult;
 	private int lambdaMethodeNr = 0;
 	private Type superClass;
 	
 	private Menge<TypePlaceholder> usedTPHs = new Menge<>();
+	
+	private Map<String, ClassGenerator> extraClasses = new HashMap<>();
 
-	public ClassGenerator(String name, Type superClass, String string,
-			short accPublic, String[] strings, TypeinferenceResultSet resultSet) {
-		super(name,superClass.get_Name(),string,accPublic,strings, new DHBWConstantPoolGen());
-		this.tiResult = resultSet;
+	public ClassGenerator(String name, Type superClass, String string, short accessflags, String[] strings, TypeinferenceResults typeinferenceResults) {
+		super(name,superClass.get_Name(),string,accessflags,strings, new DHBWConstantPoolGen());
+		this.tiResult = typeinferenceResults;
 		this.superClass = superClass;
 		
 		cp = (DHBWConstantPoolGen) super.getConstantPool();
@@ -51,8 +55,7 @@ public class ClassGenerator extends ClassGen{
 	 * @param toTPH
 	 * @return Es gilt dann "toTPH extends Type"
 	 */
-	public org.apache.commons.bcel6.generic.Type getNearestUsedType(TypePlaceholder toTPH, Menge<TypePlaceholder> usedTypes){
-		Type t = resolveTPH(toTPH, usedTypes);
+	public org.apache.commons.bcel6.generic.Type getNearestUsedType(Type t, Menge<TypePlaceholder> usedTypes){
 		if(t == null){
 			return this.getInstructionFactory().createObjectType();
 		}else if(t instanceof TypePlaceholder){ //Es muss sich in diesem Fall um einen TPH handeln:
@@ -66,12 +69,12 @@ public class ClassGenerator extends ClassGen{
 		return this.getNearestUsedType(toTPH, null);
 	}
 	
-	public Type resolveTPH(TypePlaceholder typePlaceholder) {
-		return resolveTPH(typePlaceholder, null);
+	public Type resolveTPH(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex) {
+		return resolveTPH(typePlaceholder, typeinferenceResultSetIndex, null);
 	}
 	
-	public Type resolveTPH(TypePlaceholder typePlaceholder, Menge<TypePlaceholder> toOneOfTheseTypes) {
-		return tiResult.getTypeOfPlaceholder(typePlaceholder, toOneOfTheseTypes);
+	public Type resolveTPH(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex, Menge<TypePlaceholder> toOneOfTheseTypes) {
+		return tiResult.getTypeOfPlaceholder(typePlaceholder, typeinferenceResultSetIndex, toOneOfTheseTypes);
 	}
 
 	public String createLambdaMethodName() {
@@ -156,4 +159,18 @@ public class ClassGenerator extends ClassGen{
 		return ret;
 	}
 	
+	public void addExtraClass(ClassGenerator cg){
+		extraClasses.put(cg.getClassName(), cg);
+	}
+
+	public Map<String, ClassGenerator> getExtraClasses() {
+		return extraClasses;
+	}
+
+	public TypeinferenceResults getTypeinferenceResults() {
+		return tiResult;
+	}
+	
+	
+	
 }

src/de/dhbwstuttgart/core/ConsoleInterface.java

@@ -7,6 +7,7 @@ import java.util.*;
 
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
@@ -34,13 +35,13 @@ public class ConsoleInterface {
             /////////////////////////
             // Parsen:
             /////////////////////////
-            compiler.parse(filenames);
+        	Menge<SourceFile> sourceFiles = compiler.parse(filenames);
 
             /////////////////////////
             // Typrekonstruktion:
             /////////////////////////
             try{
-            	resultSet = compiler.typeReconstruction();
+            	resultSet = compiler.typeReconstruction(sourceFiles);
             }catch(TypeinferenceException texc){
             	texc.printStackTrace();
             	fail("Fehler bei Typinferenzalgorithmus. Message: "+texc.getMessage());

src/de/dhbwstuttgart/core/MyCompiler.java

@@ -1,9 +1,6 @@
-// ino.module.MyCompiler.8569.package 
+
 package de.dhbwstuttgart.core;
-// ino.end
 
-
-// ino.module.MyCompiler.8569.import 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -42,73 +39,35 @@ import de.dhbwstuttgart.typeinference.FunVoidNInterface;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.ParserError;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 
 
-
-// ino.class.MyCompiler.21258.declaration 
-public class MyCompiler implements MyCompilerAPI
-// ino.end
-// ino.class.MyCompiler.21258.body
-{
-    // ino.attribute.NO_LINENUMBER.21262.decldescription type=line
+public class MyCompiler implements MyCompilerAPI{
     // PL: Der Zusammenhang zwischen paralist und vParaOrg muesste
     // noch geklaert werden 05-01-07
-    // ino.end
 
-    // ino.attribute.NO_LINENUMBER.21262.declaration 
     public static final int NO_LINENUMBER = -1;
-    // ino.end
-    
-    // ino.attribute.codegenlog.21265.decldescription type=line
-    // Logger
-    // ino.end
-    // ino.attribute.codegenlog.21265.declaration 
-    //protected static Logger codegenlog = Logger.getLogger("codegen");
-    // ino.end
-    // ino.attribute.inferencelog.21268.declaration 
+
     protected static Logger inferencelog = Logger.getLogger(MyCompiler.class.getName());
-    // ino.end
-    // ino.attribute.parserlog.21271.declaration 
-    //protected static Logger parserlog = Logger.getLogger("parser");
-    // ino.end
-    
-    // ino.attribute.OutputDir.21274.declaration 
+
     protected String OutputDir = "";
-    // ino.end
     
+    public Menge<Pair> testPair = null;
     
-    // ino.attribute.m_AbstractSyntaxTree.21280.decldescription type=javadoc
-    /**
-     * Der abstrake Syntaxbaum
-     * <br/>Autor: J�rg B�uerle
-     */
-    // ino.end
-    // ino.attribute.m_AbstractSyntaxTree.21280.declaration 
-    private Menge<SourceFile> m_AbstractSyntaxTree = new Menge<SourceFile>();
-    // ino.end
-    
-    // ino.method.MyCompiler.21283.defdescription type=javadoc
     /**
      * Author: J�rg B�uerle<br/>
      * Der private Konstruktor. Es soll von au�en kein Compiler angelegt werden
      * k�nnen, sondern nur eine API zur Verf�gung gestellt werden.
      * @param logger Konfiguration für Debug Ausgabe TODO
      */
-    // ino.end
-    // ino.method.MyCompiler.21283.definition 
-    private MyCompiler()
-    // ino.end
-    // ino.method.MyCompiler.21283.body 
-    {
+    private MyCompiler(){
         this.init();
     }
-    // ino.end
-    
-    // ino.method.getAPI.21286.defdescription type=javadoc
+
     /**
      * Author: Jörg Bäuerle<br/>
      * Stellt eine neue Instanz der CompilerAPI zur Verf�gung.
@@ -116,116 +75,11 @@ public class MyCompiler implements MyCompilerAPI
      * um eine Quellcode-Datei zu kompilieren.
      * @return Die Compiler-API
      */
-    // ino.end
-    // ino.method.getAPI.21286.definition 
-    public static MyCompilerAPI getAPI(LoggerConfiguration loggerConfig)
-    // ino.end
-    // ino.method.getAPI.21286.body 
-    {
+    public static MyCompilerAPI getAPI(LoggerConfiguration loggerConfig){
     	Logger.setStandardConfiguration(loggerConfig);
         return new MyCompiler();
     }
-    // ino.end
     
-    public Menge<Pair> testPair = null;
-    
-    // ino.method.wandleGeneric2RefType.21289.defdescription type=javadoc
-    /**
-     * Author: Thomas Ott<br/>
-     * Ersetzt in der Superklassenparameterliste einer Klasse, diejenigen
-     * <code>GenericTypeVars</code>, zu denen es eine Klasse gibt, die gleich hei�t.
-     * Beim Parsen werden n�mlich vom Jay nur GenericTypeVars erzeugt und keine
-     * RefTypes. Dies wird durch diese Methode nachgeholt.<br/>
-     * Bsp.: class JoergsTolleKlasse<A> extends MartinsSuperklasse<Integer, B>
-     * <br/>Wie man an diesem Beispiel sieht, kann nur eine Superklasse instantiierte
-     * Typvariablen zwischen den eckigen Klammern stehen haben, nicht jedoch die       
-     * abgeleitete Klasse.
-     * 
-     * @param className Klassenname der aktuell betrachteten Klasse
-     * @param Parameter Parameter der Superklasse
-     * @param KlassenVektor
-     
-    // ino.end
-    // ino.method.wandleGeneric2RefType.21289.definition 
-    public static void wandleGeneric2RefType(Menge<Type> Parameter, Menge<Class> KlassenVektor )
-    // ino.end
-    // ino.method.wandleGeneric2RefType.21289.body 
-    {
-        //wandleGeneric2RefType SOLLTE NICHT NUR FUER LISTEN
-        //VON TYPEN FUNKTIONIEREN PL 05-01-19
-        // otth: GenericTypeVar in Superklassenparameterlisten in RefTypes mit Parameterlsite = NULL umwandeln,
-        //       falls: f�r GenericTypeVar existiert eine gleichnamige Klasse
-	   	if(Parameter == null) return;
-    	
-            for( int i = 0; i < Parameter.size();  i++)
-            {
-                Type TempParameter = Parameter.elementAt(i);
-                inferencelog.debug("Nr. des Parameters: " + i);
-        
-                // an dieser Stelle: Parametername
-                if ( TempParameter instanceof GenericTypeVar)
-                {
-                    inferencelog.debug("Generic, WANDLE: " + TempParameter.getName());
-                    // existiert f�r GenericTypeVar eine deklarierte Klasse
-                    for( int k = 0; k < KlassenVektor.size();  k++)
-                    {
-                        if( KlassenVektor.elementAt(k).getSimpleName().equals(TempParameter.getSimpleName()) )
-                        {
-                            // Klasse existiert, darf aber keine Parameterliste in der Definition haben
-                            if( KlassenVektor.elementAt(k).get_ParaList().size() == 0 )
-                            {
-                                RefType RNeu = new RefType( TempParameter.getName().toString(), null,TempParameter.getOffset());
-                                inferencelog.debug( "Vorher: " + Parameter );
-                                // i-te Stelle ersetzen
-                                Parameter.set( i, RNeu );
-                                inferencelog.debug( "GenericTypeVar " + TempParameter.getName() + " umwandeln..." );                                
-                                inferencelog.debug( "Nachher: " + Parameter );
-                            }
-                            else
-                            {
-                                //parserlog.error( "SEMANTIK-CHECK-FEHLER: Parameter " + TempParameter.getName() + " muss weitere Parameter besitzen (laut Klassendefinition)" );
-                                //FIXME Throw exception instead of simple exit
-                                System.exit( 1 );
-                            }
-                        }
-                        else {
-                           inferencelog.debug("Ist echter Generic, wird nicht ersetzt!");
-                        }
-                    } // end for
-                }  // end if
-                else 
-                {
-                    inferencelog.debug("Nicht Generic, WANDLE nicht: " + TempParameter.getName());
-                    // RefType --> u.U. rekursiv weiterwandeln
-                    if(TempParameter instanceof RefType)
-                    {
-	                    RefType R = (RefType)TempParameter;
-	                    if( R.get_ParaList() != null )
-	                        wandleGeneric2RefType( R.get_ParaList(), KlassenVektor );
-                    }
-                    else if(TempParameter instanceof ITypeContainer)
-                    {
-                    	Type T = ((ITypeContainer)TempParameter).getContainedType();
-                    	if(T instanceof RefType)
-                    	{
-                    		RefType R = (RefType)T;
-     	                    if( R.get_ParaList() != null )
-     	                        wandleGeneric2RefType( R.get_ParaList(), KlassenVektor );
-                    	}
-                    }
-                    else
-                    { 
-                        inferencelog.error("Internal Error"); 
-                        System.exit( 1 ); 
-                    }
-                }
-            }    //end for
-    }    //end wandleGeneric2RefType
-    // ino.end
-    */
-    
-    
-    // ino.method.parse.21292.defdescription type=javadoc
     /**
      * Parst den Quellcode und baut den abstrakten Syntaxbaum auf. Danach wird
      * automatisch der von Thomas Ott implementierte Algorithmus                       
@@ -236,246 +90,19 @@ public class MyCompiler implements MyCompilerAPI
      * @throws IOException
      * @throws JavaParser.yyException
      */
-    // ino.end
-    // ino.method.parse.21292.definition 
-    private void parse_backup(Reader reader)
-    throws IOException, JavaParser.yyException
-    // ino.end
-    // ino.method.parse.21292.body 
-    {
-    	/*
-        parserlog.info("#########################################");
-        parserlog.info("# Parsen - START                        #");
-        parserlog.info("#########################################\n");
-    
-        //////////////////////////////////////
-        // Alte Daten l�schen:
-        //////////////////////////////////////
-        m_AbstractSyntaxTree = null;
-    
-        //////////////////////////////////////
-        // Scanner und Parser erzeugen:
-        //////////////////////////////////////
-        Scanner scanner = new Scanner(reader);
-        JavaParser parser = new JavaParser();
-        
-        //////////////////////////////////////
-        // Parsen ==> Ergebnis: srcFile = Abstrakter Syntaxbaum
-        //////////////////////////////////////
-        SourceFile  srcFile = (SourceFile) parser.yyparse( scanner );
-        this.testPair = parser.testPair;
-        
-        parserlog.info( "Parsen war erfolgreich!\n");
-    
-    //PL 05-07-31 verschoben nach SourceFile.java in Methode typeReconstruction
-        // otth: TypePlaceholders in Superklassenparameterlisten in RefTypes mit Parameterlsite = NULL umwandeln,
-        // falls: f�r TypePlaceholder existiert eine gleichnamige Klasse
-        // Superklasse suchen
-        //for( int i = 0; i < srcFile.KlassenVektor.size(); i++ )
-        //{
-    //Class tempKlasse = (Class)srcFile.KlassenVektor.elementAt( i );
-    
-        //PL 05-07-30 ausgetauscht um alle Typedeklarationen zu wandeln
-            // if( tempKlasse.superclassid != null && tempKlasse.get_ParaList() != null )
-        // {
-        //     // aktuelle Klasse hat Superklasse und Parameter
-        //     Menge Parameter = tempKlasse.superclassid.get_ParaList();
-        //     this.wandleGeneric2RefType(Parameter, srcFile.KlassenVektor );
-            // }
-        //wandleGeneric2RefType(tempKlasse.getContainedTypes(), srcFile.KlassenVektor );
-    
-        //}
-    
-        // otth: echte Konstruktoren von Methodendeklarationen ohne Typen unterscheiden
-        if ( srcFile != null )
-        {
-            Class     tempKlasse    = null;
-            ClassBody tempKlassBody = null;
-            Menge<mycompiler.myclass.Field>    tempMengeFieldDecl;
-            mycompiler.myclass.Field tempFieldDecl = null;
-            String    strKlasse;
-    
-            for( int i = 0; i < srcFile.KlassenVektor.size(); i++ )
-            {
-                
-                // Unterscheidung zwischen Class und Interfaces
-                if (srcFile.KlassenVektor.elementAt(i) instanceof Class) {
-                    tempKlasse = (Class)srcFile.KlassenVektor.elementAt( i );
-                    tempKlassBody = tempKlasse.get_ClassBody();
-                } else {
-                    tempKlasse = null;
-                    tempKlassBody = null;
-                }
-                    
-                if ( tempKlassBody != null )
-                {
-                    strKlasse = tempKlasse.getName();
-                    parserlog.debug("T->Felddeklarationen f�r die Klasse:" + strKlasse);
-                    parserlog.debug(  "------------------------------------");
-    
-                    // Schleife �ber alle fielddeclarations
-                    tempMengeFieldDecl = tempKlassBody.getFields();
-                    for( int k = 0; k < tempMengeFieldDecl.size(); k++ )
-                    {
-                    tempFieldDecl = tempMengeFieldDecl.elementAt(k);
-                    if( tempFieldDecl instanceof Constructor )
-                    {
-                        //parserlog.debug("T->Konstruktor: " + ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name() + " - ReturnType: " + tempFieldDecl.getTypeName());
-    
-                        // pr�fen, ob Construktorname == Klassenname - falls nein: Construktor in Methode umwandeln !!!
-                        String strConstName = ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name(); // Konstruktorname
-                        if ( !strConstName.equals( strKlasse ) )
-                        {
-                        // Element k durch neues ersetzen!
-    
-                        Method Methode     = new Method();
-                        Method Konstruktor = (Constructor)tempFieldDecl;
-    
-                        // Elementweise vom Konstruktor in die Methode kopieren
-                        Methode.set_Block( Konstruktor.get_Block() );
-                        Methode.setParameterList( Konstruktor.getParameterList() );
-                        Methode.set_ExceptionList( Konstruktor.get_ExceptionList() );
-                        Methode.setReturnType( Konstruktor.getReturnType() );
-                        Methode.setDeclIdMenge( Konstruktor.getDeclIdMenge() );
-                        // types_in_parameterlist wird wohl erst sp�ter und intern gef�llt
-    
-                        // R�ckgabetyp = Objekt der Klasse 'TypePlaceholder'
-    
-                        // #JB# 31.03.2005
-                        // ###########################################################
-                        Methode.setReturnType(TypePlaceholder.fresh(Methode));
-                        //Methode.setReturnType( new TypePlaceholder("###NEU###") );
-                        // ###########################################################
-    
-                        // Element an der Position k durch neues ersetzen!
-                        tempMengeFieldDecl.setElementAt( Methode, k );
-                        }
-                    }
-                    if( tempFieldDecl instanceof Method && !(tempFieldDecl instanceof Constructor) )
-                    {
-                        //parserlog.debug("T->Methode:     " + ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name() + " - ReturnType: " + tempFieldDecl.getTypeName());
-                    }
-                    
-                    }
-    
-                    // Debugg-Infos
-                    parserlog.debug("");
-                    parserlog.debug("T->NEUE Felddeklarationen f�r die Klasse:" + strKlasse);
-                    parserlog.debug(  "-----------------------------------------");
-                    for( int k = 0; k < tempMengeFieldDecl.size(); k++ )
-                    {
-                       tempFieldDecl = tempMengeFieldDecl.elementAt(k);
-                       //parserlog.debug("T->" + ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name() + " - Typ: " + tempFieldDecl + " - ReturnType: " + tempFieldDecl.getTypeName());
-                    }
-    
-                    // otth: TypePlaceholders durchnummerieren mit A, B, ...
-                    parserlog.debug("");
-                    parserlog.debug("");
-                    parserlog.debug("Suche TypePlaceholders in den FieldDecls:");
-                    parserlog.debug(    "------------------------------------------");
-    
-                    ParameterList   tempParameterList;
-                    Menge<FormalParameter>          tempVFktPara;
-                    FormalParameter tempFP;
-                    Method          tempMethod;
-                    Type            tempReturn;
-                    Type            tempType;
-                    for( int k = 0; k < tempMengeFieldDecl.size(); k++ )
-                    {
-                        tempFieldDecl = tempMengeFieldDecl.elementAt(k);
-                        tempMethod    = null;
-    
-                        if( tempFieldDecl instanceof Method )
-                        {
-                            tempMethod = (Method)tempFieldDecl;
-                            tempReturn = tempMethod.getReturnType();
-    
-                            // Funktionen ohne definierten R�ckgabetyp suchen!!!
-                            if( tempReturn instanceof TypePlaceholder )
-                            {
-                                // Methode mit nicht-definiertem R�ckgabetyp gefunden!
-    
-                                // #JB# 31.03.2005
-                                // ###########################################################
-                                // Wird bereits �ber fresh() gemacht!!
-                                //tempReturn.setName( TypePlaceholder.makeNewName() );
-                                // ###########################################################
-                                parserlog.debug("");
-                                parserlog.debug("Methode ohne Rueckgabetyp: " + tempMethod.get_Method_Name() + " --> " + tempReturn.getName());
-                            }
-                            else
-                            {
-                                parserlog.debug("");
-                                parserlog.debug("Methode mit Rueckgabetyp / Konstruktor:  " + tempMethod.get_Method_Name());
-                            }
-    
-                            // Methoden-Funktionsparameter durchsuchen
-                            tempParameterList = tempMethod.getParameterList();
-                            if ( tempParameterList != null )
-                            {
-                                tempVFktPara = tempParameterList.sc_get_Formalparalist();
-                                for( int l = 0; l < tempVFktPara.size(); l++ )
-                                {
-                                    tempFP   = tempVFktPara.elementAt(l);
-                                    tempType = tempFP.getType();
-                                    if( tempType instanceof TypePlaceholder )
-                                    {
-                                        if( tempType != null )
-                                        {
-                                            // neuer Name berechnen
-    
-                                            // #JB# 31.03.2005
-                                            // ###########################################################
-                                            // Wird bereits �ber fresh() gemacht!!
-                                            //tempType.setName( TypePlaceholder.makeNewName() );
-                                            // ###########################################################
-                                        }
-                                    }
-                                    parserlog.debug("");
-                                    parserlog.debug("    Parameter: " + tempFP.get_Name() + " --> " + tempType.getName());
-                                }
-                            }
-                            else
-                            {
-                                parserlog.debug("");
-                                parserlog.debug("    Methode hat keine Parameter!");
-                            }
-                        }
-                    }
-                }    //end if
-            }    //end for
-        }    //end if
-        m_AbstractSyntaxTree = srcFile;
-    
-        parserlog.info("#########################################");
-        parserlog.info("# Parsen - ENDE                         #");
-        parserlog.info("#########################################\n");
-        */
-    }   // end Methode parse()
-    // ino.end
-    
+    private void parse_backup(Reader reader) throws IOException, JavaParser.yyException{
+    	
+    }
 /////////////////////////////////////////////////////////////////////////////////////////////////   
 //   Implementierte API-Methoden:
 /////////////////////////////////////////////////////////////////////////////////////////////////
-    // ino.method.init.21295.defdescription type=javadoc
     /**
      * Author: J�rg B�uerle<br/>
      * Initialisiert den Compiler
      */
-    // ino.end
-    // ino.method.init.21295.definition 
-    public void init()
-    // ino.end
-    // ino.method.init.21295.body 
-    {
+    public void init(){
         TypePlaceholder.deleteRegistry();  
-        
-        // Log4J fuer die Ausgabe vorbereiten
-        //DOMConfigurator.configure("log4j.xml");
     }
-    // ino.end
-
-    // ino.method.parse.21298.defdescription type=javadoc
     /**
      * Author: J�rg B�uerle<br/>
      * Ruft die Parse-Methode.
@@ -484,22 +111,13 @@ public class MyCompiler implements MyCompilerAPI
      * @throws IOException Wenn was schief l�uft.
      * @throws JavaParser.yyException Wenn ein Fehler beim Parsen auftritt.
      */
-    // ino.end
-    // ino.method.parse.21298.definition 
-    public SourceFile parse(File file)
-    throws FileNotFoundException, IOException, JavaParser.yyException
-    // ino.end
-    // ino.method.parse.21298.body 
-    {
+    public SourceFile parse(File file) throws FileNotFoundException, IOException, JavaParser.yyException{
         FileReader fr = new FileReader(file);
         SourceFile ret = this.parse2SyntaxTree(fr);
-        this.m_AbstractSyntaxTree.add(ret);
         fr.close();
         return ret;
     }
-    // ino.end
-   
-    // ino.method.typeReconstruction.21304.defdescription type=javadoc
+
     /**
      * Author: J�rg B�uerle<br/>
      * Ruft den Typrekonstruktionsalgorithmus auf.
@@ -508,16 +126,7 @@ public class MyCompiler implements MyCompilerAPI
      * ist. @throws CTypeReconstructionException Wenn ein Fehler bei der               
      * Typrekonstruktion auftritt. 
      */
-    // ino.end
-    // ino.method.typeReconstruction.21304.definition 
-    public Menge<TypeinferenceResultSet> typeReconstruction()
-    throws NullPointerException, CTypeReconstructionException
-    // ino.end
-    // ino.method.typeReconstruction.21304.body 
-    {
-        if(m_AbstractSyntaxTree==null){
-            throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!");
-        }
+    public Menge<TypeinferenceResultSet> typeReconstruction(Menge<SourceFile> m_AbstractSyntaxTree) throws NullPointerException, CTypeReconstructionException{
         inferencelog.info("##########################################", Section.TYPEINFERENCE);
         inferencelog.info("# TypeReconstruction-Algorithmus - START #", Section.TYPEINFERENCE);
         inferencelog.info("##########################################\n", Section.TYPEINFERENCE);
@@ -535,7 +144,6 @@ public class MyCompiler implements MyCompilerAPI
         
         return result;
     }
-    // ino.end
 
     /**
      * Erstellt die FunN-Assumptions
@@ -559,45 +167,13 @@ public class MyCompiler implements MyCompilerAPI
 		
 		return ret;
 	}
-    
-    /**
-     * Author: J�rg B�uerle<br/>
-     * Generiert den Bytecode und das Class-File f�r den Syntaxbaum.
-     * @throws NullPointerException Wenn noch kein abstrakter Syntaxbaum vorhanden     
-     * ist. 
-     
-    @Override
-    public Menge<ClassFile> codeGeneration(ResultSet result)
-    throws NullPointerException, JVMCodeException
-    {
-        if(m_AbstractSyntaxTree==null){
-            throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!");
-        }
-        codegenlog.info("Beginn der Codegenerierung ...");
-    
-        Menge<ClassFile> ret = new Menge<ClassFile>();
-        
-        for(SourceFile sf : m_AbstractSyntaxTree){
-        	ret.addAll(sf.codegen(result));
-        }
-    
-        codegenlog.info("Codegenerierung beendet!");
-		return ret;
-    }*/
-	
 
-    // ino.method.main.21313.defdescription type=javadoc
     /**
      * Die Main-Funktion, �ber die der Compiler auch per Konsole gestartet
      * werden kann.
      * @param args Klassendatei
      */
-    // ino.end
-    // ino.method.main.21313.definition 
-    public static void main(String[] args)
-    // ino.end
-    // ino.method.main.21313.body 
-    {
+    public static void main(String[] args){
         MyCompilerAPI compiler = MyCompiler.getAPI(new LoggerConfiguration());
         
         // Hier koennten ggf. Aenderungen der Ausgabeeinstellungen
@@ -617,33 +193,9 @@ public class MyCompiler implements MyCompilerAPI
             System.err.println(e);
             System.exit(0);
         }
-    
-            /////////////////////////
-            // Semantik-Check:
-            /////////////////////////
-    //          try {
-    //                compiler.semanticCheck();
-    //            } catch (NullPointerException e) {
-    //                System.out.println("Fehler beim Aufrufen des Semantik-Checks:");
-    //                System.out.println(e);
-    //              System.exit(0);
-    //            } catch (SCException e) {
-    //                e.fehlerausgabe();
-    //              System.exit(0);
-    //            }
-    
-            /////////////////////////
-            // Code-Generierung:
-            /////////////////////////
-            //compiler.codeGeneration();
-        }
-    // ino.end
+    }
 
-    // ino.method.setOutputDir.21316.definition 
-    public void setOutputDir(String dir)
-    // ino.end
-    // ino.method.setOutputDir.21316.body 
-    {
+    public void setOutputDir(String dir){
         char c = dir.charAt(dir.length()-1);
         if (c != '/' & c != '\\') dir = dir + "/";
         OutputDir = dir;
@@ -652,75 +204,11 @@ public class MyCompiler implements MyCompilerAPI
         File f = new File(dir);
         f.mkdirs();
     }
-    // ino.end
 
-    // ino.method.getOutputDir.21319.definition 
-    public String getOutputDir()
-    // ino.end
-    // ino.method.getOutputDir.21319.body 
-    {
+    public String getOutputDir(){
         return OutputDir;
     }
-    // ino.end
-/*
-    // ino.method.getFullyQualifiedNameFromClassname.21322.definition 
-    public static String getFullyQualifiedNameFromClassname(String typ, ImportDeclarations declarations)
-    // ino.end
-    // ino.method.getFullyQualifiedNameFromClassname.21322.body 
-    {
-        String ret=null;
-        // Es ist kein FullyQualifiedName => In den Imports die Klasse suchen
-        for(int j=0;j<declarations.size();j++){
-            UsedId impDecl=declarations.elementAt(j);
-            if(impDecl.getSimpleName().equals(typ)){
-                ret=(impDecl.getQualifiedName().toString());
-                break;                          
-            }
     
-        }       
-        return ret;
-    }
-    // ino.end
-    */
-    // ino.method.makeRefTypesFullyQualified.21325.defdescription type=javadoc
-    /**
-     * @author HOTI
-     * Macht alle Referenzen auf Objekte zu fully qualified Names
-     * p.ex Menge x;   => de.dhbwstuttgart.typeinference.Menge x;
-     * @param containedTypes    Alle Typen, die die Klasse beinhaltet
-     * @param name  Alle Klassen, die es in den BasicAssumptions und im                
-     * AbstractSyntaxTree gibt @param declarations Alle Import-Declarations
-     
-    // ino.end
-    // ino.method.makeRefTypesFullyQualified.21325.definition 
-    public static void makeRefTypesFullyQualified(Menge<Type> containedTypes, ImportDeclarations declarations)
-    // ino.end
-    // ino.method.makeRefTypesFullyQualified.21325.body 
-    {
-        // HOTI 8.5.06 Anhand der ContainedTypes alle Variablen aendern
-        for( int i = 0; i < containedTypes.size();  i++)
-        {
-            Type tempParameter = (Type)(containedTypes.elementAt(i));
-            // Nat�rlich nur RefTypes updaten
-            if(tempParameter instanceof RefType){
-                RefType typ=(RefType)tempParameter;
-                UsedId fullyQualifiedName=UsedId.createFromQualifiedName(typ.getTypeName(),typ.getOffset());
-                // Kein FullyQualifiedName
-                if(fullyQualifiedName.name.size()==1){
-                    String newType=getFullyQualifiedNameFromClassname(typ.getSimpleName(),declarations); 
-                    if(newType!=null){
-                        typ.setName(newType);
-                    }
-    
-                }
-                if(typ.get_ParaList()!=null){
-                    makeRefTypesFullyQualified(typ.get_ParaList(),declarations);
-                }
-            }
-        }
-    }
-    // ino.end
-    */
     /**
      * @author Arne Lüdtke
      * Ersetzt alle GTVs durch TPHs mit gleichem Namen. Arbeitet Rekursiv.
@@ -790,8 +278,10 @@ public class MyCompiler implements MyCompilerAPI
     
     /**
      * Diese Funktion nimmt einen Menge von Dateinamen. Alle diese Dateien werden zu einem SyntaxBaum geparst.
+     * @return 
      */
-    public void parse(Menge<String> filenames) throws ParserError {
+    public Menge<SourceFile> parse(Menge<String> filenames) throws ParserError {
+    	Menge<SourceFile> m_AbstractSyntaxTree = new Menge<SourceFile>();
 		
 		for(String filename : filenames){
 				StringBuffer fileData = new StringBuffer();
@@ -816,58 +306,25 @@ public class MyCompiler implements MyCompilerAPI
 
 		        StringReader srcreader = new StringReader(fileData.toString());
 		        //Den aus der Datei ausgelesenen Quellcode zu einem Syntaxbaum parsen:
-		        this.m_AbstractSyntaxTree.add(parse2SyntaxTree(srcreader)); // Alle Dateien nacheinander hintereinander anhängen...
-				
-		}
-		/*
-		String gesamterSrc = "";
-		//Hier werden alle übergebenen Dateinamen abgearbeitet:
-		for(String filename : filenames){
-			try {
-			StringBuffer fileData = new StringBuffer();
-	        BufferedReader reader = new BufferedReader(
-	                new FileReader(filename));
-	        char[] buf = new char[1024];
-	        int numRead=0;
-	        while((numRead=reader.read(buf)) != -1){
-	            String readData = String.valueOf(buf, 0, numRead);
-	            fileData.append(readData);
-	        }
-	        reader.close();
-	        gesamterSrc += fileData.toString() + "\n"; // Alle Dateien nacheinander hintereinander anhängen...
-			} catch (Exception e) {
-				e.printStackTrace();
-				throw new TypinferenzException("Die übergebenen Dateien konnten nicht zum Parsen eingelesen werden.");
-			}
+		        m_AbstractSyntaxTree.add(parse2SyntaxTree(srcreader)); // Alle Dateien nacheinander hintereinander anhängen...
 		}
 		
-		try {
-			// und anschließend zum Parsen übergeben.
-			this.parse(gesamterSrc.toString());
-		} catch (Exception e) {
-			e.printStackTrace();
-			//throw new TypinferenzException("Fehler beim Parsen");
-		}
-		
-	*/
+		return m_AbstractSyntaxTree;
 	}
 
 	@Override
 	public SourceFile parse(String sourceCode) {
-		SourceFile ret = this.parse2SyntaxTree(new StringReader(sourceCode));
-		this.m_AbstractSyntaxTree.add(ret);
-		return ret;
+		return parse2SyntaxTree(new StringReader(sourceCode));
 	}
 
 	@Override
-	public Menge<Menge<ByteCodeResult>> generateBytecode(TypeinferenceResultSet typeinferenceResult) {
+	public Menge<ByteCodeResult> generateBytecode(Menge<SourceFile> m_AbstractSyntaxTree, TypeinferenceResults typeinferenceResults) {
 		//SourceFile parsedFile = this.m_AbstractSyntaxTree.firstElement();
 		//Class parsedClass = parsedFile.KlassenVektor.firstElement();
-		Menge<Menge<ByteCodeResult>> ret = new Menge<>();
-		for(SourceFile sf : this.m_AbstractSyntaxTree){
-			ret.addAll(sf.generateBytecode(typeinferenceResult));
+		Menge<ByteCodeResult> ret = new Menge<>();
+		for(SourceFile sf : m_AbstractSyntaxTree){
+			ret.addAll(sf.generateBytecode(typeinferenceResults));
 		}
 		return ret;
 	}
 }
-// ino.end

src/de/dhbwstuttgart/core/MyCompilerAPI.java

@@ -15,6 +15,7 @@ import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.ByteCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
 import de.dhbwstuttgart.typeinference.exceptions.ParserError;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 
@@ -85,8 +86,7 @@ public interface MyCompilerAPI
      */
     // ino.end
     // ino.method.typeReconstruction.21340.declaration 
-    public Menge<TypeinferenceResultSet> typeReconstruction()
-    throws NullPointerException, TypeinferenceException;
+    public Menge<TypeinferenceResultSet> typeReconstruction(Menge<SourceFile> m_AbstractSyntaxTree) throws NullPointerException, CTypeReconstructionException;
     // ino.end
 
     // ino.method.setOutputDir.21349.decldescription type=javadoc
@@ -112,8 +112,9 @@ public interface MyCompilerAPI
     /**
      * Parst zusammenhängende JavaKlassen in verschiedenen Dateien.
      * @param filenames - Eine Liste von Quellcodedateien, welche gseparst werden sollen
+     * @return 
      */
-	public void parse(Menge<String> filenames) throws ParserError;
+	public Menge<SourceFile> parse(Menge<String> filenames) throws ParserError;
     
 	/**
 	 * Parst den SourceCode einer Datei.
@@ -127,6 +128,6 @@ public interface MyCompilerAPI
 	 * Dafür müssen die Schritte Parsen und typeReconstruction ausgeführt werden.
 	 * @return
 	 */
-	public Menge<Menge<ByteCodeResult>> generateBytecode(TypeinferenceResultSet rs);
+	public Menge<ByteCodeResult> generateBytecode(Menge<SourceFile> m_AbstractSyntaxTree, TypeinferenceResults typeinferenceResults);
 }
 // ino.end

src/de/dhbwstuttgart/parser/JavaClassName.java

@@ -18,6 +18,7 @@ public class JavaClassName {
 	
 	public JavaClassName(String name){
 		if(name == null)throw new NullPointerException();
+		
 		String[] names = name.split("[.]");
 		boolean match = true;
 		if(names.length == 1){

src/de/dhbwstuttgart/syntaxtree/Class.java

@@ -8,6 +8,8 @@ import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
 
+import javax.lang.model.element.Modifier;
+
 import  org.apache.commons.bcel6.generic.ClassGen;
 import  org.apache.commons.bcel6.generic.ConstantPoolGen;
 import  org.apache.commons.bcel6.generic.InstructionFactory;
@@ -24,8 +26,10 @@ import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
 import de.dhbwstuttgart.core.AClassOrInterface;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.parser.JavaClassName;
+import de.dhbwstuttgart.syntaxtree.misc.DeclId;
 import de.dhbwstuttgart.syntaxtree.misc.UsedId;
 import de.dhbwstuttgart.syntaxtree.modifier.Modifiers;
+import de.dhbwstuttgart.syntaxtree.modifier.Static;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
@@ -74,7 +78,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
      * @param resultSet - Fehlende Typen im Syntaxbaum werden nach diesem ResultSet aufgelöst
      * @return
      */
-    public Menge<ByteCodeResult> genByteCode(TypeinferenceResultSet resultSet) {
+    public ByteCodeResult genByteCode(TypeinferenceResults typeinferenceResults) {
     	InstructionFactory _factory;
         DHBWConstantPoolGen    _cp;
         ClassGenerator     _cg;
@@ -85,7 +89,8 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     	logger.debug("Test");
     	
     	if(pkgName != null)throw new NotImplementedException();
-    	_cg = new ClassGenerator(name, this.getSuperClass(), name + ".java", Constants.ACC_PUBLIC , new String[] {  }, resultSet); //letzter Parameter sind implementierte Interfaces
+    	short constants = Constants.ACC_PUBLIC; //Per Definition ist jede Methode public
+    	_cg = new ClassGenerator(name, this.getSuperClass(), name + ".java", constants , new String[] {  }, typeinferenceResults); //letzter Parameter sind implementierte Interfaces
         _cp = _cg.getConstantPool();
         _factory = new DHBWInstructionFactory(_cg, _cp);
 
@@ -112,12 +117,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     		c.genByteCode(_cg, fieldInitializations);
     	}
     	
-	    ByteCodeResult code = new ByteCodeResult(_cg);
-	    results.add(code);
-	    
-	    results.addAll(getGenericClasses(_cg));
-	    
-        return results;
+	    return new ByteCodeResult(_cg);
     }
 
 	private Menge<Type> superif = new Menge<Type>();
@@ -227,8 +227,8 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
             superclassid=null;
         }
         this.offset = offset;
-        if(!name.equals("Object"))//Alle Klassen außer Object erben von Object:
-        	this.superClass = new Class("Object", -1).getType(); 
+        if(!name.equals("Object") && !name.equals("java.lang.Object"))//Alle Klassen außer Object erben von Object:
+        	this.superClass = new Class("java.lang.Object", -1).getType(); 
     }
     // ino.end
     
@@ -240,21 +240,30 @@ 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, RefType superClass, Modifiers modifiers,
-    		Menge<String> supertypeGenPara) {
+    public Class(String name, Type superClass, Modifiers modifiers, Menge supertypeGenPara) {
 		this(name,superClass,modifiers,0);
 		if(supertypeGenPara == null)return;
 		Menge<GenericTypeVar> gtvs = new Menge<>();
-		for(String gname : supertypeGenPara){
-			GenericTypeVar newGTV=new GenericTypeVar(gname,this,0);
-			gtvs.add(newGTV);
+		for(Object gname : supertypeGenPara){
+			if(gname instanceof String){
+				GenericTypeVar newGTV=new GenericTypeVar((String)gname,this,0);
+				gtvs.add(newGTV);
+			}else if(gname instanceof GenericTypeVar){
+				gtvs.add((GenericTypeVar) gname);
+			}else{
+				GenericTypeVar newGTV=new GenericTypeVar(gname.toString(),this,0);
+				gtvs.add(newGTV);
+				
+				throw new RuntimeException(gname.toString());
+			}
+
 		}
 		this.setGenericParameter(new GenericDeclarationList(gtvs,0));
 	}
     
-    public Class(String name, RefType superClass, Modifiers mod, int offset){
+    public Class(String name, Type superClass, Modifiers mod, int offset){
     	this(name,mod,offset);
-    	if(superClass == null)this.superClass = new Class("Object",-1).getType();
+    	if(superClass == null)this.superClass = new Class("java.lang.Object",-1).getType();
     	else this.superClass = superClass;
     }
     
@@ -1031,21 +1040,66 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
 		return false;
 	}
 	
-    private Collection<? extends ByteCodeResult> getGenericClasses(ClassGenerator _cg) {
+	/*
+    private Collection<? extends ByteCodeResult> getGenericClasses() {    	
 		Collection<ByteCodeResult> results = new Menge<>();
 		
-		//Super Klasse
-		String name = "java/util/Vectorjava/lang/String";	//getParentClass().getType().getBytecodeSignature(_cg);
-		
-		Type superClass = new Class("java/util/Vector",-1).getType();
-		
-		_cg = new ClassGenerator(name, superClass, name + ".java", Constants.ACC_PUBLIC , new String[] {  }, new TypeinferenceResultSet(null, null, null));
-    	
-	    ByteCodeResult code = new ByteCodeResult(_cg);
-	    
-	    results.add(code);
+		for(Field field : this.fielddecl){
+			Type type = field.getType();
+			//Der Type des Feldes
+			if(type instanceof RefType){
+				RefType refType = (RefType) type;
+				
+				if(!refType.getCombinedType(null).equals(refType.get_Name().replace(".", "%"))){
+					results.addAll(generateGenericClass(refType.getCombinedType(null), new Class("java/util/Vector",-1)));
+				}
+			}
+			
+			if(field instanceof Method){
+				Method method = (Method) field;
+				ParameterList parameterList = method.getParameterList();
+				
+				//Die Typen der Methodenparameter
+				for(FormalParameter parameter: parameterList){
+					Type parameterType = parameter.getType();
+					
+					if(parameterType instanceof RefType){
+						RefType refType = (RefType) parameterType;
+						
+						if(!refType.getCombinedType(null).equals(refType.get_Name().replace(".", "%"))){
+							results.addAll(generateGenericClass(refType.getCombinedType(null), new Class("java/util/Vector",-1)));
+						}
+					}
+				}
+			}
+		}
 	    
 		return results;
 	}
+	*/
+    
+    /*
+    private Menge<ByteCodeResult> generateGenericClass(String name, Class superClass){
+    	//TODO: bytecode -- Generics hinzuf<75>gen
+		//Type superClassType = superClass.getType();
+		
+		//TODO: bytecode
+		//ClassGenerator genericClassGenerator = new ClassGenerator(name, superClassType, name + ".java", Constants.ACC_PUBLIC , new String[] {  }, new TypeinferenceResultSet(null, null, null));
+    	
+    	//TODO: bytecode -- Namen der neuen Klasse
+		Class generatedClass = new Class(name, 0);
+		
+		//TODO: bytecode -- alle Konstruktoren generieren
+		Block konstruktorBlock = new Block();
+		konstruktorBlock.setType(new de.dhbwstuttgart.syntaxtree.type.Void(konstruktorBlock, 0));
+		konstruktorBlock.statements.add(new SuperCall(konstruktorBlock));
+		Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(konstruktorBlock, name, superClass), superClass);
+		standardKonstruktor.parserPostProcessing(generatedClass);
+		
+		generatedClass.addField(standardKonstruktor);
+		
+		return generatedClass.genByteCode(new TypeinferenceResultSet(generatedClass, new Menge<>(), new ResultSet()));
+    }
+    */
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/FormalParameter.java

@@ -236,7 +236,7 @@ public class FormalParameter extends SyntaxTreeNode implements Typeable, TypeIns
 	public String getDescription() {
 		String ret = "";
 		if(this.getType() != null && !(this.getType() instanceof TypePlaceholder)){
-			ret += this.getType().getName() + " ";
+			ret += this.getType().getBytecodeSignature(null);
 		}
 		return ret+this.getIdentifier();
 	}

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -30,6 +30,7 @@ import de.dhbwstuttgart.myexception.SCStatementException;
 import de.dhbwstuttgart.parser.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.misc.DeclId;
 import de.dhbwstuttgart.syntaxtree.modifier.Modifiers;
+import de.dhbwstuttgart.syntaxtree.modifier.Static;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Return;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
@@ -99,6 +100,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	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
@@ -226,7 +228,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.method.set_Modifiers.23545.body
 	{
 		declid.firstElement().set_Modifiers(modif);
-		// this.modi = modif;
+		this.modifiers = modif;
 	}
 
 	// ino.end
@@ -421,8 +423,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.end
 	// ino.method.toString.23605.body
 	{
-		return this.getType() + " " + this.get_Name()
-				+ ((block != null) ? block.toString() : "");
+		return this.getType() + " " + this.get_Name() + ((block != null) ? block.toString() : "");
 	}
 
 	// ino.end
@@ -744,32 +745,39 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	}
 
 	public void genByteCode(ClassGenerator cg) {
-		DHBWConstantPoolGen _cp = cg.getConstantPool();
-		DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, _cp);
-		InstructionList il = new InstructionList();
-		Class parentClass = this.getParentClass();
-	
-		//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){
-				argumentTypes[i] = parameter.getType().getBytecodeType(cg);
-				argumentNames[i] = parameter.getIdentifier();
-				i++;
+		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();
+		
+			//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()));
 		}
-		
-		//Methode generieren:
-		MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, 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()));
-		
 	}
 
 }

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -40,6 +40,7 @@ import de.dhbwstuttgart.typeinference.FunNMethod;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
 import de.dhbwstuttgart.typeinference.UndConstraint;
 import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
@@ -326,6 +327,7 @@ public class SourceFile
         for(ClassAssumption cAss : ass.getClassAssumptions()){
         	Type t1 = cAss.getAssumedClass().getType();
         	Type t2 = cAss.getAssumedClass().getSuperClass();
+        	if(t2 != null){
         	Pair p = new Pair(t1, t2);
         	//System.out.println("FCPair: "+p);
         	if(! t1.equals(t2)){//Um FC_TTO darf kein T <. T stehen.
@@ -337,6 +339,7 @@ public class SourceFile
         	}else{
         		//System.out.println("Wurde nicht aufgenommen");
         	}
+        	}
         }
         
         for( int i = 0; i < KlassenVektor.size(); i++ )
@@ -1834,10 +1837,10 @@ public class SourceFile
 	 * Bisher wird nur der Bytecode der Klassen generiert. Nicht der Interfaces.
 	 * @return
 	 */
-	public Menge<Menge<ByteCodeResult>> generateBytecode(TypeinferenceResultSet rs) {
-		Menge<Menge<ByteCodeResult>> ret = new Menge<>();
+	public Menge<ByteCodeResult> generateBytecode(TypeinferenceResults results) {
+		Menge<ByteCodeResult> ret = new Menge<>();
 		for(Class cl : this.KlassenVektor){
-			ret.add(cl.genByteCode(rs));
+			ret.add(cl.genByteCode(results));
 		}
 		return ret;
 	}

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

@@ -0,0 +1,74 @@
+package de.dhbwstuttgart.syntaxtree.factory;
+
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.syntaxtree.Class;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+import de.dhbwstuttgart.syntaxtree.misc.DeclId;
+import de.dhbwstuttgart.syntaxtree.misc.UsedId;
+import de.dhbwstuttgart.syntaxtree.modifier.Modifiers;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+
+public class ASTFactory {	
+	public static Method createMethod(String name, ParameterList paralist, Block block, Class parent) {
+		
+		
+		Method method = new Method(0);
+		DeclId DImethod = new DeclId();
+		DImethod.set_Name(name);
+		method.set_DeclId(DImethod);
+		method.set_Block(block);
+		method.setParameterList(paralist);
+		
+		block.parserPostProcessing(method);
+		method.parserPostProcessing(parent);
+		return method;
+	}
+	
+	public static Method createEmptyMethod(String withSignature, Class parent) {
+		return  ASTFactory.createMethod(withSignature, new ParameterList(), new Block(), parent);
+	}
+	
+	public static Constructor createEmptyConstructor(Class parent){
+		Block block = new Block();
+		block.setType(new de.dhbwstuttgart.syntaxtree.type.Void(block, 0));
+		block.statements.add(new SuperCall(block));
+		
+		return ASTFactory.createConstructor(parent, new ParameterList(), block);
+	}
+	
+	public static Constructor createConstructor(Class superClass, ParameterList paralist, Block block){
+		block.parserPostProcessing(superClass);
+		
+		Method method = ASTFactory.createMethod("<init>", paralist, block, superClass);
+		method.setType(new de.dhbwstuttgart.syntaxtree.type.Void(block, 0));
+		
+		return new Constructor(method, superClass);
+	}
+
+	public static Class createClass(String className, Type 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);		
+		generatedClass.addField(ASTFactory.createEmptyConstructor(generatedClass));
+		
+		generatedClass.parserPostProcessing(parent);
+		
+		return generatedClass;
+	}
+
+	public static Class createObjectClass() {
+		Class generatedClass = new Class("java.lang.Object", 0);		
+		
+		return generatedClass;
+	}
+}

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

@@ -0,0 +1,39 @@
+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;
+
+public class UnifyPairMengenBuilder {
+	
+	private Menge<Pair> buildMenge = new Menge<Pair>();
+	
+	public void addPair(Type t1, Type t2) {
+		buildMenge.add(new Pair(t1, t2));
+	}
+	
+	public void addPair(Type t1, Type t2, PairOperator pairOp) {
+		buildMenge.add(new Pair(t1, t2, pairOp));
+	}
+	
+	public Menge<Pair> getPairMenge() {
+		return buildMenge;
+	}
+	
+	public Menge<Menge<Pair>> getNestedPairMenge() {
+		Menge<Menge<Pair>> nested = new Menge<>();
+		
+		for(Pair p : buildMenge) {
+			Menge<Pair> m = new Menge<Pair>();
+			m.add(p);
+			nested.add(m);
+		}
+		
+		return nested;
+	}
+	
+	public void clear() {
+		buildMenge = new Menge<Pair>();
+	}
+}

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

@@ -0,0 +1,43 @@
+package de.dhbwstuttgart.syntaxtree.factory;
+
+import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.WildcardType;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.ObjectType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.Pair;
+import de.dhbwstuttgart.typeinference.Pair.PairOperator;
+
+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);
+	}
+	
+	public ExtendsWildcardType GetExtendsType(ObjectType extendedType) {
+		return new ExtendsWildcardType(extendedType);
+	}
+	
+	public SuperWildcardType GetSuperType(ObjectType superedType) {
+		return new SuperWildcardType(superedType);
+	}
+	
+	public WildcardType GetWildcardType() {
+		return new WildcardType(null, null, 0);
+	}
+	
+	public TypePlaceholder GetTypePlaceholder(String name) {
+		return TypePlaceholder.backdoorCreate(name);
+	}
+}

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

@@ -0,0 +1,33 @@
+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;
+
+public class Unify_FC_TTO_Builder {
+	
+	private Menge<Pair> fc = new Menge<Pair>();
+	private Menge<Class> classes = new Menge<Class>();
+	
+	public void AddInheritance(Type t1, Type t2) {
+		if(t1 instanceof RefType)
+			classes.add(new Class(t1.get_Name(), t1.getOffset()));
+		
+		if(t2 instanceof RefType)
+			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/statement/ArgumentList.java

@@ -1,39 +1,26 @@
-// ino.module.ArgumentList.8621.package 
 package de.dhbwstuttgart.syntaxtree.statement;
-// ino.end
-// ino.module.ArgumentList.8621.import 
-import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import java.util.Iterator;
+
+import org.apache.commons.bcel6.generic.InstructionList;
+
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
 
-
-
-
-// ino.class.ArgumentList.24911.declaration 
 public class ArgumentList extends SyntaxTreeNode
-// ino.end
-// ino.class.ArgumentList.24911.body
 {
-    // ino.attribute.expr.24914.declaration 
     public Menge<Expr> expr = new Menge<Expr>();
-    // ino.end
     
     
-    // ino.method.get_firstElement.24923.definition 
     public Object get_firstElement()
-    // ino.end
-    // ino.method.get_firstElement.24923.body 
     {
         return expr.firstElement();
     }
-    // ino.end
-
-
 
     /**
      * @author Andreas Stadelmeier, a10023
@@ -93,6 +80,22 @@ public class ArgumentList extends SyntaxTreeNode
 	public Menge<? extends SyntaxTreeNode> getChildren() {
 		return expr;
 	}
-    
+	
+	public InstructionList generateBytecode(ClassGenerator cg){
+		InstructionList ret = new InstructionList();
+		for(Expr e : expr){
+			ret.append(e.genByteCode(cg));
+		}
+		return ret;
+	}
+	
+	public org.apache.commons.bcel6.generic.Type[] getBytecodeTypeList(ClassGenerator cg){
+		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);
+			i++;
+		}
+		return ret;
+	}
 }
-// ino.end

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

@@ -184,8 +184,8 @@ public class Assign extends Expr
 			InstructionFactory _factory = new InstructionFactory(cg, cg.getConstantPool());
 			InstructionList il = expr2.genByteCode(cg);//expr2 rechte expr
 			
-			//TODO: ^^
-			counterAssign++; //macht STORE f<>r meherere Variable nutzbar (nicht nur ISTORE_1, ISTORE_2, etc.)
+			
+			
 			
 			/*
 			String expr2Type = expr2.getType().get_Name().toString();
@@ -214,6 +214,9 @@ 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.)
+			
 			return il;
 	}
 

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

@@ -6,8 +6,13 @@ import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
 
+import org.apache.commons.bcel6.Constants;
 import  org.apache.commons.bcel6.generic.ClassGen;
+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;
@@ -55,6 +60,7 @@ public class NewClass extends Expr
 
     // ino.attribute.arglist.25837.declaration 
     private ArgumentList arglist;
+	private boolean isStatement = false;
     // ino.end
     // ino.attribute.parserlog.25840.declaration 
     protected static Logger parserlog = Logger.getLogger("parser");
@@ -129,15 +135,7 @@ public class NewClass extends Expr
 		//TODO: Das hier noch vervollständigen
 		ConstraintsSet ret = new ConstraintsSet();
 		UndConstraint callConstraints = new UndConstraint();
-		//Die Auskommentierten Zeilen gehören zu MethodRefNew
-		//Menge<Type> argumentTypeList = new Menge<Type>();
-		//for(Expr expr : this.arglist.expr){
-		//	argumentTypeList.add(expr.getTypeVariable());
-		//}
-		//FunN funN= new FunN(null,argumentTypeList);
 		
-		//Constraint newClassTypeConstraint = new Constraint(null,null);
-		//ret.add(newClassTypeConstraint);
 		int numArgs = 0;
 		if(this.arglist != null)numArgs = this.arglist.size();
 		ConstructorAssumption cA = assumptions.getConstructorAssumption(this.get_Name(), numArgs);
@@ -147,22 +145,9 @@ public class NewClass extends Expr
 			ret.add(this.arglist.expr.elementAt(i).TYPEExpr(assumptions));
 			callConstraints.addConstraint( this.arglist.expr.elementAt(i).getType().TYPE(assumptions, this), cA.getParameterType(i).TYPE(assumptions, this));
 		}
-		//if(this.arglist != null && this.arglist.expr != null)for(Expr arg : this.arglist.expr){
-		//	ret.add(arg.TYPEExpr(assumptions));	
-		//}
 		Type thisT = assumptions.checkType(new RefType(this.get_Name(),this,0), (SyntaxTreeNode)this);
 		this.setType(thisT);
 		
-		
-		/*
-		//Ein new-Aufruf ist nichts anderes als ein MethodCall der Methode <init>
-		MethodCall newAufruf = new MethodCall(0,0);
-		this.setType(assumptions.getTypeFor(new RefType(this.get_Name(),0)));
-		newAufruf.type = this.getType();
-		newAufruf.set_Name("<init>");
-		newAufruf.set_Receiver(null);
-		ret.add(new Overloading(assumptions, newAufruf, this.getType()).generateConsstraints());
-		*/
 		return ret;
 	}
 	
@@ -176,6 +161,7 @@ public class NewClass extends Expr
 	public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){
 		ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen
 		this.setType(new Void(this,0)); //Typ des Statments auf Void setzen.
+		this.isStatement = true;
 		return ret;
 	}
 
@@ -208,8 +194,21 @@ public class NewClass extends Expr
 
 	@Override
 	public InstructionList genByteCode(ClassGenerator _cg) {
-		// TODO Bytecode
-		throw new NotImplementedException();
+		InstructionList il = new InstructionList();
+		if(arglist!=null){
+			il.append(arglist.generateBytecode(_cg));
+			il.append(_cg.getInstructionFactory().createInvoke(this.get_Name(), "<init>", 
+					org.apache.commons.bcel6.generic.Type.VOID,
+						this.arglist.getBytecodeTypeList(_cg), Constants.INVOKESPECIAL));
+		}else{
+			il.append(_cg.getInstructionFactory().createInvoke(this.get_Name(), "<init>", 
+					org.apache.commons.bcel6.generic.Type.VOID,
+						new org.apache.commons.bcel6.generic.Type[]{}, Constants.INVOKESPECIAL));
+		}
+		if(this.isStatement){
+	    	il.append(InstructionConstants.POP);
+	    }
+	    return il;
 	}
 	
 	

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

@@ -0,0 +1,23 @@
+package de.dhbwstuttgart.syntaxtree.type;
+
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.parser.JavaClassName;
+import de.dhbwstuttgart.syntaxtree.Class;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+
+public class GenericClassType extends RefType{
+
+	public GenericClassType(String fullyQualifiedName, Menge parameter, SyntaxTreeNode parent, int offset) {
+		super(fullyQualifiedName, parameter, parent, offset);
+	}
+
+	@Override
+	public String getBytecodeSignature(ClassGenerator cg) {	
+		return "L"+getTypeName()+";";
+	}
+}

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

@@ -14,11 +14,19 @@ import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.myexception.SCException;
 import de.dhbwstuttgart.parser.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.Class;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.misc.UsedId;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
 import de.dhbwstuttgart.typeinference.JavaCodeResult;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import de.dhbwstuttgart.typeinference.TypeInsertable;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.unify.CSubstitutionGenVar;
@@ -602,12 +610,13 @@ public class RefType extends ObjectType implements IMatchable
             }
             RefType newRefType=new RefType(this.getTypeName(), clonepara,this.getParent(),getOffset());
             newRefType.setPrimitiveFlag(this.getPrimitiveFlag());
+            newRefType.IsArray = this.IsArray;
             return newRefType;
         }
         else {
             RefType newRefType = new RefType(this.getTypeName(), null,getOffset()); 
             newRefType.setPrimitiveFlag(this.getPrimitiveFlag());
-    
+            newRefType.IsArray = this.IsArray;
             return newRefType;
         }
     }
@@ -814,42 +823,56 @@ public class RefType extends ObjectType implements IMatchable
 	}
 	
 	public   org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
-		return new org.apache.commons.bcel6.generic.ObjectType(this.get_Name());
+		org.apache.commons.bcel6.generic.ObjectType ret = new org.apache.commons.bcel6.generic.ObjectType(getCombinedType(cg));
+		if(this.IsArray()){
+			//Hier wird einfachhalber von einer Dimension ausgegangen. Arrays sind im Bytecode nur für main-Methode relevant
+			return new org.apache.commons.bcel6.generic.ArrayType(ret, 1);
+		}else{
+			return ret;
+		}
 	}
 
 	@Override
 	public String getBytecodeSignature(ClassGenerator cg) {
-		/*
+		//TODO: bytecode woher bekommt ich die parent klasse
+		String combinedType = getCombinedType(cg);
+		if(!combinedType.equals(getName().toString())){
+			getSuperWildcardTypes();
+			Class generatedClass = ASTFactory.createClass(getCombinedType(cg), getGenericClassType(), null, get_ParaList(), new SourceFile());
+			
+			cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResults()).getByteCode());
+		}
+		String ret = new org.apache.commons.bcel6.generic.ObjectType(combinedType).getSignature();
+		return ret;
+	}
+	
+	public String getCombinedType(ClassGenerator cg){
 		//Bsp.: Ljava/util/Vector<Ljava/lang/String;>;
 		StringBuilder sb = new StringBuilder();
 		
-		sb.append(getTypeName());
-		
-		if(parameter != null){
+		if(parameter != null && parameter.size() > 0){
+			sb.append(getName().toString().replace(".", "%"));
+			sb.append("%%");
 			for(Type type: parameter){
-				sb.append(""); //TODO: einen geeignete Delemiter suchen
-				sb.append(type.getBytecodeSignature(cg));
+				if(type instanceof RefType){
+					sb.append(((RefType) type).getCombinedType(cg).replace(".", "%"));
+				}else if(type instanceof TypePlaceholder){
+					sb.append(((TypePlaceholder) type).getBytecodeType(cg).toString().replace(".", "%"));
+				}else{
+					sb.append(type.getBytecodeType(cg).toString().replace(".", "%"));
+				}
+				
+				sb.append("%");
 			}
+		}else{
+			sb.append(this.getName().toString());
 		}
 		
 		return sb.toString();
-		*/
-		
-		String paramString = "";
-		if(this.parameter != null && this.parameter.size()>0){
-			paramString+="<";
-			Iterator<Type> it = this.parameter.iterator();
-			while(it.hasNext()){
-				Type param = it.next();
-				paramString+=param.getBytecodeSignature(cg);
-				//if(it.hasNext())
-				//paramString+=";"; //kein Delimiter zwischen den Typen
-			}
-			paramString+=">";
-		}
-		String typeSignature = this.getBytecodeType(cg).getSignature();
-		typeSignature = typeSignature.substring(0, typeSignature.length()-1);
-		return typeSignature+paramString+";";
+	}
+	
+	public GenericClassType getGenericClassType(){
+		return new GenericClassType(getName().toString(), getParaList(), parent, getOffset());
 	}
 	
 }

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

@@ -437,7 +437,15 @@ public class TypePlaceholder extends ObjectType
 
 	@Override
 	public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
-		Type resolvedType = cg.resolveTPH(this);
+		Type resolvedType = cg.resolveTPH(this, 0);
+		if(resolvedType instanceof TypePlaceholder){
+			return DHBWInstructionFactory.createObjectType();
+		}
+		return resolvedType.getBytecodeType(cg);
+	}
+	
+	public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg, Integer typeReconstructionSetIndex) {
+		Type resolvedType = cg.resolveTPH(this, typeReconstructionSetIndex);
 		if(resolvedType instanceof TypePlaceholder){
 			return DHBWInstructionFactory.createObjectType();
 		}
@@ -446,7 +454,11 @@ public class TypePlaceholder extends ObjectType
 	
 	@Override
 	public String getBytecodeSignature(ClassGenerator cg) {
-		Type resolvedType = cg.resolveTPH(this);
+		return getBytecodeSignature(cg, 0);
+	}
+	
+	public String getBytecodeSignature(ClassGenerator cg, Integer typeReconstructionSetIndex) {
+		Type resolvedType = cg.resolveTPH(this, typeReconstructionSetIndex);
 		if(resolvedType instanceof TypePlaceholder){
 			cg.addUsedTPH((TypePlaceholder)resolvedType);
 			return new TypePlaceholderType((TypePlaceholder)resolvedType).getSignature();

src/de/dhbwstuttgart/typeinference/ByteCodeResult.java

@@ -2,23 +2,26 @@ package de.dhbwstuttgart.typeinference;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
 import  org.apache.commons.bcel6.generic.ClassGen;
 
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 public class ByteCodeResult{
 
-	private ClassGen byteCode;
+	private ClassGenerator byteCode;
 	//TODO: unresolvedTPHs entfernen. BROKEN!
 	private Menge<TypePlaceholder> unresolvedTPHs = new Menge<TypePlaceholder>();
 	
-	public ByteCodeResult(ClassGen byteCode){
+	public ByteCodeResult(ClassGenerator byteCode){
 		this.byteCode = byteCode;
 	}
 	
-	public ClassGen getByteCode(){
+	public ClassGenerator getByteCode(){
 		return byteCode;
 	}
 	

src/de/dhbwstuttgart/typeinference/TypeinferenceResultSet.java

@@ -112,16 +112,6 @@ public class TypeinferenceResultSet
     	this.ownerOfResultSet.addTypeInsertPoints(ret,this.unifiedConstraints);
     	
     	return ret;
-    }
-    
-    /**
-     * Startet die Bytecodegenerierung dieser Lösung.
-     * Dabei wird die codegen-Methode der inferierten Klasse mit diesem ResultSet aufgerufen.
-     */
-    public ByteCodeResult codegen(){
-    	ByteCodeResult res = this.ownerOfResultSet.genByteCode(this).firstElement();
-    	return res;
-    }
-    
+    }    
 }
 // ino.end

src/de/dhbwstuttgart/typeinference/TypeinferenceResults.java

@@ -0,0 +1,25 @@
+package de.dhbwstuttgart.typeinference;
+
+import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+public class TypeinferenceResults {
+	
+	private Menge<TypeinferenceResultSet> typeReconstructions;
+
+	public TypeinferenceResults() {
+		typeReconstructions = new Menge<>();
+	}
+
+	public TypeinferenceResults(Menge<TypeinferenceResultSet> typeReconstructions) {
+		this.typeReconstructions = typeReconstructions;
+	}
+
+	public Type getTypeOfPlaceholder(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex, Menge<TypePlaceholder> toOneOfTheseTypes) {
+		return typeReconstructions.get(typeinferenceResultSetIndex).getTypeOfPlaceholder(typePlaceholder, toOneOfTheseTypes);
+	}
+
+	public Menge<TypeinferenceResultSet> getTypeReconstructions() {
+		return typeReconstructions;
+	}
+}

src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java

@@ -305,7 +305,7 @@ public class TypeAssumptions {
 			if(match && t instanceof RefType){
 				RefType tr = (RefType)t;
 				RefType ret = ass.getAssumedClass().getType(); //Dadurch erhält der RefType den vollen Namen (bsp. java.lang.Integer)
-				
+				ret.setArray(((RefType) t).IsArray());
 				//Falls der RefType mit Parametern angegeben wurde, so müssen diese erhalten bleiben:
 				if(tr.get_ParaList()!=null && tr.getParaList().size()>0){
 					ret.set_ParaList(tr.getParaList());

src/de/dhbwstuttgart/typeinference/unify/Unify.java

@@ -1,25 +1,15 @@
 //otth/pluemicke2.1.jav funktioniert nicht xxx anschauen
 // ino.module.Unify.8721.package 
 package de.dhbwstuttgart.typeinference.unify;
+import java.util.Collection;
 // ino.end
 // ino.module.Unify.8721.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
-
-import de.dhbwstuttgart.typeinference.Menge;
-
-import java.util.function.BiConsumer;
 import java.util.function.Function;
-import java.util.function.Supplier;
 import java.util.stream.Stream;
 
-import com.google.common.collect.Sets;
-import com.google.common.collect.Sets.SetView;
-import com.rits.cloning.Cloner;
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.logger.SectionLogger;
@@ -44,19 +34,17 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.syntaxtree.type.ObjectType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.WildcardType;
-import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.DeepCloneable;
-import de.dhbwstuttgart.typeinference.OderConstraint;
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.Pair;
 import de.dhbwstuttgart.typeinference.Pair.PairOperator;
-import de.dhbwstuttgart.typeinference.UndConstraint;
 
 // ino.end
 
 // ino.class.Unify.28049.description type=javadoc
 /**
  * Implementierung des Unifizierungsalgorithmus
- * @author Martin Pl�micke, Thomas Ott
+ * @author Martin Pl<EFBFBD>micke, Thomas Ott
  * @version $Date: 2013/05/22 22:23:50 $
  */
 // ino.end
@@ -67,7 +55,7 @@ public class Unify
 {
     
     // ino.attribute.inferencelog.28052.declaration 
-    protected static SectionLogger inferencelog = Logger.getSectionLogger(Unify.class.getName(), Section.UNIFY);
+    protected static SectionLogger inferencelog = Logger.getSectionLogger("inference", Section.UNIFY);
     // ino.end
     
     /**
@@ -126,21 +114,13 @@ public class Unify
      * Entweder alle Elemente in solved Form [A =. type, B =. type2, ...]
      * oder alle Elemente in der Form [A <. B, C <. D, ..., E <? F, G <? H, ....  I =. type, J =. type2, ...]
      * oder [] = fail
-     * Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
+     * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
      */
+    //public static Menge<Menge<Pair>> unifyWC (Menge<Pair> E, FC_TTO fc_tto)
     public static Menge<Menge<Pair>> unify (Menge<Pair> E, FC_TTO fc_tto)
     {
-    	return unifyFiltered(E, fc_tto,true);
-    }
-    
-    //public static Menge<Menge<Pair>> unifyWC (Menge<Pair> E, FC_TTO fc_tto)
-    public static Menge<Menge<Pair>> unifyFiltered (Menge<Pair> E, FC_TTO fc_tto, boolean filter)
-    {
-    	SectionLogger log = Logger.getSectionLogger(Unify.class.getName(), Section.UNIFY);
-    	
     	//Schritt 1: Aufrufen der Regeln durch sub_unify.
     	Menge<Pair> Eq = sub_unify(E,fc_tto);
-    	log.debug("Eq Set nach Schritt 1: "+Eq);
     	/* Schritt 2: Rausfiltern der Typen die entweder beides Typvariablen sind oder nicht.
     	 * Sobald ein Paar auftauch, bei denen kein Typ mehr eine Typvariable ist, kann dieses Paar
     	 * nicht mehr unifiziert werden, deshalb abbruch.*/
@@ -153,7 +133,7 @@ public class Unify
     		}
     		else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder))
     		{
-    			//Diese Paare können nicht mehr Unifiziert werden. fail.
+    			//Diese Paare k<EFBFBD>nnen nicht mehr Unifiziert werden. fail.
     			inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " muesste mindestens einen TPH enthalten.");
     			return new Menge<Menge<Pair>>();
     		}
@@ -165,8 +145,8 @@ public class Unify
     		if(!Eq1.contains(p))
     			Eq2.add(p);
     	}
-    	/* Schritt 4, Teil 1: Einsammeln der Sets für das Kartesiche Produkt.
-    	 * Hier werden die Paare verglichen. Je nach Struktur können neue Paare erzeugt
+    	/* Schritt 4, Teil 1: Einsammeln der Sets f<EFBFBD>r das Kartesiche Produkt.
+    	 * Hier werden die Paare verglichen. Je nach Struktur k<EFBFBD>nnen neue Paare erzeugt
     	 * werden, aus denen dann das kartesische Produkt gebildet wird.*/
     	Menge<Menge<Menge<Pair>>> cartProduktSets = new Menge<Menge<Menge<Pair>>>();
     	for(Pair p : Eq2)
@@ -178,7 +158,7 @@ public class Unify
                                p.TA2 = ((SuperWildcardType)p.TA2).get_SuperType(); 
                                //HIER GIBT ES EIN PROBLEM, WENN get_SuperType ein TPH LIEFERT PL 15-03-12
                                //Dann ist THP <. TPH in Eq2 anstatt in Eq1
-                               //Muesste mit folgendem if gelöst sein. PL 15-03-17
+                               //Muesste mit folgendem if gel<EFBFBD>st sein. PL 15-03-17
                                if (p.TA2 instanceof TypePlaceholder) {
                                        Eq1.addElement(p);
                                        //      Eq2.remove(p);
@@ -229,7 +209,7 @@ public class Unify
     							unifyErgs.add(unifyErgsElement.firstElement());
     						}
     					}
-//    					Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelöscht.
+//    					Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
 	    				if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty())
 	    			       || p_fc.TA2.equals(p_TA2)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05
 	    			    {
@@ -328,7 +308,7 @@ public class Unify
     			}
     			else if(p.OperatorSmaller() && p.TA2 instanceof GenericTypeVar)
     			{
-    				//Paar unverändert lassen, wenn eine GenericTypeVar ist
+    				//Paar unver<EFBFBD>ndert lassen, wenn eine GenericTypeVar ist
     				Menge<Menge<Pair>> setofsetofpairs = new Menge<Menge<Pair>>();
 					Menge<Pair> vTmp = new Menge<Pair>();
 					vTmp.add(p);
@@ -370,7 +350,7 @@ public class Unify
 	    							unifyErgs.add(unifyErgsElement.firstElement());
 	    						}
 	    					}
-	    					//Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelöscht.
+	    					//Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
     	    				if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty())
     	    			       || p_fc.TA2.equals(p_TA2)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05
     	    			    {
@@ -545,7 +525,7 @@ public class Unify
         							unifyErgs.add(unifyErgsElement.firstElement());
         						}
         					}
-//        					Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelöscht.
+//        					Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
     	    				if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty())
     	    			       || p_fc.TA2.equals(p_TA1)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05
     	    			    {
@@ -644,91 +624,8 @@ public class Unify
     		}
     	}
     	//Schritt 4, Teil 2: Kartesisches Produkt bilden.
-    	log.debug("Unify Sets nach Schritt 4 vor dem Erstellen des Karthesischen Produkts: "+cartProduktSets);
-    	/*
-    	//TODO: Vor der Bildung des Karthesischen Produkts unmögliche Kombinationen ausfiltern
-    	//cartProduktSets kontrollieren:
-    	ConstraintsSet cSet = new ConstraintsSet();
-		UndConstraint eq1cons = new UndConstraint();
-    	for(Pair p : Eq1){
-    		eq1cons.addConstraint(p.TA1, p.TA2);
-    	}
-    	cSet.add(eq1cons);
-    	for(Menge<Menge<Pair>> vecvecpair : cartProduktSets){
-        	OderConstraint orConstraints = new OderConstraint();
-    		for(Menge<Pair> pairs : vecvecpair){
-	    		UndConstraint uCons = new UndConstraint();
-    			for(Pair p : pairs){
-    	    		uCons.addConstraint(p.TA1, p.TA2);
-    			}
-    			orConstraints.addConstraint(uCons);
-    		}
-    		cSet.add(orConstraints);
-    	}
-    	
-    	Menge<Menge<Pair>> bigCartProductErg3 = cSet.cartesianProduct();
-    	if(filter)log.debug("Karthesisches Produkt nach Filterung: "+bigCartProductErg3);
-    	Sets.cartesianProduct(bigCartProductErg3);
-    	*/
-    	
-    	if(filter){
-    		//Cloner cloner = new Cloner();
-    		Menge<Menge<Menge<Pair>>> temp = new Menge<>(); //hier werden gefilterte Constraints gesammelt
-    		Menge<Pair> undMenge = new Menge<Pair>(); //Die Menge von Pairs, welche in jedem Kartesischen Produkt enthalten sind.
-    		//undMenge.addAll(cloner.deepClone(Eq1));
-    		undMenge.addAll(Unify.deepClone(Eq1));
-    		Menge<Menge<Menge<Pair>>> oderConstraints = new Menge<>();//Die zu filternden Constraints
-			for (Menge<Menge<Pair>> vecvecpair : cartProduktSets){
-    			if(vecvecpair.size() == 1){//gibt es nur eine UndMenge in diesem Set, dann kommt diese in jedem Karthesischen Produkt vor:
-    				//undMenge.addAll(cloner.deepClone(vecvecpair.firstElement()));
-    				undMenge.addAll(Unify.deepClone(vecvecpair.firstElement()));
-    				temp.add(vecvecpair);
-    			}else{//gibt es mehrere Mengen, kann gefiltert werden:
-    				oderConstraints.add(vecvecpair); //die Menge zu den zu filternden OderConstraints anfügen
-    			}
-    		}
-    		//Filtere die OderConstraints:
-    		for(Menge<Menge<Pair>> oderConstraint : oderConstraints){
-    			Menge<Menge<Pair>> filteredOCons = new Menge<>(); //diese Menge sammelt nur Cons
-    			for(Menge<Pair> pairs : oderConstraint){
-	    			Menge<Pair> testMenge = new Menge<Pair>();
-	    			//testMenge.addAll(cloner.deepClone(undMenge));
-	    			//testMenge.addAll(cloner.deepClone(pairs));
-	    			testMenge.addAll(Unify.deepClone(undMenge));
-	    			testMenge.addAll(Unify.deepClone(pairs));
-	        		Menge<Menge<Pair>> test = Unify.unifyFiltered(testMenge, fc_tto, false);
-	        		if(test.size()>0){
-	        			filteredOCons.add(pairs);
-	        		}
-	        		else{
-	        			log.debug("Ausgesondertes Constraint: "+pairs);
-	        		}
-    			}
-    			temp.add(filteredOCons);
-    		}
-    		SetView<Menge<Menge<Pair>>> difference = Sets.difference(cartProduktSets, temp);
-    		log.debug("Ausgelöschte Constraints: "+difference.toString());
-    		cartProduktSets = temp;
-			/*
-    		Unifier filterUnify = (pairs)->{
-				String pairsString = pairs.toString();
-	        	Menge<Menge<Pair>> retValue = new Menge<>();
-	        	retValue = Unify.unifyFiltered(pairs,fc_tto,false);
-	        	//Unify.unify(pairs, fc_tto, (i)->{});
-	        	log.debug("Filtere Constraints:\n"+pairsString);
-	        	log.debug("Ergebnis: "+ retValue);
-	        	return retValue;
-	        };
-            	
-            log.debug("Filtere mithilfe von 'filterWrongConstraints': "+cSet);
-            cSet.filterWrongConstraints(filterUnify);
-    		*/
-    	}
-    	
-    	//*/
-    	
-    	///* Altes Karthesisches Produkt: Auskommentiert durch Andreas Stadelmeier
-    	//Hier wird aus den in Schritt 4, Teil 1 erzeugten Vektoren das Kartesische Produkt gebildet.
+    	//TODO: Vor der Bildung des Karthesischen Produkts unm<6E>gliche Kombinationen ausfiltern
+    	//Hier wird aus den in Schritt 4, Teil 1 erzeugten Vektoren das Kartesische Produkt gebilden.
     	Menge<Pair> helpvp;
     	Menge<Menge<Pair>> bigCartProductErg = new Menge<Menge<Pair>>();
         bigCartProductErg.addElement(copyMengePair(Eq1));
@@ -747,33 +644,13 @@ public class Unify
                 }       
             }
         }
-       
-    	/*
-        if(! bigCartProductErg.equals(bigCartProductErg3)){
-        	for(int i = 0; i<bigCartProductErg3.size();i++){
-        		if(! (bigCartProductErg.get(i).equals(bigCartProductErg3.get(i)))){
-        			System.out.println();
-                	//TODO: Hier testen, wo der Unterschied zwischen den beiden Karthesischen Produkten ist
-        		}
-        	}
-        }
-        */
-        //*/
         
         //Schritt 5: Einsetzen der Subst Regel
-        //Hier werden die TPHs substituiert, und dann nach geänderten und nicht geänderten Sets sortiert.
+        //Hier werden die TPHs substituiert, und dann nach ge<EFBFBD>nderten und nicht ge<EFBFBD>nderten Sets sortiert.
         Menge<Menge<Pair>> changedSets = new Menge<Menge<Pair>>();
         Menge<Menge<Pair>> notChangedSets = new Menge<Menge<Pair>>();
-        int counter = 0;
         for(Menge<Pair> vecpair : bigCartProductErg)
         {
-        	//Klone die Menge vecpair, bevor substituiert wird. Viele Paare sind doppelt referenziert und müssen vor dem Substituieren geklont werden
-        	vecpair = vecpair.stream().map(x -> x.clone()).collect(Menge::new, Menge::add, Menge::addAll);
-        	
-        	counter++;
-        	if(counter > 1000){
-            	System.out.println(counter + " von "+bigCartProductErg.size());
-        	}
         	boolean change = false;	   //eingefuegt PL 13-05-22
         	Pair substPair = null;
         	do
@@ -823,29 +700,29 @@ public class Unify
             }
         }
         
-        //Eq2Set ist das eigentliche Ergebnis, dass zurückgegeben wird.
+        //Eq2Set ist das eigentliche Ergebnis, dass zur<EFBFBD>ckgegeben wird.
         Menge<Menge<Pair>> Eq2Set = new Menge<Menge<Pair>>();
         
-        //Schritt 6A: Beginnen mit Schritt 1 bei den geänderten.
+        //Schritt 6A: Beginnen mit Schritt 1 bei den ge<EFBFBD>nderten.
         for(Menge<Pair> vecpair : changedSets)
         {
         	Menge<Menge<Pair>> unifyErgs = unify(vecpair,fc_tto);
-        	//Die Ergebnissvektoren sind schon im Schritt 7 von dem Rekursiven Aufruf geprüft worden. Sie können direkt eingefügt werden.
+        	//Die Ergebnissvektoren sind schon im Schritt 7 von dem Rekursiven Aufruf gepr<EFBFBD>ft worden. Sie k<EFBFBD>nnen direkt eingef<EFBFBD>gt werden.
         	Eq2Set.addAll(unifyErgs);
         }
         
-        //Schritt 6B Einfügen der nicht geänderten.
+        //Schritt 6B Einf<EFBFBD>gen der nicht ge<EFBFBD>nderten.
         //Schritt 7: Aussortieren der falschen Sets
         /*
          * Durch die Rekursion in Schritt 6A sind die Ergebnisse, welche in 6A dazukommen auf jeden Fall korrekt.
-         * Es müssen nur die Ergebnisse aus 6B geprüft werden.
+         * Es m<EFBFBD>ssen nur die Ergebnisse aus 6B gepr<EFBFBD>ft werden.
          */
         for(Menge<Pair> vecpair : notChangedSets)
         {
-        	//Überprüfen ob Menge in SolvedForm ist.
+        	//<EFBFBD>berpr<EFBFBD>fen ob Menge in SolvedForm ist.
         	if(hasSolvedForm(vecpair)) //PL 13-05-22 hasSolvedForm angepasst
         	{
-        		//Überprüfung auf FreshTypeVars in den Typen
+        		//<EFBFBD>berpr<EFBFBD>fung auf FreshTypeVars in den Typen
         		boolean foundFresh = false;
         		for(Pair p : vecpair)
         		{
@@ -863,14 +740,14 @@ public class Unify
         	}
         }
     	
-        //Ergebnis zurückgeben.
+        //Ergebnis zur<EFBFBD>ckgeben.
     	return Eq2Set;
     }
     
     /**
      * PL 2014-10-25
      * schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind
-     * Rückgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
+     * R<EFBFBD>ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
      * @param var
      * @param vars
      * @param indexe
@@ -921,10 +798,10 @@ public class Unify
      * Beispiel: unifyERgs = [[a = Integer, b = Number ]], test = Menge<a>
      * In diesm fall wird b = Number aus dem Menge entfernt.
      * 
-     * Durch das Entfernen entstehen evtl. Identische Mengeen, diese werden auch gelöscht.
+     * Durch das Entfernen entstehen evtl. Identische Mengeen, diese werden auch gel<EFBFBD>scht.
      * 
-     * @param unifyErgs - Ergebnisse des Unify, die geprüft werden sollen.
-     * @param test - RefType gegen den geprüft werden soll.
+     * @param unifyErgs - Ergebnisse des Unify, die gepr<EFBFBD>ft werden sollen.
+     * @param test - RefType gegen den gepr<EFBFBD>ft werden soll.
      */
     private static void testUnifyErg(Menge<Menge<Pair>> unifyErgs, RefType test)
     {
@@ -938,7 +815,7 @@ public class Unify
 				vec--;
 			}
 		}
-    	//Gleiche Mengeen löschen
+    	//Gleiche Mengeen l<EFBFBD>schen
     	for(int i = 0; i < unifyErgs.size(); i++)
     	{
     		Menge<Pair> p1 = unifyErgs.elementAt(i);
@@ -967,13 +844,13 @@ public class Unify
     }
     
     /**
-     * Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der übergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
+     * Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der <EFBFBD>bergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
      * Beispiel: otherPairTypes = [Integer, Number, Menge<Integer>], TA1 = TPH a.
      * return: [[TPH a = Integer],[TPH a = Number],[TPH a = Menge<Integer>]]
      * 
      * @param TA1 - Der Typ der immer vorne steht
      * @param otherPairTypes - Die anderen Typen
-     * @return - Ein Menge<Menge<Pair>> der alle Paare enthält.
+     * @return - Ein Menge<Menge<Pair>> der alle Paare enth<EFBFBD>lt.
      */
     private static Menge<Menge<Pair>> generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)
     {
@@ -1074,7 +951,7 @@ public class Unify
         //Menge wird geclont, Elemente nicht
         //Menge<RefType> Mub = (Menge<RefType>)ub.clone();
         
-        //Elemente die nicht kleinste obere Schranken sind, werden gel�scht
+        //Elemente die nicht kleinste obere Schranken sind, werden gel<EFBFBD>scht
         //FUNKTIONIERT NICHT. SIEHE iftest.java PL 08-08-13
         for (int i = 0; i < ub.size(); i++) { 
             for (int j = 0; j < ub.size(); j++) {
@@ -1130,7 +1007,7 @@ throws MatchException
 // ino.method.match.28064.body 
 { 
     //PL 05-01-22 
-    //gibt eine Substitution zur�ck, die den Variablen aus FCtype
+    //gibt eine Substitution zur<EFBFBD>ck, die den Variablen aus FCtype
     //die Typterme aus tomatch zu ordnet. Es wird davon ausgegangen, dass
     //FCtype gegen tomatch gematcht werden kann.
     if (FCtype.getTypeName().equals(tomatch.getTypeName())) {
@@ -1174,7 +1051,7 @@ throws MatchException
     // ino.method.sub_unify.28067.body 
     {
     //PL 05-01-21 umbenannt in sub_unify 
-    //Luar boolean useSubst hinzugefügt, um bei bedarf zu Steuern ob Subst Regel angewendet wird oder nicht.
+    //Luar boolean useSubst hinzugef<EFBFBD>gt, um bei bedarf zu Steuern ob Subst Regel angewendet wird oder nicht.
         // otth: Unifikation - Versuch 1 :-)
     
     //Menge FC = fc_tto.getFC();
@@ -1199,7 +1076,7 @@ throws MatchException
                 inferencelog.debug("Ausgewaehltes Paar = " + P.toString() + "");
                 inferencelog.debug(  "--------------------------------------------------");
                 
-                // Bei allen Erase erfolgt keine Kopie nach H, dadurch wird das Pair gelöscht.
+                // Bei allen Erase erfolgt keine Kopie nach H, dadurch wird das Pair gel<EFBFBD>scht.
                 //ERASE3
                 if( P.isEqual() && P.OperatorEqual() )
                 {
@@ -1321,13 +1198,13 @@ throws MatchException
 	                				}
 	                				catch( SCException Ex )
 	                                {
-	                                    inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
+	                                    inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
 	                                    break;
 	                                }
 	                			}
 	                			else
 	                			{
-	                				inferencelog.info("---- Unifikation nicht m�glich: Anzahl der Parameter verschieden!");
+	                				inferencelog.info("---- Unifikation nicht m<EFBFBD>glich: Anzahl der Parameter verschieden!");
 	                                break;
 	                			}
 	                		}
@@ -1378,13 +1255,13 @@ throws MatchException
 	                				}
 	                				catch( SCException Ex )
 	                	            {
-	                	                inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
+	                	                inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
 	                	                break;
 	                	            }
 	                			}
 	                			else
 	                			{
-	                				inferencelog.info("---- Unifikation nicht m�glich: Anzahl der Parameter verschieden!");
+	                				inferencelog.info("---- Unifikation nicht m<EFBFBD>glich: Anzahl der Parameter verschieden!");
 	                                break;
 	                			}
 	                		}
@@ -1455,7 +1332,7 @@ throws MatchException
          
                 	RefType TA1 = null;
                 	RefType TA2 = null;
-                	//Hier werden die RefTypes gefüllt.
+                	//Hier werden die RefTypes gef<EFBFBD>llt.
                 	if(P.TA1 instanceof RefType && P.TA2 instanceof RefType)
                 	{
                 		TA1 = (RefType)P.TA1;
@@ -1477,7 +1354,7 @@ throws MatchException
 	                        }
 	                        catch( SCException Ex )
 	                        {
-	                            inferencelog.error("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
+	                            inferencelog.error("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
 	                            break;
 	                        }
 	                    }
@@ -1510,7 +1387,7 @@ throws MatchException
                             }
                             catch( SCException Ex )
                             {
-                                inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
+                                inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
                                 break;
                             }
                         }
@@ -1530,7 +1407,7 @@ throws MatchException
                            	}
                            	catch( SCException Ex )
                             {
-                                inferencelog.error("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
+                                inferencelog.error("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
                                 break;
                             }
                         }
@@ -1643,7 +1520,7 @@ throws MatchException
                 	
                 }
     
-                // Subst --> noch zu pr�fen
+                // Subst --> noch zu pr<EFBFBD>fen
                 if( P.TA1 instanceof TypePlaceholder && P.OperatorEqual() && useSubst) //&& P.TA2 instanceof RefType )
             //PL 05-02-09 P.TA@ duerfen auch TypePlaceholder sein
             /*  BEISPIEL:
@@ -1797,7 +1674,7 @@ throws MatchException
     
     /**
      * Implementiert die reduceEq Regel des sub_unify
-     * Da in reduce2 unnötigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren.
+     * Da in reduce2 unn<EFBFBD>tigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren.
      */
     private static void reduceEq(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO) throws SCException
     {
@@ -1819,11 +1696,11 @@ throws MatchException
         inferencelog.debug("---- Parameteranzahl gleich");
         inferencelog.debug("---- Reduce !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (" + L1.size() + ") neue(s) Paar(e)");
 
-        // hier mu� die PERMUTATION erfolgen
+        // hier mu<EFBFBD> die PERMUTATION erfolgen
         inferencelog.debug("---- PAARBILDUNG ");
         for( int k = 0; k < L1.size(); k++ )
         {
-            // pi eig. bei reduce2 �berfl�ssig, schadet aber hoff. auch nicht :-)
+            // pi eig. bei reduce2 <EFBFBD>berfl<EFBFBD>ssig, schadet aber hoff. auch nicht :-)
         	//luar 19-04-2007 durch das pi kann reduce2 auch als reduceEq verwendet werden. Wenn das pi durch k ersetzt wird, muss reduceEq entsprechend ausprogrammiert werden.
             Pair P2 = new Pair( L1.elementAt( pi(k, TA1.getTypeName(), TA2.getTypeName(), TTO ) ), L2.elementAt(k), PairOperator.Equal );
             inferencelog.debug("---- Paar1: (" + (L1.elementAt( pi(k, TA1.getTypeName(), TA2.getTypeName(), TTO ) )).getName() + ", " + (L2.elementAt(k)).getName() + P2.OperatorEqual() + ")");
@@ -2122,7 +1999,7 @@ throws MatchException
         //LIEGT
         //erlegigt 06-04-28
         Menge<Pair> res = sub_unify(subunifypair, fc_tto);
-        if (hasSolvedForm(res)) { //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
+        if (hasSolvedForm(res)) { //PL 13-05-22: hasSolvedForm geaendert, es nicht gekl<EFBFBD>rt, ob es funktioniert.
             inferencelog.debug("HasSolvedForm: ");
             printMenge("RES_SMALLER", res, 6);
             ht = MengePair2SubstHashtableMengePair(res);
@@ -2237,27 +2114,6 @@ throws MatchException
     return ret;
     }
     // ino.end
-        
-    /*
-    // ino.method.allGreater.29428.definition 
-    public static Menge<RefType> allGreater (BoundedGenericTypeVar ty, Menge<Pair> FC)
-    // ino.end
-    // ino.method.allGreater.29428.body 
-    {
-            CRefTypeSet ret = new CRefTypeSet();
-            Iterator<ObjectType> typeIt = ty.getBounds().iterator();
-            while(typeIt.hasNext()) {
-                CRefTypeSet grBounds = new CRefTypeSet();
-                RefType act = (RefType)typeIt.next();
-                grBounds.setMenge(allGreater(act, FC));
-                grBounds.addElement(act);
-                ret.unite(grBounds);
-            }
-            return ret.getMenge();
-    }
-    // ino.end
-    */
-    
     // ino.method.allGreater.28094.definition 
     public static Menge<RefType> allGreater (RefType ty, Menge<Pair> FC)
     // ino.end
@@ -2305,7 +2161,7 @@ throws MatchException
     {
         // otth: Funktion, die prueft, ob Paar( R1, R2 ) in FC liegt, 
         // bzw. deren rechten Seiten, ohne die TypePlaceholder-Variablen zu beachten
-        // z.B. Menge<A> w�re hier gleich wie Menge<Integer>
+        // z.B. Menge<A> w<EFBFBD>re hier gleich wie Menge<Integer>
         
         // z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> >  )  ,...}
         // R1 = AA<Integer, b>
@@ -2353,7 +2209,7 @@ throws MatchException
     {
         // otth: Funktion, die prueft, ob Paar( R1, \sigma(R2) ) in FC liegt, 
         // bzw. deren rechten Seiten, ohne die TypePlaceholders zu beachten
-        // z.B. Menge<A> w�re hier gleich wie Menge<Integer>
+        // z.B. Menge<A> w<EFBFBD>re hier gleich wie Menge<Integer>
         
         // z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> >  )  ,...}
         // R1 = AA<Integer, b>
@@ -2391,7 +2247,7 @@ throws MatchException
             Menge<Pair> vp = sub_unify(R2vec, fc_tto);
             
             printMenge("VP", vp, 6);
-            if ( hasSolvedForm(vp) ) //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
+            if ( hasSolvedForm(vp) ) //PL 13-05-22: hasSolvedForm geaendert, es nicht gekl<EFBFBD>rt, ob es funktioniert.
             //if( isRXSimilarRY( RFC, R2 ) )
                     {
                 inferencelog.debug("SIMILAR2");
@@ -2476,19 +2332,7 @@ throws MatchException
         inferencelog.debug("Nummer: " + nTypnrInPair);
         inferencelog.debug("TV: " + a.getName());
         inferencelog.debug("Bedingung: " + bMitVorbedingung);
-        /*
-        Cloner cloner = new Cloner();
-        cloner.setDumpClonedClasses(true);
-        SectionLogger log = Logger.getSectionLogger("Subst-Methode", Section.UNIFY);
-        Timewatch timer = Timewatch.getTimewatch();
-        de.dhbwstuttgart.logger.Timestamp timestamp = timer.start("Unify-Subst");
-        P = cloner.deepClone(P);
-        a = cloner.deepClone(a);
-        o = cloner.deepClone(o);
-        long time = timestamp.stop();
-        log.debug("Benötigte Zeit für DeepClone: "+time);
-		*/
-        
+    
         // richtiger Typ aus Pair raussuchen
         Type T = null;
         if( nTypnrInPair == 1 )
@@ -2500,7 +2344,7 @@ throws MatchException
     if (o instanceof RefType) {//PL 05-02-09 eingefuegt siehe Methodenkopf
         if( bMitVorbedingung && isTVinRefType( a, (RefType)o ) )
         {
-            inferencelog.debug("  Subst nicht m�glich, da TV " + a.getName() + " in RefType " + o.getName());
+            inferencelog.debug("  Subst nicht m<EFBFBD>glich, da TV " + a.getName() + " in RefType " + o.getName());
             return false;
         }
     }
@@ -2510,7 +2354,7 @@ throws MatchException
         {
             // Parameterliste durchgehen
             Menge vTemp = ((RefType)T).get_ParaList();
-            boolean ret = true; //EINGEFUEGT PL 14-01-16: Return darf erst am Ende zurückgegeben werden und nicht in den ifs 
+            Boolean ret = true; //EINGEFUEGT PL 14-01-16: Return darf erst am Ende zur<EFBFBD>ckgegeben werden und nicht in den ifs 
             					//sonst werden nicht alle Elemente der Forschleife durchlaufen
             for( int i = 0; i < vTemp.size(); i++ )
             {
@@ -2556,7 +2400,7 @@ throws MatchException
                 return true;
             }
         }
-        //Wildcard ergänzt PL 14-12-05
+        //Wildcard erg<EFBFBD>nzt PL 14-12-05
         if ( T instanceof ExtendsWildcardType )
         {
         	Type Temp = ((ExtendsWildcardType) T).get_ExtendsType();
@@ -2571,7 +2415,7 @@ throws MatchException
                 }
             }
         }
-        //Wildcard ergänzt PL 14-12-05
+        //Wildcard erg<EFBFBD>nzt PL 14-12-05
         if ( T instanceof SuperWildcardType )
         {
         	Type Temp = ((SuperWildcardType) T).get_SuperType();
@@ -2652,7 +2496,7 @@ throws MatchException
     {
     	
     	
-        // otth: Funktion pr�ft, ob Klasse 'Basis' von Klasse 'Mutter' direkt oder indirekt abgeleitet ist
+        // otth: Funktion pr<EFBFBD>ft, ob Klasse 'Basis' von Klasse 'Mutter' direkt oder indirekt abgeleitet ist
     
         // Basisklasse suchen
     Menge tto = fc_tto.getTTO();
@@ -2676,9 +2520,9 @@ throws MatchException
                     }
                     
                     /* 
-                     * Hier wird überprüft ob in der Paraliste ein anderes Element als ein GTV drinne ist.
-                     * Sollte ein anderes Element gefunden werden ist Reduce nicht möglich.
-                     * Beispiel: Matrix <. Menge<Menge<Integer>> ist nur durch adapt möglich.
+                     * Hier wird <EFBFBD>berpr<EFBFBD>ft ob in der Paraliste ein anderes Element als ein GTV drinne ist.
+                     * Sollte ein anderes Element gefunden werden ist Reduce nicht m<EFBFBD>glich.
+                     * Beispiel: Matrix <. Menge<Menge<Integer>> ist nur durch adapt m<EFBFBD>glich.
                      */
                     for(Type t : s)
                     {
@@ -2812,7 +2656,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
         if( n >= vD.size() )
         throw F;
     
-        // Permuationswert f�r 'n' berechnen
+        // Permuationswert f<EFBFBD>r 'n' berechnen
         Type TV = (Type)vD.elementAt(n);
         
         int nPos = -1;
@@ -2844,12 +2688,12 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     // ino.method.printMengeUnifier.28121.body 
     {
     //PL 05-01-21
-    //Ruft f�r eine Menge von Unifikatoren die Methode
+    //Ruft f<EFBFBD>r eine Menge von Unifikatoren die Methode
     //printMenge auf
     for (int i = 0; i < Uni.size(); i++) {
         inferencelog.debug((i+1) + ". Unifier");
         printMenge(strMenge, Uni.elementAt(i), nDebug);
-        if( hasSolvedForm( Uni.elementAt(i) ) ) { //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
+        if( hasSolvedForm( Uni.elementAt(i) ) ) { //PL 13-05-22: hasSolvedForm geaendert, es nicht gekl<EFBFBD>rt, ob es funktioniert.
             inferencelog.debug((i+1) + ". Unifier ist in 'Solved form'!\n");
         }
         else {
@@ -2876,7 +2720,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
         }
     
         for( int tt = 0; tt < E.size(); tt++ ) {
-        	//luar 13-03-07 If Else Block gelöscht, da sinnlos.
+        	//luar 13-03-07 If Else Block gel<EFBFBD>scht, da sinnlos.
         	if( tt > 0 )
         		strTemp = strTemp + ",\n" + E.elementAt(tt).toString();
             else
@@ -2969,7 +2813,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * Implementiert die CaptureConversion. Wendet diese auf jeden Typ im Menge TVec an.
-     * Rückgabe ist ein ErgebnisMenge
+     * R<EFBFBD>ckgabe ist ein ErgebnisMenge
      */
     private static Menge<ObjectType> CaptureConversion(Menge<ObjectType> TVec, FC_TTO fc_tto)
     {
@@ -2977,7 +2821,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	for(ObjectType t : TVec)
     	{
     		ObjectType ccT = (ObjectType)CaptureConversion(t,fc_tto);
-    						//CaptureConversion kann nur ObjectTypes zurückliefern, laesst sich aber nicht zurziehen.
+    						//CaptureConversion kann nur ObjectTypes zur<EFBFBD>ckliefern, laesst sich aber nicht zurziehen.
     		if(ccT != null)
     			retVec.add(ccT);
     	}
@@ -2987,7 +2831,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     /**
      * Erzeugt die CaptureConversion von einem Typ.
      * 
-     * @param T - Übergebener Typ, von welchem die CaptureConversion gemacht werden soll.
+     * @param T - <EFBFBD>bergebener Typ, von welchem die CaptureConversion gemacht werden soll.
      * @param fc_tto - Hilfsklasse.
      * @return - CC(T)
      */
@@ -3022,7 +2866,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     				if(t instanceof WildcardType)
     				{
     					FreshWildcardType fwcT = ((WildcardType)t).GetFreshWildcardType();
-    					//Wenn beim Original Typ an der Stelle eine BoundedGenericTypeVar ist werden die Bounds zu der Wildcard hinzugefügt.
+    					//Wenn beim Original Typ an der Stelle eine BoundedGenericTypeVar ist werden die Bounds zu der Wildcard hinzugef<EFBFBD>gt.
     					if(cl.get_ParaList().elementAt(i) instanceof BoundedGenericTypeVar)
     					{
     						BoundedGenericTypeVar bgv = (BoundedGenericTypeVar)cl.get_ParaList().elementAt(i);
@@ -3036,7 +2880,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     			}
     			refT.set_ParaList(ccTypes);
     		}
-    		//Wenn eine CaptureConversion durchgeführt wurde den Typ zurückgeben.
+    		//Wenn eine CaptureConversion durchgef<EFBFBD>hrt wurde den Typ zur<EFBFBD>ckgeben.
     		if(ccDone)
     			return refT;
     		else
@@ -3053,13 +2897,13 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     //Von hier an Greater implementierung 28-03-07
     /**
-     * Der Komplette Ablauf von greater und was die einzelnen Teilschritte machen kann anhand von Aktivitätsdiagrammen
-     * im Inovator Projekt, oder in der Studienarbeit Arne Lüdtke, 2007 nachgelesen werden.
+     * Der Komplette Ablauf von greater und was die einzelnen Teilschritte machen kann anhand von Aktivit<EFBFBD>tsdiagrammen
+     * im Inovator Projekt, oder in der Studienarbeit Arne L<EFBFBD>dtke, 2007 nachgelesen werden.
      */
     
     /**
-     * Erzeugt alle Typen die greater sind als T. Gibt diese zurück.
-     * Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
+     * Erzeugt alle Typen die greater sind als T. Gibt diese zur<EFBFBD>ck.
+     * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
      */
     private static Menge<ObjectType> greater(ObjectType T, FC_TTO fc_tto)
     //an die Aenderungen im Skript anpassen 07-11-03
@@ -3084,22 +2928,22 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	//greater1 Erzeugen
     	Menge<ObjectType> greater1Erg = greater1(T,fc_tto);
     	
-    	//Reflexivität, deshalb T hinzufügen.
+    	//Reflexivit<EFBFBD>t, deshalb T hinzuf<EFBFBD>gen.
     	if(!greater1Erg.contains(T))
     		greater1Erg.add(T);
     	
-    	//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec übernommen.
+    	//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec <EFBFBD>bernommen.
     	for(ObjectType t : greater1Erg)
     		if(!retVec.contains(t))
     			retVec.add(t);                      
     	
-    	//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einfügen
+    	//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einf<EFBFBD>gen
     	Menge<ObjectType> greater2Erg = greater2(greater1Erg,fc_tto);
     	for(ObjectType t : greater2Erg)
     		if(!retVec.contains(t))
     			retVec.add(t);           
     	
-    	//Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einfügen
+    	//Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einf<EFBFBD>gen
     	Menge<ObjectType> greater3Erg = greater3(greater2Erg,fc_tto);
     	for(ObjectType t : greater3Erg)
     		if(!retVec.contains(t))
@@ -3110,7 +2954,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * greater1 Schritt von greater.
-     * Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
+     * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
      */
     private static Menge<ObjectType> greater1(ObjectType T, FC_TTO fc_tto)
     {
@@ -3148,8 +2992,8 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     }
     
     /**
-     * Überladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
-     * welcher für die rekursion erforderlich ist mit übergeben muss.
+     * <EFBFBD>berladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
+     * welcher f<EFBFBD>r die rekursion erforderlich ist mit <EFBFBD>bergeben muss.
      */
     private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec)
     {
@@ -3158,7 +3002,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
-     * Für den Startaufruf ist der index = 0. Danach ruft sich cartProductType rekursiv auf.
+     * F<EFBFBD>r den Startaufruf ist der index = 0. Danach ruft sich cartProductType rekursiv auf.
      */
     private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec, int index)
     {
@@ -3193,8 +3037,8 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     }
     
     /**
-     * Überladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
-     * welcher für die rekursion erforderlich ist mit übergeben muss.
+     * <EFBFBD>berladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
+     * welcher f<EFBFBD>r die rekursion erforderlich ist mit <EFBFBD>bergeben muss.
      */
     private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec)
     {
@@ -3203,7 +3047,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
-     * Für den Startaufruf ist der index = 0. Danach ruft sich cartProductPair rekursiv auf.
+     * F<EFBFBD>r den Startaufruf ist der index = 0. Danach ruft sich cartProductPair rekursiv auf.
      */
     private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec, int index)
     {
@@ -3263,7 +3107,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * greaterArg Schritt von greater
-     * Für den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt
+     * F<EFBFBD>r den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt
      */
     private static Menge<Type> greaterArg(Type T, FC_TTO fc_tto)
     {
@@ -3319,7 +3163,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	    return new Menge<Type>();
     	*/
     	
-    	//Diese Abfrage sorgt für grArg(a) = {a} //Luar 07-07-31
+    	//Diese Abfrage sorgt f<EFBFBD>r grArg(a) = {a} //Luar 07-07-31
     	else if(T instanceof TypePlaceholder)
     		retVec.add(T);
     	//Diese Abfrage verhindert, dass bei FunN Wildcard-Typen generiert werden //PL 13-05-22
@@ -3348,7 +3192,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	Menge<ObjectType> retVec = new Menge<ObjectType>();
     	/*
     	 * luar 02-05-07: Beschreibung der Funktion:
-    	 * Für Jeden Typ aus greater1 durch die FC laufen, und auf der Linken seite einen Match versuchen.
+    	 * F<EFBFBD>r Jeden Typ aus greater1 durch die FC laufen, und auf der Linken seite einen Match versuchen.
     	 * Wenn das Funktioniert, dann ist der Typ auf der rechten Seite auch greater.
     	 * */
     	Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>();
@@ -3373,7 +3217,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
 	    				RefType TA2neu = ((RefType)p.TA2).clone();
 	    				SubstHashtableGeneric(TA2neu,ht);
 	    				
-	    				//TA2neu ist greater als T. Einfügen in retVec
+	    				//TA2neu ist greater als T. Einf<EFBFBD>gen in retVec
 	    				if(!retVec.contains(TA2neu))
 	    					retVec.add(TA2neu);
 	    			}
@@ -3403,12 +3247,12 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     //Von hier an Smaller implementierung luar 28-03-07
     /**
-     * Der Komplette Ablauf von smaller und was die einzelnen Teilschritte machen kann anhand von Aktivitätsdiagrammen
-     * im Inovator Projekt, oder in der Studienarbeit Arne Lüdtke, 2007 nachgelesen werden.
+     * Der Komplette Ablauf von smaller und was die einzelnen Teilschritte machen kann anhand von Aktivit<EFBFBD>tsdiagrammen
+     * im Inovator Projekt, oder in der Studienarbeit Arne L<EFBFBD>dtke, 2007 nachgelesen werden.
      */
     
     /**
-     * Erzeugt alle Typen die smaller sind als T. Gibt diese zurück.
+     * Erzeugt alle Typen die smaller sind als T. Gibt diese zur<EFBFBD>ck.
      */
     private static Menge<ObjectType> smaller(ObjectType T, FC_TTO fc_tto)
     //an die Aenderungen im Skript anpassen 07-11-03
@@ -3444,18 +3288,18 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	if(!smaller12Erg.contains(T))
     		smaller12Erg.add(T);
     	
-    	//Ergebnise in retVec einfügen. Doppelte werden gelöscht.
+    	//Ergebnise in retVec einf<EFBFBD>gen. Doppelte werden gel<EFBFBD>scht.
     	for(ObjectType t : smaller12Erg)
     		if(!retVec.contains(t))
     			retVec.add(t);
     	
-    	//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einfügen.
+    	//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einf<EFBFBD>gen.
     	Menge<ObjectType> smaller3Erg = smaller3(smaller12Erg,fc_tto);
     	for(ObjectType t : smaller3Erg)
     		if(!retVec.contains(t))
     			retVec.add(t);
     	
-    	//Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einfügen.
+    	//Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einf<EFBFBD>gen.
     	Menge<ObjectType> smaller4Erg = smaller4(smaller3Erg);
     	for(ObjectType t : smaller4Erg)
     		if(!retVec.contains(t))
@@ -3504,7 +3348,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	Menge<Type> retVec = new Menge<Type>();
     	if(T instanceof ExtendsWildcardType)
     	{
-    		//Für eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen.
+    		//F<EFBFBD>r eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen.
     		ExtendsWildcardType exT = (ExtendsWildcardType)T;
     		Menge<ObjectType> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto);
     		for(ObjectType t : smallerTypes)
@@ -3515,7 +3359,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	}
     	else if(T instanceof SuperWildcardType)
     	{
-    		//Für eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen.
+    		//F<EFBFBD>r eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen.
     		SuperWildcardType suT = (SuperWildcardType)T;
     		Menge<ObjectType> greaterTypes = greater0(suT.get_SuperType(),fc_tto);
     		for(ObjectType t : greaterTypes)
@@ -3554,7 +3398,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	Menge<ObjectType> retVec = new Menge<ObjectType>();
     	/*
     	 * luar 02-05-07: Beschreibung der Funktion:
-    	 * Für Jeden Typ aus Smaller12 durch die FC laufen, und auf der Rechten seite einen Match versuchen.
+    	 * F<EFBFBD>r Jeden Typ aus Smaller12 durch die FC laufen, und auf der Rechten seite einen Match versuchen.
     	 * Wenn das Funktioniert, dann ist der Typ auf der linken Seite auch smaller.
     	 * */
     	Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>();
@@ -3577,7 +3421,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
 	    				//Macht hat funktioniert. In Linker Seite Typen substituieren
 	    				RefType TA1neu = ((RefType)p.TA1).clone();
 	    				SubstHashtableGeneric(TA1neu,ht);
-	    				//TA1neu ist smaller als T. Einfügen in retVec
+	    				//TA1neu ist smaller als T. Einf<EFBFBD>gen in retVec
 	    				if(!retVec.contains(TA1neu))
 	    					retVec.add(TA1neu);
 	    			}
@@ -3627,12 +3471,12 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     }
     
     /**
-     * Gibt True zurück, wenn T eine FreshWildcard ist, oder im Falle eines RefTypes oder WildcardTypes eine FreshWildcard enthält.
+     * Gibt True zur<EFBFBD>ck, wenn T eine FreshWildcard ist, oder im Falle eines RefTypes oder WildcardTypes eine FreshWildcard enth<EFBFBD>lt.
      */
     private static boolean DelFreshWildcardTypeVar(Type T)
     {
     	//luar 29-05-2007
-    	//Überprüft rekursiv ob in dem RefType ein FreshWildcardType enthalten ist.
+    	//<EFBFBD>berpr<EFBFBD>ft rekursiv ob in dem RefType ein FreshWildcardType enthalten ist.
     	if(T instanceof RefType)
     	{
     		RefType refT = (RefType)T;
@@ -3641,7 +3485,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     				if(DelFreshWildcardTypeVar(t))
     					return true;
     	}
-    	//Im Falle einer Wildcard, Typen aus der WC rausnehmen und diesen rekursiv prüfen.
+    	//Im Falle einer Wildcard, Typen aus der WC rausnehmen und diesen rekursiv pr<EFBFBD>fen.
     	if(T instanceof ExtendsWildcardType)
     		return DelFreshWildcardTypeVar(((ExtendsWildcardType)T).get_ExtendsType());
     	
@@ -3650,13 +3494,15 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	
     	return T instanceof FreshWildcardType;
     }
-    
+
     public static <A extends DeepCloneable> Menge<A> deepClone(Menge<A> m){
-    	Timewatch watch = Timewatch.getTimewatch();
-    	Timestamp timer = watch.start("Unify - deepClone");
-    	Menge<A> ret = m.stream().<A>map((Function<A,A>)(x -> x.deepClone())).<Menge<A>>collect(Menge::new, Menge::add, Menge::addAll);
-    	timer.stop();
-    	return ret;
+        Timewatch watch = Timewatch.getTimewatch();
+        Timestamp timer = watch.start("Unify - deepClone");
+        Menge<A> ret = m.stream().<A>map((Function<A,A>)(x -> x.deepClone())).<Menge<A>>collect(Menge::new, Menge::add, Menge::addAll);
+        timer.stop();
+        return ret;
     }
+
+    
 }
 // ino.end

test/bytecode/ASTBytecodeTest.java

@@ -0,0 +1,95 @@
+package bytecode;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.apache.commons.bcel6.classfile.JavaClass;
+
+import de.dhbwstuttgart.bytecode.ClassGenerator;
+import de.dhbwstuttgart.core.MyCompiler;
+import de.dhbwstuttgart.core.MyCompilerAPI;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
+
+public abstract class ASTBytecodeTest {	
+	protected Class getClassToTest(){
+		Class classToTest = null;
+	    try {
+			ClassLoader classLoader = getClassLoader();
+
+		    classToTest =  classLoader.loadClass(getTestName());
+		    
+
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	    
+	    return classToTest;
+	}
+	
+	protected ClassLoader getClassLoader() throws Exception{
+		File file = new File(getRootDirectory());
+	    URL url = file.toURL();
+	    URL[] urls = new URL[]{url};
+
+	    return new URLClassLoader(urls);
+	}
+	
+	public  ASTBytecodeTest(){
+		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
+		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
+		try {
+			TypeinferenceResults results = getResults();
+			Menge<SourceFile> sourceFiles = new Menge<>();
+			sourceFiles.add(getSourceFile());
+			
+			Menge<ByteCodeResult> bytecode = compiler.generateBytecode(sourceFiles, results);
+			
+			ByteCodeResult result = bytecode.firstElement();
+			
+			String rootDirectory = getRootDirectory();
+			
+			JavaClass javaClass = result.getByteCode().getJavaClass();
+			javaClass.dump(new File(rootDirectory+javaClass.getClassName()+".class"));			
+			
+			for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){
+				JavaClass jc = cg.getJavaClass();
+				jc.dump(new File(rootDirectory+jc.getClassName()+".class"));
+			}
+			
+		}catch(Exception e){
+			System.out.print(e.getMessage());
+			throw new RuntimeException(e);
+		}	
+	}
+
+	public SourceFile getSourceFile() {
+		return new SourceFile();
+	}
+
+	public TypeinferenceResults getResults() {
+		Menge<TypeinferenceResultSet> results = new Menge<>();
+		results.add(new TypeinferenceResultSet(getSourceFile().KlassenVektor.get(0), new Menge(), new ResultSet()));
+		
+		return new TypeinferenceResults(results);
+	}
+
+	public String getRootDirectory() {
+		return System.getProperty("user.dir")+"/test/bytecode/";
+	}
+
+	public String getTestName() {
+		return "No Testname defined!";
+	}
+	
+	
+	
+	
+}

test/bytecode/Binary.jav

@@ -0,0 +1,10 @@
+class Binary{
+
+void method() {
+a;
+a = 20;
+b;
+b=59 + a;
+}
+
+}

test/bytecode/Binary2.jav

@@ -0,0 +1,8 @@
+
+class Binary2 {
+
+	Integer m(Integer x) { return x + x; }
+	
+ 	Boolean m(Boolean x) {return x || x; }
+	
+}

test/bytecode/BinaryTest.java

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

test/bytecode/BinaryTest2.java

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

test/bytecode/Main.jav

@@ -0,0 +1,6 @@
+class Main{
+
+public static void main(String[] args){
+}
+
+}

test/bytecode/MainTest.java

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

test/bytecode/NewClass.jav

@@ -0,0 +1,7 @@
+class NewClass{
+	String method() {
+		String a;
+		a = new String();
+		return a;
+	}
+}

test/bytecode/NewClassTest.java

@@ -0,0 +1,61 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URL;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import plugindevelopment.TypeInsertTester;
+import de.dhbwstuttgart.core.MyCompiler;
+import de.dhbwstuttgart.core.MyCompilerAPI;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
+
+public class NewClassTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "NewClass";
+	}
+
+	@Test
+	public void testInit() throws Exception {
+		ClassLoader cl = getClassLoader();
+		
+		cl.loadClass(testName).newInstance();
+	}
+	
+	@Test
+	public void testMethod() throws Exception {
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
+			Object obj = cls.newInstance();
+			
+			File file = new File(rootDirectory);
+		    URL url = file.toURL();
+		    URL[] urls = new URL[]{url};
+
+			
+			Class[] params = new Class[0];
+				
+			Method method = cls.getDeclaredMethod("method", params);
+			Object returnValue = method.invoke(obj);
+			assertTrue(returnValue instanceof String);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+}

test/bytecode/NewStatement.jav

@@ -0,0 +1,10 @@
+class NewStatement{
+public NewStatement(Integer i){}
+public NewStatement(String i){}
+method() {
+	NewStatement n;
+	n = new NewStatement("hallo");
+	n = new NewStatement(1);
+}
+
+}

test/bytecode/NewStatementTest.java

@@ -0,0 +1,55 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import plugindevelopment.TypeInsertTester;
+import de.dhbwstuttgart.core.MyCompiler;
+import de.dhbwstuttgart.core.MyCompilerAPI;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
+
+public class NewStatementTest {
+	
+	public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
+	public final static String testFile = "NewStatement.jav";
+	public final static String outputFile = "NewStatement.class";
+	
+	@Test
+	public void test() {
+		SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory);
+	}
+	@Test
+	public void testUntypedVectorDeclaredMethods() {
+		try{			
+			File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/");
+		    URL url = file.toURL();
+		    URL[] urls = new URL[]{url};
+
+		    ClassLoader classLoader = new URLClassLoader(urls);
+
+		    Class untypedVectorTest =  classLoader.loadClass("UntypedVector");
+			
+			for(Method method: untypedVectorTest.getDeclaredMethods()){
+				System.out.println(method.toGenericString());
+			}
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+	
+}

test/bytecode/SingleClassTester.java

@@ -2,12 +2,14 @@ package bytecode;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Map;
 
 import org.apache.commons.bcel6.classfile.JavaClass;
 
 import com.google.common.io.Files;
 
 import junit.framework.TestCase;
+import de.dhbwstuttgart.bytecode.ClassGenerator;
 import de.dhbwstuttgart.core.MyCompiler;
 import de.dhbwstuttgart.core.MyCompilerAPI;
 import de.dhbwstuttgart.logger.Logger;
@@ -15,8 +17,10 @@ import de.dhbwstuttgart.logger.LoggerConfiguration;
 import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.logger.Timewatch;
 import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.ByteCodeResult;
 import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
 
 public class SingleClassTester {
 	
@@ -24,24 +28,36 @@ public class SingleClassTester {
 		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			compiler.parse(new File(inputFile));
-			Menge<Menge<ByteCodeResult>> bytecode = compiler.generateBytecode(compiler.typeReconstruction().firstElement());
+			SourceFile sf = compiler.parse(new File(inputFile));
+			
+			Menge<SourceFile> sourceFiles = new Menge<>();
+			sourceFiles.add(sf);
+			
+			TypeinferenceResults results =  new TypeinferenceResults(compiler.typeReconstruction(sourceFiles));
+			
+			Menge<ByteCodeResult> bytecode = compiler.generateBytecode(sourceFiles, results);
 			//System.out.println(bytecode);
 			
-			for(ByteCodeResult result: bytecode.firstElement()){
-				JavaClass javaClass = result.getByteCode().getJavaClass();
-				
-				Logger.getLogger("SingleClassTester").error(result.getByteCode().getJavaClass().toString(), Section.CODEGEN);
-				
-				javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class"));
+			ByteCodeResult result = bytecode.firstElement();
+			
+			JavaClass javaClass = result.getByteCode().getJavaClass();
+			javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class"));
+			
+			for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){
+				JavaClass jc = cg.getJavaClass();
+				jc.dump(new File(outputDirectory+jc.getClassName()+".class"));
 			}
 			
+			Logger.getLogger("SingleClassTester").error(result.getByteCode().getJavaClass().toString(), Section.CODEGEN);
+			
+			
+			
 		} catch (IOException | yyException e) {
 			Logger.getLogger("SingleClassTester").error(e.toString(), Section.CODEGEN);
 			e.printStackTrace();
 			TestCase.fail();
 		}finally{
-			writeLog(outputDirectory+".log");
+			writeLog(outputDirectory+"bytecode.log");
 		}
 	}
 	

test/bytecode/SourceFileBytecodeTest.java

@@ -13,14 +13,14 @@ import junit.framework.TestCase;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-public abstract class BytecodeTest extends TestCase{
+public abstract class SourceFileBytecodeTest extends TestCase{
 	public String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
 	public String testFile;
 	public String outputDirectory;
 	
 	protected String testName;
 	
-	public BytecodeTest(){
+	public SourceFileBytecodeTest(){
 		init();
 		
 		if(testName != null){
@@ -39,11 +39,7 @@ public abstract class BytecodeTest extends TestCase{
 	protected Class getClassToTest(){
 		Class classToTest = null;
 	    try {
-			File file = new File(rootDirectory);
-		    URL url = file.toURL();
-		    URL[] urls = new URL[]{url};
-
-		    ClassLoader classLoader = new URLClassLoader(urls);
+			ClassLoader classLoader = getClassLoader();
 
 		    classToTest =  classLoader.loadClass(testName);
 		    
@@ -54,4 +50,12 @@ public abstract class BytecodeTest extends TestCase{
 	    
 	    return classToTest;
 	}
+	
+	protected ClassLoader getClassLoader() throws Exception{
+		File file = new File(rootDirectory);
+	    URL url = file.toURL();
+	    URL[] urls = new URL[]{url};
+
+	    return new URLClassLoader(urls);
+	}
 }

test/bytecode/Test2.java

@@ -0,0 +1,6 @@
+class Test2{
+
+	public static void main(java.lang.String[] args){
+		new NewStatement(1).method();
+}
+}

test/bytecode/types/AutoOverloading.jav

@@ -0,0 +1,17 @@
+import java.util.Vector;
+
+class AutoOverloading{
+
+        methode(v, x){
+          v.add(x);
+        }
+        
+        methode(v, x){
+          v.add(x);
+        }
+
+        methode(){
+                methode(new Vector<String>(),"hallo");
+                methode(new Vector<Integer>(), 1);
+        }
+}

test/bytecode/types/AutoOverloadingTest.java

@@ -0,0 +1,32 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+
+public class AutoOverloadingTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "AutoOverloading";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+	
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+}

test/bytecode/types/ExtendsObject.jav

@@ -1,3 +0,0 @@
-class ExtendsObject extends Object{
-
-}

test/bytecode/types/ExtendsObjectTest.java

@@ -2,39 +2,37 @@ package bytecode.types;
 
 import static org.junit.Assert.*;
 
-import java.io.File;
-import java.io.IOException;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.Vector;
-
-import junit.framework.TestCase;
 
+import org.junit.BeforeClass;
 import org.junit.Test;
 
-import bytecode.BytecodeTest;
-import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.core.MyCompiler;
-import de.dhbwstuttgart.core.MyCompilerAPI;
-import de.dhbwstuttgart.logger.LoggerConfiguration;
-import de.dhbwstuttgart.logger.Section;
-import de.dhbwstuttgart.parser.JavaParser.yyException;
-import de.dhbwstuttgart.typeinference.ByteCodeResult;
-import de.dhbwstuttgart.typeinference.Menge;
-import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
-import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
+import bytecode.ASTBytecodeTest;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 
-public class ExtendsObjectTest extends BytecodeTest{
-	@Override
-	protected void init() {
-		testName = "ExtendsObject";
-		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+
+public class ExtendsObjectTest extends ASTBytecodeTest{	
+	public SourceFile getSourceFile(){
+		/*
+		class ExtendsObject extends Object{
+
+		}
+		 */
+		SourceFile sourceFile = new SourceFile();
+		de.dhbwstuttgart.syntaxtree.Class classToTest = ASTFactory.createClass(getTestName(), null, null, null, sourceFile);
+		sourceFile.addElement(classToTest);
+		return sourceFile;
 	}
 	
 	@Test
 	public void testConstruct(){
 		try{
-			Class cls = getClassToTest();
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			Object obj = cls.newInstance();
 				
 			Constructor method = cls.getConstructor(new Class[]{});
 			method.newInstance();
@@ -44,5 +42,31 @@ public class ExtendsObjectTest extends BytecodeTest{
 			fail();
 		}
 	}
+	
+	@Test
+	public void testSupertype(){
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			assertEquals("java.lang.Object", cls.getSuperclass().getName());
+		}catch(Exception e){
+			e.printStackTrace();
+			fail();
+		}
+	}
+	
+	@Override
+	public String getRootDirectory() {
+		return super.getRootDirectory()+"types/";
+	}
+
+
+
+	@Override
+	public String getTestName() {
+		return "ExtendsObjectTest";
+	}
 
 }

test/bytecode/types/ExtendsType.jav

@@ -0,0 +1,13 @@
+import java.util.Vector;
+
+class SuperType{
+	Vector<Integer> integerVector;
+
+	void method() {
+		method(integerVector);
+	}
+	
+	void method(Vector<? extends Number> v) {
+		
+	}
+}

test/bytecode/types/ExtendsTypeTest.java

@@ -0,0 +1,31 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+
+public class ExtendsTypeTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "SuperType";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+}

test/bytecode/types/ExtendsVector.jav

@@ -1,5 +0,0 @@
-import java.util.Vector;
-
-class ExtendsVector extends Vector<Object>{
-
-}

test/bytecode/types/ExtendsVectorString.jav

@@ -1,5 +0,0 @@
-import java.util.Vector;
-
-class ExtendsVectorString extends Vector<String>{
-
-}

test/bytecode/types/ExtendsVectorStringTest.java

@@ -2,47 +2,86 @@ package bytecode.types;
 
 import static org.junit.Assert.*;
 
-import java.io.File;
-import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
-import java.util.Vector;
-
-import junit.framework.TestCase;
 
+import org.junit.BeforeClass;
 import org.junit.Test;
 
-import bytecode.BytecodeTest;
-import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.core.MyCompiler;
-import de.dhbwstuttgart.core.MyCompilerAPI;
-import de.dhbwstuttgart.logger.LoggerConfiguration;
-import de.dhbwstuttgart.logger.Section;
-import de.dhbwstuttgart.parser.JavaParser.yyException;
-import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import bytecode.ASTBytecodeTest;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.Type;
 import de.dhbwstuttgart.typeinference.Menge;
-import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
-import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
 
-public class ExtendsVectorStringTest extends BytecodeTest{	
-	@Override
-	protected void init() {
-		testName = "ExtendsVectorString";
-		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+
+public class ExtendsVectorStringTest extends ASTBytecodeTest{
+	
+	public SourceFile getSourceFile(){
+		/*
+		import java.util.Vector;
+
+		class ExtendsVector extends Vector<String>{
+		
+		}
+		 */
+		SourceFile sourceFile = new SourceFile();
+		
+		Menge<Type> parameter = new Menge<>();
+		parameter.add(new RefType("java.lang.String", sourceFile, 0));
+		
+		de.dhbwstuttgart.syntaxtree.Class classToTest = ASTFactory.createClass(getTestName(), new RefType("java.util.Vector", parameter, sourceFile, 0), null, null, sourceFile);
+		sourceFile.addElement(classToTest);
+		
+		return sourceFile;
 	}
 	
 	@Test
-	public void testConstruct(){
+	public void testSupertype(){
 		try{
-			Class cls = getClassToTest();
-				
-			Constructor method = cls.getConstructor(new Class[]{});
-			method.newInstance();
-			assertTrue(true);
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			assertEquals("java.util.Vector", cls.getSuperclass().getName());
 		}catch(Exception e){
 			e.printStackTrace();
 			fail();
 		}
 	}
+	
+	@Test
+	public void testParameter(){
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			Object obj = cls.newInstance();
+
+		    Class stringClass =  classLoader.loadClass("java.lang.Object");
+			
+			Class[] params = new Class[1];
+			params[0] = stringClass;
+				
+			Method method = cls.getDeclaredMethod("add", params);
+			method.invoke(obj, stringClass.newInstance());
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+	
+	@Override
+	public String getRootDirectory() {
+		return super.getRootDirectory()+"types/";
+	}
+
+
+
+	@Override
+	public String getTestName() {
+		return "ExtendsVectorString";
+	}
 
 }

test/bytecode/types/ExtendsVectorTest.java

@@ -2,47 +2,58 @@ package bytecode.types;
 
 import static org.junit.Assert.*;
 
-import java.io.File;
-import java.io.IOException;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.Vector;
-
-import junit.framework.TestCase;
 
+import org.junit.BeforeClass;
 import org.junit.Test;
 
-import bytecode.BytecodeTest;
-import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.core.MyCompiler;
-import de.dhbwstuttgart.core.MyCompilerAPI;
-import de.dhbwstuttgart.logger.LoggerConfiguration;
-import de.dhbwstuttgart.logger.Section;
-import de.dhbwstuttgart.parser.JavaParser.yyException;
-import de.dhbwstuttgart.typeinference.ByteCodeResult;
-import de.dhbwstuttgart.typeinference.Menge;
-import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
-import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
+import bytecode.ASTBytecodeTest;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 
-public class ExtendsVectorTest extends BytecodeTest{
-	@Override
-	protected void init() {
-		testName = "ExtendsVector";
-		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+
+public class ExtendsVectorTest extends ASTBytecodeTest{	
+	public SourceFile getSourceFile(){
+		/*
+		import java.util.Vector;
+
+		class ExtendsVector extends Vector<Object>{
+		
+		}
+		 */
+		SourceFile sourceFile = new SourceFile();
+		
+		de.dhbwstuttgart.syntaxtree.Class classToTest = ASTFactory.createClass(getTestName(), new RefType("java.util.Vector", sourceFile, 0), null, null, sourceFile);
+		sourceFile.addElement(classToTest);
+		
+		return sourceFile;
 	}
 	
 	@Test
-	public void testConstruct(){
+	public void testSupertype(){
 		try{
-			Class cls = getClassToTest();
-				
-			Constructor method = cls.getConstructor(new Class[]{});
-			method.newInstance();
-			assertTrue(true);
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			assertEquals("java.util.Vector", cls.getSuperclass().getName());
 		}catch(Exception e){
 			e.printStackTrace();
 			fail();
 		}
 	}
+	
+	@Override
+	public String getRootDirectory() {
+		return super.getRootDirectory()+"types/";
+	}
+
+
+
+	@Override
+	public String getTestName() {
+		return "ExtendsVector";
+	}
 
 }

test/bytecode/types/LocalVariableStringVector.jav

@@ -0,0 +1,7 @@
+import java.util.Vector;
+
+class LocalVariableStringVector{
+	void method() {
+		Vector<String> vector;
+	}
+}

test/bytecode/types/LocalVariableStringVectorTest.java

@@ -0,0 +1,39 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+
+public class LocalVariableStringVectorTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "LocalVariableStringVector";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+	
+	
+	
+	@Test
+	public void testCompiler() {
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
+			Object obj = cls.newInstance();
+
+			assertTrue(true);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+
+}

test/bytecode/types/LocalVariableVector.jav

@@ -0,0 +1,7 @@
+import java.util.Vector;
+
+class LocalVariableVector{
+	void method() {
+		Vector vector;
+	}
+}

test/bytecode/types/LocalVariableVectorTest.java

@@ -0,0 +1,38 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+
+public class LocalVariableVectorTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "LocalVariableVector";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+	
+	
+	
+	@Test
+	public void testCompiler() {
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
+			Object obj = cls.newInstance();
+
+			assertTrue(true);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+}

test/bytecode/types/MethodWithTypedVector.jav

@@ -1,6 +1,6 @@
 import java.util.Vector;
 
-class TypedVector{
+class MethodWithTypedVector{
 	public void method(Vector<String> v) {
 
 	}

test/bytecode/types/MethodWithTypedVectorTest.java

@@ -2,40 +2,44 @@ package bytecode.types;
 
 import static org.junit.Assert.*;
 
+import java.io.File;
 import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
 import java.util.Stack;
 import java.util.Vector;
 
 import org.junit.Test;
 
-import bytecode.BytecodeTest;
+import bytecode.SourceFileBytecodeTest;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.logger.Section;
 
-public class TypedVectorTest extends BytecodeTest{
+public class MethodWithTypedVectorTest extends SourceFileBytecodeTest{
 	@Override
 	protected void init() {
-		testName = "TypedVector";
+		testName = "MethodWithTypedVector";
 		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
 	}
 	
 	@Test
 	public void test() {
 		try{
-			Class cls = getClassToTest();
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
 			Object obj = cls.newInstance();
-			
-			Vector<String> stringVector = new Vector<String>();
+
+		    Class stringVector =  classLoader.loadClass("java%util%Vector%%java%lang%String%");
 			
 			Class[] params = new Class[1];
-			params[0] = stringVector.getClass();
+			params[0] = stringVector;
 				
 			Method method = cls.getDeclaredMethod("method", params);
-			method.invoke(obj, stringVector);
-			assertTrue(true);
+			method.invoke(obj, stringVector.newInstance());
 		}catch(Exception e){
-			Logger.getLogger("SingleClassTester").error(e.toString(), Section.CODEGEN);
-			fail();
+			throw new RuntimeException(e);
 		}
 	}
 }

test/bytecode/types/MethodWithUntypedVector.jav

@@ -0,0 +1,7 @@
+import java.util.Vector;
+
+class MethodWithUntypedVector{
+	public void method(Vector v) {
+
+	}
+}

test/bytecode/types/MethodWithUntypedVectorTest.java

@@ -0,0 +1,68 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Stack;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+import de.dhbwstuttgart.logger.Logger;
+import de.dhbwstuttgart.logger.Section;
+
+public class MethodWithUntypedVectorTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "MethodWithUntypedVector";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+	
+	@Test
+	public void testObjectVector() {
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
+			Object obj = cls.newInstance();
+			
+			File file = new File(rootDirectory);
+		    URL url = file.toURL();
+		    URL[] urls = new URL[]{url};
+		    
+		    Object object = new Object();
+			
+			Class[] params = new Class[1];
+			params[0] = object.getClass();
+				
+			Method method = cls.getDeclaredMethod("method", params);
+			method.invoke(obj, object);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+	
+	@Test
+	public void testGenericClass() {
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class untypedVectorTest =  classLoader.loadClass(testName);
+
+		    Class stringVector =  classLoader.loadClass("java%util%Vector%%java%lang%Object%");
+			
+			Class[] params = new Class[1];
+			params[0] = stringVector;
+				
+			Method method = untypedVectorTest.getDeclaredMethod("method", params);
+			method.invoke(untypedVectorTest.newInstance(), stringVector.newInstance());
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+}

test/bytecode/types/OverloadingAddition.jav

@@ -0,0 +1,5 @@
+class OverloadingAddition{
+        methode(a){
+          return a+a;
+        }
+}

test/bytecode/types/OverloadingAdditionTest.java

@@ -0,0 +1,32 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+
+public class OverloadingAdditionTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "OverloadingAddition";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+	
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+}

test/bytecode/types/OverloadingAdditionTest2.java

@@ -0,0 +1,211 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.omg.CORBA.TypeCodeHolder;
+
+import bytecode.ASTBytecodeTest;
+import bytecode.SourceFileBytecodeTest;
+import de.dhbwstuttgart.bytecode.TypePlaceholderType;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.misc.DeclId;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.Expr;
+import de.dhbwstuttgart.syntaxtree.statement.IntLiteral;
+import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.Type;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.Pair;
+import de.dhbwstuttgart.typeinference.ResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.TypeinferenceResults;
+
+public class OverloadingAdditionTest2 extends ASTBytecodeTest{	
+	public SourceFile getSourceFile(){
+		/*
+		class OverloadingAddition{
+		        methode(a){
+		          return a+a;
+		        }
+		}
+		 */
+		SourceFile sourceFile = new SourceFile();
+		de.dhbwstuttgart.syntaxtree.Class classToTest = ASTFactory.createClass(getTestName(), null, null, null, sourceFile);
+		
+		ParameterList parameterList = new ParameterList();
+		
+		System.out.println("Type");
+		
+		Type type = new RefType("java.lang.Integer", parameterList, 0);
+		//Type type = TypePlaceholder.getInstance("OverloadingAdditionTestTypePlaceholder_A");
+		
+		System.out.println("type: "+type.toString());
+		
+		DeclId declId = new DeclId("a");
+		declId.set_Paratyp(new Menge());	
+		
+		FormalParameter formalParameter = new FormalParameter(declId);
+		formalParameter.setType(type);
+		
+		parameterList.set_AddParameter(formalParameter);
+		
+		IntLiteral additionExpression = new IntLiteral();
+		additionExpression.set_Int(2);
+		
+		Return returnStatment = new Return(0, 0);
+		returnStatment.set_ReturnExpr(additionExpression);
+		returnStatment.setReturnType(type);
+		
+		Menge<Statement> statements = new Menge<>();
+		statements.add(returnStatment);
+		
+		Block block = new Block();
+		block.set_Statement_Menge(statements);
+		block.setType(type);
+		
+		de.dhbwstuttgart.syntaxtree.Method method = ASTFactory.createMethod("method", parameterList, block, classToTest);
+		method.setType(type);
+
+		classToTest.addField(method);
+		sourceFile.addElement(classToTest);
+		
+		return sourceFile;
+	}
+	
+	
+	
+	@Override
+	public String getRootDirectory() {
+		return super.getRootDirectory()+"types/";
+	}
+
+
+
+	@Override
+	public String getTestName() {
+		return "OverloadingAddition";
+	}
+
+
+
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(getTestName());
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+	
+	@Test
+	public void testMethodWithInteger(){
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			Object obj = cls.newInstance();
+
+		    Integer param = new Integer(1);
+			
+			Class[] params = new Class[1];
+			params[0] = param.getClass();
+				
+			Method method = cls.getDeclaredMethod("method", params);
+			Object result = method.invoke(obj, param);
+			
+			assertEquals(2, (Integer) result);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+	
+	@Test
+	public void testMethodWithDouble(){
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			Object obj = cls.newInstance();
+
+			Double param = new Double(1.5);
+			
+			Class[] params = new Class[1];
+			params[0] = param.getClass();
+				
+			Method method = cls.getDeclaredMethod("method", params);
+			Object result = method.invoke(obj, param);
+			
+			assertEquals(3.0, (Double) result);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+	
+	@Test
+	public void testMethodWithString(){
+		try{
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(getTestName());
+		    
+			Object obj = cls.newInstance();
+
+			String param = new String("abc");
+			
+			Class[] params = new Class[1];
+			params[0] = param.getClass();
+				
+			Method method = cls.getDeclaredMethod("method", params);
+			Object result = method.invoke(obj, param);
+			
+			assertEquals("abcabc", (String) result);
+		}catch(Exception e){
+			throw new RuntimeException(e);
+		}
+	}
+	
+	/*
+	public TypeinferenceResults getResults() {
+		String[] types = {
+				"java.lang.Integer",
+				"java.lang.Double",
+				"java.lang.String"
+		};
+		
+		Menge<TypeinferenceResultSet> results = new Menge<>();
+		
+		for(String typeString: types){
+			ParameterList parameterList = new ParameterList();
+			
+			
+			Type type = new RefType(typeString, parameterList, 0);
+			
+			Menge<Pair> pairs = new Menge<>();
+			pairs.add(new Pair(TypePlaceholder.fresh("OverloadingAdditionTestTypePlaceholder_A", getSourceFile().KlassenVektor.get(0)), type));
+			
+			
+			results.add(new TypeinferenceResultSet(getSourceFile().KlassenVektor.get(0), pairs, new ResultSet(pairs)));
+		}
+		
+		return new TypeinferenceResults(results);
+	}
+	*/
+}

test/bytecode/types/OverloadingTest.java

@@ -2,57 +2,69 @@ package bytecode.types;
 
 import static org.junit.Assert.*;
 
+import java.io.File;
 import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
 import java.util.Vector;
 
 import org.junit.Test;
 
-import bytecode.BytecodeTest;
+import bytecode.SourceFileBytecodeTest;
 
-public class OverloadingTest extends BytecodeTest{
+public class OverloadingTest extends SourceFileBytecodeTest{
 	@Override
 	protected void init() {
 		testName = "Overloading";
 		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
 	}
 	
+	
 	@Test
 	public void testString() {
 		try{
-			Class cls = getClassToTest();
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
 			Object obj = cls.newInstance();
 			
-			Vector<String> stringVector = new Vector<String>();
+			File file = new File(rootDirectory);
+		    URL url = file.toURL();
+		    URL[] urls = new URL[]{url};
+
+		    Class stringVector =  classLoader.loadClass("java%util%Vector%%java%lang%String%");
 			
 			Class[] params = new Class[1];
-			params[0] = stringVector.getClass();
+			params[0] = stringVector;
 				
 			Method method = cls.getDeclaredMethod("method", params);
-			method.invoke(obj, stringVector);
+			method.invoke(obj, stringVector.newInstance());
 			assertTrue(true);
 		}catch(Exception e){
-			e.printStackTrace();
-			fail();
+			throw new RuntimeException(e);
 		}
 	}
 	
 	@Test
 	public void testInteger() {
 		try{
-			Class cls = getClassToTest();
+		    ClassLoader classLoader = getClassLoader();
+
+		    Class cls =  classLoader.loadClass(testName);
+		    
 			Object obj = cls.newInstance();
-			
-			Vector<Integer> stringVector = new Vector<Integer>();
+
+		    Class integerVector =  classLoader.loadClass("java%util%Vector%%java%lang%Integer%");
 			
 			Class[] params = new Class[1];
-			params[0] = stringVector.getClass();
+			params[0] = integerVector;
 				
 			Method method = cls.getDeclaredMethod("method", params);
-			method.invoke(obj, stringVector);
+			method.invoke(obj, integerVector.newInstance());
 			assertTrue(true);
 		}catch(Exception e){
-			e.printStackTrace();
-			fail();
+			throw new RuntimeException(e);
 		}
 	}
 

test/bytecode/types/SuperType.jav

@@ -0,0 +1,13 @@
+import java.util.Vector;
+
+class SuperType{
+	Vector<Number> numberVector;
+
+	void method() {
+		method(numberVector);
+	}
+	
+	void method(Vector<? super Integer> v) {
+		
+	}
+}

test/bytecode/types/SuperType.java

@@ -0,0 +1,32 @@
+package bytecode.types;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import bytecode.SourceFileBytecodeTest;
+
+public class SuperType extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "ExtendsType";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
+	}
+	
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+}

test/plugindevelopment/TypeInsertTests/LambdaTest1.jav

@@ -1,3 +1,4 @@
+
 class LambdaTest{
 
 String var;
@@ -7,4 +8,4 @@ op = () -> (f) -> {
 	return var;
 };
 
-}
+}

test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java

@@ -14,6 +14,7 @@ import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.logger.SectionLogger;
 import de.dhbwstuttgart.logger.Timewatch;
 import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
@@ -46,8 +47,10 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
 		
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
+			SourceFile parsedFile = compiler.parse(new File(rootDirectory + sourceFileToInfere));
+			Menge<SourceFile> parsedFiles = new Menge<>();
+			parsedFiles.add(parsedFile);
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction(parsedFiles);
 			System.out.println("Typinferenz ausgeführt!");
 			//TestCase.assertTrue("Es darf nicht mehr als eine Lösungsmöglichkeit geben und nicht "+results.size(), results.size()==1);
 			for(TypeinferenceResultSet result : results){
@@ -78,8 +81,9 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
 		String inferedSource = "";
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
+			Menge<SourceFile> parsedSource = new Menge<>();
+			parsedSource.add(compiler.parse(new File(rootDirectory + sourceFileToInfere)));
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction(parsedSource);
 			//TestCase.assertTrue("Es darf nicht mehr als eine Lösungsmöglichkeit geben und nicht "+results.size(), results.size()==1);
 			for(TypeinferenceResultSet result : results){
 				TypeInsertSet point = result.getTypeInsertionPoints();

test/unify/UnifyFilter.jav

@@ -1,16 +0,0 @@
-class Test{
-	void methode(){
-		var;
-		var.methode();
-		var.methode();
-	}
-}
-
-class Klasse1 {
-	void methode(){
-	}
-}
-class Klasse2 {
-	void methode(){
-	}
-}

test/unify/UnifyFilter.java

@@ -1,58 +0,0 @@
-package unify;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.io.UnsupportedEncodingException;
-
-import org.junit.Test;
-
-import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.core.MyCompiler;
-import de.dhbwstuttgart.core.MyCompilerAPI;
-import de.dhbwstuttgart.logger.Logger;
-import de.dhbwstuttgart.logger.LoggerConfiguration;
-import de.dhbwstuttgart.logger.Section;
-import de.dhbwstuttgart.parser.JavaParser.yyException;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.typeinference.Menge;
-import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
-import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
-import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
-
-public class UnifyFilter {
-	public final static String rootDirectory = System.getProperty("user.dir")+"/test/unify/";
-	
-	private final String testFile = "UnifyFilter.jav";
-	
-	@Test
-	public void test(){
-		MyCompilerAPI compiler = MyCompiler.getAPI(new LoggerConfiguration().setOutput(Section.UNIFY, System.out));
-		try {
-			compiler.parse(new File(this.rootDirectory+testFile));
-			Menge<TypeinferenceResultSet> ergebnis = compiler.typeReconstruction();
-			//Nichts weiter unternehmen. Nur die Ausgabe des Unifikationsalgorithmus anzeigen.
-			String log = Logger.getWholeLog();
-			//System.out.println(log);
-			
-			writeLogFile(log);
-		} catch (Exception e){
-			e.printStackTrace();
-		}
-	}
-	
-	private void writeLogFile(String log){
-		try {
-			PrintWriter writer = new PrintWriter(rootDirectory+testFile+".log", "UTF-8");
-			writer.write(log);
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (UnsupportedEncodingException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		
-	}
-}

test/unify/UnifyTest.java

@@ -0,0 +1,304 @@
+package unify;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.syntaxtree.factory.UnifyPairMengenBuilder;
+import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+import de.dhbwstuttgart.syntaxtree.factory.Unify_FC_TTO_Builder;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.Pair;
+import de.dhbwstuttgart.typeinference.Pair.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.Unify;
+
+public class UnifyTest {
+
+	@Test
+	public void unifyTestSimpleTypes() {
+
+		// Init Factories and Builders
+		UnifyTypeFactory typeFactory = new UnifyTypeFactory();
+		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
+		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
+		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();
+
+		/*
+		 * Test a <. Boolean
+		 */
+
+		// Init Types
+		RefType boolT = typeFactory.GetSimpleType("java.lang.Boolean");
+		TypePlaceholder aTph = typeFactory.GetTypePlaceholder("a");
+
+		// Expected Result
+		resultBuilder.clear();
+		resultBuilder.addPair(aTph, boolT, PairOperator.Equal);
+		resultBuilder.addPair(aTph, typeFactory.GetExtendsType(boolT),
+				PairOperator.Equal);
+		Menge<Menge<Pair>> expectedResult = resultBuilder.getNestedPairMenge();
+
+		// Actual Result
+		assumptionBuilder.clear();
+		assumptionBuilder.addPair(aTph, boolT);
+		Menge<Menge<Pair>> actualResult = Unify.unify(
+				assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
+
+		// System.out.println(expectedResult);
+		// System.out.println(actualResult);
+
+		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
+
+		/*
+		 * Test b <. a, a <. Boolean
+		 */
+
+		// Init Types
+		boolT = typeFactory.GetSimpleType("java.lang.Boolean");
+		aTph = typeFactory.GetTypePlaceholder("a");
+		TypePlaceholder bTph = typeFactory.GetTypePlaceholder("b");
+
+		// Expected Result
+		resultBuilder.clear();
+		resultBuilder.addPair(aTph, boolT, PairOperator.Equal);
+		resultBuilder.addPair(aTph, typeFactory.GetExtendsType(boolT),
+				PairOperator.Equal);
+		resultBuilder.addPair(bTph, boolT, PairOperator.Equal);
+		resultBuilder.addPair(bTph, typeFactory.GetExtendsType(boolT),
+				PairOperator.Equal);
+		expectedResult = resultBuilder.getNestedPairMenge();
+
+		// Actual Result
+		assumptionBuilder.clear();
+		assumptionBuilder.addPair(bTph, aTph);
+		assumptionBuilder.addPair(aTph, boolT);
+		actualResult = Unify.unify(assumptionBuilder.getPairMenge(),
+				fcBuilder.Get_FC_TTO());
+
+		// System.out.println(expectedResult);
+		// System.out.println(actualResult);
+
+		// NOTE: Elemente im actualResult sind nicht unique
+		// Assert.assertTrue(mengeEquals(expectedResult, actualResult));
+
+		/*
+		 * Test b <. a, a <. b
+		 */
+
+		aTph = typeFactory.GetTypePlaceholder("a");
+		bTph = typeFactory.GetTypePlaceholder("b");
+
+		// Expected Result
+		resultBuilder.clear();
+		resultBuilder.addPair(bTph, aTph);
+		resultBuilder.addPair(aTph, bTph);
+
+		Menge<Pair> buffer = resultBuilder.getPairMenge();
+		expectedResult = new Menge<Menge<Pair>>();
+		expectedResult.add(buffer);
+
+		// Actual Result
+		assumptionBuilder.clear();
+		assumptionBuilder.addPair(bTph, aTph);
+		assumptionBuilder.addPair(aTph, bTph);
+		actualResult = Unify.unify(assumptionBuilder.getPairMenge(),
+				fcBuilder.Get_FC_TTO());
+
+		// System.out.println(expectedResult);
+		// System.out.println(actualResult);
+
+		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
+
+		/*
+		 * Test Integer <. a, a <. Boolean
+		 */
+
+		RefType intT = typeFactory.GetSimpleType("java.lang.Integer");
+		boolT = typeFactory.GetSimpleType("java.lang.Boolean");
+		aTph = typeFactory.GetTypePlaceholder("a");
+		bTph = typeFactory.GetTypePlaceholder("b");
+
+		// Expected Result
+		resultBuilder.clear();
+		expectedResult = resultBuilder.getNestedPairMenge();
+
+		// Actual Result
+		assumptionBuilder.clear();
+		assumptionBuilder.addPair(intT, aTph);
+		assumptionBuilder.addPair(aTph, boolT);
+		actualResult = Unify.unify(assumptionBuilder.getPairMenge(),
+				fcBuilder.Get_FC_TTO());
+
+		// System.out.println(expectedResult);
+		// System.out.println(actualResult);
+
+		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
+
+	}
+
+	@Test
+	public void unifyTestGenerics() {
+
+		// Init Factories and Builders
+		UnifyTypeFactory typeFactory = new UnifyTypeFactory();
+		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
+		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
+		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();
+
+		/*
+		 * Test a <. MyClass<T, F>
+		 */
+
+		TypePlaceholder aTph = typeFactory.GetTypePlaceholder("a");
+		RefType myType = typeFactory.GetSimpleType("MyClass",
+				typeFactory.GetTypePlaceholder("T"),
+				typeFactory.GetTypePlaceholder("F"));
+
+		// Expected Result
+		resultBuilder.clear();
+		resultBuilder.addPair(aTph, myType, PairOperator.Equal);
+		resultBuilder.addPair(aTph, typeFactory.GetExtendsType(myType));
+		Menge<Menge<Pair>> expectedResult = resultBuilder.getNestedPairMenge();
+
+		// Actual Result
+		assumptionBuilder.clear();
+		assumptionBuilder.addPair(aTph, myType);
+		Menge<Menge<Pair>> actualResult = Unify.unify(
+				assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
+
+		// System.out.println(expectedResult);
+		// System.out.println(actualResult);
+
+		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
+
+		/*
+		 * Test List<List<T>> <. List<T>
+		 */
+
+		TypePlaceholder tTph = typeFactory.GetTypePlaceholder("T");
+		RefType list = typeFactory.GetSimpleType("List", tTph);
+		RefType listlist = typeFactory.GetSimpleType("List", list);
+
+		// Expected Result
+		resultBuilder.clear();
+		resultBuilder.addPair(typeFactory.GetExtendsType(list), tTph,
+				PairOperator.Equal);
+		expectedResult = resultBuilder.getNestedPairMenge();
+
+		// Actual Result
+		assumptionBuilder.clear();
+		assumptionBuilder.addPair(listlist, list);
+		actualResult = Unify.unify(assumptionBuilder.getPairMenge(),
+				fcBuilder.Get_FC_TTO());
+
+		System.out.println(expectedResult);
+		System.out.println(actualResult);
+
+		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
+
+		/*
+		 * Test List<T> <. List<List<T>>
+		 */
+	}
+
+	@Test
+	public void unifyTestInheritance() {
+
+		// Init Factories and Builders
+		UnifyTypeFactory typeFactory = new UnifyTypeFactory();
+		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
+		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
+		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();
+
+		// Init Types
+		RefType tBool = typeFactory.GetSimpleType("java.lang.Boolean");
+		RefType tString = typeFactory.GetSimpleType("java.lang.String");
+		RefType tInt = typeFactory.GetSimpleType("java.lang.Integer");
+		TypePlaceholder tphA = typeFactory.GetTypePlaceholder("a");
+
+		// Build inheritance hierachy
+		// Bool <. String <. Int
+		fcBuilder.AddInheritance(tBool, tString);
+		fcBuilder.AddInheritance(tString, tInt);
+
+		// Build Assumptions
+		assumptionBuilder.addPair(tphA, tString);
+
+		// Build expected result
+		resultBuilder.addPair(tphA, tBool, PairOperator.Equal);
+		resultBuilder.addPair(tphA, typeFactory.GetExtendsType(tBool),
+				PairOperator.Equal);
+		resultBuilder.addPair(tphA, tString, PairOperator.Equal);
+		resultBuilder.addPair(tphA, typeFactory.GetExtendsType(tString),
+				PairOperator.Equal);
+
+		// Assert
+		Menge<Menge<Pair>> actualResult = Unify.unify(
+				assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
+
+		// System.out.println(actualResult);
+		// System.out.println("-------------------");
+		// System.out.println(resultBuilder.getNestedPairMenge());
+
+		Assert.assertTrue(mengeEquals(resultBuilder.getNestedPairMenge(),
+				actualResult));
+	}
+
+	@Test
+	public void unifyTestWildcards() {
+
+	}
+
+	private static boolean mengeEquals(Menge<Menge<Pair>> m1,
+			Menge<Menge<Pair>> m2) {
+		if (m1.size() != m2.size())
+			return false;
+
+		return containsAll(m1, m2) && containsAll(m2, m1);
+	}
+
+	private static boolean containsAll(Menge<Menge<Pair>> m1,
+			Menge<Menge<Pair>> m2) {
+		for (Menge<Pair> elem : m2)
+			if (!contains(m1, elem))
+				return false;
+		return true;
+	}
+
+	private static boolean contains(Menge<Menge<Pair>> m1, Menge<Pair> m2) {
+		for (Menge<Pair> elem : m1)
+			if (mengePairEquals(elem, m2))
+				return true;
+		return false;
+	}
+
+	private static boolean mengePairEquals(Menge<Pair> m1, Menge<Pair> m2) {
+		if (m1.size() != m2.size())
+			return false;
+
+		return containsAllPair(m1, m2) && containsAllPair(m2, m1);
+	}
+
+	private static boolean containsAllPair(Menge<Pair> m1, Menge<Pair> m2) {
+		for (Pair elem : m1)
+			if (contains(m2, elem))
+				return true;
+		return false;
+	}
+
+	private static boolean contains(Menge<Pair> m, Pair p) {
+		for (Pair elem : m)
+			if (pairEquals(elem, p))
+				return true;
+		return false;
+
+	}
+
+	private static boolean pairEquals(Pair p1, Pair p2) {
+		return (p1.TA1.equals(p2.TA1) && p1.TA2.equals(p2.TA2))
+				|| (p1.TA1.equals(p2.TA2) && p1.TA2.equals(p2.TA1));
+	}
+
+}