Backup

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.
+		* Dazu alle Abhängigkeite in Form von Pairs aus dem ResultSet ermitteln.
-		* Mit dem Einsetzen einer Generischen Variablen müssen auch alle anderen Knoten im Syntaxbaum, deren
+		* GenericVarTypeInsertPoints generieren und in TypeInsertSet speichern.
-		Typ ebenfalls dieser TypePlaceholder ist.
+		* Beim Hinzufügen von GenericVarTypeInsertPoints wird kontrolliert, ob diese bereits (auch in Teilen) schon vorhanden sind.
-		* Dies entsteht allerdings automatisch, da das gesamte ermittelte ResultSet als TIS eingesetzt wird.
+		
-		
+5. Einsetzen eines TypeInsertSet (optional)
+	1. Auf allen TypeInsertPoints die getUnresolvedTPHs-Methoden aufrufen
+	2. Alle Abhängigkeiten dieser 
 		
 				

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<TypeInsertPoint> 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<TypeInsertPoint> ret = new Vector<TypeInsertPoint>();
-		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;
 	}
 }

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<Pair> 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();
-			/*
+			//Dann Additional Offset korrigieren:
-			//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<Pair> unresolvedPairs = p.getResultSet().getConstraintsFor(insertCode.getUnresolvedTPH());
-			if(unresolvedPairs.size()>0){ //Nur falls es wirklich was zum Einsetzen gibt:
-			Iterator<Pair> 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();
-			}
-			*/
 			additionalOffset += p.getInsertLength();
 		}
 		return ret;