Worked on passing even more IRP tests

34 files changed, 338 insertions, 298 deletions

diff --git a/src/bindings/swig/wrapped/WrappedDataModel.h b/src/bindings/swig/wrapped/WrappedDataModel.h
index 1fefcbe..de0c4a9 100644
--- a/src/bindings/swig/wrapped/WrappedDataModel.h
+++ b/src/bindings/swig/wrapped/WrappedDataModel.h
@@ -82,16 +82,16 @@ public:
 		return true;
 	}
 
-	virtual void assign(const std::string& location, const Data& data) {}
-	virtual void init(const std::string& location, const Data& data) {}
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr) {}
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr) {}
 
 	virtual void addExtension(DataModelExtension* ext) {
 	}
 
-	virtual std::string andExpressions(std::list<std::string>) {
-		return "";
-	}
-
 protected:
 	DataModelCallbacks* callbacks;
 };
diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.cpp b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
index 6c96840..741e88d 100644
--- a/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
+++ b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
@@ -21,8 +21,8 @@
 
 namespace uscxml {
 
-WrappedIOProcessor::WrappedIOProcessor(InterpreterImpl* interpreter) {
-	_interpreter = interpreter;
+WrappedIOProcessor::WrappedIOProcessor(IOProcessorCallbacks* callbacks) {
+	_callbacks = callbacks;
 }
 WrappedIOProcessor::~WrappedIOProcessor() {}
 
diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.h b/src/bindings/swig/wrapped/WrappedIOProcessor.h
index f1820a4..98774b2 100644
--- a/src/bindings/swig/wrapped/WrappedIOProcessor.h
+++ b/src/bindings/swig/wrapped/WrappedIOProcessor.h
@@ -36,15 +36,15 @@ namespace uscxml {
 
 class WrappedIOProcessor : public IOProcessorImpl {
 public:
-	WrappedIOProcessor(InterpreterImpl* interpreter);
+	WrappedIOProcessor(IOProcessorCallbacks* callbacks);
 	virtual ~WrappedIOProcessor();
 
 	virtual std::list<std::string> getNames() {
 		return std::list<std::string>();
 	};
 
-	virtual std::shared_ptr<IOProcessorImpl> create(InterpreterImpl* interpreter) {
-		std::shared_ptr<IOProcessorImpl> ioProc = std::shared_ptr<IOProcessorImpl>(new WrappedIOProcessor(interpreter));
+	virtual std::shared_ptr<IOProcessorImpl> create(IOProcessorCallbacks* callbacks) {
+		std::shared_ptr<IOProcessorImpl> ioProc = std::shared_ptr<IOProcessorImpl>(new WrappedIOProcessor(callbacks));
 		return ioProc;
 	}
 
diff --git a/src/uscxml/interpreter/BasicContentExecutor.cpp b/src/uscxml/interpreter/BasicContentExecutor.cpp
index bbd6bca..192e714 100644
--- a/src/uscxml/interpreter/BasicContentExecutor.cpp
+++ b/src/uscxml/interpreter/BasicContentExecutor.cpp
@@ -118,7 +118,7 @@ void BasicContentExecutor::processSend(XERCESC_NS::DOMElement* element) {
 			 */
 			sendEvent.sendid = ATTR(getParentState(element), "id") + "." + UUID::getUUID();
 			if (HAS_ATTR(element, "idlocation")) {
-				_callbacks->assign(ATTR(element, "idlocation"), Data(sendEvent.sendid, Data::VERBATIM));
+				_callbacks->assign(ATTR(element, "idlocation"), Data(sendEvent.sendid, Data::VERBATIM), std::map<std::string, std::string>());
 			} else {
 				sendEvent.hideSendId = true;
 			}
@@ -242,7 +242,16 @@ void BasicContentExecutor::processIf(XERCESC_NS::DOMElement* content) {
 
 void BasicContentExecutor::processAssign(XERCESC_NS::DOMElement* content) {
 	std::string location = ATTR(content, "location");
-	_callbacks->assign(location, elementAsData(content));
+
+	std::map<std::string, std::string> additionalAttr;
+	auto xmlAttrs = content->getAttributes();
+	size_t nrAttrs = xmlAttrs->getLength();
+	for (size_t i = 0; i < nrAttrs; i++) {
+		auto attr = xmlAttrs->item(i);
+		additionalAttr[X(attr->getNodeName()).str()] = X(attr->getNodeValue()).str();
+	}
+
+	_callbacks->assign(location, elementAsData(content, true), additionalAttr);
 }
 
 void BasicContentExecutor::processForeach(XERCESC_NS::DOMElement* content) {
@@ -321,10 +330,10 @@ void BasicContentExecutor::process(XERCESC_NS::DOMElement* block, const X& xmlPr
 					for (std::list<std::string>::iterator nameIter = names.begin(); nameIter != names.end(); nameIter++) {
 						if (event.namelist.find(*nameIter) != event.namelist.end()) {
 							// scxml i/o proc keeps a dedicated namelist
-							_callbacks->assign(*nameIter, event.namelist.at(*nameIter));
+							_callbacks->assign(*nameIter, event.namelist.at(*nameIter), std::map<std::string, std::string>());
 						} else if (event.data.compound.find(*nameIter) != event.data.compound.end()) {
 							// this is where it would end up with non scxml i/o processors
-							_callbacks->assign(*nameIter, event.data.compound.at(*nameIter));
+							_callbacks->assign(*nameIter, event.data.compound.at(*nameIter), std::map<std::string, std::string>());
 						}
 					}
 				}
@@ -405,7 +414,7 @@ void BasicContentExecutor::invoke(XERCESC_NS::DOMElement* element) {
 		} else {
 			invokeEvent.invokeid = ATTR(getParentState(element), "id") + "." + UUID::getUUID();
 			if (HAS_ATTR(element, "idlocation")) {
-				_callbacks->assign(ATTR(element, "idlocation"), Data(invokeEvent.invokeid, Data::VERBATIM));
+				_callbacks->assign(ATTR(element, "idlocation"), Data(invokeEvent.invokeid, Data::VERBATIM), std::map<std::string, std::string>());
 			}
 		}
 
@@ -684,12 +693,10 @@ Data BasicContentExecutor::elementAsData(XERCESC_NS::DOMElement* element, bool a
 			if (asExpression) // not actually used, but likely expected
 				return Data(contentSS.str(), Data::INTERPRETED);
 
-			// test153
-			try {
-				Data d = _callbacks->getAsData(contentSS.str());
-				if (!d.empty())
-					return d;
-			} catch(...) {}
+			// test153, we need to throw for test150 in promela
+			Data d = _callbacks->getAsData(contentSS.str());
+			if (!d.empty())
+				return d;
 
 			// never actually occurs with the w3c tests
 			return Data(spaceNormalize(contentSS.str()), Data::VERBATIM);
diff --git a/src/uscxml/interpreter/BasicDelayedEventQueue.cpp b/src/uscxml/interpreter/BasicDelayedEventQueue.cpp
index 3521dc6..74ab757 100644
--- a/src/uscxml/interpreter/BasicDelayedEventQueue.cpp
+++ b/src/uscxml/interpreter/BasicDelayedEventQueue.cpp
@@ -69,14 +69,22 @@ std::shared_ptr<DelayedEventQueueImpl> BasicDelayedEventQueue::create(DelayedEve
 
 void BasicDelayedEventQueue::timerCallback(evutil_socket_t fd, short what, void *arg) {
 	struct callbackData *data = (struct callbackData*)arg;
-	std::lock_guard<std::recursive_mutex> lock(data->eventQueue->_mutex);
+	{
+		std::lock_guard<std::recursive_mutex> lock(data->eventQueue->_mutex);
 
-	if (data->eventQueue->_callbackData.find(data->eventUUID) == data->eventQueue->_callbackData.end())
-		return;
+		if (data->eventQueue->_callbackData.find(data->eventUUID) == data->eventQueue->_callbackData.end())
+			return;
+
+		event_free(data->event);
+	}
 
-	event_free(data->event);
+	// we cannot hold the mutex as this may trigger a delayed send
 	data->eventQueue->_callbacks->eventReady(data->userData, data->eventUUID);
-	data->eventQueue->_callbackData.erase(data->eventUUID);
+
+	{
+		std::lock_guard<std::recursive_mutex> lock(data->eventQueue->_mutex);
+		data->eventQueue->_callbackData.erase(data->eventUUID);
+	}
 }
 
 void BasicDelayedEventQueue::enqueueDelayed(const Event& event, size_t delayMs, const std::string& eventUUID) {
diff --git a/src/uscxml/interpreter/ContentExecutorImpl.h b/src/uscxml/interpreter/ContentExecutorImpl.h
index 278cbb9..e8c89f9 100644
--- a/src/uscxml/interpreter/ContentExecutorImpl.h
+++ b/src/uscxml/interpreter/ContentExecutorImpl.h
@@ -28,6 +28,7 @@
 
 #include <string>
 #include <set>
+#include <map>
 
 namespace XERCESC_NS {
 class DOMDocument;
@@ -59,7 +60,7 @@ public:
 
 	virtual Data evalAsData(const std::string& expr) = 0;
 	virtual Data getAsData(const std::string& expr) = 0;
-	virtual void assign(const std::string& location, const Data& data) = 0;
+	virtual void assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attrs) = 0;
 
 
 	virtual std::string getInvokeId() = 0;
diff --git a/src/uscxml/interpreter/InterpreterImpl.cpp b/src/uscxml/interpreter/InterpreterImpl.cpp
index 60ce29d..33a1169 100644
--- a/src/uscxml/interpreter/InterpreterImpl.cpp
+++ b/src/uscxml/interpreter/InterpreterImpl.cpp
@@ -388,18 +388,26 @@ void InterpreterImpl::init() {
 void InterpreterImpl::initData(XERCESC_NS::DOMElement* root) {
 	std::string id = ATTR(root, "id");
 	Data d;
+
+	std::map<std::string, std::string> additionalAttr;
+	auto xmlAttrs = root->getAttributes();
+	size_t nrAttrs = xmlAttrs->getLength();
+	for (size_t i = 0; i < nrAttrs; i++) {
+		auto attr = xmlAttrs->item(i);
+		additionalAttr[X(attr->getNodeName()).str()] = X(attr->getNodeValue()).str();
+	}
+
 	try {
 		if (Event::getParam(_invokeReq.params, id, d)) {
-			_dataModel.init(id, d);
+			_dataModel.init(id, d, additionalAttr);
 		} else if (_invokeReq.namelist.find(id) != _invokeReq.namelist.end()) {
-			_dataModel.init(id, _invokeReq.namelist[id]);
+			_dataModel.init(id, _invokeReq.namelist[id], additionalAttr);
 		} else {
 			try {
-				_dataModel.init(id, _execContent.elementAsData(root));
+				_dataModel.init(id, _execContent.elementAsData(root), additionalAttr);
 			} catch (ErrorEvent e) {
 				// test 453
-				_dataModel.init(id, _execContent.elementAsData(root, true));
-
+				_dataModel.init(id, _execContent.elementAsData(root, true), additionalAttr);
 			}
 		}
 	} catch(ErrorEvent e) {
@@ -408,8 +416,8 @@ void InterpreterImpl::initData(XERCESC_NS::DOMElement* root) {
 	}
 }
 
-void InterpreterImpl::assign(const std::string& location, const Data& data) {
-	_dataModel.assign(location, data);
+void InterpreterImpl::assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attrs) {
+	_dataModel.assign(location, data, attrs);
 }
 
 bool InterpreterImpl::isMatched(const Event& event, const std::string& eventDesc) {
@@ -556,4 +564,29 @@ void InterpreterImpl::uninvoke(const std::string& invokeId) {
 
 }
 
+void InterpreterImpl::enqueueAtInvoker(const std::string& invokeId, const Event& event) {
+	if (_invokers.find(invokeId) != _invokers.end()) {
+		std::lock_guard<std::recursive_mutex> lock(_instanceMutex);
+		try {
+			_invokers[invokeId].eventFromSCXML(event);
+		} catch (const std::exception &e) {
+			ERROR_COMMUNICATION_THROW("Exception caught while sending event to invoker '" + invokeId + "': " + e.what());
+		} catch(...) {
+			ERROR_COMMUNICATION_THROW("Exception caught while sending event to invoker '" + invokeId + "'");
+		}
+	} else {
+		ERROR_COMMUNICATION_THROW("Can not send to invoked component '" + invokeId + "', no such invokeId");
+	}
+
+}
+
+void InterpreterImpl::enqueueAtParent(const Event& event) {
+	if (_parentQueue) {
+		_parentQueue.enqueue(event);
+	} else {
+		ERROR_COMMUNICATION_THROW("Sending to parent invoker, but none is set");
+	}
+
+}
+
 }
diff --git a/src/uscxml/interpreter/InterpreterImpl.h b/src/uscxml/interpreter/InterpreterImpl.h
index 2b12624..bd3898c 100644
--- a/src/uscxml/interpreter/InterpreterImpl.h
+++ b/src/uscxml/interpreter/InterpreterImpl.h
@@ -31,6 +31,7 @@
 #include "uscxml/util/URL.h"
 #include "uscxml/plugins/Factory.h"
 #include "uscxml/plugins/DataModelImpl.h"
+#include "uscxml/plugins/IOProcessorImpl.h"
 #include "uscxml/interpreter/MicroStepImpl.h"
 #include "uscxml/interpreter/ContentExecutorImpl.h"
 #include "uscxml/interpreter/EventQueue.h"
@@ -49,6 +50,7 @@ class InterpreterIssue;
 class USCXML_API InterpreterImpl :
 	public MicroStepCallbacks,
 	public DataModelCallbacks,
+	public IOProcessorCallbacks,
 	public ContentExecutorCallbacks,
 	public DelayedEventQueueCallbacks,
 	public std::enable_shared_from_this<InterpreterImpl> {
@@ -187,7 +189,7 @@ public:
 		return _dataModel.getAsData(expr);
 	}
 
-	virtual void assign(const std::string& location, const Data& data);
+	virtual void assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attrs);
 
 	virtual std::string getInvokeId() {
 		return _invokeId;
@@ -206,6 +208,12 @@ public:
 	}
 
 	/**
+	 IOProcessorCallbacks
+	 */
+	virtual void enqueueAtInvoker(const std::string& invokeId, const Event& event);
+	virtual void enqueueAtParent(const Event& event);
+
+	/**
 	 DelayedEventQueueCallbacks
 	 */
 
diff --git a/src/uscxml/messages/Data.cpp b/src/uscxml/messages/Data.cpp
index 277b7d8..6c48c46 100644
--- a/src/uscxml/messages/Data.cpp
+++ b/src/uscxml/messages/Data.cpp
@@ -350,8 +350,8 @@ std::string Data::jsonEscape(const std::string& expr) {
 			os << "\\n";
 		} else if (expr[i] == '\r') {
 			os << "\\r";
-		} else if (expr[i] == '\'') {
-			os << "\\'";
+//		} else if (expr[i] == '\'') {
+//			os << "\\\'";
 		} else if (expr[i] == '\"') {
 			os << "\\\"";
 		} else if (expr[i] == '\\') {
diff --git a/src/uscxml/messages/Data.h b/src/uscxml/messages/Data.h
index 19134dd..b279696 100644
--- a/src/uscxml/messages/Data.h
+++ b/src/uscxml/messages/Data.h
@@ -23,6 +23,7 @@
 #include <list>
 #include <map>
 #include <memory>
+#include <type_traits>
 
 #include "uscxml/Common.h"
 #include "uscxml/util/Convenience.h"
@@ -49,27 +50,27 @@ public:
 
 	Data() : node(NULL), type(INTERPRETED) {}
 
-	Data(const char* data, size_t size, const std::string& mimeType, bool adopt = false);
+	explicit Data(const char* data, size_t size, const std::string& mimeType, bool adopt = false);
 
 	// convenience constructors
-	Data(bool atom) : node(NULL), type(VERBATIM) {
-		if (atom) {
-			this->atom = "true";
-		} else {
-			this->atom = "false";
-		}
-	}
+//	explicit Data(bool atom) : node(NULL), type(VERBATIM) {
+//		if (atom) {
+//			this->atom = "true";
+//		} else {
+//			this->atom = "false";
+//		}
+//	}
 
 	explicit Data(XERCESC_NS::DOMNode* node_) : node(node_) {}
-	//    template <typename T> Data(T value, Type type = INTERPRETED) : atom(toStr(value)), type(type) {}
 
-	// we will have to drop this constructor as it interferes with operator Data() and requires C++11
-	template <typename T>
-	explicit Data(T value, typename std::enable_if<! std::is_base_of<Data, T>::value>::type* = nullptr)
-		: node(NULL), atom(toStr(value)), type(VERBATIM) {}
+	explicit Data(const std::string& value) : node(NULL), atom(toStr(value)), type(VERBATIM) {}
+
+	template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
+	explicit Data(T value)
+		: node(NULL), atom(toStr(value)), type(INTERPRETED) {}
+
 	template <typename T>
-	explicit Data(T value, Type type, typename std::enable_if<! std::is_base_of<Data, T>::value>::type* = nullptr)
-		: node(NULL), atom(toStr(value)), type(type) {}
+	explicit Data(T value, Type type) : node(NULL), atom(toStr(value)), type(type) {}
 
 	~Data() {
 	}
@@ -170,11 +171,11 @@ public:
 	}
 
 	bool operator==(const Data &other) const {
-		return (*this < other || other < *this);
+		return !(*this != other);
 	}
 
 	bool operator!=(const Data &other) const {
-		return !(*this == other);
+		return (*this < other || other < *this);
 	}
 
 	operator std::string() const {
diff --git a/src/uscxml/plugins/DataModel.cpp b/src/uscxml/plugins/DataModel.cpp
index 96afd89..07fd4b4 100644
--- a/src/uscxml/plugins/DataModel.cpp
+++ b/src/uscxml/plugins/DataModel.cpp
@@ -57,12 +57,12 @@ void DataModel::setForeach(const std::string& item,
 	return _impl->setForeach(item, array, index, iteration);
 }
 
-void DataModel::assign(const std::string& location, const Data& data) {
-	return _impl->assign(location, data);
+void DataModel::assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
+	return _impl->assign(location, data, attr);
 }
 
-void DataModel::init(const std::string& location, const Data& data) {
-	return _impl->init(location, data);
+void DataModel::init(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
+	return _impl->init(location, data, attr);
 }
 
 bool DataModel::isDeclared(const std::string& expr) {
@@ -73,10 +73,6 @@ size_t DataModel::replaceExpressions(std::string& content) {
 	return _impl->replaceExpressions(content);
 }
 
-std::string DataModel::andExpressions(std::list<std::string> expressions) {
-	return _impl->andExpressions(expressions);
-}
-
 void DataModel::addExtension(DataModelExtension* ext) {
 	return _impl->addExtension(ext);
 }
diff --git a/src/uscxml/plugins/DataModel.h b/src/uscxml/plugins/DataModel.h
index 7716ad7..9185cc8 100644
--- a/src/uscxml/plugins/DataModel.h
+++ b/src/uscxml/plugins/DataModel.h
@@ -66,17 +66,19 @@ public:
 	                        uint32_t iteration);
 
 	/// @copydoc DataModelImpl::assign()
-	virtual void assign(const std::string& location, const Data& data);
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
 	/// @copydoc DataModelImpl::init()
-	virtual void init(const std::string& location, const Data& data);
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
 
 	/// @copydoc DataModelImpl::isDeclared()
 	virtual bool isDeclared(const std::string& expr);
 
 	/// @copydoc DataModelImpl::replaceExpressions()
 	size_t replaceExpressions(std::string& content);
-	/// @copydoc DataModelImpl::andExpressions()
-	std::string andExpressions(std::list<std::string> expressions);
 
 	/// @copydoc DataModelImpl::addExtension()
 	virtual void addExtension(DataModelExtension* ext);
diff --git a/src/uscxml/plugins/DataModelImpl.h b/src/uscxml/plugins/DataModelImpl.h
index e93361d..b1fbd88 100644
--- a/src/uscxml/plugins/DataModelImpl.h
+++ b/src/uscxml/plugins/DataModelImpl.h
@@ -182,8 +182,11 @@ public:
 	\endverbatim
 	 * @param location A variable or locatio to assign to.
 	 * @param data The Data object with the respective data.
+	 * @param attr Additional attributes of the XML assign element.
 	 */
-	virtual void assign(const std::string& location, const Data& data) = 0;
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr = std::map<std::string, std::string>()) = 0;
 
 	/**
 	 * Initialize a variable / location in the data-model with a given data object.
@@ -192,8 +195,11 @@ public:
 	 *
 	 * @param location A variable or locatio to assign to.
 	 * @param data The Data object with the respective data.
+	 * @param attr Additional attributes of the XML data element.
 	 */
-	virtual void init(const std::string& location, const Data& data) = 0;
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr = std::map<std::string, std::string>()) = 0;
 
 	/**
 	 * Register an extension to get data into and out of the data-model.
@@ -201,15 +207,6 @@ public:
 	 */
 	virtual void addExtension(DataModelExtension* ext);
 
-	/**
-	 * Concat the given terms into a conjunctive form.
-	 * @todo This is required to automatically transform a state-chart into a
-	 * state-machine. Actual transformation is still only available in legacy though.
-	 */
-	virtual std::string andExpressions(std::list<std::string>) {
-		return "";
-	}
-
 protected:
 	DataModelCallbacks* _callbacks;
 };
diff --git a/src/uscxml/plugins/EventHandler.h b/src/uscxml/plugins/EventHandler.h
index 436f878..5122e9b 100644
--- a/src/uscxml/plugins/EventHandler.h
+++ b/src/uscxml/plugins/EventHandler.h
@@ -53,9 +53,6 @@ public:
 	 * @return An object to be represented at `_x['name']`
 	 */
 	virtual Data getDataModelVariables() = 0;
-
-protected:
-	InterpreterImpl* _interpreter;
 };
 
 /**
diff --git a/src/uscxml/plugins/Factory.cpp b/src/uscxml/plugins/Factory.cpp
index 443cb59..60e7a3e 100644
--- a/src/uscxml/plugins/Factory.cpp
+++ b/src/uscxml/plugins/Factory.cpp
@@ -106,7 +106,6 @@ void Factory::registerPlugins() {
 	}
 #endif
 
-
 #ifdef WITH_DM_ECMA_V8
 	{
 		V8DataModel* dataModel = new V8DataModel();
@@ -352,12 +351,12 @@ bool Factory::hasIOProcessor(const std::string& type) {
 	return false;
 }
 
-std::shared_ptr<IOProcessorImpl> Factory::createIOProcessor(const std::string& type, InterpreterImpl* interpreter) {
+std::shared_ptr<IOProcessorImpl> Factory::createIOProcessor(const std::string& type, IOProcessorCallbacks* callbacks) {
 	// do we have this type ourself?
 	if (_ioProcessorAliases.find(type) != _ioProcessorAliases.end()) {
 		std::string canonicalName = _ioProcessorAliases[type];
 		if (_ioProcessors.find(canonicalName) != _ioProcessors.end()) {
-			std::shared_ptr<IOProcessorImpl> ioProc = _ioProcessors[canonicalName]->create(interpreter);
+			std::shared_ptr<IOProcessorImpl> ioProc = _ioProcessors[canonicalName]->create(callbacks);
 //			ioProc->setInterpreter(interpreter);
 			return ioProc;
 		}
@@ -365,7 +364,7 @@ std::shared_ptr<IOProcessorImpl> Factory::createIOProcessor(const std::string& t
 
 	// lookup in parent factory
 	if (_parentFactory) {
-		return _parentFactory->createIOProcessor(type, interpreter);
+		return _parentFactory->createIOProcessor(type, callbacks);
 	} else {
 		ERROR_EXECUTION_THROW("No IOProcessor named '" + type + "' known");
 	}
@@ -497,9 +496,9 @@ void IOProcessorImpl::eventToSCXML(Event& event,
 		event.origintype = type;
 
 	if (internal) {
-		_interpreter->enqueueInternal(event);
+		_callbacks->enqueueInternal(event);
 	} else {
-		_interpreter->enqueueExternal(event);
+		_callbacks->enqueueExternal(event);
 	}
 }
 
@@ -517,9 +516,9 @@ void InvokerImpl::eventToSCXML(Event& event,
 		event.origintype = type;
 
 	if (internal) {
-		_interpreter->enqueueInternal(event);
+		_callbacks->enqueueInternal(event);
 	} else {
-		_interpreter->enqueueExternal(event);
+		_callbacks->enqueueExternal(event);
 	}
 }
 
diff --git a/src/uscxml/plugins/Factory.h b/src/uscxml/plugins/Factory.h
index f80b581..9653107 100644
--- a/src/uscxml/plugins/Factory.h
+++ b/src/uscxml/plugins/Factory.h
@@ -25,6 +25,7 @@
 #include "uscxml/plugins/ExecutableContent.h"
 #include "uscxml/plugins/EventHandler.h"
 #include "uscxml/plugins/IOProcessor.h"
+#include "uscxml/plugins/IOProcessorImpl.h"
 #include "uscxml/plugins/Invoker.h"
 #include "uscxml/plugins/DataModelImpl.h"
 
@@ -53,7 +54,7 @@ public:
 	void registerExecutableContent(ExecutableContentImpl* executableContent);
 
 	std::shared_ptr<DataModelImpl> createDataModel(const std::string& type, DataModelCallbacks* callbacks);
-	std::shared_ptr<IOProcessorImpl> createIOProcessor(const std::string& type, InterpreterImpl* interpreter);
+	std::shared_ptr<IOProcessorImpl> createIOProcessor(const std::string& type, IOProcessorCallbacks* callbacks);
 	std::shared_ptr<InvokerImpl> createInvoker(const std::string& type, InterpreterImpl* interpreter);
 	std::shared_ptr<ExecutableContentImpl> createExecutableContent(const std::string& localName, const std::string& nameSpace, InterpreterImpl* interpreter);
 
diff --git a/src/uscxml/plugins/IOProcessorImpl.h b/src/uscxml/plugins/IOProcessorImpl.h
index bd28406..24d2631 100644
--- a/src/uscxml/plugins/IOProcessorImpl.h
+++ b/src/uscxml/plugins/IOProcessorImpl.h
@@ -23,13 +23,31 @@
 
 #include "uscxml/Common.h"
 #include "uscxml/plugins/EventHandler.h"
+#include "uscxml/interpreter/Logging.h"
 #include "uscxml/messages/Event.h"
-#include "uscxml/interpreter/InterpreterImpl.h"
 
 namespace uscxml {
 
 /**
  * @ingroup ioproc
+ * @ingroup callback
+ * Callbacks available for every IO processor.
+ */
+class USCXML_API IOProcessorCallbacks {
+public:
+	virtual ~IOProcessorCallbacks() {} ///< silence virtual destructor warning from swig
+	virtual const std::string& getName() = 0;
+	virtual const std::string& getSessionId() = 0;
+	virtual void enqueueInternal(const Event& event) = 0;
+	virtual void enqueueExternal(const Event& event) = 0;
+	virtual void enqueueAtInvoker(const std::string& invokeId, const Event& event) = 0;
+	virtual void enqueueAtParent(const Event& event) = 0;
+	virtual Logger getLogger() = 0;
+
+};
+
+/**
+ * @ingroup ioproc
  * @ingroup abstract
  * Abstract base class for IOProcessor%s implementations.
  */
@@ -41,7 +59,7 @@ public:
 	 * @param interpreter The imlementation of the associated Interpreter
 	 * @todo We will eventually introduce callbacks and prevent complete access to the interpreter.
 	 */
-	virtual std::shared_ptr<IOProcessorImpl> create(InterpreterImpl* interpreter) = 0;
+	virtual std::shared_ptr<IOProcessorImpl> create(IOProcessorCallbacks* callbacks) = 0;
 
 	/**
 	 * We received an event from the SCXML Interpreter we are associated with.
@@ -67,6 +85,7 @@ protected:
 	 */
 	void eventToSCXML(Event& event, const std::string& type, const std::string& origin, bool internal = false);
 
+	IOProcessorCallbacks* _callbacks;
 };
 
 }
diff --git a/src/uscxml/plugins/InvokerImpl.h b/src/uscxml/plugins/InvokerImpl.h
index e0446e1..e5f7366 100644
--- a/src/uscxml/plugins/InvokerImpl.h
+++ b/src/uscxml/plugins/InvokerImpl.h
@@ -115,7 +115,7 @@ protected:
 
 	XERCESC_NS::DOMElement* _finalize;
 	std::string _invokeId;
-
+	InterpreterImpl* _callbacks;
 };
 
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp
index 22e8ccc..bcde9c9 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp
@@ -420,7 +420,12 @@ Data JSCDataModel::getAsData(const std::string& content) {
 		            (trimmed[0] == '\'' && trimmed[trimmed.length() - 1] == '\''))) {
 			d = Data(trimmed.substr(1, trimmed.length() - 2), Data::VERBATIM);
 		} else {
-			d = Data(trimmed, Data::INTERPRETED);
+			// test558, test562
+			ERROR_EXECUTION(e, "Given content cannot be interpreted as data");
+			e.data.compound["literal"] = Data(trimmed, Data::VERBATIM);
+			throw e;
+
+//			d = Data(trimmed, Data::INTERPRETED);
 		}
 	}
 	return d;
@@ -684,7 +689,7 @@ JSValueRef JSCDataModel::getNodeAsValue(const DOMNode* node) {
 //    }
 }
 
-void JSCDataModel::assign(const std::string& location, const Data& data) {
+void JSCDataModel::assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
 
 	// flags on attribute are ignored?
 	if (location.compare("_sessionid") == 0) // test 322
@@ -714,7 +719,7 @@ void JSCDataModel::assign(const std::string& location, const Data& data) {
 		handleException(exception);
 }
 
-void JSCDataModel::init(const std::string& location, const Data& data) {
+void JSCDataModel::init(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
 	try {
 		if (data.empty()) {
 			assign(location, Data("null", Data::INTERPRETED));
@@ -728,26 +733,6 @@ void JSCDataModel::init(const std::string& location, const Data& data) {
 	}
 }
 
-std::string JSCDataModel::andExpressions(std::list<std::string> expressions) {
-	if (expressions.size() == 0)
-		return "";
-
-	if (expressions.size() == 1)
-		return *(expressions.begin());
-
-	std::ostringstream exprSS;
-	exprSS << "(";
-	std::string conjunction = "";
-	for (std::list<std::string>::const_iterator exprIter = expressions.begin();
-	        exprIter != expressions.end();
-	        exprIter++) {
-		exprSS << conjunction << "(" << *exprIter << ")";
-		conjunction = " && ";
-	}
-	exprSS << ")";
-	return exprSS.str();
-}
-
 void JSCDataModel::handleException(JSValueRef exception) {
 	JSStringRef exceptionStringRef = JSValueToStringCopy(_ctx, exception, NULL);
 	size_t maxSize = JSStringGetMaximumUTF8CStringSize(exceptionStringRef);
diff --git a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.h b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.h
index c5129a4..3a53da2 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.h
@@ -80,10 +80,12 @@ public:
 
 	virtual bool isDeclared(const std::string& expr);
 
-	virtual void assign(const std::string& location, const Data& data);
-	virtual void init(const std::string& location, const Data& data);
-
-	virtual std::string andExpressions(std::list<std::string>);
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
 
 protected:
 
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
index 283372d..61eb815 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
@@ -408,7 +408,7 @@ void V8DataModel::setEvent(const Event& event) {
 			}
 		}
 		if (!data.empty()) {
-//			std::cout << Data::toJSON(eventCopy.data);
+//			std::cout << Data::toJSON(data);
 			eventObj->Set(v8::String::NewSymbol("data"), getDataAsValue(data)); // set data part of _event
 		} else {
 			// test 343 / test 488
@@ -436,7 +436,10 @@ Data V8DataModel::getAsData(const std::string& content) {
 		            (trimmed[0] == '\'' && trimmed[trimmed.length() - 1] == '\''))) {
 			d = Data(trimmed.substr(1, trimmed.length() - 2), Data::VERBATIM);
 		} else {
-			d = Data(trimmed, Data::INTERPRETED);
+			// test558, test562
+			ERROR_EXECUTION(e, "Given content cannot be interpreted as data");
+			e.data.compound["literal"] = Data(trimmed, Data::VERBATIM);
+			throw e;
 		}
 	}
 	return d;
@@ -631,12 +634,22 @@ void V8DataModel::jsIn(const v8::FunctionCallbackInfo<v8::Value>& info) {
 }
 
 bool V8DataModel::isValidSyntax(const std::string& expr) {
+	v8::Locker locker(_isolate);
+	v8::Isolate::Scope isoScope(_isolate);
+	v8::HandleScope scope(_isolate);
+
+	v8::Local<v8::Context> ctx = v8::Local<v8::Context>::New(_isolate, _context);
+	v8::Context::Scope contextScope(ctx); // segfaults at newinstance without!
+
 	v8::TryCatch tryCatch;
 
 	v8::Local<v8::String> source = v8::String::New(expr.c_str());
-	v8::Local<v8::Script> script = v8::Script::Compile(source);
+	if (tryCatch.HasCaught() || source.IsEmpty()) {
+		return false;
+	}
 
-	if (script.IsEmpty() || tryCatch.HasCaught()) {
+	v8::Local<v8::Script> script = v8::Script::Compile(source);
+	if (tryCatch.HasCaught() || script.IsEmpty()) {
 		return false;
 	}
 
@@ -726,7 +739,7 @@ bool V8DataModel::evalAsBool(const std::string& expr) {
 }
 
 
-void V8DataModel::assign(const std::string& location, const Data& data) {
+void V8DataModel::assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
 
 	v8::Locker locker(_isolate);
 	v8::Isolate::Scope isoScope(_isolate);
@@ -754,8 +767,7 @@ void V8DataModel::assign(const std::string& location, const Data& data) {
 	}
 }
 
-void V8DataModel::init(const std::string& location,
-                       const Data& data) {
+void V8DataModel::init(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
 	v8::Locker locker(_isolate);
 	v8::Isolate::Scope isoScope(_isolate);
 	v8::HandleScope scope(_isolate);
@@ -774,26 +786,6 @@ void V8DataModel::init(const std::string& location,
 	}
 }
 
-std::string V8DataModel::andExpressions(std::list<std::string> expressions) {
-	if (expressions.size() == 0)
-		return "";
-
-	if (expressions.size() == 1)
-		return *(expressions.begin());
-
-	std::ostringstream exprSS;
-	exprSS << "(";
-	std::string conjunction = "";
-	for (std::list<std::string>::const_iterator exprIter = expressions.begin();
-	        exprIter != expressions.end();
-	        exprIter++) {
-		exprSS << conjunction << "(" << *exprIter << ")";
-		conjunction = " && ";
-	}
-	exprSS << ")";
-	return exprSS.str();
-}
-
 v8::Local<v8::Value> V8DataModel::evalAsValue(const std::string& expr, bool dontThrow) {
 
 //    v8::Locker locker(_isolate);
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h
index 3b4d776..a9dbca1 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h
@@ -73,10 +73,12 @@ public:
 
 	virtual bool isDeclared(const std::string& expr);
 
-	virtual void assign(const std::string& location, const Data& data);
-	virtual void init(const std::string& location, const Data& data);
-
-	virtual std::string andExpressions(std::list<std::string>);
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
 
 protected:
 
diff --git a/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp b/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp
index 2ad89b5..ad35f80 100644
--- a/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp
@@ -349,9 +349,12 @@ Data LuaDataModel::evalAsData(const std::string& content) {
 		throw originalError; // we will assume syntax error and throw
 	}
 
-	if (retVals == 0)
+#if 1
+	// Note: Empty result is not an error test302, but how to do test488?
+	if (retVals == 0 && !isValidSyntax(trimmedExpr)) {
 		throw originalError; // we will assume syntax error and throw
-
+	}
+#endif
 
 	try {
 		if (retVals == 1) {
@@ -446,7 +449,7 @@ bool LuaDataModel::isDeclared(const std::string& expr) {
 }
 
 
-void LuaDataModel::assign(const std::string& location, const Data& data) {
+void LuaDataModel::assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
 	if (location.length() == 0) {
 		ERROR_EXECUTION_THROW("Assign element has neither id nor location");
 	}
@@ -539,7 +542,7 @@ void LuaDataModel::assign(const std::string& location, const Data& data) {
 	}
 }
 
-void LuaDataModel::init(const std::string& location, const Data& data) {
+void LuaDataModel::init(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
 	luabridge::setGlobal(_luaState, luabridge::Nil(), location.c_str());
 	assign(location, data);
 }
@@ -582,17 +585,4 @@ Data LuaDataModel::getAsData(const std::string& content) {
 	return data;
 }
 
-
-std::string LuaDataModel::andExpressions(std::list<std::string> exprs) {
-	std::stringstream exprSS;
-	std::list<std::string>::const_iterator listIter;
-	std::string andExpr;
-	for (listIter = exprs.begin(); listIter != exprs.end(); listIter++) {
-		exprSS << andExpr << *listIter;
-		andExpr = " && ";
-	}
-	return exprSS.str();
-}
-
-
 }
diff --git a/src/uscxml/plugins/datamodel/lua/LuaDataModel.h b/src/uscxml/plugins/datamodel/lua/LuaDataModel.h
index 7b7121f..85d7b53 100644
--- a/src/uscxml/plugins/datamodel/lua/LuaDataModel.h
+++ b/src/uscxml/plugins/datamodel/lua/LuaDataModel.h
@@ -77,10 +77,12 @@ public:
 
 	virtual bool isDeclared(const std::string& expr);
 
-	virtual void assign(const std::string& location, const Data& data);
-	virtual void init(const std::string& location, const Data& data);
-
-	virtual std::string andExpressions(std::list<std::string>);
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
 
 protected:
 
diff --git a/src/uscxml/plugins/datamodel/null/NULLDataModel.h b/src/uscxml/plugins/datamodel/null/NULLDataModel.h
index 4bea664..fba8577 100644
--- a/src/uscxml/plugins/datamodel/null/NULLDataModel.h
+++ b/src/uscxml/plugins/datamodel/null/NULLDataModel.h
@@ -90,24 +90,14 @@ public:
 		return true;
 	}
 
-	virtual void assign(const XERCESC_NS::DOMElement* assignElem,
-	                    const XERCESC_NS::DOMNode* node,
-	                    const std::string& content) {}
-	virtual void assign(const std::string& location, const Data& data) {}
-
-	virtual void init(const XERCESC_NS::DOMElement* dataElem,
-	                  const XERCESC_NS::DOMNode* node,
-	                  const std::string& content) {}
-	virtual void init(const std::string& location, const Data& data) {}
+	virtual void assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {}
+	virtual void init(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {}
 
 	virtual void setCallbacks(DataModelCallbacks* callbacks) {
 		_callbacks = callbacks;
 	}
 
 	virtual void addExtension(DataModelExtension* ext) {}
-	virtual std::string andExpressions(std::list<std::string>) {
-		return "";
-	}
 
 protected:
 
diff --git a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp
index a524c7e..14d24c3 100644
--- a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp
@@ -146,7 +146,7 @@ void PromelaDataModel::setEvent(const Event& event) {
 			        start != end; start = event.params.upper_bound(start->first)) {
 				// only set first param key
 				if (isNumeric(start->second.atom.c_str(), 10)) {
-					variable.compound["value"].compound["data"].compound[start->first] = strTo<int>(start->second.atom);
+					variable.compound["value"].compound["data"].compound[start->first] = Data(strTo<int>(start->second.atom));
 				} else {
 					variable.compound["value"].compound["data"].compound[start->first] = start->second;
 				}
@@ -154,7 +154,7 @@ void PromelaDataModel::setEvent(const Event& event) {
 
 			for (Event::namelist_t::const_iterator iter = event.namelist.begin(); iter != event.namelist.end(); iter++) {
 				if (isNumeric(iter->second.atom.c_str(), 10)) {
-					variable.compound["value"].compound["data"].compound[iter->first] = strTo<int>(iter->second.atom);
+					variable.compound["value"].compound["data"].compound[iter->first] = Data(strTo<int>(iter->second.atom));
 				} else {
 					variable.compound["value"].compound["data"].compound[iter->first] = iter->second;
 				}
@@ -225,11 +225,25 @@ void PromelaDataModel::setEvent(const Event& event) {
 
 		PromelaParser arrayParser(ss.str(), 1, PromelaParser::PROMELA_EXPR);
 
-		setVariable(itemParser.ast, getVariable(arrayParser.ast));
+		try {
+			setVariable(itemParser.ast, getVariable(arrayParser.ast));
+		} catch (ErrorEvent e) {
+			// test150
+			PromelaParser itemDeclParser("int " + item); // this is likely the wrong type
+			evaluateDecl(itemDeclParser.ast);
+			setVariable(itemParser.ast, getVariable(arrayParser.ast));
+		}
 
 		if (index.length() > 0) {
 			PromelaParser indexParser(index, 1, PromelaParser::PROMELA_EXPR);
-			setVariable(indexParser.ast, iteration);
+			try {
+				setVariable(indexParser.ast, Data(iteration));
+			} catch (ErrorEvent e) {
+				// test150
+				PromelaParser indexDeclParser("int " + index);
+				evaluateDecl(indexDeclParser.ast);
+				setVariable(indexParser.ast, Data(iteration));
+			}
 		}
 
 	}
@@ -322,7 +336,7 @@ void PromelaDataModel::setEvent(const Event& event) {
 					PromelaParserNode* name = *opIterAsgn++;
 					int size = dataToInt(evaluateExpr(*opIterAsgn++));
 
-					variable.compound["size"] = size;
+					variable.compound["size"] = Data(size);
 					for (size_t i = 0; i < size; i++) {
 						variable.compound["value"].array.push_back(Data(0, Data::INTERPRETED));
 					}
@@ -385,7 +399,7 @@ void PromelaDataModel::setEvent(const Event& event) {
 				return Data(false);
 			if (iequals(node->value, "true"))
 				return Data(true);
-			return strTo<int>(node->value);
+			return Data(strTo<int>(node->value));
 		case PML_NAME:
 		case PML_VAR_ARRAY:
 		case PML_CMPND:
@@ -396,13 +410,13 @@ void PromelaDataModel::setEvent(const Event& event) {
 //		return Data(node->value, Data::INTERPRETED);
 		}
 		case PML_PLUS:
-			return dataToInt(evaluateExpr(*opIter++)) + dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) + dataToInt(evaluateExpr(*opIter++)));
 		case PML_MINUS:
-			return dataToInt(evaluateExpr(*opIter++)) - dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) - dataToInt(evaluateExpr(*opIter++)));
 		case PML_DIVIDE:
-			return dataToInt(evaluateExpr(*opIter++)) / dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) / dataToInt(evaluateExpr(*opIter++)));
 		case PML_MODULO:
-			return dataToInt(evaluateExpr(*opIter++)) % dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) % dataToInt(evaluateExpr(*opIter++)));
 		case PML_EQ: {
 			PromelaParserNode* lhs = *opIter++;
 			PromelaParserNode* rhs = *opIter++;
@@ -418,24 +432,24 @@ void PromelaDataModel::setEvent(const Event& event) {
 			        || (left.type == Data::VERBATIM && right.type == Data::VERBATIM)) {
 				return (left.atom.compare(right.atom) == 0 ? Data(true) : Data(false));
 			}
-			return dataToInt(left) == dataToInt(right);
+			return Data(dataToInt(left) == dataToInt(right));
 		}
 		case PML_NEG:
-			return !dataToBool(evaluateExpr(*opIter++));
+			return Data(!dataToBool(evaluateExpr(*opIter++)));
 		case PML_LT:
-			return dataToInt(evaluateExpr(*opIter++)) < dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) < dataToInt(evaluateExpr(*opIter++)));
 		case PML_LE:
-			return dataToInt(evaluateExpr(*opIter++)) <= dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) <= dataToInt(evaluateExpr(*opIter++)));
 		case PML_GT:
-			return dataToInt(evaluateExpr(*opIter++)) > dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) > dataToInt(evaluateExpr(*opIter++)));
 		case PML_GE:
-			return dataToInt(evaluateExpr(*opIter++)) >= dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) >= dataToInt(evaluateExpr(*opIter++)));
 		case PML_TIMES:
-			return dataToInt(evaluateExpr(*opIter++)) * dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) * dataToInt(evaluateExpr(*opIter++)));
 		case PML_LSHIFT:
-			return dataToInt(evaluateExpr(*opIter++)) << dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) << dataToInt(evaluateExpr(*opIter++)));
 		case PML_RSHIFT:
-			return dataToInt(evaluateExpr(*opIter++)) >> dataToInt(evaluateExpr(*opIter++));
+			return Data(dataToInt(evaluateExpr(*opIter++)) >> dataToInt(evaluateExpr(*opIter++)));
 		case PML_AND:
 		case PML_OR: {
 			PromelaParserNode* lhs = *opIter++;
@@ -452,15 +466,15 @@ void PromelaDataModel::setEvent(const Event& event) {
 			bool truthRight = dataToBool(right);
 
 			if (node->type == PML_AND) {
-				return truthLeft && truthRight;
+				return Data(truthLeft && truthRight);
 			} else {
-				return truthLeft || truthRight;
+				return Data(truthLeft || truthRight);
 			}
 		}
 		default:
 			ERROR_EXECUTION_THROW("Support for " + PromelaParserNode::typeToDesc(node->type) + " expressions not implemented");
 		}
-		return 0;
+		return Data(0, Data::INTERPRETED);
 	}
 
 	void PromelaDataModel::evaluateStmnt(void* ast) {
@@ -481,12 +495,12 @@ void PromelaDataModel::setEvent(const Event& event) {
 		}
 		case PML_INCR: {
 			PromelaParserNode* name = *opIter++;
-			setVariable(name, strTo<long>(getVariable(name)) + 1);
+			setVariable(name, Data(strTo<long>(getVariable(name)) + 1));
 			break;
 		}
 		case PML_DECR: {
 			PromelaParserNode* name = *opIter++;
-			setVariable(name, strTo<long>(getVariable(name)) - 1);
+			setVariable(name, Data(strTo<long>(getVariable(name)) - 1));
 			break;
 		}
 		default:
@@ -503,11 +517,6 @@ void PromelaDataModel::setEvent(const Event& event) {
 			ERROR_EXECUTION_THROW("Cannot assign to " + node->value);
 		}
 
-//	if (_variables.compound.find(name->value) == _variables.compound.end()) {
-//		// declare implicitly / convenience
-//		evaluateDecl(ast);
-//	}
-
 		switch (node->type) {
 		case PML_VAR_ARRAY: {
 			std::list<PromelaParserNode*>::iterator opIter = node->operands.begin();
@@ -515,6 +524,10 @@ void PromelaDataModel::setEvent(const Event& event) {
 			PromelaParserNode* name = *opIter++;
 			PromelaParserNode* expr = *opIter++;
 
+			if (!_variables.hasKey(name->value)) {
+				ERROR_EXECUTION_THROW("Variable " + name->value + " is undeclared");
+			}
+
 			// is the location an array?
 			if (!_variables[name->value].hasKey("size")) {
 				ERROR_EXECUTION_THROW("Variable " + name->value + " is no array");
@@ -532,6 +545,10 @@ void PromelaDataModel::setEvent(const Event& event) {
 		}
 		case PML_NAME: {
 			// location is an array, but no array was passed
+			if (!_variables.hasKey(node->value)) {
+				ERROR_EXECUTION_THROW("Variable " + node->value + " is undeclared");
+			}
+
 			if (_variables[node->value].hasKey("size")) {
 				if (value.compound.size() > 0 || value.atom.size() > 0)
 					ERROR_EXECUTION_THROW("Variable " + node->value + " is an array");
@@ -547,6 +564,10 @@ void PromelaDataModel::setEvent(const Event& event) {
 			std::list<PromelaParserNode*>::iterator opIter = node->operands.begin();
 			PromelaParserNode* name = *opIter++;
 
+			if (!_variables.hasKey(name->value)) {
+				ERROR_EXECUTION_THROW("Variable " + name->value + " is undeclared");
+			}
+
 			// location is no array
 			if (_variables[name->value].hasKey("size")) {
 				ERROR_EXECUTION_THROW("Variable " + name->value + " is an array");
@@ -657,38 +678,43 @@ void PromelaDataModel::setEvent(const Event& event) {
 		default:
 			ERROR_EXECUTION_THROW("Retrieving value of " + PromelaParserNode::typeToDesc(node->type) + " variable not implemented");
 		}
-		return 0;
+		return Data(0, Data::INTERPRETED);
 	}
 
-	std::string PromelaDataModel::andExpressions(std::list<std::string> expressions) {
+	void PromelaDataModel::assign(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
+		PromelaParser parser(location);
+		if (data.atom.size() > 0 && data.type == Data::INTERPRETED) {
+			setVariable(parser.ast, evalAsData(data.atom));
+		} else {
+			setVariable(parser.ast, data);
+		}
+	}
 
-		if (expressions.size() == 0)
-			return "";
+	void PromelaDataModel::init(const std::string& location, const Data& data, const std::map<std::string, std::string>& attr) {
+		{
+			std::string type = (attr.find("type") != attr.end() ? attr.at("type") : "auto");
+			std::string arrSize;
 
-		if (expressions.size() == 1)
-			return *(expressions.begin());
+			size_t bracketPos = type.find("[");
+			if (bracketPos != std::string::npos) {
+				arrSize = type.substr(bracketPos, type.length() - bracketPos);
+				type = type.substr(0, bracketPos);
+			}
 
-		std::ostringstream exprSS;
-		exprSS << "(";
-		std::string conjunction = "";
-		for (std::list<std::string>::const_iterator exprIter = expressions.begin();
-		        exprIter != expressions.end();
-		        exprIter++) {
-			exprSS << conjunction << "(" << *exprIter << ")";
-			conjunction = " && ";
+			std::string expr = type + " " + location + arrSize;
+			PromelaParser parser(expr, 1, PromelaParser::PROMELA_DECL);
+			evaluateDecl(parser.ast);
 		}
-		exprSS << ")";
-		return exprSS.str();
-	}
 
-	void PromelaDataModel::assign(const std::string& location, const Data& data) {
-		// used for e.g. to assign command line parameters and idlocation
 		PromelaParser parser(location);
-		setVariable(parser.ast, data);
-	}
-
-	void PromelaDataModel::init(const std::string& location, const Data& data) {
-		assign(location, data);
+		if (data.atom.size() > 0 && data.type == Data::INTERPRETED) {
+			Data d = Data::fromJSON(data);
+			if (!d.empty())
+				setVariable(parser.ast, Data::fromJSON(data));
+			setVariable(parser.ast, data);
+		} else {
+			setVariable(parser.ast, data);
+		}
 	}
 
 	bool PromelaDataModel::isDeclared(const std::string& expr) {
diff --git a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h
index 2c1f58d..4a763ac 100644
--- a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h
+++ b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h
@@ -60,10 +60,12 @@ public:
 
 	virtual bool isDeclared(const std::string& expr);
 
-	virtual void assign(const std::string& location, const Data& data);
-	virtual void init(const std::string& location, const Data& data);
-
-	virtual std::string andExpressions(std::list<std::string>);
+	virtual void assign(const std::string& location,
+	                    const Data& data,
+	                    const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
+	virtual void init(const std::string& location,
+	                  const Data& data,
+	                  const std::map<std::string, std::string>& attr = std::map<std::string, std::string>());
 
 protected:
 
diff --git a/src/uscxml/plugins/datamodel/promela/PromelaParser.h b/src/uscxml/plugins/datamodel/promela/PromelaParser.h
index 51a2111..236233d 100644
--- a/src/uscxml/plugins/datamodel/promela/PromelaParser.h
+++ b/src/uscxml/plugins/datamodel/promela/PromelaParser.h
@@ -83,7 +83,7 @@ public:
 	PromelaParserNode* ast;
 	Type type;
 
-	Event pendingException;
+	ErrorEvent pendingException;
 	operator bool() const {
 		return ast != NULL;
 	}
diff --git a/src/uscxml/plugins/invoker/dirmon/DirMonInvoker.cpp b/src/uscxml/plugins/invoker/dirmon/DirMonInvoker.cpp
index d6d0f99..b5d7e8b 100644
--- a/src/uscxml/plugins/invoker/dirmon/DirMonInvoker.cpp
+++ b/src/uscxml/plugins/invoker/dirmon/DirMonInvoker.cpp
@@ -65,7 +65,7 @@ DirMonInvoker::~DirMonInvoker() {
 
 std::shared_ptr<InvokerImpl> DirMonInvoker::create(InterpreterImpl* interpreter) {
 	std::shared_ptr<DirMonInvoker> invoker(new DirMonInvoker());
-	invoker->_interpreter = interpreter;
+	invoker->_callbacks = interpreter;
 	return invoker;
 }
 
@@ -99,7 +99,7 @@ void DirMonInvoker::eventFromSCXML(const Event& event) {
 
 void DirMonInvoker::invoke(const std::string& source, const Event& req) {
 	if (req.params.find("dir") == req.params.end()) {
-		LOG(_interpreter->getLogger(), USCXML_ERROR) << "No dir param given";
+		LOG(_callbacks->getLogger(), USCXML_ERROR) << "No dir param given";
 		return;
 	}
 
@@ -134,10 +134,10 @@ void DirMonInvoker::invoke(const std::string& source, const Event& req) {
 	std::multimap<std::string, Data>::const_iterator dirIter = req.params.find("dir");
 	while(dirIter != req.params.upper_bound("dir")) {
 		// this is simplified - Data might be more elaborate than a simple string atom
-		URL url = URL::resolve(dirIter->second.atom, _interpreter->getBaseURL());
+		URL url = URL::resolve(dirIter->second.atom, _callbacks->getBaseURL());
 
 		if (!url.isAbsolute()) {
-			LOG(_interpreter->getLogger(), USCXML_ERROR) << "Given directory '" << dirIter->second << "' cannot be transformed to absolute path";
+			LOG(_callbacks->getLogger(), USCXML_ERROR) << "Given directory '" << dirIter->second << "' cannot be transformed to absolute path";
 		} else {
 			_dir = url.path();
 		}
@@ -145,7 +145,7 @@ void DirMonInvoker::invoke(const std::string& source, const Event& req) {
 	}
 
 	_watcher = new DirectoryWatch(_dir, _recurse);
-	_watcher->setLogger(_interpreter->getLogger());
+	_watcher->setLogger(_callbacks->getLogger());
 	_watcher->addMonitor(this);
 	_watcher->updateEntries(true);
 
diff --git a/src/uscxml/plugins/invoker/scxml/USCXMLInvoker.cpp b/src/uscxml/plugins/invoker/scxml/USCXMLInvoker.cpp
index 0f7cc24..9ac8621 100644
--- a/src/uscxml/plugins/invoker/scxml/USCXMLInvoker.cpp
+++ b/src/uscxml/plugins/invoker/scxml/USCXMLInvoker.cpp
@@ -134,7 +134,7 @@ void USCXMLInvoker::run(void* instance) {
 		e.eventType = Event::PLATFORM;
 		e.invokeid = INSTANCE->_invokedInterpreter.getImpl()->getInvokeId();
 		e.name = "done.invoke." + e.invokeid;
-		INSTANCE->_interpreter->enqueueExternal(e);
+		INSTANCE->_callbacks->enqueueExternal(e);
 	}
 
 	INSTANCE->_isActive = false;
@@ -142,7 +142,7 @@ void USCXMLInvoker::run(void* instance) {
 
 std::shared_ptr<InvokerImpl> USCXMLInvoker::create(InterpreterImpl* interpreter) {
 	std::shared_ptr<USCXMLInvoker> invoker(new USCXMLInvoker());
-	invoker->_interpreter = interpreter;
+	invoker->_callbacks = interpreter;
 	return invoker;
 }
 
@@ -163,10 +163,10 @@ void USCXMLInvoker::invoke(const std::string& source, const Event& invokeEvent)
 		document->appendChild(newNode);
 
 		// TODO: where do we get the namespace from?
-		_invokedInterpreter = Interpreter::fromDocument(document, _interpreter->getBaseURL(), false);
+		_invokedInterpreter = Interpreter::fromDocument(document, _callbacks->getBaseURL(), false);
 	} else if (invokeEvent.data.atom.size() > 0) {
 		// test530 when deserializing
-		_invokedInterpreter = Interpreter::fromXML(invokeEvent.data.atom, _interpreter->getBaseURL());
+		_invokedInterpreter = Interpreter::fromXML(invokeEvent.data.atom, _callbacks->getBaseURL());
 
 	} else {
 		_isActive = false;
@@ -181,17 +181,17 @@ void USCXMLInvoker::invoke(const std::string& source, const Event& invokeEvent)
 		// create new instances from the parent's ActionLanguage
 #if 1
 		InterpreterImpl* invoked = _invokedInterpreter.getImpl().get();
-		invoked->_execContent = _interpreter->_execContent.getImpl()->create(invoked);
-		invoked->_delayQueue = _interpreter->_delayQueue.getImplDelayed()->create(invoked);
-		invoked->_internalQueue = _interpreter->_internalQueue.getImplBase()->create();
-		invoked->_externalQueue = _interpreter->_externalQueue.getImplBase()->create();
-		invoked->_microStepper = _interpreter->_microStepper.getImpl()->create(invoked);
+		invoked->_execContent = _callbacks->_execContent.getImpl()->create(invoked);
+		invoked->_delayQueue = _callbacks->_delayQueue.getImplDelayed()->create(invoked);
+		invoked->_internalQueue = _callbacks->_internalQueue.getImplBase()->create();
+		invoked->_externalQueue = _callbacks->_externalQueue.getImplBase()->create();
+		invoked->_microStepper = _callbacks->_microStepper.getImpl()->create(invoked);
 
 		// TODO: setup invokers dom, check datamodel attribute and create new instance from parent if matching?
 #endif
 		// copy monitors
-		std::set<InterpreterMonitor*>::const_iterator monIter = _interpreter->_monitors.begin();
-		while(monIter != _interpreter->_monitors.end()) {
+		std::set<InterpreterMonitor*>::const_iterator monIter = _callbacks->_monitors.begin();
+		while(monIter != _callbacks->_monitors.end()) {
 			if ((*monIter)->copyToInvokers()) {
 				_invokedInterpreter.getImpl()->_monitors.insert(*monIter);
 			}
diff --git a/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp b/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp
index d6993dc..cc0c9d4 100644
--- a/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp
+++ b/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp
@@ -72,16 +72,16 @@ BasicHTTPIOProcessor::~BasicHTTPIOProcessor() {
 }
 
 
-std::shared_ptr<IOProcessorImpl> BasicHTTPIOProcessor::create(InterpreterImpl* interpreter) {
+std::shared_ptr<IOProcessorImpl> BasicHTTPIOProcessor::create(IOProcessorCallbacks* callbacks) {
 	std::shared_ptr<BasicHTTPIOProcessor> io(new BasicHTTPIOProcessor());
-	io->_interpreter = interpreter;
+	io->_callbacks = callbacks;
 
 	// register at http server
-	std::string path = interpreter->getName();
+	std::string path = callbacks->getName();
 	int i = 2;
 	while (!HTTPServer::registerServlet(path + "/basichttp", io.get())) {
 		std::stringstream ss;
-		ss << interpreter->getName() << i++;
+		ss << callbacks->getName() << i++;
 		path = ss.str();
 	}
 
@@ -184,7 +184,7 @@ void BasicHTTPIOProcessor::eventFromSCXML(const std::string& target, const Event
 
 	// TODO: is this still needed with isValidTarget()?
 	if (target.length() == 0) {
-		_interpreter->enqueueInternal(Event("error.communication", Event::PLATFORM));
+		_callbacks->enqueueInternal(Event("error.communication", Event::PLATFORM));
 		return;
 	}
 
diff --git a/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.h b/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.h
index b70ce8e..dec22fe 100644
--- a/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.h
+++ b/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.h
@@ -59,7 +59,7 @@ class USCXML_PLUGIN_API BasicHTTPIOProcessor : public IOProcessorImpl, public HT
 public:
 	BasicHTTPIOProcessor();
 	virtual ~BasicHTTPIOProcessor();
-	virtual std::shared_ptr<IOProcessorImpl> create(uscxml::InterpreterImpl* interpreter);
+	virtual std::shared_ptr<IOProcessorImpl> create(uscxml::IOProcessorCallbacks* callbacks);
 
 	virtual std::list<std::string> getNames() {
 		std::list<std::string> names;
@@ -102,4 +102,4 @@ PLUMA_INHERIT_PROVIDER(BasicHTTPIOProcessor, IOProcessorImpl);
 
 }
 
-#endif /* end of include guard: BASICHTTPIOPROCESSOR_H_2CUY93KU */
\ No newline at end of file
+#endif /* end of include guard: BASICHTTPIOPROCESSOR_H_2CUY93KU */
diff --git a/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.cpp b/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.cpp
index c53915b..5a82860 100644
--- a/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.cpp
+++ b/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.cpp
@@ -41,16 +41,16 @@ SCXMLIOProcessor::~SCXMLIOProcessor() {
 }
 
 
-std::shared_ptr<IOProcessorImpl> SCXMLIOProcessor::create(InterpreterImpl* interpreter) {
+std::shared_ptr<IOProcessorImpl> SCXMLIOProcessor::create(IOProcessorCallbacks* callbacks) {
 	std::shared_ptr<SCXMLIOProcessor> io(new SCXMLIOProcessor());
-	io->_interpreter = interpreter;
+	io->_callbacks = callbacks;
 	return io;
 }
 
 Data SCXMLIOProcessor::getDataModelVariables() {
 	Data data;
 
-	data.compound["location"] = Data("#_scxml_" + _interpreter->getSessionId(), Data::VERBATIM);
+	data.compound["location"] = Data("#_scxml_" + _callbacks->getSessionId(), Data::VERBATIM);
 
 	return data;
 }
@@ -71,7 +71,7 @@ void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& ev
 	eventCopy.origintype = "http://www.w3.org/TR/scxml/#SCXMLEventProcessor";
 
 	// test 336
-	eventCopy.origin = "#_scxml_" + _interpreter->getSessionId();
+	eventCopy.origin = "#_scxml_" + _callbacks->getSessionId();
 
 	if (false) {
 	} else if(target.length() == 0) {
@@ -85,14 +85,14 @@ void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& ev
 //		reqCopy.sendid = "";
 
 		// test 198
-		_interpreter->enqueueExternal(eventCopy);
+		_callbacks->enqueueExternal(eventCopy);
 
 	} else if (iequals(target, "#_internal")) {
 		/**
 		 * #_internal: If the target is the special term '#_internal', the Processor
 		 * must add the event to the internal event queue of the sending session.
 		 */
-		_interpreter->enqueueInternal(eventCopy);
+		_callbacks->enqueueInternal(eventCopy);
 
 	} else if (iequals(target, "#_parent")) {
 		/**
@@ -100,13 +100,7 @@ void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& ev
 		 * add the event to the external event queue of the SCXML session that invoked
 		 * the sending session, if there is one.
 		 */
-
-		if (_interpreter->_parentQueue) {
-			_interpreter->_parentQueue.enqueue(eventCopy);
-		} else {
-			ERROR_COMMUNICATION_THROW("Sending to parent invoker, but none is set");
-		}
-
+		_callbacks->enqueueAtParent(eventCopy);
 	} else if (target.length() > 8 && iequals(target.substr(0, 8), "#_scxml_")) {
 		/**
 		 * #_scxml_sessionid: If the target is the special term '#_scxml_sessionid',
@@ -117,7 +111,7 @@ void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& ev
 		 */
 		std::string sessionId = target.substr(8);
 
-		std::lock_guard<std::recursive_mutex> lock(_interpreter->_instanceMutex);
+		std::lock_guard<std::recursive_mutex> lock(InterpreterImpl::_instanceMutex);
 		std::map<std::string, std::weak_ptr<InterpreterImpl> > instances = InterpreterImpl::getInstances();
 		if (instances.find(sessionId) != instances.end()) {
 			std::shared_ptr<InterpreterImpl> otherSession = instances[sessionId].lock();
@@ -138,21 +132,7 @@ void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& ev
 		 * session.
 		 */
 		std::string invokeId = target.substr(2);
-		if (_interpreter->_invokers.find(invokeId) != _interpreter->_invokers.end()) {
-			std::lock_guard<std::recursive_mutex> lock(_interpreter->_instanceMutex);
-			try {
-				_interpreter->_invokers[invokeId].eventFromSCXML(eventCopy);
-			} catch(Event e) {
-				// Is this the right thing to do?
-//				_interpreter->enqueueExternal(eventCopy);
-			} catch (const std::exception &e) {
-				ERROR_COMMUNICATION_THROW("Exception caught while sending event to invoker '" + invokeId + "': " + e.what());
-			} catch(...) {
-				ERROR_COMMUNICATION_THROW("Exception caught while sending event to invoker '" + invokeId + "'");
-			}
-		} else {
-			ERROR_COMMUNICATION_THROW("Can not send to invoked component '" + invokeId + "', no such invokeId");
-		}
+		_callbacks->enqueueAtInvoker(invokeId, eventCopy);
 	} else {
 		ERROR_COMMUNICATION_THROW("Not sure what to make of the target '" + target + "' - raising error");
 	}
@@ -160,4 +140,4 @@ void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& ev
 
 
 
-}
\ No newline at end of file
+}
diff --git a/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.h b/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.h
index 21fd13a..6494873 100644
--- a/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.h
+++ b/src/uscxml/plugins/ioprocessor/scxml/SCXMLIOProcessor.h
@@ -32,7 +32,7 @@ class SCXMLIOProcessor : public IOProcessorImpl {
 public:
 	SCXMLIOProcessor();
 	virtual ~SCXMLIOProcessor();
-	virtual std::shared_ptr<IOProcessorImpl> create(uscxml::InterpreterImpl* interpreter);
+	virtual std::shared_ptr<IOProcessorImpl> create(uscxml::IOProcessorCallbacks* callbacks);
 
 	virtual std::list<std::string> getNames() {
 		std::list<std::string> names;
@@ -46,7 +46,7 @@ public:
 
 	Data getDataModelVariables();
 protected:
-	InterpreterImpl* _interpreter;
+	IOProcessorCallbacks* _callbacks;
 };
 
 #ifdef BUILD_AS_PLUGINS
@@ -55,4 +55,4 @@ PLUMA_INHERIT_PROVIDER(SCXMLIOProcessor, IOProcessorImpl);
 
 }
 
-#endif /* end of include guard: SCXMLIOProcessor_H_2CUY93KU */
\ No newline at end of file
+#endif /* end of include guard: SCXMLIOProcessor_H_2CUY93KU */