Compare commits
183 Commits
sat
...
UnifyAllSo
Author | SHA1 | Date | |
---|---|---|---|
bc1a796e28 | |||
b8e229cf3f | |||
e0c5afcd6d | |||
9123e222f4 | |||
29bd9a3f4f | |||
7926c25c7d | |||
b4c604e2b1 | |||
d8bb4d6188 | |||
0ecaf36648 | |||
2eb7a63480 | |||
11649b39d3 | |||
303cfa5409 | |||
660ef68f7e | |||
23eab0c9a4 | |||
162ca3eb27 | |||
6d70464a1c | |||
04d3ac84e7 | |||
2db5ecc260 | |||
b325e205a1 | |||
ff2bca5ce5 | |||
66078360da | |||
bb26112a9b | |||
97d893e66b | |||
57fb90afaf | |||
63ac79f02c | |||
07fa62d11d | |||
66587a8f71 | |||
581e5e574e | |||
ae14dfd947 | |||
9d53d9d5d1 | |||
58f5e17ab5 | |||
6fce2760c5 | |||
1de897fb1f | |||
87dede5d5f | |||
f085f9f499 | |||
a40d2b991f | |||
704415ae3b | |||
65531ac12e | |||
34e632b872 | |||
3470215bae | |||
f5398fa8e9 | |||
f617ad8946 | |||
876ec6a4f6 | |||
26d9b1215f | |||
0f29bc038a | |||
a5ed5a2a46 | |||
c597b0430a | |||
06a0cb8eaf | |||
b5a601d798 | |||
7ea6777906 | |||
6b1896f58c | |||
d81c06cdd9 | |||
8baff8f376 | |||
bc2cab8c95 | |||
dca5d21c23 | |||
51a2acdbaf | |||
dcc36f082f | |||
9575afd0b4 | |||
5c797a44a1 | |||
87dbcfdad4 | |||
8048af2106 | |||
e4243b612c | |||
da4c59f2cf | |||
1c22fc7d57 | |||
0b7aea21d9 | |||
521a1cbf3b | |||
22ca2cbd4a | |||
49ea4ee283 | |||
225dc16a89 | |||
4738add4fc | |||
bc99dc4c8b | |||
2bbf9eac36 | |||
a785c85d42 | |||
ec2b501e63 | |||
8be4f94edf | |||
1b6cae1be0 | |||
41774b3faf | |||
62d44eb15c | |||
5f8c73f176 | |||
0ae777b4ac | |||
087170bdbf | |||
93d0caaefb | |||
1f031149d3 | |||
fc870fd706 | |||
4450f5c0cd | |||
478a2df3dc | |||
59243d9f94 | |||
82b08c5aae | |||
615983bf37 | |||
21bc2a67a1 | |||
52a96d7253 | |||
fef4d27d21 | |||
603c4c9c46 | |||
baee0024e9 | |||
1baaf79f8c | |||
52f480147e | |||
9717c54d53 | |||
c271c689de | |||
24c27303dd | |||
117106a7b3 | |||
5680f913ef | |||
32ab198f9e | |||
fae26a8f26 | |||
bb5a4e8580 | |||
a0de7a4467 | |||
0b680f831d | |||
95e9b2dbda | |||
dbe05bb718 | |||
4ac99b61bf | |||
f107c8d1f7 | |||
8870bc326c | |||
e1c6369bcb | |||
46255efb70 | |||
5dfa6769b2 | |||
100db9baac | |||
5d39863cc6 | |||
01dd4e57e6 | |||
6faffdf90c | |||
f4bc057aff | |||
78db0f0177 | |||
3233ccd845 | |||
b0b1426e20 | |||
103c7e4b14 | |||
3638edfa73 | |||
bd98bed5ca | |||
6299086297 | |||
de5b43d72b | |||
7e6dee8e1d | |||
dafcd2f125 | |||
273ddb92d7 | |||
dea3da3b69 | |||
13c70148a8 | |||
1667b394f2 | |||
95943b1627 | |||
0315a1f144 | |||
52a5fd7904 | |||
b5b5b5d9c9 | |||
9862df9e63 | |||
ccc16fd22b | |||
54cf24926e | |||
94d39ee21a | |||
f453343f1c | |||
bb016e6417 | |||
831bf1fe17 | |||
cba489f279 | |||
9f3439a15e | |||
356b8a7a34 | |||
6256bdfe2e | |||
6a9db81981 | |||
aa631b5099 | |||
a3a02fe475 | |||
cef82c6359 | |||
67fe88215a | |||
f31023b4fa | |||
a733eee8b5 | |||
15f5a2dc76 | |||
6fcaafe477 | |||
35b99a4095 | |||
6b57aacef0 | |||
2277f68509 | |||
1c0fa6a820 | |||
8e198679c7 | |||
419e4a6d0e | |||
5cd2ee7d80 | |||
9c35f04a09 | |||
89246ece5c | |||
5270cecec9 | |||
87fe51767c | |||
f0610aeff1 | |||
e4fbd17a55 | |||
1f269918fb | |||
5a3dcd7100 | |||
1a1ab2696d | |||
9186f5dff5 | |||
5c9b40e0b7 | |||
bd0678f362 | |||
a08e2e8815 | |||
47689f2fc6 | |||
b7aca99301 | |||
8920b32020 | |||
da41857a4f | |||
09dcdaeb96 | |||
6d0392956d |
.gitignoreREADME.mdpom.xml
asp
adaptRules.lpcartesian.lpfacultyTestInput.lpfc.lp.backupfc.lp.oldgreater.plpi.plreduceRules.lpresult.lprule5.testsmaller.plstep4.lpstep4.testsubst.lptestInput.lptestReduce.lptestUnifikation.lpunifikation.lpunifikation.lp.backupvectorTestInput.lp
maven-repository/de/dhbwstuttgart/JavaTXcompiler
0.1
JavaTXcompiler-0.1.jar.md5JavaTXcompiler-0.1.jar.sha1JavaTXcompiler-0.1.pomJavaTXcompiler-0.1.pom.md5JavaTXcompiler-0.1.pom.sha1
maven-metadata.xmlmaven-metadata.xml.md5maven-metadata.xml.sha1src/de/dhbwstuttgart
.DS_Store
bytecode
AStatement.javaArgumentExpr.javaAssignStmt.javaBytecodeGen.javaBytecodeGenMethod.javaIStatement.javaLoopStmt.javaReturnStmt.java
descriptor
signature
utilities
core
parser
SyntaxTreeGenerator
sat
asp
syntaxtree
typedeployment
typeinference
assumptions
constraints
typeAlgo
unify
MartelliMontanariUnify.javaRuleSet.javaTypeUnify.javaTypeUnifyTask.javadistributeVariance.javafreshPlaceholder.java
interfaces
model
ExtendsType.javaFiniteClosure.javaFunNType.javaOrderingUnifyPair.javaPair.javaPairOperator.javaPlaceholderType.javaReferenceType.javaSuperType.javaTypeParams.javaUnifier.javaUnifyPair.javaUnifyType.javaWildcardType.java
visitUnifyTypeVisitor.javatarget
test
asp
astfactory
bytecode
BinaryTest.javaFacTest.javaGenTest.javaGreaterEqualTest.javaGreaterThanTest.javaLambdaTest.javaLessEqualTest.javaLessThanTest.javaMatrixTest.javaOLTest.javaOpTest.javaOverloadingTest.javaPlusTest.javaPostIncTest.javaPreIncTest.javaRelOpsTest.javaStaticTest.javaTph2Test.javaTphTest.javaWhileTest.java
javFiles
AssignToLit.javBinaryInMeth.javDuMethod.javEmptyMethod.javExample.javExceptions.javFac.javFaculty.javFaculty2.javFor.javGen.javGenerics.javGenerics2.javGreaterEqual.javGreaterThan.javIfTest.javImport.javInterface1.javLamRunnable.javLambda.javLambda2.javLambda3.javLambda4.javLessEqual.javLessThan.javMatrix.javMethods.javOL.javOp.javOp2.javOverlaodGen.javOverloading.javPlus.javPostIncDec.javPreInc.javRecursiveMeth.javRelOps.javReturnMethod.javStaticM.javTph.javTph2.javVoidMeth.javWhile.jav
javFiles
AddLong.javFC_Matrix.javGenerics.javLambda.javLambdaField.javMatrix.javMatrixTest.javMeth_Gen.javVector.jav
logFiles
parser
AntlrTest.javBoundedParameter.javCastTest.javExtendsTest.javFeatherWeightJava.javFieldInitializationTest.javFieldVarTest.javGeneralParserTest.javaGenericFieldVarTest.javImportTest.javImportTest2.javImportTestGeneric.javNewTest.javOpratorTest.javPackageNameTest.javStatementsTest.javStructuralTypes.javWhileTest.jav
typeinference
visualisation
testBytecode
3
.gitignore
vendored
3
.gitignore
vendored
@ -20,3 +20,6 @@ bin
|
||||
.project
|
||||
.settings/
|
||||
/target/
|
||||
|
||||
#
|
||||
manually/
|
||||
|
19
README.md
Normal file
19
README.md
Normal file
@ -0,0 +1,19 @@
|
||||
|
||||
|
||||
# plugin site erstellen
|
||||
* die JAvaTXCOmpiler DAtei in ein plugin umwandeln und deployen.
|
||||
* siehe: http://www.vogella.com/tutorials/EclipseJarToPlugin/article.html#convert-jar-files-to-osgi-bundles-with-the-p2-maven-plugin
|
||||
* AUsführung:
|
||||
* mvn deploy #erstellt die JAR-Datei und steckt sie in ein lokales Repo (maven-repository)
|
||||
* mvn p2:site
|
||||
* mvn package # hier wird die ZIP-Filf zum Einbinden in Eclipse erstellt
|
||||
|
||||
# Einbinden in Eclipse
|
||||
* In Eclipse kann die Zip-FIle wie ein Plugin installiert werden
|
||||
* Hier tritt FEhler auf. Reflections-Library kann nicht installiert werden. Möglicherweise wird sie auch nicht gebraucht
|
||||
* Nach dem installieren de.dhbwstuttagrt.JavaTXcompiler zu den DEpendencies des plugins hinzufügen
|
||||
* Anschließend unter "Overview" auf "Updata Classpath" klicken
|
||||
|
||||
# Windows
|
||||
* JAVA_HOME setzen:
|
||||
* export JAVA_HOME=/c/Program\ Files/Java/jdk1.8.0_102/
|
@ -1,19 +0,0 @@
|
||||
%makeAdapt(smallerDot(CFC, DFC)) :- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
|
||||
%, smaller(CFC, DFC), type(CFC, CN, CNP), type(DFC, DN, DNP), mapRootFC(smaller(CFC, DFC), _, _)
|
||||
%.
|
||||
|
||||
|
||||
type(pointer(smallerDot(C,D)), DN, DNP)
|
||||
:- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
|
||||
.
|
||||
smallerDot(pointer(smallerDot(C,D)), D)
|
||||
:- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
|
||||
.
|
||||
|
||||
param(pointer(smallerDot(C,D)), P, P2)
|
||||
:- smallerDot(C, D), type(C, CN, CNP), type(D, DN, DNP), CNP != DNP
|
||||
, smaller(CFC, DFC), type(CFC, CN, CNP), type(DFC, DN, DNP)
|
||||
, pi(CFC, DFC, P1, P2), param(C, P, P1)
|
||||
.
|
||||
|
||||
|
@ -1,22 +0,0 @@
|
||||
|
||||
%Mit Hilfe von Quelle: https://www.cs.uni-potsdam.de/~torsten/Papers/asp4ki.pdf
|
||||
|
||||
%Dieser Code generiert das Karthesische Produkt der Constraints des Inputs.
|
||||
%und Constraints sind einfach weiterhin equals uns smallerDot
|
||||
%oder constraints:
|
||||
% oder(pointer, pointer)
|
||||
%constraints innerhalb des oders müssen eingepackt sein:
|
||||
% constraint(pointer, eigentlicher Constraint)
|
||||
% um mehrere constraints als Und-Constraint innerhalb eines Oders zu verbinden kann die list(..) verwendet werden
|
||||
|
||||
%Die eigentliche Oder-Verknüpfung:
|
||||
cons(Cons1), cons(Cons2) :- oder(C1, C2), constraint(C1, Cons1), constraint(C2, Cons2).
|
||||
|
||||
%Auspacken der constraints:
|
||||
equals(X,Y) :- cons(equals(X,Y)).
|
||||
smallerDot(X,Y) :- cons(smallerDot(X,Y)).
|
||||
oder(X,Y) :- cons(oder(X,Y)).
|
||||
list(X,Y) :- cons(list(X,Y)).
|
||||
equals(X,Y) :- list(equals(X,Y), _).
|
||||
smallerDot(X,Y) :- list(smallerDot(X,Y), _).
|
||||
list(A,B) :- list(_, list(A,B)).
|
@ -1,70 +0,0 @@
|
||||
typeVar(cRO).
|
||||
smaller(cAVP,cAVQ).
|
||||
type(cAVY,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cAVI,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cAVD,cjava_DOT_lang_DOT_Comparable,1).
|
||||
type(cAVH,cjava_DOT_lang_DOT_Comparable,1).
|
||||
type(cAVJ,cjava_DOT_lang_DOT_Number,0).
|
||||
typeVar(cT).
|
||||
equals(cQ,cRO).
|
||||
smaller(cAVR,cAVS).
|
||||
param(cAVZ,cYO,1).
|
||||
param(cAVZ,cYP,2).
|
||||
type(cAWD,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeVar(cO).
|
||||
smaller(cAVN,cAVO).
|
||||
type(cAWA,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cAVF,cjava_DOT_lang_DOT_Object,0).
|
||||
typeVar(cYA).
|
||||
type(cAVU,cjava_DOT_lang_DOT_Integer,0).
|
||||
equals(cN,cAVV).
|
||||
smaller(cAVB,cAVC).
|
||||
type(cAVO,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cAVB,cjava_DOT_io_DOT_Serializable,0).
|
||||
smallerDot(cT,cM).
|
||||
typeVar(cL).
|
||||
smallerDot(cM,cL).
|
||||
typeVar(cP).
|
||||
type(cAVQ,cjava_DOT_lang_DOT_Number,0).
|
||||
type(cAVR,cFaculty,0).
|
||||
smallerDot(cAWD,cAWE).
|
||||
typeVar(cYB).
|
||||
type(cAVE,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cAVN,cjava_DOT_lang_DOT_Number,0).
|
||||
equals(cT,cAVT).
|
||||
type(cAVV,cFaculty,0).
|
||||
type(cAVC,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cAVM,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cAVG,cAVH).
|
||||
type(cAVL,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cAWE,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cAVG,cjava_DOT_lang_DOT_Integer,0).
|
||||
param(cAVT,cAVU,2).
|
||||
typeVar(cYO).
|
||||
type(cAWB,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cAVW,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeVar(cM).
|
||||
param(cAVH,cAVI,1).
|
||||
typeVar(cQ).
|
||||
type(cAVX,cjava_DOT_lang_DOT_Integer,0).
|
||||
equals(cYA,cO).
|
||||
equals(cAWA,cP).
|
||||
smallerDot(cM,cAVZ).
|
||||
type(cAVK,cjava_DOT_io_DOT_Serializable,0).
|
||||
smallerDot(cP,cQ).
|
||||
smallerDot(cO,cAWB).
|
||||
param(cAVD,cAVE,1).
|
||||
smallerDot(cAVY,cYB).
|
||||
smallerDot(cAVW,cAVX).
|
||||
smaller(cAVD,cAVF).
|
||||
smaller(cAVL,cAVM).
|
||||
type(cAVP,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeVar(cYP).
|
||||
typeVar(cN).
|
||||
type(cAVT,cFun2,2).
|
||||
param(cAVT,cRO,1).
|
||||
type(cAVS,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cAWC,cFaculty,0).
|
||||
smallerDot(cN,cAWC).
|
||||
type(cAVZ,cFun2,2).
|
||||
smaller(cAVJ,cAVK).
|
125
asp/fc.lp.backup
125
asp/fc.lp.backup
@ -1,125 +0,0 @@
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%Anzahl Wildcards in einem Typ feststellen:
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%Start, am Ende der Parameterliste:
|
||||
wildcard(A) :- extendsWildcard(A).
|
||||
wildcard(A) :- superWildcard(A).
|
||||
numWildcards(TP, Ende-1, Num) :- param(TP, Param, Ende),
|
||||
numWildcards(Param, Num), type(TP,_,Ende)
|
||||
, not wildcard(Param)
|
||||
.
|
||||
numWildcards(TP, Ende-1, Num + 1) :- param(TP, Param, Ende),
|
||||
numWildcards(Param, Num), type(TP,_,Ende)
|
||||
, wildcard(Param)
|
||||
.
|
||||
%Anschließend aufsummieren:
|
||||
numWildcards(TP, ParamNum-1, NumWC1 + NumWC2 + 1) :- param(TP, Param, ParamNum),
|
||||
numWildcards(Param, NumWC1), numWildcards(TP,ParamNum, NumWC2)
|
||||
, wildcard(Param)
|
||||
.
|
||||
numWildcards(TP, ParamNum-1, NumWC1 + NumWC2) :- param(TP, Param, ParamNum),
|
||||
numWildcards(Param, NumWC1), numWildcards(TP,ParamNum, NumWC2)
|
||||
, not wildcard(Param)
|
||||
.
|
||||
|
||||
numWildcards(TP, Num) :- numWildcards(TP, 0, Num), param(TP, P, 1), wildcard(P).
|
||||
numWildcards(TP, Num) :- numWildcards(TP, 0, Num), param(TP, P, 1), not wildcard(P).
|
||||
numWildcards(TP, 0) :- type(TP, _, 0).
|
||||
numWildcards(TP, 0) :- typeVar(TP).
|
||||
|
||||
%%%%%%%%%%%%%%%%
|
||||
% Greater
|
||||
%%%%%%%%%%%%%%%%
|
||||
{ greaterGen(P, A, AFC, BFC) : smaller(AFC, BFC), type(AFC, AN, ANum) } == 1 :- greaterGen(P, A), type(A, AN, ANum)
|
||||
%, greaterArgGenNum(P, N), N < 100000
|
||||
.
|
||||
%:- greaterGen(A, _, _ , _), numWildcards(A, NW), NW >= 1.
|
||||
type(P, BN, BNum) :- greaterGen(P, A, _, B), type(B, BN, BNum).
|
||||
%Bei den Parametern gibt es zwei Fälle:
|
||||
%% Die TPHs müssen gemapt werden, die anderen übernommen
|
||||
greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(Afc, B), PNum, _).
|
||||
greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, _, B), param(B, Param, PNum), type(B, _, _).
|
||||
param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
|
||||
, type(Param, _, _)
|
||||
.
|
||||
param(P, pointer(P, Param), PNum2) :- greaterGen(P, A, Afc, B), param(A, Param, PNum)
|
||||
, mapFC(smaller(Afc,B), PNum, PNum2)
|
||||
.
|
||||
|
||||
%TypeVars bleiben einfach TypeVars:
|
||||
typeVar(Pointer) :- greaterArgGen(Pointer, T), typeVar(T).
|
||||
|
||||
makeGreaterGen(Pointer, T) :- greaterArgGen(Pointer, T), extendsWildcard(T).
|
||||
makeSmallerGen(Pointer, T) :- greaterArgGen(Pointer, T), superWildcard(T).
|
||||
makeSmallerGenG(Pointer, T),
|
||||
makeGreaterGenG(Pointer, T),
|
||||
makeSameGenG(Pointer, T)
|
||||
:- greaterArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
|
||||
|
||||
greaterGen(P, T) :- makeGreaterGenG(P, T).
|
||||
extendsWildcard(P) :- makeGreaterGenG(P, T).
|
||||
|
||||
smallerGen(P, T) :- makeGreaterGenG(P, T).
|
||||
superWildcard(P) :- makeSmallerGenG(P, T).
|
||||
|
||||
{ greaterGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenG(P, T), type(T, TN, TNum).
|
||||
|
||||
greaterArgGenNum(P, 0) :- greaterArgGen(P, _), type(P, _ ,_).
|
||||
greaterArgGenNum(pointer(P, P2), Num + 1) :- greaterArgGen(pointer(P, P2),_), greaterArgGenNum(P, Num).
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%
|
||||
% smaller
|
||||
%%%%%%%%%%%%%%%%
|
||||
{ smallerGen(P, A, AFC, BFC) : smaller(BFC, AFC), type(AFC, AN, ANum) } == 1 :- smallerGen(P, A), type(A, AN, ANum)
|
||||
.
|
||||
{ type(P, BN, BNum) : type(B,BN,BNum) } == 1 :- smallerGen(P, A, _, B).
|
||||
%Bei den Parametern gibt es drei Fälle:
|
||||
%% Die TPHs müssen gemapt werden, die anderen übernommen
|
||||
smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(B, Afc), _, PNum).
|
||||
param(P, pointer(P, Param), PNum2) :- smallerGen(P, A, Afc, B), param(A, Param, PNum)
|
||||
, mapFC(smaller(B,Afc), PNum2, PNum)
|
||||
.
|
||||
|
||||
%Neue Parameter können hinzu kommen: TODO
|
||||
%smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, _, B), param(B, Param, PNum).
|
||||
%param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
|
||||
% %, type(Param, _, _) %Es ist egal ob es ein Typparameter oder eine TypeVar ist. smallerArgGen macht das richtige
|
||||
% .
|
||||
|
||||
%Es können voraussetzungen hinzukommen:
|
||||
equals(Param, PA) :- smallerGen(P, A, Afc, B), param(Afc, Param, PNum), type(Param, _, _), param(A, PA, PNum).
|
||||
|
||||
%TypeVars bleiben einfach TypeVars:
|
||||
typeVar(Pointer) :- smallerArgGen(Pointer, T), typeVar(T).
|
||||
|
||||
makeSmallerGenS(Pointer, T) :- smallerArgGen(Pointer, T), extendsWildcard(T).
|
||||
makeGreaterGenS(Pointer, T) :- smallerArgGen(Pointer, T), superWildcard(T).
|
||||
makeSmallerGenS(Pointer, T),
|
||||
makeGreaterGenS(Pointer, T),
|
||||
makeSameGenS(Pointer, T)
|
||||
:- smallerArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
|
||||
|
||||
greaterGen(P, T) :- makeGreaterGenS(P, T).
|
||||
extendsWildcard(P) :- makeGreaterGenS(P, T).
|
||||
|
||||
smallerGen(P, T) :- makeSmallerGenS(P, T).
|
||||
superWildcard(P) :- makeSmallerGenS(P, T).
|
||||
|
||||
{ smallerGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenS(P, T), type(T, TN, TNum).
|
||||
|
||||
|
||||
%%%
|
||||
% Grundlegende Regeln
|
||||
%%%
|
||||
smaller(A, A) :- smaller(A, _).
|
||||
smaller(B, B) :- smaller(_, B).
|
||||
%smaller(A, A) :- type(A). %Alle Typen erben von sich selber. Hätte komische Nebeneffekte
|
||||
|
||||
%Mapping:
|
||||
mapFC(smaller(A,B), Num, Num2) :- smaller(A,B), param(A, P, Num), typeVar(P), param(B, P, Num2).
|
||||
|
||||
hasTypeInParameterList(A) :- type(A, _, _), param(A, P, _), type(P, _, _).
|
||||
mapRootFC(smaller(A,B), Num, Num2) :- smaller(A, B), not hasTypeInParameterList(A), param(A, P, Num), typeVar(P), param(B, P, Num2).
|
||||
|
110
asp/fc.lp.old
110
asp/fc.lp.old
@ -1,110 +0,0 @@
|
||||
|
||||
wildcard(A) :- extendsWildcard(A).
|
||||
wildcard(A) :- superWildcard(A).
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%Anzahl der Wildcards ist 1
|
||||
% Mehr benötigt man nicht verschachtelt
|
||||
% Dadurch ist numWildcards unnötig, man ändert einfach die grArg auf Wildcards
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
type(P, TN, TNum) :- makeSameGen(P, T), type(T, TN, TNum).
|
||||
param(P, TN, TNum) :- makeSameGen(P, T), param(T, TN, TNum).
|
||||
superWildcard(P) :- makeSameGen(P, T), superWildcard(T).
|
||||
extendsWildcard(P) :- makeSameGen(P, T), extendsWildcard(T).
|
||||
|
||||
%%%%%%%%%%%%%%%%%
|
||||
% Greater
|
||||
%%%%%%%%%%%%%%%%
|
||||
{ greaterGen(P, A, AFC, BFC) : smaller(AFC, BFC), type(AFC, AN, ANum) } == 1 :- greaterGen(P, A), type(A, AN, ANum)
|
||||
.
|
||||
|
||||
type(P, BN, BNum) :- greaterGen(P, A, _, B), type(B, BN, BNum).
|
||||
%Bei den Parametern gibt es zwei Fälle:
|
||||
%% Die TPHs müssen gemapt werden, die anderen übernommen
|
||||
greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(Afc, B), PNum, _).
|
||||
greaterArgGen(pointer(P, Param), Param) :- greaterGen(P, A, _, B), param(B, Param, PNum), type(B, _, _).
|
||||
param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
|
||||
, type(Param, _, _)
|
||||
.
|
||||
param(P, pointer(P, Param), PNum2) :- greaterGen(P, A, Afc, B), param(A, Param, PNum)
|
||||
, mapFC(smaller(Afc,B), PNum, PNum2)
|
||||
.
|
||||
|
||||
%TypeVars bleiben einfach TypeVars:
|
||||
typeVar(Pointer) :- greaterArgGen(Pointer, T), typeVar(T).
|
||||
|
||||
%makeGreaterGen(Pointer, T) :- greaterArgGen(Pointer, T), extendsWildcard(T).
|
||||
%makeSmallerGen(Pointer, T) :- greaterArgGen(Pointer, T), superWildcard(T).
|
||||
makeSameGen(Pointer, T) :- greaterArgGen(Pointer, T), extendsWildcard(T).
|
||||
makeSameGen(Pointer, T) :- greaterArgGen(Pointer, T), superWildcard(T).
|
||||
makeSmallerGenG(Pointer, T),
|
||||
makeGreaterGenG(Pointer, T),
|
||||
makeSameGenG(Pointer, T)
|
||||
:- greaterArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
|
||||
|
||||
greaterGen(P, T) :- makeGreaterGenG(P, T).
|
||||
extendsWildcard(P) :- makeGreaterGenG(P, T).
|
||||
|
||||
smallerGen(P, T) :- makeGreaterGenG(P, T).
|
||||
superWildcard(P) :- makeSmallerGenG(P, T).
|
||||
|
||||
{ greaterGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenG(P, T), type(T, TN, TNum).
|
||||
|
||||
greaterArgGenNum(P, 0) :- greaterArgGen(P, _), type(P, _ ,_).
|
||||
greaterArgGenNum(pointer(P, P2), Num + 1) :- greaterArgGen(pointer(P, P2),_), greaterArgGenNum(P, Num).
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%
|
||||
% smaller
|
||||
%%%%%%%%%%%%%%%%
|
||||
{ smallerGen(P, A, AFC, BFC) : smaller(BFC, AFC), type(AFC, AN, ANum) } == 1 :- smallerGen(P, A), type(A, AN, ANum)
|
||||
.
|
||||
{ type(P, BN, BNum) : type(B,BN,BNum) } == 1 :- smallerGen(P, A, _, B).
|
||||
%Bei den Parametern gibt es drei Fälle:
|
||||
%% Die TPHs müssen gemapt werden, die anderen übernommen
|
||||
smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, Afc, B), param(A, Param, PNum), mapFC(smaller(B, Afc), _, PNum).
|
||||
param(P, pointer(P, Param), PNum2) :- smallerGen(P, A, Afc, B), param(A, Param, PNum)
|
||||
, mapFC(smaller(B,Afc), PNum2, PNum)
|
||||
.
|
||||
|
||||
%Neue Parameter können hinzu kommen: TODO
|
||||
%smallerArgGen(pointer(P, Param), Param) :- smallerGen(P, A, _, B), param(B, Param, PNum).
|
||||
%param(P, pointer(P, Param), PNum) :- greaterGen(P, A, _, B), param(B, Param, PNum)
|
||||
% %, type(Param, _, _) %Es ist egal ob es ein Typparameter oder eine TypeVar ist. smallerArgGen macht das richtige
|
||||
% .
|
||||
|
||||
%Es können voraussetzungen hinzukommen:
|
||||
equals(Param, PA) :- smallerGen(P, A, Afc, B), param(Afc, Param, PNum), type(Param, _, _), param(A, PA, PNum).
|
||||
|
||||
%TypeVars bleiben einfach TypeVars:
|
||||
typeVar(Pointer) :- smallerArgGen(Pointer, T), typeVar(T).
|
||||
|
||||
makeSameGen(Pointer, T) :- smallerArgGen(Pointer, T), extendsWildcard(T).
|
||||
makeSameGen(Pointer, T) :- smallerArgGen(Pointer, T), superWildcard(T).
|
||||
makeSmallerGenS(Pointer, T),
|
||||
makeGreaterGenS(Pointer, T),
|
||||
makeSameGenS(Pointer, T)
|
||||
:- smallerArgGen(Pointer, T), not extendsWildcard(T), not superWildcard(T), type(T, N, Num).
|
||||
|
||||
greaterGen(P, T) :- makeGreaterGenS(P, T).
|
||||
extendsWildcard(P) :- makeGreaterGenS(P, T).
|
||||
|
||||
smallerGen(P, T) :- makeSmallerGenS(P, T).
|
||||
superWildcard(P) :- makeSmallerGenS(P, T).
|
||||
|
||||
{ smallerGen(P, T, TFC, TFC) : smaller(TFC, _), type(TFC, TN, TNum) } == 1 :- makeSameGenS(P, T), type(T, TN, TNum).
|
||||
|
||||
|
||||
%%%
|
||||
% Grundlegende Regeln
|
||||
%%%
|
||||
smaller(A, A) :- smaller(A, _).
|
||||
smaller(B, B) :- smaller(_, B).
|
||||
%smaller(A, A) :- type(A). %Alle Typen erben von sich selber. Hätte komische Nebeneffekte
|
||||
|
||||
%Mapping:
|
||||
mapFC(smaller(A,B), Num, Num2) :- smaller(A,B), param(A, P, Num), typeVar(P), param(B, P, Num2).
|
||||
|
||||
hasTypeInParameterList(A) :- type(A, _, _), param(A, P, _), type(P, _, _).
|
||||
mapRootFC(smaller(A,B), Num, Num2) :- smaller(A, B), not hasTypeInParameterList(A), param(A, P, Num), typeVar(P), param(B, P, Num2).
|
||||
|
@ -1,17 +0,0 @@
|
||||
{ fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)) : type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8) } == 1 :- greaterGen(V1,V2).
|
||||
{ fun19(typeVar(V15),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : typeVar(V15) ; fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), extendsWildcard(V15), type(V15,V16,V17) ; fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)) : superWildcard(V15), notExtends(V15), type(V15,V16,V17) } == 1 :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14).
|
||||
param(V2,V15,V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), typeVar(V15), fun19(typeVar(V15),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
param(V2,V15,V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
superWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
smallerGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun21(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
superWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
smallerGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun22(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
extendsWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
greaterGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun23(notSuper(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
extendsWildcard(pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
param(V2,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
greaterGen(V15,pointer(greaterGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)), param(V1,V15,V13), pi(V7,V8,V13,V14), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun24(superWildcard(V15),notExtends(V15),type(V15,V16,V17),greaterGen(V1,V2),greaterGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)),param(V1,V15,V13),pi(V7,V8,V13,V14)).
|
||||
type(V2,V9,V12) :- greaterGen(V1,V2), greaterGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V7,V8), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V7,V8),greaterGen(V1,V2)).
|
@ -1,4 +0,0 @@
|
||||
pi(V1,V2,V4,V5) :- typeVar(V3), param(V1,V3,V4), param(V2,V3,V5), type(V1,V10,V8), param(V1,V9,V7), typeVar(V9), V7 = 1 .. V8, type(V2,V14,V12), param(V2,V13,V11), typeVar(V13), V11 = 1 .. V12.
|
||||
|
||||
notSuper(V1) :- type(V1,_,_), not superWildcard(V1).
|
||||
notExtends(V1) :- type(V1,_,_), not extendsWildcard(V1).
|
@ -1,44 +0,0 @@
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
% reduce1
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
smallerDotWC(CP, DP)
|
||||
:- smallerDot(C, D), type(C, CN, NP), type(D, DN, NP)
|
||||
, type(CFC, CN, NP), type(DFC, DN, NP), smaller(CFC, DFC)
|
||||
, pi(CFC, DFC, N, N2)
|
||||
, param(C, CP, N), param(D, DP, N2), N = 1 .. NP
|
||||
.
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
% reduceExt
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
%TODO
|
||||
%smallerDotWC(CP, DP)
|
||||
%:- smallerDotWC(C, D), type(C, CN, NP), type(D, DN, NP)
|
||||
%, type(CFC, CN, NP), type(DFC, DN, NP), smaller(CFC, DFC)
|
||||
%, pi(CFC, DFC, N, N2)
|
||||
%, param(C, CP, N), param(D, DP, N2), N = 1 .. NP
|
||||
%.
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
% reduceEq
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
equals(CP, DP)
|
||||
:- smallerDot(C, D), type(C, CN, NP), type(D, CN, NP)
|
||||
, param(C, CP, N), param(D, DP, N), N = 1 .. NP
|
||||
.
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
% reduce2
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
equals(P1, P2) :- equals(C, D), type(C, CN, NP), type(D, CN, NP)
|
||||
, param(C, P1, N), param(D, P2, N)
|
||||
.
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
% swap
|
||||
%%%%%%%%%%%%%%%%%%%%
|
||||
equals(A, B) :- equals(B, A), typeVar(A), not typeVar(B).
|
@ -1 +0,0 @@
|
||||
:- equals(A, B), equals(A, C), type(B,BN,_), type(C,CN,_), CN != BN.
|
291
asp/rule5.test
291
asp/rule5.test
@ -1,291 +0,0 @@
|
||||
param(cEPQ,cAEG,1).
|
||||
param(cEQX,cAEG,1).
|
||||
param(cEQE,cAEG,1).
|
||||
typeVar(cBFS).
|
||||
type(cEON,cjava_DOT_io_DOT_Serializable,0).
|
||||
constraint(cESK,list(equals(cESN,cM),list(smallerDot(cL,cESM),list(smallerDot(cESL,cQC),null)))).
|
||||
type(cESM,cjava_DOT_util_DOT_ArrayList,1).
|
||||
param(cERA,cDKY,1).
|
||||
param(cEQM,cDKY,1).
|
||||
type(cEQE,cjava_DOT_util_DOT_List,1).
|
||||
type(cEQI,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cEPS,cjava_DOT_util_DOT_AbstractList,1).
|
||||
param(cEQD,cBFS,1).
|
||||
type(cEPQ,cjava_DOT_lang_DOT_Iterable,1).
|
||||
type(cEOM,cjava_DOT_util_DOT_ArrayList,1).
|
||||
smaller(cEOW,cEOX).
|
||||
type(cEPV,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cERQ,cCII,1).
|
||||
param(cEPY,cDKY,1).
|
||||
smaller(cEPM,cEPN).
|
||||
param(cEOQ,cBFS,1).
|
||||
smaller(cEQC,cEQD).
|
||||
type(cERM,cjava_DOT_util_DOT_Vector,1).
|
||||
param(cESJ,cQF,1).
|
||||
type(cESN,cjava_DOT_lang_DOT_Boolean,0).
|
||||
smaller(cEPI,cEPJ).
|
||||
type(cERJ,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cEQA,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cEOA,cjava_DOT_util_DOT_ArrayList,1).
|
||||
param(cEOT,cBFS,1).
|
||||
type(cEOW,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cEPC,cCII,1).
|
||||
type(cEQB,cjava_DOT_util_DOT_AbstractList,1).
|
||||
param(cENS,cCII,1).
|
||||
type(cEQS,cjava_DOT_util_DOT_Collection,1).
|
||||
typeVar(cDKY).
|
||||
type(cEPU,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
smaller(cEQG,cEQH).
|
||||
type(cEQJ,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEQG,cCII,1).
|
||||
param(cEPN,cCII,1).
|
||||
param(cESE,cDKY,1).
|
||||
param(cEQZ,cBFS,1).
|
||||
type(cERK,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cEPE,cEPF).
|
||||
type(cEOK,cjava_DOT_util_DOT_ArrayList,1).
|
||||
typeVar(cQC).
|
||||
smaller(cERE,cERF).
|
||||
param(cEOA,cCII,1).
|
||||
type(cEQQ,cjava_DOT_lang_DOT_Iterable,1).
|
||||
smaller(cEPA,cEPB).
|
||||
typeVar(cM).
|
||||
smaller(cERA,cERB).
|
||||
type(cEPP,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEPS,cCII,1).
|
||||
param(cENQ,cAEG,1).
|
||||
param(cEPH,cCII,1).
|
||||
smaller(cERW,cERX).
|
||||
type(cEOG,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cERE,cjava_DOT_io_DOT_Serializable,0).
|
||||
param(cERG,cDKY,1).
|
||||
smaller(cERS,cERT).
|
||||
param(cEOF,cBFS,1).
|
||||
type(cESA,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cERY,cDKY,1).
|
||||
typeVar(cCII).
|
||||
type(cEOO,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cERN,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
param(cENO,cBFS,1).
|
||||
typeVar(cAEG).
|
||||
type(cERB,cjava_DOT_lang_DOT_Object,0).
|
||||
typeVar(cQD).
|
||||
param(cEQP,cAEG,1).
|
||||
param(cEOO,cAEG,1).
|
||||
type(cESF,cjava_DOT_io_DOT_Serializable,0).
|
||||
param(cEPE,cBFS,1).
|
||||
type(cEPG,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cEPD,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cERC,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
type(cERQ,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cENW,cjava_DOT_lang_DOT_Iterable,1).
|
||||
type(cENQ,cjava_DOT_util_DOT_ArrayList,1).
|
||||
smaller(cESC,cESD).
|
||||
type(cEOU,cjava_DOT_util_DOT_List,1).
|
||||
smaller(cENO,cENP).
|
||||
smaller(cEOE,cEOF).
|
||||
smaller(cERO,cERP).
|
||||
type(cEPH,cjava_DOT_util_DOT_List,1).
|
||||
smaller(cESE,cESF).
|
||||
param(cERO,cCII,1).
|
||||
param(cEOS,cBFS,1).
|
||||
type(cEQX,cjava_DOT_util_DOT_List,1).
|
||||
type(cEQR,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEQY,cBFS,1).
|
||||
smaller(cEQW,cEQX).
|
||||
smaller(cEOC,cEOD).
|
||||
smaller(cERM,cERN).
|
||||
param(cEPT,cCII,1).
|
||||
param(cEQQ,cBFS,1).
|
||||
param(cERZ,cDKY,1).
|
||||
type(cENV,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
type(cEOZ,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEQK,cAEG,1).
|
||||
type(cEQO,cjava_DOT_util_DOT_AbstractList,1).
|
||||
type(cEQU,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cEOK,cEOL).
|
||||
type(cEQW,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cENO,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cERF,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEPA,cCII,1).
|
||||
type(cERV,cjava_DOT_io_DOT_Serializable,0).
|
||||
smaller(cERG,cERH).
|
||||
param(cEOU,cCII,1).
|
||||
param(cENU,cDKY,1).
|
||||
param(cESM,cQE,1).
|
||||
param(cEOP,cAEG,1).
|
||||
param(cEPO,cBFS,1).
|
||||
param(cEOK,cBFS,1).
|
||||
constraint(cESG,list(smallerDot(cL,cESJ),list(equals(cESI,cM),list(smallerDot(cESH,cQD),null)))).
|
||||
type(cEPE,cjava_DOT_util_DOT_ArrayList,1).
|
||||
param(cEQF,cAEG,1).
|
||||
smaller(cEPY,cEPZ).
|
||||
param(cESC,cDKY,1).
|
||||
param(cENY,cAEG,1).
|
||||
param(cEOM,cAEG,1).
|
||||
smaller(cEQO,cEQP).
|
||||
type(cEOR,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cESC,cjava_DOT_util_DOT_List,1).
|
||||
type(cEOP,cjava_DOT_lang_DOT_Iterable,1).
|
||||
type(cERU,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cERY,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cEPL,cAEG,1).
|
||||
param(cEOX,cAEG,1).
|
||||
type(cEQK,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cERZ,cjava_DOT_util_DOT_Collection,1).
|
||||
param(cEQA,cBFS,1).
|
||||
param(cERI,cDKY,1).
|
||||
smaller(cEPC,cEPD).
|
||||
type(cEQT,cjava_DOT_lang_DOT_Iterable,1).
|
||||
type(cERT,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cEOY,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
param(cEQU,cDKY,1).
|
||||
type(cEPB,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
type(cESI,cjava_DOT_lang_DOT_Boolean,0).
|
||||
smaller(cENU,cENV).
|
||||
type(cESE,cjava_DOT_util_DOT_Vector,1).
|
||||
param(cEOG,cCII,1).
|
||||
type(cEOI,cjava_DOT_util_DOT_List,1).
|
||||
type(cENU,cjava_DOT_util_DOT_AbstractList,1).
|
||||
smaller(cERU,cERV).
|
||||
type(cEPN,cjava_DOT_util_DOT_AbstractList,1).
|
||||
type(cEQV,cjava_DOT_util_DOT_List,1).
|
||||
type(cEPA,cjava_DOT_util_DOT_AbstractList,1).
|
||||
smaller(cEPQ,cEPR).
|
||||
type(cEQL,cjava_DOT_util_DOT_AbstractList,1).
|
||||
param(cEQH,cCII,1).
|
||||
type(cEOL,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
type(cEQY,cjava_DOT_util_DOT_AbstractList,1).
|
||||
type(cEOF,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cEQT,cBFS,1).
|
||||
smaller(cEOS,cEOT).
|
||||
type(cENR,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
type(cEQD,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cENZ,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEPG,cCII,1).
|
||||
type(cEQF,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cEQN,cjava_DOT_util_DOT_List,1).
|
||||
type(cEQH,cjava_DOT_util_DOT_Collection,1).
|
||||
smaller(cEOY,cEOZ).
|
||||
type(cERR,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
param(cERU,cCII,1).
|
||||
type(cESB,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cEPO,cEPP).
|
||||
param(cEPU,cDKY,1).
|
||||
param(cEQI,cDKY,1).
|
||||
smaller(cEQE,cEQF).
|
||||
smaller(cEQA,cEQB).
|
||||
type(cEPM,cjava_DOT_util_DOT_ArrayList,1).
|
||||
param(cENW,cCII,1).
|
||||
param(cEOE,cBFS,1).
|
||||
type(cEOX,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cEQG,cjava_DOT_util_DOT_List,1).
|
||||
param(cERH,cDKY,1).
|
||||
smaller(cEQI,cEQJ).
|
||||
param(cEOC,cAEG,1).
|
||||
type(cEPT,cjava_DOT_util_DOT_List,1).
|
||||
type(cEOT,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cERP,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cERS,cMyVector,0).
|
||||
type(cESD,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cEOD,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
smaller(cEPK,cEPL).
|
||||
type(cEPK,cjava_DOT_util_DOT_AbstractList,1).
|
||||
param(cERM,cDKY,1).
|
||||
smaller(cEPG,cEPH).
|
||||
type(cEOS,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cEQS,cBFS,1).
|
||||
param(cEQW,cAEG,1).
|
||||
type(cENY,cjava_DOT_util_DOT_Collection,1).
|
||||
param(cEPW,cBFS,1).
|
||||
type(cEOJ,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEQC,cBFS,1).
|
||||
type(cENT,cjava_DOT_lang_DOT_Iterable,1).
|
||||
param(cERK,cDKY,1).
|
||||
type(cEPY,cjava_DOT_util_DOT_Vector,1).
|
||||
type(cEQM,cjava_DOT_util_DOT_AbstractList,1).
|
||||
smaller(cENW,cENX).
|
||||
smaller(cEPW,cEPX).
|
||||
smaller(cEOM,cEON).
|
||||
smaller(cEQM,cEQN).
|
||||
smaller(cEPS,cEPT).
|
||||
type(cENX,cjava_DOT_lang_DOT_Object,0).
|
||||
smallerDot(cL,cK).
|
||||
type(cESJ,cjava_DOT_util_DOT_Vector,1).
|
||||
type(cEQC,cjava_DOT_util_DOT_List,1).
|
||||
type(cEOB,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
smaller(cEOU,cEOV).
|
||||
param(cERC,cAEG,1).
|
||||
smaller(cEQU,cEQV).
|
||||
type(cERG,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cESH,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cEOQ,cEOR).
|
||||
oder(cESG,cESK).
|
||||
smaller(cEQQ,cEQR).
|
||||
param(cEPD,cCII,1).
|
||||
type(cEPZ,cjava_DOT_util_DOT_AbstractList,1).
|
||||
param(cEQL,cAEG,1).
|
||||
type(cEPC,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
smaller(cENS,cENT).
|
||||
param(cESA,cBFS,1).
|
||||
type(cERA,cjava_DOT_lang_DOT_Iterable,1).
|
||||
smaller(cEQY,cEQZ).
|
||||
typeVar(cQE).
|
||||
type(cEOE,cjava_DOT_util_DOT_AbstractList,1).
|
||||
type(cESL,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cERX,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cENP,cjava_DOT_util_DOT_List,1).
|
||||
type(cEPI,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
typeVar(cK).
|
||||
smaller(cERK,cERL).
|
||||
type(cERD,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cERI,cjava_DOT_util_DOT_List,1).
|
||||
type(cEPJ,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cESA,cESB).
|
||||
type(cEOC,cjava_DOT_util_DOT_ArrayList,1).
|
||||
param(cEOW,cAEG,1).
|
||||
param(cERJ,cDKY,1).
|
||||
param(cEQB,cBFS,1).
|
||||
smaller(cEOI,cEOJ).
|
||||
type(cEPL,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cEQO,cAEG,1).
|
||||
smaller(cERI,cERJ).
|
||||
typeVar(cQF).
|
||||
param(cEPK,cAEG,1).
|
||||
param(cENP,cBFS,1).
|
||||
type(cERO,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
typeVar(cL).
|
||||
smaller(cEOG,cEOH).
|
||||
param(cEQV,cDKY,1).
|
||||
type(cERW,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cEQZ,cjava_DOT_util_DOT_List,1).
|
||||
type(cENS,cjava_DOT_util_DOT_Collection,1).
|
||||
smaller(cENY,cENZ).
|
||||
param(cEOI,cAEG,1).
|
||||
smaller(cEOO,cEOP).
|
||||
smaller(cERY,cERZ).
|
||||
param(cEPZ,cDKY,1).
|
||||
param(cEQN,cDKY,1).
|
||||
smaller(cEQK,cEQL).
|
||||
type(cEOH,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cEPF,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
smaller(cERC,cERD).
|
||||
type(cEPO,cjava_DOT_util_DOT_List,1).
|
||||
type(cEPR,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cEQP,cjava_DOT_util_DOT_List,1).
|
||||
smaller(cEQS,cEQT).
|
||||
type(cERL,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
param(cENT,cCII,1).
|
||||
type(cEOQ,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cEPW,cjava_DOT_util_DOT_ArrayList,1).
|
||||
type(cEPX,cjava_DOT_io_DOT_Serializable,0).
|
||||
smaller(cEPU,cEPV).
|
||||
smaller(cEOA,cEOB).
|
||||
type(cEOV,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cEPB,cCII,1).
|
||||
smaller(cENQ,cENR).
|
||||
param(cEPM,cCII,1).
|
||||
smaller(cERQ,cERR).
|
||||
param(cENV,cDKY,1).
|
||||
type(cERH,cjava_DOT_lang_DOT_Iterable,1).
|
||||
|
@ -1,15 +0,0 @@
|
||||
{ fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)) : type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7) } == 1 :- smallerGen(V1,V2).
|
||||
{ fun19(typeVar(V15),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : typeVar(V15) ; fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : notSuper(V15), notExtends(V15), type(V15,V16,V17) ; fun21(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : superWildcard(V15), notExtends(V15), type(V15,V16,V17) ; fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : superWildcard(V15), notExtends(V15), type(V15,V16,V17) ; fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : notSuper(V15), extendsWildcard(V15), type(V15,V16,V17) ; fun24(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)) : notSuper(V15), extendsWildcard(V15), type(V15,V16,V17) } == 1 :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13).
|
||||
param(V2,V15,V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), typeVar(V15), fun19(typeVar(V15),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
param(V2,V15,V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), notExtends(V15), type(V15,V16,V17), fun20(notSuper(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun21(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
greaterGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun21(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
superWildcard(pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
greaterGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), superWildcard(V15), notExtends(V15), type(V15,V16,V17), fun22(superWildcard(V15),notExtends(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
extendsWildcard(pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
smallerGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun23(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
param(V2,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17)),V14) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun24(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
smallerGen(V15,pointer(smallerGen(V1,V2), notSuper(V15), notExtends(V15), type(V15,V16,V17))) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)), param(V1,V15,V13), pi(V8,V7,V14,V13), notSuper(V15), extendsWildcard(V15), type(V15,V16,V17), fun24(notSuper(V15),extendsWildcard(V15),type(V15,V16,V17),smallerGen(V1,V2),smallerGen(V1,V2),type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)),param(V1,V15,V13),pi(V8,V7,V14,V13)).
|
||||
type(V2,V9,V12) :- smallerGen(V1,V2), smallerGen(V1,V2), type(V1,V10,V11), type(V7,V10,V11), type(V8,V9,V12), smaller(V8,V7), fun18(type(V1,V10,V11),type(V7,V10,V11),type(V8,V9,V12),smaller(V8,V7),smallerGen(V1,V2)).
|
116
asp/step4.lp
116
asp/step4.lp
@ -1,116 +0,0 @@
|
||||
wildcard(A) :- superWildcard(A).
|
||||
wildcard(A) :- extendsWildcard(A).
|
||||
|
||||
%Problem hier: Es gibt in der FiniteClosure nun smaller Beziehungen der Art:
|
||||
%%(Matrix<A> <) Vector<Vector<A>> < List<Vector<A>>
|
||||
%Mit diesen funktioniert die Unifikation in Schritt 4 des Algorithmus nicht korrekt.
|
||||
%Lösung: Man könnte es lösen mit:
|
||||
%typeVarOnly(TP) :- type(TP, _, PN), {notTypeVarOnly(TP, A) : param(TP, A, _), type(A, _, _)} == 0.
|
||||
|
||||
% Die Karthesischen Produkte von Schritt 4 des Unifikationsalgorithmus
|
||||
|
||||
{ makeRule1(A,TP,TPFC, SmallerType) : smaller(SmallerType, TPFC), type(TPFC, TypeName, NumParams) } = 1
|
||||
:- smallerDot(A, TP), type(TP, TypeName, NumParams), typeVar(A).%, smaller(_, TPFC), type(TPFC, TypeName, NumParams).
|
||||
|
||||
%:- makeRule1(A, B, C,_), makeRule1(A,B,D,_), D != C.
|
||||
|
||||
%Alle Greater Arg Paralisten des Typen C generieren
|
||||
greaterArgParaList(pointer(rule1(A, TP)), TPFC) :- makeRule1(A,TP,TPFC,_).
|
||||
|
||||
%Es braucht greaterArg Parameter von allen Parametern des Typs:
|
||||
greaterArg(pointer(P, Param), Param) :- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN), param(FCType, Param, Num), not typeVar(Param).
|
||||
|
||||
%Ein neuer Typ muss angelegt werden:
|
||||
type(P, FCTName, FCTPN)
|
||||
:- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN).
|
||||
|
||||
param(P, pointer(P, Param), N)
|
||||
:- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN)
|
||||
, param(FCType, Param, N), not typeVar(Param)
|
||||
.
|
||||
%Typvariablen bleiben bestehen. Sie werden durch das unify ausgetauscht
|
||||
param(P, Param, N)
|
||||
:- greaterArgParaList(P, FCType), type(FCType, FCTName, FCTPN)
|
||||
, param(FCType, Param, N), typeVar(Param)
|
||||
.
|
||||
|
||||
|
||||
%Die Unifikation vom AusgangsTyp im Constraint und dem greaterArgList gebildeten Typen
|
||||
unify(pointer(rule1unify(A,TP)), pointer(rule1(A,TP)), TP)
|
||||
:- makeRule1(A,TP,TPFC, _).
|
||||
|
||||
%Unify auf den SmallerType anwenden:
|
||||
type(pointer(rule1unify(A,TP,TPFC,SmallerType)), TN, TNum)
|
||||
:- makeRule1(A, TP, TPFC, SmallerType), type(SmallerType, TN, TNum).
|
||||
|
||||
{ param(pointer(rule1unify(A,TP,TPFC,SmallerType)), PNew, PN) : unify(pointer(rule1unify(A,TP)), P, PNew)} == 1
|
||||
:- makeRule1(A, TP, TPFC, SmallerType), param(SmallerType, P, PN).
|
||||
|
||||
%Am Schluss davon noch das smaller bilden:
|
||||
smallerGen(pointer(smallerDot(A,TP), SmallerType), pointer(rule1unify(A,TP,TPFC,SmallerType)))
|
||||
:- makeRule1(A, TP, TPFC, SmallerType), type(TP, TypeName, NumParams) %Die Bedingung für Regel 1
|
||||
.
|
||||
|
||||
smallerGen(A) :- list(smallerGen(A),_).
|
||||
type(A,B,C) :- list(type(A,B,C),_).
|
||||
list(A,B) :- list(_, list(A,B)).
|
||||
|
||||
smallerGen(A,A) :- smallerGen(A).
|
||||
|
||||
{ equals(A, NewType) : smallerGen(pointer(smallerDot(A,TP), SmallerType), NewType) } == 1
|
||||
:- smallerDot(A, TP), type(TP, TypeName, NumParams), typeVar(A) %Das karthesische Produkt
|
||||
, smaller(SmallerType, TPFC), type(pointer(smallerDot(A,TP), SmallerType), _, _)
|
||||
.
|
||||
|
||||
%TODO: Typen welche durch Unifikation ersetzt werden auch zu Constraints machen
|
||||
%%%%%%%%%%%%%%%%%%
|
||||
% Regel 2
|
||||
%%%%%%%%%%%%%%%%%
|
||||
|
||||
%{ makeRule2(A, Theta', TPFC) : smaller(SmallerType, TPFC), type(TPFC, TypeName, NumParams) } == 1
|
||||
%:- smallerDotWC(A, Theta'), extendsWildcard(Theta'), typeVar(A).
|
||||
%
|
||||
%%Alle Greater Arg Paralisten des Typen C generieren
|
||||
%greaterArgParaList(pointer(rule2(A, TP)), TPFC) :- makeRule2(A,TP,TPFC,_).
|
||||
%
|
||||
%unify(pointer(rule2(A,TP)), TP)
|
||||
%:- makeRule2(A,TP,TPFC)
|
||||
%% , type(TP, TypeName, NumParams), typeVar(A), type(TPFC, TypeName, NumParams)
|
||||
%.
|
||||
%
|
||||
%{ list(smallerArgGen(pointer(smallerDot(A,TP), SmallerType), SmallerType),
|
||||
%list(extendsWildcard(pointer(smallerDot(A,TP), SmallerType)), null))
|
||||
%: smaller(SmallerType, TPFC), type(SmallerType, SmallerName, SmallerPNum) } == 1
|
||||
%:- makeRule2(A, TP, TPFC) %Die Bedingung für Regel 2
|
||||
%.
|
||||
%
|
||||
%smallerArgGen(A, B) :- list(smallerArgGen(A, B), _).
|
||||
%extendsWildcard(A) :- list(extendsWildcard(A), _).
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% Regel 3
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
smallerArgGen(pointer(smallerDotWC(A, Theta')), Theta') :- smallerDotWC(A, Theta'), superWildcard(Theta').
|
||||
equals(A, pointer(smallerDotWC(A, Theta'))) :- smallerDotWC(A, Theta'), superWildcard(Theta').
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% Regel 4
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
equals(A, Theta') :- smallerDotWC(A, Theta'), not wildcard(Theta').
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% Regel 5
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
greaterGen(pointer(smallerDot(Theta,A)), Theta) :- smallerDot(Theta, A), not wildcard(Theta), not typeVar(Theta), typeVar(A) .
|
||||
equals(A, pointer(smallerDot(Theta,A))) :- smallerDot(Theta, A), not wildcard(Theta) , not typeVar(Theta), typeVar(A) .
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% Regel 6
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
greaterArgGen(pointer(smallerDotWC(Theta,A)), Theta) :- smallerDotWC(Theta, A), extendsWildcard(Theta) .
|
||||
equals(A, pointer(smallerDot(Theta,A))) :- smallerDotWC(Theta, A), extendsWildcard(Theta) .
|
||||
|
||||
%TODO: Regel 7
|
@ -1,8 +0,0 @@
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% Regel 5
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
greaterGen(pointer(smallerDot(Theta,A)), Theta) :- smallerDot(Theta, A), not wildcard(Theta), not typeVar(Theta), typeVar(A) .
|
||||
equals(A, pointer(smallerDot(Theta,A))) :- smallerDot(Theta, A), not wildcard(Theta) , not typeVar(Theta), typeVar(A) .
|
||||
|
||||
|
14
asp/subst.lp
14
asp/subst.lp
@ -1,14 +0,0 @@
|
||||
subst(TV,T) :- equals(TV, T), not occurs(TV, T), not typeVar(T), typeVar(TV).
|
||||
|
||||
equals(A, pointer(TP, subst(TV, T)))
|
||||
:- equals(A, TP), subst(TV, T), not typeVar(TP), occurs(TV, TP).
|
||||
|
||||
type(pointer(TP, subst(TV, T)), Name, Num)
|
||||
:- type(TP, Name, Num), subst(TV, T), occurs(TV, TP).
|
||||
|
||||
param(pointer(TP, subst(TV, T)), Param, PNum)
|
||||
:- type(pointer(TP, subst(TV, T)), Name, Num), subst(TV, T), param(TP, Param, PNum), not occurs(TV, Param).
|
||||
|
||||
param(pointer(TP, subst(TV, T)), pointer(Param, subst(TV, T)), PNum)
|
||||
:- type(pointer(TP, subst(TV, T)), Name, Num), subst(TV, T), param(TP, Param, PNum), occurs(TV, Param).
|
||||
|
219
asp/testInput.lp
219
asp/testInput.lp
@ -1,219 +0,0 @@
|
||||
typeVar(a).
|
||||
type(t1, cjava_DOT_util_DOT_Vector, 1).
|
||||
param(t1, t2, 1).
|
||||
type(t2, cjava_DOT_util_DOT_Vector, 1).
|
||||
param(t2, b, 1).
|
||||
typeVar(b).
|
||||
|
||||
smallerDot(a, t1).
|
||||
|
||||
|
||||
typeFC(cBUF,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBQX,cAKH,1).
|
||||
typeFC(cBRW,cjava_DOT_lang_DOT_Object,0).
|
||||
typeFC(cBRF,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBTR,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBTZ,cAKH,1).
|
||||
paramFC(cBUN,cAKH,1).
|
||||
typeFC(cBRY,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBUE,cBUF,1).
|
||||
paramFC(cBRL,cAKH,1).
|
||||
smaller(cBSB,cBSE).
|
||||
paramFC(cBTR,cBTS,1).
|
||||
smaller(cBQJ,cBQK).
|
||||
typeFC(cBQP,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBUA,cjava_DOT_util_DOT_Collection,1).
|
||||
typeFC(cBSD,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBUE,cjava_DOT_util_DOT_Collection,1).
|
||||
typeFC(cBUK,cjava_DOT_util_DOT_Collection,1).
|
||||
paramFC(cBTJ,cAKH,1).
|
||||
typeFC(cBRZ,cjava_DOT_lang_DOT_Integer,0).
|
||||
smaller(cBSF,cBSI).
|
||||
typeFC(cBRT,cjava_DOT_lang_DOT_Integer,0).
|
||||
paramFC(cBRX,cBRY,1).
|
||||
typeFC(cBRJ,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBRF,cBRG,1).
|
||||
typeFC(cBQN,cjava_DOT_lang_DOT_Integer,0).
|
||||
smaller(cBRL,cBRM).
|
||||
smaller(cBUH,cBUK).
|
||||
smaller(cBTR,cBTU).
|
||||
paramFC(cBUL,cBUM,1).
|
||||
smaller(cBRH,cBRI).
|
||||
typeFC(cBTV,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBSQ,cjava_DOT_lang_DOT_Object,0).
|
||||
typeFC(cBUL,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBTX,cjava_DOT_lang_DOT_Object,0).
|
||||
paramFC(cBSN,cAKH,1).
|
||||
typeFC(cBTE,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBUC,cBUD,1).
|
||||
smaller(cBST,cBSU).
|
||||
paramFC(cBRI,cAKH,1).
|
||||
typeFC(cBSR,cjava_DOT_lang_DOT_Iterable,1).
|
||||
typeFC(cBRC,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
typeFC(cBTL,cjava_DOT_util_DOT_Collection,1).
|
||||
typeFC(cBSF,cjava_DOT_util_DOT_AbstractList,1).
|
||||
typeFC(cBSX,cjava_DOT_util_DOT_AbstractList,1).
|
||||
paramFC(cBSI,cBSJ,1).
|
||||
typeFC(cBTH,cjava_DOT_util_DOT_Collection,1).
|
||||
paramFC(cBSV,cAKH,1).
|
||||
paramFC(cBQZ,cBRA,1).
|
||||
paramFC(cBQJ,cAKH,1).
|
||||
smaller(cBRD,cBRE).
|
||||
paramFC(cBRO,cBRP,1).
|
||||
typeFC(cBSI,cjava_DOT_util_DOT_List,1).
|
||||
typeFC(cBQX,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBUI,cBUJ,1).
|
||||
paramFC(cBQO,cBQP,1).
|
||||
typeFC(cBTA,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
paramFC(cBRJ,cAKH,1).
|
||||
paramFC(cBTV,cBTW,1).
|
||||
typeFC(cBUO,cjava_DOT_lang_DOT_Object,0).
|
||||
typeFC(cBSA,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cBUB,cBUE).
|
||||
typeFC(cBUD,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBQZ,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cBTL,cBTO).
|
||||
typeFC(cBTU,cjava_DOT_util_DOT_AbstractList,1).
|
||||
smaller(cBTZ,cBUA).
|
||||
typeFC(cBRG,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBSC,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBSK,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBST,cjava_DOT_util_DOT_AbstractList,1).
|
||||
paramFC(cBSY,cBSZ,1).
|
||||
typeFC(cBTW,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBQW,cjava_DOT_lang_DOT_Integer,0).
|
||||
smaller(cBSP,cBSQ).
|
||||
paramFC(cBSG,cBSH,1).
|
||||
smaller(cBTD,cBTG).
|
||||
typeFC(cBUG,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBSW,cjava_DOT_lang_DOT_Object,0).
|
||||
paramFC(cBTD,cBTE,1).
|
||||
paramFC(cBSX,cBSY,1).
|
||||
paramFC(cBQM,cBQN,1).
|
||||
typeFC(cBRH,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
smaller(cBSN,cBSO).
|
||||
paramFC(cBQK,cAKH,1).
|
||||
typeFC(cBTM,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBTU,cBTV,1).
|
||||
typeFC(cBQM,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBRA,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cBSV,cBSW).
|
||||
typeFC(cBSO,cjava_DOT_lang_DOT_Object,0).
|
||||
typeFC(cBSZ,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBQL,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBSL,cAKH,1).
|
||||
typeFC(cBRB,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBSY,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBUH,cBUI,1).
|
||||
paramFC(cBTH,cAKH,1).
|
||||
typeFC(cBTN,cjava_DOT_lang_DOT_Integer,0).
|
||||
smaller(cBRJ,cBRK).
|
||||
typeFC(cBRP,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBUH,cjava_DOT_util_DOT_List,1).
|
||||
paramFC(cBRE,cBRF,1).
|
||||
typeFC(cBQR,cjava_DOT_util_DOT_Collection,1).
|
||||
typeFC(cBTY,cjava_DOT_lang_DOT_Object,0).
|
||||
paramFC(cBQS,cBQT,1).
|
||||
typeFC(cBTI,cjava_DOT_lang_DOT_Iterable,1).
|
||||
typeFC(cBUC,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBSB,cBSC,1).
|
||||
typeFC(cBQS,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cBQR,cBQU).
|
||||
paramFC(cBTE,cBTF,1).
|
||||
paramFC(cBUB,cBUC,1).
|
||||
typeFC(cBRO,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBST,cAKH,1).
|
||||
typeFC(cBQO,cjava_DOT_util_DOT_List,1).
|
||||
typeFC(cBRE,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBQY,cjava_DOT_io_DOT_Serializable,0).
|
||||
typeFC(cBTQ,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cBSX,cBTA).
|
||||
typeFC(cBRN,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
typeVar(cAKH).
|
||||
paramFC(cBRH,cAKH,1).
|
||||
paramFC(cBQP,cBQQ,1).
|
||||
typeFC(cBSE,cjava_DOT_io_DOT_Serializable,0).
|
||||
smaller(cBTP,cBTQ).
|
||||
paramFC(cBRN,cBRO,1).
|
||||
typeFC(cBUI,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBRV,cjava_DOT_io_DOT_Serializable,0).
|
||||
typeFC(cBSJ,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBTK,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
paramFC(cBSJ,cBSK,1).
|
||||
typeFC(cBQK,cjava_DOT_util_DOT_AbstractList,1).
|
||||
smaller(cBUN,cBUO).
|
||||
typeFC(cBUB,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
paramFC(cBSR,cAKH,1).
|
||||
paramFC(cBSC,cBSD,1).
|
||||
paramFC(cBRA,cBRB,1).
|
||||
paramFC(cBRM,cAKH,1).
|
||||
paramFC(cBQR,cBQS,1).
|
||||
typeFC(cBSM,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
smaller(cBTH,cBTI).
|
||||
paramFC(cBTA,cBTB,1).
|
||||
smaller(cBQL,cBQO).
|
||||
typeFC(cBTB,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBUF,cBUG,1).
|
||||
paramFC(cBQL,cBQM,1).
|
||||
smaller(cBRN,cBRQ).
|
||||
smaller(cBRR,cBRU).
|
||||
smaller(cBQX,cBQY).
|
||||
typeFC(cBRM,cjava_DOT_util_DOT_List,1).
|
||||
typeFC(cBTZ,cjava_DOT_util_DOT_List,1).
|
||||
paramFC(cBTL,cBTM,1).
|
||||
typeFC(cBRI,cjava_DOT_util_DOT_Collection,1).
|
||||
typeFC(cBRK,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
typeFC(cBTS,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBUN,cjava_DOT_util_DOT_Collection,1).
|
||||
paramFC(cBRR,cBRS,1).
|
||||
smaller(cBQZ,cBRC).
|
||||
smaller(cBRV,cBRW).
|
||||
smaller(cBSL,cBSM).
|
||||
typeFC(cBSB,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBSN,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
typeFC(cBTF,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBTG,cjava_DOT_lang_DOT_Object,0).
|
||||
paramFC(cBTI,cAKH,1).
|
||||
typeFC(cBSH,cjava_DOT_lang_DOT_Integer,0).
|
||||
paramFC(cBTM,cBTN,1).
|
||||
paramFC(cBSM,cAKH,1).
|
||||
typeFC(cBTD,cjava_DOT_util_DOT_List,1).
|
||||
typeFC(cBTJ,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBQJ,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBQU,cjava_DOT_lang_DOT_Iterable,1).
|
||||
paramFC(cBSF,cBSG,1).
|
||||
typeFC(cBTC,cjava_DOT_lang_DOT_Integer,0).
|
||||
paramFC(cBQU,cBQV,1).
|
||||
typeFC(cBTT,cjava_DOT_lang_DOT_Integer,0).
|
||||
paramFC(cBUK,cBUL,1).
|
||||
paramFC(cBUA,cAKH,1).
|
||||
typeFC(cBUM,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBQT,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBSL,cjava_DOT_util_DOT_AbstractList,1).
|
||||
smaller(cBSR,cBSS).
|
||||
typeFC(cBUJ,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBQQ,cjava_DOT_lang_DOT_Integer,0).
|
||||
typeFC(cBRD,casp_DOT_UnifyWithoutWildcards_DOLLAR_MatrixTest,0).
|
||||
paramFC(cBSU,cAKH,1).
|
||||
typeFC(cBSU,cjava_DOT_util_DOT_List,1).
|
||||
typeFC(cBTP,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
typeFC(cBRQ,cjava_DOT_lang_DOT_Object,0).
|
||||
typeFC(cBRX,cjava_DOT_lang_DOT_Iterable,1).
|
||||
typeFC(cBQV,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBSG,cjava_DOT_util_DOT_Vector,1).
|
||||
paramFC(cBRY,cBRZ,1).
|
||||
typeFC(cBSV,cjava_DOT_util_DOT_List,1).
|
||||
smaller(cBRX,cBSA).
|
||||
typeFC(cBRS,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBRL,cjava_DOT_util_DOT_Vector,1).
|
||||
typeFC(cBRR,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cBTJ,cBTK).
|
||||
typeFC(cBRU,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
paramFC(cBRS,cBRT,1).
|
||||
paramFC(cBTB,cBTC,1).
|
||||
paramFC(cBTS,cBTT,1).
|
||||
typeFC(cBSP,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
smaller(cBTX,cBTY).
|
||||
paramFC(cBQV,cBQW,1).
|
||||
typeFC(cBSS,cjava_DOT_lang_DOT_Object,0).
|
||||
typeFC(cBTO,cjava_DOT_lang_DOT_Object,0).
|
@ -1,28 +0,0 @@
|
||||
equals(t1, t2). % Map<Object, Integer> =. Map<Integer, Object>
|
||||
%smallerDot(t2, t1).
|
||||
|
||||
type(t1, cMap, 2).
|
||||
type(t2, cMap, 2).
|
||||
%type(t2, cHashMap, 2).
|
||||
param(t1, t3, 1).
|
||||
param(t1, t4, 2).
|
||||
param(t2, t6, 1).
|
||||
param(t2, t5, 2).
|
||||
|
||||
type(t3, cObject, 0).
|
||||
type(t5, cInteger, 0).
|
||||
typeVar(t4).
|
||||
typeVar(t6).
|
||||
|
||||
type(tfc1, cMap, 2).
|
||||
type(tfc2, cHashMap, 2).
|
||||
param(tfc1, gA, 1).
|
||||
param(tfc1, gB, 2).
|
||||
param(tfc2, gB, 1).
|
||||
param(tfc2, gA, 2).
|
||||
typeVar(gA).
|
||||
typeVar(gB).
|
||||
smaller(tfc2, tfc1).
|
||||
smaller(tfc1, tfc1).
|
||||
|
||||
#show equals/2.
|
@ -1,12 +0,0 @@
|
||||
type(t1, cjava_DOT_util_DOT_Vector, 1).
|
||||
param(t1, t2, 1).
|
||||
type(t2, cjava_DOT_util_DOT_Vector, 1).
|
||||
param(t2, b, 1).
|
||||
typeVar(b).
|
||||
type(t3, cjava_DOT_util_DOT_Vector, 1).
|
||||
param(t3, a, 1).
|
||||
typeVar(a).
|
||||
|
||||
unify(p, t1, t3).
|
||||
|
||||
#show unify/3.
|
@ -1,23 +0,0 @@
|
||||
|
||||
%reduce:
|
||||
unify(Pointer, Param1, Param2)
|
||||
:- unify(Pointer, T1, T2), type(T1, TName, Num), type(T2, TName, Num)
|
||||
, param(T1, Param1, PNum), param(T2, Param2, PNum)
|
||||
.
|
||||
|
||||
%Ich lasse das Subst hier aus. Vector Beispiel funktioniert womöglich auch ohne
|
||||
|
||||
%swap:
|
||||
unify(Pointer, B, A) :- unify(Pointer, A, B).
|
||||
|
||||
%Subst neu implementieren.
|
||||
%Subst muss von hinten nach vorne durchgehen.
|
||||
%Mit occurs kann man prüfen, welche unify(P, A, B) ausgetauscht werden müssen
|
||||
|
||||
%Diese Fälle dürfen nicht auftreten:
|
||||
%TODO (möglicherweise braucht man sie nicht; Die Unifikation geht hier nie schief)
|
||||
|
||||
%Occurs Regeln:
|
||||
occurs(A, A) :- typeVar(A).
|
||||
occurs(A, T) :- type(T, _,_), param(T, B, _), occurs(A, B).
|
||||
|
@ -1,40 +0,0 @@
|
||||
|
||||
%reduce:
|
||||
unify(Pointer, Param1, Param2)
|
||||
:- unify(Pointer, T1, T2), type(T1, TName, Num), type(T2, TName, Num)
|
||||
, param(T1, Param1, PNum), param(T2, Param2, PNum)
|
||||
.
|
||||
|
||||
%swap:
|
||||
unify(Pointer, B, A) :- unify(Pointer, A, B).
|
||||
|
||||
%subst:
|
||||
%Neuen Typ erstellen, in diesem werden dann die TPHs ersetzt:
|
||||
type(pointer(unify(Pointer, A, B, E)), Name, Num)
|
||||
:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
|
||||
,param(E, Param, _), occurs(A, Param), Param != A.
|
||||
|
||||
param(pointer(unify(Pointer, A, B, E)), pointer(unify(Pointer, A, B, Param)), ParamNum)
|
||||
:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
|
||||
,param(E, Param, ParamNum), occurs(A, Param), Param != A.
|
||||
|
||||
param(pointer(unify(Pointer, A, B, E)), B, ParamNum)
|
||||
:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
|
||||
,param(E, A, ParamNum).
|
||||
|
||||
param(pointer(unify(Pointer, A, B, E)), Param, ParamNum)
|
||||
:- unify(Pointer, A, B), typeVar(A), not occurs(A, B), type(E, Name, Num)
|
||||
,param(E, Param, ParamNum), not occurs(A, Param).
|
||||
|
||||
|
||||
%Subst neu implementieren.
|
||||
%Subst muss von hinten nach vorne durchgehen.
|
||||
%Mit occurs kann man prüfen, welche unify(P, A, B) ausgetauscht werden müssen
|
||||
|
||||
%Diese Fälle dürfen nicht auftreten:
|
||||
%TODO (möglicherweise braucht man sie nicht; Die Unifikation geht hier nie schief)
|
||||
|
||||
%Occurs Regeln:
|
||||
occurs(A, A) :- typeVar(A).
|
||||
occurs(A, T) :- type(T, _,_), param(T, B, _), occurs(A, B).
|
||||
|
@ -1,95 +0,0 @@
|
||||
|
||||
%#show smallerGen/2.
|
||||
%#show smallerGen/4.
|
||||
|
||||
typeVar(cZW).
|
||||
smallerDot(cN,cK).
|
||||
smaller(cBHW,cBHX).
|
||||
param(cBHW,cZW,1).
|
||||
type(cBHO,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cBIM,cBIN).
|
||||
type(cBIQ,cjava_DOT_util_DOT_AbstractList,1).
|
||||
type(cBIB,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cBIC,cjava_DOT_util_DOT_List,1).
|
||||
type(cBHN,cjava_DOT_lang_DOT_Object,0).
|
||||
param(cBHS,cZW,1).
|
||||
param(cBHT,cZW,1).
|
||||
param(cBHU,cZW,1).
|
||||
param(cBHV,cZW,1).
|
||||
smaller(cBHY,cBHZ).
|
||||
type(cBIA,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
type(cBIV,cjava_DOT_lang_DOT_Object,0).
|
||||
typeVar(cK).
|
||||
smaller(cBHU,cBHV).
|
||||
smallerDot(cL,cBIY).
|
||||
type(cBIM,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cBIK,cBIL).
|
||||
type(cBIL,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cBIE,cjava_DOT_util_DOT_Vector,1).
|
||||
type(cBII,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
param(cBIY,cLL,1).
|
||||
type(cBHZ,cjava_DOT_lang_DOT_Object,0).
|
||||
typeVar(cLL).
|
||||
type(cBIR,cjava_DOT_util_DOT_List,1).
|
||||
param(cBID,cZW,1).
|
||||
type(cBHY,cMyVector,0).
|
||||
smaller(cBII,cBIJ).
|
||||
param(cBIF,cZW,1).
|
||||
type(cBIG,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cBHT,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
type(cBIT,cjava_DOT_util_DOT_AbstractList,1).
|
||||
param(cBHQ,cZW,1).
|
||||
smaller(cBIE,cBIF).
|
||||
typeVar(cL).
|
||||
param(cBHO,cZW,1).
|
||||
type(cBHM,cjava_DOT_io_DOT_Serializable,0).
|
||||
type(cBIK,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
type(cBIJ,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cBIO,cjava_DOT_util_DOT_AbstractCollection,1).
|
||||
type(cBIZ,cjava_DOT_lang_DOT_Integer,0).
|
||||
type(cBHX,cjava_DOT_lang_DOT_Object,0).
|
||||
type(cBIS,cjava_DOT_util_DOT_Vector,1).
|
||||
smaller(cBIG,cBIH).
|
||||
param(cBIW,cZW,1).
|
||||
smaller(cBIW,cBIX).
|
||||
smaller(cBHM,cBHN).
|
||||
smaller(cBIC,cBID).
|
||||
type(cBHP,cjava_DOT_util_DOT_RandomAccess,0).
|
||||
param(cBIS,cZW,1).
|
||||
param(cBIQ,cZW,1).
|
||||
param(cBIU,cZW,1).
|
||||
param(cBIR,cZW,1).
|
||||
param(cBIT,cZW,1).
|
||||
smaller(cBHO,cBHP).
|
||||
param(cBIP,cZW,1).
|
||||
type(cBIH,cjava_DOT_lang_DOT_Object,0).
|
||||
typeVar(cM).
|
||||
type(cBIU,cjava_DOT_lang_DOT_Iterable,1).
|
||||
type(cBHR,cjava_DOT_lang_DOT_Cloneable,0).
|
||||
type(cBIF,cjava_DOT_util_DOT_List,1).
|
||||
smaller(cBIU,cBIV).
|
||||
type(cBHV,cjava_DOT_lang_DOT_Iterable,1).
|
||||
smaller(cBIA,cBIB).
|
||||
equals(cLL,cN).
|
||||
type(cBIP,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cBHS,cjava_DOT_util_DOT_AbstractList,1).
|
||||
type(cBIN,cjava_DOT_lang_DOT_Object,0).
|
||||
smaller(cBHS,cBHT).
|
||||
param(cBIE,cZW,1).
|
||||
smaller(cBIS,cBIT).
|
||||
param(cBIC,cZW,1).
|
||||
param(cBIG,cZW,1).
|
||||
param(cBII,cZW,1).
|
||||
type(cBID,cjava_DOT_util_DOT_Collection,1).
|
||||
param(cBIO,cZW,1).
|
||||
type(cBIW,cjava_DOT_util_DOT_Vector,1).
|
||||
smallerDot(cM,cBIZ).
|
||||
smaller(cBIO,cBIP).
|
||||
type(cBIY,cjava_DOT_util_DOT_Vector,1).
|
||||
typeVar(cN).
|
||||
type(cBHW,cjava_DOT_util_DOT_List,1).
|
||||
type(cBHU,cjava_DOT_util_DOT_Collection,1).
|
||||
type(cBIX,cjava_DOT_io_DOT_Serializable,0).
|
||||
smaller(cBHQ,cBHR).
|
||||
smaller(cBIQ,cBIR).
|
||||
type(cBHQ,cjava_DOT_util_DOT_Vector,1).
|
@ -1 +0,0 @@
|
||||
5da32a6f73bb3ccac5dc264606071605
|
@ -1 +0,0 @@
|
||||
bcb7e8eb537f65ec0110731a924a3d4d3bba7805
|
@ -1,8 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>de.dhbwstuttgart</groupId>
|
||||
<artifactId>JavaTXcompiler</artifactId>
|
||||
<version>0.1</version>
|
||||
</project>
|
@ -1 +0,0 @@
|
||||
a909ae513fbc19ba7c25b0cbb9871db6
|
@ -1 +0,0 @@
|
||||
4863f156f9b2754ccff7128ff372a8e1e11ee0f8
|
@ -1,12 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<metadata>
|
||||
<groupId>de.dhbwstuttgart</groupId>
|
||||
<artifactId>JavaTXcompiler</artifactId>
|
||||
<versioning>
|
||||
<release>0.1</release>
|
||||
<versions>
|
||||
<version>0.1</version>
|
||||
</versions>
|
||||
<lastUpdated>20180119143709</lastUpdated>
|
||||
</versioning>
|
||||
</metadata>
|
@ -1 +0,0 @@
|
||||
f023e768b9a1e74695541c63858fa86c
|
@ -1 +0,0 @@
|
||||
705a6736ea0a93b18743edd577dcb3c5e6dd518e
|
85
pom.xml
85
pom.xml
@ -7,6 +7,7 @@
|
||||
<groupId>de.dhbwstuttgart</groupId>
|
||||
<artifactId>JavaTXcompiler</artifactId>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<version>0.1</version>
|
||||
<name>JavaTXcompiler</name>
|
||||
<url>http://maven.apache.org</url>
|
||||
@ -71,10 +72,7 @@
|
||||
<configuration>
|
||||
<sourceDirectory>src/de/dhbwstuttgart/parser/antlr/</sourceDirectory>
|
||||
<outputDirectory>src/de/dhbwstuttgart/parser/antlr/</outputDirectory>
|
||||
<arguments>
|
||||
<argument>-package</argument>
|
||||
<argument>de.dhbwstuttgart.parser.antlr</argument>
|
||||
</arguments>
|
||||
<arguments> <argument>-package</argument> <argument>de.dhbwstuttgart.parser.antlr</argument> </arguments>
|
||||
</configuration>
|
||||
</execution>
|
||||
<execution>
|
||||
@ -93,20 +91,91 @@
|
||||
</execution>
|
||||
|
||||
</executions>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<artifactId>maven-assembly-plugin</artifactId>
|
||||
<executions>
|
||||
<execution>
|
||||
<phase>package</phase>
|
||||
<goals>
|
||||
<goal>single</goal>
|
||||
</goals>
|
||||
</execution>
|
||||
</executions>
|
||||
<configuration>
|
||||
<descriptorRefs>
|
||||
<descriptorRef>jar-with-dependencies</descriptorRef>
|
||||
</descriptorRefs>
|
||||
</configuration>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.reficio</groupId>
|
||||
<artifactId>p2-maven-plugin</artifactId>
|
||||
<version>1.1.2-SNAPSHOT</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>default-cli</id>
|
||||
<configuration>
|
||||
<artifacts>
|
||||
<!-- specify your depencies here -->
|
||||
<!-- groupId:artifactId:version -->
|
||||
<artifact>
|
||||
<id>de.dhbwstuttgart:JavaTXcompiler:0.1</id>
|
||||
</artifact>
|
||||
<artifact><id>org.reflections:reflections:0.9.11</id></artifact>
|
||||
<artifact><id>com.google.guava:guava:22.0</id></artifact>
|
||||
<artifact><id>javax.annotation:javax.annotation-api:1.3.1</id></artifact>
|
||||
<artifact><id>org.glassfish:javax.annotation:3.1.1</id></artifact>
|
||||
</artifacts>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.eclipse.tycho</groupId>
|
||||
<artifactId>tycho-p2-repository-plugin</artifactId>
|
||||
<version>${tycho.version}</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<phase>package</phase>
|
||||
<goals>
|
||||
<goal>archive-repository</goal>
|
||||
</goals>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>2.3.2</version>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<configuration>
|
||||
<source>8</source>
|
||||
<target>8</target>
|
||||
<source>9</source>
|
||||
<target>9</target>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
<pluginRepositories>
|
||||
<pluginRepository>
|
||||
<id>reficio</id>
|
||||
<url>http://repo.reficio.org/maven/</url>
|
||||
</pluginRepository>
|
||||
</pluginRepositories>
|
||||
<repositories>
|
||||
<repository>
|
||||
<id>maven-repository</id>
|
||||
<url>file:///${project.basedir}/target</url>
|
||||
</repository>
|
||||
</repositories>
|
||||
<properties>
|
||||
<maven.compiler.source>1.8</maven.compiler.source>
|
||||
<maven.compiler.target>1.8</maven.compiler.target>
|
||||
<tycho.version>0.23.0</tycho.version>
|
||||
</properties>
|
||||
<distributionManagement>
|
||||
<repository>
|
||||
<id>maven-repository</id>
|
||||
<name>MyCo Internal Repository</name>
|
||||
<url>file:///${project.basedir}/maven-repository/</url>
|
||||
</repository>
|
||||
</distributionManagement>
|
||||
</project>
|
||||
|
BIN
src/de/dhbwstuttgart/.DS_Store
vendored
BIN
src/de/dhbwstuttgart/.DS_Store
vendored
Binary file not shown.
30
src/de/dhbwstuttgart/bytecode/AStatement.java
Normal file
30
src/de/dhbwstuttgart/bytecode/AStatement.java
Normal file
@ -0,0 +1,30 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import org.objectweb.asm.Label;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
|
||||
public abstract class AStatement implements IStatement {
|
||||
protected Expression expr;
|
||||
|
||||
public AStatement(Expression expr) {
|
||||
this.expr = expr;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isExprBinary() {
|
||||
return (expr instanceof BinaryExpr);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
|
||||
mv.visitInsn(Opcodes.ICONST_1);
|
||||
mv.visitJumpInsn(Opcodes.GOTO, endLabel);
|
||||
mv.visitLabel(branchLabel);
|
||||
mv.visitInsn(Opcodes.ICONST_0);
|
||||
mv.visitLabel(endLabel);
|
||||
}
|
||||
}
|
11
src/de/dhbwstuttgart/bytecode/ArgumentExpr.java
Normal file
11
src/de/dhbwstuttgart/bytecode/ArgumentExpr.java
Normal file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
|
||||
public class ArgumentExpr extends AStatement {
|
||||
|
||||
public ArgumentExpr(Expression expr) {
|
||||
super(expr);
|
||||
}
|
||||
|
||||
}
|
11
src/de/dhbwstuttgart/bytecode/AssignStmt.java
Normal file
11
src/de/dhbwstuttgart/bytecode/AssignStmt.java
Normal file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
|
||||
public class AssignStmt extends AStatement {
|
||||
|
||||
public AssignStmt(Expression rightSide) {
|
||||
super(rightSide);
|
||||
}
|
||||
|
||||
}
|
@ -1,7 +1,9 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
@ -9,11 +11,15 @@ import org.objectweb.asm.ClassWriter;
|
||||
import org.objectweb.asm.FieldVisitor;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.Type;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
|
||||
import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
|
||||
import de.dhbwstuttgart.bytecode.signature.Signature;
|
||||
import de.dhbwstuttgart.bytecode.signature.TypeToString;
|
||||
import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
|
||||
import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
|
||||
import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Literal;
|
||||
@ -23,6 +29,9 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
|
||||
import de.dhbwstuttgart.typeinference.result.ResolvedType;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultPair;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
|
||||
public class BytecodeGen implements ASTVisitor {
|
||||
@ -30,12 +39,18 @@ public class BytecodeGen implements ASTVisitor {
|
||||
ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
|
||||
|
||||
String type;
|
||||
|
||||
|
||||
String className;
|
||||
private boolean isInterface;
|
||||
private List<ResultSet> listOfResultSets;
|
||||
private ResultSet resultSet;
|
||||
|
||||
private String path;
|
||||
|
||||
private int indexOfFirstParam = 0;
|
||||
|
||||
private String superClass;
|
||||
|
||||
// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
|
||||
HashMap<String, Integer> paramsAndLocals = new HashMap<>();
|
||||
// stores generics and their bounds of class
|
||||
@ -43,20 +58,26 @@ public class BytecodeGen implements ASTVisitor {
|
||||
// stores generics and their bounds of method
|
||||
HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
|
||||
|
||||
private final TPHExtractor tphExtractor = new TPHExtractor();
|
||||
private final ArrayList<GenericInsertPair> commonPairs = new ArrayList<>();
|
||||
|
||||
HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
|
||||
byte[] bytecode;
|
||||
HashMap<String,byte[]> classFiles;
|
||||
|
||||
public BytecodeGen(HashMap<String,byte[]> classFiles, ResultSet resultSet) {
|
||||
ArrayList<String> methodNameAndParamsT = new ArrayList<>();
|
||||
|
||||
public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets, String path) {
|
||||
this.classFiles = classFiles;
|
||||
this.resultSet = resultSet;
|
||||
this.listOfResultSets = listOfResultSets;
|
||||
this.path = path;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SourceFile sourceFile) {
|
||||
for(ClassOrInterface cl : sourceFile.getClasses()) {
|
||||
System.out.println("in Class: " + cl.getClassName().toString());
|
||||
BytecodeGen classGen = new BytecodeGen(classFiles, resultSet);
|
||||
BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets,path);
|
||||
cl.accept(classGen);
|
||||
classGen.writeClass(cl.getClassName().toString());
|
||||
}
|
||||
@ -81,6 +102,7 @@ public class BytecodeGen implements ASTVisitor {
|
||||
|
||||
@Override
|
||||
public void visit(ClassOrInterface classOrInterface) {
|
||||
|
||||
className = classOrInterface.getClassName().toString();
|
||||
|
||||
cw.visitSource(className +".jav", null);
|
||||
@ -88,30 +110,63 @@ public class BytecodeGen implements ASTVisitor {
|
||||
isInterface = (classOrInterface.getModifiers()&512)==512;
|
||||
|
||||
int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
|
||||
String sig = null;
|
||||
/* if class has generics then creates signature
|
||||
* Signature looks like:
|
||||
* <E:Ljava/...>Superclass
|
||||
*/
|
||||
if(classOrInterface.getGenerics().iterator().hasNext()) {
|
||||
Signature signature = new Signature(classOrInterface, genericsAndBounds);
|
||||
sig = signature.toString();
|
||||
}
|
||||
// needs implemented Interfaces?
|
||||
cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
|
||||
, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
|
||||
|
||||
// for each field in the class
|
||||
for(Field f : classOrInterface.getFieldDecl()) {
|
||||
f.accept(this);
|
||||
|
||||
// resultSet = listOfResultSets.get(0);
|
||||
boolean isConsWithNoParamsVisited = false;
|
||||
boolean isVisited = false;
|
||||
for(ResultSet rs : listOfResultSets) {
|
||||
superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
|
||||
resultSet = rs;
|
||||
// Nur einmal ausführen!!
|
||||
if(!isVisited) {
|
||||
classOrInterface.accept(tphExtractor);
|
||||
|
||||
getCommonTPHS(tphExtractor);
|
||||
|
||||
String sig = null;
|
||||
/* if class has generics then creates signature
|
||||
* Signature looks like:
|
||||
* <E:Ljava/...>Superclass
|
||||
*/
|
||||
if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty()) {
|
||||
Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs);
|
||||
sig = signature.toString();
|
||||
System.out.println("Signature: => " + sig);
|
||||
}
|
||||
|
||||
cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
|
||||
, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
|
||||
|
||||
isVisited = true;
|
||||
}
|
||||
|
||||
for(Field f : classOrInterface.getFieldDecl()) {
|
||||
f.accept(this);
|
||||
}
|
||||
|
||||
for(Constructor c : classOrInterface.getConstructors()) {
|
||||
if(!isConsWithNoParamsVisited)
|
||||
c.accept(this);
|
||||
if(!c.getParameterList().iterator().hasNext())
|
||||
isConsWithNoParamsVisited = true;
|
||||
}
|
||||
|
||||
for(Method m : classOrInterface.getMethods()) {
|
||||
m.accept(this);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
for(Constructor c : classOrInterface.getConstructors()) {
|
||||
c.accept(this);
|
||||
}
|
||||
|
||||
for(Method m : classOrInterface.getMethods()) {
|
||||
m.accept(this);
|
||||
}
|
||||
|
||||
private void getCommonTPHS(TPHExtractor tphExtractor) {
|
||||
// Gemeinsame TPHs
|
||||
ArrayList<TypePlaceholder> cTPHs = new ArrayList<>();
|
||||
// Alle TPHs der Felder speichern
|
||||
for(TypePlaceholder tph : tphExtractor.allTPHS.keySet()) {
|
||||
if(!tphExtractor.allTPHS.get(tph))
|
||||
cTPHs.add(tph);
|
||||
}
|
||||
}
|
||||
|
||||
@ -138,31 +193,48 @@ public class BytecodeGen implements ASTVisitor {
|
||||
desc = constructor.accept(new DescriptorToString(resultSet));
|
||||
MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
|
||||
mv.visitCode();
|
||||
BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,field, mv,paramsAndLocals,cw,
|
||||
genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles);
|
||||
BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
|
||||
genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, path);
|
||||
if(!field.getParameterList().iterator().hasNext()) {
|
||||
mv.visitInsn(Opcodes.RETURN);
|
||||
}
|
||||
mv.visitMaxs(0, 0);
|
||||
mv.visitEnd();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
// TODO: check if the method is static => if static then the first param will be stored in pos 0
|
||||
// else it will be stored in pos 1 and this will be stored in pos 0
|
||||
String retType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
String methParamTypes = retType+method.name+"%%";
|
||||
method.getParameterList().accept(this);
|
||||
|
||||
Iterator<FormalParameter> itr = method.getParameterList().iterator();
|
||||
while(itr.hasNext()) {
|
||||
FormalParameter fp = itr.next();
|
||||
methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
|
||||
}
|
||||
|
||||
if(methodNameAndParamsT.contains(methParamTypes)) {
|
||||
return;
|
||||
}
|
||||
methodNameAndParamsT.add(methParamTypes);
|
||||
System.out.println("Method: "+method.name +" , paramsType: "+methParamTypes);
|
||||
String methDesc = null;
|
||||
|
||||
// Method getModifiers() ?
|
||||
int acc = isInterface?Opcodes.ACC_ABSTRACT:method.modifier;
|
||||
System.out.println(acc);
|
||||
|
||||
boolean hasGenInParameterList = genericsAndBounds.containsKey(resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor()));
|
||||
/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
|
||||
boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ");
|
||||
/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
|
||||
* prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
|
||||
if(!hasGenInParameterList) {
|
||||
for(String paramName : methodParamsAndTypes.keySet()) {
|
||||
String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
|
||||
if(genericsAndBounds.containsKey(typeOfParam)) {
|
||||
if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")) {
|
||||
hasGenInParameterList = true;
|
||||
break;
|
||||
}
|
||||
@ -170,31 +242,128 @@ public class BytecodeGen implements ASTVisitor {
|
||||
}
|
||||
|
||||
//TODO: Test if the return-type or any of the parameter is a parameterized type. (VP)
|
||||
//than create the descriptor with the new syntax.
|
||||
//then create the descriptor with the new syntax.
|
||||
|
||||
String sig = null;
|
||||
/* method.getGenerics: <....> RT method(..)
|
||||
* */
|
||||
boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
|
||||
|
||||
/* if method has generics or return type is TPH, create signature */
|
||||
// zwite operand muss weggelassen werden
|
||||
if(hasGen||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
|
||||
// resultset hier zum testen
|
||||
Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet);
|
||||
|
||||
ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs);
|
||||
System.out.println(method.name + " => Simplified Pairs: ");
|
||||
pairs.forEach(p->System.out.println(p.TA1.getName() + " -> "+p.TA2.getName()));
|
||||
Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,methodParamsAndTypes,resultSet, pairs);
|
||||
sig = signature.toString();
|
||||
}
|
||||
System.out.println(sig);
|
||||
System.out.println(method.getName()+" ==> "+sig);
|
||||
NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
|
||||
methDesc = meth.accept(new DescriptorToString(resultSet));
|
||||
System.out.println(methDesc);
|
||||
|
||||
// System.out.println(methDesc);
|
||||
MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
|
||||
|
||||
mv.visitCode();
|
||||
BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
|
||||
genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, path);
|
||||
|
||||
BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,method, mv,paramsAndLocals,cw,
|
||||
genericsAndBounds,genericsAndBounds,isInterface,classFiles);
|
||||
mv.visitMaxs(0, 0);
|
||||
mv.visitEnd();
|
||||
}
|
||||
|
||||
private ArrayList<GenericInsertPair> simplifyPairs(String methodName, ArrayList<GenericInsertPair> allPairs) {
|
||||
allPairs.forEach(p->System.out.print(p.TA1 + " < "+ p.TA2+ " ; "));
|
||||
|
||||
if(allPairs.size() < 2)
|
||||
return allPairs;
|
||||
|
||||
ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
|
||||
|
||||
MethodAndTPH method;
|
||||
ArrayList<TypePlaceholder> methodTphs = new ArrayList<>();
|
||||
ArrayList<GenericInsertPair> methodPairs = new ArrayList<>();
|
||||
for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
|
||||
if(m.getName().equals(methodName)) {
|
||||
methodTphs = m.getTphs();
|
||||
methodPairs = m.getPairs();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
|
||||
for(GenericInsertPair p : allPairs) {
|
||||
// Tph2.jav
|
||||
if(subAndSuperTph.containsKey(p.TA1)) {
|
||||
if(methodTphs.contains(subAndSuperTph.get(p.TA1)))
|
||||
continue;
|
||||
}
|
||||
subAndSuperTph.put(p.TA1, p.TA2);
|
||||
}
|
||||
int numOfVisitedPairs = 0;
|
||||
for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
|
||||
|
||||
if(numOfVisitedPairs>=subAndSuperTph.size())
|
||||
break;
|
||||
|
||||
if(!methodTphs.contains(subTph))
|
||||
continue;
|
||||
|
||||
HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
|
||||
|
||||
tphsInRel.put(tphsInRel.size(), subTph);
|
||||
TypePlaceholder superTph = subAndSuperTph.get(subTph);
|
||||
tphsInRel.put(tphsInRel.size(), superTph);
|
||||
|
||||
numOfVisitedPairs++;
|
||||
|
||||
while(subAndSuperTph.containsKey(superTph)) {
|
||||
superTph = subAndSuperTph.get(superTph);
|
||||
tphsInRel.put(tphsInRel.size(), superTph);
|
||||
numOfVisitedPairs++;
|
||||
}
|
||||
|
||||
// Subtype
|
||||
TypePlaceholder subTphRes = tphsInRel.get(0);
|
||||
// Die größte Supertype
|
||||
TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
|
||||
|
||||
while(subAndSuperTph.containsValue(subTphRes)) {
|
||||
for(TypePlaceholder tph : subAndSuperTph.keySet()) {
|
||||
if(methodTphs.contains(tph) && subAndSuperTph.get(tph).equals(subTphRes)) {
|
||||
subTphRes = tph;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(subTphRes.equals(tphsInRel.get(0))) {
|
||||
break;
|
||||
}
|
||||
tphsInRel.put(0, subTphRes);
|
||||
numOfVisitedPairs++;
|
||||
}
|
||||
|
||||
subTphRes = tphsInRel.get(0);
|
||||
|
||||
int i = 2;
|
||||
while(!methodTphs.contains(superTphRes) && (tphsInRel.size()-i) >0) {
|
||||
superTphRes = tphsInRel.get(tphsInRel.size()-i);
|
||||
i++;
|
||||
}
|
||||
// teste noch den Fall X < Y und Y nicht in TPHS der Methode
|
||||
// Dann hat man nach der While-Schleife X < Y
|
||||
// Y muss durch Object ersetzt.
|
||||
|
||||
// Zweite Operand für die Fälle wie in Lambda.jav (Paramtrisierte Typen)
|
||||
if(methodTphs.contains(superTphRes) || !tphExtractor.allTPHS.containsKey(superTphRes)) {
|
||||
GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
|
||||
simplifiedPairs.add(sPair);
|
||||
}
|
||||
}
|
||||
return simplifiedPairs;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList formalParameters) {
|
||||
paramsAndLocals = new HashMap<>();
|
||||
@ -436,5 +605,50 @@ public class BytecodeGen implements ASTVisitor {
|
||||
public void visit(UnaryExpr unaryExpr) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private class TPHExtractor extends AbstractASTWalker{
|
||||
// Alle TPHs der Felder werden iKopf der Klasse definiert
|
||||
// alle TPHs der Klasse: (TPH, is in Method?)
|
||||
final HashMap<TypePlaceholder,Boolean> allTPHS = new HashMap<>();
|
||||
MethodAndTPH methodAndTph;
|
||||
Boolean inMethod = false;
|
||||
final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
|
||||
final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder tph) {
|
||||
if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
|
||||
TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
|
||||
if(inMethod)
|
||||
methodAndTph.getTphs().add(resolvedTPH);
|
||||
|
||||
allTPHS.put(resolvedTPH,inMethod);
|
||||
resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
|
||||
if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
|
||||
if(inMethod)
|
||||
methodAndTph.getPairs().add(ag);
|
||||
allPairs.add(ag);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
|
||||
for(int i=0; i<pairs.size();++i) {
|
||||
GenericInsertPair p = pairs.get(i);
|
||||
if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
inMethod = true;
|
||||
methodAndTph = new MethodAndTPH(method.name);
|
||||
super.visit(method);
|
||||
inMethod = false;
|
||||
ListOfMethodsAndTph.add(methodAndTph);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
9
src/de/dhbwstuttgart/bytecode/IStatement.java
Normal file
9
src/de/dhbwstuttgart/bytecode/IStatement.java
Normal file
@ -0,0 +1,9 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import org.objectweb.asm.Label;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
|
||||
public interface IStatement {
|
||||
public boolean isExprBinary();
|
||||
public void genBCForRelOp(MethodVisitor mv, Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod);
|
||||
}
|
26
src/de/dhbwstuttgart/bytecode/LoopStmt.java
Normal file
26
src/de/dhbwstuttgart/bytecode/LoopStmt.java
Normal file
@ -0,0 +1,26 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import org.objectweb.asm.Label;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Statement;
|
||||
|
||||
public class LoopStmt extends AStatement {
|
||||
|
||||
private Statement loopBlock;
|
||||
|
||||
public LoopStmt(Expression expr, Statement loopBlock) {
|
||||
super(expr);
|
||||
this.loopBlock = loopBlock;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
|
||||
bytecodeGenMethod.isBinary(false);
|
||||
this.loopBlock.accept(bytecodeGenMethod);
|
||||
mv.visitJumpInsn(Opcodes.GOTO, endLabel);
|
||||
mv.visitLabel(branchLabel);
|
||||
}
|
||||
}
|
14
src/de/dhbwstuttgart/bytecode/ReturnStmt.java
Normal file
14
src/de/dhbwstuttgart/bytecode/ReturnStmt.java
Normal file
@ -0,0 +1,14 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
|
||||
public class ReturnStmt extends AStatement {
|
||||
|
||||
public ReturnStmt(Expression retexpr) {
|
||||
super(retexpr);
|
||||
}
|
||||
|
||||
}
|
@ -2,12 +2,14 @@ package de.dhbwstuttgart.bytecode.descriptor;
|
||||
|
||||
import java.util.Iterator;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.Lambda;
|
||||
import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
|
||||
import de.dhbwstuttgart.bytecode.NormalConstructor;
|
||||
import de.dhbwstuttgart.bytecode.NormalMethod;
|
||||
import de.dhbwstuttgart.bytecode.SamMethod;
|
||||
import org.objectweb.asm.Type;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
|
||||
import de.dhbwstuttgart.bytecode.utilities.Lambda;
|
||||
import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
|
||||
import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
|
||||
import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
|
||||
import de.dhbwstuttgart.bytecode.utilities.SamMethod;
|
||||
import de.dhbwstuttgart.syntaxtree.FormalParameter;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
@ -46,12 +48,20 @@ public class DescriptorToString implements DescriptorVisitor{
|
||||
}else if(method.getGenericsAndBounds().containsKey(fpDesc)){
|
||||
desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
|
||||
}else {
|
||||
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
// desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
if(resType.subSequence(0, 4).equals("TPH ")) {
|
||||
// Bound ist immer Object
|
||||
desc += "L"+Type.getInternalName(Object.class)+ ";";
|
||||
} else {
|
||||
desc += "L"+resType+ ";";
|
||||
}
|
||||
}
|
||||
}
|
||||
// else if(((RefType) fp.getType()).getParaList().size() > 0){
|
||||
// desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "%").replace("<", "%%").replace(">", "%%")+ ";";
|
||||
// }
|
||||
//TODO: generate a class java%% ... %%
|
||||
else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains("<")){
|
||||
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace("<", "$$$").replace(">", "$$$")+ ";";
|
||||
}
|
||||
else {
|
||||
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
}
|
||||
@ -67,7 +77,13 @@ public class DescriptorToString implements DescriptorVisitor{
|
||||
}else if(method.getGenericsAndBounds().containsKey(ret)){
|
||||
desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
|
||||
}else {
|
||||
desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
if(resType.subSequence(0, 4).equals("TPH ")) {
|
||||
// desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
|
||||
desc += ")" + "L"+Type.getInternalName(Object.class)+ ";";
|
||||
} else {
|
||||
desc += ")" + "L"+resType+ ";";
|
||||
}
|
||||
}
|
||||
}else {
|
||||
desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
@ -107,9 +123,21 @@ public class DescriptorToString implements DescriptorVisitor{
|
||||
Iterator<FormalParameter> itr = lambdaExpression.getParams().iterator();
|
||||
while(itr.hasNext()) {
|
||||
FormalParameter fp = itr.next();
|
||||
desc = desc + "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
|
||||
String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
|
||||
desc += "L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
desc = desc + "L"+ d + ";";
|
||||
}
|
||||
}
|
||||
|
||||
String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
|
||||
if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
|
||||
desc += ")L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
desc = desc + ")"+"L"+retType+";";
|
||||
}
|
||||
desc = addReturnType(desc, lambdaExpression.getReturnType(), resultSet);
|
||||
return desc;
|
||||
}
|
||||
|
||||
@ -119,9 +147,22 @@ public class DescriptorToString implements DescriptorVisitor{
|
||||
Iterator<RefTypeOrTPHOrWildcardOrGeneric> itr = samMethod.getArgumentList().iterator();
|
||||
while(itr.hasNext()) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
|
||||
desc = desc + "L"+resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor())+";";
|
||||
String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
|
||||
if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
|
||||
desc += "L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
desc += "L"+ d + ";";
|
||||
|
||||
}
|
||||
}
|
||||
String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
|
||||
if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
|
||||
desc += ")L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
desc = desc + ")"+"L"+retType+";";
|
||||
}
|
||||
desc = desc + ")"+"L"+resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
|
||||
return desc;
|
||||
}
|
||||
|
||||
@ -129,26 +170,34 @@ public class DescriptorToString implements DescriptorVisitor{
|
||||
public String visit(MethodFromMethodCall methodFromMethodCall) {
|
||||
String desc = "(";
|
||||
for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
|
||||
String d = e.getType().acceptTV(new TypeToDescriptor());
|
||||
if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
|
||||
desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
|
||||
}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
|
||||
desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
|
||||
String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
|
||||
if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
|
||||
desc += "L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
|
||||
desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
|
||||
}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
|
||||
desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
|
||||
}else {
|
||||
desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if(resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.toString().equals("void")) {
|
||||
String retType = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
System.out.println("DescriptorToString retType = " + retType);
|
||||
if(retType.equals("void")) {
|
||||
desc += ")V";
|
||||
}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
|
||||
desc += ")L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
String ret = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(ret)) {
|
||||
desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(ret)+ ";";
|
||||
}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(ret)){
|
||||
desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(ret)+ ";";
|
||||
if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {
|
||||
desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(retType)+ ";";
|
||||
}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(retType)){
|
||||
desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(retType)+ ";";
|
||||
}else {
|
||||
desc += ")" + "L"+resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
|
||||
desc += ")" + "L"+retType+ ";";
|
||||
}
|
||||
}
|
||||
// desc = addReturnType(desc, methodFromMethodCall.getReturnType(), resultSet);
|
||||
|
@ -1,10 +1,10 @@
|
||||
package de.dhbwstuttgart.bytecode.descriptor;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.Lambda;
|
||||
import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
|
||||
import de.dhbwstuttgart.bytecode.NormalConstructor;
|
||||
import de.dhbwstuttgart.bytecode.NormalMethod;
|
||||
import de.dhbwstuttgart.bytecode.SamMethod;
|
||||
import de.dhbwstuttgart.bytecode.utilities.Lambda;
|
||||
import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
|
||||
import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
|
||||
import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
|
||||
import de.dhbwstuttgart.bytecode.utilities.SamMethod;
|
||||
|
||||
public interface DescriptorVisitor {
|
||||
public String visit(NormalMethod method);
|
||||
|
@ -13,11 +13,15 @@ public class TypeToDescriptor implements TypeVisitor<String>{
|
||||
@Override
|
||||
public String visit(RefType refType) {
|
||||
return refType.getName().toString().replace(".", "/");
|
||||
// String t = refType.getName().toString().replace(".", "/");
|
||||
// return t.equals("Fun1")?(t+"$$"):t;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String visit(SuperWildcardType superWildcardType) {
|
||||
throw new NotImplementedException();
|
||||
System.out.println("\nWILDCARD ="+superWildcardType.getInnerType().toString().replace(".", "/"));
|
||||
return superWildcardType.getInnerType().toString().replace(".", "/");
|
||||
//throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -27,7 +31,9 @@ public class TypeToDescriptor implements TypeVisitor<String>{
|
||||
|
||||
@Override
|
||||
public String visit(ExtendsWildcardType extendsWildcardType) {
|
||||
throw new NotImplementedException();
|
||||
System.out.println("\nWILDCARD extends ="+extendsWildcardType.getInnerType().toString().replace(".", "/"));
|
||||
return extendsWildcardType.getInnerType().toString().replace(".", "/");
|
||||
//throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -1,5 +1,6 @@
|
||||
package de.dhbwstuttgart.bytecode.signature;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
|
||||
@ -8,13 +9,19 @@ import org.objectweb.asm.signature.SignatureVisitor;
|
||||
import org.objectweb.asm.signature.SignatureWriter;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
|
||||
import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
|
||||
import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.Constructor;
|
||||
import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
|
||||
import de.dhbwstuttgart.syntaxtree.Method;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
|
||||
import de.dhbwstuttgart.typeinference.result.ResolvedType;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
|
||||
public class Signature {
|
||||
@ -26,10 +33,13 @@ public class Signature {
|
||||
private Method method;
|
||||
private HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes;
|
||||
private ResultSet resultSet;
|
||||
private ArrayList<GenericInsertPair> commonPairs;
|
||||
private ArrayList<GenericInsertPair> methodPairs;
|
||||
|
||||
public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds) {
|
||||
public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds,ArrayList<GenericInsertPair> commonPairs) {
|
||||
this.classOrInterface = classOrInterface;
|
||||
this.genericsAndBounds = genericsAndBounds;
|
||||
this.commonPairs = commonPairs;
|
||||
sw = new SignatureWriter();
|
||||
createSignatureForClassOrInterface();
|
||||
}
|
||||
@ -42,12 +52,14 @@ public class Signature {
|
||||
createSignatureForConsOrMethod(this.constructor,true);
|
||||
}
|
||||
|
||||
public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,
|
||||
HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet) {
|
||||
public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,HashMap<String, String> genericsAndBounds,
|
||||
HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet, ArrayList<GenericInsertPair> methodPairs) {
|
||||
this.method = method;
|
||||
this.genericsAndBoundsMethod = genericsAndBoundsMethod;
|
||||
this.genericsAndBounds = genericsAndBounds;
|
||||
this.methodParamsAndTypes = methodParamsAndTypes;
|
||||
this.resultSet = resultSet;
|
||||
this.methodPairs = methodPairs;
|
||||
sw = new SignatureWriter();
|
||||
createSignatureForConsOrMethod(this.method,false);
|
||||
}
|
||||
@ -59,10 +71,7 @@ public class Signature {
|
||||
|
||||
private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
|
||||
|
||||
sw.visitFormalTypeParameter("R");
|
||||
// getBounds vom Return-Type
|
||||
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
|
||||
sw.visitClassBound().visitEnd();
|
||||
// sw.visitClassBound().visitEnd();
|
||||
for(int i = 0;i<numberOfParams;i++) {
|
||||
int j = i+1;
|
||||
sw.visitFormalTypeParameter("T"+ j);
|
||||
@ -70,6 +79,11 @@ public class Signature {
|
||||
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
|
||||
sw.visitClassBound().visitEnd();
|
||||
}
|
||||
|
||||
sw.visitFormalTypeParameter("R");
|
||||
// getBounds vom Return-Type
|
||||
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
|
||||
sw.visitClassBound().visitEnd();
|
||||
// TODO: prüfe ob Return-Type = void,
|
||||
sw.visitSuperclass().visitClassType(Type.getInternalName(Object.class));;
|
||||
sw.visitEnd();
|
||||
@ -90,7 +104,96 @@ public class Signature {
|
||||
GenericTypeVar g = itr.next();
|
||||
getBoundsOfTypeVar(g,genericsAndBoundsMethod);
|
||||
}
|
||||
// visits each method-parameter to create the signature
|
||||
|
||||
// Wenn die RückgabeType eine TPH ist, wird als generic behandelt
|
||||
// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
|
||||
String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
|
||||
if(ret.substring(0,4).equals("TPH ")) {
|
||||
String g = ret.substring(4,ret.length())+"$";
|
||||
if(genericsAndBounds.containsKey(g)) {
|
||||
genericsAndBoundsMethod.put(g, genericsAndBounds.get(g));
|
||||
}else {
|
||||
sw.visitFormalTypeParameter(g);
|
||||
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
|
||||
genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
|
||||
sw.visitClassBound().visitEnd();
|
||||
}
|
||||
}
|
||||
|
||||
if(ret.contains("<")) {
|
||||
RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
|
||||
if(hasTPHs(ref)) {
|
||||
createSignatureForParameterizedType(ref);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Parameters
|
||||
for(String paramName : methodParamsAndTypes.keySet()) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
|
||||
String pT = t.acceptTV(new TypeToSignature());
|
||||
// S.o
|
||||
if(pT.substring(0,4).equals("TPH ")) {
|
||||
String gP = pT.substring(4,pT.length())+"$";
|
||||
if(!genericsAndBounds.containsKey(gP) && !genericsAndBoundsMethod.containsKey(gP)) {
|
||||
sw.visitFormalTypeParameter(gP);
|
||||
String bound = Type.getInternalName(Object.class);
|
||||
boolean isTypeVar = false;
|
||||
for(GenericInsertPair pair : methodPairs) {
|
||||
if(pT.substring(4).equals(pair.TA1.getName())) {
|
||||
bound = pair.TA2.getName()+"$";
|
||||
isTypeVar = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(isTypeVar) {
|
||||
sw.visitClassBound().visitTypeVariable(bound);
|
||||
}else {
|
||||
sw.visitClassBound().visitClassType(bound);
|
||||
sw.visitClassBound().visitEnd();
|
||||
}
|
||||
|
||||
genericsAndBoundsMethod.put(gP, bound);
|
||||
}
|
||||
}
|
||||
|
||||
if(pT.contains("<")) {
|
||||
RefType ref = (RefType) methodParamsAndTypes.get(paramName);
|
||||
if(hasTPHs(ref))
|
||||
createSignatureForParameterizedType(ref);
|
||||
}
|
||||
|
||||
for(GenericInsertPair p:methodPairs) {
|
||||
String name = p.TA1.getName()+"$";
|
||||
if(!genericsAndBoundsMethod.containsKey(name)) {
|
||||
sw.visitFormalTypeParameter(name);
|
||||
sw.visitClassBound().visitTypeVariable(p.TA2.getName()+"$");
|
||||
genericsAndBoundsMethod.put(name, p.TA2.getName()+"$");
|
||||
}
|
||||
}
|
||||
|
||||
ArrayList<TypePlaceholder> types = new ArrayList<>();
|
||||
ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
|
||||
|
||||
for(GenericInsertPair p : methodPairs) {
|
||||
types.add(p.TA1);
|
||||
superTypes.add(p.TA2);
|
||||
}
|
||||
|
||||
for(GenericInsertPair p : methodPairs) {
|
||||
String name = p.TA2.getName()+"$";
|
||||
if(!types.contains(p.TA2) && !genericsAndBoundsMethod.containsKey(name)) {
|
||||
String bound = Type.getInternalName(Object.class);
|
||||
sw.visitFormalTypeParameter(name);
|
||||
sw.visitClassBound().visitClassType(bound);
|
||||
genericsAndBoundsMethod.put(name, bound);
|
||||
sw.visitClassBound().visitEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// visit each method-parameter to create the signature
|
||||
for(String paramName : methodParamsAndTypes.keySet()) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
|
||||
// parameter type deswegen ist true
|
||||
@ -105,6 +208,142 @@ public class Signature {
|
||||
}
|
||||
// sw.visitEnd();
|
||||
}
|
||||
|
||||
private void createSignatureForParameterizedType(RefType ref) {
|
||||
ArrayList<GenericInsertPair> allPairs = getAllPairs(ref);
|
||||
allPairs.addAll(methodPairs);
|
||||
ArrayList<GenericInsertPair> simplifiedPairs = simplifyPairs(allPairs);
|
||||
|
||||
HashMap<String, String> names = new HashMap<>();
|
||||
|
||||
for(GenericInsertPair pair : simplifiedPairs) {
|
||||
if(ref.getParaList().contains(pair.TA1)) {
|
||||
String sub = pair.TA1.getName()+"$";
|
||||
String superT = pair.TA2.getName()+"$";
|
||||
names.put(sub, superT);
|
||||
}
|
||||
}
|
||||
|
||||
for(String sub : names.keySet()) {
|
||||
if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) {
|
||||
sw.visitFormalTypeParameter(sub);
|
||||
String bound = names.get(sub);
|
||||
sw.visitClassBound().visitTypeVariable(bound);
|
||||
genericsAndBoundsMethod.put(sub, bound);
|
||||
}
|
||||
}
|
||||
|
||||
for(String superT : names.values()) {
|
||||
if(!names.containsKey(superT)) {
|
||||
if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) {
|
||||
sw.visitFormalTypeParameter(superT);
|
||||
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
|
||||
sw.visitClassBound().visitEnd();
|
||||
genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) {
|
||||
if(p instanceof TypePlaceholder) {
|
||||
String name = ((TypePlaceholder) p).getName() + "$";
|
||||
if(!genericsAndBoundsMethod.containsKey(name) && !genericsAndBounds.containsKey(name)) {
|
||||
sw.visitFormalTypeParameter(name);
|
||||
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
|
||||
sw.visitClassBound().visitEnd();
|
||||
genericsAndBoundsMethod.put(name, Type.getInternalName(Object.class));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
|
||||
final ArrayList<GenericInsertPair> res = new ArrayList<>();
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType;
|
||||
if(resolved instanceof TypePlaceholder) {
|
||||
resultSet.resolveType(p).additionalGenerics.forEach(ag ->{
|
||||
if(!contains(res,ag)) {
|
||||
res.add(ag);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
|
||||
for(int i=0; i<pairs.size();++i) {
|
||||
GenericInsertPair p = pairs.get(i);
|
||||
if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private ArrayList<GenericInsertPair> simplifyPairs(ArrayList<GenericInsertPair> allPairs) {
|
||||
ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
|
||||
|
||||
HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
|
||||
for(GenericInsertPair p : allPairs) {
|
||||
subAndSuperTph.put(p.TA1, p.TA2);
|
||||
}
|
||||
|
||||
subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));
|
||||
|
||||
int numOfVisitedPairs = 0;
|
||||
for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
|
||||
|
||||
if(numOfVisitedPairs>=subAndSuperTph.size())
|
||||
break;
|
||||
|
||||
HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
|
||||
|
||||
tphsInRel.put(tphsInRel.size(), subTph);
|
||||
TypePlaceholder superTph = subAndSuperTph.get(subTph);
|
||||
tphsInRel.put(tphsInRel.size(), superTph);
|
||||
|
||||
numOfVisitedPairs++;
|
||||
|
||||
while(subAndSuperTph.containsKey(superTph)) {
|
||||
superTph = subAndSuperTph.get(superTph);
|
||||
tphsInRel.put(tphsInRel.size(), superTph);
|
||||
numOfVisitedPairs++;
|
||||
}
|
||||
|
||||
// Subtype
|
||||
TypePlaceholder subTphRes = tphsInRel.get(0);
|
||||
// Die größte Supertype
|
||||
TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
|
||||
|
||||
|
||||
while(subAndSuperTph.containsValue(subTphRes)) {
|
||||
for(TypePlaceholder tph : subAndSuperTph.keySet()) {
|
||||
if(subAndSuperTph.get(tph).equals(subTphRes)) {
|
||||
subTphRes = tph;
|
||||
break;
|
||||
}
|
||||
}
|
||||
tphsInRel.put(0, subTphRes);
|
||||
numOfVisitedPairs++;
|
||||
}
|
||||
|
||||
subTphRes = tphsInRel.get(0);
|
||||
GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
|
||||
simplifiedPairs.add(sPair);
|
||||
}
|
||||
return simplifiedPairs;
|
||||
}
|
||||
|
||||
private boolean hasTPHs(RefType ref) {
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
|
||||
if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Visits parameter type or return type with {@link SignatureVisitor} to create
|
||||
* the method signature
|
||||
@ -130,10 +369,16 @@ public class Signature {
|
||||
break;
|
||||
case "TPH":
|
||||
RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
|
||||
if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH "))
|
||||
sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
|
||||
// sv.visitClassType(r.acceptTV(new TypeToSignature()));
|
||||
System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
|
||||
// der Fall wenn die Type eine Interface ist, muss betrachtet werden
|
||||
// Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
|
||||
// Interface oder eine Klasse ist.
|
||||
if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
|
||||
// sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
|
||||
sv.visitClassType(r.acceptTV(new TypeToSignature()));
|
||||
} else {
|
||||
System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
|
||||
sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if(!isParameterType)
|
||||
@ -153,7 +398,34 @@ public class Signature {
|
||||
GenericTypeVar g = itr.next();
|
||||
getBoundsOfTypeVar(g,genericsAndBounds);
|
||||
}
|
||||
|
||||
if(!commonPairs.isEmpty()) {
|
||||
ArrayList<TypePlaceholder> types = new ArrayList<>();
|
||||
ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
|
||||
|
||||
for(GenericInsertPair p : commonPairs) {
|
||||
types.add(p.TA1);
|
||||
superTypes.add(p.TA2);
|
||||
}
|
||||
|
||||
for(GenericInsertPair p : commonPairs) {
|
||||
String t = p.TA1.getName()+"$";
|
||||
String bound = p.TA2.getName()+"$";
|
||||
sw.visitFormalTypeParameter(t);
|
||||
sw.visitClassBound().visitTypeVariable(bound);
|
||||
genericsAndBounds.put(t, bound);
|
||||
}
|
||||
|
||||
for(GenericInsertPair p : commonPairs) {
|
||||
if(!types.contains(p.TA2)) {
|
||||
String t = p.TA2.getName()+"$";
|
||||
String bound = Type.getInternalName(Object.class);
|
||||
sw.visitFormalTypeParameter(t);
|
||||
sw.visitClassBound().visitClassType(bound);
|
||||
genericsAndBounds.put(t, bound);
|
||||
sw.visitClassBound().visitEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
sw.visitSuperclass().visitClassType(classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()));;
|
||||
sw.visitEnd();
|
||||
}
|
||||
|
@ -22,11 +22,18 @@ public class TypeToSignature implements TypeVisitor<String> {
|
||||
Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
|
||||
while(it.hasNext()){
|
||||
RefTypeOrTPHOrWildcardOrGeneric param = it.next();
|
||||
params += "L"+param.toString().replace(".", "/");
|
||||
if(param instanceof TypePlaceholder) {
|
||||
params += "T" + ((TypePlaceholder) param).getName() + "$";
|
||||
} else {
|
||||
params += "L"+param.toString().replace(".", "/");
|
||||
}
|
||||
|
||||
if(it.hasNext())params += ";";
|
||||
}
|
||||
params += ";>";
|
||||
}
|
||||
// String t = refType.getName().toString().replace(".", "/");
|
||||
// return t.equals("Fun1")?t+"$$"+params+";":t+params+";";
|
||||
return refType.getName().toString().replace(".", "/") + params+";";
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
@ -1,4 +1,4 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.ParameterList;
|
29
src/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java
Normal file
29
src/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java
Normal file
@ -0,0 +1,29 @@
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
|
||||
|
||||
public class MethodAndTPH {
|
||||
|
||||
private String name;
|
||||
private final ArrayList<TypePlaceholder> tphs = new ArrayList<>();
|
||||
private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
|
||||
|
||||
public MethodAndTPH(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public ArrayList<TypePlaceholder> getTphs() {
|
||||
return tphs;
|
||||
}
|
||||
|
||||
public ArrayList<GenericInsertPair> getPairs(){
|
||||
return pairs;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
}
|
@ -1,4 +1,4 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
@ -1,4 +1,4 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
@ -1,4 +1,4 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
@ -1,4 +1,4 @@
|
||||
package de.dhbwstuttgart.bytecode;
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import java.util.List;
|
||||
|
@ -1,42 +1,57 @@
|
||||
package de.dhbwstuttgart.core;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.bytecode.BytecodeGen;
|
||||
import de.dhbwstuttgart.environment.CompilationEnvironment;
|
||||
import de.dhbwstuttgart.parser.JavaTXParser;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.scope.GenericsRegistry;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
|
||||
import de.dhbwstuttgart.parser.scope.JavaClassName;
|
||||
import de.dhbwstuttgart.sat.asp.ASPUnify;
|
||||
import de.dhbwstuttgart.sat.asp.parser.ASPParser;
|
||||
import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
|
||||
import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.ParameterList;
|
||||
import de.dhbwstuttgart.syntaxtree.SourceFile;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
|
||||
import de.dhbwstuttgart.typeinference.unify.RuleSet;
|
||||
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
|
||||
import de.dhbwstuttgart.typeinference.unify.distributeVariance;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
|
||||
|
||||
import java.io.*;
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.FileWriter;
|
||||
import java.io.IOException;
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
public class JavaTXCompiler {
|
||||
|
||||
final CompilationEnvironment environment;
|
||||
public final Map<File, SourceFile> sourceFiles = new HashMap<>();
|
||||
Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
|
||||
|
||||
public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
|
||||
this(Arrays.asList(sourceFile));
|
||||
}
|
||||
|
||||
public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
|
||||
this(sourceFile);
|
||||
this.log = log;
|
||||
}
|
||||
|
||||
public JavaTXCompiler(List<File> sources) throws IOException, ClassNotFoundException {
|
||||
environment = new CompilationEnvironment(sources);
|
||||
for (File s : sources) {
|
||||
@ -95,20 +110,115 @@ public class JavaTXCompiler {
|
||||
|
||||
TypeUnify unify = new TypeUnify();
|
||||
Set<Set<UnifyPair>> results = new HashSet<>();
|
||||
for (List<Constraint<UnifyPair>> xCons : unifyCons.cartesianProduct()) {
|
||||
Set<UnifyPair> xConsSet = new HashSet<>();
|
||||
for (Constraint<UnifyPair> constraint : xCons) {
|
||||
xConsSet.addAll(constraint);
|
||||
}
|
||||
|
||||
System.out.println(xConsSet);
|
||||
Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
|
||||
System.out.println("RESULT: " + result.size());
|
||||
results.addAll(result);
|
||||
try {
|
||||
FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/test/logFiles/"+"log"));
|
||||
logFile.write("FC:\\" + finiteClosure.toString()+"\n");
|
||||
for(SourceFile sf : this.sourceFiles.values()) {
|
||||
logFile.write(ASTTypePrinter.print(sf));
|
||||
}
|
||||
logFile.flush();
|
||||
Set<List<Constraint<UnifyPair>>> cardProd = unifyCons.cartesianProduct();
|
||||
for (List<Constraint<UnifyPair>> xCons : cardProd ){
|
||||
Set<UnifyPair> xConsSet = new HashSet<>();
|
||||
for (Constraint<UnifyPair> constraint : xCons) {
|
||||
xConsSet.addAll(constraint);
|
||||
}
|
||||
//.collect(Collectors.toCollection(ArrayList::new))))
|
||||
System.out.println(xConsSet);
|
||||
Set<String> paraTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist()
|
||||
.stream().filter(z -> z.getType() instanceof TypePlaceholder)
|
||||
.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
|
||||
.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} ) )
|
||||
.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
|
||||
|
||||
Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
|
||||
.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
|
||||
|
||||
|
||||
xConsSet = xConsSet.stream().map(x -> {
|
||||
//Hier muss ueberlegt werden, ob
|
||||
//1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs
|
||||
// mit disableWildcardtable() werden.
|
||||
//2. alle Typvariablen mit Argument- oder Retuntyp-Variablen
|
||||
//in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
|
||||
//PL 2018-04-23
|
||||
if ((x.getLhsType() instanceof PlaceholderType)) {
|
||||
if (paraTypeVarNames.contains(x.getLhsType().getName())) {
|
||||
((PlaceholderType)x.getLhsType()).setVariance((byte)1);
|
||||
((PlaceholderType)x.getLhsType()).disableWildcardtable();
|
||||
}
|
||||
if (returnTypeVarNames.contains(x.getLhsType().getName())) {
|
||||
((PlaceholderType)x.getLhsType()).setVariance((byte)-1);
|
||||
((PlaceholderType)x.getLhsType()).disableWildcardtable();
|
||||
}
|
||||
}
|
||||
if ((x.getRhsType() instanceof PlaceholderType)) {
|
||||
if (paraTypeVarNames.contains(x.getRhsType().getName())) {
|
||||
((PlaceholderType)x.getRhsType()).setVariance((byte)1);
|
||||
((PlaceholderType)x.getRhsType()).disableWildcardtable();
|
||||
}
|
||||
if (returnTypeVarNames.contains(x.getRhsType().getName())) {
|
||||
((PlaceholderType)x.getRhsType()).setVariance((byte)-1);
|
||||
((PlaceholderType)x.getRhsType()).disableWildcardtable();
|
||||
}
|
||||
}
|
||||
return x;//HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE JEWEILS ANDERE SEITE
|
||||
}).map( y -> {
|
||||
if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) {
|
||||
if (((PlaceholderType)y.getLhsType()).getVariance() != 0 && ((PlaceholderType)y.getRhsType()).getVariance() == 0) {
|
||||
((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType()).getVariance());
|
||||
}
|
||||
if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) {
|
||||
((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType()).getVariance());
|
||||
}
|
||||
}
|
||||
return y; } )
|
||||
.collect(Collectors.toCollection(HashSet::new));
|
||||
varianceInheritance(xConsSet);
|
||||
Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
|
||||
//Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
|
||||
System.out.println("RESULT: " + result);
|
||||
logFile.write("RES: " + result.toString()+"\n");
|
||||
logFile.flush();
|
||||
results.addAll(result);
|
||||
}
|
||||
}
|
||||
catch (IOException e) { }
|
||||
|
||||
return results.stream().map((unifyPairs ->
|
||||
new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
|
||||
}
|
||||
return results.stream().map((unifyPairs ->
|
||||
new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
/**
|
||||
* Vererbt alle Variancen
|
||||
* @param eq The set of constraints
|
||||
*/
|
||||
private void varianceInheritance(Set<UnifyPair> eq) {
|
||||
Set<PlaceholderType> usedTPH = new HashSet<>();
|
||||
Set<PlaceholderType> phSet = eq.stream().map(x -> {
|
||||
Set<PlaceholderType> pair = new HashSet<>();
|
||||
if (x.getLhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getLhsType());
|
||||
if (x.getRhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getRhsType());
|
||||
return pair;
|
||||
}).reduce(new HashSet<>(), (a,b) -> { a.addAll(b); return a;} , (c,d) -> { c.addAll(d); return c;});
|
||||
|
||||
ArrayList<PlaceholderType> phSetVariance = new ArrayList<>(phSet);
|
||||
phSetVariance.removeIf(x -> (x.getVariance() == 0));
|
||||
while(!phSetVariance.isEmpty()) {
|
||||
PlaceholderType a = phSetVariance.remove(0);
|
||||
usedTPH.add(a);
|
||||
//HashMap<PlaceholderType,Integer> ht = new HashMap<>();
|
||||
//ht.put(a, a.getVariance());
|
||||
Set<UnifyPair> eq1 = new HashSet<>(eq);
|
||||
eq1.removeIf(x -> !(x.getLhsType() instanceof PlaceholderType && ((PlaceholderType)x.getLhsType()).equals(a)));
|
||||
eq1.stream().forEach(x -> { x.getRhsType().accept(new distributeVariance(), a.getVariance());});
|
||||
eq1 = new HashSet<>(eq);
|
||||
eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType && ((PlaceholderType)x.getRhsType()).equals(a)));
|
||||
eq1.stream().forEach(x -> { x.getLhsType().accept(new distributeVariance(), a.getVariance());});
|
||||
phSetVariance = new ArrayList<>(phSet);
|
||||
phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x)));
|
||||
}
|
||||
}
|
||||
|
||||
private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
|
||||
HashMap<String, TypePlaceholder> ret = new HashMap<>();
|
||||
@ -130,74 +240,29 @@ public class JavaTXCompiler {
|
||||
SourceFile ret = generator.convert(tree, environment.packageCrawler);
|
||||
return ret;
|
||||
}
|
||||
|
||||
public List<ResultSet> aspTypeInference() throws ClassNotFoundException, IOException, InterruptedException {
|
||||
Collection<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
|
||||
//Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
|
||||
for(SourceFile sf : this.sourceFiles.values()) {
|
||||
allClasses.addAll(getAvailableClasses(sf));
|
||||
allClasses.addAll(sf.getClasses());
|
||||
}
|
||||
HashMap<String, ClassOrInterface> classes = new HashMap<>();
|
||||
for(ClassOrInterface cl : allClasses){
|
||||
classes.put(cl.getClassName().toString(), cl);
|
||||
}
|
||||
allClasses = classes.values();
|
||||
|
||||
final ConstraintSet<Pair> cons = getConstraints();
|
||||
|
||||
String content = "";
|
||||
content = ASPFactory.generateASP(cons, allClasses);
|
||||
final String tempDirectory = "/tmp/";
|
||||
PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8");
|
||||
writer.println(content);
|
||||
writer.close();
|
||||
ASPUnify clingo = new ASPUnify(Arrays.asList(new File(tempDirectory + "test.lp")));
|
||||
String result = clingo.runClingo();
|
||||
//System.out.println(result);
|
||||
ResultSet resultSet = ASPParser.parse(result, getInvolvedTPHS(cons));
|
||||
return Arrays.asList(resultSet);
|
||||
// um pfad erweitern
|
||||
public void generateBytecode(String path) throws ClassNotFoundException, IOException {
|
||||
for(File f : sourceFiles.keySet()) {
|
||||
HashMap<String,byte[]> classFiles = new HashMap<>();
|
||||
SourceFile sf = sourceFiles.get(f);
|
||||
List<ResultSet> typeinferenceResult = this.typeInference();
|
||||
BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,path);
|
||||
// BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
|
||||
bytecodeGen.visit(sf);
|
||||
this.writeClassFile(bytecodeGen.getClassFiles(), path);
|
||||
}
|
||||
}
|
||||
|
||||
private static class TPHExtractor implements TypeVisitor<List<TypePlaceholder>> {
|
||||
@Override
|
||||
public List<TypePlaceholder> visit(RefType refType) {
|
||||
ArrayList<TypePlaceholder> ret = new ArrayList<>();
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
|
||||
ret.addAll(param.acceptTV(this));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<TypePlaceholder> visit(SuperWildcardType superWildcardType) {
|
||||
return superWildcardType.getInnerType().acceptTV(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<TypePlaceholder> visit(TypePlaceholder typePlaceholder) {
|
||||
return Arrays.asList(typePlaceholder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<TypePlaceholder> visit(ExtendsWildcardType extendsWildcardType) {
|
||||
return extendsWildcardType.getInnerType().acceptTV(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<TypePlaceholder> visit(GenericRefType genericRefType) {
|
||||
return new ArrayList<>();
|
||||
}
|
||||
}
|
||||
|
||||
protected Collection<TypePlaceholder> getInvolvedTPHS(ConstraintSet<Pair> toTest) {
|
||||
List<TypePlaceholder> ret = new ArrayList<>();
|
||||
toTest.map((Pair p)-> {
|
||||
ret.addAll(p.TA1.acceptTV(new TPHExtractor()));
|
||||
ret.addAll(p.TA2.acceptTV(new TPHExtractor()));
|
||||
return p;
|
||||
});
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
private void writeClassFile(HashMap<String, byte[]> classFiles, String path) throws IOException {
|
||||
FileOutputStream output;
|
||||
for(String name : classFiles.keySet()) {
|
||||
byte[] bytecode = classFiles.get(name);
|
||||
System.out.println("generating "+name+ ".class file ...");
|
||||
//output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
|
||||
output = new FileOutputStream(new File(path +name+".class"));
|
||||
output.write(bytecode);
|
||||
output.close();
|
||||
System.out.println(name+".class file generated");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -7,8 +7,6 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.TypePrinter;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.*;
|
||||
|
||||
@ -26,28 +24,12 @@ public class FCGenerator {
|
||||
return toFC(availableClasses).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
/*
|
||||
Hier entstehen unnötige Typpaare
|
||||
wenn es mehrere Vererbungsketten gibt
|
||||
Beispiel:
|
||||
* X<B,C> < Y<B,C>
|
||||
* X<D,E> < Y<D,E>
|
||||
Will man dies aber rausnehmen, muss man die andere Kette umbenennen.
|
||||
Schwierig/Unmöglich, dank mehrfachvererbung
|
||||
* Z<B,C,D,E> < X<B,C> < Y<B,C>
|
||||
* Z<B,C,D,E> < X<D,E> < Y<D,E>
|
||||
|
||||
*/
|
||||
public static Collection<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
|
||||
HashMap<String, Pair> pairs = new HashMap<>();
|
||||
TypePrinter printer = new TypePrinter();
|
||||
public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
|
||||
HashSet<Pair> pairs = new HashSet<>();
|
||||
for(ClassOrInterface cly : availableClasses){
|
||||
for(Pair p : getSuperTypes(cly, availableClasses)){
|
||||
String hash = p.TA1.acceptTV(printer)+";"+p.TA2.acceptTV(printer);
|
||||
pairs.put(hash, p);
|
||||
}
|
||||
pairs.addAll(getSuperTypes(cly, availableClasses));
|
||||
}
|
||||
return pairs.values();
|
||||
return pairs;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -139,23 +121,6 @@ public class FCGenerator {
|
||||
return retList;
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Klasse sorgt dafür, dass alle TPHs den selben Namen bekommen.
|
||||
* Damit lassen sich unnötige Typpaare aussortieren.
|
||||
* Gibt es zwei Typpaare der Form:
|
||||
* X<B,C> < Y<B,C>
|
||||
* X<D,E> < Y<D,E>
|
||||
* so bekommen sie hier den gleichen Namen zugewiesen und werden in der HashMap aussortiert
|
||||
* X<TPH,TPH> < Y<TPH,TPH>
|
||||
|
||||
private static class TypePrinterExcludingTPHs extends TypePrinter{
|
||||
@Override
|
||||
public String visit(TypePlaceholder typePlaceholder) {
|
||||
return "TPH";
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/**
|
||||
* Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus.
|
||||
*/
|
||||
|
@ -745,7 +745,6 @@ public class StatementGenerator {
|
||||
if(e.classInstanceCreationExpression_lf_primary() != null){
|
||||
throw new NotImplementedException();
|
||||
}else if(e.fieldAccess_lf_primary() != null){
|
||||
|
||||
throw new NotImplementedException();
|
||||
}else if(e.arrayAccess_lf_primary() != null){
|
||||
throw new NotImplementedException();
|
||||
@ -800,6 +799,8 @@ public class StatementGenerator {
|
||||
if(newExpression.typeArgumentsOrDiamond()!= null){
|
||||
if(newExpression.typeArgumentsOrDiamond().typeArguments()!=null){
|
||||
genericArgs = newExpression.typeArgumentsOrDiamond().typeArguments();
|
||||
}else {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
if(newExpression.typeArguments()!= null)throw new NotImplementedException();
|
||||
@ -831,7 +832,7 @@ public class StatementGenerator {
|
||||
}else if(literal.StringLiteral()!=null){
|
||||
RefType type = new RefType(reg.getName("java.lang.String"),literal.getStart());
|
||||
return new Literal(type,
|
||||
literal.StringLiteral().getText(),
|
||||
literal.StringLiteral().getText().substring(1, literal.StringLiteral().getText().length()-1),
|
||||
literal.getStart());
|
||||
}else if(literal.NullLiteral() != null){
|
||||
return new Literal(TypePlaceholder.fresh(literal.getStart()), null,
|
||||
@ -903,7 +904,7 @@ public class StatementGenerator {
|
||||
funNParams.add(TypePlaceholder.fresh(expression.getStart())));
|
||||
RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
|
||||
//RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()),
|
||||
//funNParams, name.getStart());
|
||||
//funNParams, name.getStart());
|
||||
return new LambdaExpression(lambdaType, params, block, expression.getStart());
|
||||
}
|
||||
}
|
||||
|
@ -427,9 +427,6 @@ public class SyntaxTreeGenerator{
|
||||
GenericsRegistry ret = new GenericsRegistry(this.globalGenerics);
|
||||
ret.putAll(generics);
|
||||
if(ctx == null || ctx.typeParameterList() == null)return ret;
|
||||
for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
|
||||
ret.put(tp.Identifier().getText(), new GenericContext(parentClass, parentMethod));
|
||||
}
|
||||
for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
|
||||
TypeGenerator.convert(tp, parentClass, parentMethod, reg, ret);
|
||||
}
|
||||
|
@ -77,6 +77,7 @@ public class TypeGenerator {
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics);
|
||||
|
||||
GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
|
||||
generics.put(name, new GenericContext(parentClass, parentMethod));
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -91,7 +92,7 @@ public class TypeGenerator {
|
||||
return ret;
|
||||
}
|
||||
if(typeBoundContext.classOrInterfaceType() != null){
|
||||
ret.add(convert(typeBoundContext.classOrInterfaceType(), reg, generics));
|
||||
ret.add(convert(typeBoundContext.classOrInterfaceType()));
|
||||
if(typeBoundContext.additionalBound() != null)
|
||||
for(Java8Parser.AdditionalBoundContext addCtx : typeBoundContext.additionalBound()){
|
||||
ret.add(convert(addCtx.interfaceType()));
|
||||
@ -102,9 +103,8 @@ public class TypeGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = classOrInterfaceTypeContext.classType_lfno_classOrInterfaceType();
|
||||
return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),classOrInterfaceTypeContext.getStart(), reg, generics);
|
||||
private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.InterfaceTypeContext interfaceTypeContext) {
|
||||
@ -114,7 +114,8 @@ public class TypeGenerator {
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ReferenceTypeContext referenceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
if(referenceTypeContext.classOrInterfaceType() != null){
|
||||
if(referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType()!= null){
|
||||
return convert(referenceTypeContext.classOrInterfaceType(), reg, generics);//return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
|
||||
Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType();
|
||||
return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
|
||||
}else{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
@ -1,60 +0,0 @@
|
||||
package de.dhbwstuttgart.sat.asp;
|
||||
|
||||
|
||||
import org.apache.commons.io.IOUtils;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class ASPUnify {
|
||||
private final List<File> input;
|
||||
private static final List<File> programFiles = new ArrayList<>();
|
||||
|
||||
private static final String aspDirectory = System.getProperty("user.dir")+"/asp/";
|
||||
static{
|
||||
programFiles.add(new File(aspDirectory + "fc.lp"));
|
||||
programFiles.add(new File(aspDirectory + "reduceRules.lp"));
|
||||
programFiles.add(new File(aspDirectory + "adaptRules.lp"));
|
||||
programFiles.add(new File(aspDirectory + "step4.lp"));
|
||||
programFiles.add(new File(aspDirectory + "subst.lp"));
|
||||
programFiles.add(new File(aspDirectory + "unifikation.lp"));
|
||||
programFiles.add(new File(aspDirectory + "cartesian.lp"));
|
||||
programFiles.add(new File(aspDirectory + "result.lp"));
|
||||
}
|
||||
|
||||
public ASPUnify(List<File> inputFiles){
|
||||
this.input = inputFiles;
|
||||
}
|
||||
|
||||
/*
|
||||
TODO: Clingo per Java Wrapper https://stackoverflow.com/questions/3356200/using-java-to-wrap-over-c
|
||||
*/
|
||||
public String runClingo() throws IOException, InterruptedException {
|
||||
String pathToClingo =
|
||||
"clingo";
|
||||
List<String> commands = new ArrayList<>();
|
||||
commands.add(pathToClingo);
|
||||
//commands.add("--outf=2"); //use JSON-Output
|
||||
commands.add("--outf=1"); //use Text-Output
|
||||
commands.add("-n 0"); //Compute n models
|
||||
for(File file : input){
|
||||
commands.add(file.getPath());
|
||||
}
|
||||
commands.addAll(programFiles.stream().map(f->f.getPath()).collect(Collectors.toList()));
|
||||
|
||||
//commands.stream().forEach(s -> System.out.print(s + " "));
|
||||
//System.out.println();
|
||||
|
||||
Process clingo = new ProcessBuilder( commands.toArray(new String[0])).start();
|
||||
InputStream output = clingo.getInputStream();
|
||||
clingo.waitFor();
|
||||
String result = IOUtils.toString(output, StandardCharsets.UTF_8);
|
||||
System.out.println(result);
|
||||
return result;
|
||||
}
|
||||
}
|
@ -6,6 +6,7 @@ import org.apache.commons.io.IOUtils;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@ -15,7 +16,12 @@ public class Clingo {
|
||||
private final List<File> input;
|
||||
private static final List<File> programFiles = new ArrayList<>();
|
||||
static{
|
||||
|
||||
programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/basis.lp"));
|
||||
programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/finiteclosure.lp"));
|
||||
programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/subst.lp"));
|
||||
programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/reduce.lp"));
|
||||
programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/unify.lp"));
|
||||
programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/adapt.lp"));
|
||||
}
|
||||
|
||||
public Clingo(List<File> inputFiles){
|
||||
@ -27,12 +33,11 @@ public class Clingo {
|
||||
*/
|
||||
public String runClingo() throws IOException, InterruptedException {
|
||||
String pathToClingo =
|
||||
"clingo";
|
||||
"/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/clingo-5.2.1-linux-x86_64/clingo";
|
||||
List<String> commands = new ArrayList<>();
|
||||
commands.add(pathToClingo);
|
||||
//commands.add("--outf=2"); //use JSON-Output
|
||||
commands.add("--outf=1"); //use Text-Output
|
||||
commands.add("-n 0"); //Compute all models
|
||||
commands.add("--outf=1"); //use JSON-Output
|
||||
for(File file : input){
|
||||
commands.add(file.getPath());
|
||||
}
|
||||
|
@ -1,7 +1,5 @@
|
||||
package de.dhbwstuttgart.sat.asp.model;
|
||||
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
|
||||
public enum ASPGencayRule {
|
||||
ASP_PAIR_EQUALS_NAME("equals"),
|
||||
ASP_PAIR_SMALLER_NAME("sub"),
|
||||
@ -9,13 +7,10 @@ public enum ASPGencayRule {
|
||||
ASP_PARAMLIST_NAME("paramEq"),
|
||||
ASP_FC_PARAMLIST_NAME("param"),
|
||||
ASP_PARAMLIST_END_POINTER("null"),
|
||||
ASP_PARAMLIST_END_RULE_EQ("endParamEq"),
|
||||
ASP_PARAMLIST_END_RULE_FC("endParam"),
|
||||
ASP_TYPE("typeEq"),
|
||||
ASP_FCTYPE("type"),
|
||||
ASP_TYPE_VAR("var"),
|
||||
ASP_GENERIC_VAR("pph"),
|
||||
ASP_WILDCARD("wildcard"),
|
||||
ASP_PARAMLIST_ORDER("paramOrder");
|
||||
|
||||
private final String text;
|
||||
|
@ -1,17 +1,14 @@
|
||||
package de.dhbwstuttgart.sat.asp.model;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.signature.Signature;
|
||||
|
||||
public enum ASPRule {
|
||||
ASP_PAIR_EQUALS_NAME("equals"),
|
||||
ASP_PAIR_SMALLER_NAME("smaller"),
|
||||
ASP_PAIR_SMALLER_DOT_NAME("smallerDot"),
|
||||
ASP_PARAMLIST_NAME("param"),
|
||||
ASP_PARAMLIST_END_POINTER("null"),
|
||||
ASP_TYPE("type"),
|
||||
ASP_TYPE_VAR("typeVar"), ASP_ODER("oder"),
|
||||
ASP_CONSTRAINT("constraint"),
|
||||
ASP_LIST_NAME("list"),
|
||||
ASP_LIST_ENDPOINTER("null");
|
||||
ASP_FCTYPE("typeFC"),
|
||||
ASP_TYPE_VAR("typeVar");
|
||||
|
||||
private final String text;
|
||||
|
||||
|
@ -6,17 +6,23 @@ import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.scope.JavaClassName;
|
||||
import de.dhbwstuttgart.sat.asp.ASPStringConverter;
|
||||
import de.dhbwstuttgart.sat.asp.model.ASPRule;
|
||||
import de.dhbwstuttgart.sat.asp.parser.antlr.*;
|
||||
import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultBaseListener;
|
||||
import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultLexer;
|
||||
import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultParser;
|
||||
import de.dhbwstuttgart.sat.asp.parser.model.ParsedType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.*;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
import org.antlr.v4.runtime.CharStreams;
|
||||
import org.antlr.v4.runtime.CommonTokenStream;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeWalker;
|
||||
|
||||
import javax.json.Json;
|
||||
import javax.json.JsonArray;
|
||||
import javax.json.JsonObject;
|
||||
import java.io.StringReader;
|
||||
import java.util.*;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
@ -27,11 +33,14 @@ import java.util.stream.Collectors;
|
||||
* TODO: Überlegen welche Informationen noch nach der Unifizierung gebraucht werden
|
||||
* -> Eigentlich nur die korrekten Namen der Typen und TPHs
|
||||
*/
|
||||
public class ASPParser extends ASPResultBaseListener {
|
||||
public class ASPParser extends UnifyResultBaseListener {
|
||||
private Collection<TypePlaceholder> originalTPHs;
|
||||
private ResultSet resultSet;
|
||||
private Map<String, RefTypeOrTPHOrWildcardOrGeneric> types = new HashMap();
|
||||
private Map<String, ParsedType> types = new HashMap<>();
|
||||
private Set<String> tphs = new HashSet<>();
|
||||
private Map<String, ParameterListNode> parameterLists = new HashMap<>();
|
||||
private Set<Relation> equalsRelations = new HashSet<>();
|
||||
private Set<Relation> smallerRelations = new HashSet<>();
|
||||
|
||||
/**
|
||||
* Parst clingo output welcher als JSON (option --outf=2) ausgibt
|
||||
@ -42,6 +51,13 @@ public class ASPParser extends ASPResultBaseListener {
|
||||
return new ASPParser(toParse, oldPlaceholders).resultSet;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterParameter(UnifyResultParser.ParameterContext ctx) {
|
||||
//Linked List (pointer, Type, nextPointer)
|
||||
List<String> params = parseParameterList(ctx.parameterList());
|
||||
parameterLists.put(params.get(0), new ParameterListNode(params.get(1), params.get(2)));
|
||||
}
|
||||
|
||||
private static class Relation {
|
||||
public final String right;
|
||||
public final String left;
|
||||
@ -71,73 +87,60 @@ public class ASPParser extends ASPResultBaseListener {
|
||||
).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private void getTPHs(ASPResultParser.AnswerContext answer){
|
||||
for(ASPResultParser.ResultSetRuleContext e : answer.resultSetRule()){
|
||||
if(e.NAME().getText().equals(ASPRule.ASP_TYPE_VAR.toString())){
|
||||
String pointer = e.parameterList().value(0).getText();
|
||||
tphs.add(pointer);
|
||||
String tphName = ASPStringConverter.fromConstant(pointer);
|
||||
Optional<TypePlaceholder> oTPH = originalTPHs.stream().filter((a)->a.getName().equals(tphName)).findAny();
|
||||
TypePlaceholder tph;
|
||||
if(oTPH.isPresent()){
|
||||
tph = oTPH.get();
|
||||
}else{
|
||||
tph = TypePlaceholder.fresh(new NullToken());
|
||||
}
|
||||
types.put(pointer, tph);
|
||||
}
|
||||
}
|
||||
}
|
||||
private void getTypes(ASPResultParser.AnswerContext answer) {
|
||||
HashMap<String, String[]> rawTypes = new HashMap<>();
|
||||
for(ASPResultParser.ResultSetRuleContext e : answer.resultSetRule()){
|
||||
if(e.NAME().getText().equals(ASPRule.ASP_TYPE.toString())){
|
||||
String pointer = e.parameterList().value(0).getText();
|
||||
String name = e.parameterList().value(1).getText();
|
||||
Integer numParams = Integer.parseInt(e.parameterList().value(2).getText());
|
||||
String[] params = new String[numParams + 1];
|
||||
params[0] = name;
|
||||
rawTypes.put(pointer, params);
|
||||
}
|
||||
}
|
||||
for(ASPResultParser.ResultSetRuleContext e : answer.resultSetRule()){
|
||||
if(e.NAME().getText().equals(ASPRule.ASP_PARAMLIST_NAME.toString())){
|
||||
String typePointer = e.parameterList().value(0).getText();
|
||||
String paramPointer = e.parameterList().value(1).getText();
|
||||
Integer paramNum = Integer.parseInt(e.parameterList().value(2).getText());
|
||||
if(rawTypes.containsKey(typePointer)) {
|
||||
String[] paramArray = rawTypes.get(typePointer);
|
||||
paramArray[paramNum] = paramPointer;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(String name : rawTypes.keySet()){
|
||||
types.put(name, createType(name, rawTypes));
|
||||
}
|
||||
@Override
|
||||
public void enterEquals(UnifyResultParser.EqualsContext ctx) {
|
||||
List<String> parameterList = parseParameterList(ctx.parameterList());
|
||||
if(parameterList.size()<2)throw new DebugException("Fehler in Equals-Regel");
|
||||
String ls = parameterList.get(0);
|
||||
String rs = parameterList.get(1);
|
||||
equalsRelations.add(new Relation(ls, rs));
|
||||
|
||||
}
|
||||
private RefType createType(String name, HashMap<String, String[]> rawTypes){
|
||||
String[] paramArray = rawTypes.get(name);
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> paramList = new ArrayList<>();
|
||||
for(int i = 1; i< paramArray.length ;i++){
|
||||
String paramPointer = paramArray[i];
|
||||
RefTypeOrTPHOrWildcardOrGeneric param;
|
||||
if(rawTypes.containsKey(paramPointer)){
|
||||
param = createType(paramPointer, rawTypes);
|
||||
}else if(tphs.contains(paramPointer)){
|
||||
String tphName = ASPStringConverter.fromConstant(paramPointer);
|
||||
param = types.get(paramPointer);
|
||||
}else{
|
||||
throw new DebugException("Fehler beim Einlesen der Clingo Ausgabe");
|
||||
}
|
||||
if(param == null)
|
||||
throw new NullPointerException();
|
||||
paramList.add(param);
|
||||
}
|
||||
return new RefType(new JavaClassName(ASPStringConverter.fromConstant(paramArray[0])), paramList, new NullToken());
|
||||
|
||||
@Override
|
||||
public void enterSmaller(UnifyResultParser.SmallerContext ctx) {
|
||||
List<String> parameterList = parseParameterList(ctx.parameterList());
|
||||
if(parameterList.size()<2)throw new DebugException("Fehler in Smaller-Regel");
|
||||
String ls = parameterList.get(0);
|
||||
String rs = parameterList.get(1);
|
||||
smallerRelations.add(new Relation(ls, rs));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterTypeVar(UnifyResultParser.TypeVarContext ctx) {
|
||||
List<String> parameterList = parseParameterList(ctx.parameterList());
|
||||
if(parameterList.size()<1)throw new DebugException("Fehler in typeVar-Regel");
|
||||
tphs.add(parameterList.get(0));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterType(UnifyResultParser.TypeContext ctx){
|
||||
List<String> parameterList = parseParameterList(ctx.parameterList());
|
||||
if(parameterList.size()<3)throw new DebugException("Fehler in Type-Regel");
|
||||
String name = parameterList.get(0);
|
||||
String typeName = parameterList.get(1);
|
||||
String paramPointer = parameterList.get(2);
|
||||
types.put(name, new ParsedType(typeName, paramPointer));
|
||||
}
|
||||
|
||||
/*
|
||||
private List<String> parsedRule;
|
||||
private List<String> parseRule(String rule){
|
||||
UnifyResultLexer lexer = new UnifyResultLexer(CharStreams.fromString(rule));
|
||||
UnifyResultParser.AspruleContext parseTree = new UnifyResultParser(new CommonTokenStream(lexer)).asprule();
|
||||
parsedRule = new ArrayList<>();
|
||||
new ParseTreeWalker().walk(this, parseTree);
|
||||
return parsedRule;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAsprule(UnifyResultParser.AspruleContext ctx) {
|
||||
super.enterAsprule(ctx);
|
||||
for(int i = 0; i< ctx.getChildCount();i++){
|
||||
parsedRule.add(ctx.getChild(i).getText());
|
||||
}
|
||||
}
|
||||
*/
|
||||
private ASPParser(String toParse, Collection<TypePlaceholder> oldPlaceholders){
|
||||
//System.out.println(toParse);
|
||||
this.originalTPHs = oldPlaceholders;
|
||||
@ -156,33 +159,73 @@ public class ASPParser extends ASPResultBaseListener {
|
||||
}
|
||||
System.out.println(completeResult);
|
||||
*/
|
||||
ASPResultLexer lexer = new ASPResultLexer(CharStreams.fromString(toParse));
|
||||
ASPResultParser.AnswerContext parseTree = new ASPResultParser(new CommonTokenStream(lexer)).answer();
|
||||
//new ParseTreeWalker().walk(this, parseTree);
|
||||
UnifyResultLexer lexer = new UnifyResultLexer(CharStreams.fromString(toParse));
|
||||
UnifyResultParser.AnswerContext parseTree = new UnifyResultParser(new CommonTokenStream(lexer)).answer();
|
||||
new ParseTreeWalker().walk(this, parseTree);
|
||||
|
||||
/*
|
||||
Diese Funktion läuft im folgenden mehrmals über das Result aus dem ASP Programm.
|
||||
Dabei werden Schritt für Schritt die Felder dieser Klasse befüllt die am Schluss das ResultSet ergeben
|
||||
*/
|
||||
getTPHs(parseTree);
|
||||
getTypes(parseTree);
|
||||
|
||||
Set<ResultPair> ret = new HashSet<>();
|
||||
for(ASPResultParser.ResultSetRuleContext e : parseTree.resultSetRule()){
|
||||
if(e.NAME().getText().equals(ASPRule.ASP_PAIR_EQUALS_NAME.toString())){
|
||||
String tp1 = e.parameterList().value(0).getText();
|
||||
String tp2 = e.parameterList().value(1).getText();
|
||||
if(tphs.contains(tp1) && tphs.contains(tp2)){
|
||||
//Diese kann man ignorieren. Sollten eigentlich nicht auftauchen
|
||||
//ret.add(new PairTPHEqualTPH((TypePlaceholder) types.get(tp1), (TypePlaceholder) types.get(tp2)));
|
||||
}else if(tphs.contains(tp1)){
|
||||
if(types.containsKey(tp2))
|
||||
ret.add(new PairTPHequalRefTypeOrWildcardType((TypePlaceholder) types.get(tp1), types.get(tp2)));
|
||||
else System.out.println(tp2);
|
||||
}
|
||||
}
|
||||
//Zuerst die params und typeVars:
|
||||
//for(String paramPointer : types.values().stream().map(parsedType -> parsedType.params).collect(Collectors.toList())){ }
|
||||
|
||||
//Dann die Equalsdot Statements
|
||||
for(Relation eq : equalsRelations){
|
||||
RefTypeOrTPHOrWildcardOrGeneric lsType = this.getType(eq.left);
|
||||
RefTypeOrTPHOrWildcardOrGeneric rsType = this.getType(eq.right);
|
||||
if(lsType instanceof TypePlaceholder && rsType instanceof RefType)
|
||||
ret.add(new PairTPHequalRefTypeOrWildcardType((TypePlaceholder) lsType, rsType));
|
||||
else if(lsType instanceof TypePlaceholder && rsType instanceof TypePlaceholder)
|
||||
ret.add(new PairTPHEqualTPH((TypePlaceholder)lsType, (TypePlaceholder)rsType));
|
||||
else throw new NotImplementedException();
|
||||
}
|
||||
this.resultSet = new ResultSet(ret);
|
||||
}
|
||||
|
||||
private RefTypeOrTPHOrWildcardOrGeneric getType(String name) {
|
||||
if(tphs.contains(name)){
|
||||
name = ASPStringConverter.fromConstant(name);
|
||||
for(TypePlaceholder tph : originalTPHs){
|
||||
if(tph.getName().equals(name))return tph;
|
||||
}
|
||||
return TypePlaceholder.fresh(new NullToken());
|
||||
}else
|
||||
if(types.containsKey(name)){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
|
||||
ParsedType t = types.get(name);
|
||||
|
||||
for(String param : getParams(t.params)){
|
||||
params.add(this.getType(param));
|
||||
}
|
||||
return new RefType(new JavaClassName(ASPStringConverter.fromConstant(t.name)), params, new NullToken());
|
||||
}else throw new DebugException("Der Typ " + name + " konnte nicht bestimmt werden");
|
||||
}
|
||||
|
||||
private static class ParameterListNode{
|
||||
final String type;
|
||||
final String nextNode;
|
||||
|
||||
public ParameterListNode(String type, String next) {
|
||||
this.type = type;
|
||||
this.nextNode = next;
|
||||
}
|
||||
}
|
||||
|
||||
private List<String> getParams(String pointer) {
|
||||
List<String> params = new ArrayList<>();
|
||||
while(pointer != null){
|
||||
if(pointer.equals(ASPRule.ASP_PARAMLIST_END_POINTER.toString()))return params;
|
||||
if(!parameterLists.containsKey(pointer))
|
||||
throw new DebugException("Fehler in Ergebnisparsen");
|
||||
//TODO: Fehler in ASP. Die adapt Regel muss erkennen, wenn die Parameterliste auf der linken Seite kürzer ist und diese Rechtzeitig beenden
|
||||
ParameterListNode param = parameterLists.get(pointer);
|
||||
pointer = param.nextNode;
|
||||
params.add(param.type);
|
||||
}
|
||||
return params;
|
||||
//Optional<ASPParameterList> ret = parameterLists.stream().filter(aspParameterList -> aspParameterList.name.equals(rs)).findAny();
|
||||
//return ret.get();
|
||||
}
|
||||
}
|
@ -1,17 +0,0 @@
|
||||
grammar ASPResult;
|
||||
|
||||
answer : 'ANSWER' (resultSetRule '.')*;
|
||||
|
||||
resultSetRule : NAME parameterList;
|
||||
|
||||
parameterList : '(' value (',' value)* ')';
|
||||
value : NAME
|
||||
| resultSetRule ;
|
||||
|
||||
NAME : [a-zA-Z0-9_']+;
|
||||
|
||||
WS : [ \t\r\n\u000C]+ -> skip
|
||||
;
|
||||
LINE_COMMENT
|
||||
: '%' ~[\r\n]* -> skip
|
||||
;
|
@ -1,13 +0,0 @@
|
||||
T__0=1
|
||||
T__1=2
|
||||
T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
NAME=6
|
||||
WS=7
|
||||
LINE_COMMENT=8
|
||||
'ANSWER'=1
|
||||
'.'=2
|
||||
'('=3
|
||||
','=4
|
||||
')'=5
|
@ -1,87 +0,0 @@
|
||||
// Generated from ASPResult.g4 by ANTLR 4.7
|
||||
package de.dhbwstuttgart.sat.asp.parser.antlr;
|
||||
|
||||
import org.antlr.v4.runtime.ParserRuleContext;
|
||||
import org.antlr.v4.runtime.tree.ErrorNode;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
/**
|
||||
* This class provides an empty implementation of {@link ASPResultListener},
|
||||
* which can be extended to create a listener which only needs to handle a subset
|
||||
* of the available methods.
|
||||
*/
|
||||
public class ASPResultBaseListener implements ASPResultListener {
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void enterAnswer(ASPResultParser.AnswerContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitAnswer(ASPResultParser.AnswerContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void enterResultSetRule(ASPResultParser.ResultSetRuleContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitResultSetRule(ASPResultParser.ResultSetRuleContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void enterParameterList(ASPResultParser.ParameterListContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitParameterList(ASPResultParser.ParameterListContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void enterValue(ASPResultParser.ValueContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitValue(ASPResultParser.ValueContext ctx) { }
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void enterEveryRule(ParserRuleContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitEveryRule(ParserRuleContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void visitTerminal(TerminalNode node) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void visitErrorNode(ErrorNode node) { }
|
||||
}
|
@ -1,121 +0,0 @@
|
||||
// Generated from ASPResult.g4 by ANTLR 4.7
|
||||
package de.dhbwstuttgart.sat.asp.parser.antlr;
|
||||
import org.antlr.v4.runtime.Lexer;
|
||||
import org.antlr.v4.runtime.CharStream;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.TokenStream;
|
||||
import org.antlr.v4.runtime.*;
|
||||
import org.antlr.v4.runtime.atn.*;
|
||||
import org.antlr.v4.runtime.dfa.DFA;
|
||||
import org.antlr.v4.runtime.misc.*;
|
||||
|
||||
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
|
||||
public class ASPResultLexer extends Lexer {
|
||||
static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
|
||||
|
||||
protected static final DFA[] _decisionToDFA;
|
||||
protected static final PredictionContextCache _sharedContextCache =
|
||||
new PredictionContextCache();
|
||||
public static final int
|
||||
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, NAME=6, WS=7, LINE_COMMENT=8;
|
||||
public static String[] channelNames = {
|
||||
"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
|
||||
};
|
||||
|
||||
public static String[] modeNames = {
|
||||
"DEFAULT_MODE"
|
||||
};
|
||||
|
||||
public static final String[] ruleNames = {
|
||||
"T__0", "T__1", "T__2", "T__3", "T__4", "NAME", "WS", "LINE_COMMENT"
|
||||
};
|
||||
|
||||
private static final String[] _LITERAL_NAMES = {
|
||||
null, "'ANSWER'", "'.'", "'('", "','", "')'"
|
||||
};
|
||||
private static final String[] _SYMBOLIC_NAMES = {
|
||||
null, null, null, null, null, null, "NAME", "WS", "LINE_COMMENT"
|
||||
};
|
||||
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #VOCABULARY} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public static final String[] tokenNames;
|
||||
static {
|
||||
tokenNames = new String[_SYMBOLIC_NAMES.length];
|
||||
for (int i = 0; i < tokenNames.length; i++) {
|
||||
tokenNames[i] = VOCABULARY.getLiteralName(i);
|
||||
if (tokenNames[i] == null) {
|
||||
tokenNames[i] = VOCABULARY.getSymbolicName(i);
|
||||
}
|
||||
|
||||
if (tokenNames[i] == null) {
|
||||
tokenNames[i] = "<INVALID>";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public String[] getTokenNames() {
|
||||
return tokenNames;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
public Vocabulary getVocabulary() {
|
||||
return VOCABULARY;
|
||||
}
|
||||
|
||||
|
||||
public ASPResultLexer(CharStream input) {
|
||||
super(input);
|
||||
_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getGrammarFileName() { return "ASPResult.g4"; }
|
||||
|
||||
@Override
|
||||
public String[] getRuleNames() { return ruleNames; }
|
||||
|
||||
@Override
|
||||
public String getSerializedATN() { return _serializedATN; }
|
||||
|
||||
@Override
|
||||
public String[] getChannelNames() { return channelNames; }
|
||||
|
||||
@Override
|
||||
public String[] getModeNames() { return modeNames; }
|
||||
|
||||
@Override
|
||||
public ATN getATN() { return _ATN; }
|
||||
|
||||
public static final String _serializedATN =
|
||||
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\n\67\b\1\4\2\t\2"+
|
||||
"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3"+
|
||||
"\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\6\7$\n\7\r\7\16\7%"+
|
||||
"\3\b\6\b)\n\b\r\b\16\b*\3\b\3\b\3\t\3\t\7\t\61\n\t\f\t\16\t\64\13\t\3"+
|
||||
"\t\3\t\2\2\n\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\3\2\5\7\2))\62;C\\aac"+
|
||||
"|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\29\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2"+
|
||||
"\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\3"+
|
||||
"\23\3\2\2\2\5\32\3\2\2\2\7\34\3\2\2\2\t\36\3\2\2\2\13 \3\2\2\2\r#\3\2"+
|
||||
"\2\2\17(\3\2\2\2\21.\3\2\2\2\23\24\7C\2\2\24\25\7P\2\2\25\26\7U\2\2\26"+
|
||||
"\27\7Y\2\2\27\30\7G\2\2\30\31\7T\2\2\31\4\3\2\2\2\32\33\7\60\2\2\33\6"+
|
||||
"\3\2\2\2\34\35\7*\2\2\35\b\3\2\2\2\36\37\7.\2\2\37\n\3\2\2\2 !\7+\2\2"+
|
||||
"!\f\3\2\2\2\"$\t\2\2\2#\"\3\2\2\2$%\3\2\2\2%#\3\2\2\2%&\3\2\2\2&\16\3"+
|
||||
"\2\2\2\')\t\3\2\2(\'\3\2\2\2)*\3\2\2\2*(\3\2\2\2*+\3\2\2\2+,\3\2\2\2,"+
|
||||
"-\b\b\2\2-\20\3\2\2\2.\62\7\'\2\2/\61\n\4\2\2\60/\3\2\2\2\61\64\3\2\2"+
|
||||
"\2\62\60\3\2\2\2\62\63\3\2\2\2\63\65\3\2\2\2\64\62\3\2\2\2\65\66\b\t\2"+
|
||||
"\2\66\22\3\2\2\2\6\2%*\62\3\b\2\2";
|
||||
public static final ATN _ATN =
|
||||
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
|
||||
static {
|
||||
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
|
||||
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
|
||||
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
|
||||
}
|
||||
}
|
||||
}
|
@ -1,13 +0,0 @@
|
||||
T__0=1
|
||||
T__1=2
|
||||
T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
NAME=6
|
||||
WS=7
|
||||
LINE_COMMENT=8
|
||||
'ANSWER'=1
|
||||
'.'=2
|
||||
'('=3
|
||||
','=4
|
||||
')'=5
|
@ -1,50 +0,0 @@
|
||||
// Generated from ASPResult.g4 by ANTLR 4.7
|
||||
package de.dhbwstuttgart.sat.asp.parser.antlr;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
/**
|
||||
* This interface defines a complete listener for a parse tree produced by
|
||||
* {@link ASPResultParser}.
|
||||
*/
|
||||
public interface ASPResultListener extends ParseTreeListener {
|
||||
/**
|
||||
* Enter a parse tree produced by {@link ASPResultParser#answer}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void enterAnswer(ASPResultParser.AnswerContext ctx);
|
||||
/**
|
||||
* Exit a parse tree produced by {@link ASPResultParser#answer}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void exitAnswer(ASPResultParser.AnswerContext ctx);
|
||||
/**
|
||||
* Enter a parse tree produced by {@link ASPResultParser#resultSetRule}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void enterResultSetRule(ASPResultParser.ResultSetRuleContext ctx);
|
||||
/**
|
||||
* Exit a parse tree produced by {@link ASPResultParser#resultSetRule}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void exitResultSetRule(ASPResultParser.ResultSetRuleContext ctx);
|
||||
/**
|
||||
* Enter a parse tree produced by {@link ASPResultParser#parameterList}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void enterParameterList(ASPResultParser.ParameterListContext ctx);
|
||||
/**
|
||||
* Exit a parse tree produced by {@link ASPResultParser#parameterList}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void exitParameterList(ASPResultParser.ParameterListContext ctx);
|
||||
/**
|
||||
* Enter a parse tree produced by {@link ASPResultParser#value}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void enterValue(ASPResultParser.ValueContext ctx);
|
||||
/**
|
||||
* Exit a parse tree produced by {@link ASPResultParser#value}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void exitValue(ASPResultParser.ValueContext ctx);
|
||||
}
|
@ -1,318 +0,0 @@
|
||||
// Generated from ASPResult.g4 by ANTLR 4.7
|
||||
package de.dhbwstuttgart.sat.asp.parser.antlr;
|
||||
import org.antlr.v4.runtime.atn.*;
|
||||
import org.antlr.v4.runtime.dfa.DFA;
|
||||
import org.antlr.v4.runtime.*;
|
||||
import org.antlr.v4.runtime.misc.*;
|
||||
import org.antlr.v4.runtime.tree.*;
|
||||
import java.util.List;
|
||||
import java.util.Iterator;
|
||||
import java.util.ArrayList;
|
||||
|
||||
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
|
||||
public class ASPResultParser extends Parser {
|
||||
static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
|
||||
|
||||
protected static final DFA[] _decisionToDFA;
|
||||
protected static final PredictionContextCache _sharedContextCache =
|
||||
new PredictionContextCache();
|
||||
public static final int
|
||||
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, NAME=6, WS=7, LINE_COMMENT=8;
|
||||
public static final int
|
||||
RULE_answer = 0, RULE_resultSetRule = 1, RULE_parameterList = 2, RULE_value = 3;
|
||||
public static final String[] ruleNames = {
|
||||
"answer", "resultSetRule", "parameterList", "value"
|
||||
};
|
||||
|
||||
private static final String[] _LITERAL_NAMES = {
|
||||
null, "'ANSWER'", "'.'", "'('", "','", "')'"
|
||||
};
|
||||
private static final String[] _SYMBOLIC_NAMES = {
|
||||
null, null, null, null, null, null, "NAME", "WS", "LINE_COMMENT"
|
||||
};
|
||||
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #VOCABULARY} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public static final String[] tokenNames;
|
||||
static {
|
||||
tokenNames = new String[_SYMBOLIC_NAMES.length];
|
||||
for (int i = 0; i < tokenNames.length; i++) {
|
||||
tokenNames[i] = VOCABULARY.getLiteralName(i);
|
||||
if (tokenNames[i] == null) {
|
||||
tokenNames[i] = VOCABULARY.getSymbolicName(i);
|
||||
}
|
||||
|
||||
if (tokenNames[i] == null) {
|
||||
tokenNames[i] = "<INVALID>";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public String[] getTokenNames() {
|
||||
return tokenNames;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
public Vocabulary getVocabulary() {
|
||||
return VOCABULARY;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getGrammarFileName() { return "ASPResult.g4"; }
|
||||
|
||||
@Override
|
||||
public String[] getRuleNames() { return ruleNames; }
|
||||
|
||||
@Override
|
||||
public String getSerializedATN() { return _serializedATN; }
|
||||
|
||||
@Override
|
||||
public ATN getATN() { return _ATN; }
|
||||
|
||||
public ASPResultParser(TokenStream input) {
|
||||
super(input);
|
||||
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
||||
}
|
||||
public static class AnswerContext extends ParserRuleContext {
|
||||
public List<ResultSetRuleContext> resultSetRule() {
|
||||
return getRuleContexts(ResultSetRuleContext.class);
|
||||
}
|
||||
public ResultSetRuleContext resultSetRule(int i) {
|
||||
return getRuleContext(ResultSetRuleContext.class,i);
|
||||
}
|
||||
public AnswerContext(ParserRuleContext parent, int invokingState) {
|
||||
super(parent, invokingState);
|
||||
}
|
||||
@Override public int getRuleIndex() { return RULE_answer; }
|
||||
@Override
|
||||
public void enterRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterAnswer(this);
|
||||
}
|
||||
@Override
|
||||
public void exitRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitAnswer(this);
|
||||
}
|
||||
}
|
||||
|
||||
public final AnswerContext answer() throws RecognitionException {
|
||||
AnswerContext _localctx = new AnswerContext(_ctx, getState());
|
||||
enterRule(_localctx, 0, RULE_answer);
|
||||
int _la;
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(8);
|
||||
match(T__0);
|
||||
setState(14);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
while (_la==NAME) {
|
||||
{
|
||||
{
|
||||
setState(9);
|
||||
resultSetRule();
|
||||
setState(10);
|
||||
match(T__1);
|
||||
}
|
||||
}
|
||||
setState(16);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (RecognitionException re) {
|
||||
_localctx.exception = re;
|
||||
_errHandler.reportError(this, re);
|
||||
_errHandler.recover(this, re);
|
||||
}
|
||||
finally {
|
||||
exitRule();
|
||||
}
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
public static class ResultSetRuleContext extends ParserRuleContext {
|
||||
public TerminalNode NAME() { return getToken(ASPResultParser.NAME, 0); }
|
||||
public ParameterListContext parameterList() {
|
||||
return getRuleContext(ParameterListContext.class,0);
|
||||
}
|
||||
public ResultSetRuleContext(ParserRuleContext parent, int invokingState) {
|
||||
super(parent, invokingState);
|
||||
}
|
||||
@Override public int getRuleIndex() { return RULE_resultSetRule; }
|
||||
@Override
|
||||
public void enterRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterResultSetRule(this);
|
||||
}
|
||||
@Override
|
||||
public void exitRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitResultSetRule(this);
|
||||
}
|
||||
}
|
||||
|
||||
public final ResultSetRuleContext resultSetRule() throws RecognitionException {
|
||||
ResultSetRuleContext _localctx = new ResultSetRuleContext(_ctx, getState());
|
||||
enterRule(_localctx, 2, RULE_resultSetRule);
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(17);
|
||||
match(NAME);
|
||||
setState(18);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
catch (RecognitionException re) {
|
||||
_localctx.exception = re;
|
||||
_errHandler.reportError(this, re);
|
||||
_errHandler.recover(this, re);
|
||||
}
|
||||
finally {
|
||||
exitRule();
|
||||
}
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
public static class ParameterListContext extends ParserRuleContext {
|
||||
public List<ValueContext> value() {
|
||||
return getRuleContexts(ValueContext.class);
|
||||
}
|
||||
public ValueContext value(int i) {
|
||||
return getRuleContext(ValueContext.class,i);
|
||||
}
|
||||
public ParameterListContext(ParserRuleContext parent, int invokingState) {
|
||||
super(parent, invokingState);
|
||||
}
|
||||
@Override public int getRuleIndex() { return RULE_parameterList; }
|
||||
@Override
|
||||
public void enterRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterParameterList(this);
|
||||
}
|
||||
@Override
|
||||
public void exitRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitParameterList(this);
|
||||
}
|
||||
}
|
||||
|
||||
public final ParameterListContext parameterList() throws RecognitionException {
|
||||
ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
|
||||
enterRule(_localctx, 4, RULE_parameterList);
|
||||
int _la;
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(20);
|
||||
match(T__2);
|
||||
setState(21);
|
||||
value();
|
||||
setState(26);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
while (_la==T__3) {
|
||||
{
|
||||
{
|
||||
setState(22);
|
||||
match(T__3);
|
||||
setState(23);
|
||||
value();
|
||||
}
|
||||
}
|
||||
setState(28);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
}
|
||||
setState(29);
|
||||
match(T__4);
|
||||
}
|
||||
}
|
||||
catch (RecognitionException re) {
|
||||
_localctx.exception = re;
|
||||
_errHandler.reportError(this, re);
|
||||
_errHandler.recover(this, re);
|
||||
}
|
||||
finally {
|
||||
exitRule();
|
||||
}
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
public static class ValueContext extends ParserRuleContext {
|
||||
public TerminalNode NAME() { return getToken(ASPResultParser.NAME, 0); }
|
||||
public ResultSetRuleContext resultSetRule() {
|
||||
return getRuleContext(ResultSetRuleContext.class,0);
|
||||
}
|
||||
public ValueContext(ParserRuleContext parent, int invokingState) {
|
||||
super(parent, invokingState);
|
||||
}
|
||||
@Override public int getRuleIndex() { return RULE_value; }
|
||||
@Override
|
||||
public void enterRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).enterValue(this);
|
||||
}
|
||||
@Override
|
||||
public void exitRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof ASPResultListener ) ((ASPResultListener)listener).exitValue(this);
|
||||
}
|
||||
}
|
||||
|
||||
public final ValueContext value() throws RecognitionException {
|
||||
ValueContext _localctx = new ValueContext(_ctx, getState());
|
||||
enterRule(_localctx, 6, RULE_value);
|
||||
try {
|
||||
setState(33);
|
||||
_errHandler.sync(this);
|
||||
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
|
||||
case 1:
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(31);
|
||||
match(NAME);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
enterOuterAlt(_localctx, 2);
|
||||
{
|
||||
setState(32);
|
||||
resultSetRule();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (RecognitionException re) {
|
||||
_localctx.exception = re;
|
||||
_errHandler.reportError(this, re);
|
||||
_errHandler.recover(this, re);
|
||||
}
|
||||
finally {
|
||||
exitRule();
|
||||
}
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
public static final String _serializedATN =
|
||||
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\n&\4\2\t\2\4\3\t"+
|
||||
"\3\4\4\t\4\4\5\t\5\3\2\3\2\3\2\3\2\7\2\17\n\2\f\2\16\2\22\13\2\3\3\3\3"+
|
||||
"\3\3\3\4\3\4\3\4\3\4\7\4\33\n\4\f\4\16\4\36\13\4\3\4\3\4\3\5\3\5\5\5$"+
|
||||
"\n\5\3\5\2\2\6\2\4\6\b\2\2\2$\2\n\3\2\2\2\4\23\3\2\2\2\6\26\3\2\2\2\b"+
|
||||
"#\3\2\2\2\n\20\7\3\2\2\13\f\5\4\3\2\f\r\7\4\2\2\r\17\3\2\2\2\16\13\3\2"+
|
||||
"\2\2\17\22\3\2\2\2\20\16\3\2\2\2\20\21\3\2\2\2\21\3\3\2\2\2\22\20\3\2"+
|
||||
"\2\2\23\24\7\b\2\2\24\25\5\6\4\2\25\5\3\2\2\2\26\27\7\5\2\2\27\34\5\b"+
|
||||
"\5\2\30\31\7\6\2\2\31\33\5\b\5\2\32\30\3\2\2\2\33\36\3\2\2\2\34\32\3\2"+
|
||||
"\2\2\34\35\3\2\2\2\35\37\3\2\2\2\36\34\3\2\2\2\37 \7\7\2\2 \7\3\2\2\2"+
|
||||
"!$\7\b\2\2\"$\5\4\3\2#!\3\2\2\2#\"\3\2\2\2$\t\3\2\2\2\5\20\34#";
|
||||
public static final ATN _ATN =
|
||||
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
|
||||
static {
|
||||
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
|
||||
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
|
||||
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
|
||||
}
|
||||
}
|
||||
}
|
@ -8,7 +8,6 @@ resultSetRule :
|
||||
| smaller
|
||||
| typeVar
|
||||
| type
|
||||
| unifier
|
||||
| otherRule
|
||||
;
|
||||
|
||||
@ -18,7 +17,6 @@ value : NAME
|
||||
|
||||
parameter : PARAMLIST_NAME parameterList;
|
||||
equals : EQUALS_NAME parameterList;
|
||||
unifier : UNIFIER_NAME parameterList;
|
||||
smaller : SMALLER_NAME parameterList;
|
||||
typeVar : TYPEVAR_NAME parameterList;
|
||||
type : TYPE_NAME parameterList;
|
||||
@ -26,7 +24,6 @@ otherRule : NAME parameterList;
|
||||
|
||||
//TODO: Es sollte Regeln für das Result set geben, welche sich nicht mit den anderen überdecken, dann auch nur diese im Result ausgeben
|
||||
PARAMLIST_NAME : 'param';
|
||||
UNIFIER_NAME : 'unifier';
|
||||
EQUALS_NAME : 'equals';
|
||||
SMALLER_NAME : 'smaller';
|
||||
TYPEVAR_NAME : 'typeVar';
|
||||
@ -38,4 +35,3 @@ WS : [ \t\r\n\u000C]+ -> skip
|
||||
LINE_COMMENT
|
||||
: '%' ~[\r\n]* -> skip
|
||||
;
|
||||
|
||||
|
@ -4,22 +4,20 @@ T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
PARAMLIST_NAME=6
|
||||
UNIFIER_NAME=7
|
||||
EQUALS_NAME=8
|
||||
SMALLER_NAME=9
|
||||
TYPEVAR_NAME=10
|
||||
TYPE_NAME=11
|
||||
NAME=12
|
||||
WS=13
|
||||
LINE_COMMENT=14
|
||||
EQUALS_NAME=7
|
||||
SMALLER_NAME=8
|
||||
TYPEVAR_NAME=9
|
||||
TYPE_NAME=10
|
||||
NAME=11
|
||||
WS=12
|
||||
LINE_COMMENT=13
|
||||
'ANSWER'=1
|
||||
'.'=2
|
||||
'('=3
|
||||
','=4
|
||||
')'=5
|
||||
'param'=6
|
||||
'unifier'=7
|
||||
'equals'=8
|
||||
'smaller'=9
|
||||
'typeVar'=10
|
||||
'type'=11
|
||||
'equals'=7
|
||||
'smaller'=8
|
||||
'typeVar'=9
|
||||
'type'=10
|
||||
|
@ -83,18 +83,6 @@ public class UnifyResultBaseListener implements UnifyResultListener {
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitEquals(UnifyResultParser.EqualsContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void enterUnifier(UnifyResultParser.UnifierContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p>The default implementation does nothing.</p>
|
||||
*/
|
||||
@Override public void exitUnifier(UnifyResultParser.UnifierContext ctx) { }
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
|
@ -17,9 +17,8 @@ public class UnifyResultLexer extends Lexer {
|
||||
protected static final PredictionContextCache _sharedContextCache =
|
||||
new PredictionContextCache();
|
||||
public static final int
|
||||
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, UNIFIER_NAME=7,
|
||||
EQUALS_NAME=8, SMALLER_NAME=9, TYPEVAR_NAME=10, TYPE_NAME=11, NAME=12,
|
||||
WS=13, LINE_COMMENT=14;
|
||||
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, EQUALS_NAME=7,
|
||||
SMALLER_NAME=8, TYPEVAR_NAME=9, TYPE_NAME=10, NAME=11, WS=12, LINE_COMMENT=13;
|
||||
public static String[] channelNames = {
|
||||
"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
|
||||
};
|
||||
@ -29,19 +28,17 @@ public class UnifyResultLexer extends Lexer {
|
||||
};
|
||||
|
||||
public static final String[] ruleNames = {
|
||||
"T__0", "T__1", "T__2", "T__3", "T__4", "PARAMLIST_NAME", "UNIFIER_NAME",
|
||||
"EQUALS_NAME", "SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS",
|
||||
"LINE_COMMENT"
|
||||
"T__0", "T__1", "T__2", "T__3", "T__4", "PARAMLIST_NAME", "EQUALS_NAME",
|
||||
"SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
|
||||
};
|
||||
|
||||
private static final String[] _LITERAL_NAMES = {
|
||||
null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'unifier'",
|
||||
"'equals'", "'smaller'", "'typeVar'", "'type'"
|
||||
null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'equals'", "'smaller'",
|
||||
"'typeVar'", "'type'"
|
||||
};
|
||||
private static final String[] _SYMBOLIC_NAMES = {
|
||||
null, null, null, null, null, null, "PARAMLIST_NAME", "UNIFIER_NAME",
|
||||
"EQUALS_NAME", "SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS",
|
||||
"LINE_COMMENT"
|
||||
null, null, null, null, null, null, "PARAMLIST_NAME", "EQUALS_NAME", "SMALLER_NAME",
|
||||
"TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
|
||||
};
|
||||
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
|
||||
|
||||
@ -101,33 +98,31 @@ public class UnifyResultLexer extends Lexer {
|
||||
public ATN getATN() { return _ATN; }
|
||||
|
||||
public static final String _serializedATN =
|
||||
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\20m\b\1\4\2\t\2\4"+
|
||||
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\17c\b\1\4\2\t\2\4"+
|
||||
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
|
||||
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3"+
|
||||
"\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b"+
|
||||
"\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3"+
|
||||
"\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r"+
|
||||
"\6\rZ\n\r\r\r\16\r[\3\16\6\16_\n\16\r\16\16\16`\3\16\3\16\3\17\3\17\7"+
|
||||
"\17g\n\17\f\17\16\17j\13\17\3\17\3\17\2\2\20\3\3\5\4\7\5\t\6\13\7\r\b"+
|
||||
"\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\3\2\5\6\2\62;C\\aac|\5\2"+
|
||||
"\13\f\16\17\"\"\4\2\f\f\17\17\2o\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2"+
|
||||
"\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2"+
|
||||
"\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2"+
|
||||
"\3\37\3\2\2\2\5&\3\2\2\2\7(\3\2\2\2\t*\3\2\2\2\13,\3\2\2\2\r.\3\2\2\2"+
|
||||
"\17\64\3\2\2\2\21<\3\2\2\2\23C\3\2\2\2\25K\3\2\2\2\27S\3\2\2\2\31Y\3\2"+
|
||||
"\2\2\33^\3\2\2\2\35d\3\2\2\2\37 \7C\2\2 !\7P\2\2!\"\7U\2\2\"#\7Y\2\2#"+
|
||||
"$\7G\2\2$%\7T\2\2%\4\3\2\2\2&\'\7\60\2\2\'\6\3\2\2\2()\7*\2\2)\b\3\2\2"+
|
||||
"\2*+\7.\2\2+\n\3\2\2\2,-\7+\2\2-\f\3\2\2\2./\7r\2\2/\60\7c\2\2\60\61\7"+
|
||||
"t\2\2\61\62\7c\2\2\62\63\7o\2\2\63\16\3\2\2\2\64\65\7w\2\2\65\66\7p\2"+
|
||||
"\2\66\67\7k\2\2\678\7h\2\289\7k\2\29:\7g\2\2:;\7t\2\2;\20\3\2\2\2<=\7"+
|
||||
"g\2\2=>\7s\2\2>?\7w\2\2?@\7c\2\2@A\7n\2\2AB\7u\2\2B\22\3\2\2\2CD\7u\2"+
|
||||
"\2DE\7o\2\2EF\7c\2\2FG\7n\2\2GH\7n\2\2HI\7g\2\2IJ\7t\2\2J\24\3\2\2\2K"+
|
||||
"L\7v\2\2LM\7{\2\2MN\7r\2\2NO\7g\2\2OP\7X\2\2PQ\7c\2\2QR\7t\2\2R\26\3\2"+
|
||||
"\2\2ST\7v\2\2TU\7{\2\2UV\7r\2\2VW\7g\2\2W\30\3\2\2\2XZ\t\2\2\2YX\3\2\2"+
|
||||
"\2Z[\3\2\2\2[Y\3\2\2\2[\\\3\2\2\2\\\32\3\2\2\2]_\t\3\2\2^]\3\2\2\2_`\3"+
|
||||
"\2\2\2`^\3\2\2\2`a\3\2\2\2ab\3\2\2\2bc\b\16\2\2c\34\3\2\2\2dh\7\'\2\2"+
|
||||
"eg\n\4\2\2fe\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3\2\2\2ik\3\2\2\2jh\3\2\2\2"+
|
||||
"kl\b\17\2\2l\36\3\2\2\2\6\2[`h\3\b\2\2";
|
||||
"\13\4\f\t\f\4\r\t\r\4\16\t\16\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4"+
|
||||
"\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3"+
|
||||
"\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13"+
|
||||
"\3\13\3\13\3\13\3\13\3\f\6\fP\n\f\r\f\16\fQ\3\r\6\rU\n\r\r\r\16\rV\3\r"+
|
||||
"\3\r\3\16\3\16\7\16]\n\16\f\16\16\16`\13\16\3\16\3\16\2\2\17\3\3\5\4\7"+
|
||||
"\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\3\2\5\6\2\62;C\\"+
|
||||
"aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\2e\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3"+
|
||||
"\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2"+
|
||||
"\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\3\35"+
|
||||
"\3\2\2\2\5$\3\2\2\2\7&\3\2\2\2\t(\3\2\2\2\13*\3\2\2\2\r,\3\2\2\2\17\62"+
|
||||
"\3\2\2\2\219\3\2\2\2\23A\3\2\2\2\25I\3\2\2\2\27O\3\2\2\2\31T\3\2\2\2\33"+
|
||||
"Z\3\2\2\2\35\36\7C\2\2\36\37\7P\2\2\37 \7U\2\2 !\7Y\2\2!\"\7G\2\2\"#\7"+
|
||||
"T\2\2#\4\3\2\2\2$%\7\60\2\2%\6\3\2\2\2&\'\7*\2\2\'\b\3\2\2\2()\7.\2\2"+
|
||||
")\n\3\2\2\2*+\7+\2\2+\f\3\2\2\2,-\7r\2\2-.\7c\2\2./\7t\2\2/\60\7c\2\2"+
|
||||
"\60\61\7o\2\2\61\16\3\2\2\2\62\63\7g\2\2\63\64\7s\2\2\64\65\7w\2\2\65"+
|
||||
"\66\7c\2\2\66\67\7n\2\2\678\7u\2\28\20\3\2\2\29:\7u\2\2:;\7o\2\2;<\7c"+
|
||||
"\2\2<=\7n\2\2=>\7n\2\2>?\7g\2\2?@\7t\2\2@\22\3\2\2\2AB\7v\2\2BC\7{\2\2"+
|
||||
"CD\7r\2\2DE\7g\2\2EF\7X\2\2FG\7c\2\2GH\7t\2\2H\24\3\2\2\2IJ\7v\2\2JK\7"+
|
||||
"{\2\2KL\7r\2\2LM\7g\2\2M\26\3\2\2\2NP\t\2\2\2ON\3\2\2\2PQ\3\2\2\2QO\3"+
|
||||
"\2\2\2QR\3\2\2\2R\30\3\2\2\2SU\t\3\2\2TS\3\2\2\2UV\3\2\2\2VT\3\2\2\2V"+
|
||||
"W\3\2\2\2WX\3\2\2\2XY\b\r\2\2Y\32\3\2\2\2Z^\7\'\2\2[]\n\4\2\2\\[\3\2\2"+
|
||||
"\2]`\3\2\2\2^\\\3\2\2\2^_\3\2\2\2_a\3\2\2\2`^\3\2\2\2ab\b\16\2\2b\34\3"+
|
||||
"\2\2\2\6\2QV^\3\b\2\2";
|
||||
public static final ATN _ATN =
|
||||
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
|
||||
static {
|
||||
|
@ -4,22 +4,20 @@ T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
PARAMLIST_NAME=6
|
||||
UNIFIER_NAME=7
|
||||
EQUALS_NAME=8
|
||||
SMALLER_NAME=9
|
||||
TYPEVAR_NAME=10
|
||||
TYPE_NAME=11
|
||||
NAME=12
|
||||
WS=13
|
||||
LINE_COMMENT=14
|
||||
EQUALS_NAME=7
|
||||
SMALLER_NAME=8
|
||||
TYPEVAR_NAME=9
|
||||
TYPE_NAME=10
|
||||
NAME=11
|
||||
WS=12
|
||||
LINE_COMMENT=13
|
||||
'ANSWER'=1
|
||||
'.'=2
|
||||
'('=3
|
||||
','=4
|
||||
')'=5
|
||||
'param'=6
|
||||
'unifier'=7
|
||||
'equals'=8
|
||||
'smaller'=9
|
||||
'typeVar'=10
|
||||
'type'=11
|
||||
'equals'=7
|
||||
'smaller'=8
|
||||
'typeVar'=9
|
||||
'type'=10
|
||||
|
@ -67,16 +67,6 @@ public interface UnifyResultListener extends ParseTreeListener {
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void exitEquals(UnifyResultParser.EqualsContext ctx);
|
||||
/**
|
||||
* Enter a parse tree produced by {@link UnifyResultParser#unifier}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void enterUnifier(UnifyResultParser.UnifierContext ctx);
|
||||
/**
|
||||
* Exit a parse tree produced by {@link UnifyResultParser#unifier}.
|
||||
* @param ctx the parse tree
|
||||
*/
|
||||
void exitUnifier(UnifyResultParser.UnifierContext ctx);
|
||||
/**
|
||||
* Enter a parse tree produced by {@link UnifyResultParser#smaller}.
|
||||
* @param ctx the parse tree
|
||||
|
@ -17,26 +17,24 @@ public class UnifyResultParser extends Parser {
|
||||
protected static final PredictionContextCache _sharedContextCache =
|
||||
new PredictionContextCache();
|
||||
public static final int
|
||||
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, UNIFIER_NAME=7,
|
||||
EQUALS_NAME=8, SMALLER_NAME=9, TYPEVAR_NAME=10, TYPE_NAME=11, NAME=12,
|
||||
WS=13, LINE_COMMENT=14;
|
||||
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, EQUALS_NAME=7,
|
||||
SMALLER_NAME=8, TYPEVAR_NAME=9, TYPE_NAME=10, NAME=11, WS=12, LINE_COMMENT=13;
|
||||
public static final int
|
||||
RULE_answer = 0, RULE_resultSetRule = 1, RULE_parameterList = 2, RULE_value = 3,
|
||||
RULE_parameter = 4, RULE_equals = 5, RULE_unifier = 6, RULE_smaller = 7,
|
||||
RULE_typeVar = 8, RULE_type = 9, RULE_otherRule = 10;
|
||||
RULE_parameter = 4, RULE_equals = 5, RULE_smaller = 6, RULE_typeVar = 7,
|
||||
RULE_type = 8, RULE_otherRule = 9;
|
||||
public static final String[] ruleNames = {
|
||||
"answer", "resultSetRule", "parameterList", "value", "parameter", "equals",
|
||||
"unifier", "smaller", "typeVar", "type", "otherRule"
|
||||
"smaller", "typeVar", "type", "otherRule"
|
||||
};
|
||||
|
||||
private static final String[] _LITERAL_NAMES = {
|
||||
null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'unifier'",
|
||||
"'equals'", "'smaller'", "'typeVar'", "'type'"
|
||||
null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'equals'", "'smaller'",
|
||||
"'typeVar'", "'type'"
|
||||
};
|
||||
private static final String[] _SYMBOLIC_NAMES = {
|
||||
null, null, null, null, null, null, "PARAMLIST_NAME", "UNIFIER_NAME",
|
||||
"EQUALS_NAME", "SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS",
|
||||
"LINE_COMMENT"
|
||||
null, null, null, null, null, null, "PARAMLIST_NAME", "EQUALS_NAME", "SMALLER_NAME",
|
||||
"TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
|
||||
};
|
||||
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
|
||||
|
||||
@ -115,21 +113,21 @@ public class UnifyResultParser extends Parser {
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(22);
|
||||
setState(20);
|
||||
match(T__0);
|
||||
setState(28);
|
||||
setState(26);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PARAMLIST_NAME) | (1L << UNIFIER_NAME) | (1L << EQUALS_NAME) | (1L << SMALLER_NAME) | (1L << TYPEVAR_NAME) | (1L << TYPE_NAME) | (1L << NAME))) != 0)) {
|
||||
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PARAMLIST_NAME) | (1L << EQUALS_NAME) | (1L << SMALLER_NAME) | (1L << TYPEVAR_NAME) | (1L << TYPE_NAME) | (1L << NAME))) != 0)) {
|
||||
{
|
||||
{
|
||||
setState(23);
|
||||
setState(21);
|
||||
resultSetRule();
|
||||
setState(24);
|
||||
setState(22);
|
||||
match(T__1);
|
||||
}
|
||||
}
|
||||
setState(30);
|
||||
setState(28);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
}
|
||||
@ -162,9 +160,6 @@ public class UnifyResultParser extends Parser {
|
||||
public TypeContext type() {
|
||||
return getRuleContext(TypeContext.class,0);
|
||||
}
|
||||
public UnifierContext unifier() {
|
||||
return getRuleContext(UnifierContext.class,0);
|
||||
}
|
||||
public OtherRuleContext otherRule() {
|
||||
return getRuleContext(OtherRuleContext.class,0);
|
||||
}
|
||||
@ -186,55 +181,48 @@ public class UnifyResultParser extends Parser {
|
||||
ResultSetRuleContext _localctx = new ResultSetRuleContext(_ctx, getState());
|
||||
enterRule(_localctx, 2, RULE_resultSetRule);
|
||||
try {
|
||||
setState(38);
|
||||
setState(35);
|
||||
_errHandler.sync(this);
|
||||
switch (_input.LA(1)) {
|
||||
case PARAMLIST_NAME:
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(31);
|
||||
setState(29);
|
||||
parameter();
|
||||
}
|
||||
break;
|
||||
case EQUALS_NAME:
|
||||
enterOuterAlt(_localctx, 2);
|
||||
{
|
||||
setState(32);
|
||||
setState(30);
|
||||
equals();
|
||||
}
|
||||
break;
|
||||
case SMALLER_NAME:
|
||||
enterOuterAlt(_localctx, 3);
|
||||
{
|
||||
setState(33);
|
||||
setState(31);
|
||||
smaller();
|
||||
}
|
||||
break;
|
||||
case TYPEVAR_NAME:
|
||||
enterOuterAlt(_localctx, 4);
|
||||
{
|
||||
setState(34);
|
||||
setState(32);
|
||||
typeVar();
|
||||
}
|
||||
break;
|
||||
case TYPE_NAME:
|
||||
enterOuterAlt(_localctx, 5);
|
||||
{
|
||||
setState(35);
|
||||
setState(33);
|
||||
type();
|
||||
}
|
||||
break;
|
||||
case UNIFIER_NAME:
|
||||
case NAME:
|
||||
enterOuterAlt(_localctx, 6);
|
||||
{
|
||||
setState(36);
|
||||
unifier();
|
||||
}
|
||||
break;
|
||||
case NAME:
|
||||
enterOuterAlt(_localctx, 7);
|
||||
{
|
||||
setState(37);
|
||||
setState(34);
|
||||
otherRule();
|
||||
}
|
||||
break;
|
||||
@ -281,27 +269,27 @@ public class UnifyResultParser extends Parser {
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(40);
|
||||
setState(37);
|
||||
match(T__2);
|
||||
setState(41);
|
||||
setState(38);
|
||||
value();
|
||||
setState(46);
|
||||
setState(43);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
while (_la==T__3) {
|
||||
{
|
||||
{
|
||||
setState(42);
|
||||
setState(39);
|
||||
match(T__3);
|
||||
setState(43);
|
||||
setState(40);
|
||||
value();
|
||||
}
|
||||
}
|
||||
setState(48);
|
||||
setState(45);
|
||||
_errHandler.sync(this);
|
||||
_la = _input.LA(1);
|
||||
}
|
||||
setState(49);
|
||||
setState(46);
|
||||
match(T__4);
|
||||
}
|
||||
}
|
||||
@ -339,20 +327,20 @@ public class UnifyResultParser extends Parser {
|
||||
ValueContext _localctx = new ValueContext(_ctx, getState());
|
||||
enterRule(_localctx, 6, RULE_value);
|
||||
try {
|
||||
setState(53);
|
||||
setState(50);
|
||||
_errHandler.sync(this);
|
||||
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
|
||||
case 1:
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(51);
|
||||
setState(48);
|
||||
match(NAME);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
enterOuterAlt(_localctx, 2);
|
||||
{
|
||||
setState(52);
|
||||
setState(49);
|
||||
resultSetRule();
|
||||
}
|
||||
break;
|
||||
@ -394,9 +382,9 @@ public class UnifyResultParser extends Parser {
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(55);
|
||||
setState(52);
|
||||
match(PARAMLIST_NAME);
|
||||
setState(56);
|
||||
setState(53);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
@ -436,51 +424,9 @@ public class UnifyResultParser extends Parser {
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(58);
|
||||
setState(55);
|
||||
match(EQUALS_NAME);
|
||||
setState(59);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
catch (RecognitionException re) {
|
||||
_localctx.exception = re;
|
||||
_errHandler.reportError(this, re);
|
||||
_errHandler.recover(this, re);
|
||||
}
|
||||
finally {
|
||||
exitRule();
|
||||
}
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
public static class UnifierContext extends ParserRuleContext {
|
||||
public TerminalNode UNIFIER_NAME() { return getToken(UnifyResultParser.UNIFIER_NAME, 0); }
|
||||
public ParameterListContext parameterList() {
|
||||
return getRuleContext(ParameterListContext.class,0);
|
||||
}
|
||||
public UnifierContext(ParserRuleContext parent, int invokingState) {
|
||||
super(parent, invokingState);
|
||||
}
|
||||
@Override public int getRuleIndex() { return RULE_unifier; }
|
||||
@Override
|
||||
public void enterRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterUnifier(this);
|
||||
}
|
||||
@Override
|
||||
public void exitRule(ParseTreeListener listener) {
|
||||
if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitUnifier(this);
|
||||
}
|
||||
}
|
||||
|
||||
public final UnifierContext unifier() throws RecognitionException {
|
||||
UnifierContext _localctx = new UnifierContext(_ctx, getState());
|
||||
enterRule(_localctx, 12, RULE_unifier);
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(61);
|
||||
match(UNIFIER_NAME);
|
||||
setState(62);
|
||||
setState(56);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
@ -516,13 +462,13 @@ public class UnifyResultParser extends Parser {
|
||||
|
||||
public final SmallerContext smaller() throws RecognitionException {
|
||||
SmallerContext _localctx = new SmallerContext(_ctx, getState());
|
||||
enterRule(_localctx, 14, RULE_smaller);
|
||||
enterRule(_localctx, 12, RULE_smaller);
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(64);
|
||||
setState(58);
|
||||
match(SMALLER_NAME);
|
||||
setState(65);
|
||||
setState(59);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
@ -558,13 +504,13 @@ public class UnifyResultParser extends Parser {
|
||||
|
||||
public final TypeVarContext typeVar() throws RecognitionException {
|
||||
TypeVarContext _localctx = new TypeVarContext(_ctx, getState());
|
||||
enterRule(_localctx, 16, RULE_typeVar);
|
||||
enterRule(_localctx, 14, RULE_typeVar);
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(67);
|
||||
setState(61);
|
||||
match(TYPEVAR_NAME);
|
||||
setState(68);
|
||||
setState(62);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
@ -600,13 +546,13 @@ public class UnifyResultParser extends Parser {
|
||||
|
||||
public final TypeContext type() throws RecognitionException {
|
||||
TypeContext _localctx = new TypeContext(_ctx, getState());
|
||||
enterRule(_localctx, 18, RULE_type);
|
||||
enterRule(_localctx, 16, RULE_type);
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(70);
|
||||
setState(64);
|
||||
match(TYPE_NAME);
|
||||
setState(71);
|
||||
setState(65);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
@ -642,13 +588,13 @@ public class UnifyResultParser extends Parser {
|
||||
|
||||
public final OtherRuleContext otherRule() throws RecognitionException {
|
||||
OtherRuleContext _localctx = new OtherRuleContext(_ctx, getState());
|
||||
enterRule(_localctx, 20, RULE_otherRule);
|
||||
enterRule(_localctx, 18, RULE_otherRule);
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
{
|
||||
setState(73);
|
||||
setState(67);
|
||||
match(NAME);
|
||||
setState(74);
|
||||
setState(68);
|
||||
parameterList();
|
||||
}
|
||||
}
|
||||
@ -664,25 +610,24 @@ public class UnifyResultParser extends Parser {
|
||||
}
|
||||
|
||||
public static final String _serializedATN =
|
||||
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\20O\4\2\t\2\4\3\t"+
|
||||
"\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4"+
|
||||
"\f\t\f\3\2\3\2\3\2\3\2\7\2\35\n\2\f\2\16\2 \13\2\3\3\3\3\3\3\3\3\3\3\3"+
|
||||
"\3\3\3\5\3)\n\3\3\4\3\4\3\4\3\4\7\4/\n\4\f\4\16\4\62\13\4\3\4\3\4\3\5"+
|
||||
"\3\5\5\58\n\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n"+
|
||||
"\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\f\2\2\r\2\4\6\b\n\f\16\20\22\24\26\2"+
|
||||
"\2\2L\2\30\3\2\2\2\4(\3\2\2\2\6*\3\2\2\2\b\67\3\2\2\2\n9\3\2\2\2\f<\3"+
|
||||
"\2\2\2\16?\3\2\2\2\20B\3\2\2\2\22E\3\2\2\2\24H\3\2\2\2\26K\3\2\2\2\30"+
|
||||
"\36\7\3\2\2\31\32\5\4\3\2\32\33\7\4\2\2\33\35\3\2\2\2\34\31\3\2\2\2\35"+
|
||||
" \3\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37\3\3\2\2\2 \36\3\2\2\2!)\5\n\6"+
|
||||
"\2\")\5\f\7\2#)\5\20\t\2$)\5\22\n\2%)\5\24\13\2&)\5\16\b\2\')\5\26\f\2"+
|
||||
"(!\3\2\2\2(\"\3\2\2\2(#\3\2\2\2($\3\2\2\2(%\3\2\2\2(&\3\2\2\2(\'\3\2\2"+
|
||||
"\2)\5\3\2\2\2*+\7\5\2\2+\60\5\b\5\2,-\7\6\2\2-/\5\b\5\2.,\3\2\2\2/\62"+
|
||||
"\3\2\2\2\60.\3\2\2\2\60\61\3\2\2\2\61\63\3\2\2\2\62\60\3\2\2\2\63\64\7"+
|
||||
"\7\2\2\64\7\3\2\2\2\658\7\16\2\2\668\5\4\3\2\67\65\3\2\2\2\67\66\3\2\2"+
|
||||
"\28\t\3\2\2\29:\7\b\2\2:;\5\6\4\2;\13\3\2\2\2<=\7\n\2\2=>\5\6\4\2>\r\3"+
|
||||
"\2\2\2?@\7\t\2\2@A\5\6\4\2A\17\3\2\2\2BC\7\13\2\2CD\5\6\4\2D\21\3\2\2"+
|
||||
"\2EF\7\f\2\2FG\5\6\4\2G\23\3\2\2\2HI\7\r\2\2IJ\5\6\4\2J\25\3\2\2\2KL\7"+
|
||||
"\16\2\2LM\5\6\4\2M\27\3\2\2\2\6\36(\60\67";
|
||||
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\17I\4\2\t\2\4\3\t"+
|
||||
"\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\3"+
|
||||
"\2\3\2\3\2\3\2\7\2\33\n\2\f\2\16\2\36\13\2\3\3\3\3\3\3\3\3\3\3\3\3\5\3"+
|
||||
"&\n\3\3\4\3\4\3\4\3\4\7\4,\n\4\f\4\16\4/\13\4\3\4\3\4\3\5\3\5\5\5\65\n"+
|
||||
"\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3"+
|
||||
"\13\3\13\3\13\2\2\f\2\4\6\b\n\f\16\20\22\24\2\2\2F\2\26\3\2\2\2\4%\3\2"+
|
||||
"\2\2\6\'\3\2\2\2\b\64\3\2\2\2\n\66\3\2\2\2\f9\3\2\2\2\16<\3\2\2\2\20?"+
|
||||
"\3\2\2\2\22B\3\2\2\2\24E\3\2\2\2\26\34\7\3\2\2\27\30\5\4\3\2\30\31\7\4"+
|
||||
"\2\2\31\33\3\2\2\2\32\27\3\2\2\2\33\36\3\2\2\2\34\32\3\2\2\2\34\35\3\2"+
|
||||
"\2\2\35\3\3\2\2\2\36\34\3\2\2\2\37&\5\n\6\2 &\5\f\7\2!&\5\16\b\2\"&\5"+
|
||||
"\20\t\2#&\5\22\n\2$&\5\24\13\2%\37\3\2\2\2% \3\2\2\2%!\3\2\2\2%\"\3\2"+
|
||||
"\2\2%#\3\2\2\2%$\3\2\2\2&\5\3\2\2\2\'(\7\5\2\2(-\5\b\5\2)*\7\6\2\2*,\5"+
|
||||
"\b\5\2+)\3\2\2\2,/\3\2\2\2-+\3\2\2\2-.\3\2\2\2.\60\3\2\2\2/-\3\2\2\2\60"+
|
||||
"\61\7\7\2\2\61\7\3\2\2\2\62\65\7\r\2\2\63\65\5\4\3\2\64\62\3\2\2\2\64"+
|
||||
"\63\3\2\2\2\65\t\3\2\2\2\66\67\7\b\2\2\678\5\6\4\28\13\3\2\2\29:\7\t\2"+
|
||||
"\2:;\5\6\4\2;\r\3\2\2\2<=\7\n\2\2=>\5\6\4\2>\17\3\2\2\2?@\7\13\2\2@A\5"+
|
||||
"\6\4\2A\21\3\2\2\2BC\7\f\2\2CD\5\6\4\2D\23\3\2\2\2EF\7\r\2\2FG\5\6\4\2"+
|
||||
"G\25\3\2\2\2\6\34%-\64";
|
||||
public static final ATN _ATN =
|
||||
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
|
||||
static {
|
||||
|
@ -1,22 +1,17 @@
|
||||
package de.dhbwstuttgart.sat.asp.writer;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
|
||||
import de.dhbwstuttgart.sat.asp.ASPStringConverter;
|
||||
import de.dhbwstuttgart.sat.asp.model.ASPRule;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
|
||||
import javax.management.Notification;
|
||||
import java.util.*;
|
||||
|
||||
public class ASPFactory implements TypeVisitor<String>{
|
||||
@ -24,112 +19,29 @@ public class ASPFactory implements TypeVisitor<String>{
|
||||
public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
|
||||
ASPFactory factory = new ASPFactory();
|
||||
factory.convertFC(fcClasses);
|
||||
//List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
|
||||
for(Pair p : constraints.getUndConstraints()){
|
||||
factory.convertPair(p);
|
||||
}
|
||||
for(Set<Constraint<Pair>> oder : constraints.getOderConstraints()){
|
||||
factory.convertOderConstraint(oder);
|
||||
List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
|
||||
for(Constraint<Pair> constraint : constraints1){
|
||||
for(Pair p : constraint){
|
||||
factory.convertPair(p);
|
||||
}
|
||||
}
|
||||
|
||||
return factory.writer.getASPFile();
|
||||
}
|
||||
|
||||
/**
|
||||
* Wandelt eine Reihe von Constraints zu einem Und-Constraint - also einer Liste - um.
|
||||
* Dieser kann dann in Oder-Constraints verwendet werden.
|
||||
* @param undCons - Eine Liste von Constraints. Bsp: equals(..), smallerDot(..)
|
||||
* @return - list(equals, list(smallerDot(..., null)
|
||||
*/
|
||||
protected ASPStatement convertListToUndConstraint(List<ASPStatement> undCons) {
|
||||
if(undCons.size() == 0)throw new NullPointerException();
|
||||
if(undCons.size() == 1){
|
||||
return undCons.get(0);
|
||||
}
|
||||
ASPStatement list = new ASPStatement(ASPRule.ASP_LIST_ENDPOINTER.toString());
|
||||
for(ASPStatement con : undCons){
|
||||
list = makeStatement(ASPRule.ASP_LIST_NAME.toString(), con.getASP(), list.getASP());
|
||||
}
|
||||
return list;
|
||||
}
|
||||
ASPWriter writer = new ASPWriter();
|
||||
boolean isFCType = false;
|
||||
|
||||
protected ASPStatement convertListToUndConstraint(Constraint<Pair> undCons) {
|
||||
List<ASPStatement> convert = new ArrayList<>();
|
||||
for(Pair p : undCons){
|
||||
convert.add(generatePairStmt(p));
|
||||
}
|
||||
return convertListToUndConstraint(convert);
|
||||
}
|
||||
|
||||
protected void convertOderConstraint(Set<Constraint<Pair>> oder) {
|
||||
if(oder.size() < 2){//Oder-Setgröße darf nicht null sein. Sonst gibt es sowieso kein Ergebnis:
|
||||
for(Pair p : oder.iterator().next()){
|
||||
this.convertPair(p); //Einfach als und Constraints behandeln, wenn es nur einen Oder-Zweig gibt
|
||||
}
|
||||
return;
|
||||
}
|
||||
List<ASPStatement> ret = new ArrayList<>();
|
||||
Iterator<Constraint<Pair>> it = oder.iterator();
|
||||
String pointer1 = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
ASPStatement stmt = makeStatement(ASPRule.ASP_CONSTRAINT.toString(), pointer1,
|
||||
convertListToUndConstraint(it.next()).getASP());
|
||||
ret.add(stmt);
|
||||
while(it.hasNext()){
|
||||
String pointer2 = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
Constraint<Pair> cons = it.next();
|
||||
stmt = makeStatement(ASPRule.ASP_CONSTRAINT.toString(), pointer2,
|
||||
convertListToUndConstraint(cons).getASP());
|
||||
ret.add(stmt);
|
||||
ASPStatement oderStmt = makeStatement(ASPRule.ASP_ODER.toString(), pointer1, pointer2);
|
||||
if(it.hasNext()){
|
||||
String oderPointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
stmt = makeStatement(ASPRule.ASP_CONSTRAINT.toString(), oderPointer, oderStmt.getASP());
|
||||
ret.add(stmt);
|
||||
pointer1 = oderPointer;
|
||||
}else{
|
||||
ret.add(oderStmt);
|
||||
}
|
||||
}
|
||||
//Alle erstellten Constraints schreiben:
|
||||
writer.addAll(ret);
|
||||
}
|
||||
|
||||
protected ASPWriter writer = new ASPWriter();
|
||||
|
||||
protected void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
|
||||
Collection<Pair> fc = FCGenerator.toFC(classes);
|
||||
HashMap<String, Pair> set = new HashMap<>();
|
||||
private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
|
||||
Set<Pair> fc = FCGenerator.toFC(classes);
|
||||
isFCType = true;
|
||||
for(Pair fcp : fc){
|
||||
StringBuilder output = new StringBuilder();
|
||||
OutputGenerator generator = new OutputGenerator(output);
|
||||
fcp.TA1.accept(generator);
|
||||
output.append("<");
|
||||
fcp.TA2.accept(generator);
|
||||
set.put(output.toString(), fcp);
|
||||
}
|
||||
for(Pair fcp : set.values()){
|
||||
convertPair(fcp);
|
||||
}
|
||||
for(ClassOrInterface cl : classes){
|
||||
RefType t = fromClassOrInterface(cl);
|
||||
convertPair(new Pair(t,t,PairOperator.SMALLER));
|
||||
}
|
||||
isFCType = false;
|
||||
}
|
||||
|
||||
private RefType fromClassOrInterface(ClassOrInterface cl){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
|
||||
for(GenericTypeVar gtv : cl.getGenerics()){
|
||||
params.add(TypePlaceholder.fresh(new NullToken()));
|
||||
}
|
||||
return new RefType(cl.getClassName(), params, new NullToken());
|
||||
}
|
||||
|
||||
protected void convertPair(Pair p){
|
||||
ASPStatement pairStmt = generatePairStmt(p);
|
||||
writer.add(pairStmt);
|
||||
}
|
||||
|
||||
protected ASPStatement generatePairStmt(Pair p) {
|
||||
private void convertPair(Pair p){
|
||||
String ls = p.TA1.acceptTV(this);
|
||||
String rs = p.TA2.acceptTV(this);
|
||||
ASPStatement pairStmt = null;
|
||||
@ -140,32 +52,40 @@ public class ASPFactory implements TypeVisitor<String>{
|
||||
}else if(p.GetOperator().equals(PairOperator.SMALLER)){
|
||||
pairStmt = makeStatement(ASPRule.ASP_PAIR_SMALLER_NAME.toString(), ls, rs);
|
||||
}else throw new NotImplementedException();
|
||||
return pairStmt;
|
||||
writer.add(pairStmt);
|
||||
}
|
||||
|
||||
protected ASPStatement makeStatement(String rule, String... params){
|
||||
private ASPStatement makeStatement(String rule, String... params){
|
||||
String stmt = rule + "(";
|
||||
Iterator<String> it = Arrays.asList(params).iterator();
|
||||
while(it.hasNext()){
|
||||
String param = it.next();
|
||||
stmt += param;
|
||||
if(it.hasNext())stmt+=",";
|
||||
for(String param : params){
|
||||
stmt += param + ",";
|
||||
}
|
||||
stmt = stmt.substring(0,stmt.length()-1);
|
||||
stmt += ")";
|
||||
return new ASPStatement(stmt);
|
||||
}
|
||||
|
||||
protected void convertParameterlist(String pointer, List<String> pointers){
|
||||
private String convertParameterlist(List<String> pointers){
|
||||
String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
Iterator<String> it = pointers.iterator();
|
||||
Integer i = 1;
|
||||
String ruleName = ASPRule.ASP_PARAMLIST_NAME.toString();
|
||||
String p = pointer;
|
||||
if(!it.hasNext()){
|
||||
return ASPRule.ASP_PARAMLIST_END_POINTER.toString();
|
||||
}
|
||||
while (it.hasNext()){
|
||||
ASPStatement stmt;
|
||||
String type = it.next();
|
||||
stmt = makeStatement(ruleName, pointer, type, i.toString());
|
||||
String nextP = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
if(it.hasNext()){
|
||||
stmt = makeStatement(ASPRule.ASP_PARAMLIST_NAME.toString(), p, type, nextP);
|
||||
}else{
|
||||
stmt = makeStatement(ASPRule.ASP_PARAMLIST_NAME.toString(), p, type,
|
||||
ASPRule.ASP_PARAMLIST_END_POINTER.toString());
|
||||
}
|
||||
p = nextP;
|
||||
writer.add(stmt);
|
||||
i++;
|
||||
}
|
||||
return pointer;
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -176,9 +96,8 @@ public class ASPFactory implements TypeVisitor<String>{
|
||||
params.add(param.acceptTV(this));
|
||||
}
|
||||
String typeName = ASPStringConverter.toConstant(refType.getName());
|
||||
String ruleName = ASPRule.ASP_TYPE.toString();
|
||||
convertParameterlist(pointer, params);
|
||||
ASPStatement stmt = makeStatement(ruleName, pointer, typeName, Integer.toString(params.size()));
|
||||
String ruleName = isFCType?ASPRule.ASP_FCTYPE.toString():ASPRule.ASP_TYPE.toString();
|
||||
ASPStatement stmt = makeStatement(ruleName, pointer, typeName, convertParameterlist(params));
|
||||
writer.add(stmt);
|
||||
return pointer;
|
||||
}
|
||||
@ -203,12 +122,6 @@ public class ASPFactory implements TypeVisitor<String>{
|
||||
|
||||
@Override
|
||||
public String visit(GenericRefType genericRefType) {
|
||||
//Kann eigentlich wie ein normaler RefType behandelt werden
|
||||
String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
String typeName = ASPStringConverter.toConstant(genericRefType.getParsedName());
|
||||
String ruleName = ASPRule.ASP_TYPE.toString();
|
||||
ASPStatement stmt = makeStatement(ruleName, pointer, typeName, ASPRule.ASP_LIST_ENDPOINTER.toString());
|
||||
writer.add(stmt);
|
||||
return pointer;
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
|
@ -15,7 +15,7 @@ import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
import java.util.*;
|
||||
|
||||
|
||||
public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
public class ASPGencayFactory implements TypeVisitor<String> {
|
||||
/* TODO:
|
||||
* Alle TPHs müssen als var(tph) definiert sein
|
||||
* Wenn es eine Variable ist, dann direkt in die type-Regel schreiben: type(p, type, tph)
|
||||
@ -56,7 +56,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
}
|
||||
|
||||
public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
|
||||
ASPFactoryAlternative factory = new ASPFactoryAlternative();
|
||||
ASPGencayFactory factory = new ASPGencayFactory();
|
||||
factory.convertFC(fcClasses);
|
||||
List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
|
||||
for(Constraint<Pair> constraint : constraints1){
|
||||
@ -70,7 +70,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
}
|
||||
|
||||
private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
|
||||
Collection<Pair> fc = FCGenerator.toFC(classes);
|
||||
Set<Pair> fc = FCGenerator.toFC(classes);
|
||||
isFCType = true;
|
||||
for(Pair fcp : fc){
|
||||
generateTheta((RefType) fcp.TA1);
|
||||
@ -130,11 +130,6 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
stmt = makeStatement(paramname, p, type,
|
||||
ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString());
|
||||
}
|
||||
if(!it.hasNext()){ //Falls es der letzte Pointer ist
|
||||
String endRule = isFCType?ASPGencayRule.ASP_PARAMLIST_END_RULE_FC.toString():ASPGencayRule.ASP_PARAMLIST_END_RULE_EQ.toString();
|
||||
writer.add(makeStatement(endRule, p,
|
||||
ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString()));
|
||||
}
|
||||
p = nextP;
|
||||
writer.add(stmt);
|
||||
}
|
||||
@ -148,11 +143,11 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
currentFCTypePointer = pointer;
|
||||
String paramPointer = ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString();
|
||||
if(refType.getParaList().size() == 1
|
||||
&& (refType.getParaList().get(0) instanceof TypePlaceholder
|
||||
|| refType.getParaList().get(0) instanceof WildcardType)){
|
||||
RefTypeOrTPHOrWildcardOrGeneric typePlaceholder = refType.getParaList().get(0);
|
||||
paramPointer = typePlaceholder.acceptTV(this);
|
||||
if(refType.getParaList().size() == 1 ){
|
||||
if(refType.getParaList().get(0) instanceof TypePlaceholder){
|
||||
TypePlaceholder typePlaceholder = (TypePlaceholder) refType.getParaList().get(0);
|
||||
paramPointer = typePlaceholder.acceptTV(this);
|
||||
}
|
||||
}else{
|
||||
List<String> params = null;
|
||||
params = generateParameter(refType);
|
||||
@ -199,8 +194,6 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
ret.addAll(generateParameter((RefType) param));
|
||||
}else if(param instanceof TypePlaceholder){
|
||||
ret.add(param.acceptTV(this));
|
||||
}else if(param instanceof WildcardType){
|
||||
ret.add(param.acceptTV(this));
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
return ret;
|
||||
@ -208,10 +201,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
|
||||
@Override
|
||||
public String visit(SuperWildcardType superWildcardType) {
|
||||
String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
writer.add(makeStatement(ASPGencayRule.ASP_WILDCARD.toString(),
|
||||
pointer, "super", superWildcardType.getInnerType().acceptTV(this)));
|
||||
return pointer;
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -232,10 +222,7 @@ public class ASPFactoryAlternative implements TypeVisitor<String> {
|
||||
|
||||
@Override
|
||||
public String visit(ExtendsWildcardType extendsWildcardType) {
|
||||
String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
|
||||
writer.add(makeStatement(ASPGencayRule.ASP_WILDCARD.toString(),
|
||||
pointer, "extends", extendsWildcardType.getInnerType().acceptTV(this)));
|
||||
return pointer;
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
@ -1,6 +1,5 @@
|
||||
package de.dhbwstuttgart.sat.asp.writer;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
|
@ -66,10 +66,10 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList formalParameters) {
|
||||
Iterator<FormalParameter> it = formalParameters.getFormalparalist().iterator();
|
||||
if(it.hasNext()){
|
||||
while(it.hasNext()){
|
||||
it.next().accept(this);
|
||||
Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
|
||||
if(genericIterator.hasNext()){
|
||||
while(genericIterator.hasNext()){
|
||||
genericIterator.next().accept(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -12,7 +12,6 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
@ -34,7 +33,6 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
|
||||
public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters,
|
||||
RefType superClass, Boolean isInterface, List<RefType> implementedInterfaces, Token offset){
|
||||
super(offset);
|
||||
if(isInterface && !Modifier.isInterface(modifiers))modifiers += Modifier.INTERFACE;
|
||||
this.modifiers = modifiers;
|
||||
this.name = name;
|
||||
this.fields = fielddecl;
|
||||
@ -108,4 +106,8 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
|
||||
public Collection<RefType> getSuperInterfaces() {
|
||||
return implementedInterfaces;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return this.name.toString() + this.genericClassParameters.toString();
|
||||
}
|
||||
}
|
||||
|
@ -31,4 +31,8 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return this.gtvs.toString();
|
||||
}
|
||||
}
|
||||
|
@ -17,7 +17,6 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Block;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Statement;
|
||||
import de.dhbwstuttgart.syntaxtree.type.WildcardType;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -38,7 +37,7 @@ public class ASTFactory {
|
||||
methoden.add(createMethod(method, jreClass));
|
||||
}
|
||||
List<Field> felder = new ArrayList<>();
|
||||
for(java.lang.reflect.Field field : jreClass.getDeclaredFields()){
|
||||
for(java.lang.reflect.Field field : jreClass.getFields()){
|
||||
felder.add(createField(field, name));
|
||||
}
|
||||
int modifier = jreClass.getModifiers();
|
||||
@ -51,15 +50,15 @@ public class ASTFactory {
|
||||
java.lang.Class superjreClass = jreClass.getSuperclass();
|
||||
RefType superClass;
|
||||
if(parameterSuperClass != null){
|
||||
superClass = (RefType) createType(parameterSuperClass);
|
||||
superClass = (RefType) convertType(parameterSuperClass);
|
||||
}else if(superjreClass != null){
|
||||
superClass = (RefType) createType(superjreClass);
|
||||
superClass = (RefType) convertType(superjreClass);
|
||||
}else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!)
|
||||
superClass = (RefType) createType(java.lang.Object.class);
|
||||
superClass = (RefType) createType(java.lang.Object.class, name, "");
|
||||
}
|
||||
List<RefType> implementedInterfaces = new ArrayList<>();
|
||||
for(Type jreInterface : jreClass.getGenericInterfaces()){
|
||||
implementedInterfaces.add((RefType) createType(jreInterface));
|
||||
implementedInterfaces.add((RefType) createType(jreInterface, name, ""));
|
||||
}
|
||||
GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null);
|
||||
|
||||
@ -68,8 +67,29 @@ public class ASTFactory {
|
||||
return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset);
|
||||
}
|
||||
|
||||
private static RefTypeOrTPHOrWildcardOrGeneric convertType(Type type){
|
||||
if(type instanceof ParameterizedType){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
|
||||
for(Type paramType : ((ParameterizedType)type).getActualTypeArguments()){
|
||||
params.add(convertType(paramType));
|
||||
}
|
||||
JavaClassName name = new JavaClassName(((ParameterizedType) type).getRawType().getTypeName());
|
||||
return new RefType(name, params, new NullToken());
|
||||
}else if(type instanceof TypeVariable){
|
||||
return new GenericRefType(((TypeVariable) type).getName(), new NullToken());
|
||||
}else if(type instanceof Class){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
|
||||
Class paramClass = (Class) type;
|
||||
for(TypeVariable tv : paramClass.getTypeParameters()){
|
||||
params.add(new GenericRefType(tv.getName(), new NullToken()));
|
||||
}
|
||||
JavaClassName name = new JavaClassName(paramClass.getName());
|
||||
return new RefType(name, params, new NullToken());
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
|
||||
return new Field(field.getName(), createType(field.getType()), field.getModifiers(), new NullToken());
|
||||
return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
|
||||
}
|
||||
|
||||
//private static RefType createType(Class classType) {
|
||||
@ -78,13 +98,13 @@ public class ASTFactory {
|
||||
|
||||
private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
|
||||
String name = constructor.getName();
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass);
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name);
|
||||
Parameter[] jreParams = constructor.getParameters();
|
||||
Type[] jreGenericParams = constructor.getGenericParameterTypes();
|
||||
List<FormalParameter> params = new ArrayList<>();
|
||||
int i = 0;
|
||||
for(Type jreParam : jreGenericParams){
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam);
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name);
|
||||
params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken()));
|
||||
i++;
|
||||
}
|
||||
@ -110,13 +130,13 @@ public class ASTFactory {
|
||||
}else{
|
||||
jreRetType = jreMethod.getReturnType();
|
||||
}
|
||||
returnType = createType(jreRetType);
|
||||
returnType = createType(jreRetType,new JavaClassName(inClass.getName()), name);
|
||||
Parameter[] jreParams = jreMethod.getParameters();
|
||||
Type[] jreGenericParams = jreMethod.getGenericParameterTypes();
|
||||
List<FormalParameter> params = new ArrayList<>();
|
||||
int i = 0;
|
||||
for(Type jreParam : jreGenericParams){
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam);
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name);
|
||||
params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken()));
|
||||
i++;
|
||||
}
|
||||
@ -137,7 +157,18 @@ public class ASTFactory {
|
||||
return new GenericDeclarationList(gtvs,new NullToken());
|
||||
}
|
||||
|
||||
private static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type){
|
||||
/*
|
||||
public RefType createType(java.lang.Class jreClass){
|
||||
List<RefTypeOrTPH> params = new ArrayList<>();
|
||||
for(TypeVariable jreTV : jreClass.getTypeParameters()){
|
||||
RefType gtv = createType(jreTV);
|
||||
params.add(gtv);
|
||||
}
|
||||
return new RefType(names.getName(jreClass.getName()), params, new NullToken());
|
||||
}
|
||||
*/
|
||||
|
||||
private static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){
|
||||
if(type.getTypeName().equals("void")){
|
||||
return new Void(new NullToken());
|
||||
}else if(type.getTypeName().equals("int")){
|
||||
@ -162,7 +193,7 @@ public class ASTFactory {
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
|
||||
if(type instanceof ParameterizedType){
|
||||
for(Type t : ((ParameterizedType)type).getActualTypeArguments()){
|
||||
params.add(createType(t));
|
||||
params.add(createType(t, parentClass, parentMethod));
|
||||
}
|
||||
}
|
||||
String name = type.getTypeName();
|
||||
@ -170,19 +201,8 @@ public class ASTFactory {
|
||||
//Diese entfernen:
|
||||
name = name.split("<")[0];
|
||||
}
|
||||
if(type instanceof java.lang.reflect.WildcardType){
|
||||
java.lang.reflect.WildcardType wildcardType = (java.lang.reflect.WildcardType) type;
|
||||
if(wildcardType.getLowerBounds().length > 0){
|
||||
return new SuperWildcardType(createType(wildcardType.getLowerBounds()[0]), new NullToken());
|
||||
}else if(wildcardType.getUpperBounds().length > 0){
|
||||
return new ExtendsWildcardType(createType(wildcardType.getUpperBounds()[0]), new NullToken());
|
||||
}else{//Es handelt sich um den '?'-Typ:
|
||||
return new ExtendsWildcardType(createObjectType(), new NullToken());
|
||||
}
|
||||
}else{
|
||||
RefType ret = new RefType(new JavaClassName(name), params, new NullToken());
|
||||
return ret;
|
||||
}
|
||||
RefType ret = new RefType(new JavaClassName(name), params, new NullToken());
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
@ -192,7 +212,7 @@ public class ASTFactory {
|
||||
java.lang.reflect.Type[] bounds = jreTypeVar.getBounds();
|
||||
if(bounds.length > 0){
|
||||
for(java.lang.reflect.Type bound : bounds){
|
||||
genericBounds.add((RefType) createType(bound));
|
||||
genericBounds.add((RefType) createType(bound, parentClass, parentMethod));
|
||||
}
|
||||
}
|
||||
return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken());
|
||||
|
@ -26,6 +26,8 @@ import de.dhbwstuttgart.typeinference.result.ResultPair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.*;
|
||||
|
||||
public class UnifyTypeFactory {
|
||||
|
||||
private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>();
|
||||
|
||||
public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses) throws ClassNotFoundException {
|
||||
/*
|
||||
@ -49,6 +51,10 @@ public class UnifyTypeFactory {
|
||||
return new UnifyPair(tl, tr, PairOperator.SMALLERDOT);
|
||||
}
|
||||
|
||||
public static UnifyPair generateSmallNotEqualDotPair(UnifyType tl, UnifyType tr){
|
||||
return new UnifyPair(tl, tr, PairOperator.SMALLERNEQDOT);
|
||||
}
|
||||
|
||||
public static UnifyPair generateEqualDotPair(UnifyType tl, UnifyType tr){
|
||||
return new UnifyPair(tl, tr, PairOperator.EQUALSDOT);
|
||||
}
|
||||
@ -113,7 +119,15 @@ public class UnifyTypeFactory {
|
||||
}
|
||||
|
||||
public static UnifyType convert(TypePlaceholder tph){
|
||||
return new PlaceholderType(tph.getName());
|
||||
PlaceholderType ntph = new PlaceholderType(tph.getName());
|
||||
int in = PLACEHOLDERS.indexOf(ntph);
|
||||
if (in == -1) {
|
||||
PLACEHOLDERS.add(ntph);
|
||||
return ntph;
|
||||
}
|
||||
else {
|
||||
return PLACEHOLDERS.get(in);
|
||||
}
|
||||
}
|
||||
|
||||
public static UnifyType convert(GenericRefType t){
|
||||
@ -142,6 +156,10 @@ public class UnifyTypeFactory {
|
||||
UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
|
||||
, UnifyTypeFactory.convert(p.TA2));
|
||||
return ret;
|
||||
}else if(p.GetOperator().equals(PairOperator.SMALLERNEQDOT)) {
|
||||
UnifyPair ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(p.TA1)
|
||||
, UnifyTypeFactory.convert(p.TA2));
|
||||
return ret;
|
||||
}else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
|
||||
UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
|
||||
, UnifyTypeFactory.convert(p.TA2));
|
||||
@ -190,7 +208,7 @@ public class UnifyTypeFactory {
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
|
||||
RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
|
||||
RefType ret = new RefType(new JavaClassName(t.getName()+"$$"), convert(t.getTypeParams(), tphs), new NullToken());
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -34,10 +34,6 @@ public class ExtendsWildcardType extends WildcardType{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "? extends "+innerType.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
|
@ -24,7 +24,7 @@ public class FunN extends RefType {
|
||||
* @return
|
||||
*/
|
||||
public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
|
||||
super(new JavaClassName("Fun"+params.size()), params, new NullToken());
|
||||
super(new JavaClassName("Fun"+(params.size())), params, new NullToken());
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -35,11 +35,6 @@ public class SuperWildcardType extends WildcardType{
|
||||
return this.innerType;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "? super "+innerType.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isExtends() {
|
||||
return false;
|
||||
|
@ -1,30 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.visual;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
public class TypePrinter implements TypeVisitor<String> {
|
||||
@Override
|
||||
public String visit(RefType refType) {
|
||||
return refType.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String visit(SuperWildcardType superWildcardType) {
|
||||
return "? super " + superWildcardType.getInnerType().acceptTV(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String visit(TypePlaceholder typePlaceholder) {
|
||||
return "TPH " + typePlaceholder.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String visit(ExtendsWildcardType extendsWildcardType) {
|
||||
return "? extends " + extendsWildcardType.getInnerType().acceptTV(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String visit(GenericRefType genericRefType) {
|
||||
return genericRefType.getParsedName();
|
||||
}
|
||||
}
|
@ -59,11 +59,13 @@ class TypeInsertPlacerClass extends AbstractASTWalker{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FormalParameter param) {
|
||||
public void visit(ParameterList params) {
|
||||
for(FormalParameter param : params){
|
||||
if(param.getType() instanceof TypePlaceholder)
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
param.getType(), param.getType().getOffset(), cl, method, results));
|
||||
super.visit(param);
|
||||
}
|
||||
super.visit(params);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -8,32 +8,36 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
|
||||
import de.dhbwstuttgart.syntaxtree.Method;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class FunNClass extends ClassOrInterface {
|
||||
public FunNClass(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
|
||||
super(0, new JavaClassName("Fun"+(funNParams.size()-1)), new ArrayList<>(),
|
||||
public FunNClass(List<GenericRefType> funNParams) {
|
||||
super(0, new JavaClassName("Fun"+(funNParams.size())), new ArrayList<>(),
|
||||
createMethods(funNParams), new ArrayList<>(), createGenerics(funNParams),
|
||||
ASTFactory.createObjectType(), true, new ArrayList<>(), new NullToken());
|
||||
|
||||
|
||||
}
|
||||
|
||||
private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
|
||||
private static GenericDeclarationList createGenerics(List<GenericRefType> funNParams) {
|
||||
//PL 2018-06-22: so geaendert, dass generierte Generics den Namen der funParams entsprechen.
|
||||
List<GenericTypeVar> generics = new ArrayList<>();
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
|
||||
generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
|
||||
for(GenericRefType param : funNParams){
|
||||
generics.add(new GenericTypeVar(param.getParsedName(),//NameGenerator.makeNewName(),
|
||||
new ArrayList<>(), new NullToken(), new NullToken()));
|
||||
}
|
||||
return new GenericDeclarationList(generics, new NullToken());
|
||||
}
|
||||
|
||||
private static List<Method> createMethods(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
|
||||
private static List<Method> createMethods(List<GenericRefType> funNParams) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
@ -16,10 +16,10 @@ import java.util.List;
|
||||
public class MethodAssumption extends Assumption{
|
||||
private ClassOrInterface receiver;
|
||||
private RefTypeOrTPHOrWildcardOrGeneric retType;
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params;
|
||||
List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
|
||||
|
||||
public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
|
||||
List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
|
||||
super(scope);
|
||||
this.receiver = receiver;
|
||||
this.retType = retType;
|
||||
@ -38,13 +38,18 @@ public class MethodAssumption extends Assumption{
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) {
|
||||
return resolver.resolve(retType);
|
||||
if(retType instanceof GenericRefType) {
|
||||
return resolver.resolve(retType);
|
||||
}
|
||||
return retType;
|
||||
}
|
||||
|
||||
public List<RefTypeOrTPHOrWildcardOrGeneric> getArgTypes(GenericsResolver resolver) {
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric param : params){
|
||||
param = resolver.resolve(param);
|
||||
if(param instanceof GenericRefType){ //Generics in den Assumptions müssen umgewandelt werden.
|
||||
param = resolver.resolve((GenericRefType) param);
|
||||
}
|
||||
ret.add(param);
|
||||
}
|
||||
return ret;
|
||||
|
@ -52,12 +52,4 @@ public class ConstraintSet<A> {
|
||||
ret.oderConstraints = newOder;
|
||||
return ret;
|
||||
}
|
||||
|
||||
public Constraint<A> getUndConstraints() {
|
||||
return undConstraints;
|
||||
}
|
||||
|
||||
public List<Set<Constraint<A>>> getOderConstraints() {
|
||||
return oderConstraints;
|
||||
}
|
||||
}
|
||||
|
@ -11,6 +11,7 @@ public class Pair implements Serializable
|
||||
public final RefTypeOrTPHOrWildcardOrGeneric TA2;
|
||||
|
||||
private PairOperator eOperator = PairOperator.SMALLER;
|
||||
|
||||
|
||||
public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 )
|
||||
{
|
||||
@ -41,14 +42,16 @@ public class Pair implements Serializable
|
||||
if( TA2 != null )
|
||||
strElement2 = TA2.toString();
|
||||
|
||||
/* PL ausskommentiert 2018-05-24
|
||||
if(OperatorEqual())
|
||||
Operator = "=";
|
||||
if(OperatorSmaller())
|
||||
Operator = "<.";
|
||||
if(OperatorSmallerExtends())
|
||||
Operator = "<?";
|
||||
*/
|
||||
|
||||
return "\n(" + strElement1 + " " + Operator + " " + strElement2 + ")";
|
||||
return "\n(" + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
|
||||
|
||||
/*- Equals: " + bEqual*/
|
||||
}
|
||||
|
@ -60,7 +60,8 @@ public class TYPE {
|
||||
|
||||
return new TypeInferenceInformation(classes);
|
||||
}
|
||||
*/
|
||||
|
||||
*/
|
||||
private ConstraintSet getConstraintsMethod(Method m, TypeInferenceInformation info, ClassOrInterface currentClass) {
|
||||
if(m.block == null)return new ConstraintSet(); //Abstrakte Methoden generieren keine Constraints
|
||||
TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
|
||||
|
@ -6,6 +6,7 @@ import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
|
||||
@ -57,8 +58,8 @@ public class TYPEStmt implements StatementVisitor{
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
|
||||
//lambdaParams.add(tphRetType);
|
||||
lambdaParams.add(0,tphRetType);
|
||||
lambdaParams.add(tphRetType);
|
||||
//lambdaParams.add(0,tphRetType);
|
||||
constraintsSet.addUndConstraint(
|
||||
new Pair(lambdaExpression.getType(),
|
||||
new FunN(lambdaParams),PairOperator.EQUALSDOT));
|
||||
@ -185,6 +186,12 @@ public class TYPEStmt implements StatementVisitor{
|
||||
}
|
||||
|
||||
private final RefType number = new RefType(ASTFactory.createClass(Number.class).getClassName(), new NullToken());
|
||||
private final RefType longg = new RefType(ASTFactory.createClass(Long.class).getClassName(), new NullToken());
|
||||
private final RefType integer = new RefType(ASTFactory.createClass(Integer.class).getClassName(), new NullToken());
|
||||
private final RefType shortt = new RefType(ASTFactory.createClass(Short.class).getClassName(), new NullToken());
|
||||
private final RefType bytee = new RefType(ASTFactory.createClass(Byte.class).getClassName(), new NullToken());
|
||||
private final RefType floatt = new RefType(ASTFactory.createClass(Float.class).getClassName(), new NullToken());
|
||||
private final RefType doublee = new RefType(ASTFactory.createClass(Double.class).getClassName(), new NullToken());
|
||||
private final RefType string = new RefType(ASTFactory.createClass(String.class).getClassName(), new NullToken());
|
||||
private final RefType bool = new RefType(ASTFactory.createClass(Boolean.class).getClassName(), new NullToken());
|
||||
@Override
|
||||
@ -205,18 +212,47 @@ public class TYPEStmt implements StatementVisitor{
|
||||
|
||||
@Override
|
||||
public void visit(BinaryExpr binary) {
|
||||
|
||||
binary.lexpr.accept(this);
|
||||
binary.rexpr.accept(this);
|
||||
if(binary.operation.equals(BinaryExpr.Operator.DIV) ||
|
||||
binary.operation.equals(BinaryExpr.Operator.MUL)||
|
||||
binary.operation.equals(BinaryExpr.Operator.MOD)||
|
||||
binary.operation.equals(BinaryExpr.Operator.ADD)){
|
||||
Set<Constraint> numericAdditionOrStringConcatenation = new HashSet<>();
|
||||
Constraint<Pair> numeric = new Constraint<>();
|
||||
Set<Constraint<Pair>> numericAdditionOrStringConcatenation = new HashSet<>();
|
||||
|
||||
//Zuerst der Fall für Numerische AusdrücPairOpnumericeratorke, das sind Mul, Mod und Div immer:
|
||||
//see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
|
||||
//Expression muss zu Numeric Convertierbar sein. also von Numeric erben
|
||||
numeric.add(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
|
||||
Constraint<Pair> numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numericAdditionOrStringConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numericAdditionOrStringConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numericAdditionOrStringConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), longg, PairOperator.SMALLERDOT));
|
||||
numericAdditionOrStringConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), floatt, PairOperator.SMALLERDOT));
|
||||
numericAdditionOrStringConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), doublee, PairOperator.SMALLERDOT));
|
||||
numericAdditionOrStringConcatenation.add(numeric);
|
||||
/*
|
||||
In Java passiert bei den binären Operatoren eine sogenannte Type Promotion:
|
||||
https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2
|
||||
@ -237,10 +273,54 @@ public class TYPEStmt implements StatementVisitor{
|
||||
binary.operation.equals(BinaryExpr.Operator.BIGGEREQUAL) ||
|
||||
binary.operation.equals(BinaryExpr.Operator.BIGGERTHAN) ||
|
||||
binary.operation.equals(BinaryExpr.Operator.LESSTHAN)){
|
||||
constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
|
||||
constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
|
||||
/* //eingefuegt PL 2018-05-24
|
||||
Set<Constraint<Pair>> numericRelationConcatenation = new HashSet<>();
|
||||
Constraint<Pair> numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
|
||||
numericRelationConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
|
||||
numericRelationConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
|
||||
numericRelationConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
|
||||
numericRelationConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
|
||||
numericRelationConcatenation.add(numeric);
|
||||
numeric = new Constraint<>();
|
||||
numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
|
||||
numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
|
||||
numericRelationConcatenation.add(numeric);
|
||||
|
||||
//***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
|
||||
constraintsSet.addOderConstraint(numericRelationConcatenation);
|
||||
//***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
|
||||
*/
|
||||
//Testeise eingefuegt PL 2018-05-24
|
||||
constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERNEQDOT));
|
||||
constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERNEQDOT));
|
||||
//Rückgabetyp ist Boolean
|
||||
constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
|
||||
constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.SMALLERDOT));
|
||||
|
||||
//auskommentiert PL 2018-05-24
|
||||
//constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
|
||||
//constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
|
||||
//Rückgabetyp ist Boolean
|
||||
//constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
|
||||
}else{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
@ -248,7 +328,16 @@ public class TYPEStmt implements StatementVisitor{
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
//Nothing to do here. Literale erzeugen keine Constraints
|
||||
//Nothing to do here. Literale erzeugen keine Constraints
|
||||
//PL 2018-06-23 Sie haben einen Typ. Der muesste hier eingefuegt werden
|
||||
//wie hier fuer double gezeigt. Im Momment auskommentiert, weil zu wenige Literaltypen
|
||||
//funktionieren
|
||||
//if (literal.value instanceof Double) {
|
||||
// constraintsSet.addUndConstraint(new Pair(literal.getType(), doublee, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
//else {
|
||||
// throw new NotImplementedException();
|
||||
//}
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -372,11 +461,14 @@ public class TYPEStmt implements StatementVisitor{
|
||||
List<MethodAssumption> ret = new ArrayList<>();
|
||||
//TODO: apply Methoden wieder anfügen. Diese könnten möglicherweise auch in den Assumptions auftauchen (überdenken)
|
||||
if(name.equals("apply")){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
|
||||
List<GenericRefType> funNParams = new ArrayList<>();
|
||||
for(int i = 0; i< numArgs + 1 ; i++){
|
||||
funNParams.add(TypePlaceholder.fresh(new NullToken()));
|
||||
//funNParams.add(TypePlaceholder.fresh(new NullToken()));
|
||||
funNParams.add(new GenericRefType(NameGenerator.makeNewName(),
|
||||
new NullToken()));
|
||||
}
|
||||
ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size()),
|
||||
funNParams.get(funNParams.size()-1);
|
||||
ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size()-1), funNParams.subList(0, funNParams.size()-1),
|
||||
new TypeScope() {
|
||||
@Override
|
||||
public Iterable<? extends GenericTypeVar> getGenerics() {
|
||||
@ -419,7 +511,7 @@ public class TYPEStmt implements StatementVisitor{
|
||||
*/
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
|
||||
for(FormalParameter fp : parameterList.getFormalparalist()){
|
||||
params.add(info.checkGTV(fp.getType()));
|
||||
params.add(fp.getType()); //info.checkGTV(fp.getType())); //PL 2018-06-22 GTV sollen in Argumenten erhalten bleiben
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
@ -94,7 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
|
||||
// SUBST - Rule
|
||||
if(lhsType instanceof PlaceholderType) {
|
||||
mgu.add((PlaceholderType) lhsType, rhsType);
|
||||
termsList = termsList.stream().map(mgu::apply).collect(Collectors.toCollection(ArrayList::new));
|
||||
//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
|
||||
termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
|
||||
idx = idx+1 == termsList.size() ? 0 : idx+1;
|
||||
continue;
|
||||
}
|
||||
|
@ -24,13 +24,27 @@ import de.dhbwstuttgart.typeinference.unify.model.Unifier;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
|
||||
import de.dhbwstuttgart.typeinference.unify.distributeVariance;
|
||||
|
||||
import java.io.FileWriter;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Implementation of the type inference rules.
|
||||
* @author Florian Steurer
|
||||
*
|
||||
*/
|
||||
public class RuleSet implements IRuleSet{
|
||||
public class RuleSet implements IRuleSet{
|
||||
|
||||
FileWriter logFile;
|
||||
|
||||
RuleSet() {
|
||||
super();
|
||||
}
|
||||
|
||||
RuleSet(FileWriter logFile) {
|
||||
this.logFile = logFile;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Optional<UnifyPair> reduceUp(UnifyPair pair) {
|
||||
@ -47,7 +61,7 @@ public class RuleSet implements IRuleSet{
|
||||
return Optional.empty();
|
||||
|
||||
// Rule is applicable, unpack the SuperType
|
||||
return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT));
|
||||
return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -65,7 +79,7 @@ public class RuleSet implements IRuleSet{
|
||||
return Optional.empty();
|
||||
|
||||
// Rule is applicable, unpack the ExtendsType
|
||||
return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT));
|
||||
return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -83,7 +97,7 @@ public class RuleSet implements IRuleSet{
|
||||
return Optional.empty();
|
||||
|
||||
// Rule is applicable, unpack both sides
|
||||
return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT));
|
||||
return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -117,7 +131,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(x instanceof ExtendsType)
|
||||
xFromFc = new ExtendsType(xFromFc);
|
||||
|
||||
UnifyType extYFromFc = fc.grArg(xFromFc).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
|
||||
UnifyType extYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
|
||||
|
||||
if(extYFromFc == null || extYFromFc.getTypeParams() != xFromFc.getTypeParams())
|
||||
return Optional.empty();
|
||||
@ -133,7 +147,7 @@ public class RuleSet implements IRuleSet{
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
|
||||
for(int rhsIdx = 0; rhsIdx < extYParams.size(); rhsIdx++)
|
||||
result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
|
||||
result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
@ -169,7 +183,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(x instanceof SuperType)
|
||||
xFromFc = new SuperType(xFromFc);
|
||||
|
||||
UnifyType supYFromFc = fc.grArg(xFromFc).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
|
||||
UnifyType supYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
|
||||
|
||||
if(supYFromFc == null || supYFromFc.getTypeParams() != xFromFc.getTypeParams())
|
||||
return Optional.empty();
|
||||
@ -184,7 +198,7 @@ public class RuleSet implements IRuleSet{
|
||||
return Optional.empty();
|
||||
|
||||
for(int rhsIdx = 0; rhsIdx < supYParams.size(); rhsIdx++)
|
||||
result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC));
|
||||
result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
@ -215,7 +229,7 @@ public class RuleSet implements IRuleSet{
|
||||
TypeParams rhsTypeParams = rhsType.getTypeParams();
|
||||
|
||||
for(int i = 0; i < lhsTypeParams.size(); i++)
|
||||
result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
@ -236,19 +250,53 @@ public class RuleSet implements IRuleSet{
|
||||
ReferenceType lhsSType = (ReferenceType) c;
|
||||
ReferenceType rhsSType = (ReferenceType) d;
|
||||
|
||||
//try {
|
||||
// logFile.write("PAIR Rules: " + pair + "\n");
|
||||
// logFile.flush();
|
||||
//}
|
||||
//catch (IOException e) { }
|
||||
|
||||
if(lhsSType.getTypeParams().empty() || lhsSType.getTypeParams().size() != rhsSType.getTypeParams().size())
|
||||
return Optional.empty();
|
||||
|
||||
UnifyType cFromFc = fc.getLeftHandedType(c.getName()).orElse(null);
|
||||
//2018-02-23: liefert Vector<Vector<Integer>>: Das kann nicht sein.
|
||||
|
||||
//NOCHMAL UEBERPRUEFEN
|
||||
//PL 18-02-09 Eingfuegt Anfang
|
||||
//C und D koennen auch gleich sein.
|
||||
if (c.getName().equals(d.getName())) {
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
TypeParams rhsTypeParams = d.getTypeParams();
|
||||
TypeParams lhsTypeParams = c.getTypeParams();
|
||||
for(int rhsIdx = 0; rhsIdx < c.getTypeParams().size(); rhsIdx++)
|
||||
result.add(new UnifyPair(lhsTypeParams.get(rhsIdx), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
//PL 18-02-09 Eingfuegt ENDE
|
||||
|
||||
//try {
|
||||
// logFile.write("cFromFc: " + cFromFc);
|
||||
// logFile.flush();
|
||||
//}
|
||||
//catch (IOException e) { }
|
||||
|
||||
if(cFromFc == null || !cFromFc.getTypeParams().arePlaceholders())
|
||||
return Optional.empty();
|
||||
|
||||
UnifyType dFromFc = fc.getAncestors(cFromFc).stream().filter(x -> x.getName().equals(d.getName())).findAny().orElse(null);
|
||||
|
||||
//try {
|
||||
// logFile.write("cFromFc: " + cFromFc);
|
||||
// logFile.flush();
|
||||
//}
|
||||
//catch (IOException e) { }
|
||||
|
||||
if(dFromFc == null || !dFromFc.getTypeParams().arePlaceholders() || dFromFc.getTypeParams().size() != cFromFc.getTypeParams().size())
|
||||
return Optional.empty();
|
||||
|
||||
//System.out.println("cFromFc: " + cFromFc);
|
||||
//System.out.println("dFromFc: " + dFromFc);
|
||||
int[] pi = pi(cFromFc.getTypeParams(), dFromFc.getTypeParams());
|
||||
|
||||
if(pi.length == 0)
|
||||
@ -259,7 +307,7 @@ public class RuleSet implements IRuleSet{
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
|
||||
for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
|
||||
result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
|
||||
result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
@ -314,16 +362,31 @@ public class RuleSet implements IRuleSet{
|
||||
TypeParams rhsTypeParams = rhsSType.getTypeParams();
|
||||
TypeParams lhsTypeParams = lhsSType.getTypeParams();
|
||||
for(int i = 0; i < rhsTypeParams.size(); i++)
|
||||
result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean erase1(UnifyPair pair, IFiniteClosure fc) {
|
||||
if(pair.getPairOp() != PairOperator.SMALLERDOT)
|
||||
if((pair.getPairOp() != PairOperator.SMALLERDOT) && (pair.getPairOp() != PairOperator.SMALLERNEQDOT))
|
||||
return false;
|
||||
|
||||
if (pair.getPairOp() == PairOperator.SMALLERNEQDOT) {
|
||||
UnifyType lhs = pair.getLhsType();
|
||||
UnifyType rhs = pair.getRhsType();
|
||||
if (lhs instanceof WildcardType) {
|
||||
lhs = ((WildcardType)lhs).getWildcardedType();
|
||||
}
|
||||
if (rhs instanceof WildcardType) {
|
||||
rhs = ((WildcardType)rhs).getWildcardedType();
|
||||
}
|
||||
|
||||
if (lhs.equals(rhs)){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
if(!(lhsType instanceof ReferenceType) && !(lhsType instanceof PlaceholderType))
|
||||
return false;
|
||||
@ -332,7 +395,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(rhsType instanceof ReferenceType) && !(rhsType instanceof PlaceholderType))
|
||||
return false;
|
||||
|
||||
return fc.greater(lhsType).contains(rhsType);
|
||||
return fc.greater(lhsType, new HashSet<>()).contains(rhsType);
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -343,7 +406,7 @@ public class RuleSet implements IRuleSet{
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
|
||||
return fc.grArg(lhsType).contains(rhsType);
|
||||
return fc.grArg(lhsType, new HashSet<>()).contains(rhsType);
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -365,7 +428,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(pair.getRhsType() instanceof PlaceholderType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT));
|
||||
return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -407,11 +470,19 @@ public class RuleSet implements IRuleSet{
|
||||
TypeParams typeDParams = typeD.getTypeParams();
|
||||
TypeParams typeDgenParams = typeDgen.getTypeParams();
|
||||
|
||||
//System.out.println("Pair: " +pair);
|
||||
//System.out.println("typeD: " +typeD);
|
||||
//System.out.println("typeDParams: " +typeDParams);
|
||||
//System.out.println("typeDgen: " +typeD);
|
||||
//System.out.println("typeDgenParams: " +typeDgenParams);
|
||||
Unifier unif = Unifier.identity();
|
||||
for(int i = 0; i < typeDParams.size(); i++)
|
||||
for(int i = 0; i < typeDParams.size(); i++) {
|
||||
//System.out.println("ADAPT" +typeDgenParams);
|
||||
if (typeDgenParams.get(i) instanceof PlaceholderType)
|
||||
unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
|
||||
|
||||
return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT));
|
||||
else System.out.println("ERROR");
|
||||
}
|
||||
return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -441,7 +512,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(typeDgen == null)
|
||||
return Optional.empty();
|
||||
|
||||
Set<UnifyType> grArg = fc.grArg(typeDgen);
|
||||
Set<UnifyType> grArg = fc.grArg(typeDgen, new HashSet<>());
|
||||
|
||||
Optional<UnifyType> opt = grArg.stream().filter(x -> x.getName().equals(typeExtDs.getName())).findAny();
|
||||
|
||||
@ -457,7 +528,7 @@ public class RuleSet implements IRuleSet{
|
||||
for(int i = 1; i < typeDParams.size(); i++)
|
||||
unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
|
||||
|
||||
return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC));
|
||||
return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -487,7 +558,7 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
// Use of smArg instead of grArg because
|
||||
// a in grArg(b) => b in smArg(a)
|
||||
Set<UnifyType> smArg = fc.smArg(typeSupDgen);
|
||||
Set<UnifyType> smArg = fc.smArg(typeSupDgen, new HashSet<>());
|
||||
opt = smArg.stream().filter(x -> x.getName().equals(typeDs.getName())).findAny();
|
||||
|
||||
if(!opt.isPresent())
|
||||
@ -509,7 +580,7 @@ public class RuleSet implements IRuleSet{
|
||||
for(int i = 1; i < typeDParams.size(); i++)
|
||||
unif.add((PlaceholderType) typeSupDsgenParams.get(i), typeDParams.get(i));
|
||||
|
||||
return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC));
|
||||
return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -581,8 +652,8 @@ public class RuleSet implements IRuleSet{
|
||||
&& typeMap.get(lhsType) > 1 // The type occurs in more pairs in the set than just the recent pair.
|
||||
&& !rhsType.getTypeParams().occurs(lhsType)) {
|
||||
Unifier uni = new Unifier(lhsType, rhsType);
|
||||
result = result.stream().map(uni::apply).collect(Collectors.toCollection(ArrayList::new));
|
||||
result1 = result1.stream().map(uni::apply).collect(Collectors.toCollection(LinkedList::new));
|
||||
result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
|
||||
result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
|
||||
applied = true;
|
||||
}
|
||||
|
||||
@ -602,7 +673,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(lhsType instanceof ExtendsType) || !(rhsType instanceof ExtendsType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT));
|
||||
return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -615,7 +686,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof ExtendsType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT));
|
||||
return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -628,7 +699,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(lhsType instanceof SuperType) || !(rhsType instanceof SuperType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT));
|
||||
return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -641,9 +712,11 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof SuperType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC));
|
||||
return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
/* PL 2018-03-06 auskommentiert sind mutmaßlich falsch
|
||||
* vgl. JAVA_BSP/Wildcard6.java
|
||||
@Override
|
||||
public Optional<UnifyPair> reduceWildcardLowUp(UnifyPair pair) {
|
||||
if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
|
||||
@ -670,6 +743,7 @@ public class RuleSet implements IRuleSet{
|
||||
return Optional.of(new UnifyPair(((SuperType) lhsType).getSuperedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.EQUALSDOT));
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public Optional<UnifyPair> reduceWildcardLeft(UnifyPair pair) {
|
||||
if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
|
||||
@ -686,7 +760,7 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
return Optional.empty();
|
||||
}
|
||||
|
||||
*/
|
||||
@Override
|
||||
public Optional<Set<UnifyPair>> reduceFunN(UnifyPair pair) {
|
||||
if((pair.getPairOp() != PairOperator.SMALLERDOT)
|
||||
@ -709,13 +783,19 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
Set<UnifyPair> result = new HashSet<UnifyPair>();
|
||||
|
||||
result.add(new UnifyPair(funNLhsType.getTypeParams().get(0), funNRhsType.getTypeParams().get(0), PairOperator.SMALLERDOT));
|
||||
for(int i = 1; i < funNLhsType.getTypeParams().size(); i++)
|
||||
result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT));
|
||||
|
||||
result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
|
||||
result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
result.stream().forEach(x -> { UnifyType l = x.getLhsType();
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
UnifyType r = x.getRhsType();
|
||||
if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
|
||||
} );
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public Optional<Set<UnifyPair>> greaterFunN(UnifyPair pair) {
|
||||
if(pair.getPairOp() != PairOperator.SMALLERDOT)
|
||||
@ -731,15 +811,29 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
Set<UnifyPair> result = new HashSet<UnifyPair>();
|
||||
|
||||
Integer variance = ((PlaceholderType)rhsType).getVariance();
|
||||
Integer inversVariance = distributeVariance.inverseVariance(variance);
|
||||
|
||||
UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
|
||||
for(int i = 0; i < freshPlaceholders.length; i++)
|
||||
for(int i = 0; i < freshPlaceholders.length-1; i++) {
|
||||
freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
|
||||
((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
|
||||
}
|
||||
freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
|
||||
((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
|
||||
result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
result.add(new UnifyPair(funNLhsType.getTypeParams().get(0), freshPlaceholders[0], PairOperator.SMALLERDOT));
|
||||
for(int i = 1; i < funNLhsType.getTypeParams().size(); i++)
|
||||
result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT));
|
||||
result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT));
|
||||
for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
|
||||
result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
result.stream().forEach(x -> { UnifyType l = x.getLhsType();
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
UnifyType r = x.getRhsType();
|
||||
if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
|
||||
} );
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
@ -758,15 +852,30 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
Set<UnifyPair> result = new HashSet<UnifyPair>();
|
||||
|
||||
Integer variance = ((PlaceholderType)lhsType).getVariance();
|
||||
Integer inversVariance = distributeVariance.inverseVariance(variance);
|
||||
|
||||
UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
|
||||
for(int i = 0; i < freshPlaceholders.length; i++)
|
||||
for(int i = 0; i < freshPlaceholders.length-1; i++) {
|
||||
freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
|
||||
((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
|
||||
}
|
||||
freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
|
||||
((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
|
||||
|
||||
result.add(new UnifyPair(freshPlaceholders[0], funNRhsType.getTypeParams().get(0), PairOperator.SMALLERDOT));
|
||||
for(int i = 1; i < funNRhsType.getTypeParams().size(); i++)
|
||||
result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT));
|
||||
result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(freshPlaceholders[funNRhsType.getTypeParams().size()-1], funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
for(int i = 0; i < funNRhsType.getTypeParams().size()-1; i++) {
|
||||
result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
result.stream().forEach(x -> { UnifyType l = x.getLhsType();
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
UnifyType r = x.getRhsType();
|
||||
if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
|
||||
} );
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
@ -780,7 +889,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof ReferenceType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT));
|
||||
return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -799,11 +908,11 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
if(isGen)
|
||||
result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
else {
|
||||
UnifyType freshTph = PlaceholderType.freshPlaceholder();
|
||||
result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT));
|
||||
result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
@ -825,11 +934,13 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
if(isGen)
|
||||
result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
else {
|
||||
UnifyType freshTph = PlaceholderType.freshPlaceholder();
|
||||
result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT));
|
||||
result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT));
|
||||
result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
Set<UnifyType> fBounded = pair.getfBounded();
|
||||
fBounded.add(lhsType);
|
||||
result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair(), fBounded));
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
|
@ -1,5 +1,6 @@
|
||||
package de.dhbwstuttgart.typeinference.unify;
|
||||
|
||||
import java.io.FileWriter;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ForkJoinPool;
|
||||
|
||||
@ -7,16 +8,16 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
|
||||
|
||||
public class TypeUnify {
|
||||
public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc) {
|
||||
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true);
|
||||
public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
|
||||
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true, logFile, log);
|
||||
ForkJoinPool pool = new ForkJoinPool();
|
||||
pool.invoke(unifyTask);
|
||||
Set<Set<UnifyPair>> res = unifyTask.join();
|
||||
return res;
|
||||
}
|
||||
|
||||
public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc) {
|
||||
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false);
|
||||
public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
|
||||
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false, logFile, log);
|
||||
Set<Set<UnifyPair>> res = unifyTask.compute();
|
||||
return res;
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,54 @@
|
||||
package de.dhbwstuttgart.typeinference.unify;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FunNType;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
|
||||
|
||||
public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
|
||||
|
||||
public static int inverseVariance(int variance) {
|
||||
Integer ret = 0;
|
||||
if (variance == 1) {
|
||||
ret = -1;
|
||||
}
|
||||
if (variance == -1) {
|
||||
ret = 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public PlaceholderType visit(PlaceholderType phty, Integer ht) {
|
||||
if (ht != 0) {
|
||||
if (phty.getVariance() == 0) {
|
||||
phty.setVariance(ht);
|
||||
}
|
||||
//PL 2018-05-17 urspruengliche Variance nicht veraendern
|
||||
//else if (phty.getVariance() != ht) {
|
||||
// phty.setVariance(0);
|
||||
//}
|
||||
}
|
||||
return phty;
|
||||
}
|
||||
|
||||
public FunNType visit(FunNType funnty, Integer ht) {
|
||||
List<UnifyType> param = new ArrayList<>(funnty.getTypeParams().get().length);
|
||||
param.addAll(Arrays.asList(funnty.getTypeParams().get()));
|
||||
UnifyType resultType = param.remove(param.size()-1);
|
||||
Integer htInverse = inverseVariance(ht);
|
||||
param = param.stream()
|
||||
.map(x -> x.accept(this, htInverse))
|
||||
.collect(Collectors.toCollection(ArrayList::new));
|
||||
param.add(resultType.accept(this, ht));
|
||||
return FunNType.getFunNType(new TypeParams(param));
|
||||
}
|
||||
|
||||
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user