2014-09-04 14:35:44 +00:00
|
|
|
package de.dhbwstuttgart.syntaxtree;
|
2014-02-11 01:47:39 +00:00
|
|
|
|
2016-07-21 14:36:33 +00:00
|
|
|
import org.apache.bcel.generic.ClassGen;
|
2014-02-19 04:20:54 +00:00
|
|
|
|
2015-06-16 11:53:32 +00:00
|
|
|
import de.dhbwstuttgart.typeinference.Menge;
|
2016-03-30 08:09:17 +00:00
|
|
|
import de.dhbwstuttgart.bytecode.ClassGenerator;
|
2014-09-08 13:12:47 +00:00
|
|
|
import de.dhbwstuttgart.core.IItemWithOffset;
|
2014-09-02 08:33:54 +00:00
|
|
|
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
|
|
|
|
import de.dhbwstuttgart.syntaxtree.type.Type;
|
|
|
|
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
2014-09-08 13:12:47 +00:00
|
|
|
import de.dhbwstuttgart.typeinference.Pair;
|
2014-09-02 08:33:54 +00:00
|
|
|
import de.dhbwstuttgart.typeinference.ResultSet;
|
|
|
|
import de.dhbwstuttgart.typeinference.TypeInsertable;
|
2016-03-30 08:09:17 +00:00
|
|
|
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
|
2014-09-02 08:33:54 +00:00
|
|
|
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
|
|
|
|
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
|
|
|
|
import de.dhbwstuttgart.typeinference.typedeployment.GenericTypeInsertPoint;
|
|
|
|
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
|
|
|
|
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
|
2014-02-11 15:30:38 +00:00
|
|
|
|
2014-09-08 13:12:47 +00:00
|
|
|
public abstract class SyntaxTreeNode implements IItemWithOffset{
|
2014-02-12 01:12:12 +00:00
|
|
|
|
2014-02-19 04:20:54 +00:00
|
|
|
protected SyntaxTreeNode parent;
|
2016-09-09 22:40:17 +00:00
|
|
|
protected SourceCodePosition position;
|
|
|
|
|
2014-02-11 15:30:38 +00:00
|
|
|
/**
|
|
|
|
* Wird nach dem Parsen aufgerufen.
|
2015-05-12 17:49:27 +00:00
|
|
|
* Erfüllt folgenden Aufgaben:
|
|
|
|
* 1. Füllt fehlende Typangaben mit TPHs auf.
|
|
|
|
* 2. Verknüpft die Knoten des Syntaxbaums. (setzt Parent)
|
2014-04-09 12:12:55 +00:00
|
|
|
* 3. Wechselt RefTypes gegebenenfalls mit GenericTypeVars aus.
|
2015-05-12 17:49:27 +00:00
|
|
|
* 4. Führt einen Teil des Syntaxckecks durch.
|
2014-02-11 15:30:38 +00:00
|
|
|
*
|
|
|
|
*/
|
2014-02-12 01:12:12 +00:00
|
|
|
public void parserPostProcessing(SyntaxTreeNode parent) {
|
2015-08-26 12:48:51 +00:00
|
|
|
if(parent == null)throw new NullPointerException();
|
2014-02-12 01:12:12 +00:00
|
|
|
this.parent = parent;
|
2014-09-09 09:15:10 +00:00
|
|
|
for(SyntaxTreeNode node : this.getChildren())
|
|
|
|
if(node!=null)node.parserPostProcessing(this);
|
2014-02-12 01:12:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public SyntaxTreeNode getParent() {
|
2015-08-26 12:48:51 +00:00
|
|
|
//if(this.parent == null)throw new NullPointerException();
|
2014-02-12 01:12:12 +00:00
|
|
|
return this.parent;
|
|
|
|
}
|
2014-02-11 15:30:38 +00:00
|
|
|
|
2015-04-22 19:40:22 +00:00
|
|
|
public abstract Menge<? extends SyntaxTreeNode> getChildren();
|
2014-02-14 16:31:55 +00:00
|
|
|
|
2016-09-09 22:40:17 +00:00
|
|
|
/*
|
2014-02-14 16:31:55 +00:00
|
|
|
public Class getParentClass(){
|
|
|
|
SyntaxTreeNode parent = this.getParent();
|
|
|
|
if(parent instanceof Class)return (Class)parent;
|
2014-04-23 23:53:35 +00:00
|
|
|
if(parent == null)
|
|
|
|
throw new DebugException("Das Wurzelelement eines Syntaxbaumes muss Class sein");
|
2014-02-14 16:31:55 +00:00
|
|
|
return parent.getParentClass();
|
|
|
|
}
|
2016-09-09 22:40:17 +00:00
|
|
|
*/
|
2014-03-12 14:27:26 +00:00
|
|
|
/**
|
|
|
|
* Eine Beschreibung/Name des SyntaxTree-Nodes
|
2016-04-07 12:53:29 +00:00
|
|
|
* Hat nichts mit der Description im Bytecode zu tun,
|
|
|
|
* wird für die Anzeige des AST im Plugin verwendet
|
2014-03-12 14:27:26 +00:00
|
|
|
* @return
|
|
|
|
*/
|
2016-04-07 12:53:29 +00:00
|
|
|
public String getDescription(){
|
2014-03-12 14:27:26 +00:00
|
|
|
return this.toString();
|
|
|
|
}
|
2014-03-14 15:34:25 +00:00
|
|
|
|
2014-04-09 12:12:55 +00:00
|
|
|
|
2014-03-14 15:34:25 +00:00
|
|
|
@Override
|
|
|
|
public boolean equals(Object object){
|
|
|
|
if(!(object instanceof SyntaxTreeNode))return false;
|
|
|
|
SyntaxTreeNode equal = (SyntaxTreeNode)object;
|
2016-04-07 12:53:29 +00:00
|
|
|
if(!equal.getDescription().equals(this.getDescription()))return false;
|
2014-03-17 16:55:55 +00:00
|
|
|
if(this.getParent()!=null)
|
2015-05-12 17:49:27 +00:00
|
|
|
if(!this.getParent().equals(equal.getParent()))return false; //auch das Elternelement überprüfen.
|
2014-03-14 15:34:25 +00:00
|
|
|
return true;
|
|
|
|
}
|
2014-04-26 17:33:26 +00:00
|
|
|
|
2014-05-07 07:36:31 +00:00
|
|
|
/**
|
|
|
|
* Methode zur Generierung der TypeInsertPoints
|
2015-05-12 17:49:27 +00:00
|
|
|
* @param insertSet - Generierte InsertPoints werden dem insertSet angefügt
|
2014-05-07 07:36:31 +00:00
|
|
|
* @param result - Das ResultSet auf dessen Basis die InsertPoints generiert werden
|
|
|
|
*/
|
|
|
|
public void addTypeInsertPoints(TypeInsertSet insertSet,ResultSet result) {
|
2014-05-07 11:01:14 +00:00
|
|
|
for(SyntaxTreeNode node : this.getChildren()){
|
|
|
|
node.addTypeInsertPoints(insertSet, result);
|
|
|
|
}
|
|
|
|
|
2015-05-12 17:49:27 +00:00
|
|
|
TypeInsertPoint tip = null; //Der TypInsertPoint für diesen Knoten
|
2014-05-07 06:10:55 +00:00
|
|
|
//Fall der Knoten ein TypeInsertable ist, kann direkt der TypeInsertPoint generiert werden.
|
|
|
|
if(this instanceof TypeInsertable){
|
|
|
|
TypeInsertable that = (TypeInsertable)this;
|
|
|
|
Type t = that.getType();
|
2014-05-07 11:01:14 +00:00
|
|
|
if(t instanceof TypePlaceholder){
|
|
|
|
tip = that.createTypeInsertPoint((TypePlaceholder) t, result);
|
|
|
|
insertSet.add(tip);//ret.addAll(((TypePlaceholder)t).getTypeInsertPoints(result));
|
|
|
|
}
|
2014-06-25 15:30:31 +00:00
|
|
|
/*
|
2015-05-12 17:49:27 +00:00
|
|
|
//Für den Fall, dass dieser Knoten Generische Variablen halten kann.
|
2014-05-07 11:01:14 +00:00
|
|
|
if(that instanceof Generic && that.getOffset()>=0){
|
|
|
|
//Alle unresolvedTPHs ermitteln und GenericTypeVarInsertPoints bilden:
|
2015-04-22 19:40:22 +00:00
|
|
|
Menge<TypePlaceholder> uTPHs = insertSet.getUnresolvedTPHs();
|
2014-06-25 15:30:31 +00:00
|
|
|
|
2014-05-07 11:01:14 +00:00
|
|
|
if(uTPHs.size()>0){//Nur wenn es auch unresolvedTPHs gibt:
|
2015-04-22 19:40:22 +00:00
|
|
|
Menge<Pair> gPairs = result.getConstraintsFor(uTPHs);
|
2014-05-07 11:01:14 +00:00
|
|
|
if(gPairs.size()>0){
|
|
|
|
GenericTypeInsertPoint genericTIP = new GenericTypeInsertPoint(that,gPairs,result);
|
|
|
|
insertSet.add(genericTIP);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-06-25 15:30:31 +00:00
|
|
|
*/
|
2014-05-07 07:36:31 +00:00
|
|
|
}
|
2014-05-07 11:01:14 +00:00
|
|
|
|
2014-09-10 21:32:36 +00:00
|
|
|
|
2014-04-26 17:33:26 +00:00
|
|
|
}
|
2014-07-23 15:24:08 +00:00
|
|
|
|
|
|
|
public boolean seesType(Type tA2) {
|
|
|
|
//TODO: Implementieren. Hier sollte ein Lookup in die Assumptions dieses Knotens erfolgen
|
|
|
|
return false;
|
|
|
|
}
|
2015-02-24 16:06:14 +00:00
|
|
|
|
|
|
|
public SyntaxTreeNode getMatchingParentNode(SyntaxTreeNode inNode) {
|
|
|
|
SyntaxTreeNode node = inNode;
|
|
|
|
while(node!=null){
|
|
|
|
if(node.equals(this))return this;
|
|
|
|
node = inNode.getParent();
|
|
|
|
}
|
|
|
|
if(this.getParent()!=null)return this.getParent().getMatchingParentNode(inNode);
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
public GTVDeclarationContext getGTVDeclarationContext(){
|
2015-08-26 12:48:51 +00:00
|
|
|
if(this.getParent()==null)
|
|
|
|
throw new NullPointerException();//throw new DebugException("getGTVDeclarationContext auf unzulässiger Klasse aufgerufen");
|
2015-02-24 16:06:14 +00:00
|
|
|
return this.getParent().getGTVDeclarationContext();
|
|
|
|
}
|
|
|
|
|
2015-06-16 11:53:32 +00:00
|
|
|
|
2014-02-11 01:47:39 +00:00
|
|
|
}
|