Merge branch 'bytecode' into unifyDev

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,7 +32,6 @@ 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

@@ -0,0 +1,70 @@
+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

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

BCEL/bcelifier/NewClassCreator.java

@@ -1,60 +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 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", "This.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+    _cg = new ClassGen("bcelifier.This", "java.lang.Object", "<Unknown>", ACC_PUBLIC | ACC_SUPER, new String[] {  });
 
     _cp = _cg.getConstantPool();
     _factory = new InstructionFactory(_cg, _cp);

notizen/stf/Notes

@@ -1,16 +0,0 @@
-- 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,8 +1,6 @@
 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;
@@ -20,24 +18,22 @@ 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 TypeinferenceResults tiResult;
+	private TypeinferenceResultSet 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 accessflags, String[] strings, TypeinferenceResults typeinferenceResults) {
+	public ClassGenerator(String name, Type superClass, String string,
-		super(name,superClass.get_Name(),string,accessflags,strings, new DHBWConstantPoolGen());
+			short accPublic, String[] strings, TypeinferenceResultSet resultSet) {
-		this.tiResult = typeinferenceResults;
+		super(name,superClass.get_Name(),string,accPublic,strings, new DHBWConstantPoolGen());
+		this.tiResult = resultSet;
 		this.superClass = superClass;
 		
 		cp = (DHBWConstantPoolGen) super.getConstantPool();
@@ -55,7 +51,8 @@ public class ClassGenerator extends ClassGen{
 	 * @param toTPH
 	 * @return Es gilt dann "toTPH extends Type"
 	 */
-	public org.apache.commons.bcel6.generic.Type getNearestUsedType(Type t, Menge<TypePlaceholder> usedTypes){
+	public org.apache.commons.bcel6.generic.Type getNearestUsedType(TypePlaceholder toTPH, Menge<TypePlaceholder> usedTypes){
+		Type t = resolveTPH(toTPH, usedTypes);
 		if(t == null){
 			return this.getInstructionFactory().createObjectType();
 		}else if(t instanceof TypePlaceholder){ //Es muss sich in diesem Fall um einen TPH handeln:
@@ -69,12 +66,12 @@ public class ClassGenerator extends ClassGen{
 		return this.getNearestUsedType(toTPH, null);
 	}
 	
-	public Type resolveTPH(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex) {
+	public Type resolveTPH(TypePlaceholder typePlaceholder) {
-		return resolveTPH(typePlaceholder, typeinferenceResultSetIndex, null);
+		return resolveTPH(typePlaceholder, null);
 	}
 	
-	public Type resolveTPH(TypePlaceholder typePlaceholder, Integer typeinferenceResultSetIndex, Menge<TypePlaceholder> toOneOfTheseTypes) {
+	public Type resolveTPH(TypePlaceholder typePlaceholder, Menge<TypePlaceholder> toOneOfTheseTypes) {
-		return tiResult.getTypeOfPlaceholder(typePlaceholder, typeinferenceResultSetIndex, toOneOfTheseTypes);
+		return tiResult.getTypeOfPlaceholder(typePlaceholder, toOneOfTheseTypes);
 	}
 
 	public String createLambdaMethodName() {
@@ -159,18 +156,4 @@ 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,7 +7,6 @@ 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;
@@ -35,13 +34,13 @@ public class ConsoleInterface {
             /////////////////////////
             // Parsen:
             /////////////////////////
-        	Menge<SourceFile> sourceFiles = compiler.parse(filenames);
+            compiler.parse(filenames);
 
             /////////////////////////
             // Typrekonstruktion:
             /////////////////////////
             try{
-            	resultSet = compiler.typeReconstruction(sourceFiles);
+            	resultSet = compiler.typeReconstruction();
             }catch(TypeinferenceException texc){
             	texc.printStackTrace();
             	fail("Fehler bei Typinferenzalgorithmus. Message: "+texc.getMessage());

src/de/dhbwstuttgart/core/MyCompiler.java

@@ -1,6 +1,9 @@
-
+// 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;
@@ -39,35 +42,73 @@ 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;
 
 
-public class MyCompiler implements MyCompilerAPI{
+
+// 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
     // 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
      */
-    private MyCompiler(){
+    // ino.end
+    // ino.method.MyCompiler.21283.definition 
+    private MyCompiler()
+    // ino.end
+    // ino.method.MyCompiler.21283.body 
+    {
         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.
@@ -75,11 +116,116 @@ public class MyCompiler implements MyCompilerAPI{
      * um eine Quellcode-Datei zu kompilieren.
      * @return Die Compiler-API
      */
-    public static MyCompilerAPI getAPI(LoggerConfiguration loggerConfig){
+    // ino.end
+    // ino.method.getAPI.21286.definition 
+    public static MyCompilerAPI getAPI(LoggerConfiguration loggerConfig)
+    // ino.end
+    // ino.method.getAPI.21286.body 
+    {
     	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                       
@@ -90,19 +236,246 @@ public class MyCompiler implements MyCompilerAPI{
      * @throws IOException
      * @throws JavaParser.yyException
      */
-    private void parse_backup(Reader reader) throws IOException, 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
+    
 /////////////////////////////////////////////////////////////////////////////////////////////////   
 //   Implementierte API-Methoden:
 /////////////////////////////////////////////////////////////////////////////////////////////////
+    // ino.method.init.21295.defdescription type=javadoc
     /**
      * Author: J�rg B�uerle<br/>
      * Initialisiert den Compiler
      */
-    public void init(){
+    // ino.end
+    // ino.method.init.21295.definition 
+    public void init()
+    // ino.end
+    // ino.method.init.21295.body 
+    {
         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.
@@ -111,13 +484,22 @@ public class MyCompiler implements MyCompilerAPI{
      * @throws IOException Wenn was schief l�uft.
      * @throws JavaParser.yyException Wenn ein Fehler beim Parsen auftritt.
      */
-    public SourceFile parse(File file) throws FileNotFoundException, IOException, JavaParser.yyException{
+    // ino.end
+    // ino.method.parse.21298.definition 
+    public SourceFile parse(File file)
+    throws FileNotFoundException, IOException, JavaParser.yyException
+    // ino.end
+    // ino.method.parse.21298.body 
+    {
         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.
@@ -126,7 +508,16 @@ public class MyCompiler implements MyCompilerAPI{
      * ist. @throws CTypeReconstructionException Wenn ein Fehler bei der               
      * Typrekonstruktion auftritt. 
      */
-    public Menge<TypeinferenceResultSet> typeReconstruction(Menge<SourceFile> m_AbstractSyntaxTree) throws NullPointerException, CTypeReconstructionException{
+    // 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!");
+        }
         inferencelog.info("##########################################", Section.TYPEINFERENCE);
         inferencelog.info("# TypeReconstruction-Algorithmus - START #", Section.TYPEINFERENCE);
         inferencelog.info("##########################################\n", Section.TYPEINFERENCE);
@@ -144,6 +535,7 @@ public class MyCompiler implements MyCompilerAPI{
         
         return result;
     }
+    // ino.end
 
     /**
      * Erstellt die FunN-Assumptions
@@ -167,13 +559,45 @@ 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
      */
-    public static void main(String[] args){
+    // ino.end
+    // ino.method.main.21313.definition 
+    public static void main(String[] args)
+    // ino.end
+    // ino.method.main.21313.body 
+    {
         MyCompilerAPI compiler = MyCompiler.getAPI(new LoggerConfiguration());
         
         // Hier koennten ggf. Aenderungen der Ausgabeeinstellungen
@@ -193,9 +617,33 @@ 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
 
-    public void setOutputDir(String dir){
+    // ino.method.setOutputDir.21316.definition 
+    public void setOutputDir(String dir)
+    // ino.end
+    // ino.method.setOutputDir.21316.body 
+    {
         char c = dir.charAt(dir.length()-1);
         if (c != '/' & c != '\\') dir = dir + "/";
         OutputDir = dir;
@@ -204,11 +652,75 @@ public class MyCompiler implements MyCompilerAPI{
         File f = new File(dir);
         f.mkdirs();
     }
+    // ino.end
 
-    public String getOutputDir(){
+    // ino.method.getOutputDir.21319.definition 
+    public String getOutputDir()
+    // ino.end
+    // ino.method.getOutputDir.21319.body 
+    {
         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.
@@ -278,10 +790,8 @@ public class MyCompiler implements MyCompilerAPI{
     
     /**
      * Diese Funktion nimmt einen Menge von Dateinamen. Alle diese Dateien werden zu einem SyntaxBaum geparst.
-     * @return 
      */
-    public Menge<SourceFile> parse(Menge<String> filenames) throws ParserError {
+    public void parse(Menge<String> filenames) throws ParserError {
-    	Menge<SourceFile> m_AbstractSyntaxTree = new Menge<SourceFile>();
 		
 		for(String filename : filenames){
 				StringBuffer fileData = new StringBuffer();
@@ -306,25 +816,58 @@ public class MyCompiler implements MyCompilerAPI{
 
 		        StringReader srcreader = new StringReader(fileData.toString());
 		        //Den aus der Datei ausgelesenen Quellcode zu einem Syntaxbaum parsen:
-		        m_AbstractSyntaxTree.add(parse2SyntaxTree(srcreader)); // Alle Dateien nacheinander hintereinander anhängen...
+		        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.");
+			}
 		}
 		
-		return m_AbstractSyntaxTree;
+		try {
+			// und anschließend zum Parsen übergeben.
+			this.parse(gesamterSrc.toString());
+		} catch (Exception e) {
+			e.printStackTrace();
+			//throw new TypinferenzException("Fehler beim Parsen");
+		}
+		
+	*/
 	}
 
 	@Override
 	public SourceFile parse(String sourceCode) {
-		return parse2SyntaxTree(new StringReader(sourceCode));
+		SourceFile ret = this.parse2SyntaxTree(new StringReader(sourceCode));
+		this.m_AbstractSyntaxTree.add(ret);
+		return ret;
 	}
 
 	@Override
-	public Menge<ByteCodeResult> generateBytecode(Menge<SourceFile> m_AbstractSyntaxTree, TypeinferenceResults typeinferenceResults) {
+	public Menge<Menge<ByteCodeResult>> generateBytecode(TypeinferenceResultSet typeinferenceResult) {
 		//SourceFile parsedFile = this.m_AbstractSyntaxTree.firstElement();
 		//Class parsedClass = parsedFile.KlassenVektor.firstElement();
-		Menge<ByteCodeResult> ret = new Menge<>();
+		Menge<Menge<ByteCodeResult>> ret = new Menge<>();
-		for(SourceFile sf : m_AbstractSyntaxTree){
+		for(SourceFile sf : this.m_AbstractSyntaxTree){
-			ret.addAll(sf.generateBytecode(typeinferenceResults));
+			ret.addAll(sf.generateBytecode(typeinferenceResult));
 		}
 		return ret;
 	}
 }
+// ino.end

src/de/dhbwstuttgart/core/MyCompilerAPI.java

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

src/de/dhbwstuttgart/parser/JavaClassName.java

@@ -18,7 +18,6 @@ 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,8 +8,6 @@ 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;
@@ -26,10 +24,8 @@ 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;
@@ -78,7 +74,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
      * @param resultSet - Fehlende Typen im Syntaxbaum werden nach diesem ResultSet aufgelöst
      * @return
      */
-    public ByteCodeResult genByteCode(TypeinferenceResults typeinferenceResults) {
+    public Menge<ByteCodeResult> genByteCode(TypeinferenceResultSet resultSet) {
     	InstructionFactory _factory;
         DHBWConstantPoolGen    _cp;
         ClassGenerator     _cg;
@@ -89,8 +85,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     	logger.debug("Test");
     	
     	if(pkgName != null)throw new NotImplementedException();
-    	short constants = Constants.ACC_PUBLIC; //Per Definition ist jede Methode public
+    	_cg = new ClassGenerator(name, this.getSuperClass(), name + ".java", Constants.ACC_PUBLIC , new String[] {  }, resultSet); //letzter Parameter sind implementierte Interfaces
-    	_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);
 
@@ -117,7 +112,12 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     		c.genByteCode(_cg, fieldInitializations);
     	}
     	
-	    return new ByteCodeResult(_cg);
+	    ByteCodeResult code = new ByteCodeResult(_cg);
+	    results.add(code);
+	    
+	    results.addAll(getGenericClasses(_cg));
+	    
+        return results;
     }
 
 	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") && !name.equals("java.lang.Object"))//Alle Klassen außer Object erben von Object:
+        if(!name.equals("Object"))//Alle Klassen außer Object erben von Object:
-        	this.superClass = new Class("java.lang.Object", -1).getType(); 
+        	this.superClass = new Class("Object", -1).getType(); 
     }
     // ino.end
     
@@ -240,30 +240,21 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
      * @param modifiers
      * @param supertypeGenPara - Eine Liste von Namen, welche die Generischen Parameter der Klasse darstellen.
      */
-    public Class(String name, Type superClass, Modifiers modifiers, Menge supertypeGenPara) {
+    public Class(String name, RefType superClass, Modifiers modifiers,
+    		Menge<String> supertypeGenPara) {
 		this(name,superClass,modifiers,0);
 		if(supertypeGenPara == null)return;
 		Menge<GenericTypeVar> gtvs = new Menge<>();
-		for(Object gname : supertypeGenPara){
+		for(String gname : supertypeGenPara){
-			if(gname instanceof String){
+			GenericTypeVar newGTV=new GenericTypeVar(gname,this,0);
-				GenericTypeVar newGTV=new GenericTypeVar((String)gname,this,0);
+			gtvs.add(newGTV);
-				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, Type superClass, Modifiers mod, int offset){
+    public Class(String name, RefType superClass, Modifiers mod, int offset){
     	this(name,mod,offset);
-    	if(superClass == null)this.superClass = new Class("java.lang.Object",-1).getType();
+    	if(superClass == null)this.superClass = new Class("Object",-1).getType();
     	else this.superClass = superClass;
     }
     
@@ -1040,66 +1031,21 @@ 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<>();
 		
-		for(Field field : this.fielddecl){
+		//Super Klasse
-			Type type = field.getType();
+		String name = "java/util/Vectorjava/lang/String";	//getParentClass().getType().getBytecodeSignature(_cg);
-			//Der Type des Feldes
+		
-			if(type instanceof RefType){
+		Type superClass = new Class("java/util/Vector",-1).getType();
-				RefType refType = (RefType) type;
+		
-				
+		_cg = new ClassGenerator(name, superClass, name + ".java", Constants.ACC_PUBLIC , new String[] {  }, new TypeinferenceResultSet(null, null, null));
-				if(!refType.getCombinedType(null).equals(refType.get_Name().replace(".", "%"))){
+    	
-					results.addAll(generateGenericClass(refType.getCombinedType(null), new Class("java/util/Vector",-1)));
+	    ByteCodeResult code = new ByteCodeResult(_cg);
-				}
+	    
-			}
+	    results.add(code);
-			
-			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().getBytecodeSignature(null);
+			ret += this.getType().getName() + " ";
 		}
 		return ret+this.getIdentifier();
 	}

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -30,7 +30,6 @@ 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;
@@ -62,6 +61,474 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 // ino.end
 // ino.class.Method.23482.body
 {
+<<<<<<< HEAD
+    // ino.attribute.block.23488.declaration 
+    private Block         block;
+    // ino.end
+    // ino.attribute.parameterlist.23491.declaration 
+    public ParameterList parameterlist = new ParameterList();
+    // ino.end
+    // ino.attribute.exceptionlist.23494.declaration 
+    private ExceptionList exceptionlist;
+    // ino.end
+    // ino.attribute.returntype.23497.declaration 
+    private Type          returntype;
+    // ino.end
+    
+    // ino.attribute.genericMethodParameters.23500.decldescription type=javadoc
+    /**
+     * HOTI 4.5.06
+     * Dieser Vektor beinhaltet alle Generischen Typen und v.a. die
+     * F-Bounded-Generics, die die Methode besitzt
+     * size()==0, falls es keine gibt
+     */
+    // ino.end
+    // ino.attribute.genericMethodParameters.23500.declaration 
+    //private Vector<GenericTypeVar> genericMethodParameters=new Vector<GenericTypeVar>();
+    // ino.end
+    
+    // ino.attribute.overloadedID.23503.declaration 
+    private int           overloadedID;
+    // ino.end
+    // ino.attribute.isAbstract.23506.declaration 
+    private boolean isAbstract = false;
+    // ino.end
+    // ino.attribute.types_in_parameterlist.23509.declaration 
+    private Vector<String>        types_in_parameterlist = new Vector<String>();
+    // ino.end
+    // ino.attribute.m_LineNumber.23512.declaration 
+    private int m_LineNumber = MyCompiler.NO_LINENUMBER;
+    // ino.end
+    private int m_Offset = -1; //hinzugef<65>gt hoth: 07.04.2006
+    // ino.attribute.inferencelog.23515.declaration 
+    protected static Logger inferencelog = Logger.getLogger("inference");
+    // ino.end
+    // ino.attribute.parserlog.23518.declaration 
+    protected static Logger parserlog = Logger.getLogger("parser");
+    // ino.end
+    
+    public Method(int offset){
+    	super(offset);
+    }
+    
+    /*
+    // ino.method.setGenericMethodParameters.23521.definition 
+    public void setGenericMethodParameters(Vector<GenericTypeVar> genericMethodParameters)
+    // ino.end
+    // ino.method.setGenericMethodParameters.23521.body 
+    {
+        this.genericMethodParameters=genericMethodParameters;
+    }
+    // ino.end
+    // ino.method.getGenericMethodParameters.23524.definition 
+    public Vector<GenericTypeVar> getGenericMethodParameters()
+    // ino.end
+    // ino.method.getGenericMethodParameters.23524.body 
+    {
+        return(genericMethodParameters);
+    }
+    // ino.end
+    */
+    /*
+    // ino.method.sc_init_parameterlist.23530.definition 
+    public void sc_init_parameterlist(boolean ext)
+    // ino.end
+    // ino.method.sc_init_parameterlist.23530.body 
+    {
+        DeclId hilf=null;
+        Vector<FormalParameter> list;
+        FormalParameter para;
+        String typeofpara;
+        int i=1;
+        if(this.getParameterList()!=null) //es gibt Parameter, dann:
+        {
+        hilf=declid.elementAt(0);
+        if(ext)
+            parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" bergabewerte gefunden:"); 
+        list=this.getParameterList().sc_get_Formalparalist();  //Vector Formalparalist aus FormalParameterList wird zwischen gesichert
+        for(Enumeration<FormalParameter> el2=list.elements(); el2.hasMoreElements();)
+        {
+            para=el2.nextElement();
+            typeofpara=para.getTypeName();
+            if(ext)
+                parserlog.debug("       "+i+". Parameter hat Typ "+typeofpara);
+            types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden im Vector abgelegt
+            i++;
+        }
+        }
+        else //keine Parameter vorhanden:
+        {
+        if(ext)
+        {
+            hilf=declid.elementAt(0);
+            parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" keine bergabewerte gefunden.");
+        }
+        }
+        if(ext)
+        {
+            parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" "+ types_in_parameterlist.size()+" bergabeparameter gefunden."); 
+            parserlog.debug("             namentlich: "+types_in_parameterlist.toString());
+        }
+    }
+    // ino.end
+     */
+    // ino.method.getTypeName.23533.defdescription type=line
+    // Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die        
+    // get_ReturnType() auf eigene Gefahr lschen. 
+    // ino.end
+  
+    // ino.method.getTypeName.23533.definition 
+    public JavaClassName getTypeName()
+    // ino.end
+    // ino.method.getTypeName.23533.body 
+    {
+    if( this.getType() == null )
+        return null;
+    else
+        return this.getType().getName();
+    }
+    // ino.end
+
+    // ino.method.get_Block.23536.definition 
+    public Block get_Block()
+    // ino.end
+    // ino.method.get_Block.23536.body 
+    {
+    return block;
+    }
+    // ino.end
+ 
+    // ino.method.setReturnType.23539.defdescription type=javadoc
+    /**
+     * <br/>Author: Jrg Buerle
+     * @param type
+     */
+    // ino.end
+    // ino.method.setReturnType.23539.definition 
+    private void setReturnType(Type type)
+    // ino.end
+    // ino.method.setReturnType.23539.body 
+    {
+        this.returntype = type;
+    }
+    // ino.end
+
+    // ino.method.set_Block.23542.definition 
+    public void set_Block( Block blo)
+    // ino.end
+    // ino.method.set_Block.23542.body 
+    {
+    	if(blo.getType() == null)blo.setType(this.returntype);
+    	this.block = blo;
+    }
+    // ino.end
+
+    // ino.method.set_Modifiers.23545.definition 
+    public void set_Modifiers(Modifiers modif)
+    // ino.end
+    // ino.method.set_Modifiers.23545.body 
+    {
+    declid.firstElement().set_Modifiers(modif);
+        //  this.modi = modif;
+    }
+    // ino.end
+
+    // ino.method.set_ExceptionList.23548.definition 
+    public void set_ExceptionList(ExceptionList exlist)
+    // ino.end
+    // ino.method.set_ExceptionList.23548.body 
+    {
+    this.exceptionlist = exlist;
+    }
+    // ino.end
+
+    // ino.method.setParameterList.23551.definition 
+    public void setParameterList( ParameterList paralist )
+    // ino.end
+    // ino.method.setParameterList.23551.body 
+    { 
+        this.parameterlist = paralist;
+    }
+    // ino.end
+
+    // ino.method.getParameterList.23554.definition 
+    public ParameterList getParameterList( )
+    // ino.end
+    // ino.method.getParameterList.23554.body 
+    { 
+        // otth: gibt die Parameterliste zurueck
+        return this.parameterlist;
+    }
+    // ino.end
+    
+    // ino.method.getParameterCount.23557.defdescription type=javadoc
+    /**
+     * Author: Jrg Buerle<br/>
+     * @return Die Anzahl der Methoden-Paramater
+     */
+    // ino.end
+    // ino.method.getParameterCount.23557.definition 
+    public int getParameterCount()
+    // ino.end
+    // ino.method.getParameterCount.23557.body 
+    {
+        if(this.getParameterList() == null)
+            return 0;
+        else
+            return this.getParameterList().getParameterCount();
+    }
+    // ino.end
+
+    // ino.method.get_ExceptionList.23560.definition 
+    public ExceptionList get_ExceptionList()
+    // ino.end
+    // ino.method.get_ExceptionList.23560.body 
+    {
+        // otth: gibt die Exceptionliste zurueck
+        return this.exceptionlist;
+    }
+    // ino.end
+    
+    // ino.method.getOverloadedID.23563.definition 
+    public int getOverloadedID()
+    // ino.end
+    // ino.method.getOverloadedID.23563.body 
+    {
+        return(overloadedID);
+    }
+    // ino.end
+
+    // ino.method.setOverloadedID.23566.definition 
+    public void setOverloadedID(int overloadedID)
+    // ino.end
+    // ino.method.setOverloadedID.23566.body 
+    {
+        this.overloadedID=overloadedID;
+    }
+    // ino.end
+    
+
+    
+    
+    // ino.method.get_codegen_Param_Type.23572.definition 
+    public String get_codegen_Param_Type(Vector paralist)
+    // ino.end
+    // ino.method.get_codegen_Param_Type.23572.body 
+    {
+        String ret = new String();
+        if(this.getParameterList() == null)
+        {
+            ret += "()";
+        } 
+        else
+        {
+            ret += this.getParameterList().get_codegen_ParameterList(paralist);
+        }
+        if(this.getType() == null)
+        {
+            ret += "V";
+        } 
+        else
+        {
+            ret += this.getType().get_codegen_Type(paralist);
+        }
+        return ret;
+    }
+    // ino.end
+    
+    
+    
+    // ino.method.get_Method_Name.23575.definition 
+    public String get_Method_Name()
+    // ino.end
+    // ino.method.get_Method_Name.23575.body 
+    {
+        DeclId hilf=declid.elementAt(0);
+        return hilf.get_Name();
+    }
+    // ino.end
+
+    // ino.method.get_Type_Paralist.23578.definition 
+    public Vector get_Type_Paralist()
+    // ino.end
+    // ino.method.get_Type_Paralist.23578.body 
+    {
+        return types_in_parameterlist;
+    }
+    // ino.end
+    
+    
+    
+    // ino.method.codegen.23581.definition 
+    public void codegen(ClassFile classfile, Vector paralist)
+    throws JVMCodeException
+    // ino.end
+    // ino.method.codegen.23581.body 
+    {
+        classfile.add_method(declid.firstElement().get_Name(), this.get_codegen_Param_Type(paralist), this.getParameterList(), this.getType(), block, declid.firstElement().get_access_flags(), paralist, isAbstract);
+    }
+    // ino.end
+
+    // ino.method.getLineNumber.23584.definition 
+    public int getLineNumber()
+    // ino.end
+    // ino.method.getLineNumber.23584.body 
+    {
+        return m_LineNumber;
+    }
+    // ino.end
+    
+    // ino.method.setLineNumber.23587.definition 
+    public void setLineNumber(int lineNumber)
+    // ino.end
+    // ino.method.setLineNumber.23587.body 
+    {
+        m_LineNumber = lineNumber;
+    }
+    // ino.end
+    
+    // ino.method.getOffset.23590.defdescription type=line
+    // hinzugef<65>gt hoth: 07.04.2006
+    // ino.end
+    // ino.method.getOffset.23590.definition 
+    public int getOffset()
+    // ino.end
+    // ino.method.getOffset.23590.body 
+    {
+        return m_Offset;
+    }
+    // ino.end
+    
+    // ino.method.getVariableLength.23593.definition 
+    public int getVariableLength()
+    // ino.end
+    // ino.method.getVariableLength.23593.body 
+    {
+        return get_Method_Name().length();
+    }
+    // ino.end
+    
+   // ino.method.setOffset.23596.defdescription type=line
+   // hinzugef<65>gt hoth: 07.04.2006
+   // ino.end
+    // ino.method.setOffset.23596.definition 
+    public void setOffset(int Offset)
+    // ino.end
+    // ino.method.setOffset.23596.body 
+    {
+        m_Offset = Offset;
+    }
+    // ino.end
+
+    
+    // ino.method.getTypeLineNumber.23602.defdescription type=javadoc
+    /**
+     * <br>Author: Jrg Buerle
+     * @return
+     */
+    // ino.end
+    // ino.method.getTypeLineNumber.23602.definition 
+    public int getTypeLineNumber()
+    // ino.end
+    // ino.method.getTypeLineNumber.23602.body 
+    {
+        return this.getLineNumber();
+    }
+    // ino.end
+
+    // ino.method.toString.23605.defdescription type=javadoc
+    /**
+     * <br/>Author: Martin Pl<50>micke
+     * @return
+     */
+    // ino.end
+    // ino.method.toString.23605.definition 
+    public String toString()
+    // ino.end
+    // ino.method.toString.23605.body 
+    {
+        return this.getType() + " "+ this.get_Name() + parameterlist.toString() +( (block!=null)?block.toString():"");
+    }
+    // ino.end
+    
+    // ino.method.setAbstract.23608.defdescription type=javadoc
+    /**
+     * Legt fuer die ByteCodeGen fest, ob Bytecode
+     * innerhalb der Methode generiert wird.
+     */
+    // ino.end
+    // ino.method.setAbstract.23608.definition 
+    public void setAbstract(boolean b)
+    // ino.end
+    // ino.method.setAbstract.23608.body 
+    {
+        isAbstract = b;
+    }
+    // ino.end
+    
+    // ino.method.isAbstract.23611.defdescription type=javadoc
+    /**
+     * Gibt zurueck, ob ByteCode innerhabl der Methode
+     * generiert wird.
+     */
+    // ino.end
+    // ino.method.isAbstract.23611.definition 
+    public boolean isAbstract()
+    // ino.end
+    // ino.method.isAbstract.23611.body 
+    {
+        return isAbstract;
+    }
+    
+    @Override
+    public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> classParalist)
+    {
+    	/*
+    	Vector<Type> paralist = new Vector<Type>();//Mit den Generischen Typen der Methode
+    	paralist.addAll(classParalist);
+    	paralist.addAll(this.genericMethodParameters);
+    	
+        // Zuerst Returntype untersuchen
+        Type returnType=getType();
+        Type pendantReturnType = null;
+        if(returnType instanceof RefType)pendantReturnType = ((RefType)returnType).findGenericType(paralist, new Vector<GenericTypeVar>());
+        //GenericTypeVar pendantReturnType=ClassHelper.findGenericType(returnType, paralist,genericMethodParameters);
+        if(pendantReturnType!=null){    //Wenn generisch, dann modifizieren
+            setReturnType(pendantReturnType);
+        }                                       
+        
+        // Dann parameterlist untersuchen
+        for(int par=0;par<getParameterCount();par++){
+            FormalParameter fp=parameterlist.formalparameter.get(par);
+            Type fpType=fp.getType();
+            // Nur wenn es sich um ein RefType-Field handelt
+            Type pendantPara = null;
+            if(fpType instanceof RefType)pendantPara = ((RefType)fpType).findGenericType(paralist, new Vector<GenericTypeVar>());
+            //GenericTypeVar pendantPara=ClassHelper.findGenericType(fpType,paralist,genericMethodParameters);
+            if(pendantPara!=null){  //Wenn generisch, dann modifizieren
+                fp.setType(pendantPara);
+            }                       
+        }
+        
+        // Zuletzt alle Lokalen Variablendeklarationen durchgehen
+        if(block!=null){
+            block.wandleRefTypeAttributes2GenericAttributes(paralist,genericMethodParameters);
+        }
+        */
+    }
+    // ino.end
+    // ino.method.set_Method_Name.23617.definition 
+    public void set_Method_Name(String string)
+    // ino.end
+    // ino.method.set_Method_Name.23617.body 
+    {
+        declid.set(0,new DeclId(string));
+    }
+    // ino.end
+    
+   
+    
+=======
 	// ino.attribute.block.23488.declaration
 	private Block block;
 	// ino.end
@@ -100,7 +567,6 @@ 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
@@ -228,7 +694,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.method.set_Modifiers.23545.body
 	{
 		declid.firstElement().set_Modifiers(modif);
-		this.modifiers = modif;
+		// this.modi = modif;
 	}
 
 	// ino.end
@@ -423,7 +889,8 @@ 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
@@ -499,6 +966,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		declid.set(0, new DeclId(string));
 	}
 
+>>>>>>> refactoring
 	public ConstraintsSet TYPE(TypeAssumptions ass) {
 		ConstraintsSet ret = new ConstraintsSet();
 		TypeAssumptions localAss = new TypeAssumptions();
@@ -745,39 +1213,32 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	}
 
 	public void genByteCode(ClassGenerator cg) {
-		for(int t = 0; t < cg.getTypeinferenceResults().getTypeReconstructions().size(); t++){			
+		DHBWConstantPoolGen _cp = cg.getConstantPool();
-			DHBWConstantPoolGen _cp = cg.getConstantPool();
+		DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, _cp);
-			DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, _cp);
+		InstructionList il = new InstructionList();
-			InstructionList il = new InstructionList();
+		Class parentClass = this.getParentClass();
-			Class parentClass = this.getParentClass();
+	
-		
+		//Die Argumentliste generieren:
-			//Die Argumentliste generieren:
+		 org.apache.commons.bcel6.generic.Type[] argumentTypes =  org.apache.commons.bcel6.generic.Type.NO_ARGS;
-			 org.apache.commons.bcel6.generic.Type[] argumentTypes =  org.apache.commons.bcel6.generic.Type.NO_ARGS;
+		String[] argumentNames = new String[]{};
-			String[] argumentNames = new String[]{};
+		if(this.parameterlist != null &&
-			if(this.parameterlist != null &&
+				this.parameterlist.size() > 0){
-					this.parameterlist.size() > 0){
+			argumentTypes = new org.apache.commons.bcel6.generic.Type[this.parameterlist.size()];
-				argumentTypes = new org.apache.commons.bcel6.generic.Type[this.parameterlist.size()];
+			argumentNames = new String[this.parameterlist.size()];
-				argumentNames = new String[this.parameterlist.size()];
+			int i = 0;
-				int i = 0;
+			for(FormalParameter parameter : this.parameterlist){
-				for(FormalParameter parameter : this.parameterlist){
+				argumentTypes[i] = parameter.getType().getBytecodeType(cg);
-					if(parameter.getType() instanceof TypePlaceholder){
+				argumentNames[i] = parameter.getIdentifier();
-						argumentTypes[i] = ((TypePlaceholder) parameter.getType()).getBytecodeType(cg, t);
+				i++;
-					}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

@@ -37,10 +37,10 @@ import de.dhbwstuttgart.typeinference.ByteCodeResult;
 import de.dhbwstuttgart.typeinference.ConstraintsSet;
 import de.dhbwstuttgart.typeinference.FunNInterface;
 import de.dhbwstuttgart.typeinference.FunNMethod;
+import de.dhbwstuttgart.typeinference.KarthesischesProdukt;
 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;
@@ -51,7 +51,9 @@ import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.unify.FC_TTO;
 import de.dhbwstuttgart.typeinference.unify.Unifier;
 import de.dhbwstuttgart.typeinference.unify.Unify;
-
+import de.dhbwstuttgart.typeinference.OderConstraint;
+import de.dhbwstuttgart.typeinference.UndConstraint;
+import de.dhbwstuttgart.typeinference.SingleConstraint;
 
 
 
@@ -327,7 +329,6 @@ 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.
@@ -339,7 +340,6 @@ public class SourceFile
         	}else{
         		//System.out.println("Wurde nicht aufgenommen");
         	}
-        	}
         }
         
         for( int i = 0; i < KlassenVektor.size(); i++ )
@@ -659,6 +659,47 @@ public class SourceFile
     	return publicAssumptions;
     }
     
+    Vector<OderConstraint> divideOderConstraints(OderConstraint oc) {
+    	
+    	//Schritt 1: Variablen an Hand des 1. Elements der UndConstraints gruppieren
+    	//!!! KLAEREN OB ES PASSIEREN KANN, DASS IM 2., 3. , ... ELEMENT ANDERE VARIABLEN VORKOMMEN KOENNEN!!!
+    	//WENN JA, DANN MUESSEN DIE VARIABLEN UEBER ALLE ELEMENTE (NICHT NUR DAS 1.) AUFGESAMMELT WERDEN
+    	Vector<Pair> pairs = oc.getUndConstraints().elementAt(0).getSingleConstraints().stream()
+    			                                                .map(x -> x.getPair())
+    			                                                .collect(Vector::new, Vector::add, Vector::addAll);
+    	Vector<Vector<TypePlaceholder>> pairvars = pairs.stream().map(p -> {Vector<TypePlaceholder> TPHs = new Vector<>(); 
+        TPHs.addAll(p.TA1.getInvolvedTypePlaceholder());
+        TPHs.addAll(p.TA2.getInvolvedTypePlaceholder());
+        return TPHs;}
+        ).collect(Vector::new, Vector::add, Vector::addAll);
+    	
+    	//Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
+        //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden m<>ssen
+      	Vector<Vector<Integer>> indexeset1 = new Vector<>();
+      	if (pairvars != null && pairvars.size()>0) { 
+      		indexeset1 = Unify.schnitt(pairvars);
+      	}
+      	
+      	//Schritt 3
+      	//Aus den Indexmengen die UndConstraints als OderConstraint neu gruppieren
+      	java.util.function.BiFunction<UndConstraint,SingleConstraint,UndConstraint> accSC = (a,b) -> { a.addConstraint(b); return a;};
+      	java.util.function.BinaryOperator<UndConstraint> combUC = (a,b) -> { a.getUndConstraints().addAll(b.getUndConstraints()); return a;};
+      	
+      	Vector<OderConstraint> ret = new Vector<OderConstraint>();
+      	for (Vector<Integer> is : indexeset1) {
+      		Stream<Stream<SingleConstraint>> vs = oc.getUndConstraints().stream().map(x -> is.stream().map(i -> x.getSingleConstraints().elementAt(i)));//.collect(Vector::new, Vector::add, Vector::addAll);;
+      		//Vector<OderConstraint> us = vs.map(x -> x.reduce(new UndConstraint(), (a,b) -> { a.addConstraint((SingleConstraint)b); return a;}))
+      				//.collect(Vector::new, Vector::add, Vector::addAll);
+      		OderConstraint OCnew = vs.reduce(new OderConstraint(), 
+      				  (y,x) -> { y.addConstraint(x.reduce(new UndConstraint(), accSC, combUC)); return y;},
+      				  (a,b) -> { a.getUndConstraints().addAll(b.getUndConstraints()); return a;}		  
+      						  );
+      		ret.addElement(OCnew);	
+      	}
+      	return ret;
+    }
+    
+   
     /////////////////////////////////////////////////////////////////////////
     // TypeReconstructionAlgorithmus
     /////////////////////////////////////////////////////////////////////////
@@ -679,7 +720,11 @@ public class SourceFile
     // ino.end
 // ino.method.typeReconstruction.21406.body 
 {
+<<<<<<< HEAD
+    	//Vector<TypeinferenceResultSet> ret = new Vector<TypeinferenceResultSet>();
+=======
     	Menge<TypeinferenceResultSet> ret = new Menge<TypeinferenceResultSet>();
+>>>>>>> refactoring
     	
     	//Logger initialisieren:
     	Logger typinferenzLog = Logger.getLogger("Typeinference");
@@ -698,7 +743,7 @@ public class SourceFile
     	FC_TTO finiteClosure = this.makeFC(globalAssumptions);
     	
     	typinferenzLog.debug("FiniteClosure: \n"+finiteClosure, Section.TYPEINFERENCE);
-    	
+
     	ConstraintsSet oderConstraints = new ConstraintsSet();
     	//Alle Constraints der in dieser SourceFile enthaltenen Klassen sammeln:
         for(Class klasse : KlassenVektor){
@@ -714,6 +759,71 @@ public class SourceFile
         	Menge<Menge<Pair>> retValue = new Menge<>();
         	retValue = Unify.unify(pairs, finiteClosure);
         	return retValue;};
+<<<<<<< HEAD
+        oderConstraints.filterWrongConstraints(unifier);
+        //oderConstraints.unifyUndConstraints(unifier);
+        
+        java.util.function.BiFunction<Vector<OderConstraint>,OderConstraint,Vector<OderConstraint>> divideOC = 
+            (a,b) -> { 
+            	       if ((b instanceof  SingleConstraint) || (b instanceof  UndConstraint)) { a.addElement(b); }
+            		   else { a.addAll(divideOderConstraints(b)); } // (b instanceof  OderConstraint)
+                       return a;
+                     };
+        java.util.function.BinaryOperator<Vector<OderConstraint>> oderAll = (a,b) -> { a.addAll(b); return a;};
+            	
+            	
+        Vector<OderConstraint> vecoderConstraints = oderConstraints.getConstraintsSet().stream().reduce(new Vector<OderConstraint>(), divideOC, oderAll);
+        
+        ConstraintsSet devidedOderConstraints = new ConstraintsSet();
+        devidedOderConstraints.addAll(vecoderConstraints);
+        //HIER WEITERMACHEN: oderConstraints in devidedOderConstraints umaendern
+        //1. Schritt:
+        Stream<Vector<Pair>> streamOneExample = 
+        devidedOderConstraints.getConstraintsSet().stream().map(
+        (constr) -> constr.getOneExample()); //.reduce(Vector::new, Vector::addAll);    
+        Vector<Vector<Pair>> vecOneExample = streamOneExample.collect(Vector::new, Vector::add, Vector::addAll);  
+        
+        //2. Schritt
+        Stream<Vector<TypePlaceholder>> streamvars = vecOneExample.stream().map(x -> x.stream().map(
+        		p -> { Vector<TypePlaceholder> TPHs = new Vector<>(); 
+        		       TPHs.addAll(p.TA1.getInvolvedTypePlaceholder());
+        		       TPHs.addAll(p.TA2.getInvolvedTypePlaceholder());
+        		       return TPHs;}
+        		).reduce(new Vector<TypePlaceholder>(),(a, b) -> { for (TypePlaceholder ty : b ) { if (!a.contains(ty)) a.add(ty); } return a; })); 
+        
+        Vector<Vector<TypePlaceholder>> vecvars = streamvars.collect(Vector::new, Vector::add, Vector::addAll);  
+        
+        //Schritt 3: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
+        //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden m<>ssen
+      	Vector<Vector<Integer>> indexeset = new Vector<>();
+      	if (vecvars != null && vecvars.size()>0) { 
+      		indexeset = Unify.schnitt(vecvars);
+      	}
+      	
+      	//Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente
+      	//           In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen
+      	Stream<Vector<OderConstraint>> streamoderconstraints = indexeset.stream().map(x -> x.stream()
+      			                                                           .map(i -> devidedOderConstraints.getConstraintsSet().elementAt(i))
+      			                                                               .collect(Vector::new, Vector::add, Vector::addAll));
+      	Vector<Vector<OderConstraint>> vecconstraintsclone = streamoderconstraints.collect(Vector::new, Vector::add, Vector::addAll);
+      	Stream<ConstraintsSet> constraintsclone = vecconstraintsclone.stream().map(
+      			oderConstraintsSubset -> {
+      				ConstraintsSet ConsoderConstraintsSubset = new ConstraintsSet ();
+      				ConsoderConstraintsSubset.addAll(oderConstraintsSubset);
+      				System.out.println(oderConstraintsSubset);
+      				return ConsoderConstraintsSubset; }
+      	);
+      	//Vector<ConstraintsSet> xxx1 = constraintsclone.collect(Vector::new, Vector::add, Vector::addAll);
+      	Stream<Vector<TypeinferenceResultSet>> ressets = constraintsclone.map(constraintsSubset -> {
+        typinferenzLog.debug("<EFBFBD>briggebliebene Konstraints:\n"+devidedOderConstraints+"\n", Section.TYPEINFERENCE);
+        //Die Constraints in Pair's umwandeln (Karthesisches Produkt bilden):
+        Vector<TypeinferenceResultSet> ret = new Vector<TypeinferenceResultSet>();
+        Vector<Vector<Pair>> xConstraints = new Vector<Vector<Pair>>();// = devidedOderConstraints.getConstraints();
+        for(Vector<UndConstraint> uC : constraintsSubset.getConstraints()){ //mit dem getConstraints-Aufruf wird das Karthesische Produkt erzeugt.
+        	Vector<Pair> cons = new Vector<Pair>(); //HIER STIMMT ES NICHT constraintsSubset ein Element OderConstraint enthaelt vgl.  (TPH AGG <. java.lang.Integer), ]| [
+   	                                                //(TPH AGG <. java.lang.Long), ]| [
+   	                          	                    //(TPH AGG <. java.lang.Double), ]| ]], 
+=======
         //oderConstraints.filterWrongConstraints(unifier);
         oderConstraints.unifyUndConstraints(unifier);
         typinferenzLog.debug("Übriggebliebene Konstraints:\n"+oderConstraints+"\n", Section.TYPEINFERENCE);
@@ -722,6 +832,7 @@ public class SourceFile
         /*
         for(Menge<UndConstraint> uC : oderConstraints.getConstraints()){ //mit dem getConstraints-Aufruf wird das Karthesische Produkt erzeugt.
         	Menge<Pair> cons = new Menge<Pair>();
+>>>>>>> refactoring
         	for(UndConstraint undCons:uC){
         		cons.addAll(undCons.getConstraintPairs());
         	}
@@ -808,19 +919,32 @@ public class SourceFile
             ).collect(Menge::new, Menge::add, Menge::addAll);    	
 
           //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
+<<<<<<< HEAD
+          //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden m<>ssen
+        	Vector<Vector<Integer>> indexeset1 = new Vector<>();
+=======
           //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen
         	Menge<Menge<Integer>> indexeset = new Menge<>();
+>>>>>>> refactoring
         	if (constraintsclonevars != null && constraintsclonevars.size()>0) { 
-        		indexeset = Unify.schnitt(constraintsclonevars);
+        		indexeset1 = Unify.schnitt(constraintsclonevars);
         	}
         	
         	//Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente
         	//           In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen
+<<<<<<< HEAD
+        	Stream<Vector<Pair>> streamconstraintsclone = indexeset1.stream().map(x -> x.stream()
+        			                                                           .map(i -> constraintsClone.elementAt(i))
+        			                                                               .collect(Vector::new, Vector::add, Vector::addAll));
+//        	Vector<Vector<Pair>> vecconstraintsclone1 = streamconstraintsclone.collect(Vector::new, Vector::add, Vector::addAll);
+            
+=======
         	Stream<Menge<Pair>> streamconstraintsclone = indexeset.stream().map(x -> x.stream()
         			                                                           .map(i -> constraintsClone.elementAt(i))
         			                                                               .<Menge<Pair>>collect(Menge::new, Menge::add, Menge::addAll));
        	//Menge<Menge<Pair>> vecconstraintsclone = streamconstraintsclone.collect(Menge::new, Menge::add, Menge::addAll);
             System.out.println();
+>>>>>>> refactoring
         	//Schritt 4: Unifikation  
         	Menge<Menge<Menge<Pair>>> vecunifyResult =
         			//streamconstraintsclone.map(x -> Unify.unify(x, finiteClosure)).collect(Menge::new, Menge::add, Menge::addAll);
@@ -913,7 +1037,7 @@ public class SourceFile
 	        //typinferenzLog.debug(supportData.getFiniteClosure());
 	        //typinferenzLog.debug("Typinformationen: \n"+this.getTypeInformation(this.getMethodList(), fieldInitializers));
 	        
-	        typinferenzLog.debug("\nJavaFiles:\n", Section.TYPEINFERENCE);
+	        //typinferenzLog.debug("\nJavaFiles:\n", Section.TYPEINFERENCE);
 	        
 	        //typinferenzLog.debug(this.printJavaCode(new ResultSet(new Menge<Pair>())));
 	        
@@ -937,7 +1061,51 @@ public class SourceFile
         if(unifyFail){
         	if(!this.KlassenVektor.isEmpty())throw new TypeinferenceException("Fehler in Typinferierung", this.KlassenVektor.firstElement());   	
         }
-        return ret;
+        return ret;});
+      	Vector<Vector<TypeinferenceResultSet>> vecressets = ressets.collect(Vector::new, Vector::add, Vector::addAll);
+      	SourceFile.inferencelog.debug("vecressets:\n" + vecressets, Section.TYPEINFERENCE);
+      	//Vector<Integer> vecressets = ressets.map(x -> x.size()).collect(Vector::new, Vector::add, Vector::addAll);
+      	//Vector<Vector<TypeinferenceResultSet>> ret = new KarthesischesProdukt<TypeinferenceResultSet>().berechneKarthesischesProdukt(vecressets);
+      	
+      	Stream<Vector<Vector<Pair>>> ressetspairs = vecressets.stream().map(x -> x.stream().map(y -> y.getUnifiedConstraints().getResultSet())
+      			                                                                         .collect(Vector::new, Vector::add, Vector::addAll));
+      	
+      	      	
+        java.util.Comparator<Vector<Vector<Pair>>> comp = (x,y) -> { if (x.size() < y.size()) return -1;
+        else if (x.size() == y.size()) return 0;
+        else return 1;
+        };
+      	
+        //Vector<Integer> ressetspairs_size =  ressetspairs.sorted(comp).map(x -> x.size()).collect(Vector::new, Vector::add, Vector::addAll);
+
+        
+      	//cart. Produkt mit Linkverschiebung//FUNKTIONIERT NICHT WIRD ZU GROSS
+      	Vector<Vector<Pair>> cardprodret_start = new Vector<>();
+    	cardprodret_start.add(new Vector<Pair>());
+    	//Vector<Vector<Pair>> ret = ressetspairs.sorted(comp).reduce(cardprodret_start, (x, y) -> {
+        Vector<Vector<Pair>> ret = ressetspairs.reduce(cardprodret_start, (x, y) -> {
+    		Vector<Vector<Pair>> cardprodret= new Vector<>();
+    		if (y.size() > 0) {
+    			//System.out.println(y);
+    			//Vector<Vector<Pair>> cardprodretold = x;
+				//cardprodret = new Vector<>();
+				for(int j = 0; j < x.size(); j++) {
+					for (int k = 0; k < y.size(); k++){
+						Vector<Pair> help = new Vector<>(); 
+						help.addAll(y.elementAt(k));
+						help.addAll(x.elementAt(j));
+						cardprodret.add(help);
+					}
+				}
+    		}
+    		else{
+    			return new Vector<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []	
+    		}
+    		return cardprodret;
+    	});
+      	
+      	
+      	return new Vector<>();
         /*
         // HOTI: Nur zur Info.Ich habe den Loglevel auf Info geschaltet, damit
         // in der GUI (Eclipse-Plugin) die Console nicht zugemüllt wird.
@@ -1837,10 +2005,10 @@ public class SourceFile
 	 * Bisher wird nur der Bytecode der Klassen generiert. Nicht der Interfaces.
 	 * @return
 	 */
-	public Menge<ByteCodeResult> generateBytecode(TypeinferenceResults results) {
+	public Menge<Menge<ByteCodeResult>> generateBytecode(TypeinferenceResultSet rs) {
-		Menge<ByteCodeResult> ret = new Menge<>();
+		Menge<Menge<ByteCodeResult>> ret = new Menge<>();
 		for(Class cl : this.KlassenVektor){
-			ret.add(cl.genByteCode(results));
+			ret.add(cl.genByteCode(rs));
 		}
 		return ret;
 	}

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

@@ -1,74 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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,26 +1,39 @@
+// ino.module.ArgumentList.8621.package 
 package de.dhbwstuttgart.syntaxtree.statement;
-
+// ino.end
+// ino.module.ArgumentList.8621.import 
 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
@@ -80,22 +93,6 @@ 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,9 +214,6 @@ 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,13 +6,8 @@ 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;
@@ -60,7 +55,6 @@ 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");
@@ -135,7 +129,15 @@ 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);
@@ -145,9 +147,22 @@ 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;
 	}
 	
@@ -161,7 +176,6 @@ 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;
 	}
 
@@ -194,21 +208,8 @@ public class NewClass extends Expr
 
 	@Override
 	public InstructionList genByteCode(ClassGenerator _cg) {
-		InstructionList il = new InstructionList();
+		// TODO Bytecode
-		if(arglist!=null){
+		throw new NotImplementedException();
-			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

@@ -1,23 +0,0 @@
-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,19 +14,11 @@ 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;
@@ -610,13 +602,12 @@ 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;
         }
     }
@@ -823,56 +814,42 @@ public class RefType extends ObjectType implements IMatchable
 	}
 	
 	public   org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
-		org.apache.commons.bcel6.generic.ObjectType ret = new org.apache.commons.bcel6.generic.ObjectType(getCombinedType(cg));
+		return new org.apache.commons.bcel6.generic.ObjectType(this.get_Name());
-		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();
 		
-		if(parameter != null && parameter.size() > 0){
+		sb.append(getTypeName());
-			sb.append(getName().toString().replace(".", "%"));
+		
-			sb.append("%%");
+		if(parameter != null){
 			for(Type type: parameter){
-				if(type instanceof RefType){
+				sb.append(""); //TODO: einen geeignete Delemiter suchen
-					sb.append(((RefType) type).getCombinedType(cg).replace(".", "%"));
+				sb.append(type.getBytecodeSignature(cg));
-				}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();
-	}
+		*/
-	
+		
-	public GenericClassType getGenericClassType(){
+		String paramString = "";
-		return new GenericClassType(getName().toString(), getParaList(), parent, getOffset());
+		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+";";
 	}
 	
 }

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

@@ -437,15 +437,7 @@ public class TypePlaceholder extends ObjectType
 
 	@Override
 	public org.apache.commons.bcel6.generic.Type getBytecodeType(ClassGenerator cg) {
-		Type resolvedType = cg.resolveTPH(this, 0);
+		Type resolvedType = cg.resolveTPH(this);
-		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();
 		}
@@ -454,11 +446,7 @@ public class TypePlaceholder extends ObjectType
 	
 	@Override
 	public String getBytecodeSignature(ClassGenerator cg) {
-		return getBytecodeSignature(cg, 0);
+		Type resolvedType = cg.resolveTPH(this);
-	}
-	
-	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,26 +2,23 @@ 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 ClassGenerator byteCode;
+	private ClassGen byteCode;
 	//TODO: unresolvedTPHs entfernen. BROKEN!
 	private Menge<TypePlaceholder> unresolvedTPHs = new Menge<TypePlaceholder>();
 	
-	public ByteCodeResult(ClassGenerator byteCode){
+	public ByteCodeResult(ClassGen byteCode){
 		this.byteCode = byteCode;
 	}
 	
-	public ClassGenerator getByteCode(){
+	public ClassGen getByteCode(){
 		return byteCode;
 	}
 	

src/de/dhbwstuttgart/typeinference/ConstraintsSet.java

@@ -21,6 +21,14 @@ public class ConstraintsSet extends UndMenge<Pair> implements Iterable<OderConst
 	public void add(OderConstraint constraint){
 		constraintsSet.add(constraint);
 	}
+	
+	public void addAll(Vector<OderConstraint> vecconstraint){
+		constraintsSet.addAll(vecconstraint);
+	}
+	
+	public Vector<OderConstraint> getConstraintsSet() {
+			return constraintsSet;
+	}
 
 	@Override
 	public String toString(){

src/de/dhbwstuttgart/typeinference/KarthesischesProdukt.java

@@ -3,17 +3,30 @@ package de.dhbwstuttgart.typeinference;
 
 public abstract class KarthesischesProdukt {
 
+<<<<<<< HEAD
+	public Vector<Vector<M>> berechneKarthesischesProdukt(Vector<Vector<M>> m1){
+		if(m1.size()==0)return m1;
+		if(m1.size()==1){
+			Vector<Vector<M>> ret = new Vector<Vector<M>>();
+			for(M o : m1.firstElement()){
+				Vector<M> v = new Vector<M>();
+=======
 	public static <M> Menge<Menge<M>> berechneKarthesischesProdukt(Menge<Menge<M>> m1){
 		if(m1.size()==0)return m1;
 		if(m1.size()==1){
 			Menge<Menge<M>> ret = new Menge<Menge<M>>();
 			for(M o : m1.firstElement()){
 				Menge<M> v = new Menge<M>();
+>>>>>>> refactoring
 				v.add(o);
 				ret.add(v);
 			}
 			return ret;
+<<<<<<< HEAD
+			//return m1;//throw new TypinferenzException("m1 hat zu wenige Objekte f<>r ein Karthesisches Produkt. Es m<>ssen mindestens 2 sein.");
+=======
 			//return m1;//throw new TypinferenzException("m1 hat zu wenige Objekte für ein Karthesisches Produkt. Es müssen mindestens 2 sein.");
+>>>>>>> refactoring
 		}
 		return berechneKarthesischesProdukt(m1, null);
 	}

src/de/dhbwstuttgart/typeinference/OderConstraint.java

@@ -33,7 +33,18 @@ public class OderConstraint extends OderMenge<Pair>{
 	
 	
 	/**
+<<<<<<< HEAD
+	 * gibt ein Exemplar zur<75>ck um die Variablen zu bestimmen
+	 */
+	public Vector<Pair> getOneExample() {
+		return this.getUndConstraints().elementAt(0).getConstraintPairs();
+	}
+	
+	/**
+	 * Liefert alle in diesem OderConstraint enthaltene Constraints. Dabei gehen die Verkn<6B>pfungen (Oder/Und) verloren.
+=======
 	 * Liefert alle in diesem OderConstraint enthaltene Constraints. Dabei gehen die Verkn<6B>pfungen (Oder/Und) verloren.
+>>>>>>> refactoring
 	 * @return
 	 */
 	public Menge<Pair> getConstraintPairs(){
@@ -44,6 +55,8 @@ public class OderConstraint extends OderMenge<Pair>{
 		return ret;
 	}
 	
+	
+	
 	/**
 	 * F<>gt ein Pair(p1, p2) dem Constraint hinzu
 	 * @param p1
@@ -69,6 +82,17 @@ public class OderConstraint extends OderMenge<Pair>{
 		}
 		return ret+"]";
 	}
+	
+	public Vector<SingleConstraint> getSingleConstraints() {
+		Vector<SingleConstraint> ret = new Vector<SingleConstraint>();
+		for(UndConstraint uc : oderConstraintPairs) {
+			if (uc instanceof SingleConstraint) {
+				ret.add((SingleConstraint)uc);
+			}
+			//else return new Exception();
+		}
+		return ret;
+	}
 
 	public Vector<UndConstraint> getUndConstraints() {
 		return this.oderConstraintPairs;

src/de/dhbwstuttgart/typeinference/SingleConstraint.java

@@ -46,6 +46,11 @@ public class SingleConstraint extends UndConstraint{
 	public Pair getPair(){
 		return constraintPair;
 	}
+	
+	@Override //liefert das eine Paar zurueck
+	public Vector<Pair> getOneExample() {
+		return getConstraintPairs();
+	}
 
 	@Override //Methode überschreiben, damit immer nur ein Vector mit nur einem Element zurückgeliefert wird.
 	public Menge<Pair> getConstraintPairs(){

src/de/dhbwstuttgart/typeinference/TypeinferenceResultSet.java

@@ -112,6 +112,16 @@ 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

@@ -1,25 +0,0 @@
-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/UndConstraint.java

@@ -47,6 +47,7 @@ public class UndConstraint extends UndMenge<Pair> {
 		super(p1, p2);
 	}
 
+	
 	@Override
 	public Vector<UndConstraint> getUndConstraints() {
 		Vector<UndConstraint> ret = new Vector<UndConstraint>();

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,15 +1,25 @@
 //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;
@@ -34,17 +44,19 @@ 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.Menge;
+import de.dhbwstuttgart.typeinference.OderConstraint;
 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<EFBFBD>micke, Thomas Ott
+ * @author Martin Pl�micke, Thomas Ott
  * @version $Date: 2013/05/22 22:23:50 $
  */
 // ino.end
@@ -55,7 +67,7 @@ public class Unify
 {
     
     // ino.attribute.inferencelog.28052.declaration 
-    protected static SectionLogger inferencelog = Logger.getSectionLogger("inference", Section.UNIFY);
+    protected static SectionLogger inferencelog = Logger.getSectionLogger(Unify.class.getName(), Section.UNIFY);
     // ino.end
     
     /**
@@ -114,13 +126,21 @@ 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<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
+     * Fü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.*/
@@ -133,7 +153,7 @@ public class Unify
     		}
     		else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder))
     		{
-    			//Diese Paare k<EFBFBD>nnen nicht mehr Unifiziert werden. fail.
+    			//Diese Paare können nicht mehr Unifiziert werden. fail.
     			inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " muesste mindestens einen TPH enthalten.");
     			return new Menge<Menge<Pair>>();
     		}
@@ -145,8 +165,8 @@ public class Unify
     		if(!Eq1.contains(p))
     			Eq2.add(p);
     	}
-    	/* Schritt 4, Teil 1: Einsammeln der Sets f<EFBFBD>r das Kartesiche Produkt.
+    	/* Schritt 4, Teil 1: Einsammeln der Sets für das Kartesiche Produkt.
-    	 * Hier werden die Paare verglichen. Je nach Struktur k<EFBFBD>nnen neue Paare erzeugt
+    	 * Hier werden die Paare verglichen. Je nach Struktur kö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)
@@ -158,7 +178,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<EFBFBD>st sein. PL 15-03-17
+                               //Muesste mit folgendem if gelöst sein. PL 15-03-17
                                if (p.TA2 instanceof TypePlaceholder) {
                                        Eq1.addElement(p);
                                        //      Eq2.remove(p);
@@ -209,7 +229,7 @@ public class Unify
     							unifyErgs.add(unifyErgsElement.firstElement());
     						}
     					}
-//    					Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
+//    					Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelö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
 	    			    {
@@ -308,7 +328,7 @@ public class Unify
     			}
     			else if(p.OperatorSmaller() && p.TA2 instanceof GenericTypeVar)
     			{
-    				//Paar unver<EFBFBD>ndert lassen, wenn eine GenericTypeVar ist
+    				//Paar unverändert lassen, wenn eine GenericTypeVar ist
     				Menge<Menge<Pair>> setofsetofpairs = new Menge<Menge<Pair>>();
 					Menge<Pair> vTmp = new Menge<Pair>();
 					vTmp.add(p);
@@ -350,7 +370,7 @@ public class Unify
 	    							unifyErgs.add(unifyErgsElement.firstElement());
 	    						}
 	    					}
-	    					//Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
+	    					//Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelö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
     	    			    {
@@ -525,7 +545,7 @@ public class Unify
         							unifyErgs.add(unifyErgsElement.firstElement());
         						}
         					}
-//        					Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
+//        					Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelö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
     	    			    {
@@ -624,8 +644,91 @@ public class Unify
     		}
     	}
     	//Schritt 4, Teil 2: Kartesisches Produkt bilden.
-    	//TODO: Vor der Bildung des Karthesischen Produkts unm<6E>gliche Kombinationen ausfiltern
+    	log.debug("Unify Sets nach Schritt 4 vor dem Erstellen des Karthesischen Produkts: "+cartProduktSets);
-    	//Hier wird aus den in Schritt 4, Teil 1 erzeugten Vektoren das Kartesische Produkt gebilden.
+    	/*
+    	//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.
     	Menge<Pair> helpvp;
     	Menge<Menge<Pair>> bigCartProductErg = new Menge<Menge<Pair>>();
         bigCartProductErg.addElement(copyMengePair(Eq1));
@@ -644,13 +747,33 @@ 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<EFBFBD>nderten und nicht ge<EFBFBD>nderten Sets sortiert.
+        //Hier werden die TPHs substituiert, und dann nach geänderten und nicht geä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
@@ -700,29 +823,29 @@ public class Unify
             }
         }
         
-        //Eq2Set ist das eigentliche Ergebnis, dass zur<EFBFBD>ckgegeben wird.
+        //Eq2Set ist das eigentliche Ergebnis, dass zurückgegeben wird.
         Menge<Menge<Pair>> Eq2Set = new Menge<Menge<Pair>>();
         
-        //Schritt 6A: Beginnen mit Schritt 1 bei den ge<EFBFBD>nderten.
+        //Schritt 6A: Beginnen mit Schritt 1 bei den geä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<EFBFBD>ft worden. Sie k<EFBFBD>nnen direkt eingef<EFBFBD>gt werden.
+        	//Die Ergebnissvektoren sind schon im Schritt 7 von dem Rekursiven Aufruf geprüft worden. Sie können direkt eingefügt werden.
         	Eq2Set.addAll(unifyErgs);
         }
         
-        //Schritt 6B Einf<EFBFBD>gen der nicht ge<EFBFBD>nderten.
+        //Schritt 6B Einfügen der nicht geä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<EFBFBD>ssen nur die Ergebnisse aus 6B gepr<EFBFBD>ft werden.
+         * Es müssen nur die Ergebnisse aus 6B geprüft werden.
          */
         for(Menge<Pair> vecpair : notChangedSets)
         {
-        	//<EFBFBD>berpr<EFBFBD>fen ob Menge in SolvedForm ist.
+        	//Überprüfen ob Menge in SolvedForm ist.
         	if(hasSolvedForm(vecpair)) //PL 13-05-22 hasSolvedForm angepasst
         	{
-        		//<EFBFBD>berpr<EFBFBD>fung auf FreshTypeVars in den Typen
+        		//Überprüfung auf FreshTypeVars in den Typen
         		boolean foundFresh = false;
         		for(Pair p : vecpair)
         		{
@@ -740,14 +863,14 @@ public class Unify
         	}
         }
     	
-        //Ergebnis zur<EFBFBD>ckgeben.
+        //Ergebnis zurückgeben.
     	return Eq2Set;
     }
     
     /**
      * PL 2014-10-25
      * schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind
-     * R<EFBFBD>ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
+     * Rückgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
      * @param var
      * @param vars
      * @param indexe
@@ -798,10 +921,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<EFBFBD>scht.
+     * Durch das Entfernen entstehen evtl. Identische Mengeen, diese werden auch gelöscht.
      * 
-     * @param unifyErgs - Ergebnisse des Unify, die gepr<EFBFBD>ft werden sollen.
+     * @param unifyErgs - Ergebnisse des Unify, die geprüft werden sollen.
-     * @param test - RefType gegen den gepr<EFBFBD>ft werden soll.
+     * @param test - RefType gegen den geprüft werden soll.
      */
     private static void testUnifyErg(Menge<Menge<Pair>> unifyErgs, RefType test)
     {
@@ -815,7 +938,7 @@ public class Unify
 				vec--;
 			}
 		}
-    	//Gleiche Mengeen l<EFBFBD>schen
+    	//Gleiche Mengeen löschen
     	for(int i = 0; i < unifyErgs.size(); i++)
     	{
     		Menge<Pair> p1 = unifyErgs.elementAt(i);
@@ -844,13 +967,13 @@ public class Unify
     }
     
     /**
-     * Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der <EFBFBD>bergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
+     * Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der ü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<EFBFBD>lt.
+     * @return - Ein Menge<Menge<Pair>> der alle Paare enthält.
      */
     private static Menge<Menge<Pair>> generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)
     {
@@ -951,7 +1074,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<EFBFBD>scht
+        //Elemente die nicht kleinste obere Schranken sind, werden gel�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++) {
@@ -1007,7 +1130,7 @@ throws MatchException
 // ino.method.match.28064.body 
 { 
     //PL 05-01-22 
-    //gibt eine Substitution zur<EFBFBD>ck, die den Variablen aus FCtype
+    //gibt eine Substitution zur�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())) {
@@ -1051,7 +1174,7 @@ throws MatchException
     // ino.method.sub_unify.28067.body 
     {
     //PL 05-01-21 umbenannt in sub_unify 
-    //Luar boolean useSubst hinzugef<EFBFBD>gt, um bei bedarf zu Steuern ob Subst Regel angewendet wird oder nicht.
+    //Luar boolean useSubst hinzugefügt, um bei bedarf zu Steuern ob Subst Regel angewendet wird oder nicht.
         // otth: Unifikation - Versuch 1 :-)
     
     //Menge FC = fc_tto.getFC();
@@ -1076,7 +1199,7 @@ throws MatchException
                 inferencelog.debug("Ausgewaehltes Paar = " + P.toString() + "");
                 inferencelog.debug(  "--------------------------------------------------");
                 
-                // Bei allen Erase erfolgt keine Kopie nach H, dadurch wird das Pair gel<EFBFBD>scht.
+                // Bei allen Erase erfolgt keine Kopie nach H, dadurch wird das Pair gelöscht.
                 //ERASE3
                 if( P.isEqual() && P.OperatorEqual() )
                 {
@@ -1198,13 +1321,13 @@ throws MatchException
 	                				}
 	                				catch( SCException Ex )
 	                                {
-	                                    inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
+	                                    inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
 	                                    break;
 	                                }
 	                			}
 	                			else
 	                			{
-	                				inferencelog.info("---- Unifikation nicht m<EFBFBD>glich: Anzahl der Parameter verschieden!");
+	                				inferencelog.info("---- Unifikation nicht m�glich: Anzahl der Parameter verschieden!");
 	                                break;
 	                			}
 	                		}
@@ -1255,13 +1378,13 @@ throws MatchException
 	                				}
 	                				catch( SCException Ex )
 	                	            {
-	                	                inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
+	                	                inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
 	                	                break;
 	                	            }
 	                			}
 	                			else
 	                			{
-	                				inferencelog.info("---- Unifikation nicht m<EFBFBD>glich: Anzahl der Parameter verschieden!");
+	                				inferencelog.info("---- Unifikation nicht m�glich: Anzahl der Parameter verschieden!");
 	                                break;
 	                			}
 	                		}
@@ -1332,7 +1455,7 @@ throws MatchException
          
                 	RefType TA1 = null;
                 	RefType TA2 = null;
-                	//Hier werden die RefTypes gef<EFBFBD>llt.
+                	//Hier werden die RefTypes gefüllt.
                 	if(P.TA1 instanceof RefType && P.TA2 instanceof RefType)
                 	{
                 		TA1 = (RefType)P.TA1;
@@ -1354,7 +1477,7 @@ throws MatchException
 	                        }
 	                        catch( SCException Ex )
 	                        {
-	                            inferencelog.error("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
+	                            inferencelog.error("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
 	                            break;
 	                        }
 	                    }
@@ -1387,7 +1510,7 @@ throws MatchException
                             }
                             catch( SCException Ex )
                             {
-                                inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
+                                inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
                                 break;
                             }
                         }
@@ -1407,7 +1530,7 @@ throws MatchException
                            	}
                            	catch( SCException Ex )
                             {
-                                inferencelog.error("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
+                                inferencelog.error("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!");
                                 break;
                             }
                         }
@@ -1520,7 +1643,7 @@ throws MatchException
                 	
                 }
     
-                // Subst --> noch zu pr<EFBFBD>fen
+                // Subst --> noch zu pr�fen
                 if( P.TA1 instanceof TypePlaceholder && P.OperatorEqual() && useSubst) //&& P.TA2 instanceof RefType )
             //PL 05-02-09 P.TA@ duerfen auch TypePlaceholder sein
             /*  BEISPIEL:
@@ -1674,7 +1797,7 @@ throws MatchException
     
     /**
      * Implementiert die reduceEq Regel des sub_unify
-     * Da in reduce2 unn<EFBFBD>tigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren.
+     * Da in reduce2 unnö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
     {
@@ -1696,11 +1819,11 @@ throws MatchException
         inferencelog.debug("---- Parameteranzahl gleich");
         inferencelog.debug("---- Reduce !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (" + L1.size() + ") neue(s) Paar(e)");
 
-        // hier mu<EFBFBD> die PERMUTATION erfolgen
+        // hier mu� die PERMUTATION erfolgen
         inferencelog.debug("---- PAARBILDUNG ");
         for( int k = 0; k < L1.size(); k++ )
         {
-            // pi eig. bei reduce2 <EFBFBD>berfl<EFBFBD>ssig, schadet aber hoff. auch nicht :-)
+            // pi eig. bei reduce2 �berfl�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() + ")");
@@ -1999,7 +2122,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<EFBFBD>rt, ob es funktioniert.
+        if (hasSolvedForm(res)) { //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
             inferencelog.debug("HasSolvedForm: ");
             printMenge("RES_SMALLER", res, 6);
             ht = MengePair2SubstHashtableMengePair(res);
@@ -2114,6 +2237,27 @@ 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
@@ -2161,7 +2305,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<EFBFBD>re hier gleich wie Menge<Integer>
+        // z.B. Menge<A> w�re hier gleich wie Menge<Integer>
         
         // z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> >  )  ,...}
         // R1 = AA<Integer, b>
@@ -2209,7 +2353,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<EFBFBD>re hier gleich wie Menge<Integer>
+        // z.B. Menge<A> w�re hier gleich wie Menge<Integer>
         
         // z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> >  )  ,...}
         // R1 = AA<Integer, b>
@@ -2247,7 +2391,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<EFBFBD>rt, ob es funktioniert.
+            if ( hasSolvedForm(vp) ) //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
             //if( isRXSimilarRY( RFC, R2 ) )
                     {
                 inferencelog.debug("SIMILAR2");
@@ -2332,7 +2476,19 @@ 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 )
@@ -2344,7 +2500,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<EFBFBD>glich, da TV " + a.getName() + " in RefType " + o.getName());
+            inferencelog.debug("  Subst nicht m�glich, da TV " + a.getName() + " in RefType " + o.getName());
             return false;
         }
     }
@@ -2354,7 +2510,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<EFBFBD>ckgegeben werden und nicht in den ifs 
+            boolean ret = true; //EINGEFUEGT PL 14-01-16: Return darf erst am Ende zurückgegeben werden und nicht in den ifs 
             					//sonst werden nicht alle Elemente der Forschleife durchlaufen
             for( int i = 0; i < vTemp.size(); i++ )
             {
@@ -2400,7 +2556,7 @@ throws MatchException
                 return true;
             }
         }
-        //Wildcard erg<EFBFBD>nzt PL 14-12-05
+        //Wildcard ergänzt PL 14-12-05
         if ( T instanceof ExtendsWildcardType )
         {
         	Type Temp = ((ExtendsWildcardType) T).get_ExtendsType();
@@ -2415,7 +2571,7 @@ throws MatchException
                 }
             }
         }
-        //Wildcard erg<EFBFBD>nzt PL 14-12-05
+        //Wildcard ergänzt PL 14-12-05
         if ( T instanceof SuperWildcardType )
         {
         	Type Temp = ((SuperWildcardType) T).get_SuperType();
@@ -2496,7 +2652,7 @@ throws MatchException
     {
     	
     	
-        // otth: Funktion pr<EFBFBD>ft, ob Klasse 'Basis' von Klasse 'Mutter' direkt oder indirekt abgeleitet ist
+        // otth: Funktion pr�ft, ob Klasse 'Basis' von Klasse 'Mutter' direkt oder indirekt abgeleitet ist
     
         // Basisklasse suchen
     Menge tto = fc_tto.getTTO();
@@ -2520,9 +2676,9 @@ throws MatchException
                     }
                     
                     /* 
-                     * Hier wird <EFBFBD>berpr<EFBFBD>ft ob in der Paraliste ein anderes Element als ein GTV drinne ist.
+                     * 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<EFBFBD>glich.
+                     * Sollte ein anderes Element gefunden werden ist Reduce nicht möglich.
-                     * Beispiel: Matrix <. Menge<Menge<Integer>> ist nur durch adapt m<EFBFBD>glich.
+                     * Beispiel: Matrix <. Menge<Menge<Integer>> ist nur durch adapt möglich.
                      */
                     for(Type t : s)
                     {
@@ -2656,7 +2812,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
         if( n >= vD.size() )
         throw F;
     
-        // Permuationswert f<EFBFBD>r 'n' berechnen
+        // Permuationswert f�r 'n' berechnen
         Type TV = (Type)vD.elementAt(n);
         
         int nPos = -1;
@@ -2688,12 +2844,12 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     // ino.method.printMengeUnifier.28121.body 
     {
     //PL 05-01-21
-    //Ruft f<EFBFBD>r eine Menge von Unifikatoren die Methode
+    //Ruft f�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<EFBFBD>rt, ob es funktioniert.
+        if( hasSolvedForm( Uni.elementAt(i) ) ) { //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
             inferencelog.debug((i+1) + ". Unifier ist in 'Solved form'!\n");
         }
         else {
@@ -2720,7 +2876,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<EFBFBD>scht, da sinnlos.
+        	//luar 13-03-07 If Else Block gelöscht, da sinnlos.
         	if( tt > 0 )
         		strTemp = strTemp + ",\n" + E.elementAt(tt).toString();
             else
@@ -2813,7 +2969,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * Implementiert die CaptureConversion. Wendet diese auf jeden Typ im Menge TVec an.
-     * R<EFBFBD>ckgabe ist ein ErgebnisMenge
+     * Rückgabe ist ein ErgebnisMenge
      */
     private static Menge<ObjectType> CaptureConversion(Menge<ObjectType> TVec, FC_TTO fc_tto)
     {
@@ -2821,7 +2977,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<EFBFBD>ckliefern, laesst sich aber nicht zurziehen.
+    						//CaptureConversion kann nur ObjectTypes zurückliefern, laesst sich aber nicht zurziehen.
     		if(ccT != null)
     			retVec.add(ccT);
     	}
@@ -2831,7 +2987,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     /**
      * Erzeugt die CaptureConversion von einem Typ.
      * 
-     * @param T - <EFBFBD>bergebener Typ, von welchem die CaptureConversion gemacht werden soll.
+     * @param T - Übergebener Typ, von welchem die CaptureConversion gemacht werden soll.
      * @param fc_tto - Hilfsklasse.
      * @return - CC(T)
      */
@@ -2866,7 +3022,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<EFBFBD>gt.
+    					//Wenn beim Original Typ an der Stelle eine BoundedGenericTypeVar ist werden die Bounds zu der Wildcard hinzugefügt.
     					if(cl.get_ParaList().elementAt(i) instanceof BoundedGenericTypeVar)
     					{
     						BoundedGenericTypeVar bgv = (BoundedGenericTypeVar)cl.get_ParaList().elementAt(i);
@@ -2880,7 +3036,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     			}
     			refT.set_ParaList(ccTypes);
     		}
-    		//Wenn eine CaptureConversion durchgef<EFBFBD>hrt wurde den Typ zur<EFBFBD>ckgeben.
+    		//Wenn eine CaptureConversion durchgeführt wurde den Typ zurückgeben.
     		if(ccDone)
     			return refT;
     		else
@@ -2897,13 +3053,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<EFBFBD>tsdiagrammen
+     * 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<EFBFBD>dtke, 2007 nachgelesen werden.
+     * im Inovator Projekt, oder in der Studienarbeit Arne Lüdtke, 2007 nachgelesen werden.
      */
     
     /**
-     * Erzeugt alle Typen die greater sind als T. Gibt diese zur<EFBFBD>ck.
+     * Erzeugt alle Typen die greater sind als T. Gibt diese zurück.
-     * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
+     * Fü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
@@ -2928,22 +3084,22 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	//greater1 Erzeugen
     	Menge<ObjectType> greater1Erg = greater1(T,fc_tto);
     	
-    	//Reflexivit<EFBFBD>t, deshalb T hinzuf<EFBFBD>gen.
+    	//Reflexivität, deshalb T hinzufügen.
     	if(!greater1Erg.contains(T))
     		greater1Erg.add(T);
     	
-    	//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec <EFBFBD>bernommen.
+    	//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec übernommen.
     	for(ObjectType t : greater1Erg)
     		if(!retVec.contains(t))
     			retVec.add(t);                      
     	
-    	//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einf<EFBFBD>gen
+    	//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einfü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<EFBFBD>gen
+    	//Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einfügen
     	Menge<ObjectType> greater3Erg = greater3(greater2Erg,fc_tto);
     	for(ObjectType t : greater3Erg)
     		if(!retVec.contains(t))
@@ -2954,7 +3110,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * greater1 Schritt von greater.
-     * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
+     * Fü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)
     {
@@ -2992,8 +3148,8 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     }
     
     /**
-     * <EFBFBD>berladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
+     * Ü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.
+     * welcher für die rekursion erforderlich ist mit übergeben muss.
      */
     private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec)
     {
@@ -3002,7 +3158,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
-     * F<EFBFBD>r den Startaufruf ist der index = 0. Danach ruft sich cartProductType rekursiv auf.
+     * Fü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)
     {
@@ -3037,8 +3193,8 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     }
     
     /**
-     * <EFBFBD>berladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
+     * Ü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.
+     * welcher für die rekursion erforderlich ist mit übergeben muss.
      */
     private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec)
     {
@@ -3047,7 +3203,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
-     * F<EFBFBD>r den Startaufruf ist der index = 0. Danach ruft sich cartProductPair rekursiv auf.
+     * Fü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)
     {
@@ -3107,7 +3263,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     
     /**
      * greaterArg Schritt von greater
-     * F<EFBFBD>r den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt
+     * Für den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt
      */
     private static Menge<Type> greaterArg(Type T, FC_TTO fc_tto)
     {
@@ -3163,7 +3319,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	    return new Menge<Type>();
     	*/
     	
-    	//Diese Abfrage sorgt f<EFBFBD>r grArg(a) = {a} //Luar 07-07-31
+    	//Diese Abfrage sorgt fü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
@@ -3192,7 +3348,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	Menge<ObjectType> retVec = new Menge<ObjectType>();
     	/*
     	 * luar 02-05-07: Beschreibung der Funktion:
-    	 * F<EFBFBD>r Jeden Typ aus greater1 durch die FC laufen, und auf der Linken seite einen Match versuchen.
+    	 * Fü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>();
@@ -3217,7 +3373,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<EFBFBD>gen in retVec
+	    				//TA2neu ist greater als T. Einfügen in retVec
 	    				if(!retVec.contains(TA2neu))
 	    					retVec.add(TA2neu);
 	    			}
@@ -3247,12 +3403,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<EFBFBD>tsdiagrammen
+     * 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<EFBFBD>dtke, 2007 nachgelesen werden.
+     * im Inovator Projekt, oder in der Studienarbeit Arne Lüdtke, 2007 nachgelesen werden.
      */
     
     /**
-     * Erzeugt alle Typen die smaller sind als T. Gibt diese zur<EFBFBD>ck.
+     * Erzeugt alle Typen die smaller sind als T. Gibt diese zurück.
      */
     private static Menge<ObjectType> smaller(ObjectType T, FC_TTO fc_tto)
     //an die Aenderungen im Skript anpassen 07-11-03
@@ -3288,18 +3444,18 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	if(!smaller12Erg.contains(T))
     		smaller12Erg.add(T);
     	
-    	//Ergebnise in retVec einf<EFBFBD>gen. Doppelte werden gel<EFBFBD>scht.
+    	//Ergebnise in retVec einfügen. Doppelte werden gelöscht.
     	for(ObjectType t : smaller12Erg)
     		if(!retVec.contains(t))
     			retVec.add(t);
     	
-    	//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einf<EFBFBD>gen.
+    	//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einfü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<EFBFBD>gen.
+    	//Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einfügen.
     	Menge<ObjectType> smaller4Erg = smaller4(smaller3Erg);
     	for(ObjectType t : smaller4Erg)
     		if(!retVec.contains(t))
@@ -3348,7 +3504,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	Menge<Type> retVec = new Menge<Type>();
     	if(T instanceof ExtendsWildcardType)
     	{
-    		//F<EFBFBD>r eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen.
+    		//Fü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)
@@ -3359,7 +3515,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	}
     	else if(T instanceof SuperWildcardType)
     	{
-    		//F<EFBFBD>r eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen.
+    		//Fü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)
@@ -3398,7 +3554,7 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     	Menge<ObjectType> retVec = new Menge<ObjectType>();
     	/*
     	 * luar 02-05-07: Beschreibung der Funktion:
-    	 * F<EFBFBD>r Jeden Typ aus Smaller12 durch die FC laufen, und auf der Rechten seite einen Match versuchen.
+    	 * Fü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>();
@@ -3421,7 +3577,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<EFBFBD>gen in retVec
+	    				//TA1neu ist smaller als T. Einfügen in retVec
 	    				if(!retVec.contains(TA1neu))
 	    					retVec.add(TA1neu);
 	    			}
@@ -3471,12 +3627,12 @@ tempKlasse.get_Superclass_Name() );                 System.out.println( "P. S.:
     }
     
     /**
-     * Gibt True zur<EFBFBD>ck, wenn T eine FreshWildcard ist, oder im Falle eines RefTypes oder WildcardTypes eine FreshWildcard enth<EFBFBD>lt.
+     * Gibt True zurück, wenn T eine FreshWildcard ist, oder im Falle eines RefTypes oder WildcardTypes eine FreshWildcard enthält.
      */
     private static boolean DelFreshWildcardTypeVar(Type T)
     {
     	//luar 29-05-2007
-    	//<EFBFBD>berpr<EFBFBD>ft rekursiv ob in dem RefType ein FreshWildcardType enthalten ist.
+    	//Überprüft rekursiv ob in dem RefType ein FreshWildcardType enthalten ist.
     	if(T instanceof RefType)
     	{
     		RefType refT = (RefType)T;
@@ -3485,7 +3641,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<EFBFBD>fen.
+    	//Im Falle einer Wildcard, Typen aus der WC rausnehmen und diesen rekursiv prüfen.
     	if(T instanceof ExtendsWildcardType)
     		return DelFreshWildcardTypeVar(((ExtendsWildcardType)T).get_ExtendsType());
     	
@@ -3494,15 +3650,13 @@ 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;
-    }
-
     
+    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;
+    }
 }
 // ino.end

test/bytecode/ASTBytecodeTest.java

@@ -1,95 +0,0 @@
-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

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

test/bytecode/Binary2.jav

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

test/bytecode/BinaryTest.java

@@ -1,34 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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/BytecodeTest.java

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

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

test/bytecode/MainTest.java

@@ -1,34 +0,0 @@
-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

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

test/bytecode/NewClassTest.java

@@ -1,61 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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,14 +2,12 @@ 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;
@@ -17,10 +15,8 @@ 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 {
 	
@@ -28,36 +24,24 @@ public class SingleClassTester {
 		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			SourceFile sf = compiler.parse(new File(inputFile));
+			compiler.parse(new File(inputFile));
-			
+			Menge<Menge<ByteCodeResult>> bytecode = compiler.generateBytecode(compiler.typeReconstruction().firstElement());
-			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);
 			
-			ByteCodeResult result = bytecode.firstElement();
+			for(ByteCodeResult result: bytecode.firstElement()){
-			
+				JavaClass javaClass = result.getByteCode().getJavaClass();
-			JavaClass javaClass = result.getByteCode().getJavaClass();
+				
-			javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class"));
+				Logger.getLogger("SingleClassTester").error(result.getByteCode().getJavaClass().toString(), Section.CODEGEN);
-			
+				
-			for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){
+				javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class"));
-				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+"bytecode.log");
+			writeLog(outputDirectory+".log");
 		}
 	}
 	

test/bytecode/Test2.java

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

test/bytecode/types/AutoOverloading.jav

@@ -1,17 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

test/bytecode/types/ExtendsObjectTest.java

@@ -2,37 +2,39 @@ 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.ASTBytecodeTest;
+import bytecode.BytecodeTest;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
+import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+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 ExtendsObjectTest extends BytecodeTest{
-public class ExtendsObjectTest extends ASTBytecodeTest{	
+	@Override
-	public SourceFile getSourceFile(){
+	protected void init() {
-		/*
+		testName = "ExtendsObject";
-		class ExtendsObject extends Object{
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
-
-		}
-		 */
-		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{
-		    ClassLoader classLoader = getClassLoader();
+			Class cls = getClassToTest();
-
-		    Class cls =  classLoader.loadClass(getTestName());
-		    
-			Object obj = cls.newInstance();
 				
 			Constructor method = cls.getConstructor(new Class[]{});
 			method.newInstance();
@@ -42,31 +44,5 @@ public class ExtendsObjectTest extends ASTBytecodeTest{
 			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

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

test/bytecode/types/ExtendsTypeTest.java

@@ -1,31 +0,0 @@
-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

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

test/bytecode/types/ExtendsVectorString.jav

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

test/bytecode/types/ExtendsVectorStringTest.java

@@ -2,86 +2,47 @@ 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.ASTBytecodeTest;
+import bytecode.BytecodeTest;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
+import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.core.MyCompiler;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.core.MyCompilerAPI;
-import de.dhbwstuttgart.syntaxtree.type.Type;
+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 ExtendsVectorStringTest extends BytecodeTest{	
-public class ExtendsVectorStringTest extends ASTBytecodeTest{
+	@Override
-	
+	protected void init() {
-	public SourceFile getSourceFile(){
+		testName = "ExtendsVectorString";
-		/*
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
-		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 testSupertype(){
+	public void testConstruct(){
 		try{
-		    ClassLoader classLoader = getClassLoader();
+			Class cls = getClassToTest();
-
+				
-		    Class cls =  classLoader.loadClass(getTestName());
+			Constructor method = cls.getConstructor(new Class[]{});
-		    
+			method.newInstance();
-			assertEquals("java.util.Vector", cls.getSuperclass().getName());
+			assertTrue(true);
 		}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,58 +2,47 @@ 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.ASTBytecodeTest;
+import bytecode.BytecodeTest;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
+import plugindevelopment.TypeInsertTester;
-import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.core.MyCompiler;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
+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 ExtendsVectorTest extends BytecodeTest{
-public class ExtendsVectorTest extends ASTBytecodeTest{	
+	@Override
-	public SourceFile getSourceFile(){
+	protected void init() {
-		/*
+		testName = "ExtendsVector";
-		import java.util.Vector;
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
-
-		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 testSupertype(){
+	public void testConstruct(){
 		try{
-		    ClassLoader classLoader = getClassLoader();
+			Class cls = getClassToTest();
-
+				
-		    Class cls =  classLoader.loadClass(getTestName());
+			Constructor method = cls.getConstructor(new Class[]{});
-		    
+			method.newInstance();
-			assertEquals("java.util.Vector", cls.getSuperclass().getName());
+			assertTrue(true);
 		}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

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

test/bytecode/types/LocalVariableStringVectorTest.java

@@ -1,39 +0,0 @@
-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

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

test/bytecode/types/LocalVariableVectorTest.java

@@ -1,38 +0,0 @@
-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/MethodWithUntypedVector.jav

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

test/bytecode/types/MethodWithUntypedVectorTest.java

@@ -1,68 +0,0 @@
-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

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

test/bytecode/types/OverloadingAdditionTest.java

@@ -1,32 +0,0 @@
-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

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

test/bytecode/types/SuperType.jav

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

test/bytecode/types/SuperType.java

@@ -1,32 +0,0 @@
-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/bytecode/types/TypedVector.jav

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

test/bytecode/types/TypedVectorTest.java

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

test/plugindevelopment/MartinTestCases/Matrix3.jav

@@ -0,0 +1,7 @@
+import java.util.Vector;
+
+class Matrix3 extends Vector<Vector<Integer>> {
+
+    op = (f) -> f.apply(this); 
+
+}

test/plugindevelopment/MartinTestCases/Matrix_lambda.jav

@@ -1,5 +1,10 @@
 import java.util.Vector;
 
+<<<<<<< HEAD
+class Matrix extends Vector<Vector<Integer>> {
+	op = (m) -> (f) -> f.apply(this, m); 
+=======
 class Matrix  {
 	op = (m) -> (f) -> f.apply(m); 
+>>>>>>> refactoring
 } 

test/plugindevelopment/TypeInsertTests/LambdaTest1.jav

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

test/plugindevelopment/TypeInsertTests/Matrix3.jav

@@ -0,0 +1,5 @@
+class Matrix3 extends Vector<Vector<Integer>> {
+
+    op = (f) -> f.apply(this); 
+
+}

test/plugindevelopment/TypeInsertTests/Matrix3.java

@@ -0,0 +1,20 @@
+package plugindevelopment.TypeInsertTests;
+
+import java.util.Vector;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.logger.Logger;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+
+public class Matrix3 {
+	private static final String TEST_FILE = "Matrix3.jav";
+	
+	@Test
+	public void run(){
+		Vector<String> mustContain = new Vector<String>();
+		mustContain.add("TestIfStmt var");
+		MultipleTypesInsertTester.testSingleInsert(this.TEST_FILE, mustContain);
+	}
+}

test/plugindevelopment/TypeInsertTests/Matrix_lambda.jav

@@ -0,0 +1,6 @@
+import java.util.Vector;
+
+class Matrix extends Vector<Vector<Integer>> {
+	op = (f) -> f.apply(this); 
+	
+} 

test/plugindevelopment/TypeInsertTests/Matrix_lambda.java

@@ -0,0 +1,20 @@
+package plugindevelopment.TypeInsertTests;
+
+import java.util.Vector;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.logger.Logger;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+
+public class Matrix_lambda {
+	private static final String TEST_FILE = "Matrix_lambda.jav";
+	
+	@Test
+	public void run(){
+		Vector<String> mustContain = new Vector<String>();
+		mustContain.add("TestIfStmt var");
+		MultipleTypesInsertTester.testSingleInsert(this.TEST_FILE, mustContain);
+	}
+}

test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java

@@ -14,7 +14,6 @@ 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;
@@ -47,10 +46,8 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
 		
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			SourceFile parsedFile = compiler.parse(new File(rootDirectory + sourceFileToInfere));
+			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			Menge<SourceFile> parsedFiles = new Menge<>();
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
-			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){
@@ -81,9 +78,8 @@ public class MultipleTypesInsertTester extends TypeInsertTester{
 		String inferedSource = "";
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			Menge<SourceFile> parsedSource = new Menge<>();
+			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			parsedSource.add(compiler.parse(new File(rootDirectory + sourceFileToInfere)));
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
-			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

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

test/unify/UnifyFilter.java

@@ -0,0 +1,58 @@
+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

@@ -1,304 +0,0 @@
-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));
-	}
-
-}