From b0ef4aecd6c00824227643575b06bdf27662915c Mon Sep 17 00:00:00 2001 From: sebastian Date: Tue, 28 Mar 2017 00:46:21 +0200 Subject: [PATCH 1/7] =?UTF-8?q?Neuen=20Test=20f=C3=BCr=20new=20Statement?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .classpath | 4 +- .../SyntaxTreeGenerator.java | 2 +- test/strucTypes/GeneralParserTest.java | 16 +++-- test/strucTypes/GeneralParserTest_Main.java | 70 +++++++++++++++++++ test/strucTypes/Main.jav | 6 ++ 5 files changed, 88 insertions(+), 10 deletions(-) create mode 100644 test/strucTypes/GeneralParserTest_Main.java create mode 100644 test/strucTypes/Main.jav diff --git a/.classpath b/.classpath index 0c07ce08..119bcfc0 100644 --- a/.classpath +++ b/.classpath @@ -1,14 +1,14 @@ - - + + diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java index 725c8e7e..cc512bd8 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java @@ -210,7 +210,7 @@ public class SyntaxTreeGenerator{ if(ctx.superclass() != null){ superClass = convert(ctx.superclass()); }else{ - superClass = new ASTFactory(reg).createObjectClass().getType(); + superClass = new RefType(new JavaClassName("java.lang.Object"), new NullToken()); } Boolean isInterface = false; List implementedInterfaces = null; diff --git a/test/strucTypes/GeneralParserTest.java b/test/strucTypes/GeneralParserTest.java index b64291e0..63b1972a 100644 --- a/test/strucTypes/GeneralParserTest.java +++ b/test/strucTypes/GeneralParserTest.java @@ -5,7 +5,6 @@ import static org.junit.Assert.*; import java.io.File; import java.util.ArrayList; import java.util.List; - import de.dhbwstuttgart.parser.JavaTXParser; import de.dhbwstuttgart.strucTypes.AS_Abstract; import de.dhbwstuttgart.strucTypes.TC_Abstract; @@ -13,6 +12,7 @@ import de.dhbwstuttgart.strucTypes.Algo_Type; import de.dhbwstuttgart.strucTypes.Algo_TypeExpr; import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.statement.CastExpr; +import sun.reflect.generics.reflectiveObjects.NotImplementedException; import org.junit.Test; @@ -41,8 +41,8 @@ public class GeneralParserTest{ //filenames.add("GenericFieldVarTest.jav"); //filenames.add("FieldVarTest.jav"); - //filenames.add("StructuralTypesField.jav"); - filenames.add("StructuralTypesSimple3.jav"); + filenames.add("StructuralTypesField.jav"); + //filenames.add("Main.jav"); JavaTXParser parser = new JavaTXParser(); try{ @@ -60,15 +60,17 @@ public class GeneralParserTest{ // Print der Expression: - System.out.println(Algo_TypeExpr.expression2code(ass, sf.getClasses().get(0).getMethods().get(0).get_Block().statements)); - System.out.println(Algo_TypeExpr.expression2code(ass, sf.getClasses().get(0).getMethods().get(2).get_Block().statements)); + //System.out.println(Algo_TypeExpr.expression2code(ass, sf.getClasses().get(0).getMethods().get(0).get_Block().statements)); + //System.out.println(Algo_TypeExpr.expression2code(ass, sf.getClasses().get(0).getMethods().get(2).get_Block().statements)); // Erstellen der TypeExpression - - + // Wegen java Build path + if (false) { + throw new NotImplementedException(); + } } diff --git a/test/strucTypes/GeneralParserTest_Main.java b/test/strucTypes/GeneralParserTest_Main.java new file mode 100644 index 00000000..d2bb4572 --- /dev/null +++ b/test/strucTypes/GeneralParserTest_Main.java @@ -0,0 +1,70 @@ +package strucTypes; + +import static org.junit.Assert.*; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +import de.dhbwstuttgart.parser.JavaTXParser; +import de.dhbwstuttgart.strucTypes.AS_Abstract; +import de.dhbwstuttgart.strucTypes.TC_Abstract; +import de.dhbwstuttgart.strucTypes.Algo_Type; +import de.dhbwstuttgart.strucTypes.Algo_TypeExpr; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.statement.CastExpr; + +import org.junit.Test; + + +/** + * Dieser Test pr�ft nur, ob .java-Dateien fehlerfrei geparst werden. + * Der dabei erstellte Syntaxbaum wird nicht kontrolliert. + * @author janulrich + * + */ +public class GeneralParserTest_Main{ + private static final String rootDirectory = System.getProperty("user.dir")+"/test/strucTypes/"; + + @Test + public void run(){ + + /* + * Auflistung aller Files die getestet werden sollen + */ + List filenames = new ArrayList(); + //filenames.add("FieldInitializationTest.jav"); + //filenames.add("ImportTest.jav"); + //filenames.add("StatementsTest.jav"); + //filenames.add("ImportTestGeneric.jav"); + //filenames.add("BoundedParameter.jav"); + //filenames.add("GenericFieldVarTest.jav"); + //filenames.add("FieldVarTest.jav"); + + //filenames.add("StructuralTypesField.jav"); + filenames.add("Main.jav"); + + JavaTXParser parser = new JavaTXParser(); + try{ + for(String filename : filenames) { + + System.out.println("Teste: "+ filename); + + SourceFile sf = parser.parse(new File(rootDirectory + filename)); + + SourceFile sfdebug = sf; + + + + + + + } + }catch(Exception exc){ + exc.printStackTrace(); + fail(); + } + assertTrue("Tests durchlaufen",filenames.size()>0); + } + +} diff --git a/test/strucTypes/Main.jav b/test/strucTypes/Main.jav new file mode 100644 index 00000000..d1a00f52 --- /dev/null +++ b/test/strucTypes/Main.jav @@ -0,0 +1,6 @@ + +class Main { + +main() { return new A<>().mt(new myInteger(1)); } + +} \ No newline at end of file From cccc9f4d4980f19b5a30285942035d4dcc164e8a Mon Sep 17 00:00:00 2001 From: sebastian Date: Wed, 29 Mar 2017 11:55:19 +0200 Subject: [PATCH 2/7] Type Constraints angepasst --- .../dhbwstuttgart/strucTypes/AS_Abstract.java | 19 + .../dhbwstuttgart/strucTypes/Algo_Type.java | 16 +- .../strucTypes/Algo_TypeExpr.java | 455 +++++++++--------- .../strucTypes/CodeGenerator.java | 6 +- src/de/dhbwstuttgart/strucTypes/TC_Dummy.java | 23 + .../dhbwstuttgart/strucTypes/TC_Method.java | 27 +- src/de/dhbwstuttgart/strucTypes/TV_Dummy.java | 18 + .../dhbwstuttgart/strucTypes2/Assumption.java | 5 + .../strucTypes2/Assumptions_Map.java | 7 + .../strucTypes2/CodeGenerator.java | 36 ++ .../strucTypes2/Collect_Types.java | 27 ++ .../strucTypes2/TV_Abstract.java | 5 + .../strucTypes2/TV_Argument.java | 5 + .../dhbwstuttgart/strucTypes2/TV_Field.java | 42 ++ src/de/dhbwstuttgart/strucTypes2/TV_Type.java | 15 + .../syntaxtree/statement/FieldVar.java | 15 + test/strucTypes/GeneralParserTest.java | 3 +- test/strucTypes/StructuralTypesSimple3.jav | 8 +- test/strucTypes2/GeneralParserTest.java | 74 +++ test/strucTypes2/StructuralTypesSimple3.jav | 16 + 20 files changed, 564 insertions(+), 258 deletions(-) create mode 100644 src/de/dhbwstuttgart/strucTypes/TC_Dummy.java create mode 100644 src/de/dhbwstuttgart/strucTypes/TV_Dummy.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/Assumption.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/Assumptions_Map.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/CodeGenerator.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/Collect_Types.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/TV_Abstract.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/TV_Argument.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/TV_Field.java create mode 100644 src/de/dhbwstuttgart/strucTypes2/TV_Type.java create mode 100644 test/strucTypes2/GeneralParserTest.java create mode 100644 test/strucTypes2/StructuralTypesSimple3.jav diff --git a/src/de/dhbwstuttgart/strucTypes/AS_Abstract.java b/src/de/dhbwstuttgart/strucTypes/AS_Abstract.java index a77627e7..5e7cbc16 100644 --- a/src/de/dhbwstuttgart/strucTypes/AS_Abstract.java +++ b/src/de/dhbwstuttgart/strucTypes/AS_Abstract.java @@ -43,6 +43,25 @@ public class AS_Abstract { } + + + public static AS_Argument find_AS_Argument(FormalParameter f, Method m , List ass ) { + AS_Argument res = null; + + for (AS_Abstract as : ass) { + if ( as.getClass().equals(AS_Argument.class) ) { + AS_Argument asa = (AS_Argument) as; + if (f == asa.fp) { + if (asa.tv_alpha.method == m) { + res = asa; + } + } + } + } + return res; + } + + public static AS_Argument find_AS_Argument_by_Name(String name, List ass ) { // if diff --git a/src/de/dhbwstuttgart/strucTypes/Algo_Type.java b/src/de/dhbwstuttgart/strucTypes/Algo_Type.java index 64a57bc9..9f0aea2c 100644 --- a/src/de/dhbwstuttgart/strucTypes/Algo_Type.java +++ b/src/de/dhbwstuttgart/strucTypes/Algo_Type.java @@ -6,7 +6,9 @@ import java.util.List; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.Field; import de.dhbwstuttgart.syntaxtree.Method; -import de.dhbwstuttgart.syntaxtree.SourceFile; + + + public class Algo_Type { @@ -61,7 +63,7 @@ public class Algo_Type { } // ASS = AssAll vereinigt mit ass_arguments (wird oben erledigt) - //-> assAll.addAll(ass_arguments); + // (Test) Beispielhafte Ausgabe der Assumptions @@ -84,11 +86,7 @@ public class Algo_Type { // Hier ist ein Fehler -> der Contraint bezieht sich auf die Expression } - - - - - + } @@ -121,10 +119,6 @@ public class Algo_Type { - - - - // Gettermethoden public Object getResult_cl_t() { return result_cl_t; diff --git a/src/de/dhbwstuttgart/strucTypes/Algo_TypeExpr.java b/src/de/dhbwstuttgart/strucTypes/Algo_TypeExpr.java index 80bca2ae..64d79bb6 100644 --- a/src/de/dhbwstuttgart/strucTypes/Algo_TypeExpr.java +++ b/src/de/dhbwstuttgart/strucTypes/Algo_TypeExpr.java @@ -3,8 +3,6 @@ package de.dhbwstuttgart.strucTypes; import java.util.ArrayList; import java.util.List; -import com.sun.xml.internal.bind.v2.runtime.unmarshaller.Receiver; - import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.Field; import de.dhbwstuttgart.syntaxtree.Method; @@ -13,339 +11,324 @@ import de.dhbwstuttgart.syntaxtree.statement.Expression; import de.dhbwstuttgart.syntaxtree.statement.FieldVar; import de.dhbwstuttgart.syntaxtree.statement.LocalVar; import de.dhbwstuttgart.syntaxtree.statement.MethodCall; +import de.dhbwstuttgart.syntaxtree.statement.Receiver; import de.dhbwstuttgart.syntaxtree.statement.Return; import de.dhbwstuttgart.syntaxtree.statement.Statement; public class Algo_TypeExpr { - - - + /* * * Hier sind die Ergebnisse * * - */ - // Ergebnisse: Expression Typed und Constraint-Set - List res_constriant_set; - //TODO Hier muss noch ein passendes Datenformat gefunden werden - String res_expression_typed; - - - - + */ + // Ergebnisse: Expression Typed und Constraint-Set + List res_constriant_set; + // TODO Hier muss noch ein passendes Datenformat gefunden werden + String res_expression_typed; + public Algo_TypeExpr() { - + } - - - - + // übergabe der assumptions und der Statments der Methode - public Algo_TypeExpr(List ass , List statements ) { - - this.res_constriant_set = new ArrayList(); - res_expression_typed = ""; - - - + public Algo_TypeExpr(List ass, List statements) { + + this.res_constriant_set = new ArrayList(); + res_expression_typed = ""; + // Methode enthält kein Statement - if (statements.size() == 0 ) { + if (statements.size() == 0) { System.out.println("Not Implemmented"); } - - - + // Methode enthält nur ein Return Statement das ein feld zurückgibt if (statements.size() == 1) { - if (statements.get(0).getClass().equals(Return.class)) { - Return exp_rt = (Return) statements.get(0); - if (exp_rt.get_Expression().getClass().equals(LocalVar.class )) { + if (statements.get(0).getClass().equals(Return.class)) { + Return exp_rt = (Return) statements.get(0); + if (exp_rt.get_Expression().getClass().equals(LocalVar.class)) { LocalVar lvar = (LocalVar) exp_rt.get_Expression(); - - String feldname = lvar.get_expression(); - + + String feldname = lvar.get_expression(); + for (AS_Abstract as : ass) { if (as.getClass().equals(AS_Argument.class)) { - AS_Argument as_arg = (AS_Argument) as; + AS_Argument as_arg = (AS_Argument) as; if (as_arg.fp.getName().equals(feldname)) { res_expression_typed = feldname + " : " + as_arg.tv_alpha.toString(); - // res_constraint_set - } + // res_constraint_set + } } - } - } + } + } } } - - - // Methode nur ein Return statment das ein feld zurückgibt und eine Methode aufruft - - - //-> Es muss so sein dass ich diese Return Statement beurteilen kann - - - - + + // Methode nur ein Return statment das ein feld zurückgibt und eine + // Methode aufruft + } - - + /* - * Methode generiert Quellcode aus einer Methode - * Letztendlich wird in der Methode der gesamte Datentyp durchwandert und erstellt - * Nach dem selben Schema muss auch die generierung der Constriants erfolgen: - */ - public static String expression2code(List ass , List statements ) { - String res = ""; - - // Leere methode + * Methode generiert Quellcode aus einer Methode Letztendlich wird in der + * Methode der gesamte Datentyp durchwandert und erstellt Nach dem selben + * Schema muss auch die generierung der Constriants erfolgen: + */ + public static String expression2code(List ass, List statements) { + String res = ""; + + // Leere methode if (statements.size() == 0) { - res = "---"; + res = "---"; } - - // Methode mit einer Return Expression + + // Methode mit einer Return Expression if (statements.size() == 1) { if (statements.get(0).getClass() == Return.class) { - Return ret = (Return) statements.get(0); - Statement ret2 = (Statement) ret.get_Expression(); - res = statement2code(ass,ret2); - } - } + Return ret = (Return) statements.get(0); + if (ret.getClass().equals(Statement.class)) { + Statement ret2 = (Statement) ret.get_Expression(); + res = statement2code(ass, ret2); + } else if (ret.getClass().equals(FieldVar.class)) { + + // Neu Implementiert - funktioniert es ?? + Expression ex = (Expression) ret; + FieldVar fvar = (FieldVar) ex; + + String exp_str = fvar.getFieldVarName(); + + // Statement Cast evtl. problematisch + List liste = new ArrayList(); + liste.add((Statement) fvar.receiver); + String reciever_str = expression2code(ass, liste); + + return reciever_str + "." + exp_str; + + } + } + } return res; } - - - public static String statement2code(List ass , Statement statement) { - + + public static String statement2code(List ass, Statement statement) { + // TODO: Else if - - if ( statement.getClass().equals(LocalVar.class) ) { + + if (statement.getClass().equals(LocalVar.class)) { LocalVar lvar = (LocalVar) statement; - String exp_str = lvar.get_expression(); + String exp_str = lvar.get_expression(); return exp_str; } - - + + // fieldvar muss ausgelagert werden weil es von Expression ableitett if (statement.getClass().equals(FieldVar.class)) { - // FieldVar ist nicht implementiert + // Neu Implementiert - funktioniert es ?? + Expression ex = (Expression) statement; + FieldVar fvar = (FieldVar) ex; + + String exp_str = fvar.getFieldVarName(); + + // Statement Cast evtl. problematisch + String reciever_str = statement2code(ass, (Statement) fvar.receiver); + + return reciever_str + "." + exp_str; } - - + if (statement.getClass().equals(MethodCall.class)) { - MethodCall mtcall = (MethodCall) statement; - Statement receiver = (Statement) mtcall.get_Receiver().get_Expression(); - String str = statement2code(ass,receiver); + MethodCall mtcall = (MethodCall) statement; + Statement receiver = (Statement) mtcall.get_Receiver().get_Expression(); + String str = statement2code(ass, receiver); ArgumentList list = mtcall.get_ArgList(); - String arg_str = ""; + String arg_str = ""; for (Expression exp : list.getArguments()) { // TODO Cast evtl ist falsch - Statement st = (Statement) exp; - arg_str = arg_str + statement2code(ass,st); + Statement st = (Statement) exp; + arg_str = arg_str + statement2code(ass, st); } - // Todo Implementing Types: - return str + "."+ mtcall.get_Name() + "( " + arg_str + " )"; - } - return "Fehler"; + // Todo Implementing Types: + return str + "." + mtcall.get_Name() + "( " + arg_str + " )"; + } + return "Fehler"; } - - - - + public List generate(List ass, List exp) { - + // Methoden enhält keine Statements if (exp.size() == 0) { - this.res_constriant_set = null; - this.res_expression_typed = null; + this.res_constriant_set = null; + this.res_expression_typed = null; } - - + // Methoden enthält ein Return Statement if (exp.size() == 1) { - Statement std = (Statement) exp.get(0); + Statement std = (Statement) exp.get(0); if (std.getClass() == Return.class) { - Return ret = (Return) std; - generate_return(ass, ret); + Return ret = (Return) std; + generate_return(ass, ret); } } - return null; + return null; } - - + public List generate_return(List ass, Return ret) { - + Expression exp = ret.get_Expression(); - - + if (exp.getClass() == LocalVar.class) { LocalVar lvar = (LocalVar) exp; // TODO wie soll ich hier mit der Language umgehen - return new ArrayList(); - } - - - if (exp.getClass() == FieldVar.class) { - + return new ArrayList(); } - - + + if (exp.getClass() == FieldVar.class) { + // Hier kommt der Constraint für die Field Var hinein. + + } + if (exp.getClass() == MethodCall.class) { - MethodCall mt_call = (MethodCall) exp; - + MethodCall mt_call = (MethodCall) exp; + // Constraint - - } - return null; + + } + return null; } - - - public List getRes_constriant_set() { return res_constriant_set; } - - - public String getRes_expression_typed() { return res_expression_typed; } - - - - - - // Neuer Versuch mit neuer herangehensweise um den Typen zu berechnen /* * Es werden die Typen der Methoden berechnet und als String ausgegeben */ public static TV_Abstract get_rt_Type_of(Expression o, List ass) { - + if (o.getClass().equals(LocalVar.class)) { - LocalVar v = (LocalVar) o; - return get_rt_Type_of_LocalVar(v, ass); + LocalVar v = (LocalVar) o; + return get_rt_Type_of_LocalVar(v, ass); + } else if (o.getClass().equals(MethodCall.class)) { + MethodCall m_call = (MethodCall) o; + return get_rt_Type_of_MethodCall(m_call, ass); + } else if (o.getClass().equals(FieldVar.class)) { + FieldVar fvar = (FieldVar) o; + String type_fvar = get_rt_Type_of_FieldVar(fvar, ass); + return new TV_Dummy(type_fvar); + } else { + return null; } - else if (o.getClass().equals(MethodCall.class)) { - MethodCall m_call = (MethodCall) o; - return get_rt_Type_of_MethodCall(m_call, ass); - } - else if (o.getClass().equals(FieldVar.class)){ - // FieldVar ist noch nicht implementiert - return null; - } - else { - return null; - } } - - + public static TV_Alpha get_rt_Type_of_LocalVar(LocalVar v, List ass) { - AS_Argument arg = AS_Abstract.find_AS_Argument_by_Name(v.get_expression(), ass); - return arg.tv_alpha; + AS_Argument arg = AS_Abstract.find_AS_Argument_by_Name(v.get_expression(), ass); + return arg.tv_alpha; } - - - public static TV_ReturnType2 get_rt_Type_of_MethodCall(MethodCall mt_call, List ass) { - TV_Abstract tv_receiver = get_rt_Type_of(mt_call.get_Receiver().get_Expression(), ass); - TV_ReturnType2 res = new TV_ReturnType2(mt_call.get_Name(), tv_receiver.toString() ); - return res; + + public static TV_ReturnType2 get_rt_Type_of_MethodCall(MethodCall mt_call, List ass) { + TV_Abstract tv_receiver = get_rt_Type_of(mt_call.get_Receiver().get_Expression(), ass); + TV_ReturnType2 res = new TV_ReturnType2(mt_call.get_Name(), tv_receiver.toString()); + return res; } - - - - + + public static String get_rt_Type_of_FieldVar(FieldVar fvar, List ass) { + + TV_Abstract exp = get_rt_Type_of(fvar.getReceiver(), ass); + + return "DeltaXXX ( " + fvar.getFieldVarName() + "," + exp.toString() + ")"; + } + // Neuer Versuch eine Methode berechneten Typen auszugeben - public static String get_Return_typed(Method m, List ass) { - Return r = (Return) m.get_Block().statements.get(0); - Expression ex = r.get_Expression(); - return get_rt_Type_of(ex,ass).toString(); + public static String get_Return_typed(Method m, List ass) { + Return r = (Return) m.get_Block().statements.get(0); + Expression ex = r.get_Expression(); + return get_rt_Type_of(ex, ass).toString(); } - - + // ------------------------------------------------------------------------ - // Erstellen der Constraints. + // Erstellen der Constraints. // Auch dieses erstellen muss Rekursiv erfolgen // ------------------------------- - - public static List generateConstraint(ClassOrInterface cl, List ass ) { - List result = new ArrayList<>(); - - + + public static List generateConstraint(ClassOrInterface cl, List ass) { + List result = new ArrayList<>(); + // 1. Generate Field Constraints - result.addAll(generateFieldConstraints(cl,ass)); - // 2. Generate Method Constraints - result.addAll(generateMethodConstraints(cl,ass)); - - - - - - return result; + result.addAll(generateFieldConstraints(cl, ass)); + // 2. Generate Method Constraints + result.addAll(generateMethodConstraints(cl, ass)); + + return result; } - - - public static List generateFieldConstraints(ClassOrInterface cl, List ass ) { - List result = new ArrayList<>(); - + + public static List generateFieldConstraints(ClassOrInterface cl, List ass) { + List result = new ArrayList<>(); + for (Field f : cl.getFieldDecl()) { - AS_Field as = (AS_Field) AS_Abstract.find_AS_Field(f, ass); - TC_Field constraint = new TC_Field(cl,f, as.get_TV_Field()); - result.add(constraint); - } - return result; + AS_Field as = (AS_Field) AS_Abstract.find_AS_Field(f, ass); + TC_Field constraint = new TC_Field(cl, f, as.get_TV_Field()); + result.add(constraint); + } + return result; } - + /* - * Leider hat das erstellen der Constraints für die Methoden nicht mehr funktioniert - * Aus dies muss Rekursiv erfolgen + * Leider hat das erstellen der Constraints für die Methoden nicht mehr + * funktioniert Aus dies muss Rekursiv erfolgen */ - public static List generateMethodConstraints(ClassOrInterface cl, List ass) { - List result = new ArrayList<>(); + public static List generateMethodConstraints(ClassOrInterface es, List ass) { - for(Method m : cl.getMethods()) { - - Return r = (Return) m.get_Block().getStatements().get(0); - Expression ex = r.get_Expression(); - if (ex.getClass().equals(LocalVar.class)) { - // Kein Constraint - } - else if (ex.getClass().equals(FieldVar.class)){ - // Noch nicht implementiert - - - } - else if (ex.getClass().equals(MethodCall.class)) { - MethodCall m_call = (MethodCall) ex; - - - TC_Method tc = new TC_Method(cl,m); - - result.add(tc); - - - } - else { - // Darf nicht vorkommen - System.out.println("Fehler - Type Expression"); - } - - - } - return result; + List constraints = new ArrayList(); + + for (Method m : es.getMethods() ) { + Return r = (Return) m.get_Block().statements.get(0); + constraints.addAll(generateMethodConstraints(r.get_Expression(), ass)); + } + return constraints; } - - - - - - - - + + public static List generateMethodConstraints(Expression ex, List ass) { + + + + + if (ex.getClass().equals(LocalVar.class)) { + List result = new ArrayList<>(); + return result; + } else if (ex.getClass().equals(FieldVar.class)) { + FieldVar v = (FieldVar) ex; + List res = generateMethodConstraints(v.getReceiver(), ass); + TV_Abstract rt_type = get_rt_Type_of(v.getReceiver(),ass); + + + // NEW TC field TC_Field() + res.add(new TC_Dummy(String.format("TC_Field: ( %s , %s , %s )" , rt_type.toString() , v.getFieldVarName() , "TV_Field(" + rt_type.toString() + " , " + v.getFieldVarName() ) )); + + return res; + + } else if (ex.getClass().equals(MethodCall.class)) { + MethodCall m_call = (MethodCall) ex; + List res = generateMethodConstraints(m_call.get_Receiver().get_Expression(), ass); + TV_Abstract rt_type = get_rt_Type_of(m_call, ass); + + + res.add(new TC_Dummy("Klasse? " , m_call.get_Name() , "Arguments" , "ReturnType: " + rt_type.toString() , "Typvar: ?" )); + return res; + + } else { + // Darf nicht vorkommen + System.out.println("Fehler - Type Expression"); + return null; + } + } + + } diff --git a/src/de/dhbwstuttgart/strucTypes/CodeGenerator.java b/src/de/dhbwstuttgart/strucTypes/CodeGenerator.java index 93dd2801..7de42fbc 100644 --- a/src/de/dhbwstuttgart/strucTypes/CodeGenerator.java +++ b/src/de/dhbwstuttgart/strucTypes/CodeGenerator.java @@ -58,8 +58,7 @@ public class CodeGenerator { public static String generateMethod(Method m, List ass ) { - String rt_type = Algo_TypeExpr.get_Return_typed(m, ass); - + String rt_type = Algo_TypeExpr.get_Return_typed(m, ass); String code = rt_type +" " + m.getName() + " ( " ; @@ -67,7 +66,8 @@ public class CodeGenerator { // Generate Formalparameter List fp = m.getParameterList().getFormalparalist(); for (FormalParameter f : fp ) { - AS_Argument arg = AS_Abstract.find_AS_Argument(f, ass); + //AS_Argument arg = AS_Abstract.find_AS_Argument(f, ass); + AS_Argument arg = AS_Abstract.find_AS_Argument(f, m, ass); code = code + arg.get_code() + ", "; } diff --git a/src/de/dhbwstuttgart/strucTypes/TC_Dummy.java b/src/de/dhbwstuttgart/strucTypes/TC_Dummy.java new file mode 100644 index 00000000..06fbaa56 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes/TC_Dummy.java @@ -0,0 +1,23 @@ +package de.dhbwstuttgart.strucTypes; + +public class TC_Dummy extends TC_Abstract { + + private String dummy; + + public TC_Dummy(String inhalt) { + this.dummy = inhalt; + } + + public TC_Dummy(String type1, String method, String arguments_of_type , String returntype , String typvar) { + this.dummy = String.format("Mue( %s , %s , %s, (%s , %s )) " , type1, method, arguments_of_type, returntype, typvar); + } + + + public String toString() { + return dummy; + } + + + + +} diff --git a/src/de/dhbwstuttgart/strucTypes/TC_Method.java b/src/de/dhbwstuttgart/strucTypes/TC_Method.java index 9603bfe5..8f222eef 100644 --- a/src/de/dhbwstuttgart/strucTypes/TC_Method.java +++ b/src/de/dhbwstuttgart/strucTypes/TC_Method.java @@ -2,6 +2,7 @@ package de.dhbwstuttgart.strucTypes; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.statement.MethodCall; /* Formal Idea: * @@ -16,18 +17,38 @@ public class TC_Method extends TC_Abstract { // Not completely implemented in the moment private ClassOrInterface cl; + private TV_Abstract typvar; private Method method; + private MethodCall method_call; - + // variante 1 -> Klasse ist bekannt public TC_Method(ClassOrInterface cl, Method method ) { super(); this.cl = cl; - this.method = method; + this.method = method; + typvar = null; + } + + // variante 2 -> Klasse ist nicht bekannt + public TC_Method(TV_Abstract typvar, MethodCall method_call) { + super(); + this.cl = null; + this.method = null; + this.typvar = typvar; + this.method_call = method_call; } + + public String toString() { - return "Mue( " + cl.getClassName().toString() + "," + method.getName() + "...)" ; + + if (cl != null) { + return "Mue( " + cl.getClassName().toString() + "," + method.getName() + "...)" ; + } + else { + return String.format("Mue( %s , %s ..." , typvar.toString() , method_call.get_Name() ); + } } diff --git a/src/de/dhbwstuttgart/strucTypes/TV_Dummy.java b/src/de/dhbwstuttgart/strucTypes/TV_Dummy.java new file mode 100644 index 00000000..486fb042 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes/TV_Dummy.java @@ -0,0 +1,18 @@ +package de.dhbwstuttgart.strucTypes; + +public class TV_Dummy extends TV_Abstract { + + + private String type = ""; + + + public TV_Dummy(String type) { + this.type = type; + } + + public String toString() { + return type; + } + + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/Assumption.java b/src/de/dhbwstuttgart/strucTypes2/Assumption.java new file mode 100644 index 00000000..afeabe8b --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/Assumption.java @@ -0,0 +1,5 @@ +package de.dhbwstuttgart.strucTypes2; + +public class Assumption { + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/Assumptions_Map.java b/src/de/dhbwstuttgart/strucTypes2/Assumptions_Map.java new file mode 100644 index 00000000..824c4c51 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/Assumptions_Map.java @@ -0,0 +1,7 @@ +package de.dhbwstuttgart.strucTypes2; + +public class Assumptions_Map { + + private Map assumption_Map = new HashMap<>(); + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/CodeGenerator.java b/src/de/dhbwstuttgart/strucTypes2/CodeGenerator.java new file mode 100644 index 00000000..f3b94025 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/CodeGenerator.java @@ -0,0 +1,36 @@ +package de.dhbwstuttgart.strucTypes2; + +import sun.reflect.generics.reflectiveObjects.NotImplementedException; + +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.SourceFile; + + + + +public class CodeGenerator { + + + + public static String generate_code_from_SourceFile(SourceFile sf) { + String res = ""; + + throw new NotImplementedException(); + + } + + + public static String generate_code_from_Class(ClassOrInterface cl) { + throw new NotImplementedException(); + } + + + + + + + + + + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/Collect_Types.java b/src/de/dhbwstuttgart/strucTypes2/Collect_Types.java new file mode 100644 index 00000000..4861c694 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/Collect_Types.java @@ -0,0 +1,27 @@ +package de.dhbwstuttgart.strucTypes2; + +import java.util.HashMap; +import java.util.Map; + +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +public class Collect_Types { + + + public static Map collect(SourceFile sf) { + + Map typen = new HashMap<>(); + + + // Sammle Typen aus Klassen + + + + + return typen; + } + + + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/TV_Abstract.java b/src/de/dhbwstuttgart/strucTypes2/TV_Abstract.java new file mode 100644 index 00000000..28a35597 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/TV_Abstract.java @@ -0,0 +1,5 @@ +package de.dhbwstuttgart.strucTypes2; + +public class TV_Abstract { + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/TV_Argument.java b/src/de/dhbwstuttgart/strucTypes2/TV_Argument.java new file mode 100644 index 00000000..4a2251df --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/TV_Argument.java @@ -0,0 +1,5 @@ +package de.dhbwstuttgart.strucTypes2; + +public class TV_Argument { + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/TV_Field.java b/src/de/dhbwstuttgart/strucTypes2/TV_Field.java new file mode 100644 index 00000000..e96067d7 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/TV_Field.java @@ -0,0 +1,42 @@ +package de.dhbwstuttgart.strucTypes2; + +import de.dhbwstuttgart.syntaxtree.Field; + +public class TV_Field extends TV_Abstract { + + private TV_Abstract type_of_class; + private Field field; + + public TV_Field(TV_Abstract type_of_class, Field field) { + super(); + this.type_of_class = type_of_class; + this.field = field; + } + + + public TV_Abstract getType_of_class() { + return type_of_class; + } + + public void setType_of_class(TV_Abstract type_of_class) { + this.type_of_class = type_of_class; + } + + public Field getField() { + return field; + } + + public void setField(Field field) { + this.field = field; + } + + + + + + + + + + +} diff --git a/src/de/dhbwstuttgart/strucTypes2/TV_Type.java b/src/de/dhbwstuttgart/strucTypes2/TV_Type.java new file mode 100644 index 00000000..ae9b538f --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes2/TV_Type.java @@ -0,0 +1,15 @@ +package de.dhbwstuttgart.strucTypes2; + +import de.dhbwstuttgart.typecheck.JavaClassName; + +public class TV_Type extends TV_Abstract { + + + private JavaClassName name; + + + + + + +} diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/FieldVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/FieldVar.java index 0eac0866..8423e38c 100644 --- a/src/de/dhbwstuttgart/syntaxtree/statement/FieldVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/FieldVar.java @@ -40,4 +40,19 @@ public class FieldVar extends Expression { ret.addOderConstraint(oderConstraints); return ret; } + + // @ Sebastian + public String getFieldVarName() { + return fieldVarName; + } + + // @ Sebastian + public Expression getReceiver() { + return receiver; + } + + + + + } diff --git a/test/strucTypes/GeneralParserTest.java b/test/strucTypes/GeneralParserTest.java index 63b1972a..9a735265 100644 --- a/test/strucTypes/GeneralParserTest.java +++ b/test/strucTypes/GeneralParserTest.java @@ -41,7 +41,8 @@ public class GeneralParserTest{ //filenames.add("GenericFieldVarTest.jav"); //filenames.add("FieldVarTest.jav"); - filenames.add("StructuralTypesField.jav"); + filenames.add("StructuralTypesSimple3.jav"); + //filenames.add("StructuralTypesField.jav"); //filenames.add("Main.jav"); JavaTXParser parser = new JavaTXParser(); diff --git a/test/strucTypes/StructuralTypesSimple3.jav b/test/strucTypes/StructuralTypesSimple3.jav index 738c2602..fb01208a 100644 --- a/test/strucTypes/StructuralTypesSimple3.jav +++ b/test/strucTypes/StructuralTypesSimple3.jav @@ -3,12 +3,12 @@ class A { A f1; - A f2; - + f2; - mt1(x) { return x; } + + mt1(x1) { return x1; } - //mt2(x) { return x.feld ; } + mt2(x2) { return x2.feld_von_x ; } mt3(x,y,z) { return x.sub(y).add(z); } diff --git a/test/strucTypes2/GeneralParserTest.java b/test/strucTypes2/GeneralParserTest.java new file mode 100644 index 00000000..2f21e653 --- /dev/null +++ b/test/strucTypes2/GeneralParserTest.java @@ -0,0 +1,74 @@ +package strucTypes2; + +import static org.junit.Assert.*; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import de.dhbwstuttgart.parser.JavaTXParser; +import de.dhbwstuttgart.strucTypes.AS_Abstract; +import de.dhbwstuttgart.strucTypes.TC_Abstract; +import de.dhbwstuttgart.strucTypes.Algo_Type; +import de.dhbwstuttgart.strucTypes.Algo_TypeExpr; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.statement.CastExpr; +import sun.reflect.generics.reflectiveObjects.NotImplementedException; + +import org.junit.Test; + + +/** + * Dieser Test pr�ft nur, ob .java-Dateien fehlerfrei geparst werden. + * Der dabei erstellte Syntaxbaum wird nicht kontrolliert. + * @author janulrich + * + */ +public class GeneralParserTest{ + private static final String rootDirectory = System.getProperty("user.dir")+"/test/strucTypes/"; + + @Test + public void run(){ + + /* + * Auflistung aller Files die getestet werden sollen + */ + List filenames = new ArrayList(); + //filenames.add("FieldInitializationTest.jav"); + //filenames.add("ImportTest.jav"); + //filenames.add("StatementsTest.jav"); + //filenames.add("ImportTestGeneric.jav"); + //filenames.add("BoundedParameter.jav"); + //filenames.add("GenericFieldVarTest.jav"); + //filenames.add("FieldVarTest.jav"); + + filenames.add("StructuralTypesSimple3.jav"); + //filenames.add("StructuralTypesField.jav"); + //filenames.add("Main.jav"); + + JavaTXParser parser = new JavaTXParser(); + try{ + for(String filename : filenames) { + + System.out.println("Teste: "+ filename); + + SourceFile sf = parser.parse(new File(rootDirectory + filename)); + + SourceFile sfdebug = sf; + + + // Hier soll der CodeGenerator hin. + + + + + + + } + }catch(Exception exc){ + exc.printStackTrace(); + fail(); + } + assertTrue("Tests durchlaufen",filenames.size()>0); + } + +} diff --git a/test/strucTypes2/StructuralTypesSimple3.jav b/test/strucTypes2/StructuralTypesSimple3.jav new file mode 100644 index 00000000..a774fc5d --- /dev/null +++ b/test/strucTypes2/StructuralTypesSimple3.jav @@ -0,0 +1,16 @@ + +class A { + + A f1; + + A f2; + + + mt1(x) { return x; } + + mt2(x) { return x.feld_von_x ; } + + mt3(x,y,z) { return x.sub(y).add(z); } + +} + From b3ffb7bd58f33854df5b0e846eb0af4e34a9858c Mon Sep 17 00:00:00 2001 From: sebastian Date: Sun, 2 Apr 2017 23:03:10 +0200 Subject: [PATCH 3/7] neuer Versuch unter Verwendung der bereits vorhandenen Typvariablen --- test/strucTypes/StructuralTypesSimple3.jav | 4 + test/strucTypes2/AssTuple.java | 65 +++ test/strucTypes2/Assumption_Abstract.java | 5 + test/strucTypes2/Assumption_Field.java | 36 ++ test/strucTypes2/Assumption_Method.java | 31 ++ test/strucTypes2/FindAssumptions.java | 42 ++ test/strucTypes2/GeneralParserTest2.java | 444 +++++++++++++++++++++ 7 files changed, 627 insertions(+) create mode 100644 test/strucTypes2/AssTuple.java create mode 100644 test/strucTypes2/Assumption_Abstract.java create mode 100644 test/strucTypes2/Assumption_Field.java create mode 100644 test/strucTypes2/Assumption_Method.java create mode 100644 test/strucTypes2/FindAssumptions.java create mode 100644 test/strucTypes2/GeneralParserTest2.java diff --git a/test/strucTypes/StructuralTypesSimple3.jav b/test/strucTypes/StructuralTypesSimple3.jav index fb01208a..0fdb8aef 100644 --- a/test/strucTypes/StructuralTypesSimple3.jav +++ b/test/strucTypes/StructuralTypesSimple3.jav @@ -12,5 +12,9 @@ class A { mt3(x,y,z) { return x.sub(y).add(z); } + mt4(x,y,z) { return x.f.add(y.sub(z,x)); } + + + } diff --git a/test/strucTypes2/AssTuple.java b/test/strucTypes2/AssTuple.java new file mode 100644 index 00000000..538f3028 --- /dev/null +++ b/test/strucTypes2/AssTuple.java @@ -0,0 +1,65 @@ +package strucTypes2; + +import java.util.Map; + +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +class AssTuple { + + private Map fAss; + private Map mAss; + private Map> argAss; + + public AssTuple(Map fAss, + Map mAss, + Map> argAss) { + super(); + this.fAss = fAss; + this.mAss = mAss; + this.argAss = argAss; + } + + public RefTypeOrTPHOrWildcardOrGeneric getTypeOfLocalVar(String name , Method method) { + + // Schaue als erstes in den Argumenten dann in den Feldvariablen der Klasse + Map argAssMethod = argAss.get(method); + if (argAssMethod.containsKey(name)) { + return argAssMethod.get(name); + } + else if (fAss.containsKey(name)) { + return fAss.get(name); + } + else { + System.err.println("Fehler: Typ nicht bekannt"); + return null; + } + + + + } + + public Map getfAss() { + return fAss; + } + + public void setfAss(Map fAss) { + this.fAss = fAss; + } + + public Map getmAss() { + return mAss; + } + + public void setmAss(Map mAss) { + this.mAss = mAss; + } + + public Map> getArgAss() { + return argAss; + } + + public void setArgAss(Map> argAss) { + this.argAss = argAss; + } +} \ No newline at end of file diff --git a/test/strucTypes2/Assumption_Abstract.java b/test/strucTypes2/Assumption_Abstract.java new file mode 100644 index 00000000..2aa728dd --- /dev/null +++ b/test/strucTypes2/Assumption_Abstract.java @@ -0,0 +1,5 @@ +package strucTypes2; + +public class Assumption_Abstract { + +} diff --git a/test/strucTypes2/Assumption_Field.java b/test/strucTypes2/Assumption_Field.java new file mode 100644 index 00000000..4c1713e4 --- /dev/null +++ b/test/strucTypes2/Assumption_Field.java @@ -0,0 +1,36 @@ +package strucTypes2; + +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; + +public class Assumption_Field { + + TypePlaceholder tph; + Field field; + + public Assumption_Field(RefTypeOrTPHOrWildcardOrGeneric tph, Field field) { + + if (tph.getClass().equals(TypePlaceholder.class)) { + this.tph = (TypePlaceholder) tph; + } + else { + System.out.println("Fehler"); + } + this.field = field; + } + + + public String toString() { + return "Assumption" + tph.toString() + " , " + field.getName(); + } + + + + + + + + + +} diff --git a/test/strucTypes2/Assumption_Method.java b/test/strucTypes2/Assumption_Method.java new file mode 100644 index 00000000..35da8360 --- /dev/null +++ b/test/strucTypes2/Assumption_Method.java @@ -0,0 +1,31 @@ +package strucTypes2; + +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; + +public class Assumption_Method { + + TypePlaceholder tph; + Method m; + + public Assumption_Method(RefTypeOrTPHOrWildcardOrGeneric tph, Method m) { + + if (tph.getClass().equals(TypePlaceholder.class)) { + this.tph = (TypePlaceholder) tph; + } + else { + System.out.println("Fehler"); + } + this.m = m; + } + + public String toString() { + return "Assumption Method: " + tph.toString() + " , " + m.getName(); + } + + + + + +} diff --git a/test/strucTypes2/FindAssumptions.java b/test/strucTypes2/FindAssumptions.java new file mode 100644 index 00000000..0b3a05d7 --- /dev/null +++ b/test/strucTypes2/FindAssumptions.java @@ -0,0 +1,42 @@ +package strucTypes2; + +import java.util.ArrayList; +import java.util.List; + +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; + +public class FindAssumptions { + + + + public static void generateFieldAssumptions(ClassOrInterface cl) { + + List res = new ArrayList(); + + for (Field f : cl.getFieldDecl()) { + res.add(new Assumption_Field(f.getType(), f)); + } + + } + + + public static void generateMethodAssumptions(ClassOrInterface cl) { + List res = new ArrayList(); + + for (Method m : cl.getMethods() ) { + res.add(new Assumption_Method()) + + } + + } + + + public static void generateArgumentAssumptions() { + + } + + +} diff --git a/test/strucTypes2/GeneralParserTest2.java b/test/strucTypes2/GeneralParserTest2.java new file mode 100644 index 00000000..34b03f70 --- /dev/null +++ b/test/strucTypes2/GeneralParserTest2.java @@ -0,0 +1,444 @@ +package strucTypes2; + +import static org.junit.Assert.*; + +import java.io.File; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import de.dhbwstuttgart.parser.JavaTXParser; +import de.dhbwstuttgart.strucTypes.AS_Abstract; +import de.dhbwstuttgart.strucTypes.TC_Abstract; +import de.dhbwstuttgart.strucTypes.Algo_Type; +import de.dhbwstuttgart.strucTypes.Algo_TypeExpr; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.FormalParameter; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.statement.Block; +import de.dhbwstuttgart.syntaxtree.statement.CastExpr; +import de.dhbwstuttgart.syntaxtree.statement.Expression; +import de.dhbwstuttgart.syntaxtree.statement.FieldVar; +import de.dhbwstuttgart.syntaxtree.statement.LocalVar; +import de.dhbwstuttgart.syntaxtree.statement.MethodCall; +import de.dhbwstuttgart.syntaxtree.statement.Receiver; +import de.dhbwstuttgart.syntaxtree.statement.Return; +import de.dhbwstuttgart.syntaxtree.statement.Statement; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import sun.reflect.generics.reflectiveObjects.NotImplementedException; + +import org.junit.Test; + +/** + * Dieser Test pr�ft nur, ob .java-Dateien fehlerfrei geparst werden. Der + * dabei erstellte Syntaxbaum wird nicht kontrolliert. + * + * @author janulrich + * + */ +public class GeneralParserTest2 { + private static final String rootDirectory = System.getProperty("user.dir") + "/test/strucTypes/"; + + @Test + public void run() { + + /* + * Auflistung aller Files die getestet werden sollen + */ + List filenames = new ArrayList(); + // filenames.add("FieldInitializationTest.jav"); + // filenames.add("ImportTest.jav"); + // filenames.add("StatementsTest.jav"); + // filenames.add("ImportTestGeneric.jav"); + // filenames.add("BoundedParameter.jav"); + // filenames.add("GenericFieldVarTest.jav"); + // filenames.add("FieldVarTest.jav"); + + filenames.add("StructuralTypesSimple3.jav"); + // filenames.add("StructuralTypesField.jav"); + // filenames.add("Main.jav"); + + JavaTXParser parser = new JavaTXParser(); + try { + for (String filename : filenames) { + + System.out.println("Teste: " + filename); + + SourceFile sf = parser.parse(new File(rootDirectory + filename)); + + SourceFile sfdebug = sf; + + // Erstellen der Assumptions + // (Assumption für die Argumente der Methode werden gleich + // miterstellt) + + // Assumptions + Map fAss = new HashMap<>(); + Map mAss = new HashMap<>(); + // Assumptions für die MethodenParameter + Map> argAss = new HashMap<>(); + + AssTuple assAll = new AssTuple(fAss,mAss,argAss); + + // Extraktion aller Typen der Methoden + for (ClassOrInterface cl : sf.getClasses()) { + for (Field f : cl.getFieldDecl()) { + String fieldname = f.getName(); + String type = f.getType().toString(); + fAss.put(fieldname, f.getType()); + System.out.println(String.format("Feldname: %s Typ: %s", fieldname, type)); + } + + for (Method m : cl.getMethods()) { + String methodName = m.getName(); + String returnType = m.getType().toString(); + mAss.put(methodName, m.getType()); + + String typeArg = ""; + Map ass = new HashMap<>(); + for (FormalParameter p : m.getParameterList().getFormalparalist()) { + String pName = p.getName(); + String pType = p.getType().toString(); + typeArg = typeArg + String.format("%s : %s", pName, pType); + ass.put(p.getName(), p.getType()); + } + argAss.put(m, ass); + System.out.println(String.format("Methodenname: %s , Arguments: %s -> ReturnType %s", + methodName, typeArg, returnType)); + } + } + + // Als nächstes muss die Expression getypt werden + for (ClassOrInterface cl : sf.getClasses()) { + for (Method m : cl.getMethods()) { + Block block = m.get_Block(); + + /* + * Wahrscheinlich ist der TPH des Blocks der wahre Typ + * und der Typ der methode kann auch kleiner sein + */ + System.out.println("Block" + block.getType().toString()); + + // ein block hat einen TPH und eine Statement Liste + // davon wird das erste statement genommen welches ein + // Return Statement ist + + // TODO: check get 0 + Statement statement = block.getStatements().get(0); + + if (statement.getClass().equals(Return.class)) { + Return rStatement = (Return) statement; + Expression expression = rStatement.get_Expression(); + + // An dieser Stelle muss ein Rekursiver Aufruf + // möglich werden + String exp = HelpMethoden.expression2String(expression); + System.out.println("Expression: " + exp); + + String exp_t = HelpMethoden.expression_typed2String(expression); + System.out.println("Expression_typed: " + exp_t); + + List constraints = HelpMethoden.TypeExpr(assAll, expression, m, cl); + for (ConstraintAbstract c : constraints) { + System.out.println(c.toString()); + } + + + + + + + } else { + System.err.println("Problem"); + } + + } + } + + } + } catch (Exception exc) { + exc.printStackTrace(); + fail(); + } + assertTrue("Tests durchlaufen", filenames.size() > 0); + } +} + +class HelpMethoden { + + public static String expression2String(Expression expression) { + + // LocalVar + if (expression.getClass().equals(LocalVar.class)) { + String resultStr = ""; + LocalVar lvar = (LocalVar) expression; + resultStr = resultStr + lvar.get_expression(); + return resultStr; + } + // FeldVar + else if (expression.getClass().equals(FieldVar.class)) { + FieldVar fieldVar = (FieldVar) expression; + Expression receiver = fieldVar.getReceiver(); + String result = HelpMethoden.expression2String(receiver); + result = result + "." + fieldVar.getFieldVarName(); + return result; + } + // MethodCall + else if (expression.getClass().equals(MethodCall.class)) { + MethodCall methodCall = (MethodCall) expression; + + // nur bei MethodCall reciever = Typ Reciver mit eigenem TPH + Expression receiver = methodCall.get_Receiver(); + + String result; + if (receiver.getClass().equals(Receiver.class)) { + Receiver r_cast = (Receiver) receiver; + result = HelpMethoden.expression2String(r_cast.get_Expression()); + } else { + result = HelpMethoden.expression2String(receiver); + } + + // Jetzt muss noch die ArgumentListe ermittelt werden + // Problem, Diese kann alles enthalten + String argumentsStr = ""; + List arguments = methodCall.get_ArgList().getArguments(); + for (Expression arg : arguments) { + argumentsStr = argumentsStr + " " + HelpMethoden.expression2String(arg); + } + + result = String.format("%s.%s(%s)", result, methodCall.get_Name(), argumentsStr); + return result; + } else { + System.err.println("Fehler"); + return null; + } + } + + public static String expression_typed2String(Expression expression) { + + // LocalVar + if (expression.getClass().equals(LocalVar.class)) { + String resultStr = ""; + LocalVar lvar = (LocalVar) expression; + resultStr = resultStr + lvar.get_expression() + ":" + lvar.getType().toString(); + return resultStr; + } + // FeldVar + else if (expression.getClass().equals(FieldVar.class)) { + FieldVar fieldVar = (FieldVar) expression; + Expression receiver = fieldVar.getReceiver(); + String result = HelpMethoden.expression_typed2String(receiver); + result = result + "." + fieldVar.getFieldVarName() + ":" + fieldVar.getType().toString(); + return result; + } + // MethodCall + else if (expression.getClass().equals(MethodCall.class)) { + MethodCall methodCall = (MethodCall) expression; + + // nur bei MethodCall reciever = Typ Reciver mit eigenem TPH + Expression receiver = methodCall.get_Receiver(); + + String result; + if (receiver.getClass().equals(Receiver.class)) { + Receiver r_cast = (Receiver) receiver; + result = HelpMethoden.expression_typed2String(r_cast.get_Expression()); + } else { + result = HelpMethoden.expression_typed2String(receiver) + ":" + receiver.getType().toString(); + } + + // Jetzt muss noch die ArgumentListe ermittelt werden + // Problem, Diese kann alles enthalten + String argumentsStr = ""; + List arguments = methodCall.get_ArgList().getArguments(); + for (Expression arg : arguments) { + argumentsStr = argumentsStr + " " + HelpMethoden.expression_typed2String(arg) + arg.getType(); + } + + result = String.format("%s.%s(%s)", result, methodCall.get_Name(), argumentsStr); + return result; + } else { + System.err.println("Fehler"); + return null; + } + } + + + // Diese Methode übernimmt die Berechnung der Typen + public static List TypeExpr(AssTuple ass, Expression expression, Method method, ClassOrInterface cl) { + + // LocalVar (Constraints für den Algo, Constraints für die Interfaces + // usw. ) + // LocalVar + if (expression.getClass().equals(LocalVar.class)) { + LocalVar lvar = (LocalVar) expression; + List constraints = new ArrayList(); + RefTypeOrTPHOrWildcardOrGeneric type = ass.getTypeOfLocalVar(lvar.get_expression(), method); + GleichConstraint constraint = new GleichConstraint(lvar.getType(), type); + constraints.add(constraint); + return constraints; + } + // FeldVar + else if (expression.getClass().equals(FieldVar.class)) { + FieldVar fieldVar = (FieldVar) expression; + Expression receiver = fieldVar.getReceiver(); + List constraints = HelpMethoden.TypeExpr(ass, receiver, method, cl); + + //TODO Hier muss der Constraint angelegt werden. Der Type receiver X besitzt ein feld mit dem Typen Y + //TODO constriant(c,f,c') + //TODO constraint(TypeKlasse, feldname, typdesfelde) + //TODO constriant(typReveier , besitzt ein feld mit dem typen , typdesfeldes); + //TODO constriant(typReceiver, name des Feldes , TypDesFeldes). + FieldConstraint constraint = new FieldConstraint(receiver.getType(), fieldVar.getFieldVarName() , fieldVar.getType()); + constraints.add(constraint); + return constraints; + + } + // MethodCall + else if (expression.getClass().equals(MethodCall.class)) { + MethodCall methodCall = (MethodCall) expression; + + // nur bei MethodCall reciever = Typ Reciver mit eigenem TPH + Expression receiver = methodCall.get_Receiver(); + + List constraints; + if (receiver.getClass().equals(Receiver.class)) { + Receiver r_cast = (Receiver) receiver; + constraints = HelpMethoden.TypeExpr(ass, r_cast.get_Expression(), method, cl); + } else { + constraints = HelpMethoden.TypeExpr(ass, receiver, method, cl); + } + + //TODO An dieser Stelle muss noch der MethodenConstraint erstellt werden + List argumentTypesVars = new ArrayList<>(); + List argumentTypes = new ArrayList<>(); + for (Expression arg : methodCall.get_ArgList().getArguments()) { + argumentTypesVars.add(arg.getType()); + constraints.addAll(HelpMethoden.TypeExpr(ass, arg, method, cl)); + } + + + + + MethodConstraint methodConstraint = new MethodConstraint(receiver.getType(), methodCall.get_Name(), argumentTypes, methodCall.getType(), argumentTypesVars ); + + constraints.add(methodConstraint); + return constraints; + + + + } else { + System.err.println("Fehler"); + return null; + } + + } + +} + + + +/**************************************** + * Definition der Constraint Klassen + */ + +class ConstraintAbstract { + +} + +class GleichConstraint extends ConstraintAbstract { + + private RefTypeOrTPHOrWildcardOrGeneric a; + private RefTypeOrTPHOrWildcardOrGeneric b; + + // Type A ist Type B + public GleichConstraint(RefTypeOrTPHOrWildcardOrGeneric a, RefTypeOrTPHOrWildcardOrGeneric b) { + this.a = a; + this.b = b; + } + + public String toString() { + return String.format("GleichConstraint( %s , %s )" , a.toString(), b.toString()); + } + +} + + +class FieldConstraint extends ConstraintAbstract { + + private RefTypeOrTPHOrWildcardOrGeneric reveiver; + private String name_of_field; + private RefTypeOrTPHOrWildcardOrGeneric attribut; + + public FieldConstraint(RefTypeOrTPHOrWildcardOrGeneric receiver, String name_of_field, + RefTypeOrTPHOrWildcardOrGeneric attribut) { + super(); + this.reveiver = receiver; + this.name_of_field = name_of_field; + this.attribut = attribut; + } + + public String toString() { + return String.format("FieldConstraint(%s , %s , %s)" , reveiver, name_of_field, attribut ); + } + + public RefTypeOrTPHOrWildcardOrGeneric getReveiver() { + return reveiver; + } + + public void setReveiver(RefTypeOrTPHOrWildcardOrGeneric reveiver) { + this.reveiver = reveiver; + } + + public String getName_of_field() { + return name_of_field; + } + + public void setName_of_field(String name_of_field) { + this.name_of_field = name_of_field; + } + + public RefTypeOrTPHOrWildcardOrGeneric getAttribut() { + return attribut; + } + + public void setAttribut(RefTypeOrTPHOrWildcardOrGeneric attribut) { + this.attribut = attribut; + } + + +} + + +class MethodConstraint extends ConstraintAbstract { + + /* Der MethodConstraint + * constraint( typ_receiver, methodname, arguments_typen ( return_type , typvar von argumenttypen ) + */ + + private RefTypeOrTPHOrWildcardOrGeneric receiver; + private String methodName; + private List argumentTypes; + private RefTypeOrTPHOrWildcardOrGeneric returnType; + private List argumentTypeVars; + + public MethodConstraint(RefTypeOrTPHOrWildcardOrGeneric receiver, String methodName, + List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType, + List argumentTypeVars) { + super(); + this.receiver = receiver; + this.methodName = methodName; + this.argumentTypes = argumentTypes; + this.returnType = returnType; + this.argumentTypeVars = argumentTypeVars; + } + + public String toString() { + return String.format("MethodConstraint( %s, %s , %s (%s , %s ))" , receiver.toString() , methodName, "arg" , returnType.toString() , argumentTypeVars.toString() ); + } + + + +} \ No newline at end of file From d4e32794fffc0648ecd8b3374f55e3f89d0be34e Mon Sep 17 00:00:00 2001 From: sebastian Date: Mon, 3 Apr 2017 02:34:43 +0200 Subject: [PATCH 4/7] =?UTF-8?q?TypeExpr=20f=C3=BCr=20methoden=20geschriebe?= =?UTF-8?q?n?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dhbwstuttgart/strucTypes3/AssTuple.java | 64 ++++++ .../strucTypes3/AssumptionGenerator.java | 69 ++++++ .../strucTypes3/ConstraintAbstract.java | 5 + .../strucTypes3/FieldConstraint.java | 49 ++++ .../strucTypes3/GleichConstraint.java | 45 ++++ .../strucTypes3/HelpMethoden.java | 209 ++++++++++++++++++ .../strucTypes3/MethodConstraint.java | 33 +++ .../strucTypes3/SubTypeConstraint.java | 45 ++++ .../strucTypes3/ToStringGenerator.java | 63 ++++++ test/strucTypes/StructuralTypesSimple3.jav | 2 +- test/strucTypes2/GeneralParserTest2.java | 13 +- test/strucTypes3/GeneralParserTest2.java | 100 +++++++++ test/strucTypes3/StructuralTypesSimple3.jav | 20 ++ .../StructuralTypesSimpleSkript.jav | 10 + 14 files changed, 715 insertions(+), 12 deletions(-) create mode 100644 src/de/dhbwstuttgart/strucTypes3/AssTuple.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/ConstraintAbstract.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/GleichConstraint.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/SubTypeConstraint.java create mode 100644 src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java create mode 100644 test/strucTypes3/GeneralParserTest2.java create mode 100644 test/strucTypes3/StructuralTypesSimple3.jav create mode 100644 test/strucTypes3/StructuralTypesSimpleSkript.jav diff --git a/src/de/dhbwstuttgart/strucTypes3/AssTuple.java b/src/de/dhbwstuttgart/strucTypes3/AssTuple.java new file mode 100644 index 00000000..c32e35f9 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/AssTuple.java @@ -0,0 +1,64 @@ +package de.dhbwstuttgart.strucTypes3; + +import java.util.Map; + +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +public class AssTuple { + + private Map fAss; + private Map mAss; + private Map> argAss; + + public AssTuple(Map fAss, + Map mAss, + Map> argAss) { + super(); + this.fAss = fAss; + this.mAss = mAss; + this.argAss = argAss; + } + + public RefTypeOrTPHOrWildcardOrGeneric getTypeOfLocalVar(String name , Method method) { + + // Schaue als erstes in den Argumenten dann in den Feldvariablen der Klasse + Map argAssMethod = argAss.get(method); + if (argAssMethod.containsKey(name)) { + return argAssMethod.get(name); + } + else if (fAss.containsKey(name)) { + return fAss.get(name); + } + else { + System.err.println("Fehler: Typ nicht bekannt"); + return null; + } + + + } + + public Map getfAss() { + return fAss; + } + + public void setfAss(Map fAss) { + this.fAss = fAss; + } + + public Map getmAss() { + return mAss; + } + + public void setmAss(Map mAss) { + this.mAss = mAss; + } + + public Map> getArgAss() { + return argAss; + } + + public void setArgAss(Map> argAss) { + this.argAss = argAss; + } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java b/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java new file mode 100644 index 00000000..1ec57122 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java @@ -0,0 +1,69 @@ +package de.dhbwstuttgart.strucTypes3; + +import java.util.HashMap; +import java.util.Map; + +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.FormalParameter; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +public class AssumptionGenerator { + + /* + * Generiert die Assumptions einer Klasse + */ + public static AssTuple generateAssumptions(ClassOrInterface cl) { + + // Erstellen der Assumptions + // (Assumption für die Argumente der Methode werden gleich + // miterstellt) + + // Assumptions + Map fAss = new HashMap<>(); + Map mAss = new HashMap<>(); + // Assumptions für die MethodenParameter + Map> argAss = new HashMap<>(); + + AssTuple assAll = new AssTuple(fAss, mAss, argAss); + + // Extraktion aller Typen der Methoden + + // Assumptions für Felder + for (Field f : cl.getFieldDecl()) { + String fieldname = f.getName(); + String type = f.getType().toString(); + fAss.put(fieldname, f.getType()); + System.out.println(String.format("Feldname: %s Typ: %s", fieldname, type)); + } + + + // Assumptions für Methoden + for (Method m : cl.getMethods()) { + String methodName = m.getName(); + String returnType = m.getType().toString(); + mAss.put(methodName, m.getType()); + + String typeArg = ""; + Map ass = new HashMap<>(); + for (FormalParameter p : m.getParameterList().getFormalparalist()) { + String pName = p.getName(); + String pType = p.getType().toString(); + typeArg = typeArg + String.format("%s : %s", pName, pType); + ass.put(p.getName(), p.getType()); + } + argAss.put(m, ass); + System.out.println(String.format("Methodenname: %s , Arguments: %s -> ReturnType %s", methodName, typeArg, + returnType)); + } + + + //TODO : Assumption für die eingene aktuelle Klasse + + + + return assAll; + } + +} diff --git a/src/de/dhbwstuttgart/strucTypes3/ConstraintAbstract.java b/src/de/dhbwstuttgart/strucTypes3/ConstraintAbstract.java new file mode 100644 index 00000000..a6b28eaf --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/ConstraintAbstract.java @@ -0,0 +1,5 @@ +package de.dhbwstuttgart.strucTypes3; + +public class ConstraintAbstract { + +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java b/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java new file mode 100644 index 00000000..67b4feaa --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java @@ -0,0 +1,49 @@ +package de.dhbwstuttgart.strucTypes3; + +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + + +class FieldConstraint extends ConstraintAbstract { + + private RefTypeOrTPHOrWildcardOrGeneric reveiver; + private String name_of_field; + private RefTypeOrTPHOrWildcardOrGeneric attribut; + + public FieldConstraint(RefTypeOrTPHOrWildcardOrGeneric receiver, String name_of_field, + RefTypeOrTPHOrWildcardOrGeneric attribut) { + super(); + this.reveiver = receiver; + this.name_of_field = name_of_field; + this.attribut = attribut; + } + + public String toString() { + return String.format("FieldConstraint(%s , %s , %s)" , reveiver, name_of_field, attribut ); + } + + public RefTypeOrTPHOrWildcardOrGeneric getReveiver() { + return reveiver; + } + + public void setReveiver(RefTypeOrTPHOrWildcardOrGeneric reveiver) { + this.reveiver = reveiver; + } + + public String getName_of_field() { + return name_of_field; + } + + public void setName_of_field(String name_of_field) { + this.name_of_field = name_of_field; + } + + public RefTypeOrTPHOrWildcardOrGeneric getAttribut() { + return attribut; + } + + public void setAttribut(RefTypeOrTPHOrWildcardOrGeneric attribut) { + this.attribut = attribut; + } + + +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/strucTypes3/GleichConstraint.java b/src/de/dhbwstuttgart/strucTypes3/GleichConstraint.java new file mode 100644 index 00000000..d83a61e7 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/GleichConstraint.java @@ -0,0 +1,45 @@ +package de.dhbwstuttgart.strucTypes3; + +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + + +public class GleichConstraint extends ConstraintAbstract { + + private RefTypeOrTPHOrWildcardOrGeneric a; + private RefTypeOrTPHOrWildcardOrGeneric b; + + // Type A ist Type B + public GleichConstraint(RefTypeOrTPHOrWildcardOrGeneric a, RefTypeOrTPHOrWildcardOrGeneric b) { + this.a = a; + this.b = b; + } + + + public String toString() { + return String.format("GleichConstraint( %s , %s )" , a.toString(), b.toString()); + } + + + public RefTypeOrTPHOrWildcardOrGeneric getA() { + return a; + } + + + public void setA(RefTypeOrTPHOrWildcardOrGeneric a) { + this.a = a; + } + + + public RefTypeOrTPHOrWildcardOrGeneric getB() { + return b; + } + + + public void setB(RefTypeOrTPHOrWildcardOrGeneric b) { + this.b = b; + } + + + + +} diff --git a/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java b/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java new file mode 100644 index 00000000..e0ad99cc --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java @@ -0,0 +1,209 @@ +package de.dhbwstuttgart.strucTypes3; + +import java.util.ArrayList; +import java.util.List; + +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.statement.Expression; +import de.dhbwstuttgart.syntaxtree.statement.FieldVar; +import de.dhbwstuttgart.syntaxtree.statement.LocalVar; +import de.dhbwstuttgart.syntaxtree.statement.MethodCall; +import de.dhbwstuttgart.syntaxtree.statement.Receiver; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import de.dhbwstuttgart.strucTypes3.AssTuple; +import de.dhbwstuttgart.strucTypes3.ConstraintAbstract; +import de.dhbwstuttgart.strucTypes3.FieldConstraint; +import de.dhbwstuttgart.strucTypes3.GleichConstraint; +import de.dhbwstuttgart.strucTypes3.MethodConstraint; + +public class HelpMethoden { + + public static String expression2String(Expression expression) { + + // LocalVar + if (expression.getClass().equals(LocalVar.class)) { + String resultStr = ""; + LocalVar lvar = (LocalVar) expression; + resultStr = resultStr + lvar.get_expression(); + return resultStr; + } + // FeldVar + else if (expression.getClass().equals(FieldVar.class)) { + FieldVar fieldVar = (FieldVar) expression; + Expression receiver = fieldVar.getReceiver(); + String result = HelpMethoden.expression2String(receiver); + result = result + "." + fieldVar.getFieldVarName(); + return result; + } + // MethodCall + else if (expression.getClass().equals(MethodCall.class)) { + MethodCall methodCall = (MethodCall) expression; + + // nur bei MethodCall reciever = Typ Reciver mit eigenem TPH + Expression receiver = methodCall.get_Receiver(); + + String result; + if (receiver.getClass().equals(Receiver.class)) { + Receiver r_cast = (Receiver) receiver; + result = HelpMethoden.expression2String(r_cast.get_Expression()); + } else { + result = HelpMethoden.expression2String(receiver); + } + + // Jetzt muss noch die ArgumentListe ermittelt werden + // Problem, Diese kann alles enthalten + String argumentsStr = ""; + List arguments = methodCall.get_ArgList().getArguments(); + for (Expression arg : arguments) { + argumentsStr = argumentsStr + " " + HelpMethoden.expression2String(arg); + } + + result = String.format("%s.%s(%s)", result, methodCall.get_Name(), argumentsStr); + return result; + } else { + System.err.println("Fehler"); + return null; + } + } + + public static String expression_typed2String(Expression expression) { + + // LocalVar + if (expression.getClass().equals(LocalVar.class)) { + String resultStr = ""; + LocalVar lvar = (LocalVar) expression; + resultStr = resultStr + lvar.get_expression() + ":" + lvar.getType().toString(); + return resultStr; + } + // FeldVar + else if (expression.getClass().equals(FieldVar.class)) { + FieldVar fieldVar = (FieldVar) expression; + Expression receiver = fieldVar.getReceiver(); + String result = HelpMethoden.expression_typed2String(receiver); + result = result + "." + fieldVar.getFieldVarName() + ":" + fieldVar.getType().toString(); + return result; + } + // MethodCall + else if (expression.getClass().equals(MethodCall.class)) { + MethodCall methodCall = (MethodCall) expression; + + // nur bei MethodCall reciever = Typ Reciver mit eigenem TPH + Expression receiver = methodCall.get_Receiver(); + + String result; + if (receiver.getClass().equals(Receiver.class)) { + Receiver r_cast = (Receiver) receiver; + result = HelpMethoden.expression_typed2String(r_cast.get_Expression()); + } else { + result = HelpMethoden.expression_typed2String(receiver) + ":" + receiver.getType().toString(); + } + + // Jetzt muss noch die ArgumentListe ermittelt werden + // Problem, Diese kann alles enthalten + String argumentsStr = ""; + List arguments = methodCall.get_ArgList().getArguments(); + for (Expression arg : arguments) { + argumentsStr = argumentsStr + " " + HelpMethoden.expression_typed2String(arg) ;//+ arg.getType(); + } + + result = String.format("%s.%s(%s)", result, methodCall.get_Name(), argumentsStr); + return result; + } else { + System.err.println("Fehler"); + return null; + } + } + + + // Diese Methode übernimmt die Berechnung der Typen + public static List TypeExpr(AssTuple ass, Expression expression, Method method, ClassOrInterface cl) { + + // LocalVar (Constraints für den Algo, Constraints für die Interfaces + // usw. ) + // LocalVar + if (expression.getClass().equals(LocalVar.class)) { + LocalVar lvar = (LocalVar) expression; + List constraints = new ArrayList(); + RefTypeOrTPHOrWildcardOrGeneric type = ass.getTypeOfLocalVar(lvar.get_expression(), method); + GleichConstraint constraint = new GleichConstraint(lvar.getType(), type); + constraints.add(constraint); + return constraints; + } + // FeldVar + else if (expression.getClass().equals(FieldVar.class)) { + FieldVar fieldVar = (FieldVar) expression; + Expression receiver = fieldVar.getReceiver(); + List constraints = HelpMethoden.TypeExpr(ass, receiver, method, cl); + + // Hier muss der Constraint angelegt werden. Der Type receiver X besitzt ein feld mit dem Typen Y + // constriant(c,f,c') + // constraint(TypeKlasse, feldname, typdesfelde) + // constriant(typReveier , besitzt ein feld mit dem typen , typdesfeldes); + // constriant(typReceiver, name des Feldes , TypDesFeldes). + FieldConstraint constraint = new FieldConstraint(receiver.getType(), fieldVar.getFieldVarName() , fieldVar.getType()); + constraints.add(constraint); + return constraints; + + } + // MethodCall + else if (expression.getClass().equals(MethodCall.class)) { + MethodCall methodCall = (MethodCall) expression; + + // nur bei MethodCall reciever = Typ Reciver mit eigenem TPH + Expression receiver = methodCall.get_Receiver(); + + List constraints; + if (receiver.getClass().equals(Receiver.class)) { + Receiver r_cast = (Receiver) receiver; + constraints = HelpMethoden.TypeExpr(ass, r_cast.get_Expression(), method, cl); + } else { + constraints = HelpMethoden.TypeExpr(ass, receiver, method, cl); + } + + // An dieser Stelle wird der Methoden Constraint erstellt + List argumentTypesVars = new ArrayList<>(); + List argumentTypes = new ArrayList<>(); + for (Expression arg : methodCall.get_ArgList().getArguments()) { + argumentTypesVars.add(arg.getType()); + constraints.addAll(HelpMethoden.TypeExpr(ass, arg, method, cl)); + } + + // Es wird der Typ des übergabeparameter erstellt + List puffer = new ArrayList<>(); + for (RefTypeOrTPHOrWildcardOrGeneric type : argumentTypesVars) { + for (ConstraintAbstract c : constraints) { + if (c.getClass().equals(GleichConstraint.class)) { + GleichConstraint gc = (GleichConstraint) c; + if (gc.getA().equals(type)) { + argumentTypes.add(gc.getB()); + + // subtype + puffer.add(new SubTypeConstraint(gc.getB() , gc.getA() )); + } + } + } + } + + constraints.addAll(puffer); + + + + + + + MethodConstraint methodConstraint = new MethodConstraint(receiver.getType(), methodCall.get_Name(), argumentTypes, methodCall.getType(), argumentTypesVars ); + + constraints.add(methodConstraint); + return constraints; + + + + } else { + System.err.println("Fehler"); + return null; + } + + } + +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java b/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java new file mode 100644 index 00000000..12679f26 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java @@ -0,0 +1,33 @@ +package de.dhbwstuttgart.strucTypes3; + +import java.util.List; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + + +class MethodConstraint extends ConstraintAbstract { + + /* Der MethodConstraint + * constraint( typ_receiver, methodname, arguments_typen ( return_type , typvar von argumenttypen ) + */ + + private RefTypeOrTPHOrWildcardOrGeneric receiver; + private String methodName; + private List argumentTypes; + private RefTypeOrTPHOrWildcardOrGeneric returnType; + private List argumentTypeVars; + + public MethodConstraint(RefTypeOrTPHOrWildcardOrGeneric receiver, String methodName, + List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType, + List argumentTypeVars) { + super(); + this.receiver = receiver; + this.methodName = methodName; + this.argumentTypes = argumentTypes; + this.returnType = returnType; + this.argumentTypeVars = argumentTypeVars; + } + + public String toString() { + return String.format("MethodConstraint( %s, %s , %s (%s , %s ))" , receiver.toString() , methodName, argumentTypes.toString() , returnType.toString() , argumentTypeVars.toString() ); + } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/strucTypes3/SubTypeConstraint.java b/src/de/dhbwstuttgart/strucTypes3/SubTypeConstraint.java new file mode 100644 index 00000000..2c194853 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/SubTypeConstraint.java @@ -0,0 +1,45 @@ +package de.dhbwstuttgart.strucTypes3; + +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +public class SubTypeConstraint extends ConstraintAbstract { + + private RefTypeOrTPHOrWildcardOrGeneric basisKlasse; + private RefTypeOrTPHOrWildcardOrGeneric subTypeKlasse; + + public SubTypeConstraint(RefTypeOrTPHOrWildcardOrGeneric basisKlasse, + RefTypeOrTPHOrWildcardOrGeneric subTypeKlasse) { + super(); + this.basisKlasse = basisKlasse; + this.subTypeKlasse = subTypeKlasse; + } + + + public String toString() { + return String.format("SubType( %s <* %s ) " ,basisKlasse, subTypeKlasse); + } + + public RefTypeOrTPHOrWildcardOrGeneric getBasisKlasse() { + return basisKlasse; + } + + public void setBasisKlasse(RefTypeOrTPHOrWildcardOrGeneric basisKlasse) { + this.basisKlasse = basisKlasse; + } + + public RefTypeOrTPHOrWildcardOrGeneric getSubTypeKlasse() { + return subTypeKlasse; + } + + public void setSubTypeKlasse(RefTypeOrTPHOrWildcardOrGeneric subTypeKlasse) { + this.subTypeKlasse = subTypeKlasse; + } + + + + + + + + +} diff --git a/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java b/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java new file mode 100644 index 00000000..e3ad677b --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java @@ -0,0 +1,63 @@ +package de.dhbwstuttgart.strucTypes3; + +import java.util.List; + +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.statement.Block; +import de.dhbwstuttgart.syntaxtree.statement.Expression; +import de.dhbwstuttgart.syntaxtree.statement.Return; +import de.dhbwstuttgart.syntaxtree.statement.Statement; + + +public class ToStringGenerator { + + public String klasseToString(ClassOrInterface cl, AssTuple assAll) { + + // Als nächstes muss die Expression getypt werden + + for (Method m : cl.getMethods()) { + Block block = m.get_Block(); + + /* + * Wahrscheinlich ist der TPH des Blocks der wahre Typ und der Typ + * der methode kann auch kleiner sein + */ + System.out.println("Block" + block.getType().toString()); + + // ein block hat einen TPH und eine Statement Liste + // davon wird das erste statement genommen welches ein + // Return Statement ist + + // TODO: check get 0 + Statement statement = block.getStatements().get(0); + + if (statement.getClass().equals(Return.class)) { + Return rStatement = (Return) statement; + Expression expression = rStatement.get_Expression(); + + // An dieser Stelle muss ein Rekursiver Aufruf + // möglich werden + String exp = HelpMethoden.expression2String(expression); + System.out.println("Expression: " + exp); + + String exp_t = HelpMethoden.expression_typed2String(expression); + System.out.println("Expression_typed: " + exp_t); + + List constraints = HelpMethoden.TypeExpr(assAll, expression, m, cl); + for (ConstraintAbstract c : constraints) { + System.out.println(c.toString()); + } + + } else { + System.err.println("Problem"); + } + + } + + return null; + } + + + +} diff --git a/test/strucTypes/StructuralTypesSimple3.jav b/test/strucTypes/StructuralTypesSimple3.jav index 0fdb8aef..b4538074 100644 --- a/test/strucTypes/StructuralTypesSimple3.jav +++ b/test/strucTypes/StructuralTypesSimple3.jav @@ -10,7 +10,7 @@ class A { mt2(x2) { return x2.feld_von_x ; } - mt3(x,y,z) { return x.sub(y).add(z); } + mt3(xaver,y,z) { return xaver.sub(y).add(z); } mt4(x,y,z) { return x.f.add(y.sub(z,x)); } diff --git a/test/strucTypes2/GeneralParserTest2.java b/test/strucTypes2/GeneralParserTest2.java index 34b03f70..6df73531 100644 --- a/test/strucTypes2/GeneralParserTest2.java +++ b/test/strucTypes2/GeneralParserTest2.java @@ -9,17 +9,12 @@ import java.util.List; import java.util.Map; import de.dhbwstuttgart.parser.JavaTXParser; -import de.dhbwstuttgart.strucTypes.AS_Abstract; -import de.dhbwstuttgart.strucTypes.TC_Abstract; -import de.dhbwstuttgart.strucTypes.Algo_Type; -import de.dhbwstuttgart.strucTypes.Algo_TypeExpr; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.Field; import de.dhbwstuttgart.syntaxtree.FormalParameter; import de.dhbwstuttgart.syntaxtree.Method; import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.statement.Block; -import de.dhbwstuttgart.syntaxtree.statement.CastExpr; import de.dhbwstuttgart.syntaxtree.statement.Expression; import de.dhbwstuttgart.syntaxtree.statement.FieldVar; import de.dhbwstuttgart.syntaxtree.statement.LocalVar; @@ -144,8 +139,7 @@ public class GeneralParserTest2 { List constraints = HelpMethoden.TypeExpr(assAll, expression, m, cl); for (ConstraintAbstract c : constraints) { System.out.println(c.toString()); - } - + } @@ -254,7 +248,7 @@ class HelpMethoden { String argumentsStr = ""; List arguments = methodCall.get_ArgList().getArguments(); for (Expression arg : arguments) { - argumentsStr = argumentsStr + " " + HelpMethoden.expression_typed2String(arg) + arg.getType(); + argumentsStr = argumentsStr + " " + HelpMethoden.expression_typed2String(arg) ;//+ arg.getType(); } result = String.format("%s.%s(%s)", result, methodCall.get_Name(), argumentsStr); @@ -438,7 +432,4 @@ class MethodConstraint extends ConstraintAbstract { public String toString() { return String.format("MethodConstraint( %s, %s , %s (%s , %s ))" , receiver.toString() , methodName, "arg" , returnType.toString() , argumentTypeVars.toString() ); } - - - } \ No newline at end of file diff --git a/test/strucTypes3/GeneralParserTest2.java b/test/strucTypes3/GeneralParserTest2.java new file mode 100644 index 00000000..18ebfa3b --- /dev/null +++ b/test/strucTypes3/GeneralParserTest2.java @@ -0,0 +1,100 @@ +package strucTypes3; + +import static org.junit.Assert.*; + +import java.io.File; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import de.dhbwstuttgart.parser.JavaTXParser; +import de.dhbwstuttgart.strucTypes3.AssTuple; +import de.dhbwstuttgart.strucTypes3.AssumptionGenerator; +import de.dhbwstuttgart.strucTypes3.ConstraintAbstract; +import de.dhbwstuttgart.strucTypes3.HelpMethoden; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.FormalParameter; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.statement.Block; +import de.dhbwstuttgart.syntaxtree.statement.Expression; +import de.dhbwstuttgart.syntaxtree.statement.FieldVar; +import de.dhbwstuttgart.syntaxtree.statement.LocalVar; +import de.dhbwstuttgart.syntaxtree.statement.MethodCall; +import de.dhbwstuttgart.syntaxtree.statement.Receiver; +import de.dhbwstuttgart.syntaxtree.statement.Return; +import de.dhbwstuttgart.syntaxtree.statement.Statement; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import sun.reflect.generics.reflectiveObjects.NotImplementedException; + +import org.junit.Test; + +/** + * Dieser Test pr�ft nur, ob .java-Dateien fehlerfrei geparst werden. Der + * dabei erstellte Syntaxbaum wird nicht kontrolliert. + * + * @author janulrich + * + */ +public class GeneralParserTest2 { + private static final String rootDirectory = System.getProperty("user.dir") + "/test/strucTypes3/"; + + @Test + public void run() { + + /* + * Auflistung aller Files die getestet werden sollen + */ + List filenames = new ArrayList(); + // filenames.add("FieldInitializationTest.jav"); + // filenames.add("ImportTest.jav"); + // filenames.add("StatementsTest.jav"); + // filenames.add("ImportTestGeneric.jav"); + // filenames.add("BoundedParameter.jav"); + // filenames.add("GenericFieldVarTest.jav"); + // filenames.add("FieldVarTest.jav"); + + filenames.add("StructuralTypesSimpleSkript.jav"); + // filenames.add("StructuralTypesField.jav"); + // filenames.add("Main.jav"); + + JavaTXParser parser = new JavaTXParser(); + try { + for (String filename : filenames) { + + System.out.println("Teste: " + filename); + + SourceFile sf = parser.parse(new File(rootDirectory + filename)); + + SourceFile sfdebug = sf; + + ClassOrInterface aktClass = sf.getClasses().get(0); + AssTuple ass = AssumptionGenerator.generateAssumptions(aktClass); + + List constraints = new ArrayList<>(); + for (Method m : aktClass.getMethods()) { + Return rt = (Return) m.get_Block().statements.get(0); + Expression ex = (Expression) rt.get_Expression(); + constraints.addAll(HelpMethoden.TypeExpr(ass, ex, m, aktClass)); + } + + constraints.forEach( (x) -> {System.out.println(x); }); + + + + + + + + + } + + } catch (Exception exc) { + exc.printStackTrace(); + fail(); + } + assertTrue("Tests durchlaufen", filenames.size() > 0); + } +} diff --git a/test/strucTypes3/StructuralTypesSimple3.jav b/test/strucTypes3/StructuralTypesSimple3.jav new file mode 100644 index 00000000..b4538074 --- /dev/null +++ b/test/strucTypes3/StructuralTypesSimple3.jav @@ -0,0 +1,20 @@ + +class A { + + A f1; + + f2; + + + mt1(x1) { return x1; } + + mt2(x2) { return x2.feld_von_x ; } + + mt3(xaver,y,z) { return xaver.sub(y).add(z); } + + mt4(x,y,z) { return x.f.add(y.sub(z,x)); } + + + +} + diff --git a/test/strucTypes3/StructuralTypesSimpleSkript.jav b/test/strucTypes3/StructuralTypesSimpleSkript.jav new file mode 100644 index 00000000..70c53673 --- /dev/null +++ b/test/strucTypes3/StructuralTypesSimpleSkript.jav @@ -0,0 +1,10 @@ + +class A { + + + mt(x,y,z) { return x.sub(y).add(z); } + + + +} + From a9b9c46d84005a59d30ef0b9d5326d350aba8312 Mon Sep 17 00:00:00 2001 From: sebastian Date: Tue, 4 Apr 2017 14:52:55 +0200 Subject: [PATCH 5/7] =?UTF-8?q?Methodenconstraint=20neu=20definiert,=20Typ?= =?UTF-8?q?variable=20eingef=C3=BCgt)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../strucTypes3/AssumptionGenerator.java | 4 +- .../strucTypes3/HelpMethoden.java | 25 +++++---- .../strucTypes3/MethodConstraint.java | 4 +- .../dhbwstuttgart/strucTypes3/MyTypeVar.java | 53 +++++++++++++++++++ .../StructuralTypesSimpleSkript.jav | 9 ++-- 5 files changed, 74 insertions(+), 21 deletions(-) create mode 100644 src/de/dhbwstuttgart/strucTypes3/MyTypeVar.java diff --git a/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java b/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java index 1ec57122..b24bcfce 100644 --- a/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java +++ b/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java @@ -50,11 +50,11 @@ public class AssumptionGenerator { for (FormalParameter p : m.getParameterList().getFormalparalist()) { String pName = p.getName(); String pType = p.getType().toString(); - typeArg = typeArg + String.format("%s : %s", pName, pType); + typeArg = typeArg + String.format("%s :%s ", pName, pType); ass.put(p.getName(), p.getType()); } argAss.put(m, ass); - System.out.println(String.format("Methodenname: %s , Arguments: %s -> ReturnType %s", methodName, typeArg, + System.out.println(String.format("Methodenname: %s , Arguments: %s -> ReturnType %s ", methodName, typeArg, returnType)); } diff --git a/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java b/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java index e0ad99cc..4d74f23a 100644 --- a/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java +++ b/src/de/dhbwstuttgart/strucTypes3/HelpMethoden.java @@ -121,7 +121,7 @@ public class HelpMethoden { // LocalVar (Constraints für den Algo, Constraints für die Interfaces // usw. ) - // LocalVar + // LocalVar ------------------------------------------------------------------------------------------ if (expression.getClass().equals(LocalVar.class)) { LocalVar lvar = (LocalVar) expression; List constraints = new ArrayList(); @@ -130,7 +130,7 @@ public class HelpMethoden { constraints.add(constraint); return constraints; } - // FeldVar + // FeldVar ------------------------------------------------------------------------------------------ else if (expression.getClass().equals(FieldVar.class)) { FieldVar fieldVar = (FieldVar) expression; Expression receiver = fieldVar.getReceiver(); @@ -146,7 +146,7 @@ public class HelpMethoden { return constraints; } - // MethodCall + // MethodCall ------------------------------------------------------------------------------------------ else if (expression.getClass().equals(MethodCall.class)) { MethodCall methodCall = (MethodCall) expression; @@ -162,13 +162,20 @@ public class HelpMethoden { } // An dieser Stelle wird der Methoden Constraint erstellt - List argumentTypesVars = new ArrayList<>(); + /* + * + */ + List argumentTypesVars = new ArrayList<>(); List argumentTypes = new ArrayList<>(); + Integer index_arg = 1; for (Expression arg : methodCall.get_ArgList().getArguments()) { - argumentTypesVars.add(arg.getType()); + argumentTypesVars.add(new MyTypeVar(methodCall.get_Name(), index_arg , receiver.getType())); + index_arg = index_arg +1; constraints.addAll(HelpMethoden.TypeExpr(ass, arg, method, cl)); + argumentTypes.add(arg.getType()); } + /* // Es wird der Typ des übergabeparameter erstellt List puffer = new ArrayList<>(); for (RefTypeOrTPHOrWildcardOrGeneric type : argumentTypesVars) { @@ -185,15 +192,11 @@ public class HelpMethoden { } } + constraints.addAll(puffer); - - - - - + */ MethodConstraint methodConstraint = new MethodConstraint(receiver.getType(), methodCall.get_Name(), argumentTypes, methodCall.getType(), argumentTypesVars ); - constraints.add(methodConstraint); return constraints; diff --git a/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java b/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java index 12679f26..8812a7da 100644 --- a/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java +++ b/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java @@ -14,11 +14,11 @@ class MethodConstraint extends ConstraintAbstract { private String methodName; private List argumentTypes; private RefTypeOrTPHOrWildcardOrGeneric returnType; - private List argumentTypeVars; + private List argumentTypeVars; public MethodConstraint(RefTypeOrTPHOrWildcardOrGeneric receiver, String methodName, List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType, - List argumentTypeVars) { + List argumentTypeVars) { super(); this.receiver = receiver; this.methodName = methodName; diff --git a/src/de/dhbwstuttgart/strucTypes3/MyTypeVar.java b/src/de/dhbwstuttgart/strucTypes3/MyTypeVar.java new file mode 100644 index 00000000..2f864a46 --- /dev/null +++ b/src/de/dhbwstuttgart/strucTypes3/MyTypeVar.java @@ -0,0 +1,53 @@ +package de.dhbwstuttgart.strucTypes3; + +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +public class MyTypeVar { + + private String method_name; + private Integer index_Argument; + private RefTypeOrTPHOrWildcardOrGeneric typevar; + + public MyTypeVar(String method_name, Integer index_Argument, RefTypeOrTPHOrWildcardOrGeneric typevar) { + super(); + this.method_name = method_name; + this.index_Argument = index_Argument; + this.typevar = typevar; + } + + + + public String getMethod_name() { + return method_name; + } + + public void setMethod_name(String method_name) { + this.method_name = method_name; + } + + public Integer getIndex_Argument() { + return index_Argument; + } + + public void setIndex_Argument(Integer index_Argument) { + this.index_Argument = index_Argument; + } + + public RefTypeOrTPHOrWildcardOrGeneric getTypevar() { + return typevar; + } + + public void setTypevar(RefTypeOrTPHOrWildcardOrGeneric typevar) { + this.typevar = typevar; + } + + public String toString() { + return String.format("TypVar?( %s , %s , %s )" , method_name , index_Argument , typevar ); + } + + + + + + +} diff --git a/test/strucTypes3/StructuralTypesSimpleSkript.jav b/test/strucTypes3/StructuralTypesSimpleSkript.jav index 70c53673..fd0b55c5 100644 --- a/test/strucTypes3/StructuralTypesSimpleSkript.jav +++ b/test/strucTypes3/StructuralTypesSimpleSkript.jav @@ -1,10 +1,7 @@ -class A { - - mt(x,y,z) { return x.sub(y).add(z); } - - - + +class A { + mt(x,y,z) { return x.sub(y).add(z); } } From ce97cf82fd44d4e4d0d3c15dfe7e768961f0d3df Mon Sep 17 00:00:00 2001 From: sebastian Date: Tue, 4 Apr 2017 17:12:01 +0200 Subject: [PATCH 6/7] =?UTF-8?q?Generierung=20von=20Interfaces=20f=C3=BCr?= =?UTF-8?q?=20Felder=20und=20Methode=20=20hinzugef=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../strucTypes3/FieldConstraint.java | 2 +- .../strucTypes3/MethodConstraint.java | 73 ++++++++++- test/strucTypes3/Construct.java | 95 ++++++++++++++ .../GeneralParserTestConstruct.java | 116 ++++++++++++++++++ 4 files changed, 284 insertions(+), 2 deletions(-) create mode 100644 test/strucTypes3/Construct.java create mode 100644 test/strucTypes3/GeneralParserTestConstruct.java diff --git a/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java b/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java index 67b4feaa..b7ec196f 100644 --- a/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java +++ b/src/de/dhbwstuttgart/strucTypes3/FieldConstraint.java @@ -3,7 +3,7 @@ package de.dhbwstuttgart.strucTypes3; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; -class FieldConstraint extends ConstraintAbstract { +public class FieldConstraint extends ConstraintAbstract { private RefTypeOrTPHOrWildcardOrGeneric reveiver; private String name_of_field; diff --git a/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java b/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java index 8812a7da..d9989da6 100644 --- a/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java +++ b/src/de/dhbwstuttgart/strucTypes3/MethodConstraint.java @@ -4,7 +4,7 @@ import java.util.List; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; -class MethodConstraint extends ConstraintAbstract { +public class MethodConstraint extends ConstraintAbstract { /* Der MethodConstraint * constraint( typ_receiver, methodname, arguments_typen ( return_type , typvar von argumenttypen ) @@ -27,7 +27,78 @@ class MethodConstraint extends ConstraintAbstract { this.argumentTypeVars = argumentTypeVars; } + + + + public RefTypeOrTPHOrWildcardOrGeneric getReceiver() { + return receiver; + } + + + + + public void setReceiver(RefTypeOrTPHOrWildcardOrGeneric receiver) { + this.receiver = receiver; + } + + + + + public String getMethodName() { + return methodName; + } + + + + + public void setMethodName(String methodName) { + this.methodName = methodName; + } + + + + + public List getArgumentTypes() { + return argumentTypes; + } + + + + + public void setArgumentTypes(List argumentTypes) { + this.argumentTypes = argumentTypes; + } + + + + + public RefTypeOrTPHOrWildcardOrGeneric getReturnType() { + return returnType; + } + + + + + public void setReturnType(RefTypeOrTPHOrWildcardOrGeneric returnType) { + this.returnType = returnType; + } + + + + + public List getArgumentTypeVars() { + return argumentTypeVars; + } + + + + + public void setArgumentTypeVars(List argumentTypeVars) { + this.argumentTypeVars = argumentTypeVars; + } + public String toString() { return String.format("MethodConstraint( %s, %s , %s (%s , %s ))" , receiver.toString() , methodName, argumentTypes.toString() , returnType.toString() , argumentTypeVars.toString() ); + } } \ No newline at end of file diff --git a/test/strucTypes3/Construct.java b/test/strucTypes3/Construct.java new file mode 100644 index 00000000..52997243 --- /dev/null +++ b/test/strucTypes3/Construct.java @@ -0,0 +1,95 @@ +package strucTypes3; + +import java.util.ArrayList; +import java.util.List; + +import com.sun.org.apache.xalan.internal.xsltc.runtime.Parameter; + +import de.dhbwstuttgart.parser.NullToken; +import de.dhbwstuttgart.strucTypes3.ConstraintAbstract; +import de.dhbwstuttgart.strucTypes3.FieldConstraint; +import de.dhbwstuttgart.strucTypes3.MethodConstraint; +import de.dhbwstuttgart.strucTypes3.MyTypeVar; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.FormalParameter; +import de.dhbwstuttgart.syntaxtree.GenericDeclarationList; +import de.dhbwstuttgart.syntaxtree.GenericTypeVar; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.ParameterList; +import de.dhbwstuttgart.typecheck.JavaClassName; + +public class Construct { + + + public static ClassOrInterface constructInterfaces(ConstraintAbstract constraint) { + + if (constraint.getClass().equals(FieldConstraint.class)) { + FieldConstraint fieldConstraint = (FieldConstraint) constraint; + return Construct.constructInterfaceField(fieldConstraint); + } + else if (constraint.getClass().equals(MethodConstraint.class)) { + MethodConstraint methodConstriant = (MethodConstraint) constraint; + return Construct.constructInterfaceMethod(methodConstriant); + + } + else { + // Fehlerfall + return null; + } + } + + + public static ClassOrInterface constructInterfaceField(FieldConstraint fieldConstriant) { + + Field field = new Field(fieldConstriant.getName_of_field() , fieldConstriant.getAttribut() , 0 , null); + List fielddecl = new ArrayList<>(); + fielddecl.add(field); + JavaClassName name = new JavaClassName(fieldConstriant.getReveiver().toString()); + ClassOrInterface face = new ClassOrInterface(0, name, fielddecl, null, null, null, null, null , null); + return face; + + } + + + public static ClassOrInterface constructInterfaceMethod(MethodConstraint methodConstraint) { + + System.out.println("Generiere Method-Interface"); + + // Erstellen der Argumente der Methode + List formalParameterList = new ArrayList<>(); + ParameterList params = new ParameterList(formalParameterList, new NullToken()); + for (MyTypeVar typeVar : methodConstraint.getArgumentTypeVars()) { + params.getFormalparalist().add(new FormalParameter(typeVar.toString() , typeVar.getTypevar(), new NullToken() )); + } + + // Erstellen der Methode + Method method = new Method(methodConstraint.getMethodName() ,methodConstraint.getReturnType(), 0, params, null, null, null); + List methodlist = new ArrayList<>(); + methodlist.add(method); + + // Name des neuen Interfaces + JavaClassName name = new JavaClassName(methodConstraint.getReceiver().toString()); + + //Erstellen der Generics + List genericTypeVarList = new ArrayList<>(); + GenericDeclarationList genericDeclaraitonList = new GenericDeclarationList(genericTypeVarList, new NullToken()); + for (MyTypeVar tv : methodConstraint.getArgumentTypeVars()) { + genericTypeVarList.add(new GenericTypeVar(tv.toString(), null, new NullToken(), new NullToken())); + } + + + ClassOrInterface face = new ClassOrInterface(0, name, null, methodlist, genericDeclaraitonList, null, true, null, null); + return face; + } + + + + + + + + + + +} diff --git a/test/strucTypes3/GeneralParserTestConstruct.java b/test/strucTypes3/GeneralParserTestConstruct.java new file mode 100644 index 00000000..a8ab15ff --- /dev/null +++ b/test/strucTypes3/GeneralParserTestConstruct.java @@ -0,0 +1,116 @@ +package strucTypes3; + +import static org.junit.Assert.*; + +import java.io.File; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import de.dhbwstuttgart.parser.JavaTXParser; +import de.dhbwstuttgart.strucTypes3.AssTuple; +import de.dhbwstuttgart.strucTypes3.AssumptionGenerator; +import de.dhbwstuttgart.strucTypes3.ConstraintAbstract; +import de.dhbwstuttgart.strucTypes3.HelpMethoden; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.FormalParameter; +import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.statement.Block; +import de.dhbwstuttgart.syntaxtree.statement.Expression; +import de.dhbwstuttgart.syntaxtree.statement.FieldVar; +import de.dhbwstuttgart.syntaxtree.statement.LocalVar; +import de.dhbwstuttgart.syntaxtree.statement.MethodCall; +import de.dhbwstuttgart.syntaxtree.statement.Receiver; +import de.dhbwstuttgart.syntaxtree.statement.Return; +import de.dhbwstuttgart.syntaxtree.statement.Statement; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import sun.reflect.generics.reflectiveObjects.NotImplementedException; + +import org.junit.Test; + +/** + * Dieser Test pr�ft nur, ob .java-Dateien fehlerfrei geparst werden. Der + * dabei erstellte Syntaxbaum wird nicht kontrolliert. + * + * @author janulrich + * + */ +public class GeneralParserTestConstruct { + private static final String rootDirectory = System.getProperty("user.dir") + "/test/strucTypes3/"; + + @Test + public void run() { + + /* + * Auflistung aller Files die getestet werden sollen + */ + List filenames = new ArrayList(); + // filenames.add("FieldInitializationTest.jav"); + // filenames.add("ImportTest.jav"); + // filenames.add("StatementsTest.jav"); + // filenames.add("ImportTestGeneric.jav"); + // filenames.add("BoundedParameter.jav"); + // filenames.add("GenericFieldVarTest.jav"); + // filenames.add("FieldVarTest.jav"); + + filenames.add("StructuralTypesSimpleSkript.jav"); + // filenames.add("StructuralTypesField.jav"); + // filenames.add("Main.jav"); + + JavaTXParser parser = new JavaTXParser(); + try { + for (String filename : filenames) { + + System.out.println("Teste: " + filename); + + SourceFile sf = parser.parse(new File(rootDirectory + filename)); + + SourceFile sfdebug = sf; + + + // Erstellen der Constrinats für die erste Klasse --------------------------------------- + ClassOrInterface aktClass = sf.getClasses().get(0); + AssTuple ass = AssumptionGenerator.generateAssumptions(aktClass); + + + List constraints = new ArrayList<>(); + for (Method m : aktClass.getMethods()) { + Return rt = (Return) m.get_Block().statements.get(0); + Expression ex = (Expression) rt.get_Expression(); + constraints.addAll(HelpMethoden.TypeExpr(ass, ex, m, aktClass)); + } + + constraints.forEach( (x) -> {System.out.println(x); }); + + + // Erstellen der Interfaces für die erste Klasse + List sf2 = new ArrayList<>(); + constraints.forEach( (constraint) -> {sf2.add( Construct.constructInterfaces(constraint)); } ); + + + + System.out.println(sf2.size()); + + + + + + + + + + + + + } + + } catch (Exception exc) { + exc.printStackTrace(); + fail(); + } + assertTrue("Tests durchlaufen", filenames.size() > 0); + } +} From eb365bb91177e4f8a2d8828b8169e995b5179d8a Mon Sep 17 00:00:00 2001 From: sebastian Date: Thu, 6 Apr 2017 11:20:06 +0200 Subject: [PATCH 7/7] =?UTF-8?q?letzte=20=C3=A4nderung?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../strucTypes3/AssumptionGenerator.java | 6 +-- .../strucTypes3/ToStringGenerator.java | 41 ++++++++++++++++++- .../syntaxtree/ClassOrInterface.java | 4 ++ test/strucTypes3/Construct.java | 16 +++++++- .../GeneralParserTestConstruct.java | 8 ++++ test/strucTypes3/StructuralTypesMiddle.jav | 27 ++++++++++++ 6 files changed, 97 insertions(+), 5 deletions(-) create mode 100644 test/strucTypes3/StructuralTypesMiddle.jav diff --git a/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java b/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java index b24bcfce..63dd80f8 100644 --- a/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java +++ b/src/de/dhbwstuttgart/strucTypes3/AssumptionGenerator.java @@ -56,10 +56,10 @@ public class AssumptionGenerator { argAss.put(m, ass); System.out.println(String.format("Methodenname: %s , Arguments: %s -> ReturnType %s ", methodName, typeArg, returnType)); - } + } - - //TODO : Assumption für die eingene aktuelle Klasse + // Assumption für die eingene aktuelle Klasse + fAss.put("this", cl.getType()); diff --git a/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java b/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java index e3ad677b..4c7703bf 100644 --- a/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java +++ b/src/de/dhbwstuttgart/strucTypes3/ToStringGenerator.java @@ -3,6 +3,10 @@ package de.dhbwstuttgart.strucTypes3; import java.util.List; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.FieldDeclaration; +import de.dhbwstuttgart.syntaxtree.FormalParameter; +import de.dhbwstuttgart.syntaxtree.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.Method; import de.dhbwstuttgart.syntaxtree.statement.Block; import de.dhbwstuttgart.syntaxtree.statement.Expression; @@ -12,7 +16,7 @@ import de.dhbwstuttgart.syntaxtree.statement.Statement; public class ToStringGenerator { - public String klasseToString(ClassOrInterface cl, AssTuple assAll) { + public static String klasseToString(ClassOrInterface cl, AssTuple assAll) { // Als nächstes muss die Expression getypt werden @@ -59,5 +63,40 @@ public class ToStringGenerator { } + public static String interface2String(ClassOrInterface face) { + + + + // Ausgabe name + String n = face.getClassName().toString(); + + // Ausgabe Generics + String generics = ""; + + //for ( GenericTypeVar f : face.getGenericDeclarationList()) { + //generics = generics + " " + f.toString(); + //} + + // Ausgabe der Felder + String felder = ""; + for (Field f : face.getFieldDecl()) { + felder = f.toString(); + } + + // Ausgabe der Methoden + String methods = ""; + for (Method m : face.getMethods()) { + String mName = m.getName() + " ( "; + //m.getParameterList().getFormalparalist().forEach((x) -> { mName.concat(x.getName().toString()); }); + for (FormalParameter fp : m.getParameterList().getFormalparalist()) { + mName = mName + " "+ fp.getName(); + } + methods = methods + mName + ") " ; + } + + return String.format(" interface: %s %s %s %s \n" , n, generics , felder, methods); + } + + } diff --git a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java index a69a55e3..66eb84cd 100755 --- a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java +++ b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java @@ -54,6 +54,10 @@ public class ClassOrInterface extends GTVDeclarationContext implements IItemWith return this.name; } + public GenericDeclarationList getGenericDeclarationList() { + return this.genericClassParameters; + } + // Get modifiers public int getModifiers(){ return this.modifiers; diff --git a/test/strucTypes3/Construct.java b/test/strucTypes3/Construct.java index 52997243..97074789 100644 --- a/test/strucTypes3/Construct.java +++ b/test/strucTypes3/Construct.java @@ -46,7 +46,21 @@ public class Construct { List fielddecl = new ArrayList<>(); fielddecl.add(field); JavaClassName name = new JavaClassName(fieldConstriant.getReveiver().toString()); - ClassOrInterface face = new ClassOrInterface(0, name, fielddecl, null, null, null, null, null , null); + + + //Erstellen der Generics + List genericTypeVarList = new ArrayList<>(); + String type_of_field = fieldConstriant.getAttribut().toString(); + genericTypeVarList.add(new GenericTypeVar(type_of_field, null, new NullToken(), new NullToken())); + GenericDeclarationList genericDeclaraitonList = new GenericDeclarationList(genericTypeVarList, new NullToken()); + + + // methods + List methods = new ArrayList(); + + + ClassOrInterface face = new ClassOrInterface(0, name, fielddecl, methods, genericDeclaraitonList, null, true, null , null); + return face; } diff --git a/test/strucTypes3/GeneralParserTestConstruct.java b/test/strucTypes3/GeneralParserTestConstruct.java index a8ab15ff..d1db8b59 100644 --- a/test/strucTypes3/GeneralParserTestConstruct.java +++ b/test/strucTypes3/GeneralParserTestConstruct.java @@ -13,6 +13,7 @@ import de.dhbwstuttgart.strucTypes3.AssTuple; import de.dhbwstuttgart.strucTypes3.AssumptionGenerator; import de.dhbwstuttgart.strucTypes3.ConstraintAbstract; import de.dhbwstuttgart.strucTypes3.HelpMethoden; +import de.dhbwstuttgart.strucTypes3.ToStringGenerator; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.Field; import de.dhbwstuttgart.syntaxtree.FormalParameter; @@ -57,6 +58,7 @@ public class GeneralParserTestConstruct { // filenames.add("FieldVarTest.jav"); filenames.add("StructuralTypesSimpleSkript.jav"); + //filenames.add("StructuralTypesMiddle.jav"); // filenames.add("StructuralTypesField.jav"); // filenames.add("Main.jav"); @@ -90,7 +92,13 @@ public class GeneralParserTestConstruct { List sf2 = new ArrayList<>(); constraints.forEach( (constraint) -> {sf2.add( Construct.constructInterfaces(constraint)); } ); + //sf2.forEach((x) -> {if (x != null ) { String y = ToStringGenerator.interface2String(x); System.out.println(y); }} ); + for (int i = 0; i < sf2.size() ; i++) { + if (sf2.get(i) != null ) { + System.out.println(ToStringGenerator.interface2String(sf2.get(i))); + } + } System.out.println(sf2.size()); diff --git a/test/strucTypes3/StructuralTypesMiddle.jav b/test/strucTypes3/StructuralTypesMiddle.jav new file mode 100644 index 00000000..4f832ff3 --- /dev/null +++ b/test/strucTypes3/StructuralTypesMiddle.jav @@ -0,0 +1,27 @@ + + + +class A { + + //Integer feld1; + + //feld2; + + + //mtNeu() { return new Integer(); } + + //mtcast(a) { return (Integer) a; } + + mfeld(r) { return r.feld; } + + + mt1(x,y,z) { return x.sub(y).add(z); } + + mt(g,h,i) { return g.div( h , i) ; } + + } + + +class Integer { +} + \ No newline at end of file