simplify ua_string generation from chars

examples/client.c

@@ -22,7 +22,7 @@ int main(int argc, char *argv[]) {
     UA_ReadRequest_init(&req);
     req.nodesToRead = UA_ReadValueId_new();
     req.nodesToReadSize = 1;
-    req.nodesToRead[0].nodeId = UA_NODEID_STATIC(1, 442); /* assume this node exists */
+    req.nodesToRead[0].nodeId = UA_NODEID_NUMERIC(1, 442); /* assume this node exists */
     req.nodesToRead[0].attributeId = UA_ATTRIBUTEID_VALUE;
 
     UA_ReadResponse resp = UA_Client_read(client, &req);

examples/client_legacy.c

@@ -64,7 +64,7 @@ static int sendOpenSecureChannel(UA_Int32 sock) {
 
 	UA_UInt32 secureChannelId = 0;
 	UA_String securityPolicy;
-	UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None", &securityPolicy);
+	securityPolicy = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None");
 
 	UA_String senderCert;
 	senderCert.data = UA_NULL;
@@ -147,8 +147,8 @@ static UA_Int32 sendCreateSession(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32
 	rq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
 	rq.requestHeader.authenticationToken.namespaceIndex = 10;
 	UA_String_copy(endpointUrl, &rq.endpointUrl);
-	UA_String_copycstring("mysession", &rq.sessionName);
-	UA_String_copycstring("abcd", &rq.clientCertificate);
+	rq.sessionName = UA_STRING("mysession");
+	rq.clientCertificate = UA_STRING("abcd");
 	UA_ByteString_newMembers(&rq.clientNonce, 1);
 	rq.clientNonce.data[0] = 0;
 	rq.requestedSessionTimeout = 1200000;
@@ -501,7 +501,7 @@ int main(int argc, char *argv[]) {
 
     //Connect to remote server
 	UA_String endpoint;
-	UA_String_copycstring("none",&endpoint);
+	endpoint = UA_STRING("none");
 	ConnectionInfo connectionInfo;
 
 

examples/server.c

@@ -181,11 +181,10 @@ int main(int argc, char** argv) {
 		.read = readTimeData,
 		.release = releaseTimeData,
 		.write = NULL};
-	UA_QualifiedName dateName;
-	UA_QUALIFIEDNAME_ASSIGN(dateName, "current time");
+	const UA_QualifiedName dateName = UA_QUALIFIEDNAME_STATIC(0, "current time");
 	UA_Server_addDataSourceVariableNode(server, dateDataSource, dateName, UA_NODEID_NULL,
-                                        UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                                        UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+                                        UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                        UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 
 	if(!(temperatureFile = fopen("/sys/class/thermal/thermal_zone0/temp", "r"))){
 		UA_LOG_WARNING(logger, UA_LOGGERCATEGORY_USERLAND, "[Linux specific] Can not open temperature file, no temperature node will be added");
@@ -196,11 +195,10 @@ int main(int argc, char** argv) {
 			.read = readTemperature,
 			.release = releaseTemperature,
 			.write = NULL};
-		UA_QualifiedName ledName;
-		UA_QUALIFIEDNAME_ASSIGN(ledName, "cpu temperature");
+		UA_QualifiedName ledName = UA_QUALIFIEDNAME(0, "cpu temperature");
 		UA_Server_addDataSourceVariableNode(server, temperatureDataSource, ledName, UA_NODEID_NULL, 
-                                            UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                                            UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+                                            UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                            UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 	}
 
 	if (	!(triggerFile = fopen("/sys/class/leds/led0/trigger", "w"))
@@ -223,21 +221,19 @@ int main(int argc, char** argv) {
 		.read = readLedStatus,
 		.release = releaseLedStatus,
 		.write = writeLedStatus};
-	UA_QualifiedName statusName;
-	UA_QUALIFIEDNAME_ASSIGN(statusName, "status LED");
+	const UA_QualifiedName statusName = UA_QUALIFIEDNAME_STATIC(0, "status LED");
 	UA_Server_addDataSourceVariableNode(server, ledStatusDataSource, statusName, UA_NODEID_NULL,
-                                        UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                                        UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+                                        UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                        UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 
 	// add a static variable node to the adresspace
     UA_Variant *myIntegerVariant = UA_Variant_new();
     UA_Int32 myInteger = 42;
     UA_Variant_setScalarCopy(myIntegerVariant, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
-    UA_QualifiedName myIntegerName;
-    UA_QUALIFIEDNAME_ASSIGN(myIntegerName, "the answer");
-    UA_NodeId myIntegerNodeId = UA_NODEID_STATIC(1, 442);
-    UA_NodeId parentNodeId = UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER);
-    UA_NodeId parentReferenceNodeId = UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES);
+    UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME_STATIC(0, "the answer");
+    UA_NodeId myIntegerNodeId = UA_NODEID_NUMERIC(1, 442);
+    UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
+    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
     UA_Server_addVariableNode(server, myIntegerVariant, myIntegerName,
                               myIntegerNodeId, parentNodeId, parentReferenceNodeId);
 

examples/server_simple.c

@@ -72,11 +72,10 @@ int main(int argc, char** argv) {
     UA_Variant *myIntegerVariant = UA_Variant_new();
     UA_Int32 myInteger = 42;
     UA_Variant_setScalarCopy(myIntegerVariant, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
-    UA_QualifiedName myIntegerName;
-    UA_QUALIFIEDNAME_ASSIGN(myIntegerName, "the answer");
+    UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
     UA_NodeId myIntegerNodeId = UA_NODEID_NULL; /* assign a random free nodeid */
-    UA_NodeId parentNodeId = UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER);
-    UA_NodeId parentReferenceNodeId = UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES);
+    UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
+    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
     UA_Server_addVariableNode(server, myIntegerVariant, myIntegerName,
                               myIntegerNodeId, parentNodeId, parentReferenceNodeId);
     
@@ -90,10 +89,10 @@ int main(int argc, char** argv) {
         UA_Variant_setScalar(variant, data, &UA_TYPES[UA_TYPES_INT32]);
         UA_QualifiedName *nodeName = UA_QualifiedName_new();
         sprintf(str,"%d",i);
-        UA_QualifiedName_copycstring(str, nodeName);
+        *nodeName = UA_QUALIFIEDNAME(1, str);
         UA_Server_addVariableNode(server, variant, *nodeName, UA_NODEID_NULL,
-                                  UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                                  UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+                                  UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                  UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
     }
 #endif
 

include/ua_types.h

@@ -321,8 +321,11 @@ UA_TYPE_HANDLING_FUNCTIONS(UA_DiagnosticInfo)
 
 /* String */
 /** Copy a (zero terminated) char-array into a UA_String. Memory for the string data is
-    allocated. */
-UA_StatusCode UA_EXPORT UA_String_copycstring(char const *src, UA_String *dst);
+    allocated. If the memory cannot be allocated, a null-string is returned. */
+UA_String UA_EXPORT UA_String_fromChars(char const *src);
+#define UA_STRING(CHARS) UA_String_fromChars(CHARS)
+#define UA_STRING_NULL (UA_String) {-1, (UA_Byte*)0 }
+#define UA_STRING_STATIC(CHARS) (const UA_String) {sizeof(CHARS), (UA_Byte*)CHARS }
 
 /** Printf a char-array into a UA_String. Memory for the string data is allocated. */
 UA_StatusCode UA_EXPORT UA_String_copyprintf(char const *fmt, UA_String *dst, ...);
@@ -330,11 +333,6 @@ UA_StatusCode UA_EXPORT UA_String_copyprintf(char const *fmt, UA_String *dst, ..
 /** Compares two strings */
 UA_Boolean UA_EXPORT UA_String_equal(const UA_String *string1, const UA_String *string2);
 
-#define UA_STRING_NULL (UA_String) {-1, (UA_Byte*)0 }
-#define UA_STRING_ASSIGN(VARIABLE, STRING) do { \
-        VARIABLE.length = sizeof(STRING)-1;     \
-        VARIABLE.data   = (UA_Byte *)STRING; } while(0)
-
 /* DateTime */
 /** Returns the current time */
 UA_DateTime UA_EXPORT UA_DateTime_now(void);
@@ -375,35 +373,45 @@ UA_Boolean UA_EXPORT UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2);
 /** Is the nodeid a null-nodeid? */
 UA_Boolean UA_EXPORT UA_NodeId_isNull(const UA_NodeId *p);
 
-#define UA_NODEID_ASSIGN(VARIABLE, NAMESPACE, NUMERICID) do {                 \
-        VARIABLE.namespaceIndex = NAMESPACE;                                  \
-        VARIABLE.identifierType = CPP_ONLY(UA_NodeId::)UA_NODEIDTYPE_NUMERIC; \
-        VARIABLE.identifier.numeric = NUMERICID; } while(0);
+#define UA_NODEID_NUMERIC(NS_INDEX, NUMERICID) (UA_NodeId) {           \
+        .namespaceIndex = NS_INDEX,                                    \
+        .identifierType = UA_NODEIDTYPE_NUMERIC,                        \
+        .identifier.numeric = NUMERICID }
+
+#define UA_NODEID_STRING(NS_INDEX, CHARS) (UA_NodeId) {                \
+        .namespaceIndex = NS_INDEX,                                    \
+        .identifierType = UA_NODEIDTYPE_STRING,                         \
+        .identifier.string = UA_STRING(CHARS) }
+
+#define UA_NODEID_GUID(NS_INDEX, GUID) (UA_NodeId) {                   \
+        .namespaceIndex = NS_INDEX,                                    \
+        .identifierType = UA_NODEIDTYPE_GUID,                           \
+        .identifier.guid = GUID }
 
-#define UA_NODEID_STATIC(NAMESPACE, NUMERICID) (UA_NodeId) {              \
-    .namespaceIndex = NAMESPACE, .identifierType = UA_NODEIDTYPE_NUMERIC, \
-    .identifier.numeric = NUMERICID }
+#define UA_NODEID_BYTESTRING(NS_INDEX, CHARS) (UA_NodeId) {            \
+        .namespaceIndex = NS_INDEX,                                    \
+        .identifierType = UA_NODEIDTYPE_BYTESTRING,                     \
+        .identifier.byteString = UA_STRING(CHARS) }
 
-#define UA_NODEID_NULL UA_NODEID_STATIC(0,0)
+#define UA_NODEID_NULL UA_NODEID_NUMERIC(0,0)
 
 /* ExpandedNodeId */
 UA_Boolean UA_EXPORT UA_ExpandedNodeId_isNull(const UA_ExpandedNodeId *p);
 
-#define UA_EXPANDEDNODEID_STATIC(NAMESPACE, NUMERICID) (UA_ExpandedNodeId) {             \
-        .nodeId = {.namespaceIndex = NAMESPACE, .identifierType = UA_NODEIDTYPE_NUMERIC, \
+#define UA_EXPANDEDNODEID_NUMERIC(NS_INDEX, NUMERICID) (UA_ExpandedNodeId) {                \
+        .nodeId = {.namespaceIndex = NS_INDEX, .identifierType = UA_NODEIDTYPE_NUMERIC, \
                    .identifier.numeric = NUMERICID },                                    \
         .serverIndex = 0, .namespaceUri = {.data = (UA_Byte*)0, .length = -1} }
     
 /* QualifiedName */
-UA_StatusCode UA_EXPORT UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst);
-#define UA_QUALIFIEDNAME_ASSIGN(VARIABLE, STRING) do {          \
-        VARIABLE.namespaceIndex = 0;                            \
-        UA_STRING_ASSIGN(VARIABLE.name, STRING); } while(0)
+#define UA_QUALIFIEDNAME(NS_INDEX, NAME) (UA_QualifiedName) {   \
+        .namespaceIndex = NS_INDEX, .name = UA_STRING(NAME) }
+#define UA_QUALIFIEDNAME_STATIC(NS_INDEX, NAME) (const UA_QualifiedName) {    \
+        .namespaceIndex = NS_INDEX, .name = UA_STRING_STATIC(NAME) }
 
 /* LocalizedText */
-/** Copy a (zero-terminated) char-array into the UA_LocalizedText. Memory for the string is
-    allocated. The locale is set to "en" by default. */
-UA_StatusCode UA_EXPORT UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst);
+#define UA_LOCALIZEDTEXT(LOCALE, TEXT) (UA_LocalizedText) {             \
+        .locale = UA_String_fromChars(LOCALE), .text = UA_STRING(TEXT) }
 
 /* Variant */
 

src/client/ua_client.c

@@ -126,10 +126,10 @@ static UA_StatusCode SecureChannelHandshake(UA_Client *client) {
 
 	UA_AsymmetricAlgorithmSecurityHeader asymHeader;
 	UA_AsymmetricAlgorithmSecurityHeader_init(&asymHeader);
-	UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None", &asymHeader.securityPolicyUri);
+	asymHeader.securityPolicyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None");
 
     /* id of opensecurechannelrequest */
-	UA_NodeId requestType = UA_NODEID_STATIC(0, UA_NS0ID_OPENSECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
+	UA_NodeId requestType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
 
 	UA_OpenSecureChannelRequest opnSecRq;
 	UA_OpenSecureChannelRequest_init(&opnSecRq);
@@ -184,7 +184,7 @@ static UA_StatusCode SecureChannelHandshake(UA_Client *client) {
 	UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
 	UA_NodeId_decodeBinary(&reply, &offset, &requestType);
 
-	if(!UA_NodeId_equal(&requestType, &UA_NODEID_STATIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
+	if(!UA_NodeId_equal(&requestType, &UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
                                                         UA_ENCODINGOFFSET_BINARY))) {
         UA_ByteString_deleteMembers(&reply);
         UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
@@ -230,7 +230,7 @@ static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *req
     seqHeader.sequenceNumber = ++client->sequenceNumber;
     seqHeader.requestId = ++client->requestId;
 
-	UA_NodeId requestId = UA_NODEID_STATIC(0, requestType->typeId.identifier.numeric +
+	UA_NodeId requestId = UA_NODEID_NUMERIC(0, requestType->typeId.identifier.numeric +
                                            UA_ENCODINGOFFSET_BINARY);
 
 	msgHeader.messageHeader.messageSize =
@@ -285,7 +285,7 @@ static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *req
     UA_NodeId responseId;
 	retval |= UA_NodeId_decodeBinary(&reply, &offset, &responseId);
 
-	if(!UA_NodeId_equal(&responseId, &UA_NODEID_STATIC(0, responseType->typeId.identifier.numeric +
+	if(!UA_NodeId_equal(&responseId, &UA_NODEID_NUMERIC(0, responseType->typeId.identifier.numeric +
                                                        UA_ENCODINGOFFSET_BINARY))) {
         UA_ByteString_deleteMembers(&reply);
         UA_SymmetricAlgorithmSecurityHeader_deleteMembers(&symHeader);
@@ -394,13 +394,13 @@ static UA_StatusCode CloseSecureChannel(UA_Client *client) {
 UA_StatusCode UA_Client_connect(UA_Client *client, UA_ConnectionConfig conf,
                                 UA_ClientNetworkLayer networkLayer, char *endpointUrl)
 {
-    UA_StatusCode retval = UA_String_copycstring(endpointUrl, &client->endpointUrl);
-    if(retval != UA_STATUSCODE_GOOD)
+    client->endpointUrl = UA_STRING(endpointUrl);
+    if(client->endpointUrl.length < 0)
         return UA_STATUSCODE_BADOUTOFMEMORY;
 
     client->networkLayer = networkLayer;
     client->connection.localConf = conf;
-    retval = networkLayer.connect(client->endpointUrl, client->networkLayer.nlHandle);
+    UA_StatusCode retval = networkLayer.connect(client->endpointUrl, client->networkLayer.nlHandle);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
 

src/server/ua_securechannel_manager.c

@@ -75,8 +75,8 @@ UA_StatusCode UA_SecureChannelManager_open(UA_SecureChannelManager           *cm
         cm->maxChannelLifetime : request->requestedLifetime;
 
     UA_ByteString_copy(&request->clientNonce, &entry->channel.clientNonce);
-    UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None",
-                          (UA_String *)&entry->channel.serverAsymAlgSettings.securityPolicyUri);
+    entry->channel.serverAsymAlgSettings.securityPolicyUri =
+        UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None");
     LIST_INSERT_HEAD(&cm->channels, entry, pointers);
 
     response->serverProtocolVersion = 0;

src/server/ua_server.c

@@ -94,13 +94,13 @@ static UA_StatusCode readStatus(const void *handle, UA_Boolean sourceTimeStamp,
     status->startTime   = ((const UA_Server*)handle)->startTime;
     status->currentTime = UA_DateTime_now();
     status->state       = UA_SERVERSTATE_RUNNING;
-    UA_String_copycstring("http://www.open62541.org", &status->buildInfo.productUri);
-    UA_String_copycstring("open62541", &status->buildInfo.manufacturerName);
-    UA_String_copycstring("open62541 OPC UA Server", &status->buildInfo.productName);
+    status->buildInfo.productUri = UA_STRING("http://www.open62541.org");
+    status->buildInfo.manufacturerName = UA_STRING("open62541");
+    status->buildInfo.productName = UA_STRING("open62541 OPC UA Server");
 #define STRINGIFY(x) #x //some magic
 #define TOSTRING(x) STRINGIFY(x) //some magic
-    UA_String_copycstring(TOSTRING(OPEN62541_VERSION_MAJOR) "." TOSTRING(OPEN62541_VERSION_MINOR) "." TOSTRING(OPEN62541_VERSION_PATCH), &status->buildInfo.softwareVersion);
-    UA_String_copycstring("0", &status->buildInfo.buildNumber);
+    status->buildInfo.softwareVersion = UA_STRING(TOSTRING(OPEN62541_VERSION_MAJOR) "." TOSTRING(OPEN62541_VERSION_MINOR) "." TOSTRING(OPEN62541_VERSION_PATCH));
+    status->buildInfo.buildNumber = UA_STRING("0");
     status->buildInfo.buildDate = ((const UA_Server*)handle)->buildDate;
     status->secondsTillShutdown = 0;
     value->value.type = &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE];
@@ -143,9 +143,9 @@ static void releaseCurrentTime(const void *handle, UA_DataValue *value) {
 }
 
 static void copyNames(UA_Node *node, char *name) {
-    UA_QualifiedName_copycstring(name, &node->browseName);
-    UA_LocalizedText_copycstring(name, &node->displayName);
-    UA_LocalizedText_copycstring(name, &node->description);
+    node->browseName = UA_QUALIFIEDNAME(0, name);
+    node->displayName = UA_LOCALIZEDTEXT("", name);
+    node->description = UA_LOCALIZEDTEXT("", name);
 }
 
 static void addDataTypeNode(UA_Server *server, char* name, UA_UInt32 datatypeid, UA_Int32 parent) {
@@ -153,8 +153,8 @@ static void addDataTypeNode(UA_Server *server, char* name, UA_UInt32 datatypeid,
     copyNames((UA_Node*)datatype, name);
     datatype->nodeId.identifier.numeric = datatypeid;
     UA_Server_addNode(server, (UA_Node*)datatype,
-                      &UA_EXPANDEDNODEID_STATIC(0, parent),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, parent),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 }
 
 static UA_VariableTypeNode* createVariableTypeNode(UA_Server *server, char* name, UA_UInt32 variabletypeid, UA_Int32 parent, UA_Boolean abstract) {
@@ -171,16 +171,16 @@ static void addVariableTypeNode_organized(UA_Server *server, char* name, UA_UInt
 	UA_VariableTypeNode *variabletype = createVariableTypeNode(server, name, variabletypeid, parent, abstract);
 
     UA_Server_addNode(server, (UA_Node*)variabletype,
-                      &UA_EXPANDEDNODEID_STATIC(0, parent),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, parent),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 }
 
 static void addVariableTypeNode_subtype(UA_Server *server, char* name, UA_UInt32 variabletypeid, UA_Int32 parent, UA_Boolean abstract) {
 	UA_VariableTypeNode *variabletype = createVariableTypeNode(server, name, variabletypeid, parent, abstract);
 
     UA_Server_addNode(server, (UA_Node*)variabletype,
-                      &UA_EXPANDEDNODEID_STATIC(0, parent),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, parent),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 }
 
 UA_Server * UA_Server_new(void) {
@@ -211,11 +211,11 @@ UA_Server * UA_Server_new(void) {
 #define APPLICATION_URI "urn:unconfigured:open62541:open62541Server"
     // mockup application description
     UA_ApplicationDescription_init(&server->description);
-    UA_String_copycstring(PRODUCT_URI, &server->description.productUri);
-    UA_String_copycstring(APPLICATION_URI, &server->description.applicationUri);
+    server->description.productUri = UA_STRING(PRODUCT_URI);
+    server->description.applicationUri = UA_STRING(APPLICATION_URI);
     server->description.discoveryUrlsSize = 0;
 
-    UA_LocalizedText_copycstring("Unconfigured open62541 application", &server->description.applicationName);
+    server->description.applicationName = UA_LOCALIZEDTEXT("", "Unconfigured open62541 application");
     server->description.applicationType = UA_APPLICATIONTYPE_SERVER;
     server->externalNamespacesSize = 0;
     server->externalNamespaces = UA_NULL;
@@ -223,15 +223,15 @@ UA_Server * UA_Server_new(void) {
     UA_EndpointDescription *endpoint = UA_EndpointDescription_new(); // todo: check return code
     if(endpoint) {
         endpoint->securityMode = UA_MESSAGESECURITYMODE_NONE;
-        UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None", &endpoint->securityPolicyUri);
-        UA_String_copycstring("http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary", &endpoint->transportProfileUri);
+        endpoint->securityPolicyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None");
+        endpoint->transportProfileUri = UA_STRING("http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary");
         endpoint->userIdentityTokens = UA_malloc(sizeof(UA_UserTokenPolicy));
         if(!endpoint->userIdentityTokens) {
             UA_EndpointDescription_delete(endpoint);
         } else {
             UA_UserTokenPolicy_init(endpoint->userIdentityTokens);
             endpoint->userIdentityTokens->tokenType = UA_USERTOKENTYPE_ANONYMOUS;
-            UA_String_copycstring("my-anonymous-policy", &endpoint->userIdentityTokens->policyId); // defined per server
+            endpoint->userIdentityTokens->policyId = UA_STRING("my-anonymous-policy"); // defined per server
 
             /* UA_String_copy(endpointUrl, &endpoint->endpointUrl); */
             /* /\* The standard says "the HostName specified in the Server Certificate is the */
@@ -275,7 +275,7 @@ UA_Server * UA_Server_new(void) {
 
     UA_ReferenceTypeNode *hassubtype = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hassubtype, "HasSubtype");
-    UA_LocalizedText_copycstring("HasSupertype", &hassubtype->inverseName);
+    hassubtype->inverseName = UA_LOCALIZEDTEXT("", "HasSupertype");
     hassubtype->nodeId.identifier.numeric = UA_NS0ID_HASSUBTYPE;
     hassubtype->isAbstract = UA_FALSE;
     hassubtype->symmetric  = UA_FALSE;
@@ -288,8 +288,8 @@ UA_Server * UA_Server_new(void) {
     hierarchicalreferences->isAbstract = UA_TRUE;
     hierarchicalreferences->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hierarchicalreferences,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_REFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_REFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *nonhierarchicalreferences = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)nonhierarchicalreferences, "NonHierarchicalReferences");
@@ -297,8 +297,8 @@ UA_Server * UA_Server_new(void) {
     nonhierarchicalreferences->isAbstract = UA_TRUE;
     nonhierarchicalreferences->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)nonhierarchicalreferences,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_REFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_REFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *haschild = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)haschild, "HasChild");
@@ -306,78 +306,78 @@ UA_Server * UA_Server_new(void) {
     haschild->isAbstract = UA_TRUE;
     haschild->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)haschild,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *organizes = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)organizes, "Organizes");
-    UA_LocalizedText_copycstring("OrganizedBy", &organizes->inverseName);
+    organizes->inverseName = UA_LOCALIZEDTEXT("", "OrganizedBy");
     organizes->nodeId.identifier.numeric = UA_NS0ID_ORGANIZES;
     organizes->isAbstract = UA_FALSE;
     organizes->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)organizes,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *haseventsource = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)haseventsource, "HasEventSource");
-    UA_LocalizedText_copycstring("EventSourceOf", &haseventsource->inverseName);
+    haseventsource->inverseName = UA_LOCALIZEDTEXT("", "EventSourceOf");
     haseventsource->nodeId.identifier.numeric = UA_NS0ID_HASEVENTSOURCE;
     haseventsource->isAbstract = UA_FALSE;
     haseventsource->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)haseventsource,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasmodellingrule = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasmodellingrule, "HasModellingRule");
-    UA_LocalizedText_copycstring("ModellingRuleOf", &hasmodellingrule->inverseName);
+    hasmodellingrule->inverseName = UA_LOCALIZEDTEXT("", "ModellingRuleOf");
     hasmodellingrule->nodeId.identifier.numeric = UA_NS0ID_HASMODELLINGRULE;
     hasmodellingrule->isAbstract = UA_FALSE;
     hasmodellingrule->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasmodellingrule,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasencoding = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasencoding, "HasEncoding");
-    UA_LocalizedText_copycstring("EncodingOf", &hasencoding->inverseName);
+    hasencoding->inverseName = UA_LOCALIZEDTEXT("", "EncodingOf");
     hasencoding->nodeId.identifier.numeric = UA_NS0ID_HASENCODING;
     hasencoding->isAbstract = UA_FALSE;
     hasencoding->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasencoding,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasdescription = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasdescription, "HasDescription");
-    UA_LocalizedText_copycstring("DescriptionOf", &hasdescription->inverseName);
+    hasdescription->inverseName = UA_LOCALIZEDTEXT("", "DescriptionOf");
     hasdescription->nodeId.identifier.numeric = UA_NS0ID_HASDESCRIPTION;
     hasdescription->isAbstract = UA_FALSE;
     hasdescription->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasdescription,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hastypedefinition = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hastypedefinition, "HasTypeDefinition");
-    UA_LocalizedText_copycstring("TypeDefinitionOf", &hastypedefinition->inverseName);
+    hastypedefinition->inverseName = UA_LOCALIZEDTEXT("", "TypeDefinitionOf");
     hastypedefinition->nodeId.identifier.numeric = UA_NS0ID_HASTYPEDEFINITION;
     hastypedefinition->isAbstract = UA_FALSE;
     hastypedefinition->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hastypedefinition,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *generatesevent = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)generatesevent, "GeneratesEvent");
-    UA_LocalizedText_copycstring("GeneratedBy", &generatesevent->inverseName);
+    generatesevent->inverseName = UA_LOCALIZEDTEXT("", "GeneratedBy");
     generatesevent->nodeId.identifier.numeric = UA_NS0ID_GENERATESEVENT;
     generatesevent->isAbstract = UA_FALSE;
     generatesevent->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)generatesevent,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *aggregates = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)aggregates, "Aggregates");
@@ -386,112 +386,112 @@ UA_Server * UA_Server_new(void) {
     aggregates->isAbstract = UA_TRUE;
     aggregates->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)aggregates,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HASCHILD),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HASCHILD),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     // complete bootstrap of hassubtype
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_HASCHILD), UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE),
-                 UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_HASCHILD), UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
+                 UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasproperty = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasproperty, "HasProperty");
-    UA_LocalizedText_copycstring("PropertyOf", &hasproperty->inverseName);
+    hasproperty->inverseName = UA_LOCALIZEDTEXT("", "PropertyOf");
     hasproperty->nodeId.identifier.numeric = UA_NS0ID_HASPROPERTY;
     hasproperty->isAbstract = UA_FALSE;
     hasproperty->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasproperty,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_AGGREGATES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_AGGREGATES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hascomponent = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hascomponent, "HasComponent");
-    UA_LocalizedText_copycstring("ComponentOf", &hascomponent->inverseName);
+    hascomponent->inverseName = UA_LOCALIZEDTEXT("", "ComponentOf");
     hascomponent->nodeId.identifier.numeric = UA_NS0ID_HASCOMPONENT;
     hascomponent->isAbstract = UA_FALSE;
     hascomponent->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hascomponent,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_AGGREGATES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_AGGREGATES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasnotifier = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasnotifier, "HasNotifier");
-    UA_LocalizedText_copycstring("NotifierOf", &hasnotifier->inverseName);
+    hasnotifier->inverseName = UA_LOCALIZEDTEXT("", "NotifierOf");
     hasnotifier->nodeId.identifier.numeric = UA_NS0ID_HASNOTIFIER;
     hasnotifier->isAbstract = UA_FALSE;
     hasnotifier->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasnotifier,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HASEVENTSOURCE),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HASEVENTSOURCE),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasorderedcomponent = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasorderedcomponent, "HasOrderedComponent");
-    UA_LocalizedText_copycstring("OrderedComponentOf", &hasorderedcomponent->inverseName);
+    hasorderedcomponent->inverseName = UA_LOCALIZEDTEXT("", "OrderedComponentOf");
     hasorderedcomponent->nodeId.identifier.numeric = UA_NS0ID_HASORDEREDCOMPONENT;
     hasorderedcomponent->isAbstract = UA_FALSE;
     hasorderedcomponent->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasorderedcomponent,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_HASCOMPONENT),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hasmodelparent = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hasmodelparent, "HasModelParent");
-    UA_LocalizedText_copycstring("ModelParentOf", &hasmodelparent->inverseName);
+    hasmodelparent->inverseName = UA_LOCALIZEDTEXT("", "ModelParentOf");
     hasmodelparent->nodeId.identifier.numeric = UA_NS0ID_HASMODELPARENT;
     hasmodelparent->isAbstract = UA_FALSE;
     hasmodelparent->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hasmodelparent,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *fromstate = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)fromstate, "FromState");
-    UA_LocalizedText_copycstring("ToTransition", &fromstate->inverseName);
+    fromstate->inverseName = UA_LOCALIZEDTEXT("", "ToTransition");
     fromstate->nodeId.identifier.numeric = UA_NS0ID_FROMSTATE;
     fromstate->isAbstract = UA_FALSE;
     fromstate->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)fromstate,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *tostate = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)tostate, "ToState");
-    UA_LocalizedText_copycstring("FromTransition", &tostate->inverseName);
+    tostate->inverseName = UA_LOCALIZEDTEXT("", "FromTransition");
     tostate->nodeId.identifier.numeric = UA_NS0ID_TOSTATE;
     tostate->isAbstract = UA_FALSE;
     tostate->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)tostate,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hascause = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hascause, "HasCause");
-    UA_LocalizedText_copycstring("MayBeCausedBy", &hascause->inverseName);
+    hascause->inverseName = UA_LOCALIZEDTEXT("", "MayBeCausedBy");
     hascause->nodeId.identifier.numeric = UA_NS0ID_HASCAUSE;
     hascause->isAbstract = UA_FALSE;
     hascause->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hascause,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
     
     UA_ReferenceTypeNode *haseffect = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)haseffect, "HasEffect");
-    UA_LocalizedText_copycstring("MayBeEffectedBy", &haseffect->inverseName);
+    haseffect->inverseName = UA_LOCALIZEDTEXT("", "MayBeEffectedBy");
     haseffect->nodeId.identifier.numeric = UA_NS0ID_HASEFFECT;
     haseffect->isAbstract = UA_FALSE;
     haseffect->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)haseffect,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_NONHIERARCHICALREFERENCES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     UA_ReferenceTypeNode *hashistoricalconfiguration = UA_ReferenceTypeNode_new();
     copyNames((UA_Node*)hashistoricalconfiguration, "HasHistoricalConfiguration");
-    UA_LocalizedText_copycstring("HistoricalConfigurationOf", &hashistoricalconfiguration->inverseName);
+    hashistoricalconfiguration->inverseName = UA_LOCALIZEDTEXT("", "HistoricalConfigurationOf");
     hashistoricalconfiguration->nodeId.identifier.numeric = UA_NS0ID_HASHISTORICALCONFIGURATION;
     hashistoricalconfiguration->isAbstract = UA_FALSE;
     hashistoricalconfiguration->symmetric  = UA_FALSE;
     UA_Server_addNode(server, (UA_Node*)hashistoricalconfiguration,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_AGGREGATES),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_AGGREGATES),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE));
 
     /**********************/
     /* Basic Object Types */
@@ -511,8 +511,8 @@ UA_Server * UA_Server_new(void) {
     folderType->nodeId.identifier.numeric = UA_NS0ID_FOLDERTYPE;
     copyNames((UA_Node*)folderType, "FolderType");
     UA_NodeStore_insert(server->nodestore, (UA_Node*)folderType, UA_NULL);
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_BASEOBJECTTYPE), UA_NODEID_STATIC(0, UA_NS0ID_HASSUBTYPE),
- 		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE), UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
+ 		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
     /*****************/
     /* Basic Folders */
@@ -522,35 +522,35 @@ UA_Server * UA_Server_new(void) {
     copyNames((UA_Node*)root, "Root");
     root->nodeId.identifier.numeric = UA_NS0ID_ROOTFOLDER;
     UA_NodeStore_insert(server->nodestore, (UA_Node*)root, UA_NULL);
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_ROOTFOLDER), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
- 		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_ROOTFOLDER), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+ 		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
     UA_ObjectNode *objects = UA_ObjectNode_new();
     copyNames((UA_Node*)objects, "Objects");
     objects->nodeId.identifier.numeric = UA_NS0ID_OBJECTSFOLDER;
     UA_Server_addNode(server, (UA_Node*)objects,
- 		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_ROOTFOLDER),
- 		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
- 		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+ 		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_ROOTFOLDER),
+ 		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+ 		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
     UA_ObjectNode *types = UA_ObjectNode_new();
     copyNames((UA_Node*)types, "Types");
     types->nodeId.identifier.numeric = UA_NS0ID_TYPESFOLDER;
     UA_Server_addNode(server, (UA_Node*)types,
- 		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_ROOTFOLDER),
- 		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_TYPESFOLDER), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
- 		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+ 		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_ROOTFOLDER),
+ 		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_TYPESFOLDER), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+ 		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
     UA_ObjectNode *views = UA_ObjectNode_new();
     copyNames((UA_Node*)views, "Views");
     views->nodeId.identifier.numeric = UA_NS0ID_VIEWSFOLDER;
     UA_Server_addNode(server, (UA_Node*)views,
- 		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_ROOTFOLDER),
- 		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_VIEWSFOLDER), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                 UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+ 		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_ROOTFOLDER),
+ 		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_VIEWSFOLDER), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                 UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
     /**********************/
     /* Further Data Types */
@@ -560,10 +560,10 @@ UA_Server * UA_Server_new(void) {
     copyNames((UA_Node*)datatypes, "DataTypes");
     datatypes->nodeId.identifier.numeric = UA_NS0ID_DATATYPESFOLDER;
     UA_Server_addNode(server, (UA_Node*)datatypes,
-                      &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_TYPESFOLDER),
-                      &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_DATATYPESFOLDER), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                 UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+                      &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_TYPESFOLDER),
+                      &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+    ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_DATATYPESFOLDER), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                 UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
     addDataTypeNode(server, "BaseDataType", UA_NS0ID_BASEDATATYPE, UA_NS0ID_DATATYPESFOLDER);
     addDataTypeNode(server, "Boolean", UA_NS0ID_BOOLEAN, UA_NS0ID_BASEDATATYPE);
@@ -600,10 +600,10 @@ UA_Server * UA_Server_new(void) {
    copyNames((UA_Node*)variabletypes, "VariableTypes");
    variabletypes->nodeId.identifier.numeric = UA_NS0ID_VARIABLETYPESFOLDER;
    UA_Server_addNode(server, (UA_Node*)variabletypes,
-                     &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_TYPESFOLDER),
-                     &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-   ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_VARIABLETYPESFOLDER), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+                     &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_TYPESFOLDER),
+                     &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+   ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_VARIABLETYPESFOLDER), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
    addVariableTypeNode_organized(server, "BaseVariableType", UA_NS0ID_BASEVARIABLETYPE, UA_NS0ID_VARIABLETYPESFOLDER, UA_TRUE);
    addVariableTypeNode_subtype(server, "PropertyType", UA_NS0ID_PROPERTYTYPE, UA_NS0ID_BASEVARIABLETYPE, UA_FALSE);
 
@@ -615,8 +615,8 @@ UA_Server * UA_Server_new(void) {
    copyNames((UA_Node*)servernode, "Server");
    servernode->nodeId.identifier.numeric = UA_NS0ID_SERVER;
    UA_Server_addNode(server, (UA_Node*)servernode,
-		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 
    UA_VariableNode *namespaceArray = UA_VariableNode_new();
    copyNames((UA_Node*)namespaceArray, "NamespaceArray");
@@ -626,19 +626,17 @@ UA_Server * UA_Server_new(void) {
    namespaceArray->variable.variant.arrayLength = 2;
    namespaceArray->variable.variant.type = &UA_TYPES[UA_TYPES_STRING];
    // Fixme: Insert the external namespaces
-   UA_String_copycstring("http://opcfoundation.org/UA/",
-		   &((UA_String *)(namespaceArray->variable.variant.data))[0]);
-   UA_String_copycstring(APPLICATION_URI,
-		   &((UA_String *)(namespaceArray->variable.variant.data))[1]);
+   ((UA_String *)namespaceArray->variable.variant.data)[0] = UA_STRING("http://opcfoundation.org/UA/");
+   ((UA_String *)namespaceArray->variable.variant.data)[1] = UA_STRING(APPLICATION_URI);
    namespaceArray->valueRank = 1;
    namespaceArray->minimumSamplingInterval = 1.0;
    namespaceArray->historizing = UA_FALSE;
    UA_Server_addNode(server, (UA_Node*)namespaceArray,
-		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_HASPROPERTY));
-   ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_SERVER_NAMESPACEARRAY),
-                UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_PROPERTYTYPE));
+		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY));
+   ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_NAMESPACEARRAY),
+                UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE));
 
    UA_VariableNode *serverArray = UA_VariableNode_new();
    copyNames((UA_Node*)serverArray, "ServerArray");
@@ -647,24 +645,23 @@ UA_Server * UA_Server_new(void) {
    serverArray->variable.variant.data = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 1);
    serverArray->variable.variant.arrayLength = 1;
    serverArray->variable.variant.type = &UA_TYPES[UA_TYPES_STRING];
-   UA_String_copycstring(APPLICATION_URI,
- 		   &((UA_String *)(serverArray->variable.variant.data))[0]);
+   *(UA_String *)serverArray->variable.variant.data = UA_STRING(APPLICATION_URI);
    serverArray->valueRank = 1;
    serverArray->minimumSamplingInterval = 1.0;
    serverArray->historizing = UA_FALSE;
    UA_Server_addNode(server, (UA_Node*)serverArray,
- 		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER),
- 		   &UA_NODEID_STATIC(0, UA_NS0ID_HASPROPERTY));
-   ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_SERVER_SERVERARRAY),
-                UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_PROPERTYTYPE));
+ 		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER),
+ 		   &UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY));
+   ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERARRAY),
+                UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE));
 
    UA_ObjectNode *servercapablities = UA_ObjectNode_new();
    copyNames((UA_Node*)servercapablities, "ServerCapabilities");
    servercapablities->nodeId.identifier.numeric = UA_NS0ID_SERVER_SERVERCAPABILITIES;
    UA_Server_addNode(server, (UA_Node*)servercapablities,
-		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_HASCOMPONENT));
+		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT));
 
    UA_VariableNode *localeIdArray = UA_VariableNode_new();
    copyNames((UA_Node*)localeIdArray, "LocaleIdArray");
@@ -673,27 +670,24 @@ UA_Server * UA_Server_new(void) {
    localeIdArray->variable.variant.data = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 2);
    localeIdArray->variable.variant.arrayLength = 2;
    localeIdArray->variable.variant.type = &UA_TYPES[UA_TYPES_STRING];
-   UA_String_copycstring("en",
-		   &((UA_String *)(localeIdArray->variable.variant.data))[0]);
-   UA_String_copycstring("de",
-		   &((UA_String *)(localeIdArray->variable.variant.data))[1]);
+   *(UA_String *)localeIdArray->variable.variant.data = UA_STRING("en");
    localeIdArray->valueRank = 1;
    localeIdArray->minimumSamplingInterval = 1.0;
    localeIdArray->historizing = UA_FALSE;
    UA_Server_addNode(server, (UA_Node*)localeIdArray,
-		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_HASPROPERTY));
-   ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_LOCALEIDARRAY), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_PROPERTYTYPE));
+		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY));
+   ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_LOCALEIDARRAY), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE));
 
    UA_VariableNode *serverstatus = UA_VariableNode_new();
    copyNames((UA_Node*)serverstatus, "ServerStatus");
-   serverstatus->nodeId = UA_NODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS);
+   serverstatus->nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS);
    serverstatus->variableType = UA_VARIABLENODETYPE_DATASOURCE;
    serverstatus->variable.dataSource = (UA_DataSource) {.handle = server, .read = readStatus,
 	   .release = releaseStatus, .write = UA_NULL};
-   UA_Server_addNode(server, (UA_Node*)serverstatus, &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_HASCOMPONENT));
+   UA_Server_addNode(server, (UA_Node*)serverstatus, &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT));
 
    UA_VariableNode *state = UA_VariableNode_new();
    UA_ServerState *stateEnum = UA_ServerState_new();
@@ -705,17 +699,17 @@ UA_Server * UA_Server_new(void) {
    state->variable.variant.arrayLength = -1;
    state->variable.variant.data = stateEnum; // points into the other object.
    UA_NodeStore_insert(server->nodestore, (UA_Node*)state, UA_NULL);
-   ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS), UA_NODEID_STATIC(0, UA_NS0ID_HASCOMPONENT),
-		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE));
+   ADDREFERENCE(UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS), UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE));
 
    UA_VariableNode *currenttime = UA_VariableNode_new();
    copyNames((UA_Node*)currenttime, "CurrentTime");
-   currenttime->nodeId = UA_NODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME);
+   currenttime->nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME);
    currenttime->variableType = UA_VARIABLENODETYPE_DATASOURCE;
    currenttime->variable.dataSource = (UA_DataSource) {.handle = NULL, .read = readCurrentTime,
 	   .release = releaseCurrentTime, .write = UA_NULL};
-   UA_Server_addNode(server, (UA_Node*)currenttime, &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_HASCOMPONENT));
+   UA_Server_addNode(server, (UA_Node*)currenttime, &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT));
 
 #ifdef DEMO_NODESET
    /**************/
@@ -725,32 +719,32 @@ UA_Server * UA_Server_new(void) {
 #define DEMOID 990
    UA_ObjectNode *demo = UA_ObjectNode_new();
    copyNames((UA_Node*)demo, "Demo");
-   demo->nodeId = UA_NODEID_STATIC(1, DEMOID);
+   demo->nodeId = UA_NODEID_NUMERIC(1, DEMOID);
    UA_Server_addNode(server, (UA_Node*)demo,
-		   &UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-   ADDREFERENCE(UA_NODEID_STATIC(1, DEMOID), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+		   &UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+   ADDREFERENCE(UA_NODEID_NUMERIC(1, DEMOID), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
 #define SCALARID 991
    UA_ObjectNode *scalar = UA_ObjectNode_new();
    copyNames((UA_Node*)scalar, "Scalar");
-   scalar->nodeId = UA_NODEID_STATIC(1, SCALARID);
+   scalar->nodeId = UA_NODEID_NUMERIC(1, SCALARID);
    UA_Server_addNode(server, (UA_Node*)scalar,
-		   &UA_EXPANDEDNODEID_STATIC(1, DEMOID),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-   ADDREFERENCE(UA_NODEID_STATIC(1, SCALARID), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+		   &UA_EXPANDEDNODEID_NUMERIC(1, DEMOID),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+   ADDREFERENCE(UA_NODEID_NUMERIC(1, SCALARID), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
 #define ARRAYID 992
    UA_ObjectNode *array = UA_ObjectNode_new();
    copyNames((UA_Node*)array, "Arrays");
-   array->nodeId = UA_NODEID_STATIC(1, ARRAYID);
+   array->nodeId = UA_NODEID_NUMERIC(1, ARRAYID);
    UA_Server_addNode(server, (UA_Node*)array,
-		   &UA_EXPANDEDNODEID_STATIC(1, DEMOID),
-		   &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
-   ADDREFERENCE(UA_NODEID_STATIC(1, ARRAYID), UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_FOLDERTYPE));
+		   &UA_EXPANDEDNODEID_NUMERIC(1, DEMOID),
+		   &UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
+   ADDREFERENCE(UA_NODEID_NUMERIC(1, ARRAYID), UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+		   UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE));
 
    UA_UInt32 id = 1000; //running id in namespace 1
    for(UA_UInt32 type = 0; UA_IS_BUILTIN(type); type++) {
@@ -764,14 +758,14 @@ UA_Server * UA_Server_new(void) {
 	    char name[15];
 	    sprintf(name, "%02d", type);
 	    UA_QUALIFIEDNAME_ASSIGN(myIntegerName, name);
-	    UA_Server_addVariableNode(server, variant, myIntegerName, UA_NODEID_STATIC(1, ++id),
-	                              UA_NODEID_STATIC(1, SCALARID), UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+	    UA_Server_addVariableNode(server, variant, myIntegerName, UA_NODEID_NUMERIC(1, ++id),
+	                              UA_NODEID_NUMERIC(1, SCALARID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
 
         //add an array node for every built-in type
         UA_Variant *arrayvar = UA_Variant_new();
         UA_Variant_setArray(arrayvar, UA_Array_new(&UA_TYPES[type], 10), 10, &UA_TYPES[type]);
-        UA_Server_addVariableNode(server, arrayvar, myIntegerName, UA_NODEID_STATIC(1, ++id),
-                                  UA_NODEID_STATIC(1, ARRAYID), UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+        UA_Server_addVariableNode(server, arrayvar, myIntegerName, UA_NODEID_NUMERIC(1, ++id),
+                                  UA_NODEID_NUMERIC(1, ARRAYID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
    }
 #endif
 

src/server/ua_server_addressspace.c

@@ -15,8 +15,8 @@ UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, const UA_Qualifi
     UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
     UA_AddNodesResult res =
         UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, &parentId, &referenceTypeId);
-    ADDREFERENCE(res.addedNodeId, UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                 UA_EXPANDEDNODEID_STATIC(0, value->type->typeId.identifier.numeric));
+    ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                 UA_EXPANDEDNODEID_NUMERIC(0, value->type->typeId.identifier.numeric));
     if(res.statusCode != UA_STATUSCODE_GOOD) {
         UA_Variant_init(&node->variable.variant);
         UA_VariableNode_delete(node);
@@ -41,8 +41,8 @@ UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
     UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
     UA_AddNodesResult res =
         UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, &parentId, &referenceTypeId);
-    ADDREFERENCE(res.addedNodeId, UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
-                 UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_BASEDATAVARIABLETYPE));
+    ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
+                 UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE));
     if(res.statusCode != UA_STATUSCODE_GOOD)
         UA_VariableNode_delete(node);
     return res.statusCode;

src/server/ua_server_binary.c

@@ -100,8 +100,8 @@ static void processOPN(UA_Connection *connection, UA_Server *server, const UA_By
     respHeader.messageHeader.messageSize = 0;
     respHeader.secureChannelId = p.securityToken.channelId;
 
-    UA_NodeId responseType = UA_NODEID_STATIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE);
-    responseType.identifier.numeric += UA_ENCODINGOFFSET_BINARY;
+    UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
+                                               UA_ENCODINGOFFSET_BINARY);
 
     respHeader.messageHeader.messageSize =
         UA_SecureConversationMessageHeader_calcSizeBinary(&respHeader)

src/ua_types.c

@@ -105,21 +105,22 @@ UA_StatusCode UA_String_copy(UA_String const *src, UA_String *dst) {
     return UA_STATUSCODE_GOOD;
 }
 
-/* The c-string needs to be null-terminated. the string cannot be smaller than zero. */
-UA_StatusCode UA_String_copycstring(char const *src, UA_String *dst) {
-    UA_String_init(dst);
-    size_t length = (UA_UInt32) strlen(src);
+UA_String UA_String_fromChars(char const *src) {
+    UA_String str;
+    size_t length = strlen(src);
     if(length == 0) {
-        dst->length = 0;
-        dst->data = UA_NULL;
-        return UA_STATUSCODE_GOOD;
+        str.length = 0;
+        str.data = UA_NULL;
+        return str;
     }
-    dst->data = UA_malloc(length);
-    if(!dst->data)
-        return UA_STATUSCODE_BADOUTOFMEMORY;
-    UA_memcpy(dst->data, src, length);
-    dst->length = length;
-    return UA_STATUSCODE_GOOD;
+    str.data = UA_malloc(length);
+    if(!str.data) {
+        str.length = -1;
+        return str;
+    }
+    UA_memcpy(str.data, src, length);
+    str.length = length;
+    return str;
 }
 
 #define UA_STRING_COPYPRINTF_BUFSIZE 1024
@@ -428,6 +429,7 @@ UA_Boolean UA_ExpandedNodeId_isNull(const UA_ExpandedNodeId *p) {
 
 /* QualifiedName */
 UA_TYPE_DELETE_DEFAULT(UA_QualifiedName)
+UA_TYPE_NEW_DEFAULT(UA_QualifiedName)
 void UA_QualifiedName_deleteMembers(UA_QualifiedName *p) {
     UA_String_deleteMembers(&p->name);
 }
@@ -437,7 +439,6 @@ void UA_QualifiedName_init(UA_QualifiedName *p) {
     p->namespaceIndex = 0;
 }
 
-UA_TYPE_NEW_DEFAULT(UA_QualifiedName)
 UA_StatusCode UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst) {
     UA_StatusCode retval = UA_String_copy(&src->name, &dst->name);
     dst->namespaceIndex = src->namespaceIndex;
@@ -446,16 +447,11 @@ UA_StatusCode UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedNam
         UA_QualifiedName_init(dst);
     }
     return retval;
-
-}
-
-UA_StatusCode UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst) {
-    dst->namespaceIndex = 0;
-    return UA_String_copycstring(src, &dst->name);
 }
 
 /* LocalizedText */
 UA_TYPE_DELETE_DEFAULT(UA_LocalizedText)
+UA_TYPE_NEW_DEFAULT(UA_LocalizedText)
 void UA_LocalizedText_deleteMembers(UA_LocalizedText *p) {
     UA_String_deleteMembers(&p->locale);
     UA_String_deleteMembers(&p->text);
@@ -466,17 +462,6 @@ void UA_LocalizedText_init(UA_LocalizedText *p) {
     UA_String_init(&p->text);
 }
 
-UA_TYPE_NEW_DEFAULT(UA_LocalizedText)
-UA_StatusCode UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst) {
-    UA_StatusCode retval = UA_String_copycstring("", &dst->locale);
-    retval |= UA_String_copycstring(src, &dst->text);
-    if(retval) {
-        UA_LocalizedText_deleteMembers(dst);
-        UA_LocalizedText_init(dst);
-    }
-    return retval;
-}
-
 UA_StatusCode UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst) {
     UA_StatusCode retval = UA_String_copy(&src->locale, &dst->locale);
     retval |= UA_String_copy(&src->text, &dst->text);
@@ -489,6 +474,7 @@ UA_StatusCode UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedTex
 
 /* ExtensionObject */
 UA_TYPE_DELETE_DEFAULT(UA_ExtensionObject)
+UA_TYPE_NEW_DEFAULT(UA_ExtensionObject)
 void UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) {
     UA_NodeId_deleteMembers(&p->typeId);
     UA_ByteString_deleteMembers(&p->body);
@@ -500,7 +486,6 @@ void UA_ExtensionObject_init(UA_ExtensionObject *p) {
     UA_ByteString_init(&p->body);
 }
 
-UA_TYPE_NEW_DEFAULT(UA_ExtensionObject)
 UA_StatusCode UA_ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst) {
     UA_StatusCode retval = UA_ByteString_copy(&src->body, &dst->body);
     retval |= UA_NodeId_copy(&src->typeId, &dst->typeId);

tests/check_builtin.c

@@ -1287,9 +1287,9 @@ START_TEST(UA_Array_copyUA_StringShallWorkOnExample) {
 	UA_String *srcArray = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 3);
 	UA_String *dstArray;
 
-	UA_String_copycstring("open", &srcArray[0]);
-	UA_String_copycstring("62541", &srcArray[1]);
-	UA_String_copycstring("opc ua", &srcArray[2]);
+	srcArray[0] = UA_STRING("open");
+	srcArray[1] = UA_STRING("62541");
+	srcArray[2] = UA_STRING("opc ua");
 	//when
 	UA_Array_copy((const void *)srcArray, (void **)&dstArray, &UA_TYPES[UA_TYPES_STRING], 3);
 	//then
@@ -1435,12 +1435,9 @@ END_TEST
 START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	// given
 	const char src[8] = {'t', 'e', 'X', 't', '1', '2', '3', (char)0};
-	UA_LocalizedText dst;
+	UA_LocalizedText dst = UA_LOCALIZEDTEXT("", src);
 
-	// when
-	UA_StatusCode ret = UA_LocalizedText_copycstring(src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq('1', dst.text.data[4]);
 	ck_assert_int_eq(0, dst.locale.length);
 	ck_assert_int_eq(7, dst.text.length);
@@ -1506,9 +1503,9 @@ END_TEST
 START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	// given
 	UA_String *srcArray = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 3);
-	UA_String_copycstring("__open", &srcArray[0]);
-	UA_String_copycstring("_62541", &srcArray[1]);
-	UA_String_copycstring("opc ua", &srcArray[2]);
+	srcArray[0] = UA_STRING("__open");
+	srcArray[1] = UA_STRING("_62541");
+	srcArray[2] = UA_STRING("opc ua");
 
 	UA_Int32 *dimensions;
 	dimensions = UA_malloc(sizeof(UA_Int32));