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) {