make builtin tests compile (still failing)

CMakeLists.txt

@@ -102,31 +102,22 @@ if(ENABLE_SELFSIGNED)
                            ${CMAKE_CURRENT_SOURCE_DIR}/tools/certs/localhost.cnf)
 endif()
 
-## auto-generate all types or only the relevant subset?
-option(TYPES_ONLY_NEEDED "Include only compile-needed types" OFF)
-if(TYPES_ONLY_NEEDED)
-    list(APPEND generate_src_options "--only-needed")
-endif()
-
-## encodings
-set(UA_ENCODING_AMOUNT 1) # binary encoding
-
-### xml
-option(ENABLE_XML_ENCODING "Enable XML-encoding of the UA types" OFF)
-if(ENABLE_XML_ENCODING)
-    MATH(EXPR UA_ENCODING_AMOUNT "${UA_ENCODING_AMOUNT}+1")
-    find_package(EXPAT REQUIRED)
-    if(EXPAT_FOUND)
-        include_directories(${EXPAT_INCLUDE_DIRS})
-    else(EXPAT_FOUND)
-        message(FATAL_ERROR "Expat library not found.")
-    endif(EXPAT_FOUND)
-	include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/ongoing")
-    list(APPEND lib_sources src/ongoing/ua_types_encoding_xml.c
-                            src/ongoing/ua_namespace_xml.c
-                            src/ongoing/ua_xml.c)
-    list(APPEND generate_src_options "--with-xml")
-endif()
+# ### xml
+# option(ENABLE_XML_ENCODING "Enable XML-encoding of the UA types" OFF)
+# if(ENABLE_XML_ENCODING)
+#     MATH(EXPR UA_ENCODING_AMOUNT "${UA_ENCODING_AMOUNT}+1")
+#     find_package(EXPAT REQUIRED)
+#     if(EXPAT_FOUND)
+#         include_directories(${EXPAT_INCLUDE_DIRS})
+#     else(EXPAT_FOUND)
+#         message(FATAL_ERROR "Expat library not found.")
+#     endif(EXPAT_FOUND)
+# 	include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/ongoing")
+#     list(APPEND lib_sources src/ongoing/ua_types_encoding_xml.c
+#                             src/ongoing/ua_namespace_xml.c
+#                             src/ongoing/ua_xml.c)
+#     list(APPEND generate_src_options "--with-xml")
+# endif()
 
 # ### json
 # option(ENABLE_JSON_ENCODING "Enable JSON-encoding of the UA types" OFF)

include/ua_types.h

@@ -238,11 +238,11 @@ typedef struct {
 /** @brief A data value with an associated status code and timestamps. */
 typedef struct {
     UA_Boolean    hasVariant : 1;
-    UA_Boolean    hasStatusCode : 1;
-    UA_Boolean    hasSourceTimeStamp : 1;
-    UA_Boolean    hasServerTimeStamp : 1;
-    UA_Boolean    hasSourcePicoSeconds : 1;
-    UA_Boolean    hasServerPicoSeconds : 1;
+    UA_Boolean    hasStatus : 1;
+    UA_Boolean    hasSourceTimestamp : 1;
+    UA_Boolean    hasServerTimestamp : 1;
+    UA_Boolean    hasSourcePicoseconds : 1;
+    UA_Boolean    hasServerPicoseconds : 1;
     UA_Variant    value;
     UA_StatusCode status;
     UA_DateTime   sourceTimestamp;

src/server/ua_server_binary.c

@@ -3,7 +3,6 @@
 #include "ua_server_internal.h"
 #include "ua_services.h"
 #include "ua_statuscodes.h"
-#include "ua_namespace_0.h"
 #include "ua_securechannel_manager.h"
 #include "ua_session_manager.h"
 #include "ua_util.h"

src/ua_config.h.in

@@ -1,7 +1,6 @@
 /* Buid options and configuration (set by cmake) */
-#define UA_ENCODING_AMOUNT ${UA_ENCODING_AMOUNT}
-#define UA_LOGLEVEL ${UA_LOGLEVEL}
 
+#define UA_LOGLEVEL ${UA_LOGLEVEL}
 #cmakedefine UA_DEBUG
 #cmakedefine UA_MULTITHREADING
 

src/ua_types.c

@@ -660,7 +660,7 @@ UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
         dstdata->arrayLength = srcdata->arrayLength;
         if(srcdata->arrayDimensions) {
             retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength,
-                                    (void **)&dstdata->arrayDimensions, &UA_TYPES[UA_INT32]);
+                                    (void **)&dstdata->arrayDimensions, &UA_TYPES[UA_TYPES_INT32]);
             if(retval == UA_STATUSCODE_GOOD)
                 dstdata->arrayDimensionsLength = srcdata->arrayDimensionsLength;
             else {
@@ -790,57 +790,57 @@ void UA_init(void *p, const UA_DataType *dataType) {
         }
 
         switch(member->memberTypeIndex) {
-        case UA_BOOLEAN:
-        case UA_SBYTE:
-        case UA_BYTE:
+        case UA_TYPES_BOOLEAN:
+        case UA_TYPES_SBYTE:
+        case UA_TYPES_BYTE:
             *ptr = 0;
             break;
-        case UA_INT16:
-        case UA_UINT16:
+        case UA_TYPES_INT16:
+        case UA_TYPES_UINT16:
             *((UA_Int16*)ptr) = 0;
             break;
-        case UA_INT32:
-        case UA_UINT32:
-        case UA_STATUSCODE:
-        case UA_FLOAT:
+        case UA_TYPES_INT32:
+        case UA_TYPES_UINT32:
+        case UA_TYPES_STATUSCODE:
+        case UA_TYPES_FLOAT:
             *((UA_Int32*)ptr) = 0;
             break;
-        case UA_INT64:
-        case UA_UINT64:
-        case UA_DOUBLE:
-        case UA_DATETIME:
+        case UA_TYPES_INT64:
+        case UA_TYPES_UINT64:
+        case UA_TYPES_DOUBLE:
+        case UA_TYPES_DATETIME:
             *((UA_Int64*)ptr) = 0;
             break;
-        case UA_GUID:
+        case UA_TYPES_GUID:
             UA_Guid_init((UA_Guid*)ptr);
             break;
-        case UA_NODEID:
+        case UA_TYPES_NODEID:
             UA_NodeId_init((UA_NodeId*)ptr);
             break;
-        case UA_EXPANDEDNODEID:
+        case UA_TYPES_EXPANDEDNODEID:
             UA_ExpandedNodeId_init((UA_ExpandedNodeId*)ptr);
             break;
-        case UA_QUALIFIEDNAME:
+        case UA_TYPES_QUALIFIEDNAME:
             UA_QualifiedName_init((UA_QualifiedName*)ptr);
             break;
-        case UA_LOCALIZEDTEXT:
+        case UA_TYPES_LOCALIZEDTEXT:
             UA_LocalizedText_init((UA_LocalizedText*)ptr);
             break;
-        case UA_EXTENSIONOBJECT:
+        case UA_TYPES_EXTENSIONOBJECT:
             UA_ExtensionObject_init((UA_ExtensionObject*)ptr);
             break;
-        case UA_DATAVALUE:
+        case UA_TYPES_DATAVALUE:
             UA_DataValue_init((UA_DataValue*)ptr);
             break;
-        case UA_VARIANT:
+        case UA_TYPES_VARIANT:
             UA_Variant_init((UA_Variant*)ptr);
             break;
-        case UA_DIAGNOSTICINFO:
+        case UA_TYPES_DIAGNOSTICINFO:
             UA_DiagnosticInfo_init((UA_DiagnosticInfo*)ptr);
             break;
-        case UA_STRING:
-        case UA_BYTESTRING:
-        case UA_XMLELEMENT:
+        case UA_TYPES_STRING:
+        case UA_TYPES_BYTESTRING:
+        case UA_TYPES_XMLELEMENT:
             UA_String_init((UA_String*)ptr);
             break;
         default:
@@ -935,33 +935,33 @@ void UA_deleteMembers(void *p, const UA_DataType *dataType) {
             // the following types have a fixed size.
             /* UA_BOOLEAN, UA_SBYTE, UA_BYTE, UA_INT16, UA_UINT16, UA_INT32, UA_UINT32, */
             /* UA_STATUSCODE, UA_FLOAT, UA_INT64, UA_UINT64, UA_DOUBLE, UA_DATETIME, UA_GUID */
-        case UA_NODEID:
+        case UA_TYPES_NODEID:
             UA_NodeId_deleteMembers((UA_NodeId*)ptr);
             break;
-        case UA_EXPANDEDNODEID:
+        case UA_TYPES_EXPANDEDNODEID:
             UA_ExpandedNodeId_deleteMembers((UA_ExpandedNodeId*)ptr);
             break;
-        case UA_QUALIFIEDNAME:
+        case UA_TYPES_QUALIFIEDNAME:
             UA_QualifiedName_deleteMembers((UA_QualifiedName*)ptr);
             break;
-        case UA_LOCALIZEDTEXT:
+        case UA_TYPES_LOCALIZEDTEXT:
             UA_LocalizedText_deleteMembers((UA_LocalizedText*)ptr);
             break;
-        case UA_EXTENSIONOBJECT:
+        case UA_TYPES_EXTENSIONOBJECT:
             UA_ExtensionObject_deleteMembers((UA_ExtensionObject*)ptr);
             break;
-        case UA_DATAVALUE:
+        case UA_TYPES_DATAVALUE:
             UA_DataValue_deleteMembers((UA_DataValue*)ptr);
             break;
-        case UA_VARIANT:
+        case UA_TYPES_VARIANT:
             UA_Variant_deleteMembers((UA_Variant*)ptr);
             break;
-        case UA_DIAGNOSTICINFO:
+        case UA_TYPES_DIAGNOSTICINFO:
             UA_DiagnosticInfo_deleteMembers((UA_DiagnosticInfo*)ptr);
             break;
-        case UA_STRING:
-        case UA_BYTESTRING:
-        case UA_XMLELEMENT:
+        case UA_TYPES_STRING:
+        case UA_TYPES_BYTESTRING:
+        case UA_TYPES_XMLELEMENT:
             UA_String_deleteMembers((UA_String*)ptr);
             break;
         default:

src/ua_types_encoding_binary.c

@@ -673,15 +673,15 @@ UA_UInt32 UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
     UA_UInt32 length = sizeof(UA_Byte);
     if(p->hasVariant)
         length += UA_Variant_calcSizeBinary(&p->value);
-    if(p->hasStatusCode)
+    if(p->hasStatus)
         length += sizeof(UA_UInt32);
-    if(p->hasSourceTimeStamp)
+    if(p->hasSourceTimestamp)
         length += sizeof(UA_DateTime);
-    if(p->hasSourcePicoSeconds)
+    if(p->hasSourcePicoseconds)
         length += sizeof(UA_Int16);
-    if(p->hasServerTimeStamp)
+    if(p->hasServerTimestamp)
         length += sizeof(UA_DateTime);
-    if(p->hasServerPicoSeconds)
+    if(p->hasServerPicoseconds)
         length += sizeof(UA_Int16);
     return length;
 }
@@ -690,15 +690,15 @@ UA_StatusCode UA_DataValue_encodeBinary(UA_DataValue const *src, UA_ByteString *
     UA_StatusCode retval = UA_Byte_encodeBinary((const UA_Byte*)src, dst, offset);
     if(src->hasVariant)
         retval |= UA_Variant_encodeBinary(&src->value, dst, offset);
-    if(src->hasStatusCode)
+    if(src->hasStatus)
         retval |= UA_StatusCode_encodeBinary(&src->status, dst, offset);
-    if(src->hasSourceTimeStamp)
+    if(src->hasSourceTimestamp)
         retval |= UA_DateTime_encodeBinary(&src->sourceTimestamp, dst, offset);
-    if(src->hasSourcePicoSeconds)
+    if(src->hasSourcePicoseconds)
         retval |= UA_Int16_encodeBinary(&src->sourcePicoseconds, dst, offset);
-    if(src->hasServerTimeStamp)
+    if(src->hasServerTimestamp)
         retval |= UA_DateTime_encodeBinary(&src->serverTimestamp, dst, offset);
-    if(src->hasServerPicoSeconds)
+    if(src->hasServerPicoseconds)
         retval |= UA_Int16_encodeBinary(&src->serverPicoseconds, dst, offset);
     return retval;
 }
@@ -711,18 +711,18 @@ UA_StatusCode UA_DataValue_decodeBinary(UA_ByteString const *src, UA_UInt32 *off
         return retval;
     if(dst->hasVariant)
         retval |= UA_Variant_decodeBinary(src, offset, &dst->value);
-    if(dst->hasStatusCode)
+    if(dst->hasStatus)
         retval |= UA_StatusCode_decodeBinary(src, offset, &dst->status);
-    if(dst->hasSourceTimeStamp)
+    if(dst->hasSourceTimestamp)
         retval |= UA_DateTime_decodeBinary(src, offset, &dst->sourceTimestamp);
-    if(dst->hasSourcePicoSeconds) {
+    if(dst->hasSourcePicoseconds) {
         retval |= UA_Int16_decodeBinary(src, offset, &dst->sourcePicoseconds);
         if(dst->sourcePicoseconds > MAX_PICO_SECONDS)
             dst->sourcePicoseconds = MAX_PICO_SECONDS;
     }
-    if(dst->hasServerTimeStamp)
+    if(dst->hasServerTimestamp)
         retval |= UA_DateTime_decodeBinary(src, offset, &dst->serverTimestamp);
-    if(dst->hasServerPicoSeconds) {
+    if(dst->hasServerPicoseconds) {
         retval |= UA_Int16_decodeBinary(src, offset, &dst->serverPicoseconds);
         if(dst->serverPicoseconds > MAX_PICO_SECONDS)
             dst->serverPicoseconds = MAX_PICO_SECONDS;
@@ -771,7 +771,7 @@ UA_UInt32 UA_Variant_calcSizeBinary(UA_Variant const *p) {
     }
 
     if(arrayLength != 1 && data->arrayDimensions != UA_NULL)
-        length += UA_Array_calcSizeBinary(data->arrayDimensions, data->arrayDimensionsLength, &UA_TYPES[UA_INT32]);
+        length += UA_Array_calcSizeBinary(data->arrayDimensions, data->arrayDimensionsLength, &UA_TYPES[UA_TYPES_INT32]);
     
     if(p->storageType == UA_VARIANT_DATASOURCE)
         p->storage.datasource.release(p->storage.datasource.handle, data);
@@ -823,7 +823,7 @@ UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst,
     }
 
     if(hasDimensions)
-        retval |= UA_Array_encodeBinary(data->arrayDimensions, data->arrayDimensionsLength, &UA_TYPES[UA_INT32], dst, offset);
+        retval |= UA_Array_encodeBinary(data->arrayDimensions, data->arrayDimensionsLength, &UA_TYPES[UA_TYPES_INT32], dst, offset);
 
     if(src->storageType == UA_VARIANT_DATASOURCE)
         src->storage.datasource.release(src->storage.datasource.handle, data);
@@ -872,7 +872,7 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, UA_UInt32 *offse
     if(hasDimensions && retval == UA_STATUSCODE_GOOD) {
         retval |= UA_Int32_decodeBinary(src, offset, &data->arrayDimensionsLength);
         if(retval == UA_STATUSCODE_GOOD)
-            retval |= UA_Array_decodeBinary(src, offset, data->arrayDimensionsLength, &data->dataPtr, &UA_TYPES[UA_INT32]);
+            retval |= UA_Array_decodeBinary(src, offset, data->arrayDimensionsLength, &data->dataPtr, &UA_TYPES[UA_TYPES_INT32]);
         if(retval)
             data->arrayLength = -1; // for deleteMembers
     }
@@ -989,57 +989,57 @@ UA_UInt32 UA_calcSizeBinary(const void *p, const UA_DataType *dataType) {
             continue;
         }
         switch(member->memberTypeIndex) {
-        case UA_BOOLEAN:
-        case UA_SBYTE:
-        case UA_BYTE:
+        case UA_TYPES_BOOLEAN:
+        case UA_TYPES_SBYTE:
+        case UA_TYPES_BYTE:
             size += 1;
             break;
-        case UA_INT16:
-        case UA_UINT16:
+        case UA_TYPES_INT16:
+        case UA_TYPES_UINT16:
             size += 2;
             break;
-        case UA_INT32:
-        case UA_UINT32:
-        case UA_STATUSCODE:
-        case UA_FLOAT:
+        case UA_TYPES_INT32:
+        case UA_TYPES_UINT32:
+        case UA_TYPES_STATUSCODE:
+        case UA_TYPES_FLOAT:
             size += 4;
             break;
-        case UA_INT64:
-        case UA_UINT64:
-        case UA_DOUBLE:
-        case UA_DATETIME:
+        case UA_TYPES_INT64:
+        case UA_TYPES_UINT64:
+        case UA_TYPES_DOUBLE:
+        case UA_TYPES_DATETIME:
             size += 8;
             break;
-        case UA_GUID:
+        case UA_TYPES_GUID:
             size += 16;
             break;
-        case UA_NODEID:
+        case UA_TYPES_NODEID:
             size += UA_NodeId_calcSizeBinary((const UA_NodeId*)ptr);
             break;
-        case UA_EXPANDEDNODEID:
+        case UA_TYPES_EXPANDEDNODEID:
             size += UA_ExpandedNodeId_calcSizeBinary((const UA_ExpandedNodeId*)ptr);
             break;
-        case UA_QUALIFIEDNAME:
+        case UA_TYPES_QUALIFIEDNAME:
             size += UA_QualifiedName_calcSizeBinary((const UA_QualifiedName*)ptr);
             break;
-        case UA_LOCALIZEDTEXT:
+        case UA_TYPES_LOCALIZEDTEXT:
             size += UA_LocalizedText_calcSizeBinary((const UA_LocalizedText*)ptr);
             break;
-        case UA_EXTENSIONOBJECT:
+        case UA_TYPES_EXTENSIONOBJECT:
             size += UA_ExtensionObject_calcSizeBinary((const UA_ExtensionObject*)ptr);
             break;
-        case UA_DATAVALUE:
+        case UA_TYPES_DATAVALUE:
             size += UA_DataValue_calcSizeBinary((const UA_DataValue*)ptr);
             break;
-        case UA_VARIANT:
+        case UA_TYPES_VARIANT:
             size += UA_Variant_calcSizeBinary((const UA_Variant*)ptr);
             break;
-        case UA_DIAGNOSTICINFO:
+        case UA_TYPES_DIAGNOSTICINFO:
             size += UA_DiagnosticInfo_calcSizeBinary((const UA_DiagnosticInfo*)ptr);
             break;
-        case UA_STRING:
-        case UA_BYTESTRING:
-        case UA_XMLELEMENT:
+        case UA_TYPES_STRING:
+        case UA_TYPES_BYTESTRING:
+        case UA_TYPES_XMLELEMENT:
             size += UA_String_calcSizeBinary((const UA_String*)ptr);
             break;
         default:
@@ -1079,63 +1079,63 @@ UA_StatusCode UA_encodeBinary(const void *src, const UA_DataType *dataType, UA_B
         }
         
         switch(member->memberTypeIndex) {
-        case UA_BOOLEAN:
-        case UA_SBYTE:
-        case UA_BYTE:
+        case UA_TYPES_BOOLEAN:
+        case UA_TYPES_SBYTE:
+        case UA_TYPES_BYTE:
             retval = UA_Byte_encodeBinary((const UA_Byte*)ptr, dst, offset);
             break;
-        case UA_INT16:
+        case UA_TYPES_INT16:
             retval = UA_Int16_encodeBinary((const UA_Int16*)ptr, dst, offset);
             break;
-        case UA_UINT16:
+        case UA_TYPES_UINT16:
             retval = UA_UInt16_encodeBinary((const UA_UInt16*)ptr, dst, offset);
             break;
-        case UA_INT32:
-        case UA_UINT32:
-        case UA_STATUSCODE:
+        case UA_TYPES_INT32:
+        case UA_TYPES_UINT32:
+        case UA_TYPES_STATUSCODE:
             retval = UA_Int32_encodeBinary((const UA_Int32*)ptr, dst, offset);
             break;
-        case UA_FLOAT:
+        case UA_TYPES_FLOAT:
             retval = UA_Float_encodeBinary((const UA_Float*)ptr, dst, offset);
             break;
-        case UA_INT64:
-        case UA_UINT64:
-        case UA_DATETIME:
+        case UA_TYPES_INT64:
+        case UA_TYPES_UINT64:
+        case UA_TYPES_DATETIME:
             retval = UA_Int64_encodeBinary((const UA_Int64*)ptr, dst, offset);
             break;
-        case UA_DOUBLE:
+        case UA_TYPES_DOUBLE:
             retval = UA_Double_encodeBinary((const UA_Double*)ptr, dst, offset);
             break;
-        case UA_GUID:
+        case UA_TYPES_GUID:
             retval = UA_Guid_encodeBinary((const UA_Guid*)ptr, dst, offset);
             break;
-        case UA_NODEID:
+        case UA_TYPES_NODEID:
             retval = UA_NodeId_encodeBinary((const UA_NodeId*)ptr, dst, offset);
             break;
-        case UA_EXPANDEDNODEID:
+        case UA_TYPES_EXPANDEDNODEID:
             retval = UA_ExpandedNodeId_encodeBinary((const UA_ExpandedNodeId*)ptr, dst, offset);
             break;
-        case UA_QUALIFIEDNAME:
+        case UA_TYPES_QUALIFIEDNAME:
             retval = UA_QualifiedName_encodeBinary((const UA_QualifiedName*)ptr, dst, offset);
             break;
-        case UA_LOCALIZEDTEXT:
+        case UA_TYPES_LOCALIZEDTEXT:
             retval = UA_LocalizedText_encodeBinary((const UA_LocalizedText*)ptr, dst, offset);
             break;
-        case UA_EXTENSIONOBJECT:
+        case UA_TYPES_EXTENSIONOBJECT:
             retval = UA_ExtensionObject_encodeBinary((const UA_ExtensionObject*)ptr, dst, offset);
             break;
-        case UA_DATAVALUE:
+        case UA_TYPES_DATAVALUE:
             retval = UA_DataValue_encodeBinary((const UA_DataValue*)ptr, dst, offset);
             break;
-        case UA_VARIANT:
+        case UA_TYPES_VARIANT:
             retval = UA_Variant_encodeBinary((const UA_Variant*)ptr, dst, offset);
             break;
-        case UA_DIAGNOSTICINFO:
+        case UA_TYPES_DIAGNOSTICINFO:
             retval = UA_DiagnosticInfo_encodeBinary((const UA_DiagnosticInfo*)ptr, dst, offset);
             break;
-        case UA_STRING:
-        case UA_BYTESTRING:
-        case UA_XMLELEMENT:
+        case UA_TYPES_STRING:
+        case UA_TYPES_BYTESTRING:
+        case UA_TYPES_XMLELEMENT:
             retval = UA_String_encodeBinary((const UA_String*)ptr, dst, offset);
             break;
         default:
@@ -1175,61 +1175,61 @@ UA_StatusCode UA_decodeBinary(const UA_ByteString *src, UA_UInt32 *offset, void
         }
         ptr += member->padding;
         switch(member->memberTypeIndex) {
-        case UA_BOOLEAN:
-        case UA_SBYTE:
-        case UA_BYTE:
+        case UA_TYPES_BOOLEAN:
+        case UA_TYPES_SBYTE:
+        case UA_TYPES_BYTE:
             retval = UA_Byte_decodeBinary(src, offset, (UA_Byte*)ptr);
             break;
-        case UA_INT16:
-        case UA_UINT16:
+        case UA_TYPES_INT16:
+        case UA_TYPES_UINT16:
             retval = UA_Int16_decodeBinary(src, offset, (UA_Int16*)ptr);
             break;
-        case UA_INT32:
-        case UA_UINT32:
-        case UA_STATUSCODE:
+        case UA_TYPES_INT32:
+        case UA_TYPES_UINT32:
+        case UA_TYPES_STATUSCODE:
             retval = UA_Int32_decodeBinary(src, offset, (UA_Int32*)ptr);
             break;
-        case UA_FLOAT:
+        case UA_TYPES_FLOAT:
             retval = UA_Float_decodeBinary(src, offset, (UA_Float*)ptr);
             break;
-        case UA_INT64:
-        case UA_UINT64:
-        case UA_DATETIME:
+        case UA_TYPES_INT64:
+        case UA_TYPES_UINT64:
+        case UA_TYPES_DATETIME:
             retval = UA_Int64_decodeBinary(src, offset, (UA_Int64*)ptr);
             break;
-        case UA_DOUBLE:
+        case UA_TYPES_DOUBLE:
             retval = UA_Double_decodeBinary(src, offset, (UA_Double*)ptr);
             break;
-        case UA_GUID:
+        case UA_TYPES_GUID:
             retval = UA_Guid_decodeBinary(src, offset, (UA_Guid*)ptr);
             break;
-        case UA_NODEID:
+        case UA_TYPES_NODEID:
             retval = UA_NodeId_decodeBinary(src, offset, (UA_NodeId*)ptr);
             break;
-        case UA_EXPANDEDNODEID:
+        case UA_TYPES_EXPANDEDNODEID:
             retval = UA_ExpandedNodeId_decodeBinary(src, offset, (UA_ExpandedNodeId*)ptr);
             break;
-        case UA_QUALIFIEDNAME:
+        case UA_TYPES_QUALIFIEDNAME:
             retval = UA_QualifiedName_decodeBinary(src, offset, (UA_QualifiedName*)ptr);
             break;
-        case UA_LOCALIZEDTEXT:
+        case UA_TYPES_LOCALIZEDTEXT:
             retval = UA_LocalizedText_decodeBinary(src, offset, (UA_LocalizedText*)ptr);
             break;
-        case UA_EXTENSIONOBJECT:
+        case UA_TYPES_EXTENSIONOBJECT:
             retval = UA_ExtensionObject_decodeBinary(src, offset, (UA_ExtensionObject*)ptr);
             break;
-        case UA_DATAVALUE:
+        case UA_TYPES_DATAVALUE:
             retval = UA_DataValue_decodeBinary(src, offset, (UA_DataValue*)ptr);
             break;
-        case UA_VARIANT:
+        case UA_TYPES_VARIANT:
             retval = UA_Variant_decodeBinary(src, offset, (UA_Variant*)ptr);
             break;
-        case UA_DIAGNOSTICINFO:
+        case UA_TYPES_DIAGNOSTICINFO:
             retval = UA_DiagnosticInfo_decodeBinary(src, offset, (UA_DiagnosticInfo*)ptr);
             break;
-        case UA_STRING:
-        case UA_BYTESTRING:
-        case UA_XMLELEMENT:
+        case UA_TYPES_STRING:
+        case UA_TYPES_BYTESTRING:
+        case UA_TYPES_XMLELEMENT:
             retval = UA_String_decodeBinary(src, offset, (UA_String*)ptr);
             break;
         default:

tests/check_builtin.c

@@ -2,8 +2,8 @@
 #include <stdlib.h>
 #include "ua_types.h"
 #include "ua_types_encoding_binary.h"
-#include "ua_namespace_0.h"
-#include "ua_transport.h"
+#include "ua_types_generated.h"
+//#include "ua_transport.h"
 #include "ua_util.h"
 #include "check.h"
 
@@ -37,18 +37,18 @@ START_TEST(UA_ExtensionObject_calcSizeShallWorkOnExample) {
 	ck_assert_int_eq(UA_ExtensionObject_calcSizeBinary(&extensionObject), 3 + 4 + 3);
 }
 END_TEST
+
 START_TEST(UA_DataValue_calcSizeShallWorkOnExample) {
 	// given
 	UA_DataValue dataValue;
-	dataValue.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE |  UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP |
-			UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS;
 	dataValue.status       = 12;
-	UA_DateTime dateTime;
-	dateTime = 80;
+    dataValue.hasStatus = UA_TRUE;
+	UA_DateTime dateTime = 80;
 	dataValue.sourceTimestamp = dateTime;
-	UA_DateTime sourceTime;
-	sourceTime = 214;
+    dataValue.hasSourceTimestamp = UA_TRUE;
+	UA_DateTime sourceTime = 214;
 	dataValue.sourcePicoseconds = sourceTime;
+    dataValue.hasSourcePicoseconds = UA_TRUE;
 	int size = 0;
 	// when
 	size = UA_DataValue_calcSizeBinary(&dataValue);
@@ -56,20 +56,25 @@ START_TEST(UA_DataValue_calcSizeShallWorkOnExample) {
 	ck_assert_int_eq(size, 21);
 }
 END_TEST
+
 START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
 	// given
 	UA_DiagnosticInfo diagnosticInfo;
-	diagnosticInfo.encodingMask  = 0x01 | 0x02 | 0x04 | 0x08 | 0x10;
 	diagnosticInfo.symbolicId    = 30;
+    diagnosticInfo.hasSymbolicId = UA_TRUE;
 	diagnosticInfo.namespaceUri  = 25;
+    diagnosticInfo.hasNamespace = UA_TRUE;
 	diagnosticInfo.localizedText = 22;
+    diagnosticInfo.hasLocalizedText = UA_TRUE;
 	UA_Byte additionalInfoData = 'd';
-	diagnosticInfo.additionalInfo.data   = &additionalInfoData; //"OPCUA";
+	diagnosticInfo.additionalInfo.data = &additionalInfoData; //"OPCUA";
 	diagnosticInfo.additionalInfo.length = 5;
+    diagnosticInfo.hasAdditionalInfo = UA_TRUE;
 	// when & then
 	ck_assert_int_eq(UA_DiagnosticInfo_calcSizeBinary(&diagnosticInfo), 26);
 }
 END_TEST
+
 START_TEST(UA_String_calcSizeWithNegativLengthShallReturnEncodingSize) {
 	// given
 	UA_String arg = { -1, UA_NULL };
@@ -79,6 +84,7 @@ START_TEST(UA_String_calcSizeWithNegativLengthShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 4);
 }
 END_TEST
+
 START_TEST(UA_String_calcSizeWithNegativLengthAndValidPointerShallReturnEncodingSize) {
 	// given
 	UA_String arg = { -1, (UA_Byte *)"OPC" };
@@ -88,6 +94,7 @@ START_TEST(UA_String_calcSizeWithNegativLengthAndValidPointerShallReturnEncoding
 	ck_assert_int_eq(encodingSize, 4);
 }
 END_TEST
+
 START_TEST(UA_String_calcSizeWithZeroLengthShallReturnEncodingSize) {
 	// given
 	UA_String arg = { 0, UA_NULL };
@@ -97,6 +104,7 @@ START_TEST(UA_String_calcSizeWithZeroLengthShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 4);
 }
 END_TEST
+
 START_TEST(UA_String_calcSizeWithZeroLengthAndValidPointerShallReturnEncodingSize) {
 	// given
 	UA_String arg = { 0, (UA_Byte *)"OPC" };
@@ -106,6 +114,7 @@ START_TEST(UA_String_calcSizeWithZeroLengthAndValidPointerShallReturnEncodingSiz
 	ck_assert_int_eq(encodingSize, 4);
 }
 END_TEST
+
 START_TEST(UA_String_calcSizeShallReturnEncodingSize) {
 	// given
 	UA_String arg = { 3, (UA_Byte *)"OPC" };
@@ -115,6 +124,7 @@ START_TEST(UA_String_calcSizeShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 4+3);
 }
 END_TEST
+
 START_TEST(UA_NodeId_calcSizeEncodingTwoByteShallReturnEncodingSize) {
 	// given
 	UA_NodeId arg;
@@ -127,6 +137,7 @@ START_TEST(UA_NodeId_calcSizeEncodingTwoByteShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 2);
 }
 END_TEST
+
 START_TEST(UA_NodeId_calcSizeEncodingFourByteShallReturnEncodingSize) {
 	// given
 	UA_NodeId arg;
@@ -139,6 +150,7 @@ START_TEST(UA_NodeId_calcSizeEncodingFourByteShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 4);
 }
 END_TEST
+
 START_TEST(UA_NodeId_calcSizeEncodingStringShallReturnEncodingSize) {
 	// given
 	UA_NodeId arg;
@@ -151,6 +163,7 @@ START_TEST(UA_NodeId_calcSizeEncodingStringShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 1+2+4+3);
 }
 END_TEST
+
 START_TEST(UA_NodeId_calcSizeEncodingStringNegativLengthShallReturnEncodingSize) {
 	// given
 	UA_NodeId arg;
@@ -162,6 +175,7 @@ START_TEST(UA_NodeId_calcSizeEncodingStringNegativLengthShallReturnEncodingSize)
 	ck_assert_int_eq(encodingSize, 1+2+4+0);
 }
 END_TEST
+
 START_TEST(UA_NodeId_calcSizeEncodingStringZeroLengthShallReturnEncodingSize) {
 	// given
 	UA_NodeId arg;
@@ -173,6 +187,7 @@ START_TEST(UA_NodeId_calcSizeEncodingStringZeroLengthShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 1+2+4+0);
 }
 END_TEST
+
 START_TEST(UA_ExpandedNodeId_calcSizeEncodingStringAndServerIndexShallReturnEncodingSize) {
 	// given
 	UA_ExpandedNodeId arg;
@@ -186,6 +201,7 @@ START_TEST(UA_ExpandedNodeId_calcSizeEncodingStringAndServerIndexShallReturnEnco
 	ck_assert_int_eq(encodingSize, 1+2+4+3+4);
 }
 END_TEST
+
 START_TEST(UA_ExpandedNodeId_calcSizeEncodingStringAndNamespaceUriShallReturnEncodingSize) {
 	// given
 	UA_ExpandedNodeId arg;
@@ -199,6 +215,7 @@ START_TEST(UA_ExpandedNodeId_calcSizeEncodingStringAndNamespaceUriShallReturnEnc
 	ck_assert_int_eq(encodingSize, 1+2+4+3+4+7);
 }
 END_TEST
+
 START_TEST(UA_Guid_calcSizeShallReturnEncodingSize) {
 	// given
 	UA_Guid   arg;
@@ -208,6 +225,7 @@ START_TEST(UA_Guid_calcSizeShallReturnEncodingSize) {
 	ck_assert_int_eq(encodingSize, 16);
 }
 END_TEST
+
 START_TEST(UA_LocalizedText_calcSizeTextOnlyShallReturnEncodingSize) {
 	// given
 	UA_LocalizedText arg;
@@ -222,6 +240,7 @@ START_TEST(UA_LocalizedText_calcSizeTextOnlyShallReturnEncodingSize) {
 	UA_LocalizedText_deleteMembers(&arg);
 }
 END_TEST
+
 START_TEST(UA_LocalizedText_calcSizeLocaleOnlyShallReturnEncodingSize) {
 	// given
 	UA_LocalizedText arg;
@@ -235,6 +254,7 @@ START_TEST(UA_LocalizedText_calcSizeLocaleOnlyShallReturnEncodingSize) {
 	UA_LocalizedText_deleteMembers(&arg);
 }
 END_TEST
+
 START_TEST(UA_LocalizedText_calcSizeTextAndLocaleShallReturnEncodingSize) {
 	// given
 	UA_LocalizedText arg;
@@ -249,11 +269,12 @@ START_TEST(UA_LocalizedText_calcSizeTextAndLocaleShallReturnEncodingSize) {
 	UA_LocalizedText_deleteMembers(&arg);
 }
 END_TEST
+
 START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {
 	// given
 	UA_Variant arg;
 	UA_Variant_init(&arg);
-	arg.vt = &UA_TYPES[UA_INT32];
+    arg.dataType = &UA_TYPES[UA_TYPES_INT32];
 #define ARRAY_LEN 8
 	arg.storage.data.arrayLength = ARRAY_LEN;
 	UA_Int32 *data[ARRAY_LEN];
@@ -267,11 +288,12 @@ START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {
 #undef ARRAY_LEN
 }
 END_TEST
+
 START_TEST(UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize) {
 	// given
 	UA_Variant arg;
 	UA_Variant_init(&arg);
-	arg.vt = &UA_TYPES[UA_STRING];
+	arg.dataType = &UA_TYPES[UA_TYPES_STRING];
 #define ARRAY_LEN 3
 	arg.storage.data.arrayLength = ARRAY_LEN;
 	UA_String strings[3];
@@ -286,6 +308,7 @@ START_TEST(UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize) {
 #undef ARRAY_LEN
 }
 END_TEST
+
 START_TEST(UA_Byte_decodeShallCopyAndAdvancePosition) {
 	// given
 	UA_Byte       dst;
@@ -301,6 +324,7 @@ START_TEST(UA_Byte_decodeShallCopyAndAdvancePosition) {
 	ck_assert_uint_eq(dst, 0x08);
 }
 END_TEST
+
 START_TEST(UA_Byte_decodeShallModifyOnlyCurrentPosition) {
 	// given
 	UA_Byte       dst[]  = { 0xFF, 0xFF, 0xFF };
@@ -317,6 +341,7 @@ START_TEST(UA_Byte_decodeShallModifyOnlyCurrentPosition) {
 	ck_assert_uint_eq(dst[2], 0xFF);
 }
 END_TEST
+
 START_TEST(UA_Int16_decodeShallAssumeLittleEndian) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -336,6 +361,7 @@ START_TEST(UA_Int16_decodeShallAssumeLittleEndian) {
 	ck_assert_int_eq(pos, 4);
 }
 END_TEST
+
 START_TEST(UA_Int16_decodeShallRespectSign) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -354,6 +380,7 @@ START_TEST(UA_Int16_decodeShallRespectSign) {
 	ck_assert_int_eq(val_00_80, -32768);
 }
 END_TEST
+
 START_TEST(UA_UInt16_decodeShallNotRespectSign) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -373,6 +400,7 @@ START_TEST(UA_UInt16_decodeShallNotRespectSign) {
 	ck_assert_uint_eq(val_00_80, (0x01 << 15));
 }
 END_TEST
+
 START_TEST(UA_Int32_decodeShallAssumeLittleEndian) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -393,6 +421,7 @@ START_TEST(UA_Int32_decodeShallAssumeLittleEndian) {
 	ck_assert_int_eq(pos, 8);
 }
 END_TEST
+
 START_TEST(UA_Int32_decodeShallRespectSign) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -412,6 +441,7 @@ START_TEST(UA_Int32_decodeShallRespectSign) {
 	ck_assert_int_eq(val_00_80, -32768);
 }
 END_TEST
+
 START_TEST(UA_UInt32_decodeShallNotRespectSign) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -432,6 +462,7 @@ START_TEST(UA_UInt32_decodeShallNotRespectSign) {
 	ck_assert_uint_eq(val_00_80, (UA_UInt32)(0x01 << 31));
 }
 END_TEST
+
 START_TEST(UA_UInt64_decodeShallNotRespectSign) {
 	// given
 	UA_ByteString rawMessage;
@@ -448,6 +479,7 @@ START_TEST(UA_UInt64_decodeShallNotRespectSign) {
 	ck_assert_uint_eq(val, expectedVal);
 }
 END_TEST
+
 START_TEST(UA_Int64_decodeShallRespectSign) {
 	// given
 	UA_ByteString rawMessage;
@@ -465,6 +497,7 @@ START_TEST(UA_Int64_decodeShallRespectSign) {
 	ck_assert_uint_eq(val, expectedVal);
 }
 END_TEST
+
 START_TEST(UA_Float_decodeShallWorkOnExample) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -496,6 +529,7 @@ START_TEST(UA_Double_decodeShallGiveOne) {
 	ck_assert(dst < 1.00000000001);
 }
 END_TEST
+
 START_TEST(UA_Double_decodeShallGiveZero) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -511,6 +545,7 @@ START_TEST(UA_Double_decodeShallGiveZero) {
 	ck_assert(dst < 0.000000001);
 }
 END_TEST
+
 START_TEST(UA_Double_decodeShallGiveMinusTwo) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -545,6 +580,7 @@ START_TEST(UA_String_decodeShallAllocateMemoryAndCopyString) {
 	UA_String_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_String_decodeWithNegativeSizeShallNotAllocateMemoryAndNullPtr) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -561,6 +597,7 @@ START_TEST(UA_String_decodeWithNegativeSizeShallNotAllocateMemoryAndNullPtr) {
 	ck_assert_ptr_eq(dst.data, UA_NULL);
 }
 END_TEST
+
 START_TEST(UA_String_decodeWithZeroSizeShallNotAllocateMemoryAndNullPtr) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -577,6 +614,7 @@ START_TEST(UA_String_decodeWithZeroSizeShallNotAllocateMemoryAndNullPtr) {
 	ck_assert_ptr_eq(dst.data, UA_NULL);
 }
 END_TEST
+
 START_TEST(UA_NodeId_decodeTwoByteShallReadTwoBytesAndSetNamespaceToZero) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -594,6 +632,7 @@ START_TEST(UA_NodeId_decodeTwoByteShallReadTwoBytesAndSetNamespaceToZero) {
 	ck_assert_int_eq(dst.namespaceIndex, 0);
 }
 END_TEST
+
 START_TEST(UA_NodeId_decodeFourByteShallReadFourBytesAndRespectNamespace) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -611,6 +650,7 @@ START_TEST(UA_NodeId_decodeFourByteShallReadFourBytesAndRespectNamespace) {
 	ck_assert_int_eq(dst.namespaceIndex, 1);
 }
 END_TEST
+
 START_TEST(UA_NodeId_decodeStringShallAllocateMemory) {
 	// given
 	UA_UInt32     pos    = 0;
@@ -631,10 +671,11 @@ START_TEST(UA_NodeId_decodeStringShallAllocateMemory) {
 	UA_NodeId_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArray) {
 	// given
 	UA_UInt32     pos    = 0;
-	UA_Byte       data[] = { UA_INT32_NS0, 0xFF, 0x00, 0x00, 0x00 };
+	UA_Byte       data[] = { UA_TYPES_IDS[UA_TYPES_INT32], 0xFF, 0x00, 0x00, 0x00 };
 	UA_ByteString src    = { 5, data };
 	UA_Variant    dst;
 	// when
@@ -642,18 +683,19 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 5);
-	ck_assert_ptr_eq((const void *)dst.vt, (const void *)&UA_TYPES[UA_INT32]);
+	ck_assert_ptr_eq((const void *)dst.dataType, (const void *)&UA_TYPES[UA_TYPES_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 1);
 	ck_assert_int_eq(*(UA_Int32 *)dst.storage.data.dataPtr, 255);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray) {
 	// given
 	UA_UInt32     pos    = 0;
 	UA_Byte       data[] =
-	{ UA_INT32_NS0 | UA_VARIANT_ENCODINGMASKTYPE_ARRAY, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+	{ UA_TYPES_IDS[UA_TYPES_INT32] | UA_VARIANT_ENCODINGMASKTYPE_ARRAY, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF,
 			0xFF,                                             0xFF };
 	UA_ByteString src = { 13, data };
 	UA_Variant    dst;
@@ -664,7 +706,7 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 1+4+2*4);
-	ck_assert_ptr_eq((const void*)dst.vt, (const void*)&UA_TYPES[UA_INT32]);
+	ck_assert_ptr_eq((const void*)dst.dataType, (const void*)&UA_TYPES[UA_TYPES_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 2);
 	ck_assert_int_eq(((UA_Int32 *)dst.storage.data.dataPtr)[0], 255);
 	ck_assert_int_eq(((UA_Int32 *)dst.storage.data.dataPtr)[1], -1);
@@ -672,12 +714,12 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	UA_Variant_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem) {
 	// given
 	UA_UInt32     pos    = 0;
 	UA_Byte       data[] =
-	{ UA_INT32_NS0 | UA_VARIANT_ENCODINGMASKTYPE_ARRAY, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF,
-			0xFF,                                             0xFF };
+	{ UA_TYPES_IDS[UA_TYPES_INT32] | UA_VARIANT_ENCODINGMASKTYPE_ARRAY, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF };
 	UA_ByteString src = { 13, data };
 
 	UA_Variant    dst;
@@ -694,8 +736,7 @@ START_TEST(UA_Variant_decodeWithTooSmallSourceShallReturnWithError) {
 	// given
 	UA_UInt32     pos    = 0;
 	UA_Byte       data[] =
-	{ UA_INT32_NS0 | UA_VARIANT_ENCODINGMASKTYPE_ARRAY, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF,
-			0xFF,                                             0xFF };
+	{ UA_TYPES_IDS[UA_TYPES_INT32] | UA_VARIANT_ENCODINGMASKTYPE_ARRAY, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF };
 	UA_ByteString src = { 4, data };
 
 	UA_Variant    dst;
@@ -771,6 +812,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 	// given
 	UA_UInt16     src;
@@ -800,11 +842,11 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 	// given
 	UA_UInt32     src;
-	UA_Byte       data[] = {  0x55, 0x55, 0x55,       0x55,
-			0x55,       0x55, 0x55,       0x55 };
+	UA_Byte       data[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
 	UA_ByteString dst    = { 8, data };
 
 	UA_StatusCode retval = 0;
@@ -833,11 +875,11 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
 	// given
 	UA_Int32 src;
-	UA_Byte  data[]   = {  0x55, 0x55,    0x55,  0x55,
-			0x55,  0x55,    0x55,  0x55 };
+	UA_Byte  data[]   = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
 	UA_ByteString dst = { 8, data };
 
 	UA_Int32  retval  = 0;
@@ -866,6 +908,7 @@ START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian) {
 	// given
 	UA_Int32 src;
@@ -888,11 +931,12 @@ START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 	// given
 	UA_UInt64     src;
-	UA_Byte       data[] = {  0x55, 0x55, 0x55,       0x55, 0x55,       0x55,       0x55,       0x55,
-			0x55,       0x55, 0x55,       0x55, 0x55,       0x55,       0x55,       0x55 };
+	UA_Byte       data[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+                             0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
 	UA_ByteString dst    = { 16, data };
 
 	UA_StatusCode retval = 0;
@@ -929,6 +973,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_Int64_encodeShallEncodeLittleEndian) {
 	// given
 	UA_Int64 src;
@@ -955,6 +1000,7 @@ START_TEST(UA_Int64_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian) {
 	// given
 	UA_Int64 src;
@@ -981,6 +1027,7 @@ START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_Float_encodeShallWorkOnExample) {
 	// given
 	UA_Float src;
@@ -1001,6 +1048,7 @@ START_TEST(UA_Float_encodeShallWorkOnExample) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 /*START_TEST(UA_Double_encodeShallWorkOnExample)
    {
     // given
@@ -1022,6 +1070,7 @@ END_TEST
     ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
    }
    END_TEST*/
+
 START_TEST(UA_String_encodeShallWorkOnExample) {
 	// given
 	UA_String src;
@@ -1051,11 +1100,12 @@ START_TEST(UA_String_encodeShallWorkOnExample) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
 	// given
 	UA_DataValue src;
 	src.serverTimestamp = 80;
-	src.encodingMask    = UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP; //Only the sourcePicoseconds
+    src.hasServerTimestamp = UA_TRUE;
 
 	UA_Byte data[] = {  0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,       0x55,
 			0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,       0x55,
@@ -1081,13 +1131,15 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
 	// given
 	UA_DataValue src;
 	src.serverTimestamp    = 80;
-	src.encodingMask       = UA_DATAVALUE_ENCODINGMASK_VARIANT | UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP; //Variant & SourvePicoseconds
+    src.hasVariant = UA_TRUE;
+    src.hasServerTimestamp = UA_TRUE;
 	UA_Variant_init(&src.value);
-	src.value.vt           = &UA_TYPES[UA_INT32];
+	src.value.dataType = &UA_TYPES[UA_TYPES_INT32];
 	src.value.storage.data.arrayLength  = 1; // one element (encoded as not an array)
 	UA_Int32  vdata  = 45;
 	src.value.storage.data.dataPtr = (void *)&vdata;
@@ -1115,6 +1167,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
+
 START_TEST(UA_DateTime_toStructShallWorkOnExample) {
 	// given
 	UA_DateTime src = 13974671891234567 + (11644473600 * 10000000); // ua counts since 1601, unix since 1970
@@ -1138,6 +1191,7 @@ START_TEST(UA_DateTime_toStructShallWorkOnExample) {
 	ck_assert_int_eq(dst.year, 2014);
 }
 END_TEST
+
 START_TEST(UA_DateTime_toStringShallWorkOnExample) {
 	// given
 	UA_DateTime src = 13974671891234567 + (11644473600 * 10000000); // ua counts since 1601, unix since 1970
@@ -1157,6 +1211,7 @@ START_TEST(UA_DateTime_toStringShallWorkOnExample) {
 	UA_String_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_ExtensionObject_copyShallWorkOnExample) {
 	// given
 	UA_Byte data[3] = { 1, 2, 3 };
@@ -1166,7 +1221,7 @@ START_TEST(UA_ExtensionObject_copyShallWorkOnExample) {
 	UA_ExtensionObject_init(&valueCopied);
 
 	value.typeId.identifierType = UA_NODEIDTYPE_NUMERIC;
-	value.typeId.identifier.numeric = UA_BYTE;
+	value.typeId.identifier.numeric = UA_TYPES_IDS[UA_TYPES_BYTE];
 	value.encoding    = UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED;
 	value.encoding    = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
 	value.body.data   = data;
@@ -1204,7 +1259,7 @@ START_TEST(UA_Array_copyByteArrayShallWorkOnExample) {
 	testString.length  = 5;
 
 	//when
-	UA_Array_copy((const void *)testString.data, 5, &UA_TYPES[UA_BYTE], (void **)&dstArray);
+	UA_Array_copy((const void *)testString.data, 5, (void **)&dstArray, &UA_TYPES[UA_TYPES_BYTE]);
 	//then
 	for(i = 0;i < size;i++)
 		ck_assert_int_eq(testString.data[i], dstArray[i]);
@@ -1220,14 +1275,14 @@ START_TEST(UA_Array_copyUA_StringShallWorkOnExample) {
 	// given
 	UA_Int32   i, j;
 	UA_String *srcArray;
-	UA_Array_new((void**)&srcArray, 3, &UA_TYPES[UA_STRING]);
+	UA_Array_new((void**)&srcArray, 3, &UA_TYPES[UA_TYPES_STRING]);
 	UA_String *dstArray;
 
 	UA_String_copycstring("open", &srcArray[0]);
 	UA_String_copycstring("62541", &srcArray[1]);
 	UA_String_copycstring("opc ua", &srcArray[2]);
 	//when
-	UA_Array_copy((const void *)srcArray, 3, &UA_TYPES[UA_STRING], (void **)&dstArray);
+	UA_Array_copy((const void *)srcArray, 3, (void **)&dstArray, &UA_TYPES[UA_TYPES_STRING]);
 	//then
 	for(i = 0;i < 3;i++) {
 		for(j = 0;j < 3;j++)
@@ -1235,12 +1290,11 @@ START_TEST(UA_Array_copyUA_StringShallWorkOnExample) {
 		ck_assert_int_eq(srcArray[i].length, dstArray[i].length);
 	}
 	//finally
-	UA_Array_delete(srcArray, 3, &UA_TYPES[UA_STRING]);
-	UA_Array_delete(dstArray, 3, &UA_TYPES[UA_STRING]);
+	UA_Array_delete(srcArray, 3, &UA_TYPES[UA_TYPES_STRING]);
+	UA_Array_delete(dstArray, 3, &UA_TYPES[UA_TYPES_STRING]);
 }
 END_TEST
 
-
 START_TEST(UA_DiagnosticInfo_copyShallWorkOnExample) {
 	//given
 	UA_DiagnosticInfo value, innerValue, copiedValue;
@@ -1248,7 +1302,7 @@ START_TEST(UA_DiagnosticInfo_copyShallWorkOnExample) {
 
 	UA_DiagnosticInfo_init(&value);
 	UA_DiagnosticInfo_init(&innerValue);
-	value.encodingMask |= UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO;
+    value.hasInnerDiagnosticInfo = UA_TRUE;
 	value.innerDiagnosticInfo = &innerValue;
 	value.additionalInfo = testString;
 
@@ -1260,7 +1314,7 @@ START_TEST(UA_DiagnosticInfo_copyShallWorkOnExample) {
 		ck_assert_int_eq(copiedValue.additionalInfo.data[i], value.additionalInfo.data[i]);
 	ck_assert_int_eq(copiedValue.additionalInfo.length, value.additionalInfo.length);
 
-	ck_assert_int_eq(copiedValue.encodingMask, value.encodingMask);
+	ck_assert_int_eq(copiedValue.hasInnerDiagnosticInfo, value.hasInnerDiagnosticInfo);
 	ck_assert_int_eq(copiedValue.innerDiagnosticInfo->locale, value.innerDiagnosticInfo->locale);
 	ck_assert_int_eq(copiedValue.innerStatusCode, value.innerStatusCode);
 	ck_assert_int_eq(copiedValue.locale, value.locale);
@@ -1276,6 +1330,7 @@ START_TEST(UA_DiagnosticInfo_copyShallWorkOnExample) {
 
 }
 END_TEST
+
 START_TEST(UA_ApplicationDescription_copyShallWorkOnExample) {
 	//given
 
@@ -1330,6 +1385,7 @@ START_TEST(UA_ApplicationDescription_copyShallWorkOnExample) {
 	UA_ApplicationDescription_deleteMembers(&copiedValue);
 }
 END_TEST
+
 START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 	// given
 	UA_String srcName = (UA_String){8, (UA_Byte*)"tEsT123!"};
@@ -1348,6 +1404,7 @@ START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 	UA_QualifiedName_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_Guid_copyShallWorkOnInputExample) {
 	//given
 	const UA_Guid src = {3, 45, 1222, {8, 7, 6, 5, 4, 3, 2, 1}};
@@ -1364,6 +1421,7 @@ START_TEST(UA_Guid_copyShallWorkOnInputExample) {
 	//finally
 }
 END_TEST
+
 START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	// given
 	const char src[8] = {'t', 'e', 'X', 't', '1', '2', '3', (char)0};
@@ -1382,23 +1440,31 @@ START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	UA_LocalizedText_deleteMembers(&dst);
 }
 END_TEST
+
 START_TEST(UA_DataValue_copyShallWorkOnInputExample) {
 	// given
 	UA_Variant srcVariant;
 	UA_Variant_init(&srcVariant);
-	UA_DataValue src = {5, srcVariant, 44, 4, 77, 58, 8};
+	UA_DataValue src;
+    UA_DataValue_init(&src);
+    src.hasSourceTimestamp = UA_TRUE;
+    src.sourceTimestamp = 4;
+    src.hasSourcePicoseconds = UA_TRUE;
+    src.sourcePicoseconds = 77;
+    src.hasServerPicoseconds = UA_TRUE;
+    src.serverPicoseconds = 8;
 	UA_DataValue dst;
 
 	// when
 	UA_StatusCode ret = UA_DataValue_copy(&src, &dst);
 	// then
 	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
-	ck_assert_int_eq(5, dst.encodingMask);
 	ck_assert_int_eq(4, dst.sourceTimestamp);
 	ck_assert_int_eq(77, dst.sourcePicoseconds);
 	ck_assert_int_eq(8, dst.serverPicoseconds);
 }
 END_TEST
+
 START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	//given
 	UA_String testString = (UA_String){5, (UA_Byte*)"OPCUA"};
@@ -1407,7 +1473,7 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	UA_Variant_init(&copiedValue);
 	value.storage.data.dataPtr = UA_malloc(sizeof(UA_String));
 	*((UA_String*)value.storage.data.dataPtr) = testString;
-	value.vt = &UA_TYPES[UA_STRING];
+    value.dataType = &UA_TYPES[UA_TYPES_STRING];
 	value.storage.data.arrayLength = 1;
 
 	//when
@@ -1428,10 +1494,11 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	UA_Variant_deleteMembers(&copiedValue);
 }
 END_TEST
+
 START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	// given
 	UA_String *srcArray;
-	UA_Array_new((void**)&srcArray, 3, &UA_TYPES[UA_STRING]);
+	UA_Array_new((void**)&srcArray, 3, &UA_TYPES[UA_TYPES_STRING]);
 	UA_String_copycstring("__open", &srcArray[0]);
 	UA_String_copycstring("_62541", &srcArray[1]);
 	UA_String_copycstring("opc ua", &srcArray[2]);
@@ -1448,7 +1515,7 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	value.storage.data.dataPtr = (void *)srcArray;
 	value.storage.data.arrayDimensionsLength = 1;
 	value.storage.data.arrayDimensions = dimensions;
-	value.vt = &UA_TYPES[UA_STRING];
+	value.dataType = &UA_TYPES[UA_TYPES_STRING];
 
 	//when
 	UA_Variant_copy(&value, &copiedValue);
@@ -1476,10 +1543,11 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	UA_Variant_deleteMembers(&copiedValue);
 }
 END_TEST
+
 START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	// given
 	UA_Int32 *srcArray;
-	UA_Array_new((void**)&srcArray, 6, &UA_TYPES[UA_INT32]);
+	UA_Array_new((void**)&srcArray, 6, &UA_TYPES[UA_TYPES_INT32]);
 	srcArray[0] = 0;
 	srcArray[1] = 1;
 	srcArray[2] = 2;
@@ -1488,7 +1556,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	srcArray[5] = 5;
 
 	UA_Int32 *dimensions;
-	UA_Array_new((void**)&dimensions, 2, &UA_TYPES[UA_INT32]);
+	UA_Array_new((void**)&dimensions, 2, &UA_TYPES[UA_TYPES_INT32]);
 	UA_Int32 dim1 = 3;
 	UA_Int32 dim2 = 2;
 	dimensions[0] = dim1;
@@ -1502,7 +1570,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	value.storage.data.dataPtr     = srcArray;
 	value.storage.data.arrayDimensionsLength = 2;
 	value.storage.data.arrayDimensions       = dimensions;
-	value.vt = &UA_TYPES[UA_INT32];
+	value.dataType = &UA_TYPES[UA_TYPES_INT32];
 
 	//when
 	UA_Variant_copy(&value, &copiedValue);
@@ -1545,7 +1613,7 @@ START_TEST(UA_ExtensionObject_encodeDecodeShallWorkOnExtensionObject) {
 	/* wrap it into a variant */
 	UA_Variant varVal;
 	UA_Variant_init(&varVal);
-	varVal.vt = &UA_TYPES[UA_INT32];
+	varVal.dataType = &UA_TYPES[UA_TYPES_INT32];
 	varVal.storage.data.dataPtr = &val;
 	varVal.storage.data.arrayDimensionsLength = -1;
 	varVal.storage.data.arrayDimensions = UA_NULL;
@@ -1556,7 +1624,7 @@ START_TEST(UA_ExtensionObject_encodeDecodeShallWorkOnExtensionObject) {
 	/* wrap it into a variable attributes */
 	UA_VariableAttributes varAttr;
 	UA_VariableAttributes_init(&varAttr);
-	varAttr.dataType = UA_NODEIDS[UA_INT32];
+	varAttr.dataType.identifier.numeric = UA_TYPES_IDS[UA_TYPES_INT32];
 	UA_Variant_copy(&varVal,&varAttr.value);
 	varAttr.userWriteMask = 41;
 	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUERANK;
@@ -1571,8 +1639,7 @@ START_TEST(UA_ExtensionObject_encodeDecodeShallWorkOnExtensionObject) {
 	/* wrap it into a extension object attributes */
 	UA_ExtensionObject extensionObject;
 	UA_ExtensionObject_init(&extensionObject);
-
-	extensionObject.typeId = UA_NODEIDS[UA_VARIABLEATTRIBUTES];
+	extensionObject.typeId.identifier.numeric = UA_TYPES_IDS[UA_TYPES_VARIABLEATTRIBUTES];
 	UA_Byte extensionData[50];
 	extensionObject.body = (UA_ByteString){.data = extensionData, .length=UA_VariableAttributes_calcSizeBinary(&varAttr)};
 	UA_UInt32 posEncode = 0;

tools/generate_datatypes.py

@@ -78,14 +78,14 @@ class BuiltinType(object):
     def typedef_c(self):
         pass
 
-    def typelayout_c(self, namespace_0):
+    def typelayout_c(self, namespace_0, outname):
         return "{.memSize = sizeof(" + self.name + "), " + \
             ".namespaceZero = UA_TRUE, " + \
             ".fixedSize = " + ("UA_TRUE" if self.fixed_size() else "UA_FALSE") + \
             ", .zeroCopyable = " + ("UA_TRUE" if self.zero_copy() else "UA_FALSE") + \
-            ", .membersSize = 1,\n\t.members[0] = {.memberTypeIndex = " + self.name.upper() + "," + \
+            ", .membersSize = 1,\n\t.members[0] = {.memberTypeIndex = UA_TYPES_" + self.name[3:].upper() + "," + \
             ".namespaceZero = UA_TRUE, .padding = 0, .isArray = UA_FALSE }, " + \
-            ".typeIndex = %s }" % (self.name.upper())
+            ".typeIndex = %s }" % (outname.upper() + "_" + self.name[3:].upper())
 
 class EnumerationType(object):
     def __init__(self, name, description = "", elements = OrderedDict()):
@@ -110,12 +110,12 @@ class EnumerationType(object):
             ",\n    ".join(map(lambda (key,value) : key.upper() + " = " + value,self.elements.iteritems())) + \
             "\n} " + self.name + ";"
 
-    def typelayout_c(self, namespace_0):
+    def typelayout_c(self, namespace_0, outname):
         return "{.memSize = sizeof(" + self.name + "), " +\
             ".namespaceZero = " + ("UA_TRUE" if namespace_0 else "UA_FALSE") + \
             ", .fixedSize = UA_TRUE, .zeroCopyable = UA_TRUE, " + \
-            ".membersSize = 1,\n\t.members[0] = {.memberTypeIndex = UA_INT32," + \
-            ".namespaceZero = UA_TRUE, .padding = 0, .isArray = UA_FALSE }, .typeIndex = %s }" % (self.name.upper())
+            ".membersSize = 1,\n\t.members[0] = {.memberTypeIndex = UA_TYPES_INT32," + \
+            ".namespaceZero = UA_TRUE, .padding = 0, .isArray = UA_FALSE }, .typeIndex = %s }" % (outname.upper() + "_" + self.name[3:].upper())
 
     def functions_c(self, typeTableName):
         return '''#define %s_new (UA_Int32*)UA_Int32_new
@@ -141,11 +141,11 @@ class OpaqueType(object):
     def typedef_c(self):
         return "typedef UA_ByteString " + self.name + ";"
 
-    def typelayout_c(self, namespace_0):
+    def typelayout_c(self, namespace_0, outname):
         return "{.memSize = sizeof(" + self.name + "), .fixedSize = UA_FALSE, .zeroCopyable = UA_FALSE, " + \
             ".namespaceZero = " + ("UA_TRUE" if namespace_0 else "UA_FALSE") + \
-            ", .membersSize = 1,\n\t.members[0] = {.memberTypeIndex = UA_BYTESTRING," + \
-            ".namespaceZero = UA_TRUE, .padding = 0, .isArray = UA_FALSE }, .typeIndex = %s }" % (self.name.upper())
+            ", .membersSize = 1,\n\t.members[0] = {.memberTypeIndex = UA_TYPES_BYTESTRING," + \
+            ".namespaceZero = UA_TRUE, .padding = 0, .isArray = UA_FALSE }, .typeIndex = %s }" % (outname.upper() + "_" + self.name[3:].upper())
 
     def functions_c(self, typeTableName):
         return '''#define %s_new UA_ByteString_new
@@ -202,17 +202,18 @@ class StructType(object):
                 returnstr += "    " + member.memberType.name + " " +name + ";\n"
         return returnstr + "} " + self.name + ";"
 
-    def typelayout_c(self, namespace_0):
+    def typelayout_c(self, namespace_0, outname):
         layout = "{.memSize = sizeof(" + self.name + "), "+ \
                  ".namespaceZero = " + ("UA_TRUE" if namespace_0 else "UA_FALSE") + \
                  ", .fixedSize = " + ("UA_TRUE" if self.fixed_size() else "UA_FALSE") + \
                  ", .zeroCopyable = " + ("sizeof(" + self.name + ") == " + str(self.mem_size()) if self.zero_copy() \
                                          else "UA_FALSE") + \
-                 ", .typeIndex = " + self.name.upper() + \
+                 ", .typeIndex = " + outname.upper() + "_" + self.name[3:].upper() + \
                  ", .membersSize = " + str(len(self.members)) + ","
         for index, member in enumerate(self.members.values()):
             layout += "\n\t.members["+ str(index)+ "] = {" + \
-                      ".memberTypeIndex = UA_" + member.memberType.name.upper()[3:] + ", " + \
+                      ".memberTypeIndex = " + ("UA_TYPES_" + member.memberType.name[3:].upper() if args.namespace_id == 0 or member.memberType.name in existing_types else \
+                                               outname.upper() + "_" + member.memberType.name[3:].upper()) + ", " + \
                       ".namespaceZero = "+ \
                       ("UA_TRUE, " if args.namespace_id == 0 or member.memberType.name in existing_types else "UA_FALSE, ") + \
                       ".padding = "
@@ -247,7 +248,7 @@ class StructType(object):
 #define %s_calcSizeBinary(p) UA_calcSizeBinary(p, %s)
 #define %s_encodeBinary(src, dst, offset) UA_encodeBinary(src, %s, dst, offset)
 #define %s_decodeBinary(src, offset, dst) UA_decodeBinary(src, offset, dst, %s)''' % \
-    tuple(itertools.chain(*itertools.repeat([self.name, "&"+typeTableName+"["+self.name.upper()+"]"], 8)))
+    tuple(itertools.chain(*itertools.repeat([self.name, "&"+typeTableName+"[" + typeTableName + "_" + self.name[3:].upper()+"]"], 8)))
 
 def parseTypeDefinitions(xmlDescription, existing_types = OrderedDict()):
     '''Returns an ordered dict that maps names to types. The order is such that
@@ -414,6 +415,7 @@ extern "C" {
 * @{
 */
 ''')
+printh("#define " + outname.upper() + "_COUNT %s\n" % (str(len(types))))
 printh("extern const UA_DataType *" + outname.upper() + ";\n")
 printh("extern const UA_UInt32 *" + outname.upper() + "_IDS;\n")
 
@@ -424,12 +426,11 @@ for t in types.itervalues():
         if t.description != "":
             printh("/** @brief " + t.description + " */")
         printh(t.typedef_c())
-    printh("#define UA_" + t.name[3:].upper() + " " + str(i))
+    printh("#define " + outname.upper() + "_" + t.name[3:].upper() + " " + str(i))
     if type(t) != BuiltinType:
         printh(t.functions_c(outname.upper()))
     i += 1
 
-printh("#define " + outname.upper() + "_COUNT %s\n" % (str(len(types))))
 printh('''
 /// @} /* end of group */\n
 #ifdef __cplusplus
@@ -452,7 +453,7 @@ const UA_DataType *''' + outname.upper() + ''' = (UA_DataType[]){''')
 for t in types.itervalues():
     printc("")
     printc("/* " + t.name + " */")
-    printc(t.typelayout_c(args.namespace_id == 0) + ",")
+    printc(t.typelayout_c(args.namespace_id == 0, outname) + ",")
 printc("};\n")
 if args.typedescriptions:
     printc('const UA_UInt32 *' + outname.upper() + '_IDS = (UA_UInt32[]){')