mapFC -> pi

Changes to be committed:
Aenderungen am Unify: Fehler behoben und Vereinfachung

	modified:   src/de/dhbwstuttgart/core/JavaTXCompiler.java
	new file:   src/de/dhbwstuttgart/typeinference/unify/Match.java
	modified:   src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
	new file:   src/de/dhbwstuttgart/typeinference/unify/interfaces/IMatch.java
	modified:   src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java
	modified:   src/de/dhbwstuttgart/typeinference/unify/model/Node.java
	modified:   src/de/dhbwstuttgart/typeinference/unify/model/TypeParams.java
	modified:   src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
	modified:   test/javFiles/Matrix.jav

asp/adaptRules.lp

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

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

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

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

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

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

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

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

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

asp/rule5.test

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pom.xml

@@ -42,12 +42,18 @@
     <artifactId>asm-all</artifactId>
     <version>[4.0.0,)</version>
 </dependency>
+<!--
+<dependency>
+    <groupId>org.bitbucket.mstrobel</groupId>
+    <artifactId>procyon-reflection</artifactId>
+    <version>[0.5.32,)</version>
+</dependency> -->
   </dependencies>
 
   <build>
     <directory>target</directory>
     <outputDirectory>target/classes</outputDirectory>
-    <finalName>${artifactId}-${version}</finalName>
+    <finalName>${project.artifactId}-${project.version}</finalName>
     <testOutputDirectory>target/test-classes</testOutputDirectory>
     <sourceDirectory>src/</sourceDirectory>
     <testSourceDirectory>test/</testSourceDirectory>
@@ -71,14 +77,30 @@
 	  	    </arguments>
 	    </configuration>
 	    </execution>
+	    <execution>
+            <id>aspParser</id>
+            <goals>
+		    <goal>antlr4</goal>
+	    </goals>
+	    <configuration>
+		    <sourceDirectory>src/de/dhbwstuttgart/sat/asp/parser/antlr/</sourceDirectory>
+		    <outputDirectory>src/de/dhbwstuttgart/sat/asp/parser/antlr/</outputDirectory>
+		    <arguments>
+			    <argument>-package</argument>
+			   <argument>de.dhbwstuttgart.sat.asp.parser.antlr</argument>
+	  	    </arguments>
+	    </configuration>
+          </execution>
+
         </executions>
       </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
 	    <artifactId>maven-compiler-plugin</artifactId>
+	    <version>2.3.2</version>
             <configuration>
-                <source>9</source>
+                <source>8</source>
-                <target>9</target>
+                <target>8</target>
             </configuration>
         </plugin>
     </plugins>

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

@@ -10,12 +10,10 @@ import org.objectweb.asm.signature.SignatureWriter;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
 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.typeinference.result.ResultSet;
 
@@ -165,7 +163,7 @@ public class Signature {
 	 * @param genAndBounds 
 	 */
 	private void getBoundsOfTypeVar(GenericTypeVar g, HashMap<String, String> genAndBounds) {
-		sw.visitFormalTypeParameter(g.getParsedName());
+		sw.visitFormalTypeParameter(g.getName());
 		
 		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator(); 
 		while(bItr.hasNext()) {
@@ -174,7 +172,7 @@ public class Signature {
 //			System.out.println("GetBounds: " + boundDesc);
 			// Ensure that <...> extends java.lang.Object OR ...
 			sw.visitClassBound().visitClassType(boundDesc);
-			genAndBounds.put(g.getParsedName(), boundDesc);
+			genAndBounds.put(g.getName(), boundDesc);
 		}
 		sw.visitClassBound().visitEnd();
 	}

src/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -7,12 +7,14 @@ 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.parser.scope.JavaClassRegistry;
+import de.dhbwstuttgart.sat.asp.ASPUnify;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
+import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
@@ -22,8 +24,7 @@ import de.dhbwstuttgart.typeinference.unify.TypeUnify;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import java.io.File;
+import java.io.*;
-import java.io.IOException;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -102,7 +103,7 @@ public class JavaTXCompiler {
 
             System.out.println(xConsSet);
             Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
-            System.out.println("RESULT: " + result);
+            System.out.println("RESULT: " + result.size());
             results.addAll(result);
         }
         return results.stream().map((unifyPairs ->
@@ -130,4 +131,73 @@ public class JavaTXCompiler {
         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);
+    }
+
+    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;
+    }
+
 }

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

@@ -1,16 +1,19 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 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.*;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class FCGenerator {
     /**
@@ -19,13 +22,32 @@ public class FCGenerator {
      *
      * @param availableClasses - Alle geparsten Klassen
      */
-    public static Set<UnifyPair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
-        HashSet<UnifyPair> pairs = new HashSet<>();
+        return toFC(availableClasses).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
-        for(ClassOrInterface cly : availableClasses){
-            pairs.addAll(getSuperTypes(cly, availableClasses));
     }
-        System.out.println(pairs);
+
-        return pairs;
+    /*
+    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();
+        for(ClassOrInterface cly : availableClasses){
+            for(Pair p : getSuperTypes(cly, availableClasses)){
+                String hash = p.TA1.acceptTV(printer)+";"+p.TA2.acceptTV(printer);
+                pairs.put(hash, p);
+            }
+        }
+        return pairs.values();
     }
 
     /**
@@ -35,29 +57,45 @@ public class FCGenerator {
      * @param forType
      * @return
      */
-    private static List<UnifyPair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
         return getSuperTypes(forType, availableClasses, new HashMap<>());
     }
 
-    //TODO: implements Interface auch als superklassen beachten
+    /**
-    private static List<UnifyPair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses, HashMap<String, UnifyType> gtvs) throws ClassNotFoundException {
+     *
-        List<UnifyType> params = new ArrayList<>();
+     * @param forType
+     * @param availableClasses
+     * @param gtvs
+     * @return
+     * @throws ClassNotFoundException
+     */
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses,
+                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs) throws ClassNotFoundException {
+        List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         //Die GTVs, die in forType hinzukommen:
-        HashMap<String, UnifyType> newGTVs = new HashMap<>();
+        HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
         //Generics mit gleichem Namen müssen den selben TPH bekommen
         for(GenericTypeVar gtv : forType.getGenerics()){
-            if(!gtvs.containsKey(gtv.getParsedName())){
+            if(!gtvs.containsKey(gtv.getName())){
-                gtvs.put(gtv.getParsedName(), PlaceholderType.freshPlaceholder());
+                TypePlaceholder replacePlaceholder = TypePlaceholder.fresh(new NullToken());
-                newGTVs.put(gtv.getParsedName(), PlaceholderType.freshPlaceholder());
+                gtvs.put(gtv.getName(), replacePlaceholder);
+                newGTVs.put(gtv.getName(), replacePlaceholder);
             }
-            params.add(gtvs.get(gtv.getParsedName()));
+            params.add(gtvs.get(gtv.getName()));
         }
 
-        Optional<ClassOrInterface> hasSuperclass = availableClasses.stream().filter(cl -> forType.getSuperClass().getName().equals(cl.getClassName())).findAny();
+
+        List<RefType> superClasses = new ArrayList<>();
+        superClasses.add(forType.getSuperClass());
+        superClasses.addAll(forType.getSuperInterfaces());
+
+        List<Pair> retList = new ArrayList<>();
+        for(RefType superType : superClasses){
+            Optional<ClassOrInterface> hasSuperclass = availableClasses.stream().filter(cl -> superType.getName().equals(cl.getClassName())).findAny();
             ClassOrInterface superClass;
             if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception
             {
-            superClass = ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(forType.getSuperClass().getName().toString()));
+                superClass = ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(superType.getName().toString()));
             }else{
                 superClass = hasSuperclass.get();
             }
@@ -67,82 +105,97 @@ public class FCGenerator {
             Beispie: Matrix<A> extends Vector<Vector<A>>
             Den ersten Parameter mit Vector<A> austauschen und dort alle Generics zu den Typplaceholdern in gtvs austauschen
              */
-        //Hier vermerken, welche Typen im der Superklasse ausgetauscht werden müssen
+            //Hier vermerken, welche Typen in der Superklasse ausgetauscht werden müssen
             Iterator<GenericTypeVar> itGenParams = superClass.getGenerics().iterator();
-        Iterator<RefTypeOrTPHOrWildcardOrGeneric> itSetParams = forType.getSuperClass().getParaList().iterator();
+            Iterator<RefTypeOrTPHOrWildcardOrGeneric> itSetParams = superType.getParaList().iterator();
-        while(itGenParams.hasNext()){
+            while(itSetParams.hasNext()){
                 RefTypeOrTPHOrWildcardOrGeneric setType = itSetParams.next();
                 //In diesem Typ die GTVs durch TPHs und Einsetzungen austauschen:
-            UnifyType setSetType = setType.acceptTV(new TypeExchanger(gtvs));
+                RefTypeOrTPHOrWildcardOrGeneric setSetType = setType.acceptTV(new TypeExchanger(gtvs));
-            newGTVs.put(itGenParams.next().getParsedName(), setSetType);
+                newGTVs.put(itGenParams.next().getName(), setSetType);
             }
 
-        UnifyType superType = forType.getSuperClass().acceptTV(new TypeExchanger(newGTVs));
+            //Für den superType kann man nun zum Austauschen der Generics wieder die gtvs nehmen:
+            //Die newGTVs sind nur für den superClass ClassOrInterface welches möglicherweise per reflection geladen wurde abgestimmt
+            RefTypeOrTPHOrWildcardOrGeneric superRefType = superType.acceptTV(new TypeExchanger(gtvs));
 
-        TypeParams paramList = new TypeParams(params);
+            RefTypeOrTPHOrWildcardOrGeneric t1 = new RefType(forType.getClassName(), params, new NullToken());
-        UnifyType t1 = new ReferenceType(forType.getClassName().toString(), paramList);
+            RefTypeOrTPHOrWildcardOrGeneric t2 = superRefType;
-        UnifyType t2 = superType;
 
-        UnifyPair ret = UnifyTypeFactory.generateSmallerPair(t1, t2);
+            Pair ret = new Pair(t1, t2, PairOperator.SMALLER);
 
-        List<UnifyPair> superTypes;
+            List<Pair> superTypes;
             //Rekursiver Aufruf. Abbruchbedingung ist Object als Superklasse:
             if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){
-            superTypes = Arrays.asList(UnifyTypeFactory.generateSmallerPair(UnifyTypeFactory.convert(ASTFactory.createObjectType()), UnifyTypeFactory.convert(ASTFactory.createObjectType())));
+                superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER));
             }else{
                 superTypes = getSuperTypes(superClass, availableClasses, newGTVs);
             }
 
-        List<UnifyPair> retList = new ArrayList<>();
             retList.add(ret);
             retList.addAll(superTypes);
+        }
 
         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.
      */
-    private static class TypeExchanger implements TypeVisitor<UnifyType>{
+    private static class TypeExchanger implements TypeVisitor<RefTypeOrTPHOrWildcardOrGeneric>{
 
-        private final HashMap<String, UnifyType> gtvs;
+        private final HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs;
 
-        TypeExchanger(HashMap<String, UnifyType> gtvs){
+        TypeExchanger(HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs){
             this.gtvs = gtvs;
         }
 
         @Override
-        public UnifyType visit(RefType refType) {
+        public RefTypeOrTPHOrWildcardOrGeneric visit(RefType refType) {
-            List<UnifyType> params = new ArrayList<>();
+            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
             for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
                 params.add(param.acceptTV(this));
             }
-            TypeParams paramList = new TypeParams(params);
+            RefTypeOrTPHOrWildcardOrGeneric ret = new RefType(refType.getName(), params, new NullToken());
-            UnifyType ret = new ReferenceType(refType.getName().toString(), paramList);
             return ret;
         }
 
         @Override
-        public UnifyType visit(SuperWildcardType superWildcardType) {
+        public RefTypeOrTPHOrWildcardOrGeneric visit(SuperWildcardType superWildcardType) {
             throw new DebugException("Dieser Fall darf nicht auftreten");
         }
 
         @Override
-        public UnifyType visit(TypePlaceholder typePlaceholder) {
+        public RefTypeOrTPHOrWildcardOrGeneric visit(TypePlaceholder typePlaceholder) {
             throw new DebugException("Dieser Fall darf nicht auftreten");
         }
 
         @Override
-        public UnifyType visit(ExtendsWildcardType extendsWildcardType) {
+        public RefTypeOrTPHOrWildcardOrGeneric visit(ExtendsWildcardType extendsWildcardType) {
             throw new DebugException("Dieser Fall darf nicht auftreten");
         }
 
         @Override
-        public UnifyType visit(GenericRefType genericRefType) {
+        public RefTypeOrTPHOrWildcardOrGeneric visit(GenericRefType genericRefType) {
             if(! gtvs.containsKey(genericRefType.getParsedName()))
                 throw new DebugException("Dieser Fall darf nicht auftreten");
-                //TODO: Diesen Dirty-Hack beseitigen. Fehler tritt bei java.lang.invoke.LambdaFormEditor$Transform$Kind auf.
-                //return UnifyTypeFactory.convert(ASTFactory.createObjectType());
             return gtvs.get(genericRefType.getParsedName());
         }
 

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

@@ -3,8 +3,8 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 
 public class GenericContext {
-    public final String parentMethod;
+    private final String parentMethod;
-    public final JavaClassName parentClass;
+    private final JavaClassName parentClass;
 
     public GenericContext(JavaClassName parentClass, String parentMethod) {
         if(parentMethod == null)parentMethod = "";

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

@@ -745,6 +745,7 @@ 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();
@@ -799,8 +800,6 @@ 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();

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

@@ -73,6 +73,7 @@ public class SyntaxTreeGenerator{
   }
   
   public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler) throws ClassNotFoundException{
+    if(ctx.packageDeclaration()!=null)this.pkgName = convert(ctx.packageDeclaration());
     List<ClassOrInterface> classes = new ArrayList<>();
     Map<String, Integer> imports = GatherNames.getImports(ctx, packageCrawler);
     this.imports = imports.keySet().stream().map(name -> reg.getName(name)).collect(Collectors.toSet());
@@ -89,6 +90,15 @@ public class SyntaxTreeGenerator{
     return new SourceFile(this.pkgName, classes, this.imports);
   }
 
+  private String convert(Java8Parser.PackageDeclarationContext packageDeclarationContext) {
+    String ret = "";
+    for(TerminalNode identifier : packageDeclarationContext.Identifier()){
+      ret += identifier.getText()+".";
+    }
+    ret = ret.substring(0, ret.length()-1);
+    return ret;
+  }
+
   public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
     Java8Parser.MethodHeaderContext header = methodDeclarationContext.methodHeader();
     int modifiers = SyntaxTreeGenerator.convert(methodDeclarationContext.methodModifier());
@@ -165,8 +175,8 @@ public class SyntaxTreeGenerator{
       }
     }
     String className = this.pkgName + (this.pkgName.length()>0?".":"") + ctx.Identifier().getText();
-    JavaClassName name = reg.getName(className);
+    JavaClassName name = reg.getName(className); //Holt den Package Namen mit dazu
-    if(! name.toString().equals(className)){
+    if(! name.toString().equals(className)){ //Kommt die Klasse schon in einem anderen Package vor?
       throw new TypeinferenceException("Name " + className + " bereits vorhanden in " + reg.getName(className).toString()
               ,ctx.getStart());
     }
@@ -203,20 +213,20 @@ public class SyntaxTreeGenerator{
     }
 
     Boolean isInterface = false;
-    List<RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces = convert(ctx.superinterfaces(), generics);
+    List<RefType> implementedInterfaces = convert(ctx.superinterfaces(), generics);
     return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass,
             isInterface, implementedInterfaces, offset);
   }
 
-  private List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.SuperinterfacesContext ctx, GenericsRegistry generics) {
+  private List<RefType> convert(Java8Parser.SuperinterfacesContext ctx, GenericsRegistry generics) {
     if(ctx == null)return new ArrayList<>();
     return convert(ctx.interfaceTypeList(), generics);
   }
 
-  private List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.InterfaceTypeListContext ctx, GenericsRegistry generics) {
+  private List<RefType> convert(Java8Parser.InterfaceTypeListContext ctx, GenericsRegistry generics) {
-    List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
+    List<RefType> ret = new ArrayList<>();
     for(Java8Parser.InterfaceTypeContext interfaceType : ctx.interfaceType()){
-      ret.add(TypeGenerator.convert(interfaceType.classType(), reg, generics));
+      ret.add((RefType) TypeGenerator.convert(interfaceType.classType(), reg, generics));
     }
     return ret;
   }
@@ -400,7 +410,7 @@ public class SyntaxTreeGenerator{
     List<Field> fields = convertFields(ctx.interfaceBody());
     List<Method> methods = convertMethods(ctx.interfaceBody(), name, superClass, generics);
 
-    List<RefTypeOrTPHOrWildcardOrGeneric> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
+    List<RefType> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
 
     return new ClassOrInterface(modifiers, name, fields, methods, new ArrayList<>(),
             genericParams, superClass, true, extendedInterfaces, ctx.getStart());
@@ -417,13 +427,16 @@ 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);
     }
     return ret;
   }
 
-  private List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.ExtendsInterfacesContext extendsInterfacesContext, GenericsRegistry generics) {
+  private List<RefType> convert(Java8Parser.ExtendsInterfacesContext extendsInterfacesContext, GenericsRegistry generics) {
     if(extendsInterfacesContext == null)return new ArrayList<>();
     return convert(extendsInterfacesContext.interfaceTypeList(), generics);
   }

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

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
@@ -23,18 +22,20 @@ import java.util.List;
 public class TypeGenerator {
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        String name;
-        if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){
-            name = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().Identifier().getText();
-            }
         Java8Parser.TypeArgumentsContext arguments;
         if(unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType() != null){
-            name = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().Identifier().getText();
             arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }else{// if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){
-            name = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().getText();
             arguments = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }
+        /**
+         * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten
+         * Beispiel: Typ<String>.InnererTyp<Integer>
+         */
+        String name = unannClassOrInterfaceTypeContext.getText();
+        if(name.contains("<")){
+            name = name.split("<")[0]; //Der Typ ist alles vor den ersten Argumenten
+        }
         return convertTypeName(name, arguments, unannClassOrInterfaceTypeContext.getStart(), reg, generics);
     }
 
@@ -75,8 +76,7 @@ public class TypeGenerator {
         //Problem <A extends B, B> ist erlaubt, würde aber bei den Bounds von A den Generic B nicht als solchen erkennen
         List<RefTypeOrTPHOrWildcardOrGeneric> bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics);
 
-        GenericTypeVar ret = new GenericTypeVar(new GenericTypeName(new GenericContext(parentClass, parentMethod), name), bounds, typeParameter.getStart(), typeParameter.getStop());
+        GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
-        generics.put(name, new GenericContext(parentClass, parentMethod));
         return ret;
     }
 
@@ -91,7 +91,7 @@ public class TypeGenerator {
             return ret;
         }
         if(typeBoundContext.classOrInterfaceType() != null){
-            ret.add(convert(typeBoundContext.classOrInterfaceType()));
+            ret.add(convert(typeBoundContext.classOrInterfaceType(), reg, generics));
             if(typeBoundContext.additionalBound() != null)
                 for(Java8Parser.AdditionalBoundContext addCtx : typeBoundContext.additionalBound()){
                     ret.add(convert(addCtx.interfaceType()));
@@ -102,8 +102,9 @@ public class TypeGenerator {
         }
     }
 
-    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext) {
+    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        throw new NotImplementedException();
+        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.InterfaceTypeContext interfaceTypeContext) {
@@ -113,10 +114,7 @@ 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){
-                Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType();
+                return convert(referenceTypeContext.classOrInterfaceType(), reg, generics);//return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
-                //return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
-                if(ctx.typeArguments() != null)throw new NotImplementedException();
-                return convertTypeName(referenceTypeContext.getText(), null,referenceTypeContext.getStart(), reg, generics);
             }else{
                 throw new NotImplementedException();
             }
@@ -133,7 +131,7 @@ public class TypeGenerator {
             String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
         if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
             if(generics.contains(name)){
-                return new GenericRefType(new GenericTypeName(generics.get(name),name), offset);
+                return new GenericRefType(name, offset);
             }else{
                 throw new TypeinferenceException("Der Typ "+ name + " ist nicht vorhanden",offset);
             }

src/de/dhbwstuttgart/parser/scope/GenericTypeName.java

@@ -1,26 +0,0 @@
-package de.dhbwstuttgart.parser.scope;
-
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-
-public class GenericTypeName extends JavaClassName {
-    private final static String DELIMITER = "%";
-
-    private final JavaClassName parentClass;
-    private final String methodName;
-
-    public GenericTypeName(GenericContext genericContext, String name) {
-        super(name);
-        this.parentClass = genericContext.parentClass;
-        this.methodName = genericContext.parentMethod;
-    }
-
-    public String getUniqueIdentifier() {
-        return parentClass.toString()
-                + DELIMITER + methodName
-                + DELIMITER + super.toString();
-    }
-
-    public JavaClassName getParentClass() {
-        return parentClass;
-    }
-}

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

@@ -0,0 +1,40 @@
+package de.dhbwstuttgart.sat.asp;
+
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ASPStringConverter {
+    private static final Map<String, String> replacements = new HashMap<>();
+    static{
+        replacements.put(".", "_DOT_");
+        replacements.put("$", "_DOLLAR_");
+    }
+
+    public static String toConstant(JavaClassName name){
+        return toConstant(name.toString());
+    }
+
+    public static String toConstant(String name){
+        return "c" + replace(name);
+    }
+
+    public static String fromConstant(String s){
+        return unReplace(s).substring(1);
+    }
+
+    private static String replace(String input){
+        for(String toReplace : replacements.keySet()){
+            input = input.replace(toReplace, replacements.get(toReplace));
+        }
+        return input;
+    }
+
+    private static String unReplace(String input){
+        for(String toReplace : replacements.keySet()){
+            input = input.replace(replacements.get(toReplace), toReplace);
+        }
+        return input;
+    }
+}

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

@@ -0,0 +1,60 @@
+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,7 +6,6 @@ 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;
@@ -16,27 +15,29 @@ 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/subst.lp"));
-        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/reduce1.lp"));
-        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/reduce2.lp"));
-        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/unify.lp"));
     }
 
     public Clingo(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 =
-                "/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/clingo-5.2.1-linux-x86_64/clingo";
+                "clingo";
         List<String> commands = new ArrayList<>();
         commands.add(pathToClingo);
-        commands.add("--outf=2"); //use JSON-Output
+        //commands.add("--outf=2"); //use JSON-Output
+        commands.add("--outf=1"); //use Text-Output
+        commands.add("-n 0"); //Compute all models
         for(File file : input){
             commands.add(file.getPath());
         }
         commands.addAll(programFiles.stream().map(f->f.getPath()).collect(Collectors.toList()));
+
         Process clingo = new ProcessBuilder( commands.toArray(new String[0])).start();
         InputStream output = clingo.getInputStream();
         clingo.waitFor();

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

@@ -0,0 +1,31 @@
+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"),
+    ASP_PAIR_SMALLER_DOT_NAME("subEq"),
+    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;
+
+    private ASPGencayRule(final String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String toString() {
+        return text;
+    }
+}

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

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

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

@@ -1,17 +1,188 @@
 package de.dhbwstuttgart.sat.asp.parser;
 
-import de.dhbwstuttgart.typeinference.result.ResultPair;
+import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+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.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 java.util.HashSet;
+import java.util.*;
-import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Ablauf:
+ * - Erst werden alle benötigten Statements eingelesen. Die Pointer bleiben als Strings erhalten
+ * - Anschließend müssen diese wieder zu einem Unify Ergebnis zurückgewandelt werden
+ * - Hier nicht die Typen aus dem unify.model packages verwenden.
+ * TODO: Überlegen welche Informationen noch nach der Unifizierung gebraucht werden
+ *  -> Eigentlich nur die korrekten Namen der Typen und TPHs
+ */
+public class ASPParser extends ASPResultBaseListener {
+    private Collection<TypePlaceholder> originalTPHs;
+    private ResultSet resultSet;
+    private Map<String, RefTypeOrTPHOrWildcardOrGeneric> types = new HashMap();
+    private Set<String> tphs = new HashSet<>();
+
+    /**
+     * Parst clingo output welcher als JSON (option --outf=2) ausgibt
+     * @param toParse
+     * @return
+     */
+    public static ResultSet parse(String toParse, Collection<TypePlaceholder> oldPlaceholders){
+        return new ASPParser(toParse, oldPlaceholders).resultSet;
+    }
+
+    private static class Relation {
+        public final String right;
+        public final String left;
+
+        Relation(String leftType, String rightType){
+            this.left = leftType;
+            this.right = rightType;
+        }
+
+        @Override
+        public int hashCode() {
+            return (left+right).hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if(obj instanceof Relation)
+                return (right+left).equals(((Relation) obj).left+((Relation) obj).right);
+            return super.equals(obj);
+        }
+    }
+
+    private List<String> parseParameterList(UnifyResultParser.ParameterListContext ctx){
+        return ctx.value().stream().map(v ->
+                //ASPStringConverter.fromConstant(v.getText())
+                v.getText()
+        ).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));
+        }
+
+    }
+    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());
+    }
+
+    private ASPParser(String toParse, Collection<TypePlaceholder> oldPlaceholders){
+        //System.out.println(toParse);
+        this.originalTPHs = oldPlaceholders;
+
+        /*
+        JsonObject jsonResult = Json.createReader(new StringReader(toParse)).readObject();
+        JsonArray results = jsonResult.getJsonArray("Call").getJsonObject(0).
+                getJsonArray("Witnesses").getJsonObject(0).
+                getJsonArray("Value");
+
+        //Im ersten Schritt werden alle Regeln geparst
+        String completeResult = "";
+        for(int i = 0; i<results.size();i++){
+            String aspStatement = results.getString(i);
+            completeResult += aspStatement + " ";
+        }
+        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);
+
+        /*
+        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);
 
-public class ASPParser {
-    ResultSet parse(String result){
         Set<ResultPair> ret = new HashSet<>();
-        for(String pair : result.split(",")){
+        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);
+                }
+            }
+        }
+        this.resultSet = new ResultSet(ret);
+    }
 
-        }
-        return new ResultSet(ret);
-    }
 }

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

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

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+grammar UnifyResult;
+
+answer : 'ANSWER' (resultSetRule '.')*;
+
+resultSetRule :
+      parameter
+    | equals
+    | smaller
+    | typeVar
+    | type
+    | unifier
+    | otherRule
+    ;
+
+parameterList : '(' value (',' value)*  ')';
+value : NAME
+        | resultSetRule ;
+
+parameter : PARAMLIST_NAME parameterList;
+equals : EQUALS_NAME parameterList;
+unifier : UNIFIER_NAME parameterList;
+smaller : SMALLER_NAME parameterList;
+typeVar : TYPEVAR_NAME parameterList;
+type : TYPE_NAME parameterList;
+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';
+TYPE_NAME : 'type';
+NAME : [a-zA-Z0-9_]+;
+
+WS  :  [ \t\r\n\u000C]+ -> skip
+    ;
+LINE_COMMENT
+    :   '%' ~[\r\n]* -> skip
+    ;
+

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

@@ -0,0 +1,25 @@
+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
+'ANSWER'=1
+'.'=2
+'('=3
+','=4
+')'=5
+'param'=6
+'unifier'=7
+'equals'=8
+'smaller'=9
+'typeVar'=10
+'type'=11

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

@@ -0,0 +1,171 @@
+// Generated from UnifyResult.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 UnifyResultListener},
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+public class UnifyResultBaseListener implements UnifyResultListener {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAnswer(UnifyResultParser.AnswerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAnswer(UnifyResultParser.AnswerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterResultSetRule(UnifyResultParser.ResultSetRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitResultSetRule(UnifyResultParser.ResultSetRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParameterList(UnifyResultParser.ParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParameterList(UnifyResultParser.ParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterValue(UnifyResultParser.ValueContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitValue(UnifyResultParser.ValueContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParameter(UnifyResultParser.ParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParameter(UnifyResultParser.ParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEquals(UnifyResultParser.EqualsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <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}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSmaller(UnifyResultParser.SmallerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSmaller(UnifyResultParser.SmallerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeVar(UnifyResultParser.TypeVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeVar(UnifyResultParser.TypeVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterType(UnifyResultParser.TypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitType(UnifyResultParser.TypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterOtherRule(UnifyResultParser.OtherRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitOtherRule(UnifyResultParser.OtherRuleContext 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/UnifyResultLexer.java

@@ -0,0 +1,139 @@
+// Generated from UnifyResult.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 UnifyResultLexer 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, 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;
+	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", "PARAMLIST_NAME", "UNIFIER_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'"
+	};
+	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"
+	};
+	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 UnifyResultLexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "UnifyResult.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\20m\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";
+	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/UnifyResultLexer.tokens

@@ -0,0 +1,25 @@
+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
+'ANSWER'=1
+'.'=2
+'('=3
+','=4
+')'=5
+'param'=6
+'unifier'=7
+'equals'=8
+'smaller'=9
+'typeVar'=10
+'type'=11

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

@@ -0,0 +1,120 @@
+// Generated from UnifyResult.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 UnifyResultParser}.
+ */
+public interface UnifyResultListener extends ParseTreeListener {
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#answer}.
+	 * @param ctx the parse tree
+	 */
+	void enterAnswer(UnifyResultParser.AnswerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#answer}.
+	 * @param ctx the parse tree
+	 */
+	void exitAnswer(UnifyResultParser.AnswerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#resultSetRule}.
+	 * @param ctx the parse tree
+	 */
+	void enterResultSetRule(UnifyResultParser.ResultSetRuleContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#resultSetRule}.
+	 * @param ctx the parse tree
+	 */
+	void exitResultSetRule(UnifyResultParser.ResultSetRuleContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#parameterList}.
+	 * @param ctx the parse tree
+	 */
+	void enterParameterList(UnifyResultParser.ParameterListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#parameterList}.
+	 * @param ctx the parse tree
+	 */
+	void exitParameterList(UnifyResultParser.ParameterListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#value}.
+	 * @param ctx the parse tree
+	 */
+	void enterValue(UnifyResultParser.ValueContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#value}.
+	 * @param ctx the parse tree
+	 */
+	void exitValue(UnifyResultParser.ValueContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#parameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterParameter(UnifyResultParser.ParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#parameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitParameter(UnifyResultParser.ParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#equals}.
+	 * @param ctx the parse tree
+	 */
+	void enterEquals(UnifyResultParser.EqualsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#equals}.
+	 * @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
+	 */
+	void enterSmaller(UnifyResultParser.SmallerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#smaller}.
+	 * @param ctx the parse tree
+	 */
+	void exitSmaller(UnifyResultParser.SmallerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#typeVar}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeVar(UnifyResultParser.TypeVarContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#typeVar}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeVar(UnifyResultParser.TypeVarContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#type}.
+	 * @param ctx the parse tree
+	 */
+	void enterType(UnifyResultParser.TypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#type}.
+	 * @param ctx the parse tree
+	 */
+	void exitType(UnifyResultParser.TypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#otherRule}.
+	 * @param ctx the parse tree
+	 */
+	void enterOtherRule(UnifyResultParser.OtherRuleContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#otherRule}.
+	 * @param ctx the parse tree
+	 */
+	void exitOtherRule(UnifyResultParser.OtherRuleContext ctx);
+}

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

@@ -0,0 +1,694 @@
+// Generated from UnifyResult.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 UnifyResultParser 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, 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;
+	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;
+	public static final String[] ruleNames = {
+		"answer", "resultSetRule", "parameterList", "value", "parameter", "equals", 
+		"unifier", "smaller", "typeVar", "type", "otherRule"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'unifier'", 
+		"'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"
+	};
+	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 "UnifyResult.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public UnifyResultParser(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 UnifyResultListener ) ((UnifyResultListener)listener).enterAnswer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)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(22);
+			match(T__0);
+			setState(28);
+			_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)) {
+				{
+				{
+				setState(23);
+				resultSetRule();
+				setState(24);
+				match(T__1);
+				}
+				}
+				setState(30);
+				_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 ParameterContext parameter() {
+			return getRuleContext(ParameterContext.class,0);
+		}
+		public EqualsContext equals() {
+			return getRuleContext(EqualsContext.class,0);
+		}
+		public SmallerContext smaller() {
+			return getRuleContext(SmallerContext.class,0);
+		}
+		public TypeVarContext typeVar() {
+			return getRuleContext(TypeVarContext.class,0);
+		}
+		public TypeContext type() {
+			return getRuleContext(TypeContext.class,0);
+		}
+		public UnifierContext unifier() {
+			return getRuleContext(UnifierContext.class,0);
+		}
+		public OtherRuleContext otherRule() {
+			return getRuleContext(OtherRuleContext.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 UnifyResultListener ) ((UnifyResultListener)listener).enterResultSetRule(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitResultSetRule(this);
+		}
+	}
+
+	public final ResultSetRuleContext resultSetRule() throws RecognitionException {
+		ResultSetRuleContext _localctx = new ResultSetRuleContext(_ctx, getState());
+		enterRule(_localctx, 2, RULE_resultSetRule);
+		try {
+			setState(38);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case PARAMLIST_NAME:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(31);
+				parameter();
+				}
+				break;
+			case EQUALS_NAME:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(32);
+				equals();
+				}
+				break;
+			case SMALLER_NAME:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(33);
+				smaller();
+				}
+				break;
+			case TYPEVAR_NAME:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(34);
+				typeVar();
+				}
+				break;
+			case TYPE_NAME:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(35);
+				type();
+				}
+				break;
+			case UNIFIER_NAME:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(36);
+				unifier();
+				}
+				break;
+			case NAME:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(37);
+				otherRule();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		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 UnifyResultListener ) ((UnifyResultListener)listener).enterParameterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)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(40);
+			match(T__2);
+			setState(41);
+			value();
+			setState(46);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==T__3) {
+				{
+				{
+				setState(42);
+				match(T__3);
+				setState(43);
+				value();
+				}
+				}
+				setState(48);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(49);
+			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(UnifyResultParser.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 UnifyResultListener ) ((UnifyResultListener)listener).enterValue(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitValue(this);
+		}
+	}
+
+	public final ValueContext value() throws RecognitionException {
+		ValueContext _localctx = new ValueContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_value);
+		try {
+			setState(53);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(51);
+				match(NAME);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(52);
+				resultSetRule();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ParameterContext extends ParserRuleContext {
+		public TerminalNode PARAMLIST_NAME() { return getToken(UnifyResultParser.PARAMLIST_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public ParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_parameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitParameter(this);
+		}
+	}
+
+	public final ParameterContext parameter() throws RecognitionException {
+		ParameterContext _localctx = new ParameterContext(_ctx, getState());
+		enterRule(_localctx, 8, RULE_parameter);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(55);
+			match(PARAMLIST_NAME);
+			setState(56);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EqualsContext extends ParserRuleContext {
+		public TerminalNode EQUALS_NAME() { return getToken(UnifyResultParser.EQUALS_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public EqualsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_equals; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterEquals(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitEquals(this);
+		}
+	}
+
+	public final EqualsContext equals() throws RecognitionException {
+		EqualsContext _localctx = new EqualsContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_equals);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(58);
+			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);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SmallerContext extends ParserRuleContext {
+		public TerminalNode SMALLER_NAME() { return getToken(UnifyResultParser.SMALLER_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public SmallerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_smaller; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterSmaller(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitSmaller(this);
+		}
+	}
+
+	public final SmallerContext smaller() throws RecognitionException {
+		SmallerContext _localctx = new SmallerContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_smaller);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(64);
+			match(SMALLER_NAME);
+			setState(65);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeVarContext extends ParserRuleContext {
+		public TerminalNode TYPEVAR_NAME() { return getToken(UnifyResultParser.TYPEVAR_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public TypeVarContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeVar; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterTypeVar(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitTypeVar(this);
+		}
+	}
+
+	public final TypeVarContext typeVar() throws RecognitionException {
+		TypeVarContext _localctx = new TypeVarContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_typeVar);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(67);
+			match(TYPEVAR_NAME);
+			setState(68);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeContext extends ParserRuleContext {
+		public TerminalNode TYPE_NAME() { return getToken(UnifyResultParser.TYPE_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public TypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_type; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitType(this);
+		}
+	}
+
+	public final TypeContext type() throws RecognitionException {
+		TypeContext _localctx = new TypeContext(_ctx, getState());
+		enterRule(_localctx, 18, RULE_type);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(70);
+			match(TYPE_NAME);
+			setState(71);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class OtherRuleContext extends ParserRuleContext {
+		public TerminalNode NAME() { return getToken(UnifyResultParser.NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public OtherRuleContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_otherRule; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterOtherRule(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitOtherRule(this);
+		}
+	}
+
+	public final OtherRuleContext otherRule() throws RecognitionException {
+		OtherRuleContext _localctx = new OtherRuleContext(_ctx, getState());
+		enterRule(_localctx, 20, RULE_otherRule);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(73);
+			match(NAME);
+			setState(74);
+			parameterList();
+			}
+		}
+		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\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";
+	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/model/ParsedASPStatement.java

@@ -1,7 +0,0 @@
-package de.dhbwstuttgart.sat.asp.parser.model;
-
-public class ParsedASPStatement {
-    public ParsedASPStatement(String statement){
-
-    }
-}

src/de/dhbwstuttgart/sat/asp/parser/model/ParsedType.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.sat.asp.parser.model;
+
+import java.util.List;
+
+public class ParsedType {
+    public final String name;
+    public final String params;
+    public ParsedType(String name, String params){
+        this.name = name;
+        this.params = params;
+    }
+}

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

@@ -0,0 +1,214 @@
+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>{
+
+    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);
+        }
+
+        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;
+    }
+
+    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<>();
+        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));
+        }
+    }
+
+    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) {
+        String ls = p.TA1.acceptTV(this);
+        String rs = p.TA2.acceptTV(this);
+        ASPStatement pairStmt = null;
+        if(p.GetOperator().equals(PairOperator.SMALLERDOT)){
+            pairStmt = makeStatement(ASPRule.ASP_PAIR_SMALLER_DOT_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
+            pairStmt = makeStatement(ASPRule.ASP_PAIR_EQUALS_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.SMALLER)){
+            pairStmt = makeStatement(ASPRule.ASP_PAIR_SMALLER_NAME.toString(), ls, rs);
+        }else throw new NotImplementedException();
+        return pairStmt;
+    }
+
+    protected 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+=",";
+        }
+        stmt += ")";
+        return new ASPStatement(stmt);
+    }
+
+    protected void convertParameterlist(String pointer, List<String> pointers){
+        Iterator<String> it = pointers.iterator();
+        Integer i = 1;
+        String ruleName = ASPRule.ASP_PARAMLIST_NAME.toString();
+        while (it.hasNext()){
+            ASPStatement stmt;
+            String type = it.next();
+            stmt = makeStatement(ruleName, pointer, type, i.toString());
+            writer.add(stmt);
+            i++;
+        }
+    }
+
+    @Override
+    public String visit(RefType refType) {
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        List<String> params = new ArrayList<>();
+        for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+            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()));
+        writer.add(stmt);
+        return pointer;
+    }
+
+    @Override
+    public String visit(SuperWildcardType superWildcardType) {
+        throw new NotImplementedException();
+    }
+
+    @Override
+    public String visit(TypePlaceholder typePlaceholder) {
+        String name = ASPStringConverter.toConstant(typePlaceholder.getName());
+        ASPStatement stmt = makeStatement(ASPRule.ASP_TYPE_VAR.toString(), name);
+        writer.add(stmt);
+        return name;
+    }
+
+    @Override
+    public String visit(ExtendsWildcardType extendsWildcardType) {
+        throw new NotImplementedException();
+    }
+
+    @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;
+    }
+}

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

@@ -0,0 +1,277 @@
+package de.dhbwstuttgart.sat.asp.writer;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
+import de.dhbwstuttgart.sat.asp.ASPStringConverter;
+import de.dhbwstuttgart.sat.asp.model.ASPGencayRule;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.type.*;
+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 java.util.*;
+
+
+public class ASPFactoryAlternative 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)
+     * Für die FCTypen eindeutige Namen für die pph-Regeln
+     *  (ergibt sich von selbst, weil man einfach den Namen der TPH in der FC verwenden kann)
+     * paramOrder wird benötigt!
+     *  Nur bei parameterlisten > 1
+     *  paramOrder(paralistPointer, parameter, num)
+     *  (ähnlich meiner paramNum)
+     * Trennung von FC und Eq:
+     *  sub -> type -> param
+     *  ...Eq -> typeEq -> paramEq
+     * type..(_,_,_p): p kann sein:
+     *  1. Variable
+     *  2. ParameterPointer
+     *  3. null
+     */
+    ASPWriter writer = new ASPWriter();
+    boolean isFCType = false;
+
+    private static List<ASPStatement> generateVar(ConstraintSet<Pair> constraints){
+        List<ASPStatement> ret = new ArrayList<>();
+        for(TypePlaceholder tph : getInvolvedTPHS(constraints)){
+            ret.add(makeStatement(ASPGencayRule.ASP_TYPE_VAR.toString(),
+                    ASPStringConverter.toConstant(tph.getName())));
+        }
+        return ret;
+    }
+
+    protected static 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;
+    }
+
+    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
+        ASPFactoryAlternative factory = new ASPFactoryAlternative();
+        factory.convertFC(fcClasses);
+        List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
+        for(Constraint<Pair> constraint : constraints1){
+            for(Pair p : constraint){
+                factory.convertPair(p);
+            }
+        }
+        factory.writer.addAll(generateVar(constraints));
+
+        return factory.writer.getASPFile();
+    }
+
+    private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
+        Collection<Pair> fc = FCGenerator.toFC(classes);
+        isFCType = true;
+        for(Pair fcp : fc){
+            generateTheta((RefType) fcp.TA1);
+            generateTheta((RefType) fcp.TA2);
+            convertPair(fcp);
+        }
+        isFCType = false;
+    }
+
+    private void generateTheta(RefType t){
+        String rule = "theta"+t.getParaList().size() ;
+        String name = ASPStringConverter.toConstant(t.getName());
+        writer.add(makeStatement(rule, name));
+    }
+
+    private void convertPair(Pair p){
+        String ls = p.TA1.acceptTV(this);
+        String rs = p.TA2.acceptTV(this);
+        ASPStatement pairStmt = null;
+        if(p.GetOperator().equals(PairOperator.SMALLERDOT)){
+            pairStmt = makeStatement(ASPGencayRule.ASP_PAIR_SMALLER_DOT_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
+            pairStmt = makeStatement(ASPGencayRule.ASP_PAIR_EQUALS_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.SMALLER)){
+            pairStmt = makeStatement(ASPGencayRule.ASP_PAIR_SMALLER_NAME.toString(), ls, rs);
+        }else throw new NotImplementedException();
+        writer.add(pairStmt);
+    }
+
+    private static ASPStatement makeStatement(String rule, String... params){
+        String stmt = rule + "(";
+        for(String param : params){
+            stmt += param + ",";
+        }
+        stmt = stmt.substring(0,stmt.length()-1);
+        stmt += ")";
+        return new ASPStatement(stmt);
+    }
+
+    private String convertParameterlist(List<String> pointers){
+        //if(pointers.size()==1)return pointers.get(0);
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        Iterator<String> it = pointers.iterator();
+        String p = pointer;
+        String paramname = ASPGencayRule.ASP_PARAMLIST_NAME.toString();
+        if(this.isFCType)paramname = ASPGencayRule.ASP_FC_PARAMLIST_NAME.toString();
+        if(!it.hasNext()){
+            return ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString();
+        }
+        while (it.hasNext()){
+            ASPStatement stmt;
+            String type = it.next();
+            String nextP = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+            if(it.hasNext()){
+                stmt = makeStatement(paramname, p, type, nextP);
+            }else{
+                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);
+        }
+        return pointer;
+    }
+
+    //Wird zum erstellen der pph(..) Regeln gebraucht
+    private String currentFCTypePointer = "";
+    @Override
+    public String visit(RefType refType) {
+        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);
+        }else{
+            List<String> params = null;
+            params = generateParameter(refType);
+            params.remove(0);
+            paramPointer = convertParameterlist(params);
+            if(refType.getParaList().size()>1){
+                //paramOrder generieren:
+                for(String param : params) {
+                    ASPStatement pOstmt = makeStatement(ASPGencayRule.ASP_PARAMLIST_ORDER.toString(),
+                            paramPointer, param);
+                    writer.add(pOstmt);
+                }
+            }
+        }
+        String typeName = ASPStringConverter.toConstant(refType.getName());
+        String ruleName = isFCType? ASPGencayRule.ASP_FCTYPE.toString(): ASPGencayRule.ASP_TYPE.toString();
+        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, paramPointer);
+        writer.add(stmt);
+        return pointer;
+        /*
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        List<String> params = null;
+        params = generateParameter(refType);
+        params.remove(0); //Das erste ist der eigentliche Typ kein parameter
+        String typeName = ASPStringConverter.toConstant(refType.getName());
+        String ruleName = isFCType? ASPGencayRule.ASP_FCTYPE.toString(): ASPGencayRule.ASP_TYPE.toString();
+        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, convertParameterlist(params));
+        writer.add(stmt);
+        return pointer;
+        */
+    }
+
+    /**
+     * Erstellt die Parameterliste, wobei type auch schon als Parameter betrachtet wird.
+     * Die RefTypes werden nicht zu extra type-Regeln umgewandelt. Es wird nur ihr Name als Konstante benutzt
+     * Das funktioniert, weil nacher das ParamOrder zuteilt, welche Typen zusammenhängen.
+     * Diese funktion nur verwenden, wenn auch ein paramOrder generiert wird
+     */
+    private List<String> generateParameter(RefType type){
+        List<String> ret = new ArrayList<>();
+        ret.add(ASPStringConverter.toConstant(type.getName()));
+        for(RefTypeOrTPHOrWildcardOrGeneric param : type.getParaList()){
+            if(param instanceof RefType){
+                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;
+    }
+
+    @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;
+    }
+
+    @Override
+    public String visit(TypePlaceholder typePlaceholder) {
+        String name = ASPStringConverter.toConstant(typePlaceholder.getName());
+
+        ASPStatement stmt = null;
+        if(isFCType){
+            stmt = makeStatement(ASPGencayRule.ASP_GENERIC_VAR.toString(),
+                    currentFCTypePointer, name);
+        } else {
+            stmt = makeStatement(ASPGencayRule.ASP_TYPE_VAR.toString(), name);
+        }
+
+        writer.add(stmt);
+        return name;
+    }
+
+    @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;
+    }
+
+    @Override
+    public String visit(GenericRefType genericRefType) {
+        throw new NotImplementedException();
+    }
+
+    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<>();
+        }
+    }
+
+}

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

@@ -1,111 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer;
-
-import de.dhbwstuttgart.exceptions.NotImplementedException;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.sat.asp.writer.model.*;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-public class ASPGenerator {
-    ASPWriter writer = new ASPWriter();
-    private final String asp;
-
-    public ASPGenerator(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses){
-        List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
-        List<Pair> constraintPairs = new ArrayList<>();
-        for(Constraint<Pair> constraint : constraints1){
-            System.out.println(UnifyTypeFactory.convert(constraint));
-            constraintPairs.addAll(constraint);
-        }
-        asp = toASP(constraintPairs, fcClasses);
-    }
-
-    public String getASP(){
-        return asp;
-    }
-
-    private String toASP(List<Pair> constraintSet, Collection<ClassOrInterface> fcClasses){
-        TypeConverter converter = new TypeConverter();
-        for(ClassOrInterface cl : fcClasses){
-            ASPRefType superClass = (ASPRefType) cl.getSuperClass().acceptTV(converter);
-            ASPPairSmaller fcEntry = new ASPPairSmaller(new ASPFCType(convert(cl)), new ASPFCType(superClass), writer);
-            writer.add(new ASPStatement(fcEntry.toASP()));
-        }
-        for(Pair cons : constraintSet){
-            writer.add(new ASPStatement(convert(cons).toASP()));
-        }
-
-        return writer.getASPFile();
-    }
-
-    private ASPPair convert(Pair pair){
-        TypeConverter converter = new TypeConverter();
-        ASPType ls = pair.TA1.acceptTV(converter);
-        ASPType rs = pair.TA2.acceptTV(converter);
-        if(pair.OperatorEqual()){
-            return new ASPPairEquals(ls, rs,writer);
-        }else if(pair.OperatorSmallerDot()){
-            return new ASPPairSmallerDot(ls, rs, writer);
-        }else throw new NotImplementedException();
-    }
-
-    private ASPRefType convert(ClassOrInterface cl){
-        List<ASPType> paramList = new ArrayList<>();
-        for(GenericTypeVar gtv : cl.getGenerics()){
-            paramList.add(new ASPGenericType(toConstant(gtv.getName())));
-        }
-        ASPParameterList params = new ASPParameterList(paramList, writer);
-        return new ASPRefType(toConstant(cl.getClassName()), params);
-    }
-
-    public static String toConstant(JavaClassName name){
-        return toConstant(name.toString().replace(".", "_"));
-    }
-
-    public static String toConstant(String name){
-        return "c" + name.toString().replace(".", "_");
-    }
-
-    private class TypeConverter implements TypeVisitor<ASPType>{
-
-        @Override
-        public ASPType visit(RefType type) {
-            List<ASPType> paramList = new ArrayList<>();
-            for(RefTypeOrTPHOrWildcardOrGeneric gtv : type.getParaList()){
-                paramList.add(gtv.acceptTV(this));
-            }
-            ASPParameterList params = new ASPParameterList(paramList, writer);
-            return new ASPRefType(toConstant(type.getName()), params);
-        }
-
-        @Override
-        public ASPType visit(SuperWildcardType superWildcardType) {
-            throw new NotImplementedException();
-        }
-
-        @Override
-        public ASPType visit(TypePlaceholder typePlaceholder) {
-            return new ASPTypeVar(toConstant(typePlaceholder.getName()));
-        }
-
-        @Override
-        public ASPType visit(ExtendsWildcardType extendsWildcardType) {
-            throw new NotImplementedException();
-        }
-
-        @Override
-        public ASPType visit(GenericRefType genericRefType) {
-            return new ASPRefType(toConstant(genericRefType.getName()),
-                    new ASPParameterList(new ArrayList<>(), writer));
-        }
-    }
-}

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

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
+package de.dhbwstuttgart.sat.asp.writer;
 
 public class ASPStatement {
     private final String stmt;

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

@@ -1,8 +1,9 @@
 package de.dhbwstuttgart.sat.asp.writer;
 
-import de.dhbwstuttgart.sat.asp.writer.model.ASPStatement;
+import java.util.ArrayList;
-
+import java.util.Collection;
 import java.util.HashSet;
+import java.util.List;
 
 public class ASPWriter {
 
@@ -19,4 +20,8 @@ public class ASPWriter {
         }
         return ret;
     }
+
+    public void addAll(Collection<ASPStatement> aspStatements) {
+        content.addAll(aspStatements);
+    }
 }

src/de/dhbwstuttgart/sat/asp/writer/model/ASPFCType.java

@@ -1,14 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-import de.dhbwstuttgart.sat.asp.writer.ASPWriter;
-
-public class ASPFCType extends ASPRefType {
-    public ASPFCType(ASPRefType refType){
-        super(refType.name, refType.params);
-    }
-
-    public String toString(){
-        return ASPRule.ASP_FCTYPE + "(" + name +"," + params.name + ")";
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPGenericType.java

@@ -1,25 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-
-public class ASPGenericType implements ASPType{
-    private final String name;
-
-    public ASPGenericType(String name){
-        this.name = name;
-    }
-
-    public String toString(){
-        return ASPRule.ASP_GENERIC_TYPE_NAME + "(" + name + ")";
-    }
-
-    @Override
-    public String toASP() {
-        return toString();
-    }
-
-    @Override
-    public String getPointer() {
-        return name;
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPPair.java

@@ -1,25 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.writer.ASPWriter;
-
-public abstract class ASPPair {
-    public final ASPType leftSide;
-    public final ASPType rightSide;
-
-    public ASPPair(ASPType ls, ASPType rs, ASPWriter writer){
-        this.leftSide = ls;
-        this.rightSide = rs;
-        writer.add(new ASPStatement(ls.toASP()));
-        writer.add(new ASPStatement(rs.toASP()));
-    }
-
-    public String toASP(){
-        return this.getRuleName() + "(" + leftSide.getPointer() + ","+ rightSide.getPointer() + ")";
-    }
-
-    public String toString(){
-        return toASP();
-    }
-
-    protected abstract String getRuleName();
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPPairEquals.java

@@ -1,15 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-import de.dhbwstuttgart.sat.asp.writer.ASPWriter;
-
-public class ASPPairEquals extends ASPPair{
-    public ASPPairEquals(ASPType ls, ASPType rs, ASPWriter writer){
-        super(ls, rs, writer);
-    }
-
-    @Override
-    protected String getRuleName() {
-        return ASPRule.ASP_PAIR_EQUALS_NAME.toString();
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPPairSmaller.java

@@ -1,17 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-import de.dhbwstuttgart.sat.asp.writer.ASPWriter;
-
-import java.util.Map;
-
-public class ASPPairSmaller extends ASPPair{
-    public ASPPairSmaller(ASPFCType ls, ASPFCType rs, ASPWriter writer){
-        super(ls, rs, writer);
-    }
-
-    @Override
-    protected String getRuleName() {
-        return ASPRule.ASP_PAIR_SMALLER_NAME.toString();
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPPairSmallerDot.java

@@ -1,15 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-import de.dhbwstuttgart.sat.asp.writer.ASPWriter;
-
-public class ASPPairSmallerDot extends ASPPair{
-    public ASPPairSmallerDot(ASPType ls, ASPType rs, ASPWriter writer){
-        super(ls, rs, writer);
-    }
-
-    @Override
-    protected String getRuleName() {
-        return ASPRule.ASP_PAIR_SMALLER_DOT_NAME.toString();
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPParameterList.java

@@ -1,45 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-import de.dhbwstuttgart.sat.asp.writer.ASPGenerator;
-import de.dhbwstuttgart.sat.asp.writer.ASPWriter;
-import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
-
-import java.util.Iterator;
-import java.util.List;
-
-public class ASPParameterList {
-    public final String name;
-    private final List<ASPType> types;
-
-    public ASPParameterList(List<ASPType> types, ASPWriter writer){
-        int paramNum = 0;
-        this.types = types;
-        if(types.size() == 0){
-            name = ASPRule.ASP_PARAMLIST_END_POINTER.toString();
-        }else{
-            name = newName();
-            String nextPointer = name;
-            Iterator<ASPType> it = types.iterator();
-            while(it.hasNext()){
-                ASPType t = it.next();
-                String param = nextPointer + "," + t.toString() + ",";
-                nextPointer = newName();
-                if(! it.hasNext())nextPointer = ASPRule.ASP_PARAMLIST_END_POINTER.toString();
-                param += nextPointer;
-                writer.add(new ASPStatement(ASPRule.ASP_PARAMLIST_NAME + "(" + param + ")"));
-                writer.add(new ASPStatement(ASPRule.ASP_PARAMLISTNUMERATION_NAME + "(" + name + "," +t + "," + paramNum + ")"));
-                paramNum++;
-                //paramDefinitions.add(new ASPStatement(ASP_PARAMLIST_NAME + "(" + param + ")"));
-            }
-        }
-    }
-
-    private String newName() {
-        return ASPGenerator.toConstant(NameGenerator.makeNewName());
-    }
-
-    public String toString(){
-        return name;
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPRefType.java

@@ -1,31 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-import de.dhbwstuttgart.sat.asp.model.ASPRule;
-
-public class ASPRefType implements ASPType {
-    protected final ASPParameterList params;
-    protected final String name;
-
-    public ASPRefType(String name, ASPParameterList params){
-        this.name = name;
-        this.params = params;
-    }
-
-    public ASPParameterList getParams() {
-        return params;
-    }
-
-    public String toString(){
-        return ASPRule.ASP_TYPE + "(" + name +"," + params.name + ")";
-    }
-
-    @Override
-    public String toASP() {
-        return toString();
-    }
-
-    @Override
-    public String getPointer() {
-        return name;
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPType.java

@@ -1,7 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-public interface ASPType {
-    String toASP();
-
-    String getPointer();
-}

src/de/dhbwstuttgart/sat/asp/writer/model/ASPTypeVar.java

@@ -1,24 +0,0 @@
-package de.dhbwstuttgart.sat.asp.writer.model;
-
-public class ASPTypeVar implements ASPType{
-    private final String name;
-
-    public ASPTypeVar(String name){
-        this.name = name;
-    }
-
-    @Override
-    public String toString() {
-        return "typeVar("+ name +")";
-    }
-
-    @Override
-    public String toASP() {
-        return toString();
-    }
-
-    @Override
-    public String getPointer() {
-        return name;
-    }
-}

src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

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

src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java

@@ -12,7 +12,9 @@ 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;
 
 /**
@@ -26,12 +28,13 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   private GenericDeclarationList genericClassParameters;
   private RefType superClass;
   protected boolean isInterface;
-  private List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces;
+  private List<RefType> implementedInterfaces;
   private List<Constructor> constructors;
 
   public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters,
-                          RefType superClass, Boolean isInterface, List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces, Token offset){
+                          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;
@@ -101,4 +104,8 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   public void accept(ASTVisitor visitor) {
     visitor.visit(this);
   }
+
+  public Collection<RefType> getSuperInterfaces() {
+    return implementedInterfaces;
+  }
 }

src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java

@@ -1,7 +1,5 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
 import org.antlr.v4.runtime.Token;
@@ -26,9 +24,9 @@ public class GenericTypeVar extends SyntaxTreeNode
      */
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds=new ArrayList<RefTypeOrTPHOrWildcardOrGeneric>();
 	private Token endOffset;
-    private GenericTypeName name;
+    private String name;
 
-    public GenericTypeVar(GenericTypeName s, List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds, Token offset, Token endOffset)
+    public GenericTypeVar(String s, List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds, Token offset, Token endOffset)
     {
         super(offset);
         name = s;
@@ -50,18 +48,15 @@ public class GenericTypeVar extends SyntaxTreeNode
         return "BoGTV " + this.name;
     }
 
-    public GenericTypeName getName() {
+    public String getName(){
-        return name;
-    }
-
-    public String getParsedName(){
         return name.toString();
     }
 
+    /*
     public JavaClassName definingClass(){
         return name.getParentClass();
     }
-
+*/
     @Override
     public void accept(ASTVisitor visitor) {
         visitor.visit(this);

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

@@ -8,7 +8,6 @@ import java.util.List;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.Field;
@@ -18,6 +17,7 @@ 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,25 +38,28 @@ public class ASTFactory {
 			methoden.add(createMethod(method, jreClass));
 		}
 		List<Field> felder = new ArrayList<>();
-		for(java.lang.reflect.Field field : jreClass.getFields()){
+		for(java.lang.reflect.Field field : jreClass.getDeclaredFields()){
 			felder.add(createField(field, name));
 		}
 		int modifier = jreClass.getModifiers();
 		boolean isInterface = jreClass.isInterface();
+		//see: https://stackoverflow.com/questions/9934774/getting-generic-parameter-from-supertype-class
+		ParameterizedType parameterSuperClass = null;
+		Type tempSuperClass = jreClass.getGenericSuperclass();
+		if(tempSuperClass != null && tempSuperClass instanceof ParameterizedType)
+			parameterSuperClass = (ParameterizedType) tempSuperClass;
 		java.lang.Class superjreClass = jreClass.getSuperclass();
 		RefType superClass;
-		if(superjreClass != null){
+		if(parameterSuperClass != null){
-			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+			superClass = (RefType) createType(parameterSuperClass);
-			for(TypeVariable tv : superjreClass.getTypeParameters()){
+		}else if(superjreClass != null){
-				params.add(new GenericRefType(new GenericTypeName(new GenericContext( name, null),tv.getName()), new NullToken()));
+			superClass = (RefType) createType(superjreClass);
-			}
-			superClass = new RefType(new JavaClassName(superjreClass.getName()), params, new NullToken());
 		}else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!)
-			superClass = (RefType) createType(java.lang.Object.class, name, "");
+			superClass = (RefType) createType(java.lang.Object.class);
 		}
 		List<RefType> implementedInterfaces = new ArrayList<>();
-		for(java.lang.Class jreInterface : jreClass.getInterfaces()){
+		for(Type jreInterface : jreClass.getGenericInterfaces()){
-			implementedInterfaces.add((RefType) createType(jreInterface, name, ""));
+			implementedInterfaces.add((RefType) createType(jreInterface));
 		}
         GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null);
 
@@ -66,17 +69,24 @@ public class ASTFactory {
 	}
 
 	private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
-		return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
+		return new Field(field.getName(), createType(field.getType()), field.getModifiers(), new NullToken());
 	}
 
+	//private static RefType createType(Class classType) {
+	//	return createClass(classType).getType();
+	//}
+
 	private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
 		String name = constructor.getName();
-		RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name);
+		RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass);
 		Parameter[] jreParams = constructor.getParameters();
+		Type[] jreGenericParams = constructor.getGenericParameterTypes();
 		List<FormalParameter> params = new ArrayList<>();
-		for(Parameter jreParam : jreParams){
+		int i = 0;
-			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name);
+		for(Type jreParam : jreGenericParams){
-			params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken()));
+			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam);
+			params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken()));
+			i++;
 		}
 		ParameterList parameterList = new ParameterList(params, new NullToken());
 		Block block = new Block(new ArrayList<Statement>(), new NullToken());
@@ -91,19 +101,24 @@ public class ASTFactory {
 		return new de.dhbwstuttgart.syntaxtree.Constructor(modifier, name,returnType, parameterList, block, gtvDeclarations, offset, new ArrayList<>());
 	}
 
-	//private static RefType createType(Class classType) {
-	//	return createClass(classType).getType();
-	//}
-
 	public static Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){
 		String name = jreMethod.getName();
 		RefTypeOrTPHOrWildcardOrGeneric returnType;
-			returnType = createType(jreMethod.getReturnType(),new JavaClassName(inClass.getName()), name);
+		Type jreRetType;
+		if(jreMethod.getGenericReturnType()!=null){
+			jreRetType = jreMethod.getGenericReturnType();
+		}else{
+			jreRetType = jreMethod.getReturnType();
+		}
+			returnType = createType(jreRetType);
 		Parameter[] jreParams = jreMethod.getParameters();
+		Type[] jreGenericParams = jreMethod.getGenericParameterTypes();
 		List<FormalParameter> params = new ArrayList<>();
-		for(Parameter jreParam : jreParams){
+		int i = 0;
-			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name);
+		for(Type jreParam : jreGenericParams){
-			params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken()));
+			RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam);
+			params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken()));
+			i++;
 		}
 		ParameterList parameterList = new ParameterList(params, new NullToken());
 		Block block = new Block(new ArrayList<Statement>(), new NullToken());
@@ -122,18 +137,7 @@ 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")){
@@ -153,20 +157,34 @@ public class ASTFactory {
 		}else{
 			if(type instanceof TypeVariable){
 				//GTVDeclarationContext via "(TypeVariable) type).getGenericDeclaration()"
-				return new GenericRefType(
+				return new GenericRefType(type.getTypeName(), new NullToken());
-						new GenericTypeName(new GenericContext(parentClass, parentMethod),type.getTypeName()),
-						new NullToken());
 			}
 			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
 			if(type instanceof ParameterizedType){
 				for(Type t : ((ParameterizedType)type).getActualTypeArguments()){
-					params.add(createType(t, parentClass, parentMethod));
+					params.add(createType(t));
 				}
 			}
-			RefType ret = new RefType(new JavaClassName(type.getTypeName()), params, new NullToken());
+			String name = type.getTypeName();
+			if(name.contains("<")){ //Komischer fix. Type von Generischen Typen kann die Generics im Namen enthalten Type<A>
+				//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;
 			}
 		}
+	}
 
 	public static de.dhbwstuttgart.syntaxtree.GenericTypeVar createGeneric(TypeVariable jreTypeVar, String jreTVName, Class context, String parentMethod){
 		JavaClassName parentClass = new JavaClassName(context.getName());
@@ -174,12 +192,10 @@ 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, parentClass, parentMethod));
+				genericBounds.add((RefType) createType(bound));
 			}
 		}
-		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(
+		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken());
-				new GenericTypeName(new GenericContext(parentClass, parentMethod), jreTVName)
-				, genericBounds, new NullToken(), new NullToken());
 	}
 
 	public static ClassOrInterface createObjectClass() {

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

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
 import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.exceptions.DebugException;
@@ -8,8 +10,9 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.sat.asp.model.ASPRule;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.syntaxtree.type.WildcardType;
@@ -35,7 +38,7 @@ public class UnifyTypeFactory {
         Generell dürfen sie immer die gleichen Namen haben.
         TODO: die transitive Hülle bilden
          */
-        return new FiniteClosure(FCGenerator.toFC(fromClasses));
+        return new FiniteClosure(FCGenerator.toUnifyFC(fromClasses));
     }
 
     public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr){
@@ -74,6 +77,16 @@ public class UnifyTypeFactory {
     }
 
     public static UnifyType convert(RefType t){
+        //Check if it is a FunN Type:
+        Pattern p = Pattern.compile("Fun(\\d+)");
+        Matcher m = p.matcher(t.getName().toString());
+        boolean b = m.matches();
+        if(b){
+            Integer N = Integer.valueOf(m.group(1));
+            if((N + 1) == t.getParaList().size()){
+                return convert(new FunN(t.getParaList()));
+            }
+        }
         UnifyType ret;
         if(t.getParaList() != null && t.getParaList().size() > 0){
             List<UnifyType> params = new ArrayList<>();
@@ -129,10 +142,13 @@ public class UnifyTypeFactory {
             UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
-        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
+        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
             UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
+        }else if(p.GetOperator().equals(PairOperator.SMALLER)){
+            return generateSmallerPair(UnifyTypeFactory.convert(p.TA1),
+                    UnifyTypeFactory.convert(p.TA2));
         }else            throw new NotImplementedException();
     }
 

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

@@ -13,16 +13,17 @@ public class BinaryExpr extends Expression
     }
 
     public enum Operator{
-        ADD,
+        ADD, // +
-        SUB,
+        SUB, // -
-        MUL,
+        MUL, // *
-        AND,
+        MOD, // Modulo Operator %
-        OR,
+        AND, // &&
-        DIV,
+        OR,  // ||
-        LESSTHAN,
+        DIV, // /
-        BIGGERTHAN,
+        LESSTHAN, // <
-        LESSEQUAL,
+        BIGGERTHAN, // >
-        BIGGEREQUAL
+        LESSEQUAL, // <=
+        BIGGEREQUAL // >=
     }
 
     public final Operator operation;

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

@@ -34,6 +34,10 @@ 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/GenericRefType.java

@@ -1,25 +1,19 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 import org.antlr.v4.runtime.Token;
 
 public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
 {
-    private GenericTypeName name;
+    private String name;
 
-    public GenericRefType(GenericTypeName name, Token offset)
+    public GenericRefType(String name, Token offset)
     {
         super(offset);
         this.name = name;
     }
 
-    public GenericTypeName getName(){
-        return name;
-    }
-
     public String getParsedName(){
         return name.toString();
     }

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

@@ -30,11 +30,16 @@ public class SuperWildcardType extends WildcardType{
 	* Beispiel: ? super Integer.
 	* Integer wird zurückgegeben.
 	*/
-	public RefTypeOrTPHOrWildcardOrGeneric get_SuperType()
+	public RefTypeOrTPHOrWildcardOrGeneric getInnerType()
 	{
 		return this.innerType;
 	}
 
+	@Override
+	public String toString() {
+		return "? super "+innerType.toString();
+	}
+
 	@Override
 	public boolean isExtends() {
 		return false;

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.visual;
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -171,7 +170,7 @@ public class OutputGenerator implements ASTVisitor{
 
     @Override
     public void visit(GenericRefType genericRefType) {
-        out.append(genericRefType.getName().toString());
+        out.append(genericRefType.getParsedName().toString());
     }
 
     @Override

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

@@ -0,0 +1,34 @@
+package de.dhbwstuttgart.syntaxtree.visual;
+
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.typeinference.result.*;
+
+public class ResultSetOutputGenerator extends OutputGenerator implements ResultSetVisitor{
+
+    public ResultSetOutputGenerator(StringBuilder out) {
+        super(out);
+    }
+
+    @Override
+    public void visit(PairTPHsmallerTPH p) {
+        print(p, "<");
+    }
+
+    @Override
+    public void visit(PairTPHequalRefTypeOrWildcardType p) {
+        print(p, "=.");
+    }
+
+    @Override
+    public void visit(PairTPHEqualTPH p) {
+        print(p, "=.");
+    }
+
+    private void print(ResultPair p , String operator){
+        out.append("(");
+        p.getLeft().accept((ResultSetVisitor) this);
+        out.append(" "+operator+" ");
+        p.getRight().accept((ResultSetVisitor) this);
+        out.append(")");
+    }
+}

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

@@ -0,0 +1,20 @@
+package de.dhbwstuttgart.syntaxtree.visual;
+
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.util.Set;
+
+public class ResultSetPrinter {
+
+    public static String print(ResultSet toPrint){
+        StringBuilder output = new StringBuilder();
+        for(ResultPair p : toPrint.results){
+            p.accept(new ResultSetOutputGenerator(output));
+            output.append("\n");
+        }
+        return output.toString();
+    }
+
+}

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

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

@@ -126,7 +126,7 @@ class TypeToInsertString implements ResultSetVisitor{
 
     @Override
     public void visit(GenericRefType genericRefType) {
-        insert += genericRefType.getName();
+        insert += genericRefType.getParsedName();
     }
 
     @Override

src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java

@@ -59,13 +59,11 @@ class TypeInsertPlacerClass extends AbstractASTWalker{
     }
 
     @Override
-    public void visit(ParameterList params) {
+    public void visit(FormalParameter param) {
-        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/FieldAssumption.java

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typeinference.assumptions;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
@@ -25,7 +26,7 @@ public class FieldAssumption extends Assumption{
     }
 
     public RefTypeOrTPHOrWildcardOrGeneric getReceiverType(GenericsResolver resolver) {
-
+        //TODO
-        return null;
+        throw new NotImplementedException();
     }
 }

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

@@ -1,8 +1,6 @@
 package de.dhbwstuttgart.typeinference.assumptions;
 
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
@@ -29,8 +27,7 @@ public class FunNClass extends ClassOrInterface {
     private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
         List<GenericTypeVar> generics = new ArrayList<>();
         for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
-            generics.add(new GenericTypeVar(new GenericTypeName(new GenericContext(
+            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
-                    new JavaClassName("Fun"+(funNParams.size()-1)), null), NameGenerator.makeNewName()),
                     new ArrayList<>(), new NullToken(), new NullToken()));
         }
         return new GenericDeclarationList(generics, new NullToken());

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

@@ -3,9 +3,7 @@ package de.dhbwstuttgart.typeinference.assumptions;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
-import de.dhbwstuttgart.syntaxtree.statement.Assign;
 import de.dhbwstuttgart.syntaxtree.type.FunN;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -14,7 +12,6 @@ import de.dhbwstuttgart.typeinference.constraints.GenericsResolver;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 
 public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
@@ -40,16 +37,14 @@ public class MethodAssumption extends Assumption{
         return receiver;
     }
 
-    public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
+    public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) {
-        return retType;
+        return resolver.resolve(retType);
     }
 
     public List<RefTypeOrTPHOrWildcardOrGeneric> getArgTypes(GenericsResolver resolver) {
         List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
         for(RefTypeOrTPHOrWildcardOrGeneric param : params){
-            if(param instanceof GenericRefType){ //Generics in den Assumptions müssen umgewandelt werden.
+            param = resolver.resolve(param);
-                param = resolver.resolve((GenericRefType) param);
-            }
             ret.add(param);
         }
         return ret;

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

@@ -52,4 +52,12 @@ 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/result/PairTPHEqualTPH.java

@@ -9,7 +9,7 @@ public class PairTPHEqualTPH extends ResultPair<TypePlaceholder, TypePlaceholder
     }
 
     @Override
-    public void accept(ResultSetVisitor visitor) {
+    public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);
     }
 }

src/de/dhbwstuttgart/typeinference/result/PairTPHequalRefTypeOrWildcardType.java

@@ -18,7 +18,7 @@ public class PairTPHequalRefTypeOrWildcardType extends ResultPair{
     }
 
     @Override
-    public void accept(ResultSetVisitor visitor) {
+    public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);
     }
 }

src/de/dhbwstuttgart/typeinference/result/PairTPHsmallerTPH.java

@@ -17,7 +17,7 @@ public class PairTPHsmallerTPH extends ResultPair{
     }
 
     @Override
-    public void accept(ResultSetVisitor visitor) {
+    public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);
     }
 }

src/de/dhbwstuttgart/typeinference/result/ResultPair.java

@@ -9,7 +9,7 @@ public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B ext
     private final A left;
     private final B right;
 
-    public abstract void accept(ResultSetVisitor visitor);
+    public abstract void accept(ResultPairVisitor visitor);
 
     public ResultPair(A left, B right){
         this.left = left;

src/de/dhbwstuttgart/typeinference/result/ResultPairVisitor.java

@@ -0,0 +1,7 @@
+package de.dhbwstuttgart.typeinference.result;
+
+public interface ResultPairVisitor {
+    void visit(PairTPHsmallerTPH p);
+    void visit(PairTPHequalRefTypeOrWildcardType p);
+    void visit(PairTPHEqualTPH p);
+}

src/de/dhbwstuttgart/typeinference/result/ResultSetVisitor.java

@@ -2,10 +2,7 @@ package de.dhbwstuttgart.typeinference.result;
 
 import de.dhbwstuttgart.syntaxtree.type.*;
 
-public interface ResultSetVisitor {
+public interface ResultSetVisitor extends ResultPairVisitor{
-    void visit(PairTPHsmallerTPH p);
-    void visit(PairTPHequalRefTypeOrWildcardType p);
-    void visit(PairTPHEqualTPH p);
 
     void visit(RefType refType);
 

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

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