11 files changed, 252 insertions, 249 deletions

diff --git a/src/bindings/swig/uscxml_beautify.i b/src/bindings/swig/uscxml_beautify.i
index 0c17e2a..159bcaa 100644
--- a/src/bindings/swig/uscxml_beautify.i
+++ b/src/bindings/swig/uscxml_beautify.i
@@ -2,8 +2,8 @@
 %rename(ActionLanguage) WrappedActionLanguage;
 %rename(NativeDataModel) DataModel;
 %rename(DataModel) WrappedDataModel;
-%rename(NativeDataModelExtension) DataModelExtension;
-%rename(DataModelExtension) WrappedDataModelExtension;
+//%rename(NativeDataModelExtension) DataModelExtension;
+//%rename(DataModelExtension) WrappedDataModelExtension;
 %rename(NativeExecutableContent) ExecutableContent;
 %rename(ExecutableContent) WrappedExecutableContent;
 %rename(NativeInvoker) Invoker;
diff --git a/src/bindings/swig/wrapped/WrappedActionLanguage.h b/src/bindings/swig/wrapped/WrappedActionLanguage.h
index f26329e..55e009c 100644
--- a/src/bindings/swig/wrapped/WrappedActionLanguage.h
+++ b/src/bindings/swig/wrapped/WrappedActionLanguage.h
@@ -19,7 +19,7 @@
 
 #ifndef WRAPPEDACTIONLANGUAGE_H_020AFC96
 #define WRAPPEDACTIONLANGUAGE_H_020AFC96
-	
+
 #include <vector>
 #include <list>
 #include <ostream>
@@ -37,10 +37,10 @@ class DataModelImpl;
 class WrappedActionLanguage : public ActionLanguage {
 public:
 
-		WrappedActionLanguage();
-		virtual ~WrappedActionLanguage();
+	WrappedActionLanguage();
+	virtual ~WrappedActionLanguage();
 
-		void setDataModel(DataModelImpl* dm);
+	void setDataModel(DataModelImpl* dm);
 };
 
 }
diff --git a/src/bindings/swig/wrapped/WrappedDataModel.h b/src/bindings/swig/wrapped/WrappedDataModel.h
index 49a3482..1fefcbe 100644
--- a/src/bindings/swig/wrapped/WrappedDataModel.h
+++ b/src/bindings/swig/wrapped/WrappedDataModel.h
@@ -35,62 +35,65 @@ namespace uscxml {
 class WrappedDataModel : public DataModelImpl {
 public:
 
-    WrappedDataModel();
-    virtual ~WrappedDataModel();
-    
-    virtual std::shared_ptr<DataModelImpl> create(DataModelCallbacks* callbacks) {
-        std::shared_ptr<WrappedDataModel> dm(create());
-        dm->callbacks = callbacks;
-        return dm;
-    }
-        
-    virtual std::list<std::string> getNames() {
-        return std::list<std::string>();
-    }
-    
-		virtual WrappedDataModel* create() {
-			return new WrappedDataModel();
-		}
-		
-    virtual bool isValidSyntax(const std::string& expr) {
-        return true;
-    }
-    
-    virtual void setEvent(const Event& event) {}
-    
-    // foreach
-    virtual uint32_t getLength(const std::string& expr) {
-        return 0;
-    }
-    
-    virtual void setForeach(const std::string& item,
-                            const std::string& array,
-                            const std::string& index,
-                            uint32_t iteration) {}
-    
-    virtual Data getAsData(const std::string& content) {
-        return Data();
-    }
-    virtual Data evalAsData(const std::string& expr) {
-        return Data();
-    }
-    virtual bool evalAsBool(const std::string& expr) {
-        return true;
-    }
-    
-    virtual bool isDeclared(const std::string& expr) {
-        return true;
-    }
-    
-    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>) {
-        return "";
-    }
+	WrappedDataModel();
+	virtual ~WrappedDataModel();
+
+	virtual std::shared_ptr<DataModelImpl> create(DataModelCallbacks* callbacks) {
+		std::shared_ptr<WrappedDataModel> dm(create());
+		dm->callbacks = callbacks;
+		return dm;
+	}
+
+	virtual std::list<std::string> getNames() {
+		return std::list<std::string>();
+	}
+
+	virtual WrappedDataModel* create() {
+		return new WrappedDataModel();
+	}
+
+	virtual bool isValidSyntax(const std::string& expr) {
+		return true;
+	}
+
+	virtual void setEvent(const Event& event) {}
+
+	// foreach
+	virtual uint32_t getLength(const std::string& expr) {
+		return 0;
+	}
+
+	virtual void setForeach(const std::string& item,
+	                        const std::string& array,
+	                        const std::string& index,
+	                        uint32_t iteration) {}
+
+	virtual Data getAsData(const std::string& content) {
+		return Data();
+	}
+	virtual Data evalAsData(const std::string& expr) {
+		return Data();
+	}
+	virtual bool evalAsBool(const std::string& expr) {
+		return true;
+	}
+
+	virtual bool isDeclared(const std::string& expr) {
+		return true;
+	}
+
+	virtual void assign(const std::string& location, const Data& data) {}
+	virtual void init(const std::string& location, const Data& data) {}
+
+	virtual void addExtension(DataModelExtension* ext) {
+	}
+
+	virtual std::string andExpressions(std::list<std::string>) {
+		return "";
+	}
 
 protected:
-    DataModelCallbacks* callbacks;
+	DataModelCallbacks* callbacks;
 };
 
 }
diff --git a/src/bindings/swig/wrapped/WrappedExecutableContent.cpp b/src/bindings/swig/wrapped/WrappedExecutableContent.cpp
index 09aa6fd..3587cb5 100644
--- a/src/bindings/swig/wrapped/WrappedExecutableContent.cpp
+++ b/src/bindings/swig/wrapped/WrappedExecutableContent.cpp
@@ -28,16 +28,16 @@ WrappedExecutableContent::WrappedExecutableContent() {}
 WrappedExecutableContent::~WrappedExecutableContent() {}
 
 void WrappedExecutableContent::enterElement(XERCESC_NS::DOMElement* element) {
-    std::stringstream ss;
-    ss << *element;
-    enterElement(ss.str());
+	std::stringstream ss;
+	ss << *element;
+	enterElement(ss.str());
 }
 
 void WrappedExecutableContent::exitElement(XERCESC_NS::DOMElement* element) {
-    std::stringstream ss;
-    ss << *element;
-    exitElement(ss.str());
+	std::stringstream ss;
+	ss << *element;
+	exitElement(ss.str());
 }
 
-    
+
 }
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedExecutableContent.h b/src/bindings/swig/wrapped/WrappedExecutableContent.h
index 0ba8d3e..6786b0a 100644
--- a/src/bindings/swig/wrapped/WrappedExecutableContent.h
+++ b/src/bindings/swig/wrapped/WrappedExecutableContent.h
@@ -35,9 +35,9 @@ public:
 	virtual ~WrappedExecutableContent();
 
 	virtual std::shared_ptr<ExecutableContentImpl> create(InterpreterImpl* interpreter) {
-        std::shared_ptr<WrappedExecutableContent> ec(new WrappedExecutableContent());
-        return ec;
-    }
+		std::shared_ptr<WrappedExecutableContent> ec(new WrappedExecutableContent());
+		return ec;
+	}
 
 	virtual std::string getLocalName() {
 		return "";
@@ -47,16 +47,16 @@ public:
 		return "http://www.w3.org/2005/07/scxml";
 	}
 
-    
-    void enterElement(XERCESC_NS::DOMElement* element);
-    virtual void enterElement(const std::string& elementXML) {}
-    
-    void exitElement(XERCESC_NS::DOMElement* element);
-    virtual void exitElement(const std::string& elementXML) {}
 
-    virtual bool processChildren() {
-        return true;
-    }
+	void enterElement(XERCESC_NS::DOMElement* element);
+	virtual void enterElement(const std::string& elementXML) {}
+
+	void exitElement(XERCESC_NS::DOMElement* element);
+	virtual void exitElement(const std::string& elementXML) {}
+
+	virtual bool processChildren() {
+		return true;
+	}
 
 };
 
diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.cpp b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
index d034bc3..6c96840 100644
--- a/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
+++ b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
@@ -22,7 +22,7 @@
 namespace uscxml {
 
 WrappedIOProcessor::WrappedIOProcessor(InterpreterImpl* interpreter) {
-  _interpreter = interpreter;
+	_interpreter = interpreter;
 }
 WrappedIOProcessor::~WrappedIOProcessor() {}
 
diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.h b/src/bindings/swig/wrapped/WrappedIOProcessor.h
index aa5f967..f1820a4 100644
--- a/src/bindings/swig/wrapped/WrappedIOProcessor.h
+++ b/src/bindings/swig/wrapped/WrappedIOProcessor.h
@@ -39,23 +39,23 @@ public:
 	WrappedIOProcessor(InterpreterImpl* interpreter);
 	virtual ~WrappedIOProcessor();
 
-    virtual std::list<std::string> getNames() {
-        return std::list<std::string>();
-    };
+	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));
-			return ioProc;
-    }
-    
-    virtual void eventFromSCXML(const std::string& target, const Event& event) {}
-    virtual bool isValidTarget(const std::string& target) {
-        return true;
-    }
+	virtual std::shared_ptr<IOProcessorImpl> create(InterpreterImpl* interpreter) {
+		std::shared_ptr<IOProcessorImpl> ioProc = std::shared_ptr<IOProcessorImpl>(new WrappedIOProcessor(interpreter));
+		return ioProc;
+	}
 
-    virtual Data getDataModelVariables() {
-        return Data();
-    }
+	virtual void eventFromSCXML(const std::string& target, const Event& event) {}
+	virtual bool isValidTarget(const std::string& target) {
+		return true;
+	}
+
+	virtual Data getDataModelVariables() {
+		return Data();
+	}
 };
 
 }
diff --git a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp
index cdb46de..f563539 100644
--- a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp
+++ b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp
@@ -26,122 +26,122 @@
 namespace uscxml {
 
 using namespace XERCESC_NS;
-    
+
 WrappedInterpreterMonitor::WrappedInterpreterMonitor() {}
 WrappedInterpreterMonitor::~WrappedInterpreterMonitor() {}
 
 void WrappedInterpreterMonitor::beforeExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
-    std::stringstream ss;
-    ss << *state;
-    beforeExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+	std::stringstream ss;
+	ss << *state;
+	beforeExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
 }
 
 void WrappedInterpreterMonitor::afterExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
-    std::stringstream ss;
-    ss << *state;
-    afterExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+	std::stringstream ss;
+	ss << *state;
+	afterExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
 }
 
 void WrappedInterpreterMonitor::beforeExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content) {
-    std::stringstream ss;
-    ss << *content;
-    beforeExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str());
+	std::stringstream ss;
+	ss << *content;
+	beforeExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str());
 }
 
 void WrappedInterpreterMonitor::afterExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content) {
-    std::stringstream ss;
-    ss << *content;
-    afterExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str());
+	std::stringstream ss;
+	ss << *content;
+	afterExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str());
 }
 
 void WrappedInterpreterMonitor::beforeUninvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
-    std::stringstream ss;
-    ss << *invoker;
-    std::string invokeId;
-    if (invoker->getUserData(X("invokeid")) != NULL) {
-        invokeId = (char*)invoker->getUserData(X("invokeid"));
-    }
-
-    beforeUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+	std::stringstream ss;
+	ss << *invoker;
+	std::string invokeId;
+	if (invoker->getUserData(X("invokeid")) != NULL) {
+		invokeId = (char*)invoker->getUserData(X("invokeid"));
+	}
+
+	beforeUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
 }
 
 void WrappedInterpreterMonitor::afterUninvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
-    std::stringstream ss;
-    ss << *invoker;
-    std::string invokeId;
-    if (invoker->getUserData(X("invokeid")) != NULL) {
-        invokeId = (char*)invoker->getUserData(X("invokeid"));
-    }
-    
-    afterUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+	std::stringstream ss;
+	ss << *invoker;
+	std::string invokeId;
+	if (invoker->getUserData(X("invokeid")) != NULL) {
+		invokeId = (char*)invoker->getUserData(X("invokeid"));
+	}
+
+	afterUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
 }
 
 void WrappedInterpreterMonitor::beforeTakingTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition) {
-    XERCESC_NS::DOMElement* sourceState = getSourceState(transition);
-    const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml");
-
-    std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root);
-    
-    std::stringstream ss;
-    ss << *transition;
-    
-    std::list<std::string> targets;
-    for (auto t : targetStates) {
-        targets.push_back(ATTR_CAST(t, "id"));
-    }
-    
-    beforeTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str());
+	XERCESC_NS::DOMElement* sourceState = getSourceState(transition);
+	const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml");
+
+	std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root);
+
+	std::stringstream ss;
+	ss << *transition;
+
+	std::list<std::string> targets;
+	for (auto t : targetStates) {
+		targets.push_back(ATTR_CAST(t, "id"));
+	}
+
+	beforeTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str());
 }
 
 void WrappedInterpreterMonitor::afterTakingTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition) {
-    XERCESC_NS::DOMElement* sourceState = getSourceState(transition);
-    const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml");
-    
-    std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root);
-    
-    std::stringstream ss;
-    ss << *transition;
-    
-    std::list<std::string> targets;
-    for (auto t : targetStates) {
-        targets.push_back(ATTR_CAST(t, "id"));
-    }
-    
-    afterTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str());
+	XERCESC_NS::DOMElement* sourceState = getSourceState(transition);
+	const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml");
+
+	std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root);
+
+	std::stringstream ss;
+	ss << *transition;
+
+	std::list<std::string> targets;
+	for (auto t : targetStates) {
+		targets.push_back(ATTR_CAST(t, "id"));
+	}
+
+	afterTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str());
 }
 
 void WrappedInterpreterMonitor::beforeEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
-    std::stringstream ss;
-    ss << *state;
-    beforeEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+	std::stringstream ss;
+	ss << *state;
+	beforeEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
 }
 
 void WrappedInterpreterMonitor::afterEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
-    std::stringstream ss;
-    ss << *state;
-    afterEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+	std::stringstream ss;
+	ss << *state;
+	afterEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
 }
 
 void WrappedInterpreterMonitor::beforeInvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
-    std::stringstream ss;
-    ss << *invoker;
-    std::string invokeId;
-    if (invoker->getUserData(X("invokeid")) != NULL) {
-        invokeId = (char*)invoker->getUserData(X("invokeid"));
-    }
-    
-    beforeInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+	std::stringstream ss;
+	ss << *invoker;
+	std::string invokeId;
+	if (invoker->getUserData(X("invokeid")) != NULL) {
+		invokeId = (char*)invoker->getUserData(X("invokeid"));
+	}
+
+	beforeInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
 }
 
 void WrappedInterpreterMonitor::afterInvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
-    std::stringstream ss;
-    ss << *invoker;
-    std::string invokeId;
-    if (invoker->getUserData(X("invokeid")) != NULL) {
-        invokeId = (char*)invoker->getUserData(X("invokeid"));
-    }
-    
-    afterInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+	std::stringstream ss;
+	ss << *invoker;
+	std::string invokeId;
+	if (invoker->getUserData(X("invokeid")) != NULL) {
+		invokeId = (char*)invoker->getUserData(X("invokeid"));
+	}
+
+	afterInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
 }
 
 }
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h
index e05dad2..697a420 100644
--- a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h
+++ b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h
@@ -34,7 +34,7 @@
 
 // forward declare
 namespace XERCESC_NS {
-    class DOMElement;
+class DOMElement;
 }
 
 namespace uscxml {
@@ -44,100 +44,100 @@ public:
 	WrappedInterpreterMonitor();
 	virtual ~WrappedInterpreterMonitor();
 
-    virtual void beforeProcessingEvent(Interpreter& interpreter, const Event& event) {}
-    virtual void beforeMicroStep(Interpreter& interpreter) {}
+	virtual void beforeProcessingEvent(Interpreter& interpreter, const Event& event) {}
+	virtual void beforeMicroStep(Interpreter& interpreter) {}
 
-    void beforeExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
-    virtual void beforeExitingState(const std::string& stateId,
+	void beforeExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
+	virtual void beforeExitingState(const std::string& stateId,
 	                                const std::string& xpath,
 	                                const std::string& stateXML) {}
 
 
-    void afterExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
-    virtual void afterExitingState(const std::string& stateId,
-                                   const std::string& xpath,
-                                   const std::string& stateXML) {}
+	void afterExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
+	virtual void afterExitingState(const std::string& stateId,
+	                               const std::string& xpath,
+	                               const std::string& stateXML) {}
 
 
-    void beforeExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content);
-    virtual void beforeExecutingContent(const std::string& tagName,
+	void beforeExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content);
+	virtual void beforeExecutingContent(const std::string& tagName,
 	                                    const std::string& xpath,
 	                                    const std::string& contentXML) {}
 
 
-    void afterExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content);
-    virtual void afterExecutingContent(const std::string& tagName,
+	void afterExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content);
+	virtual void afterExecutingContent(const std::string& tagName,
 	                                   const std::string& xpath,
 	                                   const std::string& contentXML) {}
 
 
 	void beforeUninvoking(Interpreter& interpreter,
-                          const XERCESC_NS::DOMElement* invoker,
-                          const std::string& invokeid);
+	                      const XERCESC_NS::DOMElement* invoker,
+	                      const std::string& invokeid);
 	virtual void beforeUninvoking(const std::string& xpath,
 	                              const std::string& invokeid,
 	                              const std::string& invokerXML) {}
 
 
 	void afterUninvoking(Interpreter& interpreter,
-                         const XERCESC_NS::DOMElement* invoker,
-                         const std::string& invokeid);
-    virtual void afterUninvoking(const std::string& xpath,
+	                     const XERCESC_NS::DOMElement* invoker,
+	                     const std::string& invokeid);
+	virtual void afterUninvoking(const std::string& xpath,
 	                             const std::string& invokeid,
 	                             const std::string& invokerXML) {}
 
 
-    void beforeTakingTransition(Interpreter& interpreter,
-                                const XERCESC_NS::DOMElement* transition);
+	void beforeTakingTransition(Interpreter& interpreter,
+	                            const XERCESC_NS::DOMElement* transition);
 	virtual void beforeTakingTransition(const std::string& xpath,
 	                                    const std::string& source,
 	                                    const std::list<std::string>& targets,
 	                                    const std::string& transitionXML) {}
 
-    void afterTakingTransition(Interpreter& interpreter,
-                               const XERCESC_NS::DOMElement* transition);
-    virtual void afterTakingTransition(const std::string& xpath,
+	void afterTakingTransition(Interpreter& interpreter,
+	                           const XERCESC_NS::DOMElement* transition);
+	virtual void afterTakingTransition(const std::string& xpath,
 	                                   const std::string& source,
 	                                   const std::list<std::string>& targets,
 	                                   const std::string& transitionXML) {}
 
 
-    void beforeEnteringState(Interpreter& interpreter,
-                             const XERCESC_NS::DOMElement* state);
-    virtual void beforeEnteringState(const std::string& stateId,
+	void beforeEnteringState(Interpreter& interpreter,
+	                         const XERCESC_NS::DOMElement* state);
+	virtual void beforeEnteringState(const std::string& stateId,
 	                                 const std::string& xpath,
 	                                 const std::string& stateXML) {}
 
 
-    void afterEnteringState(Interpreter& interpreter,
-                            const XERCESC_NS::DOMElement* state);
-    virtual void afterEnteringState(const std::string& stateId,
+	void afterEnteringState(Interpreter& interpreter,
+	                        const XERCESC_NS::DOMElement* state);
+	virtual void afterEnteringState(const std::string& stateId,
 	                                const std::string& xpath,
 	                                const std::string& stateXML) {}
 
 
 	void beforeInvoking(Interpreter& interpreter,
-                        const XERCESC_NS::DOMElement* invoker,
-                        const std::string& invokeid);
-    virtual void beforeInvoking(const std::string& xpath,
+	                    const XERCESC_NS::DOMElement* invoker,
+	                    const std::string& invokeid);
+	virtual void beforeInvoking(const std::string& xpath,
 	                            const std::string& invokeid,
 	                            const std::string& invokerXML) {}
 
-    void afterInvoking(Interpreter& interpreter,
-                       const XERCESC_NS::DOMElement* invoker,
-                       const std::string& invokeid);
-    virtual void afterInvoking(const std::string& xpath,
+	void afterInvoking(Interpreter& interpreter,
+	                   const XERCESC_NS::DOMElement* invoker,
+	                   const std::string& invokeid);
+	virtual void afterInvoking(const std::string& xpath,
 	                           const std::string& invokeid,
 	                           const std::string& invokerXML) {}
 
-    virtual void afterMicroStep(Interpreter& interpreter) {}
-    virtual void onStableConfiguration(Interpreter& interpreter) {}
-    
-    virtual void beforeCompletion(Interpreter& interpreter) {}
-    virtual void afterCompletion(Interpreter& interpreter) {}
+	virtual void afterMicroStep(Interpreter& interpreter) {}
+	virtual void onStableConfiguration(Interpreter& interpreter) {}
+
+	virtual void beforeCompletion(Interpreter& interpreter) {}
+	virtual void afterCompletion(Interpreter& interpreter) {}
 
 	virtual void reportIssue(Interpreter& interpreter,
-                             const InterpreterIssue& issue) {}
+	                         const InterpreterIssue& issue) {}
 };
 
 }
diff --git a/src/bindings/swig/wrapped/WrappedInvoker.cpp b/src/bindings/swig/wrapped/WrappedInvoker.cpp
index ba76420..407323d 100644
--- a/src/bindings/swig/wrapped/WrappedInvoker.cpp
+++ b/src/bindings/swig/wrapped/WrappedInvoker.cpp
@@ -22,7 +22,7 @@
 namespace uscxml {
 
 WrappedInvoker::WrappedInvoker(InterpreterImpl* interpreter) {
-  _interpreter = interpreter;
+	_interpreter = interpreter;
 }
 WrappedInvoker::~WrappedInvoker() {}
 
diff --git a/src/bindings/swig/wrapped/WrappedInvoker.h b/src/bindings/swig/wrapped/WrappedInvoker.h
index 3eb4a22..bb5d1ba 100644
--- a/src/bindings/swig/wrapped/WrappedInvoker.h
+++ b/src/bindings/swig/wrapped/WrappedInvoker.h
@@ -33,7 +33,7 @@
 
 // forward declare
 namespace XERCESC_NS {
-    class DOMElement;
+class DOMElement;
 }
 
 namespace uscxml {
@@ -42,37 +42,37 @@ class WrappedInvoker : public InvokerImpl {
 public:
 	WrappedInvoker(InterpreterImpl* interpreter);
 	virtual ~WrappedInvoker();
-    
-    virtual std::list<std::string> getNames() {
-        return std::list<std::string>();
-    };
-
-    virtual std::shared_ptr<InvokerImpl> create(InterpreterImpl* interpreter) {
-    	std::shared_ptr<InvokerImpl> inv = std::shared_ptr<InvokerImpl>(new WrappedInvoker(interpreter));
-			return inv;
-    }
-    virtual void invoke(const std::string& source, const Event& invokeEvent) {}
-    virtual void uninvoke() {}
-
-    virtual void eventFromSCXML(const Event& event) {}
-    
-    virtual XERCESC_NS::DOMElement* getFinalize() {
-        return _finalize;
-    }
-    virtual void setFinalize(XERCESC_NS::DOMElement* finalize) {
-        _finalize = finalize;
-    }
-    virtual void setInvokeId(const std::string& invokeId) {
-        _invokeId = invokeId;
-    }
-		
-    virtual Data getDataModelVariables() {
-        return Data();
-    }
-		
-    void eventToSCXML(Event& event, const std::string& type, const std::string& invokeId, bool internal = false) {
-    	
-    }
+
+	virtual std::list<std::string> getNames() {
+		return std::list<std::string>();
+	};
+
+	virtual std::shared_ptr<InvokerImpl> create(InterpreterImpl* interpreter) {
+		std::shared_ptr<InvokerImpl> inv = std::shared_ptr<InvokerImpl>(new WrappedInvoker(interpreter));
+		return inv;
+	}
+	virtual void invoke(const std::string& source, const Event& invokeEvent) {}
+	virtual void uninvoke() {}
+
+	virtual void eventFromSCXML(const Event& event) {}
+
+	virtual XERCESC_NS::DOMElement* getFinalize() {
+		return _finalize;
+	}
+	virtual void setFinalize(XERCESC_NS::DOMElement* finalize) {
+		_finalize = finalize;
+	}
+	virtual void setInvokeId(const std::string& invokeId) {
+		_invokeId = invokeId;
+	}
+
+	virtual Data getDataModelVariables() {
+		return Data();
+	}
+
+	void eventToSCXML(Event& event, const std::string& type, const std::string& invokeId, bool internal = false) {
+
+	}
 
 private:
 	InterpreterImpl* _interpreter;