|
@@ -14,17 +14,11 @@
|
|
|
* datatypes are autogenerated. */
|
|
|
|
|
|
/* Static definition of NULL type instances */
|
|
|
-UA_EXPORT const UA_String UA_STRING_NULL = {.length = 0, .data = NULL };
|
|
|
-UA_EXPORT const UA_ByteString UA_BYTESTRING_NULL = {.length = 0, .data = NULL };
|
|
|
-UA_EXPORT const UA_Guid UA_GUID_NULL = {.data1 = 0, .data2 = 0, .data3 = 0,
|
|
|
- .data4 = {0,0,0,0,0,0,0,0}};
|
|
|
-UA_EXPORT const UA_NodeId UA_NODEID_NULL = {0, UA_NODEIDTYPE_NUMERIC, {0}};
|
|
|
-UA_EXPORT const UA_ExpandedNodeId UA_EXPANDEDNODEID_NULL = {
|
|
|
- .nodeId = { .namespaceIndex = 0, .identifierType = UA_NODEIDTYPE_NUMERIC,
|
|
|
- .identifier.numeric = 0 },
|
|
|
- .namespaceUri = {.length = 0, .data = NULL}, .serverIndex = 0 };
|
|
|
-
|
|
|
-static void UA_deleteMembers_noInit(void *p, const UA_DataType *type);
|
|
|
+const UA_String UA_STRING_NULL = {0};
|
|
|
+const UA_ByteString UA_BYTESTRING_NULL = {0};
|
|
|
+const UA_Guid UA_GUID_NULL = {0};
|
|
|
+const UA_NodeId UA_NODEID_NULL = {0};
|
|
|
+const UA_ExpandedNodeId UA_EXPANDEDNODEID_NULL = {0};
|
|
|
|
|
|
/***************************/
|
|
|
/* Random Number Generator */
|
|
@@ -46,6 +40,9 @@ UA_UInt32_random(void) {
|
|
|
/* Builtin Types */
|
|
|
/*****************/
|
|
|
|
|
|
+static void deleteMembers_noInit(void *, const UA_DataType *);
|
|
|
+static UA_StatusCode copy_noInit(const void *, void *, const UA_DataType *);
|
|
|
+
|
|
|
UA_String
|
|
|
UA_String_fromChars(char const src[]) {
|
|
|
UA_String str = UA_STRING_NULL;
|
|
@@ -86,7 +83,8 @@ UA_DateTime_toStruct(UA_DateTime t) {
|
|
|
dateTimeStruct.milliSec = (UA_UInt16)((t % 10000000) / 10000);
|
|
|
|
|
|
/* Calculating the unix time with #include <time.h> */
|
|
|
- time_t secSinceUnixEpoch = (time_t)((t - UA_DATETIME_UNIX_EPOCH) / UA_SEC_TO_DATETIME);
|
|
|
+ time_t secSinceUnixEpoch =
|
|
|
+ (time_t)((t - UA_DATETIME_UNIX_EPOCH) / UA_SEC_TO_DATETIME);
|
|
|
struct tm ts;
|
|
|
memset(&ts, 0, sizeof(struct tm));
|
|
|
__secs_to_tm(secSinceUnixEpoch, &ts);
|
|
@@ -196,13 +194,15 @@ NodeId_copy(UA_NodeId const *src, UA_NodeId *dst, const UA_DataType *_) {
|
|
|
*dst = *src;
|
|
|
return UA_STATUSCODE_GOOD;
|
|
|
case UA_NODEIDTYPE_STRING:
|
|
|
- retval |= UA_String_copy(&src->identifier.string, &dst->identifier.string);
|
|
|
+ retval |= UA_String_copy(&src->identifier.string,
|
|
|
+ &dst->identifier.string);
|
|
|
break;
|
|
|
case UA_NODEIDTYPE_GUID:
|
|
|
retval |= UA_Guid_copy(&src->identifier.guid, &dst->identifier.guid);
|
|
|
break;
|
|
|
case UA_NODEIDTYPE_BYTESTRING:
|
|
|
- retval |= UA_ByteString_copy(&src->identifier.byteString, &dst->identifier.byteString);
|
|
|
+ retval |= UA_ByteString_copy(&src->identifier.byteString,
|
|
|
+ &dst->identifier.byteString);
|
|
|
break;
|
|
|
default:
|
|
|
return UA_STATUSCODE_BADINTERNALERROR;
|
|
@@ -239,7 +239,8 @@ UA_NodeId_isNull(const UA_NodeId *p) {
|
|
|
|
|
|
UA_Boolean
|
|
|
UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
|
|
|
- if(n1->namespaceIndex != n2->namespaceIndex || n1->identifierType!=n2->identifierType)
|
|
|
+ if(n1->namespaceIndex != n2->namespaceIndex ||
|
|
|
+ n1->identifierType!=n2->identifierType)
|
|
|
return false;
|
|
|
switch(n1->identifierType) {
|
|
|
case UA_NODEIDTYPE_NUMERIC:
|
|
@@ -248,11 +249,14 @@ UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
|
|
|
else
|
|
|
return false;
|
|
|
case UA_NODEIDTYPE_STRING:
|
|
|
- return UA_String_equal(&n1->identifier.string, &n2->identifier.string);
|
|
|
+ return UA_String_equal(&n1->identifier.string,
|
|
|
+ &n2->identifier.string);
|
|
|
case UA_NODEIDTYPE_GUID:
|
|
|
- return UA_Guid_equal(&n1->identifier.guid, &n2->identifier.guid);
|
|
|
+ return UA_Guid_equal(&n1->identifier.guid,
|
|
|
+ &n2->identifier.guid);
|
|
|
case UA_NODEIDTYPE_BYTESTRING:
|
|
|
- return UA_ByteString_equal(&n1->identifier.byteString, &n2->identifier.byteString);
|
|
|
+ return UA_ByteString_equal(&n1->identifier.byteString,
|
|
|
+ &n2->identifier.byteString);
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
@@ -301,8 +305,10 @@ ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst,
|
|
|
case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING:
|
|
|
case UA_EXTENSIONOBJECT_ENCODED_XML:
|
|
|
dst->encoding = src->encoding;
|
|
|
- retval = NodeId_copy(&src->content.encoded.typeId, &dst->content.encoded.typeId, NULL);
|
|
|
- retval |= UA_ByteString_copy(&src->content.encoded.body, &dst->content.encoded.body);
|
|
|
+ retval = NodeId_copy(&src->content.encoded.typeId,
|
|
|
+ &dst->content.encoded.typeId, NULL);
|
|
|
+ retval |= UA_ByteString_copy(&src->content.encoded.body,
|
|
|
+ &dst->content.encoded.body);
|
|
|
break;
|
|
|
case UA_EXTENSIONOBJECT_DECODED:
|
|
|
case UA_EXTENSIONOBJECT_DECODED_NODELETE:
|
|
@@ -338,7 +344,8 @@ Variant_copy(UA_Variant const *src, UA_Variant *dst, const UA_DataType *_) {
|
|
|
size_t length = src->arrayLength;
|
|
|
if(UA_Variant_isScalar(src))
|
|
|
length = 1;
|
|
|
- UA_StatusCode retval = UA_Array_copy(src->data, length, &dst->data, src->type);
|
|
|
+ UA_StatusCode retval = UA_Array_copy(src->data, length,
|
|
|
+ &dst->data, src->type);
|
|
|
if(retval != UA_STATUSCODE_GOOD)
|
|
|
return retval;
|
|
|
dst->arrayLength = src->arrayLength;
|
|
@@ -399,8 +406,6 @@ UA_Variant_setArrayCopy(UA_Variant *v, const void *array,
|
|
|
return UA_STATUSCODE_GOOD;
|
|
|
}
|
|
|
|
|
|
-/* Range-wise access to Variants */
|
|
|
-
|
|
|
/* Test if a range is compatible with a variant. If yes, the following values
|
|
|
* are set:
|
|
|
* - total: how many elements are in the range
|
|
@@ -443,22 +448,22 @@ computeStrides(const UA_Variant *v, const UA_NumericRange range,
|
|
|
return UA_STATUSCODE_BADINDEXRANGENODATA;
|
|
|
count *= (range.dimensions[i].max - range.dimensions[i].min) + 1;
|
|
|
}
|
|
|
+ *total = count;
|
|
|
|
|
|
/* Compute the stride length and the position of the first element */
|
|
|
- *total = count;
|
|
|
*block = count; /* Assume the range describes the entire array. */
|
|
|
- *stride = v->arrayLength; /* So it can be copied as a contiguous block */
|
|
|
+ *stride = v->arrayLength; /* So it can be copied as a contiguous block. */
|
|
|
*first = 0;
|
|
|
size_t running_dimssize = 1;
|
|
|
UA_Boolean found_contiguous = false;
|
|
|
for(size_t k = dims_count; k > 0;) {
|
|
|
k--;
|
|
|
- if(!found_contiguous && (range.dimensions[k].min != 0 ||
|
|
|
- range.dimensions[k].max + 1 != dims[k])) {
|
|
|
- /* The maximum block that can be copied contiguously */
|
|
|
+ size_t dimrange = 1 + range.dimensions[k].max - range.dimensions[k].min;
|
|
|
+ if(!found_contiguous && dimrange != dims[k]) {
|
|
|
+ /* Found the maximum block that can be copied contiguously */
|
|
|
found_contiguous = true;
|
|
|
- *block = (range.dimensions[k].max - range.dimensions[k].min + 1) * running_dimssize;
|
|
|
- *stride = dims[k] * running_dimssize;
|
|
|
+ *block = running_dimssize * dimrange;
|
|
|
+ *stride = running_dimssize * dims[k];
|
|
|
}
|
|
|
*first += running_dimssize * range.dimensions[k].min;
|
|
|
running_dimssize *= dims[k];
|
|
@@ -531,7 +536,8 @@ UA_Variant_copyRange(const UA_Variant *orig_src, UA_Variant *dst,
|
|
|
|
|
|
/* Compute the strides */
|
|
|
size_t count, block, stride, first;
|
|
|
- UA_StatusCode retval = computeStrides(src, thisrange, &count, &block, &stride, &first);
|
|
|
+ UA_StatusCode retval = computeStrides(src, thisrange, &count,
|
|
|
+ &block, &stride, &first);
|
|
|
if(retval != UA_STATUSCODE_GOOD)
|
|
|
return retval;
|
|
|
|
|
@@ -556,8 +562,9 @@ UA_Variant_copyRange(const UA_Variant *orig_src, UA_Variant *dst,
|
|
|
}
|
|
|
} else {
|
|
|
for(size_t i = 0; i < block_count; i++) {
|
|
|
- for(size_t j = 0; j < block && retval == UA_STATUSCODE_GOOD; j++) {
|
|
|
- retval = UA_copy((const void*)nextsrc, (void*)nextdst, src->type);
|
|
|
+ for(size_t j = 0; j < block; j++) {
|
|
|
+ retval = UA_copy((const void*)nextsrc,
|
|
|
+ (void*)nextdst, src->type);
|
|
|
nextdst += elem_size;
|
|
|
nextsrc += elem_size;
|
|
|
}
|
|
@@ -574,15 +581,17 @@ UA_Variant_copyRange(const UA_Variant *orig_src, UA_Variant *dst,
|
|
|
retval = UA_STATUSCODE_BADINDEXRANGENODATA;
|
|
|
}
|
|
|
|
|
|
- /* copy the content */
|
|
|
+ /* Copy the content */
|
|
|
for(size_t i = 0; i < block_count; i++) {
|
|
|
for(size_t j = 0; j < block && retval == UA_STATUSCODE_GOOD; j++) {
|
|
|
if(stringLike)
|
|
|
retval = copySubString((const UA_String*)nextsrc,
|
|
|
- (UA_String*)nextdst, nextrange.dimensions);
|
|
|
+ (UA_String*)nextdst,
|
|
|
+ nextrange.dimensions);
|
|
|
else
|
|
|
retval = UA_Variant_copyRange((const UA_Variant*)nextsrc,
|
|
|
- (UA_Variant*)nextdst, nextrange);
|
|
|
+ (UA_Variant*)nextdst,
|
|
|
+ nextrange);
|
|
|
nextdst += elem_size;
|
|
|
nextsrc += elem_size;
|
|
|
}
|
|
@@ -592,8 +601,7 @@ UA_Variant_copyRange(const UA_Variant *orig_src, UA_Variant *dst,
|
|
|
|
|
|
/* Clean up if copying failed */
|
|
|
if(retval != UA_STATUSCODE_GOOD) {
|
|
|
- size_t copied = ((nextdst - elem_size) - (uintptr_t)dst->data) / elem_size;
|
|
|
- UA_Array_delete(dst->data, copied, src->type);
|
|
|
+ UA_Array_delete(dst->data, count, src->type);
|
|
|
dst->data = NULL;
|
|
|
return retval;
|
|
|
}
|
|
@@ -603,10 +611,11 @@ UA_Variant_copyRange(const UA_Variant *orig_src, UA_Variant *dst,
|
|
|
if(isScalar)
|
|
|
return retval;
|
|
|
|
|
|
- /* Finish the array */
|
|
|
+ /* Copy array dimensions */
|
|
|
dst->arrayLength = count;
|
|
|
if(src->arrayDimensionsSize > 0) {
|
|
|
- dst->arrayDimensions = UA_Array_new(thisrange.dimensionsSize, &UA_TYPES[UA_TYPES_UINT32]);
|
|
|
+ dst->arrayDimensions =
|
|
|
+ UA_Array_new(thisrange.dimensionsSize, &UA_TYPES[UA_TYPES_UINT32]);
|
|
|
if(!dst->arrayDimensions) {
|
|
|
Variant_deletemembers(dst, NULL);
|
|
|
return UA_STATUSCODE_BADOUTOFMEMORY;
|
|
@@ -620,19 +629,20 @@ UA_Variant_copyRange(const UA_Variant *orig_src, UA_Variant *dst,
|
|
|
}
|
|
|
|
|
|
/* TODO: Allow ranges to reach inside a scalars that are array-like, e.g.
|
|
|
- variant and strings. This is already possible for reading... */
|
|
|
+ * variant and strings. This is already possible for reading... */
|
|
|
static UA_StatusCode
|
|
|
Variant_setRange(UA_Variant *v, void *array, size_t arraySize,
|
|
|
const UA_NumericRange range, UA_Boolean copy) {
|
|
|
/* Compute the strides */
|
|
|
size_t count, block, stride, first;
|
|
|
- UA_StatusCode retval = computeStrides(v, range, &count, &block, &stride, &first);
|
|
|
+ UA_StatusCode retval = computeStrides(v, range, &count,
|
|
|
+ &block, &stride, &first);
|
|
|
if(retval != UA_STATUSCODE_GOOD)
|
|
|
return retval;
|
|
|
if(count != arraySize)
|
|
|
return UA_STATUSCODE_BADINDEXRANGEINVALID;
|
|
|
|
|
|
- /* Transfer the content */
|
|
|
+ /* Move/copy the elements */
|
|
|
size_t block_count = count / block;
|
|
|
size_t elem_size = v->type->memSize;
|
|
|
uintptr_t nextdst = (uintptr_t)v->data + (first * elem_size);
|
|
@@ -646,7 +656,7 @@ Variant_setRange(UA_Variant *v, void *array, size_t arraySize,
|
|
|
} else {
|
|
|
for(size_t i = 0; i < block_count; i++) {
|
|
|
for(size_t j = 0; j < block; j++) {
|
|
|
- UA_deleteMembers_noInit((void*)nextdst, v->type);
|
|
|
+ deleteMembers_noInit((void*)nextdst, v->type);
|
|
|
retval |= UA_copy((void*)nextsrc, (void*)nextdst, v->type);
|
|
|
nextdst += elem_size;
|
|
|
nextsrc += elem_size;
|
|
@@ -655,8 +665,7 @@ Variant_setRange(UA_Variant *v, void *array, size_t arraySize,
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- /* If pointers were transferred, initialize original array to prevent
|
|
|
- * reuse */
|
|
|
+ /* If members were moved, initialize original array to prevent reuse */
|
|
|
if(!copy && !v->type->fixedSize)
|
|
|
memset(array, 0, sizeof(elem_size)*arraySize);
|
|
|
|
|
@@ -664,15 +673,16 @@ Variant_setRange(UA_Variant *v, void *array, size_t arraySize,
|
|
|
}
|
|
|
|
|
|
UA_StatusCode
|
|
|
-UA_Variant_setRange(UA_Variant *v, void * UA_RESTRICT array, size_t arraySize,
|
|
|
- const UA_NumericRange range) {
|
|
|
+UA_Variant_setRange(UA_Variant *v, void * UA_RESTRICT array,
|
|
|
+ size_t arraySize, const UA_NumericRange range) {
|
|
|
return Variant_setRange(v, array, arraySize, range, false);
|
|
|
}
|
|
|
|
|
|
UA_StatusCode
|
|
|
-UA_Variant_setRangeCopy(UA_Variant *v, const void *array, size_t arraySize,
|
|
|
- const UA_NumericRange range) {
|
|
|
- return Variant_setRange(v, (void*)(uintptr_t)array, arraySize, range, true);
|
|
|
+UA_Variant_setRangeCopy(UA_Variant *v, const void *array,
|
|
|
+ size_t arraySize, const UA_NumericRange range) {
|
|
|
+ return Variant_setRange(v, (void*)(uintptr_t)array,
|
|
|
+ arraySize, range, true);
|
|
|
}
|
|
|
|
|
|
/* LocalizedText */
|
|
@@ -727,7 +737,8 @@ DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst,
|
|
|
if(src->hasAdditionalInfo)
|
|
|
retval = UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
|
|
|
if(src->hasInnerDiagnosticInfo && src->innerDiagnosticInfo) {
|
|
|
- if((dst->innerDiagnosticInfo = UA_malloc(sizeof(UA_DiagnosticInfo)))) {
|
|
|
+ dst->innerDiagnosticInfo = UA_malloc(sizeof(UA_DiagnosticInfo));
|
|
|
+ if(dst->innerDiagnosticInfo) {
|
|
|
retval |= DiagnosticInfo_copy(src->innerDiagnosticInfo,
|
|
|
dst->innerDiagnosticInfo, NULL);
|
|
|
dst->hasInnerDiagnosticInfo = true;
|
|
@@ -779,8 +790,6 @@ copyGuid(const UA_Guid *src, UA_Guid *dst, const UA_DataType *_) {
|
|
|
return UA_STATUSCODE_GOOD;
|
|
|
}
|
|
|
|
|
|
-static UA_StatusCode copyNoInit(const void *src, void *dst, const UA_DataType *type);
|
|
|
-
|
|
|
typedef UA_StatusCode
|
|
|
(*UA_copySignature)(const void *src, void *dst, const UA_DataType *type);
|
|
|
|
|
@@ -796,48 +805,48 @@ static const UA_copySignature copyJumpTable[UA_BUILTIN_TYPES_COUNT + 1] = {
|
|
|
(UA_copySignature)copy8Byte, // UInt64
|
|
|
(UA_copySignature)copy4Byte, // Float
|
|
|
(UA_copySignature)copy8Byte, // Double
|
|
|
- (UA_copySignature)copyNoInit, // String
|
|
|
+ (UA_copySignature)copy_noInit, // String
|
|
|
(UA_copySignature)copy8Byte, // DateTime
|
|
|
(UA_copySignature)copyGuid, // Guid
|
|
|
- (UA_copySignature)copyNoInit, // ByteString
|
|
|
- (UA_copySignature)copyNoInit, // XmlElement
|
|
|
+ (UA_copySignature)copy_noInit, // ByteString
|
|
|
+ (UA_copySignature)copy_noInit, // XmlElement
|
|
|
(UA_copySignature)NodeId_copy,
|
|
|
(UA_copySignature)ExpandedNodeId_copy,
|
|
|
(UA_copySignature)copy4Byte, // StatusCode
|
|
|
- (UA_copySignature)copyNoInit, // QualifiedName
|
|
|
+ (UA_copySignature)copy_noInit, // QualifiedName
|
|
|
(UA_copySignature)LocalizedText_copy, // LocalizedText
|
|
|
(UA_copySignature)ExtensionObject_copy,
|
|
|
(UA_copySignature)DataValue_copy,
|
|
|
(UA_copySignature)Variant_copy,
|
|
|
(UA_copySignature)DiagnosticInfo_copy,
|
|
|
- (UA_copySignature)copyNoInit // all others
|
|
|
+ (UA_copySignature)copy_noInit // all others
|
|
|
};
|
|
|
|
|
|
static UA_StatusCode
|
|
|
-copyNoInit(const void *src, void *dst, const UA_DataType *type) {
|
|
|
+copy_noInit(const void *src, void *dst, const UA_DataType *type) {
|
|
|
UA_StatusCode retval = UA_STATUSCODE_GOOD;
|
|
|
uintptr_t ptrs = (uintptr_t)src;
|
|
|
uintptr_t ptrd = (uintptr_t)dst;
|
|
|
UA_Byte membersSize = type->membersSize;
|
|
|
for(size_t i = 0; i < membersSize; i++) {
|
|
|
- const UA_DataTypeMember *member = &type->members[i];
|
|
|
+ const UA_DataTypeMember *m= &type->members[i];
|
|
|
const UA_DataType *typelists[2] = { UA_TYPES, &type[-type->typeIndex] };
|
|
|
- const UA_DataType *memberType = &typelists[!member->namespaceZero][member->memberTypeIndex];
|
|
|
- if(!member->isArray) {
|
|
|
- ptrs += member->padding;
|
|
|
- ptrd += member->padding;
|
|
|
- size_t fi = memberType->builtin ? memberType->typeIndex : UA_BUILTIN_TYPES_COUNT;
|
|
|
- retval |= copyJumpTable[fi]((const void*)ptrs, (void*)ptrd, memberType);
|
|
|
- ptrs += memberType->memSize;
|
|
|
- ptrd += memberType->memSize;
|
|
|
+ const UA_DataType *mt = &typelists[!m->namespaceZero][m->memberTypeIndex];
|
|
|
+ if(!m->isArray) {
|
|
|
+ ptrs += m->padding;
|
|
|
+ ptrd += m->padding;
|
|
|
+ size_t fi = mt->builtin ? mt->typeIndex : UA_BUILTIN_TYPES_COUNT;
|
|
|
+ retval |= copyJumpTable[fi]((const void*)ptrs, (void*)ptrd, mt);
|
|
|
+ ptrs += mt->memSize;
|
|
|
+ ptrd += mt->memSize;
|
|
|
} else {
|
|
|
- ptrs += member->padding;
|
|
|
- ptrd += member->padding;
|
|
|
+ ptrs += m->padding;
|
|
|
+ ptrd += m->padding;
|
|
|
size_t *dst_size = (size_t*)ptrd;
|
|
|
const size_t size = *((const size_t*)ptrs);
|
|
|
ptrs += sizeof(size_t);
|
|
|
ptrd += sizeof(size_t);
|
|
|
- retval |= UA_Array_copy(*(void* const*)ptrs, size, (void**)ptrd, memberType);
|
|
|
+ retval |= UA_Array_copy(*(void* const*)ptrs, size, (void**)ptrd, mt);
|
|
|
if(retval == UA_STATUSCODE_GOOD)
|
|
|
*dst_size = size;
|
|
|
else
|
|
@@ -852,16 +861,18 @@ copyNoInit(const void *src, void *dst, const UA_DataType *type) {
|
|
|
UA_StatusCode
|
|
|
UA_copy(const void *src, void *dst, const UA_DataType *type) {
|
|
|
memset(dst, 0, type->memSize); /* init */
|
|
|
- UA_StatusCode retval = copyNoInit(src, dst, type);
|
|
|
+ UA_StatusCode retval = copy_noInit(src, dst, type);
|
|
|
if(retval != UA_STATUSCODE_GOOD)
|
|
|
UA_deleteMembers(dst, type);
|
|
|
return retval;
|
|
|
}
|
|
|
|
|
|
-typedef void (*UA_deleteMembersSignature)(void *p, const UA_DataType *type);
|
|
|
static void nopDeleteMembers(void *p, const UA_DataType *type) { }
|
|
|
|
|
|
-static const UA_deleteMembersSignature deleteMembersJumpTable[UA_BUILTIN_TYPES_COUNT + 1] = {
|
|
|
+typedef void (*UA_deleteMembersSignature)(void *p, const UA_DataType *type);
|
|
|
+
|
|
|
+static const
|
|
|
+UA_deleteMembersSignature deleteMembersJumpTable[UA_BUILTIN_TYPES_COUNT + 1] = {
|
|
|
(UA_deleteMembersSignature)nopDeleteMembers, // Boolean
|
|
|
(UA_deleteMembersSignature)nopDeleteMembers, // SByte
|
|
|
(UA_deleteMembersSignature)nopDeleteMembers, // Byte
|
|
@@ -881,33 +892,33 @@ static const UA_deleteMembersSignature deleteMembersJumpTable[UA_BUILTIN_TYPES_C
|
|
|
(UA_deleteMembersSignature)NodeId_deleteMembers,
|
|
|
(UA_deleteMembersSignature)ExpandedNodeId_deleteMembers, // ExpandedNodeId
|
|
|
(UA_deleteMembersSignature)nopDeleteMembers, // StatusCode
|
|
|
- (UA_deleteMembersSignature)UA_deleteMembers_noInit, // QualifiedName
|
|
|
+ (UA_deleteMembersSignature)deleteMembers_noInit, // QualifiedName
|
|
|
(UA_deleteMembersSignature)LocalizedText_deleteMembers, // LocalizedText
|
|
|
(UA_deleteMembersSignature)ExtensionObject_deleteMembers,
|
|
|
(UA_deleteMembersSignature)DataValue_deleteMembers,
|
|
|
(UA_deleteMembersSignature)Variant_deletemembers,
|
|
|
(UA_deleteMembersSignature)DiagnosticInfo_deleteMembers,
|
|
|
- (UA_deleteMembersSignature)UA_deleteMembers_noInit,
|
|
|
+ (UA_deleteMembersSignature)deleteMembers_noInit,
|
|
|
};
|
|
|
|
|
|
static void
|
|
|
-UA_deleteMembers_noInit(void *p, const UA_DataType *type) {
|
|
|
+deleteMembers_noInit(void *p, const UA_DataType *type) {
|
|
|
uintptr_t ptr = (uintptr_t)p;
|
|
|
UA_Byte membersSize = type->membersSize;
|
|
|
for(size_t i = 0; i < membersSize; i++) {
|
|
|
- const UA_DataTypeMember *member = &type->members[i];
|
|
|
+ const UA_DataTypeMember *m= &type->members[i];
|
|
|
const UA_DataType *typelists[2] = { UA_TYPES, &type[-type->typeIndex] };
|
|
|
- const UA_DataType *memberType = &typelists[!member->namespaceZero][member->memberTypeIndex];
|
|
|
- if(!member->isArray) {
|
|
|
- ptr += member->padding;
|
|
|
- size_t fi = memberType->builtin ? memberType->typeIndex : UA_BUILTIN_TYPES_COUNT;
|
|
|
- deleteMembersJumpTable[fi]((void*)ptr, memberType);
|
|
|
- ptr += memberType->memSize;
|
|
|
+ const UA_DataType *mt = &typelists[!m->namespaceZero][m->memberTypeIndex];
|
|
|
+ if(!m->isArray) {
|
|
|
+ ptr += m->padding;
|
|
|
+ size_t fi = mt->builtin ? mt->typeIndex : UA_BUILTIN_TYPES_COUNT;
|
|
|
+ deleteMembersJumpTable[fi]((void*)ptr, mt);
|
|
|
+ ptr += mt->memSize;
|
|
|
} else {
|
|
|
- ptr += member->padding;
|
|
|
+ ptr += m->padding;
|
|
|
size_t length = *(size_t*)ptr;
|
|
|
ptr += sizeof(size_t);
|
|
|
- UA_Array_delete(*(void**)ptr, length, memberType);
|
|
|
+ UA_Array_delete(*(void**)ptr, length, mt);
|
|
|
ptr += sizeof(void*);
|
|
|
}
|
|
|
}
|
|
@@ -915,13 +926,13 @@ UA_deleteMembers_noInit(void *p, const UA_DataType *type) {
|
|
|
|
|
|
void
|
|
|
UA_deleteMembers(void *p, const UA_DataType *type) {
|
|
|
- UA_deleteMembers_noInit(p, type);
|
|
|
+ deleteMembers_noInit(p, type);
|
|
|
memset(p, 0, type->memSize); /* init */
|
|
|
}
|
|
|
|
|
|
void
|
|
|
UA_delete(void *p, const UA_DataType *type) {
|
|
|
- UA_deleteMembers_noInit(p, type);
|
|
|
+ deleteMembers_noInit(p, type);
|
|
|
UA_free(p);
|
|
|
}
|
|
|
|