i21012/JavaPatternMatching
1
0
Fork 0
forked from JavaTX/JavaCompilerCore
Code Pull Requests Activity

nicht lauffaehige Version

Browse Source
This commit is contained in:
Pluemicke Martin 2015-03-10 22:32:29 +01:00
parent 3d2dbc8709
commit 6a47dfaf58
7 changed files with 169 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java
View File

@ -37,7 +37,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
*/
// ino.end
// ino.attribute.bounds.26468.declaration
Vector<Type> bounds=new Vector<Type>();
Vector<ObjectType> bounds=new Vector<ObjectType>();
// ino.end
private int endOffset;
@ -54,7 +54,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
*/
// ino.method.BoundedGenericTypeVar.29409.definition
public BoundedGenericTypeVar(String s, Vector<Type> bounds, SyntaxTreeNode parentClass, int offset, int endOffset)
public BoundedGenericTypeVar(String s, Vector<ObjectType> bounds, SyntaxTreeNode parentClass, int offset, int endOffset)
// ino.end
// ino.method.BoundedGenericTypeVar.29409.body
{
@ -74,7 +74,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
}
// ino.method.getBounds.26474.definition
public Vector<Type> getBounds()
public Vector<ObjectType> getBounds()
// ino.end
// ino.method.getBounds.26474.body
{
@ -88,12 +88,14 @@ public class BoundedGenericTypeVar extends GenericTypeVar
ConstraintsSet ret = super.TYPE(ass);
//ass.addGenericVarAssumption(this);
//Die Type methode der BoundedGenericTypeVar schreibt zusätzlich noch die Constraints für die bounds
Vector<Type> tempBounds = new Vector<>();
Vector<ObjectType> tempBounds = new Vector<>();
if(this.bounds != null){
for(Type ev : this.bounds){
for(ObjectType ev : this.bounds){
ConstraintType extendsType = ass.getTypeFor(ev, this);
if(extendsType == null)throw new TypeinferenceException("Der Typ "+ev.getName()+" ist nicht korrekt", this);
tempBounds.add(extendsType.getType());
??? stimmt der Cast???
tempBounds.add((ObjectType)extendsType.getType());
//ret.add(new SingleConstraint(ass.getTypeFor(this, this), extendsType ));
}
}
@ -102,7 +104,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
}
// ino.method.addBound.26480.definition
public void addBound(Type bound)
public void addBound(ObjectType bound)
// ino.end
// ino.method.addBound.26480.body
{

14
src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java
View File

@ -20,13 +20,13 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
public class ExtendsWildcardType extends WildcardType implements ITypeContainer, IMatchable{
private Type extendsType = null;
private ObjectType extendsType = null;
/**
* Author: Arne Lüdtke<br/>
* Standard Konstruktor für eine ExtendsWildcard
*/
public ExtendsWildcardType (int offset, Type extendsType)
public ExtendsWildcardType (int offset, ObjectType extendsType)
{
super(extendsType.getParent(), offset);
this.extendsType = extendsType;
@ -39,7 +39,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Beispiel: ? extends Integer.
* Integer wird zurückgegeben.
*/
public Type get_ExtendsType()
public ObjectType get_ExtendsType()
{
return this.extendsType;
}
@ -106,9 +106,9 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Setzt den Typ in der Wildcard
* @param T - Type to be set
*/
public void SetWildcardType(Type T)
public void SetWildcardType(ObjectType T)
{
if(T instanceof RefType)
//if(T instanceof RefType)
this.extendsType = (RefType)T;
}
@ -117,7 +117,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Das gleiche wie get_ExtendsType().
* Implementiert ITypeContainer
*/
public Type getContainedType()
public ObjectType getContainedType()
{
return this.get_ExtendsType();
}
@ -127,7 +127,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Gibt den Typen zurück, der bei einem match im Unify verwendet werden soll.
* Wird über IMatchable implementiert.
*/
public Type getMatchType()
public ObjectType getMatchType()
{
return this.get_ExtendsType();
}

2
src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java
View File

@ -30,7 +30,7 @@ import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
*/
// ino.end
// ino.class.GenericTypeVar.26505.declaration
public class GenericTypeVar extends Type
public class GenericTypeVar extends ObjectType
// ino.end
// ino.class.GenericTypeVar.26505.body
{

2
src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java
View File

@ -10,5 +10,5 @@ public abstract class ObjectType extends Type {
public ObjectType(SyntaxTreeNode parent, int offset) {
super(parent, offset);
}
public abstract Type clone();
public abstract ObjectType clone();
}

6
src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java
View File

@ -36,7 +36,7 @@ public class SuperWildcardType extends WildcardType implements ITypeContainer, I
* Beispiel: ? super Integer.
* Integer wird zurückgegeben.
*/
public Type get_SuperType()
public ObjectType get_SuperType()
{
return this.superType;
}
@ -86,9 +86,9 @@ public class SuperWildcardType extends WildcardType implements ITypeContainer, I
* Setzt den Typ in der Wildcard
* @param T - Type to be set
*/
public void SetWildcardType(Type T)
public void SetWildcardType(ObjectType T)
{
if(T instanceof RefType)
//if(T instanceof RefType)
this.superType = (RefType)T;
}

2
src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java
View File

@ -15,7 +15,7 @@ import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
*
*/
public class WildcardType extends ObjectType{
public class WildcardType extends Type{
/**
* Author: Arne Lüdtke<br/>

434
src/de/dhbwstuttgart/typeinference/unify/Unify.java
View File

@ -29,6 +29,7 @@ import de.dhbwstuttgart.syntaxtree.type.IMatchable;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.ObjectType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.WildcardType;
import de.dhbwstuttgart.typeinference.Pair;
@ -72,181 +73,7 @@ public class Unify
}
// ino.end
// ino.method.unify.28058.definition
//public static Vector<Vector<Pair>> unify(Vector<Pair> E, FC_TTO fc_tto )
public static Vector<Vector<Pair>> unifyOld(Vector<Pair> E, FC_TTO fc_tto )
// ino.end
// ino.method.unify.28058.body
{
//HIER MUSS NICHT-UNITARY UNIFIER NOCH PROGRAMMIERT WERDEN
Vector<Pair> FC = fc_tto.getFC();
//Vector TTO = fc_tto.getTTO();
//Vector<Vector<Pair>> Eq_set = new Vector<Vector<Pair>>();
Vector<Pair> Eq_11 = new Vector<Pair> ();
Vector<Pair> Eq_12 = new Vector<Pair> ();
Vector<Vector<Vector<Pair>>> sm_set = new Vector<Vector<Vector<Pair>>>();
Vector<Vector<Vector<Pair>>> gr_set = new Vector<Vector<Vector<Pair>>>();
Vector<Vector<Vector<Pair>>> bound_set = new Vector<Vector<Vector<Pair>>>();
//1./2. Schritt (smaller und greater Set bilden)
for( int i = 0; i < E.size(); i++ )
{
Pair P = E.elementAt(i);
inferencelog.debug("");
inferencelog.debug("");
inferencelog.debug("Ausgew�hltes Paar = " + P.toString() + "");
inferencelog.debug( "--------------------------------------------------");
if ( P.TA1 instanceof TypePlaceholder && P.TA2 instanceof RefType && P.OperatorSmaller())
{
//1. Schritt (smaller)
Vector<Vector<Pair>> setofsetofpairs= instanceSmaller(P, fc_tto);
//sm_set = setofsetofpairs; // Urspruenglich
sm_set.addElement(setofsetofpairs); // PL
}
else if ( (P.TA1 instanceof RefType || P.TA1 instanceof BoundedGenericTypeVar) && P.TA2 instanceof TypePlaceholder && P.OperatorSmaller())
{
//2. Schritt (greater)
//IST KEIN MATCH IN DER FUNKTION allGreater NOETIG
Vector<RefType> gr;
if (P.TA1 instanceof RefType)
gr = allGreater((RefType)P.TA1, FC);
else
gr = allGreater((BoundedGenericTypeVar)P.TA1, FC);
Vector<Pair> setofpairs = new Vector<Pair> ();
setofpairs.addElement(new Pair(P.TA2, P.TA1, PairOperator.Equal)); //Reflexivitaet
Vector<Vector<Pair>> setofsetofpairs = new Vector<Vector<Pair>>();
setofsetofpairs.addElement(setofpairs);
for (int ii = 0; ii < gr.size(); ii++)
{
setofpairs = new Vector<Pair> ();
setofpairs.addElement(new Pair(P.TA2, gr.elementAt(ii), PairOperator.Equal));
setofsetofpairs.addElement(setofpairs);
}
gr_set.addElement(setofsetofpairs);
}
else if ( P.TA1 instanceof TypePlaceholder && P.TA2 instanceof TypePlaceholder && P.OperatorSmaller())
{
//WAS PASSIERT MIT EINE PAAR HIER DRIN BLEIBT???
Eq_12.addElement(P);
printMenge("Eq_12", Eq_12, 6);
//inferencelog.debug(P.OperatorEqual());
}
else if (P.TA1 instanceof BoundedGenericTypeVar && P.TA2 instanceof RefType)
{ //PL 06-06-13
Vector<Type> bounds = ((BoundedGenericTypeVar)(P.TA1)).getBounds();
Vector<Vector<Pair>> setofsetofpairs = new Vector<Vector<Pair>>();
for (int ii = 0; ii < bounds.size(); ii++)
{
Vector<Pair> setofpairs = new Vector<Pair> ();
setofpairs.addElement(new Pair(bounds.elementAt(ii), P.TA2));
setofsetofpairs.addElement(setofpairs);
}
bound_set.addElement(setofsetofpairs);
}
else
{ //P.TA1 instanceof RefType && P.TA2 instanceof RefType
Eq_11.addElement(P);
printMenge("Eq_11", Eq_11, 6);
}
//ret.addElement(sub_unify(E, FC));
}
//3. Schritt, kartesisches Produkt
Vector<Pair> helpvp;
Vector<Vector<Pair>> newvecvecpair1 = new Vector<Vector<Pair>>();
//notwendig damit die naechste for-Schleife (ii) auf alle Faelle
//mindestens einmal durchlaufen wird.
//if (sm_set.size() == 0) sm_set.addElement(new Vector<Pair>());
//korregiert PL 06-05-12
Vector<Vector<Vector<Pair>>> Eq_2expand = sm_set;
Eq_2expand.addAll(gr_set); //kleinere und groessere Elemente zusammengefasst
Eq_2expand.addAll(bound_set); //bounds werden auch hinzugefuegt //PL 06-06-13
newvecvecpair1.addElement(copyVectorPair(Eq_11));
for (int ii = 0; ii < Eq_2expand.size(); ii++) {
Vector<Vector<Pair>> OneE_Element = Eq_2expand.elementAt(ii);
Vector<Vector<Pair>> newvecvecpair1old = newvecvecpair1;
newvecvecpair1 = new Vector<Vector<Pair>>();
for(int iii=0; iii< OneE_Element.size(); iii++) {
for(int k = 0; k < newvecvecpair1old.size(); k++) {
helpvp = copyVectorPair(newvecvecpair1old.elementAt(k));
helpvp.addAll(copyVectorPair(OneE_Element.elementAt(iii)));
newvecvecpair1.addElement(helpvp);
}
}
}
//groessere Elemente auskommentiert PL 06-05-12
// Vector<Vector<Pair>> helpvp2;
Vector<Vector<Pair>> newvecvecpair2 = newvecvecpair1; //new Vector<Vector<Pair>>();
// for (int ii = 0; ii < newvecvecpair1.size(); ii++) {
// Vector<Pair> OneUnifier = newvecvecpair1.elementAt(ii);
// //notwendig damit die naechste for-Schleife (jj) auf alle Faelle
// //mindestens einmal durchlaufen wird.
// //if (gr_set.size() == 0) gr_set.addElement(new Vector<Pair> ());
// if (gr_set.size() == 0) newvecvecpair2.addElement(OneUnifier);
// for (int jj = 0; jj < gr_set.size(); jj++) {
// Vector<Vector<Pair>> OneE_Element = gr_set.elementAt(ii);
// for(int jjj = 0; jjj< OneE_Element.size(); jjj++) {
// helpvp = copyVectorPair(OneUnifier);
// inferencelog.debug(gr_set);
// helpvp.addAll(copyVectorPair(OneE_Element.elementAt(jjj)));
// newvecvecpair2.addElement(helpvp);
// }
// }
// }
Vector<Vector<Pair>> newvecvecpair3 = new Vector<Vector<Pair>>();
//Vector<Vector<Pair>> rek = new Vector<Vector<Pair>>();
//Vector<Vector<Pair>> ret = new Vector<Vector<Pair>>();
for (int kk = 0; kk < newvecvecpair2.size(); kk++) {
//newvecvecpair3.addElement(sub_unify(newvecvecpair2.elementAt(kk), FC));
printMenge("Sigma_alt", newvecvecpair2.elementAt(kk), 6);
//4. Schritt
Vector<Pair> sigma = sub_unify(newvecvecpair2.elementAt(kk), fc_tto);
//5, Schritt
if (hasSolvedForm(sigma)) //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert.
{
Hashtable ht = VectorPair2SubstHashtableVectorPair(sigma);
Type r1;
Type r2;
boolean ready = true;
for(int ll = 0; ll < Eq_12.size(); ll++) {
r1 = (Type)ht.get(Eq_12.elementAt(ll).TA1.getName());
r2 = (Type)ht.get(Eq_12.elementAt(ll).TA2.getName());
if (r1 == null) r1 = Eq_12.elementAt(ll).TA1;
else ready = false;
if (r2 == null) r2 = Eq_12.elementAt(ll).TA2;
else ready = false;
sigma.addElement(new Pair(r1, r2));
}
//inferencelog.debug(ready);
if (!ready) {
printMenge("Sigma", sigma, 6);
//6. Schritt (a)
//7. Schritt (addAll)
newvecvecpair3.addAll(unify(sigma, fc_tto));
printMengeUnifier("newvecvecpair3_alt", newvecvecpair3, 6);
}
else {
//6. Schritt (b)
newvecvecpair3.addElement(sigma);
}
}
}
return newvecvecpair3;
}
// ino.end
/**
* Einstieg in die Unifizierung mit Wildcards
*
@ -303,6 +130,7 @@ public class Unify
else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder))
{
//Diese Paare können nicht mehr Unifiziert werden. fail.
inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " muesste mindestens einen TPH enthalten.");
return new Vector<Vector<Pair>>();
}
}
@ -346,10 +174,10 @@ public class Unify
{
RefType tmp = ((RefType)p_fc.TA2).clone(); //Unifikation vorgezogen, da isRXSimilarRY nicht ausreicht PL 07-07-29
CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder();
Vector<Type> greater1elemente;
Vector<ObjectType> greater1elemente;
if (tmp.get_ParaList() == null)
{
greater1elemente = new Vector<Type>(); //Bei Konstanten liefert greater1 [] zurueck
greater1elemente = new Vector<ObjectType>(); //Bei Konstanten liefert greater1 [] zurueck
greater1elemente.add(tmp);
}
else
@ -387,10 +215,10 @@ public class Unify
//doppelte Elemente rein
//Anfang
Vector<Type> smallers = new Vector<Type>();
Vector<Type> smaller1elemente;
Vector<ObjectType> smaller1elemente;
if (p_fc_TA1_new.get_ParaList() == null)
{
smaller1elemente = new Vector<Type>(); //Bei Konstanten liefert smaller1 [] zurueck
smaller1elemente = new Vector<ObjectType>(); //Bei Konstanten liefert smaller1 [] zurueck
smaller1elemente.add(p_fc_TA1_new);
}
else
@ -453,7 +281,7 @@ public class Unify
Stream<Vector<Pair>> strextergMenge1 =
ergMenge1.stream().map(v ->
v.stream().map(pa ->
new Pair(pa.getTA1Copy(), new ExtendsWildcardType(pa.getTA2Copy().getOffset(), pa.getTA2Copy()), pa.GetOperator(), pa.bSubst)
new Pair(pa.getTA1Copy(), new ExtendsWildcardType(pa.getTA2Copy().getOffset(), (ObjectType)pa.getTA2Copy()), pa.GetOperator(), pa.bSubst)
).collect(Vector::new, Vector::add, Vector::addAll));
Vector<Vector<Pair>> extergMenge1 = strextergMenge1.collect(Vector::new, Vector::add, Vector::addAll);
@ -484,10 +312,10 @@ public class Unify
{
RefType tmp = ((RefType)p_fc.TA2).clone(); //Unifikation vorgezogen, da isRXSimilarRY nicht ausreicht PL 07-07-29
CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder();
Vector<Type> greater1elemente;
Vector<ObjectType> greater1elemente;
if (tmp.get_ParaList() == null)
{
greater1elemente = new Vector<Type>(); //Bei Konstanten liefert greater1 [] zurueck
greater1elemente = new Vector<ObjectType>(); //Bei Konstanten liefert greater1 [] zurueck
greater1elemente.add(tmp);
}
else
@ -525,10 +353,10 @@ public class Unify
//doppelte Elemente rein
//Anfang
Vector<Type> smallers = new Vector<Type>();
Vector<Type> smaller1elemente;
Vector<ObjectType> smaller1elemente;
if (p_fc_TA1_new.get_ParaList() == null)
{
smaller1elemente = new Vector<Type>(); //Bei Konstanten liefert smaller1 [] zurueck
smaller1elemente = new Vector<ObjectType>(); //Bei Konstanten liefert smaller1 [] zurueck
smaller1elemente.add(p_fc_TA1_new);
}
else
@ -536,7 +364,7 @@ public class Unify
smaller1elemente = smaller1(p_fc_TA1_new, fc_tto);
}
for(Type smele : smaller1elemente)
for(ObjectType smele : smaller1elemente)
{
smallers.add(smele);
smallers.add(new ExtendsWildcardType(smele.getOffset(), smele).clone());
@ -608,6 +436,8 @@ public class Unify
}
else {
//kein programmierter Fall konnte angewandt werden. PL 15-03-05
//z.B. TPH <. ? extends Ty
inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " Ty wurde kein Fall gefunden");
return new Vector<Vector<Pair>>();
}
}
@ -617,7 +447,7 @@ public class Unify
{
//5. Menge
//Greater auf den Typen bilden, und mit den Ergebnissen neue Paare bilden.
Vector<Type> grErg = greater(p.TA1,fc_tto);
Vector<ObjectType> grErg = greater((ObjectType)p.TA1,fc_tto);
cartProduktSets.add(generateSetOfSetOfPair(p.TA2,grErg));
}
else if(p.OperatorSmallerExtends())
@ -642,10 +472,10 @@ public class Unify
{
RefType tmp = ((RefType)p_fc.TA2).clone(); //Unifikation vorgezogen, da isRXSimilarRY nicht ausreicht PL 07-07-29
CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder();
Vector<Type> greater1elemente;
Vector<ObjectType> greater1elemente;
if (tmp.get_ParaList() == null)
{
greater1elemente = new Vector<Type>(); //Bei Konstanten liefert greater1 [] zurueck
greater1elemente = new Vector<ObjectType>(); //Bei Konstanten liefert greater1 [] zurueck
greater1elemente.add(tmp);
}
else
@ -682,11 +512,11 @@ public class Unify
//smallerArg ersetz durch folgende Zeilen. Durch Transistivitaet von fc kommen sonst
//doppelte Elemente rein
//Anfang
Vector<Type> smallers = new Vector<Type>();
Vector<Type> smaller1elemente;
Vector<ObjectType> smallers = new Vector<ObjectType>();
Vector<ObjectType> smaller1elemente;
if (p_fc_TA1_new.get_ParaList() == null)
{
smaller1elemente = new Vector<Type>(); //Bei Konstanten liefert smaller1 [] zurueck
smaller1elemente = new Vector<ObjectType>(); //Bei Konstanten liefert smaller1 [] zurueck
smaller1elemente.add(p_fc_TA1_new);
}
else
@ -694,7 +524,7 @@ public class Unify
smaller1elemente = smaller0(p_fc_TA1_new, fc_tto); //Von Menge 2 kopiert und smaller1 durch smaller0 ersetzt, Luar 07-08-08
}
for(Type smele : smaller1elemente)
for(ObjectType smele : smaller1elemente)
{
smallers.add(smele);
//smallers.add(new ExtendsWildcardType(smele.getOffset(), smele).clone()); //Auskommentiert luar 07-08-08
@ -719,7 +549,7 @@ public class Unify
//Mit den kleineren Typen neue Paare bilden, linke Seite Klonen.
Vector<Pair> smallerPairs = new Vector<Pair>();
for(Type sT : smallers)
for(ObjectType sT : smallers)
{
smallerPairs.add(new Pair(p.TA2.clone(),new SuperWildcardType(sT.getOffset(),sT),PairOperator.Equal));
}
@ -755,6 +585,7 @@ public class Unify
}
else {
//kein programmierter Fall konnte angewandt werden. PL 15-03-05
inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " Ty wurde kein Fall gefunden");
return new Vector<Vector<Pair>>();
}
}
@ -987,7 +818,7 @@ public class Unify
* @param otherPairTypes - Die anderen Typen
* @return - Ein Vector<Vector<Pair>> der alle Paare enthält.
*/
private static Vector<Vector<Pair>> generateSetOfSetOfPair(Type TA1, Vector<Type> otherPairTypes)
private static Vector<Vector<Pair>> generateSetOfSetOfPair(Type TA1, Vector<? extends Type> otherPairTypes)
{
Vector<Vector<Pair>> setofsetofpairs = new Vector<Vector<Pair>>();
for(Type t : otherPairTypes)
@ -1228,7 +1059,8 @@ throws MatchException
{
if((P.TA2 instanceof RefType) == false || ((RefType)P.TA2).get_ParaList() == null)
{
Vector<Type> greaters = greater(P.TA1,fc_tto);
Vector<ObjectType> greaters = greater((ObjectType)P.TA1,fc_tto);
//Ist ObjectType weil P.OperatorSmaller, kann kein Wildcard sein
//System.out.println(P.TA2.toString());
// "P.TA2.toString() != null" angefügt von Andreas Stadelmeier a10023
@ -1408,36 +1240,41 @@ throws MatchException
//erledigt 15-02-03
if(P.OperatorEqual())
{
//PL 15-02-08 bisher mit keinem Beispiel getestet
if(P.TA1 instanceof WildcardType && ((WildcardType)P.TA1).GetWildcardType() instanceof TypePlaceholder
&& (P.TA2 instanceof GenericTypeVar || P.TA2 instanceof RefType))
{
H.add(new Pair(((WildcardType)P.TA1).GetWildcardType(),P.TA2, PairOperator.Equal));
bRegel = true;
continue;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//PL 15-03-05: Ich halte dies fuer falsch
////PL 15-02-08 bisher mit keinem Beispiel getestet
//if(P.TA1 instanceof WildcardType && ((WildcardType)P.TA1).GetWildcardType() instanceof TypePlaceholder
//&& (P.TA2 instanceof GenericTypeVar || P.TA2 instanceof RefType))
//{
//H.add(new Pair(((WildcardType)P.TA1).GetWildcardType(),P.TA2, PairOperator.Equal));
//bRegel = true;
//continue;
//}
//PL 15-02-08 bisher mit keinem Beispiel getestet
if((P.TA1 instanceof GenericTypeVar || P.TA1 instanceof RefType)
&& (P.TA2 instanceof WildcardType && ((WildcardType)P.TA2).GetWildcardType() instanceof TypePlaceholder))
{
H.add(new Pair(P.TA1, ((WildcardType)P.TA2).GetWildcardType(), PairOperator.Equal));
bRegel = true;
continue;
}
//if((P.TA1 instanceof GenericTypeVar || P.TA1 instanceof RefType)
//&& (P.TA2 instanceof WildcardType && ((WildcardType)P.TA2).GetWildcardType() instanceof TypePlaceholder))
//{
//H.add(new Pair(P.TA1, ((WildcardType)P.TA2).GetWildcardType(), PairOperator.Equal));
//bRegel = true;
//continue;
//}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wenn noetig extends-wildcards entfernen PL 15-02-03
//korrekt da P.OperatorEqual()
if(P.TA1 instanceof WildcardType)
{
P.TA1 = ((WildcardType)P.TA1).GetWildcardType();
}
if(P.TA2 instanceof WildcardType) {
P.TA2 = ((WildcardType)P.TA2).GetWildcardType();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//PL 15-03-05: Ich halte dies fuer falsch
//if(P.TA1 instanceof WildcardType)
//{
//P.TA1 = ((WildcardType)P.TA1).GetWildcardType();
//}
//if(P.TA2 instanceof WildcardType) {
//P.TA2 = ((WildcardType)P.TA2).GetWildcardType();
//}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RefType TA1 = null;
RefType TA2 = null;
@ -2230,7 +2067,7 @@ throws MatchException
// ino.method.allGreater.29428.body
{
CRefTypeSet ret = new CRefTypeSet();
Iterator<Type> typeIt = ty.getBounds().iterator();
Iterator<ObjectType> typeIt = ty.getBounds().iterator();
while(typeIt.hasNext()) {
CRefTypeSet grBounds = new CRefTypeSet();
RefType act = (RefType)typeIt.next();
@ -2943,12 +2780,13 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
* Implementiert die CaptureConversion. Wendet diese auf jeden Typ im Vector TVec an.
* Rückgabe ist ein Ergebnisvector
*/
private static Vector<Type> CaptureConversion(Vector<Type> TVec, FC_TTO fc_tto)
private static Vector<ObjectType> CaptureConversion(Vector<ObjectType> TVec, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
for(Type t : TVec)
Vector<ObjectType> retVec = new Vector<ObjectType>();
for(ObjectType t : TVec)
{
Type ccT = CaptureConversion(t,fc_tto);
ObjectType ccT = (ObjectType)CaptureConversion(t,fc_tto);
//CaptureConversion kann nur ObjectTypes zurückliefern, laesst sich aber nicht zurziehen.
if(ccT != null)
retVec.add(ccT);
}
@ -3013,12 +2851,14 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
else
return null;
}
if(T instanceof WildcardType)
{
return ((WildcardType)T).GetFreshWildcardType();
}
return null;
}
}
//Von hier an Greater implementierung 28-03-07
/**
@ -3030,12 +2870,12 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
* Erzeugt alle Typen die greater sind als T. Gibt diese zurück.
* Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
*/
private static Vector<Type> greater(Type T, FC_TTO fc_tto)
private static Vector<ObjectType> greater(ObjectType T, FC_TTO fc_tto)
//an die Aenderungen im Skript anpassen 07-11-03
{
Vector<Type> retVec = new Vector<Type>();
Vector<Type> greater0Erg = greater0(T,fc_tto);
for(Type t : greater0Erg)
Vector<ObjectType> retVec = new Vector<ObjectType>();
Vector<ObjectType> greater0Erg = greater0(T,fc_tto);
for(ObjectType t : greater0Erg)
{
if(!DelFreshWildcardTypeVar(t))
retVec.add(t);
@ -3046,31 +2886,31 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* greater0 Schritt von greater.
*/
private static Vector<Type> greater0(Type T, FC_TTO fc_tto)
private static Vector<ObjectType> greater0(ObjectType T, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
Vector<ObjectType> retVec = new Vector<ObjectType>();
//greater1 Erzeugen
Vector<Type> greater1Erg = greater1(T,fc_tto);
Vector<ObjectType> greater1Erg = greater1(T,fc_tto);
//Reflexivität, deshalb T hinzufügen.
if(!greater1Erg.contains(T))
greater1Erg.add(T);
//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec übernommen.
for(Type t : greater1Erg)
for(ObjectType t : greater1Erg)
if(!retVec.contains(t))
retVec.add(t);
//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einfügen
Vector<Type> greater2Erg = greater2(greater1Erg,fc_tto);
for(Type t : greater2Erg)
Vector<ObjectType> greater2Erg = greater2(greater1Erg,fc_tto);
for(ObjectType t : greater2Erg)
if(!retVec.contains(t))
retVec.add(t);
//Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einfügen
Vector<Type> greater3Erg = greater3(greater2Erg,fc_tto);
for(Type t : greater3Erg)
Vector<ObjectType> greater3Erg = greater3(greater2Erg,fc_tto);
for(ObjectType t : greater3Erg)
if(!retVec.contains(t))
retVec.add(t);
@ -3081,9 +2921,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
* greater1 Schritt von greater.
* Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
*/
private static Vector<Type> greater1(Type T, FC_TTO fc_tto)
private static Vector<ObjectType> greater1(ObjectType T, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
Vector<ObjectType> retVec = new Vector<ObjectType>();
if(T instanceof RefType)
{
RefType refT = (RefType)T;
@ -3110,8 +2950,8 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
else if(T instanceof BoundedGenericTypeVar) //PL 15-02-03 angefuegt da BGTV Kleiner als alle seine Bounds ist
{
BoundedGenericTypeVar bgtv = (BoundedGenericTypeVar)T;
Vector<Type> types = bgtv.getBounds();
retVec = types.stream().map(ty -> greater(ty, fc_tto)).reduce(new Vector<Type>(), (a,b) -> { a.addAll(b); return a;});
Vector<ObjectType> types = bgtv.getBounds();
retVec = types.stream().map(ty -> greater(ty, fc_tto)).reduce(new Vector<ObjectType>(), (a,b) -> { a.addAll(b); return a;});
}
return retVec;
}
@ -3205,11 +3045,10 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
}
return retVec;
}
/**
* Kopiert einen Vector<Type>. Es ist eine Deep Copy, da die Elemente auch kopiert werden.
*/
private static Vector<Type> copyVectorType(Vector<Type> vec)
private static Vector<Type> copyVectorType(Vector<? extends Type> vec)
{
Vector<Type> retVec = new Vector<Type>();
for(Type t : vec)
@ -3218,6 +3057,19 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
return retVec;
}
/**
* Kopiert einen Vector<ObjectType>. Es ist eine Deep Copy, da die Elemente auch kopiert werden.
* noetig wegen Type-Erasure
*/
private static Vector<ObjectType> copyVectorObjectType(Vector<ObjectType> vec)
{
Vector<ObjectType> retVec = new Vector<ObjectType>();
for(ObjectType t : vec)
retVec.add(t.clone());
return retVec;
}
/**
* greaterArg Schritt von greater
* Für den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt
@ -3229,18 +3081,22 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
{
//Bei einer ExtendsWildcard Rekursiv greater0 aufrufen und neue ExtendsWildcars erzeugen
ExtendsWildcardType exT = (ExtendsWildcardType)T;
Vector<Type> greaterTypes = greater0(exT.get_ExtendsType(),fc_tto);
for(Type t : greaterTypes)
Vector<ObjectType> greaterTypes = greater0(exT.get_ExtendsType(),fc_tto);
for(ObjectType t : greaterTypes)
retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone()));
}
else if(T instanceof SuperWildcardType)
{
//Bei einer SuperWildcard Rekursiv smaller0 aufrufen und neue SuperWildcards erzeugen.
SuperWildcardType suT = (SuperWildcardType)T;
Vector<Type> smallerTypes = smaller0(suT.get_SuperType(),fc_tto);
for(Type t : smallerTypes)
Vector<ObjectType> smallerTypes = smaller0(suT.get_SuperType(),fc_tto);
for(ObjectType t : smallerTypes)
retVec.add(new SuperWildcardType(t.getOffset(),t.clone()));
}
/* PL 15-03-10
* Kann meiner Ansicht nach nicht vorkommen
else if(T instanceof FreshExtendsWildcardType)
{
//Bei einer FreshExtendsWildcard greaterArg aufrufen, auf Bounds achten.
@ -3269,23 +3125,25 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
}
}
else if(T instanceof FreshSuperWildcardType)
return new Vector<Type>();
return new Vector<Type>();
*/
//Diese Abfrage sorgt für grArg(a) = {a} //Luar 07-07-31
else if(T instanceof TypePlaceholder)
retVec.add(T);
//Diese Abfrage verhindert, dass bei FunN Wildcard-Typen generiert werden //PL 13-05-22
else if((T instanceof RefType) && (T.getName().equals("FunN")))
retVec.add(T);
else
else //RefType oder GTV
{
//Bei allen anderen Typen greater0 und smaller0 aufrufen.
retVec.add(T);
Vector<Type> greaterTypes = greater0(T,fc_tto);
Vector<Type> smallerTypes = smaller0(T,fc_tto);
for(Type t : greaterTypes)
retVec.add((ObjectType)T);
Vector<ObjectType> greaterTypes = greater0((ObjectType)T,fc_tto);
Vector<ObjectType> smallerTypes = smaller0((ObjectType)T,fc_tto);
for(ObjectType t : greaterTypes)
retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone()));
for(Type t : smallerTypes)
for(ObjectType t : smallerTypes)
retVec.add(new SuperWildcardType(t.getOffset(),t.clone()));
}
return retVec;
@ -3294,9 +3152,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* greater2 Schritt von greater
*/
private static Vector<Type> greater2(Vector<Type> greater1Erg, FC_TTO fc_tto)
private static Vector<ObjectType> greater2(Vector<ObjectType> greater1Erg, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
Vector<ObjectType> retVec = new Vector<ObjectType>();
/*
* luar 02-05-07: Beschreibung der Funktion:
* Für Jeden Typ aus greater1 durch die FC laufen, und auf der Linken seite einen Match versuchen.
@ -3339,13 +3197,13 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* greater3 Schritt von greater
*/
private static Vector<Type> greater3(Vector<Type> greater2Erg, FC_TTO fc_tto)
private static Vector<ObjectType> greater3(Vector<ObjectType> greater2Erg, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
for(Type t : greater2Erg)
Vector<ObjectType> retVec = new Vector<ObjectType>();
for(ObjectType t : greater2Erg)
{
Vector<Type> greater1Erg = greater1(t,fc_tto);
for(Type tt : greater1Erg)
Vector<ObjectType> greater1Erg = greater1(t,fc_tto);
for(ObjectType tt : greater1Erg)
if(!retVec.contains(tt))
retVec.add(tt);
}
@ -3361,12 +3219,12 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* Erzeugt alle Typen die smaller sind als T. Gibt diese zurück.
*/
private static Vector<Type> smaller(Type T, FC_TTO fc_tto)
private static Vector<ObjectType> smaller(ObjectType T, FC_TTO fc_tto)
//an die Aenderungen im Skript anpassen 07-11-03
{
Vector<Type> retVec = new Vector<Type>();
Vector<Type> smaller0Erg = smaller0(T,fc_tto);
for(Type t : smaller0Erg)
Vector<ObjectType> retVec = new Vector<ObjectType>();
Vector<ObjectType> smaller0Erg = smaller0(T,fc_tto);
for(ObjectType t : smaller0Erg)
{
if(!DelFreshWildcardTypeVar(t))
retVec.add(t);
@ -3377,16 +3235,18 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* smaller0 Schritt von smaller
*/
private static Vector<Type> smaller0(Type T, FC_TTO fc_tto)
private static Vector<ObjectType> smaller0(ObjectType T, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
Vector<ObjectType> retVec = new Vector<ObjectType>();
Vector<Type> smaller1Erg = smaller1(T,fc_tto);
Vector<Type> smaller2Erg = smaller2(smaller1Erg,fc_tto);
Vector<ObjectType> smaller1Erg = smaller1(T,fc_tto);
Vector<ObjectType> smaller2Erg = smaller2(smaller1Erg,fc_tto);
//Unite von smaller 1 und 2 bilden, um dies an smaller 3 weiterzugeben.
Vector<Type> smaller12Erg = copyVectorType(smaller1Erg);
for(Type t : smaller2Erg)
Vector<ObjectType> smaller12Erg = copyVectorObjectType(smaller1Erg);
for(ObjectType t : smaller2Erg)
if(!smaller12Erg.contains(t))
smaller12Erg.add(t);
@ -3394,19 +3254,19 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
smaller12Erg.add(T);
//Ergebnise in retVec einfügen. Doppelte werden gelöscht.
for(Type t : smaller12Erg)
for(ObjectType t : smaller12Erg)
if(!retVec.contains(t))
retVec.add(t);
//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einfügen.
Vector<Type> smaller3Erg = smaller3(smaller12Erg,fc_tto);
for(Type t : smaller3Erg)
Vector<ObjectType> smaller3Erg = smaller3(smaller12Erg,fc_tto);
for(ObjectType t : smaller3Erg)
if(!retVec.contains(t))
retVec.add(t);
//Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einfügen.
Vector<Type> smaller4Erg = smaller4(smaller3Erg);
for(Type t : smaller4Erg)
Vector<ObjectType> smaller4Erg = smaller4(smaller3Erg);
for(ObjectType t : smaller4Erg)
if(!retVec.contains(t))
retVec.add(t);
@ -3416,9 +3276,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* smaller1 Schritt von smaller
*/
private static Vector<Type> smaller1(Type T, FC_TTO fc_tto)
private static Vector<ObjectType> smaller1(Type T, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
Vector<ObjectType> retVec = new Vector<ObjectType>();
if(T instanceof RefType)
{
RefType refT = (RefType)T;
@ -3455,8 +3315,8 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
{
//Für eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen.
ExtendsWildcardType exT = (ExtendsWildcardType)T;
Vector<Type> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto);
for(Type t : smallerTypes)
Vector<ObjectType> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto);
for(ObjectType t : smallerTypes)
{
retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone()));
retVec.add(t.clone());
@ -3466,8 +3326,8 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
{
//Für eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen.
SuperWildcardType suT = (SuperWildcardType)T;
Vector<Type> greaterTypes = greater0(suT.get_SuperType(),fc_tto);
for(Type t : greaterTypes)
Vector<ObjectType> greaterTypes = greater0(suT.get_SuperType(),fc_tto);
for(ObjectType t : greaterTypes)
{
retVec.add(new SuperWildcardType(-1,t.clone()));
retVec.add(t.clone());
@ -3490,7 +3350,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* smaller2 Schritt von smaller
*/
private static Vector<Type> smaller2(Vector<Type> smaller1Erg, FC_TTO fc_tto)
private static Vector<ObjectType> smaller2(Vector<ObjectType> smaller1Erg, FC_TTO fc_tto)
{
return CaptureConversion(smaller1Erg,fc_tto);
}
@ -3498,9 +3358,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* smaller3 Schritt von smaller
*/
private static Vector<Type> smaller3(Vector<Type> smaller12Erg, FC_TTO fc_tto)
private static Vector<ObjectType> smaller3(Vector<ObjectType> smaller12Erg, FC_TTO fc_tto)
{
Vector<Type> retVec = new Vector<Type>();
Vector<ObjectType> retVec = new Vector<ObjectType>();
/*
* luar 02-05-07: Beschreibung der Funktion:
* Für Jeden Typ aus Smaller12 durch die FC laufen, und auf der Rechten seite einen Match versuchen.
@ -3541,14 +3401,14 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/**
* smaller4 Schritt von smaller
*/
private static Vector<Type> smaller4(Vector<Type> smallerErg)
private static Vector<ObjectType> smaller4(Vector<ObjectType> smallerErg)
{
/* smaller4 ist die inverse CaptureConversion.
* Alle Typen in smallerErg werden durchlaufen, und evtl. gefundene
* FreshWildcardTypes werden durch die entsprechenden Wildcards ersetzt.
* */
Vector<Type> retVec = new Vector<Type>();
for(Type t : smallerErg)
Vector<ObjectType> retVec = new Vector<ObjectType>();
for(ObjectType t : smallerErg)
{
if(t instanceof RefType)
{