simplify some types with encoding bytes

include/ua_types.h

@@ -237,7 +237,12 @@ typedef struct {
 
 /** @brief A data value with an associated status code and timestamps. */
 typedef struct {
-    UA_Byte       encodingMask;
+    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_Variant    value;
     UA_StatusCode status;
     UA_DateTime   sourceTimestamp;
@@ -246,18 +251,15 @@ typedef struct {
     UA_Int16      serverPicoseconds;
 } UA_DataValue;
 
-enum UA_DATAVALUE_ENCODINGMASKTYPE_enum {
-    UA_DATAVALUE_ENCODINGMASK_VARIANT           = 0x01,
-    UA_DATAVALUE_ENCODINGMASK_STATUSCODE        = 0x02,
-    UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP   = 0x04,
-    UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP   = 0x08,
-    UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS = 0x10,
-    UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS = 0x20
-};
-
 /** @brief A structure that contains detailed error and diagnostic information associated with a StatusCode. */
 typedef struct UA_DiagnosticInfo {
-    UA_Byte       encodingMask;     // Type of the Enum UA_DIAGNOSTICINFO_ENCODINGMASKTYPE
+    UA_Boolean    hasSymbolicId : 1;
+    UA_Boolean    hasNamespace : 1;
+    UA_Boolean    hasLocalizedText : 1;
+    UA_Boolean    hasLocale : 1;
+    UA_Boolean    hasAdditionalInfo : 1;
+    UA_Boolean    hasInnerStatusCode : 1;
+    UA_Boolean    hasInnerDiagnosticInfo : 1;
     UA_Int32      symbolicId;
     UA_Int32      namespaceUri;
     UA_Int32      localizedText;
@@ -267,21 +269,7 @@ typedef struct UA_DiagnosticInfo {
     struct UA_DiagnosticInfo *innerDiagnosticInfo;
 } UA_DiagnosticInfo;
 
-enum UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_enum {
-    UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID          = 0x01,
-    UA_DIAGNOSTICINFO_ENCODINGMASK_NAMESPACE           = 0x02,
-    UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALIZEDTEXT       = 0x04,
-    UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALE              = 0x08,
-    UA_DIAGNOSTICINFO_ENCODINGMASK_ADDITIONALINFO      = 0x10,
-    UA_DIAGNOSTICINFO_ENCODINGMASK_INNERSTATUSCODE     = 0x20,
-    UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO = 0x40
-};
-
-/*************/
-/* Functions */
-/*************/
-
-#define UA_TYPE_PROTOTYPES(TYPE)                                     \
+#define UA_TYPE_HANDLING_FUNCTIONS(TYPE)                             \
     TYPE UA_EXPORT * TYPE##_new(void);                               \
     void UA_EXPORT TYPE##_init(TYPE * p);                            \
     void UA_EXPORT TYPE##_delete(TYPE * p);                          \
@@ -289,24 +277,24 @@ enum UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_enum {
     UA_StatusCode UA_EXPORT TYPE##_copy(const TYPE *src, TYPE *dst);
 
 /* Functions for all types */
-UA_TYPE_PROTOTYPES(UA_Boolean)
-UA_TYPE_PROTOTYPES(UA_SByte)
-UA_TYPE_PROTOTYPES(UA_Byte)
-UA_TYPE_PROTOTYPES(UA_Int16)
-UA_TYPE_PROTOTYPES(UA_UInt16)
-UA_TYPE_PROTOTYPES(UA_Int32)
-UA_TYPE_PROTOTYPES(UA_UInt32)
-UA_TYPE_PROTOTYPES(UA_Int64)
-UA_TYPE_PROTOTYPES(UA_UInt64)
-UA_TYPE_PROTOTYPES(UA_Float)
-UA_TYPE_PROTOTYPES(UA_Double)
-UA_TYPE_PROTOTYPES(UA_String)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Boolean)
+UA_TYPE_HANDLING_FUNCTIONS(UA_SByte)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Byte)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Int16)
+UA_TYPE_HANDLING_FUNCTIONS(UA_UInt16)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Int32)
+UA_TYPE_HANDLING_FUNCTIONS(UA_UInt32)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Int64)
+UA_TYPE_HANDLING_FUNCTIONS(UA_UInt64)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Float)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Double)
+UA_TYPE_HANDLING_FUNCTIONS(UA_String)
 #define UA_DateTime_new UA_Int64_new
 #define UA_DateTime_init UA_Int64_init
 #define UA_DateTime_delete UA_Int64_delete
 #define UA_DateTime_deleteMembers UA_Int64_deleteMembers
 #define UA_DateTime_copy UA_Int64_copy
-UA_TYPE_PROTOTYPES(UA_Guid)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Guid)
 #define UA_ByteString_new UA_String_new
 #define UA_ByteString_init UA_String_init
 #define UA_ByteString_delete UA_String_delete
@@ -317,19 +305,19 @@ UA_TYPE_PROTOTYPES(UA_Guid)
 #define UA_XmlElement_delete UA_String_delete
 #define UA_XmlElement_deleteMembers UA_String_deleteMembers
 #define UA_XmlElement_copy UA_String_copy
-UA_TYPE_PROTOTYPES(UA_NodeId)
-UA_TYPE_PROTOTYPES(UA_ExpandedNodeId)
+UA_TYPE_HANDLING_FUNCTIONS(UA_NodeId)
+UA_TYPE_HANDLING_FUNCTIONS(UA_ExpandedNodeId)
 #define UA_StatusCode_new UA_Int32_new
 #define UA_StatusCode_init UA_Int32_init
 #define UA_StatusCode_delete UA_Int32_delete
 #define UA_StatusCode_deleteMembers UA_Int32_deleteMembers
 #define UA_StatusCode_copy UA_Int32_copy
-UA_TYPE_PROTOTYPES(UA_QualifiedName)
-UA_TYPE_PROTOTYPES(UA_LocalizedText)
-UA_TYPE_PROTOTYPES(UA_ExtensionObject)
-UA_TYPE_PROTOTYPES(UA_DataValue)
-UA_TYPE_PROTOTYPES(UA_Variant)
-UA_TYPE_PROTOTYPES(UA_DiagnosticInfo)
+UA_TYPE_HANDLING_FUNCTIONS(UA_QualifiedName)
+UA_TYPE_HANDLING_FUNCTIONS(UA_LocalizedText)
+UA_TYPE_HANDLING_FUNCTIONS(UA_ExtensionObject)
+UA_TYPE_HANDLING_FUNCTIONS(UA_DataValue)
+UA_TYPE_HANDLING_FUNCTIONS(UA_Variant)
+UA_TYPE_HANDLING_FUNCTIONS(UA_DiagnosticInfo)
 
 /**********************************************/
 /* Custom functions for the builtin datatypes */
@@ -428,18 +416,6 @@ struct UA_DataType {
     UA_DataTypeMember members[UA_MAX_TYPE_MEMBERS];
 };
 
-struct UA_DataTypeDescription {
-    UA_DataType *types;
-    UA_UInt32 *numericNodeIds;
-    UA_UInt16 namespaceIndex;
-    UA_UInt16 tableSize;
-};
-
-/** The structured types defined in the standard are stored in this array. Generally access looks
-    like UA_TYPES_NS0[UA_INT32], where the name of the type in uppercase gives the types index. */
-extern const UA_DataType UA_EXPORT *UA_TYPES;
-extern const UA_UInt32 UA_EXPORT *UA_TYPES_IDS;
-
 void UA_EXPORT * UA_new(const UA_DataType *dataType);
 void UA_EXPORT UA_init(void *p, const UA_DataType *dataType);
 UA_StatusCode UA_EXPORT UA_copy(const void *src, void *dst, const UA_DataType *dataType);

src/ua_types.c

@@ -576,7 +576,7 @@ void UA_DataValue_deleteMembers(UA_DataValue *p) {
 }
 
 void UA_DataValue_init(UA_DataValue *p) {
-    p->encodingMask      = 0;
+    *((UA_Byte*)p) = 0; // zero out the bitfield 
     p->serverPicoseconds = 0;
     UA_DateTime_init(&p->serverTimestamp);
     p->sourcePicoseconds = 0;
@@ -587,10 +587,10 @@ void UA_DataValue_init(UA_DataValue *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_DataValue)
 UA_StatusCode UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst) {
+    *((UA_Byte*)dst) = *((const UA_Byte*)src); // the bitfield
     UA_StatusCode retval = UA_DateTime_copy(&src->serverTimestamp, &dst->serverTimestamp);
     retval |= UA_DateTime_copy(&src->sourceTimestamp, &dst->sourceTimestamp);
     retval |= UA_Variant_copy(&src->value, &dst->value);
-    dst->encodingMask = src->encodingMask;
     dst->serverPicoseconds = src->serverPicoseconds;
     dst->sourcePicoseconds = src->sourcePicoseconds;
     dst->status = src->status;
@@ -716,30 +716,30 @@ UA_StatusCode UA_Variant_copySetArray(UA_Variant *v, const void *array, UA_Int32
 UA_TYPE_DELETE_DEFAULT(UA_DiagnosticInfo)
 void UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
     UA_String_deleteMembers(&p->additionalInfo);
-    if((p->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) && p->innerDiagnosticInfo) {
+    if(p->hasInnerDiagnosticInfo && p->innerDiagnosticInfo) {
         UA_DiagnosticInfo_delete(p->innerDiagnosticInfo);
         p->innerDiagnosticInfo = UA_NULL;
     }
 }
 
+UA_TYPE_NEW_DEFAULT(UA_DiagnosticInfo)
 void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
+    *(UA_Byte*)p = 0;
+    p->symbolicId          = 0;
+    p->namespaceUri        = 0;
+    p->localizedText       = 0;
+    p->locale              = 0;
     UA_String_init(&p->additionalInfo);
-    p->encodingMask = 0;
     p->innerDiagnosticInfo = UA_NULL;
     UA_StatusCode_init(&p->innerStatusCode);
-    p->locale              = 0;
-    p->localizedText       = 0;
-    p->namespaceUri        = 0;
-    p->symbolicId          = 0;
 }
 
-UA_TYPE_NEW_DEFAULT(UA_DiagnosticInfo)
 UA_StatusCode UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst) {
     UA_DiagnosticInfo_init(dst);
+    *(UA_Byte*)dst = *(const UA_Byte*)src; // bitfields
     UA_StatusCode retval = UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
-    dst->encodingMask = src->encodingMask;
     retval |= UA_StatusCode_copy(&src->innerStatusCode, &dst->innerStatusCode);
-    if((src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) && src->innerDiagnosticInfo) {
+    if(src->hasInnerDiagnosticInfo && src->innerDiagnosticInfo) {
         if((dst->innerDiagnosticInfo = UA_malloc(sizeof(UA_DiagnosticInfo))))
             retval |= UA_DiagnosticInfo_copy(src->innerDiagnosticInfo, dst->innerDiagnosticInfo);
         else
@@ -749,10 +749,8 @@ UA_StatusCode UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_Diagnostic
     dst->localizedText = src->localizedText;
     dst->namespaceUri = src->namespaceUri;
     dst->symbolicId = src->symbolicId;
-    if(retval) {
+    if(retval)
         UA_DiagnosticInfo_deleteMembers(dst);
-        UA_DiagnosticInfo_init(dst);
-    }
     return retval;
 }
 

src/ua_types_encoding_binary.c

@@ -671,34 +671,34 @@ UA_StatusCode UA_ExtensionObject_decodeBinary(UA_ByteString const *src, UA_UInt3
 /* DataValue */
 UA_UInt32 UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
     UA_UInt32 length = sizeof(UA_Byte);
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
+    if(p->hasVariant)
         length += UA_Variant_calcSizeBinary(&p->value);
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
-        length += sizeof(UA_UInt32);   //dataValue->status
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
-        length += sizeof(UA_DateTime);  //dataValue->sourceTimestamp
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS)
-        length += sizeof(UA_Int64);    //dataValue->sourcePicoseconds
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
-        length += sizeof(UA_DateTime);  //dataValue->serverTimestamp
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS)
-        length += sizeof(UA_Int64);    //dataValue->serverPicoseconds
+    if(p->hasStatusCode)
+        length += sizeof(UA_UInt32);
+    if(p->hasSourceTimeStamp)
+        length += sizeof(UA_DateTime);
+    if(p->hasSourcePicoSeconds)
+        length += sizeof(UA_Int16);
+    if(p->hasServerTimeStamp)
+        length += sizeof(UA_DateTime);
+    if(p->hasServerPicoSeconds)
+        length += sizeof(UA_Int16);
     return length;
 }
 
 UA_StatusCode UA_DataValue_encodeBinary(UA_DataValue const *src, UA_ByteString * dst, UA_UInt32 *offset) {
-    UA_StatusCode retval = UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
-    if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
+    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->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
+    if(src->hasStatusCode)
         retval |= UA_StatusCode_encodeBinary(&src->status, dst, offset);
-    if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
+    if(src->hasSourceTimeStamp)
         retval |= UA_DateTime_encodeBinary(&src->sourceTimestamp, dst, offset);
-    if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS)
+    if(src->hasSourcePicoSeconds)
         retval |= UA_Int16_encodeBinary(&src->sourcePicoseconds, dst, offset);
-    if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
+    if(src->hasServerTimeStamp)
         retval |= UA_DateTime_encodeBinary(&src->serverTimestamp, dst, offset);
-    if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS)
+    if(src->hasServerPicoSeconds)
         retval |= UA_Int16_encodeBinary(&src->serverPicoseconds, dst, offset);
     return retval;
 }
@@ -706,21 +706,23 @@ UA_StatusCode UA_DataValue_encodeBinary(UA_DataValue const *src, UA_ByteString *
 #define MAX_PICO_SECONDS 1000
 UA_StatusCode UA_DataValue_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_DataValue *dst) {
     UA_DataValue_init(dst);
-    UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &dst->encodingMask);
-    if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
+    UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, (UA_Byte*)dst);
+    if(retval != UA_STATUSCODE_GOOD)
+        return retval;
+    if(dst->hasVariant)
         retval |= UA_Variant_decodeBinary(src, offset, &dst->value);
-    if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
+    if(dst->hasStatusCode)
         retval |= UA_StatusCode_decodeBinary(src, offset, &dst->status);
-    if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
+    if(dst->hasSourceTimeStamp)
         retval |= UA_DateTime_decodeBinary(src, offset, &dst->sourceTimestamp);
-    if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS) {
+    if(dst->hasSourcePicoSeconds) {
         retval |= UA_Int16_decodeBinary(src, offset, &dst->sourcePicoseconds);
         if(dst->sourcePicoseconds > MAX_PICO_SECONDS)
             dst->sourcePicoseconds = MAX_PICO_SECONDS;
     }
-    if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
+    if(dst->hasServerTimeStamp)
         retval |= UA_DateTime_decodeBinary(src, offset, &dst->serverTimestamp);
-    if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS) {
+    if(dst->hasServerPicoSeconds) {
         retval |= UA_Int16_decodeBinary(src, offset, &dst->serverPicoseconds);
         if(dst->serverPicoseconds > MAX_PICO_SECONDS)
             dst->serverPicoseconds = MAX_PICO_SECONDS;
@@ -885,65 +887,61 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, UA_UInt32 *offse
 
 /* DiagnosticInfo */
 UA_UInt32 UA_DiagnosticInfo_calcSizeBinary(UA_DiagnosticInfo const *ptr) {
-    UA_UInt32 length = sizeof(UA_Byte); // EncodingMask
-    if(!ptr->encodingMask)
-        return length;
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID)
+    UA_UInt32 length = sizeof(UA_Byte);
+    if(ptr->hasSymbolicId)
         length += sizeof(UA_Int32);
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_NAMESPACE)
+    if(ptr->hasNamespace)
         length += sizeof(UA_Int32);
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALIZEDTEXT)
+    if(ptr->hasLocalizedText)
         length += sizeof(UA_Int32);
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALE)
+    if(ptr->hasLocale)
         length += sizeof(UA_Int32);
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_ADDITIONALINFO)
+    if(ptr->hasAdditionalInfo)
         length += UA_String_calcSizeBinary(&ptr->additionalInfo);
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERSTATUSCODE)
+    if(ptr->hasInnerStatusCode)
         length += sizeof(UA_StatusCode);
-    if(ptr->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO)
+    if(ptr->hasInnerDiagnosticInfo)
         length += UA_DiagnosticInfo_calcSizeBinary(ptr->innerDiagnosticInfo);
     return length;
 }
 
 UA_StatusCode UA_DiagnosticInfo_encodeBinary(const UA_DiagnosticInfo *src, UA_ByteString * dst, UA_UInt32 *offset) {
-    UA_StatusCode retval = UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
-    if(!retval && !src->encodingMask)
-        return retval;
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID)
+    UA_StatusCode retval = UA_Byte_encodeBinary((const UA_Byte *)src, dst, offset);
+    if(src->hasSymbolicId)
         retval |= UA_Int32_encodeBinary(&src->symbolicId, dst, offset);
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_NAMESPACE)
+    if(src->hasNamespace)
         retval |= UA_Int32_encodeBinary( &src->namespaceUri, dst, offset);
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALIZEDTEXT)
+    if(src->hasLocalizedText)
         retval |= UA_Int32_encodeBinary(&src->localizedText, dst, offset);
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALE)
+    if(src->hasLocale)
         retval |= UA_Int32_encodeBinary(&src->locale, dst, offset);
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_ADDITIONALINFO)
+    if(src->hasAdditionalInfo)
         retval |= UA_String_encodeBinary(&src->additionalInfo, dst, offset);
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERSTATUSCODE)
+    if(src->hasInnerStatusCode)
         retval |= UA_StatusCode_encodeBinary(&src->innerStatusCode, dst, offset);
-    if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO)
+    if(src->hasInnerDiagnosticInfo)
         retval |= UA_DiagnosticInfo_encodeBinary(src->innerDiagnosticInfo, dst, offset);
     return retval;
 }
 
 UA_StatusCode UA_DiagnosticInfo_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_DiagnosticInfo *dst) {
     UA_DiagnosticInfo_init(dst);
-    UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &dst->encodingMask);
-    if(!retval && !dst->encodingMask) // in most cases, the DiagnosticInfo is empty
+    UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, (UA_Byte*)dst);
+    if(!retval)
         return retval;
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID)
+    if(dst->hasSymbolicId)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->symbolicId);
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_NAMESPACE)
+    if(dst->hasNamespace)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->namespaceUri);
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALIZEDTEXT)
+    if(dst->hasLocalizedText)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->localizedText);
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALE)
+    if(dst->hasLocale)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->locale);
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_ADDITIONALINFO)
+    if(dst->hasAdditionalInfo)
         retval |= UA_String_decodeBinary(src, offset, &dst->additionalInfo);
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERSTATUSCODE)
+    if(dst->hasInnerStatusCode)
         retval |= UA_StatusCode_decodeBinary(src, offset, &dst->innerStatusCode);
-    if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) {
+    if(dst->hasInnerDiagnosticInfo) {
         // innerDiagnosticInfo is a pointer to struct, therefore allocate
         if((dst->innerDiagnosticInfo = UA_malloc(sizeof(UA_DiagnosticInfo)))) {
             if(UA_DiagnosticInfo_decodeBinary(src, offset, dst->innerDiagnosticInfo) != UA_STATUSCODE_GOOD) {
@@ -955,7 +953,7 @@ UA_StatusCode UA_DiagnosticInfo_decodeBinary(UA_ByteString const *src, UA_UInt32
             retval |= UA_STATUSCODE_BADOUTOFMEMORY;
         }
     }
-    if(retval)
+    if(retval != UA_STATUSCODE_GOOD)
         UA_DiagnosticInfo_deleteMembers(dst);
     return retval;
 }

tools/generate_datatypes.py

@@ -414,9 +414,8 @@ extern "C" {
 * @{
 */
 ''')
-if outname != "ua_types":
-    printh("extern const UA_DataType *" + outname.upper() + ";\n")
-    printh("extern const UA_UInt32 *" + outname.upper() + "_IDS;\n")
+printh("extern const UA_DataType *" + outname.upper() + ";\n")
+printh("extern const UA_UInt32 *" + outname.upper() + "_IDS;\n")
 
 i = 0
 for t in types.itervalues():