From ef641065e2a37073bf4985f4430308d5593f18b6 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 7 May 2014 09:36:31 +0200 Subject: [PATCH] Backup --- Readme.md | 11 ++++---- src/mycompiler/SyntaxTreeNode.java | 19 +++++++++---- src/typinferenz/TypeInsertSet.java | 44 +++--------------------------- 3 files changed, 24 insertions(+), 50 deletions(-) diff --git a/Readme.md b/Readme.md index ae1809c70..3ef949bd2 100644 --- a/Readme.md +++ b/Readme.md @@ -31,14 +31,15 @@ * unifiziert Constraints aller im SourceFile vorkommenden Klassen 4. Erstellen von TypeInsertSet - * j * Durchlaufen des Syntaxbaumes * Jeder Knoten erstellt TypeInsertSets anhand des ResultSets. * Bei nichtauflösung eines TPH muss GenericVar eingesetzt werden: - * Im Syntaxbaum wird dazu die addGenericVar-Methode aufgerufen, welche einen TypeInsertPoint generiert. - * Mit dem Einsetzen einer Generischen Variablen müssen auch alle anderen Knoten im Syntaxbaum, deren - Typ ebenfalls dieser TypePlaceholder ist. - * Dies entsteht allerdings automatisch, da das gesamte ermittelte ResultSet als TIS eingesetzt wird. + * Dazu alle Abhängigkeite in Form von Pairs aus dem ResultSet ermitteln. + * GenericVarTypeInsertPoints generieren und in TypeInsertSet speichern. + * Beim Hinzufügen von GenericVarTypeInsertPoints wird kontrolliert, ob diese bereits (auch in Teilen) schon vorhanden sind. +5. Einsetzen eines TypeInsertSet (optional) + 1. Auf allen TypeInsertPoints die getUnresolvedTPHs-Methoden aufrufen + 2. Alle Abhängigkeiten dieser \ No newline at end of file diff --git a/src/mycompiler/SyntaxTreeNode.java b/src/mycompiler/SyntaxTreeNode.java index ca2a19203..d2dd879f7 100644 --- a/src/mycompiler/SyntaxTreeNode.java +++ b/src/mycompiler/SyntaxTreeNode.java @@ -4,6 +4,7 @@ import java.util.Vector; import typinferenz.ResultSet; import typinferenz.TypeInsertPoint; +import typinferenz.TypeInsertSet; import typinferenz.TypeInsertable; import typinferenz.exceptions.DebugException; import typinferenz.exceptions.TypeinferenceException; @@ -63,18 +64,26 @@ public abstract class SyntaxTreeNode { return true; } - public Vector getTypeInsertPoints(ResultSet result) { + /** + * Methode zur Generierung der TypeInsertPoints + * @param insertSet - Generierte InsertPoints werden dem insertSet angefügt + * @param result - Das ResultSet auf dessen Basis die InsertPoints generiert werden + */ + public void addTypeInsertPoints(TypeInsertSet insertSet,ResultSet result) { Vector ret = new Vector(); - for(SyntaxTreeNode node : this.getChildren()){ - ret.addAll(node.getTypeInsertPoints(result)); - } //Fall der Knoten ein TypeInsertable ist, kann direkt der TypeInsertPoint generiert werden. if(this instanceof TypeInsertable){ TypeInsertable that = (TypeInsertable)this; Type t = that.getType(); if(t instanceof TypePlaceholder) ret.add(that.createTypeInsertPoint((TypePlaceholder) t, result));//ret.addAll(((TypePlaceholder)t).getTypeInsertPoints(result)); + + } + insertSet.add(ret); + + //Nachdem die InsertPoints und GenericVarTypeInsertPoints angefügt wurden, kann im Knoten abgestiegen werden: + for(SyntaxTreeNode node : this.getChildren()){ + node.addTypeInsertPoints(insertSet, result); } - return ret; } } diff --git a/src/typinferenz/TypeInsertSet.java b/src/typinferenz/TypeInsertSet.java index 60ccda7c8..a492647a0 100644 --- a/src/typinferenz/TypeInsertSet.java +++ b/src/typinferenz/TypeInsertSet.java @@ -62,62 +62,26 @@ public class TypeInsertSet { } genericTIPs.add(toAdd); } + /* //... und dem TypeInsertSet anfügen: for(GenericTypeInsertPoint p : genericTIPs){ for(GenericTypeInsertPoint p2 : genericTIPs){ //Doppelte Generische Variablen definitionen ausschließen: for(TypeInsertPoint toAdd : p.merge(p2)){ this.add(toAdd); - //TODO: Alle Typen, welche die einzusetzenden Generischen Typen beinhalten, müssen ebenfalls eingesetzt werden. - } } //this.add(p); } - - //Anschließend sortieren: + */ + //Anschließend sortieren (nach dem Offset der InsertPoints): Collections.sort(points); for(TypeInsertPoint p : points){ - /* - //TODO: Verbessern. Momentan noch komischer Hack: - //Kontrollieren ob beim Einsetzen Generische Typvariablen entstehen: - Iterator it = p.getUnresolvedPairs().iterator(); - String genericTypeParameters = "<"; - while(it.hasNext()){ - genericTypeParameters += new GenericTypeVar(it.next(), 0).printJavaCode(p.getResultSet()); - if(it.hasNext())genericTypeParameters += ", "; - } - genericTypeParameters += ">"; - //HACK: Reftype mit dem Typ der einzusetzenden Generischen Variablen: - TypeInsertPoint tip = new TypeInsertPoint(p.getGenericTypeVarInsertNode(), new RefType(genericTypeParameters,0), p.getResultSet()); - //ret = tip.insertType(fileContent, additionalOffset); - //additionalOffset += tip.getInsertLength(); - */ - //Zuerst den Typ einsetzen JavaCodeResult insertCode = p.insertType(ret, additionalOffset); ret = insertCode.toString(); - /* - //Das additional Offset noch nicht korrigieren, da die generischen Parameter noch vor den Typ müssen. - - //Jetzt sind die übriggebliebenen TPHs bekannt und die benötigten Generischen Variablen können berechnet werden. - Vector unresolvedPairs = p.getResultSet().getConstraintsFor(insertCode.getUnresolvedTPH()); - if(unresolvedPairs.size()>0){ //Nur falls es wirklich was zum Einsetzen gibt: - Iterator it = unresolvedPairs.iterator(); - String genericTypeParameters = "<"; - while(it.hasNext()){ - genericTypeParameters += new GenericTypeVar(it.next(), 0).printJavaCode(p.getResultSet()); - if(it.hasNext())genericTypeParameters += ", "; - } - genericTypeParameters += ">"; - //Der Generische Variablen String zum Einsetzen ist nun vorhanden - TypeInsertPoint tip = new TypeInsertPoint(p.getGenericTypeVarInsertNode(), new RefType(genericTypeParameters,0), p.getResultSet()); - ret = tip.insertType(insertCode.toString(), additionalOffset).toString(); - //Jetzt das gesamte Offset korrigieren: - additionalOffset += tip.getInsertLength(); - } - */ + //Dann Additional Offset korrigieren: additionalOffset += p.getInsertLength(); } return ret;