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/10/23 08:20:28 UTC
[plc4x] 02/02: - Fixed the enum support of string-typed-enums in C
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/plc4go
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit 9bf1659ff30a4cff980a7b20aa7c0a24289bd68a
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Fri Oct 23 10:20:16 2020 +0200
- Fixed the enum support of string-typed-enums in C
---
.../resources/templates/c/enum-template-c.ftlh | 6 +-
.../resources/templates/c/enum-template-h.ftlh | 2 +-
.../generated-sources/modbus/include/data_item.h | 2 +-
.../modbus/include/modbus_data_type.h | 77 +++++
.../modbus/include/modbus_data_type_sizes.h | 76 ++++
.../modbus/include/modbus_error_code.h | 57 +++
.../plc4c/generated-sources/modbus/src/data_item.c | 2 +-
.../modbus/src/modbus_data_type.c | 305 ++++++++++++++++
.../modbus/src/modbus_data_type_sizes.c | 296 ++++++++++++++++
.../modbus/src/modbus_error_code.c | 105 ++++++
.../generated-sources/s7/src/cotp_protocol_class.c | 20 +-
.../generated-sources/s7/src/cotp_tpdu_size.c | 42 +--
.../s7/src/data_transport_error_code.c | 24 +-
.../generated-sources/s7/src/data_transport_size.c | 42 +--
.../plc4c/generated-sources/s7/src/device_group.c | 12 +-
.../plc4c/generated-sources/s7/src/memory_area.c | 54 +--
.../s7/src/szl_module_type_class.c | 16 +-
.../plc4c/generated-sources/s7/src/szl_sublist.c | 76 ++--
.../generated-sources/s7/src/transport_size.c | 384 ++++++++++-----------
19 files changed, 1257 insertions(+), 341 deletions(-)
diff --git a/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh b/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh
index f8d9d20..2be06b4 100644
--- a/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh
+++ b/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh
@@ -58,7 +58,7 @@ ${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_null() {
${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_value_of(char* value_string) {
<#list helper.getUniqueEnumValues(type.enumValues) as enumValue>
if(strcmp(value_string, "${enumValue.name}") == 0) {
- return ${enumValue.value};
+ return ${helper.getCTypeName(type.name)}_${enumValue.name};
}
</#list>
return -1;
@@ -72,7 +72,7 @@ ${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_value_for_in
switch(index) {
<#list helper.getUniqueEnumValues(type.enumValues) as enumValue>
case ${enumValue?index}: {
- return ${enumValue.value};
+ return ${helper.getCTypeName(type.name)}_${enumValue.name};
}
</#list>
default: {
@@ -91,7 +91,7 @@ ${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_value_for_in
${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName))} ${helper.getCTypeName(type.name)}_get_${helper.camelCaseToSnakeCase(constantName)}(${helper.getCTypeName(type.name)} value) {
switch(value) {
<#list helper.getUniqueEnumValues(type.enumValues) as enumValue>
- case ${helper.escapeValue(type.type, enumValue.value)}: { /* '${enumValue.value}' */
+ case ${helper.getCTypeName(type.name)}_${enumValue.name}: { /* '${enumValue.value}' */
return ${helper.escapeEnumValue(type.getConstantType(constantName), enumValue.getConstant(constantName))?no_esc};
}<#sep>
</#sep></#list>
diff --git a/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh b/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh
index 223294b..266c39b 100644
--- a/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh
+++ b/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh
@@ -59,7 +59,7 @@ extern "C" {
-->
enum ${helper.getCTypeName(type.name)} {
<#list type.enumValues as enumValue>
- ${helper.getCTypeName(type.name)}_${enumValue.name} = ${enumValue.value}<#sep>,
+ ${helper.getCTypeName(type.name)}_${enumValue.name} = <#if helper.isStringTypeReference(type.type)>${enumValue?index}<#else>${enumValue.value}</#if><#sep>,
</#sep></#list>
};
diff --git a/sandbox/plc4c/generated-sources/modbus/include/data_item.h b/sandbox/plc4c/generated-sources/modbus/include/data_item.h
index d26c489..8b2aa04 100644
--- a/sandbox/plc4c/generated-sources/modbus/include/data_item.h
+++ b/sandbox/plc4c/generated-sources/modbus/include/data_item.h
@@ -29,7 +29,7 @@
extern "C" {
#endif
-plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* buf, char* dataType, uint8_t numberOfValues, plc4c_data** data_item);
+plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* buf, char* dataType, uint16_t numberOfValues, plc4c_data** data_item);
plc4c_return_code plc4c_modbus_read_write_data_item_serialize(plc4c_spi_write_buffer* buf, plc4c_data** data_item);
diff --git a/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h
new file mode 100644
index 0000000..5430652
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h
@@ -0,0 +1,77 @@
+/*
+ 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_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_H_
+#define PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum plc4c_modbus_read_write_modbus_data_type {
+ plc4c_modbus_read_write_modbus_data_type_NULL = 00,
+ plc4c_modbus_read_write_modbus_data_type_BOOL = 01,
+ plc4c_modbus_read_write_modbus_data_type_BYTE = 10,
+ plc4c_modbus_read_write_modbus_data_type_WORD = 11,
+ plc4c_modbus_read_write_modbus_data_type_DWORD = 12,
+ plc4c_modbus_read_write_modbus_data_type_LWORD = 13,
+ plc4c_modbus_read_write_modbus_data_type_SINT = 20,
+ plc4c_modbus_read_write_modbus_data_type_INT = 21,
+ plc4c_modbus_read_write_modbus_data_type_DINT = 22,
+ plc4c_modbus_read_write_modbus_data_type_LINT = 23,
+ plc4c_modbus_read_write_modbus_data_type_USINT = 24,
+ plc4c_modbus_read_write_modbus_data_type_UINT = 25,
+ plc4c_modbus_read_write_modbus_data_type_UDINT = 26,
+ plc4c_modbus_read_write_modbus_data_type_ULINT = 27,
+ plc4c_modbus_read_write_modbus_data_type_REAL = 30,
+ plc4c_modbus_read_write_modbus_data_type_LREAL = 31,
+ plc4c_modbus_read_write_modbus_data_type_TIME = 40,
+ plc4c_modbus_read_write_modbus_data_type_LTIME = 41,
+ plc4c_modbus_read_write_modbus_data_type_DATE = 50,
+ plc4c_modbus_read_write_modbus_data_type_LDATE = 51,
+ plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY = 60,
+ plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY = 61,
+ plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME = 70,
+ plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME = 71,
+ plc4c_modbus_read_write_modbus_data_type_CHAR = 80,
+ plc4c_modbus_read_write_modbus_data_type_WCHAR = 81,
+ plc4c_modbus_read_write_modbus_data_type_STRING = 82,
+ plc4c_modbus_read_write_modbus_data_type_WSTRING = 83
+};
+typedef enum plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type;
+
+// Get an empty NULL-struct
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_null();
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_of(char* value_string);
+
+int plc4c_modbus_read_write_modbus_data_type_num_values();
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_for_index(int index);
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_get_data_type_size(plc4c_modbus_read_write_modbus_data_type value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_H_
diff --git a/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h
new file mode 100644
index 0000000..945e5e1
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h
@@ -0,0 +1,76 @@
+/*
+ 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_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_SIZES_H_
+#define PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_SIZES_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum plc4c_modbus_read_write_modbus_data_type_sizes {
+ plc4c_modbus_read_write_modbus_data_type_sizes_BOOL = 0,
+ plc4c_modbus_read_write_modbus_data_type_sizes_BYTE = 1,
+ plc4c_modbus_read_write_modbus_data_type_sizes_WORD = 2,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DWORD = 3,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LWORD = 4,
+ plc4c_modbus_read_write_modbus_data_type_sizes_SINT = 5,
+ plc4c_modbus_read_write_modbus_data_type_sizes_INT = 6,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DINT = 7,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LINT = 8,
+ plc4c_modbus_read_write_modbus_data_type_sizes_USINT = 9,
+ plc4c_modbus_read_write_modbus_data_type_sizes_UINT = 10,
+ plc4c_modbus_read_write_modbus_data_type_sizes_UDINT = 11,
+ plc4c_modbus_read_write_modbus_data_type_sizes_ULINT = 12,
+ plc4c_modbus_read_write_modbus_data_type_sizes_REAL = 13,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LREAL = 14,
+ plc4c_modbus_read_write_modbus_data_type_sizes_TIME = 15,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LTIME = 16,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DATE = 17,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LDATE = 18,
+ plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY = 19,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY = 20,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME = 21,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME = 22,
+ plc4c_modbus_read_write_modbus_data_type_sizes_CHAR = 23,
+ plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR = 24,
+ plc4c_modbus_read_write_modbus_data_type_sizes_STRING = 25,
+ plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING = 26
+};
+typedef enum plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes;
+
+// Get an empty NULL-struct
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_null();
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_of(char* value_string);
+
+int plc4c_modbus_read_write_modbus_data_type_sizes_num_values();
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_for_index(int index);
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_sizes_get_data_type_size(plc4c_modbus_read_write_modbus_data_type_sizes value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_SIZES_H_
diff --git a/sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h b/sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h
new file mode 100644
index 0000000..3a452e6
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h
@@ -0,0 +1,57 @@
+/*
+ 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_MODBUS_READ_WRITE_MODBUS_ERROR_CODE_H_
+#define PLC4C_MODBUS_READ_WRITE_MODBUS_ERROR_CODE_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum plc4c_modbus_read_write_modbus_error_code {
+ plc4c_modbus_read_write_modbus_error_code_ILLEGAL_FUNCTION = 1,
+ plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_ADDRESS = 2,
+ plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_VALUE = 3,
+ plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_FAILURE = 4,
+ plc4c_modbus_read_write_modbus_error_code_ACKNOWLEDGE = 5,
+ plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_BUSY = 6,
+ plc4c_modbus_read_write_modbus_error_code_NEGATIVE_ACKNOWLEDGE = 7,
+ plc4c_modbus_read_write_modbus_error_code_MEMORY_PARITY_ERROR = 8,
+ plc4c_modbus_read_write_modbus_error_code_GATEWAY_PATH_UNAVAILABLE = 10,
+ plc4c_modbus_read_write_modbus_error_code_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
+};
+typedef enum plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code;
+
+// Get an empty NULL-struct
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_null();
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_of(char* value_string);
+
+int plc4c_modbus_read_write_modbus_error_code_num_values();
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_for_index(int index);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PLC4C_MODBUS_READ_WRITE_MODBUS_ERROR_CODE_H_
diff --git a/sandbox/plc4c/generated-sources/modbus/src/data_item.c b/sandbox/plc4c/generated-sources/modbus/src/data_item.c
index a801284..0980c00 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/data_item.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/data_item.c
@@ -26,7 +26,7 @@
#include "data_item.h"
// Parse function.
-plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* io, char* dataType, uint8_t numberOfValues, plc4c_data** data_item) {
+plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* io, char* dataType, uint16_t numberOfValues, plc4c_data** data_item) {
uint16_t startPos = plc4c_spi_read_get_pos(io);
uint16_t curPos;
plc4c_return_code _res = OK;
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c
new file mode 100644
index 0000000..abee4ac
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c
@@ -0,0 +1,305 @@
+/*
+ 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 "modbus_data_type.h"
+#include <string.h>
+
+
+// Create an empty NULL-struct
+static const plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_null_const;
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_null() {
+ return plc4c_modbus_read_write_modbus_data_type_null_const;
+}
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_of(char* value_string) {
+ if(strcmp(value_string, "NULL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_NULL;
+ }
+ if(strcmp(value_string, "BOOL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_BOOL;
+ }
+ if(strcmp(value_string, "BYTE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_BYTE;
+ }
+ if(strcmp(value_string, "WORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_WORD;
+ }
+ if(strcmp(value_string, "DWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DWORD;
+ }
+ if(strcmp(value_string, "LWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LWORD;
+ }
+ if(strcmp(value_string, "SINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_SINT;
+ }
+ if(strcmp(value_string, "INT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_INT;
+ }
+ if(strcmp(value_string, "DINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DINT;
+ }
+ if(strcmp(value_string, "LINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LINT;
+ }
+ if(strcmp(value_string, "USINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_USINT;
+ }
+ if(strcmp(value_string, "UINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_UINT;
+ }
+ if(strcmp(value_string, "UDINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_UDINT;
+ }
+ if(strcmp(value_string, "ULINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_ULINT;
+ }
+ if(strcmp(value_string, "REAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_REAL;
+ }
+ if(strcmp(value_string, "LREAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LREAL;
+ }
+ if(strcmp(value_string, "TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_TIME;
+ }
+ if(strcmp(value_string, "LTIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME;
+ }
+ if(strcmp(value_string, "DATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DATE;
+ }
+ if(strcmp(value_string, "LDATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE;
+ }
+ if(strcmp(value_string, "TIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY;
+ }
+ if(strcmp(value_string, "LTIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY;
+ }
+ if(strcmp(value_string, "DATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME;
+ }
+ if(strcmp(value_string, "LDATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME;
+ }
+ if(strcmp(value_string, "CHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_CHAR;
+ }
+ if(strcmp(value_string, "WCHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_WCHAR;
+ }
+ if(strcmp(value_string, "STRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_STRING;
+ }
+ if(strcmp(value_string, "WSTRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_WSTRING;
+ }
+ return -1;
+}
+
+int plc4c_modbus_read_write_modbus_data_type_num_values() {
+ return 28;
+}
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_for_index(int index) {
+ switch(index) {
+ case 0: {
+ return plc4c_modbus_read_write_modbus_data_type_NULL;
+ }
+ case 1: {
+ return plc4c_modbus_read_write_modbus_data_type_BOOL;
+ }
+ case 2: {
+ return plc4c_modbus_read_write_modbus_data_type_BYTE;
+ }
+ case 3: {
+ return plc4c_modbus_read_write_modbus_data_type_WORD;
+ }
+ case 4: {
+ return plc4c_modbus_read_write_modbus_data_type_DWORD;
+ }
+ case 5: {
+ return plc4c_modbus_read_write_modbus_data_type_LWORD;
+ }
+ case 6: {
+ return plc4c_modbus_read_write_modbus_data_type_SINT;
+ }
+ case 7: {
+ return plc4c_modbus_read_write_modbus_data_type_INT;
+ }
+ case 8: {
+ return plc4c_modbus_read_write_modbus_data_type_DINT;
+ }
+ case 9: {
+ return plc4c_modbus_read_write_modbus_data_type_LINT;
+ }
+ case 10: {
+ return plc4c_modbus_read_write_modbus_data_type_USINT;
+ }
+ case 11: {
+ return plc4c_modbus_read_write_modbus_data_type_UINT;
+ }
+ case 12: {
+ return plc4c_modbus_read_write_modbus_data_type_UDINT;
+ }
+ case 13: {
+ return plc4c_modbus_read_write_modbus_data_type_ULINT;
+ }
+ case 14: {
+ return plc4c_modbus_read_write_modbus_data_type_REAL;
+ }
+ case 15: {
+ return plc4c_modbus_read_write_modbus_data_type_LREAL;
+ }
+ case 16: {
+ return plc4c_modbus_read_write_modbus_data_type_TIME;
+ }
+ case 17: {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME;
+ }
+ case 18: {
+ return plc4c_modbus_read_write_modbus_data_type_DATE;
+ }
+ case 19: {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE;
+ }
+ case 20: {
+ return plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY;
+ }
+ case 21: {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY;
+ }
+ case 22: {
+ return plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME;
+ }
+ case 23: {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME;
+ }
+ case 24: {
+ return plc4c_modbus_read_write_modbus_data_type_CHAR;
+ }
+ case 25: {
+ return plc4c_modbus_read_write_modbus_data_type_WCHAR;
+ }
+ case 26: {
+ return plc4c_modbus_read_write_modbus_data_type_STRING;
+ }
+ case 27: {
+ return plc4c_modbus_read_write_modbus_data_type_WSTRING;
+ }
+ default: {
+ return -1;
+ }
+ }
+}
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_get_data_type_size(plc4c_modbus_read_write_modbus_data_type value) {
+ switch(value) {
+ case plc4c_modbus_read_write_modbus_data_type_NULL: { /* '00' */
+ return 0;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_BOOL: { /* '01' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_BYTE: { /* '10' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_WORD: { /* '11' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DWORD: { /* '12' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LWORD: { /* '13' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_SINT: { /* '20' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_INT: { /* '21' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DINT: { /* '22' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LINT: { /* '23' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_USINT: { /* '24' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_UINT: { /* '25' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_UDINT: { /* '26' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_ULINT: { /* '27' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_REAL: { /* '30' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LREAL: { /* '31' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_TIME: { /* '40' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LTIME: { /* '41' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DATE: { /* '50' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LDATE: { /* '51' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY: { /* '60' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY: { /* '61' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME: { /* '70' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME: { /* '71' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_CHAR: { /* '80' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_WCHAR: { /* '81' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_STRING: { /* '82' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_WSTRING: { /* '83' */
+ return 2;
+ }
+ default: {
+ return 0;
+ }
+ }
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c
new file mode 100644
index 0000000..d0eed67
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c
@@ -0,0 +1,296 @@
+/*
+ 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 "modbus_data_type_sizes.h"
+#include <string.h>
+
+
+// Create an empty NULL-struct
+static const plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_null_const;
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_null() {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_null_const;
+}
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_of(char* value_string) {
+ if(strcmp(value_string, "BOOL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BOOL;
+ }
+ if(strcmp(value_string, "BYTE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BYTE;
+ }
+ if(strcmp(value_string, "CHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_CHAR;
+ }
+ if(strcmp(value_string, "DATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE;
+ }
+ if(strcmp(value_string, "DATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME;
+ }
+ if(strcmp(value_string, "DINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DINT;
+ }
+ if(strcmp(value_string, "DWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DWORD;
+ }
+ if(strcmp(value_string, "INT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_INT;
+ }
+ if(strcmp(value_string, "LDATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE;
+ }
+ if(strcmp(value_string, "LDATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME;
+ }
+ if(strcmp(value_string, "LINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LINT;
+ }
+ if(strcmp(value_string, "LREAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LREAL;
+ }
+ if(strcmp(value_string, "LTIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME;
+ }
+ if(strcmp(value_string, "LTIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY;
+ }
+ if(strcmp(value_string, "LWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LWORD;
+ }
+ if(strcmp(value_string, "REAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_REAL;
+ }
+ if(strcmp(value_string, "SINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_SINT;
+ }
+ if(strcmp(value_string, "STRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_STRING;
+ }
+ if(strcmp(value_string, "TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME;
+ }
+ if(strcmp(value_string, "TIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY;
+ }
+ if(strcmp(value_string, "UDINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UDINT;
+ }
+ if(strcmp(value_string, "UINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UINT;
+ }
+ if(strcmp(value_string, "ULINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_ULINT;
+ }
+ if(strcmp(value_string, "USINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_USINT;
+ }
+ if(strcmp(value_string, "WCHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR;
+ }
+ if(strcmp(value_string, "WORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WORD;
+ }
+ if(strcmp(value_string, "WSTRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING;
+ }
+ return -1;
+}
+
+int plc4c_modbus_read_write_modbus_data_type_sizes_num_values() {
+ return 27;
+}
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_for_index(int index) {
+ switch(index) {
+ case 0: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BOOL;
+ }
+ case 1: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BYTE;
+ }
+ case 2: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_CHAR;
+ }
+ case 3: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE;
+ }
+ case 4: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME;
+ }
+ case 5: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DINT;
+ }
+ case 6: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DWORD;
+ }
+ case 7: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_INT;
+ }
+ case 8: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE;
+ }
+ case 9: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME;
+ }
+ case 10: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LINT;
+ }
+ case 11: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LREAL;
+ }
+ case 12: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME;
+ }
+ case 13: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY;
+ }
+ case 14: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LWORD;
+ }
+ case 15: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_REAL;
+ }
+ case 16: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_SINT;
+ }
+ case 17: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_STRING;
+ }
+ case 18: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME;
+ }
+ case 19: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY;
+ }
+ case 20: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UDINT;
+ }
+ case 21: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UINT;
+ }
+ case 22: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_ULINT;
+ }
+ case 23: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_USINT;
+ }
+ case 24: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR;
+ }
+ case 25: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WORD;
+ }
+ case 26: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING;
+ }
+ default: {
+ return -1;
+ }
+ }
+}
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_sizes_get_data_type_size(plc4c_modbus_read_write_modbus_data_type_sizes value) {
+ switch(value) {
+ case plc4c_modbus_read_write_modbus_data_type_sizes_BOOL: { /* 'IEC61131_BOOL' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_BYTE: { /* 'IEC61131_BYTE' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_CHAR: { /* 'IEC61131_CHAR' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DATE: { /* 'IEC61131_DATE' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME: { /* 'IEC61131_DATE_AND_TIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DINT: { /* 'IEC61131_DINT' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DWORD: { /* 'IEC61131_DWORD' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_INT: { /* 'IEC61131_INT' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LDATE: { /* 'IEC61131_LDATE' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME: { /* 'IEC61131_LDATE_AND_TIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LINT: { /* 'IEC61131_LINT' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LREAL: { /* 'IEC61131_LREAL' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LTIME: { /* 'IEC61131_LTIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY: { /* 'IEC61131_LTIME_OF_DAY' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LWORD: { /* 'IEC61131_LWORD' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_REAL: { /* 'IEC61131_REAL' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_SINT: { /* 'IEC61131_SINT' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_STRING: { /* 'IEC61131_STRING' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_TIME: { /* 'IEC61131_TIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY: { /* 'IEC61131_TIME_OF_DAY' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_UDINT: { /* 'IEC61131_UDINT' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_UINT: { /* 'IEC61131_UINT' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_ULINT: { /* 'IEC61131_ULINT' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_USINT: { /* 'IEC61131_USINT' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR: { /* 'IEC61131_WCHAR' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_WORD: { /* 'IEC61131_WORD' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING: { /* 'IEC61131_WSTRING' */
+ return 2;
+ }
+ default: {
+ return 0;
+ }
+ }
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c
new file mode 100644
index 0000000..6f3a933
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c
@@ -0,0 +1,105 @@
+/*
+ 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 "modbus_error_code.h"
+#include <string.h>
+
+
+// Create an empty NULL-struct
+static const plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_null_const;
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_null() {
+ return plc4c_modbus_read_write_modbus_error_code_null_const;
+}
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_of(char* value_string) {
+ if(strcmp(value_string, "ILLEGAL_FUNCTION") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_FUNCTION;
+ }
+ if(strcmp(value_string, "GATEWAY_PATH_UNAVAILABLE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_PATH_UNAVAILABLE;
+ }
+ if(strcmp(value_string, "GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND;
+ }
+ if(strcmp(value_string, "ILLEGAL_DATA_ADDRESS") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_ADDRESS;
+ }
+ if(strcmp(value_string, "ILLEGAL_DATA_VALUE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_VALUE;
+ }
+ if(strcmp(value_string, "SLAVE_DEVICE_FAILURE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_FAILURE;
+ }
+ if(strcmp(value_string, "ACKNOWLEDGE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ACKNOWLEDGE;
+ }
+ if(strcmp(value_string, "SLAVE_DEVICE_BUSY") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_BUSY;
+ }
+ if(strcmp(value_string, "NEGATIVE_ACKNOWLEDGE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_NEGATIVE_ACKNOWLEDGE;
+ }
+ if(strcmp(value_string, "MEMORY_PARITY_ERROR") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_MEMORY_PARITY_ERROR;
+ }
+ return -1;
+}
+
+int plc4c_modbus_read_write_modbus_error_code_num_values() {
+ return 10;
+}
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_for_index(int index) {
+ switch(index) {
+ case 0: {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_FUNCTION;
+ }
+ case 1: {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_PATH_UNAVAILABLE;
+ }
+ case 2: {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND;
+ }
+ case 3: {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_ADDRESS;
+ }
+ case 4: {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_VALUE;
+ }
+ case 5: {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_FAILURE;
+ }
+ case 6: {
+ return plc4c_modbus_read_write_modbus_error_code_ACKNOWLEDGE;
+ }
+ case 7: {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_BUSY;
+ }
+ case 8: {
+ return plc4c_modbus_read_write_modbus_error_code_NEGATIVE_ACKNOWLEDGE;
+ }
+ case 9: {
+ return plc4c_modbus_read_write_modbus_error_code_MEMORY_PARITY_ERROR;
+ }
+ default: {
+ return -1;
+ }
+ }
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c b/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c
index 771d486..015af7c 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c
@@ -30,19 +30,19 @@ plc4c_s7_read_write_cotp_protocol_class plc4c_s7_read_write_cotp_protocol_class_
plc4c_s7_read_write_cotp_protocol_class plc4c_s7_read_write_cotp_protocol_class_value_of(char* value_string) {
if(strcmp(value_string, "CLASS_0") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_0;
}
if(strcmp(value_string, "CLASS_1") == 0) {
- return 0x10;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_1;
}
if(strcmp(value_string, "CLASS_2") == 0) {
- return 0x20;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_2;
}
if(strcmp(value_string, "CLASS_3") == 0) {
- return 0x30;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_3;
}
if(strcmp(value_string, "CLASS_4") == 0) {
- return 0x40;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_4;
}
return -1;
}
@@ -54,19 +54,19 @@ int plc4c_s7_read_write_cotp_protocol_class_num_values() {
plc4c_s7_read_write_cotp_protocol_class plc4c_s7_read_write_cotp_protocol_class_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_0;
}
case 1: {
- return 0x10;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_1;
}
case 2: {
- return 0x20;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_2;
}
case 3: {
- return 0x30;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_3;
}
case 4: {
- return 0x40;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_4;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c b/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c
index 7d78bf8..d5deae3 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c
@@ -30,25 +30,25 @@ plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_null() {
plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_value_of(char* value_string) {
if(strcmp(value_string, "SIZE_128") == 0) {
- return 0x07;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_128;
}
if(strcmp(value_string, "SIZE_256") == 0) {
- return 0x08;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_256;
}
if(strcmp(value_string, "SIZE_512") == 0) {
- return 0x09;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_512;
}
if(strcmp(value_string, "SIZE_1024") == 0) {
- return 0x0a;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_1024;
}
if(strcmp(value_string, "SIZE_2048") == 0) {
- return 0x0b;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_2048;
}
if(strcmp(value_string, "SIZE_4096") == 0) {
- return 0x0c;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_4096;
}
if(strcmp(value_string, "SIZE_8192") == 0) {
- return 0x0d;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_8192;
}
return -1;
}
@@ -60,25 +60,25 @@ int plc4c_s7_read_write_cotp_tpdu_size_num_values() {
plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x07;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_128;
}
case 1: {
- return 0x08;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_256;
}
case 2: {
- return 0x09;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_512;
}
case 3: {
- return 0x0a;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_1024;
}
case 4: {
- return 0x0b;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_2048;
}
case 5: {
- return 0x0c;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_4096;
}
case 6: {
- return 0x0d;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_8192;
}
default: {
return -1;
@@ -88,25 +88,25 @@ plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_value_for_
uint16_t plc4c_s7_read_write_cotp_tpdu_size_get_size_in_bytes(plc4c_s7_read_write_cotp_tpdu_size value) {
switch(value) {
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_128: { /* '0x07' */
return 128;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_256: { /* '0x08' */
return 256;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_512: { /* '0x09' */
return 512;
}
- case 10: { /* '0x0a' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_1024: { /* '0x0a' */
return 1024;
}
- case 11: { /* '0x0b' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_2048: { /* '0x0b' */
return 2048;
}
- case 12: { /* '0x0c' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_4096: { /* '0x0c' */
return 4096;
}
- case 13: { /* '0x0d' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_8192: { /* '0x0d' */
return 8192;
}
default: {
diff --git a/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c b/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c
index cb13d9d..4d71dfb 100644
--- a/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c
+++ b/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c
@@ -30,22 +30,22 @@ plc4c_s7_read_write_data_transport_error_code plc4c_s7_read_write_data_transport
plc4c_s7_read_write_data_transport_error_code plc4c_s7_read_write_data_transport_error_code_value_of(char* value_string) {
if(strcmp(value_string, "RESERVED") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_error_code_RESERVED;
}
if(strcmp(value_string, "ACCESS_DENIED") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_error_code_ACCESS_DENIED;
}
if(strcmp(value_string, "INVALID_ADDRESS") == 0) {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_error_code_INVALID_ADDRESS;
}
if(strcmp(value_string, "DATA_TYPE_NOT_SUPPORTED") == 0) {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_error_code_DATA_TYPE_NOT_SUPPORTED;
}
if(strcmp(value_string, "NOT_FOUND") == 0) {
- return 0x0A;
+ return plc4c_s7_read_write_data_transport_error_code_NOT_FOUND;
}
if(strcmp(value_string, "OK") == 0) {
- return 0xFF;
+ return plc4c_s7_read_write_data_transport_error_code_OK;
}
return -1;
}
@@ -57,22 +57,22 @@ int plc4c_s7_read_write_data_transport_error_code_num_values() {
plc4c_s7_read_write_data_transport_error_code plc4c_s7_read_write_data_transport_error_code_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_error_code_RESERVED;
}
case 1: {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_error_code_ACCESS_DENIED;
}
case 2: {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_error_code_INVALID_ADDRESS;
}
case 3: {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_error_code_DATA_TYPE_NOT_SUPPORTED;
}
case 4: {
- return 0x0A;
+ return plc4c_s7_read_write_data_transport_error_code_NOT_FOUND;
}
case 5: {
- return 0xFF;
+ return plc4c_s7_read_write_data_transport_error_code_OK;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c b/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c
index 5b2bf04..14b508d 100644
--- a/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c
@@ -30,25 +30,25 @@ plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_
plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_value_of(char* value_string) {
if(strcmp(value_string, "NULL") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_size_NULL;
}
if(strcmp(value_string, "BIT") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_size_BIT;
}
if(strcmp(value_string, "BYTE_WORD_DWORD") == 0) {
- return 0x04;
+ return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
if(strcmp(value_string, "INTEGER") == 0) {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_size_INTEGER;
}
if(strcmp(value_string, "DINTEGER") == 0) {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_size_DINTEGER;
}
if(strcmp(value_string, "REAL") == 0) {
- return 0x07;
+ return plc4c_s7_read_write_data_transport_size_REAL;
}
if(strcmp(value_string, "OCTET_STRING") == 0) {
- return 0x09;
+ return plc4c_s7_read_write_data_transport_size_OCTET_STRING;
}
return -1;
}
@@ -60,25 +60,25 @@ int plc4c_s7_read_write_data_transport_size_num_values() {
plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_size_NULL;
}
case 1: {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_size_BIT;
}
case 2: {
- return 0x04;
+ return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
case 3: {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_size_INTEGER;
}
case 4: {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_size_DINTEGER;
}
case 5: {
- return 0x07;
+ return plc4c_s7_read_write_data_transport_size_REAL;
}
case 6: {
- return 0x09;
+ return plc4c_s7_read_write_data_transport_size_OCTET_STRING;
}
default: {
return -1;
@@ -88,25 +88,25 @@ plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_
bool plc4c_s7_read_write_data_transport_size_get_size_in_bits(plc4c_s7_read_write_data_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_data_transport_size_NULL: { /* '0x00' */
return false;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_data_transport_size_BIT: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_data_transport_size_INTEGER: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_data_transport_size_DINTEGER: { /* '0x06' */
return false;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_data_transport_size_REAL: { /* '0x07' */
return false;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_data_transport_size_OCTET_STRING: { /* '0x09' */
return false;
}
default: {
diff --git a/sandbox/plc4c/generated-sources/s7/src/device_group.c b/sandbox/plc4c/generated-sources/s7/src/device_group.c
index 08fff70..f5bebb4 100644
--- a/sandbox/plc4c/generated-sources/s7/src/device_group.c
+++ b/sandbox/plc4c/generated-sources/s7/src/device_group.c
@@ -30,13 +30,13 @@ plc4c_s7_read_write_device_group plc4c_s7_read_write_device_group_null() {
plc4c_s7_read_write_device_group plc4c_s7_read_write_device_group_value_of(char* value_string) {
if(strcmp(value_string, "PG_OR_PC") == 0) {
- return 0x01;
+ return plc4c_s7_read_write_device_group_PG_OR_PC;
}
if(strcmp(value_string, "OS") == 0) {
- return 0x02;
+ return plc4c_s7_read_write_device_group_OS;
}
if(strcmp(value_string, "OTHERS") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_device_group_OTHERS;
}
return -1;
}
@@ -48,13 +48,13 @@ int plc4c_s7_read_write_device_group_num_values() {
plc4c_s7_read_write_device_group plc4c_s7_read_write_device_group_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x01;
+ return plc4c_s7_read_write_device_group_PG_OR_PC;
}
case 1: {
- return 0x02;
+ return plc4c_s7_read_write_device_group_OS;
}
case 2: {
- return 0x03;
+ return plc4c_s7_read_write_device_group_OTHERS;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/memory_area.c b/sandbox/plc4c/generated-sources/s7/src/memory_area.c
index 6a7fe3a..51a929f 100644
--- a/sandbox/plc4c/generated-sources/s7/src/memory_area.c
+++ b/sandbox/plc4c/generated-sources/s7/src/memory_area.c
@@ -30,31 +30,31 @@ plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_null() {
plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_value_of(char* value_string) {
if(strcmp(value_string, "COUNTERS") == 0) {
- return 0x1C;
+ return plc4c_s7_read_write_memory_area_COUNTERS;
}
if(strcmp(value_string, "TIMERS") == 0) {
- return 0x1D;
+ return plc4c_s7_read_write_memory_area_TIMERS;
}
if(strcmp(value_string, "DIRECT_PERIPHERAL_ACCESS") == 0) {
- return 0x80;
+ return plc4c_s7_read_write_memory_area_DIRECT_PERIPHERAL_ACCESS;
}
if(strcmp(value_string, "INPUTS") == 0) {
- return 0x81;
+ return plc4c_s7_read_write_memory_area_INPUTS;
}
if(strcmp(value_string, "OUTPUTS") == 0) {
- return 0x82;
+ return plc4c_s7_read_write_memory_area_OUTPUTS;
}
if(strcmp(value_string, "FLAGS_MARKERS") == 0) {
- return 0x83;
+ return plc4c_s7_read_write_memory_area_FLAGS_MARKERS;
}
if(strcmp(value_string, "DATA_BLOCKS") == 0) {
- return 0x84;
+ return plc4c_s7_read_write_memory_area_DATA_BLOCKS;
}
if(strcmp(value_string, "INSTANCE_DATA_BLOCKS") == 0) {
- return 0x85;
+ return plc4c_s7_read_write_memory_area_INSTANCE_DATA_BLOCKS;
}
if(strcmp(value_string, "LOCAL_DATA") == 0) {
- return 0x86;
+ return plc4c_s7_read_write_memory_area_LOCAL_DATA;
}
return -1;
}
@@ -66,31 +66,31 @@ int plc4c_s7_read_write_memory_area_num_values() {
plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x1C;
+ return plc4c_s7_read_write_memory_area_COUNTERS;
}
case 1: {
- return 0x1D;
+ return plc4c_s7_read_write_memory_area_TIMERS;
}
case 2: {
- return 0x80;
+ return plc4c_s7_read_write_memory_area_DIRECT_PERIPHERAL_ACCESS;
}
case 3: {
- return 0x81;
+ return plc4c_s7_read_write_memory_area_INPUTS;
}
case 4: {
- return 0x82;
+ return plc4c_s7_read_write_memory_area_OUTPUTS;
}
case 5: {
- return 0x83;
+ return plc4c_s7_read_write_memory_area_FLAGS_MARKERS;
}
case 6: {
- return 0x84;
+ return plc4c_s7_read_write_memory_area_DATA_BLOCKS;
}
case 7: {
- return 0x85;
+ return plc4c_s7_read_write_memory_area_INSTANCE_DATA_BLOCKS;
}
case 8: {
- return 0x86;
+ return plc4c_s7_read_write_memory_area_LOCAL_DATA;
}
default: {
return -1;
@@ -100,31 +100,31 @@ plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_value_for_index(
char* plc4c_s7_read_write_memory_area_get_short_name(plc4c_s7_read_write_memory_area value) {
switch(value) {
- case 28: { /* '0x1C' */
+ case plc4c_s7_read_write_memory_area_COUNTERS: { /* '0x1C' */
return "C";
}
- case 29: { /* '0x1D' */
+ case plc4c_s7_read_write_memory_area_TIMERS: { /* '0x1D' */
return "T";
}
- case 128: { /* '0x80' */
+ case plc4c_s7_read_write_memory_area_DIRECT_PERIPHERAL_ACCESS: { /* '0x80' */
return "D";
}
- case 129: { /* '0x81' */
+ case plc4c_s7_read_write_memory_area_INPUTS: { /* '0x81' */
return "I";
}
- case 130: { /* '0x82' */
+ case plc4c_s7_read_write_memory_area_OUTPUTS: { /* '0x82' */
return "Q";
}
- case 131: { /* '0x83' */
+ case plc4c_s7_read_write_memory_area_FLAGS_MARKERS: { /* '0x83' */
return "M";
}
- case 132: { /* '0x84' */
+ case plc4c_s7_read_write_memory_area_DATA_BLOCKS: { /* '0x84' */
return "DB";
}
- case 133: { /* '0x85' */
+ case plc4c_s7_read_write_memory_area_INSTANCE_DATA_BLOCKS: { /* '0x85' */
return "DBI";
}
- case 134: { /* '0x86' */
+ case plc4c_s7_read_write_memory_area_LOCAL_DATA: { /* '0x86' */
return "LD";
}
default: {
diff --git a/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c b/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c
index 220cea1..6967575 100644
--- a/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c
+++ b/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c
@@ -30,16 +30,16 @@ plc4c_s7_read_write_szl_module_type_class plc4c_s7_read_write_szl_module_type_cl
plc4c_s7_read_write_szl_module_type_class plc4c_s7_read_write_szl_module_type_class_value_of(char* value_string) {
if(strcmp(value_string, "CPU") == 0) {
- return 0x0;
+ return plc4c_s7_read_write_szl_module_type_class_CPU;
}
if(strcmp(value_string, "IM") == 0) {
- return 0x4;
+ return plc4c_s7_read_write_szl_module_type_class_IM;
}
if(strcmp(value_string, "FM") == 0) {
- return 0x8;
+ return plc4c_s7_read_write_szl_module_type_class_FM;
}
if(strcmp(value_string, "CP") == 0) {
- return 0xC;
+ return plc4c_s7_read_write_szl_module_type_class_CP;
}
return -1;
}
@@ -51,16 +51,16 @@ int plc4c_s7_read_write_szl_module_type_class_num_values() {
plc4c_s7_read_write_szl_module_type_class plc4c_s7_read_write_szl_module_type_class_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x0;
+ return plc4c_s7_read_write_szl_module_type_class_CPU;
}
case 1: {
- return 0x4;
+ return plc4c_s7_read_write_szl_module_type_class_IM;
}
case 2: {
- return 0x8;
+ return plc4c_s7_read_write_szl_module_type_class_FM;
}
case 3: {
- return 0xC;
+ return plc4c_s7_read_write_szl_module_type_class_CP;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c b/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c
index b727b2f..46fa12e 100644
--- a/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c
+++ b/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c
@@ -30,61 +30,61 @@ plc4c_s7_read_write_szl_sublist plc4c_s7_read_write_szl_sublist_null() {
plc4c_s7_read_write_szl_sublist plc4c_s7_read_write_szl_sublist_value_of(char* value_string) {
if(strcmp(value_string, "MODULE_IDENTIFICATION") == 0) {
- return 0x11;
+ return plc4c_s7_read_write_szl_sublist_MODULE_IDENTIFICATION;
}
if(strcmp(value_string, "CPU_FEATURES") == 0) {
- return 0x12;
+ return plc4c_s7_read_write_szl_sublist_CPU_FEATURES;
}
if(strcmp(value_string, "USER_MEMORY_AREA") == 0) {
- return 0x13;
+ return plc4c_s7_read_write_szl_sublist_USER_MEMORY_AREA;
}
if(strcmp(value_string, "SYSTEM_AREAS") == 0) {
- return 0x14;
+ return plc4c_s7_read_write_szl_sublist_SYSTEM_AREAS;
}
if(strcmp(value_string, "BLOCK_TYPES") == 0) {
- return 0x15;
+ return plc4c_s7_read_write_szl_sublist_BLOCK_TYPES;
}
if(strcmp(value_string, "STATUS_MODULE_LEDS") == 0) {
- return 0x19;
+ return plc4c_s7_read_write_szl_sublist_STATUS_MODULE_LEDS;
}
if(strcmp(value_string, "COMPONENT_IDENTIFICATION") == 0) {
- return 0x1C;
+ return plc4c_s7_read_write_szl_sublist_COMPONENT_IDENTIFICATION;
}
if(strcmp(value_string, "INTERRUPT_STATUS") == 0) {
- return 0x22;
+ return plc4c_s7_read_write_szl_sublist_INTERRUPT_STATUS;
}
if(strcmp(value_string, "ASSIGNMENT_BETWEEN_PROCESS_IMAGE_PARTITIONS_AND_OBS") == 0) {
- return 0x25;
+ return plc4c_s7_read_write_szl_sublist_ASSIGNMENT_BETWEEN_PROCESS_IMAGE_PARTITIONS_AND_OBS;
}
if(strcmp(value_string, "COMMUNICATION_STATUS_DATA") == 0) {
- return 0x32;
+ return plc4c_s7_read_write_szl_sublist_COMMUNICATION_STATUS_DATA;
}
if(strcmp(value_string, "STATUS_SINGLE_MODULE_LED") == 0) {
- return 0x74;
+ return plc4c_s7_read_write_szl_sublist_STATUS_SINGLE_MODULE_LED;
}
if(strcmp(value_string, "DP_MASTER_SYSTEM_INFORMATION") == 0) {
- return 0x90;
+ return plc4c_s7_read_write_szl_sublist_DP_MASTER_SYSTEM_INFORMATION;
}
if(strcmp(value_string, "MODULE_STATUS_INFORMATION") == 0) {
- return 0x91;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION;
}
if(strcmp(value_string, "RACK_OR_STATION_STATUS_INFORMATION") == 0) {
- return 0x92;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION;
}
if(strcmp(value_string, "RACK_OR_STATION_STATUS_INFORMATION_2") == 0) {
- return 0x94;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION_2;
}
if(strcmp(value_string, "ADDITIONAL_DP_MASTER_SYSTEM_OR_PROFINET_IO_SYSTEM_INFORMATION") == 0) {
- return 0x95;
+ return plc4c_s7_read_write_szl_sublist_ADDITIONAL_DP_MASTER_SYSTEM_OR_PROFINET_IO_SYSTEM_INFORMATION;
}
if(strcmp(value_string, "MODULE_STATUS_INFORMATION_PROFINET_IO_AND_PROFIBUS_DP") == 0) {
- return 0x96;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION_PROFINET_IO_AND_PROFIBUS_DP;
}
if(strcmp(value_string, "DIAGNOSTIC_BUFFER") == 0) {
- return 0xA0;
+ return plc4c_s7_read_write_szl_sublist_DIAGNOSTIC_BUFFER;
}
if(strcmp(value_string, "MODULE_DIAGNOSTIC_DATA") == 0) {
- return 0xB1;
+ return plc4c_s7_read_write_szl_sublist_MODULE_DIAGNOSTIC_DATA;
}
return -1;
}
@@ -96,61 +96,61 @@ int plc4c_s7_read_write_szl_sublist_num_values() {
plc4c_s7_read_write_szl_sublist plc4c_s7_read_write_szl_sublist_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x11;
+ return plc4c_s7_read_write_szl_sublist_MODULE_IDENTIFICATION;
}
case 1: {
- return 0x12;
+ return plc4c_s7_read_write_szl_sublist_CPU_FEATURES;
}
case 2: {
- return 0x13;
+ return plc4c_s7_read_write_szl_sublist_USER_MEMORY_AREA;
}
case 3: {
- return 0x14;
+ return plc4c_s7_read_write_szl_sublist_SYSTEM_AREAS;
}
case 4: {
- return 0x15;
+ return plc4c_s7_read_write_szl_sublist_BLOCK_TYPES;
}
case 5: {
- return 0x19;
+ return plc4c_s7_read_write_szl_sublist_STATUS_MODULE_LEDS;
}
case 6: {
- return 0x1C;
+ return plc4c_s7_read_write_szl_sublist_COMPONENT_IDENTIFICATION;
}
case 7: {
- return 0x22;
+ return plc4c_s7_read_write_szl_sublist_INTERRUPT_STATUS;
}
case 8: {
- return 0x25;
+ return plc4c_s7_read_write_szl_sublist_ASSIGNMENT_BETWEEN_PROCESS_IMAGE_PARTITIONS_AND_OBS;
}
case 9: {
- return 0x32;
+ return plc4c_s7_read_write_szl_sublist_COMMUNICATION_STATUS_DATA;
}
case 10: {
- return 0x74;
+ return plc4c_s7_read_write_szl_sublist_STATUS_SINGLE_MODULE_LED;
}
case 11: {
- return 0x90;
+ return plc4c_s7_read_write_szl_sublist_DP_MASTER_SYSTEM_INFORMATION;
}
case 12: {
- return 0x91;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION;
}
case 13: {
- return 0x92;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION;
}
case 14: {
- return 0x94;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION_2;
}
case 15: {
- return 0x95;
+ return plc4c_s7_read_write_szl_sublist_ADDITIONAL_DP_MASTER_SYSTEM_OR_PROFINET_IO_SYSTEM_INFORMATION;
}
case 16: {
- return 0x96;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION_PROFINET_IO_AND_PROFIBUS_DP;
}
case 17: {
- return 0xA0;
+ return plc4c_s7_read_write_szl_sublist_DIAGNOSTIC_BUFFER;
}
case 18: {
- return 0xB1;
+ return plc4c_s7_read_write_szl_sublist_MODULE_DIAGNOSTIC_DATA;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/transport_size.c b/sandbox/plc4c/generated-sources/s7/src/transport_size.c
index 24505a1..c2e1039 100644
--- a/sandbox/plc4c/generated-sources/s7/src/transport_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/transport_size.c
@@ -32,52 +32,52 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_null() {
plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_value_of(char* value_string) {
if(strcmp(value_string, "LWORD") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_transport_size_LWORD;
}
if(strcmp(value_string, "BOOL") == 0) {
- return 0x01;
+ return plc4c_s7_read_write_transport_size_BOOL;
}
if(strcmp(value_string, "BYTE") == 0) {
- return 0x02;
+ return plc4c_s7_read_write_transport_size_BYTE;
}
if(strcmp(value_string, "CHAR") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_transport_size_CHAR;
}
if(strcmp(value_string, "WORD") == 0) {
- return 0x04;
+ return plc4c_s7_read_write_transport_size_WORD;
}
if(strcmp(value_string, "INT") == 0) {
- return 0x05;
+ return plc4c_s7_read_write_transport_size_INT;
}
if(strcmp(value_string, "DWORD") == 0) {
- return 0x06;
+ return plc4c_s7_read_write_transport_size_DWORD;
}
if(strcmp(value_string, "DINT") == 0) {
- return 0x07;
+ return plc4c_s7_read_write_transport_size_DINT;
}
if(strcmp(value_string, "REAL") == 0) {
- return 0x08;
+ return plc4c_s7_read_write_transport_size_REAL;
}
if(strcmp(value_string, "DATE") == 0) {
- return 0x09;
+ return plc4c_s7_read_write_transport_size_DATE;
}
if(strcmp(value_string, "TIME_OF_DAY") == 0) {
- return 0x0A;
+ return plc4c_s7_read_write_transport_size_TIME_OF_DAY;
}
if(strcmp(value_string, "TIME") == 0) {
- return 0x0B;
+ return plc4c_s7_read_write_transport_size_TIME;
}
if(strcmp(value_string, "S5TIME") == 0) {
- return 0x0C;
+ return plc4c_s7_read_write_transport_size_S5TIME;
}
if(strcmp(value_string, "DATE_AND_TIME") == 0) {
- return 0x0F;
+ return plc4c_s7_read_write_transport_size_DATE_AND_TIME;
}
if(strcmp(value_string, "WCHAR") == 0) {
- return 0x13;
+ return plc4c_s7_read_write_transport_size_WCHAR;
}
if(strcmp(value_string, "LREAL") == 0) {
- return 0x30;
+ return plc4c_s7_read_write_transport_size_LREAL;
}
return -1;
}
@@ -89,52 +89,52 @@ int plc4c_s7_read_write_transport_size_num_values() {
plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_transport_size_LWORD;
}
case 1: {
- return 0x01;
+ return plc4c_s7_read_write_transport_size_BOOL;
}
case 2: {
- return 0x02;
+ return plc4c_s7_read_write_transport_size_BYTE;
}
case 3: {
- return 0x03;
+ return plc4c_s7_read_write_transport_size_CHAR;
}
case 4: {
- return 0x04;
+ return plc4c_s7_read_write_transport_size_WORD;
}
case 5: {
- return 0x05;
+ return plc4c_s7_read_write_transport_size_INT;
}
case 6: {
- return 0x06;
+ return plc4c_s7_read_write_transport_size_DWORD;
}
case 7: {
- return 0x07;
+ return plc4c_s7_read_write_transport_size_DINT;
}
case 8: {
- return 0x08;
+ return plc4c_s7_read_write_transport_size_REAL;
}
case 9: {
- return 0x09;
+ return plc4c_s7_read_write_transport_size_DATE;
}
case 10: {
- return 0x0A;
+ return plc4c_s7_read_write_transport_size_TIME_OF_DAY;
}
case 11: {
- return 0x0B;
+ return plc4c_s7_read_write_transport_size_TIME;
}
case 12: {
- return 0x0C;
+ return plc4c_s7_read_write_transport_size_S5TIME;
}
case 13: {
- return 0x0F;
+ return plc4c_s7_read_write_transport_size_DATE_AND_TIME;
}
case 14: {
- return 0x13;
+ return plc4c_s7_read_write_transport_size_WCHAR;
}
case 15: {
- return 0x30;
+ return plc4c_s7_read_write_transport_size_LREAL;
}
default: {
return -1;
@@ -144,52 +144,52 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_value_for_
bool plc4c_s7_read_write_transport_size_get_supported__s7_300(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return true;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return false;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return false;
}
default: {
@@ -200,52 +200,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_300(plc4c_s7_read_writ
bool plc4c_s7_read_write_transport_size_get_supported__logo(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return false;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return true;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return false;
}
default: {
@@ -256,52 +256,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__logo(plc4c_s7_read_write_
uint8_t plc4c_s7_read_write_transport_size_get_size_in_bytes(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return 8;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return 1;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return 1;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return 1;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return 2;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return 2;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return 4;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return 4;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return 4;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return 2;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return 4;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return 4;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return 4;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return 12;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return 2;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return 8;
}
default: {
@@ -312,52 +312,52 @@ uint8_t plc4c_s7_read_write_transport_size_get_size_in_bytes(plc4c_s7_read_write
bool plc4c_s7_read_write_transport_size_get_supported__s7_400(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return true;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return false;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return false;
}
default: {
@@ -368,52 +368,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_400(plc4c_s7_read_writ
bool plc4c_s7_read_write_transport_size_get_supported__s7_1200(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return false;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return true;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return true;
}
default: {
@@ -424,52 +424,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_1200(plc4c_s7_read_wri
uint8_t plc4c_s7_read_write_transport_size_get_size_code(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return 'X';
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return 'X';
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return 'B';
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return 'B';
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return 'W';
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return 'W';
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return 'D';
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return 'D';
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return 'D';
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return 'X';
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return 'X';
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return 'X';
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return 'X';
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return 'X';
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return 'X';
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return 'X';
}
default: {
@@ -480,52 +480,52 @@ uint8_t plc4c_s7_read_write_transport_size_get_size_code(plc4c_s7_read_write_tra
bool plc4c_s7_read_write_transport_size_get_supported__s7_1500(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return true;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return true;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return true;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return true;
}
default: {
@@ -536,52 +536,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_1500(plc4c_s7_read_wri
plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_transport_size_get_data_transport_size(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return -1;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return plc4c_s7_read_write_data_transport_size_BIT;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return plc4c_s7_read_write_data_transport_size_INTEGER;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return plc4c_s7_read_write_data_transport_size_INTEGER;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return -1;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return -1;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return -1;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return -1;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return -1;
}
default: {
@@ -592,52 +592,52 @@ plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_transport_size_get_d
plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_get_base_type(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return -1;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return -1;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return -1;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return -1;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return -1;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return -1;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return plc4c_s7_read_write_transport_size_WORD;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return plc4c_s7_read_write_transport_size_INT;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return -1;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return -1;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return -1;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return -1;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return -1;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return -1;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return -1;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return plc4c_s7_read_write_transport_size_REAL;
}
default: {
@@ -648,52 +648,52 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_get_base_t
uint8_t plc4c_s7_read_write_transport_size_get_data_protocol_id(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return 14;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return 01;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return 11;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return 41;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return 12;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return 23;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return 13;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return 25;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return 31;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return 54;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return 55;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return 51;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return 52;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return 56;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return 42;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return 32;
}
default: {