From 6a47dfaf58ef8f92efe0947428dac92a85fca82e Mon Sep 17 00:00:00 2001 From: Pluemicke Martin Date: Tue, 10 Mar 2015 22:32:29 +0100 Subject: [PATCH] nicht lauffaehige Version --- .../type/BoundedGenericTypeVar.java | 16 +- .../syntaxtree/type/ExtendsWildcardType.java | 14 +- .../syntaxtree/type/GenericTypeVar.java | 2 +- .../syntaxtree/type/ObjectType.java | 2 +- .../syntaxtree/type/SuperWildcardType.java | 6 +- .../syntaxtree/type/WildcardType.java | 2 +- .../typeinference/unify/Unify.java | 434 ++++++------------ 7 files changed, 169 insertions(+), 307 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java index 46a043f3..cc284edc 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java @@ -37,7 +37,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar */ // ino.end // ino.attribute.bounds.26468.declaration - Vector bounds=new Vector(); + Vector bounds=new Vector(); // ino.end private int endOffset; @@ -54,7 +54,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar */ // ino.method.BoundedGenericTypeVar.29409.definition - public BoundedGenericTypeVar(String s, Vector bounds, SyntaxTreeNode parentClass, int offset, int endOffset) + public BoundedGenericTypeVar(String s, Vector 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 getBounds() + public Vector 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 tempBounds = new Vector<>(); + Vector 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 { diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java index 00f0629f..69cb4e6f 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java @@ -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
* 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(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java index 658e7536..bb1a22a5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java @@ -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 { diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java b/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java index 61eea8a5..5c1e5064 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java @@ -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(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java index 42f7f4bf..5907388c 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java @@ -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; } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java index e6277b7a..aa32de77 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java @@ -15,7 +15,7 @@ import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException; * */ -public class WildcardType extends ObjectType{ +public class WildcardType extends Type{ /** * Author: Arne Lüdtke
diff --git a/src/de/dhbwstuttgart/typeinference/unify/Unify.java b/src/de/dhbwstuttgart/typeinference/unify/Unify.java index 55050f38..3b6d00c1 100755 --- a/src/de/dhbwstuttgart/typeinference/unify/Unify.java +++ b/src/de/dhbwstuttgart/typeinference/unify/Unify.java @@ -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> unify(Vector E, FC_TTO fc_tto ) - public static Vector> unifyOld(Vector E, FC_TTO fc_tto ) - // ino.end - // ino.method.unify.28058.body - { - //HIER MUSS NICHT-UNITARY UNIFIER NOCH PROGRAMMIERT WERDEN - - Vector FC = fc_tto.getFC(); - //Vector TTO = fc_tto.getTTO(); - //Vector> Eq_set = new Vector>(); - Vector Eq_11 = new Vector (); - Vector Eq_12 = new Vector (); - Vector>> sm_set = new Vector>>(); - Vector>> gr_set = new Vector>>(); - Vector>> bound_set = new Vector>>(); - - //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> 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 gr; - if (P.TA1 instanceof RefType) - gr = allGreater((RefType)P.TA1, FC); - else - gr = allGreater((BoundedGenericTypeVar)P.TA1, FC); - Vector setofpairs = new Vector (); - setofpairs.addElement(new Pair(P.TA2, P.TA1, PairOperator.Equal)); //Reflexivitaet - Vector> setofsetofpairs = new Vector>(); - setofsetofpairs.addElement(setofpairs); - for (int ii = 0; ii < gr.size(); ii++) - { - setofpairs = new Vector (); - 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 bounds = ((BoundedGenericTypeVar)(P.TA1)).getBounds(); - Vector> setofsetofpairs = new Vector>(); - for (int ii = 0; ii < bounds.size(); ii++) - { - Vector setofpairs = new Vector (); - 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 helpvp; - Vector> newvecvecpair1 = new Vector>(); - - //notwendig damit die naechste for-Schleife (ii) auf alle Faelle - //mindestens einmal durchlaufen wird. - //if (sm_set.size() == 0) sm_set.addElement(new Vector()); - - //korregiert PL 06-05-12 - Vector>> 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> OneE_Element = Eq_2expand.elementAt(ii); - Vector> newvecvecpair1old = newvecvecpair1; - newvecvecpair1 = new Vector>(); - 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> helpvp2; - Vector> newvecvecpair2 = newvecvecpair1; //new Vector>(); - // for (int ii = 0; ii < newvecvecpair1.size(); ii++) { - // Vector 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 ()); - // if (gr_set.size() == 0) newvecvecpair2.addElement(OneUnifier); - // for (int jj = 0; jj < gr_set.size(); jj++) { - // Vector> 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> newvecvecpair3 = new Vector>(); - //Vector> rek = new Vector>(); - //Vector> ret = new Vector>(); - 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 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>(); } } @@ -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 greater1elemente; + Vector greater1elemente; if (tmp.get_ParaList() == null) { - greater1elemente = new Vector(); //Bei Konstanten liefert greater1 [] zurueck + greater1elemente = new Vector(); //Bei Konstanten liefert greater1 [] zurueck greater1elemente.add(tmp); } else @@ -387,10 +215,10 @@ public class Unify //doppelte Elemente rein //Anfang Vector smallers = new Vector(); - Vector smaller1elemente; + Vector smaller1elemente; if (p_fc_TA1_new.get_ParaList() == null) { - smaller1elemente = new Vector(); //Bei Konstanten liefert smaller1 [] zurueck + smaller1elemente = new Vector(); //Bei Konstanten liefert smaller1 [] zurueck smaller1elemente.add(p_fc_TA1_new); } else @@ -453,7 +281,7 @@ public class Unify Stream> 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> 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 greater1elemente; + Vector greater1elemente; if (tmp.get_ParaList() == null) { - greater1elemente = new Vector(); //Bei Konstanten liefert greater1 [] zurueck + greater1elemente = new Vector(); //Bei Konstanten liefert greater1 [] zurueck greater1elemente.add(tmp); } else @@ -525,10 +353,10 @@ public class Unify //doppelte Elemente rein //Anfang Vector smallers = new Vector(); - Vector smaller1elemente; + Vector smaller1elemente; if (p_fc_TA1_new.get_ParaList() == null) { - smaller1elemente = new Vector(); //Bei Konstanten liefert smaller1 [] zurueck + smaller1elemente = new Vector(); //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>(); } } @@ -617,7 +447,7 @@ public class Unify { //5. Menge //Greater auf den Typen bilden, und mit den Ergebnissen neue Paare bilden. - Vector grErg = greater(p.TA1,fc_tto); + Vector 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 greater1elemente; + Vector greater1elemente; if (tmp.get_ParaList() == null) { - greater1elemente = new Vector(); //Bei Konstanten liefert greater1 [] zurueck + greater1elemente = new Vector(); //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 smallers = new Vector(); - Vector smaller1elemente; + Vector smallers = new Vector(); + Vector smaller1elemente; if (p_fc_TA1_new.get_ParaList() == null) { - smaller1elemente = new Vector(); //Bei Konstanten liefert smaller1 [] zurueck + smaller1elemente = new Vector(); //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 smallerPairs = new Vector(); - 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>(); } } @@ -987,7 +818,7 @@ public class Unify * @param otherPairTypes - Die anderen Typen * @return - Ein Vector> der alle Paare enthält. */ - private static Vector> generateSetOfSetOfPair(Type TA1, Vector otherPairTypes) + private static Vector> generateSetOfSetOfPair(Type TA1, Vector otherPairTypes) { Vector> setofsetofpairs = new Vector>(); for(Type t : otherPairTypes) @@ -1228,7 +1059,8 @@ throws MatchException { if((P.TA2 instanceof RefType) == false || ((RefType)P.TA2).get_ParaList() == null) { - Vector greaters = greater(P.TA1,fc_tto); + Vector 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 typeIt = ty.getBounds().iterator(); + Iterator 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 CaptureConversion(Vector TVec, FC_TTO fc_tto) + private static Vector CaptureConversion(Vector TVec, FC_TTO fc_tto) { - Vector retVec = new Vector(); - for(Type t : TVec) + Vector retVec = new Vector(); + 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 ...> werden keine ? extends-, ? super-Typen erzeugt */ - private static Vector greater(Type T, FC_TTO fc_tto) + private static Vector greater(ObjectType T, FC_TTO fc_tto) //an die Aenderungen im Skript anpassen 07-11-03 { - Vector retVec = new Vector(); - Vector greater0Erg = greater0(T,fc_tto); - for(Type t : greater0Erg) + Vector retVec = new Vector(); + Vector 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 greater0(Type T, FC_TTO fc_tto) + private static Vector greater0(ObjectType T, FC_TTO fc_tto) { - Vector retVec = new Vector(); + Vector retVec = new Vector(); //greater1 Erzeugen - Vector greater1Erg = greater1(T,fc_tto); + Vector 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 greater2Erg = greater2(greater1Erg,fc_tto); - for(Type t : greater2Erg) + Vector 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 greater3Erg = greater3(greater2Erg,fc_tto); - for(Type t : greater3Erg) + Vector 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 ...> werden keine ? extends-, ? super-Typen erzeugt */ - private static Vector greater1(Type T, FC_TTO fc_tto) + private static Vector greater1(ObjectType T, FC_TTO fc_tto) { - Vector retVec = new Vector(); + Vector retVec = new Vector(); 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 types = bgtv.getBounds(); - retVec = types.stream().map(ty -> greater(ty, fc_tto)).reduce(new Vector(), (a,b) -> { a.addAll(b); return a;}); + Vector types = bgtv.getBounds(); + retVec = types.stream().map(ty -> greater(ty, fc_tto)).reduce(new Vector(), (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. Es ist eine Deep Copy, da die Elemente auch kopiert werden. */ - private static Vector copyVectorType(Vector vec) + private static Vector copyVectorType(Vector vec) { Vector retVec = new Vector(); for(Type t : vec) @@ -3218,6 +3057,19 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.: return retVec; } + /** + * Kopiert einen Vector. Es ist eine Deep Copy, da die Elemente auch kopiert werden. + * noetig wegen Type-Erasure + */ + private static Vector copyVectorObjectType(Vector vec) + { + Vector retVec = new Vector(); + 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 greaterTypes = greater0(exT.get_ExtendsType(),fc_tto); - for(Type t : greaterTypes) + Vector 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 smallerTypes = smaller0(suT.get_SuperType(),fc_tto); - for(Type t : smallerTypes) + Vector 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(); + return new Vector(); + */ + //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 greaterTypes = greater0(T,fc_tto); - Vector smallerTypes = smaller0(T,fc_tto); - for(Type t : greaterTypes) + retVec.add((ObjectType)T); + Vector greaterTypes = greater0((ObjectType)T,fc_tto); + Vector 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 greater2(Vector greater1Erg, FC_TTO fc_tto) + private static Vector greater2(Vector greater1Erg, FC_TTO fc_tto) { - Vector retVec = new Vector(); + Vector retVec = new Vector(); /* * 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 greater3(Vector greater2Erg, FC_TTO fc_tto) + private static Vector greater3(Vector greater2Erg, FC_TTO fc_tto) { - Vector retVec = new Vector(); - for(Type t : greater2Erg) + Vector retVec = new Vector(); + for(ObjectType t : greater2Erg) { - Vector greater1Erg = greater1(t,fc_tto); - for(Type tt : greater1Erg) + Vector 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 smaller(Type T, FC_TTO fc_tto) + private static Vector smaller(ObjectType T, FC_TTO fc_tto) //an die Aenderungen im Skript anpassen 07-11-03 { - Vector retVec = new Vector(); - Vector smaller0Erg = smaller0(T,fc_tto); - for(Type t : smaller0Erg) + Vector retVec = new Vector(); + Vector 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 smaller0(Type T, FC_TTO fc_tto) + private static Vector smaller0(ObjectType T, FC_TTO fc_tto) { - Vector retVec = new Vector(); + Vector retVec = new Vector(); - Vector smaller1Erg = smaller1(T,fc_tto); - Vector smaller2Erg = smaller2(smaller1Erg,fc_tto); + Vector smaller1Erg = smaller1(T,fc_tto); + + + Vector smaller2Erg = smaller2(smaller1Erg,fc_tto); //Unite von smaller 1 und 2 bilden, um dies an smaller 3 weiterzugeben. - Vector smaller12Erg = copyVectorType(smaller1Erg); - for(Type t : smaller2Erg) + Vector 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 smaller3Erg = smaller3(smaller12Erg,fc_tto); - for(Type t : smaller3Erg) + Vector 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 smaller4Erg = smaller4(smaller3Erg); - for(Type t : smaller4Erg) + Vector 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 smaller1(Type T, FC_TTO fc_tto) + private static Vector smaller1(Type T, FC_TTO fc_tto) { - Vector retVec = new Vector(); + Vector retVec = new Vector(); 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 smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto); - for(Type t : smallerTypes) + Vector 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 greaterTypes = greater0(suT.get_SuperType(),fc_tto); - for(Type t : greaterTypes) + Vector 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 smaller2(Vector smaller1Erg, FC_TTO fc_tto) + private static Vector smaller2(Vector 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 smaller3(Vector smaller12Erg, FC_TTO fc_tto) + private static Vector smaller3(Vector smaller12Erg, FC_TTO fc_tto) { - Vector retVec = new Vector(); + Vector retVec = new Vector(); /* * 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 smaller4(Vector smallerErg) + private static Vector smaller4(Vector smallerErg) { /* smaller4 ist die inverse CaptureConversion. * Alle Typen in smallerErg werden durchlaufen, und evtl. gefundene * FreshWildcardTypes werden durch die entsprechenden Wildcards ersetzt. * */ - Vector retVec = new Vector(); - for(Type t : smallerErg) + Vector retVec = new Vector(); + for(ObjectType t : smallerErg) { if(t instanceof RefType) {