still merging...

.travis.yml

@@ -43,4 +43,4 @@ after_success:
    - cd ..
    - cd ..
    - rm -rf open62541
-   - ./.coverity.sh
+   - ./tools/.coverity.sh

README.md

@@ -70,19 +70,11 @@ $ make all
 $ svn checkout svn://svn.code.sf.net/p/check/code/trunk check-code
 $ cd check-code
 $ autoreconf --install
-$ ./configure --prefix=
+$ ./configure
 $ make
 $ make install
 ```
 
-##### Get Pyhton with lxml module
-* [TBD]
-
-## Clone open62541
-```bash
-$ git clone https://github.com/acplt/open62541.git
-```
-
 ## Building 
 * use autogen.sh only first time and whenever aclocal.m4 or configure.ac were modified
 ```bash
@@ -92,6 +84,7 @@ $ ./configure --enable-debug=yes
 $ make
 $ make check
 ```
+
 ### Configure Options 
 * --enable-debug=(yes|no|verbose) - omit/include debug code
 * --enable-multithreading - enable pthreads (for examples/src/opcuaServerMT)

src/ua_basictypes.c

@@ -8,7 +8,7 @@
 
 static inline UA_Int32 UA_VTable_isValidType(UA_Int32 type) {
 	if(type < 0 /* UA_BOOLEAN */ || type > 271 /* UA_INVALID */)
-		return UA_ERR_INVALID_VALUE;
+		return UA_INVALIDTYPE;
 	return UA_SUCCESS;
 }
 
@@ -31,31 +31,23 @@ UA_Int32 UA_calcSize(void const * data, UA_UInt32 type) {
 UA_Int32 UA_Array_calcSize(UA_Int32 nElements, UA_Int32 type, void const * const * data) {
 	if(UA_VTable_isValidType(type) != UA_SUCCESS) return 0;
 	UA_Int32 length = sizeof(UA_Int32);
-	UA_Int32 i;
-
-	if (nElements > 0) {
-		for(i=0; i<nElements;i++) {
-			length += UA_calcSize((void*)data[i],type);
-		}
+	for(UA_Int32 i=0; i<nElements; i++) {
+		length += UA_calcSize((void*)data[i],type);
 	}
 	return length;
 }
 
 UA_Int32 UA_Array_encodeBinary(void const * const *src, UA_Int32 noElements, UA_Int32 type, UA_Int32* pos, UA_ByteString* dst) {
 	UA_Int32 retval = UA_SUCCESS;
-	UA_Int32 i = 0;
-
 	retval = UA_Int32_encodeBinary(&noElements, pos, dst);
-	for(i=0; i<noElements; i++) {
+	for(UA_Int32 i=0; i<noElements; i++) {
 		retval |= UA_[type].encodeBinary((void*)src[i], pos, dst);
 	}
-
 	return retval;
 }
 
 UA_Int32 UA_Array_delete(void *** p, UA_Int32 noElements, UA_Int32 type) {
 	UA_Int32 retval = UA_SUCCESS;
-
 	void ** arr = *p;
 	if(arr != UA_NULL) {
 		for(UA_Int32 i=0; i<noElements; i++) {
@@ -64,23 +56,20 @@ UA_Int32 UA_Array_delete(void *** p, UA_Int32 noElements, UA_Int32 type) {
 	}
 	UA_free(arr);
 	*p = UA_NULL;
-	
 	return retval;
 }
 
 UA_Int32 UA_Array_decodeBinary(UA_ByteString const * src, UA_Int32 noElements, UA_Int32 type, UA_Int32* pos, void *** dst) {
 	UA_Int32 retval = UA_SUCCESS;
-
 	void ** arr = *dst;
-	UA_Int32 i;
-	for(i=0; i<noElements && retval == UA_SUCCESS; i++) {
+	UA_Int32 i=0;
+	for(; i<noElements && retval == UA_SUCCESS; i++) {
 		retval |= UA_[type].decodeBinary(src, pos, arr[i]);
 	}
 
 	if(retval != UA_SUCCESS) {
 		UA_Array_delete(dst, i, type); // Be careful! The pointer to dst is not reset in the calling function
 	}
-
 	return retval;
 }
 
@@ -93,7 +82,6 @@ UA_Int32 UA_Array_decodeBinary(UA_ByteString const * src, UA_Int32 noElements, U
  */
 UA_Int32 UA_Array_new(void ***p,UA_Int32 noElements, UA_Int32 type) {
 	UA_Int32 retval = UA_SUCCESS;
-	UA_Int32 i = 0;
 	// Get memory for the pointers
 	CHECKED_DECODE(UA_VTable_isValidType(type), ;);
 	CHECKED_DECODE(UA_alloc((void**)p, sizeof(void*)*noElements), ;);
@@ -101,6 +89,7 @@ UA_Int32 UA_Array_new(void ***p,UA_Int32 noElements, UA_Int32 type) {
 	// calculate the addresses to prevent memory segmentation. This would however not call
 	// init for each member
 	void *arr = *p;
+	UA_Int32 i=0;
 	for(; i<noElements && retval == UA_SUCCESS; i++) {
 		retval |= UA_[type].new((void**)arr+i);
 	}
@@ -115,8 +104,6 @@ UA_Int32 UA_Array_copy(void const * const * src, UA_Int32 noElements, UA_Int32 t
 	// Get memory for the pointers
 	CHECKED_DECODE(UA_Array_new(dst, noElements, type), dst = UA_NULL;);
 	void **arr = *dst;
-	//void *srcArr = *src;
-
 	//only namespace zero types atm
 	if(UA_VTable_isValidType(type) != UA_SUCCESS)
 		return UA_ERROR;
@@ -149,35 +136,34 @@ UA_Int32 UA_memcpy(void * dst, void const * src, UA_Int32 size){
 	return UA_SUCCESS;
 }
 
-
-#define UA_TYPE_START_ENCODEBINARY(TYPE) \
+#define UA_TYPE_ENCODEBINARY(TYPE, CODE)										\
 UA_Int32 TYPE##_encodeBinary(TYPE const * src, UA_Int32* pos, UA_ByteString * dst) { \
 	UA_Int32 retval = UA_SUCCESS; \
 	if ( *pos < 0 || *pos+TYPE##_calcSize(src) > dst->length ) { \
 		return UA_ERR_INVALID_VALUE; \
-	} else {
+	} else { \
+        CODE \
+	} \
+	return retval; \
+}
 
 // Attention! this macro works only for TYPEs with storageSize = encodingSize
-#define UA_TYPE_START_DECODEBINARY(TYPE) \
+#define UA_TYPE_DECODEBINARY(TYPE, CODE)								\
 UA_Int32 TYPE##_decodeBinary(UA_ByteString const * src, UA_Int32* pos, TYPE * dst) { \
 	UA_Int32 retval = UA_SUCCESS; \
 	if ( *pos < 0 || *pos+TYPE##_calcSize(UA_NULL) > src->length ) { \
 		return UA_ERR_INVALID_VALUE; \
-	} else {
-
-#define UA_TYPE_END_XXCODEBINARY \
+	} else { \
+        CODE \
 	} \
 	return retval; \
 }
 
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Boolean)
-UA_TYPE_START_ENCODEBINARY(UA_Boolean)
-	UA_Boolean tmpBool = ((*src > 0) ? UA_TRUE : UA_FALSE);
-	memcpy(&(dst->data[(*pos)++]), &tmpBool, sizeof(UA_Boolean));
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_Boolean)
-	*dst = ((UA_Boolean) (src->data[(*pos)++]) > 0) ? UA_TRUE : UA_FALSE;
-UA_TYPE_END_XXCODEBINARY
+UA_TYPE_ENCODEBINARY(UA_Boolean,
+    UA_Boolean tmpBool = ((*src > 0) ? UA_TRUE : UA_FALSE);
+	memcpy(&(dst->data[(*pos)++]), &tmpBool, sizeof(UA_Boolean));)
+UA_TYPE_DECODEBINARY(UA_Boolean, *dst = ((UA_Boolean) (src->data[(*pos)++]) > 0) ? UA_TRUE : UA_FALSE;)
 UA_Int32 UA_Boolean_init(UA_Boolean * p){
 	if(p==UA_NULL)return UA_ERROR;
 	*p = UA_FALSE;
@@ -188,80 +174,46 @@ UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Boolean)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Boolean)
 UA_TYPE_METHOD_COPY(UA_Boolean)
 
-UA_Int32 UA_Boolean_copycstring(cstring src, UA_Boolean* dst) {
-	*dst = UA_FALSE;
-	if (0 == strncmp(src, "true", 4) || 0 == strncmp(src, "TRUE", 4)) {
-		*dst = UA_TRUE;
-	}
-	return UA_SUCCESS;
-}
-
-UA_Int32 UA_Boolean_decodeXML(XML_Stack* s, XML_Attr* attr, UA_Boolean* dst, _Bool isStart) {
-	DBG_VERBOSE(printf("UA_Boolean entered with dst=%p,isStart=%d\n", (void* ) dst, isStart));
-	if (isStart) {
-		if (dst == UA_NULL) {
-			UA_Boolean_new(&dst);
-			s->parent[s->depth - 1].children[s->parent[s->depth - 1].activeChild].obj = (void*) dst;
-		}
-		UA_Boolean_copycstring((cstring) attr[1], dst);
-	}
-	return UA_SUCCESS;
-}
-
+/* UA_Byte */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Byte)
-UA_TYPE_START_ENCODEBINARY(UA_Byte)
-	dst->data[(*pos)++] = *src;
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_Byte)
-	*dst = src->data[(*pos)++];
-UA_TYPE_END_XXCODEBINARY
-
+UA_TYPE_ENCODEBINARY(UA_Byte, dst->data[(*pos)++] = *src;)
+UA_TYPE_DECODEBINARY(UA_Byte, *dst = src->data[(*pos)++];)
 UA_TYPE_METHOD_DELETE_FREE(UA_Byte)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Byte)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_Byte)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Byte)
 UA_TYPE_METHOD_COPY(UA_Byte)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_Byte)
 
+/* UA_SByte */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_SByte)
-UA_TYPE_START_ENCODEBINARY(UA_SByte)
-	dst->data[(*pos)++] = *src;
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_SByte)
-	*dst = src->data[(*pos)++];
-UA_TYPE_END_XXCODEBINARY
+UA_TYPE_ENCODEBINARY(UA_SByte, dst->data[(*pos)++] = *src;)
+UA_TYPE_DECODEBINARY(UA_SByte, *dst = src->data[(*pos)++];)
 UA_TYPE_METHOD_DELETE_FREE(UA_SByte)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_SByte)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_SByte)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_SByte)
 UA_TYPE_METHOD_COPY(UA_SByte)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_SByte)
 
+/* UA_UInt16 */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_UInt16)
-UA_TYPE_START_ENCODEBINARY(UA_UInt16)
-	dst->data[(*pos)++] = (*src & 0x00FF) >> 0;
-	dst->data[(*pos)++] = (*src & 0xFF00) >> 8;
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_UInt16)
+UA_TYPE_ENCODEBINARY(UA_UInt16,
+    dst->data[(*pos)++] = (*src & 0x00FF) >> 0;
+	dst->data[(*pos)++] = (*src & 0xFF00) >> 8;)
+UA_TYPE_DECODEBINARY(UA_UInt16,
 	*dst =  (UA_UInt16) src->data[(*pos)++] << 0;
-	*dst |= (UA_UInt16) src->data[(*pos)++] << 8;
-UA_TYPE_END_XXCODEBINARY
+    *dst |= (UA_UInt16) src->data[(*pos)++] << 8;)
 UA_TYPE_METHOD_DELETE_FREE(UA_UInt16)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_UInt16)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_UInt16)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_UInt16)
 UA_TYPE_METHOD_COPY(UA_UInt16)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_UInt16)
 
 /** UA_Int16 - signed integer, 2 bytes */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Int16)
-UA_TYPE_START_ENCODEBINARY(UA_Int16)
-	retval = UA_UInt16_encodeBinary((UA_UInt16 const *) src,pos,dst);
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_Int16)
+UA_TYPE_ENCODEBINARY(UA_Int16, retval = UA_UInt16_encodeBinary((UA_UInt16 const *) src,pos,dst);)
+UA_TYPE_DECODEBINARY(UA_Int16,
 	*dst  = (UA_Int16) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 0);
-	*dst |= (UA_Int16) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 8);
-UA_TYPE_END_XXCODEBINARY
+    *dst |= (UA_Int16) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 8);)
 UA_TYPE_METHOD_DELETE_FREE(UA_Int16)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Int16)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_Int16)
@@ -270,18 +222,16 @@ UA_TYPE_METHOD_COPY(UA_Int16)
 
 /** UA_Int32 - signed integer, 4 bytes */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Int32)
-UA_TYPE_START_ENCODEBINARY(UA_Int32)
-	dst->data[(*pos)++] = (*src & 0x000000FF) >> 0;
-	dst->data[(*pos)++] = (*src & 0x0000FF00) >> 8;
-	dst->data[(*pos)++] = (*src & 0x00FF0000) >> 16;
-	dst->data[(*pos)++] = (*src & 0xFF000000) >> 24;
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_Int32)
+UA_TYPE_ENCODEBINARY(UA_Int32,
+    dst->data[(*pos)++] = (*src & 0x000000FF) >> 0;
+    dst->data[(*pos)++] = (*src & 0x0000FF00) >> 8;
+    dst->data[(*pos)++] = (*src & 0x00FF0000) >> 16;
+    dst->data[(*pos)++] = (*src & 0xFF000000) >> 24;)
+UA_TYPE_DECODEBINARY(UA_Int32,
 	*dst  = (UA_Int32) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 0);
 	*dst |= (UA_Int32) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 8);
 	*dst |= (UA_Int32) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 16);
-	*dst |= (UA_Int32) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 24);
-	UA_TYPE_END_XXCODEBINARY
+    *dst |= (UA_Int32) (((UA_SByte) (src->data[(*pos)++]) & 0xFF) << 24);)
 UA_TYPE_METHOD_DELETE_FREE(UA_Int32)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Int32)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_Int32)
@@ -290,36 +240,31 @@ UA_TYPE_METHOD_COPY(UA_Int32)
 
 /** UA_UInt32 - unsigned integer, 4 bytes */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_UInt32)
-UA_TYPE_START_ENCODEBINARY(UA_UInt32)
-	retval = UA_Int32_encodeBinary((UA_Int32 const *)src,pos,dst);
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_UInt32)
+UA_TYPE_ENCODEBINARY(UA_UInt32, retval = UA_Int32_encodeBinary((UA_Int32 const *)src,pos,dst);)
+UA_TYPE_DECODEBINARY(UA_UInt32,
 	UA_UInt32 t1 = (UA_UInt32)((UA_Byte)(src->data[(*pos)++] & 0xFF));
 	UA_UInt32 t2 = (UA_UInt32)((UA_Byte)(src->data[(*pos)++]& 0xFF) << 8);
 	UA_UInt32 t3 = (UA_UInt32)((UA_Byte)(src->data[(*pos)++]& 0xFF) << 16);
 	UA_UInt32 t4 = (UA_UInt32)((UA_Byte)(src->data[(*pos)++]& 0xFF) << 24);
-	*dst = t1 + t2 + t3 + t4;
-UA_TYPE_END_XXCODEBINARY
+    *dst = t1 + t2 + t3 + t4;)
 UA_TYPE_METHOD_DELETE_FREE(UA_UInt32)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_UInt32)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_UInt32)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_UInt32)
 UA_TYPE_METHOD_COPY(UA_UInt32)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_UInt32)
 
 /** UA_Int64 - signed integer, 8 bytes */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Int64)
-UA_TYPE_START_ENCODEBINARY(UA_Int64)
-	dst->data[(*pos)++] = (*src & 0x00000000000000FF) >> 0;
-	dst->data[(*pos)++] = (*src & 0x000000000000FF00) >> 8;
-	dst->data[(*pos)++] = (*src & 0x0000000000FF0000) >> 16;
-	dst->data[(*pos)++] = (*src & 0x00000000FF000000) >> 24;
-	dst->data[(*pos)++] = (*src & 0x000000FF00000000) >> 32;
-	dst->data[(*pos)++] = (*src & 0x0000FF0000000000) >> 40;
-	dst->data[(*pos)++] = (*src & 0x00FF000000000000) >> 48;
-	dst->data[(*pos)++] = (*src & 0xFF00000000000000) >> 56;
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_Int64)
+UA_TYPE_ENCODEBINARY(UA_Int64,
+    dst->data[(*pos)++] = (*src & 0x00000000000000FF) >> 0;
+    dst->data[(*pos)++] = (*src & 0x000000000000FF00) >> 8;
+    dst->data[(*pos)++] = (*src & 0x0000000000FF0000) >> 16;
+    dst->data[(*pos)++] = (*src & 0x00000000FF000000) >> 24;
+    dst->data[(*pos)++] = (*src & 0x000000FF00000000) >> 32;
+    dst->data[(*pos)++] = (*src & 0x0000FF0000000000) >> 40;
+    dst->data[(*pos)++] = (*src & 0x00FF000000000000) >> 48;
+    dst->data[(*pos)++] = (*src & 0xFF00000000000000) >> 56;)
+UA_TYPE_DECODEBINARY(UA_Int64,
 	*dst  = (UA_Int64) src->data[(*pos)++] << 0;
 	*dst |= (UA_Int64) src->data[(*pos)++] << 8;
 	*dst |= (UA_Int64) src->data[(*pos)++] << 16;
@@ -327,21 +272,17 @@ UA_TYPE_START_DECODEBINARY(UA_Int64)
 	*dst |= (UA_Int64) src->data[(*pos)++] << 32;
 	*dst |= (UA_Int64) src->data[(*pos)++] << 40;
 	*dst |= (UA_Int64) src->data[(*pos)++] << 48;
-	*dst |= (UA_Int64) src->data[(*pos)++] << 56;
-UA_TYPE_END_XXCODEBINARY
+    *dst |= (UA_Int64) src->data[(*pos)++] << 56;)
 UA_TYPE_METHOD_DELETE_FREE(UA_Int64)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Int64)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_Int64)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Int64)
 UA_TYPE_METHOD_COPY(UA_Int64)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_Int64)
 
 /** UA_UInt64 - unsigned integer, 8 bytes */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_UInt64)
-UA_TYPE_START_ENCODEBINARY(UA_UInt64)
-	return UA_Int64_encodeBinary((UA_Int64 const *)src,pos,dst);
-UA_TYPE_END_XXCODEBINARY
-UA_TYPE_START_DECODEBINARY(UA_UInt64)
+UA_TYPE_ENCODEBINARY(UA_UInt64, return UA_Int64_encodeBinary((UA_Int64 const *)src,pos,dst);)
+UA_TYPE_DECODEBINARY(UA_UInt64,
 	UA_UInt64 t1 = (UA_UInt64) src->data[(*pos)++];
 	UA_UInt64 t2 = (UA_UInt64) src->data[(*pos)++] << 8;
 	UA_UInt64 t3 = (UA_UInt64) src->data[(*pos)++] << 16;
@@ -350,20 +291,18 @@ UA_TYPE_START_DECODEBINARY(UA_UInt64)
 	UA_UInt64 t6 = (UA_UInt64) src->data[(*pos)++] << 40;
 	UA_UInt64 t7 = (UA_UInt64) src->data[(*pos)++] << 48;
 	UA_UInt64 t8 = (UA_UInt64) src->data[(*pos)++] << 56;
-	*dst = t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8;
-UA_TYPE_END_XXCODEBINARY
+    *dst = t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8;)
 UA_TYPE_METHOD_DELETE_FREE(UA_UInt64)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_UInt64)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_UInt64)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_UInt64)
 UA_TYPE_METHOD_COPY(UA_UInt64)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_UInt64)
 
 /** UA_Float - IEE754 32bit float with biased exponent */
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Float)
 // FIXME: Implement NaN, Inf and Zero(s)
 UA_Byte UA_FLOAT_ZERO[] = {0x00,0x00,0x00,0x00};
-UA_TYPE_START_DECODEBINARY(UA_Float)
+UA_TYPE_DECODEBINARY(UA_Float,
 	if (memcmp(&(src->data[*pos]),UA_FLOAT_ZERO,4)==0) { return UA_Int32_decodeBinary(src,pos,(UA_Int32*)dst); }
 	UA_Float mantissa;
 	mantissa = (UA_Float) (src->data[*pos] & 0xFF);							// bits 0-7
@@ -378,14 +317,8 @@ UA_TYPE_START_DECODEBINARY(UA_Float)
 	} else {
 		*dst = (UA_Float) sign * 2.0 * (1.0 + mantissa / 128.0 ) / ((UA_Float) (biasedExponent-127));
 	}
-	*pos += 4;
-UA_TYPE_END_XXCODEBINARY
-#ifdef __pdp11
-#error FIXME UA_Float_encodeBinary is not yet completely byte order agnostic
-#endif
-UA_TYPE_START_ENCODEBINARY(UA_Float)
-	return UA_UInt32_encodeBinary((UA_UInt32*)src,pos,dst);
-UA_TYPE_END_XXCODEBINARY
+    *pos += 4;)
+UA_TYPE_ENCODEBINARY(UA_Float, return UA_UInt32_encodeBinary((UA_UInt32*)src,pos,dst);)
 UA_TYPE_METHOD_DELETE_FREE(UA_Float)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Float)
 UA_Int32 UA_Float_init(UA_Float * p){
@@ -395,13 +328,12 @@ UA_Int32 UA_Float_init(UA_Float * p){
 }
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Float)
 UA_TYPE_METHOD_COPY(UA_Float)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_Float)
 
-/** UA_Double - IEEE754 64bit float with biased exponent*/
+/** UA_Float - IEEE754 64bit float with biased exponent*/
 UA_TYPE_METHOD_CALCSIZE_SIZEOF(UA_Double)
 // FIXME: Implement NaN, Inf and Zero(s)
 UA_Byte UA_DOUBLE_ZERO[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
-UA_TYPE_START_DECODEBINARY(UA_Double)
+UA_TYPE_DECODEBINARY(UA_Double,
 	if (memcmp(&(src->data[*pos]),UA_DOUBLE_ZERO,8)==0) { return UA_Int64_decodeBinary(src,pos,(UA_Int64*)dst); }
 	UA_Double mantissa;
 	mantissa = (UA_Double) (src->data[*pos] & 0xFF);							// bits 0-7
@@ -423,20 +355,13 @@ UA_TYPE_START_DECODEBINARY(UA_Double)
 	} else {
 		*dst = (UA_Double) sign * 2.0 * (1.0 + mantissa / 8.0 ) / ((UA_Double) (biasedExponent-1023));
 	}
-	*pos += 8;
-UA_TYPE_END_XXCODEBINARY
-#ifdef __pdp11
-#error FIXME UA_Float_decodeBinary is not yet completely byte order agnostic
-#endif
-UA_TYPE_START_ENCODEBINARY(UA_Double)
-	return UA_UInt64_encodeBinary((UA_UInt64*)src,pos,dst);
-UA_TYPE_END_XXCODEBINARY
+    *pos += 8;)
+UA_TYPE_ENCODEBINARY(UA_Double, return UA_UInt64_encodeBinary((UA_UInt64*)src,pos,dst);)
 UA_TYPE_METHOD_DELETE_FREE(UA_Double)
 UA_TYPE_METHOD_DELETEMEMBERS_NOACTION(UA_Double)
 UA_TYPE_METHOD_INIT_DEFAULT(UA_Double)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Double)
 UA_TYPE_METHOD_COPY(UA_Double)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_Double)
 
 /** UA_String */
 UA_Int32 UA_String_calcSize(UA_String const * string) {
@@ -452,16 +377,12 @@ UA_Int32 UA_String_calcSize(UA_String const * string) {
 }
 UA_Int32 UA_String_encodeBinary(UA_String const * src, UA_Int32* pos, UA_ByteString* dst) {
 	UA_Int32 retval = UA_SUCCESS;
-	if (src == UA_NULL) {
-		return UA_ERR_INVALID_VALUE;
-	} else if (*pos < 0 || *pos + UA_String_calcSize(src) > dst->length) {
-		return UA_ERR_INVALID_VALUE;
-	} else {
-		retval = UA_Int32_encodeBinary(&(src->length),pos,dst);
-		if (src->length > 0) {
-			retval |= UA_memcpy(&(dst->data[*pos]), src->data, src->length);
-			*pos += src->length;
-		}
+	if (src == UA_NULL) return UA_ERR_INVALID_VALUE;
+	if (*pos < 0 || *pos + UA_String_calcSize(src) > dst->length) return UA_ERR_INVALID_VALUE;
+	retval |= UA_Int32_encodeBinary(&(src->length), pos, dst);
+	if (src->length > 0) {
+		retval |= UA_memcpy(&(dst->data[*pos]), src->data, src->length);
+		*pos += src->length;
 	}
 	return retval;
 }
@@ -553,7 +474,6 @@ UA_Int32 UA_String_init(UA_String* p){
 
 UA_Int32 UA_String_compare(const UA_String* string1, const UA_String* string2) {
 	UA_Int32 retval;
-
 	if (string1->length == 0 && string2->length == 0) {
 		retval = UA_EQUAL;
 	} else if (string1->length == -1 && string2->length == -1) {
@@ -572,11 +492,10 @@ void UA_String_printf(char const * label, const UA_String* string) {
 			string->length, (char*)string->data);
 }
 void UA_String_printx(char const * label, const UA_String* string) {
-	UA_Int32 i;
 	if (string == UA_NULL) { printf("%s {NULL}\n", label); return; }
 	printf("%s {Length=%d, Data=", label, string->length);
 	if (string->length > 0) {
-		for (i = 0; i < string->length; i++) {
+		for (UA_Int32 i = 0; i < string->length; i++) {
 			printf("%c%d", i == 0 ? '{' : ',', (string->data)[i]);
 			// if (i > 0 && !(i%20)) { printf("\n\t"); }
 		}
@@ -586,10 +505,9 @@ void UA_String_printx(char const * label, const UA_String* string) {
 	printf("}}\n");
 }
 void UA_String_printx_hex(char const * label, const UA_String* string) {
-	UA_Int32 i;
 	printf("%s {Length=%d, Data=", label, string->length);
 	if (string->length > 0) {
-		for (i = 0; i < string->length; i++) {
+		for (UA_Int32 i = 0; i < string->length; i++) {
 			printf("%c%x", i == 0 ? '{' : ',', (string->data)[i]);
 		}
 	} else {
@@ -598,7 +516,6 @@ void UA_String_printx_hex(char const * label, const UA_String* string) {
 	printf("}}\n");
 }
 
-
 // TODO: should we really want to handle UA_String and UA_ByteString the same way?
 UA_TYPE_METHOD_PROTOTYPES_AS(UA_ByteString, UA_String)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_ByteString)
@@ -630,6 +547,7 @@ UA_Int32 UA_ByteString_newMembers(UA_ByteString* p, UA_Int32 length) {
 	return retval;
 }
 
+/* UA_Guid */
 UA_Int32 UA_Guid_calcSize(UA_Guid const * p) {
 	if (p == UA_NULL) {
 		return sizeof(UA_Guid);
@@ -638,53 +556,46 @@ UA_Int32 UA_Guid_calcSize(UA_Guid const * p) {
 	}
 }
 
-UA_TYPE_START_ENCODEBINARY(UA_Guid)
-	UA_Int32 i=0;
-	retval |= UA_UInt32_encodeBinary(&(src->data1), pos, dst);
-	retval |= UA_UInt16_encodeBinary(&(src->data2), pos, dst);
-	retval |= UA_UInt16_encodeBinary(&(src->data3), pos, dst);
-	for (i=0;i<8;i++) {
-		retval |= UA_Byte_encodeBinary(&(src->data4[i]), pos, dst);
-	}
-UA_TYPE_END_XXCODEBINARY
+UA_TYPE_ENCODEBINARY(UA_Guid,
+    retval |= UA_UInt32_encodeBinary(&(src->data1), pos, dst);
+    retval |= UA_UInt16_encodeBinary(&(src->data2), pos, dst);
+    retval |= UA_UInt16_encodeBinary(&(src->data3), pos, dst);
+    for (UA_Int32 i=0;i<8;i++) {
+	    retval |= UA_Byte_encodeBinary(&(src->data4[i]), pos, dst);
+    })
 
 UA_Int32 UA_Guid_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_Guid *dst) {
 	UA_Int32 retval = UA_SUCCESS;
-	UA_Int32 i=0;
 	// TODO: This could be done with a single memcpy (if the compiler does no fancy realigning of structs)
 	CHECKED_DECODE(UA_UInt32_decodeBinary(src,pos,&dst->data1), ;);
 	CHECKED_DECODE(UA_UInt16_decodeBinary(src,pos,&dst->data2), ;);
 	CHECKED_DECODE(UA_UInt16_decodeBinary(src,pos,&dst->data3), ;);
-	for (i=0;i<8;i++) {
+	for (UA_Int32 i=0;i<8;i++) {
 		CHECKED_DECODE(UA_Byte_decodeBinary(src,pos,&dst->data4[i]), ;);
 	}
 	return retval;
 }
 UA_TYPE_METHOD_DELETE_STRUCT(UA_Guid)
 UA_Int32 UA_Guid_deleteMembers(UA_Guid* p) { return UA_SUCCESS; }
-UA_Int32 UA_Guid_compare(const UA_Guid *g1, const UA_Guid *g2) {
-	return memcmp(g1, g2, sizeof(UA_Guid));
-}
-
-UA_Int32 UA_Guid_init(UA_Guid* p) {
-	if(p==UA_NULL)return UA_ERROR;
+UA_Int32 UA_Guid_compare(const UA_Guid *g1, const UA_Guid *g2) { return memcmp(g1, g2, sizeof(UA_Guid)); }
+UA_Int32 UA_Guid_init(UA_Guid* p){
+	if(p==UA_NULL) return UA_ERROR;
 	p->data1 = 0;
 	p->data2 = 0;
 	p->data3 = 0;
 	memset(p->data4,8,sizeof(UA_Byte));
 	return UA_SUCCESS;
 }
-
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Guid)
-
-UA_Int32 UA_Guid_copy(UA_Guid const *src, UA_Guid *dst) {
+UA_Int32 UA_Guid_copy(UA_Guid const *src, UA_Guid *dst)
+{
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_alloc((void**)&dst,UA_Guid_calcSize(UA_NULL));
 	retval |= UA_memcpy((void*)dst,(void*)src,UA_Guid_calcSize(UA_NULL));
 	return retval;
 }
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_Guid)
 
+/* UA_LocalizedText */
 UA_Int32 UA_LocalizedText_calcSize(UA_LocalizedText const * p) {
 	UA_Int32 length = 0;
 	if (p==UA_NULL) {
@@ -702,17 +613,14 @@ UA_Int32 UA_LocalizedText_calcSize(UA_LocalizedText const * p) {
 	}
 	return length;
 }
-
-UA_TYPE_START_ENCODEBINARY(UA_LocalizedText)
+UA_TYPE_ENCODEBINARY(UA_LocalizedText,
 	retval |= UA_Byte_encodeBinary(&(src->encodingMask),pos,dst);
 	if (src->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE) {
 		retval |= UA_String_encodeBinary(&(src->locale),pos,dst);
 	}
 	if (src->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT) {
 		retval |= UA_String_encodeBinary(&(src->text),pos,dst);
-	}
-UA_TYPE_END_XXCODEBINARY
-
+	})
 UA_Int32 UA_LocalizedText_decodeBinary(UA_ByteString const * src, UA_Int32 *pos, UA_LocalizedText *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 
@@ -728,7 +636,6 @@ UA_Int32 UA_LocalizedText_decodeBinary(UA_ByteString const * src, UA_Int32 *pos,
 	}
 	return retval;
 }
-
 UA_TYPE_METHOD_DELETE_STRUCT(UA_LocalizedText)
 UA_Int32 UA_LocalizedText_deleteMembers(UA_LocalizedText* p) {
 	return UA_SUCCESS | UA_String_deleteMembers(&p->locale) | UA_String_deleteMembers(&p->text);
@@ -741,9 +648,7 @@ UA_Int32 UA_LocalizedText_init(UA_LocalizedText* p){
 	UA_String_init(&(p->text));
 	return UA_SUCCESS;
 }
-
 UA_TYPE_METHOD_NEW_DEFAULT(UA_LocalizedText)
-
 UA_Int32 UA_LocalizedText_copycstring(char const * src, UA_LocalizedText* dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	if(dst==UA_NULL) return UA_ERROR;
@@ -752,8 +657,7 @@ UA_Int32 UA_LocalizedText_copycstring(char const * src, UA_LocalizedText* dst) {
 	retval |= UA_String_copycstring(src,&(dst->text));
 	return retval;
 }
-UA_Int32 UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText* dst)
-{
+UA_Int32 UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText* dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_alloc((void**)dst,UA_LocalizedText_calcSize(UA_NULL));
 	retval |= UA_Byte_copy(&(src->encodingMask), &(dst->encodingMask));
@@ -761,6 +665,7 @@ UA_Int32 UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText* ds
 	retval |= UA_String_copy(&(src->text), &(dst->text));
 	return retval;
 }
+
 /* Serialization of UA_NodeID is specified in 62541-6, §5.2.2.9 */
 UA_Int32 UA_NodeId_calcSize(UA_NodeId const *p) {
 	UA_Int32 length = 0;
@@ -792,7 +697,7 @@ UA_Int32 UA_NodeId_calcSize(UA_NodeId const *p) {
 	}
 	return length;
 }
-UA_TYPE_START_ENCODEBINARY(UA_NodeId)
+UA_TYPE_ENCODEBINARY(UA_NodeId,
 	// temporary variables for endian-save code
 	UA_Byte srcByte;
 	UA_UInt16 srcUInt16;
@@ -826,8 +731,7 @@ UA_TYPE_START_ENCODEBINARY(UA_NodeId)
 		retval |= UA_UInt16_encodeBinary(&(src->namespace), pos, dst);
 		retval |= UA_ByteString_encodeBinary(&(src->identifier.byteString), pos, dst);
 		break;
-	}
-UA_TYPE_END_XXCODEBINARY
+	})
 
 UA_Int32 UA_NodeId_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_NodeId *dst) {
 	UA_Int32 retval = UA_SUCCESS;
@@ -894,11 +798,8 @@ UA_Int32 UA_NodeId_deleteMembers(UA_NodeId* p) {
 void UA_NodeId_printf(char* label, const UA_NodeId* node) {
 	UA_Int32 l;
 
-	printf("%s {encodingByte=%d, namespace=%d,", label,
-			(int)( node->encodingByte), (int) (node->namespace));
-
+	printf("%s {encodingByte=%d, namespace=%d,", label, (int)( node->encodingByte), (int) (node->namespace));
 	switch (node->encodingByte & UA_NODEIDTYPE_MASK) {
-
 	case UA_NODEIDTYPE_TWOBYTE:
 	case UA_NODEIDTYPE_FOURBYTE:
 	case UA_NODEIDTYPE_NUMERIC:
@@ -1028,15 +929,14 @@ UA_Int32 UA_ExpandedNodeId_calcSize(UA_ExpandedNodeId const * p) {
 	return length;
 }
 
-UA_TYPE_START_ENCODEBINARY(UA_ExpandedNodeId)
+UA_TYPE_ENCODEBINARY(UA_ExpandedNodeId,
 	retval |= UA_NodeId_encodeBinary(&(src->nodeId),pos,dst);
 	if (src->nodeId.encodingByte & UA_NODEIDTYPE_NAMESPACE_URI_FLAG) {
 		retval |= UA_String_encodeBinary(&(src->namespaceUri),pos,dst);
 	}
 	if (src->nodeId.encodingByte & UA_NODEIDTYPE_SERVERINDEX_FLAG) {
 		retval |= UA_UInt32_encodeBinary(&(src->serverIndex),pos,dst);
-	}
-UA_TYPE_END_XXCODEBINARY
+	})
 UA_Int32 UA_ExpandedNodeId_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_ExpandedNodeId *dst) {
 	UA_UInt32 retval = UA_SUCCESS;
 	UA_ExpandedNodeId_init(dst);
@@ -1068,8 +968,7 @@ UA_Int32 UA_ExpandedNodeId_init(UA_ExpandedNodeId* p){
 	return UA_SUCCESS;
 }
 UA_TYPE_METHOD_NEW_DEFAULT(UA_ExpandedNodeId)
-UA_Int32 UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst)
-{
+UA_Int32 UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	UA_String_copy(&(src->namespaceUri), &(dst->namespaceUri));
 	UA_NodeId_copy(&(src->nodeId), &(dst->nodeId));
@@ -1100,21 +999,17 @@ UA_Int32 UA_ExtensionObject_calcSize(UA_ExtensionObject const * p) {
 	return length;
 }
 
-UA_TYPE_START_ENCODEBINARY(UA_ExtensionObject)
+UA_TYPE_ENCODEBINARY(UA_ExtensionObject,
 	retval |= UA_NodeId_encodeBinary(&(src->typeId),pos,dst);
 	retval |= UA_Byte_encodeBinary(&(src->encoding),pos,dst);
 	switch (src->encoding) {
 	case UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED:
 		break;
 	case UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING:
-		// FIXME: This code is valid for numeric nodeIds in ns0 only!
-		retval |= UA_[UA_ns0ToVTableIndex(src->typeId.identifier.numeric)].encodeBinary(src->body.data,pos,dst);
-		break;
 	case UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISXML:
-		perror("UA_ExtensionObject_encodeBinary - requested encoding of body as XML not yet supported!");
+		retval |= UA_ByteString_encodeBinary(&(src->body),pos,dst);
 		break;
-	}
-UA_TYPE_END_XXCODEBINARY
+	})
 UA_Int32 UA_ExtensionObject_decodeBinary(UA_ByteString const * src, UA_Int32 *pos, UA_ExtensionObject *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	UA_ExtensionObject_init(dst);
@@ -1139,7 +1034,7 @@ UA_Int32 UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) {
 	retval |= UA_ByteString_deleteMembers(&(p->body));
 	return retval;
 }
-UA_Int32 UA_ExtensionObject_init(UA_ExtensionObject* p){
+UA_Int32 UA_ExtensionObject_init(UA_ExtensionObject* p) {
 	if(p==UA_NULL)return UA_ERROR;
 	UA_ByteString_init(&(p->body));
 	p->encoding = 0;
@@ -1147,8 +1042,7 @@ UA_Int32 UA_ExtensionObject_init(UA_ExtensionObject* p){
 	return UA_SUCCESS;
 }
 UA_TYPE_METHOD_NEW_DEFAULT(UA_ExtensionObject)
-UA_Int32 UA_ExtensionObject_copy(UA_ExtensionObject const  *src, UA_ExtensionObject *dst)
-{
+UA_Int32 UA_ExtensionObject_copy(UA_ExtensionObject const  *src, UA_ExtensionObject *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_ExtensionObject_calcSize(UA_NULL);
 	retval |= UA_Byte_copy(&(src->encoding),&(dst->encoding));
@@ -1232,10 +1126,9 @@ UA_Int32 UA_DiagnosticInfo_decodeBinary(UA_ByteString const * src, UA_Int32 *pos
 	}
 	return retval;
 }
-UA_TYPE_START_ENCODEBINARY(UA_DiagnosticInfo)
-	UA_Int32 i;
+UA_TYPE_ENCODEBINARY(UA_DiagnosticInfo,
 	retval |= UA_Byte_encodeBinary(&(src->encodingMask), pos, dst);
-	for (i = 0; i < 7; i++) {
+	for (UA_Int32 i = 0; i < 7; i++) {
 		switch ( (0x01 << i) & src->encodingMask)  {
 		case UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID:
 			retval |= UA_Int32_encodeBinary(&(src->symbolicId), pos, dst);
@@ -1259,8 +1152,7 @@ UA_TYPE_START_ENCODEBINARY(UA_DiagnosticInfo)
 			retval |= UA_DiagnosticInfo_encodeBinary(src->innerDiagnosticInfo, pos, dst);
 			break;
 		}
-	}
-UA_TYPE_END_XXCODEBINARY
+	})
 
 UA_TYPE_METHOD_DELETE_STRUCT(UA_DiagnosticInfo)
 UA_Int32 UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
@@ -1306,10 +1198,7 @@ UA_Int32 UA_DiagnosticInfo_copy(UA_DiagnosticInfo const  *src, UA_DiagnosticInfo
 
 	return retval;
 }
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_DiagnosticInfo)
-
-UA_TYPE_METHOD_PROTOTYPES_AS_WOXML(UA_DateTime,UA_Int64)
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_DateTime)
+UA_TYPE_METHOD_PROTOTYPES_AS(UA_DateTime,UA_Int64)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_DateTime)
 
 #include <sys/time.h>
@@ -1360,14 +1249,13 @@ UA_DateTimeStruct UA_DateTime_toStruct(UA_DateTime time){
 
 UA_Int32 UA_DateTime_toString(UA_DateTime time, UA_String* timeString){
 	char *charBuf = (char*)(*timeString).data;
-
 	UA_DateTimeStruct tSt = UA_DateTime_toStruct(time);
-
-	sprintf(charBuf, "%2d/%2d/%4d %2d:%2d:%2d.%3d.%3d.%3d", tSt.mounth, tSt.day, tSt.year, tSt.hour, tSt.min, tSt.sec, tSt.milliSec, tSt.microSec, tSt.nanoSec);
-
+	sprintf(charBuf, "%2d/%2d/%4d %2d:%2d:%2d.%3d.%3d.%3d", tSt.mounth, tSt.day, tSt.year,
+			tSt.hour, tSt.min, tSt.sec, tSt.milliSec, tSt.microSec, tSt.nanoSec);
 	return UA_SUCCESS;
 }
 
+/* UA_XmlElement */
 UA_TYPE_METHOD_PROTOTYPES_AS(UA_XmlElement, UA_ByteString)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_XmlElement)
 
@@ -1375,12 +1263,8 @@ UA_TYPE_METHOD_NEW_DEFAULT(UA_XmlElement)
 UA_TYPE_METHOD_PROTOTYPES_AS(UA_IntegerId, UA_Int32)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_IntegerId)
 
-UA_TYPE_METHOD_PROTOTYPES_AS_WOXML(UA_StatusCode, UA_UInt32)
+UA_TYPE_METHOD_PROTOTYPES_AS(UA_StatusCode, UA_UInt32)
 UA_TYPE_METHOD_NEW_DEFAULT(UA_StatusCode)
-UA_Int32 UA_StatusCode_decodeXML(XML_Stack* s, XML_Attr* attr, UA_StatusCode* dst, _Bool isStart) {
-	DBG_VERBOSE(printf("UA_StatusCode_decodeXML entered with dst=%p,isStart=%d\n", (void* ) dst, isStart));
-	return UA_ERR_NOT_IMPLEMENTED;
-}
 
 /** QualifiedName - Part 4, Chapter
  * but see Part 6, Chapter 5.2.2.13 for Binary Encoding
@@ -1401,11 +1285,10 @@ UA_Int32 UA_QualifiedName_decodeBinary(UA_ByteString const * src, UA_Int32 *pos,
 	CHECKED_DECODE(UA_String_decodeBinary(src,pos,&(dst->name)), ;);
 	return retval;
 }
-UA_TYPE_START_ENCODEBINARY(UA_QualifiedName)
+UA_TYPE_ENCODEBINARY(UA_QualifiedName,
 	retval |= UA_UInt16_encodeBinary(&(src->namespaceIndex),pos,dst);
 	//retval |= UA_UInt16_encodeBinary(&(src->reserved),pos,dst);
-	retval |= UA_String_encodeBinary(&(src->name),pos,dst);
-UA_TYPE_END_XXCODEBINARY
+	retval |= UA_String_encodeBinary(&(src->name),pos,dst);)
 UA_Int32 UA_QualifiedName_delete(UA_QualifiedName  * p) {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_QualifiedName_deleteMembers(p);
@@ -1417,7 +1300,7 @@ UA_Int32 UA_QualifiedName_deleteMembers(UA_QualifiedName  * p) {
 	retval |= UA_String_deleteMembers(&p->name);
 	return retval;
 }
-UA_Int32 UA_QualifiedName_init(UA_QualifiedName * p){
+UA_Int32 UA_QualifiedName_init(UA_QualifiedName * p) {
 	if(p==UA_NULL)return UA_ERROR;
 	UA_String_init(&(p->name));
 	p->namespaceIndex=0;
@@ -1425,8 +1308,7 @@ UA_Int32 UA_QualifiedName_init(UA_QualifiedName * p){
 	return UA_SUCCESS;
 }
 UA_TYPE_METHOD_NEW_DEFAULT(UA_QualifiedName)
-UA_Int32 UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst)
-{
+UA_Int32 UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_alloc((void**)&dst,UA_QualifiedName_calcSize(UA_NULL));
 	retval |= UA_String_copy(&(src->name),&(dst->name));
@@ -1439,14 +1321,11 @@ UA_Int32 UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *ds
 UA_Int32 UA_Variant_calcSize(UA_Variant const * p) {
 	UA_Int32 length = 0;
 	if (p == UA_NULL) return sizeof(UA_Variant);
-	UA_UInt32 builtinNs0Id = p->encodingMask & 0x3F; // Bits 0-5
+	UA_UInt32 ns0Id = p->encodingMask & 0x1F; // Bits 1-5
 	UA_Boolean isArray = p->encodingMask & (0x01 << 7); // Bit 7
 	UA_Boolean hasDimensions = p->encodingMask & (0x01 << 6); // Bit 6
-	UA_Int32 i;
 
-	if (p->vt == UA_NULL || builtinNs0Id != p->vt->ns0Id) {
-		return UA_ERR_INCONSISTENT;
-	}
+	if (p->vt == UA_NULL || ns0Id != p->vt->ns0Id) return UA_ERR_INCONSISTENT;
 	length += sizeof(UA_Byte); //p->encodingMask
 	if (isArray) { // array length is encoded
 		length += sizeof(UA_Int32); //p->arrayLength
@@ -1456,7 +1335,7 @@ UA_Int32 UA_Variant_calcSize(UA_Variant const * p) {
 			// fails for arrays with null-ptrs, see test case
 			// UA_Variant_calcSizeVariableSizeArrayWithNullPtrWillReturnWrongEncodingSize
 			// Simply do not allow?
-			for (i=0;i<p->arrayLength;i++) {
+			for (UA_Int32 i=0;i<p->arrayLength;i++) {
 				length += p->vt->calcSize(p->data[i]);
 			}
 		}
@@ -1477,12 +1356,8 @@ UA_Int32 UA_Variant_calcSize(UA_Variant const * p) {
 	}
 	return length;
 }
-UA_TYPE_START_ENCODEBINARY(UA_Variant)
-	UA_Int32 i = 0;
-
-	if (src->vt == UA_NULL || ( src->encodingMask & UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK) != src->vt->ns0Id) {
-		return UA_ERR_INCONSISTENT;
-	}
+UA_TYPE_ENCODEBINARY(UA_Variant,
+	if (src->vt == UA_NULL || ( src->encodingMask & UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK) != src->vt->ns0Id) return UA_ERR_INCONSISTENT;
 
 	retval |= UA_Byte_encodeBinary(&(src->encodingMask),pos,dst);
 	if (src->encodingMask & UA_VARIANT_ENCODINGMASKTYPE_ARRAY) { // encode array length
@@ -1490,7 +1365,7 @@ UA_TYPE_START_ENCODEBINARY(UA_Variant)
 	}
 	if (src->arrayLength > 0) {
 		//encode array as given by variant type
-		for (i=0;i<src->arrayLength;i++) {
+		for (UA_Int32 i=0;i<src->arrayLength;i++) {
 			retval |= src->vt->encodeBinary(src->data[i],pos,dst);
 		}
 	} else {
@@ -1501,7 +1376,7 @@ UA_TYPE_START_ENCODEBINARY(UA_Variant)
 				retval = UA_ERR_NO_MEMORY;
 			}
 		} else {
-			retval |= src->vt->encodeBinary(src->data[i],pos,dst);
+			retval |= src->vt->encodeBinary(src->data[0],pos,dst);
 		}
 	}
 
@@ -1509,13 +1384,12 @@ UA_TYPE_START_ENCODEBINARY(UA_Variant)
 		//encode dimension field
 		UA_Int32_encodeBinary(&(src->arrayDimensionsLength), pos, dst);
 		if(src->arrayDimensionsLength >0){
-			for (i=0;i<src->arrayDimensionsLength;i++) {
+			for (UA_Int32 i=0;i<src->arrayDimensionsLength;i++) {
 				retval |= UA_Int32_encodeBinary(src->arrayDimensions[i], pos, dst);
 			}
 		}
 
-	}
-UA_TYPE_END_XXCODEBINARY
+	})
 
 UA_Int32 UA_Variant_decodeBinary(UA_ByteString const * src, UA_Int32 *pos, UA_Variant *dst) {
 	UA_Int32 retval = UA_SUCCESS;
@@ -1562,7 +1436,7 @@ UA_Int32 UA_Variant_deleteMembers(UA_Variant  * p) {
 	}
 	return retval;
 }
-UA_Int32 UA_Variant_init(UA_Variant * p){
+UA_Int32 UA_Variant_init(UA_Variant * p) {
 	if(p==UA_NULL)return UA_ERROR;
 	p->arrayLength = -1; // no element, p->data == UA_NULL
 	p->data = UA_NULL;
@@ -1574,15 +1448,12 @@ UA_Int32 UA_Variant_init(UA_Variant * p){
 }
 UA_TYPE_METHOD_NEW_DEFAULT(UA_Variant)
 
-UA_Int32 UA_Variant_copy(UA_Variant const *src, UA_Variant *dst)
-{
+UA_Int32 UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	UA_Int32 ns0Id = src->encodingMask & UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK;
 	UA_Int32 uaIdx = UA_ns0ToVTableIndex(ns0Id);
 	void * pData;
-	if(UA_VTable_isValidType(uaIdx) != UA_SUCCESS){
-		return UA_ERROR;
-	}
+	if(UA_VTable_isValidType(uaIdx) != UA_SUCCESS) return UA_ERROR;
 	dst->vt = &UA_[uaIdx];
 	retval |= UA_Int32_copy(&(src->arrayLength), &(dst->arrayLength));
 	retval |= UA_Byte_copy(&(src->encodingMask), &(dst->encodingMask));
@@ -1672,7 +1543,7 @@ UA_Int32 UA_DataValue_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_
 	}
 	return retval;
 }
-UA_TYPE_START_ENCODEBINARY(UA_DataValue)
+UA_TYPE_ENCODEBINARY(UA_DataValue,
 	retval |= UA_Byte_encodeBinary(&(src->encodingMask),pos,dst);
 	if (src->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT) {
 		retval |= UA_Variant_encodeBinary(&(src->value),pos,dst);
@@ -1691,8 +1562,8 @@ UA_TYPE_START_ENCODEBINARY(UA_DataValue)
 	}
 	if (src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS) {
 		retval |= UA_Int16_encodeBinary(&(src->serverPicoseconds),pos,dst);
-	}
-UA_TYPE_END_XXCODEBINARY
+	})
+
 UA_Int32 UA_DataValue_calcSize(UA_DataValue const * p) {
 	UA_Int32 length = 0;
 
@@ -1752,38 +1623,16 @@ UA_Int32 UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst){
 	UA_DateTime_copy(&(src->sourceTimestamp),&(dst->sourceTimestamp));
 	UA_StatusCode_copy(&(src->status),&(dst->status));
 	UA_Variant_copy(&(src->value),&(dst->value));
-
 	return retval;
 }
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_DataValue)
 
 /* UA_InvalidType - internal type necessary to handle inited Variants correctly */
-UA_Int32 UA_InvalidType_calcSize(UA_InvalidType const * p) {
-	return 0;
-}
-UA_TYPE_START_ENCODEBINARY(UA_InvalidType)
-	retval = UA_ERR_INVALID_VALUE;
-UA_TYPE_END_XXCODEBINARY
-
-UA_TYPE_START_DECODEBINARY(UA_InvalidType)
-	retval = UA_ERR_INVALID_VALUE;
-UA_TYPE_END_XXCODEBINARY
-UA_Int32 UA_InvalidType_free(UA_InvalidType* p) {
-	return UA_ERR_INVALID_VALUE;
-}
-UA_Int32 UA_InvalidType_delete(UA_InvalidType* p) {
-	return UA_ERR_INVALID_VALUE;
-}
-UA_Int32 UA_InvalidType_deleteMembers(UA_InvalidType* p) {
-	return UA_ERR_INVALID_VALUE;
-}
-UA_Int32 UA_InvalidType_init(UA_InvalidType* p) {
-	return UA_ERR_INVALID_VALUE;
-}
-UA_Int32 UA_InvalidType_copy(UA_InvalidType const* src, UA_InvalidType *dst) {
-	return UA_ERR_INVALID_VALUE;
-}
-UA_Int32 UA_InvalidType_new(UA_InvalidType** p) {
-	return UA_ERR_INVALID_VALUE;
-}
-UA_TYPE_METHOD_DECODEXML_NOTIMPL(UA_InvalidType)
+UA_Int32 UA_InvalidType_calcSize(UA_InvalidType const * p) { return 0; }
+UA_TYPE_ENCODEBINARY(UA_InvalidType, retval = UA_ERR_INVALID_VALUE;)
+UA_TYPE_DECODEBINARY(UA_InvalidType, retval = UA_ERR_INVALID_VALUE;)
+UA_Int32 UA_InvalidType_free(UA_InvalidType* p) { return UA_ERR_INVALID_VALUE; }
+UA_Int32 UA_InvalidType_delete(UA_InvalidType* p) { return UA_ERR_INVALID_VALUE; }
+UA_Int32 UA_InvalidType_deleteMembers(UA_InvalidType* p) { return UA_ERR_INVALID_VALUE; }
+UA_Int32 UA_InvalidType_init(UA_InvalidType* p) { return UA_ERR_INVALID_VALUE; }
+UA_Int32 UA_InvalidType_copy(UA_InvalidType const* src, UA_InvalidType *dst) { return UA_ERR_INVALID_VALUE; }
+UA_Int32 UA_InvalidType_new(UA_InvalidType** p) { return UA_ERR_INVALID_VALUE; }