mapFC -> pi

*

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).

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.BoolLiteral</li>
@@ -253,7 +253,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.CharLiteral</li>
@@ -253,7 +253,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.DoubleLiteral</li>
@@ -263,7 +263,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.FloatLiteral</li>
@@ -263,7 +263,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.NumberLiteral</li>
@@ -263,7 +263,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/Literal.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.literal.Literal</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.Literal</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.LongLiteral</li>
@@ -263,7 +263,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/NegativeExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.NegativeExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.NegativeExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/NotExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.NotExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.NotExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/Null.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.Null</li>
@@ -245,7 +245,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/PositivExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.PositivExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.PositivExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/PostDecExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.PostDecExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostDecExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/PostIncExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.PostIncExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostIncExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/PreDecExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.PreDecExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreDecExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/PreIncExpr.html

@@ -115,7 +115,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.UnaryExpr</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.statement.PreIncExpr</li>
+<li>de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreIncExpr</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Expr.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Expr</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.literal.Literal</a></li>
+<li><a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">de.dhbwstuttgart.syntaxtree.statement.Literal</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.statement.literal.StringLiteral</li>
@@ -253,7 +253,7 @@ extends <a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html"
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.literal.Literal">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.statement.Literal">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.statement.<a href="../../../../de/dhbwstuttgart/syntaxtree/statement/Literal.html" title="class in de.dhbwstuttgart.syntaxtree.statement">Literal</a></h3>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/Literal.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.literal.Literal</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.Literal</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,7 +70,7 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.literal.Literal" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.Literal</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.Literal" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.Literal</h2>
 </div>
 <div class="classUseContainer">
 <ul class="blockList">

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/NegativeExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.NegativeExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.NegativeExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.NegativeExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.NegativeExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.NegativeExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.NegativeExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.NegativeExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.NegativeExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/NotExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.NotExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.NotExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.NotExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.NotExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.NotExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.NotExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.NotExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.NotExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/PositivExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.PositivExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PositivExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.PositivExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PositivExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PositivExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PositivExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.PositivExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.PositivExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/PostDecExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.PostDecExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostDecExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.PostDecExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PostDecExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostDecExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PostDecExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.PostDecExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostDecExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/PostIncExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.PostIncExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostIncExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.PostIncExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PostIncExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostIncExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PostIncExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.PostIncExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.PostIncExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/PreDecExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.PreDecExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreDecExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.PreDecExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PreDecExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreDecExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PreDecExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.PreDecExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreDecExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/statement/class-use/PreIncExpr.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.PreIncExpr</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreIncExpr</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,9 +70,9 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.PreIncExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PreIncExpr</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreIncExpr" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.statement.PreIncExpr</h2>
 </div>
-<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.PreIncExpr</div>
+<div class="classUseContainer">No usage of de.dhbwstuttgart.syntaxtree.statement.javaInternal.PreIncExpr</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
 <div class="bottomNav"><a name="navbar.bottom">
 <!--   -->

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

@@ -22,6 +22,11 @@
    	 <artifactId>antlr4</artifactId>
    	 <version>4.7</version>
 	</dependency>
+<dependency>
+    <groupId>commons-io</groupId>
+    <artifactId>commons-io</artifactId>
+    <version>2.6</version>
+</dependency>
 <dependency>
 <groupId>com.google.guava</groupId>
     <artifactId>guava</artifactId>
@@ -37,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>
@@ -65,9 +76,33 @@
 			   <argument>de.dhbwstuttgart.parser.antlr</argument>
 	  	    </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>8</source>
+                <target>8</target>
+            </configuration>
+        </plugin>
     </plugins>
        </build>
    <properties>

src/de/dhbwstuttgart/bytecode/BytecodeGen.java

@@ -1,54 +1,73 @@
 package de.dhbwstuttgart.bytecode;
 
-import java.awt.List;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.FieldVisitor;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
+import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.signature.Signature;
+import de.dhbwstuttgart.bytecode.signature.TypeToString;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class BytecodeGen implements ASTVisitor {
 	
 	ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
-//	String methDesc;
 	
 	String type;
 	
 	String className;
+	private boolean isInterface;
+	private ResultSet resultSet;
+	private int indexOfFirstParam = 0;
 	
 	// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
-	HashMap<String, Integer> paramsAndLocals;// = new HashMap<>();
+	HashMap<String, Integer> paramsAndLocals = new HashMap<>();
+	// stores generics and their bounds of class
+	HashMap<String, String> genericsAndBounds = new HashMap<>();
+	// stores generics and their bounds of method
+	HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
+	
+	HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
 	byte[] bytecode;
 	HashMap<String,byte[]> classFiles;
 	
-	public BytecodeGen(HashMap<String,byte[]> classFiles) {
+	public BytecodeGen(HashMap<String,byte[]> classFiles, ResultSet resultSet) {
 		this.classFiles = classFiles;
-		paramsAndLocals = new HashMap<>();
+		this.resultSet = resultSet;
 	}
 	
 	@Override
 	public void visit(SourceFile sourceFile) {
 		for(ClassOrInterface cl : sourceFile.getClasses()) {
-			BytecodeGen classGen = new BytecodeGen(classFiles);
+			System.out.println("in Class: " + cl.getClassName().toString());
+			BytecodeGen classGen = new BytecodeGen(classFiles, resultSet);
 			cl.accept(classGen);
 			classGen.writeClass(cl.getClassName().toString());
 		}
 	}
-
+	
+	/**
+	 * Associates the bytecode of the class that was build with the classWriter {@link #cw}
+	 * with the class name in the map {@link #classFiles}
+	 * 
+	 * @param name name of the class with which the the bytecode is to be associated
+	 */
 	private void writeClass(String name) {
 		bytecode = cw.toByteArray();
 		classFiles.put(name, bytecode);
@@ -58,17 +77,32 @@ public class BytecodeGen implements ASTVisitor {
 	public HashMap<String,byte[]> getClassFiles() {
 		return classFiles;
 	}
+	
+	
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
 		className = classOrInterface.getClassName().toString();
-		// access flages??
-		cw.visit(Opcodes.V1_8, classOrInterface.getModifiers()+Opcodes.ACC_SUPER, classOrInterface.getClassName().toString()
-				, null, classOrInterface.getSuperClass().toString(), null);
+		
+		cw.visitSource(className +".jav", null);
+		
+		isInterface = (classOrInterface.getModifiers()&512)==512;
+
+		int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
+		String sig = null;
+		/* if class has generics then creates signature
+		 * Signature looks like:
+		 * <E:Ljava/...>Superclass 
+		 */
+		if(classOrInterface.getGenerics().iterator().hasNext()) {
+			Signature signature = new Signature(classOrInterface, genericsAndBounds);
+			sig = signature.toString();
+		}
+		// needs implemented Interfaces?
+		cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
+				, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
 		
 		// for each field in the class
 		for(Field f : classOrInterface.getFieldDecl()) {
-			System.out.println("get Fields");
-			System.out.println(f.getName());
 			f.accept(this);
 		}
 		
@@ -79,42 +113,98 @@ public class BytecodeGen implements ASTVisitor {
 		for(Method m : classOrInterface.getMethods()) {
 			m.accept(this);
 		}
-		cw.visitSource(classOrInterface.getClassName().toString()+".jav", null);
 	}
-	
+
 	@Override
 	public void visit(Constructor field) {
-		Descriptor desc = new Descriptor(field);
-		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc.getDesc(), null, null); 
+		field.getParameterList().accept(this);
+		
+		String desc = null;
+		boolean hasGen = false;
+		
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+			if(genericsAndBounds.containsKey(typeOfParam)) {
+				hasGen = true;
+				break;
+			}
+		}
+		String sig = null;
+		if(hasGen) {
+			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes);
+			sig = signature.toString();
+		}
+		NormalConstructor constructor = new NormalConstructor(field,genericsAndBounds,hasGen);
+		desc = constructor.accept(new DescriptorToString(resultSet));
+		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
 		mv.visitCode();		
-		System.out.println("-----Constructor-----");
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,field, mv,paramsAndLocals,desc.getDesc(),cw);
-
-		mv.visitInsn(Opcodes.RETURN);
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,field, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles);
+		if(!field.getParameterList().iterator().hasNext()) {
+			mv.visitInsn(Opcodes.RETURN);
+		}
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
 
 	@Override
 	public void visit(Method method) {
+		// TODO: check if the method is static => if static then the first param will be stored in pos 0
+		// else it will be stored in pos 1 and this will be stored in pos 0
 		method.getParameterList().accept(this);
-		Descriptor methDesc = new Descriptor(method);
-		System.out.println("-----Method-----");
-		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, method.getName(), methDesc.getDesc(), null, null); 
+
+		String methDesc = null;
+		
+		// Method getModifiers() ?
+		int acc = isInterface?Opcodes.ACC_ABSTRACT:method.modifier;
+		
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor()));
+		if(!hasGenInParameterList) {
+			for(String paramName : methodParamsAndTypes.keySet()) {
+				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+				if(genericsAndBounds.containsKey(typeOfParam)) {
+					hasGenInParameterList = true;
+					break;
+				}
+			}
+		}
+		
+		//TODO: Test if the return-type or any of the parameter is a parameterized type. (VP)
+		//than create the descriptor with the new syntax.
+		
+		String sig = null;
+		boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
+		
+		/* if method has generics or return type is TPH, create signature */
+		if(hasGen||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
+			// resultset hier zum testen 
+			Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet);
+			sig = signature.toString();
+		}
+		System.out.println(sig);
+		NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
+		methDesc = meth.accept(new DescriptorToString(resultSet));
+		System.out.println(methDesc);
+		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
+
 		mv.visitCode();		
 		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,method, mv,paramsAndLocals,methDesc.getDesc(),cw);
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,method, mv,paramsAndLocals,cw,
+				genericsAndBounds,genericsAndBounds,isInterface,classFiles);
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
 	
 	@Override
 	public void visit(ParameterList formalParameters) {
+		paramsAndLocals = new HashMap<>();
+		methodParamsAndTypes = new HashMap<>();
 		Iterator<FormalParameter> itr = formalParameters.iterator();
 		int i = 1;
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
 			paramsAndLocals.put(fp.getName(), i);
+			methodParamsAndTypes.put(fp.getName(), resultSet.resolveType(fp.getType()).resolvedType);
 			fp.accept(this);
 			i++;
 		}
@@ -157,7 +247,6 @@ public class BytecodeGen implements ASTVisitor {
 	// ??
 	@Override
 	public void visit(FieldVar fieldVar) {
-		System.out.println("in fieldvar");
 //		cw.newField(fieldVar.receiver.toString(), fieldVar.fieldVarName.toString(), fieldVar.getType().toString());
 		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, fieldVar.fieldVarName, "L"+fieldVar.getType()+";", null, null);
 		fv.visitEnd();
@@ -166,7 +255,6 @@ public class BytecodeGen implements ASTVisitor {
 	// access flages?? modifiers
 	@Override
 	public void visit(Field field) {
-		System.out.println("in field");
 		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, field.getName(), "L"+field.getType().toString().replace(".", "/")+";", null, null);
 		fv.visitEnd();
 	}
@@ -184,9 +272,8 @@ public class BytecodeGen implements ASTVisitor {
 	}
 
 	@Override
-	public void visit(Binary binary) {
-		// TODO Auto-generated method stub
-		
+	public void visit(BinaryExpr binary) {
+
 	}
 
 	@Override
@@ -285,12 +372,6 @@ public class BytecodeGen implements ASTVisitor {
 		
 	}
 
-	@Override
-	public void visit(UnaryPlus unaryPlus) {
-		// TODO Auto-generated method stub
-		
-	}
-
 	@Override
 	public void visit(WhileStmt whileStmt) {
 		// TODO Auto-generated method stub
@@ -303,11 +384,6 @@ public class BytecodeGen implements ASTVisitor {
 		
 	}
 
-	@Override
-	public void visit(Null aNull) {
-		// TODO Auto-generated method stub
-		
-	}
 	// ???
 	@Override
 	public void visit(Literal literal) {
@@ -356,4 +432,9 @@ public class BytecodeGen implements ASTVisitor {
 
 	}
 
+	@Override
+	public void visit(UnaryExpr unaryExpr) {
+		throw new NotImplementedException();
+	}
+
 }

src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java

@@ -1,82 +1,114 @@
 package de.dhbwstuttgart.bytecode;
 
-import java.io.PrintStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
 import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
-import java.security.GeneralSecurityException;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Handle;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.objectweb.asm.signature.SignatureVisitor;
+import org.objectweb.asm.signature.SignatureWriter;
 
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
+import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.signature.Signature;
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.bytecode.signature.TypeToString;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
+
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
+
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class BytecodeGenMethod implements StatementVisitor{
 	
 	private Method m;
 	private MethodVisitor mv;
 	private HashMap<String, Integer> paramsAndLocals = new HashMap<>(); 
-	private String desc;
 	private String className;
-	private int lamCounter;
+	private int lamCounter = -1;
 	private ClassWriter cw;
+	private ResultSet resultSet;
+	private boolean isInterface;
+	HashMap<String, String> genericsAndBoundsMethod;
+	private HashMap<String,String> genericsAndBounds;
+	private boolean isBinaryExp = false;
 	
 	//for tests **
 	private String fieldName;
 	private String fieldDesc;
 	private Expression rightSideTemp;
-	private String where;
+	private boolean isRightSideALambda = false;
+	private KindOfLambda kindOfLambda;
+	private HashMap<String, byte[]> classFiles;
 	
-	public BytecodeGenMethod(String className, Method m, MethodVisitor mv, HashMap<String, Integer> paramsAndLocals,
-			String desc, ClassWriter cw) {
-		
-		this.where = "NORMAL METHOD";
+	private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface = new ArrayList<>();;
+	
+	public BytecodeGenMethod(String className,ResultSet resultSet, Method m, MethodVisitor mv, 
+			HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod, 
+			HashMap<String,String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles) {
 		
 		this.className = className;
+		this.resultSet = resultSet;
 		this.m = m;
 		this.mv = mv;
 		this.paramsAndLocals = paramsAndLocals;
-		this.desc = desc;
 		this.cw = cw;
-		this.lamCounter = -1;
+		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.genericsAndBounds = genericsAndBounds;
+		this.isInterface = isInterface;
+		this.classFiles = classFiles;
 		
-		this.m.block.accept(this);
+		if(!isInterface)
+			this.m.block.accept(this);
 		
 	}
 	
-	public BytecodeGenMethod(LambdaExpression lambdaExpression, MethodVisitor mv, 
-			HashMap<String, Integer> paramsAndLocals, String desc) {
-		System.out.println("++++++IN LAMBDA -------");
-		
-		this.where = "&&&&&&&& LAMBDA METHOD";
+	public BytecodeGenMethod(LambdaExpression lambdaExpression,ResultSet resultSet ,MethodVisitor mv, 
+			 int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles) {
 		
+		this.resultSet = resultSet;
 		this.mv = mv;
-		this.paramsAndLocals = paramsAndLocals;
-		this.desc = desc;
-		
-		this.lamCounter = -1;
-		
+		this.isInterface = isInterface;
+		this.classFiles = classFiles;
+
+		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
+		int i = indexOfFirstParamLam;
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			this.paramsAndLocals.put(fp.getName(), i);
+			i++;
+		}
 		lambdaExpression.methodBody.accept(this);
 	}
 	
+	private String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
+		return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
+	}
+	
+	
 	@Override
 	public void visit(Block block) {
 		for(Statement stmt : block.getStatements()) {
-			System.out.println(where);
-			System.out.println("Stmt : " + stmt.toString());
+//			System.out.println(where);
 			stmt.accept(this);
-			System.out.println("--------------------------\n");
 		}
 	}
 	
@@ -84,75 +116,174 @@ public class BytecodeGenMethod implements StatementVisitor{
 	public void visit(SuperCall superCall) {
 		superCall.receiver.accept(this);
 		superCall.arglist.accept(this);
-//		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", superCall.name, desc,false);
-		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Object.class), superCall.name, desc,false);
+		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Object.class), superCall.name, "()V",isInterface);
 	}
 	
 	// ??
 	@Override
 	public void visit(LocalVar localVar) {
-		System.out.println("in Local Var");
+		mv.visitVarInsn(Opcodes.ALOAD, paramsAndLocals.get(localVar.name));
+		if(isBinaryExp) {
+			getVlaue(getResolvedType(localVar.getType()));
+		}
 	}
 	// ??
 	@Override
 	public void visit(LocalVarDecl localVarDecl) {
-//		Integer i;
-		paramsAndLocals.put(localVarDecl.getName(), paramsAndLocals.size()+1);
-		System.out.println("In localVarDecl");
+
 	}
 
 	@Override
 	public void visit(Assign assign) {
-		System.out.println("Assign : \nright = "+assign.rightSide + "\nLeft = " + assign.lefSide);
-		
-		if(assign.lefSide.getClass().equals(AssignToField.class)) {
-			// load_0, ldc or .. then putfield
-			this.rightSideTemp = assign.rightSide;
-			assign.lefSide.accept(this);
+		// if the right side is a lambda => the left side must be a functional interface
+		if(assign.rightSide instanceof LambdaExpression) {
+			isRightSideALambda = true;
 		}else {
-			assign.rightSide.accept(this);
-			assign.lefSide.accept(this);
+			isRightSideALambda = false;
 		}
 		
+		if(assign.rightSide instanceof BinaryExpr)
+			isBinaryExp = true;
 		
-		
+		if(assign.lefSide instanceof AssignToField) {
+			// load_0, ldc or .. then putfield
+			this.rightSideTemp = assign.rightSide;
+		}else {
+			assign.rightSide.accept(this);
+		}
+		if(isBinaryExp) {
+			doAssign(getResolvedType(assign.lefSide.getType()));
+			isBinaryExp = false;
+		}
+		assign.lefSide.accept(this);
 	}
 	
 	@Override
-	public void visit(Binary binary) {
-		System.out.println("++ In Binary: ");
+	public void visit(BinaryExpr binary) {
+		binary.lexpr.accept(this);
+		binary.rexpr.accept(this);
+		switch (binary.operation.toString()) {
+		case "ADD":
+			mv.visitInsn(Opcodes.IADD);
+			break;
+
+		default:
+			break;
+		}
+		
 	}
 	
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
-		System.out.println("\n++ In Lambda: ");
 		this.lamCounter++;
+		
+		Lambda lam = new Lambda(lambdaExpression);
+		String lamDesc = lam.accept(new DescriptorToString(resultSet));
 		//Call site, which, when invoked, returns an instance of the functional interface to which
 		//the lambda is being converted
 		MethodType mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class,
 						MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);
 				
+
 		Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", 
 				"metafactory", mt.toMethodDescriptorString(), false);
 		String methodName = "lambda$new$" + this.lamCounter;
-		// Type erasure
-		Type arg1 = Type.getMethodType("()V");
-		// real Type
-		Type arg3 = Type.getMethodType("()V");
-		Handle arg2 = new Handle(Opcodes.H_INVOKESTATIC, this.className, methodName, 
-				arg3.toString(),false);
-		mv.visitInvokeDynamicInsn("run", "()Ljava/lang/Runnable;", bootstrap, 
-				arg1, arg2,arg3);
-
-		MethodVisitor mvLambdaBody = cw.visitMethod(Opcodes.ACC_PRIVATE+ Opcodes.ACC_STATIC + Opcodes.ACC_SYNTHETIC, 
-				methodName, arg3.toString(), null, null);
-//		new BytecodeGenLambda(lambdaExpression, mvLambdaBody);
 		
-		new BytecodeGenMethod(lambdaExpression, mvLambdaBody, new HashMap<>(), arg3.toString());
+		// Für die Parameter-Typen und Return-Typ braucht man die Bounds (für die Typlöschung)
+		
+		String typeErasure = "(";
+		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
+		while(itr.hasNext()) {
+			itr.next();
+			typeErasure += "L"+Type.getInternalName(Object.class) + ";";
+		}
+		
+		typeErasure += ")L"+Type.getInternalName(Object.class) + ";";
+		// Type erasure
+		Type arg1 = Type.getMethodType(typeErasure);
+//		Type arg1 = Type.getMethodType(lamDesc);
+		// real Type
+		Type arg3 = Type.getMethodType(lamDesc);
+		
+		int staticOrSpecial=0;
+		int staticOrInstance=0;
+		int indexOfFirstParamLam = 0;
+		this.kindOfLambda = new KindOfLambda(lambdaExpression);
+
+		if(kindOfLambda.isInstanceCapturingLambda()) {
+			mv.visitVarInsn(Opcodes.ALOAD, 0);
+			staticOrSpecial = Opcodes.H_INVOKESPECIAL;
+			indexOfFirstParamLam = 1;
+		}else {
+			staticOrSpecial = Opcodes.H_INVOKESTATIC;
+			staticOrInstance = Opcodes.ACC_STATIC;
+		}
+		
+		// first check if capturing lambda then invokestatic or invokespecial
+		Handle arg2 = new Handle(staticOrSpecial, this.className, methodName, 
+				arg3.toString(),false);
+		// Descriptor of functional interface methode
+		SamMethod samMethod = new SamMethod(kindOfLambda.getArgumentList(), lambdaExpression.getType());
+		// Desc: (this/nothing)TargetType
+		String fiMethodDesc = samMethod.accept(new DescriptorToString(resultSet));
+		mv.visitInvokeDynamicInsn("apply", fiMethodDesc, bootstrap, arg1, arg2,arg3);
+		
+		MethodVisitor mvLambdaBody = cw.visitMethod(Opcodes.ACC_PRIVATE+ staticOrInstance + Opcodes.ACC_SYNTHETIC, 
+				methodName, arg3.toString(), null, null);
+
+		new BytecodeGenMethod(lambdaExpression,this.resultSet,mvLambdaBody,indexOfFirstParamLam,isInterface,
+				classFiles);
+		
 		mvLambdaBody.visitMaxs(0, 0);
 		mvLambdaBody.visitEnd();
+		cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup",
+				Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL);
+		
+//		generateBCForFunN(lambdaExpression,typeErasure);
 	}
 
+	private void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc) {
+		ClassWriter classWriter =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
+		
+		SignatureWriter methSig = new SignatureWriter();
+		
+		int numberOfParams = 0;
+		SignatureVisitor paramVisitor = methSig.visitParameterType();
+		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
+		while(itr.hasNext()) {
+			numberOfParams++;
+			// getBounds
+			paramVisitor.visitTypeVariable("T"+numberOfParams);
+			itr.next();
+		}
+		methSig.visitReturnType().visitTypeVariable("R");
+		// ")"+lam.getReturn.getBounds
+		Signature sig = new Signature(lambdaExpression,numberOfParams);
+		String name = "Fun"+numberOfParams;
+		classWriter.visit(Opcodes.V1_8, Opcodes.ACC_INTERFACE+Opcodes.ACC_ABSTRACT, name, 
+				sig.toString(), Type.getInternalName(Object.class), null);
+		MethodVisitor mvApply = classWriter.visitMethod(Opcodes.ACC_PUBLIC+Opcodes.ACC_ABSTRACT, "apply", 
+				methDesc, methSig.toString(), null);
+		mvApply.visitEnd();
+		writeClassFile(classWriter.toByteArray(),name);
+	}
+	
+	public void writeClassFile(byte[] bytecode, String name) {
+		FileOutputStream output;
+		try {
+			System.out.println("generating "+name+ ".class file...");
+			output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/examples/" +name+".class"));				
+			output.write(bytecode);
+			output.close();
+			System.out.println(name+".class file generated");
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+}
+
 	@Override
 	public void visit(CastExpr castExpr) {
 		// TODO Auto-generated method stub
@@ -167,15 +298,15 @@ public class BytecodeGenMethod implements StatementVisitor{
 
 	@Override
 	public void visit(FieldVar fieldVar) {
-		System.out.println("in fieldVar " + fieldVar.fieldVarName + " ** receiver: "+fieldVar.receiver);
 		
 		fieldName = fieldVar.fieldVarName;
-		fieldDesc = fieldVar.getType().toString();
+		fieldDesc = "L"+getResolvedType(fieldVar.getType())+";";
 		
 		fieldVar.receiver.accept(this);
 		// test (if)
 		if(!fieldVar.receiver.getClass().equals(StaticClassName.class)) {
-			mv.visitFieldInsn(Opcodes.GETFIELD,fieldVar.getType().toString(),fieldName ,fieldDesc);
+			mv.visitFieldInsn(Opcodes.GETFIELD,getResolvedType(fieldVar.receiver.getType()),
+					fieldName ,fieldDesc);
 		}
 		
 //		mv.visitFieldInsn(Opcodes.GETSTATIC, fieldVar.receiver.getType().toString().replace(".", "/"), 
@@ -190,7 +321,7 @@ public class BytecodeGenMethod implements StatementVisitor{
 
 	@Override
 	public void visit(IfStmt ifStmt) {
-		System.out.println("++ IF-Statment: ");
+		System.out.println("If");
 	}
 
 	@Override
@@ -201,31 +332,29 @@ public class BytecodeGenMethod implements StatementVisitor{
 
 	@Override
 	public void visit(MethodCall methodCall) {
-		System.out.println("	In Methodcall: (" +methodCall.name+")" );
-		System.out.print("		Method-Receiver: ");
-		if(methodCall.receiver instanceof ExpressionReceiver){
-			System.out.print(((ExpressionReceiver) methodCall.receiver).expr + "\n");
-		}else{
-			System.out.print(((StaticClassName) methodCall.receiver).getType().toString() + "\n");
-		}
-		
 		methodCall.receiver.accept(this);
 		methodCall.arglist.accept(this);
 		
-		Descriptor mDesc = new Descriptor(methodCall.arglist, methodCall.getType());
+		MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
+				genericsAndBoundsMethod,genericsAndBounds);
+		String mDesc = method.accept(new DescriptorToString(resultSet));
 		
-		mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, methodCall.receiver.getType().toString(),
-				methodCall.name, mDesc.getDesc(), false);
-		// test
-		if(!methodCall.getType().toString().equals("V")) {
-			mv.visitInsn(Opcodes.POP);
+		// is methodCall.receiver functional Interface)?
+		if(varsFunInterface.contains(methodCall.receiver.getType())) {
+			mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()), 
+					methodCall.name, mDesc, false);
+		}else {
+			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, getResolvedType(methodCall.receiver.getType()),
+					methodCall.name, mDesc, isInterface);
 		}
+		// test
+//		if(!methodCall.getType().toString().equals("V")) {
+//			mv.visitInsn(Opcodes.POP);
+//		}
 	}
 
 	@Override
 	public void visit(NewClass methodCall) {
-		System.out.println("In NewClass: ");
-		System.out.println("name: " + methodCall.name + " *** " + "Receiver: " + methodCall.receiver);
 		
 		mv.visitTypeInsn(Opcodes.NEW, methodCall.name.replace(".", "/"));
 		mv.visitInsn(Opcodes.DUP);
@@ -233,11 +362,11 @@ public class BytecodeGenMethod implements StatementVisitor{
 		methodCall.arglist.accept(this);
 		String d = "(";
 		for(Expression e : methodCall.arglist.getArguments()) {
-			d = d + "L"+e.getType().toString().replace(".", "/") + ";";
+			d = d + "L"+getResolvedType(e.getType()) + ";";
 		}
 		d += ")V";
 		
-		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, methodCall.name.replace(".", "/"), "<init>", d, false);
+		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, methodCall.name.replace(".", "/"), "<init>", d, isInterface);
 	}
 
 	@Override
@@ -248,13 +377,17 @@ public class BytecodeGenMethod implements StatementVisitor{
 
 	@Override
 	public void visit(ExpressionReceiver receiver) {
-		System.out.println("	in Receiver");
-		System.out.println("		expr : " + receiver.expr);
 		receiver.expr.accept(this);
 	}
 
+	@Override
+	public void visit(UnaryExpr unaryExpr) {
+		System.out.println(unaryExpr.operation.toString());
+	}
+
 	@Override
 	public void visit(Return aReturn) {
+		aReturn.retexpr.accept(this);
 		mv.visitInsn(Opcodes.ARETURN);
 	}
 
@@ -265,33 +398,26 @@ public class BytecodeGenMethod implements StatementVisitor{
 
 	@Override
 	public void visit(StaticClassName staticClassName) {
-		System.out.println("In StaticClassName: ");
 //		mv.visitMethodInsn(Opcodes.INVOKESTATIC, staticClassName.getType().toString().replace(".", "/"), 
 //				staticClassName.toString(), staticClassName.getType().toString(), false);
-		mv.visitFieldInsn(Opcodes.GETSTATIC, staticClassName.getType().toString().replace(".", "/"), 
+		mv.visitFieldInsn(Opcodes.GETSTATIC, getResolvedType(staticClassName.getType()), 
 				fieldName, fieldDesc);
 	}
 
 	@Override
 	public void visit(Super aSuper) {
-		System.out.println(">> In Super: ");
+
 	}
 
 	@Override
 	public void visit(This aThis) {
-		System.out.println("-> IN This");
 		mv.visitVarInsn(Opcodes.ALOAD, 0);
 	}
 
-	@Override
-	public void visit(UnaryPlus unaryPlus) {
-		System.out.println("++ In UnaryPlus: ");
-	}
-
 	@Override
 	public void visit(WhileStmt whileStmt) {
-		// TODO Auto-generated method stub
-		
+		whileStmt.expr.accept(this);
+		whileStmt.loopBlock.accept(this);
 	}
 
 	@Override
@@ -301,14 +427,203 @@ public class BytecodeGenMethod implements StatementVisitor{
 	}
 
 	@Override
-	public void visit(Null aNull) {
-		mv.visitInsn(Opcodes.ACONST_NULL);
+	public void visit(Literal literal) {
+		Object value = literal.value;
+		String typeOfLiteral = resultSet.resolveType(literal.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+		if(this.isBinaryExp) {
+			getVlaue(typeOfLiteral);
+		}else {
+			doAssign(typeOfLiteral, value);
+		}
+		
+		
+	}
+	
+	private void getVlaue(String typeOfLiteral) {
+		switch (typeOfLiteral) {
+		case "java/lang/String":
+			break;
+		case "java/lang/Boolean":
+			break;
+		case "java/lang/Byte":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf", 
+					"(B)Ljava/lang/Byte;", false);
+			break;
+		case "java/lang/Short":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf", 
+					"(S)Ljava/lang/Short;", false);
+			break;
+		case "java/lang/Integer":
+			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue", 
+					"()I", false);
+			break;
+		case "java/lang/Long":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf", 
+					"(J)Ljava/lang/Long;", false);
+			break;
+		case "java/lang/Float":
+			break;
+		case "java/lang/Double":
+			break;
+		case "java/lang/Character":
+			break;
+		default:
+			break;
+		}
 	}
 
-	@Override
-	public void visit(Literal literal) {
-		// value?
-		mv.visitLdcInsn(literal.getType().toString());
+	private void doAssign(String type, Object value) {
+		switch (type) {
+		case "java/lang/String":
+			mv.visitLdcInsn(String.valueOf(value));
+			break;
+		case "java/lang/Boolean":
+			visitBooleanLiteral((Boolean) value);
+			break;
+		case "java/lang/Byte":
+			visitByteLiteral(((Double) value).byteValue(),false);
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf", 
+					"(B)Ljava/lang/Byte;", false);
+			break;
+		case "java/lang/Short":
+			visitShortLiteral(((Double) value).shortValue(),false);
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf", 
+					"(S)Ljava/lang/Short;", false);
+			break;
+		case "java/lang/Integer":
+			//zweite Argument isLong
+			visitIntegerLiteral(((Double) value).intValue(), false);
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf", 
+					"(I)Ljava/lang/Integer;", false);
+			break;
+		case "java/lang/Long":
+			visitLongLiteral(((Double) value).longValue(), true);
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf", 
+					"(J)Ljava/lang/Long;", false);
+			break;
+		case "java/lang/Float":
+			visitFloatLiteral(((Double) value).floatValue());
+			break;
+		case "java/lang/Double":
+			visitDoubleLiteral((Double) value);
+			break;
+		case "java/lang/Character":
+			visitCharLiteral((Character) value);
+			break;
+		default:
+			break;
+		}
+	}
+	
+	private void doAssign(String type) {
+		switch (type) {
+		case "java/lang/String":
+			break;
+		case "java/lang/Boolean":
+			break;
+		case "java/lang/Byte":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf", 
+					"(B)Ljava/lang/Byte;", false);
+			break;
+		case "java/lang/Short":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf", 
+					"(S)Ljava/lang/Short;", false);
+			break;
+		case "java/lang/Integer":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf", 
+					"(I)Ljava/lang/Integer;", false);
+			break;
+		case "java/lang/Long":
+			mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf", 
+					"(J)Ljava/lang/Long;", false);
+			break;
+		case "java/lang/Float":
+			break;
+		case "java/lang/Double":
+			break;
+		case "java/lang/Character":
+			break;
+		default:
+			break;
+		}
+	}
+
+	private void visitCharLiteral(Character value) {
+		mv.visitIntInsn(Opcodes.BIPUSH, (int) value);
+		mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Character", "valueOf", 
+				"(C)Ljava/lang/Character;", false);
+	}
+
+	private void visitDoubleLiteral(Double value) {
+		if(value == 0) {
+			mv.visitInsn(Opcodes.DCONST_0);
+		}else if(value == 1) {
+			mv.visitInsn(Opcodes.DCONST_1);
+		}else {
+			mv.visitLdcInsn(value);
+		}
+		mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Double", "valueOf", 
+				"(D)Ljava/lang/Double;", false);
+	}
+
+	private void visitFloatLiteral(Float value) {
+		if(value.intValue()>-1 && value.intValue() < 3) {
+			//Opcodes.FCONST_0 = 11, Opcodes.FCONST_1 = 12, usw
+			mv.visitInsn(value.intValue()+11);
+		}else {
+			mv.visitLdcInsn(value);
+		}
+		mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Float", "valueOf", 
+				"(F)Ljava/lang/Float;", false);
+	}
+
+	private void visitLongLiteral(Long value, boolean isLong) {
+		if(value<Math.pow(2, 15) || (value>=-Math.pow(2, 15))&&value<-128) {
+			visitShortLiteral(value.shortValue(),isLong);
+		}else {
+			mv.visitLdcInsn(value);
+		}
+	}
+
+	private void visitShortLiteral(Short value,boolean isLong) {
+		if(value< 128 || (value>-129 && value<-1)) {
+			visitByteLiteral(value.byteValue(), isLong);
+		}else if(value<Math.pow(2, 15) || (value>=-Math.pow(2, 15))&&value<-128) {
+			mv.visitIntInsn(Opcodes.SIPUSH, value);
+		}
+	}
+
+	private void visitByteLiteral(Byte value, boolean isLong) {
+		
+		if(!isLong && value<6 && value>-1) {
+			//Opcodes.ICONST_0 = 3, Opcodes.ICONST_1 = 4, usw
+			mv.visitInsn(value+3);
+		}else if(isLong && value>-1 && value<2){
+			//Opcodes.LCONST_0 = 9, Opcodes.LCONST_1 = 10
+			mv.visitInsn(value+9);
+		}else {
+			mv.visitIntInsn(Opcodes.BIPUSH, value);
+		}
+		
+	}
+
+	private void visitIntegerLiteral(Integer value, boolean isLong) {
+		
+		if(value<Math.pow(2, 15) || (value>=-Math.pow(2, 15))&&value<-128) {
+			visitShortLiteral(value.shortValue(),isLong);
+		}else {
+			mv.visitLdcInsn(value);
+		}
+	}
+
+	private void visitBooleanLiteral(Boolean b) {
+		if(b) {
+			mv.visitInsn(Opcodes.ICONST_1);
+		}else {
+			mv.visitInsn(Opcodes.ICONST_0);
+		}
+		mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Boolean", "valueOf", 
+				"(Z)Ljava/lang/Boolean;", false);	
 	}
 
 	@Override
@@ -320,18 +635,26 @@ public class BytecodeGenMethod implements StatementVisitor{
 
 	@Override
 	public void visit(AssignToField assignLeftSide) {
+//		temporäre Lösung für testen, bis ich weiss wie man funktionale
+//		interfaces erkennt
+		if(isRightSideALambda)
+			varsFunInterface.add(assignLeftSide.field.getType());
 		// Loads the an object reference from the local variable 
 		//			array slot onto the top of the operand stack.
 		assignLeftSide.field.receiver.accept(this);
 		this.rightSideTemp.accept(this);
-		mv.visitFieldInsn(Opcodes.PUTFIELD, assignLeftSide.field.receiver.getType().toString(), 
-				assignLeftSide.field.fieldVarName, assignLeftSide.field.getType().toString());
+		mv.visitFieldInsn(Opcodes.PUTFIELD, getResolvedType(assignLeftSide.field.receiver.getType()), 
+				assignLeftSide.field.fieldVarName, getResolvedType(assignLeftSide.field.getType()));
 	}
 
 	@Override
 	public void visit(AssignToLocal assignLeftSide) {
+		if(isRightSideALambda)
+			varsFunInterface.add(assignLeftSide.localVar.getType());
 		paramsAndLocals.put(assignLeftSide.localVar.name, paramsAndLocals.size()+1);
 		mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.size());
+		// Debug:::
+		
 	}
 
 }

src/de/dhbwstuttgart/bytecode/ClassFile.java

@@ -1,14 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-public class ClassFile {
-	
-	String name;
-	byte[] bytecode;
-	
-	public ClassFile(String name, byte[] bytecode) {
-		this.name = name;
-		this.bytecode = bytecode;
-	}
-	
-
-}

src/de/dhbwstuttgart/bytecode/Descriptor.java

@@ -1,54 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-import java.awt.List;
-import java.util.Iterator;
-
-import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
-import de.dhbwstuttgart.syntaxtree.statement.Expression;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-
-public class Descriptor {
-	String desc;
-	
-	public Descriptor(Method method) {
-		desc = "(";
-		Iterator<FormalParameter> itr = method.getParameterList().iterator();
-		while(itr.hasNext()) {
-			FormalParameter fp = itr.next();
-			desc = desc + "L"+fp.getType().toString().replace(".", "/") + ";";
-		}
-		if(method.getReturnType().toString().equals("void")){
-			desc = desc + ")V";
-		}else {
-			desc = desc + ")" + "L"+method.getReturnType().toString().replace(".", "/")+";";
-		}
-		
-	}
-	
-	public Descriptor(Constructor constructor) {
-		desc = "(";
-		Iterator<FormalParameter> itr = constructor.getParameterList().iterator();
-		while(itr.hasNext()) {
-			FormalParameter fp = itr.next();
-			desc = desc + "L"+fp.getType().toString().replace(".", "/") + ";";
-		}
-		desc = desc + ")V";
-	}
-	
-	public Descriptor(ArgumentList argList, RefTypeOrTPHOrWildcardOrGeneric returnType) {
-		desc = "(";
-		for(Expression e : argList.getArguments()) {
-			desc = desc + "L"+e.getType().toString().replace(".", "/") + ";";
-		}
-		desc = desc + ")"+returnType.toString();
-		
-	}
-	
-	public String getDesc() {
-		return this.desc;
-	}
-
-}

src/de/dhbwstuttgart/bytecode/KindOfLambda.java

@@ -1,24 +1,33 @@
 package de.dhbwstuttgart.bytecode;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
-import org.objectweb.asm.MethodVisitor;
+
+import java.util.ArrayList;
+import java.util.List;
 
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
-public class BytecodeGenLambda implements StatementVisitor{
-	private LambdaExpression lambdaExpression;
-	private MethodVisitor mv;
+public class KindOfLambda implements StatementVisitor{
+	private boolean isInstanceCapturingLambda = false;
+	private List<RefTypeOrTPHOrWildcardOrGeneric> argumentList = new ArrayList<>();
 	
-	public BytecodeGenLambda(LambdaExpression lambdaExpression, MethodVisitor mv) {
-		this.lambdaExpression = lambdaExpression;
-		this.mv = mv;
-		
+	public KindOfLambda(LambdaExpression lambdaExpression) {
+		lambdaExpression.methodBody.accept(this);
 		
 	}
-
+	
+	public boolean isInstanceCapturingLambda() {
+		return this.isInstanceCapturingLambda;
+	}
+	
+	public List<RefTypeOrTPHOrWildcardOrGeneric> getArgumentList() {
+		return argumentList;
+	}
+	
 	@Override
 	public void visit(ArgumentList argumentList) {
 		// TODO Auto-generated method stub
@@ -27,26 +36,25 @@ public class BytecodeGenLambda implements StatementVisitor{
 
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
-		// TODO Auto-generated method stub
 		
 	}
 
 	@Override
 	public void visit(Assign assign) {
-		// TODO Auto-generated method stub
-		
+		assign.rightSide.accept(this);
 	}
 
 	@Override
-	public void visit(Binary binary) {
+	public void visit(BinaryExpr binary) {
 		// TODO Auto-generated method stub
 		
 	}
 
 	@Override
 	public void visit(Block block) {
-		// TODO Auto-generated method stub
-		
+		for(Statement stmt : block.getStatements()) {
+			stmt.accept(this);
+		}
 	}
 
 	@Override
@@ -63,8 +71,7 @@ public class BytecodeGenLambda implements StatementVisitor{
 
 	@Override
 	public void visit(FieldVar fieldVar) {
-		// TODO Auto-generated method stub
-		
+		fieldVar.receiver.accept(this);
 	}
 
 	@Override
@@ -99,8 +106,7 @@ public class BytecodeGenLambda implements StatementVisitor{
 
 	@Override
 	public void visit(MethodCall methodCall) {
-		// TODO Auto-generated method stub
-		
+		methodCall.receiver.accept(this);
 	}
 
 	@Override
@@ -117,14 +123,17 @@ public class BytecodeGenLambda implements StatementVisitor{
 
 	@Override
 	public void visit(ExpressionReceiver receiver) {
-		// TODO Auto-generated method stub
-		
+		receiver.expr.accept(this);
+	}
+
+	@Override
+	public void visit(UnaryExpr unaryExpr) {
+		throw new NotImplementedException();
 	}
 
 	@Override
 	public void visit(Return aReturn) {
-		// TODO Auto-generated method stub
-		
+		aReturn.retexpr.accept(this);
 	}
 
 	@Override
@@ -147,14 +156,8 @@ public class BytecodeGenLambda implements StatementVisitor{
 
 	@Override
 	public void visit(This aThis) {
-		// TODO Auto-generated method stub
-		
-	}
-
-	@Override
-	public void visit(UnaryPlus unaryPlus) {
-		// TODO Auto-generated method stub
-		
+		this.isInstanceCapturingLambda = true;
+		this.argumentList.add(aThis.getType());
 	}
 
 	@Override
@@ -169,12 +172,6 @@ public class BytecodeGenLambda implements StatementVisitor{
 		
 	}
 
-	@Override
-	public void visit(Null aNull) {
-		// TODO Auto-generated method stub
-		
-	}
-
 	@Override
 	public void visit(Literal literal) {
 		// TODO Auto-generated method stub

src/de/dhbwstuttgart/bytecode/Lambda.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.bytecode;
+
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
+public class Lambda {
+	private LambdaExpression lambdaExpression;
+	
+	public Lambda(LambdaExpression lambdaExpression) {
+		this.lambdaExpression = lambdaExpression;
+	}
+	
+	public ParameterList getParams() {
+		return lambdaExpression.params;
+	}
+	
+	public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
+		return lambdaExpression.getReturnType();
+	}
+	
+	public String accept(DescriptorVisitor descVisitor) {
+		return descVisitor.visit(this);
+	}
+}

src/de/dhbwstuttgart/bytecode/MethodFromMethodCall.java

@@ -0,0 +1,42 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.HashMap;
+
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
+import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
+public class MethodFromMethodCall {
+	private ArgumentList argList;
+	private RefTypeOrTPHOrWildcardOrGeneric returnType;
+	private HashMap<String, String> genericsAndBoundsMethod;
+	private HashMap<String,String> genericsAndBounds;
+	
+	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType,
+			HashMap<String, String> genericsAndBoundsMethod,HashMap<String,String> genericsAndBounds) {
+		this.argList = argList;
+		this.returnType = returnType;
+		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.genericsAndBounds = genericsAndBounds;
+	}
+	
+	public ArgumentList getArgList() {
+		return argList;
+	}
+
+	public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
+		return returnType;
+	}
+	
+	public HashMap<String, String> getGenericsAndBoundsMethod(){
+		return genericsAndBoundsMethod;
+	}
+	
+	public HashMap<String,String> getGenericsAndBounds(){
+		return genericsAndBounds;
+	}
+	
+	public String accept(DescriptorVisitor descVisitor) {
+		return descVisitor.visit(this);
+	}
+}

src/de/dhbwstuttgart/bytecode/NormalConstructor.java

@@ -0,0 +1,40 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.HashMap;
+
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+
+public class NormalConstructor {
+	private Constructor constructor;
+	private HashMap<String, String> genericsAndBounds;
+	private boolean hasGenerics;
+	
+	public NormalConstructor(Constructor constructor, boolean hasGenerics) {
+		this.constructor = constructor;
+		this.hasGenerics = hasGenerics;
+	}
+	
+	public NormalConstructor(Constructor constructor, HashMap<String, String> genericsAndBounds, boolean hasGenerics) {
+		this.constructor = constructor;
+		this.genericsAndBounds = genericsAndBounds;
+		this.hasGenerics = hasGenerics;
+	}
+
+	public HashMap<String, String> getGenericsAndBounds() {
+		return genericsAndBounds;
+	}
+
+	public boolean hasGen() {
+		return hasGenerics;
+	}
+
+	public ParameterList getParameterList() {
+		return constructor.getParameterList();
+	}
+	
+	public String accept(DescriptorVisitor descVisitor) {
+		return descVisitor.visit(this);
+	}
+}

src/de/dhbwstuttgart/bytecode/NormalMethod.java

@@ -0,0 +1,56 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.HashMap;
+
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
+public class NormalMethod {
+	private Method method;
+	private HashMap<String, String> genericsAndBounds;
+	private HashMap<String, String> genericsAndBoundsMethod;
+	private boolean hasGenerics;
+	
+	public NormalMethod(Method method, boolean hasGenerics) {
+		this.method = method;
+		this.hasGenerics = hasGenerics;
+	}
+
+	public NormalMethod(Method method, HashMap<String, String> genericsAndBounds,
+			HashMap<String, String> genericsAndBoundsMethod,boolean hasGenerics) {
+		this.method = method;
+		this.genericsAndBounds = genericsAndBounds;
+		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.hasGenerics = hasGenerics;
+	}
+
+	public Method getMethod() {
+		return method;
+	}
+	
+	public ParameterList getParameterList() {
+		return method.getParameterList();
+	}
+	
+	public HashMap<String, String> getGenericsAndBounds(){
+		return genericsAndBounds;
+	}
+	
+	public HashMap<String, String> getGenericsAndBoundsMethod(){
+		return genericsAndBoundsMethod;
+	}
+	
+	public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
+		return method.getReturnType();
+	}
+	
+	public boolean hasGen() {
+		return this.hasGenerics;
+	}
+	
+	public String accept(DescriptorVisitor descVisitor) {
+		return descVisitor.visit(this);
+	}
+}

src/de/dhbwstuttgart/bytecode/SamMethod.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.List;
+
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
+public class SamMethod {
+	private List<RefTypeOrTPHOrWildcardOrGeneric> argumentList;
+	private RefTypeOrTPHOrWildcardOrGeneric returnType;
+	
+	public SamMethod(List<RefTypeOrTPHOrWildcardOrGeneric> argumentList, RefTypeOrTPHOrWildcardOrGeneric returnType) {
+		this.argumentList = argumentList;
+		this.returnType = returnType;
+	}
+	
+	public List<RefTypeOrTPHOrWildcardOrGeneric> getArgumentList() {
+		return argumentList;
+	}
+
+
+
+	public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
+		return returnType;
+	}
+
+
+
+	public String accept(DescriptorVisitor descVisitor) {
+		return descVisitor.visit(this);
+	}
+}

src/de/dhbwstuttgart/bytecode/Test.java

@@ -1,150 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.lang.invoke.CallSite;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Handle;
-import org.objectweb.asm.Label;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-
-
-public class Test {
-	private static final String rootDirectory = System.getProperty("user.dir") + "/bin/de/dhbwstuttgart/bytecode/";
-
-	protected static ClassLoader getClassLoader() throws Exception {
-		File file = new File(rootDirectory);
-		URL url = file.toURI().toURL();
-		URL[] urls = new URL[] { url };
-		System.out.println(urls[0]);
-		return new URLClassLoader(urls);
-	}
-
-	public static void main(String[] args) {
-		// Test Lambda
-		ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
-		cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "TestClass", null, "java/lang/Object", null);
-
-		cw.visitSource("TestClass.java", null);
-
-		// Create Constructor
-		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
-		mv.visitVarInsn(Opcodes.ALOAD, 0);
-
-		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
-
-		// mv.visitMethodInsn(INVOKEDYNAMIC, "#0", "run", "()Ljava/lang/Runnable");
-		//Call site, which, when invoked, returns an instance of the functional interface to which
-		//the lambda is being converted
-		MethodType mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class,
-				MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);
-		
-		Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", "metafactory",
-				mt.toMethodDescriptorString());
-		Handle arg2 = new Handle(Opcodes.H_INVOKESTATIC, "TestClass", "lambda$0", "()V");
-
-		mv.visitInvokeDynamicInsn("run", "()Ljava/lang/Runnable;", bootstrap, 
-				Type.getMethodType("()V"), arg2,
-				Type.getMethodType("()V"));
-
-		mv.visitVarInsn(Opcodes.ASTORE, 1);
-		mv.visitVarInsn(Opcodes.ALOAD, 1);
-		mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/lang/Runnable", "run", "()V");
-		mv.visitInsn(Opcodes.RETURN);
-		
-		// creates bridge method, contains lambdas body
-				MethodVisitor mvl = cw.visitMethod(Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC + Opcodes.ACC_SYNTHETIC, "lambda$0",
-						"()V", null, null);
-				mvl.visitCode();
-				mvl.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
-				mvl.visitLdcInsn("lambda");
-				mvl.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
-				mvl.visitInsn(Opcodes.RETURN);
-				mvl.visitMaxs(2, 0);
-				mvl.visitEnd();
-		
-		mv.visitMaxs(1, 2);
-		mv.visitEnd();
-		
-
-		cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup",
-				Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL);
-		cw.visitEnd();
-
-		byte[] b = cw.toByteArray();
-
-		// Test if statement
-		/*
-		 * ClassWriter cw = new
-		 * ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
-		 * 
-		 * cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_SUPER, "TestIf", null,
-		 * "java/lang/Object", null); MethodVisitor mv =
-		 * cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "(Ljava/lang/Boolean;)V", null,
-		 * null); mv.visitCode();
-		 * 
-		 * // Label l0 = new Label(); // mv.visitLabel(l0);
-		 * 
-		 * mv.visitVarInsn(Opcodes.ALOAD, 0);
-		 * 
-		 * mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>",
-		 * "()V");
-		 * 
-		 * // Label l1 = new Label(); // mv.visitLabel(l1);
-		 * mv.visitVarInsn(Opcodes.ALOAD, 1); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,
-		 * "java/lang/Boolean", "booleanValue", "()Z");
-		 * 
-		 * Label label = new Label(); mv.visitJumpInsn(Opcodes.IFEQ, label);
-		 * 
-		 * mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out",
-		 * "Ljava/io/PrintStream;"); mv.visitLdcInsn("1");
-		 * mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println",
-		 * "(Ljava/lang/String;)V");
-		 * 
-		 * Label endLabel = new Label(); mv.visitJumpInsn(Opcodes.GOTO, endLabel);
-		 * 
-		 * mv.visitLabel(label); mv.visitFieldInsn(Opcodes.GETSTATIC,
-		 * "java/lang/System", "out", "Ljava/io/PrintStream;"); mv.visitLdcInsn("0");
-		 * mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println",
-		 * "(Ljava/lang/String;)V");
-		 * 
-		 * 
-		 * 
-		 * mv.visitLabel(endLabel); mv.visitInsn(Opcodes.RETURN);
-		 * 
-		 * // Label l2 = new Label(); // mv.visitLabel(l2);
-		 * 
-		 * // mv.visitLocalVariable("this", "LTestIf;", null, l0, l2, 0); //
-		 * mv.visitLocalVariable("b", "Ljava/lang/Boolean;", null, l0, l2, 1);
-		 * mv.visitMaxs(2, 2); mv.visitEnd();
-		 * 
-		 * cw.visitEnd(); byte[] b = cw.toByteArray();
-		 */
-		FileOutputStream output;
-
-		try {
-			output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/TestClass.class"));
-			output.write(b);
-			output.close();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IOException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-
-	}
-}

src/de/dhbwstuttgart/bytecode/TestClass.java

@@ -1,8 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-public class TestClass {
-	public TestClass() {
-		Runnable lam = () -> System.out.println("lambda");
-		lam.run();
-	}
-}

src/de/dhbwstuttgart/bytecode/TestFields.java

@@ -1,59 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.FieldVisitor;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-
-public class TestFields {
-	private static final String rootDirectory = System.getProperty("user.dir") + "/bin/de/dhbwstuttgart/bytecode/";
-	
-	public static void main(String[] args) {
-		// TODO Auto-generated method stub
-		ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
-		cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "TetsF", null, "java/lang/Object", null);
-		
-		cw.visitSource("TetsF.java", null);
-
-		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, "z", Type.INT_TYPE.getDescriptor(), null, null);
-		fv.visitEnd();
-		
-		FieldVisitor fvS = cw.visitField(Opcodes.ACC_PUBLIC, "s", "Ljava/lang/String;", null, null);
-		fvS.visitEnd();
-		// Create Constructor
-		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
-		mv.visitCode();
-		
-		mv.visitVarInsn(Opcodes.ALOAD, 0);
-		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
-		mv.visitVarInsn(Opcodes.ALOAD, 0);
-		mv.visitLdcInsn("");
-		mv.visitFieldInsn(Opcodes.PUTFIELD, "TetsF", "s", "Ljava/lang/String;");
-		mv.visitInsn(Opcodes.RETURN);
-		mv.visitMaxs(2, 1);
-		mv.visitEnd();
-		
-		byte[] b = cw.toByteArray();
-		
-		FileOutputStream output;
-
-		try {
-			output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/TetsF.class"));
-			output.write(b);
-			output.close();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IOException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-
-}

src/de/dhbwstuttgart/bytecode/TestIf.java

@@ -1,11 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-public class TestIf {
-	public TestIf(Boolean b) {
-		if(b) {
-			System.out.println("1");
-		}else {
-			System.out.println("0");
-		}
-	}
-}

src/de/dhbwstuttgart/bytecode/TestMeth.java

@@ -1,18 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-public class TestMeth {
-	private int z;
-	public String s;
-	public TestMeth(int temp) {
-		this.z = temp;
-	}
-	public void m1(int a, int b) {
-		int y = m2(1,2,3,4);
-	}
-	
-	public int m2(int a, int b, int x, int y) {
-		Integer c = 55;
-		Integer g;
-		return a+b+y+c;
-	}
-}

src/de/dhbwstuttgart/bytecode/TetsF.java

@@ -1,6 +0,0 @@
-package de.dhbwstuttgart.bytecode;
-
-public class TetsF {
-	private int z;
-	public String s = "";
-}

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

@@ -0,0 +1,158 @@
+package de.dhbwstuttgart.bytecode.descriptor;
+
+import java.util.Iterator;
+
+import de.dhbwstuttgart.bytecode.Lambda;
+import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.NormalConstructor;
+import de.dhbwstuttgart.bytecode.NormalMethod;
+import de.dhbwstuttgart.bytecode.SamMethod;
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+public class DescriptorToString implements DescriptorVisitor{
+	ResultSet resultSet;
+	
+	public DescriptorToString(ResultSet resultSet) {
+		this.resultSet = resultSet;
+	}
+	
+	private String addReturnType(String desc, RefTypeOrTPHOrWildcardOrGeneric returnType, ResultSet resultSet) {
+		if(resultSet.resolveType(returnType).resolvedType.toString().equals("void")){
+			desc = desc + ")V";
+		}else {
+			desc = desc + ")" + "L"+resultSet.resolveType(returnType).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+		}
+		return desc;
+	}
+	
+	@Override
+	public String visit(NormalMethod method) {
+		
+		String desc = "(";
+		Iterator<FormalParameter> itr = method.getParameterList().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+//			System.out.println(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToSignature()));
+//			System.out.println("Parmetrisierte typ ? "+ ((RefType) fp.getType()).getParaList().size());
+			if(method.hasGen()) {
+				String fpDesc = fp.getType().acceptTV(new TypeToDescriptor());
+				if(method.getGenericsAndBoundsMethod().containsKey(fpDesc)) {
+					desc += "L"+method.getGenericsAndBoundsMethod().get(fpDesc)+ ";";
+				}else if(method.getGenericsAndBounds().containsKey(fpDesc)){
+					desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
+				}else {
+					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				}
+			}
+//			else if(((RefType) fp.getType()).getParaList().size() > 0){
+//				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "%").replace("<", "%%").replace(">", "%%")+ ";";
+//			}
+			else {
+				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+			}
+		}
+		
+		if(resultSet.resolveType(method.getReturnType()).resolvedType.toString().equals("void")) {
+			desc += ")V";
+		}else {
+			if(method.hasGen()) {
+				String ret = method.getReturnType().acceptTV(new TypeToDescriptor());
+				if(method.getGenericsAndBoundsMethod().containsKey(ret)) {
+					desc += ")L"+method.getGenericsAndBoundsMethod().get(ret)+ ";";
+				}else if(method.getGenericsAndBounds().containsKey(ret)){
+					desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
+				}else {
+					desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				}
+			}else {
+				desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+			}
+		}
+//		desc = addReturnType(desc,method.getReturnType(), resultSet);
+		return desc;
+	}
+
+	@Override
+	public String visit(NormalConstructor constructor) {
+		String desc = "(";
+		Iterator<FormalParameter> itr = constructor.getParameterList().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			if(constructor.hasGen()) {
+//				System.out.println("Cons has Gens");
+				String fpDesc = fp.getType().acceptTV(new TypeToDescriptor());
+//				System.out.println(fpDesc);
+				if(constructor.getGenericsAndBounds().containsKey(fpDesc)){
+					desc += "L"+constructor.getGenericsAndBounds().get(fpDesc)+ ";";
+				}else {
+					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				}
+			}else {
+//				System.out.println("Cons has NOT Gens");
+				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+			}
+		}
+		desc = desc + ")V";
+		return desc;
+	}
+
+	@Override
+	public String visit(Lambda lambdaExpression) {
+		String desc = "(";
+		Iterator<FormalParameter> itr = lambdaExpression.getParams().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			desc = desc + "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+		}
+		desc = addReturnType(desc, lambdaExpression.getReturnType(), resultSet);
+		return desc;
+	}
+
+	@Override
+	public String visit(SamMethod samMethod) {
+		String desc = "(";
+		Iterator<RefTypeOrTPHOrWildcardOrGeneric> itr = samMethod.getArgumentList().iterator();
+		while(itr.hasNext()) {
+			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
+			desc = desc + "L"+resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor())+";";
+		}
+		desc = desc + ")"+"L"+resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
+		return desc;
+	}
+
+	@Override
+	public String visit(MethodFromMethodCall methodFromMethodCall) {
+		String desc = "(";
+		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
+			String d = e.getType().acceptTV(new TypeToDescriptor());
+			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
+				desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
+			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
+				desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
+			}else {
+				desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+			}
+		}
+		
+		if(resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.toString().equals("void")) {
+			desc += ")V";
+		}else {
+			String ret = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(ret)) {
+				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(ret)+ ";";
+			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(ret)){
+				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(ret)+ ";";
+			}else {
+				desc += ")" + "L"+resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+			}
+		}
+//		desc = addReturnType(desc, methodFromMethodCall.getReturnType(), resultSet);
+		return desc;
+	}
+	
+}

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

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.bytecode.descriptor;
+
+import de.dhbwstuttgart.bytecode.Lambda;
+import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.NormalConstructor;
+import de.dhbwstuttgart.bytecode.NormalMethod;
+import de.dhbwstuttgart.bytecode.SamMethod;
+
+public interface DescriptorVisitor {
+	public String visit(NormalMethod method);
+	public String visit(NormalConstructor constructor);
+	public String visit(Lambda lambdaExpression);
+	public String visit(SamMethod samMethod);
+	public String visit(MethodFromMethodCall methodFromMethodCall);
+}

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

@@ -0,0 +1,37 @@
+package de.dhbwstuttgart.bytecode.descriptor;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
+
+public class TypeToDescriptor implements TypeVisitor<String>{
+
+	@Override
+	public String visit(RefType refType) {
+		return refType.getName().toString().replace(".", "/");
+	}
+
+	@Override
+	public String visit(SuperWildcardType superWildcardType) {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public String visit(TypePlaceholder typePlaceholder) {
+		return typePlaceholder.toString().replace(".", "/");
+	}
+
+	@Override
+	public String visit(ExtendsWildcardType extendsWildcardType) {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public String visit(GenericRefType genericRefType) {
+		return genericRefType.getParsedName().replace(".", "/");
+	}
+}

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

@@ -0,0 +1,184 @@
+package de.dhbwstuttgart.bytecode.signature;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.objectweb.asm.Type;
+import org.objectweb.asm.signature.SignatureVisitor;
+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.GenericTypeVar;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+public class Signature {
+	private ClassOrInterface classOrInterface;
+	private HashMap<String, String> genericsAndBounds;
+	private HashMap<String, String> genericsAndBoundsMethod;
+	private SignatureWriter sw;
+	private Constructor constructor;
+	private Method method;
+	private HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes;
+	private ResultSet resultSet;
+	
+	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds) {
+		this.classOrInterface = classOrInterface;
+		this.genericsAndBounds = genericsAndBounds;
+		sw = new SignatureWriter();
+		createSignatureForClassOrInterface();
+	}
+
+	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes) {
+		this.constructor = constructor;
+		this.genericsAndBounds = genericsAndBounds;
+		this.methodParamsAndTypes = methodParamsAndTypes;
+		sw = new SignatureWriter();
+		createSignatureForConsOrMethod(this.constructor,true);
+	}
+
+	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,
+			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet) {
+		this.method = method;
+		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.methodParamsAndTypes = methodParamsAndTypes;
+		this.resultSet = resultSet;
+		sw = new SignatureWriter();
+		createSignatureForConsOrMethod(this.method,false);
+	}
+	
+	public Signature(LambdaExpression lambdaExpression,int numberOfParams) {
+		sw = new SignatureWriter();
+		createSignatureForFunN(lambdaExpression, numberOfParams);
+	}
+
+	private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
+		
+		sw.visitFormalTypeParameter("R");
+		// getBounds vom Return-Type
+		sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+		sw.visitClassBound().visitEnd();
+		for(int i = 0;i<numberOfParams;i++) {
+			int j = i+1;
+			sw.visitFormalTypeParameter("T"+ j);
+			// getBounds von Params
+			sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+			sw.visitClassBound().visitEnd();
+		}
+		// TODO: prüfe ob Return-Type = void,
+		sw.visitSuperclass().visitClassType(Type.getInternalName(Object.class));;
+		sw.visitEnd();
+	}
+
+	/**
+	 * Creates signature for a method or constructor with @see {@link SignatureWriter}
+	 * Signature looks like: 
+	 * <typevaliables (K:Ljava/lang/Object "Bounds")>(params L.. OR T.. Or basistape)ReturnType
+	 * 
+	 * @param method method or constructor
+	 * @param isConstructor true if constructor
+	 */
+	private void createSignatureForConsOrMethod(Method method, boolean isConstructor) {
+		Iterator<? extends GenericTypeVar> itr = method.getGenerics().iterator();
+		// visits all formal type parameter and visits their bounds <T:...;B:...;...>
+		while(itr.hasNext()) {
+			GenericTypeVar g = itr.next();
+			getBoundsOfTypeVar(g,genericsAndBoundsMethod);
+		}
+		// visits each method-parameter to create the signature 
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
+			// parameter type deswegen ist true
+			doVisitParamsOrReturn(t,true);
+		}
+		if(isConstructor) {
+			sw.visitReturnType().visitBaseType('V');
+		}else {
+			RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
+			// return type deswegen ist false
+			doVisitParamsOrReturn(returnType, false);
+		}
+//		sw.visitEnd();
+	}
+	/**
+	 * Visits parameter type or return type with {@link SignatureVisitor} to create
+	 * the method signature
+	 * @param t type of parameter or return type
+	 * @param isParameterType true if t is type of parameter
+	 */
+	private void doVisitParamsOrReturn(RefTypeOrTPHOrWildcardOrGeneric t, boolean isParameterType) {
+		String type = t.acceptTV(new TypeToString());
+		SignatureVisitor sv;
+		if(isParameterType) {
+			 sv = sw.visitParameterType();
+		}
+		else {
+			sv = sw.visitReturnType();
+		}
+		switch (type) {
+		case "RT":
+			sv.visitClassType(t.acceptTV(new TypeToSignature()));
+			break;
+		case "GRT":
+			GenericRefType g = (GenericRefType) t;
+			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()));
+			break;
+		case "TPH":
+			RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
+			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH "))
+				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
+//			sv.visitClassType(r.acceptTV(new TypeToSignature()));
+			System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+			break;
+		default:
+			if(!isParameterType)
+				sv.visitBaseType('V');
+			break;
+		}
+	}
+	/**
+	 * Creates signature for class or interface with {@link SignatureWriter}
+	 * Signature looks like: 
+	 * <typevaliables (K:Ljava/lang/Object "Bounds")>superclass
+	 */
+	private void createSignatureForClassOrInterface() {
+		Iterator<GenericTypeVar> itr = classOrInterface.getGenerics().iterator();
+
+		while(itr.hasNext()) {
+			GenericTypeVar g = itr.next();
+			getBoundsOfTypeVar(g,genericsAndBounds);
+		}
+		
+		sw.visitSuperclass().visitClassType(classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()));;
+		sw.visitEnd();
+	}
+	/**
+	 * Get bounds of type variable
+	 * @param g type variable
+	 * @param genAndBounds 
+	 */
+	private void getBoundsOfTypeVar(GenericTypeVar g, HashMap<String, String> genAndBounds) {
+		sw.visitFormalTypeParameter(g.getName());
+		
+		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator(); 
+		while(bItr.hasNext()) {
+			RefTypeOrTPHOrWildcardOrGeneric b =bItr.next();
+			String boundDesc = b.acceptTV(new TypeToDescriptor());
+//			System.out.println("GetBounds: " + boundDesc);
+			// Ensure that <...> extends java.lang.Object OR ...
+			sw.visitClassBound().visitClassType(boundDesc);
+			genAndBounds.put(g.getName(), boundDesc);
+		}
+		sw.visitClassBound().visitEnd();
+	}
+	
+	public String toString() {
+		return sw.toString();
+	}
+	
+}

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

@@ -0,0 +1,53 @@
+package de.dhbwstuttgart.bytecode.signature;
+
+import java.util.Iterator;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
+
+public class TypeToSignature implements TypeVisitor<String> {
+
+	@Override
+	public String visit(RefType refType) {
+//		return refType.toString().replace(".", "/");
+		String params = "";
+        if(refType.getParaList().size()>0){
+            params += "<";
+            Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
+            while(it.hasNext()){
+                RefTypeOrTPHOrWildcardOrGeneric param = it.next();
+                params += "L"+param.toString().replace(".", "/");
+                if(it.hasNext())params += ";";
+            }
+            params += ";>";
+        }
+        return refType.getName().toString().replace(".", "/") + params+";";
+	}
+
+	@Override
+	public String visit(SuperWildcardType superWildcardType) {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public String visit(TypePlaceholder typePlaceholder) {
+		return typePlaceholder.toString().replace(".", "/");
+	}
+
+	@Override
+	public String visit(ExtendsWildcardType extendsWildcardType) {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public String visit(GenericRefType genericRefType) {
+		return genericRefType.getParsedName().replace(".", "/");
+	}
+	
+}

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

@@ -0,0 +1,38 @@
+package de.dhbwstuttgart.bytecode.signature;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
+
+public class TypeToString implements TypeVisitor<String>{
+
+	@Override
+	public String visit(RefType refType) {
+		return "RT";
+	}
+
+	@Override
+	public String visit(SuperWildcardType superWildcardType) {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public String visit(TypePlaceholder typePlaceholder) {
+		return "TPH";
+	}
+
+	@Override
+	public String visit(ExtendsWildcardType extendsWildcardType) {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public String visit(GenericRefType genericRefType) {
+		return "GRT";
+	}
+
+}

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,14 +24,13 @@ 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.IOException;
+import java.io.*;
 import java.util.*;
 import java.util.stream.Collectors;
 
 public class JavaTXCompiler {
 
-	final CompilationEnvironment environment;
+    final CompilationEnvironment environment;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
 
     public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
@@ -38,55 +39,85 @@ public class JavaTXCompiler {
 
     public JavaTXCompiler(List<File> sources) throws IOException, ClassNotFoundException {
         environment = new CompilationEnvironment(sources);
-        for(File s : sources){
-            sourceFiles.put(s,parse(s));
+        for (File s : sources) {
+            sourceFiles.put(s, parse(s));
         }
     }
 
-    public List<ResultSet> typeInference() throws ClassNotFoundException {
+    public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException {
         List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
-        for(SourceFile sf : sourceFiles.values()){
+        for (SourceFile sf : sourceFiles.values()) {
             allClasses.addAll(sf.getClasses());
         }
         List<ClassOrInterface> importedClasses = new ArrayList<>();
         //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-        for(File forSourceFile : sourceFiles.keySet())
-            for(JavaClassName name : sourceFiles.get(forSourceFile).getImports()){
+        for (File forSourceFile : sourceFiles.keySet())
+            for (JavaClassName name : sourceFiles.get(forSourceFile).getImports()) {
+                //TODO: Hier werden imports von eigenen (.jav) Klassen nicht beachtet
                 ClassOrInterface importedClass = ASTFactory.createClass(
                         ClassLoader.getSystemClassLoader().loadClass(name.toString()));
                 importedClasses.add(importedClass);
             }
         allClasses.addAll(importedClasses);
-        FiniteClosure finiteClosure =  UnifyTypeFactory.generateFC(allClasses);
 
-        final ConstraintSet<Pair> cons = new TYPE(sourceFiles.values(), allClasses).getConstraints();
+        return new TYPE(sourceFiles.values(), allClasses).getConstraints();
+    }
+
+    public List<ClassOrInterface> getAvailableClasses(SourceFile forSourceFile) throws ClassNotFoundException {
+        List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        for (SourceFile sf : sourceFiles.values()) {
+            allClasses.addAll(sf.getClasses());
+        }
+        List<ClassOrInterface> importedClasses = new ArrayList<>();
+        for (JavaClassName name : forSourceFile.getImports()) {
+            //TODO: Hier werden imports von eigenen (.jav) Klassen nicht beachtet
+            ClassOrInterface importedClass = ASTFactory.createClass(
+                    ClassLoader.getSystemClassLoader().loadClass(name.toString()));
+            importedClasses.add(importedClass);
+            allClasses.addAll(importedClasses);
+        }
+        return allClasses;
+    }
+
+    public List<ResultSet> typeInference() throws ClassNotFoundException {
+        List<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());
+        }
+
+        final ConstraintSet<Pair> cons = getConstraints();
+
+        FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses);
+        System.out.println(finiteClosure);
         ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
 
         TypeUnify unify = new TypeUnify();
         Set<Set<UnifyPair>> results = new HashSet<>();
-        for(List<Constraint<UnifyPair>> xCons : unifyCons.cartesianProduct()){
+        for (List<Constraint<UnifyPair>> xCons : unifyCons.cartesianProduct()) {
             Set<UnifyPair> xConsSet = new HashSet<>();
-            for(Constraint<UnifyPair> constraint : xCons){
+            for (Constraint<UnifyPair> constraint : xCons) {
                 xConsSet.addAll(constraint);
             }
 
-            //System.out.println(xConsSet);
+            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 ->
                 new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
-        }
+    }
 
-    private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints){
+    private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
         HashMap<String, TypePlaceholder> ret = new HashMap<>();
-        constraints.map((Pair p)->{
-            if(p.TA1 instanceof TypePlaceholder){
-                ret.put(((TypePlaceholder)p.TA1).getName(), (TypePlaceholder) p.TA1);
+        constraints.map((Pair p) -> {
+            if (p.TA1 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
             }
-            if(p.TA2 instanceof TypePlaceholder){
-                ret.put(((TypePlaceholder)p.TA2).getName(), (TypePlaceholder) p.TA2);
+            if (p.TA2 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
             }
             return null;
         });
@@ -96,8 +127,77 @@ public class JavaTXCompiler {
     private SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
         CompilationUnitContext tree = JavaTXParser.parse(sourceFile);
         SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(sourceFile), new GenericsRegistry(null));
-        SourceFile ret =  generator.convert(tree);
+        SourceFile ret = generator.convert(tree, environment.packageCrawler);
         return ret;
     }
-    
-}
+
+    public List<ResultSet> aspTypeInference() throws ClassNotFoundException, IOException, InterruptedException {
+        Collection<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
+        for(SourceFile sf : this.sourceFiles.values()) {
+            allClasses.addAll(getAvailableClasses(sf));
+            allClasses.addAll(sf.getClasses());
+        }
+        HashMap<String, ClassOrInterface> classes = new HashMap<>();
+        for(ClassOrInterface cl : allClasses){
+            classes.put(cl.getClassName().toString(), cl);
+        }
+        allClasses = classes.values();
+
+        final ConstraintSet<Pair> cons = getConstraints();
+
+        String content = "";
+        content = ASPFactory.generateASP(cons, allClasses);
+        final String tempDirectory = "/tmp/";
+        PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8");
+        writer.println(content);
+        writer.close();
+        ASPUnify clingo = new ASPUnify(Arrays.asList(new File(tempDirectory + "test.lp")));
+        String result = clingo.runClingo();
+        //System.out.println(result);
+        ResultSet resultSet = ASPParser.parse(result, getInvolvedTPHS(cons));
+        return Arrays.asList(resultSet);
+    }
+
+    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/environment/CompilationEnvironment.java

@@ -5,10 +5,7 @@ import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
@@ -35,6 +32,7 @@ import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 public class CompilationEnvironment {
 	private final List<URL> librarys;
 	private final List<File> sourceFiles;
+	public final PackageCrawler packageCrawler;
 
 	/**
 	 * Imitiert die Environment beim Aufruf des JavaCompilers auf einer Menge von java-Dateien
@@ -42,22 +40,37 @@ public class CompilationEnvironment {
 	 * @param sourceFiles die zu kompilierenden Dateien
 	 */
 	public CompilationEnvironment(List<File> sourceFiles) {
-		String bootClassPath = System.getProperty("sun.boot.class.path");
-        librarys = new ArrayList<>();
-        for(String path : bootClassPath.split(File.pathSeparator)) {
-        	try {
-        		librarys.add(new URL("file:"+path));
-			} catch (MalformedURLException e) {
-				new DebugException("Fehler im Classpath auf diesem System");
+		/**
+		 * Java 9 bringt einige Änderungen am Classloader
+		 * So funktioniert der BootClassLoader nicht mehr.
+		 * hier gibts ein paar Quellen zum nachlesen:
+		 * http://java9.wtf/class-loading/
+		 * https://stackoverflow.com/questions/46494112/classloaders-hierarchy-in-java-9
+		 *
+		 */
+		//String bootClassPath = System.getProperty("sun.boot.class.path");
+		//		ClassLoader cl = ClassLoader.getPlatformClassLoader();
+				ClassLoader cl = ClassLoader.getSystemClassLoader();
+				String bootClassPath = System.getProperty("java.class.path");
+		librarys = new ArrayList<>();
+		for(String path : bootClassPath.split(File.pathSeparator)) {
+				   try {
+							   librarys.add(new URL("file:"+path));
+							   } catch (MalformedURLException e) {
+									   new DebugException("Fehler im Classpath auf diesem System");
+							   }
 			}
-        }
+		//URLClassLoader loader = new URLClassLoader(new URL[0], cl);
+		//librarys = Arrays.asList(loader.getURLs());
+
 		this.sourceFiles = sourceFiles;
+        this.packageCrawler = new PackageCrawler(librarys);
 	}
 
 	public JavaClassRegistry getRegistry(File forSourceFile) throws ClassNotFoundException, IOException {
-		List<String> allNames;
+		Map<String, Integer> allNames;
 		CompilationUnitContext tree = JavaTXParser.parse(forSourceFile);
-		allNames = GatherNames.getNames(tree, new PackageCrawler(librarys));
+		allNames = GatherNames.getNames(tree, packageCrawler);
 		return new JavaClassRegistry(allNames);
 	}
 

src/de/dhbwstuttgart/environment/PackageCrawler.java

@@ -1,10 +1,7 @@
 package de.dhbwstuttgart.environment;
 
 import java.net.URL;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
 
 import org.reflections.Reflections;
 import org.reflections.scanners.ResourcesScanner;
@@ -66,14 +63,14 @@ public class PackageCrawler {
         return classes;
     }
 
-  public List<String> getClassNames(String packageName){
-    List<String> nameList = new ArrayList();
+  public Map<String, Integer> getClassNames(String packageName){
+      Map<String, Integer> nameList = new HashMap<>();
     Set<Class<?>> classes = getClassesInPackage(packageName);
       if(packageName.equals("java.lang") && ! classes.contains(Object.class)) {
         classes.add(Object.class);
       }
     for(Class c : classes){
-      nameList.add(c.getName());
+      nameList.put(c.getName(), c.getTypeParameters().length);
     }
     return nameList;
   }

src/de/dhbwstuttgart/parser/JavaTXParser.java

@@ -29,7 +29,7 @@ public class JavaTXParser {
         */
     }
     
-    /* F<EFBFBD>r das Typsystem ist es notwendig, dass sich der Source in einer Datei befindet:
+    /* Für das Typsystem ist es notwendig, dass sich der Source in einer Datei befindet:
     public SourceFile parse(String fileContent) throws IOException, java.lang.ClassNotFoundException {
         return this.parse(new ByteArrayInputStream(fileContent.getBytes(StandardCharsets.UTF_8)));
     }

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

@@ -0,0 +1,203 @@
+package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
+
+import de.dhbwstuttgart.exceptions.DebugException;
+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 {
+    /**
+     * Baut die FiniteClosure aus availableClasses.
+     * Klassen welche nicht in availableClasses vorkommen werden im Java Classpath nachgeschlagen.
+     *
+     * @param availableClasses - Alle geparsten Klassen
+     */
+    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+        return toFC(availableClasses).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
+    }
+
+    /*
+    Hier entstehen unnötige Typpaare
+    wenn es mehrere Vererbungsketten gibt
+     Beispiel:
+     * X<B,C> < Y<B,C>
+     * X<D,E> < Y<D,E>
+     Will man dies aber rausnehmen, muss man die andere Kette umbenennen.
+     Schwierig/Unmöglich, dank mehrfachvererbung
+     * Z<B,C,D,E> < X<B,C> < Y<B,C>
+     * Z<B,C,D,E> < X<D,E> < Y<D,E>
+
+     */
+    public static Collection<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+        HashMap<String, Pair> pairs = new HashMap<>();
+        TypePrinter printer = new TypePrinter();
+        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();
+    }
+
+    /**
+     * Bildet eine Kette vom übergebenen Typ bis hin zum höchsten bekannten Typ
+     * Als Generics werden TPHs benutzt, welche der Unifikationsalgorithmus korrekt interpretieren muss.
+     * Die verwendeten TPHs werden in der Kette nach oben gereicht, so erhält der selbe GTV immer den selben TPH
+     * @param forType
+     * @return
+     */
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+        return getSuperTypes(forType, availableClasses, new HashMap<>());
+    }
+
+    /**
+     *
+     * @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, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
+        //Generics mit gleichem Namen müssen den selben TPH bekommen
+        for(GenericTypeVar gtv : forType.getGenerics()){
+            if(!gtvs.containsKey(gtv.getName())){
+                TypePlaceholder replacePlaceholder = TypePlaceholder.fresh(new NullToken());
+                gtvs.put(gtv.getName(), replacePlaceholder);
+                newGTVs.put(gtv.getName(), replacePlaceholder);
+            }
+            params.add(gtvs.get(gtv.getName()));
+        }
+
+
+        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(superType.getName().toString()));
+            }else{
+                superClass = hasSuperclass.get();
+            }
+            /*
+            Die Parameter der superklasse müssen jetzt nach den Angaben in der Subklasse
+            modifiziert werden
+            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 in der Superklasse ausgetauscht werden müssen
+            Iterator<GenericTypeVar> itGenParams = superClass.getGenerics().iterator();
+            Iterator<RefTypeOrTPHOrWildcardOrGeneric> itSetParams = superType.getParaList().iterator();
+            while(itSetParams.hasNext()){
+                RefTypeOrTPHOrWildcardOrGeneric setType = itSetParams.next();
+                //In diesem Typ die GTVs durch TPHs und Einsetzungen austauschen:
+                RefTypeOrTPHOrWildcardOrGeneric setSetType = setType.acceptTV(new TypeExchanger(gtvs));
+                newGTVs.put(itGenParams.next().getName(), setSetType);
+            }
+
+            //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));
+
+            RefTypeOrTPHOrWildcardOrGeneric t1 = new RefType(forType.getClassName(), params, new NullToken());
+            RefTypeOrTPHOrWildcardOrGeneric t2 = superRefType;
+
+            Pair ret = new Pair(t1, t2, PairOperator.SMALLER);
+
+            List<Pair> superTypes;
+            //Rekursiver Aufruf. Abbruchbedingung ist Object als Superklasse:
+            if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){
+                superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER));
+            }else{
+                superTypes = getSuperTypes(superClass, availableClasses, newGTVs);
+            }
+
+            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<RefTypeOrTPHOrWildcardOrGeneric>{
+
+        private final HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs;
+
+        TypeExchanger(HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs){
+            this.gtvs = gtvs;
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(RefType refType) {
+            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+                params.add(param.acceptTV(this));
+            }
+            RefTypeOrTPHOrWildcardOrGeneric ret = new RefType(refType.getName(), params, new NullToken());
+            return ret;
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(SuperWildcardType superWildcardType) {
+            throw new DebugException("Dieser Fall darf nicht auftreten");
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(TypePlaceholder typePlaceholder) {
+            throw new DebugException("Dieser Fall darf nicht auftreten");
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(ExtendsWildcardType extendsWildcardType) {
+            throw new DebugException("Dieser Fall darf nicht auftreten");
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(GenericRefType genericRefType) {
+            if(! gtvs.containsKey(genericRefType.getParsedName()))
+                throw new DebugException("Dieser Fall darf nicht auftreten");
+            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;
-    public final JavaClassName parentClass;
+    private final String parentMethod;
+    private final JavaClassName parentClass;
 
     public GenericContext(JavaClassName parentClass, String parentMethod) {
         if(parentMethod == null)parentMethod = "";

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

@@ -7,7 +7,7 @@ import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.*;
+import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr.Operation;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
@@ -95,7 +95,7 @@ public class StatementGenerator {
 
     private Statement convert(Java8Parser.StatementWithoutTrailingSubstatementContext stmt) {
         if(stmt.block() != null){
-            return convert(stmt.block());
+            return convert(stmt.block(), false);
         }else if(stmt.emptyStatement() != null){
             return new EmptyStmt(stmt.getStart());
         }else if(stmt.expressionStatement() != null){
@@ -121,14 +121,14 @@ public class StatementGenerator {
         }else throw new NotImplementedException();
     }
 
-    public Block convert(Java8Parser.BlockContext block) {
+    public Block convert(Java8Parser.BlockContext block, boolean addTrailingReturn) {
         List<Statement> statements = new ArrayList<>();
         if(block.blockStatements() != null)
             for(Java8Parser.BlockStatementContext statementContext : block.blockStatements().blockStatement()){
                 List<Statement> stmt = convert(statementContext);
                 statements.addAll(stmt);
             }
-        statements = SyntacticSugar.addTrailingReturn(statements);
+        if(addTrailingReturn)statements = SyntacticSugar.addTrailingReturn(statements);
         return new Block(statements, block.getStart());
     }
 
@@ -279,23 +279,24 @@ public class StatementGenerator {
     }
 
     private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
-        //TODO
-        throw new NotImplementedException();
+    		Expression argument = convert(stmt.unaryExpression());
+    		Token offset = stmt.getStart();
+    		return new UnaryExpr(UnaryExpr.Operation.PREINCREMENT, argument, TypePlaceholder.fresh(offset), offset);
     }
 
-    private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
-        //TODO
-        throw new NotImplementedException();
+	private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
+		return new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, convert(stmt.unaryExpression()),
+                TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
     }
 
     private Statement convert(Java8Parser.PostIncrementExpressionContext stmt) {
-        //TODO
-        throw new NotImplementedException();
+        return new UnaryExpr(UnaryExpr.Operation.POSTINCREMENT, convert(stmt.postfixExpression()),
+                TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
     }
 
     private Statement convert(Java8Parser.PostDecrementExpressionContext stmt) {
-        //TODO
-        throw new NotImplementedException();
+    		return new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, convert(stmt.postfixExpression()),
+                TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
     }
 
     private Statement convert(Java8Parser.AssignmentContext stmt) {
@@ -316,8 +317,10 @@ public class StatementGenerator {
     }
 
     private Statement convert(Java8Parser.IfThenElseStatementContext stmt){
-        //TODO
-        throw new NotImplementedException();
+        Expression expr = convert(stmt.expression());
+        Statement thenBlock = convert(stmt.statementNoShortIf());
+        Statement elseBlock = convert(stmt.statement());
+        return new IfStmt(TypePlaceholder.fresh(stmt.getStart()), expr, thenBlock, elseBlock, stmt.getStart());
     }
 
     private Statement convert(Java8Parser.IfThenElseStatementNoShortIfContext stmt){
@@ -541,8 +544,7 @@ public class StatementGenerator {
         if(expression.conditionalOrExpression() == null){
             return convert(expression.conditionalAndExpression());
         }else{
-            return new Binary(convert(expression.conditionalOrExpression()),
-                    convert(expression.conditionalAndExpression()), Binary.Operator.OR);
+            throw new NotImplementedException();
         }
     }
 
@@ -550,8 +552,7 @@ public class StatementGenerator {
         if(expression.conditionalAndExpression() == null){
             return convert(expression.inclusiveOrExpression());
         }else{
-            return new Binary(convert(expression.conditionalAndExpression()),
-                    convert(expression.inclusiveOrExpression()), Binary.Operator.AND);
+            throw new NotImplementedException();
         }
     }
 
@@ -588,11 +589,43 @@ public class StatementGenerator {
     }
 
     private Expression convert(Java8Parser.RelationalExpressionContext expression) {
-        if(expression.relationalExpression() == null){
+        if(expression.relationalExpression() == null) {
             return convert(expression.shiftExpression());
-        }else{
-            throw new NotImplementedException();
+        }else {
+            String operator = expression.getChild(1).getText();
+            return new BinaryExpr(convertBinaryOperator(operator), TypePlaceholder.fresh(expression.getStart()),
+                    convert(expression.relationalExpression()),
+                    convert(expression.shiftExpression()), expression.getStart());
         }
+            //}else throw new NotImplementedException();
+    }
+
+    private BinaryExpr.Operator convertBinaryOperator(String operator) {
+        //return BinaryExpr.Operator.ADD;
+    		if(operator.equals("+")) {
+    			return BinaryExpr.Operator.ADD;
+    		}else if(operator.equals("-")) {
+    			return BinaryExpr.Operator.SUB;
+    		}else if(operator.equals("*")) {
+    			return BinaryExpr.Operator.MUL;
+    		}else if(operator.equals("&")) {
+    			return BinaryExpr.Operator.AND;
+    		}else if(operator.equals("|")) {
+    			return BinaryExpr.Operator.OR;
+    		}else if(operator.equals("/")) {
+    			return BinaryExpr.Operator.DIV;
+    		}else if(operator.equals("<")) {
+    			return BinaryExpr.Operator.LESSTHAN;
+    		}else if(operator.equals(">")) {
+    			return BinaryExpr.Operator.BIGGERTHAN;
+    		}else if(operator.equals(">=")) {
+    			return BinaryExpr.Operator.BIGGEREQUAL;
+    		} else if(operator.equals("<=")) {
+    			return BinaryExpr.Operator.LESSEQUAL;
+    		} else {
+    			throw new NotImplementedException();
+    		}
+//    		throw new NotImplementedException();
     }
 
     private Expression convert(Java8Parser.ShiftExpressionContext expression) {
@@ -604,10 +637,15 @@ public class StatementGenerator {
     }
 
     private Expression convert(Java8Parser.AdditiveExpressionContext expression) {
+
         if(expression.additiveExpression() == null){
             return convert(expression.multiplicativeExpression());
-        }else{
-            throw new NotImplementedException();
+        }else {
+            Expression leftSide = convert(expression.additiveExpression());
+            Expression rightSide = convert(expression.multiplicativeExpression());
+            BinaryExpr.Operator op = convertBinaryOperator(expression.getChild(1).getText());
+            Token offset = expression.getStart();
+            return new BinaryExpr(op, TypePlaceholder.fresh(expression.getStart()), leftSide, rightSide, offset);
         }
     }
 
@@ -615,7 +653,11 @@ public class StatementGenerator {
         if(expression.multiplicativeExpression() == null){
             return convert(expression.unaryExpression());
         }else{
-            throw new NotImplementedException();
+        		Expression leftSide = convert(expression.multiplicativeExpression());
+        		Expression rightSide = convert(expression.unaryExpression());
+        		BinaryExpr.Operator op = convertBinaryOperator(expression.getChild(1).getText());
+        		Token offset = expression.getStart();
+        		return new BinaryExpr(op, TypePlaceholder.fresh(offset), leftSide, rightSide, offset);
         }
     }
 
@@ -627,9 +669,11 @@ public class StatementGenerator {
         }else if(expression.unaryExpressionNotPlusMinus() != null){
             return convert(expression.unaryExpressionNotPlusMinus());
         }else if(expression.getText().startsWith("+")){
-            return new UnaryPlus(convert(expression.unaryExpression()));
+            return new UnaryExpr(UnaryExpr.Operation.PLUS, convert(expression.unaryExpression()),
+                    TypePlaceholder.fresh(expression.getStart()), expression.getStart());
         }else if(expression.getText().startsWith("-")){
-            return new UnaryMinus(convert(expression.unaryExpression()));
+            return new UnaryExpr(UnaryExpr.Operation.MINUS, convert(expression.unaryExpression()),
+                    TypePlaceholder.fresh(expression.getStart()), expression.getStart());
         }else{
             //Diese Exceptions sollte nie geworfen werden.
             //Der Code wurde nur noch nicht getestet. Sollte zur Sicherheit drin bleiben.
@@ -672,10 +716,10 @@ public class StatementGenerator {
         }
 
         for(Java8Parser.PostIncrementExpression_lf_postfixExpressionContext inc : expression.postIncrementExpression_lf_postfixExpression()){
-            expr = new PostIncExpr(expr);
+            expr = new UnaryExpr(UnaryExpr.Operation.POSTINCREMENT, expr, TypePlaceholder.fresh(inc.getStart()), inc.getStart());
         }
         for(Java8Parser.PostDecrementExpression_lf_postfixExpressionContext dec : expression.postDecrementExpression_lf_postfixExpression()){
-            expr = new PostDecExpr(expr);
+            expr = new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, expr, TypePlaceholder.fresh(dec.getStart()), dec.getStart());
         }
 
         return expr;
@@ -701,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();
@@ -755,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();
@@ -771,25 +814,27 @@ public class StatementGenerator {
     private Expression convert(Java8Parser.LiteralContext literal) {
         if(literal.IntegerLiteral() != null || literal.FloatingPointLiteral()!= null){
             Number value = Double.parseDouble(literal.IntegerLiteral().getText());
-            return new NumberLiteral(TypePlaceholder.fresh(literal.getStart()),
+            return new Literal(TypePlaceholder.fresh(literal.getStart()),
                     value, literal.getStart());
         }else if(literal.BooleanLiteral() != null){
             RefType type = new RefType(reg.getName("java.lang.Boolean"),literal.getStart());
-            return new BoolLiteral(type,
+            return new Literal(type,
                     Boolean.parseBoolean(literal.BooleanLiteral().getText()),
                     literal.getStart());
         }else if(literal.CharacterLiteral() != null){
             RefType type = new RefType(reg.getName("java.lang.Character"),literal.getStart());
-            return new CharLiteral(type,
-                    literal.CharacterLiteral().getText().charAt(0),
+            return new Literal(type,
+            			// das gibt immer ' zurück, der Char befindet sich in Position 1 
+        				//literal.CharacterLiteral().getText().charAt(0),
+                    literal.CharacterLiteral().getText().charAt(1),
                     literal.getStart());
         }else if(literal.StringLiteral()!=null){
             RefType type = new RefType(reg.getName("java.lang.String"),literal.getStart());
-            return new StringLiteral(type,
+            return new Literal(type,
                     literal.StringLiteral().getText(),
                     literal.getStart());
         }else  if(literal.NullLiteral() != null){
-            return new Null(TypePlaceholder.fresh(literal.getStart()),
+            return new Literal(TypePlaceholder.fresh(literal.getStart()), null,
                     literal.getStart());
         }else {
             throw new NotImplementedException();
@@ -850,7 +895,7 @@ public class StatementGenerator {
                     expression.lambdaBody().expression().getStart()));
             block = new Block(statements, expression.lambdaBody().getStart());
         }else{
-            block = lambdaGenerator.convert(expression.lambdaBody().block());
+            block = lambdaGenerator.convert(expression.lambdaBody().block(), true);
         }
         List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
         funNParams.add(TypePlaceholder.fresh(expression.getStart()));//ret-Type

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

@@ -1,6 +1,9 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 
 import java.util.List;
@@ -10,22 +13,27 @@ public class SyntacticSugar {
     public static List<Statement> addTrailingReturn(List<Statement> statements){
         if(statements.size()!=0) {
             Statement lastStmt = statements.get(statements.size() - 1);
-            if (lastStmt instanceof Return) return statements;
-            if (lastStmt instanceof WhileStmt) {
-                //TODO
-                //if (hasReturn(((WhileStmt) lastStmt).loopBlock)) return statements;
-            } else if (lastStmt instanceof IfStmt) {
-                if (hasReturn(((IfStmt) lastStmt).then_block)
-                        && hasReturn(((IfStmt) lastStmt).else_block)) return statements;
-            } else if (lastStmt instanceof ForStmt) {
-                if (hasReturn(((ForStmt) lastStmt).body_Loop_block)) return statements;
-            } else {
-            }
+            ReturnFinder hasReturn = new ReturnFinder();
+            lastStmt.accept(hasReturn);
+            if(hasReturn.hasReturn)return statements;
         }
         statements.add(new ReturnVoid(new NullToken()));
         return statements;
     }
 
+    private static class ReturnFinder extends AbstractASTWalker{
+        public boolean hasReturn = false;
+        @Override
+        public void visit(Return aReturn) {
+            hasReturn = true;
+        }
+
+        @Override
+        public void visit(ReturnVoid aReturn) {
+            hasReturn = true;
+        }
+    }
+
     private static boolean hasReturn(Block block){
         for(Statement s : block.getStatements())
             if(s instanceof Return)return true;

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

@@ -1,10 +1,12 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
+import de.dhbwstuttgart.environment.PackageCrawler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import java.lang.ClassNotFoundException;
 
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
+import de.dhbwstuttgart.parser.scope.GatherNames;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
@@ -17,9 +19,8 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 import java.lang.reflect.Modifier;
 import java.sql.Ref;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
 
 //import jdk.internal.dynalink.support.TypeConverterFactory;
 import org.antlr.v4.runtime.CommonToken;
@@ -30,7 +31,7 @@ public class SyntaxTreeGenerator{
   private JavaClassRegistry reg;
   private final GenericsRegistry globalGenerics;
   private String pkgName = "";
-  List<JavaClassName> imports = new ArrayList();
+  Set<JavaClassName> imports = new HashSet();
 
   List<Statement> fieldInitializations = new ArrayList<>();
 
@@ -71,56 +72,11 @@ public class SyntaxTreeGenerator{
     return ret;
   }
   
-  public void setImports(Java8Parser.CompilationUnitContext ctx) throws ClassNotFoundException {
-    List<JavaClassName> newImports = new ArrayList();
-    for(Java8Parser.ImportDeclarationContext importDeclCtx : ctx.importDeclaration()){
-      if(importDeclCtx.singleTypeImportDeclaration() != null){
-        newImports.add(convertSingleTypeImportDeclaration(importDeclCtx.singleTypeImportDeclaration()));
-      }
-      else if(importDeclCtx.typeImportOnDemandDeclaration() != null){
-        newImports.addAll(convertTypeImportOnDemandDeclaration(importDeclCtx.typeImportOnDemandDeclaration()));
-      }
-      else if(importDeclCtx.singleStaticImportDeclaration() != null){
-        newImports.add(convertSingleStaticImportDeclaration(importDeclCtx.singleStaticImportDeclaration()));
-      }
-      else{
-        newImports.addAll(convertStaticImportOnDemandDeclaration(importDeclCtx.staticImportOnDemandDeclaration()));
-      }
-    }
-    this.imports.addAll(newImports);
-  }
-  
-  private JavaClassName convertSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx) throws ClassNotFoundException{
-    String typeName = convertTypeName(ctx.typeName());
-	JavaClassName ret = reg.getName(typeName);
-	return ret;
-  }
-  
-  private List<JavaClassName> convertTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx){
-    return reg.getAllFromPackage(ctx.packageOrTypeName().getText());
-  }
-  
-  private JavaClassName convertSingleStaticImportDeclaration(Java8Parser.SingleStaticImportDeclarationContext ctx){
-    throw new NotImplementedException();
-  }
-  
-  private List<JavaClassName> convertStaticImportOnDemandDeclaration(Java8Parser.StaticImportOnDemandDeclarationContext ctx){
-    return reg.getAllFromPackage(ctx.typeName().getText());
-  }
-  
-  private String getPackageFromClass(String cls){
-    String ret = "";
-    String[] parts = cls.split("\\.");
-    for(int i = 0; i < parts.length - 1; i++){
-      ret = ret + "." + parts[i];
-    }
-    ret = ret.substring(1);
-    return ret;
-  }
-  
-  public SourceFile convert(Java8Parser.CompilationUnitContext ctx) throws ClassNotFoundException{
+  public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler) throws ClassNotFoundException{
+    if(ctx.packageDeclaration()!=null)this.pkgName = convert(ctx.packageDeclaration());
     List<ClassOrInterface> classes = new ArrayList<>();
-    this.setImports(ctx);
+    Map<String, Integer> imports = GatherNames.getImports(ctx, packageCrawler);
+    this.imports = imports.keySet().stream().map(name -> reg.getName(name)).collect(Collectors.toSet());
     for(Java8Parser.TypeDeclarationContext typeDecl : ctx.typeDeclaration()){
       ClassOrInterface newClass;
       if(typeDecl.classDeclaration() != null){
@@ -134,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());
@@ -181,12 +146,12 @@ public class SyntaxTreeGenerator{
         //TODO: Error! Abstrakte Methode ohne abstrakt Keyword
       }
     }else{
-      block = stmtGen.convert(body.block());
+      block = stmtGen.convert(body.block(),true);
     }
     if(parentClass.equals(new JavaClassName(name))){
-      return new Constructor(modifiers, name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart(), fieldInitializations);
+      return new Constructor(modifiers, name, retType, parameterList, block, gtvDeclarations, header.getStart(), fieldInitializations);
     }else{
-      return new Method(modifiers, name, retType, modifiers, parameterList,block, gtvDeclarations, header.getStart());
+      return new Method(modifiers, name, retType, parameterList,block, gtvDeclarations, header.getStart());
     }
   }
 
@@ -209,7 +174,12 @@ public class SyntaxTreeGenerator{
         modifiers += newModifier;
       }
     }
-    JavaClassName name = reg.getName(ctx.Identifier().getText());
+    String className = this.pkgName + (this.pkgName.length()>0?".":"") + ctx.Identifier().getText();
+    JavaClassName name = reg.getName(className); //Holt den Package Namen mit dazu
+    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());
+    }
     GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "", reg, new GenericsRegistry(globalGenerics));
     Token offset = ctx.getStart();
     GenericDeclarationList genericClassParameters;
@@ -243,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) {
-    List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
+  private List<RefType> convert(Java8Parser.InterfaceTypeListContext ctx, GenericsRegistry generics) {
+    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;
   }
@@ -266,10 +236,9 @@ public class SyntaxTreeGenerator{
    */
   private Constructor generateStandardConstructor(String className, JavaClassName parentClass, RefType superClass, GenericDeclarationList classGenerics, Token offset){
     RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset);
-    int modifiers = 0;
     ParameterList params = new ParameterList(new ArrayList<>(), offset);
     Block block = new Block(new ArrayList<>(), offset);
-    return new Constructor(Modifier.PUBLIC, className, classType, modifiers, params, block, classGenerics, offset, fieldInitializations);
+    return new Constructor(Modifier.PUBLIC, className, classType, params, block, classGenerics, offset, fieldInitializations);
   }
 
   private RefType convert(Java8Parser.SuperclassContext superclass) {
@@ -424,6 +393,8 @@ public class SyntaxTreeGenerator{
         modifiers += newModifier;
       }
     }
+    if(!Modifier.isInterface(modifiers))modifiers += Modifier.INTERFACE;
+    
     JavaClassName name = reg.getName(ctx.Identifier().getText());
 
     GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "", reg, new GenericsRegistry(globalGenerics));
@@ -439,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());
@@ -456,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;
@@ -14,6 +13,7 @@ import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
@@ -22,27 +22,34 @@ 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);
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannTypeContext unannTypeContext, JavaClassRegistry reg, GenericsRegistry genericsRegistry) {
         if(unannTypeContext.unannPrimitiveType()!=null){
-            throw new NotImplementedException();
+            if(unannTypeContext.unannPrimitiveType().getText().equals("boolean")){
+                return new RefType(ASTFactory.createClass(Boolean.class).getClassName(), unannTypeContext.getStart());
+            }else{
+                Java8Parser.NumericTypeContext numericType = unannTypeContext.unannPrimitiveType().numericType();
+                throw new NotImplementedException();
+            }
         }else
         if(unannTypeContext.unannReferenceType().unannArrayType()!=null){
-            System.out.println(unannTypeContext.getText());
+            //System.out.println(unannTypeContext.getText());
             throw new NotImplementedException();
         }else
         if(unannTypeContext.unannReferenceType().unannTypeVariable()!=null){
@@ -69,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());
-        generics.put(name, new GenericContext(parentClass, parentMethod));
+        GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
         return ret;
     }
 
@@ -85,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()));
@@ -96,8 +102,9 @@ public class TypeGenerator {
         }
     }
 
-    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext) {
-        throw new NotImplementedException();
+    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
+        Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = classOrInterfaceTypeContext.classType_lfno_classOrInterfaceType();
+        return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),classOrInterfaceTypeContext.getStart(), reg, generics);
     }
 
     private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.InterfaceTypeContext interfaceTypeContext) {
@@ -107,8 +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 convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
+                return convert(referenceTypeContext.classOrInterfaceType(), reg, generics);//return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
             }else{
                 throw new NotImplementedException();
             }
@@ -125,13 +131,17 @@ 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);
             }
         }
         if(typeArguments == null){
-            return new RefType(reg.getName(name), offset);
+            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+            for(int i = 0; i<reg.getNumberOfGenerics(name);i++){
+                params.add(TypePlaceholder.fresh(offset));
+            }
+            return new RefType(reg.getName(name), params, offset);
         }else{
             return new RefType(reg.getName(name), convert(typeArguments, reg, generics), offset);
         }

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

@@ -1,7 +1,9 @@
 package de.dhbwstuttgart.parser.scope;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import de.dhbwstuttgart.parser.antlr.Java8BaseListener;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
@@ -13,8 +15,8 @@ import de.dhbwstuttgart.parser.antlr.Java8Parser;
 
 public class GatherNames {
 
-	  public static List<String> getNames(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException{
-		  List<String> ret = new ArrayList<>();
+	  public static Map<String, Integer> getNames(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException{
+		  Map<String, Integer> ret = new HashMap<>();
 	    String pkgName = getPackageName(ctx);
 	    String nameString = "";
 	    for (Java8Parser.TypeDeclarationContext typeDecl : ctx.typeDeclaration()){
@@ -26,6 +28,8 @@ public class GatherNames {
 	          else{
 	            nameString = typeDecl.interfaceDeclaration().normalInterfaceDeclaration().Identifier().toString();
 	          }
+				int numGenerics = typeDecl.interfaceDeclaration().normalInterfaceDeclaration().typeParameters()!=null?
+						typeDecl.interfaceDeclaration().normalInterfaceDeclaration().typeParameters().typeParameterList().typeParameter().size():0;
 	          //Die Generic TypeParameter Definitionen Nicht! an die JavaClassName-Registry anfügen:
 	          /* //Diese gelängen dadurch in den globalen Scope, was sie schließlich nicht sind
 	          if(typeDecl.classDeclaration().normalClassDeclaration().typeParameters() != null){
@@ -34,7 +38,7 @@ public class GatherNames {
 	            }
 	          }
 	          */
-	          ret.add(nameString);
+	          ret.put(nameString, numGenerics);
 	        }
 	      }
 	      else{
@@ -53,30 +57,36 @@ public class GatherNames {
 	            }
 	          }
 	          */
-	          ret.add(nameString);
+				int numGenerics = typeDecl.classDeclaration().normalClassDeclaration().typeParameters()!=null?
+						typeDecl.classDeclaration().normalClassDeclaration().typeParameters().typeParameterList().typeParameter().size():0;
+
+				ret.put(nameString, numGenerics);
 	        }
 	      }
 	    }
-	    ret.addAll(getImports(ctx, packages));
+	    ret.putAll(getImports(ctx, packages));
 	    return ret;
 	  }
 	  
 
-	  private static List<String> getImports(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException {
-	    List<String> ret = new ArrayList();
-		  ret.addAll(packages.getClassNames("java.lang"));
-	    for(Java8Parser.ImportDeclarationContext importDeclCtx : ctx.importDeclaration()){
+	  public static Map<String, Integer> getImports(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException {
+		  Map<String, Integer> ret = new HashMap<>();
+	    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
+		  //ret.putAll(packages.getClassNames("java.lang"));
+		  for(Java8Parser.ImportDeclarationContext importDeclCtx : ctx.importDeclaration()){
 	      if(importDeclCtx.singleTypeImportDeclaration() != null){
-	    	  ret.add(importDeclCtx.singleTypeImportDeclaration().typeName().getText());
+	    	  Class cl = classLoader.loadClass(importDeclCtx.singleTypeImportDeclaration().typeName().getText());
+			  ret.put(cl.getName(), cl.getTypeParameters().length);
 	      }
 	      else if(importDeclCtx.typeImportOnDemandDeclaration() != null){
-	    	  ret.addAll(packages.getClassNames(importDeclCtx.typeImportOnDemandDeclaration().packageOrTypeName().getText()));
+	    	  ret.putAll(packages.getClassNames(importDeclCtx.typeImportOnDemandDeclaration().packageOrTypeName().getText()));
 	      }
 	      else if(importDeclCtx.singleStaticImportDeclaration() != null){
-	    	  ret.add(importDeclCtx.singleStaticImportDeclaration().typeName().getText()+"."+importDeclCtx.singleStaticImportDeclaration().Identifier().getText());
-	      }
+			  Class cl = classLoader.loadClass(importDeclCtx.singleStaticImportDeclaration().typeName().getText()+"."+importDeclCtx.singleStaticImportDeclaration().Identifier().getText());
+			  ret.put(cl.getName(), cl.getTypeParameters().length);
+		  }
 	      else{
-	    	  ret.addAll(packages.getClassNames(importDeclCtx.staticImportOnDemandDeclaration().typeName().getText()));
+	    	  ret.putAll(packages.getClassNames(importDeclCtx.staticImportOnDemandDeclaration().typeName().getText()));
 	      }
 	    }
 	    return ret;

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/parser/scope/JavaClassName.java

@@ -49,8 +49,10 @@ public class JavaClassName {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + ((name == null) ? 0 : name.hashCode());
+		/*
 		result = prime * result
 				+ ((packageName == null) ? 0 : packageName.hashCode()); //PackageName does not infect hashCode
+		*/
 		return result;
 	}
 

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

@@ -8,20 +8,16 @@ import java.util.*;
  * Speichert die Klassen f<>r einen bestimmten Projektscope
  */
 public class JavaClassRegistry {
-    final List<JavaClassName> existingClasses = new ArrayList<>();
+    final Map<JavaClassName, Integer> existingClasses = new HashMap<>();
 
-    public JavaClassRegistry(List<String> initialNames){
-        for(String name : initialNames){
-            existingClasses.add(new JavaClassName(name));
+    public JavaClassRegistry(Map<String, Integer> initialNames){
+        for(String name : initialNames.keySet()){
+            existingClasses.put(new JavaClassName(name), initialNames.get(name));
         }
     }
-    
-    public void add(String className){
-        existingClasses.add(new JavaClassName(className));
-    }
 
     public JavaClassName getName(String className) {
-        for(JavaClassName name : existingClasses){
+        for(JavaClassName name : existingClasses.keySet()){
             if(name.equals(new JavaClassName(className)))return name;
         }
         throw new NotImplementedException();
@@ -34,7 +30,7 @@ public class JavaClassRegistry {
 
     public List<JavaClassName> getAllFromPackage(String packageName) {
         List<JavaClassName> ret = new ArrayList<>();
-        for(JavaClassName className : this.existingClasses){
+        for(JavaClassName className : this.existingClasses.keySet()){
             JavaClassName toCompare = new JavaClassName(packageName + "." + JavaClassName.stripClassName(className.toString()));
             if(toCompare.toString().equals(className.toString())){
                 ret.add(className);
@@ -44,6 +40,10 @@ public class JavaClassRegistry {
     }
 
     public boolean contains(String whole) {
-        return existingClasses.contains(new JavaClassName(whole));
+        return existingClasses.containsKey(new JavaClassName(whole));
+    }
+
+    public int getNumberOfGenerics(String name) {
+        return existingClasses.get(new JavaClassName(name));
     }
 }

src/de/dhbwstuttgart/sat/CNF/CNF.java

@@ -0,0 +1,8 @@
+package de.dhbwstuttgart.sat.CNF;
+
+public class CNF {
+    /*
+    Baut die CNF Datei.
+    Hier muss man überlegen, in welchem Form die Constraints gebaut werden
+     */
+}

src/de/dhbwstuttgart/sat/CNF/Writer.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.sat.CNF;
+
+import java.io.*;
+
+/**
+ * Schreibt CNFs in eine Datei im DIMACS CNF Format
+ */
+public class Writer {
+    public Writer(FileWriter output){
+
+    }
+}

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

@@ -0,0 +1,47 @@
+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 Clingo {
+    private final List<File> input;
+    private static final List<File> programFiles = new ArrayList<>();
+    static{
+        
+    }
+
+    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 =
+                "clingo";
+        List<String> commands = new ArrayList<>();
+        commands.add(pathToClingo);
+        //commands.add("--outf=2"); //use JSON-Output
+        commands.add("--outf=1"); //use Text-Output
+        commands.add("-n 0"); //Compute all models
+        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();
+        String result = IOUtils.toString(output, StandardCharsets.UTF_8);
+        return result;
+    }
+}

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

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.sat.asp.model;
+
+import de.dhbwstuttgart.bytecode.signature.Signature;
+
+public enum ASPRule {
+    ASP_PAIR_EQUALS_NAME("equals"),
+    ASP_PAIR_SMALLER_NAME("smaller"),
+    ASP_PAIR_SMALLER_DOT_NAME("smallerDot"),
+    ASP_PARAMLIST_NAME("param"),
+    ASP_TYPE("type"),
+    ASP_TYPE_VAR("typeVar"), ASP_ODER("oder"),
+    ASP_CONSTRAINT("constraint"),
+    ASP_LIST_NAME("list"),
+    ASP_LIST_ENDPOINTER("null");
+
+    private final String text;
+
+    private ASPRule(final String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String toString() {
+        return text;
+    }
+}

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

@@ -0,0 +1,188 @@
+package de.dhbwstuttgart.sat.asp.parser;
+
+import de.dhbwstuttgart.exceptions.DebugException;
+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.*;
+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);
+
+        Set<ResultPair> ret = new HashSet<>();
+        for(ASPResultParser.ResultSetRuleContext e : parseTree.resultSetRule()){
+            if(e.NAME().getText().equals(ASPRule.ASP_PAIR_EQUALS_NAME.toString())){
+                String tp1 = e.parameterList().value(0).getText();
+                String tp2 = e.parameterList().value(1).getText();
+                if(tphs.contains(tp1) && tphs.contains(tp2)){
+                    //Diese kann man ignorieren. Sollten eigentlich nicht auftauchen
+                    //ret.add(new PairTPHEqualTPH((TypePlaceholder) types.get(tp1), (TypePlaceholder) types.get(tp2)));
+                }else if(tphs.contains(tp1)){
+                    if(types.containsKey(tp2))
+                    ret.add(new PairTPHequalRefTypeOrWildcardType((TypePlaceholder) types.get(tp1), types.get(tp2)));
+                    else System.out.println(tp2);
+                }
+            }
+        }
+        this.resultSet = 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) { }
+}