Introduced constants for XML names

4 files changed, 439 insertions, 439 deletions

diff --git a/src/uscxml/transform/ChartToC.cpp b/src/uscxml/transform/ChartToC.cpp
index 4cdb3ef..dbd4e8c 100644
--- a/src/uscxml/transform/ChartToC.cpp
+++ b/src/uscxml/transform/ChartToC.cpp
@@ -84,7 +84,7 @@ void ChartToC::setHistoryCompletion() {
 			parent = history->getParentNode();
 		}
 
-		bool deep = (HAS_ATTR(history, "type") && iequals(ATTR(history, "type"), "deep"));
+		bool deep = (HAS_ATTR(history, kXMLCharType) && iequals(ATTR(history, kXMLCharType), "deep"));
 		for (auto stateIter = _states.begin(); stateIter != _states.end(); stateIter++) {
 			DOMElement* state = *stateIter;
 			if (state == history)
@@ -140,7 +140,7 @@ void ChartToC::resortStates(DOMNode* node) {
 		resortStates(child);
 		if (child->getNodeType() == DOMNode::ELEMENT_NODE &&
 		        TAGNAME_CAST(child) == XML_PREFIX(node).str() + "history" &&
-		        (!HAS_ATTR(element, "type") || iequals(ATTR(element, "type"), "shallow"))) {
+		        (!HAS_ATTR(element, kXMLCharType) || iequals(ATTR(element, kXMLCharType), "shallow"))) {
 			DOMNode* tmp = child->getNextSibling();
 			if (child != element->getFirstChild()) {
 				element->insertBefore(child, element->getFirstChild());
@@ -157,8 +157,8 @@ void ChartToC::resortStates(DOMNode* node) {
 		resortStates(child);
 		if (child->getNodeType() == DOMNode::ELEMENT_NODE &&
 		        TAGNAME_CAST(child) == XML_PREFIX(node).str() + "history" &&
-		        HAS_ATTR(element, "type") &&
-		        iequals(ATTR(element, "type"), "deep")) {
+		        HAS_ATTR(element, kXMLCharType) &&
+		        iequals(ATTR(element, kXMLCharType), "deep")) {
 
 			DOMNode* tmp = child->getNextSibling();
 			if (child != element->getFirstChild()) {
@@ -203,8 +203,8 @@ void ChartToC::setStateCompletion() {
 		if (isParallel(state)) {
 			completion = getChildStates(state);
 
-		} else if (HAS_ATTR(state, "initial")) {
-			completion = getStates(tokenize(ATTR(state, "initial")), _scxml);
+		} else if (HAS_ATTR(state, kXMLCharInitial)) {
+			completion = getStates(tokenize(ATTR(state, kXMLCharInitial)), _scxml);
 
 		} else {
 			std::list<DOMElement*> initElems = DOMUtils::filterChildElements(XML_PREFIX(state).str() + "initial", state);
@@ -259,8 +259,8 @@ void ChartToC::prepare() {
 		DOMElement* state(_states[i]);
 		state->setAttribute(X("documentOrder"), X(toStr(i)));
 		if (state->getParentNode()->getNodeType() == DOMNode::ELEMENT_NODE &&
-		        HAS_ATTR_CAST(state->getParentNode(), "documentOrder")) {
-			state->setAttribute(X("parent"), X(ATTR_CAST(state->getParentNode(), "documentOrder")));
+		        HAS_ATTR_CAST(state->getParentNode(), X("documentOrder"))) {
+			state->setAttribute(X("parent"), X(ATTR_CAST(state->getParentNode(), X("documentOrder"))));
 		}
 
 		// set the states' children and whether it has a history
@@ -302,8 +302,8 @@ void ChartToC::prepare() {
 		DOMElement* transition = *transIter;
 		transition->setAttribute(X("documentOrder"), X(toStr(index)));
 		if (transition->getParentNode()->getNodeType() == DOMNode::ELEMENT_NODE &&
-		        HAS_ATTR_CAST(transition->getParentNode(), "documentOrder")) {
-			transition->setAttribute(X("source"), X(ATTR_CAST(transition->getParentNode(), "documentOrder")));
+		        HAS_ATTR_CAST(transition->getParentNode(), X("documentOrder"))) {
+			transition->setAttribute(X("source"), X(ATTR_CAST(transition->getParentNode(), X("documentOrder"))));
 		}
 	}
 
@@ -355,15 +355,15 @@ void ChartToC::prepare() {
 		transition->setAttribute(X("conflictBools"), X(conflictBools));
 
 		// and target
-		if (HAS_ATTR(transition, "target")) {
-			std::list<std::string> targets = tokenize(ATTR(transition, "target"));
+		if (HAS_ATTR(transition, kXMLCharTarget)) {
+			std::list<std::string> targets = tokenize(ATTR(transition, kXMLCharTarget));
 
 			std::string targetBools;
 			for (size_t j = 0; j < _states.size(); j++) {
 				DOMElement* state(_states[j]);
 
-				if (HAS_ATTR(state, "id") &&
-				        std::find(targets.begin(), targets.end(), escape(ATTR(state, "id"))) != targets.end()) {
+				if (HAS_ATTR(state, kXMLCharId) &&
+				        std::find(targets.begin(), targets.end(), escape(ATTR(state, kXMLCharId))) != targets.end()) {
 					targetBools += "1";
 				} else {
 					targetBools += "0";
@@ -469,15 +469,15 @@ void ChartToC::findNestedMachines() {
 		if(!areFromSameMachine(invoke, _scxml))
 			continue;
 
-		if (HAS_ATTR(invoke, "type") &&
-		        ATTR(invoke, "type") != "scxml" &&
-		        ATTR(invoke, "type") != "http://www.w3.org/TR/scxml/")
+		if (HAS_ATTR(invoke, kXMLCharType) &&
+		        ATTR(invoke, kXMLCharType) != "scxml" &&
+		        ATTR(invoke, kXMLCharType) != "http://www.w3.org/TR/scxml/")
 			continue;
 
 		ChartToC* c2c = NULL;
-		if (HAS_ATTR(invoke, "src")) {
+		if (HAS_ATTR(invoke, kXMLCharSource)) {
 
-			URL srcURL(ATTR(invoke, "src"));
+			URL srcURL(ATTR(invoke, kXMLCharSource));
 			if (!srcURL.isAbsolute()) {
 				srcURL = URL::resolve(srcURL, _baseURL);
 			}
@@ -1156,7 +1156,7 @@ void ChartToC::writeExecContent(std::ostream& stream) {
 				size_t j = 0;
 				for (auto iter = invokes.begin(); iter != invokes.end(); iter++, j++) {
 					DOMElement* invoke = *iter;
-					stream << "    ctx->invoke(ctx, s, &" << _prefix << "_elem_invokes[" << ATTR(invoke, "documentOrder") << "], uninvoke);" << std::endl;
+					stream << "    ctx->invoke(ctx, s, &" << _prefix << "_elem_invokes[" << ATTR(invoke, X("documentOrder")) << "], uninvoke);" << std::endl;
 					stream << std::endl;
 				}
 				stream << "    return USCXML_ERR_OK;" << std::endl;
@@ -1169,13 +1169,13 @@ void ChartToC::writeExecContent(std::ostream& stream) {
 		DOMElement* transition(_transitions[i]);
 		std::list<DOMNode*> execContent = DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition);
 
-		if (HAS_ATTR(transition, "cond")) {
+		if (HAS_ATTR(transition, kXMLCharCond)) {
 			stream << "static int " << _prefix << "_" << DOMUtils::idForNode(transition) << "_is_enabled(const uscxml_ctx* ctx, const uscxml_transition* transition) {" << std::endl;
-			if (HAS_ATTR(_scxml, "datamodel") && ATTR(_scxml, "datamodel") == "native") {
-				stream << "    return (" << ATTR(transition, "cond") << ");" << std::endl;
+			if (HAS_ATTR(_scxml, kXMLCharDataModel) && ATTR(_scxml, kXMLCharDataModel) == "native") {
+				stream << "    return (" << ATTR(transition, kXMLCharCond) << ");" << std::endl;
 			} else {
 				stream << "    if likely(ctx->is_true != NULL) {" << std::endl;
-				stream << "        return (ctx->is_true(ctx, \"" << escape(ATTR(transition, "cond")) << "\"));" << std::endl;
+				stream << "        return (ctx->is_true(ctx, \"" << escape(ATTR(transition, kXMLCharCond)) << "\"));" << std::endl;
 				stream << "    }" << std::endl;
 				stream << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
 			}
@@ -1205,7 +1205,7 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 
 	if (node->getNodeType() == DOMNode::TEXT_NODE) {
 		if (boost::trim_copy(X(node->getNodeValue()).str()).length() > 0) {
-			if (HAS_ATTR(_scxml, "datamodel") && ATTR(_scxml, "datamodel") == "native") {
+			if (HAS_ATTR(_scxml, kXMLCharDataModel) && ATTR(_scxml, kXMLCharDataModel) == "native") {
 				stream << node->getNodeValue();
 			} else {
 				std::string escaped = escape(X(node->getNodeValue()).str());
@@ -1242,7 +1242,7 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << "if likely(ctx->exec_content_script != NULL) {" << std::endl;
 		stream << padding;
 		stream << "    if unlikely((err = ctx->exec_content_script(ctx, ";
-		stream << (HAS_ATTR(elem, "src") ? "\"" + escape(ATTR(elem, "src")) + "\"" : "NULL") << ", ";
+		stream << (HAS_ATTR(elem, kXMLCharSource) ? "\"" + escape(ATTR(elem, kXMLCharSource)) + "\"" : "NULL") << ", ";
 
 		std::list<DOMNode*> scriptTexts = DOMUtils::filterChildType(DOMNode::TEXT_NODE, elem);
 		if (scriptTexts.size() > 0) {
@@ -1263,8 +1263,8 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << "if likely(ctx->exec_content_log != NULL) {" << std::endl;
 		stream << padding;
 		stream << "    if unlikely((ctx->exec_content_log(ctx, ";
-		stream << (HAS_ATTR(elem, "label") ? "\"" + escape(ATTR(elem, "label")) + "\"" : "NULL") << ", ";
-		stream << (HAS_ATTR(elem, "expr") ? "\"" + escape(ATTR(elem, "expr")) + "\"" : "NULL");
+		stream << (HAS_ATTR(elem, kXMLCharLabel) ? "\"" + escape(ATTR(elem, kXMLCharLabel)) + "\"" : "NULL") << ", ";
+		stream << (HAS_ATTR(elem, kXMLCharExpr) ? "\"" + escape(ATTR(elem, kXMLCharExpr)) + "\"" : "NULL");
 		stream << ")) != USCXML_ERR_OK) return err;" << std::endl;
 		stream << padding << "} else {" << std::endl;
 		stream << padding << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
@@ -1276,15 +1276,15 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << padding << "          ctx->exec_content_foreach_done != NULL) {" << std::endl;
 		stream << std::endl;
 
-		stream << padding << "    if unlikely((ctx->exec_content_foreach_init(ctx, &" << _prefix << "_elem_foreachs[" << ATTR(elem, "documentOrder") << "])) != USCXML_ERR_OK) return err;" << std::endl;
-		stream << padding << "    while (ctx->exec_content_foreach_next(ctx, &" << _prefix << "_elem_foreachs[" << ATTR(elem, "documentOrder") << "]) == USCXML_ERR_OK) {" << std::endl;
+		stream << padding << "    if unlikely((ctx->exec_content_foreach_init(ctx, &" << _prefix << "_elem_foreachs[" << ATTR(elem, X("documentOrder")) << "])) != USCXML_ERR_OK) return err;" << std::endl;
+		stream << padding << "    while (ctx->exec_content_foreach_next(ctx, &" << _prefix << "_elem_foreachs[" << ATTR(elem, X("documentOrder")) << "]) == USCXML_ERR_OK) {" << std::endl;
 		DOMNode* child = node->getFirstChild();
 		while(child) {
 			writeExecContent(stream, child, indent + 2);
 			child = child->getNextSibling();
 		}
 		stream << padding << "    }" << std::endl;
-		stream << padding << "    if ((ctx->exec_content_foreach_done(ctx, &" << _prefix << "_elem_foreachs[" << ATTR(elem, "documentOrder") << "])) != USCXML_ERR_OK) return err;" << std::endl;
+		stream << padding << "    if ((ctx->exec_content_foreach_done(ctx, &" << _prefix << "_elem_foreachs[" << ATTR(elem, X("documentOrder")) << "])) != USCXML_ERR_OK) return err;" << std::endl;
 		stream << padding << "} else {" << std::endl;
 		stream << padding << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
 		stream << padding << "}" << std::endl;
@@ -1293,12 +1293,12 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << padding;
 		stream << "if likely(ctx->is_true != NULL) {" << std::endl;
 		stream << padding;
-		stream << "    if (ctx->is_true(ctx, " << (HAS_ATTR(elem, "cond") ? "\"" + escape(ATTR(elem, "cond")) + "\"" : "NULL") << ")) {" << std::endl;
+		stream << "    if (ctx->is_true(ctx, " << (HAS_ATTR(elem, kXMLCharCond) ? "\"" + escape(ATTR(elem, kXMLCharCond)) + "\"" : "NULL") << ")) {" << std::endl;
 		DOMNode* child = elem->getFirstChild();
 		while(child) {
 			if (child->getNodeType() == DOMNode::ELEMENT_NODE && TAGNAME_CAST(child) == "elseif") {
 				stream << padding;
-				stream << "    } else if (ctx->is_true(ctx, " << (HAS_ATTR_CAST(child, "cond") ? "\"" + escape(ATTR_CAST(child, "cond")) + "\"" : "NULL") << ")) {" << std::endl;
+				stream << "    } else if (ctx->is_true(ctx, " << (HAS_ATTR_CAST(child, kXMLCharCond) ? "\"" + escape(ATTR_CAST(child, kXMLCharCond)) + "\"" : "NULL") << ")) {" << std::endl;
 			} else if (child->getNodeType() == DOMNode::ELEMENT_NODE && TAGNAME_CAST(child) == "else") {
 				stream << padding;
 				stream << "    } else {" << std::endl;
@@ -1316,7 +1316,7 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << padding;
 		stream << "if likely(ctx->exec_content_assign != NULL) {" << std::endl;
 		stream << padding;
-		stream << "    if ((ctx->exec_content_assign(ctx, &" << _prefix << "_elem_assigns[" << ATTR(elem, "documentOrder") << "]";
+		stream << "    if ((ctx->exec_content_assign(ctx, &" << _prefix << "_elem_assigns[" << ATTR(elem, X("documentOrder")) << "]";
 		stream << ")) != USCXML_ERR_OK) return err;" << std::endl;
 		stream << padding << "} else {" << std::endl;
 		stream << padding << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
@@ -1328,7 +1328,7 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << "if likely(ctx->exec_content_raise != NULL) {" << std::endl;
 		stream << padding;
 		stream << "    if unlikely((ctx->exec_content_raise(ctx, ";
-		stream << (HAS_ATTR(elem, "event") ? "\"" + escape(ATTR(elem, "event")) + "\"" : "NULL");
+		stream << (HAS_ATTR(elem, kXMLCharEvent) ? "\"" + escape(ATTR(elem, kXMLCharEvent)) + "\"" : "NULL");
 		stream << ")) != USCXML_ERR_OK) return err;" << std::endl;
 		stream << padding << "} else {" << std::endl;
 		stream << padding << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
@@ -1338,7 +1338,7 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << padding;
 		stream << "if likely(ctx->exec_content_send != NULL) {" << std::endl;
 		stream << padding;
-		stream << "    if ((ctx->exec_content_send(ctx, &" << _prefix << "_elem_sends[" << ATTR(elem, "documentOrder") << "]";
+		stream << "    if ((ctx->exec_content_send(ctx, &" << _prefix << "_elem_sends[" << ATTR(elem, X("documentOrder")) << "]";
 		stream << ")) != USCXML_ERR_OK) return err;" << std::endl;
 		stream << padding << "} else {" << std::endl;
 		stream << padding << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
@@ -1349,8 +1349,8 @@ void ChartToC::writeExecContent(std::ostream& stream, const DOMNode* node, size_
 		stream << "if likely(ctx->exec_content_cancel != NULL) {" << std::endl;
 		stream << padding;
 		stream << "    if ((ctx->exec_content_cancel(ctx, ";
-		stream << (HAS_ATTR(elem, "sendid") ? "\"" + escape(ATTR(elem, "sendid")) + "\"" : "NULL") << ", ";
-		stream << (HAS_ATTR(elem, "sendidexpr") ? "\"" + escape(ATTR(elem, "sendidexpr")) + "\"" : "NULL");
+		stream << (HAS_ATTR(elem, kXMLCharSendId) ? "\"" + escape(ATTR(elem, kXMLCharSendId)) + "\"" : "NULL") << ", ";
+		stream << (HAS_ATTR(elem, kXMLCharSendIdExpr) ? "\"" + escape(ATTR(elem, kXMLCharSendIdExpr)) + "\"" : "NULL");
 		stream << ")) != USCXML_ERR_OK) return err;" << std::endl;
 		stream << padding << "} else {" << std::endl;
 		stream << padding << "    return USCXML_ERR_MISSING_CALLBACK;" << std::endl;
@@ -1398,11 +1398,11 @@ void ChartToC::writeElementInfoInvocation(std::ostream& stream) {
 			stream << "    { " << std::endl;
 
 			stream << "        /* machine     */ ";
-			if (HAS_ATTR(invoke, "md5sum")) {
+			if (HAS_ATTR(invoke, X("md5sum"))) {
 #if 1
 				size_t machIdx = 0;
 				for (std::list<ChartToC*>::iterator machIter = _allMachines.begin(); machIter != _allMachines.end(); machIter++, machIdx++) {
-					if ((*machIter)->_md5 == ATTR(invoke, "md5sum")) {
+					if ((*machIter)->_md5 == ATTR(invoke, X("md5sum"))) {
 						stream << "&" << (*machIter)->_prefix << "_machine";
 						break;
 					}
@@ -1422,44 +1422,44 @@ void ChartToC::writeElementInfoInvocation(std::ostream& stream) {
 			stream << ", " << std::endl;
 
 			stream << "        /* type        */ ";
-			stream << (HAS_ATTR(invoke, "type") ? "\"" +  escape(ATTR(invoke, "type")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharType) ? "\"" +  escape(ATTR(invoke, kXMLCharType)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* typeexpr    */ ";
-			stream << (HAS_ATTR(invoke, "typeexpr") ? "\"" +  escape(ATTR(invoke, "typeexpr")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharTypeExpr) ? "\"" +  escape(ATTR(invoke, kXMLCharTypeExpr)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* src         */ ";
-			stream << (HAS_ATTR(invoke, "src") ? "\"" + escape(ATTR(invoke, "src")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharSource) ? "\"" + escape(ATTR(invoke, kXMLCharSource)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* srcexpr     */ ";
-			stream << (HAS_ATTR(invoke, "srcexpr") ? "\"" +  escape(ATTR(invoke, "srcexpr")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharSourceExpr) ? "\"" +  escape(ATTR(invoke, kXMLCharSourceExpr)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* id          */ ";
-			stream << (HAS_ATTR(invoke, "id") ? "\"" +  escape(ATTR(invoke, "id")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharId) ? "\"" +  escape(ATTR(invoke, kXMLCharId)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* idlocation  */ ";
-			stream << (HAS_ATTR(invoke, "idlocation") ? "\"" +  escape(ATTR(invoke, "idlocation")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharIdLocation) ? "\"" +  escape(ATTR(invoke, kXMLCharIdLocation)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* sourcename  */ ";
-			stream << (HAS_ATTR_CAST(invoke->getParentNode(), "id") ? "\"" +  escape(ATTR_CAST(invoke->getParentNode(), "id")) + "\"" : "NULL");
+			stream << (HAS_ATTR_CAST(invoke->getParentNode(), kXMLCharId) ? "\"" +  escape(ATTR_CAST(invoke->getParentNode(), kXMLCharId)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* namelist    */ ";
-			stream << (HAS_ATTR(invoke, "namelist") ? "\"" +  escape(ATTR(invoke, "namelist")) + "\"" : "NULL");
+			stream << (HAS_ATTR(invoke, kXMLCharNameList) ? "\"" +  escape(ATTR(invoke, kXMLCharNameList)) + "\"" : "NULL");
 			stream << ", " << std::endl;
 
 			stream << "        /* autoforward */ ";
-			stream << (HAS_ATTR(invoke, "autoforward") && stringIsTrue(ATTR(invoke, "autoforward")) ? "1" : "0");
+			stream << (HAS_ATTR(invoke, kXMLCharAutoForward) && stringIsTrue(ATTR(invoke, kXMLCharAutoForward)) ? "1" : "0");
 			stream << ", " << std::endl;
 
 			stream << "        /* params      */ ";
-			if (HAS_ATTR(invoke, "paramIndex")) {
-				stream << "&" << _prefix << "_elem_params[" << escape(ATTR(invoke, "paramIndex")) << "]";
+			if (HAS_ATTR(invoke, X("paramIndex"))) {
+				stream << "&" << _prefix << "_elem_params[" << escape(ATTR(invoke, X("paramIndex"))) << "]";
 			} else {
 				stream << "NULL";
 			}
@@ -1475,7 +1475,7 @@ void ChartToC::writeElementInfoInvocation(std::ostream& stream) {
 			stream << ", " << std::endl;
 
 			std::list<DOMElement*> contents = DOMUtils::filterChildElements(XML_PREFIX(invoke).str() + "content", invoke);
-			if (contents.size() > 0 && !HAS_ATTR(invoke, "md5sum")) {
+			if (contents.size() > 0 && !HAS_ATTR(invoke, X("md5sum"))) {
 				std::stringstream ss;
 				DOMNodeList* cChilds = contents.front()->getChildNodes();
 				for (size_t j = 0; j < cChilds->getLength(); j++) {
@@ -1484,7 +1484,7 @@ void ChartToC::writeElementInfoInvocation(std::ostream& stream) {
 				stream << "        /* content      */ ";
 				stream << (ss.str().size() > 0 ? "\"" + escape(ss.str()) + "\", " : "NULL, ") << std::endl;
 				stream << "        /* contentexpr  */ ";
-				stream << (HAS_ATTR_CAST(contents.front(), "expr") ? "\"" + ATTR_CAST(contents.front(), "expr") + "\", " : "NULL, ") << std::endl;
+				stream << (HAS_ATTR_CAST(contents.front(), kXMLCharExpr) ? "\"" + ATTR_CAST(contents.front(), kXMLCharExpr) + "\", " : "NULL, ") << std::endl;
 			} else {
 				stream << "        /* content     */ NULL," << std::endl;
 				stream << "        /* contentexpr */ NULL," << std::endl;
@@ -1516,9 +1516,9 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 		for (auto iter = foreachs.begin(); iter != foreachs.end(); iter++, i++) {
 			DOMElement* foreach = *iter;
 			stream << "    { ";
-			stream << (HAS_ATTR(foreach, "array") ? "\"" + escape(ATTR(foreach, "array")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(foreach, "item") ? "\"" + escape(ATTR(foreach, "item")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(foreach, "index") ? "\"" + escape(ATTR(foreach, "index")) + "\"" : "NULL");
+			stream << (HAS_ATTR(foreach, kXMLCharArray) ? "\"" + escape(ATTR(foreach, kXMLCharArray)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(foreach, kXMLCharItem) ? "\"" + escape(ATTR(foreach, kXMLCharItem)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(foreach, kXMLCharIndex) ? "\"" + escape(ATTR(foreach, kXMLCharIndex)) + "\"" : "NULL");
 			stream << " }" << (i + 1 < foreachs.size() ? ",": "") << std::endl;
 			foreach->setAttribute(X("documentOrder"), X(toStr(i)));
 		}
@@ -1537,8 +1537,8 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 			DOMElement* assign = *iter;
 
 			stream << "    { ";
-			stream << (HAS_ATTR(assign, "location") ? "\"" + escape(ATTR(assign, "location")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(assign, "expr") ? "\"" + escape(ATTR(assign, "expr")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(assign, kXMLCharLocation) ? "\"" + escape(ATTR(assign, kXMLCharLocation)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(assign, kXMLCharExpr) ? "\"" + escape(ATTR(assign, kXMLCharExpr)) + "\"" : "NULL") << ", ";
 
 			std::list<DOMNode*> assignTexts = DOMUtils::filterChildType(DOMNode::TEXT_NODE, assign);
 			if (assignTexts.size() > 0) {
@@ -1596,9 +1596,9 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 				parent = data->getParentNode()->getParentNode();
 			}
 			stream << "    { ";
-			stream << (HAS_ATTR(data, "id") ? "\"" + escape(ATTR(data, "id")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(data, "src") ? "\"" + escape(ATTR(data, "src")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(data, "expr") ? "\"" + escape(ATTR(data, "expr")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(data, kXMLCharId) ? "\"" + escape(ATTR(data, kXMLCharId)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(data, kXMLCharSource) ? "\"" + escape(ATTR(data, kXMLCharSource)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(data, kXMLCharExpr) ? "\"" + escape(ATTR(data, kXMLCharExpr)) + "\"" : "NULL") << ", ";
 
 			std::list<DOMNode*> dataTexts = DOMUtils::filterChildType(DOMNode::TEXT_NODE, data);
 			if (dataTexts.size() > 0) {
@@ -1643,9 +1643,9 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 				parent = param->getParentNode();
 			}
 			stream << "    { ";
-			stream << (HAS_ATTR(param, "name") ? "\"" + escape(ATTR(param, "name")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(param, "expr") ? "\"" + escape(ATTR(param, "expr")) + "\"" : "NULL") << ", ";
-			stream << (HAS_ATTR(param, "location") ? "\"" + escape(ATTR(param, "location")) + "\"" : "NULL");
+			stream << (HAS_ATTR(param, kXMLCharName) ? "\"" + escape(ATTR(param, kXMLCharName)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(param, kXMLCharExpr) ? "\"" + escape(ATTR(param, kXMLCharExpr)) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(param, kXMLCharLocation) ? "\"" + escape(ATTR(param, kXMLCharLocation)) + "\"" : "NULL");
 			stream << " }," << std::endl;
 
 		}
@@ -1663,27 +1663,27 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 			DOMElement* send = *iter;
 			stream << "    { ";
 			stream << std::endl << "        /* event       */ ";
-			stream << (HAS_ATTR(send, "event") ? "\"" + escape(ATTR(send, "event")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharEvent) ? "\"" + escape(ATTR(send, kXMLCharEvent)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* eventexpr   */ ";
-			stream << (HAS_ATTR(send, "eventexpr") ? "\"" + escape(ATTR(send, "eventexpr")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharEventExpr) ? "\"" + escape(ATTR(send, kXMLCharEventExpr)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* target      */ ";
-			stream << (HAS_ATTR(send, "target") ? "\"" + escape(ATTR(send, "target")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharTarget) ? "\"" + escape(ATTR(send, kXMLCharTarget)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* targetexpr  */ ";
-			stream << (HAS_ATTR(send, "targetexpr") ? "\"" + escape(ATTR(send, "targetexpr")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharTargetExpr) ? "\"" + escape(ATTR(send, kXMLCharTargetExpr)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* type        */ ";
-			stream << (HAS_ATTR(send, "type") ? "\"" + escape(ATTR(send, "type")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharType) ? "\"" + escape(ATTR(send, kXMLCharType)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* typeexpr    */ ";
-			stream << (HAS_ATTR(send, "typeexpr") ? "\"" + escape(ATTR(send, "typeexpr")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharTypeExpr) ? "\"" + escape(ATTR(send, kXMLCharTypeExpr)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* id          */ ";
-			stream << (HAS_ATTR(send, "id") ? "\"" + escape(ATTR(send, "id")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharId) ? "\"" + escape(ATTR(send, kXMLCharId)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* idlocation  */ ";
-			stream << (HAS_ATTR(send, "idlocation") ? "\"" + escape(ATTR(send, "idlocation")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharIdLocation) ? "\"" + escape(ATTR(send, kXMLCharIdLocation)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* delay       */ ";
-			stream << (HAS_ATTR(send, "delay") ? "\"" + escape(ATTR(send, "delay")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharDelay) ? "\"" + escape(ATTR(send, kXMLCharDelay)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* delayexpr   */ ";
-			stream << (HAS_ATTR(send, "delayexpr") ? "\"" + escape(ATTR(send, "delayexpr")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharDelayExpr) ? "\"" + escape(ATTR(send, kXMLCharDelayExpr)) + "\"" : "NULL") << ", ";
 			stream << std::endl << "        /* namelist    */ ";
-			stream << (HAS_ATTR(send, "namelist") ? "\"" + escape(ATTR(send, "namelist")) + "\"" : "NULL") << ", ";
+			stream << (HAS_ATTR(send, kXMLCharNameList) ? "\"" + escape(ATTR(send, kXMLCharNameList)) + "\"" : "NULL") << ", ";
 
 			std::list<DOMElement*> contents = DOMUtils::filterChildElements(XML_PREFIX(send).str() + "content", send);
 			if (contents.size() > 0) {
@@ -1695,7 +1695,7 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 				stream << std::endl << "        /* content     */ ";
 				stream << (ss.str().size() > 0 ? "\"" + escape(ss.str()) + "\", " : "NULL, ");
 				stream << std::endl << "        /* contentexpr  */ ";
-				stream << (HAS_ATTR_CAST(contents.front(), "expr") ? "\"" + ATTR_CAST(contents.front(), "expr") + "\", " : "NULL, ");
+				stream << (HAS_ATTR_CAST(contents.front(), kXMLCharExpr) ? "\"" + ATTR_CAST(contents.front(), kXMLCharExpr) + "\", " : "NULL, ");
 			} else {
 				stream << std::endl << "        /* content     */ ";
 				stream << "NULL,";
@@ -1705,8 +1705,8 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 
 
 			stream << std::endl << "        /* params      */ ";
-			if (HAS_ATTR(send, "paramIndex")) {
-				stream << "&" << _prefix << "_elem_params[" << escape(ATTR(send, "paramIndex")) << "] ";
+			if (HAS_ATTR(send, X("paramIndex"))) {
+				stream << "&" << _prefix << "_elem_params[" << escape(ATTR(send, X("paramIndex"))) << "] ";
 			} else {
 				stream << "NULL ";
 			}
@@ -1729,7 +1729,7 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 		stream << "    { ";
 
 		// parent
-		stream << ATTR_CAST(donedata->getParentNode(), "documentOrder") << ", ";
+		stream << ATTR_CAST(donedata->getParentNode(), X("documentOrder")) << ", ";
 
 		std::list<DOMElement*> contents = DOMUtils::filterChildElements(XML_PREFIX(donedata).str() + "content", donedata);
 		if (contents.size() > 0) {
@@ -1739,13 +1739,13 @@ void ChartToC::writeElementInfo(std::ostream& stream) {
 				ss << *(cChilds->item(j));
 			}
 			stream << (ss.str().size() > 0 ? "\"" + escape(ss.str()) + "\", " : "NULL, ");
-			stream << (HAS_ATTR_CAST(contents.front(), "expr") ? "\"" + ATTR_CAST(contents.front(), "expr") + "\", " : "NULL, ");
+			stream << (HAS_ATTR_CAST(contents.front(), kXMLCharExpr) ? "\"" + ATTR_CAST(contents.front(), kXMLCharExpr) + "\", " : "NULL, ");
 		} else {
 			stream << "NULL, NULL, ";
 		}
 
-		if (HAS_ATTR(donedata, "paramIndex")) {
-			stream << "&" << _prefix << "_elem_params[" << escape(ATTR(donedata, "paramIndex")) << "]";
+		if (HAS_ATTR(donedata, X("paramIndex"))) {
+			stream << "&" << _prefix << "_elem_params[" << escape(ATTR(donedata, X("paramIndex"))) << "]";
 		} else {
 			stream << "NULL";
 		}
@@ -1796,7 +1796,7 @@ void ChartToC::writeMachineInfo(std::ostream& stream) {
 	stream << "        /* nr_states      */ " << _states.size() << "," << std::endl;
 	stream << "        /* nr_transitions */ " << _transitions.size() << "," << std::endl;
 	stream << "        /* name           */ \"" << escape(_name) << "\"," << std::endl;
-	stream << "        /* datamodel      */ \"" << (HAS_ATTR(_scxml, "datamodel") ? ATTR(_scxml, "datamodel") : "null") << "\"," << std::endl;
+	stream << "        /* datamodel      */ \"" << (HAS_ATTR(_scxml, kXMLCharDataModel) ? ATTR(_scxml, kXMLCharDataModel) : "null") << "\"," << std::endl;
 	stream << "        /* uuid           */ \"" << _md5 << "\"," << std::endl;
 	stream << "        /* states         */ " << "&" << _prefix << "_states[0], " << std::endl;
 	if (_transitions.size() > 0) {
@@ -1843,7 +1843,7 @@ void ChartToC::writeMachineInfo(std::ostream& stream) {
 		stream << "        /* nr_states      */ " << m->_states.size() << "," << std::endl;
 		stream << "        /* nr_transitions */ " << m->_transitions.size() << "," << std::endl;
 		stream << "        /* name           */ \"" << escape(m->_name) << "\"," << std::endl;
-		stream << "        /* datamodel      */ \"" << (HAS_ATTR(m->_scxml, "datamodel") ? ATTR(m->_scxml, "datamodel") : "null") << "\"," << std::endl;
+		stream << "        /* datamodel      */ \"" << (HAS_ATTR(m->_scxml, kXMLCharDataModel) ? ATTR(m->_scxml, kXMLCharDataModel) : "null") << "\"," << std::endl;
 		stream << "        /* uuid           */ \"" << m->_md5 << "\"," << std::endl;
 		stream << "        /* states         */ " << "&" << m->_prefix << "_states[0], " << std::endl;
 		stream << "        /* transitions    */ " << "&" << m->_prefix << "_transitions[0], " << std::endl;
@@ -1894,12 +1894,12 @@ void ChartToC::writeStates(std::ostream& stream) {
 
 		// name
 		stream << "        /* name       */ ";
-		stream << (HAS_ATTR(state, "id") ? "\"" + escape(ATTR(state, "id")) + "\"" : "NULL");
+		stream << (HAS_ATTR(state, kXMLCharId) ? "\"" + escape(ATTR(state, kXMLCharId)) + "\"" : "NULL");
 		stream << "," << std::endl;
 
 		// parent
 		stream << "        /* parent     */ ";
-		stream << (i == 0 ? "0" : ATTR_CAST(state->getParentNode(), "documentOrder"));
+		stream << (i == 0 ? "0" : ATTR_CAST(state->getParentNode(), X("documentOrder")));
 		stream << "," << std::endl;
 
 		// onentry
@@ -1919,20 +1919,20 @@ void ChartToC::writeStates(std::ostream& stream) {
 
 		// children
 		stream << "        /* children   */ { ";
-		writeCharArrayInitList(stream, ATTR(state, "childBools"));
-		stream << " /* " << ATTR(state, "childBools") << " */ }," << std::endl;
+		writeCharArrayInitList(stream, ATTR(state, X("childBools")));
+		stream << " /* " << ATTR(state, X("childBools")) << " */ }," << std::endl;
 
 		// default completion
 		stream << "        /* completion */ { ";
-		writeCharArrayInitList(stream, ATTR(state, "completionBools"));
-		stream << " /* " << ATTR(state, "completionBools") << " */ }, \t" << std::endl;
+		writeCharArrayInitList(stream, ATTR(state, X("completionBools")));
+		stream << " /* " << ATTR(state, X("completionBools")) << " */ }, \t" << std::endl;
 
 		stream << "        /* ancestors  */ { ";
-		writeCharArrayInitList(stream, ATTR(state, "ancBools"));
-		stream << " /* " << ATTR(state, "ancBools") << " */ }," << std::endl;
+		writeCharArrayInitList(stream, ATTR(state, X("ancBools")));
+		stream << " /* " << ATTR(state, X("ancBools")) << " */ }," << std::endl;
 
 		stream << "        /* data       */ ";
-		stream << (HAS_ATTR(state, "dataIndex") ? "&" + _prefix + "_elem_datas[" + escape(ATTR(state, "dataIndex")) + "]" : "NULL");
+		stream << (HAS_ATTR(state, X("dataIndex")) ? "&" + _prefix + "_elem_datas[" + escape(ATTR(state, X("dataIndex"))) + "]" : "NULL");
 		stream << "," << std::endl;
 
 		stream << "        /* type       */ ";
@@ -1943,7 +1943,7 @@ void ChartToC::writeStates(std::ostream& stream) {
 		} else if (isFinal(state)) {
 			stream << "USCXML_STATE_FINAL";
 		} else if (isHistory(state)) {
-			if (HAS_ATTR(state, "type") && iequals(ATTR(state, "type"), "deep")) {
+			if (HAS_ATTR(state, kXMLCharType) && iequals(ATTR(state, kXMLCharType), "deep")) {
 				stream << "USCXML_STATE_HISTORY_DEEP";
 			} else {
 				stream << "USCXML_STATE_HISTORY_SHALLOW";
@@ -1957,7 +1957,7 @@ void ChartToC::writeStates(std::ostream& stream) {
 		} else { // <scxml>
 			stream << "USCXML_STATE_COMPOUND";
 		}
-		if (HAS_ATTR(state, "hasHistoryChild")) {
+		if (HAS_ATTR(state, X("hasHistoryChild"))) {
 			stream << " | USCXML_STATE_HAS_HISTORY";
 		}
 
@@ -1987,21 +1987,21 @@ void ChartToC::writeTransitions(std::ostream& stream) {
 		for (size_t i = 0; i < _transitions.size(); i++) {
 			DOMElement* transition(_transitions[i]);
 
-			stream << "    {   /* transition number " << ATTR(transition, "documentOrder") << " with priority " << toStr(i) << std::endl;
-			stream << "           target: " << ATTR(transition, "target") << std::endl;
+			stream << "    {   /* transition number " << ATTR(transition, X("documentOrder")) << " with priority " << toStr(i) << std::endl;
+			stream << "           target: " << ATTR(transition, kXMLCharTarget) << std::endl;
 			stream << "         */" << std::endl;
 
 			// source
 			stream << "        /* source     */ ";
-			stream << ATTR_CAST(transition->getParentNode(), "documentOrder");
+			stream << ATTR_CAST(transition->getParentNode(), X("documentOrder"));
 			stream << "," << std::endl;
 
 			// targets
 			stream << "        /* target     */ ";
-			if (HAS_ATTR(transition, "targetBools")) {
+			if (HAS_ATTR(transition, X("targetBools"))) {
 				stream << "{ ";
-				writeCharArrayInitList(stream, ATTR(transition, "targetBools"));
-				stream << " /* " << ATTR(transition, "targetBools") << " */ }";
+				writeCharArrayInitList(stream, ATTR(transition, X("targetBools")));
+				stream << " /* " << ATTR(transition, X("targetBools")) << " */ }";
 
 			} else {
 				stream << "{ 0x00 }";
@@ -2009,17 +2009,17 @@ void ChartToC::writeTransitions(std::ostream& stream) {
 			stream << "," << std::endl;
 
 			stream << "        /* event      */ ";
-			stream << (HAS_ATTR(transition, "event") ? "\"" + escape(ATTR(transition, "event")) + "\"" : "NULL");
+			stream << (HAS_ATTR(transition, kXMLCharEvent) ? "\"" + escape(ATTR(transition, kXMLCharEvent)) + "\"" : "NULL");
 			stream << "," << std::endl;
 
 			stream << "        /* condition  */ ";
-			stream << (HAS_ATTR(transition, "cond") ? "\"" + escape(ATTR(transition, "cond")) + "\"" : "NULL");
+			stream << (HAS_ATTR(transition, kXMLCharCond) ? "\"" + escape(ATTR(transition, kXMLCharCond)) + "\"" : "NULL");
 			stream << "," << std::endl;
 
 
 			// is enabled
 			stream << "        /* is_enabled */ ";
-			if (HAS_ATTR(transition, "cond")) {
+			if (HAS_ATTR(transition, kXMLCharCond)) {
 				stream << _prefix << "_" << DOMUtils::idForNode(transition) << "_is_enabled";
 			} else {
 				stream << "NULL";
@@ -2038,17 +2038,17 @@ void ChartToC::writeTransitions(std::ostream& stream) {
 			// type
 			stream << "        /* type       */ ";
 			std::string seperator = "";
-			if (!HAS_ATTR(transition, "target")) {
+			if (!HAS_ATTR(transition, kXMLCharTarget)) {
 				stream << seperator << "USCXML_TRANS_TARGETLESS";
 				seperator = " | ";
 			}
 
-			if (HAS_ATTR(transition, "type") && iequals(ATTR(transition, "type"), "internal")) {
+			if (HAS_ATTR(transition, kXMLCharType) && iequals(ATTR(transition, kXMLCharType), "internal")) {
 				stream << seperator << "USCXML_TRANS_INTERNAL";
 				seperator = " | ";
 			}
 
-			if (!HAS_ATTR(transition, "event")) {
+			if (!HAS_ATTR(transition, kXMLCharEvent)) {
 				stream << seperator << "USCXML_TRANS_SPONTANEOUS";
 				seperator = " | ";
 			}
@@ -2070,13 +2070,13 @@ void ChartToC::writeTransitions(std::ostream& stream) {
 
 			// conflicts
 			stream << "        /* conflicts  */ { ";
-			writeCharArrayInitList(stream, ATTR(transition, "conflictBools"));
-			stream << " /* " << ATTR(transition, "conflictBools") << " */ }, " << std::endl;
+			writeCharArrayInitList(stream, ATTR(transition, X("conflictBools")));
+			stream << " /* " << ATTR(transition, X("conflictBools")) << " */ }, " << std::endl;
 
 			// exit set
 			stream << "        /* exit set   */ { ";
-			writeCharArrayInitList(stream, ATTR(transition, "exitSetBools"));
-			stream << " /* " << ATTR(transition, "exitSetBools") << " */ }" << std::endl;
+			writeCharArrayInitList(stream, ATTR(transition, X("exitSetBools")));
+			stream << " /* " << ATTR(transition, X("exitSetBools")) << " */ }" << std::endl;
 
 			stream << "    }" << (i + 1 < _transitions.size() ? ",": "") << std::endl;
 		}
diff --git a/src/uscxml/transform/ChartToPromela.cpp b/src/uscxml/transform/ChartToPromela.cpp
index 6d77a94..2c73e60 100644
--- a/src/uscxml/transform/ChartToPromela.cpp
+++ b/src/uscxml/transform/ChartToPromela.cpp
@@ -95,25 +95,25 @@ void ChartToPromela::prepare() {
 	std::list<DOMElement*> invokes = DOMUtils::inDocumentOrder({ XML_PREFIX(_scxml).str() + "invoke" }, _scxml);
 	for (auto invoke : invokes) {
 
-		if (!HAS_ATTR(invoke, "id")) {
+		if (!HAS_ATTR(invoke, kXMLCharId)) {
 			invoke->setAttribute(X("id"), X("INV_" + UUID::getUUID().substr(0,5)));
-		} else if (HAS_ATTR(invoke, "id") && UUID::isUUID(ATTR(invoke, "id"))) {
+		} else if (HAS_ATTR(invoke, kXMLCharId) && UUID::isUUID(ATTR(invoke, kXMLCharId))) {
 			// shorten UUIDs
-			invoke->setAttribute(X("id"), X("INV_" + ATTR(invoke, "id").substr(0,5)));
+			invoke->setAttribute(X("id"), X("INV_" + ATTR(invoke, kXMLCharId).substr(0,5)));
 		}
 
-		if (HAS_ATTR(invoke, "type") &&
-		        ATTR(invoke, "type") != "scxml" &&
-		        ATTR(invoke, "type") != "http://www.w3.org/TR/scxml/" &&
-		        ATTR(invoke, "type") != "http://www.w3.org/TR/scxml/#SCXMLEventProcessor")
+		if (HAS_ATTR(invoke, kXMLCharType) &&
+		        ATTR(invoke, kXMLCharType) != "scxml" &&
+		        ATTR(invoke, kXMLCharType) != "http://www.w3.org/TR/scxml/" &&
+		        ATTR(invoke, kXMLCharType) != "http://www.w3.org/TR/scxml/#SCXMLEventProcessor")
 			continue;
 
-		assert(HAS_ATTR(invoke, "id"));
+		assert(HAS_ATTR(invoke, kXMLCharId));
 		invoke->setAttribute(X("name"), invoke->getAttribute(X("id")));
 
 		Interpreter nested;
-		if (HAS_ATTR(invoke, "src")) {
-			nested = Interpreter::fromURL(URL::resolve(ATTR(invoke, "src"), _baseURL));
+		if (HAS_ATTR(invoke, kXMLCharSource)) {
+			nested = Interpreter::fromURL(URL::resolve(ATTR(invoke, kXMLCharSource), _baseURL));
 		} else {
 			std::list<DOMElement*> contents = DOMUtils::filterChildElements(XML_PREFIX(invoke).str() + "content", invoke);
 			std::list<DOMElement*> scxmls = DOMUtils::filterChildElements(XML_PREFIX(invoke).str() + "scxml", contents.front());
@@ -131,15 +131,15 @@ void ChartToPromela::prepare() {
 		_machinesNested[invoke]->_machinesAll = _machinesAll;
 		(*_machinesAll)[invoke] = _machinesNested[invoke];
 
-		_machinesNested[invoke]->_invokerid = ATTR(invoke, "id");
+		_machinesNested[invoke]->_invokerid = ATTR(invoke, kXMLCharId);
 		_analyzer->createMacroName(_machinesNested[invoke]->_invokerid);
 		_analyzer->addEvent("done.invoke." + _machinesNested[invoke]->_invokerid);
 
-		_machinesNested[invoke]->_prefix = _analyzer->macroForLiteral(ATTR(invoke, "id")) + "_";
+		_machinesNested[invoke]->_prefix = _analyzer->macroForLiteral(ATTR(invoke, kXMLCharId)) + "_";
 
 
-		_machinesPerId[ATTR_CAST(invoke, "id")] = invoke;
-		(*_machinesAllPerId)[ATTR(invoke, "id")] = invoke;
+		_machinesPerId[ATTR_CAST(invoke, kXMLCharId)] = invoke;
+		(*_machinesAllPerId)[ATTR(invoke, kXMLCharId)] = invoke;
 
 	}
 
@@ -155,20 +155,20 @@ void ChartToPromela::prepare() {
 
 	for (auto element : values) {
 		std::string key;
-		if (HAS_ATTR(element, "id")) {
-			key = ATTR(element, "id");
-		} else if (HAS_ATTR(element, "location")) {
-			key = ATTR(element, "location");
+		if (HAS_ATTR(element, kXMLCharId)) {
+			key = ATTR(element, kXMLCharId);
+		} else if (HAS_ATTR(element, kXMLCharLocation)) {
+			key = ATTR(element, kXMLCharLocation);
 		}
 
 		if (key.length() == 0)
 			continue;
 
 		std::string value;
-		if (HAS_ATTR(element, "expr")) {
-			value = ATTR(element, "expr");
-		} else if (HAS_ATTR(element, "src")) {
-			URL absUrl = URL::resolve(ATTR_CAST(element, "src"), _baseURL);
+		if (HAS_ATTR(element, kXMLCharExpr)) {
+			value = ATTR(element, kXMLCharExpr);
+		} else if (HAS_ATTR(element, kXMLCharSource)) {
+			URL absUrl = URL::resolve(ATTR_CAST(element, kXMLCharSource), _baseURL);
 			value = absUrl.getInContent();
 		} else {
 			std::list<DOMNode*> assignTexts = DOMUtils::filterChildType(DOMNode::TEXT_NODE, element, true);
@@ -677,8 +677,8 @@ void ChartToPromela::writeVariables(std::ostream& stream) {
 	PromelaCodeAnalyzer::PromelaTypedef allTypes = _analyzer->getTypes();
 
 	for (auto data : datas) {
-		std::string identifier = (HAS_ATTR_CAST(data, "id") ? ATTR_CAST(data, "id") : "");
-		std::string type = boost::trim_copy(HAS_ATTR_CAST(data, "type") ? ATTR_CAST(data, "type") : "");
+		std::string identifier = (HAS_ATTR_CAST(data, kXMLCharId) ? ATTR_CAST(data, kXMLCharId) : "");
+		std::string type = boost::trim_copy(HAS_ATTR_CAST(data, kXMLCharType) ? ATTR_CAST(data, kXMLCharType) : "");
 
 		_dataModelVars.insert(identifier);
 		if (processedIdentifiers.find(identifier) != processedIdentifiers.end())
@@ -760,9 +760,9 @@ void ChartToPromela::writeStrings(std::ostream& stream) {
 
 	{
 		for (size_t i = 0; i < _states.size(); i++) {
-			if (HAS_ATTR(_states[i], "id")) {
-				stream << "#define " << _prefix << _analyzer->macroForLiteral(ATTR(_states[i], "id")) << " " << toStr(i);
-				stream << " /* index for state " << ATTR(_states[i], "id") << " */" << std::endl;
+			if (HAS_ATTR(_states[i], kXMLCharId)) {
+				stream << "#define " << _prefix << _analyzer->macroForLiteral(ATTR(_states[i], kXMLCharId)) << " " << toStr(i);
+				stream << " /* index for state " << ATTR(_states[i], kXMLCharId) << " */" << std::endl;
 			}
 		}
 	}
@@ -787,25 +787,25 @@ void ChartToPromela::writeTransitions(std::ostream& stream) {
 
 		/** source */
 		stream << "  " << _prefix << "transitions[" << toStr(i) << "].source = ";
-		stream << ATTR_CAST(transition->getParentNode(), "documentOrder") ;
+		stream << ATTR_CAST(transition->getParentNode(), X("documentOrder")) ;
 		stream << ";" << std::endl;
 
 		/** target */
-		if (HAS_ATTR(transition, "targetBools")) {
-			std::string targetBools = ATTR(transition, "targetBools");
+		if (HAS_ATTR(transition, X("targetBools"))) {
+			std::string targetBools = ATTR(transition, X("targetBools"));
 			for (size_t j = 0; j < _states.size(); j++) {
 				if (targetBools[j] == '1')
 					stream << "  " << _prefix << "transitions[" << toStr(i) << "].target[" << toStr(j) << "] = 1;" << std::endl;
 			}
 		}
 
-		if (!HAS_ATTR(transition, "event"))
+		if (!HAS_ATTR(transition, kXMLCharEvent))
 			stream << "  " << _prefix << "transitions[" << toStr(i) << "].type[USCXML_TRANS_SPONTANEOUS] = 1;" << std::endl;
 
-		if (!HAS_ATTR(transition, "target"))
+		if (!HAS_ATTR(transition, kXMLCharTarget))
 			stream << "  " << _prefix << "transitions[" << toStr(i) << "].type[USCXML_TRANS_TARGETLESS] = 1;" << std::endl;
 
-		if (HAS_ATTR(transition, "type") && ATTR(transition, "type") == "internal")
+		if (HAS_ATTR(transition, kXMLCharType) && ATTR(transition, kXMLCharType) == "internal")
 			stream << "  " << _prefix << "transitions[" << toStr(i) << "].type[USCXML_TRANS_INTERNAL] = 1;" << std::endl;
 
 		if (TAGNAME_CAST(transition->getParentNode()) == XML_PREFIX(transition).str() + "history")
@@ -814,16 +814,16 @@ void ChartToPromela::writeTransitions(std::ostream& stream) {
 		if (TAGNAME_CAST(transition->getParentNode()) == XML_PREFIX(transition).str() + "initial")
 			stream << "  " << _prefix << "transitions[" << toStr(i) << "].type[USCXML_TRANS_INITIAL] = 1;" << std::endl;
 
-		if (HAS_ATTR(transition, "conflictBools")) {
-			std::string conflicts = ATTR(transition, "conflictBools");
+		if (HAS_ATTR(transition, X("conflictBools"))) {
+			std::string conflicts = ATTR(transition, X("conflictBools"));
 			for (size_t j = 0; j < conflicts.size(); j++) {
 				if (conflicts[j] == '1')
 					stream << "  " << _prefix << "transitions[" << toStr(i) << "].conflicts[" << toStr(j) << "] = 1;" << std::endl;
 			}
 		}
 
-		if (HAS_ATTR(transition, "exitSetBools")) {
-			std::string exitSet = ATTR(transition, "exitSetBools");
+		if (HAS_ATTR(transition, X("exitSetBools"))) {
+			std::string exitSet = ATTR(transition, X("exitSetBools"));
 			for (size_t j = 0; j < exitSet.size(); j++) {
 				if (exitSet[j] == '1')
 					stream << "  " << _prefix << "transitions[" << toStr(i) << "].exit_set[" << toStr(j) << "] = 1;" << std::endl;
@@ -842,28 +842,28 @@ void ChartToPromela::writeStates(std::ostream& stream) {
 		DOMElement* state(_states[i]);
 
 		stream << "  " << _prefix << "states[" << toStr(i) << "].parent = ";
-		stream << (i == 0 ? "0" : ATTR_CAST(state->getParentNode(), "documentOrder"));
+		stream << (i == 0 ? "0" : ATTR_CAST(state->getParentNode(), X("documentOrder")));
 		stream << ";" << std::endl;
 
 
-		if (HAS_ATTR(state, "childBools")) {
-			std::string childs = ATTR(state, "childBools");
+		if (HAS_ATTR(state, X("childBools"))) {
+			std::string childs = ATTR(state, X("childBools"));
 			for (size_t j = 0; j < childs.size(); j++) {
 				if (childs[j] == '1')
 					stream << "  " << _prefix << "states[" << toStr(i) << "].children[" << toStr(j) << "] = 1;" << std::endl;
 			}
 		}
 
-		if (HAS_ATTR(state, "completionBools")) {
-			std::string completions = ATTR(state, "completionBools");
+		if (HAS_ATTR(state, X("completionBools"))) {
+			std::string completions = ATTR(state, X("completionBools"));
 			for (size_t j = 0; j < completions.size(); j++) {
 				if (completions[j] == '1')
 					stream << "  " << _prefix << "states[" << toStr(i) << "].completion[" << toStr(j) << "] = 1;" << std::endl;
 			}
 		}
 
-		if (HAS_ATTR(state, "ancBools")) {
-			std::string ancestors = ATTR(state, "ancBools");
+		if (HAS_ATTR(state, X("ancBools"))) {
+			std::string ancestors = ATTR(state, X("ancBools"));
 			for (size_t j = 0; j < ancestors.size(); j++) {
 				if (ancestors[j] == '1')
 					stream << "  " << _prefix << "states[" << toStr(i) << "].ancestors[" << toStr(j) << "] = 1;" << std::endl;
@@ -875,7 +875,7 @@ void ChartToPromela::writeStates(std::ostream& stream) {
 		} else if (isFinal(state)) {
 			stream << "  " << _prefix << "states[" << toStr(i) << "].type[USCXML_STATE_FINAL] = 1;" << std::endl;
 		} else if (isHistory(state)) {
-			if (HAS_ATTR(state, "type") && iequals(ATTR(state, "type"), "deep")) {
+			if (HAS_ATTR(state, kXMLCharType) && iequals(ATTR(state, kXMLCharType), "deep")) {
 				stream << "  " << _prefix << "states[" << toStr(i) << "].type[USCXML_STATE_HISTORY_DEEP] = 1;" << std::endl;
 			} else {
 				stream << "  " << _prefix << "states[" << toStr(i) << "].type[USCXML_STATE_HISTORY_SHALLOW] = 1;" << std::endl;
@@ -889,7 +889,7 @@ void ChartToPromela::writeStates(std::ostream& stream) {
 		} else { // <scxml>
 			stream << "  " << _prefix << "states[" << toStr(i) << "].type[USCXML_STATE_COMPOUND] = 1;" << std::endl;
 		}
-		if (HAS_ATTR(state, "hasHistoryChild")) {
+		if (HAS_ATTR(state, X("hasHistoryChild"))) {
 			stream << "  " << _prefix << "states[" << toStr(i) << "].type[USCXML_STATE_HAS_HISTORY] = 1;" << std::endl;
 		}
 
@@ -909,8 +909,8 @@ void ChartToPromela::writeRaiseDoneDate(std::ostream& stream, const DOMElement*
 		auto& content = contents.front();
 
 		// an expression
-		if (HAS_ATTR(content, "expr")) {
-			stream << dataToAssignments(_prefix + "_tmpE.data", Data(ADAPT_SRC(ATTR(content, "expr")), Data::INTERPRETED));
+		if (HAS_ATTR(content, kXMLCharExpr)) {
+			stream << dataToAssignments(_prefix + "_tmpE.data", Data(ADAPT_SRC(ATTR(content, kXMLCharExpr)), Data::INTERPRETED));
 			return;
 		}
 
@@ -941,14 +941,14 @@ void ChartToPromela::writeRaiseDoneDate(std::ostream& stream, const DOMElement*
 	if (params.size() > 0) {
 		Data d;
 		for (auto& param : params) {
-			if (!HAS_ATTR(param, "name"))
+			if (!HAS_ATTR(param, kXMLCharName))
 				continue;
-			std::string name = ATTR(param, "name");
+			std::string name = ATTR(param, kXMLCharName);
 			std::string expr;
-			if (HAS_ATTR(param, "expr")) {
-				expr = ATTR(param, "expr");
-			} else if (HAS_ATTR(param, "location")) {
-				expr = ATTR(param, "location");
+			if (HAS_ATTR(param, kXMLCharExpr)) {
+				expr = ATTR(param, kXMLCharExpr);
+			} else if (HAS_ATTR(param, kXMLCharLocation)) {
+				expr = ATTR(param, kXMLCharLocation);
 			}
 
 			d[name] = Data(expr, Data::INTERPRETED);
@@ -996,8 +996,8 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 		}
 
 	} else if(TAGNAME(element) == "log") {
-		std::string label = (HAS_ATTR(element, "label") ? ATTR(element, "label") : "");
-		std::string expr = (HAS_ATTR(element, "expr") ? ADAPT_SRC(ATTR(element, "expr")) : "");
+		std::string label = (HAS_ATTR(element, kXMLCharLabel) ? ATTR(element, kXMLCharLabel) : "");
+		std::string expr = (HAS_ATTR(element, kXMLCharExpr) ? ADAPT_SRC(ATTR(element, kXMLCharExpr)) : "");
 		std::string trimmedExpr = boost::trim_copy(expr);
 		bool isStringLiteral = (boost::starts_with(trimmedExpr, "\"") || boost::starts_with(trimmedExpr, "'"));
 
@@ -1027,17 +1027,17 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 		}
 
 	} else if(TAGNAME(element) == "foreach") {
-		stream << padding << "for (" << (HAS_ATTR(element, "index") ? _prefix + ATTR(element, "index") : "_index") << " in " << _prefix << ATTR(element, "array") << ") {" << std::endl;
-		if (HAS_ATTR(element, "item")) {
-			stream << padding << "  " << _prefix << ATTR(element, "item") << " = " << _prefix << ATTR(element, "array") << "[" << (HAS_ATTR(element, "index") ? _prefix + ATTR(element, "index") : "_index") << "];" << std::endl;
+		stream << padding << "for (" << (HAS_ATTR(element, kXMLCharIndex) ? _prefix + ATTR(element, kXMLCharIndex) : "_index") << " in " << _prefix << ATTR(element, kXMLCharArray) << ") {" << std::endl;
+		if (HAS_ATTR(element, kXMLCharItem)) {
+			stream << padding << "  " << _prefix << ATTR(element, kXMLCharItem) << " = " << _prefix << ATTR(element, kXMLCharArray) << "[" << (HAS_ATTR(element, kXMLCharIndex) ? _prefix + ATTR(element, kXMLCharIndex) : "_index") << "];" << std::endl;
 		}
 		const XERCESC_NS::DOMNode* child = element->getFirstChild();
 		while(child) {
 			writeExecContent(stream, child, indent + 1);
 			child = child->getNextSibling();
 		}
-		//		if (HAS_ATTR(nodeElem, "index"))
-		//			stream << padding << "  " << _prefix << ATTR(nodeElem, "index") << "++;" << std::endl;
+		//		if (HAS_ATTR(nodeElem, kXMLCharIndex))
+		//			stream << padding << "  " << _prefix << ATTR(nodeElem, kXMLCharIndex) << "++;" << std::endl;
 		stream << padding << "}" << std::endl;
 
 	} else if(TAGNAME(element) == "if") {
@@ -1065,27 +1065,27 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 		std::string insertOp = "!";
 		if (TAGNAME(element) == "raise") {
 			targetQueue = _prefix + "iQ";
-		} else if (!HAS_ATTR(element, "target")) {
+		} else if (!HAS_ATTR(element, kXMLCharTarget)) {
 //      if (_allowEventInterleaving) {
 //        targetQueue = _prefix + "tmpQ";
 //      } else {
 			targetQueue = _prefix + "eQ";
 //      }
-		} else if (ATTR(element, "target").compare("#_internal") == 0) {
+		} else if (ATTR(element, kXMLCharTarget).compare("#_internal") == 0) {
 			targetQueue = _prefix + "iQ";
-		} else if (ATTR(element, "target").compare("#_parent") == 0) {
+		} else if (ATTR(element, kXMLCharTarget).compare("#_parent") == 0) {
 			targetQueue = _parent->_prefix + "eQ";
-		} else if (boost::starts_with(ATTR(element, "target"), "#_") && _machinesAllPerId->find(ATTR(element, "target").substr(2)) != _machinesAllPerId->end()) {
-			targetQueue = (*_machinesAll)[(*_machinesAllPerId)[ATTR(element, "target").substr(2)]]->_prefix + "eQ";
+		} else if (boost::starts_with(ATTR(element, kXMLCharTarget), "#_") && _machinesAllPerId->find(ATTR(element, kXMLCharTarget).substr(2)) != _machinesAllPerId->end()) {
+			targetQueue = (*_machinesAll)[(*_machinesAllPerId)[ATTR(element, kXMLCharTarget).substr(2)]]->_prefix + "eQ";
 		}
 		if (targetQueue.length() > 0) {
 			// this is for our external queue
 			std::string event;
 
-			if (HAS_ATTR(element, "event")) {
-				event = _analyzer->macroForLiteral(ATTR(element, "event"));
-			} else if (HAS_ATTR(element, "eventexpr")) {
-				event = ADAPT_SRC(ATTR(element, "eventexpr"));
+			if (HAS_ATTR(element, kXMLCharEvent)) {
+				event = _analyzer->macroForLiteral(ATTR(element, kXMLCharEvent));
+			} else if (HAS_ATTR(element, kXMLCharEventExpr)) {
+				event = ADAPT_SRC(ATTR(element, kXMLCharEventExpr));
 			}
 			if (_analyzer->usesComplexEventStruct()) {
 				stream << padding << "{" << std::endl;
@@ -1093,17 +1093,17 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 				std::stringstream typeAssignSS;
 				typeAssignSS << padding << "  " << _prefix << "_tmpE.name = " << event << ";" << std::endl;
 
-				if (HAS_ATTR(element, "idlocation")) {
+				if (HAS_ATTR(element, kXMLCharIdLocation)) {
 					typeAssignSS << padding << "  /* idlocation */" << std::endl;
 					typeAssignSS << padding << "  _lastSendId = _lastSendId + 1;" << std::endl;
-					typeAssignSS << padding << "  " << _prefix << ATTR(element, "idlocation") << " = _lastSendId;" << std::endl;
+					typeAssignSS << padding << "  " << _prefix << ATTR(element, kXMLCharIdLocation) << " = _lastSendId;" << std::endl;
 					typeAssignSS << padding << "  " << _prefix << "_tmpE.sendid = _lastSendId;" << std::endl;
 					typeAssignSS << padding << "  if" << std::endl;
 					typeAssignSS << padding << "  :: _lastSendId == 2147483647 -> _lastSendId = 0;" << std::endl;
 					typeAssignSS << padding << "  :: else -> skip;" << std::endl;
 					typeAssignSS << padding << "  fi;" << std::endl;
-				} else if (HAS_ATTR(element, "id")) {
-					typeAssignSS << padding << "  " << _prefix << "_tmpE.sendid = " << _analyzer->macroForLiteral(ATTR(element, "id")) << ";" << std::endl;
+				} else if (HAS_ATTR(element, kXMLCharId)) {
+					typeAssignSS << padding << "  " << _prefix << "_tmpE.sendid = " << _analyzer->macroForLiteral(ATTR(element, kXMLCharId)) << ";" << std::endl;
 				}
 
 				if (_analyzer->usesEventField("invokeid") && _parent != NULL) { // do not send invokeid if we send / raise to ourself
@@ -1124,10 +1124,10 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 //					insertOp += "!";
 					typeAssignSS << padding << "  _lastSeqId = _lastSeqId + 1;" << std::endl;
 #endif
-					if (HAS_ATTR_CAST(element, "delay")) {
-						typeAssignSS << padding << "  " << _prefix << "_tmpE.delay = " << ATTR_CAST(element, "delay") << ";" << std::endl;
-					} else if (HAS_ATTR_CAST(element, "delayexpr")) {
-						typeAssignSS << padding << "  " << _prefix << "_tmpE.delay = " << ADAPT_SRC(ATTR_CAST(element, "delayexpr")) << ";" << std::endl;
+					if (HAS_ATTR_CAST(element, kXMLCharDelay)) {
+						typeAssignSS << padding << "  " << _prefix << "_tmpE.delay = " << ATTR_CAST(element, kXMLCharDelay) << ";" << std::endl;
+					} else if (HAS_ATTR_CAST(element, kXMLCharDelayExpr)) {
+						typeAssignSS << padding << "  " << _prefix << "_tmpE.delay = " << ADAPT_SRC(ATTR_CAST(element, kXMLCharDelayExpr)) << ";" << std::endl;
 					} else {
 						typeAssignSS << padding << "  " << _prefix << "_tmpE.delay = 0;" << std::endl;
 					}
@@ -1144,10 +1144,10 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 
 				std::list<DOMElement*> sendParams = DOMUtils::filterChildElements(XML_PREFIX(element).str() + "param", element);
 				std::list<DOMElement*> sendContents = DOMUtils::filterChildElements(XML_PREFIX(element).str() + "content", element);
-				std::string sendNameList = ATTR(element, "namelist");
+				std::string sendNameList = ATTR(element, kXMLCharNameList);
 				if (sendParams.size() > 0) {
 					for (auto sendParam : sendParams) {
-						typeAssignSS << padding << "  " << _prefix << "_tmpE.data." << ATTR(sendParam, "name") << " = " << ADAPT_SRC(ATTR(sendParam, "expr"))  << ";" << std::endl;
+						typeAssignSS << padding << "  " << _prefix << "_tmpE.data." << ATTR(sendParam, kXMLCharName) << " = " << ADAPT_SRC(ATTR(sendParam, kXMLCharExpr))  << ";" << std::endl;
 					}
 				}
 				if (sendNameList.size() > 0) {
@@ -1168,8 +1168,8 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 						} else {
 							typeAssignSS << padding << "  " << _prefix << "_tmpE.data = " << content << ";" << std::endl;
 						}
-					} else if (HAS_ATTR(contentElem, "expr")) {
-						typeAssignSS << padding << "  " << _prefix << "_tmpE.data = " << ADAPT_SRC(ATTR(contentElem, "expr")) << ";" << std::endl;
+					} else if (HAS_ATTR(contentElem, kXMLCharExpr)) {
+						typeAssignSS << padding << "  " << _prefix << "_tmpE.data = " << ADAPT_SRC(ATTR(contentElem, kXMLCharExpr)) << ";" << std::endl;
 					}
 				}
 
@@ -1227,10 +1227,10 @@ void ChartToPromela::writeExecContent(std::ostream& stream, const XERCESC_NS::DO
 		stream << padding << "fi" << std::endl;
 
 	} else if(TAGNAME(element) == "cancel") {
-		if (HAS_ATTR(element, "sendid")) {
-			stream << "  " << padding << "cancelSendId(" << _analyzer->macroForLiteral(ATTR(element, "sendid")) << "," << _analyzer->macroForLiteral(_invokerid) << ");" << std::endl;
-		} else if (HAS_ATTR(element, "sendidexpr")) {
-			stream << "  " << padding << "cancelSendId(" << ADAPT_SRC(ATTR(element, "sendidexpr")) << "," << _analyzer->macroForLiteral(_invokerid) << ");" << std::endl;
+		if (HAS_ATTR(element, kXMLCharSendId)) {
+			stream << "  " << padding << "cancelSendId(" << _analyzer->macroForLiteral(ATTR(element, kXMLCharSendId)) << "," << _analyzer->macroForLiteral(_invokerid) << ");" << std::endl;
+		} else if (HAS_ATTR(element, kXMLCharSendIdExpr)) {
+			stream << "  " << padding << "cancelSendId(" << ADAPT_SRC(ATTR(element, kXMLCharSendIdExpr)) << "," << _analyzer->macroForLiteral(_invokerid) << ");" << std::endl;
 		}
 	} else {
 		LOGD(USCXML_VERBATIM) << "'" << TAGNAME(element) << "' not supported" << std::endl << element << std::endl;
@@ -1419,8 +1419,8 @@ void ChartToPromela::writeFSMMacrostep(std::ostream& stream) {
 				ChartToPromela* invoker = _machinesNested[invokeElem];
 
 				// pass variables via namelist
-				if (HAS_ATTR(invokeElem, "namelist")) {
-					std::list<std::string> namelist = tokenize(ATTR_CAST(invokeElem, "namelist"));
+				if (HAS_ATTR(invokeElem, kXMLCharNameList)) {
+					std::list<std::string> namelist = tokenize(ATTR_CAST(invokeElem, kXMLCharNameList));
 					for (auto name : namelist) {
 						if (invoker->_dataModelVars.find(name) != invoker->_dataModelVars.end()) {
 							stream << "          " << invoker->_prefix << name << " = " << _prefix << name << ";" << std::endl;
@@ -1431,8 +1431,8 @@ void ChartToPromela::writeFSMMacrostep(std::ostream& stream) {
 				// pass variables via params
 				std::list<DOMElement*> invokeParams = DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + + "param", invokeElem);
 				for (auto param : invokeParams) {
-					std::string name = ATTR(param, "name");
-					std::string expression = ATTR(param, "expr");
+					std::string name = ATTR(param, kXMLCharName);
+					std::string expression = ATTR(param, kXMLCharExpr);
 					if (invoker->_dataModelVars.find(name) != invoker->_dataModelVars.end()) {
 						stream << "          " << invoker->_prefix << name << " = " << ADAPT_SRC(expression) << ";" << std::endl;
 					}
@@ -1441,8 +1441,8 @@ void ChartToPromela::writeFSMMacrostep(std::ostream& stream) {
 				TRACE_EXECUTION_V("Invoking in state %d", "i");
 
 				stream << "          run " << invoker->_prefix << "step() priority 20;" << std::endl;
-				if (HAS_ATTR(invokeElem, "idlocation")) {
-					stream << "          " << ADAPT_SRC(ATTR(invokeElem, "idlocation")) << " = ";
+				if (HAS_ATTR(invokeElem, kXMLCharIdLocation)) {
+					stream << "          " << ADAPT_SRC(ATTR(invokeElem, kXMLCharIdLocation)) << " = ";
 					stream << _analyzer->macroForLiteral(invoker->_invokerid) << ";" << std::endl;
 				}
 
@@ -1486,10 +1486,10 @@ void ChartToPromela::writeFSMMacrostep(std::ostream& stream) {
 		for (auto state : _states) {
 			std::list<DOMElement*> invokers = DOMUtils::filterChildElements(XML_PREFIX(state).str() + "invoke", state, false);
 			if (invokers.size() > 0) {
-				stream << "        :: i == " << ATTR(state, "documentOrder") << " && " << _prefix << "invocations[i] -> { " << std::endl;
+				stream << "        :: i == " << ATTR(state, X("documentOrder")) << " && " << _prefix << "invocations[i] -> { " << std::endl;
 				for (auto invoker : invokers) {
 					assert(_machinesNested.find(invoker) != _machinesNested.end());
-					if (HAS_ATTR(invoker, "autoforward") && stringIsTrue(ATTR(invoker, "autoforward"))) {
+					if (HAS_ATTR(invoker, kXMLCharAutoForward) && stringIsTrue(ATTR(invoker, kXMLCharAutoForward))) {
 						stream << "          " << _machinesNested[invoker]->_prefix << "eQ " << insertOp << " " << _prefix << "_event;" << std::endl;
 						if (_analyzer->usesEventField("delay")) {
 							stream << "          insertWithDelay(" << _machinesNested[invoker]->_prefix << "eQ);" << std::endl;
@@ -1654,8 +1654,8 @@ void ChartToPromela::writeFSMDequeueEvent(std::ostream& stream) {
 				ChartToPromela* invoker = _machinesNested[invokeElem];
 
 				// pass variables via namelist
-				if (HAS_ATTR(invokeElem, "namelist")) {
-					std::list<std::string> namelist = tokenize(ATTR_CAST(invokeElem, "namelist"));
+				if (HAS_ATTR(invokeElem, kXMLCharNameList)) {
+					std::list<std::string> namelist = tokenize(ATTR_CAST(invokeElem, kXMLCharNameList));
 					for (auto name : namelist) {
 						if (invoker->_dataModelVars.find(name) != invoker->_dataModelVars.end()) {
 							stream << "          " << invoker->_prefix << name << " = " << _prefix << name << ";" << std::endl;
@@ -1666,8 +1666,8 @@ void ChartToPromela::writeFSMDequeueEvent(std::ostream& stream) {
 				// pass variables via params
 				std::list<DOMElement*> invokeParams = DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + + "param", invokeElem);
 				for (auto param : invokeParams) {
-					std::string name = ATTR(param, "name");
-					std::string expression = ATTR(param, "expr");
+					std::string name = ATTR(param, kXMLCharName);
+					std::string expression = ATTR(param, kXMLCharExpr);
 					if (invoker->_dataModelVars.find(name) != invoker->_dataModelVars.end()) {
 						stream << "          " << invoker->_prefix << name << " = " << ADAPT_SRC(expression) << ";" << std::endl;
 					}
@@ -1676,8 +1676,8 @@ void ChartToPromela::writeFSMDequeueEvent(std::ostream& stream) {
 				TRACE_EXECUTION_V("Invoking in state %d", "i");
 
 				stream << "          run " << invoker->_prefix << "step() priority 20;" << std::endl;
-				if (HAS_ATTR(invokeElem, "idlocation")) {
-					stream << "          " << ADAPT_SRC(ATTR(invokeElem, "idlocation")) << " = ";
+				if (HAS_ATTR(invokeElem, kXMLCharIdLocation)) {
+					stream << "          " << ADAPT_SRC(ATTR(invokeElem, kXMLCharIdLocation)) << " = ";
 					stream << _analyzer->macroForLiteral(invoker->_invokerid) << ";" << std::endl;
 				}
 
@@ -1737,10 +1737,10 @@ void ChartToPromela::writeFSMDequeueEvent(std::ostream& stream) {
 		for (auto state : _states) {
 			std::list<DOMElement*> invokers = DOMUtils::filterChildElements(XML_PREFIX(state).str() + "invoke", state, false);
 			if (invokers.size() > 0) {
-				stream << "        :: i == " << ATTR(state, "documentOrder") << " && " << _prefix << "invocations[i] -> { " << std::endl;
+				stream << "        :: i == " << ATTR(state, X("documentOrder")) << " && " << _prefix << "invocations[i] -> { " << std::endl;
 				for (auto invoker : invokers) {
 					assert(_machinesNested.find(invoker) != _machinesNested.end());
-					if (HAS_ATTR(invoker, "autoforward") && stringIsTrue(ATTR(invoker, "autoforward"))) {
+					if (HAS_ATTR(invoker, kXMLCharAutoForward) && stringIsTrue(ATTR(invoker, kXMLCharAutoForward))) {
 						stream << "          " << _machinesNested[invoker]->_prefix << "eQ " << insertOp << " " << _prefix << "_event;" << std::endl;
 						if (_analyzer->usesEventField("delay")) {
 							stream << "          insertWithDelay(" << _machinesNested[invoker]->_prefix << "eQ);" << std::endl;
@@ -1851,9 +1851,9 @@ void ChartToPromela::writeFSMSelectTransitions(std::ostream& stream) {
 
 		for (size_t i = 0; i < _transitions.size(); i++) {
 			stream << "          || (i == " << toStr(i);
-			if (HAS_ATTR(_transitions[i], "event") && ATTR(_transitions[i], "event") != "*") {
+			if (HAS_ATTR(_transitions[i], kXMLCharEvent) && ATTR(_transitions[i], kXMLCharEvent) != "*") {
 				stream << " && (false";
-				std::list<std::string> eventLiterals = tokenize(ATTR(_transitions[i], "event"));
+				std::list<std::string> eventLiterals = tokenize(ATTR(_transitions[i], kXMLCharEvent));
 				for (auto eventLiteral : eventLiterals) {
 					if (boost::ends_with(eventLiteral, ".*")) {
 						eventLiteral = eventLiteral.substr(0, eventLiteral.size() - 2);
@@ -1868,8 +1868,8 @@ void ChartToPromela::writeFSMSelectTransitions(std::ostream& stream) {
 				}
 				stream << ")";
 			}
-			if (HAS_ATTR(_transitions[i], "cond")) {
-				stream << " && " << ADAPT_SRC(ATTR(_transitions[i], "cond"));
+			if (HAS_ATTR(_transitions[i], kXMLCharCond)) {
+				stream << " && " << ADAPT_SRC(ATTR(_transitions[i], kXMLCharCond));
 			}
 			stream << ")" << std::endl;
 		}
@@ -2501,12 +2501,12 @@ void ChartToPromela::writeFSMEnterStates(std::ostream& stream) {
 			continue;
 
 		DOMElement* parent = static_cast<DOMElement*>(state->getParentNode());
-		if (!HAS_ATTR(parent, "id"))
+		if (!HAS_ATTR(parent, kXMLCharId))
 			continue;
 
-		std::string doneEvent = _analyzer->macroForLiteral("done.state." + ATTR_CAST(state->getParentNode(), "id"));
+		std::string doneEvent = _analyzer->macroForLiteral("done.state." + ATTR_CAST(state->getParentNode(), kXMLCharId));
 
-		stream << "             :: (i == " << ATTR(state, "documentOrder") << ") -> {" << std::endl;
+		stream << "             :: (i == " << ATTR(state, X("documentOrder")) << ") -> {" << std::endl;
 
 		if (_analyzer->usesComplexEventStruct()) {
 			std::string typeReset = _analyzer->getTypeReset(_prefix + "_tmpE", _analyzer->getType("_event"), 7);
@@ -2573,10 +2573,10 @@ void ChartToPromela::writeFSMEnterStates(std::ostream& stream) {
 	stream << "                  if" << std::endl;
 
 	for (auto state : _states) {
-		if (isParallel(state) && HAS_ATTR(state, "id")) {
-			stream << "                  :: j == " << toStr(ATTR(state, "documentOrder")) << " -> {" << std::endl;
+		if (isParallel(state) && HAS_ATTR(state, kXMLCharId)) {
+			stream << "                  :: j == " << toStr(ATTR(state, X("documentOrder"))) << " -> {" << std::endl;
 
-			std::string doneEvent = _analyzer->macroForLiteral("done.state." + ATTR(state, "id"));
+			std::string doneEvent = _analyzer->macroForLiteral("done.state." + ATTR(state, kXMLCharId));
 
 			if (_analyzer->usesComplexEventStruct()) {
 				std::string typeReset = _analyzer->getTypeReset(_prefix + "_tmpE", _analyzer->getType("_event"), 10);
@@ -2669,7 +2669,7 @@ void ChartToPromela::writeFSMTerminateMachine(std::ostream& stream) {
 	stream << "    if" << std::endl;
 
 	for (auto machine : _machinesNested) {
-		stream << "    :: i == " << ATTR_CAST(machine.first->getParentNode(), "documentOrder") << " -> {" << std::endl;
+		stream << "    :: i == " << ATTR_CAST(machine.first->getParentNode(), X("documentOrder")) << " -> {" << std::endl;
 		stream << "      " << machine.second->_prefix << "flags[USCXML_CTX_FINISHED] = true;" << std::endl;
 		stream << "    }" << std::endl;
 	}
@@ -2752,7 +2752,7 @@ void ChartToPromela::writeIfBlock(std::ostream& stream, std::list<DOMElement*>&
 
 	stream << padding << "if" << std::endl;
 	// we need to nest the elseifs to resolve promela if semantics
-	stream << padding << ":: (" << ADAPT_SRC(ATTR(ifNode, "cond")) << ") -> {" << std::endl;
+	stream << padding << ":: (" << ADAPT_SRC(ATTR(ifNode, kXMLCharCond)) << ") -> {" << std::endl;
 
 	DOMNode* child;
 	if (TAGNAME(ifNode) == "if") {
diff --git a/src/uscxml/transform/ChartToVHDL.cpp b/src/uscxml/transform/ChartToVHDL.cpp
index 1f25bb8..810d823 100644
--- a/src/uscxml/transform/ChartToVHDL.cpp
+++ b/src/uscxml/transform/ChartToVHDL.cpp
@@ -56,14 +56,14 @@ void ChartToVHDL::findEvents() {
 	}, _scxml);
 
 	for (auto withEvent : withEvents) {
-//            if (HAS_ATTR_CAST(withEvent, "event")) {
-//                if (ATTR_CAST(withEvent, "event") != "*")
-//                    _eventTrie.addWord(ATTR_CAST(withEvent, "event"));
+//            if (HAS_ATTR_CAST(withEvent, kXMLCharEvent)) {
+//                if (ATTR_CAST(withEvent, kXMLCharEvent) != "*")
+//                    _eventTrie.addWord(ATTR_CAST(withEvent, kXMLCharEvent));
 //            }
 		// Tokenized version below
 
-		if (HAS_ATTR_CAST(withEvent, "event")) {
-			std::string eventNames = ATTR_CAST(withEvent, "event");
+		if (HAS_ATTR_CAST(withEvent, kXMLCharEvent)) {
+			std::string eventNames = ATTR_CAST(withEvent, kXMLCharEvent);
 			std::list<std::string> events = tokenize(eventNames);
 			for (std::list<std::string>::iterator eventIter = events.begin();
 			        eventIter != events.end(); eventIter++) {
@@ -159,8 +159,8 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "    next_event_we_i :in  std_logic;" << std::endl;
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) { // create enable line if transition has conditions
-			stream << "    transition_condition_fulfilled_" << ATTR(transition, "postFixOrder") <<
+		if (HAS_ATTR(transition, kXMLCharCond)) { // create enable line if transition has conditions
+			stream << "    transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder")) <<
 			       "_i : std_logic;"
 			       << std::endl;
 		}
@@ -170,20 +170,20 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "    error_o     :out std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+		stream << "    state_active_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "    entry_set_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+			stream << "    entry_set_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "    exit_set_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+			stream << "    exit_set_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "    transition_set_" << ATTR(transition, "postFixOrder") << "_o :out std_logic;"
+			stream << "    transition_set_" << ATTR(transition, X("postFixOrder")) << "_o :out std_logic;"
 			       << std::endl;
 		}
 	}
@@ -201,23 +201,23 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "    rst_i  :in    std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder")
+		stream << "    state_active_" << ATTR(state, X("documentOrder"))
 		       << "_i :in std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "    entry_set_" << ATTR(state, "documentOrder")
+			stream << "    entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "    exit_set_" << ATTR(state, "documentOrder")
+			stream << "    exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "    transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "    transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 	}
@@ -238,15 +238,15 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "    rst_i  :in    std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder")
+		stream << "    state_active_" << ATTR(state, X("documentOrder"))
 		       << "_i :in std_logic;" << std::endl;
 	}
 
 	stream << "    --outputs" << std::endl;
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) {
-			stream << "    transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
+		if (HAS_ATTR(transition, kXMLCharCond)) {
+			stream << "    transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
 			       << "_o :out std_logic;" << std::endl;
 		}
 	}
@@ -272,30 +272,30 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 
 	stream << "  -- wiring" << std::endl;
 	for (auto state : _states) {
-		stream << "  signal state_active_" << ATTR(state, "documentOrder")
+		stream << "  signal state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig : std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "  signal entry_set_" << ATTR(state, "documentOrder")
+			stream << "  signal entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "  signal exit_set_" << ATTR(state, "documentOrder")
+			stream << "  signal exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "  signal transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "  signal transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) { // create enable line if transition has conditions
-			stream << "  signal transition_condition_fulfilled_" << ATTR(transition, "postFixOrder") <<
+		if (HAS_ATTR(transition, kXMLCharCond)) { // create enable line if transition has conditions
+			stream << "  signal transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder")) <<
 			       "_sig : std_logic;"
 			       << std::endl;
 		}
@@ -323,35 +323,35 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "      error_o  => error_o," << std::endl;
 
 	for (auto state : _states) {
-		stream << "      state_active_" << ATTR(state, "documentOrder")
-		       << "_o => state_active_" << ATTR(state, "documentOrder")
+		stream << "      state_active_" << ATTR(state, X("documentOrder"))
+		       << "_o => state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig," << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "      entry_set_" << ATTR(state, "documentOrder")
-			       << "_o => entry_set_" << ATTR(state, "documentOrder")
+			stream << "      entry_set_" << ATTR(state, X("documentOrder"))
+			       << "_o => entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "      exit_set_" << ATTR(state, "documentOrder")
-			       << "_o => exit_set_" << ATTR(state, "documentOrder")
+			stream << "      exit_set_" << ATTR(state, X("documentOrder"))
+			       << "_o => exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "      transition_set_" << ATTR(transition, "postFixOrder")
-			       << "_o => transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "      transition_set_" << ATTR(transition, X("postFixOrder"))
+			       << "_o => transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) { // create enable line if transition has conditions
-			stream << "      transition_condition_fulfilled_" << ATTR(transition, "postFixOrder") <<
-			       "_i => transition_condition_fulfilled_" << ATTR(transition, "postFixOrder") <<
+		if (HAS_ATTR(transition, kXMLCharCond)) { // create enable line if transition has conditions
+			stream << "      transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder")) <<
+			       "_i => transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder")) <<
 			       "_sig," << std::endl;
 		}
 	}
@@ -370,27 +370,27 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "      event_we_o => next_event_we_i," << std::endl;
 
 	for (auto state : _states) {
-		stream << "      state_active_" << ATTR(state, "documentOrder")
-		       << "_i => state_active_" << ATTR(state, "documentOrder")
+		stream << "      state_active_" << ATTR(state, X("documentOrder"))
+		       << "_i => state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig," << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "      entry_set_" << ATTR(state, "documentOrder")
-			       << "_i => entry_set_" << ATTR(state, "documentOrder")
+			stream << "      entry_set_" << ATTR(state, X("documentOrder"))
+			       << "_i => entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "      exit_set_" << ATTR(state, "documentOrder")
-			       << "_i => exit_set_" << ATTR(state, "documentOrder")
+			stream << "      exit_set_" << ATTR(state, X("documentOrder"))
+			       << "_i => exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "      transition_set_" << ATTR(transition, "postFixOrder")
-			       << "_i => transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "      transition_set_" << ATTR(transition, X("postFixOrder"))
+			       << "_i => transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
@@ -407,17 +407,17 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 	stream << "      rst_i  => reset," << std::endl;
 
 	for (auto state : _states) {
-		stream << "      state_active_" << ATTR(state, "documentOrder")
-		       << "_i => state_active_" << ATTR(state, "documentOrder")
+		stream << "      state_active_" << ATTR(state, X("documentOrder"))
+		       << "_i => state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig," << std::endl;
 	}
 
 	stream << "      --outputs" << std::endl;
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) {
-			stream << "      transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
-			       << "_o => transition_condition_fulfilled_" << ATTR(transition, "postFixOrder") <<
+		if (HAS_ATTR(transition, kXMLCharCond)) {
+			stream << "      transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
+			       << "_o => transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder")) <<
 			       "_sig," << std::endl;
 		}
 	}
@@ -432,8 +432,8 @@ void ChartToVHDL::writeTestbench(std::ostream &stream) {
 
 	std::string passStateNo = "";
 	for (auto final : topLevelFinal) {
-		if (ATTR(final, "id") == "pass") {
-			passStateNo = ATTR(final, "documentOrder");
+		if (ATTR(final, kXMLCharId) == "pass") {
+			passStateNo = ATTR(final, X("documentOrder"));
 		}
 	}
 
@@ -486,7 +486,7 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 	stream << "    rst  :in    std_logic;" << std::endl;
 	stream << "    --outputs" << std::endl;
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder")
+		stream << "    state_active_" << ATTR(state, X("documentOrder"))
 		       << "_o :out std_logic;" << std::endl;
 	}
 	stream << "    completed_o :out std_logic" << std::endl;
@@ -511,20 +511,20 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 	stream << "    error_o     :out std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+		stream << "    state_active_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "    entry_set_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+			stream << "    entry_set_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "    exit_set_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+			stream << "    exit_set_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "    transition_set_" << ATTR(transition, "postFixOrder") << "_o :out std_logic;"
+			stream << "    transition_set_" << ATTR(transition, X("postFixOrder")) << "_o :out std_logic;"
 			       << std::endl;
 		}
 	}
@@ -541,23 +541,23 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 	stream << "    rst_i  :in    std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder")
+		stream << "    state_active_" << ATTR(state, X("documentOrder"))
 		       << "_i :in std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "    entry_set_" << ATTR(state, "documentOrder")
+			stream << "    entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "    exit_set_" << ATTR(state, "documentOrder")
+			stream << "    exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "    transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "    transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 	}
@@ -583,23 +583,23 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 
 	stream << "  -- wiring" << std::endl;
 	for (auto state : _states) {
-		stream << "  signal state_active_" << ATTR(state, "documentOrder")
+		stream << "  signal state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig : std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "  signal entry_set_" << ATTR(state, "documentOrder")
+			stream << "  signal entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "  signal exit_set_" << ATTR(state, "documentOrder")
+			stream << "  signal exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "  signal transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "  signal transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 	}
@@ -610,8 +610,8 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 	stream << std::endl;
 
 	for (auto state : _states) {
-		stream << "state_active_" << ATTR(state, "documentOrder")
-		       << "_o <= state_active_" << ATTR(state, "documentOrder")
+		stream << "state_active_" << ATTR(state, X("documentOrder"))
+		       << "_o <= state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig;" << std::endl;
 	}
 	stream << std::endl;
@@ -629,27 +629,27 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 	stream << "      error_o  => error_o," << std::endl;
 
 	for (auto state : _states) {
-		stream << "      state_active_" << ATTR(state, "documentOrder")
-		       << "_o => state_active_" << ATTR(state, "documentOrder")
+		stream << "      state_active_" << ATTR(state, X("documentOrder"))
+		       << "_o => state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig," << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "      entry_set_" << ATTR(state, "documentOrder")
-			       << "_o => entry_set_" << ATTR(state, "documentOrder")
+			stream << "      entry_set_" << ATTR(state, X("documentOrder"))
+			       << "_o => entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "      exit_set_" << ATTR(state, "documentOrder")
-			       << "_o => exit_set_" << ATTR(state, "documentOrder")
+			stream << "      exit_set_" << ATTR(state, X("documentOrder"))
+			       << "_o => exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "      transition_set_" << ATTR(transition, "postFixOrder")
-			       << "_o => transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "      transition_set_" << ATTR(transition, X("postFixOrder"))
+			       << "_o => transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
@@ -668,27 +668,27 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 	stream << "      event_we_o => next_event_we_i," << std::endl;
 
 	for (auto state : _states) {
-		stream << "      state_active_" << ATTR(state, "documentOrder")
-		       << "_i => state_active_" << ATTR(state, "documentOrder")
+		stream << "      state_active_" << ATTR(state, X("documentOrder"))
+		       << "_i => state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig," << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "      entry_set_" << ATTR(state, "documentOrder")
-			       << "_i => entry_set_" << ATTR(state, "documentOrder")
+			stream << "      entry_set_" << ATTR(state, X("documentOrder"))
+			       << "_i => entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "      exit_set_" << ATTR(state, "documentOrder")
-			       << "_i => exit_set_" << ATTR(state, "documentOrder")
+			stream << "      exit_set_" << ATTR(state, X("documentOrder"))
+			       << "_i => exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "      transition_set_" << ATTR(transition, "postFixOrder")
-			       << "_i => transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "      transition_set_" << ATTR(transition, X("postFixOrder"))
+			       << "_i => transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig," << std::endl;
 		}
 	}
@@ -704,8 +704,8 @@ void ChartToVHDL::writeTopLevel(std::ostream &stream) {
 
 	std::string passStateNo = "";
 	for (auto final : topLevelFinal) {
-		if (ATTR(final, "id") == "pass") {
-			passStateNo = ATTR(final, "documentOrder");
+		if (ATTR(final, kXMLCharId) == "pass") {
+			passStateNo = ATTR(final, X("documentOrder"));
 		}
 	}
 	stream << "end architecture;" << std::endl;
@@ -724,23 +724,23 @@ void ChartToVHDL::writeEventController(std::ostream &stream) {
 	stream << "    rst_i  :in    std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder")
+		stream << "    state_active_" << ATTR(state, X("documentOrder"))
 		       << "_i :in std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "    entry_set_" << ATTR(state, "documentOrder")
+			stream << "    entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "    exit_set_" << ATTR(state, "documentOrder")
+			stream << "    exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "    transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "    transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_i :in std_logic;" << std::endl;
 		}
 	}
@@ -814,18 +814,18 @@ void ChartToVHDL::writeEventController(std::ostream &stream) {
 		for (auto state : _states) {
 
 			if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-				stream << std::endl << "      or entry_set_" << ATTR(state, "documentOrder")
+				stream << std::endl << "      or entry_set_" << ATTR(state, X("documentOrder"))
 				       << "_i";
 			}
 
 			if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-				stream << std::endl << "      or exit_set_" << ATTR(state, "documentOrder")
+				stream << std::endl << "      or exit_set_" << ATTR(state, X("documentOrder"))
 				       << "_i";
 			}
 		}
 		for (auto transition : _transitions) {
 			if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-				stream << std::endl << "      or transition_set_" << ATTR(transition, "postFixOrder")
+				stream << std::endl << "      or transition_set_" << ATTR(transition, X("postFixOrder"))
 				       << "_i";
 			}
 		}
@@ -866,7 +866,7 @@ void ChartToVHDL::writeEventController(std::ostream &stream) {
 
 				size_t jj = 0;
 				for (auto eventIter = _eventNames.begin(); eventIter != _eventNames.end(); eventIter++, jj++) {
-					if (((*eventIter)->value) == ATTR(exContentElem, "event")) {
+					if (((*eventIter)->value) == ATTR(exContentElem, kXMLCharEvent)) {
 						break;
 					}
 				}
@@ -954,15 +954,15 @@ void ChartToVHDL::writeConditionSolver(std::ostream &stream) {
 	stream << "    rst_i  :in    std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder")
+		stream << "    state_active_" << ATTR(state, X("documentOrder"))
 		       << "_i :in std_logic;" << std::endl;
 	}
 
 	stream << "    --outputs" << std::endl;
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) {
-			stream << "    transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
+		if (HAS_ATTR(transition, kXMLCharCond)) {
+			stream << "    transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
 			       << "_o :out std_logic;" << std::endl;
 		}
 	}
@@ -986,8 +986,8 @@ void ChartToVHDL::writeConditionSolver(std::ostream &stream) {
 	}
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) {
-			stream << "signal transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
+		if (HAS_ATTR(transition, kXMLCharCond)) {
+			stream << "signal transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig : std_logic;" << std::endl;
 		}
 	}
@@ -1002,9 +1002,9 @@ void ChartToVHDL::writeConditionSolver(std::ostream &stream) {
 	stream << std::endl;
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) {
-			stream << "transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
-			       << "_o <= transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
+		if (HAS_ATTR(transition, kXMLCharCond)) {
+			stream << "transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
+			       << "_o <= transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig;" << std::endl;
 		}
 	}
@@ -1017,10 +1017,10 @@ void ChartToVHDL::writeConditionSolver(std::ostream &stream) {
 	// solve conditions
 	stream << "-- solve conditions" << std::endl;
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) {
-			stream << "-- cond:"<< ATTR(transition, "cond") << std::endl;
+		if (HAS_ATTR(transition, kXMLCharCond)) {
+			stream << "-- cond:"<< ATTR(transition, kXMLCharCond) << std::endl;
 			// TODO parse code here and generate hardware from AST
-			stream << "transition_condition_fulfilled_" << ATTR(transition, "postFixOrder")
+			stream << "transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig <= '0';" << std::endl;
 		}
 	}
@@ -1041,15 +1041,15 @@ std::string ChartToVHDL::getLineForExecContent(const DOMNode *elem) {
 		if (ecBlock->getNodeType() == DOMNode::ELEMENT_NODE) {
 			std::string localName = LOCALNAME_CAST(ecBlock);
 			if (localName == XML_PREFIX(_scxml).str() + "transition") {
-				return "transition_set_" + ATTR_CAST(ecBlock, "postFixOrder") + "_i";
+				return "transition_set_" + ATTR_CAST(ecBlock, X("postFixOrder")) + "_i";
 			}
 
 			if (localName == XML_PREFIX(_scxml).str() + "onentry") {
-				return "entry_set_" + ATTR_CAST(ecBlock->getParentNode(), "documentOrder") + "_i";
+				return "entry_set_" + ATTR_CAST(ecBlock->getParentNode(), X("documentOrder")) + "_i";
 			}
 
 			if (localName == XML_PREFIX(_scxml).str() + "onexit") {
-				return "exit_set_" + ATTR_CAST(ecBlock->getParentNode(), "documentOrder") + "_i";
+				return "exit_set_" + ATTR_CAST(ecBlock->getParentNode(), X("documentOrder")) + "_i";
 			}
 
 		}
@@ -1073,8 +1073,8 @@ void ChartToVHDL::writeMicroStepper(std::ostream &stream) {
 	stream << "    next_event_we_i :in  std_logic;" << std::endl;
 
 	for (auto transition : _transitions) {
-		if (HAS_ATTR(transition, "cond")) { // create enable line if transition has conditions
-			stream << "signal transition_condition_fulfilled_" << ATTR(transition, "postFixOrder") <<
+		if (HAS_ATTR(transition, kXMLCharCond)) { // create enable line if transition has conditions
+			stream << "signal transition_condition_fulfilled_" << ATTR(transition, X("postFixOrder")) <<
 			       "_i : std_logic;"
 			       << std::endl;
 		}
@@ -1084,20 +1084,20 @@ void ChartToVHDL::writeMicroStepper(std::ostream &stream) {
 	stream << "    error_o     :out std_logic;" << std::endl;
 
 	for (auto state : _states) {
-		stream << "    state_active_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+		stream << "    state_active_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "    entry_set_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+			stream << "    entry_set_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "    exit_set_" << ATTR(state, "documentOrder") << "_o :out std_logic;" << std::endl;
+			stream << "    exit_set_" << ATTR(state, X("documentOrder")) << "_o :out std_logic;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "    transition_set_" << ATTR(transition, "postFixOrder") << "_o :out std_logic;"
+			stream << "    transition_set_" << ATTR(transition, X("postFixOrder")) << "_o :out std_logic;"
 			       << std::endl;
 		}
 	}
@@ -1254,18 +1254,18 @@ void ChartToVHDL::writeSignalsAndComponents(std::ostream &stream) {
 	std::list<std::string> signalDecls;
 
 	for (auto state : _states) {
-		std::string parent = ATTR(state, "parent");
+		std::string parent = ATTR(state, X("parent"));
 
-		signalDecls.push_back("signal state_active_" + ATTR(state, "documentOrder") + "_sig : std_logic;");
-		signalDecls.push_back("signal state_next_" + ATTR(state, "documentOrder") + "_sig : std_logic;");
-		signalDecls.push_back("signal in_entry_set_" + ATTR(state, "documentOrder") + "_sig : std_logic;");
-		signalDecls.push_back("signal in_exit_set_" + ATTR(state, "documentOrder") + "_sig : std_logic;");
-		signalDecls.push_back("signal in_complete_entry_set_" + ATTR(state, "documentOrder") + "_sig : std_logic;");
+		signalDecls.push_back("signal state_active_" + ATTR(state, X("documentOrder")) + "_sig : std_logic;");
+		signalDecls.push_back("signal state_next_" + ATTR(state, X("documentOrder")) + "_sig : std_logic;");
+		signalDecls.push_back("signal in_entry_set_" + ATTR(state, X("documentOrder")) + "_sig : std_logic;");
+		signalDecls.push_back("signal in_exit_set_" + ATTR(state, X("documentOrder")) + "_sig : std_logic;");
+		signalDecls.push_back("signal in_complete_entry_set_" + ATTR(state, X("documentOrder")) + "_sig : std_logic;");
 
 		// not needed for <scxml> state
 		if (parent.size() != 0) {
 			signalDecls.push_back(
-			    "signal in_complete_entry_set_up_" + ATTR(state, "documentOrder") + "_sig : std_logic;");
+			    "signal in_complete_entry_set_up_" + ATTR(state, X("documentOrder")) + "_sig : std_logic;");
 		}
 	}
 
@@ -1282,7 +1282,7 @@ void ChartToVHDL::writeSignalsAndComponents(std::ostream &stream) {
 	stream << "signal optimal_transition_set_combined_sig : std_logic;" << std::endl;
 
 	for (auto transition : _transitions) {
-		stream << "signal in_optimal_transition_set_" << ATTR(transition, "postFixOrder") << "_sig : std_logic;"
+		stream << "signal in_optimal_transition_set_" << ATTR(transition, X("postFixOrder")) << "_sig : std_logic;"
 		       << std::endl;
 	}
 	stream << std::endl;
@@ -1405,9 +1405,9 @@ void ChartToVHDL::writeInternalEventHandler(std::ostream &stream) {
 	VContainer eventConsumed = VOR;
 	for (auto transition : _transitions) {
 
-		if (HAS_ATTR(transition, "event") == true) {
+		if (HAS_ATTR(transition, kXMLCharEvent) == true) {
 			*eventConsumed += VLINE("in_optimal_transition_set_"
-			                        + ATTR(transition, "postFixOrder") + "_sig");
+			                        + ATTR(transition, X("postFixOrder")) + "_sig");
 		}
 	}
 
@@ -1467,21 +1467,21 @@ void ChartToVHDL::writeActiveStateNplusOne(std::ostream &stream) {
 	stream << "-- active configuration" << std::endl;
 
 	for (auto state : _states) {
-		std::string parent = ATTR(state, "parent");
+		std::string parent = ATTR(state, X("parent"));
 
 		// special case for <scxml> to start the state machine
 		if (parent.size() == 0) {
-			stream << "        state_next_" << ATTR(state, "documentOrder") << "_sig <= " <<
+			stream << "        state_next_" << ATTR(state, X("documentOrder")) << "_sig <= " <<
 			       "not completed_sig;" << std::endl;
 			continue;
 		}
 
 		VBranch *tree = (VASSIGN,
-		                 VLINE("state_next_" + ATTR(state, "documentOrder") + "_sig"),
+		                 VLINE("state_next_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                 (VOR,
-		                  VLINE("in_complete_entry_set_" + ATTR(state, "documentOrder") + "_sig"),
-		                  (VAND, (VNOT, VLINE("in_exit_set_" + ATTR(state, "documentOrder") + "_sig")),
-		                   VLINE("state_active_" + ATTR(state, "documentOrder") + "_sig"))
+		                  VLINE("in_complete_entry_set_" + ATTR(state, X("documentOrder")) + "_sig"),
+		                  (VAND, (VNOT, VLINE("in_exit_set_" + ATTR(state, X("documentOrder")) + "_sig")),
+		                   VLINE("state_active_" + ATTR(state, X("documentOrder")) + "_sig"))
 		                 ));
 
 		tree->print(stream);
@@ -1497,12 +1497,12 @@ void ChartToVHDL::writeOptimalTransitionSetSelection(std::ostream &stream) {
 
 	for (auto transIter = _transitions.begin(); transIter != _transitions.end(); transIter++) {
 		DOMElement *transition = *transIter;
-		std::string conflicts = ATTR(transition, "conflictBools");
+		std::string conflicts = ATTR(transition, X("conflictBools"));
 
 
 		VContainer nameMatchers = VOR;
-		if (HAS_ATTR(transition, "event")) {
-			std::list<std::string> eventDescs = tokenize(ATTR(transition, "event"));
+		if (HAS_ATTR(transition, kXMLCharEvent)) {
+			std::list<std::string> eventDescs = tokenize(ATTR(transition, kXMLCharEvent));
 			for (std::list<std::string>::iterator descIter = eventDescs.begin();
 			        descIter != eventDescs.end(); descIter++) {
 				std::list<TrieNode *> eventNames = _eventTrie.getWordsWithPrefix(
@@ -1517,26 +1517,26 @@ void ChartToVHDL::writeOptimalTransitionSetSelection(std::ostream &stream) {
 		}
 
 		VContainer conflicters = VOR;
-		for (size_t j = 0; j < strTo<size_t>(ATTR(transition, "postFixOrder")); j++) {
+		for (size_t j = 0; j < strTo<size_t>(ATTR(transition, X("postFixOrder"))); j++) {
 			if (conflicts[j] == '1') {
 				*conflicters += VLINE("in_optimal_transition_set_" + toStr(j) + "_sig");
 			}
 		}
 
 		VBranch *tree = (VASSIGN,
-		                 VLINE("in_optimal_transition_set_" + ATTR(transition, "postFixOrder") + "_sig"),
+		                 VLINE("in_optimal_transition_set_" + ATTR(transition, X("postFixOrder")) + "_sig"),
 		                 (VAND,
-		                  (HAS_ATTR(transition, "event")
+		                  (HAS_ATTR(transition, kXMLCharEvent)
 		                   ? (VNOT, VLINE("spontaneous_active"))
 		                   : (VNOP, VLINE("spontaneous_en"))),
 
-		                  HAS_ATTR(transition, "cond")
+		                  HAS_ATTR(transition, kXMLCharCond)
 		                  ? (VNOP,
-		                     VLINE("transition_condition_fulfilled_" + ATTR(transition, "postFixOrder") +
+		                     VLINE("transition_condition_fulfilled_" + ATTR(transition, X("postFixOrder")) +
 		                           "_i"))
 		                  : (VNOP, VLINE("'1'")),
 
-		                  VLINE("state_active_" + ATTR(transition, "source") + "_sig"),
+		                  VLINE("state_active_" + ATTR(transition, kXMLCharSource) + "_sig"),
 		                  nameMatchers,
 		                  (VNOT, conflicters)));
 
@@ -1544,10 +1544,10 @@ void ChartToVHDL::writeOptimalTransitionSetSelection(std::ostream &stream) {
 		stream << ";" << std::endl;
 
 		*optimalTransitions += VLINE("in_optimal_transition_set_"
-		                             + ATTR(transition, "postFixOrder") + "_sig");
-		if (HAS_ATTR(transition, "event") == false) {
+		                             + ATTR(transition, X("postFixOrder")) + "_sig");
+		if (HAS_ATTR(transition, kXMLCharEvent) == false) {
 			*spontaneoursActive += VLINE("in_optimal_transition_set_"
-			                             + ATTR(transition, "postFixOrder") + "_sig");
+			                             + ATTR(transition, X("postFixOrder")) + "_sig");
 		}
 	}
 
@@ -1570,23 +1570,23 @@ void ChartToVHDL::writeExitSet(std::ostream &stream) {
 
 	for (auto state : _states) {
 
-		std::string completion = ATTR(state, "completionBools");
-		std::string ancestors = ATTR(state, "ancBools");
-		std::string children = ATTR(state, "childBools");
-		std::string parent = ATTR(state, "parent");
+		std::string completion = ATTR(state, X("completionBools"));
+		std::string ancestors = ATTR(state, X("ancBools"));
+		std::string children = ATTR(state, X("childBools"));
+		std::string parent = ATTR(state, X("parent"));
 
 		VContainer exitsetters = VOR;
 		for (auto transition : _transitions) {
-			std::string exitSet = ATTR(transition, "exitSetBools");
-			if (exitSet.at(strTo<size_t>(ATTR(state, "documentOrder"))) == '1') {
-				*exitsetters += VLINE("in_optimal_transition_set_" + ATTR(transition, "postFixOrder") + "_sig ");
+			std::string exitSet = ATTR(transition, X("exitSetBools"));
+			if (exitSet.at(strTo<size_t>(ATTR(state, X("documentOrder")))) == '1') {
+				*exitsetters += VLINE("in_optimal_transition_set_" + ATTR(transition, X("postFixOrder")) + "_sig ");
 			}
 		}
 
 		VBranch *tree = (VASSIGN,
-		                 VLINE("in_exit_set_" + ATTR(state, "documentOrder") + "_sig"),
+		                 VLINE("in_exit_set_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                 (VAND,
-		                  VLINE("state_active_" + ATTR(state, "documentOrder") + "_sig"),
+		                  VLINE("state_active_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                  exitsetters));
 
 		tree->print(stream);
@@ -1600,11 +1600,11 @@ void ChartToVHDL::writeEntrySet(std::ostream &stream) {
 	for (auto state : _states) {
 
 		VBranch *tree = (VASSIGN,
-		                 VLINE("in_entry_set_" + ATTR(state, "documentOrder") + "_sig"),
+		                 VLINE("in_entry_set_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                 (VAND,
-		                  VLINE("in_complete_entry_set_" + ATTR(state, "documentOrder") + "_sig"),
-		                  (VOR, VLINE("in_exit_set_" + ATTR(state, "documentOrder") + "_sig"),
-		                   (VNOT, VLINE("state_active_" + ATTR(state, "documentOrder") + "_sig")))));
+		                  VLINE("in_complete_entry_set_" + ATTR(state, X("documentOrder")) + "_sig"),
+		                  (VOR, VLINE("in_exit_set_" + ATTR(state, X("documentOrder")) + "_sig"),
+		                   (VNOT, VLINE("state_active_" + ATTR(state, X("documentOrder")) + "_sig")))));
 
 		tree->print(stream);
 		stream << ";" << std::endl;
@@ -1615,10 +1615,10 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 	stream << "-- complete entry set selection" << std::endl;
 
 	for (auto state : _states) {
-		std::string completion = ATTR(state, "completionBools");
-		std::string ancestors = ATTR(state, "ancBools");
-		std::string children = ATTR(state, "childBools");
-		std::string parent = ATTR(state, "parent");
+		std::string completion = ATTR(state, X("completionBools"));
+		std::string ancestors = ATTR(state, X("ancBools"));
+		std::string children = ATTR(state, X("childBools"));
+		std::string parent = ATTR(state, X("parent"));
 
 		if (parent.size() == 0) {
 			continue; // skips <scxml> node
@@ -1629,11 +1629,11 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 		VContainer optimalEntrysetters = VOR;
 		for (auto transition : _transitions) {
 			// Is this state in TargetSet of the transition?
-			std::string targetSet = ATTR(transition, "targetBools");
-			if (targetSet[strTo<size_t>(ATTR(state, "documentOrder"))] == '1') {
+			std::string targetSet = ATTR(transition, X("targetBools"));
+			if (targetSet[strTo<size_t>(ATTR(state, X("documentOrder")))] == '1') {
 				//yes? then add the transition to optimal entry set of the state
 				*optimalEntrysetters +=
-				    VLINE("in_optimal_transition_set_" + ATTR(transition, "postFixOrder") + "_sig");
+				    VLINE("in_optimal_transition_set_" + ATTR(transition, X("postFixOrder")) + "_sig");
 			}
 		}
 
@@ -1642,16 +1642,16 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 		if (isCompound(state) || isParallel(state)) {
 			for (auto tmp_state : _states) {
 				// is tmp_state is child of state continue?
-				if (children[strTo<size_t>(ATTR(state, "documentOrder"))] == '1') {
+				if (children[strTo<size_t>(ATTR(state, X("documentOrder")))] == '1') {
 					// yes? then add its complete_entry_set_up as ancestor completion
 					*completeEntrysetters +=
-					    VLINE("in_complete_entry_set_up_" + ATTR(tmp_state, "documentOrder") + "_sig");
+					    VLINE("in_complete_entry_set_up_" + ATTR(tmp_state, X("documentOrder")) + "_sig");
 				}
 			}
 		}
 
 		VBranch *tree = (VASSIGN,
-		                 VLINE("in_complete_entry_set_up_" + ATTR(state, "documentOrder") + "_sig"),
+		                 VLINE("in_complete_entry_set_up_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                 (VOR, optimalEntrysetters, completeEntrysetters)
 		                );
 		tree->print(stream);
@@ -1661,9 +1661,9 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 
 	// descendant completion
 	for (auto state : _states) {
-		std::string completion = ATTR(state, "completionBools");
-		std::string ancestors = ATTR(state, "ancBools");
-		std::string parent = ATTR(state, "parent"); //is it a int ?
+		std::string completion = ATTR(state, X("completionBools"));
+		std::string ancestors = ATTR(state, X("ancBools"));
+		std::string parent = ATTR(state, X("parent")); //is it a int ?
 
 		if (parent.size() == 0) {
 			continue; // skips <scxml> node
@@ -1674,18 +1674,18 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 		if (getParentState(state) != NULL &&
 		        isCompound(getParentState(state))) {
 			std::string children = ATTR_CAST(_states[strTo<size_t>(parent)],
-			                                 "childBools");
+			                                 X("childBools"));
 
-			std::string parentInit = ATTR(getParentState(state), "initial");
+			std::string parentInit = ATTR(getParentState(state), kXMLCharInitial);
 			if (// if parent has init field an this state is inside --> add it as default completion
 			    (!parentInit.empty()
-			     && ATTR(state, "id").compare(parentInit) == 0) ||
+			     && ATTR(state, kXMLCharId).compare(parentInit) == 0) ||
 			    // or add this state as default completion when parent has no init field and it is the first in document order
 			    (parentInit.empty() &&
-			     (strTo<size_t>(ATTR(getParentState(state), "documentOrder")) + 1) ==
-			     strTo<size_t>(ATTR(state, "documentOrder")))) {
+			     (strTo<size_t>(ATTR(getParentState(state), X("documentOrder"))) + 1) ==
+			     strTo<size_t>(ATTR(state, X("documentOrder"))))) {
 				*descendantCompletion +=
-				    VLINE("in_entry_set_" + ATTR(getParentState(state), "documentOrder") + "_sig");
+				    VLINE("in_entry_set_" + ATTR(getParentState(state), X("documentOrder")) + "_sig");
 
 				// but only if compound parent is not already completed
 				for (auto tmp_state : _states) {
@@ -1693,12 +1693,12 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 						// skip state itselve
 						continue;
 					}
-					if (children[strTo<size_t>(ATTR(tmp_state, "documentOrder"))] == '1') {
+					if (children[strTo<size_t>(ATTR(tmp_state, X("documentOrder")))] == '1') {
 						*descendantCompletion += (VNOT,
 						                          (VAND,
-						                           VLINE("state_active_" + ATTR(tmp_state, "documentOrder") + "_sig"),
+						                           VLINE("state_active_" + ATTR(tmp_state, X("documentOrder")) + "_sig"),
 						                           (VNOT,
-						                            VLINE("in_exit_set_" + ATTR(tmp_state, "documentOrder") +
+						                            VLINE("in_exit_set_" + ATTR(tmp_state, X("documentOrder")) +
 						                                  "_sig"))));
 					}
 				}
@@ -1711,13 +1711,13 @@ void ChartToVHDL::writeCompleteEntrySet(std::ostream &stream) {
 			if (getParentState(state) != NULL &&
 			        isParallel(getParentState(state))) {
 				*descendantCompletion +=
-				    VLINE("in_complete_entry_set_" + ATTR(getParentState(state), "documentOrder") + "_sig");
+				    VLINE("in_complete_entry_set_" + ATTR(getParentState(state), X("documentOrder")) + "_sig");
 			}
 
 		VBranch *tree = (VASSIGN,
-		                 VLINE("in_complete_entry_set_" + ATTR(state, "documentOrder") + "_sig"),
+		                 VLINE("in_complete_entry_set_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                 (VOR,
-		                  VLINE("in_complete_entry_set_up_" + ATTR(state, "documentOrder") + "_sig"),
+		                  VLINE("in_complete_entry_set_up_" + ATTR(state, X("documentOrder")) + "_sig"),
 		                  descendantCompletion));
 
 		tree->print(stream);
@@ -1734,7 +1734,7 @@ void ChartToVHDL::writeStateHandler(std::ostream &stream) {
 	stream << "    if rst = '1' then" << std::endl;
 
 	for (auto state : _states) {
-		stream << "        state_active_" << ATTR(state, "documentOrder") << "_sig <= " << "'0';" << std::endl;
+		stream << "        state_active_" << ATTR(state, X("documentOrder")) << "_sig <= " << "'0';" << std::endl;
 	}
 
 	stream << "        in_complete_entry_set_0_sig <= '1';" << std::endl;
@@ -1742,8 +1742,8 @@ void ChartToVHDL::writeStateHandler(std::ostream &stream) {
 	stream << "        in_complete_entry_set_0_sig <= '0';" << std::endl;
 
 	for (auto state : _states) {
-		stream << "        state_active_" << ATTR(state, "documentOrder") << "_sig <= " << "state_next_" <<
-		       ATTR(state, "documentOrder") << "_sig;" << std::endl;
+		stream << "        state_active_" << ATTR(state, X("documentOrder")) << "_sig <= " << "state_next_" <<
+		       ATTR(state, X("documentOrder")) << "_sig;" << std::endl;
 	}
 
 	stream << "    end if;" << std::endl;
@@ -1758,7 +1758,7 @@ void ChartToVHDL::writeSystemSignalMapping(std::ostream &stream) {
 
 	VContainer tlf = VOR;
 	for (auto final : topLevelFinal) {
-		*tlf += VLINE("state_active_" + ATTR(final, "documentOrder") + "_sig");
+		*tlf += VLINE("state_active_" + ATTR(final, X("documentOrder")) + "_sig");
 
 	}
 
@@ -1785,26 +1785,26 @@ void ChartToVHDL::writeSystemSignalMapping(std::ostream &stream) {
 	// interface signals
 	stream << "-- interface signals" << std::endl;
 	for (auto state : _states) {
-		stream << "state_active_" << ATTR(state, "documentOrder")
-		       << "_o <= state_active_" << ATTR(state, "documentOrder")
+		stream << "state_active_" << ATTR(state, X("documentOrder"))
+		       << "_o <= state_active_" << ATTR(state, X("documentOrder"))
 		       << "_sig;" << std::endl;
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onexit", state).size() > 0) {
-			stream << "exit_set_" << ATTR(state, "documentOrder")
-			       << "_o <= in_exit_set_" << ATTR(state, "documentOrder")
+			stream << "exit_set_" << ATTR(state, X("documentOrder"))
+			       << "_o <= in_exit_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig;" << std::endl;
 		}
 
 		if (DOMUtils::filterChildElements(XML_PREFIX(_scxml).str() + "onentry", state).size() > 0) {
-			stream << "entry_set_" << ATTR(state, "documentOrder")
-			       << "_o <= in_entry_set_" << ATTR(state, "documentOrder")
+			stream << "entry_set_" << ATTR(state, X("documentOrder"))
+			       << "_o <= in_entry_set_" << ATTR(state, X("documentOrder"))
 			       << "_sig;" << std::endl;
 		}
 	}
 
 	for (auto transition : _transitions) {
 		if (DOMUtils::filterChildType(DOMNode::ELEMENT_NODE, transition).size() > 0) {
-			stream << "transition_set_" << ATTR(transition, "postFixOrder")
-			       << "_o <= in_optimal_transition_set_" << ATTR(transition, "postFixOrder")
+			stream << "transition_set_" << ATTR(transition, X("postFixOrder"))
+			       << "_o <= in_optimal_transition_set_" << ATTR(transition, X("postFixOrder"))
 			       << "_sig;" << std::endl;
 		}
 	}
diff --git a/src/uscxml/transform/promela/PromelaCodeAnalyzer.cpp b/src/uscxml/transform/promela/PromelaCodeAnalyzer.cpp
index 044e660..f8af351 100644
--- a/src/uscxml/transform/promela/PromelaCodeAnalyzer.cpp
+++ b/src/uscxml/transform/promela/PromelaCodeAnalyzer.cpp
@@ -40,8 +40,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 	{
 		for (size_t i = 0; i < interpreter->_states.size(); i++) {
 			DOMElement* state = interpreter->_states[i];
-			if (HAS_ATTR(state, "id")) {
-				createMacroName(ATTR(state, "id"));
+			if (HAS_ATTR(state, kXMLCharId)) {
+				createMacroName(ATTR(state, kXMLCharId));
 			}
 		}
 	}
@@ -56,8 +56,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		}, interpreter->_scxml);
 
 		for (auto internalEventName : internalEventNames) {
-			if (HAS_ATTR_CAST(internalEventName, "event")) {
-				std::string eventNames = ATTR_CAST(internalEventName, "event");
+			if (HAS_ATTR_CAST(internalEventName, kXMLCharEvent)) {
+				std::string eventNames = ATTR_CAST(internalEventName, kXMLCharEvent);
 				std::list<std::string> events = tokenize(eventNames);
 				for (std::list<std::string>::iterator eventIter = events.begin();
 				        eventIter != events.end(); eventIter++) {
@@ -73,8 +73,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		}
 
 		for (auto state : interpreter->_states) {
-			if (HAS_ATTR(state, "id") && (isCompound(state) || isParallel(state))) {
-				addEvent("done.state." + ATTR(state, "id"));
+			if (HAS_ATTR(state, kXMLCharId) && (isCompound(state) || isParallel(state))) {
+				addEvent("done.state." + ATTR(state, kXMLCharId));
 			}
 		}
 
@@ -82,8 +82,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		for (auto invoker : invokers) {
 			addCode("_event.invokeid", interpreter);
 
-			if (HAS_ATTR(invoker, "id")) {
-				addEvent("done.state." + ATTR(invoker, "id"));
+			if (HAS_ATTR(invoker, kXMLCharId)) {
+				addEvent("done.state." + ATTR(invoker, kXMLCharId));
 			}
 		}
 	}
@@ -126,8 +126,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		}, interpreter->_scxml);
 
 		for (auto cond : withCond) {
-			if (HAS_ATTR(cond, "cond")) {
-				std::string code = ATTR_CAST(cond, "cond");
+			if (HAS_ATTR(cond, kXMLCharCond)) {
+				std::string code = ATTR_CAST(cond, kXMLCharCond);
 				code = sanitizeCode(code);
 				addCode(code, interpreter);
 				cond->setAttribute(X("cond"), X(code));
@@ -143,8 +143,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		}, interpreter->_scxml);
 
 		for (auto expr : withExpr) {
-			if (HAS_ATTR(expr, "expr")) {
-				std::string code = ATTR_CAST(expr, "expr");
+			if (HAS_ATTR(expr, kXMLCharExpr)) {
+				std::string code = ATTR_CAST(expr, kXMLCharExpr);
 				code = sanitizeCode(code);
 				addCode(code, interpreter);
 				expr->setAttribute(X("expr"), X(code));
@@ -156,8 +156,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		}, interpreter->_scxml);
 
 		for (auto location : withLocation) {
-			if (HAS_ATTR(location, "location")) {
-				std::string code = ATTR_CAST(location, "location");
+			if (HAS_ATTR(location, kXMLCharLocation)) {
+				std::string code = ATTR_CAST(location, kXMLCharLocation);
 				code = sanitizeCode(code);
 				addCode(code, interpreter);
 				location->setAttribute(X("location"), X(code));
@@ -186,13 +186,13 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 		}, interpreter->_scxml);
 
 		for (auto foreach : foreachs) {
-				if (HAS_ATTR(foreach, "index")) {
-					addCode(ATTR(foreach, "index"), interpreter);
+				if (HAS_ATTR(foreach, kXMLCharIndex)) {
+					addCode(ATTR(foreach, kXMLCharIndex), interpreter);
 				} else {
 					_hasIndexLessLoops = true;
 				}
-				if (HAS_ATTR(foreach, "item")) {
-					addCode(ATTR(foreach, "item"), interpreter);
+				if (HAS_ATTR(foreach, kXMLCharItem)) {
+					addCode(ATTR(foreach, kXMLCharItem), interpreter);
 				}
 			}
 
@@ -208,17 +208,17 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 			}
 
 			for (auto send : sends) {
-				if (HAS_ATTR(send, "idlocation")) {
+				if (HAS_ATTR(send, kXMLCharIdLocation)) {
 					addCode("_event.sendid", interpreter);
 				}
-				if (HAS_ATTR(send, "id")) {
-					addLiteral(ATTR(send, "id"));
+				if (HAS_ATTR(send, kXMLCharId)) {
+					addLiteral(ATTR(send, kXMLCharId));
 					addCode("_event.sendid", interpreter);
 				}
 
 				// do we need delays?
-				if (HAS_ATTR(send, "delay") || HAS_ATTR(send, "delayexpr")) {
-					size_t delay = strTo<size_t>(ATTR(send, "delay"));
+				if (HAS_ATTR(send, kXMLCharDelay) || HAS_ATTR(send, kXMLCharDelayExpr)) {
+					size_t delay = strTo<size_t>(ATTR(send, kXMLCharDelay));
 					if (delay > largestDelay)
 						largestDelay = delay;
 					addCode("_event.delay", interpreter);
@@ -236,8 +236,8 @@ void PromelaCodeAnalyzer::analyze(ChartToPromela* interpreter) {
 			withNamelists.splice(withNamelists.end(), DOMUtils::inDocumentOrder({XML_PREFIX(interpreter->_scxml).str() + "send"}, interpreter->_scxml));
 			withNamelists.splice(withNamelists.end(), DOMUtils::inDocumentOrder({XML_PREFIX(interpreter->_scxml).str() + "invoke"}, interpreter->_scxml));
 			for (auto withNamelist : withNamelists) {
-				if (HAS_ATTR(withNamelist, "namelist")) {
-					std::string namelist = ATTR(withNamelist, "namelist");
+				if (HAS_ATTR(withNamelist, kXMLCharNameList)) {
+					std::string namelist = ATTR(withNamelist, kXMLCharNameList);
 					std::list<std::string> names = tokenize(namelist);
 					for (std::list<std::string>::iterator nameIter = names.begin(); nameIter != names.end(); nameIter++) {
 						addCode("_event.data." + *nameIter + " = 0;", interpreter); // introduce for _event_t typedef