modified: src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

Kommentare zur Max Min optimierung rasugenommen

.gitignore

@@ -20,3 +20,6 @@ bin
 .project
 .settings/
 /target/
+
+#
+manually/

README.md

@@ -0,0 +1,19 @@
+
+
+# plugin site erstellen
+* die JAvaTXCOmpiler DAtei in ein plugin umwandeln und deployen.
+* siehe: http://www.vogella.com/tutorials/EclipseJarToPlugin/article.html#convert-jar-files-to-osgi-bundles-with-the-p2-maven-plugin
+* AUsführung:
+	* mvn deploy #erstellt die JAR-Datei und steckt sie in ein lokales Repo (maven-repository)
+	* mvn p2:site
+	* mvn package # hier wird die ZIP-Filf zum Einbinden in Eclipse erstellt
+
+# Einbinden in Eclipse
+* In Eclipse kann die Zip-FIle wie ein Plugin installiert werden
+* Hier tritt FEhler auf. Reflections-Library kann nicht installiert werden. Möglicherweise wird sie auch nicht gebraucht
+* Nach dem installieren de.dhbwstuttagrt.JavaTXcompiler zu den DEpendencies des plugins hinzufügen
+* Anschließend unter "Overview" auf "Updata Classpath" klicken
+
+# Windows
+* JAVA_HOME setzen:
+	* export JAVA_HOME=/c/Program\ Files/Java/jdk1.8.0_102/

asp/adaptRules.lp

@@ -1,19 +0,0 @@
-%makeAdapt(smallerDot(CFC, DFC)) :- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
-	%, smaller(CFC, DFC), type(CFC, CN, CNP), type(DFC, DN, DNP), mapRootFC(smaller(CFC, DFC), _, _)
-	%.
-
-
-type(pointer(smallerDot(C,D)), DN, DNP)
-:- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
-	.
-smallerDot(pointer(smallerDot(C,D)), D)
-:- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
-	.
-
-param(pointer(smallerDot(C,D)), P, P2)
-:- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
-	, smaller(CFC, DFC), type(CFC, CN, CNP), type(DFC, DN, DNP)
-	, pi(CFC, DFC, P1, P2), param(C, P, P1)
-	.
-
-

asp/cartesian.lp

@@ -1,22 +0,0 @@
-
-%Mit Hilfe von Quelle: https://www.cs.uni-potsdam.de/~torsten/Papers/asp4ki.pdf
-
-%Dieser Code generiert das Karthesische Produkt der Constraints des Inputs.
-%und Constraints sind einfach weiterhin equals uns smallerDot
-%oder constraints:
-% oder(pointer, pointer)
-%constraints innerhalb des oders müssen eingepackt sein:
-% constraint(pointer, eigentlicher Constraint)
-% um mehrere constraints als Und-Constraint innerhalb eines Oders zu verbinden kann die list(..) verwendet werden
-
-%Die eigentliche Oder-Verknüpfung:
-cons(Cons1), cons(Cons2) :- oder(C1, C2), constraint(C1, Cons1), constraint(C2, Cons2).
-
-%Auspacken der constraints:
-equals(X,Y) :- cons(equals(X,Y)).
-smallerDot(X,Y) :- cons(smallerDot(X,Y)).
-oder(X,Y) :- cons(oder(X,Y)).
-list(X,Y) :- cons(list(X,Y)).
-equals(X,Y) :- list(equals(X,Y), _).
-smallerDot(X,Y) :- list(smallerDot(X,Y), _).
-list(A,B) :- list(_, list(A,B)).

asp/facultyTestInput.lp

@@ -1,70 +0,0 @@
-typeVar(cRO).
-smaller(cAVP,cAVQ).
-type(cAVY,cjava_DOT_lang_DOT_Integer,0).
-type(cAVI,cjava_DOT_lang_DOT_Integer,0).
-type(cAVD,cjava_DOT_lang_DOT_Comparable,1).
-type(cAVH,cjava_DOT_lang_DOT_Comparable,1).
-type(cAVJ,cjava_DOT_lang_DOT_Number,0).
-typeVar(cT).
-equals(cQ,cRO).
-smaller(cAVR,cAVS).
-param(cAVZ,cYO,1).
-param(cAVZ,cYP,2).
-type(cAWD,cjava_DOT_lang_DOT_Integer,0).
-typeVar(cO).
-smaller(cAVN,cAVO).
-type(cAWA,cjava_DOT_lang_DOT_Integer,0).
-type(cAVF,cjava_DOT_lang_DOT_Object,0).
-typeVar(cYA).
-type(cAVU,cjava_DOT_lang_DOT_Integer,0).
-equals(cN,cAVV).
-smaller(cAVB,cAVC).
-type(cAVO,cjava_DOT_lang_DOT_Object,0).
-type(cAVB,cjava_DOT_io_DOT_Serializable,0).
-smallerDot(cT,cM).
-typeVar(cL).
-smallerDot(cM,cL).
-typeVar(cP).
-type(cAVQ,cjava_DOT_lang_DOT_Number,0).
-type(cAVR,cFaculty,0).
-smallerDot(cAWD,cAWE).
-typeVar(cYB).
-type(cAVE,cjava_DOT_lang_DOT_Integer,0).
-type(cAVN,cjava_DOT_lang_DOT_Number,0).
-equals(cT,cAVT).
-type(cAVV,cFaculty,0).
-type(cAVC,cjava_DOT_lang_DOT_Object,0).
-type(cAVM,cjava_DOT_lang_DOT_Object,0).
-smaller(cAVG,cAVH).
-type(cAVL,cjava_DOT_lang_DOT_Object,0).
-type(cAWE,cjava_DOT_lang_DOT_Integer,0).
-type(cAVG,cjava_DOT_lang_DOT_Integer,0).
-param(cAVT,cAVU,2).
-typeVar(cYO).
-type(cAWB,cjava_DOT_lang_DOT_Integer,0).
-type(cAVW,cjava_DOT_lang_DOT_Integer,0).
-typeVar(cM).
-param(cAVH,cAVI,1).
-typeVar(cQ).
-type(cAVX,cjava_DOT_lang_DOT_Integer,0).
-equals(cYA,cO).
-equals(cAWA,cP).
-smallerDot(cM,cAVZ).
-type(cAVK,cjava_DOT_io_DOT_Serializable,0).
-smallerDot(cP,cQ).
-smallerDot(cO,cAWB).
-param(cAVD,cAVE,1).
-smallerDot(cAVY,cYB).
-smallerDot(cAVW,cAVX).
-smaller(cAVD,cAVF).
-smaller(cAVL,cAVM).
-type(cAVP,cjava_DOT_lang_DOT_Integer,0).
-typeVar(cYP).
-typeVar(cN).
-type(cAVT,cFun2,2).
-param(cAVT,cRO,1).
-type(cAVS,cjava_DOT_lang_DOT_Object,0).
-type(cAWC,cFaculty,0).
-smallerDot(cN,cAWC).
-type(cAVZ,cFun2,2).
-smaller(cAVJ,cAVK).

asp/fc.lp.backup

@@ -1,125 +0,0 @@
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%Anzahl Wildcards in einem Typ feststellen:
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%Start, am Ende der Parameterliste:
-wildcard(A) :- extendsWildcard(A).
-wildcard(A) :- superWildcard(A).
-numWildcards(TP, Ende-1, Num) :- param(TP, Param, Ende),
-        numWildcards(Param, Num), type(TP,_,Ende)
-        , not wildcard(Param)
-        .
-numWildcards(TP, Ende-1, Num + 1) :- param(TP, Param, Ende),
-        numWildcards(Param, Num), type(TP,_,Ende)
-        , wildcard(Param)
-        .
-%Anschließend aufsummieren:
-numWildcards(TP, ParamNum-1, NumWC1 + NumWC2 + 1) :- param(TP, Param, ParamNum),
-        numWildcards(Param, NumWC1), numWildcards(TP,ParamNum, NumWC2)
-        , wildcard(Param)
-        .
-numWildcards(TP, ParamNum-1, NumWC1 + NumWC2) :- param(TP, Param, ParamNum),
-        numWildcards(Param, NumWC1), numWildcards(TP,ParamNum, NumWC2)
-        , not wildcard(Param)
-        .
-
-numWildcards(TP, Num) :- numWildcards(TP, 0, Num), param(TP, P, 1), wildcard(P).
-numWildcards(TP, Num) :- numWildcards(TP, 0, Num), param(TP, P, 1), not wildcard(P).
-numWildcards(TP, 0) :- type(TP, _, 0).
-numWildcards(TP, 0) :- typeVar(TP).
-
-%%%%%%%%%%%%%%%%
-% Greater
-%%%%%%%%%%%%%%%%
-{ greaterGen(P, A, AFC, BFC) : smaller(AFC, BFC), type(AFC, AN, ANum) } == 1 :- greaterGen(P, A), type(A, AN, ANum)
-%, greaterArgGenNum(P, N), N < 100000
-.
-%:- greaterGen(A, _, _ , _), numWildcards(A, NW), NW >= 1.
-type(P, BN, BNum) :- greaterGen(P, A, _, B), type(B, BN, BNum).
-%Bei den Parametern gibt es zwei Fälle:
-%% Die TPHs müssen gemapt werden, die anderen übernommen
-greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(Afc, B), PNum, _).
-greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, _, B), param(B, Param, PNum), type(B, _, _).
-param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
-	, type(Param, _, _)
-	.
-param(P, pointer(P, Param), PNum2) :- greaterGen(P, A, Afc, B), param(A, Param, PNum)
-	, mapFC(smaller(Afc,B), PNum, PNum2) 
-	.
-
-%TypeVars bleiben einfach TypeVars:
-typeVar(Pointer) :- greaterArgGen(Pointer, T), typeVar(T).
-
-makeGreaterGen(Pointer, T) :- greaterArgGen(Pointer, T), extendsWildcard(T).
-makeSmallerGen(Pointer, T) :- greaterArgGen(Pointer, T), superWildcard(T).
-makeSmallerGenG(Pointer, T),
-makeGreaterGenG(Pointer, T),
-makeSameGenG(Pointer, T)
-:- greaterArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
-
-greaterGen(P, T) :- makeGreaterGenG(P, T).
-extendsWildcard(P) :- makeGreaterGenG(P, T).
-
-smallerGen(P, T) :- makeGreaterGenG(P, T).
-superWildcard(P) :- makeSmallerGenG(P, T).
-
-{ greaterGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenG(P, T), type(T, TN, TNum).
-
-greaterArgGenNum(P, 0) :- greaterArgGen(P, _), type(P, _ ,_).
-greaterArgGenNum(pointer(P, P2), Num + 1) :- greaterArgGen(pointer(P, P2),_), greaterArgGenNum(P, Num).
-
-
-%%%%%%%%%%%%%%%%%
-% smaller
-%%%%%%%%%%%%%%%%
-{ smallerGen(P, A, AFC, BFC) : smaller(BFC, AFC), type(AFC, AN, ANum) } == 1 :- smallerGen(P, A), type(A, AN, ANum)
-.
-{ type(P, BN, BNum) : type(B,BN,BNum) } == 1 :- smallerGen(P, A, _, B).
-%Bei den Parametern gibt es drei Fälle:
-%% Die TPHs müssen gemapt werden, die anderen übernommen
-smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(B, Afc), _, PNum).
-param(P, pointer(P, Param), PNum2) :- smallerGen(P, A, Afc, B), param(A, Param, PNum)
-	, mapFC(smaller(B,Afc), PNum2, PNum) 
-	.
-
-%Neue Parameter können hinzu kommen: TODO
-%smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, _, B), param(B, Param, PNum).
-%param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
-%	%, type(Param, _, _) %Es ist egal ob es ein Typparameter oder eine TypeVar ist. smallerArgGen macht das richtige
-%	.
-
-%Es können voraussetzungen hinzukommen:
-equals(Param, PA) :- smallerGen(P, A, Afc, B), param(Afc, Param, PNum), type(Param, _, _), param(A, PA, PNum).
-
-%TypeVars bleiben einfach TypeVars:
-typeVar(Pointer) :- smallerArgGen(Pointer, T), typeVar(T).
-
-makeSmallerGenS(Pointer, T) :- smallerArgGen(Pointer, T), extendsWildcard(T).
-makeGreaterGenS(Pointer, T) :- smallerArgGen(Pointer, T), superWildcard(T).
-makeSmallerGenS(Pointer, T),
-makeGreaterGenS(Pointer, T),
-makeSameGenS(Pointer, T)
-:- smallerArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
-
-greaterGen(P, T) :- makeGreaterGenS(P, T).
-extendsWildcard(P) :- makeGreaterGenS(P, T).
-
-smallerGen(P, T) :- makeSmallerGenS(P, T).
-superWildcard(P) :- makeSmallerGenS(P, T).
-
-{ smallerGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenS(P, T), type(T, TN, TNum).
-
-
-%%%
-% Grundlegende Regeln
-%%%
-smaller(A, A) :- smaller(A, _).
-smaller(B, B) :- smaller(_, B).
-%smaller(A, A) :- type(A). %Alle Typen erben von sich selber. Hätte komische Nebeneffekte
-
-%Mapping:
-mapFC(smaller(A,B), Num, Num2) :- smaller(A,B), param(A, P, Num), typeVar(P), param(B, P, Num2).
-
-hasTypeInParameterList(A) :- type(A, _, _), param(A, P, _), type(P, _, _).
-mapRootFC(smaller(A,B), Num, Num2) :- smaller(A, B), not hasTypeInParameterList(A), param(A, P, Num), typeVar(P), param(B, P, Num2).
-

asp/fc.lp.old

@@ -1,110 +0,0 @@
-
-wildcard(A) :- extendsWildcard(A).
-wildcard(A) :- superWildcard(A).
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%Anzahl der Wildcards ist 1
-% Mehr benötigt man nicht verschachtelt
-% Dadurch ist numWildcards unnötig, man ändert einfach die grArg auf Wildcards
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-type(P, TN, TNum) :- makeSameGen(P, T), type(T, TN, TNum).
-param(P, TN, TNum) :- makeSameGen(P, T), param(T, TN, TNum).
-superWildcard(P) :- makeSameGen(P, T), superWildcard(T).
-extendsWildcard(P) :- makeSameGen(P, T), extendsWildcard(T).
-
-%%%%%%%%%%%%%%%%%
-% Greater
-%%%%%%%%%%%%%%%%
-{ greaterGen(P, A, AFC, BFC) : smaller(AFC, BFC), type(AFC, AN, ANum) } == 1 :- greaterGen(P, A), type(A, AN, ANum)
-.
-
-type(P, BN, BNum) :- greaterGen(P, A, _, B), type(B, BN, BNum).
-%Bei den Parametern gibt es zwei Fälle:
-%% Die TPHs müssen gemapt werden, die anderen übernommen
-greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(Afc, B), PNum, _).
-greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, _, B), param(B, Param, PNum), type(B, _, _).
-param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
-	, type(Param, _, _)
-	.
-param(P, pointer(P, Param), PNum2) :- greaterGen(P, A, Afc, B), param(A, Param, PNum)
-	, mapFC(smaller(Afc,B), PNum, PNum2)
-	.
-
-%TypeVars bleiben einfach TypeVars:
-typeVar(Pointer) :- greaterArgGen(Pointer, T), typeVar(T).
-
-%makeGreaterGen(Pointer, T) :- greaterArgGen(Pointer, T), extendsWildcard(T).
-%makeSmallerGen(Pointer, T) :- greaterArgGen(Pointer, T), superWildcard(T).
-makeSameGen(Pointer, T) :- greaterArgGen(Pointer, T), extendsWildcard(T).
-makeSameGen(Pointer, T) :- greaterArgGen(Pointer, T), superWildcard(T).
-makeSmallerGenG(Pointer, T),
-makeGreaterGenG(Pointer, T),
-makeSameGenG(Pointer, T)
-:- greaterArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
-
-greaterGen(P, T) :- makeGreaterGenG(P, T).
-extendsWildcard(P) :- makeGreaterGenG(P, T).
-
-smallerGen(P, T) :- makeGreaterGenG(P, T).
-superWildcard(P) :- makeSmallerGenG(P, T).
-
-{ greaterGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenG(P, T), type(T, TN, TNum).
-
-greaterArgGenNum(P, 0) :- greaterArgGen(P, _), type(P, _ ,_).
-greaterArgGenNum(pointer(P, P2), Num + 1) :- greaterArgGen(pointer(P, P2),_), greaterArgGenNum(P, Num).
-
-
-%%%%%%%%%%%%%%%%%
-% smaller
-%%%%%%%%%%%%%%%%
-{ smallerGen(P, A, AFC, BFC) : smaller(BFC, AFC), type(AFC, AN, ANum) } == 1 :- smallerGen(P, A), type(A, AN, ANum)
-.
-{ type(P, BN, BNum) : type(B,BN,BNum) } == 1 :- smallerGen(P, A, _, B).
-%Bei den Parametern gibt es drei Fälle:
-%% Die TPHs müssen gemapt werden, die anderen übernommen
-smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(B, Afc), _, PNum).
-param(P, pointer(P, Param), PNum2) :- smallerGen(P, A, Afc, B), param(A, Param, PNum)
-	, mapFC(smaller(B,Afc), PNum2, PNum) 
-	.
-
-%Neue Parameter können hinzu kommen: TODO
-%smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, _, B), param(B, Param, PNum).
-%param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
-%	%, type(Param, _, _) %Es ist egal ob es ein Typparameter oder eine TypeVar ist. smallerArgGen macht das richtige
-%	.
-
-%Es können voraussetzungen hinzukommen:
-equals(Param, PA) :- smallerGen(P, A, Afc, B), param(Afc, Param, PNum), type(Param, _, _), param(A, PA, PNum).
-
-%TypeVars bleiben einfach TypeVars:
-typeVar(Pointer) :- smallerArgGen(Pointer, T), typeVar(T).
-
-makeSameGen(Pointer, T) :- smallerArgGen(Pointer, T), extendsWildcard(T).
-makeSameGen(Pointer, T) :- smallerArgGen(Pointer, T), superWildcard(T).
-makeSmallerGenS(Pointer, T),
-makeGreaterGenS(Pointer, T),
-makeSameGenS(Pointer, T)
-:- smallerArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
-
-greaterGen(P, T) :- makeGreaterGenS(P, T).
-extendsWildcard(P) :- makeGreaterGenS(P, T).
-
-smallerGen(P, T) :- makeSmallerGenS(P, T).
-superWildcard(P) :- makeSmallerGenS(P, T).
-
-{ smallerGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenS(P, T), type(T, TN, TNum).
-
-
-%%%
-% Grundlegende Regeln
-%%%
-smaller(A, A) :- smaller(A, _).
-smaller(B, B) :- smaller(_, B).
-%smaller(A, A) :- type(A). %Alle Typen erben von sich selber. Hätte komische Nebeneffekte
-
-%Mapping:
-mapFC(smaller(A,B), Num, Num2) :- smaller(A,B), param(A, P, Num), typeVar(P), param(B, P, Num2).
-
-hasTypeInParameterList(A) :- type(A, _, _), param(A, P, _), type(P, _, _).
-mapRootFC(smaller(A,B), Num, Num2) :- smaller(A, B), not hasTypeInParameterList(A), param(A, P, Num), typeVar(P), param(B, P, Num2).
-

asp/greater.pl

@@ -1,17 +0,0 @@
-{ fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)) : type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8) } == 1 :- greaterGen(V1,V2).
-{ fun19(typeVar(V15),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : typeVar(V15) ; fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), extendsWildcard(V15), type(V15,V16,V17) ; fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : superWildcard(V15), notExtends(V15), type(V15,V16,V17) } == 1 :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14).
-param(V2,V15,V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), typeVar(V15), fun19(typeVar(V15),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-param(V2,V15,V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-superWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-smallerGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-superWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-smallerGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-extendsWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-greaterGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-extendsWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-greaterGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
-type(V2,V9,V12) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)).

asp/pi.pl

@@ -1,4 +0,0 @@
-pi(V1,V2,V4,V5) :- typeVar(V3), param(V1,V3,V4), param(V2,V3,V5), type(V1,V10,V8), param(V1,V9,V7), typeVar(V9), V7 = 1 .. V8, type(V2,V14,V12), param(V2,V13,V11), typeVar(V13), V11 = 1 .. V12.
-
-notSuper(V1) :- type(V1,_,_), not superWildcard(V1).
-notExtends(V1) :- type(V1,_,_), not extendsWildcard(V1).

asp/reduceRules.lp

@@ -1,44 +0,0 @@
-
-%%%%%%%%%%%%%%%%%%%%
-% reduce1
-%%%%%%%%%%%%%%%%%%%%
-smallerDotWC(CP, DP)
-:- smallerDot(C, D), type(C, CN, NP), type(D, DN, NP)
-	, type(CFC, CN, NP), type(DFC, DN, NP), smaller(CFC, DFC)
-	, pi(CFC, DFC, N, N2)
-	, param(C, CP, N), param(D, DP, N2), N = 1 .. NP
-	.
-
-
-%%%%%%%%%%%%%%%%%%%%
-% reduceExt
-%%%%%%%%%%%%%%%%%%%%
-%TODO
-%smallerDotWC(CP, DP)
-%:- smallerDotWC(C, D), type(C, CN, NP), type(D, DN, NP)
-	%, type(CFC, CN, NP), type(DFC, DN, NP), smaller(CFC, DFC)
-	%, pi(CFC, DFC, N, N2)
-	%, param(C, CP, N), param(D, DP, N2), N = 1 .. NP
-	%.
-
-
-%%%%%%%%%%%%%%%%%%%%
-% reduceEq
-%%%%%%%%%%%%%%%%%%%%
-equals(CP, DP)
-:- smallerDot(C, D), type(C, CN, NP), type(D, CN, NP)
-	, param(C, CP, N), param(D, DP, N), N = 1 .. NP
-	.
-
-
-%%%%%%%%%%%%%%%%%%%%
-% reduce2
-%%%%%%%%%%%%%%%%%%%%
-equals(P1, P2) :- equals(C, D), type(C, CN, NP), type(D, CN, NP)
-	, param(C, P1, N), param(D, P2, N)
-	.
-
-%%%%%%%%%%%%%%%%%%%%
-% swap
-%%%%%%%%%%%%%%%%%%%%
-equals(A, B) :- equals(B, A), typeVar(A), not typeVar(B).

asp/result.lp

@@ -1 +0,0 @@
-:- equals(A, B), equals(A, C), type(B,BN,_), type(C,CN,_), CN != BN.

asp/rule5.test

@@ -1,291 +0,0 @@
-param(cEPQ,cAEG,1).
-param(cEQX,cAEG,1).
-param(cEQE,cAEG,1).
-typeVar(cBFS).
-type(cEON,cjava_DOT_io_DOT_Serializable,0).
-constraint(cESK,list(equals(cESN,cM),list(smallerDot(cL,cESM),list(smallerDot(cESL,cQC),null)))).
-type(cESM,cjava_DOT_util_DOT_ArrayList,1).
-param(cERA,cDKY,1).
-param(cEQM,cDKY,1).
-type(cEQE,cjava_DOT_util_DOT_List,1).
-type(cEQI,cjava_DOT_util_DOT_Collection,1).
-type(cEPS,cjava_DOT_util_DOT_AbstractList,1).
-param(cEQD,cBFS,1).
-type(cEPQ,cjava_DOT_lang_DOT_Iterable,1).
-type(cEOM,cjava_DOT_util_DOT_ArrayList,1).
-smaller(cEOW,cEOX).
-type(cEPV,cjava_DOT_lang_DOT_Object,0).
-param(cERQ,cCII,1).
-param(cEPY,cDKY,1).
-smaller(cEPM,cEPN).
-param(cEOQ,cBFS,1).
-smaller(cEQC,cEQD).
-type(cERM,cjava_DOT_util_DOT_Vector,1).
-param(cESJ,cQF,1).
-type(cESN,cjava_DOT_lang_DOT_Boolean,0).
-smaller(cEPI,cEPJ).
-type(cERJ,cjava_DOT_util_DOT_Collection,1).
-type(cEQA,cjava_DOT_util_DOT_ArrayList,1).
-type(cEOA,cjava_DOT_util_DOT_ArrayList,1).
-param(cEOT,cBFS,1).
-type(cEOW,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cEPC,cCII,1).
-type(cEQB,cjava_DOT_util_DOT_AbstractList,1).
-param(cENS,cCII,1).
-type(cEQS,cjava_DOT_util_DOT_Collection,1).
-typeVar(cDKY).
-type(cEPU,cjava_DOT_util_DOT_AbstractCollection,1).
-smaller(cEQG,cEQH).
-type(cEQJ,cjava_DOT_lang_DOT_Object,0).
-param(cEQG,cCII,1).
-param(cEPN,cCII,1).
-param(cESE,cDKY,1).
-param(cEQZ,cBFS,1).
-type(cERK,cjava_DOT_util_DOT_Vector,1).
-smaller(cEPE,cEPF).
-type(cEOK,cjava_DOT_util_DOT_ArrayList,1).
-typeVar(cQC).
-smaller(cERE,cERF).
-param(cEOA,cCII,1).
-type(cEQQ,cjava_DOT_lang_DOT_Iterable,1).
-smaller(cEPA,cEPB).
-typeVar(cM).
-smaller(cERA,cERB).
-type(cEPP,cjava_DOT_lang_DOT_Object,0).
-param(cEPS,cCII,1).
-param(cENQ,cAEG,1).
-param(cEPH,cCII,1).
-smaller(cERW,cERX).
-type(cEOG,cjava_DOT_util_DOT_Collection,1).
-type(cERE,cjava_DOT_io_DOT_Serializable,0).
-param(cERG,cDKY,1).
-smaller(cERS,cERT).
-param(cEOF,cBFS,1).
-type(cESA,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cERY,cDKY,1).
-typeVar(cCII).
-type(cEOO,cjava_DOT_util_DOT_Collection,1).
-type(cERN,cjava_DOT_lang_DOT_Cloneable,0).
-param(cENO,cBFS,1).
-typeVar(cAEG).
-type(cERB,cjava_DOT_lang_DOT_Object,0).
-typeVar(cQD).
-param(cEQP,cAEG,1).
-param(cEOO,cAEG,1).
-type(cESF,cjava_DOT_io_DOT_Serializable,0).
-param(cEPE,cBFS,1).
-type(cEPG,cjava_DOT_util_DOT_ArrayList,1).
-type(cEPD,cjava_DOT_util_DOT_Collection,1).
-type(cERC,cjava_DOT_util_DOT_AbstractCollection,1).
-type(cERQ,cjava_DOT_util_DOT_ArrayList,1).
-type(cENW,cjava_DOT_lang_DOT_Iterable,1).
-type(cENQ,cjava_DOT_util_DOT_ArrayList,1).
-smaller(cESC,cESD).
-type(cEOU,cjava_DOT_util_DOT_List,1).
-smaller(cENO,cENP).
-smaller(cEOE,cEOF).
-smaller(cERO,cERP).
-type(cEPH,cjava_DOT_util_DOT_List,1).
-smaller(cESE,cESF).
-param(cERO,cCII,1).
-param(cEOS,cBFS,1).
-type(cEQX,cjava_DOT_util_DOT_List,1).
-type(cEQR,cjava_DOT_lang_DOT_Object,0).
-param(cEQY,cBFS,1).
-smaller(cEQW,cEQX).
-smaller(cEOC,cEOD).
-smaller(cERM,cERN).
-param(cEPT,cCII,1).
-param(cEQQ,cBFS,1).
-param(cERZ,cDKY,1).
-type(cENV,cjava_DOT_util_DOT_AbstractCollection,1).
-type(cEOZ,cjava_DOT_lang_DOT_Object,0).
-param(cEQK,cAEG,1).
-type(cEQO,cjava_DOT_util_DOT_AbstractList,1).
-type(cEQU,cjava_DOT_util_DOT_Vector,1).
-smaller(cEOK,cEOL).
-type(cEQW,cjava_DOT_util_DOT_ArrayList,1).
-type(cENO,cjava_DOT_util_DOT_ArrayList,1).
-type(cERF,cjava_DOT_lang_DOT_Object,0).
-param(cEPA,cCII,1).
-type(cERV,cjava_DOT_io_DOT_Serializable,0).
-smaller(cERG,cERH).
-param(cEOU,cCII,1).
-param(cENU,cDKY,1).
-param(cESM,cQE,1).
-param(cEOP,cAEG,1).
-param(cEPO,cBFS,1).
-param(cEOK,cBFS,1).
-constraint(cESG,list(smallerDot(cL,cESJ),list(equals(cESI,cM),list(smallerDot(cESH,cQD),null)))).
-type(cEPE,cjava_DOT_util_DOT_ArrayList,1).
-param(cEQF,cAEG,1).
-smaller(cEPY,cEPZ).
-param(cESC,cDKY,1).
-param(cENY,cAEG,1).
-param(cEOM,cAEG,1).
-smaller(cEQO,cEQP).
-type(cEOR,cjava_DOT_lang_DOT_Object,0).
-type(cESC,cjava_DOT_util_DOT_List,1).
-type(cEOP,cjava_DOT_lang_DOT_Iterable,1).
-type(cERU,cjava_DOT_util_DOT_ArrayList,1).
-type(cERY,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cEPL,cAEG,1).
-param(cEOX,cAEG,1).
-type(cEQK,cjava_DOT_util_DOT_ArrayList,1).
-type(cERZ,cjava_DOT_util_DOT_Collection,1).
-param(cEQA,cBFS,1).
-param(cERI,cDKY,1).
-smaller(cEPC,cEPD).
-type(cEQT,cjava_DOT_lang_DOT_Iterable,1).
-type(cERT,cjava_DOT_lang_DOT_Object,0).
-type(cEOY,cjava_DOT_lang_DOT_Cloneable,0).
-param(cEQU,cDKY,1).
-type(cEPB,cjava_DOT_util_DOT_AbstractCollection,1).
-type(cESI,cjava_DOT_lang_DOT_Boolean,0).
-smaller(cENU,cENV).
-type(cESE,cjava_DOT_util_DOT_Vector,1).
-param(cEOG,cCII,1).
-type(cEOI,cjava_DOT_util_DOT_List,1).
-type(cENU,cjava_DOT_util_DOT_AbstractList,1).
-smaller(cERU,cERV).
-type(cEPN,cjava_DOT_util_DOT_AbstractList,1).
-type(cEQV,cjava_DOT_util_DOT_List,1).
-type(cEPA,cjava_DOT_util_DOT_AbstractList,1).
-smaller(cEPQ,cEPR).
-type(cEQL,cjava_DOT_util_DOT_AbstractList,1).
-param(cEQH,cCII,1).
-type(cEOL,cjava_DOT_lang_DOT_Cloneable,0).
-type(cEQY,cjava_DOT_util_DOT_AbstractList,1).
-type(cEOF,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cEQT,cBFS,1).
-smaller(cEOS,cEOT).
-type(cENR,cjava_DOT_lang_DOT_Cloneable,0).
-type(cEQD,cjava_DOT_util_DOT_Collection,1).
-type(cENZ,cjava_DOT_lang_DOT_Object,0).
-param(cEPG,cCII,1).
-type(cEQF,cjava_DOT_util_DOT_Collection,1).
-type(cEQN,cjava_DOT_util_DOT_List,1).
-type(cEQH,cjava_DOT_util_DOT_Collection,1).
-smaller(cEOY,cEOZ).
-type(cERR,cjava_DOT_lang_DOT_Cloneable,0).
-param(cERU,cCII,1).
-type(cESB,cjava_DOT_lang_DOT_Object,0).
-smaller(cEPO,cEPP).
-param(cEPU,cDKY,1).
-param(cEQI,cDKY,1).
-smaller(cEQE,cEQF).
-smaller(cEQA,cEQB).
-type(cEPM,cjava_DOT_util_DOT_ArrayList,1).
-param(cENW,cCII,1).
-param(cEOE,cBFS,1).
-type(cEOX,cjava_DOT_util_DOT_Collection,1).
-type(cEQG,cjava_DOT_util_DOT_List,1).
-param(cERH,cDKY,1).
-smaller(cEQI,cEQJ).
-param(cEOC,cAEG,1).
-type(cEPT,cjava_DOT_util_DOT_List,1).
-type(cEOT,cjava_DOT_util_DOT_Collection,1).
-type(cERP,cjava_DOT_lang_DOT_Object,0).
-type(cERS,cMyVector,0).
-type(cESD,cjava_DOT_lang_DOT_Object,0).
-type(cEOD,cjava_DOT_util_DOT_RandomAccess,0).
-smaller(cEPK,cEPL).
-type(cEPK,cjava_DOT_util_DOT_AbstractList,1).
-param(cERM,cDKY,1).
-smaller(cEPG,cEPH).
-type(cEOS,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cEQS,cBFS,1).
-param(cEQW,cAEG,1).
-type(cENY,cjava_DOT_util_DOT_Collection,1).
-param(cEPW,cBFS,1).
-type(cEOJ,cjava_DOT_lang_DOT_Object,0).
-param(cEQC,cBFS,1).
-type(cENT,cjava_DOT_lang_DOT_Iterable,1).
-param(cERK,cDKY,1).
-type(cEPY,cjava_DOT_util_DOT_Vector,1).
-type(cEQM,cjava_DOT_util_DOT_AbstractList,1).
-smaller(cENW,cENX).
-smaller(cEPW,cEPX).
-smaller(cEOM,cEON).
-smaller(cEQM,cEQN).
-smaller(cEPS,cEPT).
-type(cENX,cjava_DOT_lang_DOT_Object,0).
-smallerDot(cL,cK).
-type(cESJ,cjava_DOT_util_DOT_Vector,1).
-type(cEQC,cjava_DOT_util_DOT_List,1).
-type(cEOB,cjava_DOT_util_DOT_RandomAccess,0).
-smaller(cEOU,cEOV).
-param(cERC,cAEG,1).
-smaller(cEQU,cEQV).
-type(cERG,cjava_DOT_util_DOT_Collection,1).
-type(cESH,cjava_DOT_lang_DOT_Object,0).
-smaller(cEOQ,cEOR).
-oder(cESG,cESK).
-smaller(cEQQ,cEQR).
-param(cEPD,cCII,1).
-type(cEPZ,cjava_DOT_util_DOT_AbstractList,1).
-param(cEQL,cAEG,1).
-type(cEPC,cjava_DOT_util_DOT_AbstractCollection,1).
-smaller(cENS,cENT).
-param(cESA,cBFS,1).
-type(cERA,cjava_DOT_lang_DOT_Iterable,1).
-smaller(cEQY,cEQZ).
-typeVar(cQE).
-type(cEOE,cjava_DOT_util_DOT_AbstractList,1).
-type(cESL,cjava_DOT_lang_DOT_Object,0).
-type(cERX,cjava_DOT_lang_DOT_Object,0).
-type(cENP,cjava_DOT_util_DOT_List,1).
-type(cEPI,cjava_DOT_util_DOT_RandomAccess,0).
-typeVar(cK).
-smaller(cERK,cERL).
-type(cERD,cjava_DOT_lang_DOT_Object,0).
-type(cERI,cjava_DOT_util_DOT_List,1).
-type(cEPJ,cjava_DOT_lang_DOT_Object,0).
-smaller(cESA,cESB).
-type(cEOC,cjava_DOT_util_DOT_ArrayList,1).
-param(cEOW,cAEG,1).
-param(cERJ,cDKY,1).
-param(cEQB,cBFS,1).
-smaller(cEOI,cEOJ).
-type(cEPL,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cEQO,cAEG,1).
-smaller(cERI,cERJ).
-typeVar(cQF).
-param(cEPK,cAEG,1).
-param(cENP,cBFS,1).
-type(cERO,cjava_DOT_util_DOT_AbstractCollection,1).
-typeVar(cL).
-smaller(cEOG,cEOH).
-param(cEQV,cDKY,1).
-type(cERW,cjava_DOT_lang_DOT_Object,0).
-type(cEQZ,cjava_DOT_util_DOT_List,1).
-type(cENS,cjava_DOT_util_DOT_Collection,1).
-smaller(cENY,cENZ).
-param(cEOI,cAEG,1).
-smaller(cEOO,cEOP).
-smaller(cERY,cERZ).
-param(cEPZ,cDKY,1).
-param(cEQN,cDKY,1).
-smaller(cEQK,cEQL).
-type(cEOH,cjava_DOT_lang_DOT_Object,0).
-type(cEPF,cjava_DOT_util_DOT_RandomAccess,0).
-smaller(cERC,cERD).
-type(cEPO,cjava_DOT_util_DOT_List,1).
-type(cEPR,cjava_DOT_lang_DOT_Object,0).
-type(cEQP,cjava_DOT_util_DOT_List,1).
-smaller(cEQS,cEQT).
-type(cERL,cjava_DOT_util_DOT_RandomAccess,0).
-param(cENT,cCII,1).
-type(cEOQ,cjava_DOT_util_DOT_Collection,1).
-type(cEPW,cjava_DOT_util_DOT_ArrayList,1).
-type(cEPX,cjava_DOT_io_DOT_Serializable,0).
-smaller(cEPU,cEPV).
-smaller(cEOA,cEOB).
-type(cEOV,cjava_DOT_lang_DOT_Object,0).
-param(cEPB,cCII,1).
-smaller(cENQ,cENR).
-param(cEPM,cCII,1).
-smaller(cERQ,cERR).
-param(cENV,cDKY,1).
-type(cERH,cjava_DOT_lang_DOT_Iterable,1).
-

asp/smaller.pl

@@ -1,15 +0,0 @@
-{ fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)) : type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7) } == 1 :- smallerGen(V1,V2).
-{ fun19(typeVar(V15),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : typeVar(V15) ; fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun21(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : superWildcard(V15), notExtends(V15), type(V15,V16,V17) ; fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : superWildcard(V15), notExtends(V15), type(V15,V16,V17) ; fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : notSuper(V15), extendsWildcard(V15), type(V15,V16,V17) ; fun24(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : notSuper(V15), extendsWildcard(V15), type(V15,V16,V17) } == 1 :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13).
-param(V2,V15,V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), typeVar(V15), fun19(typeVar(V15),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-param(V2,V15,V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun21(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-greaterGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun21(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-superWildcard(pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-greaterGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-extendsWildcard(pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-smallerGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun24(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-smallerGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun24(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
-type(V2,V9,V12) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)).

asp/step4.lp

@@ -1,116 +0,0 @@
-wildcard(A) :- superWildcard(A).
-wildcard(A) :- extendsWildcard(A).
-
-%Problem hier: Es gibt in der FiniteClosure nun smaller Beziehungen der Art:
-%%(Matrix<A> <) Vector<Vector<A>> < List<Vector<A>>
-%Mit diesen funktioniert die Unifikation in Schritt 4 des Algorithmus nicht korrekt.
-%Lösung: Man könnte es lösen mit:
-%typeVarOnly(TP) :- type(TP, _, PN), {notTypeVarOnly(TP, A) : param(TP, A, _), type(A, _, _)} == 0.
-
-% Die Karthesischen Produkte von Schritt 4 des Unifikationsalgorithmus
-
-{ makeRule1(A,TP,TPFC, SmallerType) : smaller(SmallerType, TPFC), type(TPFC, TypeName, NumParams) } = 1
-:- smallerDot(A, TP), type(TP, TypeName, NumParams), typeVar(A).%, smaller(_, TPFC), type(TPFC, TypeName, NumParams).
-
-%:- makeRule1(A, B, C,_), makeRule1(A,B,D,_), D != C.
-
-%Alle Greater Arg Paralisten des Typen C generieren
-greaterArgParaList(pointer(rule1(A, TP)), TPFC) :- makeRule1(A,TP,TPFC,_).
-
-%Es braucht greaterArg Parameter von allen Parametern des Typs:
-greaterArg(pointer(P, Param), Param)  :- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN), param(FCType, Param, Num), not typeVar(Param).
-
-%Ein neuer Typ muss angelegt werden:
-type(P, FCTName, FCTPN) 
-:- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN).
-
-param(P, pointer(P, Param), N)
-:- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN)
-	, param(FCType, Param, N), not typeVar(Param)
-	.
-%Typvariablen bleiben bestehen. Sie werden durch das unify ausgetauscht
-param(P, Param, N)
-:- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN)
-	, param(FCType, Param, N), typeVar(Param)
-	.
-
-
-%Die Unifikation vom AusgangsTyp im Constraint und dem greaterArgList gebildeten Typen
-unify(pointer(rule1unify(A,TP)), pointer(rule1(A,TP)), TP) 
-:- makeRule1(A,TP,TPFC, _).
-
-%Unify auf den SmallerType anwenden:
-type(pointer(rule1unify(A,TP,TPFC,SmallerType)), TN, TNum)
-:- makeRule1(A, TP, TPFC, SmallerType), type(SmallerType, TN, TNum).
-
-{ param(pointer(rule1unify(A,TP,TPFC,SmallerType)), PNew, PN) : unify(pointer(rule1unify(A,TP)), P, PNew)} == 1
-:- makeRule1(A, TP, TPFC, SmallerType), param(SmallerType, P, PN).
-
-%Am Schluss davon noch das smaller bilden:
-smallerGen(pointer(smallerDot(A,TP), SmallerType), pointer(rule1unify(A,TP,TPFC,SmallerType)))
-:- makeRule1(A, TP, TPFC, SmallerType), type(TP, TypeName, NumParams) %Die Bedingung für Regel 1
-	.
-
-smallerGen(A) :- list(smallerGen(A),_).
-type(A,B,C) :- list(type(A,B,C),_).
-list(A,B) :- list(_, list(A,B)).
-
-smallerGen(A,A) :- smallerGen(A).
-
-{ equals(A, NewType) : smallerGen(pointer(smallerDot(A,TP), SmallerType), NewType) } == 1
-:- smallerDot(A, TP), type(TP, TypeName, NumParams), typeVar(A) %Das karthesische Produkt
-	, smaller(SmallerType, TPFC), type(pointer(smallerDot(A,TP), SmallerType), _, _)
- 	.
-
-%TODO: Typen welche durch Unifikation ersetzt werden auch zu Constraints machen
-%%%%%%%%%%%%%%%%%%
-% Regel 2
-%%%%%%%%%%%%%%%%%
-
-%{ makeRule2(A, Theta', TPFC) : smaller(SmallerType, TPFC), type(TPFC, TypeName, NumParams) } == 1
-%:- smallerDotWC(A, Theta'), extendsWildcard(Theta'), typeVar(A).
-%
-%%Alle Greater Arg Paralisten des Typen C generieren
-%greaterArgParaList(pointer(rule2(A, TP)), TPFC) :- makeRule2(A,TP,TPFC,_).
-%
-%unify(pointer(rule2(A,TP)), TP) 
-%:- makeRule2(A,TP,TPFC)
-%%	, type(TP, TypeName, NumParams), typeVar(A), type(TPFC, TypeName, NumParams)
-	%.
-%
-%{ list(smallerArgGen(pointer(smallerDot(A,TP), SmallerType), SmallerType),
-%list(extendsWildcard(pointer(smallerDot(A,TP), SmallerType)), null))
-%: smaller(SmallerType, TPFC), type(SmallerType, SmallerName, SmallerPNum) } == 1
-%:- makeRule2(A, TP, TPFC) %Die Bedingung für Regel 2
-	%.
-%
-%smallerArgGen(A, B) :- list(smallerArgGen(A, B), _).
-%extendsWildcard(A) :- list(extendsWildcard(A), _).
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Regel 3
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-smallerArgGen(pointer(smallerDotWC(A, Theta')), Theta') :- smallerDotWC(A, Theta'), superWildcard(Theta').
-equals(A, pointer(smallerDotWC(A, Theta'))) :- smallerDotWC(A, Theta'), superWildcard(Theta').
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Regel 4
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-equals(A, Theta') :- smallerDotWC(A, Theta'), not wildcard(Theta').
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Regel 5
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-greaterGen(pointer(smallerDot(Theta,A)), Theta) :- smallerDot(Theta, A), not wildcard(Theta), not typeVar(Theta), typeVar(A) .
-equals(A, pointer(smallerDot(Theta,A))) :- smallerDot(Theta, A), not wildcard(Theta) , not typeVar(Theta), typeVar(A) .
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Regel 6
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-greaterArgGen(pointer(smallerDotWC(Theta,A)), Theta) :- smallerDotWC(Theta, A), extendsWildcard(Theta) .
-equals(A, pointer(smallerDot(Theta,A))) :- smallerDotWC(Theta, A), extendsWildcard(Theta) .
-
-%TODO: Regel 7

asp/step4.test

@@ -1,8 +0,0 @@
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Regel 5
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
-greaterGen(pointer(smallerDot(Theta,A)), Theta) :- smallerDot(Theta, A), not wildcard(Theta), not typeVar(Theta), typeVar(A) .
-equals(A, pointer(smallerDot(Theta,A))) :- smallerDot(Theta, A), not wildcard(Theta) , not typeVar(Theta), typeVar(A) .
-
-

asp/subst.lp

@@ -1,14 +0,0 @@
-subst(TV,T) :- equals(TV, T), not occurs(TV, T), not typeVar(T), typeVar(TV).
-
-equals(A, pointer(TP, subst(TV, T)))
-:- equals(A, TP), subst(TV, T), not typeVar(TP), occurs(TV, TP).
-
-type(pointer(TP, subst(TV, T)), Name, Num)
-:- type(TP, Name, Num), subst(TV, T), occurs(TV, TP).
-
-param(pointer(TP, subst(TV, T)), Param, PNum)
-:- type(pointer(TP, subst(TV, T)), Name, Num), subst(TV, T), param(TP, Param, PNum), not occurs(TV, Param).
-
-param(pointer(TP, subst(TV, T)), pointer(Param, subst(TV, T)), PNum)
-:- type(pointer(TP, subst(TV, T)), Name, Num), subst(TV, T), param(TP, Param, PNum), occurs(TV, Param).
-

asp/testInput.lp

@@ -1,219 +0,0 @@
-typeVar(a).
-type(t1, cjava_DOT_util_DOT_Vector, 1).
-param(t1, t2, 1).
-type(t2, cjava_DOT_util_DOT_Vector, 1).
-param(t2, b, 1).
-typeVar(b).
-
-smallerDot(a, t1).
-
-
-typeFC(cBUF,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBQX,cAKH,1).
-typeFC(cBRW,cjava_DOT_lang_DOT_Object,0).
-typeFC(cBRF,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBTR,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBTZ,cAKH,1).
-paramFC(cBUN,cAKH,1).
-typeFC(cBRY,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBUE,cBUF,1).
-paramFC(cBRL,cAKH,1).
-smaller(cBSB,cBSE).
-paramFC(cBTR,cBTS,1).
-smaller(cBQJ,cBQK).
-typeFC(cBQP,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBUA,cjava_DOT_util_DOT_Collection,1).
-typeFC(cBSD,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBUE,cjava_DOT_util_DOT_Collection,1).
-typeFC(cBUK,cjava_DOT_util_DOT_Collection,1).
-paramFC(cBTJ,cAKH,1).
-typeFC(cBRZ,cjava_DOT_lang_DOT_Integer,0).
-smaller(cBSF,cBSI).
-typeFC(cBRT,cjava_DOT_lang_DOT_Integer,0).
-paramFC(cBRX,cBRY,1).
-typeFC(cBRJ,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBRF,cBRG,1).
-typeFC(cBQN,cjava_DOT_lang_DOT_Integer,0).
-smaller(cBRL,cBRM).
-smaller(cBUH,cBUK).
-smaller(cBTR,cBTU).
-paramFC(cBUL,cBUM,1).
-smaller(cBRH,cBRI).
-typeFC(cBTV,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBSQ,cjava_DOT_lang_DOT_Object,0).
-typeFC(cBUL,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBTX,cjava_DOT_lang_DOT_Object,0).
-paramFC(cBSN,cAKH,1).
-typeFC(cBTE,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBUC,cBUD,1).
-smaller(cBST,cBSU).
-paramFC(cBRI,cAKH,1).
-typeFC(cBSR,cjava_DOT_lang_DOT_Iterable,1).
-typeFC(cBRC,cjava_DOT_util_DOT_RandomAccess,0).
-typeFC(cBTL,cjava_DOT_util_DOT_Collection,1).
-typeFC(cBSF,cjava_DOT_util_DOT_AbstractList,1).
-typeFC(cBSX,cjava_DOT_util_DOT_AbstractList,1).
-paramFC(cBSI,cBSJ,1).
-typeFC(cBTH,cjava_DOT_util_DOT_Collection,1).
-paramFC(cBSV,cAKH,1).
-paramFC(cBQZ,cBRA,1).
-paramFC(cBQJ,cAKH,1).
-smaller(cBRD,cBRE).
-paramFC(cBRO,cBRP,1).
-typeFC(cBSI,cjava_DOT_util_DOT_List,1).
-typeFC(cBQX,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBUI,cBUJ,1).
-paramFC(cBQO,cBQP,1).
-typeFC(cBTA,cjava_DOT_util_DOT_AbstractCollection,1).
-paramFC(cBRJ,cAKH,1).
-paramFC(cBTV,cBTW,1).
-typeFC(cBUO,cjava_DOT_lang_DOT_Object,0).
-typeFC(cBSA,cjava_DOT_lang_DOT_Object,0).
-smaller(cBUB,cBUE).
-typeFC(cBUD,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBQZ,cjava_DOT_util_DOT_Vector,1).
-smaller(cBTL,cBTO).
-typeFC(cBTU,cjava_DOT_util_DOT_AbstractList,1).
-smaller(cBTZ,cBUA).
-typeFC(cBRG,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBSC,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBSK,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBST,cjava_DOT_util_DOT_AbstractList,1).
-paramFC(cBSY,cBSZ,1).
-typeFC(cBTW,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBQW,cjava_DOT_lang_DOT_Integer,0).
-smaller(cBSP,cBSQ).
-paramFC(cBSG,cBSH,1).
-smaller(cBTD,cBTG).
-typeFC(cBUG,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBSW,cjava_DOT_lang_DOT_Object,0).
-paramFC(cBTD,cBTE,1).
-paramFC(cBSX,cBSY,1).
-paramFC(cBQM,cBQN,1).
-typeFC(cBRH,cjava_DOT_util_DOT_AbstractCollection,1).
-smaller(cBSN,cBSO).
-paramFC(cBQK,cAKH,1).
-typeFC(cBTM,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBTU,cBTV,1).
-typeFC(cBQM,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBRA,cjava_DOT_util_DOT_Vector,1).
-smaller(cBSV,cBSW).
-typeFC(cBSO,cjava_DOT_lang_DOT_Object,0).
-typeFC(cBSZ,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBQL,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBSL,cAKH,1).
-typeFC(cBRB,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBSY,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBUH,cBUI,1).
-paramFC(cBTH,cAKH,1).
-typeFC(cBTN,cjava_DOT_lang_DOT_Integer,0).
-smaller(cBRJ,cBRK).
-typeFC(cBRP,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBUH,cjava_DOT_util_DOT_List,1).
-paramFC(cBRE,cBRF,1).
-typeFC(cBQR,cjava_DOT_util_DOT_Collection,1).
-typeFC(cBTY,cjava_DOT_lang_DOT_Object,0).
-paramFC(cBQS,cBQT,1).
-typeFC(cBTI,cjava_DOT_lang_DOT_Iterable,1).
-typeFC(cBUC,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBSB,cBSC,1).
-typeFC(cBQS,cjava_DOT_util_DOT_Vector,1).
-smaller(cBQR,cBQU).
-paramFC(cBTE,cBTF,1).
-paramFC(cBUB,cBUC,1).
-typeFC(cBRO,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBST,cAKH,1).
-typeFC(cBQO,cjava_DOT_util_DOT_List,1).
-typeFC(cBRE,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBQY,cjava_DOT_io_DOT_Serializable,0).
-typeFC(cBTQ,cjava_DOT_lang_DOT_Object,0).
-smaller(cBSX,cBTA).
-typeFC(cBRN,cjava_DOT_util_DOT_AbstractCollection,1).
-typeVar(cAKH).
-paramFC(cBRH,cAKH,1).
-paramFC(cBQP,cBQQ,1).
-typeFC(cBSE,cjava_DOT_io_DOT_Serializable,0).
-smaller(cBTP,cBTQ).
-paramFC(cBRN,cBRO,1).
-typeFC(cBUI,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBRV,cjava_DOT_io_DOT_Serializable,0).
-typeFC(cBSJ,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBTK,cjava_DOT_util_DOT_RandomAccess,0).
-paramFC(cBSJ,cBSK,1).
-typeFC(cBQK,cjava_DOT_util_DOT_AbstractList,1).
-smaller(cBUN,cBUO).
-typeFC(cBUB,cjava_DOT_util_DOT_AbstractCollection,1).
-paramFC(cBSR,cAKH,1).
-paramFC(cBSC,cBSD,1).
-paramFC(cBRA,cBRB,1).
-paramFC(cBRM,cAKH,1).
-paramFC(cBQR,cBQS,1).
-typeFC(cBSM,cjava_DOT_util_DOT_AbstractCollection,1).
-smaller(cBTH,cBTI).
-paramFC(cBTA,cBTB,1).
-smaller(cBQL,cBQO).
-typeFC(cBTB,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBUF,cBUG,1).
-paramFC(cBQL,cBQM,1).
-smaller(cBRN,cBRQ).
-smaller(cBRR,cBRU).
-smaller(cBQX,cBQY).
-typeFC(cBRM,cjava_DOT_util_DOT_List,1).
-typeFC(cBTZ,cjava_DOT_util_DOT_List,1).
-paramFC(cBTL,cBTM,1).
-typeFC(cBRI,cjava_DOT_util_DOT_Collection,1).
-typeFC(cBRK,cjava_DOT_lang_DOT_Cloneable,0).
-typeFC(cBTS,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBUN,cjava_DOT_util_DOT_Collection,1).
-paramFC(cBRR,cBRS,1).
-smaller(cBQZ,cBRC).
-smaller(cBRV,cBRW).
-smaller(cBSL,cBSM).
-typeFC(cBSB,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBSN,cjava_DOT_util_DOT_AbstractCollection,1).
-typeFC(cBTF,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBTG,cjava_DOT_lang_DOT_Object,0).
-paramFC(cBTI,cAKH,1).
-typeFC(cBSH,cjava_DOT_lang_DOT_Integer,0).
-paramFC(cBTM,cBTN,1).
-paramFC(cBSM,cAKH,1).
-typeFC(cBTD,cjava_DOT_util_DOT_List,1).
-typeFC(cBTJ,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBQJ,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBQU,cjava_DOT_lang_DOT_Iterable,1).
-paramFC(cBSF,cBSG,1).
-typeFC(cBTC,cjava_DOT_lang_DOT_Integer,0).
-paramFC(cBQU,cBQV,1).
-typeFC(cBTT,cjava_DOT_lang_DOT_Integer,0).
-paramFC(cBUK,cBUL,1).
-paramFC(cBUA,cAKH,1).
-typeFC(cBUM,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBQT,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBSL,cjava_DOT_util_DOT_AbstractList,1).
-smaller(cBSR,cBSS).
-typeFC(cBUJ,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBQQ,cjava_DOT_lang_DOT_Integer,0).
-typeFC(cBRD,casp_DOT_UnifyWithoutWildcards_DOLLAR_MatrixTest,0).
-paramFC(cBSU,cAKH,1).
-typeFC(cBSU,cjava_DOT_util_DOT_List,1).
-typeFC(cBTP,cjava_DOT_util_DOT_RandomAccess,0).
-typeFC(cBRQ,cjava_DOT_lang_DOT_Object,0).
-typeFC(cBRX,cjava_DOT_lang_DOT_Iterable,1).
-typeFC(cBQV,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBSG,cjava_DOT_util_DOT_Vector,1).
-paramFC(cBRY,cBRZ,1).
-typeFC(cBSV,cjava_DOT_util_DOT_List,1).
-smaller(cBRX,cBSA).
-typeFC(cBRS,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBRL,cjava_DOT_util_DOT_Vector,1).
-typeFC(cBRR,cjava_DOT_util_DOT_Vector,1).
-smaller(cBTJ,cBTK).
-typeFC(cBRU,cjava_DOT_lang_DOT_Cloneable,0).
-paramFC(cBRS,cBRT,1).
-paramFC(cBTB,cBTC,1).
-paramFC(cBTS,cBTT,1).
-typeFC(cBSP,cjava_DOT_lang_DOT_Cloneable,0).
-smaller(cBTX,cBTY).
-paramFC(cBQV,cBQW,1).
-typeFC(cBSS,cjava_DOT_lang_DOT_Object,0).
-typeFC(cBTO,cjava_DOT_lang_DOT_Object,0).

asp/testReduce.lp

@@ -1,28 +0,0 @@
-equals(t1, t2). % Map<Object, Integer> =. Map<Integer, Object>
-%smallerDot(t2, t1).
-
-type(t1, cMap, 2).
-type(t2, cMap, 2).
-%type(t2, cHashMap, 2).
-param(t1, t3, 1).
-param(t1, t4, 2).
-param(t2, t6, 1).
-param(t2, t5, 2).
-
-type(t3, cObject, 0).
-type(t5, cInteger, 0).
-typeVar(t4).
-typeVar(t6).
-
-type(tfc1, cMap, 2).
-type(tfc2, cHashMap, 2).
-param(tfc1, gA, 1).
-param(tfc1, gB, 2).
-param(tfc2, gB, 1).
-param(tfc2, gA, 2).
-typeVar(gA).
-typeVar(gB).
-smaller(tfc2, tfc1).
-smaller(tfc1, tfc1).
-
-#show equals/2.

asp/testUnifikation.lp

@@ -1,12 +0,0 @@
-type(t1, cjava_DOT_util_DOT_Vector, 1).
-param(t1, t2, 1).
-type(t2, cjava_DOT_util_DOT_Vector, 1).
-param(t2, b, 1).
-typeVar(b).
-type(t3, cjava_DOT_util_DOT_Vector, 1).
-param(t3, a, 1).
-typeVar(a).
-
-unify(p, t1, t3).
-
-#show unify/3.

asp/unifikation.lp

@@ -1,23 +0,0 @@
-
-%reduce:
-unify(Pointer, Param1, Param2)
- :- unify(Pointer, T1, T2), type(T1, TName, Num), type(T2, TName, Num)
-	, param(T1, Param1, PNum), param(T2, Param2, PNum)
-	.
-
-%Ich lasse das Subst hier aus. Vector Beispiel funktioniert womöglich auch ohne
-
-%swap:
-unify(Pointer, B, A) :- unify(Pointer, A, B).
-
-%Subst neu implementieren.
-%Subst muss von hinten nach vorne durchgehen.
-%Mit occurs kann man prüfen, welche unify(P, A, B) ausgetauscht werden müssen
-
-%Diese Fälle dürfen nicht auftreten:
-%TODO (möglicherweise braucht man sie nicht; Die Unifikation geht hier nie schief)
-
-%Occurs Regeln:
-occurs(A, A) :- typeVar(A).
-occurs(A, T) :- type(T, _,_), param(T, B, _), occurs(A, B).
-

asp/unifikation.lp.backup

@@ -1,40 +0,0 @@
-
-%reduce:
-unify(Pointer, Param1, Param2)
- :- unify(Pointer, T1, T2), type(T1, TName, Num), type(T2, TName, Num)
-	, param(T1, Param1, PNum), param(T2, Param2, PNum)
-	.
-
-%swap:
-unify(Pointer, B, A) :- unify(Pointer, A, B).
-
-%subst:
-%Neuen Typ erstellen, in diesem werden dann die TPHs ersetzt:
-type(pointer(unify(Pointer, A, B, E)), Name, Num)
-:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
-	,param(E, Param, _), occurs(A, Param), Param != A.
-
-param(pointer(unify(Pointer, A, B, E)), pointer(unify(Pointer, A, B, Param)), ParamNum)
-:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
-	,param(E, Param, ParamNum), occurs(A, Param), Param != A.
-
-param(pointer(unify(Pointer, A, B, E)), B, ParamNum)
-:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
-	,param(E, A, ParamNum).
-
-param(pointer(unify(Pointer, A, B, E)), Param, ParamNum)
-:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
-	,param(E, Param, ParamNum), not occurs(A, Param).
-
-
-%Subst neu implementieren.
-%Subst muss von hinten nach vorne durchgehen.
-%Mit occurs kann man prüfen, welche unify(P, A, B) ausgetauscht werden müssen
-
-%Diese Fälle dürfen nicht auftreten:
-%TODO (möglicherweise braucht man sie nicht; Die Unifikation geht hier nie schief)
-
-%Occurs Regeln:
-occurs(A, A) :- typeVar(A).
-occurs(A, T) :- type(T, _,_), param(T, B, _), occurs(A, B).
-

asp/vectorTestInput.lp

@@ -1,95 +0,0 @@
-
-%#show smallerGen/2.
-%#show smallerGen/4.
-
-typeVar(cZW).
-smallerDot(cN,cK).
-smaller(cBHW,cBHX).
-param(cBHW,cZW,1).
-type(cBHO,cjava_DOT_util_DOT_Vector,1).
-smaller(cBIM,cBIN).
-type(cBIQ,cjava_DOT_util_DOT_AbstractList,1).
-type(cBIB,cjava_DOT_lang_DOT_Object,0).
-type(cBIC,cjava_DOT_util_DOT_List,1).
-type(cBHN,cjava_DOT_lang_DOT_Object,0).
-param(cBHS,cZW,1).
-param(cBHT,cZW,1).
-param(cBHU,cZW,1).
-param(cBHV,cZW,1).
-smaller(cBHY,cBHZ).
-type(cBIA,cjava_DOT_lang_DOT_Cloneable,0).
-type(cBIV,cjava_DOT_lang_DOT_Object,0).
-typeVar(cK).
-smaller(cBHU,cBHV).
-smallerDot(cL,cBIY).
-type(cBIM,cjava_DOT_lang_DOT_Object,0).
-smaller(cBIK,cBIL).
-type(cBIL,cjava_DOT_lang_DOT_Object,0).
-type(cBIE,cjava_DOT_util_DOT_Vector,1).
-type(cBII,cjava_DOT_util_DOT_AbstractCollection,1).
-param(cBIY,cLL,1).
-type(cBHZ,cjava_DOT_lang_DOT_Object,0).
-typeVar(cLL).
-type(cBIR,cjava_DOT_util_DOT_List,1).
-param(cBID,cZW,1).
-type(cBHY,cMyVector,0).
-smaller(cBII,cBIJ).
-param(cBIF,cZW,1).
-type(cBIG,cjava_DOT_util_DOT_Collection,1).
-type(cBHT,cjava_DOT_util_DOT_AbstractCollection,1).
-type(cBIT,cjava_DOT_util_DOT_AbstractList,1).
-param(cBHQ,cZW,1).
-smaller(cBIE,cBIF).
-typeVar(cL).
-param(cBHO,cZW,1).
-type(cBHM,cjava_DOT_io_DOT_Serializable,0).
-type(cBIK,cjava_DOT_util_DOT_RandomAccess,0).
-type(cBIJ,cjava_DOT_lang_DOT_Object,0).
-type(cBIO,cjava_DOT_util_DOT_AbstractCollection,1).
-type(cBIZ,cjava_DOT_lang_DOT_Integer,0).
-type(cBHX,cjava_DOT_lang_DOT_Object,0).
-type(cBIS,cjava_DOT_util_DOT_Vector,1).
-smaller(cBIG,cBIH).
-param(cBIW,cZW,1).
-smaller(cBIW,cBIX).
-smaller(cBHM,cBHN).
-smaller(cBIC,cBID).
-type(cBHP,cjava_DOT_util_DOT_RandomAccess,0).
-param(cBIS,cZW,1).
-param(cBIQ,cZW,1).
-param(cBIU,cZW,1).
-param(cBIR,cZW,1).
-param(cBIT,cZW,1).
-smaller(cBHO,cBHP).
-param(cBIP,cZW,1).
-type(cBIH,cjava_DOT_lang_DOT_Object,0).
-typeVar(cM).
-type(cBIU,cjava_DOT_lang_DOT_Iterable,1).
-type(cBHR,cjava_DOT_lang_DOT_Cloneable,0).
-type(cBIF,cjava_DOT_util_DOT_List,1).
-smaller(cBIU,cBIV).
-type(cBHV,cjava_DOT_lang_DOT_Iterable,1).
-smaller(cBIA,cBIB).
-equals(cLL,cN).
-type(cBIP,cjava_DOT_util_DOT_Collection,1).
-type(cBHS,cjava_DOT_util_DOT_AbstractList,1).
-type(cBIN,cjava_DOT_lang_DOT_Object,0).
-smaller(cBHS,cBHT).
-param(cBIE,cZW,1).
-smaller(cBIS,cBIT).
-param(cBIC,cZW,1).
-param(cBIG,cZW,1).
-param(cBII,cZW,1).
-type(cBID,cjava_DOT_util_DOT_Collection,1).
-param(cBIO,cZW,1).
-type(cBIW,cjava_DOT_util_DOT_Vector,1).
-smallerDot(cM,cBIZ).
-smaller(cBIO,cBIP).
-type(cBIY,cjava_DOT_util_DOT_Vector,1).
-typeVar(cN).
-type(cBHW,cjava_DOT_util_DOT_List,1).
-type(cBHU,cjava_DOT_util_DOT_Collection,1).
-type(cBIX,cjava_DOT_io_DOT_Serializable,0).
-smaller(cBHQ,cBHR).
-smaller(cBIQ,cBIR).
-type(cBHQ,cjava_DOT_util_DOT_Vector,1).

maven-repository/de/dhbwstuttgart/JavaTXcompiler/0.1/JavaTXcompiler-0.1.jar.md5

@@ -1 +0,0 @@
-5da32a6f73bb3ccac5dc264606071605

maven-repository/de/dhbwstuttgart/JavaTXcompiler/0.1/JavaTXcompiler-0.1.jar.sha1

@@ -1 +0,0 @@
-bcb7e8eb537f65ec0110731a924a3d4d3bba7805

maven-repository/de/dhbwstuttgart/JavaTXcompiler/0.1/JavaTXcompiler-0.1.pom

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>de.dhbwstuttgart</groupId>
-  <artifactId>JavaTXcompiler</artifactId>
-  <version>0.1</version>
-</project>

maven-repository/de/dhbwstuttgart/JavaTXcompiler/0.1/JavaTXcompiler-0.1.pom.md5

@@ -1 +0,0 @@
-a909ae513fbc19ba7c25b0cbb9871db6

maven-repository/de/dhbwstuttgart/JavaTXcompiler/0.1/JavaTXcompiler-0.1.pom.sha1

@@ -1 +0,0 @@
-4863f156f9b2754ccff7128ff372a8e1e11ee0f8

maven-repository/de/dhbwstuttgart/JavaTXcompiler/maven-metadata.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<metadata>
-  <groupId>de.dhbwstuttgart</groupId>
-  <artifactId>JavaTXcompiler</artifactId>
-  <versioning>
-    <release>0.1</release>
-    <versions>
-      <version>0.1</version>
-    </versions>
-    <lastUpdated>20180119143709</lastUpdated>
-  </versioning>
-</metadata>

maven-repository/de/dhbwstuttgart/JavaTXcompiler/maven-metadata.xml.md5

@@ -1 +0,0 @@
-f023e768b9a1e74695541c63858fa86c

maven-repository/de/dhbwstuttgart/JavaTXcompiler/maven-metadata.xml.sha1

@@ -1 +0,0 @@
-705a6736ea0a93b18743edd577dcb3c5e6dd518e

pom.xml

@@ -7,6 +7,7 @@
   <groupId>de.dhbwstuttgart</groupId>
   <artifactId>JavaTXcompiler</artifactId>
   <packaging>jar</packaging>
+   
   <version>0.1</version>
   <name>JavaTXcompiler</name>
   <url>http://maven.apache.org</url>
@@ -71,10 +72,7 @@
 	    <configuration>
 		    <sourceDirectory>src/de/dhbwstuttgart/parser/antlr/</sourceDirectory>
 		    <outputDirectory>src/de/dhbwstuttgart/parser/antlr/</outputDirectory>
-		    <arguments>
-			    <argument>-package</argument>
-			   <argument>de.dhbwstuttgart.parser.antlr</argument>
-	  	    </arguments>
+		    <arguments> <argument>-package</argument> <argument>de.dhbwstuttgart.parser.antlr</argument> </arguments>
 	    </configuration>
 	    </execution>
 	    <execution>
@@ -93,20 +91,91 @@
           </execution>
 
         </executions>
+</plugin>
+ <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <descriptorRefs>
+            <descriptorRef>jar-with-dependencies</descriptorRef>
+          </descriptorRefs>
+        </configuration>
       </plugin>
+<plugin>
+    <groupId>org.reficio</groupId>
+    <artifactId>p2-maven-plugin</artifactId>
+    <version>1.1.2-SNAPSHOT</version>
+    <executions>
+     <execution>
+      <id>default-cli</id>
+      <configuration>
+       <artifacts>
+        <!-- specify your depencies here -->
+	<!-- groupId:artifactId:version -->
+        <artifact>
+		<id>de.dhbwstuttgart:JavaTXcompiler:0.1</id>
+        </artifact>
+		<artifact><id>org.reflections:reflections:0.9.11</id></artifact>
+		<artifact><id>com.google.guava:guava:22.0</id></artifact>
+		<artifact><id>javax.annotation:javax.annotation-api:1.3.1</id></artifact>
+		<artifact><id>org.glassfish:javax.annotation:3.1.1</id></artifact>
+       </artifacts>
+      </configuration>
+     </execution>
+    </executions>
+   </plugin>
+   <plugin>
+    <groupId>org.eclipse.tycho</groupId>
+    <artifactId>tycho-p2-repository-plugin</artifactId>
+    <version>${tycho.version}</version>
+    <executions>
+     <execution>
+      <phase>package</phase>
+      <goals>
+       <goal>archive-repository</goal>
+      </goals>
+     </execution>
+    </executions>
+   </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
-	    <artifactId>maven-compiler-plugin</artifactId>
-	    <version>2.3.2</version>
+            <artifactId>maven-compiler-plugin</artifactId>
             <configuration>
-                <source>8</source>
-                <target>8</target>
+                <source>9</source>
+                <target>9</target>
             </configuration>
         </plugin>
     </plugins>
        </build>
+        <pluginRepositories>
+  <pluginRepository>
+   <id>reficio</id>
+   <url>http://repo.reficio.org/maven/</url>
+  </pluginRepository>
+ </pluginRepositories>
+ <repositories>
+	 <repository>
+        <id>maven-repository</id>
+	<url>file:///${project.basedir}/target</url>
+</repository>
+</repositories>
    <properties>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
+    <tycho.version>0.23.0</tycho.version>
   </properties>
+  <distributionManagement>
+    <repository>
+	    <id>maven-repository</id>
+      <name>MyCo Internal Repository</name>
+      <url>file:///${project.basedir}/maven-repository/</url>
+    </repository>
+  </distributionManagement>
 </project>

src/de/dhbwstuttgart/bytecode/AStatement.java

@@ -0,0 +1,30 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public abstract class AStatement implements IStatement {
+	protected Expression expr;
+	
+	public AStatement(Expression expr) {
+		this.expr = expr;
+	}
+	
+	@Override
+	public boolean isExprBinary() {
+		return (expr instanceof BinaryExpr);
+	}
+	
+	@Override
+	public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
+		mv.visitInsn(Opcodes.ICONST_1);
+		mv.visitJumpInsn(Opcodes.GOTO, endLabel);
+		mv.visitLabel(branchLabel);
+		mv.visitInsn(Opcodes.ICONST_0);
+		mv.visitLabel(endLabel);
+	}
+}

src/de/dhbwstuttgart/bytecode/ArgumentExpr.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.bytecode;
+
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public class ArgumentExpr extends AStatement {
+	
+	public ArgumentExpr(Expression expr) {
+		super(expr);
+	}
+	
+}

src/de/dhbwstuttgart/bytecode/AssignStmt.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.bytecode;
+
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public class AssignStmt extends AStatement {
+	
+	public AssignStmt(Expression rightSide) {
+		super(rightSide);
+	}
+
+}

src/de/dhbwstuttgart/bytecode/BytecodeGen.java

@@ -1,7 +1,9 @@
 package de.dhbwstuttgart.bytecode;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -9,11 +11,15 @@ import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.FieldVisitor;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
 
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.signature.Signature;
 import de.dhbwstuttgart.bytecode.signature.TypeToString;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.Literal;
@@ -23,6 +29,9 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class BytecodeGen implements ASTVisitor {
@@ -30,12 +39,18 @@ public class BytecodeGen implements ASTVisitor {
 	ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
 	
 	String type;
-	
+
 	String className;
 	private boolean isInterface;
+	private List<ResultSet> listOfResultSets;
 	private ResultSet resultSet;
+	
+	private String path;
+	
 	private int indexOfFirstParam = 0;
 	
+	private String superClass;
+	
 	// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
 	HashMap<String, Integer> paramsAndLocals = new HashMap<>();
 	// stores generics and their bounds of class
@@ -43,20 +58,26 @@ public class BytecodeGen implements ASTVisitor {
 	// stores generics and their bounds of method
 	HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
 	
+	private final TPHExtractor tphExtractor = new TPHExtractor();
+	private final ArrayList<GenericInsertPair> commonPairs = new ArrayList<>();
+	
 	HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
 	byte[] bytecode;
 	HashMap<String,byte[]> classFiles;
 	
-	public BytecodeGen(HashMap<String,byte[]> classFiles, ResultSet resultSet) {
+	ArrayList<String> methodNameAndParamsT = new ArrayList<>();
+	
+	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets, String path) {
 		this.classFiles = classFiles;
-		this.resultSet = resultSet;
+		this.listOfResultSets = listOfResultSets;
+		this.path = path;
 	}
 	
 	@Override
 	public void visit(SourceFile sourceFile) {
 		for(ClassOrInterface cl : sourceFile.getClasses()) {
 			System.out.println("in Class: " + cl.getClassName().toString());
-			BytecodeGen classGen = new BytecodeGen(classFiles, resultSet);
+			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets,path);
 			cl.accept(classGen);
 			classGen.writeClass(cl.getClassName().toString());
 		}
@@ -81,6 +102,7 @@ public class BytecodeGen implements ASTVisitor {
 	
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
+		
 		className = classOrInterface.getClassName().toString();
 		
 		cw.visitSource(className +".jav", null);
@@ -88,30 +110,63 @@ public class BytecodeGen implements ASTVisitor {
 		isInterface = (classOrInterface.getModifiers()&512)==512;
 
 		int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
-		String sig = null;
-		/* if class has generics then creates signature
-		 * Signature looks like:
-		 * <E:Ljava/...>Superclass 
-		 */
-		if(classOrInterface.getGenerics().iterator().hasNext()) {
-			Signature signature = new Signature(classOrInterface, genericsAndBounds);
-			sig = signature.toString();
-		}
-		// needs implemented Interfaces?
-		cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
-				, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
 		
-		// for each field in the class
-		for(Field f : classOrInterface.getFieldDecl()) {
-			f.accept(this);
+		
+//		resultSet = listOfResultSets.get(0);
+		boolean isConsWithNoParamsVisited = false;
+		boolean isVisited = false;
+		for(ResultSet rs : listOfResultSets) {
+			superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
+			resultSet = rs;
+			// Nur einmal ausführen!!
+			if(!isVisited) {
+				classOrInterface.accept(tphExtractor);
+
+				getCommonTPHS(tphExtractor);
+
+				String sig = null;
+				/* if class has generics then creates signature
+				 * Signature looks like:
+				 * <E:Ljava/...>Superclass 
+				 */
+				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty()) {
+					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs);
+					sig = signature.toString();
+					System.out.println("Signature: => " + sig);
+				}
+				
+				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
+						, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
+				
+				isVisited = true;
+			}
+			
+			for(Field f : classOrInterface.getFieldDecl()) {
+				f.accept(this);
+			}
+			
+			for(Constructor c : classOrInterface.getConstructors()) {
+				if(!isConsWithNoParamsVisited)
+					c.accept(this);
+				if(!c.getParameterList().iterator().hasNext())
+					isConsWithNoParamsVisited = true;
+			}
+			
+			for(Method m : classOrInterface.getMethods()) {
+				m.accept(this);
+			}
+		
 		}
 		
-		for(Constructor c : classOrInterface.getConstructors()) {
-			c.accept(this);
-		}
-		
-		for(Method m : classOrInterface.getMethods()) {
-			m.accept(this);
+	}
+
+	private void getCommonTPHS(TPHExtractor tphExtractor) {
+		// Gemeinsame TPHs
+		ArrayList<TypePlaceholder> cTPHs = new ArrayList<>();
+		// Alle TPHs der Felder speichern
+		for(TypePlaceholder tph : tphExtractor.allTPHS.keySet()) {
+			if(!tphExtractor.allTPHS.get(tph))
+				cTPHs.add(tph);
 		}
 	}
 
@@ -138,31 +193,48 @@ public class BytecodeGen implements ASTVisitor {
 		desc = constructor.accept(new DescriptorToString(resultSet));
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
 		mv.visitCode();		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,field, mv,paramsAndLocals,cw,
-				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles);
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, path);
 		if(!field.getParameterList().iterator().hasNext()) {
 			mv.visitInsn(Opcodes.RETURN);
 		}
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
-
+	
 	@Override
 	public void visit(Method method) {
 		// TODO: check if the method is static => if static then the first param will be stored in pos 0
 		// else it will be stored in pos 1 and this will be stored in pos 0
+		String retType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		String methParamTypes = retType+method.name+"%%";
 		method.getParameterList().accept(this);
 
+		Iterator<FormalParameter> itr = method.getParameterList().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
+		}
+		
+		if(methodNameAndParamsT.contains(methParamTypes)) {
+			return;
+		}
+		methodNameAndParamsT.add(methParamTypes);
+		System.out.println("Method: "+method.name +" , paramsType: "+methParamTypes);
 		String methDesc = null;
 		
 		// Method getModifiers() ?
 		int acc = isInterface?Opcodes.ACC_ABSTRACT:method.modifier;
+		System.out.println(acc);
 		
-		boolean hasGenInParameterList = genericsAndBounds.containsKey(resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor()));
+		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ");
+		/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
+		 * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
 		if(!hasGenInParameterList) {
 			for(String paramName : methodParamsAndTypes.keySet()) {
 				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
-				if(genericsAndBounds.containsKey(typeOfParam)) {
+				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")) {
 					hasGenInParameterList = true;
 					break;
 				}
@@ -170,31 +242,128 @@ public class BytecodeGen implements ASTVisitor {
 		}
 		
 		//TODO: Test if the return-type or any of the parameter is a parameterized type. (VP)
-		//than create the descriptor with the new syntax.
+		//then create the descriptor with the new syntax.
 		
 		String sig = null;
+		/* method.getGenerics: <....> RT method(..) 
+		 * */
 		boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
 		
 		/* if method has generics or return type is TPH, create signature */
+		// zwite operand muss weggelassen werden
 		if(hasGen||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
-			// resultset hier zum testen 
-			Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet);
+			
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs);
+			System.out.println(method.name + " => Simplified Pairs: ");
+			pairs.forEach(p->System.out.println(p.TA1.getName() + " -> "+p.TA2.getName()));
+			Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,methodParamsAndTypes,resultSet, pairs);
 			sig = signature.toString();
 		}
-		System.out.println(sig);
+		System.out.println(method.getName()+" ==> "+sig);
 		NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
 		methDesc = meth.accept(new DescriptorToString(resultSet));
-		System.out.println(methDesc);
+		
+//		System.out.println(methDesc);
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
 
 		mv.visitCode();		
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, path);
 		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,method, mv,paramsAndLocals,cw,
-				genericsAndBounds,genericsAndBounds,isInterface,classFiles);
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
 	
+	private ArrayList<GenericInsertPair> simplifyPairs(String methodName, ArrayList<GenericInsertPair> allPairs) {
+		allPairs.forEach(p->System.out.print(p.TA1 + " < "+ p.TA2+ " ; "));
+		
+		if(allPairs.size() < 2)
+			return allPairs;
+		
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		MethodAndTPH method;
+		ArrayList<TypePlaceholder> methodTphs = new ArrayList<>();
+		ArrayList<GenericInsertPair> methodPairs = new ArrayList<>();
+		for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
+			if(m.getName().equals(methodName)) {
+				methodTphs = m.getTphs();
+				methodPairs = m.getPairs();
+				break;
+			}
+		}
+
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			// Tph2.jav
+			if(subAndSuperTph.containsKey(p.TA1)) {
+				if(methodTphs.contains(subAndSuperTph.get(p.TA1)))
+					continue;
+			}
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			if(!methodTphs.contains(subTph))
+				continue;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(methodTphs.contains(tph) && subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				if(subTphRes.equals(tphsInRel.get(0))) {
+					break;
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			
+			int i = 2;
+			while(!methodTphs.contains(superTphRes) && (tphsInRel.size()-i) >0) {
+				superTphRes = tphsInRel.get(tphsInRel.size()-i);
+				i++;
+			}
+			// teste noch den Fall X < Y und Y nicht in TPHS der Methode
+			// 		 Dann hat man nach der While-Schleife X < Y
+			//		 Y muss durch Object ersetzt.
+			
+			// Zweite Operand für die Fälle wie in Lambda.jav (Paramtrisierte Typen) 
+			if(methodTphs.contains(superTphRes) || !tphExtractor.allTPHS.containsKey(superTphRes)) {
+				GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+				simplifiedPairs.add(sPair);
+			}
+		}
+		return simplifiedPairs;
+	}
+
 	@Override
 	public void visit(ParameterList formalParameters) {
 		paramsAndLocals = new HashMap<>();
@@ -436,5 +605,50 @@ public class BytecodeGen implements ASTVisitor {
 	public void visit(UnaryExpr unaryExpr) {
 		throw new NotImplementedException();
 	}
+	
+	private class TPHExtractor extends AbstractASTWalker{
+		// Alle TPHs der Felder werden iKopf der Klasse definiert
+		// alle TPHs der Klasse: (TPH, is in Method?)
+		final HashMap<TypePlaceholder,Boolean> allTPHS = new HashMap<>();
+		MethodAndTPH methodAndTph;
+		Boolean inMethod = false;
+		final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
+		final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
+		
+		@Override
+		public void visit(TypePlaceholder tph) {
+			if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
+				TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
+				if(inMethod)
+					methodAndTph.getTphs().add(resolvedTPH);
+				
+				allTPHS.put(resolvedTPH,inMethod);
+				resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
+					if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
+						if(inMethod)
+							methodAndTph.getPairs().add(ag);
+						allPairs.add(ag);
+					}
+				});
+			}
+		}
+		private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+			for(int i=0; i<pairs.size();++i) {
+				GenericInsertPair p = pairs.get(i);
+				if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+					return true;
+			}
+			return false;
+		}
+		@Override
+		public void visit(Method method) {
+			inMethod = true;
+			methodAndTph = new MethodAndTPH(method.name);
+			super.visit(method);
+			inMethod = false;
+			ListOfMethodsAndTph.add(methodAndTph);
+		}
+		
+	}
 
 }

src/de/dhbwstuttgart/bytecode/IStatement.java

@@ -0,0 +1,9 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+
+public interface IStatement {
+	public boolean isExprBinary();
+	public void genBCForRelOp(MethodVisitor mv, Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod);
+}

src/de/dhbwstuttgart/bytecode/LoopStmt.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+
+public class LoopStmt extends AStatement {
+	
+    private Statement loopBlock;
+    
+    public LoopStmt(Expression expr, Statement loopBlock) {
+    		super(expr);
+    		this.loopBlock = loopBlock;
+    }
+
+	@Override
+	public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
+		bytecodeGenMethod.isBinary(false);
+		this.loopBlock.accept(bytecodeGenMethod);
+		mv.visitJumpInsn(Opcodes.GOTO, endLabel);
+		mv.visitLabel(branchLabel);
+	}
+}

src/de/dhbwstuttgart/bytecode/ReturnStmt.java

@@ -0,0 +1,14 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.MethodVisitor;
+
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public class ReturnStmt extends AStatement {
+	
+	public ReturnStmt(Expression retexpr) {
+		super(retexpr);
+	}
+	
+}

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java

@@ -2,12 +2,14 @@ package de.dhbwstuttgart.bytecode.descriptor;
 
 import java.util.Iterator;
 
-import de.dhbwstuttgart.bytecode.Lambda;
-import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
-import de.dhbwstuttgart.bytecode.NormalConstructor;
-import de.dhbwstuttgart.bytecode.NormalMethod;
-import de.dhbwstuttgart.bytecode.SamMethod;
+import org.objectweb.asm.Type;
+
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.bytecode.utilities.Lambda;
+import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
+import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -46,12 +48,20 @@ public class DescriptorToString implements DescriptorVisitor{
 				}else if(method.getGenericsAndBounds().containsKey(fpDesc)){
 					desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
 				}else {
-					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+//					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+					String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+					if(resType.subSequence(0, 4).equals("TPH ")) {
+						// Bound ist immer Object
+						desc += "L"+Type.getInternalName(Object.class)+ ";";
+					} else {
+						desc += "L"+resType+ ";";
+					}
 				}
 			}
-//			else if(((RefType) fp.getType()).getParaList().size() > 0){
-//				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "%").replace("<", "%%").replace(">", "%%")+ ";";
-//			}
+			//TODO: generate a class java%% ... %%
+			else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains("<")){
+				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace("<", "$$$").replace(">", "$$$")+ ";";
+			}
 			else {
 				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 			}
@@ -67,7 +77,13 @@ public class DescriptorToString implements DescriptorVisitor{
 				}else if(method.getGenericsAndBounds().containsKey(ret)){
 					desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
 				}else {
-					desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+					String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+					if(resType.subSequence(0, 4).equals("TPH ")) {
+//						desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
+						desc += ")" + "L"+Type.getInternalName(Object.class)+ ";";
+					} else {
+						desc += ")" + "L"+resType+ ";";
+					}
 				}
 			}else {
 				desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
@@ -107,9 +123,21 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<FormalParameter> itr = lambdaExpression.getParams().iterator();
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
-			desc = desc + "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+			String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
+			}else {
+				desc = desc + "L"+ d + ";";
+			}
+		}
+		
+		String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
+		}else {
+			desc = desc + ")"+"L"+retType+";";
 		}
-		desc = addReturnType(desc, lambdaExpression.getReturnType(), resultSet);
 		return desc;
 	}
 
@@ -119,9 +147,22 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<RefTypeOrTPHOrWildcardOrGeneric> itr = samMethod.getArgumentList().iterator();
 		while(itr.hasNext()) {
 			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
-			desc = desc + "L"+resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor())+";";
+			String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
+			
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
+			}else {
+				desc += "L"+ d + ";";
+				
+			}
+		}
+		String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
+		}else {
+			desc = desc + ")"+"L"+retType+";";
 		}
-		desc = desc + ")"+"L"+resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
 		return desc;
 	}
 
@@ -129,26 +170,34 @@ public class DescriptorToString implements DescriptorVisitor{
 	public String visit(MethodFromMethodCall methodFromMethodCall) {
 		String desc = "(";
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
-			String d = e.getType().acceptTV(new TypeToDescriptor());
-			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
-				desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
-			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
-				desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
+			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+			
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
-				desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
+					desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
+				}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
+					desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
+				}else {
+					desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				}
 			}
+			
 		}
-		
-		if(resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.toString().equals("void")) {
+		String retType = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		System.out.println("DescriptorToString retType = " + retType);
+		if(retType.equals("void")) {
 			desc += ")V";
+		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
-			String ret = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
-			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(ret)) {
-				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(ret)+ ";";
-			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(ret)){
-				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(ret)+ ";";
+			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {
+				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(retType)+ ";";
+			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(retType)){
+				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(retType)+ ";";
 			}else {
-				desc += ")" + "L"+resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				desc += ")" + "L"+retType+ ";";
 			}
 		}
 //		desc = addReturnType(desc, methodFromMethodCall.getReturnType(), resultSet);

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorVisitor.java

@@ -1,10 +1,10 @@
 package de.dhbwstuttgart.bytecode.descriptor;
 
-import de.dhbwstuttgart.bytecode.Lambda;
-import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
-import de.dhbwstuttgart.bytecode.NormalConstructor;
-import de.dhbwstuttgart.bytecode.NormalMethod;
-import de.dhbwstuttgart.bytecode.SamMethod;
+import de.dhbwstuttgart.bytecode.utilities.Lambda;
+import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
+import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 
 public interface DescriptorVisitor {
 	public String visit(NormalMethod method);

src/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java

@@ -13,11 +13,15 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(RefType refType) {
 		return refType.getName().toString().replace(".", "/");
+//		String t = refType.getName().toString().replace(".", "/");
+//		return t.equals("Fun1")?(t+"$$"):t;
 	}
 
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+		System.out.println("\nWILDCARD ="+superWildcardType.getInnerType().toString().replace(".", "/"));
+		return superWildcardType.getInnerType().toString().replace(".", "/");
+		//throw new NotImplementedException();
 	}
 
 	@Override
@@ -27,7 +31,9 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+		System.out.println("\nWILDCARD extends ="+extendsWildcardType.getInnerType().toString().replace(".", "/"));
+		return extendsWildcardType.getInnerType().toString().replace(".", "/");
+		//throw new NotImplementedException();
 	}
 
 	@Override

src/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.bytecode.signature;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 
@@ -8,13 +9,19 @@ import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class Signature {
@@ -26,10 +33,13 @@ public class Signature {
 	private Method method;
 	private HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes;
 	private ResultSet resultSet;
+	private ArrayList<GenericInsertPair> commonPairs;
+	private ArrayList<GenericInsertPair> methodPairs;
 	
-	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds) {
+	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds,ArrayList<GenericInsertPair> commonPairs) {
 		this.classOrInterface = classOrInterface;
 		this.genericsAndBounds = genericsAndBounds;
+		this.commonPairs = commonPairs;
 		sw = new SignatureWriter();
 		createSignatureForClassOrInterface();
 	}
@@ -42,12 +52,14 @@ public class Signature {
 		createSignatureForConsOrMethod(this.constructor,true);
 	}
 
-	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,
-			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet) {
+	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,HashMap<String, String> genericsAndBounds,
+			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet, ArrayList<GenericInsertPair> methodPairs) {
 		this.method = method;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.genericsAndBounds = genericsAndBounds;
 		this.methodParamsAndTypes = methodParamsAndTypes;
 		this.resultSet = resultSet;
+		this.methodPairs = methodPairs;
 		sw = new SignatureWriter();
 		createSignatureForConsOrMethod(this.method,false);
 	}
@@ -59,10 +71,7 @@ public class Signature {
 
 	private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
 		
-		sw.visitFormalTypeParameter("R");
-		// getBounds vom Return-Type
-		sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
-		sw.visitClassBound().visitEnd();
+//		sw.visitClassBound().visitEnd();
 		for(int i = 0;i<numberOfParams;i++) {
 			int j = i+1;
 			sw.visitFormalTypeParameter("T"+ j);
@@ -70,6 +79,11 @@ public class Signature {
 			sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
 			sw.visitClassBound().visitEnd();
 		}
+
+		sw.visitFormalTypeParameter("R");
+		// getBounds vom Return-Type
+		sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+		sw.visitClassBound().visitEnd();
 		// TODO: prüfe ob Return-Type = void,
 		sw.visitSuperclass().visitClassType(Type.getInternalName(Object.class));;
 		sw.visitEnd();
@@ -90,7 +104,96 @@ public class Signature {
 			GenericTypeVar g = itr.next();
 			getBoundsOfTypeVar(g,genericsAndBoundsMethod);
 		}
-		// visits each method-parameter to create the signature 
+		
+		// Wenn die RückgabeType eine TPH ist, wird als generic behandelt
+		// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
+		String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
+		if(ret.substring(0,4).equals("TPH ")) {
+			String g = ret.substring(4,ret.length())+"$";
+			if(genericsAndBounds.containsKey(g)) {
+				genericsAndBoundsMethod.put(g, genericsAndBounds.get(g));
+			}else {
+				sw.visitFormalTypeParameter(g);
+				sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+				genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
+				sw.visitClassBound().visitEnd();
+			}
+		}
+		
+		if(ret.contains("<")) {
+			RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
+			if(hasTPHs(ref)) {
+				createSignatureForParameterizedType(ref);
+			}
+			
+		}
+		
+		// Parameters
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
+			String pT = t.acceptTV(new TypeToSignature()); 
+			// S.o
+			if(pT.substring(0,4).equals("TPH ")) {
+				String gP = pT.substring(4,pT.length())+"$";
+				if(!genericsAndBounds.containsKey(gP) && !genericsAndBoundsMethod.containsKey(gP)) {
+					sw.visitFormalTypeParameter(gP);
+					String bound = Type.getInternalName(Object.class);
+					boolean isTypeVar = false;
+					for(GenericInsertPair pair : methodPairs) {
+						if(pT.substring(4).equals(pair.TA1.getName())) {
+							bound = pair.TA2.getName()+"$";
+							isTypeVar = true;
+							break;
+						}
+					}
+					
+					if(isTypeVar) {
+						sw.visitClassBound().visitTypeVariable(bound);
+					}else {
+						sw.visitClassBound().visitClassType(bound);
+						sw.visitClassBound().visitEnd();
+					}
+					
+					genericsAndBoundsMethod.put(gP, bound);
+				}
+			}
+			
+			if(pT.contains("<")) {
+				RefType ref = (RefType) methodParamsAndTypes.get(paramName);
+				if(hasTPHs(ref))
+					createSignatureForParameterizedType(ref);
+			}
+			
+			for(GenericInsertPair p:methodPairs) {
+				String name = p.TA1.getName()+"$";
+				if(!genericsAndBoundsMethod.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitTypeVariable(p.TA2.getName()+"$");
+					genericsAndBoundsMethod.put(name, p.TA2.getName()+"$");
+				}
+			}
+			
+			ArrayList<TypePlaceholder> types = new ArrayList<>();
+			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
+			
+			for(GenericInsertPair p : methodPairs) {
+				types.add(p.TA1);
+				superTypes.add(p.TA2);
+			}
+			
+			for(GenericInsertPair p : methodPairs) {
+				String name = p.TA2.getName()+"$";
+				if(!types.contains(p.TA2) && !genericsAndBoundsMethod.containsKey(name)) {
+					String bound = Type.getInternalName(Object.class);
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(bound);
+					genericsAndBoundsMethod.put(name, bound);
+					sw.visitClassBound().visitEnd();
+				}
+			}
+		}
+		
+		// visit each method-parameter to create the signature 
 		for(String paramName : methodParamsAndTypes.keySet()) {
 			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
 			// parameter type deswegen ist true
@@ -105,6 +208,142 @@ public class Signature {
 		}
 //		sw.visitEnd();
 	}
+	
+	private void createSignatureForParameterizedType(RefType ref) {
+		ArrayList<GenericInsertPair> allPairs = getAllPairs(ref);
+		allPairs.addAll(methodPairs);
+		ArrayList<GenericInsertPair> simplifiedPairs = simplifyPairs(allPairs);
+		
+		HashMap<String, String> names = new HashMap<>();
+		
+		for(GenericInsertPair pair : simplifiedPairs) {
+			if(ref.getParaList().contains(pair.TA1)) {
+				String sub = pair.TA1.getName()+"$";
+				String superT = pair.TA2.getName()+"$";
+				names.put(sub, superT);
+			}
+		}
+		
+		for(String sub : names.keySet()) {
+			if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) {
+				sw.visitFormalTypeParameter(sub);
+				String bound = names.get(sub);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBoundsMethod.put(sub, bound);
+			}
+		}
+		
+		for(String superT : names.values()) {
+			if(!names.containsKey(superT)) {
+				if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) {
+					sw.visitFormalTypeParameter(superT);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class));
+				}
+			}
+		}
+		
+		for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) {
+			if(p instanceof TypePlaceholder) {
+				String name = ((TypePlaceholder) p).getName() + "$";
+				if(!genericsAndBoundsMethod.containsKey(name) && !genericsAndBounds.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(name, Type.getInternalName(Object.class));
+				}
+			}
+		}
+	}
+
+	private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
+		final ArrayList<GenericInsertPair> res = new ArrayList<>();
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType;
+			if(resolved instanceof TypePlaceholder) {
+				resultSet.resolveType(p).additionalGenerics.forEach(ag ->{
+					if(!contains(res,ag)) {
+						res.add(ag);
+					}
+				});
+			}
+				
+		}
+		return res;
+	}
+	
+	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+		for(int i=0; i<pairs.size();++i) {
+			GenericInsertPair p = pairs.get(i);
+			if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+				return true;
+		}
+		return false;
+	}
+	
+	private ArrayList<GenericInsertPair> simplifyPairs(ArrayList<GenericInsertPair> allPairs) {
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		
+		subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));
+		
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+			simplifiedPairs.add(sPair);
+		}
+		return simplifiedPairs;
+	}
+	
+	private boolean hasTPHs(RefType ref) {
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
+				return true;
+		}
+		return false;
+	}
+
 	/**
 	 * Visits parameter type or return type with {@link SignatureVisitor} to create
 	 * the method signature
@@ -130,10 +369,16 @@ public class Signature {
 			break;
 		case "TPH":
 			RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
-			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH "))
-				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
-//			sv.visitClassType(r.acceptTV(new TypeToSignature()));
-			System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+			// der Fall wenn die Type eine Interface ist, muss betrachtet werden
+			// Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
+			// Interface oder eine Klasse ist.
+			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
+//				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
+				sv.visitClassType(r.acceptTV(new TypeToSignature()));
+			} else {
+				System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
+			}
 			break;
 		default:
 			if(!isParameterType)
@@ -153,7 +398,34 @@ public class Signature {
 			GenericTypeVar g = itr.next();
 			getBoundsOfTypeVar(g,genericsAndBounds);
 		}
-		
+		if(!commonPairs.isEmpty()) {
+			ArrayList<TypePlaceholder> types = new ArrayList<>();
+			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
+			
+			for(GenericInsertPair p : commonPairs) {
+				types.add(p.TA1);
+				superTypes.add(p.TA2);
+			}
+			
+			for(GenericInsertPair p : commonPairs) {
+				String t = p.TA1.getName()+"$";
+				String bound = p.TA2.getName()+"$";
+				sw.visitFormalTypeParameter(t);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBounds.put(t, bound);
+			}
+			
+			for(GenericInsertPair p : commonPairs) {
+				if(!types.contains(p.TA2)) {
+					String t = p.TA2.getName()+"$";
+					String bound = Type.getInternalName(Object.class);
+					sw.visitFormalTypeParameter(t);
+					sw.visitClassBound().visitClassType(bound);
+					genericsAndBounds.put(t, bound);
+					sw.visitClassBound().visitEnd();
+				}
+			}
+		}
 		sw.visitSuperclass().visitClassType(classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()));;
 		sw.visitEnd();
 	}

src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java

@@ -22,11 +22,18 @@ public class TypeToSignature implements TypeVisitor<String> {
             Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
             while(it.hasNext()){
                 RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-                params += "L"+param.toString().replace(".", "/");
+                if(param instanceof TypePlaceholder) {
+                		params += "T" + ((TypePlaceholder) param).getName() + "$";
+                } else {
+                		params += "L"+param.toString().replace(".", "/");
+                }
+                
                 if(it.hasNext())params += ";";
             }
             params += ";>";
         }
+//        		String t = refType.getName().toString().replace(".", "/");
+//        		return t.equals("Fun1")?t+"$$"+params+";":t+params+";";
         return refType.getName().toString().replace(".", "/") + params+";";
 	}
 

src/de/dhbwstuttgart/bytecode/utilities/KindOfLambda.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;

src/de/dhbwstuttgart/bytecode/utilities/Lambda.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
 import de.dhbwstuttgart.syntaxtree.ParameterList;

src/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java

@@ -0,0 +1,29 @@
+package de.dhbwstuttgart.bytecode.utilities;
+
+import java.util.ArrayList;
+
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+
+public class MethodAndTPH {
+	
+	private String name;
+	private final ArrayList<TypePlaceholder> tphs = new ArrayList<>();
+	private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
+
+	public MethodAndTPH(String name) {
+		this.name = name;
+	}
+
+	public ArrayList<TypePlaceholder> getTphs() {
+		return tphs;
+	}
+	
+	public ArrayList<GenericInsertPair> getPairs(){
+		return pairs;
+	}
+	
+	public String getName() {
+		return name;
+	}
+}

src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.HashMap;
 

src/de/dhbwstuttgart/bytecode/utilities/NormalConstructor.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.HashMap;
 

src/de/dhbwstuttgart/bytecode/utilities/NormalMethod.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.HashMap;
 

src/de/dhbwstuttgart/bytecode/utilities/SamMethod.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.List;
 

src/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -1,42 +1,57 @@
 package de.dhbwstuttgart.core;
 
 
+import de.dhbwstuttgart.bytecode.BytecodeGen;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.parser.JavaTXParser;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.sat.asp.ASPUnify;
-import de.dhbwstuttgart.sat.asp.parser.ASPParser;
-import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
+import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
+import de.dhbwstuttgart.typeinference.unify.RuleSet;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import java.io.*;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class JavaTXCompiler {
 
     final CompilationEnvironment environment;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
+    Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
 
     public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
         this(Arrays.asList(sourceFile));
     }
 
+    public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
+    	this(sourceFile);
+    	this.log = log;
+    }
+    
     public JavaTXCompiler(List<File> sources) throws IOException, ClassNotFoundException {
         environment = new CompilationEnvironment(sources);
         for (File s : sources) {
@@ -95,20 +110,115 @@ public class JavaTXCompiler {
 
         TypeUnify unify = new TypeUnify();
         Set<Set<UnifyPair>> results = new HashSet<>();
-        for (List<Constraint<UnifyPair>> xCons : unifyCons.cartesianProduct()) {
-            Set<UnifyPair> xConsSet = new HashSet<>();
-            for (Constraint<UnifyPair> constraint : xCons) {
-                xConsSet.addAll(constraint);
-            }
-
-            System.out.println(xConsSet);
-            Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
-            System.out.println("RESULT: " + result.size());
-            results.addAll(result);
+        try {
+			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/test/logFiles/"+"log"));
+			logFile.write("FC:\\" + finiteClosure.toString()+"\n");
+			for(SourceFile sf : this.sourceFiles.values()) {
+				logFile.write(ASTTypePrinter.print(sf));
+			}
+			logFile.flush();
+			Set<List<Constraint<UnifyPair>>> cardProd = unifyCons.cartesianProduct(); 
+			for (List<Constraint<UnifyPair>> xCons : cardProd ){
+				Set<UnifyPair> xConsSet = new HashSet<>();
+				for (Constraint<UnifyPair> constraint : xCons) {
+					xConsSet.addAll(constraint);
+				}
+				//.collect(Collectors.toCollection(ArrayList::new))))
+				System.out.println(xConsSet);
+				Set<String> paraTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist()
+						.stream().filter(z -> z.getType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} )  )
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
+				
+				Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
+				
+				
+				xConsSet = xConsSet.stream().map(x -> { 
+					//Hier muss ueberlegt werden, ob
+					//1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs 
+					//   mit disableWildcardtable() werden.
+					//2. alle Typvariablen mit Argument- oder Retuntyp-Variablen 
+					//in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+					//PL 2018-04-23
+					if ((x.getLhsType() instanceof PlaceholderType)) {
+						if (paraTypeVarNames.contains(x.getLhsType().getName())) { 
+							((PlaceholderType)x.getLhsType()).setVariance((byte)1);
+							((PlaceholderType)x.getLhsType()).disableWildcardtable();
+						}
+						if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+							((PlaceholderType)x.getLhsType()).setVariance((byte)-1);
+							((PlaceholderType)x.getLhsType()).disableWildcardtable();
+						}
+					}
+					if ((x.getRhsType() instanceof PlaceholderType)) {
+						if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+							((PlaceholderType)x.getRhsType()).setVariance((byte)1);
+							((PlaceholderType)x.getRhsType()).disableWildcardtable();
+						}
+						if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+							((PlaceholderType)x.getRhsType()).setVariance((byte)-1);
+							((PlaceholderType)x.getRhsType()).disableWildcardtable();
+						}	
+					}
+					return x;//HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE JEWEILS ANDERE SEITE 
+				}).map( y -> { 
+						if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) {
+							if (((PlaceholderType)y.getLhsType()).getVariance() != 0  && ((PlaceholderType)y.getRhsType()).getVariance() == 0) { 
+								((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType()).getVariance()); 
+							} 
+							if (((PlaceholderType)y.getLhsType()).getVariance() == 0  && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { 
+								((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType()).getVariance()); 
+							} 
+						}
+					return y; } )
+				.collect(Collectors.toCollection(HashSet::new));
+					varianceInheritance(xConsSet);
+    				Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+    				//Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+    				System.out.println("RESULT: " + result);
+    				logFile.write("RES: " + result.toString()+"\n");
+    				logFile.flush();
+    				results.addAll(result);
+            	}
+        	}
+    		catch (IOException e) { }
+			
+		return results.stream().map((unifyPairs ->
+               new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
         }
-        return results.stream().map((unifyPairs ->
-                new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
-    }
+    
+    /**
+	 * Vererbt alle Variancen
+	 * @param eq The set of constraints
+	 */
+	private void varianceInheritance(Set<UnifyPair> eq) {
+		Set<PlaceholderType> usedTPH = new HashSet<>();
+		Set<PlaceholderType> phSet = eq.stream().map(x -> { 
+			Set<PlaceholderType> pair = new HashSet<>();
+			if (x.getLhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getLhsType());
+			if (x.getRhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getRhsType());
+			return pair;
+		}).reduce(new HashSet<>(), (a,b) -> { a.addAll(b); return a;} , (c,d) -> { c.addAll(d); return c;});
+		
+		ArrayList<PlaceholderType> phSetVariance =  new ArrayList<>(phSet);
+		phSetVariance.removeIf(x -> (x.getVariance() == 0));
+		while(!phSetVariance.isEmpty()) {
+			PlaceholderType a = phSetVariance.remove(0);
+			usedTPH.add(a);
+			//HashMap<PlaceholderType,Integer> ht = new HashMap<>();
+			//ht.put(a, a.getVariance());
+			Set<UnifyPair> eq1 = new HashSet<>(eq); 
+			eq1.removeIf(x -> !(x.getLhsType() instanceof PlaceholderType && ((PlaceholderType)x.getLhsType()).equals(a)));
+			eq1.stream().forEach(x -> { x.getRhsType().accept(new distributeVariance(), a.getVariance());});
+			eq1 = new HashSet<>(eq); 
+			eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType && ((PlaceholderType)x.getRhsType()).equals(a)));
+			eq1.stream().forEach(x -> { x.getLhsType().accept(new distributeVariance(), a.getVariance());});
+			phSetVariance =  new ArrayList<>(phSet);
+			phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x)));
+		}		
+}
 
     private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
         HashMap<String, TypePlaceholder> ret = new HashMap<>();
@@ -130,74 +240,29 @@ public class JavaTXCompiler {
         SourceFile ret = generator.convert(tree, environment.packageCrawler);
         return ret;
     }
-
-    public List<ResultSet> aspTypeInference() throws ClassNotFoundException, IOException, InterruptedException {
-        Collection<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
-        //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-        for(SourceFile sf : this.sourceFiles.values()) {
-            allClasses.addAll(getAvailableClasses(sf));
-            allClasses.addAll(sf.getClasses());
-        }
-        HashMap<String, ClassOrInterface> classes = new HashMap<>();
-        for(ClassOrInterface cl : allClasses){
-            classes.put(cl.getClassName().toString(), cl);
-        }
-        allClasses = classes.values();
-
-        final ConstraintSet<Pair> cons = getConstraints();
-
-        String content = "";
-        content = ASPFactory.generateASP(cons, allClasses);
-        final String tempDirectory = "/tmp/";
-        PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8");
-        writer.println(content);
-        writer.close();
-        ASPUnify clingo = new ASPUnify(Arrays.asList(new File(tempDirectory + "test.lp")));
-        String result = clingo.runClingo();
-        //System.out.println(result);
-        ResultSet resultSet = ASPParser.parse(result, getInvolvedTPHS(cons));
-        return Arrays.asList(resultSet);
+    // um pfad erweitern
+    public void generateBytecode(String path) throws ClassNotFoundException, IOException {
+    		for(File f : sourceFiles.keySet()) {
+    			HashMap<String,byte[]> classFiles = new HashMap<>();
+    			SourceFile sf = sourceFiles.get(f);
+    			List<ResultSet> typeinferenceResult = this.typeInference();
+    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,path);
+//    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
+        		bytecodeGen.visit(sf);
+        		this.writeClassFile(bytecodeGen.getClassFiles(), path);
+    		}
     }
 
-    private static class TPHExtractor implements TypeVisitor<List<TypePlaceholder>> {
-        @Override
-        public List<TypePlaceholder> visit(RefType refType) {
-            ArrayList<TypePlaceholder> ret = new ArrayList<>();
-            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
-                ret.addAll(param.acceptTV(this));
-            }
-            return ret;
-        }
-
-        @Override
-        public List<TypePlaceholder> visit(SuperWildcardType superWildcardType) {
-            return superWildcardType.getInnerType().acceptTV(this);
-        }
-
-        @Override
-        public List<TypePlaceholder> visit(TypePlaceholder typePlaceholder) {
-            return Arrays.asList(typePlaceholder);
-        }
-
-        @Override
-        public List<TypePlaceholder> visit(ExtendsWildcardType extendsWildcardType) {
-            return extendsWildcardType.getInnerType().acceptTV(this);
-        }
-
-        @Override
-        public List<TypePlaceholder> visit(GenericRefType genericRefType) {
-            return new ArrayList<>();
-        }
-    }
-
-    protected Collection<TypePlaceholder> getInvolvedTPHS(ConstraintSet<Pair> toTest) {
-        List<TypePlaceholder> ret = new ArrayList<>();
-        toTest.map((Pair p)-> {
-            ret.addAll(p.TA1.acceptTV(new TPHExtractor()));
-            ret.addAll(p.TA2.acceptTV(new TPHExtractor()));
-            return p;
-        });
-        return ret;
-    }
-
-}
+	private void writeClassFile(HashMap<String, byte[]> classFiles, String path) throws IOException {
+		FileOutputStream output;
+		for(String name : classFiles.keySet()) {
+			byte[] bytecode = classFiles.get(name);
+			System.out.println("generating "+name+ ".class file ...");
+			//output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
+			output = new FileOutputStream(new File(path +name+".class"));
+			output.write(bytecode);
+			output.close();
+			System.out.println(name+".class file generated");
+		}
+	}
+}

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java

@@ -7,8 +7,6 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
-import de.dhbwstuttgart.syntaxtree.visual.TypePrinter;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 
@@ -26,28 +24,12 @@ public class FCGenerator {
         return toFC(availableClasses).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
     }
 
-    /*
-    Hier entstehen unnötige Typpaare
-    wenn es mehrere Vererbungsketten gibt
-     Beispiel:
-     * X<B,C> < Y<B,C>
-     * X<D,E> < Y<D,E>
-     Will man dies aber rausnehmen, muss man die andere Kette umbenennen.
-     Schwierig/Unmöglich, dank mehrfachvererbung
-     * Z<B,C,D,E> < X<B,C> < Y<B,C>
-     * Z<B,C,D,E> < X<D,E> < Y<D,E>
-
-     */
-    public static Collection<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
-        HashMap<String, Pair> pairs = new HashMap<>();
-        TypePrinter printer = new TypePrinter();
+    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+        HashSet<Pair> pairs = new HashSet<>();
         for(ClassOrInterface cly : availableClasses){
-            for(Pair p : getSuperTypes(cly, availableClasses)){
-                String hash = p.TA1.acceptTV(printer)+";"+p.TA2.acceptTV(printer);
-                pairs.put(hash, p);
-            }
+            pairs.addAll(getSuperTypes(cly, availableClasses));
         }
-        return pairs.values();
+        return pairs;
     }
 
     /**
@@ -139,23 +121,6 @@ public class FCGenerator {
         return retList;
     }
 
-    /**
-     * Diese Klasse sorgt dafür, dass alle TPHs den selben Namen bekommen.
-     * Damit lassen sich unnötige Typpaare aussortieren.
-     * Gibt es zwei Typpaare der Form:
-     * X<B,C> < Y<B,C>
-     * X<D,E> < Y<D,E>
-     * so bekommen sie hier den gleichen Namen zugewiesen und werden in der HashMap aussortiert
-     * X<TPH,TPH> < Y<TPH,TPH>
-
-    private static class TypePrinterExcludingTPHs extends TypePrinter{
-        @Override
-        public String visit(TypePlaceholder typePlaceholder) {
-            return "TPH";
-        }
-    }
-     */
-
     /**
      * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus.
      */

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java

@@ -745,7 +745,6 @@ public class StatementGenerator {
         if(e.classInstanceCreationExpression_lf_primary() != null){
             throw new NotImplementedException();
         }else if(e.fieldAccess_lf_primary() != null){
-            
             throw new NotImplementedException();
         }else if(e.arrayAccess_lf_primary() != null){
             throw new NotImplementedException();
@@ -800,6 +799,8 @@ public class StatementGenerator {
         if(newExpression.typeArgumentsOrDiamond()!= null){
             if(newExpression.typeArgumentsOrDiamond().typeArguments()!=null){
                 genericArgs = newExpression.typeArgumentsOrDiamond().typeArguments();
+            }else {
+                throw new NotImplementedException();
             }
         }
         if(newExpression.typeArguments()!= null)throw new NotImplementedException();
@@ -831,7 +832,7 @@ public class StatementGenerator {
         }else if(literal.StringLiteral()!=null){
             RefType type = new RefType(reg.getName("java.lang.String"),literal.getStart());
             return new Literal(type,
-                    literal.StringLiteral().getText(),
+                    literal.StringLiteral().getText().substring(1,  literal.StringLiteral().getText().length()-1),
                     literal.getStart());
         }else  if(literal.NullLiteral() != null){
             return new Literal(TypePlaceholder.fresh(literal.getStart()), null,
@@ -903,7 +904,7 @@ public class StatementGenerator {
                 funNParams.add(TypePlaceholder.fresh(expression.getStart())));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         //RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()),
-                //funNParams, name.getStart());
+        		//funNParams, name.getStart());
         return new LambdaExpression(lambdaType, params, block, expression.getStart());
     }
 }

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java

@@ -427,9 +427,6 @@ public class SyntaxTreeGenerator{
     GenericsRegistry ret = new GenericsRegistry(this.globalGenerics);
     ret.putAll(generics);
     if(ctx == null || ctx.typeParameterList() == null)return ret;
-    for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
-      ret.put(tp.Identifier().getText(), new GenericContext(parentClass, parentMethod));
-    }
     for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
       TypeGenerator.convert(tp, parentClass, parentMethod, reg, ret);
     }

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java

@@ -77,6 +77,7 @@ public class TypeGenerator {
         List<RefTypeOrTPHOrWildcardOrGeneric> bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics);
 
         GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
+        generics.put(name, new GenericContext(parentClass, parentMethod));
         return ret;
     }
 
@@ -91,7 +92,7 @@ public class TypeGenerator {
             return ret;
         }
         if(typeBoundContext.classOrInterfaceType() != null){
-            ret.add(convert(typeBoundContext.classOrInterfaceType(), reg, generics));
+            ret.add(convert(typeBoundContext.classOrInterfaceType()));
             if(typeBoundContext.additionalBound() != null)
                 for(Java8Parser.AdditionalBoundContext addCtx : typeBoundContext.additionalBound()){
                     ret.add(convert(addCtx.interfaceType()));
@@ -102,9 +103,8 @@ public class TypeGenerator {
         }
     }
 
-    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = classOrInterfaceTypeContext.classType_lfno_classOrInterfaceType();
-        return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),classOrInterfaceTypeContext.getStart(), reg, generics);
+    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext) {
+        throw new NotImplementedException();
     }
 
     private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.InterfaceTypeContext interfaceTypeContext) {
@@ -114,7 +114,8 @@ public class TypeGenerator {
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ReferenceTypeContext referenceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
         if(referenceTypeContext.classOrInterfaceType() != null){
             if(referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType()!= null){
-                return convert(referenceTypeContext.classOrInterfaceType(), reg, generics);//return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
+                Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType();
+                return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
             }else{
                 throw new NotImplementedException();
             }

src/de/dhbwstuttgart/sat/asp/ASPUnify.java

@@ -1,60 +0,0 @@
-package de.dhbwstuttgart.sat.asp;
-
-
-import org.apache.commons.io.IOUtils;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class ASPUnify {
-    private final List<File> input;
-    private static final List<File> programFiles = new ArrayList<>();
-
-    private static final String aspDirectory = System.getProperty("user.dir")+"/asp/";
-    static{
-        programFiles.add(new File(aspDirectory + "fc.lp"));
-        programFiles.add(new File(aspDirectory + "reduceRules.lp"));
-        programFiles.add(new File(aspDirectory + "adaptRules.lp"));
-        programFiles.add(new File(aspDirectory + "step4.lp"));
-        programFiles.add(new File(aspDirectory + "subst.lp"));
-        programFiles.add(new File(aspDirectory + "unifikation.lp"));
-        programFiles.add(new File(aspDirectory + "cartesian.lp"));
-        programFiles.add(new File(aspDirectory + "result.lp"));
-    }
-
-    public ASPUnify(List<File> inputFiles){
-        this.input = inputFiles;
-    }
-
-    /*
-    TODO: Clingo per Java Wrapper https://stackoverflow.com/questions/3356200/using-java-to-wrap-over-c
-     */
-    public String runClingo() throws IOException, InterruptedException {
-        String pathToClingo =
-                "clingo";
-        List<String> commands = new ArrayList<>();
-        commands.add(pathToClingo);
-        //commands.add("--outf=2"); //use JSON-Output
-        commands.add("--outf=1"); //use Text-Output
-        commands.add("-n 0"); //Compute n models
-        for(File file : input){
-            commands.add(file.getPath());
-        }
-        commands.addAll(programFiles.stream().map(f->f.getPath()).collect(Collectors.toList()));
-
-        //commands.stream().forEach(s -> System.out.print(s + " "));
-        //System.out.println();
-
-        Process clingo = new ProcessBuilder( commands.toArray(new String[0])).start();
-        InputStream output = clingo.getInputStream();
-        clingo.waitFor();
-        String result = IOUtils.toString(output, StandardCharsets.UTF_8);
-        System.out.println(result);
-        return result;
-    }
-}

src/de/dhbwstuttgart/sat/asp/Clingo.java

@@ -6,6 +6,7 @@ import org.apache.commons.io.IOUtils;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
@@ -15,7 +16,12 @@ public class Clingo {
     private final List<File> input;
     private static final List<File> programFiles = new ArrayList<>();
     static{
-        
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/basis.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/finiteclosure.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/subst.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/reduce.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/unify.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/adapt.lp"));
     }
 
     public Clingo(List<File> inputFiles){
@@ -27,12 +33,11 @@ public class Clingo {
      */
     public String runClingo() throws IOException, InterruptedException {
         String pathToClingo =
-                "clingo";
+                "/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/clingo-5.2.1-linux-x86_64/clingo";
         List<String> commands = new ArrayList<>();
         commands.add(pathToClingo);
         //commands.add("--outf=2"); //use JSON-Output
-        commands.add("--outf=1"); //use Text-Output
-        commands.add("-n 0"); //Compute all models
+        commands.add("--outf=1"); //use JSON-Output
         for(File file : input){
             commands.add(file.getPath());
         }

src/de/dhbwstuttgart/sat/asp/model/ASPGencayRule.java

@@ -1,7 +1,5 @@
 package de.dhbwstuttgart.sat.asp.model;
 
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-
 public enum ASPGencayRule {
     ASP_PAIR_EQUALS_NAME("equals"),
     ASP_PAIR_SMALLER_NAME("sub"),
@@ -9,13 +7,10 @@ public enum ASPGencayRule {
     ASP_PARAMLIST_NAME("paramEq"),
     ASP_FC_PARAMLIST_NAME("param"),
     ASP_PARAMLIST_END_POINTER("null"),
-    ASP_PARAMLIST_END_RULE_EQ("endParamEq"),
-    ASP_PARAMLIST_END_RULE_FC("endParam"),
     ASP_TYPE("typeEq"),
     ASP_FCTYPE("type"),
     ASP_TYPE_VAR("var"),
     ASP_GENERIC_VAR("pph"),
-    ASP_WILDCARD("wildcard"),
     ASP_PARAMLIST_ORDER("paramOrder");
 
     private final String text;

src/de/dhbwstuttgart/sat/asp/model/ASPRule.java

@@ -1,17 +1,14 @@
 package de.dhbwstuttgart.sat.asp.model;
 
-import de.dhbwstuttgart.bytecode.signature.Signature;
-
 public enum ASPRule {
     ASP_PAIR_EQUALS_NAME("equals"),
     ASP_PAIR_SMALLER_NAME("smaller"),
     ASP_PAIR_SMALLER_DOT_NAME("smallerDot"),
     ASP_PARAMLIST_NAME("param"),
+    ASP_PARAMLIST_END_POINTER("null"),
     ASP_TYPE("type"),
-    ASP_TYPE_VAR("typeVar"), ASP_ODER("oder"),
-    ASP_CONSTRAINT("constraint"),
-    ASP_LIST_NAME("list"),
-    ASP_LIST_ENDPOINTER("null");
+    ASP_FCTYPE("typeFC"),
+    ASP_TYPE_VAR("typeVar");
 
     private final String text;
 

src/de/dhbwstuttgart/sat/asp/parser/ASPParser.java

@@ -6,17 +6,23 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.sat.asp.ASPStringConverter;
 import de.dhbwstuttgart.sat.asp.model.ASPRule;
-import de.dhbwstuttgart.sat.asp.parser.antlr.*;
+import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultBaseListener;
+import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultLexer;
+import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultParser;
 import de.dhbwstuttgart.sat.asp.parser.model.ParsedType;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.*;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 
+import javax.json.Json;
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import java.io.StringReader;
 import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 /**
@@ -27,11 +33,14 @@ import java.util.stream.Collectors;
  * TODO: Überlegen welche Informationen noch nach der Unifizierung gebraucht werden
  *  -> Eigentlich nur die korrekten Namen der Typen und TPHs
  */
-public class ASPParser extends ASPResultBaseListener {
+public class ASPParser extends UnifyResultBaseListener {
     private Collection<TypePlaceholder> originalTPHs;
     private ResultSet resultSet;
-    private Map<String, RefTypeOrTPHOrWildcardOrGeneric> types = new HashMap();
+    private Map<String, ParsedType> types = new HashMap<>();
     private Set<String> tphs = new HashSet<>();
+    private Map<String, ParameterListNode> parameterLists = new HashMap<>();
+    private Set<Relation> equalsRelations = new HashSet<>();
+    private Set<Relation> smallerRelations = new HashSet<>();
 
     /**
      * Parst clingo output welcher als JSON (option --outf=2) ausgibt
@@ -42,6 +51,13 @@ public class ASPParser extends ASPResultBaseListener {
         return new ASPParser(toParse, oldPlaceholders).resultSet;
     }
 
+    @Override
+    public void enterParameter(UnifyResultParser.ParameterContext ctx) {
+        //Linked List (pointer, Type, nextPointer)
+        List<String> params = parseParameterList(ctx.parameterList());
+        parameterLists.put(params.get(0), new ParameterListNode(params.get(1), params.get(2)));
+    }
+
     private static class Relation {
         public final String right;
         public final String left;
@@ -71,73 +87,60 @@ public class ASPParser extends ASPResultBaseListener {
         ).collect(Collectors.toList());
     }
 
-    private void getTPHs(ASPResultParser.AnswerContext answer){
-        for(ASPResultParser.ResultSetRuleContext e : answer.resultSetRule()){
-            if(e.NAME().getText().equals(ASPRule.ASP_TYPE_VAR.toString())){
-                String pointer = e.parameterList().value(0).getText();
-                tphs.add(pointer);
-                String tphName = ASPStringConverter.fromConstant(pointer);
-                Optional<TypePlaceholder> oTPH = originalTPHs.stream().filter((a)->a.getName().equals(tphName)).findAny();
-                TypePlaceholder tph;
-                if(oTPH.isPresent()){
-                    tph = oTPH.get();
-                }else{
-                    tph = TypePlaceholder.fresh(new NullToken());
-                }
-                types.put(pointer, tph);
-            }
-        }
-    }
-    private void getTypes(ASPResultParser.AnswerContext answer) {
-        HashMap<String, String[]> rawTypes = new HashMap<>();
-        for(ASPResultParser.ResultSetRuleContext e : answer.resultSetRule()){
-            if(e.NAME().getText().equals(ASPRule.ASP_TYPE.toString())){
-                String pointer = e.parameterList().value(0).getText();
-                String name = e.parameterList().value(1).getText();
-                Integer numParams = Integer.parseInt(e.parameterList().value(2).getText());
-                String[] params = new String[numParams + 1];
-                params[0] = name;
-                rawTypes.put(pointer, params);
-            }
-        }
-        for(ASPResultParser.ResultSetRuleContext e : answer.resultSetRule()){
-            if(e.NAME().getText().equals(ASPRule.ASP_PARAMLIST_NAME.toString())){
-                String typePointer = e.parameterList().value(0).getText();
-                String paramPointer = e.parameterList().value(1).getText();
-                Integer paramNum = Integer.parseInt(e.parameterList().value(2).getText());
-                if(rawTypes.containsKey(typePointer)) {
-                    String[] paramArray = rawTypes.get(typePointer);
-                    paramArray[paramNum] = paramPointer;
-                }
-            }
-        }
-
-        for(String name : rawTypes.keySet()){
-            types.put(name, createType(name, rawTypes));
-        }
+    @Override
+    public void enterEquals(UnifyResultParser.EqualsContext ctx) {
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<2)throw new DebugException("Fehler in Equals-Regel");
+        String ls = parameterList.get(0);
+        String rs = parameterList.get(1);
+        equalsRelations.add(new Relation(ls, rs));
 
     }
-    private RefType createType(String name, HashMap<String, String[]> rawTypes){
-        String[] paramArray = rawTypes.get(name);
-        List<RefTypeOrTPHOrWildcardOrGeneric> paramList = new ArrayList<>();
-        for(int i = 1; i< paramArray.length ;i++){
-            String paramPointer = paramArray[i];
-            RefTypeOrTPHOrWildcardOrGeneric param;
-            if(rawTypes.containsKey(paramPointer)){
-                param = createType(paramPointer, rawTypes);
-            }else if(tphs.contains(paramPointer)){
-                String tphName = ASPStringConverter.fromConstant(paramPointer);
-                param = types.get(paramPointer);
-            }else{
-                throw new DebugException("Fehler beim Einlesen der Clingo Ausgabe");
-            }
-            if(param == null)
-                throw new NullPointerException();
-            paramList.add(param);
-        }
-        return new RefType(new JavaClassName(ASPStringConverter.fromConstant(paramArray[0])), paramList, new NullToken());
+
+    @Override
+    public void enterSmaller(UnifyResultParser.SmallerContext ctx) {
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<2)throw new DebugException("Fehler in Smaller-Regel");
+        String ls = parameterList.get(0);
+        String rs = parameterList.get(1);
+        smallerRelations.add(new Relation(ls, rs));
     }
 
+    @Override
+    public void enterTypeVar(UnifyResultParser.TypeVarContext ctx) {
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<1)throw new DebugException("Fehler in typeVar-Regel");
+        tphs.add(parameterList.get(0));
+    }
+
+    @Override
+    public void enterType(UnifyResultParser.TypeContext ctx){
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<3)throw new DebugException("Fehler in Type-Regel");
+        String name = parameterList.get(0);
+        String typeName = parameterList.get(1);
+        String paramPointer = parameterList.get(2);
+        types.put(name, new ParsedType(typeName, paramPointer));
+    }
+
+    /*
+        private List<String> parsedRule;
+        private List<String> parseRule(String rule){
+            UnifyResultLexer lexer = new UnifyResultLexer(CharStreams.fromString(rule));
+            UnifyResultParser.AspruleContext parseTree = new UnifyResultParser(new CommonTokenStream(lexer)).asprule();
+            parsedRule = new ArrayList<>();
+            new ParseTreeWalker().walk(this, parseTree);
+            return parsedRule;
+        }
+
+        @Override
+        public void enterAsprule(UnifyResultParser.AspruleContext ctx) {
+            super.enterAsprule(ctx);
+            for(int i = 0; i< ctx.getChildCount();i++){
+                parsedRule.add(ctx.getChild(i).getText());
+            }
+        }
+    */
     private ASPParser(String toParse, Collection<TypePlaceholder> oldPlaceholders){
         //System.out.println(toParse);
         this.originalTPHs = oldPlaceholders;
@@ -156,33 +159,73 @@ public class ASPParser extends ASPResultBaseListener {
         }
         System.out.println(completeResult);
         */
-        ASPResultLexer lexer = new ASPResultLexer(CharStreams.fromString(toParse));
-        ASPResultParser.AnswerContext parseTree = new ASPResultParser(new CommonTokenStream(lexer)).answer();
-        //new ParseTreeWalker().walk(this, parseTree);
+        UnifyResultLexer lexer = new UnifyResultLexer(CharStreams.fromString(toParse));
+        UnifyResultParser.AnswerContext parseTree = new UnifyResultParser(new CommonTokenStream(lexer)).answer();
+        new ParseTreeWalker().walk(this, parseTree);
 
         /*
         Diese Funktion läuft im folgenden mehrmals über das Result aus dem ASP Programm.
         Dabei werden Schritt für Schritt die Felder dieser Klasse befüllt die am Schluss das ResultSet ergeben
         */
-        getTPHs(parseTree);
-        getTypes(parseTree);
-
         Set<ResultPair> ret = new HashSet<>();
-        for(ASPResultParser.ResultSetRuleContext e : parseTree.resultSetRule()){
-            if(e.NAME().getText().equals(ASPRule.ASP_PAIR_EQUALS_NAME.toString())){
-                String tp1 = e.parameterList().value(0).getText();
-                String tp2 = e.parameterList().value(1).getText();
-                if(tphs.contains(tp1) && tphs.contains(tp2)){
-                    //Diese kann man ignorieren. Sollten eigentlich nicht auftauchen
-                    //ret.add(new PairTPHEqualTPH((TypePlaceholder) types.get(tp1), (TypePlaceholder) types.get(tp2)));
-                }else if(tphs.contains(tp1)){
-                    if(types.containsKey(tp2))
-                    ret.add(new PairTPHequalRefTypeOrWildcardType((TypePlaceholder) types.get(tp1), types.get(tp2)));
-                    else System.out.println(tp2);
-                }
-            }
+        //Zuerst die params und typeVars:
+        //for(String paramPointer : types.values().stream().map(parsedType -> parsedType.params).collect(Collectors.toList())){ }
+
+        //Dann die Equalsdot Statements
+        for(Relation eq : equalsRelations){
+            RefTypeOrTPHOrWildcardOrGeneric lsType = this.getType(eq.left);
+            RefTypeOrTPHOrWildcardOrGeneric rsType = this.getType(eq.right);
+            if(lsType instanceof TypePlaceholder && rsType instanceof RefType)
+                ret.add(new PairTPHequalRefTypeOrWildcardType((TypePlaceholder) lsType, rsType));
+            else if(lsType instanceof TypePlaceholder && rsType instanceof TypePlaceholder)
+                ret.add(new PairTPHEqualTPH((TypePlaceholder)lsType, (TypePlaceholder)rsType));
+            else throw new NotImplementedException();
         }
         this.resultSet = new ResultSet(ret);
     }
 
+    private RefTypeOrTPHOrWildcardOrGeneric getType(String name) {
+        if(tphs.contains(name)){
+            name = ASPStringConverter.fromConstant(name);
+            for(TypePlaceholder tph : originalTPHs){
+                if(tph.getName().equals(name))return tph;
+            }
+            return TypePlaceholder.fresh(new NullToken());
+        }else
+        if(types.containsKey(name)){
+            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+            ParsedType t = types.get(name);
+
+            for(String param : getParams(t.params)){
+                params.add(this.getType(param));
+            }
+            return new RefType(new JavaClassName(ASPStringConverter.fromConstant(t.name)), params, new NullToken());
+        }else throw new DebugException("Der Typ " + name + " konnte nicht bestimmt werden");
+    }
+
+    private static class ParameterListNode{
+        final String type;
+        final String nextNode;
+
+        public ParameterListNode(String type, String next) {
+            this.type = type;
+            this.nextNode = next;
+        }
+    }
+
+    private List<String> getParams(String pointer) {
+        List<String> params = new ArrayList<>();
+        while(pointer != null){
+            if(pointer.equals(ASPRule.ASP_PARAMLIST_END_POINTER.toString()))return params;
+            if(!parameterLists.containsKey(pointer))
+                throw new DebugException("Fehler in Ergebnisparsen");
+            //TODO: Fehler in ASP. Die adapt Regel muss erkennen, wenn die Parameterliste auf der linken Seite kürzer ist und diese Rechtzeitig beenden
+            ParameterListNode param = parameterLists.get(pointer);
+            pointer = param.nextNode;
+            params.add(param.type);
+        }
+        return params;
+        //Optional<ASPParameterList> ret = parameterLists.stream().filter(aspParameterList -> aspParameterList.name.equals(rs)).findAny();
+        //return ret.get();
+    }
 }

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResult.g4

@@ -1,17 +0,0 @@
-grammar ASPResult;
-
-answer : 'ANSWER' (resultSetRule '.')*;
-
-resultSetRule : NAME parameterList;
-
-parameterList : '(' value (',' value)*  ')';
-value : NAME
-        | resultSetRule ;
-
-NAME : [a-zA-Z0-9_']+;
-
-WS  :  [ \t\r\n\u000C]+ -> skip
-    ;
-LINE_COMMENT
-    :   '%' ~[\r\n]* -> skip
-    ;

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResult.tokens

@@ -1,13 +0,0 @@
-T__0=1
-T__1=2
-T__2=3
-T__3=4
-T__4=5
-NAME=6
-WS=7
-LINE_COMMENT=8
-'ANSWER'=1
-'.'=2
-'('=3
-','=4
-')'=5

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResultBaseListener.java

@@ -1,87 +0,0 @@
-// Generated from ASPResult.g4 by ANTLR 4.7
-package de.dhbwstuttgart.sat.asp.parser.antlr;
-
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.tree.ErrorNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
-
-/**
- * This class provides an empty implementation of {@link ASPResultListener},
- * which can be extended to create a listener which only needs to handle a subset
- * of the available methods.
- */
-public class ASPResultBaseListener implements ASPResultListener {
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterAnswer(ASPResultParser.AnswerContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitAnswer(ASPResultParser.AnswerContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterResultSetRule(ASPResultParser.ResultSetRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitResultSetRule(ASPResultParser.ResultSetRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterParameterList(ASPResultParser.ParameterListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitParameterList(ASPResultParser.ParameterListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterValue(ASPResultParser.ValueContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitValue(ASPResultParser.ValueContext ctx) { }
-
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterEveryRule(ParserRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitEveryRule(ParserRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void visitTerminal(TerminalNode node) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void visitErrorNode(ErrorNode node) { }
-}

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResultLexer.java

@@ -1,121 +0,0 @@
-// Generated from ASPResult.g4 by ANTLR 4.7
-package de.dhbwstuttgart.sat.asp.parser.antlr;
-import org.antlr.v4.runtime.Lexer;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.TokenStream;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.atn.*;
-import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.misc.*;
-
-@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class ASPResultLexer extends Lexer {
-	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
-
-	protected static final DFA[] _decisionToDFA;
-	protected static final PredictionContextCache _sharedContextCache =
-		new PredictionContextCache();
-	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, NAME=6, WS=7, LINE_COMMENT=8;
-	public static String[] channelNames = {
-		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
-	};
-
-	public static String[] modeNames = {
-		"DEFAULT_MODE"
-	};
-
-	public static final String[] ruleNames = {
-		"T__0", "T__1", "T__2", "T__3", "T__4", "NAME", "WS", "LINE_COMMENT"
-	};
-
-	private static final String[] _LITERAL_NAMES = {
-		null, "'ANSWER'", "'.'", "'('", "','", "')'"
-	};
-	private static final String[] _SYMBOLIC_NAMES = {
-		null, null, null, null, null, null, "NAME", "WS", "LINE_COMMENT"
-	};
-	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
-
-	/**
-	 * @deprecated Use {@link #VOCABULARY} instead.
-	 */
-	@Deprecated
-	public static final String[] tokenNames;
-	static {
-		tokenNames = new String[_SYMBOLIC_NAMES.length];
-		for (int i = 0; i < tokenNames.length; i++) {
-			tokenNames[i] = VOCABULARY.getLiteralName(i);
-			if (tokenNames[i] == null) {
-				tokenNames[i] = VOCABULARY.getSymbolicName(i);
-			}
-
-			if (tokenNames[i] == null) {
-				tokenNames[i] = "<INVALID>";
-			}
-		}
-	}
-
-	@Override
-	@Deprecated
-	public String[] getTokenNames() {
-		return tokenNames;
-	}
-
-	@Override
-
-	public Vocabulary getVocabulary() {
-		return VOCABULARY;
-	}
-
-
-	public ASPResultLexer(CharStream input) {
-		super(input);
-		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
-	}
-
-	@Override
-	public String getGrammarFileName() { return "ASPResult.g4"; }
-
-	@Override
-	public String[] getRuleNames() { return ruleNames; }
-
-	@Override
-	public String getSerializedATN() { return _serializedATN; }
-
-	@Override
-	public String[] getChannelNames() { return channelNames; }
-
-	@Override
-	public String[] getModeNames() { return modeNames; }
-
-	@Override
-	public ATN getATN() { return _ATN; }
-
-	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\n\67\b\1\4\2\t\2"+
-		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3"+
-		"\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\6\7$\n\7\r\7\16\7%"+
-		"\3\b\6\b)\n\b\r\b\16\b*\3\b\3\b\3\t\3\t\7\t\61\n\t\f\t\16\t\64\13\t\3"+
-		"\t\3\t\2\2\n\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\3\2\5\7\2))\62;C\\aac"+
-		"|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\29\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2"+
-		"\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\3"+
-		"\23\3\2\2\2\5\32\3\2\2\2\7\34\3\2\2\2\t\36\3\2\2\2\13 \3\2\2\2\r#\3\2"+
-		"\2\2\17(\3\2\2\2\21.\3\2\2\2\23\24\7C\2\2\24\25\7P\2\2\25\26\7U\2\2\26"+
-		"\27\7Y\2\2\27\30\7G\2\2\30\31\7T\2\2\31\4\3\2\2\2\32\33\7\60\2\2\33\6"+
-		"\3\2\2\2\34\35\7*\2\2\35\b\3\2\2\2\36\37\7.\2\2\37\n\3\2\2\2 !\7+\2\2"+
-		"!\f\3\2\2\2\"$\t\2\2\2#\"\3\2\2\2$%\3\2\2\2%#\3\2\2\2%&\3\2\2\2&\16\3"+
-		"\2\2\2\')\t\3\2\2(\'\3\2\2\2)*\3\2\2\2*(\3\2\2\2*+\3\2\2\2+,\3\2\2\2,"+
-		"-\b\b\2\2-\20\3\2\2\2.\62\7\'\2\2/\61\n\4\2\2\60/\3\2\2\2\61\64\3\2\2"+
-		"\2\62\60\3\2\2\2\62\63\3\2\2\2\63\65\3\2\2\2\64\62\3\2\2\2\65\66\b\t\2"+
-		"\2\66\22\3\2\2\2\6\2%*\62\3\b\2\2";
-	public static final ATN _ATN =
-		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
-	static {
-		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
-		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
-			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
-		}
-	}
-}

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResultLexer.tokens

@@ -1,13 +0,0 @@
-T__0=1
-T__1=2
-T__2=3
-T__3=4
-T__4=5
-NAME=6
-WS=7
-LINE_COMMENT=8
-'ANSWER'=1
-'.'=2
-'('=3
-','=4
-')'=5

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResultListener.java

@@ -1,50 +0,0 @@
-// Generated from ASPResult.g4 by ANTLR 4.7
-package de.dhbwstuttgart.sat.asp.parser.antlr;
-import org.antlr.v4.runtime.tree.ParseTreeListener;
-
-/**
- * This interface defines a complete listener for a parse tree produced by
- * {@link ASPResultParser}.
- */
-public interface ASPResultListener extends ParseTreeListener {
-	/**
-	 * Enter a parse tree produced by {@link ASPResultParser#answer}.
-	 * @param ctx the parse tree
-	 */
-	void enterAnswer(ASPResultParser.AnswerContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link ASPResultParser#answer}.
-	 * @param ctx the parse tree
-	 */
-	void exitAnswer(ASPResultParser.AnswerContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link ASPResultParser#resultSetRule}.
-	 * @param ctx the parse tree
-	 */
-	void enterResultSetRule(ASPResultParser.ResultSetRuleContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link ASPResultParser#resultSetRule}.
-	 * @param ctx the parse tree
-	 */
-	void exitResultSetRule(ASPResultParser.ResultSetRuleContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link ASPResultParser#parameterList}.
-	 * @param ctx the parse tree
-	 */
-	void enterParameterList(ASPResultParser.ParameterListContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link ASPResultParser#parameterList}.
-	 * @param ctx the parse tree
-	 */
-	void exitParameterList(ASPResultParser.ParameterListContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link ASPResultParser#value}.
-	 * @param ctx the parse tree
-	 */
-	void enterValue(ASPResultParser.ValueContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link ASPResultParser#value}.
-	 * @param ctx the parse tree
-	 */
-	void exitValue(ASPResultParser.ValueContext ctx);
-}

src/de/dhbwstuttgart/sat/asp/parser/antlr/ASPResultParser.java

@@ -1,318 +0,0 @@
-// Generated from ASPResult.g4 by ANTLR 4.7
-package de.dhbwstuttgart.sat.asp.parser.antlr;
-import org.antlr.v4.runtime.atn.*;
-import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.misc.*;
-import org.antlr.v4.runtime.tree.*;
-import java.util.List;
-import java.util.Iterator;
-import java.util.ArrayList;
-
-@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class ASPResultParser extends Parser {
-	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
-
-	protected static final DFA[] _decisionToDFA;
-	protected static final PredictionContextCache _sharedContextCache =
-		new PredictionContextCache();
-	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, NAME=6, WS=7, LINE_COMMENT=8;
-	public static final int
-		RULE_answer = 0, RULE_resultSetRule = 1, RULE_parameterList = 2, RULE_value = 3;
-	public static final String[] ruleNames = {
-		"answer", "resultSetRule", "parameterList", "value"
-	};
-
-	private static final String[] _LITERAL_NAMES = {
-		null, "'ANSWER'", "'.'", "'('", "','", "')'"
-	};
-	private static final String[] _SYMBOLIC_NAMES = {
-		null, null, null, null, null, null, "NAME", "WS", "LINE_COMMENT"
-	};
-	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
-
-	/**
-	 * @deprecated Use {@link #VOCABULARY} instead.
-	 */
-	@Deprecated
-	public static final String[] tokenNames;
-	static {
-		tokenNames = new String[_SYMBOLIC_NAMES.length];
-		for (int i = 0; i < tokenNames.length; i++) {
-			tokenNames[i] = VOCABULARY.getLiteralName(i);
-			if (tokenNames[i] == null) {
-				tokenNames[i] = VOCABULARY.getSymbolicName(i);
-			}
-
-			if (tokenNames[i] == null) {
-				tokenNames[i] = "<INVALID>";
-			}
-		}
-	}
-
-	@Override
-	@Deprecated
-	public String[] getTokenNames() {
-		return tokenNames;
-	}
-
-	@Override
-
-	public Vocabulary getVocabulary() {
-		return VOCABULARY;
-	}
-
-	@Override
-	public String getGrammarFileName() { return "ASPResult.g4"; }
-
-	@Override
-	public String[] getRuleNames() { return ruleNames; }
-
-	@Override
-	public String getSerializedATN() { return _serializedATN; }
-
-	@Override
-	public ATN getATN() { return _ATN; }
-
-	public ASPResultParser(TokenStream input) {
-		super(input);
-		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
-	}
-	public static class AnswerContext extends ParserRuleContext {
-		public List<ResultSetRuleContext> resultSetRule() {
-			return getRuleContexts(ResultSetRuleContext.class);
-		}
-		public ResultSetRuleContext resultSetRule(int i) {
-			return getRuleContext(ResultSetRuleContext.class,i);
-		}
-		public AnswerContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_answer; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterAnswer(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitAnswer(this);
-		}
-	}
-
-	public final AnswerContext answer() throws RecognitionException {
-		AnswerContext _localctx = new AnswerContext(_ctx, getState());
-		enterRule(_localctx, 0, RULE_answer);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(8);
-			match(T__0);
-			setState(14);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			while (_la==NAME) {
-				{
-				{
-				setState(9);
-				resultSetRule();
-				setState(10);
-				match(T__1);
-				}
-				}
-				setState(16);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-			}
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ResultSetRuleContext extends ParserRuleContext {
-		public TerminalNode NAME() { return getToken(ASPResultParser.NAME, 0); }
-		public ParameterListContext parameterList() {
-			return getRuleContext(ParameterListContext.class,0);
-		}
-		public ResultSetRuleContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_resultSetRule; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterResultSetRule(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitResultSetRule(this);
-		}
-	}
-
-	public final ResultSetRuleContext resultSetRule() throws RecognitionException {
-		ResultSetRuleContext _localctx = new ResultSetRuleContext(_ctx, getState());
-		enterRule(_localctx, 2, RULE_resultSetRule);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(17);
-			match(NAME);
-			setState(18);
-			parameterList();
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ParameterListContext extends ParserRuleContext {
-		public List<ValueContext> value() {
-			return getRuleContexts(ValueContext.class);
-		}
-		public ValueContext value(int i) {
-			return getRuleContext(ValueContext.class,i);
-		}
-		public ParameterListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_parameterList; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterParameterList(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitParameterList(this);
-		}
-	}
-
-	public final ParameterListContext parameterList() throws RecognitionException {
-		ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
-		enterRule(_localctx, 4, RULE_parameterList);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(20);
-			match(T__2);
-			setState(21);
-			value();
-			setState(26);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			while (_la==T__3) {
-				{
-				{
-				setState(22);
-				match(T__3);
-				setState(23);
-				value();
-				}
-				}
-				setState(28);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-			}
-			setState(29);
-			match(T__4);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ValueContext extends ParserRuleContext {
-		public TerminalNode NAME() { return getToken(ASPResultParser.NAME, 0); }
-		public ResultSetRuleContext resultSetRule() {
-			return getRuleContext(ResultSetRuleContext.class,0);
-		}
-		public ValueContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_value; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterValue(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitValue(this);
-		}
-	}
-
-	public final ValueContext value() throws RecognitionException {
-		ValueContext _localctx = new ValueContext(_ctx, getState());
-		enterRule(_localctx, 6, RULE_value);
-		try {
-			setState(33);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
-			case 1:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(31);
-				match(NAME);
-				}
-				break;
-			case 2:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(32);
-				resultSetRule();
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\n&\4\2\t\2\4\3\t"+
-		"\3\4\4\t\4\4\5\t\5\3\2\3\2\3\2\3\2\7\2\17\n\2\f\2\16\2\22\13\2\3\3\3\3"+
-		"\3\3\3\4\3\4\3\4\3\4\7\4\33\n\4\f\4\16\4\36\13\4\3\4\3\4\3\5\3\5\5\5$"+
-		"\n\5\3\5\2\2\6\2\4\6\b\2\2\2$\2\n\3\2\2\2\4\23\3\2\2\2\6\26\3\2\2\2\b"+
-		"#\3\2\2\2\n\20\7\3\2\2\13\f\5\4\3\2\f\r\7\4\2\2\r\17\3\2\2\2\16\13\3\2"+
-		"\2\2\17\22\3\2\2\2\20\16\3\2\2\2\20\21\3\2\2\2\21\3\3\2\2\2\22\20\3\2"+
-		"\2\2\23\24\7\b\2\2\24\25\5\6\4\2\25\5\3\2\2\2\26\27\7\5\2\2\27\34\5\b"+
-		"\5\2\30\31\7\6\2\2\31\33\5\b\5\2\32\30\3\2\2\2\33\36\3\2\2\2\34\32\3\2"+
-		"\2\2\34\35\3\2\2\2\35\37\3\2\2\2\36\34\3\2\2\2\37 \7\7\2\2 \7\3\2\2\2"+
-		"!$\7\b\2\2\"$\5\4\3\2#!\3\2\2\2#\"\3\2\2\2$\t\3\2\2\2\5\20\34#";
-	public static final ATN _ATN =
-		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
-	static {
-		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
-		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
-			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
-		}
-	}
-}

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResult.g4

@@ -8,7 +8,6 @@ resultSetRule :
     | smaller
     | typeVar
     | type
-    | unifier
     | otherRule
     ;
 
@@ -18,7 +17,6 @@ value : NAME
 
 parameter : PARAMLIST_NAME parameterList;
 equals : EQUALS_NAME parameterList;
-unifier : UNIFIER_NAME parameterList;
 smaller : SMALLER_NAME parameterList;
 typeVar : TYPEVAR_NAME parameterList;
 type : TYPE_NAME parameterList;
@@ -26,7 +24,6 @@ otherRule : NAME parameterList;
 
 //TODO: Es sollte Regeln für das Result set geben, welche sich nicht mit den anderen überdecken, dann auch nur diese im Result ausgeben
 PARAMLIST_NAME : 'param';
-UNIFIER_NAME : 'unifier';
 EQUALS_NAME : 'equals';
 SMALLER_NAME : 'smaller';
 TYPEVAR_NAME : 'typeVar';
@@ -38,4 +35,3 @@ WS  :  [ \t\r\n\u000C]+ -> skip
 LINE_COMMENT
     :   '%' ~[\r\n]* -> skip
     ;
-

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResult.tokens

@@ -4,22 +4,20 @@ T__2=3
 T__3=4
 T__4=5
 PARAMLIST_NAME=6
-UNIFIER_NAME=7
-EQUALS_NAME=8
-SMALLER_NAME=9
-TYPEVAR_NAME=10
-TYPE_NAME=11
-NAME=12
-WS=13
-LINE_COMMENT=14
+EQUALS_NAME=7
+SMALLER_NAME=8
+TYPEVAR_NAME=9
+TYPE_NAME=10
+NAME=11
+WS=12
+LINE_COMMENT=13
 'ANSWER'=1
 '.'=2
 '('=3
 ','=4
 ')'=5
 'param'=6
-'unifier'=7
-'equals'=8
-'smaller'=9
-'typeVar'=10
-'type'=11
+'equals'=7
+'smaller'=8
+'typeVar'=9
+'type'=10

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultBaseListener.java

@@ -83,18 +83,6 @@ public class UnifyResultBaseListener implements UnifyResultListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitEquals(UnifyResultParser.EqualsContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterUnifier(UnifyResultParser.UnifierContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitUnifier(UnifyResultParser.UnifierContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultLexer.java

@@ -17,9 +17,8 @@ public class UnifyResultLexer extends Lexer {
 	protected static final PredictionContextCache _sharedContextCache =
 		new PredictionContextCache();
 	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, UNIFIER_NAME=7, 
-		EQUALS_NAME=8, SMALLER_NAME=9, TYPEVAR_NAME=10, TYPE_NAME=11, NAME=12, 
-		WS=13, LINE_COMMENT=14;
+		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, EQUALS_NAME=7, 
+		SMALLER_NAME=8, TYPEVAR_NAME=9, TYPE_NAME=10, NAME=11, WS=12, LINE_COMMENT=13;
 	public static String[] channelNames = {
 		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
 	};
@@ -29,19 +28,17 @@ public class UnifyResultLexer extends Lexer {
 	};
 
 	public static final String[] ruleNames = {
-		"T__0", "T__1", "T__2", "T__3", "T__4", "PARAMLIST_NAME", "UNIFIER_NAME", 
-		"EQUALS_NAME", "SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", 
-		"LINE_COMMENT"
+		"T__0", "T__1", "T__2", "T__3", "T__4", "PARAMLIST_NAME", "EQUALS_NAME", 
+		"SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
 	};
 
 	private static final String[] _LITERAL_NAMES = {
-		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'unifier'", 
-		"'equals'", "'smaller'", "'typeVar'", "'type'"
+		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'equals'", "'smaller'", 
+		"'typeVar'", "'type'"
 	};
 	private static final String[] _SYMBOLIC_NAMES = {
-		null, null, null, null, null, null, "PARAMLIST_NAME", "UNIFIER_NAME", 
-		"EQUALS_NAME", "SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", 
-		"LINE_COMMENT"
+		null, null, null, null, null, null, "PARAMLIST_NAME", "EQUALS_NAME", "SMALLER_NAME", 
+		"TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
 	};
 	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
 
@@ -101,33 +98,31 @@ public class UnifyResultLexer extends Lexer {
 	public ATN getATN() { return _ATN; }
 
 	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\20m\b\1\4\2\t\2\4"+
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\17c\b\1\4\2\t\2\4"+
 		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
-		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3"+
-		"\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b"+
-		"\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3"+
-		"\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r"+
-		"\6\rZ\n\r\r\r\16\r[\3\16\6\16_\n\16\r\16\16\16`\3\16\3\16\3\17\3\17\7"+
-		"\17g\n\17\f\17\16\17j\13\17\3\17\3\17\2\2\20\3\3\5\4\7\5\t\6\13\7\r\b"+
-		"\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\3\2\5\6\2\62;C\\aac|\5\2"+
-		"\13\f\16\17\"\"\4\2\f\f\17\17\2o\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2"+
-		"\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2"+
-		"\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2"+
-		"\3\37\3\2\2\2\5&\3\2\2\2\7(\3\2\2\2\t*\3\2\2\2\13,\3\2\2\2\r.\3\2\2\2"+
-		"\17\64\3\2\2\2\21<\3\2\2\2\23C\3\2\2\2\25K\3\2\2\2\27S\3\2\2\2\31Y\3\2"+
-		"\2\2\33^\3\2\2\2\35d\3\2\2\2\37 \7C\2\2 !\7P\2\2!\"\7U\2\2\"#\7Y\2\2#"+
-		"$\7G\2\2$%\7T\2\2%\4\3\2\2\2&\'\7\60\2\2\'\6\3\2\2\2()\7*\2\2)\b\3\2\2"+
-		"\2*+\7.\2\2+\n\3\2\2\2,-\7+\2\2-\f\3\2\2\2./\7r\2\2/\60\7c\2\2\60\61\7"+
-		"t\2\2\61\62\7c\2\2\62\63\7o\2\2\63\16\3\2\2\2\64\65\7w\2\2\65\66\7p\2"+
-		"\2\66\67\7k\2\2\678\7h\2\289\7k\2\29:\7g\2\2:;\7t\2\2;\20\3\2\2\2<=\7"+
-		"g\2\2=>\7s\2\2>?\7w\2\2?@\7c\2\2@A\7n\2\2AB\7u\2\2B\22\3\2\2\2CD\7u\2"+
-		"\2DE\7o\2\2EF\7c\2\2FG\7n\2\2GH\7n\2\2HI\7g\2\2IJ\7t\2\2J\24\3\2\2\2K"+
-		"L\7v\2\2LM\7{\2\2MN\7r\2\2NO\7g\2\2OP\7X\2\2PQ\7c\2\2QR\7t\2\2R\26\3\2"+
-		"\2\2ST\7v\2\2TU\7{\2\2UV\7r\2\2VW\7g\2\2W\30\3\2\2\2XZ\t\2\2\2YX\3\2\2"+
-		"\2Z[\3\2\2\2[Y\3\2\2\2[\\\3\2\2\2\\\32\3\2\2\2]_\t\3\2\2^]\3\2\2\2_`\3"+
-		"\2\2\2`^\3\2\2\2`a\3\2\2\2ab\3\2\2\2bc\b\16\2\2c\34\3\2\2\2dh\7\'\2\2"+
-		"eg\n\4\2\2fe\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3\2\2\2ik\3\2\2\2jh\3\2\2\2"+
-		"kl\b\17\2\2l\36\3\2\2\2\6\2[`h\3\b\2\2";
+		"\13\4\f\t\f\4\r\t\r\4\16\t\16\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4"+
+		"\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3"+
+		"\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13"+
+		"\3\13\3\13\3\13\3\13\3\f\6\fP\n\f\r\f\16\fQ\3\r\6\rU\n\r\r\r\16\rV\3\r"+
+		"\3\r\3\16\3\16\7\16]\n\16\f\16\16\16`\13\16\3\16\3\16\2\2\17\3\3\5\4\7"+
+		"\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\3\2\5\6\2\62;C\\"+
+		"aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\2e\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3"+
+		"\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2"+
+		"\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\3\35"+
+		"\3\2\2\2\5$\3\2\2\2\7&\3\2\2\2\t(\3\2\2\2\13*\3\2\2\2\r,\3\2\2\2\17\62"+
+		"\3\2\2\2\219\3\2\2\2\23A\3\2\2\2\25I\3\2\2\2\27O\3\2\2\2\31T\3\2\2\2\33"+
+		"Z\3\2\2\2\35\36\7C\2\2\36\37\7P\2\2\37 \7U\2\2 !\7Y\2\2!\"\7G\2\2\"#\7"+
+		"T\2\2#\4\3\2\2\2$%\7\60\2\2%\6\3\2\2\2&\'\7*\2\2\'\b\3\2\2\2()\7.\2\2"+
+		")\n\3\2\2\2*+\7+\2\2+\f\3\2\2\2,-\7r\2\2-.\7c\2\2./\7t\2\2/\60\7c\2\2"+
+		"\60\61\7o\2\2\61\16\3\2\2\2\62\63\7g\2\2\63\64\7s\2\2\64\65\7w\2\2\65"+
+		"\66\7c\2\2\66\67\7n\2\2\678\7u\2\28\20\3\2\2\29:\7u\2\2:;\7o\2\2;<\7c"+
+		"\2\2<=\7n\2\2=>\7n\2\2>?\7g\2\2?@\7t\2\2@\22\3\2\2\2AB\7v\2\2BC\7{\2\2"+
+		"CD\7r\2\2DE\7g\2\2EF\7X\2\2FG\7c\2\2GH\7t\2\2H\24\3\2\2\2IJ\7v\2\2JK\7"+
+		"{\2\2KL\7r\2\2LM\7g\2\2M\26\3\2\2\2NP\t\2\2\2ON\3\2\2\2PQ\3\2\2\2QO\3"+
+		"\2\2\2QR\3\2\2\2R\30\3\2\2\2SU\t\3\2\2TS\3\2\2\2UV\3\2\2\2VT\3\2\2\2V"+
+		"W\3\2\2\2WX\3\2\2\2XY\b\r\2\2Y\32\3\2\2\2Z^\7\'\2\2[]\n\4\2\2\\[\3\2\2"+
+		"\2]`\3\2\2\2^\\\3\2\2\2^_\3\2\2\2_a\3\2\2\2`^\3\2\2\2ab\b\16\2\2b\34\3"+
+		"\2\2\2\6\2QV^\3\b\2\2";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultLexer.tokens

@@ -4,22 +4,20 @@ T__2=3
 T__3=4
 T__4=5
 PARAMLIST_NAME=6
-UNIFIER_NAME=7
-EQUALS_NAME=8
-SMALLER_NAME=9
-TYPEVAR_NAME=10
-TYPE_NAME=11
-NAME=12
-WS=13
-LINE_COMMENT=14
+EQUALS_NAME=7
+SMALLER_NAME=8
+TYPEVAR_NAME=9
+TYPE_NAME=10
+NAME=11
+WS=12
+LINE_COMMENT=13
 'ANSWER'=1
 '.'=2
 '('=3
 ','=4
 ')'=5
 'param'=6
-'unifier'=7
-'equals'=8
-'smaller'=9
-'typeVar'=10
-'type'=11
+'equals'=7
+'smaller'=8
+'typeVar'=9
+'type'=10

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultListener.java

@@ -67,16 +67,6 @@ public interface UnifyResultListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitEquals(UnifyResultParser.EqualsContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link UnifyResultParser#unifier}.
-	 * @param ctx the parse tree
-	 */
-	void enterUnifier(UnifyResultParser.UnifierContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link UnifyResultParser#unifier}.
-	 * @param ctx the parse tree
-	 */
-	void exitUnifier(UnifyResultParser.UnifierContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link UnifyResultParser#smaller}.
 	 * @param ctx the parse tree

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultParser.java

@@ -17,26 +17,24 @@ public class UnifyResultParser extends Parser {
 	protected static final PredictionContextCache _sharedContextCache =
 		new PredictionContextCache();
 	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, UNIFIER_NAME=7, 
-		EQUALS_NAME=8, SMALLER_NAME=9, TYPEVAR_NAME=10, TYPE_NAME=11, NAME=12, 
-		WS=13, LINE_COMMENT=14;
+		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, EQUALS_NAME=7, 
+		SMALLER_NAME=8, TYPEVAR_NAME=9, TYPE_NAME=10, NAME=11, WS=12, LINE_COMMENT=13;
 	public static final int
 		RULE_answer = 0, RULE_resultSetRule = 1, RULE_parameterList = 2, RULE_value = 3, 
-		RULE_parameter = 4, RULE_equals = 5, RULE_unifier = 6, RULE_smaller = 7, 
-		RULE_typeVar = 8, RULE_type = 9, RULE_otherRule = 10;
+		RULE_parameter = 4, RULE_equals = 5, RULE_smaller = 6, RULE_typeVar = 7, 
+		RULE_type = 8, RULE_otherRule = 9;
 	public static final String[] ruleNames = {
 		"answer", "resultSetRule", "parameterList", "value", "parameter", "equals", 
-		"unifier", "smaller", "typeVar", "type", "otherRule"
+		"smaller", "typeVar", "type", "otherRule"
 	};
 
 	private static final String[] _LITERAL_NAMES = {
-		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'unifier'", 
-		"'equals'", "'smaller'", "'typeVar'", "'type'"
+		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'equals'", "'smaller'", 
+		"'typeVar'", "'type'"
 	};
 	private static final String[] _SYMBOLIC_NAMES = {
-		null, null, null, null, null, null, "PARAMLIST_NAME", "UNIFIER_NAME", 
-		"EQUALS_NAME", "SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", 
-		"LINE_COMMENT"
+		null, null, null, null, null, null, "PARAMLIST_NAME", "EQUALS_NAME", "SMALLER_NAME", 
+		"TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
 	};
 	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
 
@@ -115,21 +113,21 @@ public class UnifyResultParser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(22);
+			setState(20);
 			match(T__0);
-			setState(28);
+			setState(26);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PARAMLIST_NAME) | (1L << UNIFIER_NAME) | (1L << EQUALS_NAME) | (1L << SMALLER_NAME) | (1L << TYPEVAR_NAME) | (1L << TYPE_NAME) | (1L << NAME))) != 0)) {
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PARAMLIST_NAME) | (1L << EQUALS_NAME) | (1L << SMALLER_NAME) | (1L << TYPEVAR_NAME) | (1L << TYPE_NAME) | (1L << NAME))) != 0)) {
 				{
 				{
-				setState(23);
+				setState(21);
 				resultSetRule();
-				setState(24);
+				setState(22);
 				match(T__1);
 				}
 				}
-				setState(30);
+				setState(28);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -162,9 +160,6 @@ public class UnifyResultParser extends Parser {
 		public TypeContext type() {
 			return getRuleContext(TypeContext.class,0);
 		}
-		public UnifierContext unifier() {
-			return getRuleContext(UnifierContext.class,0);
-		}
 		public OtherRuleContext otherRule() {
 			return getRuleContext(OtherRuleContext.class,0);
 		}
@@ -186,55 +181,48 @@ public class UnifyResultParser extends Parser {
 		ResultSetRuleContext _localctx = new ResultSetRuleContext(_ctx, getState());
 		enterRule(_localctx, 2, RULE_resultSetRule);
 		try {
-			setState(38);
+			setState(35);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case PARAMLIST_NAME:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(31);
+				setState(29);
 				parameter();
 				}
 				break;
 			case EQUALS_NAME:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(32);
+				setState(30);
 				equals();
 				}
 				break;
 			case SMALLER_NAME:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(33);
+				setState(31);
 				smaller();
 				}
 				break;
 			case TYPEVAR_NAME:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(34);
+				setState(32);
 				typeVar();
 				}
 				break;
 			case TYPE_NAME:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(35);
+				setState(33);
 				type();
 				}
 				break;
-			case UNIFIER_NAME:
+			case NAME:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(36);
-				unifier();
-				}
-				break;
-			case NAME:
-				enterOuterAlt(_localctx, 7);
-				{
-				setState(37);
+				setState(34);
 				otherRule();
 				}
 				break;
@@ -281,27 +269,27 @@ public class UnifyResultParser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(40);
+			setState(37);
 			match(T__2);
-			setState(41);
+			setState(38);
 			value();
-			setState(46);
+			setState(43);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__3) {
 				{
 				{
-				setState(42);
+				setState(39);
 				match(T__3);
-				setState(43);
+				setState(40);
 				value();
 				}
 				}
-				setState(48);
+				setState(45);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(49);
+			setState(46);
 			match(T__4);
 			}
 		}
@@ -339,20 +327,20 @@ public class UnifyResultParser extends Parser {
 		ValueContext _localctx = new ValueContext(_ctx, getState());
 		enterRule(_localctx, 6, RULE_value);
 		try {
-			setState(53);
+			setState(50);
 			_errHandler.sync(this);
 			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(51);
+				setState(48);
 				match(NAME);
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(52);
+				setState(49);
 				resultSetRule();
 				}
 				break;
@@ -394,9 +382,9 @@ public class UnifyResultParser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(55);
+			setState(52);
 			match(PARAMLIST_NAME);
-			setState(56);
+			setState(53);
 			parameterList();
 			}
 		}
@@ -436,51 +424,9 @@ public class UnifyResultParser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(58);
+			setState(55);
 			match(EQUALS_NAME);
-			setState(59);
-			parameterList();
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class UnifierContext extends ParserRuleContext {
-		public TerminalNode UNIFIER_NAME() { return getToken(UnifyResultParser.UNIFIER_NAME, 0); }
-		public ParameterListContext parameterList() {
-			return getRuleContext(ParameterListContext.class,0);
-		}
-		public UnifierContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_unifier; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterUnifier(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitUnifier(this);
-		}
-	}
-
-	public final UnifierContext unifier() throws RecognitionException {
-		UnifierContext _localctx = new UnifierContext(_ctx, getState());
-		enterRule(_localctx, 12, RULE_unifier);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(61);
-			match(UNIFIER_NAME);
-			setState(62);
+			setState(56);
 			parameterList();
 			}
 		}
@@ -516,13 +462,13 @@ public class UnifyResultParser extends Parser {
 
 	public final SmallerContext smaller() throws RecognitionException {
 		SmallerContext _localctx = new SmallerContext(_ctx, getState());
-		enterRule(_localctx, 14, RULE_smaller);
+		enterRule(_localctx, 12, RULE_smaller);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(64);
+			setState(58);
 			match(SMALLER_NAME);
-			setState(65);
+			setState(59);
 			parameterList();
 			}
 		}
@@ -558,13 +504,13 @@ public class UnifyResultParser extends Parser {
 
 	public final TypeVarContext typeVar() throws RecognitionException {
 		TypeVarContext _localctx = new TypeVarContext(_ctx, getState());
-		enterRule(_localctx, 16, RULE_typeVar);
+		enterRule(_localctx, 14, RULE_typeVar);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(67);
+			setState(61);
 			match(TYPEVAR_NAME);
-			setState(68);
+			setState(62);
 			parameterList();
 			}
 		}
@@ -600,13 +546,13 @@ public class UnifyResultParser extends Parser {
 
 	public final TypeContext type() throws RecognitionException {
 		TypeContext _localctx = new TypeContext(_ctx, getState());
-		enterRule(_localctx, 18, RULE_type);
+		enterRule(_localctx, 16, RULE_type);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(70);
+			setState(64);
 			match(TYPE_NAME);
-			setState(71);
+			setState(65);
 			parameterList();
 			}
 		}
@@ -642,13 +588,13 @@ public class UnifyResultParser extends Parser {
 
 	public final OtherRuleContext otherRule() throws RecognitionException {
 		OtherRuleContext _localctx = new OtherRuleContext(_ctx, getState());
-		enterRule(_localctx, 20, RULE_otherRule);
+		enterRule(_localctx, 18, RULE_otherRule);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(73);
+			setState(67);
 			match(NAME);
-			setState(74);
+			setState(68);
 			parameterList();
 			}
 		}
@@ -664,25 +610,24 @@ public class UnifyResultParser extends Parser {
 	}
 
 	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\20O\4\2\t\2\4\3\t"+
-		"\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4"+
-		"\f\t\f\3\2\3\2\3\2\3\2\7\2\35\n\2\f\2\16\2 \13\2\3\3\3\3\3\3\3\3\3\3\3"+
-		"\3\3\3\5\3)\n\3\3\4\3\4\3\4\3\4\7\4/\n\4\f\4\16\4\62\13\4\3\4\3\4\3\5"+
-		"\3\5\5\58\n\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n"+
-		"\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\f\2\2\r\2\4\6\b\n\f\16\20\22\24\26\2"+
-		"\2\2L\2\30\3\2\2\2\4(\3\2\2\2\6*\3\2\2\2\b\67\3\2\2\2\n9\3\2\2\2\f<\3"+
-		"\2\2\2\16?\3\2\2\2\20B\3\2\2\2\22E\3\2\2\2\24H\3\2\2\2\26K\3\2\2\2\30"+
-		"\36\7\3\2\2\31\32\5\4\3\2\32\33\7\4\2\2\33\35\3\2\2\2\34\31\3\2\2\2\35"+
-		" \3\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37\3\3\2\2\2 \36\3\2\2\2!)\5\n\6"+
-		"\2\")\5\f\7\2#)\5\20\t\2$)\5\22\n\2%)\5\24\13\2&)\5\16\b\2\')\5\26\f\2"+
-		"(!\3\2\2\2(\"\3\2\2\2(#\3\2\2\2($\3\2\2\2(%\3\2\2\2(&\3\2\2\2(\'\3\2\2"+
-		"\2)\5\3\2\2\2*+\7\5\2\2+\60\5\b\5\2,-\7\6\2\2-/\5\b\5\2.,\3\2\2\2/\62"+
-		"\3\2\2\2\60.\3\2\2\2\60\61\3\2\2\2\61\63\3\2\2\2\62\60\3\2\2\2\63\64\7"+
-		"\7\2\2\64\7\3\2\2\2\658\7\16\2\2\668\5\4\3\2\67\65\3\2\2\2\67\66\3\2\2"+
-		"\28\t\3\2\2\29:\7\b\2\2:;\5\6\4\2;\13\3\2\2\2<=\7\n\2\2=>\5\6\4\2>\r\3"+
-		"\2\2\2?@\7\t\2\2@A\5\6\4\2A\17\3\2\2\2BC\7\13\2\2CD\5\6\4\2D\21\3\2\2"+
-		"\2EF\7\f\2\2FG\5\6\4\2G\23\3\2\2\2HI\7\r\2\2IJ\5\6\4\2J\25\3\2\2\2KL\7"+
-		"\16\2\2LM\5\6\4\2M\27\3\2\2\2\6\36(\60\67";
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\17I\4\2\t\2\4\3\t"+
+		"\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\3"+
+		"\2\3\2\3\2\3\2\7\2\33\n\2\f\2\16\2\36\13\2\3\3\3\3\3\3\3\3\3\3\3\3\5\3"+
+		"&\n\3\3\4\3\4\3\4\3\4\7\4,\n\4\f\4\16\4/\13\4\3\4\3\4\3\5\3\5\5\5\65\n"+
+		"\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3"+
+		"\13\3\13\3\13\2\2\f\2\4\6\b\n\f\16\20\22\24\2\2\2F\2\26\3\2\2\2\4%\3\2"+
+		"\2\2\6\'\3\2\2\2\b\64\3\2\2\2\n\66\3\2\2\2\f9\3\2\2\2\16<\3\2\2\2\20?"+
+		"\3\2\2\2\22B\3\2\2\2\24E\3\2\2\2\26\34\7\3\2\2\27\30\5\4\3\2\30\31\7\4"+
+		"\2\2\31\33\3\2\2\2\32\27\3\2\2\2\33\36\3\2\2\2\34\32\3\2\2\2\34\35\3\2"+
+		"\2\2\35\3\3\2\2\2\36\34\3\2\2\2\37&\5\n\6\2 &\5\f\7\2!&\5\16\b\2\"&\5"+
+		"\20\t\2#&\5\22\n\2$&\5\24\13\2%\37\3\2\2\2% \3\2\2\2%!\3\2\2\2%\"\3\2"+
+		"\2\2%#\3\2\2\2%$\3\2\2\2&\5\3\2\2\2\'(\7\5\2\2(-\5\b\5\2)*\7\6\2\2*,\5"+
+		"\b\5\2+)\3\2\2\2,/\3\2\2\2-+\3\2\2\2-.\3\2\2\2.\60\3\2\2\2/-\3\2\2\2\60"+
+		"\61\7\7\2\2\61\7\3\2\2\2\62\65\7\r\2\2\63\65\5\4\3\2\64\62\3\2\2\2\64"+
+		"\63\3\2\2\2\65\t\3\2\2\2\66\67\7\b\2\2\678\5\6\4\28\13\3\2\2\29:\7\t\2"+
+		"\2:;\5\6\4\2;\r\3\2\2\2<=\7\n\2\2=>\5\6\4\2>\17\3\2\2\2?@\7\13\2\2@A\5"+
+		"\6\4\2A\21\3\2\2\2BC\7\f\2\2CD\5\6\4\2D\23\3\2\2\2EF\7\r\2\2FG\5\6\4\2"+
+		"G\25\3\2\2\2\6\34%-\64";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {

src/de/dhbwstuttgart/sat/asp/writer/ASPFactory.java

@@ -1,22 +1,17 @@
 package de.dhbwstuttgart.sat.asp.writer;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.sat.asp.ASPStringConverter;
 import de.dhbwstuttgart.sat.asp.model.ASPRule;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
-import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 
-import javax.management.Notification;
 import java.util.*;
 
 public class ASPFactory implements TypeVisitor<String>{
@@ -24,112 +19,29 @@ public class ASPFactory implements TypeVisitor<String>{
     public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
         ASPFactory factory = new ASPFactory();
         factory.convertFC(fcClasses);
-        //List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
-        for(Pair p : constraints.getUndConstraints()){
-            factory.convertPair(p);
-        }
-        for(Set<Constraint<Pair>> oder : constraints.getOderConstraints()){
-            factory.convertOderConstraint(oder);
+        List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
+        for(Constraint<Pair> constraint : constraints1){
+            for(Pair p : constraint){
+                factory.convertPair(p);
+            }
         }
 
         return factory.writer.getASPFile();
     }
 
-    /**
-     * Wandelt eine Reihe von Constraints zu einem Und-Constraint - also einer Liste - um.
-     * Dieser kann dann in Oder-Constraints verwendet werden.
-     * @param undCons - Eine Liste von Constraints. Bsp: equals(..), smallerDot(..)
-     * @return - list(equals, list(smallerDot(..., null)
-     */
-    protected ASPStatement convertListToUndConstraint(List<ASPStatement> undCons) {
-        if(undCons.size() == 0)throw new NullPointerException();
-        if(undCons.size() == 1){
-            return undCons.get(0);
-        }
-        ASPStatement list = new ASPStatement(ASPRule.ASP_LIST_ENDPOINTER.toString());
-        for(ASPStatement con : undCons){
-            list = makeStatement(ASPRule.ASP_LIST_NAME.toString(), con.getASP(), list.getASP());
-        }
-        return list;
-    }
+    ASPWriter writer = new ASPWriter();
+    boolean isFCType = false;
 
-    protected ASPStatement convertListToUndConstraint(Constraint<Pair> undCons) {
-        List<ASPStatement> convert = new ArrayList<>();
-        for(Pair p : undCons){
-            convert.add(generatePairStmt(p));
-        }
-        return convertListToUndConstraint(convert);
-    }
-
-    protected void convertOderConstraint(Set<Constraint<Pair>> oder) {
-        if(oder.size() < 2){//Oder-Setgröße darf nicht null sein. Sonst gibt es sowieso kein Ergebnis:
-            for(Pair p : oder.iterator().next()){
-                this.convertPair(p); //Einfach als und Constraints behandeln, wenn es nur einen Oder-Zweig gibt
-            }
-            return;
-        }
-        List<ASPStatement> ret = new ArrayList<>();
-        Iterator<Constraint<Pair>> it = oder.iterator();
-        String pointer1 = ASPStringConverter.toConstant(NameGenerator.makeNewName());
-        ASPStatement stmt = makeStatement(ASPRule.ASP_CONSTRAINT.toString(), pointer1,
-                convertListToUndConstraint(it.next()).getASP());
-        ret.add(stmt);
-        while(it.hasNext()){
-            String pointer2 = ASPStringConverter.toConstant(NameGenerator.makeNewName());
-            Constraint<Pair> cons = it.next();
-            stmt = makeStatement(ASPRule.ASP_CONSTRAINT.toString(), pointer2,
-                    convertListToUndConstraint(cons).getASP());
-            ret.add(stmt);
-            ASPStatement oderStmt = makeStatement(ASPRule.ASP_ODER.toString(), pointer1, pointer2);
-            if(it.hasNext()){
-                String oderPointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
-                stmt = makeStatement(ASPRule.ASP_CONSTRAINT.toString(), oderPointer, oderStmt.getASP());
-                ret.add(stmt);
-                pointer1 = oderPointer;
-            }else{
-                ret.add(oderStmt);
-            }
-        }
-        //Alle erstellten Constraints schreiben:
-        writer.addAll(ret);
-    }
-
-    protected ASPWriter writer = new ASPWriter();
-
-    protected void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
-        Collection<Pair> fc = FCGenerator.toFC(classes);
-        HashMap<String, Pair> set = new HashMap<>();
+    private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
+        Set<Pair> fc = FCGenerator.toFC(classes);
+        isFCType = true;
         for(Pair fcp : fc){
-            StringBuilder output = new StringBuilder();
-            OutputGenerator generator = new OutputGenerator(output);
-            fcp.TA1.accept(generator);
-            output.append("<");
-            fcp.TA2.accept(generator);
-            set.put(output.toString(), fcp);
-        }
-        for(Pair fcp : set.values()){
             convertPair(fcp);
         }
-        for(ClassOrInterface cl : classes){
-            RefType t = fromClassOrInterface(cl);
-            convertPair(new Pair(t,t,PairOperator.SMALLER));
-        }
+        isFCType = false;
     }
 
-    private RefType fromClassOrInterface(ClassOrInterface cl){
-        List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
-        for(GenericTypeVar gtv : cl.getGenerics()){
-            params.add(TypePlaceholder.fresh(new NullToken()));
-        }
-        return new RefType(cl.getClassName(), params, new NullToken());
-    }
-
-    protected void convertPair(Pair p){
-        ASPStatement pairStmt = generatePairStmt(p);
-        writer.add(pairStmt);
-    }
-
-    protected ASPStatement generatePairStmt(Pair p) {
+    private void convertPair(Pair p){
         String ls = p.TA1.acceptTV(this);
         String rs = p.TA2.acceptTV(this);
         ASPStatement pairStmt = null;
@@ -140,32 +52,40 @@ public class ASPFactory implements TypeVisitor<String>{
         }else if(p.GetOperator().equals(PairOperator.SMALLER)){
             pairStmt = makeStatement(ASPRule.ASP_PAIR_SMALLER_NAME.toString(), ls, rs);
         }else throw new NotImplementedException();
-        return pairStmt;
+        writer.add(pairStmt);
     }
 
-    protected ASPStatement makeStatement(String rule, String... params){
+    private ASPStatement makeStatement(String rule, String... params){
         String stmt = rule + "(";
-        Iterator<String> it = Arrays.asList(params).iterator();
-        while(it.hasNext()){
-            String param = it.next();
-            stmt += param;
-            if(it.hasNext())stmt+=",";
+        for(String param : params){
+            stmt += param + ",";
         }
+        stmt = stmt.substring(0,stmt.length()-1);
         stmt += ")";
         return new ASPStatement(stmt);
     }
 
-    protected void convertParameterlist(String pointer, List<String> pointers){
+    private String convertParameterlist(List<String> pointers){
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
         Iterator<String> it = pointers.iterator();
-        Integer i = 1;
-        String ruleName = ASPRule.ASP_PARAMLIST_NAME.toString();
+        String p = pointer;
+        if(!it.hasNext()){
+            return ASPRule.ASP_PARAMLIST_END_POINTER.toString();
+        }
         while (it.hasNext()){
             ASPStatement stmt;
             String type = it.next();
-            stmt = makeStatement(ruleName, pointer, type, i.toString());
+            String nextP = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+            if(it.hasNext()){
+                stmt = makeStatement(ASPRule.ASP_PARAMLIST_NAME.toString(), p, type, nextP);
+            }else{
+                stmt = makeStatement(ASPRule.ASP_PARAMLIST_NAME.toString(), p, type,
+                        ASPRule.ASP_PARAMLIST_END_POINTER.toString());
+            }
+            p = nextP;
             writer.add(stmt);
-            i++;
         }
+        return pointer;
     }
 
     @Override
@@ -176,9 +96,8 @@ public class ASPFactory implements TypeVisitor<String>{
             params.add(param.acceptTV(this));
         }
         String typeName = ASPStringConverter.toConstant(refType.getName());
-        String ruleName = ASPRule.ASP_TYPE.toString();
-        convertParameterlist(pointer, params);
-        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, Integer.toString(params.size()));
+        String ruleName = isFCType?ASPRule.ASP_FCTYPE.toString():ASPRule.ASP_TYPE.toString();
+        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, convertParameterlist(params));
         writer.add(stmt);
         return pointer;
     }
@@ -203,12 +122,6 @@ public class ASPFactory implements TypeVisitor<String>{
 
     @Override
     public String visit(GenericRefType genericRefType) {
-        //Kann eigentlich wie ein normaler RefType behandelt werden
-        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
-        String typeName = ASPStringConverter.toConstant(genericRefType.getParsedName());
-        String ruleName = ASPRule.ASP_TYPE.toString();
-        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, ASPRule.ASP_LIST_ENDPOINTER.toString());
-        writer.add(stmt);
-        return pointer;
+        throw new NotImplementedException();
     }
 }

src/de/dhbwstuttgart/sat/asp/writer/ASPGencayFactory.java

@@ -15,7 +15,7 @@ import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import java.util.*;
 
 
-public class ASPFactoryAlternative implements TypeVisitor<String> {
+public class ASPGencayFactory implements TypeVisitor<String> {
     /* TODO:
      * Alle TPHs müssen als var(tph) definiert sein
      * Wenn es eine Variable ist, dann direkt in die type-Regel schreiben: type(p, type, tph)
@@ -56,7 +56,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
     }
 
     public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
-        ASPFactoryAlternative factory = new ASPFactoryAlternative();
+        ASPGencayFactory factory = new ASPGencayFactory();
         factory.convertFC(fcClasses);
         List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
         for(Constraint<Pair> constraint : constraints1){
@@ -70,7 +70,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
     }
 
     private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
-        Collection<Pair> fc = FCGenerator.toFC(classes);
+        Set<Pair> fc = FCGenerator.toFC(classes);
         isFCType = true;
         for(Pair fcp : fc){
             generateTheta((RefType) fcp.TA1);
@@ -130,11 +130,6 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
                 stmt = makeStatement(paramname, p, type,
                         ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString());
             }
-            if(!it.hasNext()){ //Falls es der letzte Pointer ist
-                String endRule = isFCType?ASPGencayRule.ASP_PARAMLIST_END_RULE_FC.toString():ASPGencayRule.ASP_PARAMLIST_END_RULE_EQ.toString();
-                writer.add(makeStatement(endRule, p,
-                        ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString()));
-            }
             p = nextP;
             writer.add(stmt);
         }
@@ -148,11 +143,11 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
         String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
         currentFCTypePointer = pointer;
         String paramPointer = ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString();
-        if(refType.getParaList().size() == 1
-                && (refType.getParaList().get(0) instanceof TypePlaceholder
-                    || refType.getParaList().get(0) instanceof WildcardType)){
-            RefTypeOrTPHOrWildcardOrGeneric typePlaceholder = refType.getParaList().get(0);
-            paramPointer = typePlaceholder.acceptTV(this);
+        if(refType.getParaList().size() == 1 ){
+            if(refType.getParaList().get(0) instanceof TypePlaceholder){
+                TypePlaceholder typePlaceholder = (TypePlaceholder) refType.getParaList().get(0);
+                paramPointer = typePlaceholder.acceptTV(this);
+            }
         }else{
             List<String> params = null;
             params = generateParameter(refType);
@@ -199,8 +194,6 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
                 ret.addAll(generateParameter((RefType) param));
             }else if(param instanceof TypePlaceholder){
                 ret.add(param.acceptTV(this));
-            }else if(param instanceof WildcardType){
-                ret.add(param.acceptTV(this));
             }else throw new NotImplementedException();
         }
         return ret;
@@ -208,10 +201,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
 
     @Override
     public String visit(SuperWildcardType superWildcardType) {
-        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
-        writer.add(makeStatement(ASPGencayRule.ASP_WILDCARD.toString(),
-                pointer, "super", superWildcardType.getInnerType().acceptTV(this)));
-        return pointer;
+        throw new NotImplementedException();
     }
 
     @Override
@@ -232,10 +222,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
 
     @Override
     public String visit(ExtendsWildcardType extendsWildcardType) {
-        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
-        writer.add(makeStatement(ASPGencayRule.ASP_WILDCARD.toString(),
-                pointer, "extends", extendsWildcardType.getInnerType().acceptTV(this)));
-        return pointer;
+        throw new NotImplementedException();
     }
 
     @Override

src/de/dhbwstuttgart/sat/asp/writer/ASPWriter.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.sat.asp.writer;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;

src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

@@ -66,10 +66,10 @@ public abstract class AbstractASTWalker implements ASTVisitor{
 
     @Override
     public void visit(ParameterList formalParameters) {
-        Iterator<FormalParameter> it = formalParameters.getFormalparalist().iterator();
-        if(it.hasNext()){
-            while(it.hasNext()){
-                it.next().accept(this);
+        Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
+        if(genericIterator.hasNext()){
+            while(genericIterator.hasNext()){
+                genericIterator.next().accept(this);
             }
         }
     }

src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java

@@ -12,7 +12,6 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 
-import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -34,7 +33,6 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters,
                           RefType superClass, Boolean isInterface, List<RefType> implementedInterfaces, Token offset){
     super(offset);
-    if(isInterface && !Modifier.isInterface(modifiers))modifiers += Modifier.INTERFACE;
       this.modifiers = modifiers;
       this.name = name;
       this.fields = fielddecl;
@@ -108,4 +106,8 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   public Collection<RefType> getSuperInterfaces() {
     return implementedInterfaces;
   }
+  
+  public String toString() {
+	  return this.name.toString() + this.genericClassParameters.toString();
+  }
 }

src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java

@@ -31,4 +31,8 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
 	public void accept(ASTVisitor visitor) {
 		visitor.visit(this);
 	}
+	
+	public String toString() {
+		return this.gtvs.toString();
+	}
 }

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

@@ -17,7 +17,6 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
-import de.dhbwstuttgart.syntaxtree.type.WildcardType;
 import org.antlr.v4.runtime.Token;
 
 /**
@@ -38,7 +37,7 @@ public class ASTFactory {
 			methoden.add(createMethod(method, jreClass));
 		}
 		List<Field> felder = new ArrayList<>();
-		for(java.lang.reflect.Field field : jreClass.getDeclaredFields()){
+		for(java.lang.reflect.Field field : jreClass.getFields()){
 			felder.add(createField(field, name));
 		}
 		int modifier = jreClass.getModifiers();
@@ -51,15 +50,15 @@ public class ASTFactory {
 		java.lang.Class superjreClass = jreClass.getSuperclass();
 		RefType superClass;
 		if(parameterSuperClass != null){
-			superClass = (RefType) createType(parameterSuperClass);
+			superClass = (RefType) convertType(parameterSuperClass);
 		}else if(superjreClass != null){
-			superClass = (RefType) createType(superjreClass);
+			superClass = (RefType) convertType(superjreClass);
 		}else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!)
-			superClass = (RefType) createType(java.lang.Object.class);
+			superClass = (RefType) createType(java.lang.Object.class, name, "");
 		}
 		List<RefType> implementedInterfaces = new ArrayList<>();
 		for(Type jreInterface : jreClass.getGenericInterfaces()){
-			implementedInterfaces.add((RefType) createType(jreInterface));
+			implementedInterfaces.add((RefType) createType(jreInterface, name, ""));
 		}
         GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null);
 
@@ -68,8 +67,29 @@ public class ASTFactory {
 		return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset);
 	}
 
+	private static RefTypeOrTPHOrWildcardOrGeneric convertType(Type type){
+		if(type instanceof ParameterizedType){
+			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+			for(Type paramType : ((ParameterizedType)type).getActualTypeArguments()){
+				params.add(convertType(paramType));
+			}
+			JavaClassName name = new JavaClassName(((ParameterizedType) type).getRawType().getTypeName());
+			return new RefType(name, params, new NullToken());
+		}else if(type instanceof TypeVariable){
+			return new GenericRefType(((TypeVariable) type).getName(), new NullToken());
+		}else if(type instanceof Class){
+			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+			Class paramClass = (Class) type;
+			for(TypeVariable tv : paramClass.getTypeParameters()){
+				params.add(new GenericRefType(tv.getName(), new NullToken()));
+			}
+			JavaClassName name = new JavaClassName(paramClass.getName());
+			return new RefType(name, params, new NullToken());
+		}else throw new NotImplementedException();
+	}
+
 	private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
-		return new Field(field.getName(), createType(field.getType()), field.getModifiers(), new NullToken());
+		return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
 	}
 
 	//private static RefType createType(Class classType) {
@@ -78,13 +98,13 @@ public class ASTFactory {
 
 	private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
 		String name = constructor.getName();
-		RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass);
+		RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name);
 		Parameter[] jreParams = constructor.getParameters();
 		Type[] jreGenericParams = constructor.getGenericParameterTypes();
 		List<FormalParameter> params = new ArrayList<>();
 		int i = 0;
 		for(Type jreParam : jreGenericParams){
-			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam);
+			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name);
 			params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken()));
 			i++;
 		}
@@ -110,13 +130,13 @@ public class ASTFactory {
 		}else{
 			jreRetType = jreMethod.getReturnType();
 		}
-			returnType = createType(jreRetType);
+			returnType = createType(jreRetType,new JavaClassName(inClass.getName()), name);
 		Parameter[] jreParams = jreMethod.getParameters();
 		Type[] jreGenericParams = jreMethod.getGenericParameterTypes();
 		List<FormalParameter> params = new ArrayList<>();
 		int i = 0;
 		for(Type jreParam : jreGenericParams){
-			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam);
+			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name);
 			params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken()));
 			i++;
 		}
@@ -137,7 +157,18 @@ public class ASTFactory {
 		return new GenericDeclarationList(gtvs,new NullToken());
 	}
 
-	private static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type){
+    /*
+	public RefType createType(java.lang.Class jreClass){
+		List<RefTypeOrTPH> params = new ArrayList<>();
+		for(TypeVariable jreTV : jreClass.getTypeParameters()){
+			RefType gtv = createType(jreTV);
+			params.add(gtv);
+		}
+		return new RefType(names.getName(jreClass.getName()), params, new NullToken());
+	}
+	*/
+
+	private static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){
 		if(type.getTypeName().equals("void")){
 			return new Void(new NullToken());
 		}else if(type.getTypeName().equals("int")){
@@ -162,7 +193,7 @@ public class ASTFactory {
 			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
 			if(type instanceof ParameterizedType){
 				for(Type t : ((ParameterizedType)type).getActualTypeArguments()){
-					params.add(createType(t));
+					params.add(createType(t, parentClass, parentMethod));
 				}
 			}
 			String name = type.getTypeName();
@@ -170,19 +201,8 @@ public class ASTFactory {
 				//Diese entfernen:
 				name = name.split("<")[0];
 			}
-			if(type instanceof java.lang.reflect.WildcardType){
-				java.lang.reflect.WildcardType wildcardType = (java.lang.reflect.WildcardType) type;
-				if(wildcardType.getLowerBounds().length > 0){
-					return new SuperWildcardType(createType(wildcardType.getLowerBounds()[0]), new NullToken());
-				}else if(wildcardType.getUpperBounds().length > 0){
-					return new ExtendsWildcardType(createType(wildcardType.getUpperBounds()[0]), new NullToken());
-				}else{//Es handelt sich um den '?'-Typ:
-					return new ExtendsWildcardType(createObjectType(), new NullToken());
-				}
-			}else{
-				RefType ret = new RefType(new JavaClassName(name), params, new NullToken());
-				return ret;
-			}
+			RefType ret = new RefType(new JavaClassName(name), params, new NullToken());
+			return ret;
 		}
 	}
 
@@ -192,7 +212,7 @@ public class ASTFactory {
 		java.lang.reflect.Type[] bounds = jreTypeVar.getBounds();
 		if(bounds.length > 0){
 			for(java.lang.reflect.Type bound : bounds){
-				genericBounds.add((RefType) createType(bound));
+				genericBounds.add((RefType) createType(bound, parentClass, parentMethod));
 			}
 		}
 		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken());

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

@@ -26,6 +26,8 @@ import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 
 public class UnifyTypeFactory {
+	
+	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
 
     public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses) throws ClassNotFoundException {
         /*
@@ -49,6 +51,10 @@ public class UnifyTypeFactory {
         return new UnifyPair(tl, tr, PairOperator.SMALLERDOT);
     }
 
+    public static UnifyPair generateSmallNotEqualDotPair(UnifyType tl, UnifyType tr){
+        return new UnifyPair(tl, tr, PairOperator.SMALLERNEQDOT);
+    }
+    
     public static UnifyPair generateEqualDotPair(UnifyType tl, UnifyType tr){
         return new UnifyPair(tl, tr, PairOperator.EQUALSDOT);
     }
@@ -113,7 +119,15 @@ public class UnifyTypeFactory {
     }
 
     public static UnifyType convert(TypePlaceholder tph){
-        return new PlaceholderType(tph.getName());
+    	PlaceholderType ntph = new PlaceholderType(tph.getName());
+    	int in = PLACEHOLDERS.indexOf(ntph);
+		if (in == -1) {
+			PLACEHOLDERS.add(ntph);
+			return ntph;
+		}
+		else {
+			return PLACEHOLDERS.get(in);
+		}
     }
 
     public static UnifyType convert(GenericRefType t){
@@ -142,6 +156,10 @@ public class UnifyTypeFactory {
             UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
+        }else if(p.GetOperator().equals(PairOperator.SMALLERNEQDOT)) {
+            UnifyPair ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(p.TA1)
+                    , UnifyTypeFactory.convert(p.TA2));
+            return ret;
         }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
             UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
@@ -190,7 +208,7 @@ public class UnifyTypeFactory {
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
-        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()+"$$"), convert(t.getTypeParams(), tphs), new NullToken());
         return ret;
     }
 

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

@@ -34,10 +34,6 @@ public class ExtendsWildcardType extends WildcardType{
 		return false;
 	}
 
-	@Override
-	public String toString() {
-		return "? extends "+innerType.toString();
-	}
 
 	@Override
 	public void accept(ASTVisitor visitor) {

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

@@ -24,7 +24,7 @@ public class FunN extends RefType {
 	 * @return
 	 */
 	public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
-		super(new JavaClassName("Fun"+params.size()), params, new NullToken());
+		super(new JavaClassName("Fun"+(params.size())), params, new NullToken());
 	}
 
 	/**

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

@@ -35,11 +35,6 @@ public class SuperWildcardType extends WildcardType{
 		return this.innerType;
 	}
 
-	@Override
-	public String toString() {
-		return "? super "+innerType.toString();
-	}
-
 	@Override
 	public boolean isExtends() {
 		return false;

src/de/dhbwstuttgart/syntaxtree/visual/TypePrinter.java

@@ -1,30 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.visual;
-
-import de.dhbwstuttgart.syntaxtree.type.*;
-
-public class TypePrinter implements TypeVisitor<String> {
-    @Override
-    public String visit(RefType refType) {
-        return refType.toString();
-    }
-
-    @Override
-    public String visit(SuperWildcardType superWildcardType) {
-        return "? super " + superWildcardType.getInnerType().acceptTV(this);
-    }
-
-    @Override
-    public String visit(TypePlaceholder typePlaceholder) {
-        return "TPH " + typePlaceholder.getName();
-    }
-
-    @Override
-    public String visit(ExtendsWildcardType extendsWildcardType) {
-        return "? extends " + extendsWildcardType.getInnerType().acceptTV(this);
-    }
-
-    @Override
-    public String visit(GenericRefType genericRefType) {
-        return genericRefType.getParsedName();
-    }
-}

src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java

@@ -59,11 +59,13 @@ class TypeInsertPlacerClass extends AbstractASTWalker{
     }
 
     @Override
-    public void visit(FormalParameter param) {
+    public void visit(ParameterList params) {
+        for(FormalParameter param : params){
             if(param.getType() instanceof TypePlaceholder)
                 inserts.add(TypeInsertFactory.createInsertPoints(
                         param.getType(), param.getType().getOffset(), cl, method, results));
-        super.visit(param);
+        }
+        super.visit(params);
     }
 
     @Override

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

@@ -8,32 +8,36 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class FunNClass extends ClassOrInterface {
-    public FunNClass(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
-        super(0, new JavaClassName("Fun"+(funNParams.size()-1)), new ArrayList<>(),
+    public FunNClass(List<GenericRefType> funNParams) {
+        super(0, new JavaClassName("Fun"+(funNParams.size())), new ArrayList<>(),
                 createMethods(funNParams), new ArrayList<>(), createGenerics(funNParams),
                 ASTFactory.createObjectType(), true, new ArrayList<>(), new NullToken());
 
 
         }
 
-    private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static GenericDeclarationList createGenerics(List<GenericRefType> funNParams) {
+    	//PL 2018-06-22: so geaendert, dass generierte Generics den Namen der funParams entsprechen.
         List<GenericTypeVar> generics = new ArrayList<>();
-        for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
-            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
+        for(GenericRefType param : funNParams){
+            generics.add(new GenericTypeVar(param.getParsedName(),//NameGenerator.makeNewName(),
                     new ArrayList<>(), new NullToken(), new NullToken()));
         }
         return new GenericDeclarationList(generics, new NullToken());
     }
 
-    private static List<Method> createMethods(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static List<Method> createMethods(List<GenericRefType> funNParams) {
         return null;
     }
 }

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

@@ -16,10 +16,10 @@ import java.util.List;
 public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
-    List<RefTypeOrTPHOrWildcardOrGeneric> params;
+    List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
@@ -38,13 +38,18 @@ public class MethodAssumption extends Assumption{
     }
 
     public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) {
-        return resolver.resolve(retType);
+        if(retType instanceof GenericRefType) {
+        	return resolver.resolve(retType);
+        }
+        return retType;
     }
 
     public List<RefTypeOrTPHOrWildcardOrGeneric> getArgTypes(GenericsResolver resolver) {
         List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
         for(RefTypeOrTPHOrWildcardOrGeneric param : params){
-            param = resolver.resolve(param);
+            if(param instanceof GenericRefType){ //Generics in den Assumptions müssen umgewandelt werden.
+                param = resolver.resolve((GenericRefType) param);
+            }
             ret.add(param);
         }
         return ret;

src/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java

@@ -52,12 +52,4 @@ public class ConstraintSet<A> {
         ret.oderConstraints = newOder;
         return ret;
     }
-
-    public Constraint<A> getUndConstraints() {
-        return undConstraints;
-    }
-
-    public List<Set<Constraint<A>>> getOderConstraints() {
-        return oderConstraints;
-    }
 }

src/de/dhbwstuttgart/typeinference/constraints/Pair.java

@@ -11,6 +11,7 @@ public class Pair implements Serializable
     public final RefTypeOrTPHOrWildcardOrGeneric TA2;
 
     private PairOperator eOperator = PairOperator.SMALLER;
+    
 
     public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 )
     {
@@ -41,14 +42,16 @@ public class Pair implements Serializable
         if( TA2 != null )
            strElement2 = TA2.toString();
         
+       /* PL ausskommentiert 2018-05-24
         if(OperatorEqual())
         	Operator = "=";
         if(OperatorSmaller())
         	Operator = "<.";
         if(OperatorSmallerExtends())
         	Operator = "<?";
+        	*/
         
-        return "\n(" + strElement1 + " " + Operator + " " + strElement2 + ")";
+        return "\n(" + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
         
        /*- Equals: " + bEqual*/
     }

src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java

@@ -60,7 +60,8 @@ public class TYPE {
 
             return new TypeInferenceInformation(classes);
         }
-    */
+
+            */
     private ConstraintSet getConstraintsMethod(Method m, TypeInferenceInformation info, ClassOrInterface currentClass) {
         if(m.block == null)return new ConstraintSet(); //Abstrakte Methoden generieren keine Constraints
         TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);

src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java

@@ -6,6 +6,7 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
@@ -57,8 +58,8 @@ public class TYPEStmt implements StatementVisitor{
     public void visit(LambdaExpression lambdaExpression) {
         TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
         List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
-        //lambdaParams.add(tphRetType);
-        lambdaParams.add(0,tphRetType);
+        lambdaParams.add(tphRetType);
+        //lambdaParams.add(0,tphRetType);
         constraintsSet.addUndConstraint(
                 new Pair(lambdaExpression.getType(),
                         new FunN(lambdaParams),PairOperator.EQUALSDOT));
@@ -185,6 +186,12 @@ public class TYPEStmt implements StatementVisitor{
     }
 
     private final RefType number = new RefType(ASTFactory.createClass(Number.class).getClassName(), new NullToken());
+    private final RefType longg = new RefType(ASTFactory.createClass(Long.class).getClassName(), new NullToken());
+    private final RefType integer = new RefType(ASTFactory.createClass(Integer.class).getClassName(), new NullToken());
+    private final RefType shortt = new RefType(ASTFactory.createClass(Short.class).getClassName(), new NullToken());
+    private final RefType bytee = new RefType(ASTFactory.createClass(Byte.class).getClassName(), new NullToken());
+    private final RefType floatt = new RefType(ASTFactory.createClass(Float.class).getClassName(), new NullToken());
+    private final RefType doublee = new RefType(ASTFactory.createClass(Double.class).getClassName(), new NullToken());
     private final RefType string = new RefType(ASTFactory.createClass(String.class).getClassName(), new NullToken());
     private final RefType bool =  new RefType(ASTFactory.createClass(Boolean.class).getClassName(), new NullToken());
     @Override
@@ -205,18 +212,47 @@ public class TYPEStmt implements StatementVisitor{
 
     @Override
     public void visit(BinaryExpr binary) {
-
+    		binary.lexpr.accept(this);
+    		binary.rexpr.accept(this);
         if(binary.operation.equals(BinaryExpr.Operator.DIV) ||
                 binary.operation.equals(BinaryExpr.Operator.MUL)||
                 binary.operation.equals(BinaryExpr.Operator.MOD)||
                 binary.operation.equals(BinaryExpr.Operator.ADD)){
-            Set<Constraint> numericAdditionOrStringConcatenation = new HashSet<>();
-            Constraint<Pair> numeric = new Constraint<>();
+            Set<Constraint<Pair>> numericAdditionOrStringConcatenation = new HashSet<>();
+            
             //Zuerst der Fall für Numerische AusdrücPairOpnumericeratorke, das sind Mul, Mod und Div immer:
             //see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
-            numeric.add(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+            Constraint<Pair> numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            numericAdditionOrStringConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            numericAdditionOrStringConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            numericAdditionOrStringConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), longg, PairOperator.SMALLERDOT));
+            numericAdditionOrStringConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), floatt, PairOperator.SMALLERDOT));
+            numericAdditionOrStringConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), doublee, PairOperator.SMALLERDOT));
+            numericAdditionOrStringConcatenation.add(numeric);
             /*
             In Java passiert bei den binären Operatoren eine sogenannte Type Promotion:
             https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2
@@ -237,10 +273,54 @@ public class TYPEStmt implements StatementVisitor{
                 binary.operation.equals(BinaryExpr.Operator.BIGGEREQUAL) ||
                 binary.operation.equals(BinaryExpr.Operator.BIGGERTHAN) ||
                 binary.operation.equals(BinaryExpr.Operator.LESSTHAN)){
-            constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
-            constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+  /*      	//eingefuegt PL 2018-05-24
+        	Set<Constraint<Pair>> numericRelationConcatenation = new HashSet<>();
+        	Constraint<Pair> numeric = new Constraint<>();
+        	numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            
+            //***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
+            constraintsSet.addOderConstraint(numericRelationConcatenation);
+            //***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
+    */        
+            //Testeise eingefuegt PL 2018-05-24
+            constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERNEQDOT));
+            constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERNEQDOT));
             //Rückgabetyp ist Boolean
-            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
+            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.SMALLERDOT));
+        	
+            //auskommentiert PL 2018-05-24
+            //constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
+            //constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+            //Rückgabetyp ist Boolean
+            //constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
         }else{
                 throw new NotImplementedException();
         }
@@ -248,7 +328,16 @@ public class TYPEStmt implements StatementVisitor{
 
     @Override
     public void visit(Literal literal) {
-        //Nothing to do here. Literale erzeugen keine Constraints
+        //Nothing to do here. Literale erzeugen keine Constraints 
+    	//PL 2018-06-23 Sie haben einen Typ. Der muesste hier eingefuegt werden
+    	//wie hier fuer double gezeigt. Im Momment auskommentiert, weil zu wenige Literaltypen
+    	//funktionieren
+    	//if (literal.value instanceof Double) {
+    	//	constraintsSet.addUndConstraint(new Pair(literal.getType(), doublee, PairOperator.EQUALSDOT));
+    	//}
+    	//else {
+    	//	throw new NotImplementedException();
+    	//}
     }
 
     @Override
@@ -372,11 +461,14 @@ public class TYPEStmt implements StatementVisitor{
         List<MethodAssumption> ret = new ArrayList<>();
         //TODO: apply Methoden wieder anfügen. Diese könnten möglicherweise auch in den Assumptions auftauchen (überdenken)
         if(name.equals("apply")){
-            List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
+            List<GenericRefType> funNParams = new ArrayList<>();
             for(int i = 0; i< numArgs + 1 ; i++){
-                funNParams.add(TypePlaceholder.fresh(new NullToken()));
+                //funNParams.add(TypePlaceholder.fresh(new NullToken()));
+            	funNParams.add(new GenericRefType(NameGenerator.makeNewName(),
+                        new NullToken()));
             }
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size()),
+            funNParams.get(funNParams.size()-1);
+            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size()-1), funNParams.subList(0, funNParams.size()-1),
                     new TypeScope() {
                         @Override
                         public Iterable<? extends GenericTypeVar> getGenerics() {
@@ -419,7 +511,7 @@ public class TYPEStmt implements StatementVisitor{
          */
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         for(FormalParameter fp : parameterList.getFormalparalist()){
-            params.add(info.checkGTV(fp.getType()));
+            params.add(fp.getType()); //info.checkGTV(fp.getType())); //PL 2018-06-22 GTV sollen in Argumenten erhalten bleiben
         }
         return params;
     }

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

@@ -94,7 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				termsList = termsList.stream().map(mgu::apply).collect(Collectors.toCollection(ArrayList::new));
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
+				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}

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

@@ -24,13 +24,27 @@ import de.dhbwstuttgart.typeinference.unify.model.Unifier;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
+
+import java.io.FileWriter;
+import java.io.IOException;
 
 /**
  * Implementation of the type inference rules.
  * @author Florian Steurer
  *
  */
-public class RuleSet implements IRuleSet{	
+public class RuleSet implements IRuleSet{
+	
+	FileWriter logFile;
+	
+	RuleSet() {
+		super();
+	}
+	
+	RuleSet(FileWriter logFile) {
+		this.logFile = logFile;
+	}
 	
 	@Override
 	public Optional<UnifyPair> reduceUp(UnifyPair pair) {
@@ -47,7 +61,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 		
 		// Rule is applicable, unpack the SuperType 
-		return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -65,7 +79,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 
 		// Rule is applicable, unpack the ExtendsType
-		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -83,7 +97,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 		
 		// Rule is applicable, unpack both sides
-		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -117,7 +131,7 @@ public class RuleSet implements IRuleSet{
 		if(x instanceof ExtendsType)
 			xFromFc = new ExtendsType(xFromFc);
 		
-		UnifyType extYFromFc = fc.grArg(xFromFc).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
+		UnifyType extYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
 		
 		if(extYFromFc == null || extYFromFc.getTypeParams() != xFromFc.getTypeParams())
 			return Optional.empty();
@@ -133,7 +147,7 @@ public class RuleSet implements IRuleSet{
 		Set<UnifyPair> result = new HashSet<>();
 		
 		for(int rhsIdx = 0; rhsIdx < extYParams.size(); rhsIdx++)
-			result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
+			result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -169,7 +183,7 @@ public class RuleSet implements IRuleSet{
 		if(x instanceof SuperType)
 			xFromFc = new SuperType(xFromFc);
 		
-		UnifyType supYFromFc = fc.grArg(xFromFc).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
+		UnifyType supYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
 		
 		if(supYFromFc == null || supYFromFc.getTypeParams() != xFromFc.getTypeParams())
 			return Optional.empty();
@@ -184,7 +198,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 		
 		for(int rhsIdx = 0; rhsIdx < supYParams.size(); rhsIdx++)
-			result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC));
+			result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -215,7 +229,7 @@ public class RuleSet implements IRuleSet{
 		TypeParams rhsTypeParams = rhsType.getTypeParams();
 		
 		for(int i = 0; i < lhsTypeParams.size(); i++)
-			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -236,19 +250,53 @@ public class RuleSet implements IRuleSet{
 		ReferenceType lhsSType = (ReferenceType) c;
 		ReferenceType rhsSType = (ReferenceType) d;
 		
+		//try {
+		//	logFile.write("PAIR Rules: " + pair + "\n");
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
 		if(lhsSType.getTypeParams().empty() || lhsSType.getTypeParams().size() != rhsSType.getTypeParams().size())
 			return Optional.empty();
 		
 		UnifyType cFromFc = fc.getLeftHandedType(c.getName()).orElse(null);
+		//2018-02-23: liefert Vector<Vector<Integer>>: Das kann nicht sein.
+		
+		//NOCHMAL UEBERPRUEFEN
+		//PL 18-02-09 Eingfuegt Anfang
+		//C und D koennen auch gleich sein.
+		if (c.getName().equals(d.getName())) {
+			Set<UnifyPair> result = new HashSet<>();
+			TypeParams rhsTypeParams = d.getTypeParams();
+			TypeParams lhsTypeParams = c.getTypeParams();
+			for(int rhsIdx = 0; rhsIdx < c.getTypeParams().size(); rhsIdx++)
+				result.add(new UnifyPair(lhsTypeParams.get(rhsIdx), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+		
+			return Optional.of(result);
+		}
+		//PL 18-02-09 Eingfuegt ENDE
+		
+		//try {
+		//	logFile.write("cFromFc: " + cFromFc);
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
 		
 		if(cFromFc == null || !cFromFc.getTypeParams().arePlaceholders())
 			return Optional.empty();
 		
 		UnifyType dFromFc = fc.getAncestors(cFromFc).stream().filter(x -> x.getName().equals(d.getName())).findAny().orElse(null);
 		
+		//try {
+		//	logFile.write("cFromFc: " + cFromFc);
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
 		if(dFromFc == null || !dFromFc.getTypeParams().arePlaceholders() || dFromFc.getTypeParams().size() != cFromFc.getTypeParams().size())
 			return Optional.empty();
-		
+		//System.out.println("cFromFc: " + cFromFc);
+		//System.out.println("dFromFc: " + dFromFc);
 		int[] pi = pi(cFromFc.getTypeParams(), dFromFc.getTypeParams());
 		
 		if(pi.length == 0)
@@ -259,7 +307,7 @@ public class RuleSet implements IRuleSet{
 		Set<UnifyPair> result = new HashSet<>();
 		
 		for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
-			result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
+			result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -314,16 +362,31 @@ public class RuleSet implements IRuleSet{
 		TypeParams rhsTypeParams = rhsSType.getTypeParams();
 		TypeParams lhsTypeParams = lhsSType.getTypeParams();
 		for(int i = 0; i < rhsTypeParams.size(); i++)
-			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
 
 	@Override
 	public boolean erase1(UnifyPair pair, IFiniteClosure fc) {
-		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+		if((pair.getPairOp() != PairOperator.SMALLERDOT) && (pair.getPairOp() != PairOperator.SMALLERNEQDOT))
 			return false;
 		
+		if (pair.getPairOp() == PairOperator.SMALLERNEQDOT) {
+			UnifyType lhs = pair.getLhsType();
+			UnifyType rhs = pair.getRhsType();
+			if (lhs instanceof WildcardType) {
+				lhs = ((WildcardType)lhs).getWildcardedType();
+			}
+			if (rhs instanceof WildcardType) {
+				rhs = ((WildcardType)rhs).getWildcardedType();
+			}
+		
+			if	(lhs.equals(rhs)){
+				return false;
+			}
+		}
+		
 		UnifyType lhsType = pair.getLhsType();
 		if(!(lhsType instanceof ReferenceType) && !(lhsType instanceof PlaceholderType))
 			return false;
@@ -332,7 +395,7 @@ public class RuleSet implements IRuleSet{
 		if(!(rhsType instanceof ReferenceType) && !(rhsType instanceof PlaceholderType))
 			return false;
 		
-		return fc.greater(lhsType).contains(rhsType);
+		return fc.greater(lhsType, new HashSet<>()).contains(rhsType);
 	}
 
 	@Override
@@ -343,7 +406,7 @@ public class RuleSet implements IRuleSet{
 		UnifyType lhsType = pair.getLhsType();		
 		UnifyType rhsType = pair.getRhsType();
 		
-		return fc.grArg(lhsType).contains(rhsType);
+		return fc.grArg(lhsType, new HashSet<>()).contains(rhsType);
 	}
 
 	@Override
@@ -365,7 +428,7 @@ public class RuleSet implements IRuleSet{
 		if(!(pair.getRhsType() instanceof PlaceholderType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT));
+		return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -407,11 +470,19 @@ public class RuleSet implements IRuleSet{
 		TypeParams typeDParams = typeD.getTypeParams();
 		TypeParams typeDgenParams = typeDgen.getTypeParams();
 		
+		//System.out.println("Pair: " +pair);
+		//System.out.println("typeD: " +typeD);
+		//System.out.println("typeDParams: " +typeDParams);
+		//System.out.println("typeDgen: " +typeD);
+		//System.out.println("typeDgenParams: " +typeDgenParams);
 		Unifier unif = Unifier.identity();
-		for(int i = 0; i < typeDParams.size(); i++) 
+		for(int i = 0; i < typeDParams.size(); i++) { 
+			//System.out.println("ADAPT" +typeDgenParams);
+			if (typeDgenParams.get(i) instanceof PlaceholderType) 
 			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
-		
-		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT));
+			else System.out.println("ERROR");
+		}
+		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -441,7 +512,7 @@ public class RuleSet implements IRuleSet{
 		if(typeDgen == null)
 			return Optional.empty();
 		
-		Set<UnifyType> grArg = fc.grArg(typeDgen);
+		Set<UnifyType> grArg = fc.grArg(typeDgen, new HashSet<>());
 		
 		Optional<UnifyType> opt = grArg.stream().filter(x -> x.getName().equals(typeExtDs.getName())).findAny();
 
@@ -457,7 +528,7 @@ public class RuleSet implements IRuleSet{
 		for(int i = 1; i < typeDParams.size(); i++) 
 			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
 		
-		return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC));
+		return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -487,7 +558,7 @@ public class RuleSet implements IRuleSet{
 
 		// Use of smArg instead of grArg because
 		// a in grArg(b) => b in smArg(a)
-		Set<UnifyType> smArg = fc.smArg(typeSupDgen);
+		Set<UnifyType> smArg = fc.smArg(typeSupDgen, new HashSet<>());
 		opt = smArg.stream().filter(x -> x.getName().equals(typeDs.getName())).findAny();
 
 		if(!opt.isPresent())
@@ -509,7 +580,7 @@ public class RuleSet implements IRuleSet{
 		for(int i = 1; i < typeDParams.size(); i++) 
 			unif.add((PlaceholderType) typeSupDsgenParams.get(i), typeDParams.get(i));
 		
-		return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC));
+		return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	/**
@@ -581,8 +652,8 @@ public class RuleSet implements IRuleSet{
 					&& typeMap.get(lhsType) > 1  // The type occurs in more pairs in the set than just the recent pair.
 					&& !rhsType.getTypeParams().occurs(lhsType)) {
 				Unifier uni = new Unifier(lhsType,  rhsType);
-				result = result.stream().map(uni::apply).collect(Collectors.toCollection(ArrayList::new));
-				result1 = result1.stream().map(uni::apply).collect(Collectors.toCollection(LinkedList::new));
+				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
+				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
 				applied = true;
 			}
 			
@@ -602,7 +673,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof ExtendsType) || !(rhsType instanceof ExtendsType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT)); 
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair())); 
 	}
 
 	@Override
@@ -615,7 +686,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof ExtendsType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -628,7 +699,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof SuperType) || !(rhsType instanceof SuperType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -641,9 +712,11 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof SuperType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC));
+		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 	}
 
+	/* PL 2018-03-06 auskommentiert sind mutmaßlich falsch
+	 * vgl. JAVA_BSP/Wildcard6.java
 	@Override
 	public Optional<UnifyPair> reduceWildcardLowUp(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
@@ -670,6 +743,7 @@ public class RuleSet implements IRuleSet{
 		return Optional.of(new UnifyPair(((SuperType) lhsType).getSuperedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.EQUALSDOT));
 	}
 
+	
 	@Override
 	public Optional<UnifyPair> reduceWildcardLeft(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
@@ -686,7 +760,7 @@ public class RuleSet implements IRuleSet{
 		
 		return Optional.empty();
 	}
-
+	*/
 	@Override
 	public Optional<Set<UnifyPair>> reduceFunN(UnifyPair pair) {
 		if((pair.getPairOp() != PairOperator.SMALLERDOT)  
@@ -709,13 +783,19 @@ public class RuleSet implements IRuleSet{
 		
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		result.add(new UnifyPair(funNLhsType.getTypeParams().get(0), funNRhsType.getTypeParams().get(0), PairOperator.SMALLERDOT));
-		for(int i = 1; i < funNLhsType.getTypeParams().size(); i++)
-			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT));
-		
+		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
+			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+        								   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+        								   UnifyType r = x.getRhsType();
+        								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+								     } );
 		return Optional.of(result);
 	}
-
+	
+	
 	@Override
 	public Optional<Set<UnifyPair>> greaterFunN(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOT)
@@ -731,15 +811,29 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
+		Integer variance = ((PlaceholderType)rhsType).getVariance();
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		
 		UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
-		for(int i = 0; i < freshPlaceholders.length; i++)
+		for(int i = 0; i < freshPlaceholders.length-1; i++) {
 			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
+		}
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
+		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		
-		result.add(new UnifyPair(funNLhsType.getTypeParams().get(0), freshPlaceholders[0], PairOperator.SMALLERDOT));
-		for(int i = 1; i < funNLhsType.getTypeParams().size(); i++)
-			result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT));
-		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT));
+		for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
+			result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
 		
+		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+									   UnifyType r = x.getRhsType();
+									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+									 } );
 		return Optional.of(result);
 	}
 
@@ -758,15 +852,30 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
+		Integer variance = ((PlaceholderType)lhsType).getVariance();
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		
 		UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
-		for(int i = 0; i < freshPlaceholders.length; i++)
+		for(int i = 0; i < freshPlaceholders.length-1; i++) {
 			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
+		}
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
 		
-		result.add(new UnifyPair(freshPlaceholders[0], funNRhsType.getTypeParams().get(0), PairOperator.SMALLERDOT));
-		for(int i = 1; i < funNRhsType.getTypeParams().size(); i++)
-			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT));
-		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT));
+		result.add(new UnifyPair(freshPlaceholders[funNRhsType.getTypeParams().size()-1], funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		
+		for(int i = 0; i < funNRhsType.getTypeParams().size()-1; i++) {
+			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
+		
+		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+		   							   UnifyType r = x.getRhsType();
+		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+									 } );
 		return Optional.of(result);
 	}
 
@@ -780,7 +889,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof ReferenceType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT));
+		return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -799,11 +908,11 @@ public class RuleSet implements IRuleSet{
 		
 		Set<UnifyPair> result = new HashSet<>();
 		if(isGen)
-			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
 			UnifyType freshTph = PlaceholderType.freshPlaceholder();
-			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT));
-			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT));
+			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		}
 		
 		return Optional.of(result);
@@ -825,11 +934,13 @@ public class RuleSet implements IRuleSet{
 		
 		Set<UnifyPair> result = new HashSet<>();
 		if(isGen)
-			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
 			UnifyType freshTph = PlaceholderType.freshPlaceholder();
-			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT));
-			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT));
+			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+			Set<UnifyType> fBounded = pair.getfBounded();
+			fBounded.add(lhsType);
+			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair(), fBounded));
 		}
 		
 		return Optional.of(result);

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify;
 
+import java.io.FileWriter;
 import java.util.Set;
 import java.util.concurrent.ForkJoinPool;
 
@@ -7,16 +8,16 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
-	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true);
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true, logFile, log);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		return res;
 	}
 	
-	public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false);
+	public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false, logFile, log);
 		Set<Set<UnifyPair>> res = unifyTask.compute();
 		return res;
 	}

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

@@ -0,0 +1,54 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+
+public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
+	
+	public static int inverseVariance(int variance) { 
+		Integer ret = 0;
+		if (variance == 1) {
+		   ret = -1;
+		}
+		if (variance == -1) {
+			ret = 1;
+		}
+		return ret;
+	}
+
+
+	@Override
+	public PlaceholderType visit(PlaceholderType phty, Integer ht) {
+		if (ht != 0) {
+			if (phty.getVariance() == 0) {
+				phty.setVariance(ht);
+			}
+			//PL 2018-05-17 urspruengliche Variance nicht veraendern
+			//else if (phty.getVariance() != ht) {
+			//	phty.setVariance(0);
+			//}
+		}
+		return phty;
+	}
+	
+	public FunNType visit(FunNType funnty, Integer ht) {
+		List<UnifyType> param = new ArrayList<>(funnty.getTypeParams().get().length);
+		param.addAll(Arrays.asList(funnty.getTypeParams().get()));
+		UnifyType resultType = param.remove(param.size()-1);
+		Integer htInverse = inverseVariance(ht);
+		param = param.stream()
+				     .map(x -> x.accept(this, htInverse))
+				     .collect(Collectors.toCollection(ArrayList::new));
+		param.add(resultType.accept(this, ht));
+		return FunNType.getFunNType(new TypeParams(param));
+	}
+	
+	
+}