From c8dd52ac1bb9a60a7dc748f1044ddc757e8c87a4 Mon Sep 17 00:00:00 2001 From: Christoph Richter Date: Mon, 2 Jul 2018 14:42:05 +0200 Subject: [PATCH 1/2] StringIndexHelper: Added function to modify multiple bracket entries StringIndexHelper: Extended replace function for all bracket entries --- pom.xml | 2 +- .../cpp/converter/StringIndexHelper.java | 33 +++++++++++++++---- 2 files changed, 28 insertions(+), 7 deletions(-) diff --git a/pom.xml b/pom.xml index 91bc6806..bd3ed0d3 100644 --- a/pom.xml +++ b/pom.xml @@ -8,7 +8,7 @@ de.monticore.lang.monticar embedded-montiarc-math-generator - 0.0.16-SNAPSHOT + 0.0.17-SNAPSHOT diff --git a/src/main/java/de/monticore/lang/monticar/generator/cpp/converter/StringIndexHelper.java b/src/main/java/de/monticore/lang/monticar/generator/cpp/converter/StringIndexHelper.java index 677638b8..0f96d07a 100644 --- a/src/main/java/de/monticore/lang/monticar/generator/cpp/converter/StringIndexHelper.java +++ b/src/main/java/de/monticore/lang/monticar/generator/cpp/converter/StringIndexHelper.java @@ -2,28 +2,36 @@ package de.monticore.lang.monticar.generator.cpp.converter; /** * @author Sascha Schneiders + * @author Christoph Richter */ public class StringIndexHelper { public static String modifyContentBetweenBracketsByAdding(String input, String modifier) { + return modifyContentBetweenBracketsByAdding(input, modifier, "(", ",", ")"); + } + + /** + * Only adds modifier in the first occurring bracket + */ + public static String modifyContentBetweenBracketsByAdding(String input, String modifier, String bracketStart, String bracketSep, String bracketEnd) { String result = ""; boolean done = false; - int indexFirst = input.indexOf("(", 0); + int indexFirst = input.indexOf(bracketStart, 0); if (indexFirst == -1) return input; result += input.substring(0, indexFirst); - int indexSecond = input.indexOf(",", indexFirst + 1); + int indexSecond = input.indexOf(bracketSep, indexFirst + bracketSep.length()); if (indexSecond == -1) { - indexSecond = input.indexOf(")", indexFirst + 1); + indexSecond = input.indexOf(bracketEnd, indexFirst + bracketEnd.length()); done = true; } while (!done) { result += input.substring(indexFirst, indexSecond) + modifier; indexFirst = indexSecond; - indexSecond = input.indexOf(",", indexSecond + 1); + indexSecond = input.indexOf(bracketSep, indexSecond + bracketSep.length()); if (indexSecond == -1) { - indexSecond = input.indexOf(")", indexFirst + 1); + indexSecond = input.indexOf(bracketEnd, indexFirst + bracketEnd.length()); done = true; } } @@ -37,9 +45,22 @@ public class StringIndexHelper { if (input.endsWith(endPart)) { int indexFirst = input.lastIndexOf(endPart); result = input.substring(0, indexFirst); - result+=newEndPart; + result += newEndPart; } return result; } + public static String modifyContentBetweenBracketsByAddingForAllBrackets(String input, String modifier, String bracketStart, String bracketSep, String bracketEnd) { + String[] parts = input.split("(?<=\\))"); + StringBuilder sb = new StringBuilder(); + for (String s : parts) { + sb.append(modifyContentBetweenBracketsByAdding(s, modifier, bracketStart, bracketSep, bracketEnd)); + } + return sb.toString(); + } + + public static String modifyContentBetweenBracketsByAddingForAllBrackets(String input, String modifier) { + return modifyContentBetweenBracketsByAddingForAllBrackets(input, modifier, "(", ",", ")"); + } + } -- GitLab From 560cebbdeb71a6c539183a4796906658b17ab2d9 Mon Sep 17 00:00:00 2001 From: Christoph Richter Date: Tue, 3 Jul 2018 14:42:39 +0200 Subject: [PATCH 2/2] MathInformationRegister: Functions to replace variables by their definition --- .../optimization/MathInformationRegister.java | 78 ++++++++++++++++++- 1 file changed, 74 insertions(+), 4 deletions(-) diff --git a/src/main/java/de/monticore/lang/monticar/generator/optimization/MathInformationRegister.java b/src/main/java/de/monticore/lang/monticar/generator/optimization/MathInformationRegister.java index c8693c0c..e762f49f 100644 --- a/src/main/java/de/monticore/lang/monticar/generator/optimization/MathInformationRegister.java +++ b/src/main/java/de/monticore/lang/monticar/generator/optimization/MathInformationRegister.java @@ -1,10 +1,8 @@ package de.monticore.lang.monticar.generator.optimization; -import de.monticore.lang.math._symboltable.expression.MathExpressionSymbol; -import de.monticore.lang.math._symboltable.expression.MathNumberExpressionSymbol; -import de.monticore.lang.math._symboltable.expression.MathValueExpressionSymbol; -import de.monticore.lang.math._symboltable.expression.MathValueSymbol; +import de.monticore.lang.math._symboltable.expression.*; import de.monticore.lang.math._symboltable.matrix.MathMatrixAccessOperatorSymbol; +import de.monticore.lang.math._symboltable.matrix.MathMatrixNameExpressionSymbol; import de.monticore.lang.monticar.generator.BluePrint; import de.monticore.lang.monticar.generator.Variable; import de.monticore.lang.monticar.generator.cpp.BluePrintCPP; @@ -19,6 +17,7 @@ import java.util.Optional; * This class stores information of already encountered math information * * @author Sascha Schneiders + * @author Christoph Richter */ public class MathInformationRegister { protected List variables = new ArrayList<>();//contains in implementation Math section declared Variables @@ -164,6 +163,7 @@ public class MathInformationRegister { var.addDimensionalInformation(dimension.getTextualRepresentation()); this.variables.add(var); var.addProperties(mathValueSymbol.getType().getProperties()); + this.mathValueSymbols.add(mathValueSymbol); } public Variable getVariable(String name) { @@ -200,4 +200,74 @@ public class MathInformationRegister { } return result; } + + /** + * Searches MathValueSymbol in list and returns first matching symbol which contains the type declaration information + * + * @param symbol Symbol for which type information should be collected + * @return returns the first type declaration as symbol + */ + public MathValueSymbol getFullTypeInformation(MathValueSymbol symbol) { + MathValueSymbol result = getMathValueSymbol(symbol.getName()); + if (result == null) + result = symbol; + return result; + } + + /** + * Variables are replaced by their definition. + * + * @param nonAtomarExpression Expression in which the variables will be substituted + * @param atomarValueName Defines the name of the atomar variable after which no more substitution will be made + * @return MathExpressionSymbol containing the replaces variables + */ + public MathExpressionSymbol resolveMathExpressionToAtomarExpression(MathExpressionSymbol nonAtomarExpression, String atomarValueName) { + MathExpressionSymbol result; + if (nonAtomarExpression.isArithmeticExpression()) { + // recursively substitute expressions + MathArithmeticExpressionSymbol arithmeticSubstituted = (MathArithmeticExpressionSymbol) nonAtomarExpression; + MathArithmeticExpressionSymbol arithmeticResult = new MathArithmeticExpressionSymbol(); + arithmeticResult.setMathOperator(arithmeticSubstituted.getOperator()); + arithmeticResult.setLeftExpression(resolveMathExpressionToAtomarExpression(arithmeticSubstituted.getLeftExpression(), atomarValueName)); + arithmeticResult.setRightExpression(resolveMathExpressionToAtomarExpression(arithmeticSubstituted.getRightExpression(), atomarValueName)); + result = arithmeticResult; + } else if (nonAtomarExpression instanceof MathValueSymbol) { + // substitute value expr by assigned expr + MathValueSymbol valueExpr = (MathValueSymbol) nonAtomarExpression; + result = getSubstituteByName(valueExpr.getName(), nonAtomarExpression, atomarValueName); + } else if (nonAtomarExpression instanceof MathMatrixNameExpressionSymbol) { + MathMatrixNameExpressionSymbol sourceExpr = (MathMatrixNameExpressionSymbol) nonAtomarExpression; + MathMatrixNameExpressionSymbol targetExpr; + // modifiy access name + String accessName = getSubstituteByName(sourceExpr.getNameToAccess(), nonAtomarExpression, atomarValueName).getTextualRepresentation(); + if (sourceExpr.isMathMatrixAccessOperatorSymbolPresent() && !(accessName.contains("("))) { + targetExpr = new MathMatrixNameExpressionSymbol(String.format("(%s)", accessName)); + // modify access operator + MathMatrixAccessOperatorSymbol sourceAccessOperator = sourceExpr.getMathMatrixAccessOperatorSymbol(); + MathMatrixAccessOperatorSymbol targetAccessOperator = new MathMatrixAccessOperatorSymbol(); + targetAccessOperator.setMathMatrixAccessSymbols(sourceAccessOperator.getMathMatrixAccessSymbols()); + targetAccessOperator.setAccessStartSymbol(".at("); + targetExpr.setMathMatrixAccessOperatorSymbol(targetAccessOperator); + result = targetExpr; + } else { + result = nonAtomarExpression; + } + } else if (nonAtomarExpression instanceof IMathNamedExpression) { + // substitute value expr by assigned expr + result = getSubstituteByName(((IMathNamedExpression) nonAtomarExpression).getNameToAccess(), nonAtomarExpression, atomarValueName); + } else { + result = nonAtomarExpression; + } + return result; + } + + private MathExpressionSymbol getSubstituteByName(String name, MathExpressionSymbol expr, String atomarValueName) { + MathExpressionSymbol result; + MathValueSymbol declaration = getMathValueSymbol(name); + if ((declaration != null) && (declaration.getValue() != null) && (!name.contentEquals(atomarValueName))) + result = declaration.getValue(); + else + result = expr; + return result; + } } -- GitLab