You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2020/06/02 14:07:52 UTC
[plc4x] branch feature/c-code-generation updated: - Started working
on the parser and serializer code ...
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/c-code-generation
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/feature/c-code-generation by this push:
new 0309396 - Started working on the parser and serializer code ...
0309396 is described below
commit 0309396ade99968e9955a81e016996ff0fb6b514
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Tue Jun 2 16:07:43 2020 +0200
- Started working on the parser and serializer code ...
---
.../plc4x/language/c/CLanguageTemplateHelper.java | 459 ++++++++++++++++++++-
.../resources/templates/c/pojo-template-c.ftlh | 121 ++++++
.../modbus/src/modbus_constants.c | 19 +
.../generated-sources/modbus/src/modbus_pdu.c | 138 +++++++
.../modbus/src/modbus_pdu_diagnostic_request.c | 17 +
.../modbus/src/modbus_pdu_diagnostic_response.c | 17 +
.../modbus/src/modbus_pdu_error.c | 17 +
.../src/modbus_pdu_get_com_event_counter_request.c | 13 +
.../modbus_pdu_get_com_event_counter_response.c | 21 +
.../src/modbus_pdu_get_com_event_log_request.c | 13 +
.../src/modbus_pdu_get_com_event_log_response.c | 28 ++
...odbus_pdu_mask_write_holding_register_request.c | 25 ++
...dbus_pdu_mask_write_holding_register_response.c | 25 ++
.../modbus/src/modbus_pdu_read_coils_request.c | 21 +
.../modbus/src/modbus_pdu_read_coils_response.c | 16 +
...modbus_pdu_read_device_identification_request.c | 13 +
...odbus_pdu_read_device_identification_response.c | 13 +
.../src/modbus_pdu_read_discrete_inputs_request.c | 21 +
.../src/modbus_pdu_read_discrete_inputs_response.c | 16 +
.../src/modbus_pdu_read_exception_status_request.c | 13 +
.../modbus_pdu_read_exception_status_response.c | 17 +
.../src/modbus_pdu_read_fifo_queue_request.c | 17 +
.../src/modbus_pdu_read_fifo_queue_response.c | 19 +
.../src/modbus_pdu_read_file_record_request.c | 16 +
.../src/modbus_pdu_read_file_record_request_item.c | 29 ++
.../src/modbus_pdu_read_file_record_response.c | 16 +
.../modbus_pdu_read_file_record_response_item.c | 20 +
.../modbus_pdu_read_holding_registers_request.c | 21 +
.../modbus_pdu_read_holding_registers_response.c | 16 +
.../src/modbus_pdu_read_input_registers_request.c | 21 +
.../src/modbus_pdu_read_input_registers_response.c | 16 +
...read_write_multiple_holding_registers_request.c | 32 ++
...ead_write_multiple_holding_registers_response.c | 16 +
.../src/modbus_pdu_report_server_id_request.c | 13 +
.../src/modbus_pdu_report_server_id_response.c | 16 +
.../src/modbus_pdu_write_file_record_request.c | 16 +
.../modbus_pdu_write_file_record_request_item.c | 28 ++
.../src/modbus_pdu_write_file_record_response.c | 16 +
.../modbus_pdu_write_file_record_response_item.c | 28 ++
.../src/modbus_pdu_write_multiple_coils_request.c | 24 ++
.../src/modbus_pdu_write_multiple_coils_response.c | 21 +
..._pdu_write_multiple_holding_registers_request.c | 24 ++
...pdu_write_multiple_holding_registers_response.c | 21 +
.../src/modbus_pdu_write_single_coil_request.c | 21 +
.../src/modbus_pdu_write_single_coil_response.c | 21 +
.../src/modbus_pdu_write_single_register_request.c | 21 +
.../modbus_pdu_write_single_register_response.c | 21 +
.../modbus/src/modbus_serial_adu.c | 37 ++
.../generated-sources/modbus/src/modbus_tcp_adu.c | 34 ++
.../plc4c/generated-sources/s7/src/cotp_packet.c | 46 +++
.../s7/src/cotp_packet_connection_request.c | 24 ++
.../s7/src/cotp_packet_connection_response.c | 24 ++
.../generated-sources/s7/src/cotp_packet_data.c | 21 +
.../s7/src/cotp_packet_disconnect_request.c | 24 ++
.../s7/src/cotp_packet_disconnect_response.c | 21 +
.../s7/src/cotp_packet_tpdu_error.c | 21 +
.../generated-sources/s7/src/cotp_parameter.c | 36 ++
.../s7/src/cotp_parameter_called_tsap.c | 17 +
.../s7/src/cotp_parameter_calling_tsap.c | 17 +
.../s7/src/cotp_parameter_checksum.c | 17 +
...p_parameter_disconnect_additional_information.c | 13 +
.../s7/src/cotp_parameter_tpdu_size.c | 16 +
.../plc4c/generated-sources/s7/src/s7_address.c | 21 +
.../generated-sources/s7/src/s7_address_any.c | 43 ++
.../plc4c/generated-sources/s7/src/s7_message.c | 66 +++
.../generated-sources/s7/src/s7_message_request.c | 13 +
.../generated-sources/s7/src/s7_message_response.c | 21 +
.../s7/src/s7_message_response_data.c | 21 +
.../s7/src/s7_message_user_data.c | 13 +
.../plc4c/generated-sources/s7/src/s7_parameter.c | 36 ++
.../s7/src/s7_parameter_read_var_request.c | 16 +
.../s7/src/s7_parameter_read_var_response.c | 17 +
.../s7/src/s7_parameter_setup_communication.c | 33 ++
.../s7/src/s7_parameter_user_data.c | 16 +
.../s7/src/s7_parameter_user_data_item.c | 21 +
.../s7_parameter_user_data_item_cpu_functions.c | 54 +++
.../s7/src/s7_parameter_write_var_request.c | 16 +
.../s7/src/s7_parameter_write_var_response.c | 17 +
.../plc4c/generated-sources/s7/src/s7_payload.c | 27 ++
.../s7/src/s7_payload_read_var_response.c | 13 +
.../s7/src/s7_payload_user_data.c | 13 +
.../s7/src/s7_payload_user_data_item.c | 38 ++
..._user_data_item_cpu_function_read_szl_request.c | 13 +
...user_data_item_cpu_function_read_szl_response.c | 22 +
.../s7/src/s7_payload_write_var_request.c | 13 +
.../s7/src/s7_payload_write_var_response.c | 13 +
.../s7/src/s7_var_payload_data_item.c | 30 ++
.../s7/src/s7_var_payload_status_item.c | 16 +
.../s7/src/s7_var_request_parameter_item.c | 21 +
.../s7/src/s7_var_request_parameter_item_address.c | 20 +
.../generated-sources/s7/src/szl_data_tree_item.c | 29 ++
sandbox/plc4c/generated-sources/s7/src/szl_id.c | 23 ++
.../plc4c/generated-sources/s7/src/tpkt_packet.c | 34 ++
.../spi/include/plc4c/spi/evaluation_helper.h | 26 ++
sandbox/plc4c/spi/src/evaluation_helper.c | 27 ++
95 files changed, 2735 insertions(+), 8 deletions(-)
diff --git a/build-utils/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java b/build-utils/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
index a3b7247..9026dc8 100644
--- a/build-utils/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
+++ b/build-utils/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
@@ -21,21 +21,19 @@ package org.apache.plc4x.language.c;
import net.objecthunter.exp4j.Expression;
import net.objecthunter.exp4j.ExpressionBuilder;
import org.apache.commons.lang3.math.NumberUtils;
+import org.apache.commons.text.WordUtils;
import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerLanguageTemplateHelper;
import org.apache.plc4x.plugins.codegenerator.types.definitions.*;
import org.apache.plc4x.plugins.codegenerator.types.enums.EnumValue;
-import org.apache.plc4x.plugins.codegenerator.types.fields.ArrayField;
-import org.apache.plc4x.plugins.codegenerator.types.fields.PropertyField;
-import org.apache.plc4x.plugins.codegenerator.types.fields.SwitchField;
-import org.apache.plc4x.plugins.codegenerator.types.fields.TypedField;
-import org.apache.plc4x.plugins.codegenerator.types.references.ComplexTypeReference;
-import org.apache.plc4x.plugins.codegenerator.types.references.FloatTypeReference;
-import org.apache.plc4x.plugins.codegenerator.types.references.SimpleTypeReference;
-import org.apache.plc4x.plugins.codegenerator.types.references.TypeReference;
+import org.apache.plc4x.plugins.codegenerator.types.fields.*;
+import org.apache.plc4x.plugins.codegenerator.types.references.*;
import org.apache.plc4x.plugins.codegenerator.types.terms.*;
import sun.tools.tree.ArrayExpression;
import java.util.*;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
public class CLanguageTemplateHelper implements FreemarkerLanguageTemplateHelper {
@@ -71,6 +69,10 @@ public class CLanguageTemplateHelper implements FreemarkerLanguageTemplateHelper
return typeDefinition.isAbstract();
}
+ public boolean isSimpleType(TypeReference typeReference) {
+ return typeReference instanceof SimpleTypeReference;
+ }
+
public boolean isDiscriminatedType(ComplexTypeDefinition typeDefinition) {
return typeDefinition instanceof DiscriminatedComplexTypeDefinition;
}
@@ -415,4 +417,445 @@ public class CLanguageTemplateHelper implements FreemarkerLanguageTemplateHelper
return "";
}
+ public String getReadBufferReadMethodCall(SimpleTypeReference simpleTypeReference) {
+ switch (simpleTypeReference.getBaseType()) {
+ case BIT: {
+ return "plc4c_spi_read_bit(buf)";
+ }
+ case UINT: {
+ IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (integerTypeReference.getSizeInBits() <= 4) {
+ return "plc4c_spi_read_unsigned_byte(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 8) {
+ return "plc4c_spi_read_unsigned_short(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 16) {
+ return "plc4c_spi_read_unsigned_int(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 32) {
+ return "plc4c_spi_read_unsigned_long(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ return "plc4c_spi_read_unsigned_big_integer(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ case INT: {
+ IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (integerTypeReference.getSizeInBits() <= 8) {
+ return "plc4c_spi_read_byte(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 16) {
+ return "plc4c_spi_read_short(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 32) {
+ return "plc4c_spi_read_int(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 64) {
+ return "plc4c_spi_read_long(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ return "plc4c_spi_read_big_integer(buf, " + integerTypeReference.getSizeInBits() + ")";
+ }
+ case FLOAT: {
+ FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
+ if(floatTypeReference.getSizeInBits() <= 32) {
+ return "plc4c_spi_read_float(buf, " + floatTypeReference.getSizeInBits() + ")";
+ } else {
+ return "plc4c_spi_read_double(buf, " + floatTypeReference.getSizeInBits() + ")";
+ }
+ }
+ case STRING: {
+ StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
+ return "plc4c_spi_read_string(buf, " + stringTypeReference.getSizeInBits() + ", \"" +
+ stringTypeReference.getEncoding() + "\")";
+ }
+ }
+ return "Hurz";
+ }
+
+ public String toSwitchExpression(String expression) {
+ StringBuilder sb = new StringBuilder();
+ Pattern pattern = Pattern.compile("([^\\.]*)\\.([a-zA-Z\\d]+)(.*)");
+ Matcher matcher;
+ while ((matcher = pattern.matcher(expression)).matches()) {
+ String prefix = matcher.group(1);
+ String middle = matcher.group(2);
+ sb.append(prefix).append(".get").append(WordUtils.capitalize(middle)).append("()");
+ expression = matcher.group(3);
+ }
+ sb.append(expression);
+ return sb.toString();
+ }
+
+ public String toParseExpression(TypedField field, Term term, Argument[] parserArguments) {
+ return toExpression(field, term, term1 -> toVariableParseExpression(field, term1, parserArguments));
+ }
+
+ public String toSerializationExpression(TypedField field, Term term, Argument[] parserArguments) {
+ return toExpression(field, term, term1 -> toVariableSerializationExpression(field, term1, parserArguments));
+ }
+
+ private String toExpression(TypedField field, Term term, Function<Term, String> variableExpressionGenerator) {
+ if(term == null) {
+ return "";
+ }
+ 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 this literal references an Enum type, then we have to output it differently.
+ if(types.get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
+ return variableLiteral.getName() + "." + variableLiteral.getChild().getName();
+ } else {
+ return variableExpressionGenerator.apply(term);
+ }
+ } else {
+ throw new RuntimeException("Unsupported Literal type " + term.getClass().getName());
+ }
+ } else if (term instanceof UnaryTerm) {
+ UnaryTerm ut = (UnaryTerm) term;
+ Term a = ut.getA();
+ switch(ut.getOperation()) {
+ case "!":
+ return "!(" + toExpression(field, a, variableExpressionGenerator) + ")";
+ case "-":
+ return "-(" + toExpression(field, a, variableExpressionGenerator) + ")";
+ case "()":
+ return "(" + toExpression(field, a, variableExpressionGenerator) + ")";
+ default:
+ throw new RuntimeException("Unsupported unary operation type " + ut.getOperation());
+ }
+ } else if (term instanceof BinaryTerm) {
+ BinaryTerm bt = (BinaryTerm) term;
+ Term a = bt.getA();
+ Term b = bt.getB();
+ String operation = bt.getOperation();
+ switch (operation) {
+ case "^":
+ return "Math.pow((" + toExpression(field, a, variableExpressionGenerator) + "), (" + toExpression(field, b, variableExpressionGenerator) + "))";
+ default:
+ return "(" + toExpression(field, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, b, variableExpressionGenerator) + ")";
+ }
+ } 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(field, a, variableExpressionGenerator) + ") ? " + toExpression(field, b, variableExpressionGenerator) + " : " + toExpression(field, c, variableExpressionGenerator) + ")";
+ } else {
+ throw new RuntimeException("Unsupported ternary operation type " + tt.getOperation());
+ }
+ } else {
+ throw new RuntimeException("Unsupported Term type " + term.getClass().getName());
+ }
+ }
+
+ private String toVariableParseExpression(TypedField field, Term term, Argument[] parserArguments) {
+ VariableLiteral vl = (VariableLiteral) term;
+ // CAST expressions are special as we need to add a ".class" to the second parameter in Java.
+ if("CAST".equals(vl.getName())) {
+ StringBuilder sb = new StringBuilder(vl.getName());
+ if((vl.getArgs() == null) || (vl.getArgs().size() != 2)) {
+ throw new RuntimeException("A CAST expression expects exactly two arguments.");
+ }
+ sb.append("(").append(toVariableParseExpression(field, vl.getArgs().get(0), parserArguments))
+ .append(", ").append(((VariableLiteral) vl.getArgs().get(1)).getName()).append(".class)");
+ return sb.toString() + ((vl.getChild() != null) ? "." + toVariableExpressionRest(vl.getChild()) : "");
+ }
+ else if("STATIC_CALL".equals(vl.getName())) {
+ StringBuilder sb = new StringBuilder();
+ if(!(vl.getArgs().get(0) instanceof StringLiteral)) {
+ throw new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral");
+ }
+ // Get the class and method name
+ String methodName = ((StringLiteral) vl.getArgs().get(0)).getValue();
+ // Cut off the double-quptes
+ methodName = methodName.substring(1, methodName.length() - 1);
+ sb.append(methodName).append("(");
+ for(int i = 1; i < vl.getArgs().size(); i++) {
+ Term arg = vl.getArgs().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 = "io".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) {
+ sb.append(va.getName() + ((va.getChild() != null) ? "." + toVariableExpressionRest(va.getChild()) : ""));
+ }
+ // We have to manually evaluate the type information at code-generation time.
+ else if(isTypeArg) {
+ String part = va.getChild().getName();
+ 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, va, null));
+ }
+ } else if(arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
+ }
+ }
+ 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(vl.getName());
+ if(vl.getArgs() != null) {
+ sb.append("(");
+ boolean firstArg = true;
+ for(Term arg : vl.getArgs()) {
+ if(!firstArg) {
+ sb.append(", ");
+ }
+ sb.append(toParseExpression(field, arg, parserArguments));
+ firstArg = false;
+ }
+ sb.append(")");
+ }
+ if(vl.getIndex() != VariableLiteral.NO_INDEX) {
+ sb.append("[").append(vl.getIndex()).append("]");
+ }
+ return sb.toString() + ((vl.getChild() != null) ? "." + toVariableExpressionRest(vl.getChild()) : "");
+ }
+ return vl.getName() + ((vl.getChild() != null) ? "." + toVariableExpressionRest(vl.getChild()) : "");
+ }
+
+ private String toVariableSerializationExpression(TypedField field, Term term, Argument[] serialzerArguments) {
+ VariableLiteral vl = (VariableLiteral) term;
+ if("STATIC_CALL".equals(vl.getName())) {
+ StringBuilder sb = new StringBuilder();
+ if(!(vl.getArgs().get(0) instanceof StringLiteral)) {
+ throw new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral");
+ }
+ String methodName = ((StringLiteral) vl.getArgs().get(0)).getValue();
+ methodName = methodName.substring(1, methodName.length() - 1);
+ sb.append(methodName).append("(");
+ for(int i = 1; i < vl.getArgs().size(); i++) {
+ Term arg = vl.getArgs().get(i);
+ if(i > 1) {
+ sb.append(", ");
+ }
+ if(arg instanceof VariableLiteral) {
+ VariableLiteral va = (VariableLiteral) arg;
+ // "io" and "_value" are always available in every parser.
+ boolean isSerializerArg = "io".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;
+ }
+ }
+ }
+ if(isSerializerArg) {
+ sb.append(va.getName() + ((va.getChild() != null) ? "." + toVariableExpressionRest(va.getChild()) : ""));
+ } else if(isTypeArg) {
+ String part = va.getChild().getName();
+ 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, null));
+ }
+ } else if(arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
+ }
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+ // Discriminator values have to be handled a little differently.
+ /*else if(vl.getName().equals("DISCRIMINATOR_VALUES")) {
+ final String typeName = getLanguageTypeNameForSpecType(field.getType());
+ switch (typeName) {
+ case "byte":
+ return "((Number) _value.getDiscriminatorValues()[" + vl.getIndex() + "]).byteValue()";
+ case "short":
+ return "((Number) _value.getDiscriminatorValues()[" + vl.getIndex() + "]).shortValue()";
+ case "int":
+ return "((Number) _value.getDiscriminatorValues()[" + vl.getIndex() + "]).intValue()";
+ case "long":
+ return "((Number) _value.getDiscriminatorValues()[" + vl.getIndex() + "]).longValue()";
+ case "float":
+ return "((Number) _value.getDiscriminatorValues()[" + vl.getIndex() + "]).floatValue()";
+ case "double":
+ return "((Number) _value.getDiscriminatorValues()[" + vl.getIndex() + "]).doubleValue()";
+ default:
+ return "_value.getDiscriminatorValues()[" + vl.getIndex() + "]";
+ }
+ }*/
+ // All uppercase names are not fields, but utility methods.
+ else if(vl.getName().equals(vl.getName().toUpperCase())) {
+ StringBuilder sb = new StringBuilder(vl.getName());
+ if(vl.getArgs() != null) {
+ sb.append("(");
+ boolean firstArg = true;
+ for(Term arg : vl.getArgs()) {
+ if(!firstArg) {
+ sb.append(", ");
+ }
+
+ if(arg instanceof VariableLiteral) {
+ VariableLiteral va = (VariableLiteral) arg;
+ boolean isSerializerArg = "io".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() + ((va.getChild() != null) ? "." + toVariableExpressionRest(va.getChild()) : ""));
+ } else if(isTypeArg) {
+ String part = va.getChild().getName();
+ 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, null));
+ }
+ } else if(arg instanceof StringLiteral) {
+ sb.append(((StringLiteral) arg).getValue());
+ }
+ firstArg = false;
+ }
+ sb.append(")");
+ }
+ return sb.toString();
+ }
+ // 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());
+ boolean isTypeArg = "_type".equals(vl.getName());
+ if(!isSerializerArg && !isTypeArg && serialzerArguments != null) {
+ for (Argument serializerArgument : serialzerArguments) {
+ if (serializerArgument.getName().equals(vl.getName())) {
+ isSerializerArg = true;
+ break;
+ }
+ }
+ }
+ if(isSerializerArg) {
+ return vl.getName() + ((vl.getChild() != null) ? "." + toVariableExpressionRest(vl.getChild()) : "");
+ } else if(isTypeArg) {
+ String part = vl.getChild().getName();
+ switch (part) {
+ case "name":
+ return"\"" + field.getTypeName() + "\"";
+ case "length":
+ return"\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
+ case "encoding":
+ String encoding = ((StringTypeReference) field.getType()).getEncoding();
+ // Cut off the single quotes.
+ encoding = encoding.substring(1, encoding.length() - 1);
+ return"\"" + encoding + "\"";
+ default:
+ return "";
+ }
+ } else {
+ return "_value." + toVariableExpressionRest(vl);
+ }
+ }
+
+ private String toVariableExpressionRest(VariableLiteral vl) {
+ return "get" + WordUtils.capitalize(vl.getName()) + "()" + ((vl.isIndexed() ? "[" + vl.getIndex() + "]" : "") +
+ ((vl.getChild() != null) ? "." + toVariableExpressionRest(vl.getChild()) : ""));
+ }
+
+ public int getNumBits(SimpleTypeReference simpleTypeReference) {
+ switch (simpleTypeReference.getBaseType()) {
+ case BIT: {
+ return 1;
+ }
+ case UINT:
+ case INT: {
+ IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ return integerTypeReference.getSizeInBits();
+ }
+ case FLOAT: {
+ FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
+ return floatTypeReference.getSizeInBits();
+ }
+ case STRING: {
+ IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ return integerTypeReference.getSizeInBits();
+ }
+ default: {
+ return 0;
+ }
+ }
+ }
+
+ public String getReservedValue(ReservedField reservedField) {
+ final String languageTypeName = getLanguageTypeName(reservedField.getType());
+ if("BigInteger".equals(languageTypeName)) {
+ return "BigInteger.valueOf(" + reservedField.getReferenceValue() + ")";
+ } else {
+ return "(" + languageTypeName + ") " + reservedField.getReferenceValue();
+ }
+ }
+
+ public SimpleTypeReference getEnumBaseType(TypeReference enumType) {
+ if(!(enumType instanceof ComplexTypeReference)) {
+ throw new RuntimeException("type reference for enum types must be of type complex type");
+ }
+ ComplexTypeReference complexType = (ComplexTypeReference) enumType;
+ EnumTypeDefinition enumTypeDefinition = (EnumTypeDefinition) types.get(complexType.getName());
+ return (SimpleTypeReference) enumTypeDefinition.getType();
+ }
+
}
diff --git a/build-utils/language-c/src/main/resources/templates/c/pojo-template-c.ftlh b/build-utils/language-c/src/main/resources/templates/c/pojo-template-c.ftlh
index 35efa6f..901957c 100644
--- a/build-utils/language-c/src/main/resources/templates/c/pojo-template-c.ftlh
+++ b/build-utils/language-c/src/main/resources/templates/c/pojo-template-c.ftlh
@@ -38,6 +38,127 @@ ${helper.setConstants(type, protocolName, outputFlavor)}${helper.getSourceDirect
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "${helper.camelCaseToSnakeCase(typeName)}.h"
+plc4c_return_code plc4c_${helper.getCTypeName(type.name)}_parse(plc4c_read_buffer buf, <#if type.parserArguments?has_content><#list type.parserArguments as parserArgument>${helper.getLanguageTypeName(parserArgument.type)} ${parserArgument.name}<#sep>, </#list>, </#if>plc4c_${helper.getCTypeName(type.name)}** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_${helper.getCTypeName(type.name)}* msg = malloc(sizeof(plc4c_${helper.getCTypeName(type.name)}));
+<#list type.fields as field>
+ <#switch field.typeName>
+ <#case "checksum">
+
+ // Checksum Field (${field.name})
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = ${helper.getNullValueForType(field.type)};
+ {
+ // Create an array of all the bytes read in this message element so far.
+ byte[] checksumRawData = io.getBytes(startPos, io.getPos());
+ ${helper.getLanguageTypeNameForField(field)} _${field.name}Ref = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ ${field.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(field, field.checksumExpression, type.parserArguments)});
+ if(${field.name} != _${field.name}Ref) {
+ throw new ParseException(String.format("Checksum verification failed. Expected %04X but got %04X",_${field.name}Ref & 0xFFFF, ${field.name} & 0xFFFF));
+ }
+ }
+ <#break>
+ <#case "const">
+
+ // Const Field (${field.name})
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ if(${field.name} != ${typeName}.${field.name?upper_case}) {
+ throw new ParseException("Expected constant value " + ${typeName}.${field.name?upper_case} + " but got " + ${field.name});
+ }
+ <#break>
+ <#case "enum">
+
+ // Enum field (${field.name})
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = ${helper.getLanguageTypeNameForField(field)}.valueOf(${helper.getReadBufferReadMethodCall(helper.getEnumBaseType(field.type))?no_esc});
+ <#break>
+ <#case "discriminator">
+
+ // Discriminator Field (${field.name}) (Used as input to a switch field)
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ <#break>
+ <#case "implicit">
+
+ // Implicit Field (${field.name}) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ <#break>
+ <#case "manual">
+
+ // Manual Field (${field.name})
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(field, field.parseExpression, type.parserArguments)});
+ msg.${helper.camelCaseToSnakeCase(field.name)} = ${field.name};
+ <#break>
+ <#case "optional">
+
+ // Optional Field (${field.name}) (Can be skipped, if a given expression evaluates to false)
+ <#if field.conditionExpression.contains("curPos")>
+ curPos = io.getPos() - startPos;
+ </#if>
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = NULL;
+ if(${helper.toParseExpression(field, field.conditionExpression, type.parserArguments)?no_esc}) {
+ <#if helper.isSimpleType(field.type)>
+ ${field.name} = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ <#else>
+ ${field.name} = plc4c_${helper.getCTypeName(field.type.name)}_parse(buf<#if field.params?has_content>, <#list field.params as parserTerm>${helper.toParseExpression(field, parserTerm, type.parserArguments)}<#sep>, </#sep></#list></#if>);
+ </#if>
+ }
+ <#break>
+ <#case "padding">
+
+ // Padding Field (${field.name})
+ bool _${field.name}NeedsPadding = (bool) ((plc4c_spi_read_has_more(buf, ${helper.getNumBits(field.type)})) && (${helper.toParseExpression(field, field.paddingCondition, type.parserArguments)?no_esc}));
+ if(_${field.name}NeedsPadding) {
+ // Just read the padding data and ignore it
+ ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ }
+ <#break>
+ <#case "reserved">
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ ${helper.getLanguageTypeNameForField(field)} reserved = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ if(reserved != ${helper.getReservedValue(field)}) {
+ LOGGER.info("Expected constant value " + ${field.referenceValue} + " but got " + reserved + " for reserved field.");
+ }
+ }
+ <#break>
+ <#case "simple">
+
+ // Simple Field (${field.name})
+ <#-- Inizialize a local variable with the simple type (Intentionally keeping the java-style names so they can be used in expressions) -->
+ <#if helper.isSimpleType(field.type)>
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = ${helper.getReadBufferReadMethodCall(field.type)?no_esc};
+ <#else>
+ <#-- Inizialize a local variable with the complex type (Intentionally keeping the java-style names so they can be used in expressions) -->
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = plc4c_${helper.getCTypeName(field.type.name)}_parse(buf<#if field.params?has_content>, <#list field.params as parserTerm>${helper.toParseExpression(field, parserTerm, type.parserArguments)}<#sep>, </#sep></#list></#if>);
+ </#if>
+ <#-- Update the protpery in the struct -->
+ msg.${helper.camelCaseToSnakeCase(field.name)} = ${field.name};
+ <#break>
+ <#case "switch">
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ <#list field.cases as case>
+ <#if case.discriminatorValues?has_content>if(<#list case.discriminatorValues as discriminatorValue>plc4c_spi_evaluation_helper_equals(${helper.toSwitchExpression(field.discriminatorNames[discriminatorValue?index])?no_esc}, ${discriminatorValue})<#sep> && </#sep></#list>) </#if>{
+ plc4c_${helper.getCTypeName(case.name)}_parse(buf, msg<#if case.parserArguments?has_content>, <#list case.parserArguments as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>);
+ }<#sep> else </#sep>
+ </#list>
+ <#break>
+ <#case "virtual">
+
+ // Virtual field (Just declare a local variable so we can access it in the parser)
+ ${helper.getLanguageTypeNameForField(field)} ${field.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(field, field.valueExpression, type.parserArguments)});
+ <#break>
+ </#switch>
+</#list>
+
+ return OK;
+}
+
+plc4c_return_code plc4c_${helper.getCTypeName(type.name)}_serialize(plc4c_write_buffer buf, plc4c_${helper.getCTypeName(type.name)}* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_constants.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_constants.c
index 8b6ee8c..f7d72c2 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_constants.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_constants.c
@@ -19,6 +19,25 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_constants.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_constants_parse(plc4c_read_buffer buf, plc4c_modbus_read_write_modbus_constants** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_constants* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_constants));
+
+ // Const Field (modbusTcpDefaultPort)
+ uint16_t modbusTcpDefaultPort = plc4c_spi_read_unsigned_int(buf, 16);
+ if(modbusTcpDefaultPort != ModbusConstants.MODBUSTCPDEFAULTPORT) {
+ throw new ParseException("Expected constant value " + ModbusConstants.MODBUSTCPDEFAULTPORT + " but got " + modbusTcpDefaultPort);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_constants_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_constants* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu.c
index a9ed410..77afde9 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu.c
@@ -19,6 +19,144 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu));
+
+ // Implicit Field (error) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ bool error = plc4c_spi_read_bit(buf);
+
+ // Implicit Field (function) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ unsigned int function = plc4c_spi_read_unsigned_short(buf, 7);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(error, true)) {
+ plc4c_modbus_read_write_modbus_pdu_error_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x02) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x02) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x01) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_coils_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x01) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_coils_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x05) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_write_single_coil_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x05) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_write_single_coil_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x0F) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x0F) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x04) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_input_registers_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x04) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_input_registers_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x03) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x03) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x06) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_write_single_register_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x06) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_write_single_register_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x10) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x10) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x17) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x17) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x16) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x16) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x18) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x18) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x14) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_file_record_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x14) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_file_record_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x15) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_write_file_record_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x15) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_write_file_record_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x07) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_exception_status_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x07) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_exception_status_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x08) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_diagnostic_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x08) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_diagnostic_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x0B) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x0B) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x0C) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x0C) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x11) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_report_server_id_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x11) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_report_server_id_response_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x2B) && plc4c_spi_evaluation_helper_equals(response, false)) {
+ plc4c_modbus_read_write_modbus_pdu_read_device_identification_request_parse(buf, msg, response);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(error, false) && plc4c_spi_evaluation_helper_equals(function, 0x2B) && plc4c_spi_evaluation_helper_equals(response, true)) {
+ plc4c_modbus_read_write_modbus_pdu_read_device_identification_response_parse(buf, msg, response);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_request.c
index 387d95b..5caad7b 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_request.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_diagnostic_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_diagnostic_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_diagnostic_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_diagnostic_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_diagnostic_request));
+
+ // Simple Field (subfunction)
+ uint8_t subfunction = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.subfunction = subfunction;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_diagnostic_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_diagnostic_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_response.c
index f115bf7..b0e34c7 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_diagnostic_response.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_diagnostic_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_diagnostic_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_diagnostic_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_diagnostic_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_diagnostic_response));
+
+ // Simple Field (subfunction)
+ uint8_t subfunction = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.subfunction = subfunction;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_diagnostic_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_diagnostic_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_error.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_error.c
index bce4880..8de5d1e 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_error.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_error.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_error.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_error_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_error** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_error* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_error));
+
+ // Simple Field (exceptionCode)
+ uint8_t exceptionCode = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.exception_code = exceptionCode;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_error_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_error* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_request.c
index f005edd..7c03e99 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_get_com_event_counter_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_response.c
index 868f3f3..5fb8c63 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_counter_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_get_com_event_counter_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response));
+
+ // Simple Field (status)
+ uint16_t status = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.status = status;
+
+ // Simple Field (eventCount)
+ uint16_t eventCount = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.event_count = eventCount;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_get_com_event_counter_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_request.c
index dd88c26..4435810 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_get_com_event_log_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_get_com_event_log_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_response.c
index aa89f95..14add6d 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_get_com_event_log_response.c
@@ -19,6 +19,34 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_get_com_event_log_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Simple Field (status)
+ uint16_t status = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.status = status;
+
+ // Simple Field (eventCount)
+ uint16_t eventCount = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.event_count = eventCount;
+
+ // Simple Field (messageCount)
+ uint16_t messageCount = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.message_count = messageCount;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_get_com_event_log_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_request.c
index aa92610..f92bcc7 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_request.c
@@ -19,6 +19,31 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_mask_write_holding_register_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request));
+
+ // Simple Field (referenceAddress)
+ uint16_t referenceAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.reference_address = referenceAddress;
+
+ // Simple Field (andMask)
+ uint16_t andMask = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.and_mask = andMask;
+
+ // Simple Field (orMask)
+ uint16_t orMask = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.or_mask = orMask;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_response.c
index ee0f23a..bd4e662 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_mask_write_holding_register_response.c
@@ -19,6 +19,31 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_mask_write_holding_register_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response));
+
+ // Simple Field (referenceAddress)
+ uint16_t referenceAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.reference_address = referenceAddress;
+
+ // Simple Field (andMask)
+ uint16_t andMask = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.and_mask = andMask;
+
+ // Simple Field (orMask)
+ uint16_t orMask = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.or_mask = orMask;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_mask_write_holding_register_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_request.c
index 4340631..353749d 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_request.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_coils_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_coils_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_coils_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_coils_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_coils_request));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_coils_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_coils_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_response.c
index e063c02..a5448cf 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_coils_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_coils_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_coils_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_coils_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_coils_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_coils_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_coils_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_coils_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_request.c
index a72c8cf..fe20273 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_device_identification_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_device_identification_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_device_identification_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_device_identification_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_device_identification_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_device_identification_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_device_identification_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_response.c
index 3f2dfe1..9292e06 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_device_identification_response.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_device_identification_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_device_identification_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_device_identification_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_device_identification_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_device_identification_response));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_device_identification_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_device_identification_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_request.c
index 54df322..6565c60 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_request.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_discrete_inputs_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_response.c
index a3114a5..8898106 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_discrete_inputs_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_discrete_inputs_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_discrete_inputs_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_request.c
index d8b0cbe..8a8ffae 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_exception_status_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_exception_status_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_exception_status_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_exception_status_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_exception_status_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_exception_status_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_exception_status_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_response.c
index b992410..0657f79 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_exception_status_response.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_exception_status_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_exception_status_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_exception_status_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_exception_status_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_exception_status_response));
+
+ // Simple Field (value)
+ uint8_t value = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.value = value;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_exception_status_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_exception_status_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_request.c
index dcf9b7b..1935118 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_request.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_fifo_queue_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request));
+
+ // Simple Field (fifoPointerAddress)
+ uint16_t fifoPointerAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.fifo_pointer_address = fifoPointerAddress;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_response.c
index c352f2b..c19bb71 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_fifo_queue_response.c
@@ -19,6 +19,25 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_fifo_queue_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t byteCount = plc4c_spi_read_unsigned_int(buf, 16);
+
+ // Implicit Field (fifoCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t fifoCount = plc4c_spi_read_unsigned_int(buf, 16);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_fifo_queue_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request.c
index bfe9c76..0f1e5f2 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_file_record_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_file_record_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_file_record_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_file_record_request));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_file_record_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request_item.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request_item.c
index f588bec..7cc2598 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request_item.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_request_item.c
@@ -19,6 +19,35 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_file_record_request_item.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_request_item_parse(plc4c_read_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_file_record_request_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_file_record_request_item* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_file_record_request_item));
+
+ // Simple Field (referenceType)
+ uint8_t referenceType = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.reference_type = referenceType;
+
+ // Simple Field (fileNumber)
+ uint16_t fileNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.file_number = fileNumber;
+
+ // Simple Field (recordNumber)
+ uint16_t recordNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.record_number = recordNumber;
+
+ // Simple Field (recordLength)
+ uint16_t recordLength = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.record_length = recordLength;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_request_item_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_file_record_request_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response.c
index 4e037ac..fe61cd2 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_file_record_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_file_record_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_file_record_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_file_record_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_file_record_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response_item.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response_item.c
index 9f94d3c..99146de 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response_item.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_file_record_response_item.c
@@ -19,6 +19,26 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_file_record_response_item.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_response_item_parse(plc4c_read_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_file_record_response_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_file_record_response_item* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_file_record_response_item));
+
+ // Implicit Field (dataLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t dataLength = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Simple Field (referenceType)
+ uint8_t referenceType = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.reference_type = referenceType;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_file_record_response_item_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_file_record_response_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_request.c
index 895d193..60f2da1 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_request.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_holding_registers_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_holding_registers_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_response.c
index fa34c9c..52d9760 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_holding_registers_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_holding_registers_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_holding_registers_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_request.c
index 2fa0c59..fa79426 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_request.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_input_registers_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_input_registers_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_input_registers_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_input_registers_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_input_registers_request));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_input_registers_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_input_registers_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_response.c
index 9a607c9..e065f5b 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_input_registers_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_input_registers_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_input_registers_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_input_registers_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_input_registers_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_input_registers_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_input_registers_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_input_registers_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_request.c
index e1c776d..1f2106c 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_request.c
@@ -19,6 +19,38 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_write_multiple_holding_registers_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request));
+
+ // Simple Field (readStartingAddress)
+ uint16_t readStartingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.read_starting_address = readStartingAddress;
+
+ // Simple Field (readQuantity)
+ uint16_t readQuantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.read_quantity = readQuantity;
+
+ // Simple Field (writeStartingAddress)
+ uint16_t writeStartingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.write_starting_address = writeStartingAddress;
+
+ // Simple Field (writeQuantity)
+ uint16_t writeQuantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.write_quantity = writeQuantity;
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_response.c
index b06d6ad..96b7642 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_read_write_multiple_holding_registers_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_read_write_multiple_holding_registers_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_read_write_multiple_holding_registers_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_request.c
index e3891ac..d945dd1 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_report_server_id_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_report_server_id_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_report_server_id_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_report_server_id_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_report_server_id_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_report_server_id_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_report_server_id_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_response.c
index 82fd963..ffef818 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_report_server_id_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_report_server_id_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_report_server_id_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_report_server_id_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_report_server_id_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_report_server_id_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_report_server_id_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_report_server_id_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request.c
index 0481815..1ab0ed2 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_file_record_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_file_record_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_file_record_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_file_record_request));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_file_record_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request_item.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request_item.c
index 889ef99..5c146a3 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request_item.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_request_item.c
@@ -19,6 +19,34 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_file_record_request_item.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_request_item_parse(plc4c_read_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_file_record_request_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_file_record_request_item* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_file_record_request_item));
+
+ // Simple Field (referenceType)
+ uint8_t referenceType = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.reference_type = referenceType;
+
+ // Simple Field (fileNumber)
+ uint16_t fileNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.file_number = fileNumber;
+
+ // Simple Field (recordNumber)
+ uint16_t recordNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.record_number = recordNumber;
+
+ // Implicit Field (recordLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t recordLength = plc4c_spi_read_unsigned_int(buf, 16);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_request_item_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_file_record_request_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response.c
index d82c720..5e17a24 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_file_record_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_file_record_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_file_record_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_file_record_response));
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_file_record_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response_item.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response_item.c
index 3d34eb0..e760c0a 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response_item.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_file_record_response_item.c
@@ -19,6 +19,34 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_file_record_response_item.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_response_item_parse(plc4c_read_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_file_record_response_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_file_record_response_item* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_file_record_response_item));
+
+ // Simple Field (referenceType)
+ uint8_t referenceType = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.reference_type = referenceType;
+
+ // Simple Field (fileNumber)
+ uint16_t fileNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.file_number = fileNumber;
+
+ // Simple Field (recordNumber)
+ uint16_t recordNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.record_number = recordNumber;
+
+ // Implicit Field (recordLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t recordLength = plc4c_spi_read_unsigned_int(buf, 16);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_file_record_response_item_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_file_record_response_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_request.c
index e11908a..a292668 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_request.c
@@ -19,6 +19,30 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_multiple_coils_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_response.c
index 7043468..3459bdd 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_coils_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_multiple_coils_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_multiple_coils_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_request.c
index bb457c9..cd4858f 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_request.c
@@ -19,6 +19,30 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_multiple_holding_registers_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t byteCount = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_response.c
index db63b04..07425ac 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_multiple_holding_registers_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_multiple_holding_registers_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response));
+
+ // Simple Field (startingAddress)
+ uint16_t startingAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.starting_address = startingAddress;
+
+ // Simple Field (quantity)
+ uint16_t quantity = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.quantity = quantity;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_multiple_holding_registers_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_request.c
index 0997ff1..56afdad 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_request.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_single_coil_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_coil_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_single_coil_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_single_coil_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_single_coil_request));
+
+ // Simple Field (address)
+ uint16_t address = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.address = address;
+
+ // Simple Field (value)
+ uint16_t value = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.value = value;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_coil_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_single_coil_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_response.c
index 4f35148..b20210c 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_coil_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_single_coil_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_coil_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_single_coil_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_single_coil_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_single_coil_response));
+
+ // Simple Field (address)
+ uint16_t address = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.address = address;
+
+ // Simple Field (value)
+ uint16_t value = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.value = value;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_coil_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_single_coil_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_request.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_request.c
index 0faa357..e667788 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_request.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_request.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_single_register_request.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_register_request_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_single_register_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_single_register_request* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_single_register_request));
+
+ // Simple Field (address)
+ uint16_t address = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.address = address;
+
+ // Simple Field (value)
+ uint16_t value = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.value = value;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_register_request_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_single_register_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_response.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_response.c
index bc87e53..da587e5 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_response.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_pdu_write_single_register_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_pdu_write_single_register_response.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_register_response_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_pdu_write_single_register_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_pdu_write_single_register_response* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_pdu_write_single_register_response));
+
+ // Simple Field (address)
+ uint16_t address = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.address = address;
+
+ // Simple Field (value)
+ uint16_t value = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.value = value;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_pdu_write_single_register_response_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_pdu_write_single_register_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_serial_adu.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_serial_adu.c
index 5cdafa2..5f47244 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_serial_adu.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_serial_adu.c
@@ -19,6 +19,43 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_serial_adu.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_serial_adu_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_serial_adu** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_serial_adu* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_serial_adu));
+
+ // Simple Field (transactionId)
+ uint16_t transactionId = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.transaction_id = transactionId;
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ uint16_t reserved = plc4c_spi_read_unsigned_int(buf, 16);
+ if(reserved != (uint16_t) 0x0000) {
+ LOGGER.info("Expected constant value " + 0x0000 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (length)
+ uint16_t length = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.length = length;
+
+ // Simple Field (address)
+ uint8_t address = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.address = address;
+
+ // Simple Field (pdu)
+ plc4c_modbus_read_write_modbus_pdu pdu = plc4c_modbus_read_write_modbus_pdu_parse(buf, response);
+ msg.pdu = pdu;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_serial_adu_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_serial_adu* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_tcp_adu.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_tcp_adu.c
index 8201345..ed24a67 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/modbus_tcp_adu.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_tcp_adu.c
@@ -19,6 +19,40 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "modbus_tcp_adu.h"
+plc4c_return_code plc4c_modbus_read_write_modbus_tcp_adu_parse(plc4c_read_buffer buf, bool response, plc4c_modbus_read_write_modbus_tcp_adu** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_modbus_read_write_modbus_tcp_adu* msg = malloc(sizeof(plc4c_modbus_read_write_modbus_tcp_adu));
+
+ // Simple Field (transactionIdentifier)
+ uint16_t transactionIdentifier = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.transaction_identifier = transactionIdentifier;
+
+ // Const Field (protocolIdentifier)
+ uint16_t protocolIdentifier = plc4c_spi_read_unsigned_int(buf, 16);
+ if(protocolIdentifier != ModbusTcpADU.PROTOCOLIDENTIFIER) {
+ throw new ParseException("Expected constant value " + ModbusTcpADU.PROTOCOLIDENTIFIER + " but got " + protocolIdentifier);
+ }
+
+ // Implicit Field (length) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t length = plc4c_spi_read_unsigned_int(buf, 16);
+
+ // Simple Field (unitIdentifier)
+ uint8_t unitIdentifier = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.unit_identifier = unitIdentifier;
+
+ // Simple Field (pdu)
+ plc4c_modbus_read_write_modbus_pdu pdu = plc4c_modbus_read_write_modbus_pdu_parse(buf, response);
+ msg.pdu = pdu;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_modbus_read_write_modbus_tcp_adu_serialize(plc4c_write_buffer buf, plc4c_modbus_read_write_modbus_tcp_adu* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet.c
index 4db53a3..b4fcad4 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet.c
@@ -19,6 +19,52 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet));
+
+ // Implicit Field (headerLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t headerLength = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Discriminator Field (tpduCode) (Used as input to a switch field)
+ uint8_t tpduCode = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(tpduCode, 0xF0)) {
+ plc4c_s7_read_write_cotp_packet_data_parse(buf, msg, cotpLen);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(tpduCode, 0xE0)) {
+ plc4c_s7_read_write_cotp_packet_connection_request_parse(buf, msg, cotpLen);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(tpduCode, 0xD0)) {
+ plc4c_s7_read_write_cotp_packet_connection_response_parse(buf, msg, cotpLen);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(tpduCode, 0x80)) {
+ plc4c_s7_read_write_cotp_packet_disconnect_request_parse(buf, msg, cotpLen);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(tpduCode, 0xC0)) {
+ plc4c_s7_read_write_cotp_packet_disconnect_response_parse(buf, msg, cotpLen);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(tpduCode, 0x70)) {
+ plc4c_s7_read_write_cotp_packet_tpdu_error_parse(buf, msg, cotpLen);
+ }
+
+ // Optional Field (payload) (Can be skipped, if a given expression evaluates to false)
+ curPos = io.getPos() - startPos;
+ plc4c_s7_read_write_s7_message payload = NULL;
+ if((curPos) < (cotpLen)) {
+ payload = plc4c_s7_read_write_s7_message_parse(buf);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_request.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_request.c
index 5ae4b21..167960b 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_request.c
@@ -19,6 +19,30 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet_connection_request.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_connection_request_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet_connection_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet_connection_request* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet_connection_request));
+
+ // Simple Field (destinationReference)
+ uint16_t destinationReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.destination_reference = destinationReference;
+
+ // Simple Field (sourceReference)
+ uint16_t sourceReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.source_reference = sourceReference;
+
+ // Enum field (protocolClass)
+ plc4c_s7_read_write_cotp_protocol_class protocolClass = plc4c_s7_read_write_cotp_protocol_class.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_connection_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet_connection_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_response.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_response.c
index 984ed4a..5dba755 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_connection_response.c
@@ -19,6 +19,30 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet_connection_response.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_connection_response_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet_connection_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet_connection_response* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet_connection_response));
+
+ // Simple Field (destinationReference)
+ uint16_t destinationReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.destination_reference = destinationReference;
+
+ // Simple Field (sourceReference)
+ uint16_t sourceReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.source_reference = sourceReference;
+
+ // Enum field (protocolClass)
+ plc4c_s7_read_write_cotp_protocol_class protocolClass = plc4c_s7_read_write_cotp_protocol_class.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_connection_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet_connection_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_data.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_data.c
index ab6b7bd..ebad668 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_data.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_data.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet_data.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_data_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet_data** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet_data* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet_data));
+
+ // Simple Field (eot)
+ bool eot = plc4c_spi_read_bit(buf);
+ msg.eot = eot;
+
+ // Simple Field (tpduRef)
+ unsigned int tpduRef = plc4c_spi_read_unsigned_short(buf, 7);
+ msg.tpdu_ref = tpduRef;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_data_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet_data* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_request.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_request.c
index ef238c3..f88f837 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_request.c
@@ -19,6 +19,30 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet_disconnect_request.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_disconnect_request_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet_disconnect_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet_disconnect_request* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet_disconnect_request));
+
+ // Simple Field (destinationReference)
+ uint16_t destinationReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.destination_reference = destinationReference;
+
+ // Simple Field (sourceReference)
+ uint16_t sourceReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.source_reference = sourceReference;
+
+ // Enum field (protocolClass)
+ plc4c_s7_read_write_cotp_protocol_class protocolClass = plc4c_s7_read_write_cotp_protocol_class.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_disconnect_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet_disconnect_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_response.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_response.c
index 7db81f8..e195c7f 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_disconnect_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet_disconnect_response.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_disconnect_response_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet_disconnect_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet_disconnect_response* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet_disconnect_response));
+
+ // Simple Field (destinationReference)
+ uint16_t destinationReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.destination_reference = destinationReference;
+
+ // Simple Field (sourceReference)
+ uint16_t sourceReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.source_reference = sourceReference;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_disconnect_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet_disconnect_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_tpdu_error.c b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_tpdu_error.c
index b0a28c6..274a165 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_packet_tpdu_error.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_packet_tpdu_error.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_packet_tpdu_error.h"
+plc4c_return_code plc4c_s7_read_write_cotp_packet_tpdu_error_parse(plc4c_read_buffer buf, uint16_t cotpLen, plc4c_s7_read_write_cotp_packet_tpdu_error** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_packet_tpdu_error* msg = malloc(sizeof(plc4c_s7_read_write_cotp_packet_tpdu_error));
+
+ // Simple Field (destinationReference)
+ uint16_t destinationReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.destination_reference = destinationReference;
+
+ // Simple Field (rejectCause)
+ uint8_t rejectCause = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.reject_cause = rejectCause;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_packet_tpdu_error_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_packet_tpdu_error* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter.c b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter.c
index 8f0e494..0cf7986 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter.c
@@ -19,6 +19,42 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_parameter.h"
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_parse(plc4c_read_buffer buf, uint8_t rest, plc4c_s7_read_write_cotp_parameter** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_parameter* msg = malloc(sizeof(plc4c_s7_read_write_cotp_parameter));
+
+ // Discriminator Field (parameterType) (Used as input to a switch field)
+ uint8_t parameterType = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Implicit Field (parameterLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t parameterLength = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0xC0)) {
+ plc4c_s7_read_write_cotp_parameter_tpdu_size_parse(buf, msg, rest);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0xC1)) {
+ plc4c_s7_read_write_cotp_parameter_calling_tsap_parse(buf, msg, rest);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0xC2)) {
+ plc4c_s7_read_write_cotp_parameter_called_tsap_parse(buf, msg, rest);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0xC3)) {
+ plc4c_s7_read_write_cotp_parameter_checksum_parse(buf, msg, rest);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0xE0)) {
+ plc4c_s7_read_write_cotp_parameter_disconnect_additional_information_parse(buf, msg, rest);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_parameter* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_called_tsap.c b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_called_tsap.c
index d5e9fa8..fab4a87 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_called_tsap.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_called_tsap.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_parameter_called_tsap.h"
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_called_tsap_parse(plc4c_read_buffer buf, uint8_t rest, plc4c_s7_read_write_cotp_parameter_called_tsap** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_parameter_called_tsap* msg = malloc(sizeof(plc4c_s7_read_write_cotp_parameter_called_tsap));
+
+ // Simple Field (tsapId)
+ uint16_t tsapId = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.tsap_id = tsapId;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_called_tsap_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_parameter_called_tsap* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_calling_tsap.c b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_calling_tsap.c
index 8c0769c..e060210 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_calling_tsap.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_calling_tsap.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_parameter_calling_tsap.h"
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_calling_tsap_parse(plc4c_read_buffer buf, uint8_t rest, plc4c_s7_read_write_cotp_parameter_calling_tsap** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_parameter_calling_tsap* msg = malloc(sizeof(plc4c_s7_read_write_cotp_parameter_calling_tsap));
+
+ // Simple Field (tsapId)
+ uint16_t tsapId = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.tsap_id = tsapId;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_calling_tsap_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_parameter_calling_tsap* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_checksum.c b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_checksum.c
index a4c57c9..b33f989 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_checksum.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_checksum.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_parameter_checksum.h"
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_checksum_parse(plc4c_read_buffer buf, uint8_t rest, plc4c_s7_read_write_cotp_parameter_checksum** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_parameter_checksum* msg = malloc(sizeof(plc4c_s7_read_write_cotp_parameter_checksum));
+
+ // Simple Field (crc)
+ uint8_t crc = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.crc = crc;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_checksum_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_parameter_checksum* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_disconnect_additional_information.c b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_disconnect_additional_information.c
index 8678b7b..380b27c 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_disconnect_additional_information.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_disconnect_additional_information.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_parameter_disconnect_additional_information.h"
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_disconnect_additional_information_parse(plc4c_read_buffer buf, uint8_t rest, plc4c_s7_read_write_cotp_parameter_disconnect_additional_information** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_parameter_disconnect_additional_information* msg = malloc(sizeof(plc4c_s7_read_write_cotp_parameter_disconnect_additional_information));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_disconnect_additional_information_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_parameter_disconnect_additional_information* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_tpdu_size.c b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_tpdu_size.c
index f1ec47e..9ac1142 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_tpdu_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_parameter_tpdu_size.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "cotp_parameter_tpdu_size.h"
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_tpdu_size_parse(plc4c_read_buffer buf, uint8_t rest, plc4c_s7_read_write_cotp_parameter_tpdu_size** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_cotp_parameter_tpdu_size* msg = malloc(sizeof(plc4c_s7_read_write_cotp_parameter_tpdu_size));
+
+ // Enum field (tpduSize)
+ plc4c_s7_read_write_cotp_tpdu_size tpduSize = plc4c_s7_read_write_cotp_tpdu_size.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_cotp_parameter_tpdu_size_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_cotp_parameter_tpdu_size* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_address.c b/sandbox/plc4c/generated-sources/s7/src/s7_address.c
index 99ab834..8257321 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_address.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_address.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_address.h"
+plc4c_return_code plc4c_s7_read_write_s7_address_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_address** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_address* msg = malloc(sizeof(plc4c_s7_read_write_s7_address));
+
+ // Discriminator Field (addressType) (Used as input to a switch field)
+ uint8_t addressType = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(addressType, 0x10)) {
+ plc4c_s7_read_write_s7_address_any_parse(buf, msg);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_address_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_address* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_address_any.c b/sandbox/plc4c/generated-sources/s7/src/s7_address_any.c
index fb299ce..278dfbc 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_address_any.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_address_any.c
@@ -19,6 +19,49 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_address_any.h"
+plc4c_return_code plc4c_s7_read_write_s7_address_any_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_address_any** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_address_any* msg = malloc(sizeof(plc4c_s7_read_write_s7_address_any));
+
+ // Enum field (transportSize)
+ plc4c_s7_read_write_transport_size transportSize = plc4c_s7_read_write_transport_size.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ // Simple Field (numberOfElements)
+ uint16_t numberOfElements = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.number_of_elements = numberOfElements;
+
+ // Simple Field (dbNumber)
+ uint16_t dbNumber = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.db_number = dbNumber;
+
+ // Enum field (area)
+ plc4c_s7_read_write_memory_area area = plc4c_s7_read_write_memory_area.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ unsigned int reserved = plc4c_spi_read_unsigned_short(buf, 5);
+ if(reserved != (unsigned int) 0x00) {
+ LOGGER.info("Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (byteAddress)
+ uint16_t byteAddress = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.byte_address = byteAddress;
+
+ // Simple Field (bitAddress)
+ unsigned int bitAddress = plc4c_spi_read_unsigned_byte(buf, 3);
+ msg.bit_address = bitAddress;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_address_any_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_address_any* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_message.c b/sandbox/plc4c/generated-sources/s7/src/s7_message.c
index d7e88c7..4132434 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_message.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_message.c
@@ -19,6 +19,72 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_message.h"
+plc4c_return_code plc4c_s7_read_write_s7_message_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_message** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_message* msg = malloc(sizeof(plc4c_s7_read_write_s7_message));
+
+ // Const Field (protocolId)
+ uint8_t protocolId = plc4c_spi_read_unsigned_short(buf, 8);
+ if(protocolId != S7Message.PROTOCOLID) {
+ throw new ParseException("Expected constant value " + S7Message.PROTOCOLID + " but got " + protocolId);
+ }
+
+ // Discriminator Field (messageType) (Used as input to a switch field)
+ uint8_t messageType = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ uint16_t reserved = plc4c_spi_read_unsigned_int(buf, 16);
+ if(reserved != (uint16_t) 0x0000) {
+ LOGGER.info("Expected constant value " + 0x0000 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (tpduReference)
+ uint16_t tpduReference = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.tpdu_reference = tpduReference;
+
+ // Implicit Field (parameterLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t parameterLength = plc4c_spi_read_unsigned_int(buf, 16);
+
+ // Implicit Field (payloadLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t payloadLength = plc4c_spi_read_unsigned_int(buf, 16);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(messageType, 0x01)) {
+ plc4c_s7_read_write_s7_message_request_parse(buf, msg);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(messageType, 0x02)) {
+ plc4c_s7_read_write_s7_message_response_parse(buf, msg);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(messageType, 0x03)) {
+ plc4c_s7_read_write_s7_message_response_data_parse(buf, msg);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(messageType, 0x07)) {
+ plc4c_s7_read_write_s7_message_user_data_parse(buf, msg);
+ }
+
+ // Optional Field (parameter) (Can be skipped, if a given expression evaluates to false)
+ plc4c_s7_read_write_s7_parameter parameter = NULL;
+ if((parameterLength) > (0)) {
+ parameter = plc4c_s7_read_write_s7_parameter_parse(buf, messageType);
+ }
+
+ // Optional Field (payload) (Can be skipped, if a given expression evaluates to false)
+ plc4c_s7_read_write_s7_payload payload = NULL;
+ if((payloadLength) > (0)) {
+ payload = plc4c_s7_read_write_s7_payload_parse(buf, messageType, parameter);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_message_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_message* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_message_request.c b/sandbox/plc4c/generated-sources/s7/src/s7_message_request.c
index e543edd..09a890e 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_message_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_message_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_message_request.h"
+plc4c_return_code plc4c_s7_read_write_s7_message_request_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_message_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_message_request* msg = malloc(sizeof(plc4c_s7_read_write_s7_message_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_message_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_message_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_message_response.c b/sandbox/plc4c/generated-sources/s7/src/s7_message_response.c
index 7bb1a39..db41412 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_message_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_message_response.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_message_response.h"
+plc4c_return_code plc4c_s7_read_write_s7_message_response_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_message_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_message_response* msg = malloc(sizeof(plc4c_s7_read_write_s7_message_response));
+
+ // Simple Field (errorClass)
+ uint8_t errorClass = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.error_class = errorClass;
+
+ // Simple Field (errorCode)
+ uint8_t errorCode = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.error_code = errorCode;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_message_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_message_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_message_response_data.c b/sandbox/plc4c/generated-sources/s7/src/s7_message_response_data.c
index 83c1779..de4d9ac 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_message_response_data.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_message_response_data.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_message_response_data.h"
+plc4c_return_code plc4c_s7_read_write_s7_message_response_data_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_message_response_data** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_message_response_data* msg = malloc(sizeof(plc4c_s7_read_write_s7_message_response_data));
+
+ // Simple Field (errorClass)
+ uint8_t errorClass = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.error_class = errorClass;
+
+ // Simple Field (errorCode)
+ uint8_t errorCode = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.error_code = errorCode;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_message_response_data_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_message_response_data* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_message_user_data.c b/sandbox/plc4c/generated-sources/s7/src/s7_message_user_data.c
index 2abf318..6af0c2b 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_message_user_data.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_message_user_data.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_message_user_data.h"
+plc4c_return_code plc4c_s7_read_write_s7_message_user_data_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_message_user_data** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_message_user_data* msg = malloc(sizeof(plc4c_s7_read_write_s7_message_user_data));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_message_user_data_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_message_user_data* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter.c
index 8583c72..540b519 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter.c
@@ -19,6 +19,42 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter));
+
+ // Discriminator Field (parameterType) (Used as input to a switch field)
+ uint8_t parameterType = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0xF0)) {
+ plc4c_s7_read_write_s7_parameter_setup_communication_parse(buf, msg, messageType);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0x04) && plc4c_spi_evaluation_helper_equals(messageType, 0x01)) {
+ plc4c_s7_read_write_s7_parameter_read_var_request_parse(buf, msg, messageType);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0x04) && plc4c_spi_evaluation_helper_equals(messageType, 0x03)) {
+ plc4c_s7_read_write_s7_parameter_read_var_response_parse(buf, msg, messageType);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0x05) && plc4c_spi_evaluation_helper_equals(messageType, 0x01)) {
+ plc4c_s7_read_write_s7_parameter_write_var_request_parse(buf, msg, messageType);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0x05) && plc4c_spi_evaluation_helper_equals(messageType, 0x03)) {
+ plc4c_s7_read_write_s7_parameter_write_var_response_parse(buf, msg, messageType);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameterType, 0x00) && plc4c_spi_evaluation_helper_equals(messageType, 0x07)) {
+ plc4c_s7_read_write_s7_parameter_user_data_parse(buf, msg, messageType);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_request.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_request.c
index 49b6793..c114ba1 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_request.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_read_var_request.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_read_var_request_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter_read_var_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_read_var_request* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_read_var_request));
+
+ // Implicit Field (numItems) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t numItems = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_read_var_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_read_var_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_response.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_response.c
index edb7af9..ea26140 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_read_var_response.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_read_var_response.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_read_var_response_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter_read_var_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_read_var_response* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_read_var_response));
+
+ // Simple Field (numItems)
+ uint8_t numItems = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.num_items = numItems;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_read_var_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_read_var_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_setup_communication.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_setup_communication.c
index e5cba40..90cffb5 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_setup_communication.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_setup_communication.c
@@ -19,6 +19,39 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_setup_communication.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_setup_communication_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter_setup_communication** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_setup_communication* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_setup_communication));
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ uint8_t reserved = plc4c_spi_read_unsigned_short(buf, 8);
+ if(reserved != (uint8_t) 0x00) {
+ LOGGER.info("Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (maxAmqCaller)
+ uint16_t maxAmqCaller = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.max_amq_caller = maxAmqCaller;
+
+ // Simple Field (maxAmqCallee)
+ uint16_t maxAmqCallee = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.max_amq_callee = maxAmqCallee;
+
+ // Simple Field (pduLength)
+ uint16_t pduLength = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.pdu_length = pduLength;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_setup_communication_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_setup_communication* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data.c
index a07c057..2c43f2c 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_user_data.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_user_data_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter_user_data** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_user_data* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_user_data));
+
+ // Implicit Field (numItems) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t numItems = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_user_data_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_user_data* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item.c
index 9ddf7c7..eea731c 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_user_data_item.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_user_data_item_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_parameter_user_data_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_user_data_item* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_user_data_item));
+
+ // Discriminator Field (itemType) (Used as input to a switch field)
+ uint8_t itemType = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(itemType, 0x12)) {
+ plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions_parse(buf, msg);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_user_data_item_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_user_data_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item_cpu_functions.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item_cpu_functions.c
index 46e71e4..a2b28e6 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item_cpu_functions.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_user_data_item_cpu_functions.c
@@ -19,6 +19,60 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_user_data_item_cpu_functions.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions));
+
+ // Implicit Field (itemLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t itemLength = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Simple Field (method)
+ uint8_t method = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.method = method;
+
+ // Simple Field (cpuFunctionType)
+ unsigned int cpuFunctionType = plc4c_spi_read_unsigned_byte(buf, 4);
+ msg.cpu_function_type = cpuFunctionType;
+
+ // Simple Field (cpuFunctionGroup)
+ unsigned int cpuFunctionGroup = plc4c_spi_read_unsigned_byte(buf, 4);
+ msg.cpu_function_group = cpuFunctionGroup;
+
+ // Simple Field (cpuSubfunction)
+ uint8_t cpuSubfunction = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.cpu_subfunction = cpuSubfunction;
+
+ // Simple Field (sequenceNumber)
+ uint8_t sequenceNumber = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.sequence_number = sequenceNumber;
+
+ // Optional Field (dataUnitReferenceNumber) (Can be skipped, if a given expression evaluates to false)
+ uint8_t dataUnitReferenceNumber = NULL;
+ if((cpuFunctionType) == (8)) {
+ dataUnitReferenceNumber = plc4c_spi_read_unsigned_short(buf, 8);
+ }
+
+ // Optional Field (lastDataUnit) (Can be skipped, if a given expression evaluates to false)
+ uint8_t lastDataUnit = NULL;
+ if((cpuFunctionType) == (8)) {
+ lastDataUnit = plc4c_spi_read_unsigned_short(buf, 8);
+ }
+
+ // Optional Field (errorCode) (Can be skipped, if a given expression evaluates to false)
+ uint16_t errorCode = NULL;
+ if((cpuFunctionType) == (8)) {
+ errorCode = plc4c_spi_read_unsigned_int(buf, 16);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_user_data_item_cpu_functions* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_request.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_request.c
index 2ed61c4..7b85c1b 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_request.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_write_var_request.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_write_var_request_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter_write_var_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_write_var_request* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_write_var_request));
+
+ // Implicit Field (numItems) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t numItems = plc4c_spi_read_unsigned_short(buf, 8);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_write_var_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_write_var_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_response.c b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_response.c
index ff4da65..611b411 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_parameter_write_var_response.c
@@ -19,6 +19,23 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_parameter_write_var_response.h"
+plc4c_return_code plc4c_s7_read_write_s7_parameter_write_var_response_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter_write_var_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_parameter_write_var_response* msg = malloc(sizeof(plc4c_s7_read_write_s7_parameter_write_var_response));
+
+ // Simple Field (numItems)
+ uint8_t numItems = plc4c_spi_read_unsigned_short(buf, 8);
+ msg.num_items = numItems;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_parameter_write_var_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_parameter_write_var_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload.c
index f659c26..6db858a 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload.c
@@ -19,6 +19,33 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter parameter, plc4c_s7_read_write_s7_payload** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload));
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(parameter.getDiscriminatorValues()[0], 0x04) && plc4c_spi_evaluation_helper_equals(messageType, 0x03)) {
+ plc4c_s7_read_write_s7_payload_read_var_response_parse(buf, msg, messageType, parameter);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameter.getDiscriminatorValues()[0], 0x05) && plc4c_spi_evaluation_helper_equals(messageType, 0x01)) {
+ plc4c_s7_read_write_s7_payload_write_var_request_parse(buf, msg, messageType, parameter);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameter.getDiscriminatorValues()[0], 0x05) && plc4c_spi_evaluation_helper_equals(messageType, 0x03)) {
+ plc4c_s7_read_write_s7_payload_write_var_response_parse(buf, msg, messageType, parameter);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(parameter.getDiscriminatorValues()[0], 0x00) && plc4c_spi_evaluation_helper_equals(messageType, 0x07)) {
+ plc4c_s7_read_write_s7_payload_user_data_parse(buf, msg, messageType, parameter);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_read_var_response.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_read_var_response.c
index 7132b16..b819f01 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_read_var_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_read_var_response.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_read_var_response.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_read_var_response_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter parameter, plc4c_s7_read_write_s7_payload_read_var_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_read_var_response* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_read_var_response));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_read_var_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_read_var_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data.c
index 5103869..ed2b159 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_user_data.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter parameter, plc4c_s7_read_write_s7_payload_user_data** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_user_data* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_user_data));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_user_data* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
index 9e7ddfb..a6f2a4b 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
@@ -19,6 +19,44 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_user_data_item.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_parse(plc4c_read_buffer buf, unsigned int cpuFunctionType, plc4c_s7_read_write_s7_payload_user_data_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_user_data_item* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_user_data_item));
+
+ // Enum field (returnCode)
+ plc4c_s7_read_write_data_transport_error_code returnCode = plc4c_s7_read_write_data_transport_error_code.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ // Enum field (transportSize)
+ plc4c_s7_read_write_data_transport_size transportSize = plc4c_s7_read_write_data_transport_size.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ // Implicit Field (dataLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t dataLength = plc4c_spi_read_unsigned_int(buf, 16);
+
+ // Simple Field (szlId)
+ plc4c_s7_read_write_szl_id szlId = plc4c_s7_read_write_szl_id_parse(buf);
+ msg.szl_id = szlId;
+
+ // Simple Field (szlIndex)
+ uint16_t szlIndex = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.szl_index = szlIndex;
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(cpuFunctionType, 0x04)) {
+ plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request_parse(buf, msg, cpuFunctionType);
+ } else
+ if(plc4c_spi_evaluation_helper_equals(cpuFunctionType, 0x08)) {
+ plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response_parse(buf, msg, cpuFunctionType);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_user_data_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_request.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_request.c
index 6f201ab..4c14644 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_user_data_item_cpu_function_read_szl_request.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request_parse(plc4c_read_buffer buf, unsigned int cpuFunctionType, plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_response.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_response.c
index 880ce6a..249c067 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_user_data_item_cpu_function_read_szl_response.c
@@ -19,6 +19,28 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_user_data_item_cpu_function_read_szl_response.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response_parse(plc4c_read_buffer buf, unsigned int cpuFunctionType, plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response));
+
+ // Const Field (szlItemLength)
+ uint16_t szlItemLength = plc4c_spi_read_unsigned_int(buf, 16);
+ if(szlItemLength != S7PayloadUserDataItemCpuFunctionReadSzlResponse.SZLITEMLENGTH) {
+ throw new ParseException("Expected constant value " + S7PayloadUserDataItemCpuFunctionReadSzlResponse.SZLITEMLENGTH + " but got " + szlItemLength);
+ }
+
+ // Implicit Field (szlItemCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t szlItemCount = plc4c_spi_read_unsigned_int(buf, 16);
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_read_szl_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_request.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_request.c
index 0b227de..948579d 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_request.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_request.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_write_var_request.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_write_var_request_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter parameter, plc4c_s7_read_write_s7_payload_write_var_request** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_write_var_request* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_write_var_request));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_write_var_request_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_write_var_request* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_response.c b/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_response.c
index d7f9047..6992b30 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_response.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_payload_write_var_response.c
@@ -19,6 +19,19 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_payload_write_var_response.h"
+plc4c_return_code plc4c_s7_read_write_s7_payload_write_var_response_parse(plc4c_read_buffer buf, uint8_t messageType, plc4c_s7_read_write_s7_parameter parameter, plc4c_s7_read_write_s7_payload_write_var_response** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_payload_write_var_response* msg = malloc(sizeof(plc4c_s7_read_write_s7_payload_write_var_response));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_payload_write_var_response_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_payload_write_var_response* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c b/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c
index 8deea8e..35a304d 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c
@@ -19,6 +19,36 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_var_payload_data_item.h"
+plc4c_return_code plc4c_s7_read_write_s7_var_payload_data_item_parse(plc4c_read_buffer buf, bool lastItem, plc4c_s7_read_write_s7_var_payload_data_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_var_payload_data_item* msg = malloc(sizeof(plc4c_s7_read_write_s7_var_payload_data_item));
+
+ // Enum field (returnCode)
+ plc4c_s7_read_write_data_transport_error_code returnCode = plc4c_s7_read_write_data_transport_error_code.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ // Enum field (transportSize)
+ plc4c_s7_read_write_data_transport_size transportSize = plc4c_s7_read_write_data_transport_size.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ // Simple Field (dataLength)
+ uint16_t dataLength = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.data_length = dataLength;
+
+ // Padding Field (pad)
+ bool _padNeedsPadding = (bool) ((plc4c_spi_read_has_more(buf, 8)) && ((!(lastItem)) && (((((COUNT(data)) % (2))) == (1)))));
+ if(_padNeedsPadding) {
+ // Just read the padding data and ignore it
+ plc4c_spi_read_unsigned_short(buf, 8);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_var_payload_data_item_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_var_payload_data_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_status_item.c b/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_status_item.c
index a8e0f20..b99ee44 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_status_item.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_var_payload_status_item.c
@@ -19,6 +19,22 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_var_payload_status_item.h"
+plc4c_return_code plc4c_s7_read_write_s7_var_payload_status_item_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_var_payload_status_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_var_payload_status_item* msg = malloc(sizeof(plc4c_s7_read_write_s7_var_payload_status_item));
+
+ // Enum field (returnCode)
+ plc4c_s7_read_write_data_transport_error_code returnCode = plc4c_s7_read_write_data_transport_error_code.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_var_payload_status_item_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_var_payload_status_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item.c b/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item.c
index 9896a5f..0273d79 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item.c
@@ -19,6 +19,27 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_var_request_parameter_item.h"
+plc4c_return_code plc4c_s7_read_write_s7_var_request_parameter_item_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_var_request_parameter_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_var_request_parameter_item* msg = malloc(sizeof(plc4c_s7_read_write_s7_var_request_parameter_item));
+
+ // Discriminator Field (itemType) (Used as input to a switch field)
+ uint8_t itemType = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ if(plc4c_spi_evaluation_helper_equals(itemType, 0x12)) {
+ plc4c_s7_read_write_s7_var_request_parameter_item_address_parse(buf, msg);
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_var_request_parameter_item_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_var_request_parameter_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item_address.c b/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item_address.c
index 17c12dd..969768e 100644
--- a/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item_address.c
+++ b/sandbox/plc4c/generated-sources/s7/src/s7_var_request_parameter_item_address.c
@@ -19,6 +19,26 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "s7_var_request_parameter_item_address.h"
+plc4c_return_code plc4c_s7_read_write_s7_var_request_parameter_item_address_parse(plc4c_read_buffer buf, plc4c_s7_read_write_s7_var_request_parameter_item_address** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_s7_var_request_parameter_item_address* msg = malloc(sizeof(plc4c_s7_read_write_s7_var_request_parameter_item_address));
+
+ // Implicit Field (itemLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint8_t itemLength = plc4c_spi_read_unsigned_short(buf, 8);
+
+ // Simple Field (address)
+ plc4c_s7_read_write_s7_address address = plc4c_s7_read_write_s7_address_parse(buf);
+ msg.address = address;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_s7_var_request_parameter_item_address_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_s7_var_request_parameter_item_address* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/szl_data_tree_item.c b/sandbox/plc4c/generated-sources/s7/src/szl_data_tree_item.c
index e35d755..5705d3e 100644
--- a/sandbox/plc4c/generated-sources/s7/src/szl_data_tree_item.c
+++ b/sandbox/plc4c/generated-sources/s7/src/szl_data_tree_item.c
@@ -19,6 +19,35 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "szl_data_tree_item.h"
+plc4c_return_code plc4c_s7_read_write_szl_data_tree_item_parse(plc4c_read_buffer buf, plc4c_s7_read_write_szl_data_tree_item** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_szl_data_tree_item* msg = malloc(sizeof(plc4c_s7_read_write_szl_data_tree_item));
+
+ // Simple Field (itemIndex)
+ uint16_t itemIndex = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.item_index = itemIndex;
+
+ // Simple Field (moduleTypeId)
+ uint16_t moduleTypeId = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.module_type_id = moduleTypeId;
+
+ // Simple Field (ausbg)
+ uint16_t ausbg = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.ausbg = ausbg;
+
+ // Simple Field (ausbe)
+ uint16_t ausbe = plc4c_spi_read_unsigned_int(buf, 16);
+ msg.ausbe = ausbe;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_szl_data_tree_item_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_szl_data_tree_item* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/szl_id.c b/sandbox/plc4c/generated-sources/s7/src/szl_id.c
index 52d5351..c98404d 100644
--- a/sandbox/plc4c/generated-sources/s7/src/szl_id.c
+++ b/sandbox/plc4c/generated-sources/s7/src/szl_id.c
@@ -19,6 +19,29 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "szl_id.h"
+plc4c_return_code plc4c_s7_read_write_szl_id_parse(plc4c_read_buffer buf, plc4c_s7_read_write_szl_id** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_szl_id* msg = malloc(sizeof(plc4c_s7_read_write_szl_id));
+
+ // Enum field (typeClass)
+ plc4c_s7_read_write_szl_module_type_class typeClass = plc4c_s7_read_write_szl_module_type_class.valueOf(plc4c_spi_read_byte(buf, 4));
+
+ // Simple Field (sublistExtract)
+ unsigned int sublistExtract = plc4c_spi_read_unsigned_byte(buf, 4);
+ msg.sublist_extract = sublistExtract;
+
+ // Enum field (sublistList)
+ plc4c_s7_read_write_szl_sublist sublistList = plc4c_s7_read_write_szl_sublist.valueOf(plc4c_spi_read_byte(buf, 8));
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_szl_id_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_szl_id* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/tpkt_packet.c b/sandbox/plc4c/generated-sources/s7/src/tpkt_packet.c
index d832238..057b788 100644
--- a/sandbox/plc4c/generated-sources/s7/src/tpkt_packet.c
+++ b/sandbox/plc4c/generated-sources/s7/src/tpkt_packet.c
@@ -19,6 +19,40 @@
#include <plc4c/spi/read_buffer.h>
#include <plc4c/spi/write_buffer.h>
+#include <plc4c/spi/evaluation_helper.h>
#include "tpkt_packet.h"
+plc4c_return_code plc4c_s7_read_write_tpkt_packet_parse(plc4c_read_buffer buf, plc4c_s7_read_write_tpkt_packet** message) {
+ uint16_t start_pos = plc4c_spi_read_get_pos(buf);
+ uint16_t cur_pos;
+
+ plc4c_s7_read_write_tpkt_packet* msg = malloc(sizeof(plc4c_s7_read_write_tpkt_packet));
+
+ // Const Field (protocolId)
+ uint8_t protocolId = plc4c_spi_read_unsigned_short(buf, 8);
+ if(protocolId != TPKTPacket.PROTOCOLID) {
+ throw new ParseException("Expected constant value " + TPKTPacket.PROTOCOLID + " but got " + protocolId);
+ }
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ uint8_t reserved = plc4c_spi_read_unsigned_short(buf, 8);
+ if(reserved != (uint8_t) 0x00) {
+ LOGGER.info("Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Implicit Field (len) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ uint16_t len = plc4c_spi_read_unsigned_int(buf, 16);
+
+ // Simple Field (payload)
+ plc4c_s7_read_write_cotp_packet payload = plc4c_s7_read_write_cotp_packet_parse(buf, (len) - (4));
+ msg.payload = payload;
+
+ return OK;
+}
+
+plc4c_return_code plc4c_s7_read_write_tpkt_packet_serialize(plc4c_write_buffer buf, plc4c_s7_read_write_tpkt_packet* message) {
+ return OK;
+}
diff --git a/sandbox/plc4c/spi/include/plc4c/spi/evaluation_helper.h b/sandbox/plc4c/spi/include/plc4c/spi/evaluation_helper.h
new file mode 100644
index 0000000..41fc1a1
--- /dev/null
+++ b/sandbox/plc4c/spi/include/plc4c/spi/evaluation_helper.h
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+#ifndef PLC4C_SPI_EVALUATION_HELPER_H_
+#define PLC4C_SPI_EVALUATION_HELPER_H_
+
+#include <stdbool.h>
+
+bool plc4c_spi_evaluation_helper_equals(int a, int b);
+
+#endif // PLC4C_SPI_EVALUATION_HELPER_H_
diff --git a/sandbox/plc4c/spi/src/evaluation_helper.c b/sandbox/plc4c/spi/src/evaluation_helper.c
new file mode 100644
index 0000000..36d320c
--- /dev/null
+++ b/sandbox/plc4c/spi/src/evaluation_helper.c
@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <plc4c/spi/evaluation_helper.h>
+
+#include <stdbool.h>
+
+bool plc4c_spi_evaluation_helper_equals(int a, int b) {
+ return a == b;
+}
+