diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/EnhancedForStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/EnhancedForStatement.java index e1d1b42..a447d10 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/EnhancedForStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/EnhancedForStatement.java @@ -3,14 +3,14 @@ public class EnhancedForStatement extends Statement { private VariableDeclaration singleVariableDeclaration; - private Statement expression; + private Expression expression; private Statement body; public VariableDeclaration getParameter() { return singleVariableDeclaration; } public void setParameter(VariableDeclaration parameter) { this.singleVariableDeclaration = parameter; } - public Statement getExpression() { return expression; } - public void setExpression(Statement expression) { this.expression = expression; } + public Expression getExpression() { return expression; } + public void setExpression(Expression expression) { this.expression = expression; } public Statement getBody() { return body; } public void setBody(Statement body) { this.body = body; } diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/ExpressionStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/ExpressionStatement.java index 1d23a01..f8fdf96 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/ExpressionStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/ExpressionStatement.java @@ -1,10 +1,14 @@ package code.ast; public class ExpressionStatement extends Statement{ - private Statement expression; + private Expression expression; - public Statement getExpression() { return expression; } - public void setExpression(Statement expression) { this.expression = expression; } + public ExpressionStatement(Expression expression) { + this.expression = expression; + } + + public Expression getExpression() { return expression; } + public void setExpression(Expression expression) { this.expression = expression; } @Override public String toString() { diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/ForStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/ForStatement.java index bf736a5..479d6b5 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/ForStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/ForStatement.java @@ -6,7 +6,7 @@ public class ForStatement extends Statement { private List initializers = new ArrayList<>(); - private Statement condition; + private Expression optionalConditionExpression; private List updaters = new ArrayList<>(); private Statement body; @@ -18,12 +18,12 @@ this.initializers = initializers; } - public Statement getCondition() { - return condition; + public Expression getExpression() { + return optionalConditionExpression; } - public void setCondition(Statement condition) { - this.condition = condition; + public void setExpression(Expression expression) { + this.optionalConditionExpression = expression; } public List getUpdaters() { @@ -53,7 +53,7 @@ } sb.append("; "); - if (condition != null) sb.append(condition); + if (optionalConditionExpression != null) sb.append(optionalConditionExpression); sb.append("; "); for (int i = 0; i < updaters.size(); i++) { diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/IfStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/IfStatement.java index e7521f1..d688700 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/IfStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/IfStatement.java @@ -2,15 +2,15 @@ public class IfStatement extends Statement { - private Statement expression; + private Expression expression; private Statement thenStatement; private Statement elseStatement; - public Statement getExpression() { + public Expression getExpression() { return expression; } - public void setExpression(Statement expression) { + public void setExpression(Expression expression) { this.expression = expression; } diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/ReturnStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/ReturnStatement.java index 501cd26..400de02 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/ReturnStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/ReturnStatement.java @@ -1,13 +1,13 @@ package code.ast; public class ReturnStatement extends Statement{ - private Statement expression; + private Expression expression; - public Statement getExpression() { + public Expression getExpression() { return expression; } - public void setExpression(Statement expression) { + public void setExpression(Expression expression) { this.expression = expression; } diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclaration.java b/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclaration.java index 6a7b25b..5d86c98 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclaration.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclaration.java @@ -9,6 +9,7 @@ public class VariableDeclaration extends ASTNode implements IAnnotatable { private Type type; private String variableName; + private Expression optionalInitializer; private Map annotations = new HashMap<>(); public VariableDeclaration(Type type, String variableName) { @@ -16,6 +17,11 @@ this.variableName = variableName; } + public VariableDeclaration(Type type, String variableName, Expression initializer) { + this(type, variableName); + this.optionalInitializer = initializer; + } + public Type getType() { return type; } @@ -32,6 +38,10 @@ this.variableName = variableName; } + public Expression getInitializer() { return optionalInitializer; } + + public void setInitializer(Expression initializer) { this.optionalInitializer = initializer; } + @Override public Annotation getAnnotation(String name) { return annotations.get(name); diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclarationStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclarationStatement.java index 0348fce..c384ffa 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclarationStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/VariableDeclarationStatement.java @@ -5,15 +5,15 @@ public class VariableDeclarationStatement extends Statement { - private List modifiers = new ArrayList<>(); + private List modifiers = new ArrayList<>(); private Type type; private List fragments = new ArrayList<>(); - public List getModifiers() { + public List getModifiers() { return modifiers; } - public void setModifiers(List modifiers) { + public void setModifiers(List modifiers) { this.modifiers = modifiers; } @@ -37,7 +37,7 @@ public String toString() { StringBuilder sb = new StringBuilder(); - for (Statement mod : modifiers) { + for (Integer mod : modifiers) { sb.append(mod.toString()).append(" "); } diff --git a/AlgebraicDataflowArchitectureModel/src/code/ast/WhileStatement.java b/AlgebraicDataflowArchitectureModel/src/code/ast/WhileStatement.java index be37a35..6d22d84 100644 --- a/AlgebraicDataflowArchitectureModel/src/code/ast/WhileStatement.java +++ b/AlgebraicDataflowArchitectureModel/src/code/ast/WhileStatement.java @@ -2,14 +2,14 @@ public class WhileStatement extends Statement { - private Statement expression; + private Expression expression; private Statement body; - public Statement getExpression() { + public Expression getExpression() { return expression; } - public void setExpression(Statement expression) { + public void setExpression(Expression expression) { this.expression = expression; } diff --git a/AlgebraicDataflowArchitectureModel/src/generators/ILanguageSpecific.java b/AlgebraicDataflowArchitectureModel/src/generators/ILanguageSpecific.java index bce2707..2c89884 100644 --- a/AlgebraicDataflowArchitectureModel/src/generators/ILanguageSpecific.java +++ b/AlgebraicDataflowArchitectureModel/src/generators/ILanguageSpecific.java @@ -3,14 +3,11 @@ import java.util.ArrayList; import java.util.List; -import code.ast.CompilationUnit; -import code.ast.FieldDeclaration; -import code.ast.MethodDeclaration; -import code.ast.TypeDeclaration; -import code.ast.VariableDeclaration; +import code.ast.*; import models.algebra.Expression; import models.algebra.Term; import models.algebra.Type; +import models.algebra.Variable; import models.dataFlowModel.DataTransferChannel.IResourceStateAccessor; public interface ILanguageSpecific { @@ -24,7 +21,7 @@ Type newListType(String compTypeName); Type newMapType(Type keyType, String compTypeName); Type newTupleType(List compTypes); - String getVariableDeclaration(String typeName, String varName); + VariableDeclaration getVariableDeclaration(Type typeName, String varName); boolean declareField(); String getSelfExp(); String getFieldAccessor(String fieldName); @@ -33,11 +30,11 @@ String getMethodInvocation(String receiverName, String methodName); String getMethodInvocation(String receiverName, String methodName, List parameters); String getConstructorInvocation(String componentName, List parameters); - String getReturnStatement(String returnValue); - String getIfStatement(Term condition, String block); - String getForStatementForList(String varName, String list); - String getForStatementForCollection(String varName, String varType, String collection); - String getForStatementForMap(String varName, String varType, String map); + ReturnStatement getReturnStatement(String returnValue); + IfStatement getIfStatement(Term condition, Statement block); + ForStatement getForStatementForList(Variable varName, Expression list); + EnhancedForStatement getForStatementForCollection(String varName, String varType, String collection); + EnhancedForStatement getForStatementForMap(String varName, String varType, String map); String getEndForStatement(); String getEndForStatement(String varName); String toComponentName(String name); diff --git a/AlgebraicDataflowArchitectureModel/src/generators/JavaSpecific.java b/AlgebraicDataflowArchitectureModel/src/generators/JavaSpecific.java index e40f789..d0c42c7 100644 --- a/AlgebraicDataflowArchitectureModel/src/generators/JavaSpecific.java +++ b/AlgebraicDataflowArchitectureModel/src/generators/JavaSpecific.java @@ -1,19 +1,13 @@ package generators; -import java.util.ArrayList; +import java.util.Arrays; import java.util.List; -import code.ast.CompilationUnit; -import code.ast.FieldDeclaration; -import code.ast.ImportDeclaration; -import code.ast.MethodDeclaration; -import code.ast.TypeDeclaration; -import code.ast.VariableDeclaration; +import code.ast.*; +import code.ast.Variable; +import models.algebra.*; import models.algebra.Expression; -import models.algebra.Parameter; -import models.algebra.Term; import models.algebra.Type; -import models.algebra.Variable; import models.dataConstraintModel.DataConstraintModel; public class JavaSpecific implements ILanguageSpecific { @@ -96,8 +90,8 @@ } @Override - public String getVariableDeclaration(String typeName, String varName) { - return typeName + " " + varName; + public VariableDeclaration getVariableDeclaration(Type typeName, String varName) { + return new VariableDeclaration(typeName, varName); } @Override @@ -176,28 +170,60 @@ } @Override - public String getReturnStatement(String returnValue) { - return "return " + returnValue; + public ReturnStatement getReturnStatement(String returnValue) { + ReturnStatement returnStatement = new ReturnStatement(); + returnStatement.setExpression(new code.ast.Variable(returnValue) { + }); + return returnStatement; } @Override - public String getIfStatement(Term condition, String block) { - return "if (" + condition.toImplementation(new String[] {""})+ ") {\n" + "\t" + block.replace("\n", "\n\t") + "\n}"; + public IfStatement getIfStatement(Term condition, Statement block) { + IfStatement ifStatement = new IfStatement(); + String conditionSource = condition.toImplementation(new String[]{""}); + ifStatement.setExpression(new code.ast.Variable(conditionSource)); + ifStatement.setThenStatement(block); + return ifStatement; } @Override - public String getForStatementForList(String varName, String list) { - return "for (int " + varName + getAssignment() + "0; " + varName + " < " + list + ".size(); " + varName + "++) {"; + public ForStatement getForStatementForList(models.algebra.Variable varName, Expression list) { + ForStatement forStatement = new ForStatement(); + forStatement.getInitializers().add(new PlainStatement("int " + varName.getName() + " = 0")); + InfixExpression condition = new InfixExpression( + new Symbol("<", 2, Symbol.Type.INFIX), + new code.ast.Variable(varName.getName()), + new code.ast.Variable(list.toString() + ".size()") + ); + forStatement.setExpression(condition); + PostfixExpression increment = new PostfixExpression( + new code.ast.Variable(varName.getName()), + PostfixExpression.Operator.INCREMENT + ); + forStatement.setUpdaters(Arrays.asList(new ExpressionStatement(increment))); + return forStatement; } @Override - public String getForStatementForCollection(String varName, String varType, String collection) { - return "for (" + varType + " " + varName + ": " + collection + ") {"; + public EnhancedForStatement getForStatementForCollection(String varName, String varType, String collection) { + EnhancedForStatement enhancedForStatement = new EnhancedForStatement(); + + VariableDeclaration varDeclaration = new VariableDeclaration(new models.algebra.Type(varName,varType), varName); + enhancedForStatement.setParameter(varDeclaration); + enhancedForStatement.setExpression(new code.ast.Variable(collection)); + + return enhancedForStatement; } @Override - public String getForStatementForMap(String varName, String varType, String map) { - return "for (" + varType + " " + varName + ": " + map + ".keySet()) {"; + public EnhancedForStatement getForStatementForMap(String varName, String varType, String map) { + EnhancedForStatement enhancedForStatement = new EnhancedForStatement(); + + VariableDeclaration varDeclaration = new VariableDeclaration(new models.algebra.Type(varName,varType), varName); + enhancedForStatement.setParameter(varDeclaration); + enhancedForStatement.setExpression(new code.ast.Variable(map + ".keySet()")); + + return enhancedForStatement; } @Override @@ -294,9 +320,9 @@ @Override public String getTupleGet(String tupleExp, int idx, int length) { - Expression t = new Variable(tupleExp, DataConstraintModel.typeTuple); + models.algebra.Expression t = new models.algebra.Variable(tupleExp); for (int i = 0; i < idx; i++) { - Term next = new Term(DataConstraintModel.snd); + Term next = new Term(DataConstraintModel.snd); next.addChild(t); t = next; } @@ -305,17 +331,17 @@ last.addChild(t); t = last; } - return t.toImplementation(new String[]{}); + return t.toImplementation(new String[]{""}); } @Override public String getDecomposedTuple(String tupleExp, VariableDeclaration tupleVar, List vars) { String statements = ""; - statements += getVariableDeclaration(tupleVar.getType().getInterfaceTypeName(), tupleVar.getName()) + statements += getVariableDeclaration(tupleVar.getType(), tupleVar.getName()) + getAssignment() + tupleExp + getStatementDelimiter(); for (int i = 0; i < vars.size(); i++) { VariableDeclaration var = vars.get(i); - statements += "\n" + getVariableDeclaration(var.getType().getInterfaceTypeName(), var.getName()) + statements += "\n" + getVariableDeclaration(var.getType(), var.getName()) + getAssignment() + getTupleGet(tupleVar.getName(), i, vars.size()) + getStatementDelimiter(); diff --git a/AlgebraicDataflowArchitectureModel/src/tests/ASTTest.java b/AlgebraicDataflowArchitectureModel/src/tests/ASTTest.java index c29320f..57015ee 100644 --- a/AlgebraicDataflowArchitectureModel/src/tests/ASTTest.java +++ b/AlgebraicDataflowArchitectureModel/src/tests/ASTTest.java @@ -1,72 +1,172 @@ package tests; import code.ast.*; +import generators.JavaSpecific; +import models.algebra.Symbol; +import models.algebra.Term; import models.dataConstraintModel.DataConstraintModel; +import org.junit.Test; import java.util.Arrays; import java.util.List; public class ASTTest { - public static void main(String[] args) { + @Test + public void test() { - MethodDeclaration method = new MethodDeclaration("Test", false); + JavaSpecific javaGen = new JavaSpecific(); + MethodDeclaration methodDeclaration = javaGen.newMethodDeclaration("Test", JavaSpecific.typeVoid); Block methodBody = new Block(); - VariableDeclarationStatement varStmt = new VariableDeclarationStatement(); - varStmt.setModifiers(List.of(new PlainStatement("private"))); - varStmt.setType(new PrimitiveType(new SimpleName("int"))); - varStmt.setFragments(List.of( + VariableDeclarationStatement variableDeclarationStatement = new VariableDeclarationStatement(); + variableDeclarationStatement.setModifiers(List.of(Modifier.PRIVATE)); + variableDeclarationStatement.setFragments(List.of( new VariableDeclaration(DataConstraintModel.typeInt, "x"), new VariableDeclaration(DataConstraintModel.typeInt, "sum") )); - methodBody.addStatement(varStmt); + methodBody.addStatement(variableDeclarationStatement); - ForStatement forStmt = new ForStatement(); - forStmt.setInitializers(Arrays.asList(new PlainStatement("int j = 0"))); - forStmt.setCondition(new PlainStatement("j < 5")); - forStmt.setUpdaters(Arrays.asList(new PlainStatement("j++"))); + models.algebra.Variable j = new models.algebra.Variable("j"); + models.algebra.Constant limit = new models.algebra.Constant("5"); + ForStatement forStatement = javaGen.getForStatementForList(j, limit); Block forBody = new Block(); - forBody.addStatement("sum += j;"); - forStmt.setBody(forBody); - methodBody.addStatement(forStmt); + forBody.addStatement(new ExpressionStatement( + new InfixExpression(new Symbol("+=", 2, Symbol.Type.INFIX), new Variable("sum"), new Variable("j")) + )); + forStatement.setBody(forBody); + methodBody.addStatement(forStatement); - EnhancedForStatement enhancedFor = new EnhancedForStatement(); - enhancedFor.setParameter(new VariableDeclaration(DataConstraintModel.typeString, "s")); - enhancedFor.setExpression(new PlainStatement("list")); - Block eForBody = new Block(); - eForBody.addStatement("System.out.println(s);"); - enhancedFor.setBody(eForBody); - methodBody.addStatement(enhancedFor); + EnhancedForStatement efStmt = javaGen.getForStatementForCollection("s", "String", "list"); + Block efBody = new Block(); + efBody.addStatement("System.out.println(s);"); + efStmt.setBody(efBody); + methodBody.addStatement(efStmt); - WhileStatement whileStmt = new WhileStatement(); - whileStmt.setExpression(new PlainStatement("sum < 100")); + Term moduloTerm = new Term(new Symbol("%", 2, Symbol.Type.INFIX)); + moduloTerm.addChild(new models.algebra.Variable("sum")); + moduloTerm.addChild(new models.algebra.Constant("2")); + Term ifCondTerm = new Term(new Symbol("==", 2, Symbol.Type.INFIX)); + ifCondTerm.addChild(moduloTerm); + ifCondTerm.addChild(new models.algebra.Constant("0"));Block thenBlock = new Block(); + thenBlock.addStatement(new ExpressionStatement(new InfixExpression(new Symbol("+=", 2, Symbol.Type.INFIX), new Variable("sum"), new Constant("10")))); + + IfStatement ifStmt = javaGen.getIfStatement(ifCondTerm, thenBlock); + Block elseB = new Block(); + elseB.addStatement(new ExpressionStatement(new InfixExpression(new Symbol("+=", 2, Symbol.Type.INFIX), new Variable("sum"), new Constant("5")))); + ifStmt.setElseStatement(elseB); Block whileBody = new Block(); - IfStatement ifStmt = new IfStatement(); - ifStmt.setExpression(new PlainStatement("sum % 2 == 0")); - - Block thenBlock = new Block(); - ExpressionStatement exprStmt = new ExpressionStatement(); - exprStmt.setExpression(new PlainStatement("sum += 10")); - thenBlock.addStatement(exprStmt); - - Block elseBlock = new Block(); - elseBlock.addStatement("sum += 5;"); - - ifStmt.setThenStatement(thenBlock); - ifStmt.setElseStatement(elseBlock); - whileBody.addStatement(ifStmt); + WhileStatement whileStmt = new WhileStatement(); + whileStmt.setExpression(new InfixExpression(new Symbol("<", 2, Symbol.Type.INFIX), new Variable("sum"), new Constant("100"))); whileStmt.setBody(whileBody); methodBody.addStatement(whileStmt); - ReturnStatement returnStmt = new ReturnStatement(); - returnStmt.setExpression(new PlainStatement("sum")); - methodBody.addStatement(returnStmt); + methodBody.addStatement(javaGen.getReturnStatement("sum")); - method.setBody(methodBody); + methodDeclaration.setBody(methodBody); + System.out.println("--- Generated Code"); + System.out.println(methodDeclaration.toString()); - System.out.println("--- Generated Code ---"); - System.out.println(method.toString()); +// +// MethodDeclaration methodDeclaration = new MethodDeclaration("Test", false); +// Block methodBody = new Block(); +// +// VariableDeclarationStatement variableDeclarationStatement = new VariableDeclarationStatement(); +// variableDeclarationStatement.setModifiers(List.of(new PlainStatement("private"))); +// +// variableDeclarationStatement.setFragments(List.of( +// new VariableDeclaration(new SimpleType("int"), "x"), +// new VariableDeclaration(new SimpleType("int"), "sum") +// )); +// methodBody.addStatement(variableDeclarationStatement); +// +// ForStatement forStatement = new ForStatement(); +// +// forStatement.setInitializers(Arrays.asList(new PlainStatement("int j = 0"))); +// +// InfixExpression condition = new InfixExpression( +// new Symbol("<", 2, Symbol.Type.INFIX), +// new Variable("j"), +// new Constant("5") +// ); +// forStatement.setExpression(condition); +// +// PostfixExpression increment = new PostfixExpression( +// new Variable("j"), +// PostfixExpression.Operator.INCREMENT +// ); +// forStatement.setUpdaters(Arrays.asList(new ExpressionStatement(increment))); +// +// Block forBody = new Block(); +// InfixExpression forAddition = new InfixExpression( +// new Symbol("+=", 2, Symbol.Type.INFIX), +// new Variable("sum"), +// new Variable("j") +// ); +// forBody.addStatement(new ExpressionStatement(forAddition)); +// forStatement.setBody(forBody); +// methodBody.addStatement(forStatement); +// +// EnhancedForStatement enhancedForStatement = new EnhancedForStatement(); +// enhancedForStatement.setParameter(new SimpleType("String"), "s"); +// enhancedForStatement.setExpression(new Variable("list")); +// +// Block enhancedForBody = new Block(); +// enhancedForBody.addStatement("System.out.println(s);"); +// enhancedForStatement.setBody(enhancedForBody); +// methodBody.addStatement(enhancedForStatement); +// +// WhileStatement whileStatement = new WhileStatement(); +// InfixExpression whileCondition = new InfixExpression( +// new Symbol("<", 2, Symbol.Type.INFIX), +// new Variable("sum"), +// new Constant("100") +// ); +// whileStatement.setExpression(whileCondition); +// +// Block whileBody = new Block(); +// IfStatement ifStatement = new IfStatement(); +// +// InfixExpression moduloExpression = new InfixExpression( +// new Symbol("%", 2, Symbol.Type.INFIX), +// new Variable("sum"), +// new Constant("2") +// ); +// InfixExpression ifCondition = new InfixExpression( +// new Symbol("==", 2, Symbol.Type.INFIX), +// moduloExpression, +// new Constant("0") +// ); +// ifStatement.setExpression(ifCondition); +// +// Block thenBlock = new Block(); +// thenBlock.addStatement(new ExpressionStatement(new InfixExpression( +// new Symbol("+=", 2, Symbol.Type.INFIX), +// new Variable("sum"), +// new Constant("10") +// ))); +// +// Block elseBlock = new Block(); +// elseBlock.addStatement(new ExpressionStatement(new InfixExpression( +// new Symbol("+=", 2, Symbol.Type.INFIX), +// new Variable("sum"), +// new Constant("5") +// ))); +// +// ifStatement.setThenStatement(thenBlock); +// ifStatement.setElseStatement(elseBlock); +// whileBody.addStatement(ifStatement); +// whileStatement.setBody(whileBody); +// methodBody.addStatement(whileStatement); +// +// ReturnStatement returnStatement = new ReturnStatement(); +// returnStatement.setExpression(new Variable("sum")); +// methodBody.addStatement(returnStatement); +// +// methodDeclaration.setBody(methodBody); +// +// System.out.println("--- Generated Code ---"); +// System.out.println(methodDeclaration.toString()); } } \ No newline at end of file