From 81aa1c79dd158aa7bc76876552e4b1d05ecea656 Mon Sep 17 00:00:00 2001 From: Stefan Radomski Date: Thu, 2 Apr 2015 13:44:48 +0200 Subject: Reactivated PHP bindings and some work on PROMELA --- CMakeLists.txt | 2 +- apps/uscxml-transform.cpp | 6 + contrib/cmake/FindPHP5.cmake | 8 +- contrib/cmake/USCXMLMacros.cmake | 2 +- src/bindings/CMakeLists.txt | 1 + src/bindings/swig/java/uscxml.i | 2 +- src/bindings/swig/php/CMakeLists.txt | 100 + src/bindings/swig/php/test.php | 85 + src/bindings/swig/php/uscxml.i | 406 +++ src/bindings/swig/php/uscxmlNativePHP.php | 3110 ++++++++++++++++++++ src/uscxml/DOMUtils.cpp | 6 + src/uscxml/DOMUtils.h | 1 + src/uscxml/Interpreter.cpp | 10 +- src/uscxml/Interpreter.h | 4 +- src/uscxml/messages/Data.h | 4 +- .../plugins/invoker/umundo/UmundoInvoker.cpp | 6 +- src/uscxml/plugins/invoker/umundo/UmundoInvoker.h | 2 +- src/uscxml/transform/ChartToPromela.cpp | 816 +++-- src/uscxml/transform/ChartToPromela.h | 130 +- test/src/test-predicates.cpp | 2 +- test/src/test-promela-parser.cpp | 56 + test/uscxml/promela/test-event-source-auto.scxml | 51 +- 22 files changed, 4246 insertions(+), 564 deletions(-) create mode 100644 src/bindings/swig/php/CMakeLists.txt create mode 100644 src/bindings/swig/php/test.php create mode 100644 src/bindings/swig/php/uscxml.i create mode 100644 src/bindings/swig/php/uscxmlNativePHP.php diff --git a/CMakeLists.txt b/CMakeLists.txt index edb8716..bed2f59 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1316,7 +1316,7 @@ endif() # enable config.h style compile time options and add as "uscxml/config.h" configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/uscxml/config.h) -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test/ctest/CTestCustom.ctest.in ${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.ctest @ONCE) +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test/ctest/CTestCustom.ctest.in ${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.ctest) ############################################################ # Some concluding remarks diff --git a/apps/uscxml-transform.cpp b/apps/uscxml-transform.cpp index 055c1ae..1e9c26d 100644 --- a/apps/uscxml-transform.cpp +++ b/apps/uscxml-transform.cpp @@ -232,6 +232,12 @@ int main(int argc, char** argv) { exit(EXIT_FAILURE); } + if (verbose) { + std::list issues = interpreter.validate(); + for (std::list::iterator issueIter = issues.begin(); issueIter != issues.end(); issueIter++) { + std::cerr << *issueIter << std::endl; + } + } if (outType == "pml") { if (outputFile.size() == 0 || outputFile == "-") { diff --git a/contrib/cmake/FindPHP5.cmake b/contrib/cmake/FindPHP5.cmake index eee8e3f..fded5fd 100644 --- a/contrib/cmake/FindPHP5.cmake +++ b/contrib/cmake/FindPHP5.cmake @@ -1,8 +1,8 @@ if (UNIX) - if (APPLE) - # mavericks broke it - will look into it eventually - return() - endif() + # if (APPLE) + # # mavericks broke it - will look into it eventually + # return() + # endif() if (NOT PHP_CONFIG) find_program(PHP_CONFIG NAMES php-config diff --git a/contrib/cmake/USCXMLMacros.cmake b/contrib/cmake/USCXMLMacros.cmake index 082caa0..aa48bcf 100644 --- a/contrib/cmake/USCXMLMacros.cmake +++ b/contrib/cmake/USCXMLMacros.cmake @@ -68,7 +68,7 @@ SET(TWO_PART_VERSION_REGEX "[0-9]+\\.[0-9]+") MACRO(THREE_PART_VERSION_TO_VARS version major minor patch) IF(${version} MATCHES ${THREE_PART_VERSION_REGEX}) STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" ${major} "${version}") - STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" ${minor} "${version}") + STRING(REGEX REPLACE "^[0-9]+\\.([0-9]+)\\.[0-9]+" "\\1" ${minor} "${version}") STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" ${patch} "${version}") ELSEIF(${version} MATCHES ${TWO_PART_VERSION_REGEX}) STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+" "\\1" ${major} "${version}") diff --git a/src/bindings/CMakeLists.txt b/src/bindings/CMakeLists.txt index edddc31..0a258b8 100644 --- a/src/bindings/CMakeLists.txt +++ b/src/bindings/CMakeLists.txt @@ -26,6 +26,7 @@ if (SWIG_FOUND) INCLUDE(${SWIG_USE_FILE}) add_subdirectory(swig/java) add_subdirectory(swig/csharp) + add_subdirectory(swig/php) if(SWIG_VERSION VERSION_LESS 3.0.0) message(STATUS "SWIG version > 3.0 is recommended, found ${SWIG_VERSION}") endif() diff --git a/src/bindings/swig/java/uscxml.i b/src/bindings/swig/java/uscxml.i index e9b6bf0..031b9c0 100644 --- a/src/bindings/swig/java/uscxml.i +++ b/src/bindings/swig/java/uscxml.i @@ -335,7 +335,7 @@ import java.util.LinkedList; %} %rename(getNameListNative) uscxml::Event::getNameList(); -%rename(getParamstNative) uscxml::Event::getParams(); +%rename(getParamsNative) uscxml::Event::getParams(); %rename(setNameListNative) uscxml::Event::setNameList(const std::map&); %rename(setParamsNative) uscxml::Event::setParams(const std::multimap&); %javamethodmodifiers uscxml::Event::getNameList() "private"; diff --git a/src/bindings/swig/php/CMakeLists.txt b/src/bindings/swig/php/CMakeLists.txt new file mode 100644 index 0000000..802f3a2 --- /dev/null +++ b/src/bindings/swig/php/CMakeLists.txt @@ -0,0 +1,100 @@ +# generate PHP module + +find_package(PHP5) +if(PHP5_FOUND) + include_directories(${PHP5_INCLUDE_PATH}) +else() + message(STATUS "No PHP5 libraries found - not building php module") + return() +endif() + +# copied from cmake's FindPHP4.cmake and adapted +if(APPLE) + # this is a hack for now + set(PHP_MODULE_CXX_FLAGS "${CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS} -Wl") + foreach(symbol + __efree + __emalloc + __estrdup + __estrndup + __object_init + __object_init_ex + __zend_get_parameters_array_ex + __zend_list_find + __zval_copy_ctor + __zval_copy_ctor_func + _add_property_zval_ex + _alloc_globals + _compiler_globals + _convert_to_double + _convert_to_long + _convert_to_boolean + __convert_to_string + _gc_remove_zval_from_buffer + _call_user_function + _php_sprintf + _executor_globals + _zend_get_constant + _zend_lookup_class + _zend_register_long_constant + _zval_is_true + _zend_error + _zend_hash_find + __zend_hash_add_or_update + _zend_register_internal_class_ex + _zend_register_list_destructors_ex + _zend_register_resource + _zend_rsrc_list_get_rsrc_type + _zend_wrong_param_count + _zend_throw_exception + _zval_used_for_init + ) + set(PHP_MODULE_CXX_FLAGS + "${PHP_MODULE_CXX_FLAGS},-U,${symbol}") + endforeach() +endif() + +#message(FATAL_ERROR "PHP_LDFLAGS: ${PHP_LDFLAGS}") + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +include_directories(${PHP_INCLUDE_DIRS}) + +SET(CMAKE_SWIG_FLAGS "") + +# we need ; to produce a space with the package .. weird +SET_SOURCE_FILES_PROPERTIES(uscxml.i PROPERTIES CPLUSPLUS ON) + +SWIG_ADD_MODULE(uscxmlNativePHP php5 uscxml.i) +foreach(PHP_LIBRARY ${PHP_LIBRARIES}) +# SWIG_LINK_LIBRARIES(uscxmlNativePHP ${PHP_LIBRARY}) +endforeach() +SWIG_LINK_LIBRARIES(uscxmlNativePHP uscxml) + +if (APPLE) + set_target_properties(uscxmlNativePHP PROPERTIES LINK_FLAGS ${PHP_MODULE_CXX_FLAGS}) +endif() + +set(PHP_COMPILE_FLAGS "-DSWIG") + +if (PHP_ZTS_ENABLED) + # we are only building php bindings for unices anyhow + set(PHP_COMPILE_FLAGS "${PHP_COMPILE_FLAGS} -DZTS") + set(PHP_COMPILE_FLAGS "${PHP_COMPILE_FLAGS} -DPTHREADS") +endif() +if (PHP_DEBUG_ENABLED) + set(PHP_COMPILE_FLAGS "${PHP_COMPILE_FLAGS} -DZEND_DEBUG") +endif() + +ADD_CUSTOM_COMMAND( + TARGET uscxmlNativePHP + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_BINARY_DIR}/uscxmlNativePHP.php + ${PROJECT_SOURCE_DIR}/src/bindings/swig/php/uscxmlNativePHP.php +) + +set_target_properties(uscxmlNativePHP PROPERTIES COMPILE_FLAGS ${PHP_COMPILE_FLAGS}) +set_target_properties(uscxmlNativePHP PROPERTIES FOLDER "Bindings") + +set(USCXML_LANGUAGE_BINDINGS "php ${USCXML_LANGUAGE_BINDINGS}") +set(USCXML_LANGUAGE_BINDINGS ${USCXML_LANGUAGE_BINDINGS} PARENT_SCOPE) diff --git a/src/bindings/swig/php/test.php b/src/bindings/swig/php/test.php new file mode 100644 index 0000000..739c6a1 --- /dev/null +++ b/src/bindings/swig/php/test.php @@ -0,0 +1,85 @@ +addMonitor($monitor); +$interpreter->interpret(); + +// interleave interpreter execution with this thread +$interpreter = Interpreter::fromURL('https://raw.githubusercontent.com/tklab-tud/uscxml/master/test/uscxml/test-invoked.scxml'); +$parentQueue = new ParentQueue(); +$interpreter->setParentQueue($parentQueue); + +while($interpreter->step() > 0) { + $event = $parentQueue->pop(); + print("Name: " . $event->getName() . "\n"); + print("Type: " . $event->getType() . "\n"); + print("Origin: " . $event->getOrigin() . "\n"); + print("OriginType: " . $event->getOriginType() . "\n"); + print("Content " . strlen($event->getContent()) . " bytes: \n'" . $event->getContent() . "'\n"); + + $namelist = $event->getNameList(); + print("Namelist ".$namelist->size()." elements: \n"); + $keys = $event->getNameListKeys(); + for ($i = 0; $i < $keys->size(); $i++) { + print($keys->get($i) . "\t" . Data::toJSON($namelist->get($keys->get($i))) . "\n"); + } + + $params = $event->getParamMap(); + print("Params ". $params->size() ." elements: \n"); + $keys = $event->getParamMapKeys(); + for ($i = 0; $i < $keys->size(); $i++) { + print($keys->get($i)."\n"); + $paramList = $params->get($keys->get($i)); + for ($j = 0; $j < $paramList->size(); $j++) { + print("\t" . Data::toJSON($paramList->get($i)) . "\n"); + } + } + +} + +?> \ No newline at end of file diff --git a/src/bindings/swig/php/uscxml.i b/src/bindings/swig/php/uscxml.i new file mode 100644 index 0000000..d737f96 --- /dev/null +++ b/src/bindings/swig/php/uscxml.i @@ -0,0 +1,406 @@ +%module(directors="1", allprotected="1") uscxmlNativePHP + +// provide a macro for the header files +#define SWIGIMPORTED 1 + +%include +%include +%include +%include +%include "../stl_set.i" +%include "../stl_list.i" + +//%include + +// these are needed at least for the templates to work +typedef uscxml::Blob Blob; +typedef uscxml::Data Data; +typedef uscxml::Event Event; +typedef uscxml::InvokeRequest InvokeRequest; +typedef uscxml::SendRequest SendRequest; +typedef uscxml::Invoker Invoker; +typedef uscxml::IOProcessor IOProcessor; +typedef uscxml::DataModel DataModel; +typedef uscxml::DataModelExtension DataModelExtension; +typedef uscxml::ExecutableContent ExecutableContent; +typedef uscxml::InvokerImpl InvokerImpl; +typedef uscxml::IOProcessorImpl IOProcessorImpl; +typedef uscxml::DataModelImpl DataModelImpl; +typedef uscxml::ExecutableContentImpl ExecutableContentImpl; +typedef uscxml::InterpreterIssue InterpreterIssue; + +%feature("director") uscxml::WrappedInvoker; +%feature("director") uscxml::WrappedDataModel; +%feature("director") uscxml::WrappedDataModelExtension; +%feature("director") uscxml::WrappedIOProcessor; +%feature("director") uscxml::WrappedExecutableContent; +%feature("director") uscxml::WrappedInterpreterMonitor; + +// disable warning related to unknown base class +#pragma SWIG nowarn=401 +// do not warn when we override symbols via extend +#pragma SWIG nowarn=302 +// do not warn when ignoring overrided method +#pragma SWIG nowarn=516 + +//%javaconst(1); + +%rename(equals) operator==; // signature is wrong, still useful +%rename(isValid) operator bool; + +//************************************************** +// This ends up in the generated wrapper code +//************************************************** + +%{ + +#include "../../../uscxml/Message.h" +#include "../../../uscxml/Factory.h" +#include "../../../uscxml/Interpreter.h" +#include "../../../uscxml/concurrency/BlockingQueue.h" +#include "../../../uscxml/server/HTTPServer.h" +//#include "../../../uscxml/debug/DebuggerServlet.h" + +#include "../wrapped/WrappedInvoker.h" +#include "../wrapped/WrappedDataModel.h" +#include "../wrapped/WrappedExecutableContent.h" +#include "../wrapped/WrappedIOProcessor.h" +#include "../wrapped/WrappedInterpreterMonitor.h" + +using namespace uscxml; +using namespace Arabica::DOM; + +// the wrapped* C++ classes get rid of DOM nodes and provide more easily wrapped base classes +#include "../wrapped/WrappedInvoker.cpp" +#include "../wrapped/WrappedDataModel.cpp" +#include "../wrapped/WrappedExecutableContent.cpp" +#include "../wrapped/WrappedIOProcessor.cpp" +#include "../wrapped/WrappedInterpreterMonitor.cpp" + +%} + +%insert("begin") %{ +void*** tsrm_ls; +%} + +#if 0 +%define WRAP_THROW_EXCEPTION( MATCH ) +%javaexception("org.uscxml.InterpreterException") MATCH { + try { + $action + } + catch ( uscxml::Event& e ) { + jclass eclass = jenv->FindClass("org/uscxml/InterpreterException"); + if ( eclass ) { + std::stringstream ss; + ss << std::endl << e; + jenv->ThrowNew( eclass, ss.str().c_str() ); + } + } +} +%enddef + +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromXML); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromURL); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::step); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::interpret); +#endif + +%define WRAP_HASHCODE( CLASSNAME ) +%extend CLASSNAME { + virtual int hashCode() { +/* std::cout << "Calc hashcode as " << (int)(size_t)self->getImpl().get() << std::endl << std::flush;*/ + return (int)(size_t)self->getImpl().get(); + } +}; +%enddef + +%define WRAP_TO_STRING( CLASSNAME ) +%extend CLASSNAME { + virtual std::string toString() { + std::stringstream ss; + ss << *self; + return ss.str(); + } +}; +%enddef + +WRAP_TO_STRING(uscxml::Event); +WRAP_TO_STRING(uscxml::Data); +WRAP_TO_STRING(uscxml::SendRequest); +WRAP_TO_STRING(uscxml::InvokeRequest); +WRAP_TO_STRING(uscxml::InterpreterIssue); + +WRAP_HASHCODE(uscxml::Interpreter); + +%include "../uscxml_ignores.i" + +// bytearray for Blob::data +// see: http://stackoverflow.com/questions/9934059/swig-technique-to-wrap-unsigned-binary-data + +%apply (char *STRING, size_t LENGTH) { (const char* data, size_t size) }; + +#if 0 +%typemap(jni) char* getData "jbyteArray" +%typemap(jtype) char* getData "byte[]" +%typemap(jstype) char* getData "byte[]" +%typemap(javaout) char* getData { + return $jnicall; +} + +%typemap(out) char* getData { + $result = JCALL1(NewByteArray, jenv, ((uscxml::Blob const *)arg1)->getSize()); + JCALL4(SetByteArrayRegion, jenv, $result, 0, ((uscxml::Blob const *)arg1)->getSize(), (jbyte *)$1); +} +#endif + +//*********************************************** +// Beautify important classes +//*********************************************** + +#if 0 +%javamethodmodifiers uscxml::Event::getParamMap() "private"; +%javamethodmodifiers uscxml::Event::getParamMapKeys() "private"; +%javamethodmodifiers uscxml::Event::setParamMap(const std::map >&) "private"; +%javamethodmodifiers uscxml::Event::getNameListKeys() "private"; +%javamethodmodifiers uscxml::Interpreter::getIOProcessorKeys() "private"; +%javamethodmodifiers uscxml::Interpreter::getInvokerKeys() "private"; +%javamethodmodifiers uscxml::Interpreter::getInvokers() "private"; +%javamethodmodifiers uscxml::Interpreter::getIOProcessors() "private"; +%javamethodmodifiers uscxml::Data::getCompoundKeys() "private"; + +%javamethodmodifiers uscxml::Blob::setData(const char* data, size_t length) "private"; +%javamethodmodifiers uscxml::Blob::setMimeType(const std::string& mimeType) "private"; +#endif + +%include "../uscxml_beautify.i" + + +%typemap(javaimports) uscxml::Interpreter %{ +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.LinkedList; +import java.net.URL; +%} + +%typemap(javacode) uscxml::Interpreter %{ + public static Interpreter fromURL(URL uri) throws org.uscxml.InterpreterException { + return Interpreter.fromURL(uri.toString()); + } + + public Map getIOProcessors() { + Map ioProcs = new HashMap(); + StringVector keys = getIOProcessorKeys(); + IOProcMap ioProcMap = getIOProcessorsNative(); + for (int i = 0; i < keys.size(); i++) { + ioProcs.put(keys.get(i), ioProcMap.get(keys.get(i))); + } + return ioProcs; + } + + public Map getInvokers() { + Map invokers = new HashMap(); + StringVector keys = getInvokerKeys(); + InvokerMap invokerMap = getInvokersNative(); + for (int i = 0; i < keys.size(); i++) { + invokers.put(keys.get(i), invokerMap.get(keys.get(i))); + } + return invokers; + } + + @Override + public boolean equals(Object other) { + if (other instanceof Interpreter) { + return equals((Interpreter)other); + } + return hashCode() == other.hashCode(); + } +%} + +#if 0 +%rename(getCompoundNative) uscxml::Data::getCompound(); +%rename(getArrayNative) uscxml::Data::getArray(); +%rename(setCompoundNative) uscxml::Data::setCompound(const std::map&); +%rename(setArrayNative) uscxml::Data::setArray(const std::list&); +%javamethodmodifiers uscxml::Data::getCompound() "private"; +%javamethodmodifiers uscxml::Data::getArray() "private"; +%javamethodmodifiers uscxml::Data::setCompound(const std::map&) "private"; +%javamethodmodifiers uscxml::Data::setArray(const std::list&) "private"; +%javamethodmodifiers uscxml::Data::getCompoundKeys() "private"; +#endif + +%typemap(javaimports) uscxml::Data %{ +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.LinkedList; +%} + +%typemap(javacode) uscxml::Data %{ + public Data(byte[] data, String mimeType) { + this(uscxmlNativeJavaJNI.new_Data__SWIG_0(), true); + setBinary(new Blob(data, mimeType)); + } + + public Data(Map compound) { + this(uscxmlNativeJavaJNI.new_Data__SWIG_0(), true); + setCompound(compound); + } + + public Data(List array) { + this(uscxmlNativeJavaJNI.new_Data__SWIG_0(), true); + setArray(array); + } + + public Map getCompound() { + Map compound = new HashMap(); + DataMap dataMap = getCompoundNative(); + StringVector dataMapKeys = getCompoundKeys(); + for (int i = 0; i < dataMapKeys.size(); i++) { + compound.put(dataMapKeys.get(i), dataMap.get(dataMapKeys.get(i))); + } + return compound; + } + + public void setCompound(Map compound) { + DataMap dataMap = new DataMap(); + for (String key : compound.keySet()) { + dataMap.set(key, compound.get(key)); + } + setCompoundNative(dataMap); + } + + public List getArray() { + List array = new LinkedList(); + DataList dataList = getArrayNative(); + for (int i = 0; i < dataList.size(); i++) { + array.add(dataList.get(i)); + } + return array; + } + + public void setArray(List array) { + DataList dataList = new DataList(); + for (Data data : array) { + dataList.add(data); + } + setArrayNative(dataList); + } + +%} + +#if 0 +%rename(getNameListNative) uscxml::Event::getNameList(); +%rename(getParamsNative) uscxml::Event::getParams(); +%rename(setNameListNative) uscxml::Event::setNameList(const std::map&); +%rename(setParamsNative) uscxml::Event::setParams(const std::multimap&); +%javamethodmodifiers uscxml::Event::getNameList() "private"; +%javamethodmodifiers uscxml::Event::getNameListKeys() "private"; +%javamethodmodifiers uscxml::Event::getParams() "private"; +%javamethodmodifiers uscxml::Event::setNameList(const std::map&) "private"; +%javamethodmodifiers uscxml::Event::setParams(const std::multimap&) "private"; +#endif + +%typemap(javaimports) uscxml::Event %{ +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.LinkedList; +%} + +%typemap(javacode) uscxml::Event %{ + public Map> getParams() { + Map> params = new HashMap>(); + ParamMap paramMap = getParamMap(); + StringVector paramMapKeys = getParamMapKeys(); + + for (int i = 0; i < paramMapKeys.size(); i++) { + String key = paramMapKeys.get(i); + DataList dataList = paramMap.get(key); + + for (int j = 0; j < dataList.size(); j++) { + Data data = dataList.get(j); + if (!params.containsKey(key)) + params.put(key, new LinkedList()); + params.get(key).add(data); + } + } + return params; + } + + public void setParams(Map> params) { + ParamMap paramMap = new ParamMap(); + for (String key : params.keySet()) { + DataList datalist = new DataList(); + for (Data data : params.get(key)) { + datalist.add(data); + } + paramMap.set(key, datalist); + } + setParamMap(paramMap); + } + + public Map getNameList() { + Map namelist = new HashMap(); + StringVector nameMapKeys = getNameListKeys(); + DataMap nameMap = getNameListNative(); + + for (int i = 0; i < nameMapKeys.size(); i++) { + namelist.put(nameMapKeys.get(i), nameMap.get(nameMapKeys.get(i))); + } + return namelist; + } + + public void setNameList(Map namelist) { + DataMap nameListMap = new DataMap(); + for (String key : namelist.keySet()) { + nameListMap.set(key, namelist.get(key)); + } + setNameListNative(nameListMap); + } +%} + + +//*********************************************** +// Parse the header file to generate wrappers +//*********************************************** + +%include "../../../uscxml/Common.h" +%include "../../../uscxml/Factory.h" +%include "../../../uscxml/Message.h" +%include "../../../uscxml/Interpreter.h" +%include "../../../uscxml/concurrency/BlockingQueue.h" +%include "../../../uscxml/server/HTTPServer.h" +//%include "../../../uscxml/debug/DebuggerServlet.h" +%include "../../../uscxml/debug/InterpreterIssue.h" + +%include "../../../uscxml/messages/Blob.h" +%include "../../../uscxml/messages/Data.h" +%include "../../../uscxml/messages/Event.h" +%include "../../../uscxml/messages/InvokeRequest.h" +%include "../../../uscxml/messages/SendRequest.h" + +%include "../../../uscxml/plugins/DataModel.h" +%include "../../../uscxml/plugins/EventHandler.h" +%include "../../../uscxml/plugins/ExecutableContent.h" +%include "../../../uscxml/plugins/Invoker.h" +%include "../../../uscxml/plugins/IOProcessor.h" + +%include "../wrapped/WrappedInvoker.h" +%include "../wrapped/WrappedDataModel.h" +%include "../wrapped/WrappedExecutableContent.h" +%include "../wrapped/WrappedIOProcessor.h" +%include "../wrapped/WrappedInterpreterMonitor.h" + + +%template(IssueList) std::list; +%template(DataList) std::list; +%template(DataMap) std::map; +%template(StringSet) std::set; +%template(StringVector) std::vector; +%template(StringList) std::list; +%template(ParamMap) std::map >; +%template(IOProcMap) std::map; +%template(InvokerMap) std::map; +%template(ParentQueue) uscxml::concurrency::BlockingQueue; diff --git a/src/bindings/swig/php/uscxmlNativePHP.php b/src/bindings/swig/php/uscxmlNativePHP.php new file mode 100644 index 0000000..12757d3 --- /dev/null +++ b/src/bindings/swig/php/uscxmlNativePHP.php @@ -0,0 +1,3110 @@ +_cPtr,$value); + if ($var === 'rem') return imaxdiv_t_rem_set($this->_cPtr,$value); + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'quot') return imaxdiv_t_quot_get($this->_cPtr); + if ($var === 'rem') return imaxdiv_t_rem_get($this->_cPtr); + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('imaxdiv_t_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_imaxdiv_t') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_imaxdiv_t(); + } +} + +class Factory { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($parentFactory_or_pluginPath,$parentFactory=null) { + if (is_resource($parentFactory_or_pluginPath) && get_resource_type($parentFactory_or_pluginPath) === '_p_uscxml__Factory') { + $this->_cPtr=$parentFactory_or_pluginPath; + return; + } + switch (func_num_args()) { + case 1: $this->_cPtr=new_Factory($parentFactory_or_pluginPath); break; + default: $this->_cPtr=new_Factory($parentFactory_or_pluginPath,$parentFactory); + } + } + + function registerIOProcessor($ioProcessor) { + Factory_registerIOProcessor($this->_cPtr,$ioProcessor); + } + + function registerDataModel($dataModel) { + Factory_registerDataModel($this->_cPtr,$dataModel); + } + + function registerInvoker($invoker) { + Factory_registerInvoker($this->_cPtr,$invoker); + } + + function registerExecutableContent($executableContent) { + Factory_registerExecutableContent($this->_cPtr,$executableContent); + } + + function hasDataModel($type) { + return Factory_hasDataModel($this->_cPtr,$type); + } + + function hasIOProcessor($type) { + return Factory_hasIOProcessor($this->_cPtr,$type); + } + + function hasInvoker($type) { + return Factory_hasInvoker($this->_cPtr,$type); + } + + function hasExecutableContent($localName,$nameSpace) { + return Factory_hasExecutableContent($this->_cPtr,$localName,$nameSpace); + } + + function listComponents() { + Factory_listComponents($this->_cPtr); + } + + static function getInstance() { + $r=Factory_getInstance(); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Factory($r); + } + return $r; + } + + static function setDefaultPluginPath($path) { + Factory_setDefaultPluginPath($path); + } + + static function getDefaultPluginPath() { + return Factory_getDefaultPluginPath(); + } +} + +class InterpreterOptions { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + $func = 'InterpreterOptions_'.$var.'_set'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr,$value); + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + $func = 'InterpreterOptions_'.$var.'_get'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr); + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('InterpreterOptions_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__InterpreterOptions') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_InterpreterOptions(); + } + + function isValid() { + return InterpreterOptions_isValid($this->_cPtr); + } + + static function printUsageAndExit($progName) { + InterpreterOptions_printUsageAndExit($progName); + } + + function getCapabilities() { + return InterpreterOptions_getCapabilities($this->_cPtr); + } +} + +class NameSpaceInfo { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__NameSpaceInfo') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NameSpaceInfo(); + } + + function getXMLPrefixForNS($ns) { + return NameSpaceInfo_getXMLPrefixForNS($this->_cPtr,$ns); + } +} + +class Interpreter { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + static function fromXML($xml,$sourceURL) { + $r=Interpreter_fromXML($xml,$sourceURL); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Interpreter($r); + } + return $r; + } + + static function fromURL($URL) { + $r=Interpreter_fromURL($URL); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Interpreter($r); + } + return $r; + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__Interpreter') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_Interpreter(); + } + + function isValid() { + return Interpreter_isValid($this->_cPtr); + } + + function equals($other) { + return Interpreter_equals($this->_cPtr,$other); + } + + function writeTo($stream) { + Interpreter_writeTo($this->_cPtr,$stream); + } + + function reset() { + Interpreter_reset($this->_cPtr); + } + + function interpret() { + Interpreter_interpret($this->_cPtr); + } + + function step($waitForMS_or_blocking=null) { + switch (func_num_args()) { + case 0: $r=Interpreter_step($this->_cPtr); break; + default: $r=Interpreter_step($this->_cPtr,$waitForMS_or_blocking); + } + return $r; + } + + function validate() { + $r=Interpreter_validate($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new IssueList($r); + } + return $r; + } + + function getState() { + return Interpreter_getState($this->_cPtr); + } + + function addMonitor($monitor) { + Interpreter_addMonitor($this->_cPtr,$monitor); + } + + function removeMonitor($monitor) { + Interpreter_removeMonitor($this->_cPtr,$monitor); + } + + function setSourceURL($sourceURL) { + Interpreter_setSourceURL($this->_cPtr,$sourceURL); + } + + function getSourceURL() { + return Interpreter_getSourceURL($this->_cPtr); + } + + function getBaseURL($xpathExpr=null) { + switch (func_num_args()) { + case 0: $r=Interpreter_getBaseURL($this->_cPtr); break; + default: $r=Interpreter_getBaseURL($this->_cPtr,$xpathExpr); + } + return $r; + } + + function setNameSpaceInfo($nsInfo) { + Interpreter_setNameSpaceInfo($this->_cPtr,$nsInfo); + } + + function getNameSpaceInfo() { + $r=Interpreter_getNameSpaceInfo($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NameSpaceInfo($r); + } + return $r; + } + + function getCmdLineOptions() { + $r=Interpreter_getCmdLineOptions($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function getDataModel() { + $r=Interpreter_getDataModel($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NativeDataModel($r); + } + return $r; + } + + function getIOProcessorsNative() { + $r=Interpreter_getIOProcessorsNative($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new IOProcMap($r); + } + return $r; + } + + function getInvokersNative() { + $r=Interpreter_getInvokersNative($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new InvokerMap($r); + } + return $r; + } + + function addDataModelExtension($ext) { + Interpreter_addDataModelExtension($this->_cPtr,$ext); + } + + function setParentQueue($parentQueue) { + Interpreter_setParentQueue($this->_cPtr,$parentQueue); + } + + function setFactory($factory) { + Interpreter_setFactory($this->_cPtr,$factory); + } + + function getFactory() { + $r=Interpreter_getFactory($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Factory($r); + } + return $r; + } + + function receiveInternal($event) { + Interpreter_receiveInternal($this->_cPtr,$event); + } + + function receive($event,$toFront=false) { + Interpreter_receive($this->_cPtr,$event,$toFront); + } + + function getCurrentEvent() { + $r=Interpreter_getCurrentEvent($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Event($r); + } + return $r; + } + + function isInState($stateId) { + return Interpreter_isInState($this->_cPtr,$stateId); + } + + function setInitalConfiguration($states) { + Interpreter_setInitalConfiguration($this->_cPtr,$states); + } + + function setCapabilities($capabilities) { + Interpreter_setCapabilities($this->_cPtr,$capabilities); + } + + function setName($name) { + Interpreter_setName($this->_cPtr,$name); + } + + function getName() { + return Interpreter_getName($this->_cPtr); + } + + function getSessionId() { + return Interpreter_getSessionId($this->_cPtr); + } + + function hasLegalConfiguration() { + return Interpreter_hasLegalConfiguration($this->_cPtr); + } + + function isLegalConfiguration($config) { + return Interpreter_isLegalConfiguration($this->_cPtr,$config); + } + + function hashCode() { + return Interpreter_hashCode($this->_cPtr); + } + + function addIOProcessor($ioProc) { + Interpreter_addIOProcessor($this->_cPtr,$ioProc); + } + + function setDataModel($dataModel) { + Interpreter_setDataModel($this->_cPtr,$dataModel); + } + + function setInvoker($invokeId,$invoker) { + Interpreter_setInvoker($this->_cPtr,$invokeId,$invoker); + } + + function getBasicConfiguration() { + $r=Interpreter_getBasicConfiguration($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getConfiguration() { + $r=Interpreter_getConfiguration($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getIOProcessorKeys() { + $r=Interpreter_getIOProcessorKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getInvokerKeys() { + $r=Interpreter_getInvokerKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } +} + +class NativeInterpreterMonitor { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function beforeProcessingEvent($interpreter,$event) { + NativeInterpreterMonitor_beforeProcessingEvent($this->_cPtr,$interpreter,$event); + } + + function beforeMicroStep($interpreter) { + NativeInterpreterMonitor_beforeMicroStep($this->_cPtr,$interpreter); + } + + function afterMicroStep($interpreter) { + NativeInterpreterMonitor_afterMicroStep($this->_cPtr,$interpreter); + } + + function onStableConfiguration($interpreter) { + NativeInterpreterMonitor_onStableConfiguration($this->_cPtr,$interpreter); + } + + function beforeCompletion($interpreter) { + NativeInterpreterMonitor_beforeCompletion($this->_cPtr,$interpreter); + } + + function afterCompletion($interpreter) { + NativeInterpreterMonitor_afterCompletion($this->_cPtr,$interpreter); + } + + function reportIssue($interpreter,$issue) { + NativeInterpreterMonitor_reportIssue($this->_cPtr,$interpreter,$issue); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__InterpreterMonitor') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeInterpreterMonitor(); + } +} + +class StateTransitionMonitor extends NativeInterpreterMonitor { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + NativeInterpreterMonitor::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return NativeInterpreterMonitor::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return NativeInterpreterMonitor::__isset($var); + } + + function beforeTakingTransition($interpreter,$transition,$moreComing) { + StateTransitionMonitor_beforeTakingTransition($this->_cPtr,$interpreter,$transition,$moreComing); + } + + function onStableConfiguration($interpreter) { + StateTransitionMonitor_onStableConfiguration($this->_cPtr,$interpreter); + } + + function beforeProcessingEvent($interpreter,$event) { + StateTransitionMonitor_beforeProcessingEvent($this->_cPtr,$interpreter,$event); + } + + function beforeExitingState($interpreter,$state,$moreComing) { + StateTransitionMonitor_beforeExitingState($this->_cPtr,$interpreter,$state,$moreComing); + } + + function beforeEnteringState($interpreter,$state,$moreComing) { + StateTransitionMonitor_beforeEnteringState($this->_cPtr,$interpreter,$state,$moreComing); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__StateTransitionMonitor') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_StateTransitionMonitor(); + } +} + +class HTTPServer { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + const HTTPS = 0; + + const HTTP = HTTPServer_HTTP; + + const WebSockets = HTTPServer_WebSockets; + + static function getInstance($port=null,$wsPort=null,$sslConf=null) { + switch (func_num_args()) { + case 0: $r=HTTPServer_getInstance(); break; + case 1: $r=HTTPServer_getInstance($port); break; + default: $r=HTTPServer_getInstance($port,$wsPort,$sslConf); + } + if (!is_resource($r)) return $r; + return new HTTPServer($r); + } + + static function getBaseURL($type=null) { + switch (func_num_args()) { + case 0: $r=HTTPServer_getBaseURL(); break; + default: $r=HTTPServer_getBaseURL($type); + } + return $r; + } + + static function registerServlet($path,$servlet) { + return HTTPServer_registerServlet($path,$servlet); + } + + static function unregisterServlet($servlet) { + HTTPServer_unregisterServlet($servlet); + } +} + +abstract class HTTPServlet { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function httpRecvRequest($request) { + return HTTPServlet_httpRecvRequest($this->_cPtr,$request); + } + + function setURL($url) { + HTTPServlet_setURL($this->_cPtr,$url); + } + + function canAdaptPath() { + return HTTPServlet_canAdaptPath($this->_cPtr); + } +} + +abstract class WebSocketServlet { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function wsRecvRequest($conn,$frame) { + return WebSocketServlet_wsRecvRequest($this->_cPtr,$conn,$frame); + } + + function setURL($url) { + WebSocketServlet_setURL($this->_cPtr,$url); + } + + function canAdaptPath() { + return WebSocketServlet_canAdaptPath($this->_cPtr); + } +} + +class InterpreterIssue { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + $func = 'InterpreterIssue_'.$var.'_set'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr,$value); + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + $func = 'InterpreterIssue_'.$var.'_get'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr); + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('InterpreterIssue_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + const USCXML_ISSUE_FATAL = 0; + + const USCXML_ISSUE_WARNING = InterpreterIssue_USCXML_ISSUE_WARNING; + + const USCXML_ISSUE_INFO = InterpreterIssue_USCXML_ISSUE_INFO; + + function __construct($msg,$node,$severity) { + if (is_resource($msg) && get_resource_type($msg) === '_p_uscxml__InterpreterIssue') { + $this->_cPtr=$msg; + return; + } + $this->_cPtr=new_InterpreterIssue($msg,$node,$severity); + } + + function toString() { + return InterpreterIssue_toString($this->_cPtr); + } +} + +class Blob { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($other_or_data=null,$mimeType=null) { + if (is_resource($other_or_data) && get_resource_type($other_or_data) === '_p_uscxml__Blob') { + $this->_cPtr=$other_or_data; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Blob(); break; + case 1: $this->_cPtr=new_Blob($other_or_data); break; + default: $this->_cPtr=new_Blob($other_or_data,$mimeType); + } + } + + function isValid() { + return Blob_isValid($this->_cPtr); + } + + function equals($other) { + return Blob_equals($this->_cPtr,$other); + } + + static function fromBase64($base64,$mimeType=null) { + switch (func_num_args()) { + case 1: $r=Blob_fromBase64($base64); break; + default: $r=Blob_fromBase64($base64,$mimeType); + } + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Blob($r); + } + return $r; + } + + function base64() { + return Blob_base64($this->_cPtr); + } + + function md5() { + return Blob_md5($this->_cPtr); + } + + function getData() { + return Blob_getData($this->_cPtr); + } + + function getSize() { + return Blob_getSize($this->_cPtr); + } + + function getMimeType() { + return Blob_getMimeType($this->_cPtr); + } + + function setMimeType($mimeType) { + Blob_setMimeType($this->_cPtr,$mimeType); + } +} + +class Data { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + const VERBATIM = 0; + + const INTERPRETED = Data_INTERPRETED; + + function __construct($atom=null,$type=null) { + if (is_resource($atom) && get_resource_type($atom) === '_p_uscxml__Data') { + $this->_cPtr=$atom; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Data(); break; + case 1: $this->_cPtr=new_Data($atom); break; + default: $this->_cPtr=new_Data($atom,$type); + } + } + + function c_empty() { + return Data_c_empty($this->_cPtr); + } + + function merge($other) { + Data_merge($this->_cPtr,$other); + } + + function hasKey($key) { + return Data_hasKey($this->_cPtr,$key); + } + + function at($key) { + $r=Data_at($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function item($index) { + $r=Data_item($this->_cPtr,$index); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function put($key_or_index,$data) { + Data_put($this->_cPtr,$key_or_index,$data); + } + + function equals($other) { + return Data_equals($this->_cPtr,$other); + } + + static function fromJSON($jsonString) { + $r=Data_fromJSON($jsonString); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + static function toJSON($data) { + return Data_toJSON($data); + } + + static function fromXML($xmlString) { + $r=Data_fromXML($xmlString); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function toXMLString() { + return Data_toXMLString($this->_cPtr); + } + + function getCompound() { + $r=Data_getCompound($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataMap($r); + } + return $r; + } + + function setCompound($compound) { + Data_setCompound($this->_cPtr,$compound); + } + + function getArray() { + $r=Data_getArray($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataList($r); + } + return $r; + } + + function setArray($array) { + Data_setArray($this->_cPtr,$array); + } + + function getAtom() { + return Data_getAtom($this->_cPtr); + } + + function setAtom($atom) { + Data_setAtom($this->_cPtr,$atom); + } + + function getBinary() { + $r=Data_getBinary($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Blob($r); + } + return $r; + } + + function setBinary($binary) { + Data_setBinary($this->_cPtr,$binary); + } + + function getType() { + return Data_getType($this->_cPtr); + } + + function setType($type) { + Data_setType($this->_cPtr,$type); + } + + function toString() { + return Data_toString($this->_cPtr); + } + + function getCompoundKeys() { + $r=Data_getCompoundKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getXML() { + return Data_getXML($this->_cPtr); + } + + function setXML($xml) { + Data_setXML($this->_cPtr,$xml); + } +} + +class Event { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + const INTERNAL = 1; + + const EXTERNAL = 2; + + const PLATFORM = 3; + + function __construct($name=null,$type=null) { + if (is_resource($name) && get_resource_type($name) === '_p_uscxml__Event') { + $this->_cPtr=$name; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Event(); break; + case 1: $this->_cPtr=new_Event($name); break; + default: $this->_cPtr=new_Event($name,$type); + } + } + + function equals($other) { + return Event_equals($this->_cPtr,$other); + } + + function getName() { + return Event_getName($this->_cPtr); + } + + function setName($name) { + Event_setName($this->_cPtr,$name); + } + + function getEventType() { + return Event_getEventType($this->_cPtr); + } + + function setEventType($type) { + Event_setEventType($this->_cPtr,$type); + } + + function getOrigin() { + return Event_getOrigin($this->_cPtr); + } + + function setOrigin($origin) { + Event_setOrigin($this->_cPtr,$origin); + } + + function getOriginType() { + return Event_getOriginType($this->_cPtr); + } + + function setOriginType($originType) { + Event_setOriginType($this->_cPtr,$originType); + } + + function getDOM() { + return Event_getDOM($this->_cPtr); + } + + function getRaw() { + return Event_getRaw($this->_cPtr); + } + + function setRaw($raw) { + Event_setRaw($this->_cPtr,$raw); + } + + function getContent() { + return Event_getContent($this->_cPtr); + } + + function setContent($content) { + Event_setContent($this->_cPtr,$content); + } + + function getXML() { + return Event_getXML($this->_cPtr); + } + + function setXML($xml) { + Event_setXML($this->_cPtr,$xml); + } + + function getSendId() { + return Event_getSendId($this->_cPtr); + } + + function setSendId($sendId) { + Event_setSendId($this->_cPtr,$sendId); + } + + function getInvokeId() { + return Event_getInvokeId($this->_cPtr); + } + + function setInvokeId($invokeId) { + Event_setInvokeId($this->_cPtr,$invokeId); + } + + function getData() { + $r=Event_getData($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function setData($data) { + Event_setData($this->_cPtr,$data); + } + + static function fromXML($xmlString) { + $r=Event_fromXML($xmlString); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Event($r); + } + return $r; + } + + function toXMLString() { + return Event_toXMLString($this->_cPtr); + } + + function getNameList() { + $r=Event_getNameList($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataMap($r); + } + return $r; + } + + function setNameList($nameList) { + Event_setNameList($this->_cPtr,$nameList); + } + + function toString() { + return Event_toString($this->_cPtr); + } + + function getParamMap() { + $r=Event_getParamMap($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new ParamMap($r); + } + return $r; + } + + function getParamMapKeys() { + $r=Event_getParamMapKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function setParamMap($paramMap) { + Event_setParamMap($this->_cPtr,$paramMap); + } + + function getNameListKeys() { + $r=Event_getNameListKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } +} + +class InvokeRequest extends Event { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + Event::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return Event::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return Event::__isset($var); + } + + function __construct($event=null) { + if (is_resource($event) && get_resource_type($event) === '_p_uscxml__InvokeRequest') { + $this->_cPtr=$event; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_InvokeRequest(); break; + default: $this->_cPtr=new_InvokeRequest($event); + } + } + + function getType() { + return InvokeRequest_getType($this->_cPtr); + } + + function setType($type) { + InvokeRequest_setType($this->_cPtr,$type); + } + + function getSource() { + return InvokeRequest_getSource($this->_cPtr); + } + + function setSource($src) { + InvokeRequest_setSource($this->_cPtr,$src); + } + + function isAutoForwarded() { + return InvokeRequest_isAutoForwarded($this->_cPtr); + } + + function setAutoForwarded($autoForward) { + InvokeRequest_setAutoForwarded($this->_cPtr,$autoForward); + } + + function toXMLString() { + return InvokeRequest_toXMLString($this->_cPtr); + } + + function toString() { + return InvokeRequest_toString($this->_cPtr); + } +} + +class SendRequest extends Event { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + Event::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return Event::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return Event::__isset($var); + } + + function __construct($event=null) { + if (is_resource($event) && get_resource_type($event) === '_p_uscxml__SendRequest') { + $this->_cPtr=$event; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_SendRequest(); break; + default: $this->_cPtr=new_SendRequest($event); + } + } + + function getTarget() { + return SendRequest_getTarget($this->_cPtr); + } + + function setTarget($target) { + SendRequest_setTarget($this->_cPtr,$target); + } + + function getType() { + return SendRequest_getType($this->_cPtr); + } + + function setType($type) { + SendRequest_setType($this->_cPtr,$type); + } + + function getDelayMs() { + return SendRequest_getDelayMs($this->_cPtr); + } + + function setDelayMs($delayMs) { + SendRequest_setDelayMs($this->_cPtr,$delayMs); + } + + function toXMLString() { + return SendRequest_toXMLString($this->_cPtr); + } + + function toString() { + return SendRequest_toString($this->_cPtr); + } +} + +abstract class NativeDataModelExtension { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function provides() { + return NativeDataModelExtension_provides($this->_cPtr); + } + + function getValueOf($member) { + $r=NativeDataModelExtension_getValueOf($this->_cPtr,$member); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function setValueOf($member,$data) { + NativeDataModelExtension_setValueOf($this->_cPtr,$member,$data); + } +} + +abstract class DataModelImpl { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function getNames() { + $r=DataModelImpl_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function validate($location,$schema) { + return DataModelImpl_validate($this->_cPtr,$location,$schema); + } + + function isLocation($expr) { + return DataModelImpl_isLocation($this->_cPtr,$expr); + } + + function isValidSyntax($expr) { + return DataModelImpl_isValidSyntax($this->_cPtr,$expr); + } + + function setEvent($event) { + DataModelImpl_setEvent($this->_cPtr,$event); + } + + function getStringAsData($content) { + $r=DataModelImpl_getStringAsData($this->_cPtr,$content); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function getLength($expr) { + return DataModelImpl_getLength($this->_cPtr,$expr); + } + + function setForeach($item,$array,$index,$iteration) { + DataModelImpl_setForeach($this->_cPtr,$item,$array,$index,$iteration); + } + + function pushContext() { + DataModelImpl_pushContext($this->_cPtr); + } + + function popContext() { + DataModelImpl_popContext($this->_cPtr); + } + + function evalAsString($expr) { + return DataModelImpl_evalAsString($this->_cPtr,$expr); + } + + function evalAsBool($scriptNode_or_expr,$expr=null) { + switch (func_num_args()) { + case 1: $r=DataModelImpl_evalAsBool($this->_cPtr,$scriptNode_or_expr); break; + default: $r=DataModelImpl_evalAsBool($this->_cPtr,$scriptNode_or_expr,$expr); + } + return $r; + } + + function isDeclared($expr) { + return DataModelImpl_isDeclared($this->_cPtr,$expr); + } + + function addExtension($ext) { + DataModelImpl_addExtension($this->_cPtr,$ext); + } + + function andExpressions($arg1) { + return DataModelImpl_andExpressions($this->_cPtr,$arg1); + } +} + +class NativeDataModel { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__DataModel') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeDataModel(); + } + + function isValid() { + return NativeDataModel_isValid($this->_cPtr); + } + + function equals($other) { + return NativeDataModel_equals($this->_cPtr,$other); + } + + function getNames() { + $r=NativeDataModel_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function validate($location,$schema) { + return NativeDataModel_validate($this->_cPtr,$location,$schema); + } + + function isLocation($expr) { + return NativeDataModel_isLocation($this->_cPtr,$expr); + } + + function isValidSyntax($expr) { + return NativeDataModel_isValidSyntax($this->_cPtr,$expr); + } + + function setEvent($event) { + NativeDataModel_setEvent($this->_cPtr,$event); + } + + function getStringAsData($content) { + $r=NativeDataModel_getStringAsData($this->_cPtr,$content); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function pushContext() { + NativeDataModel_pushContext($this->_cPtr); + } + + function popContext() { + NativeDataModel_popContext($this->_cPtr); + } + + function evalAsString($expr) { + return NativeDataModel_evalAsString($this->_cPtr,$expr); + } + + function evalAsBool($scriptNode,$expr) { + return NativeDataModel_evalAsBool($this->_cPtr,$scriptNode,$expr); + } + + function getLength($expr) { + return NativeDataModel_getLength($this->_cPtr,$expr); + } + + function setForeach($item,$array,$index,$iteration) { + NativeDataModel_setForeach($this->_cPtr,$item,$array,$index,$iteration); + } + + function assign($location,$data) { + NativeDataModel_assign($this->_cPtr,$location,$data); + } + + function init($location,$data) { + NativeDataModel_init($this->_cPtr,$location,$data); + } + + function isDeclared($expr) { + return NativeDataModel_isDeclared($this->_cPtr,$expr); + } + + function andExpressions($expressions) { + return NativeDataModel_andExpressions($this->_cPtr,$expressions); + } + + function addExtension($ext) { + NativeDataModel_addExtension($this->_cPtr,$ext); + } +} + +abstract class EventHandlerImpl { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function getNames() { + $r=EventHandlerImpl_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function setInvokeId($invokeId) { + EventHandlerImpl_setInvokeId($this->_cPtr,$invokeId); + } + + function setType($type) { + EventHandlerImpl_setType($this->_cPtr,$type); + } + + function getType() { + return EventHandlerImpl_getType($this->_cPtr); + } + + function getDataModelVariables() { + $r=EventHandlerImpl_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + EventHandlerImpl_send($this->_cPtr,$req); + } + + function returnErrorExecution($arg1) { + EventHandlerImpl_returnErrorExecution($this->_cPtr,$arg1); + } + + function returnErrorCommunication($arg1) { + EventHandlerImpl_returnErrorCommunication($this->_cPtr,$arg1); + } + + function returnEvent($event,$internal=false) { + EventHandlerImpl_returnEvent($this->_cPtr,$event,$internal); + } +} + +class EventHandler { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($other=null) { + if (is_resource($other) && get_resource_type($other) === '_p_uscxml__EventHandler') { + $this->_cPtr=$other; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_EventHandler(); break; + default: $this->_cPtr=new_EventHandler($other); + } + } + + function getNames() { + $r=EventHandler_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function getDataModelVariables() { + $r=EventHandler_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + EventHandler_send($this->_cPtr,$req); + } + + function setInvokeId($invokeId) { + EventHandler_setInvokeId($this->_cPtr,$invokeId); + } + + function setType($type) { + EventHandler_setType($this->_cPtr,$type); + } + + function getType() { + return EventHandler_getType($this->_cPtr); + } +} + +abstract class ExecutableContentImpl { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function getLocalName() { + return ExecutableContentImpl_getLocalName($this->_cPtr); + } + + function getNamespace() { + return ExecutableContentImpl_getNamespace($this->_cPtr); + } + + function enterElement($node) { + ExecutableContentImpl_enterElement($this->_cPtr,$node); + } + + function exitElement($node) { + ExecutableContentImpl_exitElement($this->_cPtr,$node); + } + + function processChildren() { + return ExecutableContentImpl_processChildren($this->_cPtr); + } +} + +class NativeExecutableContent { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__ExecutableContent') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeExecutableContent(); + } + + function isValid() { + return NativeExecutableContent_isValid($this->_cPtr); + } + + function equals($other) { + return NativeExecutableContent_equals($this->_cPtr,$other); + } + + function getLocalName() { + return NativeExecutableContent_getLocalName($this->_cPtr); + } + + function getNamespace() { + return NativeExecutableContent_getNamespace($this->_cPtr); + } + + function enterElement($node) { + NativeExecutableContent_enterElement($this->_cPtr,$node); + } + + function exitElement($node) { + NativeExecutableContent_exitElement($this->_cPtr,$node); + } + + function processChildren() { + return NativeExecutableContent_processChildren($this->_cPtr); + } +} + +abstract class InvokerImpl extends EventHandlerImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandlerImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandlerImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandlerImpl::__isset($var); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function invoke($req) { + InvokerImpl_invoke($this->_cPtr,$req); + } + + function uninvoke() { + InvokerImpl_uninvoke($this->_cPtr); + } + + function deleteOnUninvoke() { + return InvokerImpl_deleteOnUninvoke($this->_cPtr); + } +} + +class NativeInvoker extends EventHandler { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandler::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandler::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandler::__isset($var); + } + + function __construct($other=null) { + if (is_resource($other) && get_resource_type($other) === '_p_uscxml__Invoker') { + $this->_cPtr=$other; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_NativeInvoker(); break; + default: $this->_cPtr=new_NativeInvoker($other); + } + } + + function isValid() { + return NativeInvoker_isValid($this->_cPtr); + } + + function equals($other) { + return NativeInvoker_equals($this->_cPtr,$other); + } + + function invoke($req) { + NativeInvoker_invoke($this->_cPtr,$req); + } + + function uninvoke() { + NativeInvoker_uninvoke($this->_cPtr); + } + + function deleteOnUninvoke() { + return NativeInvoker_deleteOnUninvoke($this->_cPtr); + } +} + +abstract class IOProcessorImpl extends EventHandlerImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandlerImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandlerImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandlerImpl::__isset($var); + } + function __construct($h) { + $this->_cPtr=$h; + } +} + +class NativeIOProcessor extends EventHandler { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandler::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandler::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandler::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__IOProcessor') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeIOProcessor(); + } + + function isValid() { + return NativeIOProcessor_isValid($this->_cPtr); + } + + function equals($other) { + return NativeIOProcessor_equals($this->_cPtr,$other); + } +} + +class Invoker extends InvokerImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + InvokerImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return InvokerImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return InvokerImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedInvoker') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'Invoker') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_Invoker($_this); + } + + function getNames() { + $r=Invoker_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function getDataModelVariables() { + $r=Invoker_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + Invoker_send($this->_cPtr,$req); + } + + function invoke($req) { + Invoker_invoke($this->_cPtr,$req); + } + + function uninvoke() { + Invoker_uninvoke($this->_cPtr); + } + + function deleteOnUninvoke() { + return Invoker_deleteOnUninvoke($this->_cPtr); + } + + function create($interpreter) { + $r=Invoker_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Invoker($r); + } + return $r; + } +} + +class DataModelExtension extends NativeDataModelExtension { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + NativeDataModelExtension::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return NativeDataModelExtension::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return NativeDataModelExtension::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedDataModelExtension') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'DataModelExtension') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_DataModelExtension($_this); + } + + function provides() { + return DataModelExtension_provides($this->_cPtr); + } + + function getValueOf($member) { + $r=DataModelExtension_getValueOf($this->_cPtr,$member); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function setValueOf($member,$data) { + DataModelExtension_setValueOf($this->_cPtr,$member,$data); + } +} + +class DataModel extends DataModelImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + DataModelImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return DataModelImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return DataModelImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedDataModel') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'DataModel') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_DataModel($_this); + } + + function create($interpreter) { + $r=DataModel_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataModel($r); + } + return $r; + } + + function getNames() { + $r=DataModel_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function andExpressions($arg0) { + return DataModel_andExpressions($this->_cPtr,$arg0); + } + + function validate($location,$schema) { + return DataModel_validate($this->_cPtr,$location,$schema); + } + + function setEvent($event) { + DataModel_setEvent($this->_cPtr,$event); + } + + function getStringAsData($content) { + $r=DataModel_getStringAsData($this->_cPtr,$content); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function getLength($expr) { + return DataModel_getLength($this->_cPtr,$expr); + } + + function setForeach($item,$array,$index,$iteration) { + DataModel_setForeach($this->_cPtr,$item,$array,$index,$iteration); + } + + function pushContext() { + DataModel_pushContext($this->_cPtr); + } + + function popContext() { + DataModel_popContext($this->_cPtr); + } + + function evalAsString($expr) { + return DataModel_evalAsString($this->_cPtr,$expr); + } + + function isDeclared($expr) { + return DataModel_isDeclared($this->_cPtr,$expr); + } + + function isLocation($expr) { + return DataModel_isLocation($this->_cPtr,$expr); + } + + function evalAsBool($expr_or_node_or_elem,$expr_or_content=null) { + switch (func_num_args()) { + case 1: $this->_cPtr=DataModel_evalAsBool($this->_cPtr,$expr_or_node_or_elem); break; + default: $this->_cPtr=DataModel_evalAsBool($this->_cPtr,$expr_or_node_or_elem,$expr_or_content); + } + return $r; + } + + function init($dataElem,$location,$content) { + DataModel_init($this->_cPtr,$dataElem,$location,$content); + } + + function assign($assignElem,$location,$content) { + DataModel_assign($this->_cPtr,$assignElem,$location,$content); + } + + function c_eval($scriptElem,$expr) { + DataModel_c_eval($this->_cPtr,$scriptElem,$expr); + } +} + +class ExecutableContent extends ExecutableContentImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + ExecutableContentImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return ExecutableContentImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return ExecutableContentImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedExecutableContent') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'ExecutableContent') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_ExecutableContent($_this); + } + + function create($interpreter) { + $r=ExecutableContent_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new ExecutableContent($r); + } + return $r; + } + + function getLocalName() { + return ExecutableContent_getLocalName($this->_cPtr); + } + + function getNamespace() { + return ExecutableContent_getNamespace($this->_cPtr); + } + + function processChildren() { + return ExecutableContent_processChildren($this->_cPtr); + } + + function enterElement($node) { + ExecutableContent_enterElement($this->_cPtr,$node); + } + + function exitElement($node) { + ExecutableContent_exitElement($this->_cPtr,$node); + } +} + +class IOProcessor extends IOProcessorImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + IOProcessorImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return IOProcessorImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return IOProcessorImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedIOProcessor') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'IOProcessor') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_IOProcessor($_this); + } + + function create($interpreter) { + $r=IOProcessor_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new IOProcessor($r); + } + return $r; + } + + function getNames() { + $r=IOProcessor_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function getDataModelVariables() { + $r=IOProcessor_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + IOProcessor_send($this->_cPtr,$req); + } +} + +class InterpreterMonitor extends NativeInterpreterMonitor { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + NativeInterpreterMonitor::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return NativeInterpreterMonitor::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return NativeInterpreterMonitor::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedInterpreterMonitor') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'InterpreterMonitor') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_InterpreterMonitor($_this); + } + + function beforeExitingState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_beforeExitingState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function afterExitingState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_afterExitingState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function beforeExecutingContent($interpreter,$tagName,$xpath,$element) { + InterpreterMonitor_beforeExecutingContent($this->_cPtr,$interpreter,$tagName,$xpath,$element); + } + + function afterExecutingContent($interpreter,$tagName,$xpath,$element) { + InterpreterMonitor_afterExecutingContent($this->_cPtr,$interpreter,$tagName,$xpath,$element); + } + + function beforeUninvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_beforeUninvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function afterUninvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_afterUninvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function beforeTakingTransition($interpreter,$xpath,$source,$targets,$element,$moreComing) { + InterpreterMonitor_beforeTakingTransition($this->_cPtr,$interpreter,$xpath,$source,$targets,$element,$moreComing); + } + + function afterTakingTransition($interpreter,$xpath,$source,$targets,$element,$moreComing) { + InterpreterMonitor_afterTakingTransition($this->_cPtr,$interpreter,$xpath,$source,$targets,$element,$moreComing); + } + + function beforeEnteringState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_beforeEnteringState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function afterEnteringState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_afterEnteringState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function beforeInvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_beforeInvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function afterInvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_afterInvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function reportIssue($interpreter,$issue) { + InterpreterMonitor_reportIssue($this->_cPtr,$interpreter,$issue); + } +} + +class IssueList { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function c_list($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_std__listT_uscxml__InterpreterIssue_t') { + $this->_cPtr=$res; + return; + } + return new IssueList(new_c_list()); + } + + function size() { + return IssueList_size($this->_cPtr); + } + + function c_empty() { + return IssueList_c_empty($this->_cPtr); + } + + function clear() { + IssueList_clear($this->_cPtr); + } + + function add($x) { + IssueList_add($this->_cPtr,$x); + } + + function get($i) { + $r=IssueList_get($this->_cPtr,$i); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new InterpreterIssue($r); + } + return $r; + } +} + +class DataList { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function size() { + return DataList_size($this->_cPtr); + } + + function c_empty() { + return DataList_c_empty($this->_cPtr); + } + + function clear() { + DataList_clear($this->_cPtr); + } + + function add($x) { + DataList_add($this->_cPtr,$x); + } + + function get($i) { + $r=DataList_get($this->_cPtr,$i); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } +} + +class DataMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_uscxml__Data_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_DataMap(); break; + default: $this->_cPtr=new_DataMap($arg1); + } + } + + function size() { + return DataMap_size($this->_cPtr); + } + + function clear() { + DataMap_clear($this->_cPtr); + } + + function get($key) { + $r=DataMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function set($key,$x) { + DataMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + DataMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return DataMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return DataMap_is_empty($this->_cPtr); + } +} + +class StringSet { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__setT_std__string_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_StringSet(); break; + default: $this->_cPtr=new_StringSet($arg1); + } + } + + function size() { + return StringSet_size($this->_cPtr); + } + + function c_empty() { + return StringSet_c_empty($this->_cPtr); + } + + function clear() { + StringSet_clear($this->_cPtr); + } + + function get($key) { + return StringSet_get($this->_cPtr,$key); + } + + function insert($key) { + StringSet_insert($this->_cPtr,$key); + } + + function del($key) { + StringSet_del($this->_cPtr,$key); + } + + function has_key($key) { + return StringSet_has_key($this->_cPtr,$key); + } +} + +class StringVector { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($n=null) { + if (is_resource($n) && get_resource_type($n) === '_p_std__vectorT_std__string_t') { + $this->_cPtr=$n; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_StringVector(); break; + default: $this->_cPtr=new_StringVector($n); + } + } + + function size() { + return StringVector_size($this->_cPtr); + } + + function capacity() { + return StringVector_capacity($this->_cPtr); + } + + function reserve($n) { + StringVector_reserve($this->_cPtr,$n); + } + + function clear() { + StringVector_clear($this->_cPtr); + } + + function push($x) { + StringVector_push($this->_cPtr,$x); + } + + function is_empty() { + return StringVector_is_empty($this->_cPtr); + } + + function pop() { + return StringVector_pop($this->_cPtr); + } + + function get($i) { + return StringVector_get($this->_cPtr,$i); + } + + function set($i,$val) { + StringVector_set($this->_cPtr,$i,$val); + } +} + +class StringList { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function size() { + return StringList_size($this->_cPtr); + } + + function c_empty() { + return StringList_c_empty($this->_cPtr); + } + + function clear() { + StringList_clear($this->_cPtr); + } + + function add($x) { + StringList_add($this->_cPtr,$x); + } + + function get($i) { + return StringList_get($this->_cPtr,$i); + } +} + +class ParamMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_std__listT_uscxml__Data_t_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_ParamMap(); break; + default: $this->_cPtr=new_ParamMap($arg1); + } + } + + function size() { + return ParamMap_size($this->_cPtr); + } + + function clear() { + ParamMap_clear($this->_cPtr); + } + + function get($key) { + $r=ParamMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataList($r); + } + return $r; + } + + function set($key,$x) { + ParamMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + ParamMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return ParamMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return ParamMap_is_empty($this->_cPtr); + } +} + +class IOProcMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_uscxml__IOProcessor_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_IOProcMap(); break; + default: $this->_cPtr=new_IOProcMap($arg1); + } + } + + function size() { + return IOProcMap_size($this->_cPtr); + } + + function clear() { + IOProcMap_clear($this->_cPtr); + } + + function get($key) { + $r=IOProcMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NativeIOProcessor($r); + } + return $r; + } + + function set($key,$x) { + IOProcMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + IOProcMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return IOProcMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return IOProcMap_is_empty($this->_cPtr); + } +} + +class InvokerMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_uscxml__Invoker_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_InvokerMap(); break; + default: $this->_cPtr=new_InvokerMap($arg1); + } + } + + function size() { + return InvokerMap_size($this->_cPtr); + } + + function clear() { + InvokerMap_clear($this->_cPtr); + } + + function get($key) { + $r=InvokerMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NativeInvoker($r); + } + return $r; + } + + function set($key,$x) { + InvokerMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + InvokerMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return InvokerMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return InvokerMap_is_empty($this->_cPtr); + } +} + +class ParentQueue { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__concurrency__BlockingQueueT_uscxml__SendRequest_t') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_ParentQueue(); + } + + function push($elem) { + ParentQueue_push($this->_cPtr,$elem); + } + + function push_front($elem) { + ParentQueue_push_front($this->_cPtr,$elem); + } + + function pop() { + $r=ParentQueue_pop($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new SendRequest($r); + } + return $r; + } + + function clear() { + ParentQueue_clear($this->_cPtr); + } + + function isEmpty() { + return ParentQueue_isEmpty($this->_cPtr); + } +} + + +?> diff --git a/src/uscxml/DOMUtils.cpp b/src/uscxml/DOMUtils.cpp index 2d3c3ea..5d72d5f 100644 --- a/src/uscxml/DOMUtils.cpp +++ b/src/uscxml/DOMUtils.cpp @@ -122,6 +122,12 @@ std::list > DOMUtils::getElementsByType(const Ar return result; } +NameSpacingParser NameSpacingParser::fromFile(const std::string& file) { + Arabica::SAX::InputSource inputSource; + inputSource.setSystemId(file); + return fromInputSource(inputSource); +} + NameSpacingParser NameSpacingParser::fromXML(const std::string& xml) { std::stringstream* ss = new std::stringstream(); (*ss) << xml; diff --git a/src/uscxml/DOMUtils.h b/src/uscxml/DOMUtils.h index 2264e64..0691952 100644 --- a/src/uscxml/DOMUtils.h +++ b/src/uscxml/DOMUtils.h @@ -84,6 +84,7 @@ class USCXML_API NameSpacingParser : public Arabica::SAX2DOM::Parser& source); diff --git a/src/uscxml/Interpreter.cpp b/src/uscxml/Interpreter.cpp index 060a397..1b2ca15 100644 --- a/src/uscxml/Interpreter.cpp +++ b/src/uscxml/Interpreter.cpp @@ -2260,7 +2260,7 @@ bool InterpreterImpl::nameMatch(const std::string& eventDescs, const std::string return true; // eventDesc has to be a real prefix of event now and therefore shorter - if (eventDesc.size() >= eventName.size()) + if (eventDesc.size() > eventName.size()) goto NEXT_DESC; // are they already equal? @@ -2910,17 +2910,19 @@ NodeSet InterpreterImpl::getTargetStates(const Arabica::XPath::Node return targets; } -std::list InterpreterImpl::tokenize(const std::string& line, const char sep) { +#define ISWHITESPACE(char) (isspace(char)) + +std::list InterpreterImpl::tokenize(const std::string& line, const char sep, bool trimWhiteSpace) { std::list tokens; // appr. 3x faster than stringstream size_t start = 0; for (int i = 0; i < line.size(); i++) { - if (line[i] == sep) { + if (line[i] == sep || (trimWhiteSpace && ISWHITESPACE(line[i]))) { if (i > 0 && start < i) { tokens.push_back(line.substr(start, i - start)); } - while(line[++i] == sep); // skip multiple occurences of seperator + while(line[i] == sep || (trimWhiteSpace && ISWHITESPACE(line[i]))) { i++; } // skip multiple occurences of seperator and whitespaces start = i; } else if (i + 1 == line.size()) { tokens.push_back(line.substr(start, i + 1 - start)); diff --git a/src/uscxml/Interpreter.h b/src/uscxml/Interpreter.h index 7019eb9..bef4c88 100644 --- a/src/uscxml/Interpreter.h +++ b/src/uscxml/Interpreter.h @@ -448,9 +448,9 @@ public: static Arabica::XPath::NodeSet filterChildType(const Arabica::DOM::Node_base::Type type, const Arabica::XPath::NodeSet& nodeSet, bool recurse = false); static std::list tokenizeIdRefs(const std::string& idRefs) { - return tokenize(idRefs); + return tokenize(idRefs, ' ', true); } - static std::list tokenize(const std::string& line, const char seperator = ' '); + static std::list tokenize(const std::string& line, const char seperator = ' ', bool trimWhiteSpace = false); static std::string spaceNormalize(const std::string& text); static bool nameMatch(const std::string& eventDescs, const std::string& event); diff --git a/src/uscxml/messages/Data.h b/src/uscxml/messages/Data.h index 818b26e..f4d220f 100644 --- a/src/uscxml/messages/Data.h +++ b/src/uscxml/messages/Data.h @@ -132,8 +132,8 @@ public: } const Data item(const size_t index) const { - if (array.size() < index) { - std::list::const_iterator arrayIter; + if (array.size() > index) { + std::list::const_iterator arrayIter = array.begin(); for (int i = 0; i < index; i++, arrayIter++) {} return *arrayIter; } diff --git a/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp b/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp index 5fd325d..0302d87 100644 --- a/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp +++ b/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp @@ -176,8 +176,8 @@ void UmundoInvoker::invoke(const InvokeRequest& req) { } _node = new umundo::Node(); - umundo::MDNSDiscoveryOptions discOpts; - _discovery = new umundo::Discovery(umundo::Discovery::MDNS, &discOpts); + umundo::DiscoveryConfigMDNS discOpts; + _discovery = new umundo::Discovery(&discOpts); _discovery->add(*_node); @@ -335,7 +335,7 @@ void UmundoInvoker::removed(umundo::ServiceDescription desc) { returnEvent(addedEvent); } -void UmundoInvoker::changed(umundo::ServiceDescription desc) { +void UmundoInvoker::changed(umundo::ServiceDescription desc, uint64_t what) { } bool UmundoInvoker::jsonbufToData(Data& data, const JSONProto& json) { diff --git a/src/uscxml/plugins/invoker/umundo/UmundoInvoker.h b/src/uscxml/plugins/invoker/umundo/UmundoInvoker.h index 1c5c9a3..4c0e988 100644 --- a/src/uscxml/plugins/invoker/umundo/UmundoInvoker.h +++ b/src/uscxml/plugins/invoker/umundo/UmundoInvoker.h @@ -60,7 +60,7 @@ public: virtual void added(umundo::ServiceDescription); virtual void removed(umundo::ServiceDescription); - virtual void changed(umundo::ServiceDescription); + virtual void changed(umundo::ServiceDescription, uint64_t what); virtual void welcome(umundo::TypedPublisher atPub, const umundo::SubscriberStub& sub); virtual void farewell(umundo::TypedPublisher fromPub, const umundo::SubscriberStub& sub); diff --git a/src/uscxml/transform/ChartToPromela.cpp b/src/uscxml/transform/ChartToPromela.cpp index b750409..59f1d75 100644 --- a/src/uscxml/transform/ChartToPromela.cpp +++ b/src/uscxml/transform/ChartToPromela.cpp @@ -130,200 +130,6 @@ void ChartToPromela::writeTo(std::ostream& stream) { writeProgram(stream); } -void PromelaEventSource::writeStart(std::ostream& stream, int indent) { - std::string padding; - for (int i = 0; i < indent; i++) { - padding += " "; - } - stream << padding << "run " << name << "EventSource() priority 10;" << std::endl; -} - -void PromelaEventSource::writeStop(std::ostream& stream, int indent) { - std::string padding; - for (int i = 0; i < indent; i++) { - padding += " "; - } - - stream << padding << name << "EventSourceDone = 1;" << std::endl; -} - -void PromelaEventSource::writeDeclarations(std::ostream& stream, int indent) { - std::string padding; - for (int i = 0; i < indent; i++) { - padding += " "; - } - stream << "bool " << name << "EventSourceDone = 0;" << std::endl; - -} - -void PromelaEventSource::writeBody(std::ostream& stream) { - - stream << "proctype " << name << "EventSource() {" << std::endl; - stream << " " << name << "EventSourceDone = 0;" << std::endl; - if (analyzer->usesComplexEventStruct()) { - stream << " _event_t tmpE;" << std::endl; - } - stream << " " << name << "NewEvent:" << std::endl; - stream << " " << "if" << std::endl; - stream << " " << ":: " << name << "EventSourceDone -> goto " << name << "Done;" << std::endl; - stream << " " << ":: " << "len(eQ) >= " << externalQueueLength - longestSequence << " -> skip;" << std::endl; - stream << " " << ":: else { " << std::endl; - - Trie& trie = analyzer->getTrie(); - if (source.type == PromelaInline::PROMELA_EVENT_SOURCE_CUSTOM) { - // custom event source - std::string content = source.content; - - boost::replace_all(content, "#REDO#", name + "NewEvent"); - boost::replace_all(content, "#DONE#", name + "Done"); - - std::list eventNames = trie.getChildsWithWords(trie.getNodeWithPrefix("")); - std::list::iterator eventNameIter = eventNames.begin(); - while(eventNameIter != eventNames.end()) { - boost::replace_all(content, "#" + (*eventNameIter)->value + "#", (*eventNameIter)->identifier); - eventNameIter++; - } - - stream << ChartToPromela::beautifyIndentation(content, 2) << std::endl; - } else { - // standard event source - stream << " " << " if" << std::endl; -// stream << " " << " :: 1 -> " << "goto " << sourceName << "NewEvent;" << std::endl; - - std::list >::const_iterator seqIter = sequences.begin(); - while(seqIter != sequences.end()) { - stream << " " << ":: skip -> { "; - std::list::const_iterator evIter = seqIter->begin(); - while(evIter != seqIter->end()) { - TrieNode* node = trie.getNodeWithPrefix(*evIter); - if (!node) { - std::cerr << "Event " << *evIter << " defined in event source but never used in transitions" << std::endl; - evIter++; - continue; - } - if (analyzer->usesComplexEventStruct()) { - stream << "tmpE.name = " << analyzer->macroForLiteral(node->value) << "; eQ!tmpE; "; - } else { - stream << "eQ!" << analyzer->macroForLiteral(node->value) << "; "; - } - evIter++; - } - stream << "goto " << name << "NewEvent;"; - stream << " }" << std::endl; - seqIter++; - } - - stream << " " << " fi;" << std::endl; - } - - stream << " " << "}" << std::endl; - stream << " " << "fi;" << std::endl; - stream << name << "Done:" << " skip;" << std::endl; - stream << "}" << std::endl; - - -// std::list::iterator sourceIter = eventSources.inlines.begin(); -// int i = 0; -// while(sourceIter != eventSources.inlines.end()) { -// if (sourceIter->type != PromelaInline::PROMELA_EVENT_SOURCE_CUSTOM && sourceIter->type != PromelaInline::PROMELA_EVENT_SOURCE) { -// sourceIter++; -// continue; -// } -// -// std::string sourceName = name + "_"+ toStr(i); -// -// stream << "proctype " << sourceName << "EventSource() {" << std::endl; -// stream << " " << sourceName << "EventSourceDone = 0;" << std::endl; -// stream << " " << sourceName << "NewEvent:" << std::endl; -// stream << " " << "if" << std::endl; -// stream << " " << ":: " << sourceName << "EventSourceDone -> skip;" << std::endl; -// stream << " " << ":: else { " << std::endl; -// -// Trie& trie = analyzer->getTrie(); -// -// if (sourceIter->type == PromelaInline::PROMELA_EVENT_SOURCE_CUSTOM) { -// std::string content = sourceIter->content; -// -// boost::replace_all(content, "#REDO#", sourceName + "NewEvent"); -// boost::replace_all(content, "#DONE#", sourceName + "Done"); -// -// std::list eventNames = trie.getChildsWithWords(trie.getNodeWithPrefix("")); -// std::list::iterator eventNameIter = eventNames.begin(); -// while(eventNameIter != eventNames.end()) { -// boost::replace_all(content, "#" + (*eventNameIter)->value + "#", (*eventNameIter)->identifier); -// eventNameIter++; -// } -// -// stream << ChartToPromela::beautifyIndentation(content, 2) << std::endl; -// -// } else { -// stream << " " << " if" << std::endl; -//// stream << " " << " :: 1 -> " << "goto " << sourceName << "NewEvent;" << std::endl; -// -// std::list >::const_iterator seqIter = sourceIter->sequences.begin(); -// while(seqIter != sourceIter->sequences.end()) { -// stream << " " << ":: "; -// std::list::const_iterator evIter = seqIter->begin(); -// while(evIter != seqIter->end()) { -// TrieNode* node = trie.getNodeWithPrefix(*evIter); -// stream << "eQ!" << node->identifier << "; "; -// evIter++; -// } -// stream << "goto " << sourceName << "NewEvent;" << std::endl; -// seqIter++; -// } -// -// stream << " " << " fi;" << std::endl; -// } -// -// stream << " " << "}" << std::endl; -// stream << " " << "fi;" << std::endl; -// stream << sourceName << "Done:" << " skip;" << std::endl; -// stream << "}" << std::endl; -// -// i++; -// sourceIter++; -// } -} - -PromelaEventSource::PromelaEventSource() { - type = PROMELA_EVENT_SOURCE_INVALID; - analyzer = NULL; -} - -PromelaEventSource::PromelaEventSource(const PromelaInline& source, PromelaCodeAnalyzer* analyzer, uint32_t eQueueLength) { - type = PROMELA_EVENT_SOURCE_INVALID; - this->analyzer = analyzer; - externalQueueLength = eQueueLength; - - this->source = source; - - if (source.type == PromelaInline::PROMELA_EVENT_SOURCE) { - std::stringstream ssLines(source.content); - std::string line; - while(std::getline(ssLines, line)) { - boost::trim(line); - if (line.length() == 0) - continue; - if (boost::starts_with(line, "//")) - continue; - - std::list seq; - std::stringstream ssToken(line); - std::string token; - while(std::getline(ssToken, token, ' ')) { - if (token.length() == 0) - continue; - seq.push_back(token); - if (analyzer != NULL) - analyzer->addEvent(token); - } - sequences.push_back(seq); - if (seq.size() > longestSequence) - longestSequence = seq.size(); - } - } -} void PromelaCodeAnalyzer::addCode(const std::string& code, ChartToPromela* interpreter) { PromelaParser parser(code); @@ -570,7 +376,7 @@ std::string PromelaCodeAnalyzer::macroForLiteral(const std::string& literal) { throw std::runtime_error("Literal " + literal + " passed with quotes"); if (_strMacroNames.find(literal) == _strMacroNames.end()) - throw std::runtime_error("No macro for literal " + literal + " known"); + throw std::runtime_error("No macro for literal '" + literal + "' known"); return _strMacroNames[literal]; } @@ -1051,16 +857,6 @@ void ChartToPromela::writeTransition(std::ostream& stream, GlobalTransition* tra } // std::cout << "###" << std::endl; for (std::list::iterator actionIter = transition->actions.begin(); actionIter != transition->actions.end(); actionIter++) { -#if 0 - if (actionIter->onEntry) { - std::cout << "onEntry: " << actionIter->onEntry << std::endl; - } else if (actionIter->raiseDone) { - std::cout << "raiseDone: " << actionIter->raiseDone << std::endl; - } else { - std::cout << "#" << std::endl; - } - foo.insert(*actionIter); -#endif actionsInTransition[transition].insert(*actionIter); } // std::copy(transition->actions.begin(), transition->actions.end(), std::inserter(actionsInTransition[transition], actionsInTransition[transition].begin())); @@ -1163,6 +959,7 @@ void ChartToPromela::writeTransition(std::ostream& stream, GlobalTransition* tra isConditionalized = true; } +#if 0 switch (ecIter->type) { case ExecContentSeqItem::EXEC_CONTENT_ALL_BUT: std::cout << "ALL_BUT" << std::endl; @@ -1177,6 +974,7 @@ void ChartToPromela::writeTransition(std::ostream& stream, GlobalTransition* tra default: break; } +#endif if (action.exited) { // we left a state @@ -1226,86 +1024,31 @@ void ChartToPromela::writeTransition(std::ostream& stream, GlobalTransition* tra // an invoke element if (_machines.find(action.invoke) != _machines.end()) { -#if 1 stream << padding << _prefix << "start!" << _analyzer->macroForLiteral(_machines[action.invoke]->_invokerid) << ";" << std::endl; -#else - - // nested SCXML document - - // set from namelist - if (HAS_ATTR_CAST(action.invoke, "namelist")) { - std::list namelist = tokenize(ATTR_CAST(action.invoke, "namelist")); - for (std::list::iterator nlIter = namelist.begin(); nlIter != namelist.end(); nlIter++) { - if (_machines[action.invoke]->_dataModelVars.find(*nlIter) != _machines[action.invoke]->_dataModelVars.end()) { - stream << padding << _machines[action.invoke]->_prefix << *nlIter << " = " << _prefix << *nlIter << std::endl; - } - } - } - - // set from params - NodeSet invokeParams = filterChildElements(_nsInfo.xmlNSPrefix + "param", action.invoke); - for (int i = 0; i < invokeParams.size(); i++) { - std::string identifier = ATTR_CAST(invokeParams[i], "name"); - std::string expression = ATTR_CAST(invokeParams[i], "expr"); - if (_machines[action.invoke]->_dataModelVars.find(identifier) != _machines[action.invoke]->_dataModelVars.end()) { - stream << padding << _machines[action.invoke]->_prefix << identifier << " = " << ADAPT_SRC(expression) << ";" << std::endl; - } - } - -// stream << padding << " /* assign local variables from invoke request */" << std::endl; -// -// if (_analyzer->usesComplexEventStruct() && _analyzer->usesEventField("data")) { -// for (std::set::iterator dmIter = _dataModelVars.begin(); dmIter != _dataModelVars.end(); dmIter++) { -// if (_analyzer->usesEventDataField(*dmIter)) { -// stream << " if" << std::endl; -// stream << " :: " << _prefix << "_event.data." << *dmIter << " -> " << _prefix << *dmIter << " = " << "_event.data." << *dmIter << ";" << std::endl; -// stream << " :: else -> skip;" << std::endl; -// stream << " fi" << std::endl; -// } -// } -// } -// stream << std::endl; - - stream << padding << "run " << _machines[action.invoke]->_prefix << "run() priority 20;" << std::endl; - if (HAS_ATTR_CAST(action.invoke, "idlocation")) { - stream << padding << ADAPT_SRC(ATTR_CAST(action.invoke, "idlocation")) << " = " << _analyzer->macroForLiteral(_machines[_machinesPerId[ATTR_CAST(action.invoke, "id")]]->_invokerid) << ";" << std::endl; - } -#endif } else { - if (HAS_ATTR_CAST(action.invoke, "invokeid") && _invokers.find(ATTR_CAST(action.invoke, "invokeid")) != _invokers.end()) - _invokers[ATTR_CAST(action.invoke, "invokeid")].writeStart(stream, indent); + if (HAS_ATTR_CAST(action.invoke, "id")) { + stream << padding << _prefix << ATTR_CAST(action.invoke, "id") << "Running = true;" << std::endl; + } } } if (action.uninvoke) { - assert(_machines.find(action.uninvoke) != _machines.end()); - stream << padding << "do" << std::endl; - stream << padding << ":: " << _prefix << "start??" << _analyzer->macroForLiteral(_machines[action.uninvoke]->_invokerid) << " -> skip" << std::endl; - stream << padding << ":: else -> break;" << std::endl; - stream << padding << "od" << std::endl; - -// std::cout << action.uninvoke << std::endl; - // an invoke element to uninvoke if (_machines.find(action.uninvoke) != _machines.end()) { - // nested SCXML document - stream << padding << _machines[action.uninvoke]->_prefix << "canceled = true;" << std::endl; - if (_analyzer->usesEventField("delay")) - stream << padding << "removePendingEventsForInvoker(" << _analyzer->macroForLiteral(_machines[action.uninvoke]->_invokerid) << ");" << std::endl; -// writeRemovePendingEventsFromInvoker(stream, _machines[action.uninvoke], indent, false); -#if 0 stream << padding << "do" << std::endl; - if (_allowEventInterleaving) - stream << padding << ":: len(" << _machines[action.uninvoke]->_prefix << "tmpQ) > 0 -> " << _machines[action.uninvoke]->_prefix << "tmpQ?_;" << std::endl; - stream << padding << ":: len(" << _machines[action.uninvoke]->_prefix << "eQ) > 0 -> " << _machines[action.uninvoke]->_prefix << "eQ?_;" << std::endl; + stream << padding << ":: " << _prefix << "start??" << _analyzer->macroForLiteral(_machines[action.uninvoke]->_invokerid) << " -> skip" << std::endl; stream << padding << ":: else -> break;" << std::endl; stream << padding << "od" << std::endl; -#endif + + stream << padding << _machines[action.uninvoke]->_prefix << "canceled = true;" << std::endl; + if (_analyzer->usesEventField("delay")) { + stream << padding << "removePendingEventsForInvoker(" << _analyzer->macroForLiteral(_machines[action.uninvoke]->_invokerid) << ");" << std::endl; + } } else { - if (HAS_ATTR_CAST(action.uninvoke, "invokeid") && _invokers.find(ATTR_CAST(action.invoke, "invokeid")) != _invokers.end()) - stream << padding << ATTR_CAST(action.uninvoke, "invokeid") << "EventSourceDone" << "= 1;" << std::endl; + if (HAS_ATTR_CAST(action.uninvoke, "id")) { + stream << padding << _prefix << ATTR_CAST(action.uninvoke, "id") << "Running = false;" << std::endl; + } } -// continue; } if (isConditionalized) { @@ -1682,17 +1425,7 @@ void ChartToPromela::writeExecutableContent(std::ostream& stream, const Arabica: for (int i = 0; i < indent; i++) { padding += " "; } - - if (node.getNodeType() == Node_base::COMMENT_NODE) { - // we cannot have labels in an atomic block, just process inline promela - PromelaInlines promInls = PromelaInlines::fromNode(node); - // TODO! - // if (promInls) { - // stream << padding << "skip;" << std::endl; - // stream << beautifyIndentation(inlinePromela.str(), indent) << std::endl; - // } - } - + if (node.getNodeType() == Node_base::TEXT_NODE) { if (boost::trim_copy(node.getNodeValue()).length() > 0) stream << beautifyIndentation(ADAPT_SRC(node.getNodeValue()), indent) << std::endl; @@ -1894,94 +1627,168 @@ void ChartToPromela::writeExecutableContent(std::ostream& stream, const Arabica: } } - -PromelaInlines PromelaInlines::fromNodeSet(const NodeSet& node, bool recurse) { - PromelaInlines allPromInls; - Arabica::XPath::NodeSet comments = InterpreterImpl::filterChildType(Node_base::COMMENT_NODE, node, recurse); - for (int i = 0; i < comments.size(); i++) { - allPromInls.merge(PromelaInlines::fromNode(comments[i])); - } - return allPromInls; - +PromelaInlines::~PromelaInlines() { + return; } -PromelaInlines PromelaInlines::fromNode(const Arabica::DOM::Node& node) { - if (node.getNodeType() != Node_base::COMMENT_NODE && node.getNodeType() != Node_base::TEXT_NODE) - return PromelaInlines(); - return PromelaInlines(node.getNodeValue(), node); -} +std::list PromelaInlines::getRelatedTo(const Arabica::DOM::Node& node, PromelaInline::PromelaInlineType type) { + std::list related; + + std::map, std::list >::iterator inlIter = inlines.begin(); + while (inlIter != inlines.end()) { + std::list::iterator pmlIter = inlIter->second.begin(); + while (pmlIter != inlIter->second.end()) { + if ((type != PromelaInline::PROMELA_NIL || (*pmlIter)->type == type) && (*pmlIter)->relatesTo(node)) { + related.push_back(*pmlIter); + } + pmlIter++; + } + inlIter++; + } + return related; - PromelaInlines PromelaInlines::fromString(const std::string& text) { - return PromelaInlines(text, Arabica::DOM::Node()); + return related; } -PromelaInlines::PromelaInlines() : nrProgressLabels(0), nrAcceptLabels(0), nrEndLabels(0), nrEventSources(0), nrCodes(0) { +std::list PromelaInlines::getAllOfType(uint32_t type) { + std::list related; + + std::map, std::list >::iterator inlIter = inlines.begin(); + while (inlIter != inlines.end()) { + std::list::iterator pmlIter = inlIter->second.begin(); + while (pmlIter != inlIter->second.end()) { + if ((*pmlIter)->type & type) { + related.push_back(*pmlIter); + } + pmlIter++; + } + inlIter++; + } + return related; } -PromelaInlines::PromelaInlines(const std::string& content, const Arabica::DOM::Node& node) - : nrProgressLabels(0), nrAcceptLabels(0), nrEndLabels(0), nrEventSources(0), nrCodes(0) { +PromelaInline::PromelaInline(const Arabica::DOM::Node& node) : prevSibling(NULL), nextSibling(NULL), type(PROMELA_NIL) { + if (node.getNodeType() != Node_base::COMMENT_NODE && node.getNodeType() != Node_base::TEXT_NODE) + return; // nothing to do - std::stringstream ssLine(content); + std::stringstream ssLine(node.getNodeValue()); std::string line; + + while(std::getline(ssLine, line)) { + // skip to first promela line + boost::trim(line); + if (boost::starts_with(line, "promela")) + break; + } - bool isInPromelaCode = false; - PromelaInline promInl; + if (!boost::starts_with(line, "promela")) + return; + if (false) { + } else if (boost::starts_with(line, "promela-code")) { + type = PROMELA_CODE; + } else if (boost::starts_with(line, "promela-ltl")) { + type = PROMELA_LTL; + } else if (boost::starts_with(line, "promela-event-all")) { + type = PROMELA_EVENT_ALL_BUT; + } else if (boost::starts_with(line, "promela-event")) { + type = PROMELA_EVENT_ONLY; + } else if (boost::starts_with(line, "promela-progress")) { + type = PROMELA_PROGRESS_LABEL; + } else if (boost::starts_with(line, "promela-accept")) { + type = PROMELA_ACCEPT_LABEL; + } else if (boost::starts_with(line, "promela-end")) { + type = PROMELA_END_LABEL; + } + + std::stringstream contentSS; + size_t endType = line.find_first_of(": \n"); + + std::string seperator; + if (endType != std::string::npos && endType + 1 < line.size()) { + contentSS << line.substr(endType + 1, line.size() - endType + 1); + seperator = "\n"; + } + while(std::getline(ssLine, line)) { - std::string trimLine = boost::trim_copy(line); - if (trimLine.length() == 0) - continue; - if (boost::starts_with(trimLine, "#promela")) { - if (isInPromelaCode) { - code.push_back(promInl); - isInPromelaCode = false; - } - promInl = PromelaInline(); - } - - if (false) { - } else if (boost::starts_with(trimLine, "#promela-progress")) { - nrProgressLabels++; - promInl.type = PromelaInline::PROMELA_PROGRESS_LABEL; - promInl.content = line; - code.push_back(promInl); - } else if (boost::starts_with(trimLine, "#promela-accept")) { - nrAcceptLabels++; - promInl.type = PromelaInline::PROMELA_ACCEPT_LABEL; - promInl.content = line; - code.push_back(promInl); - } else if (boost::starts_with(trimLine, "#promela-end")) { - nrEndLabels++; - promInl.type = PromelaInline::PROMELA_END_LABEL; - promInl.content = line; - code.push_back(promInl); - } else if (boost::starts_with(trimLine, "#promela-inline")) { - nrCodes++; - isInPromelaCode = true; - promInl.type = PromelaInline::PROMELA_CODE; - } else if (boost::starts_with(trimLine, "#promela-event-source-custom")) { - nrEventSources++; - isInPromelaCode = true; - promInl.type = PromelaInline::PROMELA_EVENT_SOURCE_CUSTOM; - } else if (boost::starts_with(trimLine, "#promela-event-source")) { - nrEventSources++; - isInPromelaCode = true; - promInl.type = PromelaInline::PROMELA_EVENT_SOURCE; - } else if (isInPromelaCode) { - promInl.content += line; - promInl.content += "\n"; - } - } - // inline code ends with comment - if (isInPromelaCode) { - code.push_back(promInl); + boost::trim(line); + if (boost::starts_with(line, "promela")) { + std::cerr << "Split multiple #promela pragmas into multiple comments!" << std::endl; + break; + } + contentSS << seperator << line; + seperator = "\n"; } + content = contentSS.str(); +} + + +PromelaInlines::PromelaInlines(const Arabica::DOM::Node& node) { + NodeSet levelNodes; + levelNodes.push_back(node); + + size_t level = 0; + while(levelNodes.size() > 0) { + PromelaInline* predecessor = NULL; + + // iterate all nodes at given level + for (int i = 0; i < levelNodes.size(); i++) { - // iterate inlinesFound and classify -// PromelaEventSource promES; // TODO! use this + // get all comments + NodeSet comments = InterpreterImpl::filterChildType(Node_base::COMMENT_NODE, levelNodes[i]); + for (int j = 0; j < comments.size(); j++) { + PromelaInline* tmp = new PromelaInline(comments[j]); + if (tmp->type == PromelaInline::PROMELA_NIL) { + delete tmp; + continue; + } + if (predecessor != NULL) { + tmp->prevSibling = predecessor; + predecessor->nextSibling = tmp; + } + tmp->level = level; + tmp->container = Element(levelNodes[i]); + predecessor = tmp; + inlines[levelNodes[i]].push_back(tmp); + allInlines.push_back(tmp); + } + } + + levelNodes = InterpreterImpl::filterChildType(Node_base::ELEMENT_NODE, levelNodes); + level++; + } } +void PromelaInline::dump() { +#if 0 + switch(type) { + case PROMELA_NIL: + std::cerr << "PROMELA_NIL" << std::endl; + break; + case PROMELA_CODE: + std::cerr << "PROMELA_CODE" << std::endl; + break; + case PROMELA_EVENT_SOURCE_ALL: + std::cerr << "PROMELA_EVENT_SOURCE" << std::endl; + break; + case PROMELA_INVOKER: + std::cerr << "PROMELA_INVOKER" << std::endl; + break; + case PROMELA_PROGRESS_LABEL: + std::cerr << "PROMELA_PROGRESS_LABEL" << std::endl; + break; + case PROMELA_ACCEPT_LABEL: + std::cerr << "PROMELA_ACCEPT_LABEL" << std::endl; + break; + case PROMELA_END_LABEL: + std::cerr << "PROMELA_END_LABEL" << std::endl; + break; + } +#endif +} + + void ChartToPromela::writeIfBlock(std::ostream& stream, const Arabica::XPath::NodeSet& condChain, int indent) { if (condChain.size() == 0) return; @@ -2157,6 +1964,13 @@ void ChartToPromela::writeDeclarations(std::ostream& stream) { stream << "_x_t " << _prefix << "_x;" << std::endl; } + std::list pmls = pmlInlines.getAllOfType(PromelaInline::PROMELA_EVENT_ALL_BUT | PromelaInline::PROMELA_EVENT_ONLY); + for (std::list::iterator pmlIter = pmls.begin(); pmlIter != pmls.end(); pmlIter++) { + if ((*pmlIter)->container && LOCALNAME((*pmlIter)->container) == "invoke") { + stream << "bool " << _prefix << ATTR_CAST((*pmlIter)->container, "id") << "Running;" << std::endl; + } + } + stream << std::endl << std::endl; // get all data elements @@ -2206,41 +2020,6 @@ void ChartToPromela::writeDeclarations(std::ostream& stream) { std::string decl = type + " " + _prefix + identifier + arrSize; stream << decl << ";" << std::endl; -#if 0 - - NodeSet dataText = filterChildType(Node_base::TEXT_NODE, data, true); - std::string value; - if (dataText.size() > 0) { - value = dataText[0].getNodeValue(); - boost::trim(value); - } - - if (identifier.length() > 0) { - - size_t bracketPos = type.find("["); - if (bracketPos != std::string::npos) { - arrSize = type.substr(bracketPos, type.length() - bracketPos); - type = type.substr(0, bracketPos); - } - std::string decl = type + " " + _prefix + identifier + arrSize; - stream << decl << ";" << std::endl; - - if (arrSize.length() > 0) { - _varInitializers.push_back(value); - } else { - if (expression.length() > 0) { - // id and expr given - _varInitializers.push_back(identifier + " = " + boost::trim_copy(expression) + ";"); - } else if (value.length() > 0) { - // id and text content given - _varInitializers.push_back(identifier + " = " + value + ";"); - } - } - } else if (value.length() > 0) { - // no id but text content given - stream << beautifyIndentation(value) << std::endl; - } -#endif } @@ -2277,33 +2056,10 @@ void ChartToPromela::writeDeclarations(std::ostream& stream) { } stream << std::endl; - if (_globalEventSource || _invokers.size() > 0) - stream << "/* event sources */" << std::endl; - - if (_globalEventSource) { - _globalEventSource.writeDeclarations(stream); - } - - std::map::iterator invIter = _invokers.begin(); - while(invIter != _invokers.end()) { - invIter->second.writeDeclarations(stream); - invIter++; - } - + } void ChartToPromela::writeEventSources(std::ostream& stream) { - std::list::iterator inlineIter; - - if (_globalEventSource) { - _globalEventSource.writeBody(stream); - } - - std::map::iterator invIter = _invokers.begin(); - while(invIter != _invokers.end()) { - invIter->second.writeBody(stream); - invIter++; - } } void ChartToPromela::writeStartInvoker(std::ostream& stream, const Arabica::DOM::Node& node, ChartToPromela* invoker, int indent) { @@ -2427,27 +2183,96 @@ void ChartToPromela::writeFSM(std::ostream& stream) { stream << " scheduleMachines();" << std::endl << std::endl; } + std::list eventSources = pmlInlines.getAllOfType(PromelaInline::PROMELA_EVENT_ALL_BUT | + PromelaInline::PROMELA_EVENT_ONLY); + stream << " atomic {" << std::endl; stream << " /* pop an event */" << std::endl; stream << " if" << std::endl; stream << " :: len(" << _prefix << "iQ) != 0 -> " << _prefix << "iQ ? " << _prefix << "_event /* from internal queue */" << std::endl; - stream << " :: else -> " << _prefix << "eQ ? " << _prefix << "_event /* from external queue */" << std::endl; - stream << " fi;" << std::endl << std::endl; + if (eventSources.size() > 0) { + stream << " :: len(" << _prefix << "eQ) != 0 -> " << _prefix << "eQ ? " << _prefix << "_event /* from external queue */" << std::endl; + stream << " :: else -> {" << std::endl; + stream << " /* external queue is empty -> automatically enqueue external event */" << std::endl; + stream << " if" << std::endl; -#if 0 - if (!_analyzer->usesComplexEventStruct()) { - stream << " printf(\"======= Process %d dequeued %d\\n\", _pid, " << _prefix << "_event);" << std::endl; + for (std::list::iterator esIter = eventSources.begin(); esIter != eventSources.end(); esIter++) { + PromelaEventSource es(**esIter); + + std::string condition = "true"; + + if (LOCALNAME(es.container) == "invoke") { + if (HAS_ATTR_CAST(es.container, "id")) { + condition = _prefix + ATTR_CAST(es.container, "id") + "Running"; + } else { + LOG(ERROR) << "Invoker has no id"; + } + } else if (HAS_ATTR(es.container, "id")) { + condition = _prefix + "_x.states[" + _analyzer->macroForLiteral(ATTR(es.container, "id")) + "]"; + } + stream << " :: " << condition << " -> {" << std::endl; + + if (es.type == PromelaInline::PROMELA_EVENT_ALL_BUT) { + std::string excludeEventDescs; + for (std::list::iterator evIter = es.events.array.begin(); evIter != es.events.array.end(); evIter++) { + excludeEventDescs += " " + evIter->atom; + } + + NodeSet transitions = filterChildElements("transition", es.container, true); + std::set eventNames; + for (int i = 0; i < transitions.size(); i++) { + if (!HAS_ATTR_CAST(transitions[i], "event")) + continue; + if (HAS_ATTR_CAST(transitions[i], "cond") && ATTR_CAST(transitions[i], "cond").find("_event.") != std::string::npos) + continue; + std::list events = InterpreterImpl::tokenizeIdRefs(ATTR_CAST(transitions[i], "event")); + for (std::list::iterator evIter = events.begin(); evIter != events.end(); evIter++) { + std::string eventName = *evIter; + if (boost::ends_with(eventName, "*")) + eventName = eventName.substr(0, eventName.size() - 1); + if (boost::ends_with(eventName, ".")) + eventName = eventName.substr(0, eventName.size() - 1); + + // is this event excluded? + if (!InterpreterImpl::nameMatch(excludeEventDescs, eventName)) { + eventNames.insert(eventName); + } + } + } + + if (eventNames.size() > 0) { + stream << " if " << std::endl; + for (std::set::iterator evIter = eventNames.begin(); evIter != eventNames.end(); evIter++) { + stream << " :: true -> { " << _prefix << "_event.name = " << _analyzer->macroForLiteral(*evIter) << " }" << std::endl; + } + stream << " fi " << std::endl; + } + + } else if (es.type == PromelaInline::PROMELA_EVENT_ONLY) { + if (es.events.array.size() > 0) { + stream << " if " << std::endl; + for (std::list::iterator evIter = es.events.array.begin(); evIter != es.events.array.end(); evIter++) { + stream << " :: true -> { " << std::endl; + stream << dataToAssignments(" _event", *evIter); + stream << " } " << std::endl; + } + stream << " fi " << std::endl; + } else { + stream << dataToAssignments(" _event", es.events); + } + } else { + assert(false); + } + stream << " }" << std::endl; + } + + stream << " fi" << std::endl; + stream << " }" << std::endl; } else { - stream << " printf(\"======= Process %d dequeued %d\\n\", _pid, " << _prefix << "_event.name);" << std::endl; - if (_analyzer->usesEventField("sendid")) - stream << " printf(\" sendid: %d\\n\", " << _prefix << "_event.sendid);" << std::endl; - if (_analyzer->usesEventField("invokeid")) - stream << " printf(\" invokeid: %d\\n\", " << _prefix << "_event.invokeid);" << std::endl; - if (_analyzer->usesEventField("delay")) - stream << " printf(\" delay: %d\\n\", " << _prefix << "_event.delay);" << std::endl; + stream << " :: else -> " << _prefix << "eQ ? " << _prefix << "_event /* from external queue */" << std::endl; } - stream << std::endl; -#endif + stream << " fi;" << std::endl << std::endl; + stream << " /* terminate if we are stopped */" << std::endl; stream << " if" << std::endl; @@ -2532,16 +2357,6 @@ void ChartToPromela::writeFSM(std::ostream& stream) { stream << " removePendingEventsForInvoker(" << _analyzer->macroForLiteral(this->_invokerid) << ")" << std::endl; } - // stop all event sources - if (_globalEventSource) - _globalEventSource.writeStop(stream, 2); - - std::map::iterator invIter = _invokers.begin(); - while(invIter != _invokers.end()) { - invIter->second.writeStop(stream, 2); - invIter++; - } - stream << " }" << std::endl; stream << "}" << std::endl; } @@ -2907,8 +2722,7 @@ void ChartToPromela::writeMain(std::ostream& stream) { } stream << std::endl; } - if (_globalEventSource) - _globalEventSource.writeStart(stream, 1); + stream << " run " << (_prefix.size() == 0 ? "machine_" : _prefix) << "run() priority 10;" << std::endl; stream << "}" << std::endl; @@ -3175,44 +2989,44 @@ void ChartToPromela::initNodes() { } } } - // external event names from comments and event sources - NodeSet promelaEventSourceComments; - NodeSet invokers = _xpath.evaluate("//" + _nsInfo.xpathPrefix + "invoke", _scxml).asNodeSet(); - promelaEventSourceComments.push_back(filterChildType(Node_base::COMMENT_NODE, invokers, false)); // comments in invoke elements - promelaEventSourceComments.push_back(filterChildType(Node_base::COMMENT_NODE, _scxml, false)); // comments in scxml element - - for (int i = 0; i < promelaEventSourceComments.size(); i++) { - PromelaInlines promInls = PromelaInlines::fromNode(promelaEventSourceComments[i]); + + { + // gather all inline promela comments + pmlInlines = PromelaInlines(_scxml); + if (pmlInlines.getAllOfType(PromelaInline::PROMELA_EVENT_ONLY).size() > 0) + _analyzer->addCode("_x.states", this); - for ( std::list::iterator promIter = promInls.code.begin(); promIter != promInls.code.end(); promIter++) { - if (promIter->type == PromelaInline::PROMELA_EVENT_SOURCE || promIter->type == PromelaInline::PROMELA_EVENT_SOURCE_CUSTOM) { - PromelaEventSource promES(*promIter, _analyzer, _externalQueueLength); - if (TAGNAME_CAST(promelaEventSourceComments[i].getParentNode()) == "scxml") { - promES.type = PromelaEventSource::PROMELA_EVENT_SOURCE_GLOBAL; - promES.name = "global"; - _globalEventSource = promES; - } else { - Element invoker = Element(promelaEventSourceComments[i].getParentNode()); - if (!HAS_ATTR_CAST(promelaEventSourceComments[i].getParentNode(), "id")) { - invoker.setAttribute("invokeid", "invoker" + toStr(_invokers.size())); // if there is no invokeid, enumerate - } else { - invoker.setAttribute("invokeid", ATTR_CAST(promelaEventSourceComments[i].getParentNode(), "id")); + // register events and string literals + for (std::list::iterator inlIter = pmlInlines.allInlines.begin(); inlIter != pmlInlines.allInlines.end(); inlIter++) { + if ((*inlIter)->type != (PromelaInline::PROMELA_EVENT_ONLY)) + continue; + + Data json = Data::fromJSON((*inlIter)->content); + if (!json.empty()) { + std::list eventNames = PromelaInlines::getEventNames(json); + for (std::list::iterator evIter = eventNames.begin(); evIter != eventNames.end(); evIter++) { + _analyzer->addEvent(*evIter); + } + + std::list stringLiterals = PromelaInlines::getStringLiterals(json); + for (std::list::iterator strIter = stringLiterals.begin(); strIter != stringLiterals.end(); strIter++) { + _analyzer->addLiteral(*strIter); + } + + if (json.array.size() > 0) { + for (int i = 0; i < json.array.size(); i++) { + std::string expr = dataToAssignments("_event", json.item(i)); + _analyzer->addCode(expr, this); } - std::string invokeId = ATTR_CAST(promelaEventSourceComments[i].getParentNode(), "invokeid"); - - promES.type = PromelaEventSource::PROMELA_EVENT_SOURCE_INVOKER; - promES.name = invokeId; - _invokers[invokeId] = promES; + } else { + std::string expr = dataToAssignments("_event", json); + _analyzer->addCode(expr, this); + } + } } } - - if (_globalEventSource || _invokers.size() > 0) { - _allowEventInterleaving = true; - } else { - _allowEventInterleaving = false; - } // add platform variables as string literals _analyzer->addLiteral(_prefix + "_sessionid"); @@ -3331,11 +3145,55 @@ void ChartToPromela::initNodes() { } } - +std::list PromelaInlines::getStringLiterals(const Data& data) { + std::list literals; + if (data.atom.size() > 0 && data.type == Data::VERBATIM) { + literals.push_back(data.atom); + } + if (data.array.size() > 0) { + for (std::list::const_iterator arrIter = data.array.begin(); arrIter != data.array.end(); arrIter++) { + std::list nested = getStringLiterals(*arrIter); + literals.insert(literals.end(), nested.begin(), nested.end()); + } + } + if (data.compound.size() > 0) { + for (std::map::const_iterator compIter = data.compound.begin(); compIter != data.compound.end(); compIter++) { + std::list nested = getStringLiterals(compIter->second); + literals.insert(literals.end(), nested.begin(), nested.end()); + } + } + return literals; +} + +std::list PromelaInlines::getEventNames(const Data& data) { + std::list eventNames; + if (data.compound.size() > 0 && data.hasKey("name")) { + eventNames.push_back(data.at("name")); + } + if (data.array.size() > 0) { + for (std::list::const_iterator arrIter = data.array.begin(); arrIter != data.array.end(); arrIter++) { + std::list nested = getEventNames(*arrIter); + eventNames.insert(eventNames.end(), nested.begin(), nested.end()); + } + } + if (data.compound.size() > 0) { + for (std::map::const_iterator compIter = data.compound.begin(); compIter != data.compound.end(); compIter++) { + std::list nested = getEventNames(compIter->second); + eventNames.insert(eventNames.end(), nested.begin(), nested.end()); + } + } + + return eventNames; +} + std::string ChartToPromela::dataToAssignments(const std::string& prefix, const Data& data) { std::stringstream retVal; if (data.atom.size() > 0) { - retVal << prefix << " = " << data.atom << ";" << std::endl; + if (data.type == Data::VERBATIM) { + retVal << prefix << " = " << _analyzer->macroForLiteral(data.atom) << ";" << std::endl; + } else { + retVal << prefix << " = " << data.atom << ";" << std::endl; + } } else if (data.compound.size() > 0) { for (std::map::const_iterator cIter = data.compound.begin(); cIter != data.compound.end(); cIter++) { retVal << dataToAssignments(prefix + "." + cIter->first, cIter->second); @@ -3358,18 +3216,6 @@ std::string ChartToPromela::sanitizeCode(const std::string& code) { return replaced; } -void PromelaInline::dump() { -// std::list >::iterator outerIter = sequences.begin(); -// while(outerIter != sequences.end()) { -// std::list::iterator innerIter = outerIter->begin(); -// while(innerIter != outerIter->end()) { -// std::cout << *innerIter << " "; -// innerIter++; -// } -// std::cout << std::endl; -// outerIter++; -// } -} void ChartToPromela::writeProgram(std::ostream& stream) { diff --git a/src/uscxml/transform/ChartToPromela.h b/src/uscxml/transform/ChartToPromela.h index 9a8b0a3..1b0b16d 100644 --- a/src/uscxml/transform/ChartToPromela.h +++ b/src/uscxml/transform/ChartToPromela.h @@ -36,31 +36,96 @@ namespace uscxml { class PromelaCodeAnalyzer; class ChartToPromela; class PromelaParserNode; - + class USCXML_API PromelaInline { public: - PromelaInline() : type(PROMELA_NIL) {} + enum PromelaInlineType { + PROMELA_NIL = 0x0000, + PROMELA_LTL = 0x0001, + PROMELA_CODE = 0x0002, + PROMELA_EVENT_ALL_BUT = 0x0004, + PROMELA_EVENT_ONLY = 0x0008, + PROMELA_PROGRESS_LABEL = 0x0010, + PROMELA_ACCEPT_LABEL = 0x0020, + PROMELA_END_LABEL = 0x0040 + }; + PromelaInline(const Arabica::DOM::Node& node); + virtual ~PromelaInline() {} + operator bool() { return (type != PROMELA_NIL); } - void dump(); - - enum PromelaInlineType { - PROMELA_NIL, - PROMELA_CODE, - PROMELA_EVENT_SOURCE, - PROMELA_EVENT_SOURCE_CUSTOM, - PROMELA_PROGRESS_LABEL, - PROMELA_ACCEPT_LABEL, - PROMELA_END_LABEL - }; + std::list children; + PromelaInline* prevSibling; + PromelaInline* nextSibling; + + virtual void dump(); + virtual bool relatesTo(const Arabica::DOM::Node& node) { + return container == node; + } + + size_t level; std::string content; + Arabica::DOM::Element container; PromelaInlineType type; + +protected: + PromelaInline() : prevSibling(NULL), nextSibling(NULL), type(PROMELA_NIL) {}; +}; + +class USCXML_API PromelaInlines { +public: + + PromelaInlines(const Arabica::DOM::Node& node); + PromelaInlines() {} + + virtual ~PromelaInlines(); + + std::list getRelatedTo(const Arabica::DOM::Node& node, PromelaInline::PromelaInlineType type); + std::list getAllOfType(uint32_t type); + + std::map, std::list > inlines; + std::list allInlines; + + static std::list getStringLiterals(const Data& data); + static std::list getEventNames(const Data& data); + + +}; + +class USCXML_API PromelaEventSource : public PromelaInline { +public: + PromelaEventSource(const PromelaInline& pmlInline) { + type = pmlInline.type; + container = pmlInline.container; + content = pmlInline.content; + events = Data::fromJSON(pmlInline.content); + } + + virtual bool relatesTo(const Arabica::DOM::Node& node) { + return container == node || InterpreterImpl::isDescendant(node, container); + } + + Data events; }; +#if 0 + + +class USCXML_API PromelaInlinesAutoEvents : public PromelaInline { +public: + virtual ~PromelaInlinesAutoEvents() {} + virtual bool relatesTo(const Arabica::DOM::Node&); + virtual void setContent(const std::string& content); + virtual void dump(); + + std::map states; +}; + + class USCXML_API PromelaEventSource { public: @@ -93,37 +158,8 @@ public: PromelaCodeAnalyzer* analyzer; }; -class USCXML_API PromelaInlines { -public: - - static PromelaInlines fromNodeSet(const Arabica::XPath::NodeSet& node, bool recurse = false); - static PromelaInlines fromNode(const Arabica::DOM::Node& node); - static PromelaInlines fromString(const std::string& text); +#endif - PromelaInlines(const std::string& text, const Arabica::DOM::Node& node); - PromelaInlines(); - - void merge(const PromelaInlines& other) { - code.insert(code.end(), other.code.begin(), other.code.end()); - nrProgressLabels += other.nrProgressLabels; - nrAcceptLabels += other.nrAcceptLabels; - nrEndLabels += other.nrEndLabels; - nrEventSources += other.nrEventSources; - nrCodes += other.nrCodes; - } - - operator bool() { - return code.size() > 0; - } - - std::list code; - int nrProgressLabels; - int nrAcceptLabels; - int nrEndLabels; - int nrEventSources; - int nrCodes; -}; - class USCXML_API PromelaCodeAnalyzer { public: class PromelaTypedef { @@ -172,6 +208,9 @@ public: bool usesInPredicate() { return _usesInPredicate; } + void usesInPredicate(bool value) { + _usesInPredicate = value; + } bool usesPlatformVars() { return _usesPlatformVars; } @@ -366,8 +405,9 @@ protected: uint32_t _externalQueueLength; uint32_t _internalQueueLength; - std::map _invokers; - PromelaEventSource _globalEventSource; + PromelaInlines pmlInlines; +// std::map _invokers; +// PromelaEventSource _globalEventSource; std::map > _historyMembers; // ids of all history states std::set _dataModelVars; diff --git a/test/src/test-predicates.cpp b/test/src/test-predicates.cpp index f66e8ba..7ba9225 100644 --- a/test/src/test-predicates.cpp +++ b/test/src/test-predicates.cpp @@ -118,7 +118,7 @@ int main(int argc, char** argv) { assert(InterpreterImpl::nameMatch(transEvents, "error")); assert(!InterpreterImpl::nameMatch(transEvents, "foo")); - transEvents = "error foo"; + transEvents = " error foo"; assert(InterpreterImpl::nameMatch(transEvents, "error")); assert(InterpreterImpl::nameMatch(transEvents, "error.send")); assert(InterpreterImpl::nameMatch(transEvents, "error.send.failed")); diff --git a/test/src/test-promela-parser.cpp b/test/src/test-promela-parser.cpp index 00cc347..8c8f2b4 100644 --- a/test/src/test-promela-parser.cpp +++ b/test/src/test-promela-parser.cpp @@ -9,13 +9,68 @@ #include #include #include +#include using namespace uscxml; using namespace boost; +using namespace Arabica::DOM; extern int promela_debug; void testInlinePromela() { + + DOMImplementation domFactory = Arabica::SimpleDOM::DOMImplementation::getDOMImplementation(); + Document document = domFactory.createDocument("", "", 0); + + { + std::string test = "\ + promela-code This is foo!\ + "; + + Comment comment = document.createComment(test); + PromelaInline inl(comment); + assert(inl.type == PromelaInline::PROMELA_CODE); + assert(inl.content == "This is foo!"); + } + + { + std::string test = "\ + promela-code\n \ + This is foo!\ + "; + + Comment comment = document.createComment(test); + PromelaInline inl(comment); + assert(inl.type == PromelaInline::PROMELA_CODE); + assert(inl.content == "This is foo!"); + } + + { + std::string test = "\ + promela-event\n \ + [{\"name\": \"e1\", \"data\": { \"foo\": \"some string\" }}, \ + {\"name\": \"e1\", \"data\": { \"bar\": 12 }}]"; + + Comment comment = document.createComment(test); + PromelaInline inl(comment); + assert(inl.type == PromelaInline::PROMELA_EVENT_ONLY); + + PromelaEventSource es(inl); + assert(es.events.array.size() == 2); + + } + + { + Interpreter interpreter = Interpreter::fromURL("/Users/sradomski/Documents/TK/Code/uscxml/test/uscxml/promela/test-event-source-auto.scxml"); + assert(interpreter); + PromelaInlines inls(interpreter.getDocument().getDocumentElement()); + + assert(inls.getAllOfType(PromelaInline::PROMELA_EVENT_ONLY).size() == 1); + assert(inls.getAllOfType(PromelaInline::PROMELA_EVENT_ALL_BUT).size() == 1); + interpreter.getImpl()->getState("s0"); + } + +#if 0 { std::string test = "\ #promela-inline:\n \ @@ -169,6 +224,7 @@ void testInlinePromela() { assert(pmlES.sequences.size() == 0); assert(boost::trim_copy(pmlES.source.content) == "This is foo!"); } +#endif } void checkTokenLocations(const std::string& expr, PromelaParserNode* ast) { diff --git a/test/uscxml/promela/test-event-source-auto.scxml b/test/uscxml/promela/test-event-source-auto.scxml index ef0e26c..cb33636 100644 --- a/test/uscxml/promela/test-event-source-auto.scxml +++ b/test/uscxml/promela/test-event-source-auto.scxml @@ -1,22 +1,45 @@ - + An auto event source will raise all events that enable transitions. If a + transition depends on a data field, these will have to be specified explicitly. + + promela-event-all-but + [ "error.bar" ] + --> + + + + + + + + - - + + + + + - \ No newline at end of file + -- cgit v0.12