You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2021/09/28 10:09:12 UTC
[plc4x] 01/04: refactor(codegen): cleanup *TemplateHelperCode
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit effb1c18ba4840733fce16ad3976679ef2d2dc51
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue Sep 28 11:30:05 2021 +0200
refactor(codegen): cleanup *TemplateHelperCode
---
.../plc4x/language/c/CLanguageTemplateHelper.java | 941 +++++++++++----------
.../language/go/GoLanguageTemplateHelper.java | 741 ++++++++--------
.../language/java/JavaLanguageTemplateHelper.java | 776 +++++++++--------
3 files changed, 1288 insertions(+), 1170 deletions(-)
diff --git a/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java b/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
index 01488e0..ae47e56 100644
--- a/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
+++ b/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
@@ -21,6 +21,7 @@ package org.apache.plc4x.language.c;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.BaseFreemarkerLanguageTemplateHelper;
import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerException;
+import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer;
import org.apache.plc4x.plugins.codegenerator.types.definitions.*;
import org.apache.plc4x.plugins.codegenerator.types.fields.*;
import org.apache.plc4x.plugins.codegenerator.types.references.*;
@@ -151,27 +152,28 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
*/
public boolean requiresPointerAccess(ComplexTypeDefinition typeDefinition, String propertyName) {
final Optional<NamedField> namedFieldOptional = typeDefinition.getFields().stream()
- .filter(field -> field instanceof NamedField)
- .map(field -> (NamedField) field)
+ .filter(NamedField.class::isInstance)
+ .map(NamedField.class::cast)
.filter(namedField -> namedField.getName().equals(propertyName))
.findFirst();
// If the property name refers to a field, check if it's an optional field.
// If it is, pointer access is required, if not, it's not.
if (namedFieldOptional.isPresent()) {
- final NamedField namedField = namedFieldOptional.get();
- if (namedField instanceof TypedField) {
- TypedField typedField = (TypedField) namedField;
- return !(typedField.isEnumField()) && typedField.getType().isComplexTypeReference();
- }
- return false;
+ return namedFieldOptional
+ .filter(TypedField.class::isInstance)
+ .map(TypedField.class::cast)
+ .map(typedField -> !(typedField.isEnumField()) && typedField.getType().isComplexTypeReference())
+ .orElse(false);
}
- final Optional<Argument> parserArgument = typeDefinition.getParserArguments()
+ return typeDefinition.getParserArguments()
.orElse(Collections.emptyList())
.stream()
- .filter(argument -> argument.getName().equals(propertyName)).findFirst();
- // If the property name refers to a parser argument, as soon as it's a complex type,
- // pointer access is required.
- return parserArgument.filter(argument -> argument.getType() instanceof ComplexTypeReference).isPresent();
+ .filter(argument -> argument.getName().equals(propertyName)).findFirst()
+ // If the property name refers to a parser argument, as soon as it's a complex type,
+ // pointer access is required.
+ .map(Argument::getType)
+ .filter(ComplexTypeReference.class::isInstance)
+ .isPresent();
// In all other cases, the property might be a built-in constant, so we don't need pointer
// access for any of these.
}
@@ -254,17 +256,19 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
}
public String getLoopExpressionSuffix(TypedField field) {
- if (field instanceof ArrayField) {
- ArrayField arrayField = (ArrayField) field;
- if (arrayField.getLoopType() == ArrayField.LoopType.COUNT) {
- Term countTerm = arrayField.getLoopExpression();
- if (countTerm != null && countTerm.isFixedValueExpression()) {
- int evaluatedCount = evaluateFixedValueExpression(countTerm);
- return "[" + evaluatedCount + "]";
- }
- }
+ if (!(field instanceof ArrayField)) {
+ return "";
}
- return "";
+ ArrayField arrayField = (ArrayField) field;
+ if (arrayField.getLoopType() != ArrayField.LoopType.COUNT) {
+ return "";
+ }
+ Term countTerm = arrayField.getLoopExpression();
+ if (countTerm == null || !countTerm.isFixedValueExpression()) {
+ return "";
+ }
+ int evaluatedCount = evaluateFixedValueExpression(countTerm);
+ return "[" + evaluatedCount + "]";
}
/**
@@ -275,34 +279,35 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
*/
public String getTypeSizeForField(TypedField field) {
TypeReference typeReference = field.getType();
- if (typeReference instanceof SimpleTypeReference) {
- SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
- switch (simpleTypeReference.getBaseType()) {
- case BIT:
- return " : 1";
- case BYTE:
- return " : 8";
- case UINT:
- case INT:
- // If the bit-size is exactly one of the built-in type-sizes, omit the suffix.
- if ((simpleTypeReference.getSizeInBits() == 8) || (simpleTypeReference.getSizeInBits() == 16) ||
- (simpleTypeReference.getSizeInBits() == 32) || (simpleTypeReference.getSizeInBits() == 64)) {
- return "";
- }
- return " : " + simpleTypeReference.getSizeInBits();
- case FLOAT:
- case UFLOAT:
- // If the bit-size is exactly one of the built-in type-sizes, omit the suffix.
- if ((simpleTypeReference.getSizeInBits() == 32) || (simpleTypeReference.getSizeInBits() == 64)) {
- return "";
- }
- return " : " + simpleTypeReference.getSizeInBits();
- case STRING:
- case TIME:
- case DATE:
- case DATETIME:
+ if (!(typeReference instanceof SimpleTypeReference)) {
+ return "";
+ }
+ SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
+ switch (simpleTypeReference.getBaseType()) {
+ case BIT:
+ return " : 1";
+ case BYTE:
+ return " : 8";
+ case UINT:
+ case INT:
+ // If the bit-size is exactly one of the built-in type-sizes, omit the suffix.
+ if ((simpleTypeReference.getSizeInBits() == 8) || (simpleTypeReference.getSizeInBits() == 16) ||
+ (simpleTypeReference.getSizeInBits() == 32) || (simpleTypeReference.getSizeInBits() == 64)) {
return "";
- }
+ }
+ return " : " + simpleTypeReference.getSizeInBits();
+ case FLOAT:
+ case UFLOAT:
+ // If the bit-size is exactly one of the built-in type-sizes, omit the suffix.
+ if ((simpleTypeReference.getSizeInBits() == 32) || (simpleTypeReference.getSizeInBits() == 64)) {
+ return "";
+ }
+ return " : " + simpleTypeReference.getSizeInBits();
+ case STRING:
+ case TIME:
+ case DATE:
+ case DATETIME:
+ return "";
}
return "";
}
@@ -471,7 +476,6 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
case BIT:
return "false";
case BYTE:
- return "0";
case UINT:
case INT:
return "0";
@@ -505,208 +509,149 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
}
public String toParseExpression(TypeDefinition baseType, Field field, Term term, List<Argument> parserArguments) {
- return toExpression(baseType, field, term, term1 -> toVariableParseExpression(baseType, field, term1, parserArguments));
+ return toExpression(baseType, field, term, variableLiteral -> toVariableParseExpression(baseType, field, variableLiteral, parserArguments));
}
public String toSerializationExpression(TypeDefinition baseType, Field field, Term term, List<Argument> parserArguments) {
- return toExpression(baseType, field, term, term1 -> toVariableSerializationExpression(baseType, field, term1, parserArguments));
+ return toExpression(baseType, field, term, variableLiteral -> toVariableSerializationExpression(baseType, field, variableLiteral, parserArguments));
}
- private String toExpression(TypeDefinition baseType, Field field, Term term, Function<Term, String> variableExpressionGenerator) {
+ private String toExpression(TypeDefinition baseType, Field field, Term term, Function<VariableLiteral, String> variableExpressionGenerator) {
+ Tracer tracer = Tracer.start("toExpression");
if (term == null) {
- return "";
+ return tracer + "";
}
if (term instanceof Literal) {
- if (term instanceof NullLiteral) {
- return "NULL";
- } else if (term instanceof BooleanLiteral) {
- return Boolean.toString(((BooleanLiteral) term).getValue());
- } else if (term instanceof NumericLiteral) {
- return ((NumericLiteral) term).getNumber().toString();
- } else if (term instanceof StringLiteral) {
- return "\"" + ((StringLiteral) term).getValue() + "\"";
- } else if (term instanceof VariableLiteral) {
- VariableLiteral variableLiteral = (VariableLiteral) term;
- if (variableLiteral.contains("lengthInBytes")) {
- TypeDefinition lengthType;
- String lengthExpression;
- if (variableLiteral.getName().equals("lengthInBytes")) {
- lengthType = (baseType.getParentType() == null) ? baseType : (ComplexTypeDefinition) baseType.getParentType();
- lengthExpression = "_message";
- } else {
- final Optional<TypeReference> typeReferenceForProperty = getTypeReferenceForProperty((ComplexTypeDefinition) baseType, variableLiteral.getName());
- if (!typeReferenceForProperty.isPresent()) {
- throw new FreemarkerException("Unknown type for property " + variableLiteral.getName());
- }
- lengthType = getTypeDefinitionForTypeReference(typeReferenceForProperty.get());
- lengthExpression = variableExpressionGenerator.apply(term);
- }
- return getCTypeName(lengthType.getName()) + "_length_in_bytes(" + lengthExpression + ")";
- } else if (variableLiteral.getName().equals("lastItem")) {
- return "lastItem";
- // If this literal references an Enum type, then we have to output it differently.
- } else if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
- return getCTypeName(variableLiteral.getName()) + "_" + variableLiteral.getChild().map(VariableLiteral::getName).orElseThrow(() -> new FreemarkerException("child required"));
- } else {
- return variableExpressionGenerator.apply(term);
- }
- } else {
- throw new FreemarkerException("Unsupported Literal type " + term.getClass().getName());
- }
+ return toLiteralExpression(baseType, term, variableExpressionGenerator, tracer);
} else if (term instanceof UnaryTerm) {
- UnaryTerm ut = (UnaryTerm) term;
- Term a = ut.getA();
- switch (ut.getOperation()) {
- case "!":
- return "!(" + toExpression(baseType, field, a, variableExpressionGenerator) + ")";
- case "-":
- return "-(" + toExpression(baseType, field, a, variableExpressionGenerator) + ")";
- case "()":
- return "(" + toExpression(baseType, field, a, variableExpressionGenerator) + ")";
- default:
- throw new FreemarkerException("Unsupported unary operation type " + ut.getOperation());
- }
+ return toUnaryTermExpression(baseType, field, (UnaryTerm) term, variableExpressionGenerator, tracer);
} else if (term instanceof BinaryTerm) {
- BinaryTerm bt = (BinaryTerm) term;
- Term a = bt.getA();
- Term b = bt.getB();
- String operation = bt.getOperation();
- if ("^".equals(operation)) {
- return "Math.pow((" + toExpression(baseType, field, a, variableExpressionGenerator) + "), (" + toExpression(baseType, field, b, variableExpressionGenerator) + "))";
- }
- return "(" + toExpression(baseType, field, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(baseType, field, b, variableExpressionGenerator) + ")";
+ return toBinaryTermExpression(baseType, field, (BinaryTerm) term, variableExpressionGenerator, tracer);
} else if (term instanceof TernaryTerm) {
- TernaryTerm tt = (TernaryTerm) term;
- if ("if".equals(tt.getOperation())) {
- Term a = tt.getA();
- Term b = tt.getB();
- Term c = tt.getC();
- return "((" + toExpression(baseType, field, a, variableExpressionGenerator) + ") ? " + toExpression(baseType, field, b, variableExpressionGenerator) + " : " + toExpression(baseType, field, c, variableExpressionGenerator) + ")";
- } else {
- throw new FreemarkerException("Unsupported ternary operation type " + tt.getOperation());
- }
+ return toTernaryTermExpression(baseType, field, (TernaryTerm) term, variableExpressionGenerator, tracer);
} else {
throw new FreemarkerException("Unsupported Term type " + term.getClass().getName());
}
}
- public String toVariableParseExpression(TypeDefinition baseType, Field field, Term term, List<Argument> parserArguments) {
- VariableLiteral vl = (VariableLiteral) term;
- if ("CAST".equals(vl.getName())) {
+ private String toUnaryTermExpression(TypeDefinition baseType, Field field, UnaryTerm unaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("unary term instanceOf");
+ Term a = unaryTerm.getA();
+ switch (unaryTerm.getOperation()) {
+ case "!":
+ tracer = tracer.dive("case !");
+ return tracer + "!(" + toExpression(baseType, field, a, variableExpressionGenerator) + ")";
+ case "-":
+ tracer = tracer.dive("case -");
+ return tracer + "-(" + toExpression(baseType, field, a, variableExpressionGenerator) + ")";
+ case "()":
+ tracer = tracer.dive("case ()");
+ return tracer + "(" + toExpression(baseType, field, a, variableExpressionGenerator) + ")";
+ default:
+ throw new FreemarkerException("Unsupported unary operation type " + unaryTerm.getOperation());
+ }
+ }
- if ((!vl.getArgs().isPresent()) || (vl.getArgs().get().size() != 2)) {
- throw new FreemarkerException("A CAST expression expects exactly two arguments.");
- }
- List<Term> args = vl.getArgs().get();
- final VariableLiteral sourceTerm = (VariableLiteral) args.get(0);
- final VariableLiteral typeTerm = (VariableLiteral) vl.getArgs().get().get(1);
- final TypeDefinition castType = getTypeDefinitions().get(typeTerm.getName());
- // If we're casting to a sub-type of a discriminated value, we got to cast to the parent
- // type instead and add the name of the sub-type as prefix to the property we're trying to
- // access next.
- StringBuilder sb = new StringBuilder();
- sb.append("((");
- if (castType.getParentType() != null) {
- sb.append(getCTypeName(castType.getParentType().getName()));
+ private String toBinaryTermExpression(TypeDefinition baseType, Field field, BinaryTerm binaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("binary term instanceOf");
+ Term a = binaryTerm.getA();
+ Term b = binaryTerm.getB();
+ String operation = binaryTerm.getOperation();
+ if ("^".equals(operation)) {
+ tracer = tracer.dive("^");
+ return tracer + "Math.pow((" + toExpression(baseType, field, a, variableExpressionGenerator) + "), (" + toExpression(baseType, field, b, variableExpressionGenerator) + "))";
+ }
+ return tracer + "(" + toExpression(baseType, field, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(baseType, field, b, variableExpressionGenerator) + ")";
+ }
+
+ private String toTernaryTermExpression(TypeDefinition baseType, Field field, TernaryTerm ternaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("ternary term instanceOf");
+ if ("if".equals(ternaryTerm.getOperation())) {
+ Term a = ternaryTerm.getA();
+ Term b = ternaryTerm.getB();
+ Term c = ternaryTerm.getC();
+ return tracer + "((" + toExpression(baseType, field, a, variableExpressionGenerator) + ") ? " + toExpression(baseType, field, b, variableExpressionGenerator) + " : " + toExpression(baseType, field, c, variableExpressionGenerator) + ")";
+ } else {
+ throw new FreemarkerException("Unsupported ternary operation type " + ternaryTerm.getOperation());
+ }
+ }
+
+ private String toLiteralExpression(TypeDefinition baseType, Term term, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("literal term instanceOf");
+ if (term instanceof NullLiteral) {
+ tracer = tracer.dive("null literal instanceOf");
+ return tracer + "NULL";
+ } else if (term instanceof BooleanLiteral) {
+ tracer = tracer.dive("boolean literal instanceOf");
+ return tracer + Boolean.toString(((BooleanLiteral) term).getValue());
+ } else if (term instanceof NumericLiteral) {
+ tracer = tracer.dive("numeric literal instanceOf");
+ return tracer + ((NumericLiteral) term).getNumber().toString();
+ } else if (term instanceof StringLiteral) {
+ tracer = tracer.dive("string literal instanceOf");
+ return tracer + toStringLiteralExpression((StringLiteral) term);
+ } else if (term instanceof VariableLiteral) {
+ tracer = tracer.dive("variable literal instanceOf");
+ return tracer + toVariableLiteralExpression(baseType, (VariableLiteral) term, variableExpressionGenerator, tracer);
+ } else {
+ throw new FreemarkerException("Unsupported Literal type " + term.getClass().getName());
+ }
+ }
+
+ private String toStringLiteralExpression(StringLiteral term) {
+ return "\"" + term.getValue() + "\"";
+ }
+
+ private String toVariableLiteralExpression(TypeDefinition baseType, VariableLiteral variableLiteral, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("toVariableLiteralExpression");
+ if (variableLiteral.contains("lengthInBytes")) {
+ tracer = tracer.dive("lengthInBytesContained");
+ TypeDefinition lengthType;
+ String lengthExpression;
+ if (variableLiteral.getName().equals("lengthInBytes")) {
+ tracer = tracer.dive("lengthInBytes contained in variable name");
+ lengthType = (baseType.getParentType() == null) ? baseType : (ComplexTypeDefinition) baseType.getParentType();
+ lengthExpression = "_message";
} else {
- sb.append(getCTypeName(castType.getName()));
- }
- sb.append("*) (");
- sb.append(toVariableParseExpression(baseType, field, sourceTerm, parserArguments)).append("))");
- if (vl.getChild().isPresent()) {
- if (castType.getParentType() != null) {
- // Change the name of the property to contain the sub-type-prefix.
- sb.append("->").append(camelCaseToSnakeCase(castType.getName())).append("_");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
- } else {
- sb.append("->");
- appendVariableExpressionRest(sb, castType, vl.getChild().get());
+ final Optional<TypeReference> typeReferenceForProperty = getTypeReferenceForProperty((ComplexTypeDefinition) baseType, variableLiteral.getName());
+ if (!typeReferenceForProperty.isPresent()) {
+ throw new FreemarkerException("Unknown type for property " + variableLiteral.getName());
}
+ lengthType = getTypeDefinitionForTypeReference(typeReferenceForProperty.get());
+ lengthExpression = variableExpressionGenerator.apply(variableLiteral);
}
- return sb.toString();
+ return tracer + getCTypeName(lengthType.getName()) + "_length_in_bytes(" + lengthExpression + ")";
+ } else if (variableLiteral.getName().equals("lastItem")) {
+ tracer = tracer.dive("lastitem");
+ return tracer + "lastItem";
+ // If this literal references an Enum type, then we have to output it differently.
+ } else if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
+ tracer = tracer.dive("enum type definition");
+ return tracer + getCTypeName(variableLiteral.getName()) + "_" + variableLiteral.getChild().map(VariableLiteral::getName).orElseThrow(() -> new FreemarkerException("child required"));
+ } else {
+ return tracer + variableExpressionGenerator.apply(variableLiteral);
}
- // STATIC_CALL implies that driver specific static logic should be called
- if ("STATIC_CALL".equals(vl.getName())) {
- if (!vl.getArgs().isPresent()) {
- throw new FreemarkerException("'STATIC_CALL' needs at least one args");
- }
- List<Term> terms = vl.getArgs().get();
- if (!(terms.get(0) instanceof StringLiteral)) {
- throw new FreemarkerException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral");
- }
- String functionName = ((StringLiteral) terms.get(0)).getValue();
- // We'll cut off the java package structure and just take the segment after the last "."
- functionName = functionName.substring(functionName.lastIndexOf('.') + 1, functionName.length() - 1);
- // But to make the function name unique, well add the driver prefix to it.
- StringBuilder sb = new StringBuilder(getCTypeName(functionName));
- if (terms.size() > 1) {
- sb.append("(");
- boolean firstArg = true;
- for (int i = 1; i < terms.size(); i++) {
- Term arg = terms.get(i);
- if (!firstArg) {
- sb.append(", ");
- }
- sb.append(toParseExpression(baseType, field, arg, parserArguments));
- firstArg = false;
- }
- sb.append(")");
- }
- return sb.toString();
+ }
+
+ public String toVariableParseExpression(TypeDefinition baseType, Field field, VariableLiteral variableLiteral, List<Argument> parserArguments) {
+ Tracer tracer = Tracer.start("toVariableParseExpression");
+ if ("CAST".equals(variableLiteral.getName())) {
+ return toCastVariableParseExpression(baseType, field, variableLiteral, parserArguments, tracer);
}
- // Any name that is full upper-case is considered a function call.
- // These are generally defined in the spi file evaluation_helper.c.
- // All should have a name prefix "plc4c_spi_evaluation_helper_".
- else if (vl.getName().equals(vl.getName().toUpperCase())) {
- StringBuilder sb = new StringBuilder("plc4c_spi_evaluation_helper_" + vl.getName().toLowerCase());
- if (vl.getArgs().isPresent()) {
- // TODO: replace with map join
- sb.append("(");
- boolean firstArg = true;
- for (Term arg : vl.getArgs().get()) {
- if (!firstArg) {
- sb.append(", ");
- }
- sb.append(toParseExpression(baseType, field, arg, parserArguments));
- firstArg = false;
- }
- sb.append(")");
- }
- if (vl.getIndex() != VariableLiteral.NO_INDEX) {
- sb.append("[").append(vl.getIndex()).append("]");
- }
- if (vl.getChild().isPresent()) {
- sb.append(".");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
- }
- return sb.toString();
- } else if ("readBuffer".equals(vl.getName())) {
- StringBuilder sb = new StringBuilder("readBuffer");
- if (vl.getChild().isPresent()) {
- // TODO: replace with map join
- sb.append(".");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
- }
- return sb.toString();
- } else if ("writeBuffer".equals(vl.getName())) {
- StringBuilder sb = new StringBuilder("writeBuffer");
- if (vl.getChild().isPresent()) {
- sb.append(".");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
- }
- return sb.toString();
- } else if ("_type".equals(vl.getName())) {
- if ((vl.getChild().isPresent()) && "encoding".equals(vl.getChild().get().getName()) && (field instanceof TypedField) && (((TypedField) field).getType() instanceof StringTypeReference)) {
- // TODO: replace with map join
- TypedField typedField = (TypedField) field;
- StringTypeReference stringTypeReference = (StringTypeReference) typedField.getType();
- return "\"" + stringTypeReference.getEncoding().substring(1, stringTypeReference.getEncoding().length() - 1) + "\"";
- } else {
- throw new FreemarkerException("_type is currently pretty much hard-coded for some use cases, please check CLanguageTemplateHelper.toVariableParseExpression");
- }
+ if ("STATIC_CALL".equals(variableLiteral.getName())) {
+ return toStaticCallVariableParseExpression(baseType, field, variableLiteral, parserArguments, tracer);
+ }
+ if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) {
+ return toUpperCaseVariableParseExpression(baseType, field, variableLiteral, parserArguments, tracer);
+ } else if ("readBuffer".equals(variableLiteral.getName())) {
+ return toReadBufferVariableParseExpression(baseType, variableLiteral, tracer);
+ } else if ("writeBuffer".equals(variableLiteral.getName())) {
+ return toWriteBufferVariableParseExpression(baseType, variableLiteral, tracer);
+ } else if ("_type".equals(variableLiteral.getName())) {
+ return toTypeVariableParseExpression(field, variableLiteral, tracer);
}
- final String name = vl.getName();
+ final String name = variableLiteral.getName();
// In case of DataIo types, we'll just check the arguments.
if (baseType instanceof DataIoTypeDefinition) {
@@ -732,7 +677,7 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
// If it's a simple field, there is no sub-type to access.
if (propertyType instanceof SimpleTypeReference) {
- if (vl.getChild().isPresent()) {
+ if (variableLiteral.getChild().isPresent()) {
throw new FreemarkerException("Simple property '" + name + "' doesn't have child properties.");
}
return name;
@@ -741,7 +686,7 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
// If it references a complex, type we need to get that type's definition first.
final TypeDefinition propertyTypeDefinition = getTypeDefinitions().get(((ComplexTypeReference) propertyType).getName());
// If we're not accessing any child property, no need to handle anything special.
- if (!vl.getChild().isPresent()) {
+ if (!variableLiteral.getChild().isPresent()) {
return name;
}
// If there is a child we need to check if this is a discriminator property.
@@ -750,53 +695,271 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
if (propertyTypeDefinition instanceof ComplexTypeDefinition) {
final Optional<DiscriminatorField> discriminatorFieldOptional = ((ComplexTypeDefinition) propertyTypeDefinition).getFields().stream().filter(
curField -> curField instanceof DiscriminatorField).map(curField -> (DiscriminatorField) curField).filter(
- discriminatorField -> discriminatorField.getName().equals(vl.getChild().get().getName())).findFirst();
+ discriminatorField -> discriminatorField.getName().equals(variableLiteral.getChild().get().getName())).findFirst();
// If child references a discriminator field of the type we found, we have to escape it.
if (discriminatorFieldOptional.isPresent()) {
- return getCTypeName(propertyTypeDefinition.getName()) + "_get_discriminator(" + name + "->_type)." + vl.getChild().get().getName();
+ return getCTypeName(propertyTypeDefinition.getName()) + "_get_discriminator(" + name + "->_type)." + variableLiteral.getChild().get().getName();
}
}
// Handling enum properties in C is a little more tricky as we have to use the enum value
// and pass this to a function that returns the desired property value.
else if (propertyTypeDefinition instanceof EnumTypeDefinition) {
return getCTypeName(propertyTypeDefinition.getName()) +
- "_get_" + camelCaseToSnakeCase(vl.getChild().get().getName()) +
- "(*" + vl.getName() + ")";
+ "_get_" + camelCaseToSnakeCase(variableLiteral.getChild().get().getName()) +
+ "(*" + variableLiteral.getName() + ")";
}
// Else ... generate a simple access path.
- StringBuilder sb = new StringBuilder(vl.getName());
- if (vl.getChild().isPresent()) {
+ StringBuilder sb = new StringBuilder(variableLiteral.getName());
+ if (variableLiteral.getChild().isPresent()) {
sb.append(".");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
+ appendVariableExpressionRest(sb, baseType, variableLiteral.getChild().get());
}
return sb.toString();
}
- private String toVariableSerializationExpression(TypeDefinition baseType, Field field, Term term, List<Argument> serializerArguments) {
- VariableLiteral vl = (VariableLiteral) term;
- if ("STATIC_CALL".equals(vl.getName())) {
- if (!vl.getArgs().isPresent()) {
- throw new FreemarkerException("'STATIC_CALL' needs at least one attribute");
+ private String toTypeVariableParseExpression(Field field, VariableLiteral variableLiteral, Tracer tracer) {
+ tracer = tracer.dive("type");
+ if ((variableLiteral.getChild().isPresent()) && "encoding".equals(variableLiteral.getChild().get().getName()) && (field instanceof TypedField) && (((TypedField) field).getType() instanceof StringTypeReference)) {
+ // TODO: replace with map join
+ TypedField typedField = (TypedField) field;
+ StringTypeReference stringTypeReference = (StringTypeReference) typedField.getType();
+ return tracer + "\"" + stringTypeReference.getEncoding().substring(1, stringTypeReference.getEncoding().length() - 1) + "\"";
+ } else {
+ throw new FreemarkerException("_type is currently pretty much hard-coded for some use cases, please check CLanguageTemplateHelper.toVariableParseExpression");
+ }
+ }
+
+ private String toReadBufferVariableParseExpression(TypeDefinition baseType, VariableLiteral variableLiteral, Tracer tracer) {
+ tracer = tracer.dive("readbuffer");
+ StringBuilder sb = new StringBuilder("readBuffer");
+ if (variableLiteral.getChild().isPresent()) {
+ // TODO: replace with map join
+ sb.append(".");
+ appendVariableExpressionRest(sb, baseType, variableLiteral.getChild().get());
+ }
+ return tracer + sb.toString();
+ }
+
+ /*
+ * Any name that is full upper-case is considered a function call.
+ * These are generally defined in the spi file evaluation_helper.c.
+ * All should have a name prefix "plc4c_spi_evaluation_helper_".
+ */
+ private String toUpperCaseVariableParseExpression(TypeDefinition baseType, Field field, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
+ tracer = tracer.dive("UPPER");
+ StringBuilder sb = new StringBuilder("plc4c_spi_evaluation_helper_" + variableLiteral.getName().toLowerCase());
+ if (variableLiteral.getArgs().isPresent()) {
+ // TODO: replace with map join
+ sb.append("(");
+ boolean firstArg = true;
+ for (Term arg : variableLiteral.getArgs().get()) {
+ if (!firstArg) {
+ sb.append(", ");
+ }
+ sb.append(toParseExpression(baseType, field, arg, parserArguments));
+ firstArg = false;
+ }
+ sb.append(")");
+ }
+ if (variableLiteral.getIndex() != VariableLiteral.NO_INDEX) {
+ sb.append("[").append(variableLiteral.getIndex()).append("]");
+ }
+ if (variableLiteral.getChild().isPresent()) {
+ sb.append(".");
+ appendVariableExpressionRest(sb, baseType, variableLiteral.getChild().get());
+ }
+ return tracer + sb.toString();
+ }
+
+ private String toCastVariableParseExpression(TypeDefinition baseType, Field field, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
+ tracer = tracer.dive("CAST");
+ if ((!variableLiteral.getArgs().isPresent()) || (variableLiteral.getArgs().get().size() != 2)) {
+ throw new FreemarkerException("A CAST expression expects exactly two arguments.");
+ }
+ List<Term> args = variableLiteral.getArgs().get();
+ final VariableLiteral sourceTerm = (VariableLiteral) args.get(0);
+ final VariableLiteral typeTerm = (VariableLiteral) variableLiteral.getArgs().get().get(1);
+ final TypeDefinition castType = getTypeDefinitions().get(typeTerm.getName());
+ // If we're casting to a sub-type of a discriminated value, we got to cast to the parent
+ // type instead and add the name of the sub-type as prefix to the property we're trying to
+ // access next.
+ StringBuilder sb = new StringBuilder();
+ sb.append("((");
+ if (castType.getParentType() != null) {
+ sb.append(getCTypeName(castType.getParentType().getName()));
+ } else {
+ sb.append(getCTypeName(castType.getName()));
+ }
+ sb.append("*) (");
+ sb.append(toVariableParseExpression(baseType, field, sourceTerm, parserArguments)).append("))");
+ if (variableLiteral.getChild().isPresent()) {
+ if (castType.getParentType() != null) {
+ // Change the name of the property to contain the sub-type-prefix.
+ sb.append("->").append(camelCaseToSnakeCase(castType.getName())).append("_");
+ appendVariableExpressionRest(sb, baseType, variableLiteral.getChild().get());
+ } else {
+ sb.append("->");
+ appendVariableExpressionRest(sb, castType, variableLiteral.getChild().get());
+ }
+ }
+ return tracer + sb.toString();
+ }
+
+ /*
+ * STATIC_CALL implies that driver specific static logic should be called
+ */
+ private String toStaticCallVariableParseExpression(TypeDefinition baseType, Field field, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
+ tracer = tracer.dive("STATIC_CALL");
+ if (!variableLiteral.getArgs().isPresent()) {
+ throw new FreemarkerException("'STATIC_CALL' needs at least one args");
+ }
+ List<Term> terms = variableLiteral.getArgs().get();
+ if (!(terms.get(0) instanceof StringLiteral)) {
+ throw new FreemarkerException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral");
+ }
+ String functionName = ((StringLiteral) terms.get(0)).getValue();
+ // We'll cut off the java package structure and just take the segment after the last "."
+ functionName = functionName.substring(functionName.lastIndexOf('.') + 1, functionName.length() - 1);
+ // But to make the function name unique, well add the driver prefix to it.
+ StringBuilder sb = new StringBuilder(getCTypeName(functionName));
+ if (terms.size() > 1) {
+ sb.append("(");
+ boolean firstArg = true;
+ for (int i = 1; i < terms.size(); i++) {
+ Term arg = terms.get(i);
+ if (!firstArg) {
+ sb.append(", ");
+ }
+ sb.append(toParseExpression(baseType, field, arg, parserArguments));
+ firstArg = false;
+ }
+ sb.append(")");
+ }
+ return tracer + sb.toString();
+ }
+
+ private String toWriteBufferVariableParseExpression(TypeDefinition baseType, VariableLiteral variableLiteral, Tracer tracer) {
+ tracer = tracer.dive("writeBuffer");
+ StringBuilder sb = new StringBuilder("writeBuffer");
+ if (variableLiteral.getChild().isPresent()) {
+ sb.append(".");
+ appendVariableExpressionRest(sb, baseType, variableLiteral.getChild().get());
+ }
+ return tracer + sb.toString();
+ }
+
+ private String toVariableSerializationExpression(TypeDefinition baseType, Field field, VariableLiteral variableLiteral, List<Argument> serializerArguments) {
+ Tracer tracer = Tracer.start("toVariableSerializationExpression");
+ if ("STATIC_CALL".equals(variableLiteral.getName())) {
+ return toStaticCallSerializationExpression(baseType, field, serializerArguments, variableLiteral, tracer);
+ }
+ // All uppercase names are not fields, but utility methods.
+ if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) {
+ return toUppercaseSerializationExpression(baseType, field, serializerArguments, variableLiteral, tracer);
+ }
+ // If we are accessing implicit fields, we need to rely on a local variable instead.
+ if (isVariableLiteralImplicitField(variableLiteral)) {
+ tracer = tracer.dive("is variable implicit field");
+ return tracer + toSerializationExpression(thisType, getReferencedImplicitField(variableLiteral), getReferencedImplicitField(variableLiteral).getSerializeExpression(), serializerArguments);
+ }
+ // The synthetic checksumRawData is a local field and should not be accessed as bean property.
+ boolean isSerializerArg = "checksumRawData".equals(variableLiteral.getName()) || "_value".equals(variableLiteral.getName()) || "element".equals(variableLiteral.getName()) || "size".equals(variableLiteral.getName());
+ boolean isTypeArg = "_type".equals(variableLiteral.getName());
+ if (!isSerializerArg && !isTypeArg && serializerArguments != null) {
+ for (Argument serializerArgument : serializerArguments) {
+ if (serializerArgument.getName().equals(variableLiteral.getName())) {
+ isSerializerArg = true;
+ break;
+ }
+ }
+ }
+ if (isSerializerArg) {
+ StringBuilder sb = new StringBuilder(variableLiteral.getName());
+ if (variableLiteral.getChild().isPresent()) {
+ sb.append(".");
+ appendVariableExpressionRest(sb, baseType, variableLiteral.getChild().get());
+ }
+ return sb.toString();
+ }
+ if (isTypeArg) {
+ tracer = tracer.dive("is type arg");
+ String part = variableLiteral.getChild().get().getName();
+ switch (part) {
+ case "name":
+ tracer = tracer.dive("name");
+ return tracer + "\"" + field.getTypeName() + "\"";
+ case "length":
+ tracer = tracer.dive("length");
+ return tracer + "\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
+ case "encoding":
+ tracer = tracer.dive("encoding");
+ if (!(field instanceof TypedField)) {
+ throw new FreemarkerException("'encoding' only supported for typed fields.");
+ }
+ TypedField typedField = (TypedField) field;
+ if (!(typedField.getType() instanceof StringTypeReference)) {
+ throw new FreemarkerException("Can only access 'encoding' for string types.");
+ }
+ StringTypeReference stringTypeReference = (StringTypeReference) typedField.getType();
+ String encoding = stringTypeReference.getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ return tracer + "\"" + encoding + "\"";
+ default:
+ return tracer + "";
}
- List<Term> args = vl.getArgs().get();
- if (!(args.get(0) instanceof StringLiteral)) {
- throw new FreemarkerException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral");
+ }
+ // If it wasn't an enum, treat it as a normal property.
+ if (variableLiteral.getName().equals("lengthInBits")) {
+ tracer = tracer.dive("is length in bits");
+ return tracer + getCTypeName(baseType.getName()) + "_length_in_bits(_message)";
+ }
+ if (variableLiteral.getChild().isPresent() && "length".equals(variableLiteral.getChild().get().getName())) {
+ tracer = tracer.dive("is length");
+ return tracer + "sizeof(_message->" + camelCaseToSnakeCase(variableLiteral.getName()) + ")";
+ }
+ StringBuilder sb = new StringBuilder("_message->");
+ // If this is a property of a sub-type, add the sub-type name to the property.
+ if (baseType != thisType) {
+ sb.append(camelCaseToSnakeCase(baseType.getName())).append("_");
+ }
+
+ // If this expression references enum constants we need to do things differently
+ final Optional<TypeReference> typeReferenceForProperty =
+ getTypeReferenceForProperty((ComplexTypeDefinition) baseType, variableLiteral.getName());
+ if (typeReferenceForProperty.isPresent()) {
+ final TypeReference typeReference = typeReferenceForProperty.get();
+ if (typeReference instanceof ComplexTypeReference) {
+ final TypeDefinition typeDefinitionForTypeReference =
+ getTypeDefinitionForTypeReference(typeReference);
+ if ((typeDefinitionForTypeReference instanceof EnumTypeDefinition) && (variableLiteral.getChild().isPresent())) {
+ tracer = tracer.dive("is enum type definition");
+ sb.append(camelCaseToSnakeCase(variableLiteral.getName()));
+ return getCTypeName(typeDefinitionForTypeReference.getName()) +
+ tracer + "_get_" + camelCaseToSnakeCase(variableLiteral.getChild().get().getName()) +
+ "(" + sb + ")";
+ }
}
- String functionName = ((StringLiteral) args.get(0)).getValue();
- // We'll cut off the java package structure and just take the segment after the last "."
- functionName = functionName.substring(functionName.lastIndexOf('.') + 1, functionName.length() - 1);
- // But to make the function name unique, well add the driver prefix to it.
- StringBuilder sb = new StringBuilder(getCTypeName(functionName));
+ }
+ // If it wasn't an enum, treat it as a normal property.
+ appendVariableExpressionRest(sb, baseType, variableLiteral);
+ return tracer + sb.toString();
+ }
+
+ private String toUppercaseSerializationExpression(TypeDefinition baseType, Field field, List<Argument> serializerArguments, VariableLiteral vl, Tracer tracer) {
+ tracer = tracer.dive("UPPER_CASE");
+ StringBuilder sb = new StringBuilder("plc4c_spi_evaluation_helper_" + vl.getName().toLowerCase());
+ if (vl.getArgs().isPresent()) {
sb.append("(");
- for (int i = 1; i < args.size(); i++) {
- Term arg = args.get(i);
- if (i > 1) {
+ boolean firstArg = true;
+ for (Term arg : vl.getArgs().get()) {
+ if (!firstArg) {
sb.append(", ");
}
+
if (arg instanceof VariableLiteral) {
VariableLiteral va = (VariableLiteral) arg;
- // "io" and "_value" are always available in every parser.
- boolean isSerializerArg = "writeBuffer".equals(va.getName()) || "_value".equals(va.getName()) || "element".equals(va.getName());
+ boolean isSerializerArg = "io".equals(va.getName());
boolean isTypeArg = "_type".equals(va.getName());
if (!isSerializerArg && !isTypeArg && serializerArguments != null) {
for (Argument serializerArgument : serializerArguments) {
@@ -807,13 +970,9 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
}
}
if (isSerializerArg) {
- if ("_value".equals(va.getName())) {
- sb.append("_message");
- } else {
- sb.append(va.getName());
- }
+ sb.append(va.getName());
if (va.getChild().isPresent()) {
- sb.append("->");
+ sb.append(".");
appendVariableExpressionRest(sb, baseType, va.getChild().get());
}
} else if (isTypeArg) {
@@ -846,208 +1005,134 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
} else if (arg instanceof StringLiteral) {
sb.append(((StringLiteral) arg).getValue());
}
+ firstArg = false;
}
sb.append(")");
- return sb.toString();
}
- // All uppercase names are not fields, but utility methods.
- else if (vl.getName().equals(vl.getName().toUpperCase())) {
- StringBuilder sb = new StringBuilder("plc4c_spi_evaluation_helper_" + vl.getName().toLowerCase());
- if (vl.getArgs().isPresent()) {
- sb.append("(");
- boolean firstArg = true;
- for (Term arg : vl.getArgs().get()) {
- if (!firstArg) {
- sb.append(", ");
- }
+ return tracer + sb.toString();
+ }
- if (arg instanceof VariableLiteral) {
- VariableLiteral va = (VariableLiteral) arg;
- boolean isSerializerArg = "io".equals(va.getName());
- boolean isTypeArg = "_type".equals(va.getName());
- if (!isSerializerArg && !isTypeArg && serializerArguments != null) {
- for (Argument serializerArgument : serializerArguments) {
- if (serializerArgument.getName().equals(va.getName())) {
- isSerializerArg = true;
- break;
- }
- }
- }
- if (isSerializerArg) {
- sb.append(va.getName());
- if (va.getChild().isPresent()) {
- sb.append(".");
- appendVariableExpressionRest(sb, baseType, va.getChild().get());
- }
- } else if (isTypeArg) {
- String part = va.getChild().get().getName();
- switch (part) {
- case "name":
- sb.append("\"").append(field.getTypeName()).append("\"");
- break;
- case "length":
- sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
- break;
- case "encoding":
- if (!(field instanceof TypedField)) {
- throw new FreemarkerException("'encoding' only supported for typed fields.");
- }
- TypedField typedField = (TypedField) field;
- if (!(typedField.getType() instanceof StringTypeReference)) {
- throw new FreemarkerException("Can only access 'encoding' for string types.");
- }
- StringTypeReference stringTypeReference = (StringTypeReference) typedField.getType();
- String encoding = stringTypeReference.getEncoding();
- // Cut off the single quotes.
- encoding = encoding.substring(1, encoding.length() - 1);
- sb.append("\"").append(encoding).append("\"");
- break;
- }
- } else {
- sb.append(toVariableSerializationExpression(baseType, field, va, null));
- }
- } else if (arg instanceof StringLiteral) {
- sb.append(((StringLiteral) arg).getValue());
- }
- firstArg = false;
- }
- sb.append(")");
- }
- return sb.toString();
+ private String toStaticCallSerializationExpression(TypeDefinition baseType, Field field, List<Argument> serializerArguments, VariableLiteral vl, Tracer tracer) {
+ tracer = tracer.dive("toStaticCallSerializationExpression");
+ if (!vl.getArgs().isPresent()) {
+ throw new FreemarkerException("'STATIC_CALL' needs at least one attribute");
}
- // If we are accessing implicit fields, we need to rely on a local variable instead.
- if (isVariableLiteralImplicitField(vl)) {
- return toSerializationExpression(thisType, getReferencedImplicitField(vl), getReferencedImplicitField(vl).getSerializeExpression(), serializerArguments);
+ List<Term> args = vl.getArgs().get();
+ if (!(args.get(0) instanceof StringLiteral)) {
+ throw new FreemarkerException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral");
}
- // The synthetic checksumRawData is a local field and should not be accessed as bean property.
- boolean isSerializerArg = "checksumRawData".equals(vl.getName()) || "_value".equals(vl.getName()) || "element".equals(vl.getName()) || "size".equals(vl.getName());
- boolean isTypeArg = "_type".equals(vl.getName());
- if (!isSerializerArg && !isTypeArg && serializerArguments != null) {
- for (Argument serializerArgument : serializerArguments) {
- if (serializerArgument.getName().equals(vl.getName())) {
- isSerializerArg = true;
- break;
- }
+ String functionName = ((StringLiteral) args.get(0)).getValue();
+ // We'll cut off the java package structure and just take the segment after the last "."
+ functionName = functionName.substring(functionName.lastIndexOf('.') + 1, functionName.length() - 1);
+ // But to make the function name unique, well add the driver prefix to it.
+ StringBuilder sb = new StringBuilder(getCTypeName(functionName));
+ sb.append("(");
+ for (int i = 1; i < args.size(); i++) {
+ Term arg = args.get(i);
+ if (i > 1) {
+ sb.append(", ");
}
- }
- if (isSerializerArg) {
- StringBuilder sb = new StringBuilder(vl.getName());
- if (vl.getChild().isPresent()) {
- sb.append(".");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
- }
- return sb.toString();
- } else if (isTypeArg) {
- String part = vl.getChild().get().getName();
- switch (part) {
- case "name":
- return "\"" + field.getTypeName() + "\"";
- case "length":
- return "\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
- case "encoding":
- if (!(field instanceof TypedField)) {
- throw new FreemarkerException("'encoding' only supported for typed fields.");
- }
- TypedField typedField = (TypedField) field;
- if (!(typedField.getType() instanceof StringTypeReference)) {
- throw new FreemarkerException("Can only access 'encoding' for string types.");
+ if (arg instanceof VariableLiteral) {
+ VariableLiteral va = (VariableLiteral) arg;
+ // "io" and "_value" are always available in every parser.
+ boolean isSerializerArg = "writeBuffer".equals(va.getName()) || "_value".equals(va.getName()) || "element".equals(va.getName());
+ boolean isTypeArg = "_type".equals(va.getName());
+ if (!isSerializerArg && !isTypeArg && serializerArguments != null) {
+ for (Argument serializerArgument : serializerArguments) {
+ if (serializerArgument.getName().equals(va.getName())) {
+ isSerializerArg = true;
+ break;
+ }
}
- StringTypeReference stringTypeReference = (StringTypeReference) typedField.getType();
- String encoding = stringTypeReference.getEncoding();
- // Cut off the single quotes.
- encoding = encoding.substring(1, encoding.length() - 1);
- return "\"" + encoding + "\"";
- default:
- return "";
- }
- } else {
- // If it wasn't an enum, treat it as a normal property.
- if (vl.getName().equals("lengthInBits")) {
- return getCTypeName(baseType.getName()) + "_length_in_bits(_message)";
- } else if (vl.getChild().isPresent() && "length".equals(vl.getChild().get().getName())) {
- return "sizeof(_message->" + camelCaseToSnakeCase(vl.getName()) + ")";
- } else {
- StringBuilder sb = new StringBuilder("_message->");
- // If this is a property of a sub-type, add the sub-type name to the property.
- if (baseType != thisType) {
- sb.append(camelCaseToSnakeCase(baseType.getName())).append("_");
}
-
- // If this expression references enum constants we need to do things differently
- final Optional<TypeReference> typeReferenceForProperty =
- getTypeReferenceForProperty((ComplexTypeDefinition) baseType, vl.getName());
- if (typeReferenceForProperty.isPresent()) {
- final TypeReference typeReference = typeReferenceForProperty.get();
- if (typeReference instanceof ComplexTypeReference) {
- final TypeDefinition typeDefinitionForTypeReference =
- getTypeDefinitionForTypeReference(typeReference);
- if ((typeDefinitionForTypeReference instanceof EnumTypeDefinition) && (vl.getChild().isPresent())) {
- sb.append(camelCaseToSnakeCase(vl.getName()));
- return getCTypeName(typeDefinitionForTypeReference.getName()) +
- "_get_" + camelCaseToSnakeCase(vl.getChild().get().getName()) +
- "(" + sb + ")";
- }
+ if (isSerializerArg) {
+ if ("_value".equals(va.getName())) {
+ sb.append("_message");
+ } else {
+ sb.append(va.getName());
}
+ if (va.getChild().isPresent()) {
+ sb.append("->");
+ appendVariableExpressionRest(sb, baseType, va.getChild().get());
+ }
+ } else if (isTypeArg) {
+ String part = va.getChild().get().getName();
+ switch (part) {
+ case "name":
+ sb.append("\"").append(field.getTypeName()).append("\"");
+ break;
+ case "length":
+ sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
+ break;
+ case "encoding":
+ if (!(field instanceof TypedField)) {
+ throw new FreemarkerException("'encoding' only supported for typed fields.");
+ }
+ TypedField typedField = (TypedField) field;
+ if (!(typedField.getType() instanceof StringTypeReference)) {
+ throw new FreemarkerException("Can only access 'encoding' for string types.");
+ }
+ StringTypeReference stringTypeReference = (StringTypeReference) typedField.getType();
+ String encoding = stringTypeReference.getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ sb.append("\"").append(encoding).append("\"");
+ break;
+ }
+ } else {
+ sb.append(toVariableSerializationExpression(baseType, field, va, null));
}
- // If it wasn't an enum, treat it as a normal property.
- appendVariableExpressionRest(sb, baseType, vl);
- return sb.toString();
+ } else if (arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
}
}
+ sb.append(")");
+ return tracer + sb.toString();
}
- private void appendVariableExpressionRest(StringBuilder sb, TypeDefinition baseType, VariableLiteral vl) {
- if (vl.isIndexed()) {
+ private void appendVariableExpressionRest(StringBuilder sb, TypeDefinition baseType, VariableLiteral variableLiteral) {
+ if (variableLiteral.isIndexed()) {
sb.insert(0, "plc4c_utils_list_get_value(");
- sb.append(camelCaseToSnakeCase(vl.getName()));
- sb.append(", ").append(vl.getIndex()).append(")");
+ sb.append(camelCaseToSnakeCase(variableLiteral.getName()));
+ sb.append(", ").append(variableLiteral.getIndex()).append(")");
} else {
- sb.append(camelCaseToSnakeCase(vl.getName()));
+ sb.append(camelCaseToSnakeCase(variableLiteral.getName()));
}
// Suppress any "lengthInBytes" properties as these are handled differently in C
- if ((vl.getChild().isPresent()) && !vl.getChild().get().getName().equals("lengthInBytes")) {
- sb.append(".");
- appendVariableExpressionRest(sb, baseType, vl.getChild().get());
- }
+ variableLiteral.getChild()
+ .filter(child -> "lengthInBytes".equals(child.getName()))
+ .ifPresent(child -> {
+ sb.append(".");
+ appendVariableExpressionRest(sb, baseType, child);
+ });
}
public int getNumBits(SimpleTypeReference simpleTypeReference) {
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return 1;
- }
case UINT:
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
return integerTypeReference.getSizeInBits();
- }
- case FLOAT: {
+ case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
return floatTypeReference.getSizeInBits();
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
return stringTypeReference.getSizeInBits();
- }
- default: {
+ default:
return 0;
- }
}
}
public String getLengthInBitsFunctionNameForComplexTypedField(Field field) {
- if (field instanceof TypedField) {
- TypedField typedField = (TypedField) field;
- final TypeReference typeReference = typedField.getType();
- if (typeReference instanceof ComplexTypeReference) {
- ComplexTypeReference complexTypeReference = (ComplexTypeReference) typeReference;
- return getCTypeName(complexTypeReference.getName()) + "_length_in_bits";
- } else {
- throw new FreemarkerException("lengthInBits functions only exist for complex types");
- }
- } else {
- throw new FreemarkerException("lengthInBits functions only exist for TypedFields");
- }
+ return field.asTypedField()
+ .map(TypedField::getType)
+ .orElseThrow(() -> new FreemarkerException("lengthInBits functions only exist for TypedFields"))
+ .asComplexTypeReference()
+ .map(complexTypeReference -> getCTypeName(complexTypeReference.getName()) + "_length_in_bits")
+ .orElseThrow(() -> new FreemarkerException("lengthInBits functions only exist for complex types"));
}
public String getEnumExpression(String expression) {
diff --git a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
index 43234e9..1b44c14 100644
--- a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
+++ b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
@@ -21,6 +21,7 @@ package org.apache.plc4x.language.go;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.BaseFreemarkerLanguageTemplateHelper;
+import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerException;
import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer;
import org.apache.plc4x.plugins.codegenerator.types.definitions.*;
import org.apache.plc4x.plugins.codegenerator.types.enums.EnumValue;
@@ -164,29 +165,26 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
if (typeReference instanceof SimpleTypeReference) {
SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "values.NewPlcBOOL";
- }
- case BYTE: {
+ case BYTE:
return "values.NewPlcUINT";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 8) {
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
return "values.NewPlcUSINT";
}
- if (integerTypeReference.getSizeInBits() <= 16) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
return "values.NewPlcUINT";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
return "values.NewPlcUDINT";
}
- if (integerTypeReference.getSizeInBits() <= 64) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 64) {
return "values.NewPlcULINT";
}
return "values.NewPlcBINT";
- }
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return "values.NewPlcSINT";
@@ -201,9 +199,8 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "values.NewPlcLINT";
}
return "values.NewPlcBINT";
- }
case FLOAT:
- case UFLOAT: {
+ case UFLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
int sizeInBits = ((floatTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.FLOAT) ? 1 : 0) +
floatTypeReference.getExponent() + floatTypeReference.getMantissa();
@@ -214,21 +211,16 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "values.NewPlcLREAL";
}
return "values.NewPlcBREAL";
- }
- case STRING: {
+ case STRING:
return "values.NewPlcSTRING";
- }
- case TIME: {
+ case TIME:
return "values.NewPlcTIME";
- }
- case DATE: {
+ case DATE:
return "values.NewPlcDATE";
- }
- case DATETIME: {
+ case DATETIME:
return "values.NewPlcDATE_AND_TIME";
- }
}
- throw new RuntimeException("Unsupported simple type");
+ throw new FreemarkerException("Unsupported simple type" + simpleTypeReference.getBaseType());
} else {
return (typeReference != null) ? ((ComplexTypeReference) typeReference).getName() : "";
}
@@ -258,28 +250,23 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
public int getNumBits(SimpleTypeReference simpleTypeReference) {
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return 1;
- }
- case BYTE: {
+
+ case BYTE:
return 8;
- }
case UINT:
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
return integerTypeReference.getSizeInBits();
- }
- case FLOAT: {
+ case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
return floatTypeReference.getSizeInBits();
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
return stringTypeReference.getSizeInBits();
- }
- default: {
+ default:
return 0;
- }
}
}
@@ -298,29 +285,26 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, String valueString, TypedField field) {
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "readBuffer.ReadBit(\"" + logicalName + "\")";
- }
- case BYTE: {
+ case BYTE:
return "readBuffer.ReadByte(\"" + logicalName + "\")";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 8) {
- return "readBuffer.ReadUint8(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
+ return "readBuffer.ReadUint8(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- if (integerTypeReference.getSizeInBits() <= 16) {
- return "readBuffer.ReadUint16(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
+ return "readBuffer.ReadUint16(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
- return "readBuffer.ReadUint32(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
+ return "readBuffer.ReadUint32(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- if (integerTypeReference.getSizeInBits() <= 64) {
- return "readBuffer.ReadUint64(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 64) {
+ return "readBuffer.ReadUint64(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- return "readBuffer.ReadBigInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
- }
- case INT: {
+ return "readBuffer.ReadBigInt(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return "readBuffer.ReadInt8(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
@@ -335,8 +319,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "readBuffer.ReadInt64(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
}
return "readBuffer.ReadBigInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
- }
- case FLOAT: {
+ case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
if (floatTypeReference.getSizeInBits() <= 32) {
return "readBuffer.ReadFloat32(\"" + logicalName + "\", true, " + floatTypeReference.getExponent() + ", " + floatTypeReference.getMantissa() + ")";
@@ -345,13 +328,11 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "readBuffer.ReadFloat64(\"" + logicalName + "\", true, " + floatTypeReference.getExponent() + ", " + floatTypeReference.getMantissa() + ")";
}
return "readBuffer.ReadBigFloat(\"" + logicalName + "\", true, " + floatTypeReference.getExponent() + ", " + floatTypeReference.getMantissa() + ")";
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
return "readBuffer.ReadString(\"" + logicalName + "\", uint32(" + toParseExpression(field, stringTypeReference.getLengthExpression(), null) + "))";
- }
}
- return "Hurz";
+ throw new FreemarkerException("Unsupported base type" + simpleTypeReference.getBaseType());
}
@Override
@@ -367,29 +348,26 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
writerArgsString += ", " + StringUtils.join(writerArgs, ", ");
}
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "writeBuffer.WriteBit(\"" + logicalName + "\", " + fieldName + writerArgsString + ")";
- }
- case BYTE: {
+ case BYTE:
return "writeBuffer.WriteByte(\"" + logicalName + "\", " + fieldName + writerArgsString + ")";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 8) {
- return "writeBuffer.WriteUint8(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
+ return "writeBuffer.WriteUint8(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
}
- if (integerTypeReference.getSizeInBits() <= 16) {
- return "writeBuffer.WriteUint16(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
+ return "writeBuffer.WriteUint16(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
- return "writeBuffer.WriteUint32(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
+ return "writeBuffer.WriteUint32(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
}
- if (integerTypeReference.getSizeInBits() <= 64) {
- return "writeBuffer.WriteUint64(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 64) {
+ return "writeBuffer.WriteUint64(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
}
- return "writeBuffer.WriteBigInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
- }
- case INT: {
+ return "writeBuffer.WriteBigInt(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return "writeBuffer.WriteInt8(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
@@ -404,9 +382,8 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "writeBuffer.WriteInt64(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
}
return "writeBuffer.WriteBigInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
- }
case FLOAT:
- case UFLOAT: {
+ case UFLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
if (floatTypeReference.getSizeInBits() <= 32) {
return "writeBuffer.WriteFloat32(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
@@ -415,16 +392,14 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "writeBuffer.WriteFloat64(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
}
return "writeBuffer.WriteBigFloat(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")";
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
String encoding = ((stringTypeReference.getEncoding() != null) && (stringTypeReference.getEncoding().length() > 2)) ?
stringTypeReference.getEncoding().substring(1, stringTypeReference.getEncoding().length() - 1) : "UTF-8";
return "writeBuffer.WriteString(\"" + logicalName + "\", uint8(" + toSerializationExpression(field, stringTypeReference.getLengthExpression(), thisType.getParserArguments().orElse(Collections.emptyList())) + "), \"" +
encoding + "\", " + fieldName + writerArgsString + ")";
- }
}
- return "Hurz";
+ throw new FreemarkerException("Unsupported base type" + simpleTypeReference.getBaseType());
}
public String getReservedValue(ReservedField reservedField) {
@@ -501,142 +476,141 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
return "";
}
if (term instanceof Literal) {
- tracer = tracer.dive("literal term instanceOf");
- if (term instanceof NullLiteral) {
- tracer = tracer.dive("null literal instanceOf");
- return tracer + "nil";
- } else if (term instanceof BooleanLiteral) {
- tracer = tracer.dive("boolean literal instanceOf");
- return tracer + getCastExpressionForTypeReference(fieldType) + "(" + ((BooleanLiteral) term).getValue() + ")";
- } else if (term instanceof NumericLiteral) {
- tracer = tracer.dive("numeric literal instanceOf");
- if (getCastExpressionForTypeReference(fieldType).equals("string")) {
- tracer = tracer.dive("type reference string");
- return tracer + "(" + ((NumericLiteral) term).getNumber().toString() + ")";
- } else {
- return tracer + getCastExpressionForTypeReference(fieldType) + "(" + ((NumericLiteral) term).getNumber().toString() + ")";
- }
- } else if (term instanceof StringLiteral) {
- tracer = tracer.dive("string literal instanceOf");
- return tracer + "\"" + ((StringLiteral) term).getValue() + "\"";
- } else if (term instanceof VariableLiteral) {
- tracer = tracer.dive("variable literal instanceOf");
- return tracer + toVariableExpression(fieldType, (VariableLiteral) term, parserArguments, serializerArguments, serialize, suppressPointerAccess);
- } else {
- throw new RuntimeException("Unsupported Literal type " + term.getClass().getName());
- }
+ return toLiteralTermExpression(fieldType, term, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
} else if (term instanceof UnaryTerm) {
- tracer = tracer.dive("unary term instanceOf");
- UnaryTerm ut = (UnaryTerm) term;
- Term a = ut.getA();
- switch (ut.getOperation()) {
- case "!":
- tracer = tracer.dive("case !");
- return tracer + "!(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ")";
- case "-":
- tracer = tracer.dive("case -");
- return tracer + "-(" + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + "))";
- case "()":
- tracer = tracer.dive("case ()");
- return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ")";
- default:
- throw new RuntimeException("Unsupported unary operation type " + ut.getOperation());
- }
+ return toUnaryTermExpression(fieldType, (UnaryTerm) term, parserArguments, serializerArguments, serialize, tracer);
} else if (term instanceof BinaryTerm) {
- tracer = tracer.dive("binary term instanceOf");
- BinaryTerm bt = (BinaryTerm) term;
- Term a = bt.getA();
- Term b = bt.getB();
- String operation = bt.getOperation();
- switch (operation) {
- case "^":
- tracer = tracer.dive("^");
- emitRequiredImport("math");
- return tracer + "Math.pow(" +
- getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " +
- getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + "))";
- // If we start casting for comparisons, equals or non equals, really messy things happen.
- case "==":
- case "!=":
- case ">":
- case "<":
- case ">=":
- case "<=":
- tracer = tracer.dive("compare");
- // For every access of optional elements we need pointer access ...
- // Except for doing a nil or not-nil check :-(
- // So in case of such a check, we need to suppress the pointer-access.
- boolean suppressPointerAccessOverride = (operation.equals("==") || operation.equals("!=")) && ((a instanceof NullLiteral) || (b instanceof NullLiteral));
- return tracer + "bool((" + toExpression(null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + ") " +
- operation +
- " (" + toExpression(null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + "))";
- default:
- tracer = tracer.dive("default");
- if (fieldType instanceof StringTypeReference) {
- tracer = tracer.dive("string type reference");
- return tracer + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) +
- operation + " " +
- toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false);
- }
- return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " +
- operation + " " +
- getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + ")";
- }
+ return toBinaryTermExpression(fieldType, (BinaryTerm) term, parserArguments, serializerArguments, serialize, tracer);
} else if (term instanceof TernaryTerm) {
- tracer = tracer.dive("ternary term instanceOf");
- TernaryTerm tt = (TernaryTerm) term;
- if ("if".equals(tt.getOperation())) {
- Term a = tt.getA();
- Term b = tt.getB();
- Term c = tt.getC();
- return tracer + "utils.InlineIf(" + toExpression(new DefaultBooleanTypeReference(), a, parserArguments, serializerArguments, serialize, false) + ", " +
- "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + ")}, " +
- "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, c, parserArguments, serializerArguments, serialize, false) + ")}).(" + getCastExpressionForTypeReference(fieldType) + ")";
+ return toTernaryTermExpression(fieldType, (TernaryTerm) term, parserArguments, serializerArguments, serialize, tracer);
+ } else {
+ throw new RuntimeException("Unsupported Term type " + term.getClass().getName());
+ }
+ }
+
+ private String toTernaryTermExpression(TypeReference fieldType, TernaryTerm ternaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) {
+ tracer = tracer.dive("ternary term instanceOf");
+ if ("if".equals(ternaryTerm.getOperation())) {
+ Term a = ternaryTerm.getA();
+ Term b = ternaryTerm.getB();
+ Term c = ternaryTerm.getC();
+ return tracer + "utils.InlineIf(" + toExpression(new DefaultBooleanTypeReference(), a, parserArguments, serializerArguments, serialize, false) + ", " +
+ "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + ")}, " +
+ "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, c, parserArguments, serializerArguments, serialize, false) + ")}).(" + getCastExpressionForTypeReference(fieldType) + ")";
+ } else {
+ throw new RuntimeException("Unsupported ternary operation type " + ternaryTerm.getOperation());
+ }
+ }
+
+ private String toBinaryTermExpression(TypeReference fieldType, BinaryTerm binaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) {
+ tracer = tracer.dive("binary term instanceOf");
+ Term a = binaryTerm.getA();
+ Term b = binaryTerm.getB();
+ String operation = binaryTerm.getOperation();
+ switch (operation) {
+ case "^":
+ tracer = tracer.dive("^");
+ emitRequiredImport("math");
+ return tracer + "Math.pow(" +
+ getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " +
+ getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + "))";
+ // If we start casting for comparisons, equals or non equals, really messy things happen.
+ case "==":
+ case "!=":
+ case ">":
+ case "<":
+ case ">=":
+ case "<=":
+ tracer = tracer.dive("compare");
+ // For every access of optional elements we need pointer access ...
+ // Except for doing a nil or not-nil check :-(
+ // So in case of such a check, we need to suppress the pointer-access.
+ boolean suppressPointerAccessOverride = (operation.equals("==") || operation.equals("!=")) && ((a instanceof NullLiteral) || (b instanceof NullLiteral));
+ return tracer + "bool((" + toExpression(null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + ") " +
+ operation +
+ " (" + toExpression(null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + "))";
+ default:
+ tracer = tracer.dive("default");
+ if (fieldType instanceof StringTypeReference) {
+ tracer = tracer.dive("string type reference");
+ return tracer + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) +
+ operation + " " +
+ toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false);
+ }
+ return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " +
+ operation + " " +
+ getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + ")";
+ }
+ }
+
+ private String toUnaryTermExpression(TypeReference fieldType, UnaryTerm unaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) {
+ tracer = tracer.dive("unary term instanceOf");
+ Term a = unaryTerm.getA();
+ switch (unaryTerm.getOperation()) {
+ case "!":
+ tracer = tracer.dive("case !");
+ return tracer + "!(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ")";
+ case "-":
+ tracer = tracer.dive("case -");
+ return tracer + "-(" + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + "))";
+ case "()":
+ tracer = tracer.dive("case ()");
+ return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ")";
+ default:
+ throw new RuntimeException("Unsupported unary operation type " + unaryTerm.getOperation());
+ }
+ }
+
+ private String toLiteralTermExpression(TypeReference fieldType, Term term, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("literal term instanceOf");
+ if (term instanceof NullLiteral) {
+ tracer = tracer.dive("null literal instanceOf");
+ return tracer + "nil";
+ } else if (term instanceof BooleanLiteral) {
+ tracer = tracer.dive("boolean literal instanceOf");
+ return tracer + getCastExpressionForTypeReference(fieldType) + "(" + ((BooleanLiteral) term).getValue() + ")";
+ } else if (term instanceof NumericLiteral) {
+ tracer = tracer.dive("numeric literal instanceOf");
+ if (getCastExpressionForTypeReference(fieldType).equals("string")) {
+ tracer = tracer.dive("type reference string");
+ return tracer + "(" + ((NumericLiteral) term).getNumber().toString() + ")";
} else {
- throw new RuntimeException("Unsupported ternary operation type " + tt.getOperation());
+ return tracer + getCastExpressionForTypeReference(fieldType) + "(" + ((NumericLiteral) term).getNumber().toString() + ")";
}
+ } else if (term instanceof StringLiteral) {
+ tracer = tracer.dive("string literal instanceOf");
+ return tracer + "\"" + ((StringLiteral) term).getValue() + "\"";
+ } else if (term instanceof VariableLiteral) {
+ tracer = tracer.dive("variable literal instanceOf");
+ return tracer + toVariableExpression(fieldType, (VariableLiteral) term, parserArguments, serializerArguments, serialize, suppressPointerAccess);
} else {
- throw new RuntimeException("Unsupported Term type " + term.getClass().getName());
+ throw new RuntimeException("Unsupported Literal type " + term.getClass().getName());
}
}
private String toVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess) {
Tracer tracer = Tracer.start("toVariableExpression");
if ("lengthInBytes".equals(variableLiteral.getName())) {
- tracer = tracer.dive("lengthInBytes");
- return tracer + (serialize ? getCastExpressionForTypeReference(typeReference) + "(m." : "") + "LengthInBytes()" + (serialize ? ")" : "");
+ return toLengthInBytesVariableExpression(typeReference, serialize, tracer);
} else if ("lengthInBits".equals(variableLiteral.getName())) {
- tracer = tracer.dive("lengthInBits");
- return tracer + (serialize ? getCastExpressionForTypeReference(typeReference) + "(m." : "") + "LengthInBits()" + (serialize ? ")" : "");
+ return toLengthInBitsVariableExpression(typeReference, serialize, tracer);
} else if ("_value".equals(variableLiteral.getName())) {
- final Tracer tracer2 = tracer.dive("_value");
- return variableLiteral.getChild()
- .map(child -> tracer2.dive("withChild") + toVariableExpression(typeReference, child, parserArguments, serializerArguments, serialize, suppressPointerAccess))
- .orElse(tracer2 + "m");
+ return toValueVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
}
if ("length".equals(variableLiteral.getChild().map(VariableLiteral::getName).orElse(""))) {
- tracer = tracer.dive("length");
- return tracer + (serialize ? ("len(m." + StringUtils.capitalize(variableLiteral.getName()) + ")") : ("(" + variableLiteral.getName() + ")"));
+ return toLengthVariableExpression(variableLiteral, serialize, tracer);
}
// If this literal references an Enum type, then we have to output it differently.
else if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
- tracer = tracer.dive("enum");
- VariableLiteral child = variableLiteral.getChild().orElseThrow(() -> new RuntimeException("Enum should have a child"));
- return tracer + variableLiteral.getName() + "_" + child.getName() +
- child.getChild().map(childChild -> "." + toVariableExpression(typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("");
+ return toEnumVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer);
}
// If we are accessing enum constants, these also need to be output differently.
else if ((getFieldForNameFromCurrent(variableLiteral.getName()) instanceof EnumField) && (variableLiteral.getChild().isPresent())) {
- tracer = tracer.dive("enum constant");
- VariableLiteral child = variableLiteral.getChild().get();
- return tracer + variableLiteral.getName() + "." + StringUtils.capitalize(child.getName()) + "()" +
- child.getChild().map(childChild -> "." + toVariableExpression(typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("");
+ return toConstantVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer);
}
// If we are accessing optional fields, (we might need to use pointer-access).
else if (!serialize && (getFieldForNameFromCurrent(variableLiteral.getName()) instanceof OptionalField)) {
- tracer = tracer.dive("optional fields");
- return tracer + "(" + (suppressPointerAccess ? "" : "*") + variableLiteral.getName() + ")" +
- variableLiteral.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("");
+ return toOptionalVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer);
}
// If we are accessing implicit fields, we need to rely on local variable instead.
//else if (isVariableLiteralImplicitField(vl)) {
@@ -648,170 +622,19 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
// CAST expressions are special as we need to add a ".class" to the second parameter in Java.
else if ("CAST".equals(variableLiteral.getName())) {
- tracer = tracer.dive("CAST");
- List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A Cast expression needs arguments"));
- if (arguments.size() != 2) {
- throw new RuntimeException("A CAST expression expects exactly two arguments.");
- }
- VariableLiteral firstArgument = arguments.get(0).asLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
- .asVariableLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a Variable literal"));
- VariableLiteral typeLiteral = arguments.get(1).asLiteral()
- .orElseThrow(() -> new RuntimeException("Second argument should be a literal"))
- .asVariableLiteral()
- .orElseThrow(() -> new RuntimeException("Second argument should be a Variable literal"));
- final TypeDefinition typeDefinition = getTypeDefinitions().get(typeLiteral.getName());
- TypeReference type = typeDefinition.getTypeReference();
- StringBuilder sb = new StringBuilder();
- if (type instanceof ComplexTypeReference) {
- sb.append("Cast");
- }
- sb.append(typeLiteral.getName());
- sb.append("(").append(toVariableExpression(typeReference, firstArgument, parserArguments, serializerArguments, serialize, suppressPointerAccess)).append(")");
- return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + StringUtils.capitalize(toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))).orElse("");
+ return toCastVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
} else if ("STATIC_CALL".equals(variableLiteral.getName())) {
- tracer = tracer.dive("STATIC_CALL");
- StringBuilder sb = new StringBuilder();
- List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
- if (arguments.size() < 1) {
- throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
- }
- // Get the class and method name
- String staticCall = arguments.get(0).asLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
- .asStringLiteral()
- .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
- getValue();
- // Cut off the double-quotes
- staticCall = staticCall.substring(1, staticCall.length() - 1);
- // Remove all the previous parts prior to the Class name (Which starts with an uppercase letter)
- while (staticCall.contains(".") && !StringUtils.isAllUpperCase(staticCall.substring(0, 1))) {
- staticCall = staticCall.substring(staticCall.indexOf(".") + 1);
- }
- String className = staticCall.substring(0, staticCall.indexOf("."));
- String methodName = staticCall.substring(staticCall.indexOf(".") + 1);
- sb.append(className).append(StringUtils.capitalize(methodName)).append("(");
- for (int i = 1; i < arguments.size(); i++) {
- Term arg = arguments.get(i);
- if (i > 1) {
- sb.append(", ");
- }
- if (arg instanceof VariableLiteral) {
- VariableLiteral va = (VariableLiteral) arg;
- // "io" is the default name of the reader argument which is always available.
- boolean isParserArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || ((thisType instanceof DataIoTypeDefinition) && "_value".equals(va.getName()));
- boolean isTypeArg = "_type".equals(va.getName());
- if (!isParserArg && !isTypeArg && parserArguments != null) {
- for (Argument parserArgument : parserArguments) {
- if (parserArgument.getName().equals(va.getName())) {
- isParserArg = true;
- break;
- }
- }
- }
- if (isParserArg) {
- if (va.getName().equals("_value")) {
- sb.append(va.getName().substring(1)).append(va.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""));
- } else {
- sb.append(va.getName()).append((va.getChild().isPresent()) ?
- "." + toVariableExpression(typeReference, variableLiteral.getChild().get(), parserArguments, serializerArguments, false, suppressPointerAccess) : "");
- }
- }
- // We have to manually evaluate the type information at code-generation time.
- else if (isTypeArg) {
- String part = va.getChild().map(VariableLiteral::getName).orElse("");
- switch (part) {
- case "name":
-// sb.append("\"").append(field.getTypeName()).append("\"");
- break;
- case "length":
- sb.append("\"").append(((SimpleTypeReference) typeReference).getSizeInBits()).append("\"");
- break;
- case "encoding":
- String encoding = ((StringTypeReference) typeReference).getEncoding();
- // Cut off the single quotes.
- encoding = encoding.substring(1, encoding.length() - 1);
- sb.append("\"").append(encoding).append("\"");
- break;
- }
- } else {
- sb.append(toVariableExpression(typeReference, va, parserArguments, serializerArguments, serialize, suppressPointerAccess));
- }
- } else if (arg instanceof StringLiteral) {
- sb.append(((StringLiteral) arg).getValue());
- }
- }
- sb.append(")");
- return tracer + sb.toString();
+ return toStaticCallVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
} else if ("COUNT".equals(variableLiteral.getName())) {
- tracer = tracer.dive("count");
- VariableLiteral countLiteral = variableLiteral.getArgs()
- .orElseThrow(() -> new RuntimeException("Count needs at least one arg"))
- .get(0)
- .asLiteral()
- .orElseThrow(() -> new RuntimeException("Count needs a literal"))
- .asVariableLiteral()
- .orElseThrow(() -> new RuntimeException("Count needs a variable literal"));
- return tracer + (typeReference instanceof SimpleTypeReference ? getCastExpressionForTypeReference(typeReference) : "") + "(len(" +
- toVariableExpression(typeReference, countLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess) +
- "))";
+ return toCoundVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
} else if ("ARRAY_SIZE_IN_BYTES".equals(variableLiteral.getName())) {
- tracer = tracer.dive("array size in bytes");
- VariableLiteral va = variableLiteral.getArgs()
- .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs at least one arg"))
- .get(0)
- .asLiteral()
- .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs a literal"))
- .asVariableLiteral()
- .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs a variable literal"));
- // "io" and "m" are always available in every parser.
- boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || "m".equals(va.getName()) || "element".equals(va.getName());
- if (!isSerializerArg && serializerArguments != null) {
- for (Argument serializerArgument : serializerArguments) {
- if (serializerArgument.getName().equals(va.getName())) {
- isSerializerArg = true;
- break;
- }
- }
- }
- StringBuilder sb = new StringBuilder();
- if (isSerializerArg) {
- sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, true, suppressPointerAccess)).orElse(""));
- } else {
- sb.append(toVariableExpression(typeReference, va, parserArguments, serializerArguments, true, suppressPointerAccess));
- }
- return tracer + getCastExpressionForTypeReference(typeReference) + "(" + va.getName() + "ArraySizeInBytes(" + sb.toString() + "))";
+ return toArraySizeInBytesVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer);
} else if ("CEIL".equals(variableLiteral.getName())) {
- tracer = tracer.dive("ceil");
- Term va = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("CEIL needs at least one arg")).get(0);
- // The Ceil function expects 64 bit floating point values.
- TypeReference tr = new DefaultFloatTypeReference(SimpleTypeReference.SimpleBaseType.FLOAT, 11, 52);
- emitRequiredImport("math");
- return tracer + "math.Ceil(" + toExpression(tr, va, parserArguments, serializerArguments, serialize, suppressPointerAccess) + ")";
+ return toCeilVariableExpression(variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
}
// All uppercase names are not fields, but utility methods.
else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) {
- tracer = tracer.dive("utility medhods");
- StringBuilder sb = new StringBuilder(variableLiteral.getName());
- if (variableLiteral.getArgs().isPresent()) {
- sb.append("(");
- boolean firstArg = true;
- for (Term arg : variableLiteral.getArgs().get()) {
- if (!firstArg) {
- sb.append(", ");
- }
- sb.append(toExpression(typeReference, arg, parserArguments, serializerArguments, serialize, suppressPointerAccess));
- firstArg = false;
- }
- sb.append(")");
- }
- if (variableLiteral.getIndex() != VariableLiteral.NO_INDEX) {
- sb.append("[").append(variableLiteral.getIndex()).append("]");
- }
- return tracer + sb.toString() + variableLiteral.getChild()
- .map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))
- .orElse("");
+ return toUppercaseVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer);
}
// If the current property references a discriminator value, we have to serialize it differently.
@@ -842,6 +665,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
"." + StringUtils.capitalize(variableLiteral.getChild().orElseThrow(() -> new RuntimeException("enum needs a child")).getName()) + "()";
}
}
+ // TODO: is this really meant to fall through?
} else if (isVariableLiteralImplicitField(variableLiteral)) {
tracer = tracer.dive("implicit");
if (serialize) {
@@ -873,6 +697,223 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
.orElse("");
}
+ private String toUppercaseVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("utility medhods");
+ StringBuilder sb = new StringBuilder(variableLiteral.getName());
+ if (variableLiteral.getArgs().isPresent()) {
+ sb.append("(");
+ boolean firstArg = true;
+ for (Term arg : variableLiteral.getArgs().get()) {
+ if (!firstArg) {
+ sb.append(", ");
+ }
+ sb.append(toExpression(typeReference, arg, parserArguments, serializerArguments, serialize, suppressPointerAccess));
+ firstArg = false;
+ }
+ sb.append(")");
+ }
+ if (variableLiteral.getIndex() != VariableLiteral.NO_INDEX) {
+ sb.append("[").append(variableLiteral.getIndex()).append("]");
+ }
+ return tracer + sb.toString() + variableLiteral.getChild()
+ .map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))
+ .orElse("");
+ }
+
+ private String toCeilVariableExpression(VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("ceil");
+ Term va = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("CEIL needs at least one arg")).get(0);
+ // The Ceil function expects 64 bit floating point values.
+ TypeReference tr = new DefaultFloatTypeReference(SimpleTypeReference.SimpleBaseType.FLOAT, 11, 52);
+ emitRequiredImport("math");
+ return tracer + "math.Ceil(" + toExpression(tr, va, parserArguments, serializerArguments, serialize, suppressPointerAccess) + ")";
+ }
+
+ private String toArraySizeInBytesVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("array size in bytes");
+ VariableLiteral va = variableLiteral.getArgs()
+ .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs at least one arg"))
+ .get(0)
+ .asLiteral()
+ .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs a literal"))
+ .asVariableLiteral()
+ .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs a variable literal"));
+ // "io" and "m" are always available in every parser.
+ boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || "m".equals(va.getName()) || "element".equals(va.getName());
+ if (!isSerializerArg && serializerArguments != null) {
+ for (Argument serializerArgument : serializerArguments) {
+ if (serializerArgument.getName().equals(va.getName())) {
+ isSerializerArg = true;
+ break;
+ }
+ }
+ }
+ StringBuilder sb = new StringBuilder();
+ if (isSerializerArg) {
+ sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, true, suppressPointerAccess)).orElse(""));
+ } else {
+ sb.append(toVariableExpression(typeReference, va, parserArguments, serializerArguments, true, suppressPointerAccess));
+ }
+ return tracer + getCastExpressionForTypeReference(typeReference) + "(" + va.getName() + "ArraySizeInBytes(" + sb.toString() + "))";
+ }
+
+ private String toCoundVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("count");
+ VariableLiteral countLiteral = variableLiteral.getArgs()
+ .orElseThrow(() -> new RuntimeException("Count needs at least one arg"))
+ .get(0)
+ .asLiteral()
+ .orElseThrow(() -> new RuntimeException("Count needs a literal"))
+ .asVariableLiteral()
+ .orElseThrow(() -> new RuntimeException("Count needs a variable literal"));
+ return tracer + (typeReference instanceof SimpleTypeReference ? getCastExpressionForTypeReference(typeReference) : "") + "(len(" +
+ toVariableExpression(typeReference, countLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess) +
+ "))";
+ }
+
+ private String toStaticCallVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("STATIC_CALL");
+ StringBuilder sb = new StringBuilder();
+ List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
+ if (arguments.size() < 1) {
+ throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
+ }
+ // Get the class and method name
+ String staticCall = arguments.get(0).asLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
+ .asStringLiteral()
+ .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
+ getValue();
+ // Cut off the double-quotes
+ staticCall = staticCall.substring(1, staticCall.length() - 1);
+ // Remove all the previous parts prior to the Class name (Which starts with an uppercase letter)
+ while (staticCall.contains(".") && !StringUtils.isAllUpperCase(staticCall.substring(0, 1))) {
+ staticCall = staticCall.substring(staticCall.indexOf(".") + 1);
+ }
+ String className = staticCall.substring(0, staticCall.indexOf("."));
+ String methodName = staticCall.substring(staticCall.indexOf(".") + 1);
+ sb.append(className).append(StringUtils.capitalize(methodName)).append("(");
+ for (int i = 1; i < arguments.size(); i++) {
+ Term arg = arguments.get(i);
+ if (i > 1) {
+ sb.append(", ");
+ }
+ if (arg instanceof VariableLiteral) {
+ VariableLiteral va = (VariableLiteral) arg;
+ // "io" is the default name of the reader argument which is always available.
+ boolean isParserArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || ((thisType instanceof DataIoTypeDefinition) && "_value".equals(va.getName()));
+ boolean isTypeArg = "_type".equals(va.getName());
+ if (!isParserArg && !isTypeArg && parserArguments != null) {
+ for (Argument parserArgument : parserArguments) {
+ if (parserArgument.getName().equals(va.getName())) {
+ isParserArg = true;
+ break;
+ }
+ }
+ }
+ if (isParserArg) {
+ if (va.getName().equals("_value")) {
+ sb.append(va.getName().substring(1)).append(va.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""));
+ } else {
+ sb.append(va.getName()).append((va.getChild().isPresent()) ?
+ "." + toVariableExpression(typeReference, variableLiteral.getChild().get(), parserArguments, serializerArguments, false, suppressPointerAccess) : "");
+ }
+ }
+ // We have to manually evaluate the type information at code-generation time.
+ else if (isTypeArg) {
+ String part = va.getChild().map(VariableLiteral::getName).orElse("");
+ switch (part) {
+ case "name":
+// sb.append("\"").append(field.getTypeName()).append("\"");
+ break;
+ case "length":
+ sb.append("\"").append(((SimpleTypeReference) typeReference).getSizeInBits()).append("\"");
+ break;
+ case "encoding":
+ String encoding = ((StringTypeReference) typeReference).getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ sb.append("\"").append(encoding).append("\"");
+ break;
+ }
+ } else {
+ sb.append(toVariableExpression(typeReference, va, parserArguments, serializerArguments, serialize, suppressPointerAccess));
+ }
+ } else if (arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
+ }
+ }
+ sb.append(")");
+ return tracer + sb.toString();
+ }
+
+ private String toCastVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("CAST");
+ List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A Cast expression needs arguments"));
+ if (arguments.size() != 2) {
+ throw new RuntimeException("A CAST expression expects exactly two arguments.");
+ }
+ VariableLiteral firstArgument = arguments.get(0).asLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
+ .asVariableLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a Variable literal"));
+ VariableLiteral typeLiteral = arguments.get(1).asLiteral()
+ .orElseThrow(() -> new RuntimeException("Second argument should be a literal"))
+ .asVariableLiteral()
+ .orElseThrow(() -> new RuntimeException("Second argument should be a Variable literal"));
+ final TypeDefinition typeDefinition = getTypeDefinitions().get(typeLiteral.getName());
+ TypeReference type = typeDefinition.getTypeReference();
+ StringBuilder sb = new StringBuilder();
+ if (type instanceof ComplexTypeReference) {
+ sb.append("Cast");
+ }
+ sb.append(typeLiteral.getName());
+ sb.append("(").append(toVariableExpression(typeReference, firstArgument, parserArguments, serializerArguments, serialize, suppressPointerAccess)).append(")");
+ return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + StringUtils.capitalize(toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))).orElse("");
+ }
+
+ private String toOptionalVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("optional fields");
+ return tracer + "(" + (suppressPointerAccess ? "" : "*") + variableLiteral.getName() + ")" +
+ variableLiteral.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("");
+ }
+
+ private String toConstantVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("enum constant");
+ VariableLiteral child = variableLiteral.getChild().get();
+ return tracer + variableLiteral.getName() + "." + StringUtils.capitalize(child.getName()) + "()" +
+ child.getChild().map(childChild -> "." + toVariableExpression(typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("");
+ }
+
+ private String toEnumVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) {
+ tracer = tracer.dive("enum");
+ VariableLiteral child = variableLiteral.getChild().orElseThrow(() -> new RuntimeException("Enum should have a child"));
+ return tracer + variableLiteral.getName() + "_" + child.getName() +
+ child.getChild().map(childChild -> "." + toVariableExpression(typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("");
+ }
+
+ private String toLengthVariableExpression(VariableLiteral variableLiteral, boolean serialize, Tracer tracer) {
+ tracer = tracer.dive("length");
+ return tracer + (serialize ? ("len(m." + StringUtils.capitalize(variableLiteral.getName()) + ")") : ("(" + variableLiteral.getName() + ")"));
+ }
+
+ private String toValueVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
+ final Tracer tracer2 = tracer.dive("_value");
+ return variableLiteral.getChild()
+ .map(child -> tracer2.dive("withChild") + toVariableExpression(typeReference, child, parserArguments, serializerArguments, serialize, suppressPointerAccess))
+ .orElse(tracer2 + "m");
+ }
+
+ private String toLengthInBitsVariableExpression(TypeReference typeReference, boolean serialize, Tracer tracer) {
+ tracer = tracer.dive("lengthInBits");
+ return tracer + (serialize ? getCastExpressionForTypeReference(typeReference) + "(m." : "") + "LengthInBits()" + (serialize ? ")" : "");
+ }
+
+ private String toLengthInBytesVariableExpression(TypeReference typeReference, boolean serialize, Tracer tracer) {
+ tracer = tracer.dive("lengthInBytes");
+ return tracer + (serialize ? getCastExpressionForTypeReference(typeReference) + "(m." : "") + "LengthInBytes()" + (serialize ? ")" : "");
+ }
+
public String getSizeInBits(ComplexTypeDefinition complexTypeDefinition, List<Argument> parserArguments) {
int sizeInBits = 0;
StringBuilder sb = new StringBuilder();
diff --git a/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java b/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
index 754f2dc..96b990d 100644
--- a/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
+++ b/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
@@ -28,7 +28,6 @@ import java.util.List;
import java.util.Optional;
import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.commons.text.WordUtils;
import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.BaseFreemarkerLanguageTemplateHelper;
@@ -41,7 +40,6 @@ import org.apache.plc4x.plugins.codegenerator.types.terms.*;
import java.util.Map;
import java.util.function.Function;
-import java.util.function.Supplier;
@SuppressWarnings({"unused", "WeakerAccess"})
public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelper {
@@ -105,29 +103,26 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
if (typeReference instanceof SimpleTypeReference) {
SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return allowPrimitive ? boolean.class.getSimpleName() : Boolean.class.getSimpleName();
- }
- case BYTE: {
+ case BYTE:
return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 4) {
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 4) {
return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
}
- if (integerTypeReference.getSizeInBits() <= 8) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
return allowPrimitive ? short.class.getSimpleName() : Short.class.getSimpleName();
}
- if (integerTypeReference.getSizeInBits() <= 16) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
return allowPrimitive ? int.class.getSimpleName() : Integer.class.getSimpleName();
}
- if (integerTypeReference.getSizeInBits() <= 32) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
return allowPrimitive ? long.class.getSimpleName() : Long.class.getSimpleName();
}
return BigInteger.class.getSimpleName();
- }
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
@@ -142,9 +137,8 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
return allowPrimitive ? long.class.getSimpleName() : Long.class.getSimpleName();
}
return BigInteger.class.getSimpleName();
- }
case FLOAT:
- case UFLOAT: {
+ case UFLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
int sizeInBits = ((floatTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.FLOAT) ? 1 : 0) +
floatTypeReference.getExponent() + floatTypeReference.getMantissa();
@@ -155,19 +149,15 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
return allowPrimitive ? double.class.getSimpleName() : Double.class.getSimpleName();
}
return BigDecimal.class.getSimpleName();
- }
- case STRING: {
+ case STRING:
return String.class.getSimpleName();
- }
- case TIME: {
+ case TIME:
return LocalTime.class.getSimpleName();
- }
- case DATE: {
+ case DATE:
return LocalDate.class.getSimpleName();
- }
- case DATETIME: {
+ case DATETIME:
return LocalDateTime.class.getSimpleName();
- }
+
}
throw new RuntimeException("Unsupported simple type");
} else {
@@ -179,28 +169,25 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
if (typeReference instanceof SimpleTypeReference) {
SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "PlcBOOL";
- }
- case BYTE: {
+ case BYTE:
return "PlcSINT";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 4) {
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 4) {
return "PlcUSINT";
}
- if (integerTypeReference.getSizeInBits() <= 8) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
return "PlcUINT";
}
- if (integerTypeReference.getSizeInBits() <= 16) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
return "PlcUDINT";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
return "PlcULINT";
}
- }
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return "PlcSINT";
@@ -214,9 +201,9 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
if (integerTypeReference.getSizeInBits() <= 64) {
return "PlcLINT";
}
- }
+
case FLOAT:
- case UFLOAT: {
+ case UFLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
int sizeInBits = ((floatTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.FLOAT) ? 1 : 0) +
floatTypeReference.getExponent() + floatTypeReference.getMantissa();
@@ -226,19 +213,12 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
if (sizeInBits <= 64) {
return "PlcLREAL";
}
- }
- case STRING: {
+ case STRING:
return "PlcSTRING";
- }
- case TIME: {
+ case TIME:
+ case DATE:
+ case DATETIME:
return "PlcTIME";
- }
- case DATE: {
- return "PlcTIME";
- }
- case DATETIME: {
- return "PlcTIME";
- }
}
throw new RuntimeException("Unsupported simple type");
} else {
@@ -251,23 +231,20 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
if (typeReference instanceof SimpleTypeReference) {
SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "false";
- }
- case BYTE: {
+ case BYTE:
return "0";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 16) {
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
return "0";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
return "0l";
}
return "null";
- }
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 32) {
return "0";
@@ -276,8 +253,7 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
return "0l";
}
return "null";
- }
- case FLOAT: {
+ case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
int sizeInBits = ((floatTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.FLOAT) ? 1 : 0) +
floatTypeReference.getExponent() + floatTypeReference.getMantissa();
@@ -288,12 +264,10 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
return "0.0";
}
return "null";
- }
- case STRING: {
+ case STRING:
return "null";
- }
}
- return "Hurz";
+ throw new FreemarkerException("Unmapped basetype" + simpleTypeReference.getBaseType());
} else {
return "null";
}
@@ -316,28 +290,22 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
public int getNumBits(SimpleTypeReference simpleTypeReference) {
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return 1;
- }
- case BYTE: {
+ case BYTE:
return 8;
- }
case UINT:
- case INT: {
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
return integerTypeReference.getSizeInBits();
- }
- case FLOAT: {
+ case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
return floatTypeReference.getSizeInBits();
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
return stringTypeReference.getSizeInBits();
- }
- default: {
+ default:
return 0;
- }
}
}
@@ -348,30 +316,27 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, String valueString, TypedField field) {
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "readBuffer.readBit(\"" + logicalName + "\")";
- }
- case BYTE: {
+ case BYTE:
ByteTypeReference byteTypeReference = (ByteTypeReference) simpleTypeReference;
return "readBuffer.readByte(\"" + logicalName + "\")";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 4) {
- return "readBuffer.readUnsignedByte(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 4) {
+ return "readBuffer.readUnsignedByte(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- if (integerTypeReference.getSizeInBits() <= 8) {
- return "readBuffer.readUnsignedShort(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
+ return "readBuffer.readUnsignedShort(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- if (integerTypeReference.getSizeInBits() <= 16) {
- return "readBuffer.readUnsignedInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
+ return "readBuffer.readUnsignedInt(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
- return "readBuffer.readUnsignedLong(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
+ return "readBuffer.readUnsignedLong(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
}
- return "readBuffer.readUnsignedBigInteger(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
- }
- case INT: {
+ return "readBuffer.readUnsignedBigInteger(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ")";
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return "readBuffer.readSignedByte(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
@@ -386,8 +351,7 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
return "readBuffer.readLong(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ")";
}
return "readBuffer.readBigInteger(" + integerTypeReference.getSizeInBits() + ")";
- }
- case FLOAT: {
+ case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
String type = (floatTypeReference.getSizeInBits() <= 32) ? "Float" : "Double";
String typeCast = (floatTypeReference.getSizeInBits() <= 32) ? "float" : "double";
@@ -398,14 +362,12 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
", " + floatTypeReference.getExponent() + ", " +
floatTypeReference.getMantissa() + ");" +
"\n })).get()";
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
return "readBuffer.readString(\"" + logicalName + "\", " + toParseExpression(field, stringTypeReference.getLengthExpression(), null) + ", \"" +
stringTypeReference.getEncoding() + "\")";
- }
}
- return "Hurz";
+ return "";
}
@Override
@@ -419,30 +381,27 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
writerArgsString += ", " + StringUtils.join(writerArgs, ", ");
}
switch (simpleTypeReference.getBaseType()) {
- case BIT: {
+ case BIT:
return "writeBuffer.writeBit(\"" + logicalName + "\", (boolean) " + fieldName + "" + writerArgsString + ")";
- }
- case BYTE: {
+ case BYTE:
ByteTypeReference byteTypeReference = (ByteTypeReference) simpleTypeReference;
return "writeBuffer.writeByte(\"" + logicalName + "\", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
- }
- case UINT: {
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 4) {
- return "writeBuffer.writeUnsignedByte(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
+ case UINT:
+ IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 4) {
+ return "writeBuffer.writeUnsignedByte(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
}
- if (integerTypeReference.getSizeInBits() <= 8) {
- return "writeBuffer.writeUnsignedShort(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").shortValue()" + writerArgsString + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
+ return "writeBuffer.writeUnsignedShort(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").shortValue()" + writerArgsString + ")";
}
- if (integerTypeReference.getSizeInBits() <= 16) {
- return "writeBuffer.writeUnsignedInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").intValue()" + writerArgsString + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
+ return "writeBuffer.writeUnsignedInt(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").intValue()" + writerArgsString + ")";
}
- if (integerTypeReference.getSizeInBits() <= 32) {
- return "writeBuffer.writeUnsignedLong(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").longValue()" + writerArgsString + ")";
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
+ return "writeBuffer.writeUnsignedLong(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").longValue()" + writerArgsString + ")";
}
- return "writeBuffer.writeUnsignedBigInteger(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", (BigInteger) " + fieldName + "" + writerArgsString + ")";
- }
- case INT: {
+ return "writeBuffer.writeUnsignedBigInteger(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", (BigInteger) " + fieldName + "" + writerArgsString + ")";
+ case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
return "writeBuffer.writeSignedByte(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
@@ -457,9 +416,8 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
return "writeBuffer.writeLong(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").longValue()" + writerArgsString + ")";
}
return "writeBuffer.writeBigInteger(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", BigInteger.valueOf( " + fieldName + ")" + writerArgsString + ")";
- }
case FLOAT:
- case UFLOAT: {
+ case UFLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
if (floatTypeReference.getSizeInBits() <= 32) {
return "writeBuffer.writeFloat(\"" + logicalName + "\", " + fieldName + "," + floatTypeReference.getExponent() + "," + floatTypeReference.getMantissa() + "" + writerArgsString + ")";
@@ -468,14 +426,12 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
} else {
throw new RuntimeException("Unsupported float type");
}
- }
- case STRING: {
+ case STRING:
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
return "writeBuffer.writeString(\"" + logicalName + "\", " + toSerializationExpression(field, stringTypeReference.getLengthExpression(), thisType.getParserArguments().orElse(Collections.emptyList())) + ", \"" +
stringTypeReference.getEncoding() + "\", (String) " + fieldName + "" + writerArgsString + ")";
- }
}
- return "Hurz";
+ throw new FreemarkerException("Unmapped basetype" + simpleTypeReference.getBaseType());
}
/*public String getReadMethodName(SimpleTypeReference simpleTypeReference) {
@@ -566,82 +522,94 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
private String toExpression(TypedField field, Term term, Function<VariableLiteral, String> variableExpressionGenerator) {
Tracer tracer = Tracer.start("toExpression");
if (term == null) {
- return "";
+ return tracer + "";
}
if (term instanceof Literal) {
- tracer = tracer.dive("literal term instanceOf");
- Literal literal = (Literal) term;
- if (literal instanceof NullLiteral) {
- tracer = tracer.dive("null literal instanceOf");
- return tracer + "null";
- } else if (literal instanceof BooleanLiteral) {
- tracer = tracer.dive("boolean literal instanceOf");
- return tracer + Boolean.toString(((BooleanLiteral) literal).getValue());
- } else if (literal instanceof NumericLiteral) {
- tracer = tracer.dive("numeric literal instanceOf");
- return tracer + ((NumericLiteral) literal).getNumber().toString();
- } else if (literal instanceof StringLiteral) {
- tracer = tracer.dive("string literal instanceOf");
- return tracer + "\"" + ((StringLiteral) literal).getValue() + "\"";
- } else if (literal instanceof VariableLiteral) {
- tracer = tracer.dive("variable literal instanceOf");
- VariableLiteral variableLiteral = (VariableLiteral) literal;
- // If this literal references an Enum type, then we have to output it differently.
- if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
- tracer = tracer.dive("enum definition instanceOf");
- VariableLiteral enumDefinitionChild = variableLiteral.getChild()
- .orElseThrow(() -> new RuntimeException("enum definitions should have childs"));
- return tracer + variableLiteral.getName() + "." + enumDefinitionChild.getName() +
- enumDefinitionChild.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
- } else {
- return tracer + variableExpressionGenerator.apply(variableLiteral);
- }
- } else {
- throw new RuntimeException("Unsupported Literal type " + literal.getClass().getName());
- }
+ return toLiteralTermExpression((Literal) term, variableExpressionGenerator, tracer);
} else if (term instanceof UnaryTerm) {
- tracer = tracer.dive("unary term instanceOf");
- UnaryTerm ut = (UnaryTerm) term;
- Term a = ut.getA();
- switch (ut.getOperation()) {
- case "!":
- tracer = tracer.dive("case !");
- return tracer + "!(" + toExpression(field, a, variableExpressionGenerator) + ")";
- case "-":
- tracer = tracer.dive("case -");
- return tracer + "-(" + toExpression(field, a, variableExpressionGenerator) + ")";
- case "()":
- tracer = tracer.dive("case ()");
- return tracer + "(" + toExpression(field, a, variableExpressionGenerator) + ")";
- default:
- throw new RuntimeException("Unsupported unary operation type " + ut.getOperation());
- }
+ return toUnaryTermExpression(field, (UnaryTerm) term, variableExpressionGenerator, tracer);
} else if (term instanceof BinaryTerm) {
- tracer = tracer.dive("binary term instanceOf");
- BinaryTerm bt = (BinaryTerm) term;
- Term a = bt.getA();
- Term b = bt.getB();
- String operation = bt.getOperation();
- switch (operation) {
- case "^":
- tracer = tracer.dive("^");
- return tracer + "Math.pow((" + toExpression(field, a, variableExpressionGenerator) + "), (" + toExpression(field, b, variableExpressionGenerator) + "))";
- default:
- return tracer + "(" + toExpression(field, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, b, variableExpressionGenerator) + ")";
- }
+ return toBinaryTermExpression(field, (BinaryTerm) term, variableExpressionGenerator, tracer);
} else if (term instanceof TernaryTerm) {
- tracer = tracer.dive("ternary term instanceOf");
- TernaryTerm tt = (TernaryTerm) term;
- if ("if".equals(tt.getOperation())) {
- Term a = tt.getA();
- Term b = tt.getB();
- Term c = tt.getC();
- return tracer + "((" + toExpression(field, a, variableExpressionGenerator) + ") ? " + toExpression(field, b, variableExpressionGenerator) + " : " + toExpression(field, c, variableExpressionGenerator) + ")";
+ return toTernaryTermExpression(field, (TernaryTerm) term, variableExpressionGenerator, tracer);
+ } else {
+ throw new RuntimeException("Unsupported Term type " + term.getClass().getName());
+ }
+ }
+
+ private String toLiteralTermExpression(Literal literal, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("literal term instanceOf");
+ if (literal instanceof NullLiteral) {
+ tracer = tracer.dive("null literal instanceOf");
+ return tracer + "null";
+ } else if (literal instanceof BooleanLiteral) {
+ tracer = tracer.dive("boolean literal instanceOf");
+ return tracer + Boolean.toString(((BooleanLiteral) literal).getValue());
+ } else if (literal instanceof NumericLiteral) {
+ tracer = tracer.dive("numeric literal instanceOf");
+ return tracer + ((NumericLiteral) literal).getNumber().toString();
+ } else if (literal instanceof StringLiteral) {
+ tracer = tracer.dive("string literal instanceOf");
+ return tracer + "\"" + ((StringLiteral) literal).getValue() + "\"";
+ } else if (literal instanceof VariableLiteral) {
+ tracer = tracer.dive("variable literal instanceOf");
+ VariableLiteral variableLiteral = (VariableLiteral) literal;
+ // If this literal references an Enum type, then we have to output it differently.
+ if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
+ tracer = tracer.dive("enum definition instanceOf");
+ VariableLiteral enumDefinitionChild = variableLiteral.getChild()
+ .orElseThrow(() -> new RuntimeException("enum definitions should have childs"));
+ return tracer + variableLiteral.getName() + "." + enumDefinitionChild.getName() +
+ enumDefinitionChild.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
} else {
- throw new RuntimeException("Unsupported ternary operation type " + tt.getOperation());
+ return tracer + variableExpressionGenerator.apply(variableLiteral);
}
} else {
- throw new RuntimeException("Unsupported Term type " + term.getClass().getName());
+ throw new RuntimeException("Unsupported Literal type " + literal.getClass().getName());
+ }
+ }
+
+ private String toUnaryTermExpression(TypedField field, UnaryTerm unaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("unary term instanceOf");
+ Term a = unaryTerm.getA();
+ switch (unaryTerm.getOperation()) {
+ case "!":
+ tracer = tracer.dive("case !");
+ return tracer + "!(" + toExpression(field, a, variableExpressionGenerator) + ")";
+ case "-":
+ tracer = tracer.dive("case -");
+ return tracer + "-(" + toExpression(field, a, variableExpressionGenerator) + ")";
+ case "()":
+ tracer = tracer.dive("case ()");
+ return tracer + "(" + toExpression(field, a, variableExpressionGenerator) + ")";
+ default:
+ throw new RuntimeException("Unsupported unary operation type " + unaryTerm.getOperation());
+ }
+ }
+
+ private String toBinaryTermExpression(TypedField field, BinaryTerm binaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("binary term instanceOf");
+ Term a = binaryTerm.getA();
+ Term b = binaryTerm.getB();
+ String operation = binaryTerm.getOperation();
+ switch (operation) {
+ case "^":
+ tracer = tracer.dive("^");
+ return tracer + "Math.pow((" + toExpression(field, a, variableExpressionGenerator) + "), (" + toExpression(field, b, variableExpressionGenerator) + "))";
+ default:
+ return tracer + "(" + toExpression(field, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, b, variableExpressionGenerator) + ")";
+ }
+ }
+
+ private String toTernaryTermExpression(TypedField field, TernaryTerm ternaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
+ tracer = tracer.dive("ternary term instanceOf");
+ if ("if".equals(ternaryTerm.getOperation())) {
+ Term a = ternaryTerm.getA();
+ Term b = ternaryTerm.getB();
+ Term c = ternaryTerm.getC();
+ return tracer + "((" + toExpression(field, a, variableExpressionGenerator) + ") ? " + toExpression(field, b, variableExpressionGenerator) + " : " + toExpression(field, c, variableExpressionGenerator) + ")";
+ } else {
+ throw new RuntimeException("Unsupported ternary operation type " + ternaryTerm.getOperation());
}
}
@@ -653,137 +621,191 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
Tracer tracer = Tracer.start("toVariableParseExpression");
// CAST expressions are special as we need to add a ".class" to the second parameter in Java.
if ("CAST".equals(variableLiteral.getName())) {
- tracer = tracer.dive("CAST");
- StringBuilder sb = new StringBuilder(variableLiteral.getName());
- List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A Cast expression needs arguments"));
- if (arguments.size() != 2) {
- throw new RuntimeException("A CAST expression expects exactly two arguments.");
- }
- VariableLiteral firstArgument = arguments.get(0).asLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
- .asVariableLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a Variable literal"));
- VariableLiteral secondArgument = arguments.get(1).asLiteral().orElseThrow(() -> new RuntimeException("Second argument should be a literal"))
- .asVariableLiteral()
- .orElseThrow(() -> new RuntimeException("Second argument should be a Variable literal"));
- sb.append("(")
- .append(toVariableParseExpression(field, firstArgument, parserArguments))
- .append(", ")
- .append(secondArgument.getName()).append(".class)");
- return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
+ return toCastVariableParseExpression(field, variableLiteral, parserArguments, tracer);
} else if ("STATIC_CALL".equals(variableLiteral.getName())) {
- tracer = tracer.dive("STATIC_CALL");
- StringBuilder sb = new StringBuilder();
- List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
- if (arguments.size() < 1) {
- throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
- }
- // Get the class and method name
- String methodName = arguments.get(0).asLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
- .asStringLiteral()
- .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
- getValue();
- // Cut off the double-quotes
- methodName = methodName.substring(1, methodName.length() - 1);
- sb.append(methodName).append("(");
- for (int i = 1; i < arguments.size(); i++) {
- Term arg = arguments.get(i);
- if (i > 1) {
+ return toStaticCallVariableParseExpression(field, variableLiteral, parserArguments, tracer);
+ } else if (isVariableLiteralImplicitField(variableLiteral)) { // If we are accessing implicit fields, we need to rely on a local variable instead.
+ return toImplictVariableParseExpression(variableLiteral, tracer);
+ } else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) { // All uppercase names are not fields, but utility methods.
+ return toUpperCaseVariableParseExpression(field, variableLiteral, parserArguments, tracer);
+ }
+ return tracer + variableLiteral.getName() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
+ }
+
+ private String toUpperCaseVariableParseExpression(TypedField field, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
+ tracer = tracer.dive("UPPERCASE");
+ StringBuilder sb = new StringBuilder(variableLiteral.getName());
+ if (variableLiteral.getArgs().isPresent()) {
+ sb.append("(");
+ boolean firstArg = true;
+ for (Term arg : variableLiteral.getArgs().get()) {
+ if (!firstArg) {
sb.append(", ");
}
- if (arg instanceof VariableLiteral) {
- VariableLiteral variableLiteralArg = (VariableLiteral) arg;
- // "readBuffer" is the default name of the reader argument which is always available.
- boolean isParserArg = "readBuffer".equals(variableLiteralArg.getName());
- boolean isTypeArg = "_type".equals(variableLiteralArg.getName());
- if (!isParserArg && !isTypeArg && parserArguments != null) {
- for (Argument parserArgument : parserArguments) {
- if (parserArgument.getName().equals(variableLiteralArg.getName())) {
- isParserArg = true;
- break;
- }
+ sb.append(toParseExpression(field, arg, parserArguments));
+ firstArg = false;
+ }
+ sb.append(")");
+ }
+ if (variableLiteral.getIndex() != VariableLiteral.NO_INDEX) {
+ sb.append("[").append(variableLiteral.getIndex()).append("]");
+ }
+ return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
+ }
+
+ private String toImplictVariableParseExpression(VariableLiteral variableLiteral, Tracer tracer) {
+ tracer = tracer.dive("implicit");
+ return tracer + variableLiteral.getName();
+ }
+
+ private String toStaticCallVariableParseExpression(TypedField field, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
+ tracer = tracer.dive("STATIC_CALL");
+ StringBuilder sb = new StringBuilder();
+ List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
+ if (arguments.size() < 1) {
+ throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
+ }
+ // Get the class and method name
+ String methodName = arguments.get(0).asLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
+ .asStringLiteral()
+ .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
+ getValue();
+ // Cut off the double-quotes
+ methodName = methodName.substring(1, methodName.length() - 1);
+ sb.append(methodName).append("(");
+ for (int i = 1; i < arguments.size(); i++) {
+ Term arg = arguments.get(i);
+ if (i > 1) {
+ sb.append(", ");
+ }
+ if (arg instanceof VariableLiteral) {
+ VariableLiteral variableLiteralArg = (VariableLiteral) arg;
+ // "readBuffer" is the default name of the reader argument which is always available.
+ boolean isParserArg = "readBuffer".equals(variableLiteralArg.getName());
+ boolean isTypeArg = "_type".equals(variableLiteralArg.getName());
+ if (!isParserArg && !isTypeArg && parserArguments != null) {
+ for (Argument parserArgument : parserArguments) {
+ if (parserArgument.getName().equals(variableLiteralArg.getName())) {
+ isParserArg = true;
+ break;
}
}
- if (isParserArg) {
- sb.append(variableLiteralArg.getName()).append(variableLiteralArg.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
- } else if (isTypeArg) {// We have to manually evaluate the type information at code-generation time.
- String part = variableLiteralArg.getChild().map(VariableLiteral::getName).orElse("");
- switch (part) {
- case "name":
- sb.append("\"").append(field.getTypeName()).append("\"");
- break;
- case "length":
- sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
- break;
- case "encoding":
- String encoding = ((StringTypeReference) field.getType()).getEncoding();
- // Cut off the single quotes.
- encoding = encoding.substring(1, encoding.length() - 1);
- sb.append("\"").append(encoding).append("\"");
- break;
- }
- } else {
- sb.append(toVariableParseExpression(field, variableLiteralArg, null));
+ }
+ if (isParserArg) {
+ sb.append(variableLiteralArg.getName()).append(variableLiteralArg.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
+ } else if (isTypeArg) {// We have to manually evaluate the type information at code-generation time.
+ String part = variableLiteralArg.getChild().map(VariableLiteral::getName).orElse("");
+ switch (part) {
+ case "name":
+ sb.append("\"").append(field.getTypeName()).append("\"");
+ break;
+ case "length":
+ sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
+ break;
+ case "encoding":
+ String encoding = ((StringTypeReference) field.getType()).getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ sb.append("\"").append(encoding).append("\"");
+ break;
}
- } else if (arg instanceof StringLiteral) {
- sb.append(((StringLiteral) arg).getValue());
+ } else {
+ sb.append(toVariableParseExpression(field, variableLiteralArg, null));
}
+ } else if (arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
}
- sb.append(")");
- return tracer + sb.toString();
- } else if (isVariableLiteralImplicitField(variableLiteral)) { // If we are accessing implicit fields, we need to rely on a local variable instead.
- tracer = tracer.dive("implicit");
- return tracer + variableLiteral.getName();
- } else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) { // All uppercase names are not fields, but utility methods.
- tracer = tracer.dive("UPPERCASE");
- StringBuilder sb = new StringBuilder(variableLiteral.getName());
- if (variableLiteral.getArgs().isPresent()) {
- sb.append("(");
- boolean firstArg = true;
- for (Term arg : variableLiteral.getArgs().get()) {
- if (!firstArg) {
- sb.append(", ");
- }
- sb.append(toParseExpression(field, arg, parserArguments));
- firstArg = false;
- }
- sb.append(")");
- }
- if (variableLiteral.getIndex() != VariableLiteral.NO_INDEX) {
- sb.append("[").append(variableLiteral.getIndex()).append("]");
- }
- return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
}
- return tracer + variableLiteral.getName() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
+ sb.append(")");
+ return tracer + sb.toString();
+ }
+
+ private String toCastVariableParseExpression(TypedField field, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
+ tracer = tracer.dive("CAST");
+ StringBuilder sb = new StringBuilder(variableLiteral.getName());
+ List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A Cast expression needs arguments"));
+ if (arguments.size() != 2) {
+ throw new RuntimeException("A CAST expression expects exactly two arguments.");
+ }
+ VariableLiteral firstArgument = arguments.get(0).asLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
+ .asVariableLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a Variable literal"));
+ VariableLiteral secondArgument = arguments.get(1).asLiteral().orElseThrow(() -> new RuntimeException("Second argument should be a literal"))
+ .asVariableLiteral()
+ .orElseThrow(() -> new RuntimeException("Second argument should be a Variable literal"));
+ sb.append("(")
+ .append(toVariableParseExpression(field, firstArgument, parserArguments))
+ .append(", ")
+ .append(secondArgument.getName()).append(".class)");
+ return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
}
private String toVariableSerializationExpression(TypedField field, VariableLiteral variableLiteral, List<Argument> serialzerArguments) {
Tracer tracer = Tracer.start("variable serialization expression");
if ("STATIC_CALL".equals(variableLiteral.getName())) {
- tracer = tracer.dive("STATIC_CALL");
- StringBuilder sb = new StringBuilder();
- List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
- if (arguments.size() < 1) {
- throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
+ return toStaticCallSerializationExpression(field, variableLiteral, serialzerArguments, tracer);
+ }
+ // All uppercase names are not fields, but utility methods.
+ else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) {
+ return toUpperCaseSerializationExpression(field, variableLiteral, serialzerArguments, tracer);
+ } else if (isVariableLiteralImplicitField(variableLiteral)) { // If we are accessing implicit fields, we need to rely on a local variable instead.
+ tracer = tracer.dive("implicit field");
+ return tracer + toSerializationExpression(getReferencedImplicitField(variableLiteral), getReferencedImplicitField(variableLiteral).getSerializeExpression(), serialzerArguments);
+ } else if (isVariableLiteralVirtualField(variableLiteral)) {
+ tracer = tracer.dive("virtual field");
+ return tracer + "_value." + toVariableExpressionRest(variableLiteral);
+ }
+ // The synthetic checksumRawData is a local field and should not be accessed as bean property.
+ boolean isSerializerArg = "checksumRawData".equals(variableLiteral.getName()) || "_value".equals(variableLiteral.getName()) || "element".equals(variableLiteral.getName()) || "size".equals(variableLiteral.getName());
+ boolean isTypeArg = "_type".equals(variableLiteral.getName());
+ if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
+ for (Argument serializerArgument : serialzerArguments) {
+ if (serializerArgument.getName().equals(variableLiteral.getName())) {
+ isSerializerArg = true;
+ break;
+ }
}
- // Get the class and method name
- String methodName = arguments.get(0).asLiteral()
- .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
- .asStringLiteral()
- .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
- getValue();
- methodName = methodName.substring(1, methodName.length() - 1);
- sb.append(methodName).append("(");
- for (int i = 1; i < arguments.size(); i++) {
- Term arg = arguments.get(i);
- if (i > 1) {
+ }
+ if (isSerializerArg) {
+ tracer = tracer.dive("serializer arg");
+ return tracer + variableLiteral.getName() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
+ } else if (isTypeArg) {
+ tracer = tracer.dive("type arg");
+ String part = variableLiteral.getChild().map(VariableLiteral::getName).orElse("");
+ switch (part) {
+ case "name":
+ return tracer + "\"" + field.getTypeName() + "\"";
+ case "length":
+ return tracer + "\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
+ case "encoding":
+ String encoding = ((StringTypeReference) field.getType()).getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ return tracer + "\"" + encoding + "\"";
+ default:
+ return tracer + "";
+ }
+ } else {
+ return tracer + "_value." + toVariableExpressionRest(variableLiteral);
+ }
+ }
+
+ private String toUpperCaseSerializationExpression(TypedField field, VariableLiteral variableLiteral, List<Argument> serialzerArguments, Tracer tracer) {
+ tracer = tracer.dive("UPPER_CASE");
+ StringBuilder sb = new StringBuilder(variableLiteral.getName());
+ if (variableLiteral.getArgs().isPresent()) {
+ sb.append("(");
+ boolean firstArg = true;
+ for (Term arg : variableLiteral.getArgs().get()) {
+ if (!firstArg) {
sb.append(", ");
}
+
if (arg instanceof VariableLiteral) {
VariableLiteral va = (VariableLiteral) arg;
- // "readBuffer" and "_value" are always available in every parser.
- boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || "_value".equals(va.getName()) || "element".equals(va.getName());
+ boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName());
boolean isTypeArg = "_type".equals(va.getName());
if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
for (Argument serializerArgument : serialzerArguments) {
@@ -817,103 +839,73 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
} else if (arg instanceof StringLiteral) {
sb.append(((StringLiteral) arg).getValue());
}
+ firstArg = false;
}
sb.append(")");
- return tracer + sb.toString();
}
- // All uppercase names are not fields, but utility methods.
- else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) {
- tracer = tracer.dive("UPPER_CASE");
- StringBuilder sb = new StringBuilder(variableLiteral.getName());
- if (variableLiteral.getArgs().isPresent()) {
- sb.append("(");
- boolean firstArg = true;
- for (Term arg : variableLiteral.getArgs().get()) {
- if (!firstArg) {
- sb.append(", ");
- }
-
- if (arg instanceof VariableLiteral) {
- VariableLiteral va = (VariableLiteral) arg;
- boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName());
- boolean isTypeArg = "_type".equals(va.getName());
- if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
- for (Argument serializerArgument : serialzerArguments) {
- if (serializerArgument.getName().equals(va.getName())) {
- isSerializerArg = true;
- break;
- }
- }
- }
- if (isSerializerArg) {
- sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
- } else if (isTypeArg) {
- String part = va.getChild().map(VariableLiteral::getName).orElse("");
- switch (part) {
- case "name":
- sb.append("\"").append(field.getTypeName()).append("\"");
- break;
- case "length":
- sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
- break;
- case "encoding":
- String encoding = ((StringTypeReference) field.getType()).getEncoding();
- // Cut off the single quotes.
- encoding = encoding.substring(1, encoding.length() - 1);
- sb.append("\"").append(encoding).append("\"");
- break;
- }
- } else {
- sb.append(toVariableSerializationExpression(field, va, serialzerArguments));
+ return tracer + sb.toString();
+ }
+
+ private String toStaticCallSerializationExpression(TypedField field, VariableLiteral variableLiteral, List<Argument> serialzerArguments, Tracer tracer) {
+ tracer = tracer.dive("STATIC_CALL");
+ StringBuilder sb = new StringBuilder();
+ List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
+ if (arguments.size() < 1) {
+ throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
+ }
+ // Get the class and method name
+ String methodName = arguments.get(0).asLiteral()
+ .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
+ .asStringLiteral()
+ .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
+ getValue();
+ methodName = methodName.substring(1, methodName.length() - 1);
+ sb.append(methodName).append("(");
+ for (int i = 1; i < arguments.size(); i++) {
+ Term arg = arguments.get(i);
+ if (i > 1) {
+ sb.append(", ");
+ }
+ if (arg instanceof VariableLiteral) {
+ VariableLiteral va = (VariableLiteral) arg;
+ // "readBuffer" and "_value" are always available in every parser.
+ boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || "_value".equals(va.getName()) || "element".equals(va.getName());
+ boolean isTypeArg = "_type".equals(va.getName());
+ if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
+ for (Argument serializerArgument : serialzerArguments) {
+ if (serializerArgument.getName().equals(va.getName())) {
+ isSerializerArg = true;
+ break;
}
- } else if (arg instanceof StringLiteral) {
- sb.append(((StringLiteral) arg).getValue());
}
- firstArg = false;
}
- sb.append(")");
- }
- return tracer + sb.toString();
- } else if (isVariableLiteralImplicitField(variableLiteral)) { // If we are accessing implicit fields, we need to rely on a local variable instead.
- tracer = tracer.dive("implicit field");
- return tracer + toSerializationExpression(getReferencedImplicitField(variableLiteral), getReferencedImplicitField(variableLiteral).getSerializeExpression(), serialzerArguments);
- } else if (isVariableLiteralVirtualField(variableLiteral)) {
- tracer = tracer.dive("virtual field");
- return tracer + "_value." + toVariableExpressionRest(variableLiteral);
- }
- // The synthetic checksumRawData is a local field and should not be accessed as bean property.
- boolean isSerializerArg = "checksumRawData".equals(variableLiteral.getName()) || "_value".equals(variableLiteral.getName()) || "element".equals(variableLiteral.getName()) || "size".equals(variableLiteral.getName());
- boolean isTypeArg = "_type".equals(variableLiteral.getName());
- if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
- for (Argument serializerArgument : serialzerArguments) {
- if (serializerArgument.getName().equals(variableLiteral.getName())) {
- isSerializerArg = true;
- break;
+ if (isSerializerArg) {
+ sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
+ } else if (isTypeArg) {
+ String part = va.getChild().map(VariableLiteral::getName).orElse("");
+ switch (part) {
+ case "name":
+ sb.append("\"").append(field.getTypeName()).append("\"");
+ break;
+ case "length":
+ sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
+ break;
+ case "encoding":
+ String encoding = ((StringTypeReference) field.getType()).getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ sb.append("\"").append(encoding).append("\"");
+ break;
+ }
+ } else {
+ sb.append(toVariableSerializationExpression(field, va, serialzerArguments));
}
+ } else if (arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
}
}
- if (isSerializerArg) {
- tracer = tracer.dive("serializer arg");
- return tracer + variableLiteral.getName() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse("");
- } else if (isTypeArg) {
- tracer = tracer.dive("type arg");
- String part = variableLiteral.getChild().map(VariableLiteral::getName).orElse("");
- switch (part) {
- case "name":
- return tracer + "\"" + field.getTypeName() + "\"";
- case "length":
- return tracer + "\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
- case "encoding":
- String encoding = ((StringTypeReference) field.getType()).getEncoding();
- // Cut off the single quotes.
- encoding = encoding.substring(1, encoding.length() - 1);
- return tracer + "\"" + encoding + "\"";
- default:
- return tracer + "";
- }
- } else {
- return tracer + "_value." + toVariableExpressionRest(variableLiteral);
- }
+ sb.append(")");
+ return tracer + sb.toString();
}
private String toVariableExpressionRest(VariableLiteral variableLiteral) {