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.end
// ino.attribute.bounds.26468.declaration // ino.attribute.bounds.26468.declaration
Vector<Type> bounds=new Vector<Type>(); Vector<ObjectType> bounds=new Vector<ObjectType>();
// ino.end // ino.end
private int endOffset; private int endOffset;
@ -54,7 +54,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
*/ */
// ino.method.BoundedGenericTypeVar.29409.definition // 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.end
// ino.method.BoundedGenericTypeVar.29409.body // ino.method.BoundedGenericTypeVar.29409.body
{ {
@ -74,7 +74,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
} }
// ino.method.getBounds.26474.definition // ino.method.getBounds.26474.definition
public Vector<Type> getBounds() public Vector<ObjectType> getBounds()
// ino.end // ino.end
// ino.method.getBounds.26474.body // ino.method.getBounds.26474.body
{ {
@ -88,12 +88,14 @@ public class BoundedGenericTypeVar extends GenericTypeVar
ConstraintsSet ret = super.TYPE(ass); ConstraintsSet ret = super.TYPE(ass);
//ass.addGenericVarAssumption(this); //ass.addGenericVarAssumption(this);
//Die Type methode der BoundedGenericTypeVar schreibt zusätzlich noch die Constraints für die bounds //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){ if(this.bounds != null){
for(Type ev : this.bounds){ for(ObjectType ev : this.bounds){
ConstraintType extendsType = ass.getTypeFor(ev, this); ConstraintType extendsType = ass.getTypeFor(ev, this);
if(extendsType == null)throw new TypeinferenceException("Der Typ "+ev.getName()+" ist nicht korrekt", 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 )); //ret.add(new SingleConstraint(ass.getTypeFor(this, this), extendsType ));
} }
} }
@ -102,7 +104,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar
} }
// ino.method.addBound.26480.definition // ino.method.addBound.26480.definition
public void addBound(Type bound) public void addBound(ObjectType bound)
// ino.end // ino.end
// ino.method.addBound.26480.body // 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{ public class ExtendsWildcardType extends WildcardType implements ITypeContainer, IMatchable{
private Type extendsType = null; private ObjectType extendsType = null;
/** /**
* Author: Arne Lüdtke<br/> * Author: Arne Lüdtke<br/>
* Standard Konstruktor für eine ExtendsWildcard * Standard Konstruktor für eine ExtendsWildcard
*/ */
public ExtendsWildcardType (int offset, Type extendsType) public ExtendsWildcardType (int offset, ObjectType extendsType)
{ {
super(extendsType.getParent(), offset); super(extendsType.getParent(), offset);
this.extendsType = extendsType; this.extendsType = extendsType;
@ -39,7 +39,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Beispiel: ? extends Integer. * Beispiel: ? extends Integer.
* Integer wird zurückgegeben. * Integer wird zurückgegeben.
*/ */
public Type get_ExtendsType() public ObjectType get_ExtendsType()
{ {
return this.extendsType; return this.extendsType;
} }
@ -106,9 +106,9 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Setzt den Typ in der Wildcard * Setzt den Typ in der Wildcard
* @param T - Type to be set * @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; this.extendsType = (RefType)T;
} }
@ -117,7 +117,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer,
* Das gleiche wie get_ExtendsType(). * Das gleiche wie get_ExtendsType().
* Implementiert ITypeContainer * Implementiert ITypeContainer
*/ */
public Type getContainedType() public ObjectType getContainedType()
{ {
return this.get_ExtendsType(); 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. * Gibt den Typen zurück, der bei einem match im Unify verwendet werden soll.
* Wird über IMatchable implementiert. * Wird über IMatchable implementiert.
*/ */
public Type getMatchType() public ObjectType getMatchType()
{ {
return this.get_ExtendsType(); 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.end
// ino.class.GenericTypeVar.26505.declaration // ino.class.GenericTypeVar.26505.declaration
public class GenericTypeVar extends Type public class GenericTypeVar extends ObjectType
// ino.end // ino.end
// ino.class.GenericTypeVar.26505.body // 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) { public ObjectType(SyntaxTreeNode parent, int offset) {
super(parent, 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. * Beispiel: ? super Integer.
* Integer wird zurückgegeben. * Integer wird zurückgegeben.
*/ */
public Type get_SuperType() public ObjectType get_SuperType()
{ {
return this.superType; return this.superType;
} }
@ -86,9 +86,9 @@ public class SuperWildcardType extends WildcardType implements ITypeContainer, I
* Setzt den Typ in der Wildcard * Setzt den Typ in der Wildcard
* @param T - Type to be set * @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; 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/> * 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.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType; import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.ObjectType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.WildcardType; import de.dhbwstuttgart.syntaxtree.type.WildcardType;
import de.dhbwstuttgart.typeinference.Pair; import de.dhbwstuttgart.typeinference.Pair;
@ -72,181 +73,7 @@ public class Unify
} }
// ino.end // 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 * Einstieg in die Unifizierung mit Wildcards
* *
@ -303,6 +130,7 @@ public class Unify
else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder)) else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder))
{ {
//Diese Paare können nicht mehr Unifiziert werden. fail. //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>>(); 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 RefType tmp = ((RefType)p_fc.TA2).clone(); //Unifikation vorgezogen, da isRXSimilarRY nicht ausreicht PL 07-07-29
CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder(); CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder();
Vector<Type> greater1elemente; Vector<ObjectType> greater1elemente;
if (tmp.get_ParaList() == null) 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); greater1elemente.add(tmp);
} }
else else
@ -387,10 +215,10 @@ public class Unify
//doppelte Elemente rein //doppelte Elemente rein
//Anfang //Anfang
Vector<Type> smallers = new Vector<Type>(); Vector<Type> smallers = new Vector<Type>();
Vector<Type> smaller1elemente; Vector<ObjectType> smaller1elemente;
if (p_fc_TA1_new.get_ParaList() == null) 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); smaller1elemente.add(p_fc_TA1_new);
} }
else else
@ -453,7 +281,7 @@ public class Unify
Stream<Vector<Pair>> strextergMenge1 = Stream<Vector<Pair>> strextergMenge1 =
ergMenge1.stream().map(v -> ergMenge1.stream().map(v ->
v.stream().map(pa -> 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)); ).collect(Vector::new, Vector::add, Vector::addAll));
Vector<Vector<Pair>> extergMenge1 = strextergMenge1.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 RefType tmp = ((RefType)p_fc.TA2).clone(); //Unifikation vorgezogen, da isRXSimilarRY nicht ausreicht PL 07-07-29
CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder(); CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder();
Vector<Type> greater1elemente; Vector<ObjectType> greater1elemente;
if (tmp.get_ParaList() == null) 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); greater1elemente.add(tmp);
} }
else else
@ -525,10 +353,10 @@ public class Unify
//doppelte Elemente rein //doppelte Elemente rein
//Anfang //Anfang
Vector<Type> smallers = new Vector<Type>(); Vector<Type> smallers = new Vector<Type>();
Vector<Type> smaller1elemente; Vector<ObjectType> smaller1elemente;
if (p_fc_TA1_new.get_ParaList() == null) 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); smaller1elemente.add(p_fc_TA1_new);
} }
else else
@ -536,7 +364,7 @@ public class Unify
smaller1elemente = smaller1(p_fc_TA1_new, fc_tto); smaller1elemente = smaller1(p_fc_TA1_new, fc_tto);
} }
for(Type smele : smaller1elemente) for(ObjectType smele : smaller1elemente)
{ {
smallers.add(smele); smallers.add(smele);
smallers.add(new ExtendsWildcardType(smele.getOffset(), smele).clone()); smallers.add(new ExtendsWildcardType(smele.getOffset(), smele).clone());
@ -608,6 +436,8 @@ public class Unify
} }
else { else {
//kein programmierter Fall konnte angewandt werden. PL 15-03-05 //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>>(); return new Vector<Vector<Pair>>();
} }
} }
@ -617,7 +447,7 @@ public class Unify
{ {
//5. Menge //5. Menge
//Greater auf den Typen bilden, und mit den Ergebnissen neue Paare bilden. //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)); cartProduktSets.add(generateSetOfSetOfPair(p.TA2,grErg));
} }
else if(p.OperatorSmallerExtends()) 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 RefType tmp = ((RefType)p_fc.TA2).clone(); //Unifikation vorgezogen, da isRXSimilarRY nicht ausreicht PL 07-07-29
CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder(); CSubstitutionSet gtv2tv = tmp.GenericTypeVar2TypePlaceholder();
Vector<Type> greater1elemente; Vector<ObjectType> greater1elemente;
if (tmp.get_ParaList() == null) 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); greater1elemente.add(tmp);
} }
else else
@ -682,11 +512,11 @@ public class Unify
//smallerArg ersetz durch folgende Zeilen. Durch Transistivitaet von fc kommen sonst //smallerArg ersetz durch folgende Zeilen. Durch Transistivitaet von fc kommen sonst
//doppelte Elemente rein //doppelte Elemente rein
//Anfang //Anfang
Vector<Type> smallers = new Vector<Type>(); Vector<ObjectType> smallers = new Vector<ObjectType>();
Vector<Type> smaller1elemente; Vector<ObjectType> smaller1elemente;
if (p_fc_TA1_new.get_ParaList() == null) 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); smaller1elemente.add(p_fc_TA1_new);
} }
else 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 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(smele);
//smallers.add(new ExtendsWildcardType(smele.getOffset(), smele).clone()); //Auskommentiert luar 07-08-08 //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. //Mit den kleineren Typen neue Paare bilden, linke Seite Klonen.
Vector<Pair> smallerPairs = new Vector<Pair>(); 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)); smallerPairs.add(new Pair(p.TA2.clone(),new SuperWildcardType(sT.getOffset(),sT),PairOperator.Equal));
} }
@ -755,6 +585,7 @@ public class Unify
} }
else { else {
//kein programmierter Fall konnte angewandt werden. PL 15-03-05 //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>>(); return new Vector<Vector<Pair>>();
} }
} }
@ -987,7 +818,7 @@ public class Unify
* @param otherPairTypes - Die anderen Typen * @param otherPairTypes - Die anderen Typen
* @return - Ein Vector<Vector<Pair>> der alle Paare enthält. * @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>>(); Vector<Vector<Pair>> setofsetofpairs = new Vector<Vector<Pair>>();
for(Type t : otherPairTypes) for(Type t : otherPairTypes)
@ -1228,7 +1059,8 @@ throws MatchException
{ {
if((P.TA2 instanceof RefType) == false || ((RefType)P.TA2).get_ParaList() == null) 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()); //System.out.println(P.TA2.toString());
// "P.TA2.toString() != null" angefügt von Andreas Stadelmeier a10023 // "P.TA2.toString() != null" angefügt von Andreas Stadelmeier a10023
@ -1408,36 +1240,41 @@ throws MatchException
//erledigt 15-02-03 //erledigt 15-02-03
if(P.OperatorEqual()) if(P.OperatorEqual())
{ {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//PL 15-02-08 bisher mit keinem Beispiel getestet //PL 15-03-05: Ich halte dies fuer falsch
if(P.TA1 instanceof WildcardType && ((WildcardType)P.TA1).GetWildcardType() instanceof TypePlaceholder ////PL 15-02-08 bisher mit keinem Beispiel getestet
&& (P.TA2 instanceof GenericTypeVar || P.TA2 instanceof RefType)) //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; //H.add(new Pair(((WildcardType)P.TA1).GetWildcardType(),P.TA2, PairOperator.Equal));
continue; //bRegel = true;
} //continue;
//}
//PL 15-02-08 bisher mit keinem Beispiel getestet //PL 15-02-08 bisher mit keinem Beispiel getestet
if((P.TA1 instanceof GenericTypeVar || P.TA1 instanceof RefType) //if((P.TA1 instanceof GenericTypeVar || P.TA1 instanceof RefType)
&& (P.TA2 instanceof WildcardType && ((WildcardType)P.TA2).GetWildcardType() instanceof TypePlaceholder)) //&& (P.TA2 instanceof WildcardType && ((WildcardType)P.TA2).GetWildcardType() instanceof TypePlaceholder))
{ //{
H.add(new Pair(P.TA1, ((WildcardType)P.TA2).GetWildcardType(), PairOperator.Equal)); //H.add(new Pair(P.TA1, ((WildcardType)P.TA2).GetWildcardType(), PairOperator.Equal));
bRegel = true; //bRegel = true;
continue; //continue;
} //}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wenn noetig extends-wildcards entfernen PL 15-02-03 //wenn noetig extends-wildcards entfernen PL 15-02-03
//korrekt da P.OperatorEqual() //korrekt da P.OperatorEqual()
if(P.TA1 instanceof WildcardType) /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{ //PL 15-03-05: Ich halte dies fuer falsch
P.TA1 = ((WildcardType)P.TA1).GetWildcardType(); //if(P.TA1 instanceof WildcardType)
} //{
if(P.TA2 instanceof WildcardType) { //P.TA1 = ((WildcardType)P.TA1).GetWildcardType();
P.TA2 = ((WildcardType)P.TA2).GetWildcardType(); //}
} //if(P.TA2 instanceof WildcardType) {
//P.TA2 = ((WildcardType)P.TA2).GetWildcardType();
//}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RefType TA1 = null; RefType TA1 = null;
RefType TA2 = null; RefType TA2 = null;
@ -2230,7 +2067,7 @@ throws MatchException
// ino.method.allGreater.29428.body // ino.method.allGreater.29428.body
{ {
CRefTypeSet ret = new CRefTypeSet(); CRefTypeSet ret = new CRefTypeSet();
Iterator<Type> typeIt = ty.getBounds().iterator(); Iterator<ObjectType> typeIt = ty.getBounds().iterator();
while(typeIt.hasNext()) { while(typeIt.hasNext()) {
CRefTypeSet grBounds = new CRefTypeSet(); CRefTypeSet grBounds = new CRefTypeSet();
RefType act = (RefType)typeIt.next(); 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. * Implementiert die CaptureConversion. Wendet diese auf jeden Typ im Vector TVec an.
* Rückgabe ist ein Ergebnisvector * 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>(); Vector<ObjectType> retVec = new Vector<ObjectType>();
for(Type t : TVec) 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) if(ccT != null)
retVec.add(ccT); retVec.add(ccT);
} }
@ -3013,12 +2851,14 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
else else
return null; return null;
} }
if(T instanceof WildcardType) if(T instanceof WildcardType)
{ {
return ((WildcardType)T).GetFreshWildcardType(); return ((WildcardType)T).GetFreshWildcardType();
} }
return null; return null;
} }
//Von hier an Greater implementierung 28-03-07 //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. * 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 * 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 //an die Aenderungen im Skript anpassen 07-11-03
{ {
Vector<Type> retVec = new Vector<Type>(); Vector<ObjectType> retVec = new Vector<ObjectType>();
Vector<Type> greater0Erg = greater0(T,fc_tto); Vector<ObjectType> greater0Erg = greater0(T,fc_tto);
for(Type t : greater0Erg) for(ObjectType t : greater0Erg)
{ {
if(!DelFreshWildcardTypeVar(t)) if(!DelFreshWildcardTypeVar(t))
retVec.add(t); retVec.add(t);
@ -3046,31 +2886,31 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* greater0 Schritt von greater. * 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 //greater1 Erzeugen
Vector<Type> greater1Erg = greater1(T,fc_tto); Vector<ObjectType> greater1Erg = greater1(T,fc_tto);
//Reflexivität, deshalb T hinzufügen. //Reflexivität, deshalb T hinzufügen.
if(!greater1Erg.contains(T)) if(!greater1Erg.contains(T))
greater1Erg.add(T); greater1Erg.add(T);
//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec übernommen. //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)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einfügen //Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einfügen
Vector<Type> greater2Erg = greater2(greater1Erg,fc_tto); Vector<ObjectType> greater2Erg = greater2(greater1Erg,fc_tto);
for(Type t : greater2Erg) for(ObjectType t : greater2Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einfügen //Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einfügen
Vector<Type> greater3Erg = greater3(greater2Erg,fc_tto); Vector<ObjectType> greater3Erg = greater3(greater2Erg,fc_tto);
for(Type t : greater3Erg) for(ObjectType t : greater3Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
@ -3081,9 +2921,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
* greater1 Schritt von greater. * greater1 Schritt von greater.
* Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt * 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) if(T instanceof RefType)
{ {
RefType refT = (RefType)T; 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 else if(T instanceof BoundedGenericTypeVar) //PL 15-02-03 angefuegt da BGTV Kleiner als alle seine Bounds ist
{ {
BoundedGenericTypeVar bgtv = (BoundedGenericTypeVar)T; BoundedGenericTypeVar bgtv = (BoundedGenericTypeVar)T;
Vector<Type> types = bgtv.getBounds(); Vector<ObjectType> types = bgtv.getBounds();
retVec = types.stream().map(ty -> greater(ty, fc_tto)).reduce(new Vector<Type>(), (a,b) -> { a.addAll(b); return a;}); retVec = types.stream().map(ty -> greater(ty, fc_tto)).reduce(new Vector<ObjectType>(), (a,b) -> { a.addAll(b); return a;});
} }
return retVec; return retVec;
} }
@ -3205,11 +3045,10 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
return retVec; return retVec;
} }
/** /**
* Kopiert einen Vector<Type>. Es ist eine Deep Copy, da die Elemente auch kopiert werden. * 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>(); Vector<Type> retVec = new Vector<Type>();
for(Type t : vec) for(Type t : vec)
@ -3218,6 +3057,19 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
return retVec; 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 * greaterArg Schritt von greater
* Für den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt * 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 //Bei einer ExtendsWildcard Rekursiv greater0 aufrufen und neue ExtendsWildcars erzeugen
ExtendsWildcardType exT = (ExtendsWildcardType)T; ExtendsWildcardType exT = (ExtendsWildcardType)T;
Vector<Type> greaterTypes = greater0(exT.get_ExtendsType(),fc_tto); Vector<ObjectType> greaterTypes = greater0(exT.get_ExtendsType(),fc_tto);
for(Type t : greaterTypes) for(ObjectType t : greaterTypes)
retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone())); retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone()));
} }
else if(T instanceof SuperWildcardType) else if(T instanceof SuperWildcardType)
{ {
//Bei einer SuperWildcard Rekursiv smaller0 aufrufen und neue SuperWildcards erzeugen. //Bei einer SuperWildcard Rekursiv smaller0 aufrufen und neue SuperWildcards erzeugen.
SuperWildcardType suT = (SuperWildcardType)T; SuperWildcardType suT = (SuperWildcardType)T;
Vector<Type> smallerTypes = smaller0(suT.get_SuperType(),fc_tto); Vector<ObjectType> smallerTypes = smaller0(suT.get_SuperType(),fc_tto);
for(Type t : smallerTypes) for(ObjectType t : smallerTypes)
retVec.add(new SuperWildcardType(t.getOffset(),t.clone())); retVec.add(new SuperWildcardType(t.getOffset(),t.clone()));
} }
/* PL 15-03-10
* Kann meiner Ansicht nach nicht vorkommen
else if(T instanceof FreshExtendsWildcardType) else if(T instanceof FreshExtendsWildcardType)
{ {
//Bei einer FreshExtendsWildcard greaterArg aufrufen, auf Bounds achten. //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) 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 //Diese Abfrage sorgt für grArg(a) = {a} //Luar 07-07-31
else if(T instanceof TypePlaceholder) else if(T instanceof TypePlaceholder)
retVec.add(T); retVec.add(T);
//Diese Abfrage verhindert, dass bei FunN Wildcard-Typen generiert werden //PL 13-05-22 //Diese Abfrage verhindert, dass bei FunN Wildcard-Typen generiert werden //PL 13-05-22
else if((T instanceof RefType) && (T.getName().equals("FunN"))) else if((T instanceof RefType) && (T.getName().equals("FunN")))
retVec.add(T); retVec.add(T);
else else //RefType oder GTV
{ {
//Bei allen anderen Typen greater0 und smaller0 aufrufen. //Bei allen anderen Typen greater0 und smaller0 aufrufen.
retVec.add(T); retVec.add((ObjectType)T);
Vector<Type> greaterTypes = greater0(T,fc_tto); Vector<ObjectType> greaterTypes = greater0((ObjectType)T,fc_tto);
Vector<Type> smallerTypes = smaller0(T,fc_tto); Vector<ObjectType> smallerTypes = smaller0((ObjectType)T,fc_tto);
for(Type t : greaterTypes) for(ObjectType t : greaterTypes)
retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone())); retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone()));
for(Type t : smallerTypes) for(ObjectType t : smallerTypes)
retVec.add(new SuperWildcardType(t.getOffset(),t.clone())); retVec.add(new SuperWildcardType(t.getOffset(),t.clone()));
} }
return retVec; return retVec;
@ -3294,9 +3152,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* greater2 Schritt von greater * 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: * 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. * 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 * 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>(); Vector<ObjectType> retVec = new Vector<ObjectType>();
for(Type t : greater2Erg) for(ObjectType t : greater2Erg)
{ {
Vector<Type> greater1Erg = greater1(t,fc_tto); Vector<ObjectType> greater1Erg = greater1(t,fc_tto);
for(Type tt : greater1Erg) for(ObjectType tt : greater1Erg)
if(!retVec.contains(tt)) if(!retVec.contains(tt))
retVec.add(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. * 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 //an die Aenderungen im Skript anpassen 07-11-03
{ {
Vector<Type> retVec = new Vector<Type>(); Vector<ObjectType> retVec = new Vector<ObjectType>();
Vector<Type> smaller0Erg = smaller0(T,fc_tto); Vector<ObjectType> smaller0Erg = smaller0(T,fc_tto);
for(Type t : smaller0Erg) for(ObjectType t : smaller0Erg)
{ {
if(!DelFreshWildcardTypeVar(t)) if(!DelFreshWildcardTypeVar(t))
retVec.add(t); retVec.add(t);
@ -3377,16 +3235,18 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* smaller0 Schritt von smaller * 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<ObjectType> smaller1Erg = smaller1(T,fc_tto);
Vector<Type> smaller2Erg = smaller2(smaller1Erg,fc_tto);
Vector<ObjectType> smaller2Erg = smaller2(smaller1Erg,fc_tto);
//Unite von smaller 1 und 2 bilden, um dies an smaller 3 weiterzugeben. //Unite von smaller 1 und 2 bilden, um dies an smaller 3 weiterzugeben.
Vector<Type> smaller12Erg = copyVectorType(smaller1Erg); Vector<ObjectType> smaller12Erg = copyVectorObjectType(smaller1Erg);
for(Type t : smaller2Erg) for(ObjectType t : smaller2Erg)
if(!smaller12Erg.contains(t)) if(!smaller12Erg.contains(t))
smaller12Erg.add(t); smaller12Erg.add(t);
@ -3394,19 +3254,19 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
smaller12Erg.add(T); smaller12Erg.add(T);
//Ergebnise in retVec einfügen. Doppelte werden gelöscht. //Ergebnise in retVec einfügen. Doppelte werden gelöscht.
for(Type t : smaller12Erg) for(ObjectType t : smaller12Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einfügen. //Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einfügen.
Vector<Type> smaller3Erg = smaller3(smaller12Erg,fc_tto); Vector<ObjectType> smaller3Erg = smaller3(smaller12Erg,fc_tto);
for(Type t : smaller3Erg) for(ObjectType t : smaller3Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einfügen. //Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einfügen.
Vector<Type> smaller4Erg = smaller4(smaller3Erg); Vector<ObjectType> smaller4Erg = smaller4(smaller3Erg);
for(Type t : smaller4Erg) for(ObjectType t : smaller4Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
@ -3416,9 +3276,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* smaller1 Schritt von smaller * 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) if(T instanceof RefType)
{ {
RefType refT = (RefType)T; 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. //Für eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen.
ExtendsWildcardType exT = (ExtendsWildcardType)T; ExtendsWildcardType exT = (ExtendsWildcardType)T;
Vector<Type> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto); Vector<ObjectType> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto);
for(Type t : smallerTypes) for(ObjectType t : smallerTypes)
{ {
retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone())); retVec.add(new ExtendsWildcardType(t.getOffset(),t.clone()));
retVec.add(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. //Für eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen.
SuperWildcardType suT = (SuperWildcardType)T; SuperWildcardType suT = (SuperWildcardType)T;
Vector<Type> greaterTypes = greater0(suT.get_SuperType(),fc_tto); Vector<ObjectType> greaterTypes = greater0(suT.get_SuperType(),fc_tto);
for(Type t : greaterTypes) for(ObjectType t : greaterTypes)
{ {
retVec.add(new SuperWildcardType(-1,t.clone())); retVec.add(new SuperWildcardType(-1,t.clone()));
retVec.add(t.clone()); retVec.add(t.clone());
@ -3490,7 +3350,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* smaller2 Schritt von smaller * 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); return CaptureConversion(smaller1Erg,fc_tto);
} }
@ -3498,9 +3358,9 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* smaller3 Schritt von smaller * 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: * 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. * 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 * 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. /* smaller4 ist die inverse CaptureConversion.
* Alle Typen in smallerErg werden durchlaufen, und evtl. gefundene * Alle Typen in smallerErg werden durchlaufen, und evtl. gefundene
* FreshWildcardTypes werden durch die entsprechenden Wildcards ersetzt. * FreshWildcardTypes werden durch die entsprechenden Wildcards ersetzt.
* */ * */
Vector<Type> retVec = new Vector<Type>(); Vector<ObjectType> retVec = new Vector<ObjectType>();
for(Type t : smallerErg) for(ObjectType t : smallerErg)
{ {
if(t instanceof RefType) if(t instanceof RefType)
{ {