From 8cbd22f56210ea85cb56770620c0da5efb7763b7 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Tue, 11 Feb 2014 16:30:38 +0100 Subject: [PATCH] =?UTF-8?q?SyntaxTreeNode=20angef=C3=BCgt.=20SourceFile=20?= =?UTF-8?q?steht=20nun=20nur=20noch=20f=C3=BCr=20eine=20Java-Datei=20nicht?= =?UTF-8?q?=20mehr=20f=C3=BCr=20mehrere.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mycompiler/MyCompiler.java | 125 +++++++++++------- src/mycompiler/MyCompilerAPI.java | 18 +-- src/mycompiler/SourceFile.java | 90 +++++++++---- src/mycompiler/SyntaxTreeNode.java | 13 ++ src/mycompiler/myclass/Class.java | 17 +++ src/mycompiler/myclass/Field.java | 9 +- src/mycompiler/myclass/FieldDecl.java | 2 +- src/mycompiler/myclass/FormalParameter.java | 17 +-- src/mycompiler/myclass/Method.java | 8 +- src/mycompiler/myparser/JavaParser.java | 2 +- src/mycompiler/mystatement/Assign.java | 14 +- src/mycompiler/mystatement/Block.java | 12 +- src/mycompiler/mystatement/ExprStmt.java | 13 +- src/mycompiler/mystatement/IfStmt.java | 12 +- src/mycompiler/mystatement/InstVar.java | 2 +- src/mycompiler/mystatement/IntLiteral.java | 4 +- .../mystatement/LambdaExpression.java | 14 +- .../mystatement/LocalOrFieldVar.java | 12 +- src/mycompiler/mystatement/LocalVarDecl.java | 10 +- src/mycompiler/mystatement/LongLiteral.java | 2 +- src/mycompiler/mystatement/MethodCall.java | 12 +- src/mycompiler/mystatement/NewClass.java | 8 +- src/mycompiler/mystatement/Return.java | 6 +- src/mycompiler/mystatement/Statement.java | 31 ++--- src/mycompiler/mystatement/This.java | 2 +- src/mycompiler/mystatement/WhileStmt.java | 4 +- src/typinferenz/Overloading.java | 4 +- .../{Typable.java => Typeable.java} | 6 +- 28 files changed, 264 insertions(+), 205 deletions(-) rename src/typinferenz/{Typable.java => Typeable.java} (86%) diff --git a/src/mycompiler/MyCompiler.java b/src/mycompiler/MyCompiler.java index 5f266c90..eb9ead73 100755 --- a/src/mycompiler/MyCompiler.java +++ b/src/mycompiler/MyCompiler.java @@ -41,6 +41,7 @@ import mycompiler.mytypereconstruction.TypeinferenceResultSet; import org.apache.log4j.Logger; import org.apache.log4j.xml.DOMConfigurator; +import com.sun.corba.se.spi.orbutil.fsm.Guard.Result; import com.sun.org.apache.xerces.internal.impl.xs.identity.Field; import typinferenz.TypinferenzException; @@ -97,7 +98,7 @@ public class MyCompiler implements MyCompilerAPI */ // ino.end // ino.attribute.m_AbstractSyntaxTree.21280.declaration - private SourceFile m_AbstractSyntaxTree; + private Vector m_AbstractSyntaxTree = new Vector(); // ino.end // ino.method.MyCompiler.21283.defdescription type=javadoc @@ -248,11 +249,12 @@ public class MyCompiler implements MyCompilerAPI */ // ino.end // ino.method.parse.21292.definition - private void parse(Reader reader) + private void parse_backup(Reader reader) throws IOException, JavaParser.yyException // ino.end // ino.method.parse.21292.body { + /* parserlog.info("#########################################"); parserlog.info("# Parsen - START #"); parserlog.info("#########################################\n"); @@ -459,6 +461,7 @@ public class MyCompiler implements MyCompilerAPI parserlog.info("#########################################"); parserlog.info("# Parsen - ENDE #"); parserlog.info("#########################################\n"); + */ } // end Methode parse() // ino.end @@ -501,32 +504,11 @@ public class MyCompiler implements MyCompilerAPI // ino.method.parse.21298.body { FileReader fr = new FileReader(file); - this.parse(fr); + this.m_AbstractSyntaxTree.add(this.parse2SyntaxTree(file.getName(), fr)); fr.close(); } // ino.end - - // ino.method.parse.21301.defdescription type=javadoc - /** - * Author: J�rg B�uerle
- * Ruft die Parse-Methode. - * @param srcCode Der zu parsende Quellcode - * @throws IOException Wenn was schief l�uft. - * @throws JavaParser.yyException Wenn ein Fehler beim Parsen auftritt. - */ - // ino.end - // ino.method.parse.21301.definition - public void parse(String srcCode) - throws IOException, yyException - // ino.end - // ino.method.parse.21301.body - { - StringReader sr = new StringReader(srcCode); - this.parse(sr); - sr.close(); - } - // ino.end - + // ino.method.typeReconstruction.21304.defdescription type=javadoc /** * Author: J�rg B�uerle
@@ -550,10 +532,13 @@ public class MyCompiler implements MyCompilerAPI inferencelog.info("# TypeReconstruction-Algorithmus - START #"); inferencelog.info("##########################################\n"); - TypeAssumptions globalAssumptions = m_AbstractSyntaxTree.makeBasicAssumptions(); + TypeAssumptions globalAssumptions = m_AbstractSyntaxTree.elementAt(0).makeBasicAssumptions(); + Vector result = new Vector(); + for(SourceFile srcFile : m_AbstractSyntaxTree){ + result.addAll(srcFile.typeReconstruction(globalAssumptions)); + + } - Vector result = m_AbstractSyntaxTree.typeReconstruction(globalAssumptions); - inferencelog.info("#########################################"); inferencelog.info("# TypeReconstruction-Algorithmus - ENDE #"); inferencelog.info("#########################################\n"); @@ -562,23 +547,7 @@ public class MyCompiler implements MyCompilerAPI } // ino.end - // ino.method.getSyntaxTree.21307.defdescription type=javadoc - /** - * Author: J�rg B�uerle
- * Liefert den geparsten Syntaxbaume zur�ck. - * @return Die Syntaxb�ume - * @throws NullPointerException Wenn noch keine Syntaxb�ume berechnet worden sind. - */ - // ino.end - // ino.method.getSyntaxTree.21307.definition - public SourceFile getSyntaxTree() - throws NullPointerException - // ino.end - // ino.method.getSyntaxTree.21307.body - { - return m_AbstractSyntaxTree; - } - // ino.end + // ino.method.codeGeneration.21310.defdescription type=javadoc /** @@ -599,7 +568,7 @@ public class MyCompiler implements MyCompilerAPI } codegenlog.info("Beginn der Codegenerierung ..."); - m_AbstractSyntaxTree.codegen(); + //m_AbstractSyntaxTree.codegen(); codegenlog.info("Codegenerierung beendet!"); } @@ -778,9 +747,69 @@ public class MyCompiler implements MyCompilerAPI } /** - * Alle übergebenen Dateien werden zu einem String zusammengefügt und gemeinsam in einer SourceFile geparst. + * Parst den Inhalt einer Datei zu einem Syntaxbaum. + */ + private SourceFile parse2SyntaxTree(String filename, Reader fileContent){ + + //StringReader reader = new StringReader(fileContent); + ////////////////////////////////////// + // Scanner und Parser erzeugen: + ////////////////////////////////////// + Scanner scanner = new Scanner(fileContent); + JavaParser parser = new JavaParser(); + + ////////////////////////////////////// + // Parsen ==> Ergebnis: srcFile + ////////////////////////////////////// + SourceFile srcFile = null; + try { + srcFile = (SourceFile) parser.yyparse( scanner ); + } catch (IOException | yyException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + ////////////////////////////////////// + // Postprocessing: + ////////////////////////////////////// + srcFile.setFileName(filename); + srcFile.parserPostProcessing(null); //Muss mit null aufgerufen werden. + //Fertig: + return srcFile; + } + + /** + * Diese Funktion nimmt einen Vector von Dateinamen. Alle diese Dateien werden zu einem SyntaxBaum geparst. */ public void parse(Vector filenames) { + + for(String filename : filenames){ + StringBuffer fileData = new StringBuffer(); + BufferedReader reader; + try { + reader = new BufferedReader( + new FileReader(filename)); + } catch (FileNotFoundException e) { + throw new TypinferenzException("Die Datei "+ filename+" konnte nicht gelesen werden."); + } + char[] buf = new char[1024]; + int numRead=0; + try { + while((numRead=reader.read(buf)) != -1){ + String readData = String.valueOf(buf, 0, numRead); + fileData.append(readData); + } + reader.close(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + StringReader srcreader = new StringReader(fileData.toString()); + //Den aus der Datei ausgelesenen Quellcode zu einem Syntaxbaum parsen: + this.m_AbstractSyntaxTree.add(parse2SyntaxTree(filename,srcreader)); // Alle Dateien nacheinander hintereinander anhängen... + + } + /* String gesamterSrc = ""; //Hier werden alle übergebenen Dateinamen abgearbeitet: for(String filename : filenames){ @@ -811,7 +840,7 @@ public class MyCompiler implements MyCompilerAPI //throw new TypinferenzException("Fehler beim Parsen"); } + */ } - } // ino.end diff --git a/src/mycompiler/MyCompilerAPI.java b/src/mycompiler/MyCompilerAPI.java index 11d985f5..2d18b201 100755 --- a/src/mycompiler/MyCompilerAPI.java +++ b/src/mycompiler/MyCompilerAPI.java @@ -61,13 +61,14 @@ public interface MyCompilerAPI * @param srcCode Der zu parsende Quellcode * @throws IOException Wenn was schief läuft. * @throws JavaParser.yyException Wenn ein Fehler beim Parsen auftritt. - */ + // ino.end // ino.method.parse.21337.declaration public void parse(String srcCode) throws IOException, JavaParser.yyException; // ino.end - + */ + // ino.method.typeReconstruction.21340.decldescription type=javadoc /** * Author: Jörg Bäuerle
@@ -83,19 +84,6 @@ public interface MyCompilerAPI throws NullPointerException, CTypeReconstructionException; // ino.end - // ino.method.getSyntaxTree.21343.decldescription type=javadoc - /** - * Author: Jörg Bäuerle
- * Liefert den geparsten Syntaxbaum zurück. - * @return Die Syntaxbäume - * @throws NullPointerException Wenn noch kein Syntaxbaum berechnet worden ist. - */ - // ino.end - // ino.method.getSyntaxTree.21343.declaration - public SourceFile getSyntaxTree() - throws NullPointerException; - // ino.end - // ino.method.codeGeneration.21346.decldescription type=javadoc /** * Author: Jörg Bäuerle
diff --git a/src/mycompiler/SourceFile.java b/src/mycompiler/SourceFile.java index 6001aaba..fc60a2ae 100755 --- a/src/mycompiler/SourceFile.java +++ b/src/mycompiler/SourceFile.java @@ -42,6 +42,7 @@ import sun.reflect.generics.reflectiveObjects.NotImplementedException; import sun.reflect.generics.reflectiveObjects.TypeVariableImpl; import typinferenz.ConstraintsSet; import typinferenz.FunN; +import typinferenz.TypinferenzException; import typinferenz.UndConstraint; import typinferenz.assumptions.TypeAssumptions; @@ -50,6 +51,7 @@ import typinferenz.assumptions.TypeAssumptions; // ino.class.SourceFile.21355.declaration public class SourceFile + implements SyntaxTreeNode // ino.end // ino.class.SourceFile.21355.body { @@ -121,37 +123,13 @@ public class SourceFile // ino.attribute.InterfaceVektor.21379.declaration public Vector InterfaceVektor = new Vector(); // ino.end - - // ino.attribute.imports.21382.decldescription type=javadoc + private String filename; /** - * HOTI 4.5.06 - * Beinhaltet alle Imports des aktuell geparsten Files - * in Form einer UsedId + * Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei. + * SourceFile stellt dabei den Wurzelknoten des Syntaxbaumes dar. */ - // ino.end - // ino.attribute.imports.21382.declaration - private ImportDeclarations imports=new ImportDeclarations(); - // ino.end - // ino.attribute.baseTypeTranslationTable.21385.decldescription type=javadoc - /** - * Table zum Übersetzen der nicht implementierten Base-Types: - * Überall im Compiler wird statt bspw. int Integer verwendet - * d.h. 1+2 liefert ein Integer - * Deshalb benötigen wir hier eine Tabelle, mit der man die von - * der JRE gelieferten Base-Typen (int,char, etc) und die Objekt- - * Typen umwandeln können - */ - // ino.end - // ino.attribute.baseTypeTranslationTable.21385.declaration - private Hashtable baseTypeTranslationTable; - // ino.end - - // ino.method.SourceFile.21388.definition - public SourceFile() - // ino.end - // ino.method.SourceFile.21388.body - { - // HOTI 4.5.06 + public SourceFile(){ + // HOTI 4.5.06 // Base-Type-Translations anlegen (siehe kommentar BaseTypeTranslationTable) baseTypeTranslationTable=new Hashtable(); baseTypeTranslationTable.put("int","java.lang.Integer"); @@ -180,7 +158,32 @@ public class SourceFile this.imports.add(UsedId.createFromQualifiedName("java.lang.Object",-1)); } } + + // ino.attribute.imports.21382.decldescription type=javadoc + /** + * HOTI 4.5.06 + * Beinhaltet alle Imports des aktuell geparsten Files + * in Form einer UsedId + */ // ino.end + // ino.attribute.imports.21382.declaration + private ImportDeclarations imports=new ImportDeclarations(); + // ino.end + // ino.attribute.baseTypeTranslationTable.21385.decldescription type=javadoc + /** + * Table zum Übersetzen der nicht implementierten Base-Types: + * Überall im Compiler wird statt bspw. int Integer verwendet + * d.h. 1+2 liefert ein Integer + * Deshalb benötigen wir hier eine Tabelle, mit der man die von + * der JRE gelieferten Base-Typen (int,char, etc) und die Objekt- + * Typen umwandeln können + */ + // ino.end + // ino.attribute.baseTypeTranslationTable.21385.declaration + private Hashtable baseTypeTranslationTable; + // ino.end + + // ino.method.addElement.21394.defdescription type=javadoc @@ -1498,5 +1501,34 @@ public class SourceFile } // ino.end + + @Override + public void parserPostProcessing(SyntaxTreeNode parent) { + if(parent!=null)throw new TypinferenzException("Eine SourceFile hat keine Elternelement im Syntaxbaum"); + } + + + @Override + public SyntaxTreeNode getParent() { + // TODO Auto-generated method stub + return null; + } + + + @Override + public Vector getChildren() { + // TODO Auto-generated method stub + return null; + } + + + /** + * SourceFile stellt eine geparste Java-Datei dar. Mit dieser Methode wird der Name der eingelesenen Datei gesetzt. + * @param filename - Der Name der eingelesenen JavaDatei + */ + public void setFileName(String filename) { + this.filename = filename; + } + } // ino.end diff --git a/src/mycompiler/SyntaxTreeNode.java b/src/mycompiler/SyntaxTreeNode.java index 635ceafd..d96b2c03 100644 --- a/src/mycompiler/SyntaxTreeNode.java +++ b/src/mycompiler/SyntaxTreeNode.java @@ -1,5 +1,18 @@ package mycompiler; +import java.util.Vector; + public interface SyntaxTreeNode { + /** + * Wird nach dem Parsen aufgerufen. + * Erfüllt folgenden Aufgaben: + * 1. Füllt fehlende Typangaben mit TPHs auf. + * 2. Verknüpft die Knoten des Syntaxbaums. (setzt Parent) + * + */ + public void parserPostProcessing(SyntaxTreeNode parent); + + public SyntaxTreeNode getParent(); + public Vector getChildren(); } diff --git a/src/mycompiler/myclass/Class.java b/src/mycompiler/myclass/Class.java index 6a7295c4..d4c7019b 100755 --- a/src/mycompiler/myclass/Class.java +++ b/src/mycompiler/myclass/Class.java @@ -115,6 +115,7 @@ public class Class extends AClassOrInterface implements SyntaxTreeNode protected Logger parselog = Logger.getLogger("parser"); // ino.end protected Logger typinferenzLog = Logger.getLogger("Typeinference"); + private SyntaxTreeNode parent; // ino.method.Class.23041.definition @@ -1129,6 +1130,22 @@ public class Class extends AClassOrInterface implements SyntaxTreeNode TypeAssumptions ret = this.getTypeAssumptions(); return ret; } + + @Override + public void parserPostProcessing(SyntaxTreeNode parent) { + this.parent = parent; + } + + @Override + public SyntaxTreeNode getParent() { + return null; + } + + @Override + public Vector getChildren() { + // TODO Auto-generated method stub + return null; + } } // ino.end diff --git a/src/mycompiler/myclass/Field.java b/src/mycompiler/myclass/Field.java index 7bbe9d4e..0e313424 100644 --- a/src/mycompiler/myclass/Field.java +++ b/src/mycompiler/myclass/Field.java @@ -2,28 +2,29 @@ package mycompiler.myclass; import java.util.Vector; +import mycompiler.SyntaxTreeNode; import mycompiler.mybytecode.ClassFile; import mycompiler.myexception.JVMCodeException; import mycompiler.mytype.Type; import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent; import typinferenz.JavaCodeResult; import typinferenz.ResultSet; -import typinferenz.Typable; +import typinferenz.Typeable; import typinferenz.TypeInsertable; import typinferenz.assumptions.TypeAssumptions; -public abstract class Field implements TypeInsertable, Typable{ +public abstract class Field implements TypeInsertable, Typeable, SyntaxTreeNode{ // ino.attribute.declid.23370.declaration protected Vector declid = new Vector(); // Vector, da 'int a, b, c, ...' auch eingeparst werden muss private Type typ; @Override - public void setTypeVariable(Type typ) { + public void setType(Type typ) { this.typ = typ; } @Override - public Type getTypeVariable() { + public Type getType() { return typ; } diff --git a/src/mycompiler/myclass/FieldDecl.java b/src/mycompiler/myclass/FieldDecl.java index cbc1c278..d994b567 100755 --- a/src/mycompiler/myclass/FieldDecl.java +++ b/src/mycompiler/myclass/FieldDecl.java @@ -6,7 +6,7 @@ import java.util.Vector; import typinferenz.JavaCodeResult; import typinferenz.ResultSet; -import typinferenz.Typable; +import typinferenz.Typeable; import typinferenz.TypeInsertable; import typinferenz.assumptions.TypeAssumptions; import mycompiler.mybytecode.ClassFile; diff --git a/src/mycompiler/myclass/FormalParameter.java b/src/mycompiler/myclass/FormalParameter.java index c9400e46..1ab559d8 100755 --- a/src/mycompiler/myclass/FormalParameter.java +++ b/src/mycompiler/myclass/FormalParameter.java @@ -16,11 +16,11 @@ import org.apache.log4j.Logger; import typinferenz.JavaCodeResult; import typinferenz.ResultSet; -import typinferenz.Typable; +import typinferenz.Typeable; import typinferenz.TypeInsertable; // ino.class.FormalParameter.23391.declaration -public class FormalParameter implements ITypeReplacementListener, Typable, TypeInsertable +public class FormalParameter implements ITypeReplacementListener, Typeable, TypeInsertable // ino.end // ino.class.FormalParameter.23391.body { @@ -180,21 +180,14 @@ public class FormalParameter implements ITypeReplacementListener, Typable, TypeI //private Type typeVariable; - public void setTypeVariable(Type typ) { - this.setType(typ); - } - public Type getTypeVariable() { - return this.getType(); - } - public String getTypeInformation() { - return getTypeVariable().toString() + " " +this.get_Name(); + return getType().toString() + " " +this.get_Name(); } @Override public String toString(){ String ret = ""; - if(this.getTypeVariable() != null)ret += this.getTypeVariable().toString(); + if(this.getType() != null)ret += this.getType().toString(); if(this.get_Name() != null)ret += " "+get_Name(); return ret; } @@ -202,7 +195,7 @@ public class FormalParameter implements ITypeReplacementListener, Typable, TypeI public JavaCodeResult printJavaCode(ResultSet resultSet) { JavaCodeResult ret = new JavaCodeResult(); - if(this.getTypeVariable() != null)ret.attach(this.getTypeVariable().printJavaCode(resultSet)); + if(this.getType() != null)ret.attach(this.getType().printJavaCode(resultSet)); if(this.get_Name() != null)ret.attach(" "+get_Name()); return ret; diff --git a/src/mycompiler/myclass/Method.java b/src/mycompiler/myclass/Method.java index c4c88e5d..bf27fa25 100755 --- a/src/mycompiler/myclass/Method.java +++ b/src/mycompiler/myclass/Method.java @@ -197,7 +197,7 @@ public class Method extends Field implements ITypeReplacementListener, IItemWith // this.returntype = type; //auskommentiert von Andreas Stadelmeier (a10023) //Der ReturnType der Methode ist der Returntype des Methodenblocks: if(block!=null) - this.block.setTypeVariable(type); + this.block.setType(type); this.returntype = type; } // ino.end @@ -207,7 +207,7 @@ public class Method extends Field implements ITypeReplacementListener, IItemWith // ino.end // ino.method.set_Block.23542.body { - if(blo.getTypeVariable() == null)blo.setTypeVariable(this.returntype); + if(blo.getType() == null)blo.setType(this.returntype); this.block = blo; } // ino.end @@ -306,7 +306,7 @@ public class Method extends Field implements ITypeReplacementListener, IItemWith // ino.end // ino.method.getReturnType.23569.body { - return this.block.getTypeVariable(); + return this.block.getType(); //return this.returntype; //auskommentiert von Andreas Stadelmeier (a10023) } // ino.end @@ -549,7 +549,7 @@ public class Method extends Field implements ITypeReplacementListener, IItemWith ret.add(this.block.TYPEStmt(ass)); //eine Verknüpfung mit der Type Assumption aus dem Assumption Set und dem ermittelten Typ der Methode: - ret.add(new SingleConstraint(this.block.getTypeVariable(), assumedType)); + ret.add(new SingleConstraint(this.block.getType(), assumedType)); return ret; } diff --git a/src/mycompiler/myparser/JavaParser.java b/src/mycompiler/myparser/JavaParser.java index eeee109c..cf8ab5a8 100644 --- a/src/mycompiler/myparser/JavaParser.java +++ b/src/mycompiler/myparser/JavaParser.java @@ -1383,7 +1383,7 @@ case 79: case 80: // line 884 "./../src/mycompiler/myparser/JavaParser.jay" { - ((FieldDeclaration)yyVals[0+yyTop]).setTypeVariable(((Type)yyVals[-1+yyTop])); + ((FieldDeclaration)yyVals[0+yyTop]).setType(((Type)yyVals[-1+yyTop])); yyVal=((FieldDeclaration)yyVals[0+yyTop]); } break; diff --git a/src/mycompiler/mystatement/Assign.java b/src/mycompiler/mystatement/Assign.java index c117c66e..2a9a9b1d 100755 --- a/src/mycompiler/mystatement/Assign.java +++ b/src/mycompiler/mystatement/Assign.java @@ -196,9 +196,9 @@ public class Assign extends Expr ret.add(expr1.TYPEExpr(assumptions)); ret.add(expr2.TYPEExpr(assumptions)); //this.setTypeVariable( TypePlaceholder.fresh(this)); - this.setTypeVariable(TypePlaceholder.fresh(this)); - ret.add(new SingleConstraint(expr2.getTypeVariable(), expr1.getTypeVariable())); //expr1.type < expr2.type - ret.add(new SingleConstraint(expr1.getTypeVariable(), this.getTypeVariable())); + this.setType(TypePlaceholder.fresh(this)); + ret.add(new SingleConstraint(expr2.getType(), expr1.getType())); //expr1.type < expr2.type + ret.add(new SingleConstraint(expr1.getType(), this.getType())); return ret; } @@ -211,7 +211,7 @@ public class Assign extends Expr @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){ ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen - this.setTypeVariable(new Void(0)); //Typ des Statments auf Void setzen. + this.setType(new Void(0)); //Typ des Statments auf Void setzen. return ret; } @@ -228,8 +228,8 @@ public class Assign extends Expr // ino.end // ino.method.toString.24960.body { - if(getTypeVariable() == null)return "(" + expr1.toString() + " = " + expr2.toString() + ")"; - return getTypeVariable().toString() + "(" + expr1.toString() + " = " + expr2.toString() + ")"; + if(getType() == null)return "(" + expr1.toString() + " = " + expr2.toString() + ")"; + return getType().toString() + "(" + expr1.toString() + " = " + expr2.toString() + ")"; } // ino.end @@ -250,7 +250,7 @@ public class Assign extends Expr @Override public String getTypeInformation(){ - return "(" + expr1.getTypeInformation() + " = " + expr2.getTypeInformation() + ") : "+this.getTypeVariable(); + return "(" + expr1.getTypeInformation() + " = " + expr2.getTypeInformation() + ") : "+this.getType(); } @Override diff --git a/src/mycompiler/mystatement/Block.java b/src/mycompiler/mystatement/Block.java index 6ea730da..074d3410 100755 --- a/src/mycompiler/mystatement/Block.java +++ b/src/mycompiler/mystatement/Block.java @@ -233,20 +233,20 @@ public class Block extends Statement if(statements.size()>0){ Statement stmt = statements.elementAt(statements.size()-1); typinferenceLog.debug("Prozessing statement: "+stmt); - this.setTypeVariable(stmt.getTypeVariable()); + this.setType(stmt.getType()); for(int i= statements.size()-2; i >= 0; i--) { stmt = statements.elementAt(i); typinferenceLog.debug("Prozessing statement: "+stmt); - if (!(stmt.getTypeVariable() instanceof Void)) - if (this.getTypeVariable() instanceof Void) { + if (!(stmt.getType() instanceof Void)) + if (this.getType() instanceof Void) { //this.setTypeVariable(stmt.getTypeVariable()); throw new TypinferenzException("Falscher Return Type"); } else { TypePlaceholder tph = TypePlaceholder.fresh(this); - ret.add(new SingleConstraint(this.getTypeVariable(), tph)); - ret.add(new SingleConstraint(stmt.getTypeVariable(), tph)); - this.setTypeVariable(tph); + ret.add(new SingleConstraint(this.getType(), tph)); + ret.add(new SingleConstraint(stmt.getType(), tph)); + this.setType(tph); } } if (this.type instanceof TypePlaceholder) { diff --git a/src/mycompiler/mystatement/ExprStmt.java b/src/mycompiler/mystatement/ExprStmt.java index f39b0c7e..08eb65d9 100755 --- a/src/mycompiler/mystatement/ExprStmt.java +++ b/src/mycompiler/mystatement/ExprStmt.java @@ -46,22 +46,13 @@ public abstract class ExprStmt extends Statement implements ITypeReplacementList // ino.end // ino.method.getTypeName.25279.body { - if (getTypeVariable()!=null) - return getTypeVariable().getName(); + if (getType()!=null) + return getType().getName(); else return null; } // ino.end - // ino.method.getType.25282.definition - public Type getType() - // ino.end - // ino.method.getType.25282.body - { - return getTypeVariable(); - } - // ino.end - // ino.method.getTypeLineNumber.25291.defdescription type=javadoc diff --git a/src/mycompiler/mystatement/IfStmt.java b/src/mycompiler/mystatement/IfStmt.java index f93541e8..b869eb90 100755 --- a/src/mycompiler/mystatement/IfStmt.java +++ b/src/mycompiler/mystatement/IfStmt.java @@ -379,18 +379,18 @@ public class IfStmt extends Statement @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); - this.setTypeVariable(TypePlaceholder.fresh(this)); + this.setType(TypePlaceholder.fresh(this)); ret.add(expr.TYPEExpr(assumptions)); // die Constraints für (expressionDesIfStmt) ret.add(this.then_block.TYPEStmt(assumptions)); if(else_block!=null){ ret.add(this.else_block.TYPEStmt(assumptions)); - if(!(else_block.getTypeVariable() instanceof Void))ret.add(new SingleConstraint(else_block.getTypeVariable(),this.getTypeVariable())); + if(!(else_block.getType() instanceof Void))ret.add(new SingleConstraint(else_block.getType(),this.getType())); } - ret.add(new SingleConstraint(expr.getTypeVariable(),new RefType("boolean",0))); //(expressionDesIfStmt)<.boolean - if(!(then_block.getTypeVariable() instanceof Void))ret.add(new SingleConstraint(then_block.getTypeVariable(),this.getTypeVariable())); - if(then_block.getTypeVariable() instanceof Void && - (else_block == null || else_block.getTypeVariable() instanceof Void))this.setTypeVariable(new Void(this.getOffset())); + ret.add(new SingleConstraint(expr.getType(),new RefType("boolean",0))); //(expressionDesIfStmt)<.boolean + if(!(then_block.getType() instanceof Void))ret.add(new SingleConstraint(then_block.getType(),this.getType())); + if(then_block.getType() instanceof Void && + (else_block == null || else_block.getType() instanceof Void))this.setType(new Void(this.getOffset())); return ret; } diff --git a/src/mycompiler/mystatement/InstVar.java b/src/mycompiler/mystatement/InstVar.java index 61a5fabf..d196037b 100755 --- a/src/mycompiler/mystatement/InstVar.java +++ b/src/mycompiler/mystatement/InstVar.java @@ -266,7 +266,7 @@ public class InstVar extends Expr public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); ret.add(expr.TYPEExpr(assumptions)); - this.setTypeVariable(TypePlaceholder.fresh(this)); + this.setType(TypePlaceholder.fresh(this)); return null; } diff --git a/src/mycompiler/mystatement/IntLiteral.java b/src/mycompiler/mystatement/IntLiteral.java index bfee57ce..19976869 100755 --- a/src/mycompiler/mystatement/IntLiteral.java +++ b/src/mycompiler/mystatement/IntLiteral.java @@ -190,7 +190,7 @@ public class IntLiteral extends Literal // ino.end // ino.method.toString.25484.body { - return getTypeVariable().toString() + " " + Int; + return getType().toString() + " " + Int; } // ino.end // ino.method.wandleRefTypeAttributes2GenericAttributes.25487.definition @@ -204,7 +204,7 @@ public class IntLiteral extends Literal @Override public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); - this.setTypeVariable(new IntegerType()); + this.setType(new IntegerType()); return ret; } diff --git a/src/mycompiler/mystatement/LambdaExpression.java b/src/mycompiler/mystatement/LambdaExpression.java index ae943664..2e87d03c 100755 --- a/src/mycompiler/mystatement/LambdaExpression.java +++ b/src/mycompiler/mystatement/LambdaExpression.java @@ -9,7 +9,7 @@ import typinferenz.ConstraintsSet; import typinferenz.FreshTypeVariable; import typinferenz.FunN; import typinferenz.ResultSet; -import typinferenz.Typable; +import typinferenz.Typeable; import typinferenz.TypinferenzException; import typinferenz.assumptions.TypeAssumptions; import mycompiler.mybytecode.ClassFile; @@ -126,16 +126,16 @@ public class LambdaExpression extends Expr{ Vector paramTypes = new Vector(); for(FormalParameter param : params.formalparameter){ - if(param.getTypeVariable()==null)param.setTypeVariable(TypePlaceholder.fresh(this)); + if(param.getType()==null)param.setType(TypePlaceholder.fresh(this)); int offset = 0; //Jeder Parameter der LambdaExpression wird als CParaTypeAssumption der Assumption liste hinzugefügt: - ArgumentAssumptions.add(new CParaTypeAssumption("", "", offset, offset, param.get_Name(), param.getTypeVariable(), offset, offset, null)); - paramTypes.add(param.getTypeVariable()); + ArgumentAssumptions.add(new CParaTypeAssumption("", "", offset, offset, param.get_Name(), param.getType(), offset, offset, null)); + paramTypes.add(param.getType()); } - this.setTypeVariable(TypePlaceholder.fresh(this)); + this.setType(TypePlaceholder.fresh(this)); //ArgumentAssumptions + assumptions ergeben die Assumptions für die Statements innerhalb des Lambda-Bodys: ret.add(method_body.TYPEStmt(ArgumentAssumptions.add(assumptions))); //Es gibt die LambdaExpression nur mit einem Block als Method Body, nicht mit einer einzelnen Expression - ret.add(new SingleConstraint(new FunN(method_body.getTypeVariable(), paramTypes),this.getTypeVariable())); + ret.add(new SingleConstraint(new FunN(method_body.getType(), paramTypes),this.getType())); return ret; } @@ -146,7 +146,7 @@ public class LambdaExpression extends Expr{ @Override public String getTypeInformation(){ - return this.getTypeVariable().toString()+" :: ("+this.params.getTypeInformation()+ ") -> " +this.method_body.getTypeInformation(); + return this.getType().toString()+" :: ("+this.params.getTypeInformation()+ ") -> " +this.method_body.getTypeInformation(); } @Override diff --git a/src/mycompiler/mystatement/LocalOrFieldVar.java b/src/mycompiler/mystatement/LocalOrFieldVar.java index 3c7f9f47..db6b5973 100755 --- a/src/mycompiler/mystatement/LocalOrFieldVar.java +++ b/src/mycompiler/mystatement/LocalOrFieldVar.java @@ -145,8 +145,8 @@ public class LocalOrFieldVar extends Expr } // Falls noetig, Unboxing auf primitiven Typ! - if (this.getTypeVariable() instanceof RefType) { - RefType rt = (RefType) this.getTypeVariable(); + if (this.getType() instanceof RefType) { + RefType rt = (RefType) this.getType(); if (! rt.getPrimitiveFlag()) return; if (rt.getName().equalsIgnoreCase("java.lang.Integer")) { // Int Unboxen @@ -178,8 +178,8 @@ public class LocalOrFieldVar extends Expr // ino.end // ino.method.toString.25534.body { - if(getTypeVariable()==null)return usedid.toString(); - return usedid.toString() + ": " + getTypeVariable().toString(); + if(getType()==null)return usedid.toString(); + return usedid.toString() + ": " + getType().toString(); } // ino.end @@ -205,13 +205,13 @@ public class LocalOrFieldVar extends Expr ConstraintsSet ret = new ConstraintsSet(); //gibt es eine Assumption für den die LocalOrFieldVar-Variablen, dann folgendes ausführen: Type thisTypeAssumption = assumptions.getVarType(this.get_Name()); - this.setTypeVariable(thisTypeAssumption); + this.setType(thisTypeAssumption); //ret.add(new Constraint(thisTypeAssumption, this.getTypeVariable())); return ret; } public String getTypeInformation(){ - return this.getTypeVariable()+" "+this.get_Name(); + return this.getType()+" "+this.get_Name(); } diff --git a/src/mycompiler/mystatement/LocalVarDecl.java b/src/mycompiler/mystatement/LocalVarDecl.java index fd8bfd97..8d00c211 100755 --- a/src/mycompiler/mystatement/LocalVarDecl.java +++ b/src/mycompiler/mystatement/LocalVarDecl.java @@ -362,12 +362,12 @@ public class LocalVarDecl extends Statement implements ITypeReplacementListener // ino.end // ino.method.replaceType.25608.body { - if(e.getOldType().equals(this.getTypeVariable())){ + if(e.getOldType().equals(this.getType())){ inferencelog.debug("Ersetze Typ in LocalVarDecl \""+this.get_Name()+"\"\n"); - if(getTypeVariable() instanceof TypePlaceholder){ - ((TypePlaceholder)getTypeVariable()).removeReplacementListener(this); + if(getType() instanceof TypePlaceholder){ + ((TypePlaceholder)getType()).removeReplacementListener(this); } - this.setTypeVariable(e.getNewType()); + this.setType(e.getNewType()); } if(e.getOldType().equals(this.getDeclType())){ inferencelog.debug("Ersetze Typ in LocalVarDecl \""+this.get_Name()+"\"\n"); @@ -484,7 +484,7 @@ public class LocalVarDecl extends Statement implements ITypeReplacementListener if(this.getDeclType()==null || this.getDeclType() instanceof TypePlaceholder)this.setDeclType(TypePlaceholder.fresh(this)); assumptions.addInstVarAssumption(assumptions.getThisValue().getName(), this.get_Name(), this.getDeclType()); //assumptions.remove(null); // falls Variable mit diesem Namen bereits vorhanden. - this.setTypeVariable(new Void(0)); //Return typ einer Variablendeklaration ist Void + this.setType(new Void(0)); //Return typ einer Variablendeklaration ist Void return ret; } diff --git a/src/mycompiler/mystatement/LongLiteral.java b/src/mycompiler/mystatement/LongLiteral.java index 14267040..405d87a2 100755 --- a/src/mycompiler/mystatement/LongLiteral.java +++ b/src/mycompiler/mystatement/LongLiteral.java @@ -190,7 +190,7 @@ public class LongLiteral extends Literal // ino.end // ino.method.toString.25484.body { - return getTypeVariable().toString() + " " + Long; + return getType().toString() + " " + Long; } // ino.end // ino.method.wandleRefTypeAttributes2GenericAttributes.25487.definition diff --git a/src/mycompiler/mystatement/MethodCall.java b/src/mycompiler/mystatement/MethodCall.java index 9a6f2d2a..4296171a 100755 --- a/src/mycompiler/mystatement/MethodCall.java +++ b/src/mycompiler/mystatement/MethodCall.java @@ -259,13 +259,13 @@ public class MethodCall extends Expr // Auf eine TypePlaceholders-Variable (=> nichterkannte) kann kein Methodenaufruf ausgeführt werden // Es muss sich also um einen RefType handeln. Ansonsten gibt es einen Fehler - if(!(receiver.get_Expr().getTypeVariable() instanceof RefType)){ - throw new JVMCodeException("Es kann nur auf ein RefType ein Methodenaufruf ausgeführt werden ("+receiver+"["+receiver.get_Expr().getTypeVariable()+"])"); + if(!(receiver.get_Expr().getType() instanceof RefType)){ + throw new JVMCodeException("Es kann nur auf ein RefType ein Methodenaufruf ausgeführt werden ("+receiver+"["+receiver.get_Expr().getType()+"])"); } // HOTI 4.5.06 // Es handelt sich also um einen RefType. Der Klassenname wird nun bezogen - String receiverClassName=((RefType)receiver.get_Expr().getTypeVariable()).getTypeName(); + String receiverClassName=((RefType)receiver.get_Expr().getType()).getTypeName(); // Die richtige Methode wird gesucht und gesetzt called_method=getMethodFittingMethodCallAndClassname(receiverClassName); @@ -668,7 +668,7 @@ public class MethodCall extends Expr //Hier der Ablauf für einen Methodenaufruf: ConstraintsSet ret = new ConstraintsSet(); //Der Return-Type des MEthodenaufrufs ist zunächst unbekannt: - this.setTypeVariable(TypePlaceholder.fresh(this)); + this.setType(TypePlaceholder.fresh(this)); //Berechne die Constraints des Receivers if(receiver == null){ receiver = new Receiver(new This(0,0)); @@ -681,7 +681,7 @@ public class MethodCall extends Expr } //Noch das Overloading-Constraint anhängen: - ret.add(new Overloading(assumptions, this, this.getTypeVariable()).generateConsstraints()); + ret.add(new Overloading(assumptions, this, this.getType()).generateConsstraints()); return ret; } @@ -695,7 +695,7 @@ public class MethodCall extends Expr @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){ ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen - this.setTypeVariable(new Void(0)); //Typ des Statments auf Void setzen, da als alleinstehendes Statement + this.setType(new Void(0)); //Typ des Statments auf Void setzen, da als alleinstehendes Statement return ret; } diff --git a/src/mycompiler/mystatement/NewClass.java b/src/mycompiler/mystatement/NewClass.java index 1f1d264b..63c75dd4 100755 --- a/src/mycompiler/mystatement/NewClass.java +++ b/src/mycompiler/mystatement/NewClass.java @@ -190,7 +190,7 @@ public class NewClass extends Expr // ino.method.toString.25867.body { String ret = "NEW "; - Type thisType = getTypeVariable(); + Type thisType = getType(); if(thisType != null)ret += thisType.toString(); else ret += this.get_Name(); return ret; @@ -241,11 +241,11 @@ public class NewClass extends Expr //Ein new-Aufruf ist nichts anderes als ein MethodCall der Methode MethodCall newAufruf = new MethodCall(0,0); - this.setTypeVariable(new RefType(this.get_Name(),0)); + this.setType(new RefType(this.get_Name(),0)); newAufruf.type = new RefType(this.get_Name(),0); newAufruf.set_Name(""); newAufruf.set_Receiver(null); - ret.add(new Overloading(assumptions, newAufruf, this.getTypeVariable()).generateConsstraints()); + ret.add(new Overloading(assumptions, newAufruf, this.getType()).generateConsstraints()); return ret; } @@ -266,7 +266,7 @@ public class NewClass extends Expr @Override public JavaCodeResult printJavaCode(ResultSet resultSet) { JavaCodeResult ret = new JavaCodeResult("new "); - ret.attach(this.getTypeVariable().printJavaCode(resultSet)); + ret.attach(this.getType().printJavaCode(resultSet)); ret.attach("("); if(this.arglist!=null && this.arglist.expr != null){ Iterator it = this.arglist.expr.iterator(); diff --git a/src/mycompiler/mystatement/Return.java b/src/mycompiler/mystatement/Return.java index bdc60955..70297c5b 100755 --- a/src/mycompiler/mystatement/Return.java +++ b/src/mycompiler/mystatement/Return.java @@ -117,8 +117,8 @@ public class Return extends Statement ConstraintsSet ret = new ConstraintsSet(); ret.add(this.retexpr.TYPEExpr(assumptions)); //this.setTypeVariable(TypePlaceholder.fresh("Return Type")); - this.setTypeVariable(TypePlaceholder.fresh(this)); - ret.add(new SingleConstraint(retexpr.getTypeVariable(), this.getTypeVariable())); + this.setType(TypePlaceholder.fresh(this)); + ret.add(new SingleConstraint(retexpr.getType(), this.getType())); return ret; } @@ -132,7 +132,7 @@ public class Return extends Statement @Override public String getTypeInformation(){ - String ret = this.getTypeVariable()+" :: (Return "+this.retexpr.getTypeInformation()+")"; + String ret = this.getType()+" :: (Return "+this.retexpr.getTypeInformation()+")"; return ret; } diff --git a/src/mycompiler/mystatement/Statement.java b/src/mycompiler/mystatement/Statement.java index a3974846..16386c1f 100755 --- a/src/mycompiler/mystatement/Statement.java +++ b/src/mycompiler/mystatement/Statement.java @@ -10,9 +10,10 @@ import sun.reflect.generics.reflectiveObjects.NotImplementedException; import typinferenz.ConstraintsSet; import typinferenz.JavaCodeResult; import typinferenz.ResultSet; -import typinferenz.Typable; +import typinferenz.Typeable; import typinferenz.assumptions.TypeAssumptions; import mycompiler.IItemWithOffset; +import mycompiler.SyntaxTreeNode; import mycompiler.mybytecode.ClassFile; import mycompiler.mybytecode.CodeAttribute; import mycompiler.myclass.Class; @@ -36,7 +37,7 @@ import mycompiler.mytypereconstruction.typeassumption.CTypeAssumption; // ino.class.Statement.26184.declaration -public abstract class Statement implements IItemWithOffset, Typable, ITypeReplacementListener +public abstract class Statement implements IItemWithOffset, Typeable, ITypeReplacementListener, SyntaxTreeNode // ino.end // ino.class.Statement.26184.body { @@ -99,15 +100,9 @@ public abstract class Statement implements IItemWithOffset, Typable, ITypeReplac */ public abstract ConstraintsSet TYPEStmt(TypeAssumptions assumptions); - /** - * @author AI10023 - Andreas Stadelmeier - * Jedem Statement und jeder Expression wird im Zuge des Typinferenzalgorithmus eine Typvariable zugewiesen. - * Daher müssen alle Statements und Expressions die Methoden setTypeVariable und getTypeVariable implementieren. - */ - public void setTypeVariable(Type typ){ - this.setType(typ); - } - public Type getTypeVariable(){ + + + public Type getType(){ return type; } @@ -123,14 +118,14 @@ public abstract class Statement implements IItemWithOffset, Typable, ITypeReplac /** - *
Author: J�rg B�uerle - * Verschoben aus ExprStmt von Andreas Stadelmeier, a10023 - * @param t + * @author AI10023 - Andreas Stadelmeier + * Jedem Statement und jeder Expression wird im Zuge des Typinferenzalgorithmus eine Typvariable zugewiesen. + * Daher müssen alle Statements und Expressions die Methoden setTypeVariable und getTypeVariable implementieren. */ public void setType(Type t) { - if(this.getTypeVariable() instanceof TypePlaceholder){ - ((TypePlaceholder)this.getTypeVariable()).removeReplacementListener(this); + if(this.getType() instanceof TypePlaceholder){ + ((TypePlaceholder)this.getType()).removeReplacementListener(this); } if(t instanceof TypePlaceholder){ ((TypePlaceholder)t).addReplacementListener(this); @@ -140,8 +135,8 @@ public abstract class Statement implements IItemWithOffset, Typable, ITypeReplac public void replaceType(CReplaceTypeEvent e) { - if(getTypeVariable() instanceof TypePlaceholder){ - ((TypePlaceholder)getTypeVariable()).removeReplacementListener(this); + if(getType() instanceof TypePlaceholder){ + ((TypePlaceholder)getType()).removeReplacementListener(this); } this.setType(e.getNewType()); } diff --git a/src/mycompiler/mystatement/This.java b/src/mycompiler/mystatement/This.java index 27ad875a..9942e600 100755 --- a/src/mycompiler/mystatement/This.java +++ b/src/mycompiler/mystatement/This.java @@ -168,7 +168,7 @@ public class This extends Expr public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); //this.set_Type(new); - this.setTypeVariable(assumptions.getThisValue());//Die Assumption für this als TypeVariable setzen. + this.setType(assumptions.getThisValue());//Die Assumption für this als TypeVariable setzen. return ret; } diff --git a/src/mycompiler/mystatement/WhileStmt.java b/src/mycompiler/mystatement/WhileStmt.java index ca596276..97a8194c 100755 --- a/src/mycompiler/mystatement/WhileStmt.java +++ b/src/mycompiler/mystatement/WhileStmt.java @@ -180,10 +180,10 @@ public class WhileStmt extends Statement public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); ret.add(expr.TYPEExpr(assumptions)); - SingleConstraint exprMustBeBool = new SingleConstraint(expr.getTypeVariable(), new RefType("boolean", 0)); // while(expr){}; expr <. boolean + SingleConstraint exprMustBeBool = new SingleConstraint(expr.getType(), new RefType("boolean", 0)); // while(expr){}; expr <. boolean ret.add(exprMustBeBool); ret.add(this.loop_block.TYPEStmt(assumptions)); - this.setTypeVariable(loop_block.getTypeVariable()); + this.setType(loop_block.getType()); return ret; } diff --git a/src/typinferenz/Overloading.java b/src/typinferenz/Overloading.java index 7b88b7ae..7020e61e 100755 --- a/src/typinferenz/Overloading.java +++ b/src/typinferenz/Overloading.java @@ -63,7 +63,7 @@ public class Overloading{ for(int i=0; i parameterAssumptions = new Vector(); parameterAssumptions.add(assumption.getAssumedType()); @@ -73,7 +73,7 @@ public class Overloading{ //Ein Constraint für den Receiver der Methode (falls vorhanden)... //ret.add(new Constraint(methodCall.get_Receiver().get_Expr().getTypeVariable(), new RefType(assumption.getClassName(), null, 0))); if(methodCall.get_Receiver() != null && methodCall.get_Receiver().get_Expr() != null) - methodConstraint.addConstraint(methodCall.get_Receiver().get_Expr().getTypeVariable(), assumption.getClassType()); + methodConstraint.addConstraint(methodCall.get_Receiver().get_Expr().getType(), assumption.getClassType()); //ret.add(new Constraint(methodCall.get_Receiver().get_Expr().getTypeVariable(), new RefType(assumption.getClassName(), parameterAssumptions, 0))); //return ret; //Bereits nach der ersten Assumption abbrechen... diff --git a/src/typinferenz/Typable.java b/src/typinferenz/Typeable.java similarity index 86% rename from src/typinferenz/Typable.java rename to src/typinferenz/Typeable.java index ad736dc5..2f307e2b 100755 --- a/src/typinferenz/Typable.java +++ b/src/typinferenz/Typeable.java @@ -3,7 +3,7 @@ package typinferenz; import mycompiler.mytype.Type; import mycompiler.mytypereconstruction.replacementlistener.ITypeReplacementListener; -public interface Typable { +public interface Typeable { /** * @author Andreas Stadelmeier, a10023 * Jede Expression und jedes Statement muss im Zuge des Typinferenzalgorithmus das Interfece Typable einbinden. @@ -11,6 +11,6 @@ public interface Typable { * Dabei kann auch eine FreshTypeVariable als Typ vergeben werden. * @param typ Der Typ der Typable-Expression/Statement */ - void setTypeVariable(Type typ); - Type getTypeVariable(); + void setType(Type typ); + Type getType(); }