From ea6ff84c9f7b9b47653d8c5b0a3cc5631c33b836 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= Date: Thu, 20 Nov 2014 20:20:28 +0100 Subject: [PATCH] Aufteilung Unifikation --- bin/.gitignore | 5 - .../dhbwstuttgart/syntaxtree/SourceFile.java | 126 ++++++++++++++++-- .../typeinference/ConstraintsSet.java | 8 ++ .../typeinference/OderConstraint.java | 20 +++ .../typeinference/SingleConstraint.java | 5 + .../typeinference/UndConstraint.java | 1 + 6 files changed, 147 insertions(+), 18 deletions(-) diff --git a/bin/.gitignore b/bin/.gitignore index 56a30e6a..fd04598c 100644 --- a/bin/.gitignore +++ b/bin/.gitignore @@ -1,6 +1 @@ -/bytecode/ /de/ -/mycompiler/ -/parser/ -/plugindevelopment/ -/syntaxTree/ diff --git a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java index d3d35cde..2448f8ca 100755 --- a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java +++ b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java @@ -48,7 +48,9 @@ import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; import de.dhbwstuttgart.typeinference.unify.FC_TTO; import de.dhbwstuttgart.typeinference.unify.Unifier; import de.dhbwstuttgart.typeinference.unify.Unify; - +import de.dhbwstuttgart.typeinference.OderConstraint; +import de.dhbwstuttgart.typeinference.UndConstraint; +import de.dhbwstuttgart.typeinference.SingleConstraint; @@ -642,6 +644,46 @@ public class SourceFile return publicAssumptions; } + Vector divideOderConstraints(OderConstraint oc) { + + //Schritt 1: Variablen an Hand des 1. Elements der UndConstraints gruppieren + //!!! KLAEREN OB ES PASSIEREN KANN, DASS IM 2., 3. , ... ELEMENT ANDERE VARIABLEN VORKOMMEN KOENNEN!!! + //WENN JA, DANN MUESSEN DIE VARIABLEN UEBER ALLE ELEMENTE (NICHT NUR DAS 1.) AUFGESAMMELT WERDEN + Vector pairs = oc.getUndConstraints().elementAt(0).getSingleConstraints().stream() + .map(x -> x.getPair()) + .collect(Vector::new, Vector::add, Vector::addAll); + Vector> pairvars = pairs.stream().map(p -> {Vector TPHs = new Vector<>(); + TPHs.addAll(p.TA1.getInvolvedTypePlaceholder()); + TPHs.addAll(p.TA2.getInvolvedTypePlaceholder()); + return TPHs;} + ).collect(Vector::new, Vector::add, Vector::addAll); + + //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen + //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen + Vector> indexeset1 = new Vector<>(); + if (pairvars != null && pairvars.size()>0) { + indexeset1 = Unify.schnitt(pairvars); + } + + //Schritt 3 + //Aus den Indexmengen die UndConstraints als OderConstraint neu gruppieren + java.util.function.BiFunction accSC = (a,b) -> { a.addConstraint(b); return a;}; + java.util.function.BinaryOperator combUC = (a,b) -> { a.getUndConstraints().addAll(b.getUndConstraints()); return a;}; + + Vector ret = new Vector(); + for (Vector is : indexeset1) { + Stream> vs = oc.getUndConstraints().stream().map(x -> is.stream().map(i -> x.getSingleConstraints().elementAt(i)));//.collect(Vector::new, Vector::add, Vector::addAll);; + //Vector us = vs.map(x -> x.reduce(new UndConstraint(), (a,b) -> { a.addConstraint((SingleConstraint)b); return a;})) + //.collect(Vector::new, Vector::add, Vector::addAll); + OderConstraint OCnew = vs.reduce(new OderConstraint(), + (y,x) -> { y.addConstraint(x.reduce(new UndConstraint(), accSC, combUC)); return y;}, + (a,b) -> { a.getUndConstraints().addAll(b.getUndConstraints()); return a;} + ); + ret.addElement(OCnew); + } + return ret; + } + ///////////////////////////////////////////////////////////////////////// // TypeReconstructionAlgorithmus ///////////////////////////////////////////////////////////////////////// @@ -662,7 +704,7 @@ public class SourceFile // ino.end // ino.method.typeReconstruction.21406.body { - Vector ret = new Vector(); + //Vector ret = new Vector(); //Logger initialisieren: Logger typinferenzLog = Logger.getLogger("Typeinference"); @@ -681,7 +723,7 @@ public class SourceFile FC_TTO finiteClosure = this.makeFC(globalAssumptions); typinferenzLog.debug("FiniteClosure: \n"+finiteClosure, Section.TYPEINFERENCE); - + ConstraintsSet oderConstraints = new ConstraintsSet(); //Alle Constraints der in dieser SourceFile enthaltenen Klassen sammeln: for(Class klasse : KlassenVektor){ @@ -699,11 +741,67 @@ public class SourceFile return retValue;}; oderConstraints.filterWrongConstraints(unifier); //oderConstraints.unifyUndConstraints(unifier); - typinferenzLog.debug("Übriggebliebene Konstraints:\n"+oderConstraints+"\n", Section.TYPEINFERENCE); + + java.util.function.BiFunction,OderConstraint,Vector> divideOC = + (a,b) -> { + if ((b instanceof SingleConstraint) || (b instanceof UndConstraint)) { a.addElement(b); } + else { a.addAll(divideOderConstraints(b)); } // (b instanceof OderConstraint) + return a; + }; + java.util.function.BinaryOperator> oderAll = (a,b) -> { a.addAll(b); return a;}; + + + Vector vecoderConstraints = oderConstraints.getConstraintsSet().stream().reduce(new Vector(), divideOC, oderAll); + + ConstraintsSet devidedOderConstraints = new ConstraintsSet(); + devidedOderConstraints.addAll(vecoderConstraints); + //HIER WEITERMACHEN: oderConstraints in devidedOderConstraints umaendern + //1. Schritt: + Stream> streamOneExample = + devidedOderConstraints.getConstraintsSet().stream().map( + (constr) -> constr.getOneExample()); //.reduce(Vector::new, Vector::addAll); + Vector> vecOneExample = streamOneExample.collect(Vector::new, Vector::add, Vector::addAll); + + //2. Schritt + Stream> streamvars = vecOneExample.stream().map(x -> x.stream().map( + p -> { Vector TPHs = new Vector<>(); + TPHs.addAll(p.TA1.getInvolvedTypePlaceholder()); + TPHs.addAll(p.TA2.getInvolvedTypePlaceholder()); + return TPHs;} + ).reduce(new Vector(),(a, b) -> { for (TypePlaceholder ty : b ) { if (!a.contains(ty)) a.add(ty); } return a; })); + + Vector> vecvars = streamvars.collect(Vector::new, Vector::add, Vector::addAll); + + //Schritt 3: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen + //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen + Vector> indexeset = new Vector<>(); + if (vecvars != null && vecvars.size()>0) { + indexeset = Unify.schnitt(vecvars); + } + + //Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente + // In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen + Stream> streamoderconstraints = indexeset.stream().map(x -> x.stream() + .map(i -> devidedOderConstraints.getConstraintsSet().elementAt(i)) + .collect(Vector::new, Vector::add, Vector::addAll)); + Vector> vecconstraintsclone = streamoderconstraints.collect(Vector::new, Vector::add, Vector::addAll); + Stream constraintsclone = vecconstraintsclone.stream().map( + oderConstraintsSubset -> { + ConstraintsSet ConsoderConstraintsSubset = new ConstraintsSet (); + ConsoderConstraintsSubset.addAll(oderConstraintsSubset); + System.out.println(oderConstraintsSubset); + return ConsoderConstraintsSubset; } + ); + //Vector xxx1 = constraintsclone.collect(Vector::new, Vector::add, Vector::addAll); + Stream> ressets = constraintsclone.map(constraintsSubset -> { + typinferenzLog.debug("Übriggebliebene Konstraints:\n"+devidedOderConstraints+"\n", Section.TYPEINFERENCE); //Die Constraints in Pair's umwandeln (Karthesisches Produkt bilden): - Vector> xConstraints = new Vector>();// = oderConstraints.getConstraints(); - for(Vector uC : oderConstraints.getConstraints()){ //mit dem getConstraints-Aufruf wird das Karthesische Produkt erzeugt. - Vector cons = new Vector(); + Vector ret = new Vector(); + Vector> xConstraints = new Vector>();// = devidedOderConstraints.getConstraints(); + for(Vector uC : constraintsSubset.getConstraints()){ //mit dem getConstraints-Aufruf wird das Karthesische Produkt erzeugt. + Vector cons = new Vector(); //HIER STIMMT ES NICHT constraintsSubset ein Element OderConstraint enthaelt vgl. (TPH AGG <. java.lang.Integer), ]| [ + //(TPH AGG <. java.lang.Long), ]| [ + //(TPH AGG <. java.lang.Double), ]| ]], for(UndConstraint undCons:uC){ cons.addAll(undCons.getConstraintPairs()); } @@ -790,17 +888,17 @@ public class SourceFile //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen - Vector> indexeset = new Vector<>(); + Vector> indexeset1 = new Vector<>(); if (constraintsclonevars != null && constraintsclonevars.size()>0) { - indexeset = Unify.schnitt(constraintsclonevars); + indexeset1 = Unify.schnitt(constraintsclonevars); } //Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente // In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen - Stream> streamconstraintsclone = indexeset.stream().map(x -> x.stream() + Stream> streamconstraintsclone = indexeset1.stream().map(x -> x.stream() .map(i -> constraintsClone.elementAt(i)) .collect(Vector::new, Vector::add, Vector::addAll)); -// Vector> vecconstraintsclone = streamconstraintsclone.collect(Vector::new, Vector::add, Vector::addAll); +// Vector> vecconstraintsclone1 = streamconstraintsclone.collect(Vector::new, Vector::add, Vector::addAll); //Schritt 4: Unifikation Vector>> vecunifyResult = @@ -887,7 +985,7 @@ public class SourceFile //typinferenzLog.debug(supportData.getFiniteClosure()); //typinferenzLog.debug("Typinformationen: \n"+this.getTypeInformation(this.getMethodList(), fieldInitializers)); - typinferenzLog.debug("\nJavaFiles:\n", Section.TYPEINFERENCE); + //typinferenzLog.debug("\nJavaFiles:\n", Section.TYPEINFERENCE); //typinferenzLog.debug(this.printJavaCode(new ResultSet(new Vector()))); @@ -911,7 +1009,9 @@ public class SourceFile if(unifyFail){ if(!this.KlassenVektor.isEmpty())throw new TypeinferenceException("Fehler in Typinferierung", this.KlassenVektor.firstElement()); } - return ret; + return ret;}); + Vector> vecressets = ressets.collect(Vector::new, Vector::add, Vector::addAll); + return new Vector(); /* // HOTI: Nur zur Info.Ich habe den Loglevel auf Info geschaltet, damit // in der GUI (Eclipse-Plugin) die Console nicht zugemüllt wird. diff --git a/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java b/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java index 7572a6b3..ea8e3adc 100755 --- a/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java +++ b/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java @@ -21,6 +21,14 @@ public class ConstraintsSet implements Iterable{ public void add(OderConstraint constraint){ constraintsSet.add(constraint); } + + public void addAll(Vector vecconstraint){ + constraintsSet.addAll(vecconstraint); + } + + public Vector getConstraintsSet() { + return constraintsSet; + } /** * Liefert alle Constraint-Variationen diff --git a/src/de/dhbwstuttgart/typeinference/OderConstraint.java b/src/de/dhbwstuttgart/typeinference/OderConstraint.java index 1f2762d4..7cce85ac 100755 --- a/src/de/dhbwstuttgart/typeinference/OderConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/OderConstraint.java @@ -31,6 +31,13 @@ public class OderConstraint{ } + /** + * gibt ein Exemplar zurück um die Variablen zu bestimmen + */ + public Vector getOneExample() { + return this.getUndConstraints().elementAt(0).getConstraintPairs(); + } + /** * Liefert alle in diesem OderConstraint enthaltene Constraints. Dabei gehen die Verknüpfungen (Oder/Und) verloren. * @return @@ -43,6 +50,8 @@ public class OderConstraint{ return ret; } + + /** * Fügt ein Pair(p1, p2) dem Constraint hinzu * @param p1 @@ -68,6 +77,17 @@ public class OderConstraint{ } return ret+"]"; } + + public Vector getSingleConstraints() { + Vector ret = new Vector(); + for(UndConstraint uc : oderConstraintPairs) { + if (uc instanceof SingleConstraint) { + ret.add((SingleConstraint)uc); + } + //else return new Exception(); + } + return ret; + } public Vector getUndConstraints() { return this.oderConstraintPairs; diff --git a/src/de/dhbwstuttgart/typeinference/SingleConstraint.java b/src/de/dhbwstuttgart/typeinference/SingleConstraint.java index 2ab2e624..63cb70d5 100755 --- a/src/de/dhbwstuttgart/typeinference/SingleConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/SingleConstraint.java @@ -37,6 +37,11 @@ public class SingleConstraint extends UndConstraint{ public Pair getPair(){ return constraintPair; } + + @Override //liefert das eine Paar zurueck + public Vector getOneExample() { + return getConstraintPairs(); + } @Override //Methode überschreiben, damit immer nur ein Vector mit nur einem Element zurückgeliefert wird. public Vector getConstraintPairs(){ diff --git a/src/de/dhbwstuttgart/typeinference/UndConstraint.java b/src/de/dhbwstuttgart/typeinference/UndConstraint.java index 6dd7ec14..5388484e 100755 --- a/src/de/dhbwstuttgart/typeinference/UndConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/UndConstraint.java @@ -20,6 +20,7 @@ public class UndConstraint extends OderConstraint { super(); } + @Override public Vector getUndConstraints() { Vector ret = new Vector();