From 045bde78c0587316e0373c7698413412d0f315f9 Mon Sep 17 00:00:00 2001 From: Stefan Radomski Date: Tue, 1 Aug 2017 23:47:10 +0200 Subject: Reenabled V8, Debugger tests and smaller fixes --- CMakeLists.txt | 12 +- README.md | 8 +- TODO.txt | 1 + config.h.in | 2 + contrib/cmake/FindV8.cmake | 29 +- src/uscxml/Common.h | 5 +- src/uscxml/debug/DebugSession.cpp | 34 +- src/uscxml/debug/DebugSession.h | 1 + src/uscxml/debug/DebuggerServlet.cpp | 10 +- src/uscxml/debug/DebuggerServlet.h | 2 +- src/uscxml/debug/InterpreterIssue.cpp | 4 +- src/uscxml/interpreter/BasicContentExecutor.cpp | 22 +- src/uscxml/interpreter/BasicContentExecutor.h | 2 +- src/uscxml/interpreter/ContentExecutor.cpp | 4 +- src/uscxml/interpreter/ContentExecutor.h | 2 +- src/uscxml/interpreter/ContentExecutorImpl.h | 2 +- src/uscxml/interpreter/InterpreterImpl.cpp | 19 +- src/uscxml/plugins/DataModel.h | 6 +- src/uscxml/plugins/DataModelImpl.h | 6 +- src/uscxml/plugins/Factory.cpp | 18 +- src/uscxml/plugins/datamodel/CMakeLists.txt | 7 +- .../ecmascript/JavaScriptCore/JSCDataModel.cpp | 14 - .../datamodel/ecmascript/v8/031405/V8DataModel.cpp | 863 ++++++++++++ .../datamodel/ecmascript/v8/031405/V8DataModel.h | 126 ++ .../datamodel/ecmascript/v8/032317/V8DataModel.cpp | 898 ++++++++++++ .../datamodel/ecmascript/v8/032317/V8DataModel.h | 127 ++ .../datamodel/ecmascript/v8/V8DataModel.cpp | 906 ------------ .../plugins/datamodel/ecmascript/v8/V8DataModel.h | 126 -- .../plugins/datamodel/promela/PromelaDataModel.cpp | 29 +- .../plugins/datamodel/promela/PromelaDataModel.h | 1 + .../plugins/datamodel/promela/parser/promela.l | 5 +- .../datamodel/promela/parser/promela.lex.yy.cpp | 1271 +++++++++-------- .../datamodel/promela/parser/promela.tab.cpp | 1475 +++++++++----------- .../datamodel/promela/parser/promela.tab.hpp | 209 ++- .../plugins/datamodel/promela/parser/promela.ypp | 10 +- test/CMakeLists.txt | 3 +- test/ctest/CTestCustom.ctest.in | 12 +- test/src/test-gen-c.cpp | 14 +- test/src/test-http-debugger.pl | 299 +++- test/src/test-http-debugger.scxml | 16 + test/src/test-lifecycle.cpp | 1 + test/src/test-performance.cpp | 1 + test/src/test-promela-parser.cpp | 12 +- test/src/test-stress.cpp | 9 +- test/src/test-validating.cpp | 7 +- test/w3c/confPromela.xsl | 2 +- test/w3c/promela/test310.scxml | 2 +- test/w3c/promela/test411.scxml | 2 +- test/w3c/promela/test413.scxml | 4 +- 49 files changed, 3915 insertions(+), 2725 deletions(-) create mode 100644 src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.cpp create mode 100644 src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.h create mode 100644 src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.cpp create mode 100644 src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.h delete mode 100644 src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp delete mode 100644 src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h create mode 100644 test/src/test-http-debugger.scxml diff --git a/CMakeLists.txt b/CMakeLists.txt index dda1e57..9725848 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -410,13 +410,13 @@ OPTION(WITH_DM_ECMA_V8 "Do search for the V8 ECMAScript implementation" ON) if (WITH_DM_ECMA_V8) find_package(V8) if (V8_FOUND) - # set(ECMA_FOUND ON) - # include_directories(${V8_INCLUDE_DIR}) - # list (APPEND USCXML_OPT_LIBS ${V8_LIBRARY}) + set(ECMA_FOUND ON) + include_directories(${V8_INCLUDE_DIR}) + list (APPEND USCXML_OPT_LIBS ${V8_LIBRARY}) - message(WARNING "We no longer support the V8 ECMAScript engine - contributions are welcome") - set(V8_FOUND OFF) - set(WITH_DM_ECMA_V8 OFF) + # message(WARNING "We no longer support the V8 ECMAScript engine - contributions are welcome") + # set(V8_FOUND OFF) + # set(WITH_DM_ECMA_V8 OFF) else() set(WITH_DM_ECMA_V8 OFF) endif() diff --git a/README.md b/README.md index 9a1e352..7e3c2a4 100644 --- a/README.md +++ b/README.md @@ -84,11 +84,15 @@ For more detailled information, refer to the [documentation](http://tklab-tud.gi ## Changes - * **[9db80409b3ca048c4b404a43d2c224f374c0090a](https://github.com/tklab-tud/uscxml/pull/163/commits/9db80409b3ca048c4b404a43d2c224f374c0090a):** + * **08/01/2017:** + + We selectively re-enabled support for Google's V8 ECMAScript engine, but only in version 3.23.17 and 3.14.05 and API compatible versions. These two versions are noteworthy as the first one used to be distributed via MacPorts and the second one is still found in many Linux distributions (e.g. Debian and Ubuntu). It is bordering on impossible to build them from source today as they are rather old. If you need an ECMAScript datamodel and do not have binary images of these, just go for `libjavascriptcoregtk-4.0-dev`. Make sure it's version **4.0** as the previous version had a bug with `JSCheckScriptSyntax`. + + * **07/19/2017:** We **dropped support for Google's V8 ECMAScript engine**. The API is changing too fast and there is no reliable way to get / build / identify older versions. The latest branch will not work with the wrappers generated from even SWIG 4.0 and I have no time to keep up with them. Use JavaScriptCore, its API is unchanged since we started to support it in 2012. If you feel capable to maintain the [](V8DataModel.cpp) send a push request. Everything will be left in place but we will ignore `libv8` at configure time. I may have another look when a number of Linux distribution settled on a more recent version, most are still shipping v8 in version 3.14. - * **[bfefa5fd44b9ed1491612f26b099db8ad624247b](https://github.com/tklab-tud/uscxml/pull/155/commits/bfefa5fd44b9ed1491612f26b099db8ad624247b):** + * **07/05/2017:** We **broke the InterpreterMonitor** API by substituting the Interpreter instance in the first formal parameter by its sessionId throughout all callbacks. Retrieving the actual Interpreter involved locking a weak_ptr into a shared_ptr which proved to be a performance bottleneck. You can retrieve the Interpreter from its sessionId via the new static method `Interpreter::fromSessionId` if you actually need. diff --git a/TODO.txt b/TODO.txt index 901189d..37c3dd6 100644 --- a/TODO.txt +++ b/TODO.txt @@ -1 +1,2 @@ Arraybuffers +Run tests on build slaves \ No newline at end of file diff --git a/config.h.in b/config.h.in index 3955b87..9658e3c 100644 --- a/config.h.in +++ b/config.h.in @@ -44,6 +44,8 @@ #cmakedefine USCXML_VERSION_PATCH "@USCXML_VERSION_PATCH@" #cmakedefine USCXML_VERSION "@USCXML_VERSION@" +#cmakedefine V8_VERSION @V8_VERSION@ + // #cmakedefine XERCESC_NS @XERCESC_NS@ /** build type */ diff --git a/contrib/cmake/FindV8.cmake b/contrib/cmake/FindV8.cmake index 575836e..f992098 100644 --- a/contrib/cmake/FindV8.cmake +++ b/contrib/cmake/FindV8.cmake @@ -57,13 +57,30 @@ if (V8_LIBRARY AND V8_INCLUDE_DIR) set(CMAKE_REQUIRED_LIBRARIES ${V8_LIBRARY}) check_cxx_source_compiles(" #include - int main(){ v8::Local foo = v8::Array::New(v8::Isolate::GetCurrent()); } - " V8_VER_GREATER_032317) + int main(){ + v8::Locker locker; + v8::HandleScope scope; + v8::Local global = v8::ObjectTemplate::New(); + v8::Persistent context = v8::Context::New(0, global); + v8::Context::Scope contextScope(context); + }" V8_VER_COMPILES_AS_031405) - if (NOT V8_VER_GREATER_032317) - message(STATUS "Your V8 installation is too old - we need >= 3.23.17") - unset(V8_LIBRARY) - unset(V8_INCLUDE_DIR) + if (NOT V8_VER_COMPILES_AS_031405) + check_cxx_source_compiles(" + #include + int main(){ + v8::Local foo = v8::Array::New(v8::Isolate::GetCurrent()); + }" V8_VER_COMPILES_AS_032317) + + if (NOT V8_VER_COMPILES_AS_032317) + message(STATUS "Your V8 installation is unsupported - we support 3.14.5 and 3.23.17") + unset(V8_LIBRARY) + unset(V8_INCLUDE_DIR) + else() + set(V8_VERSION "032317") + endif() + else() + set(V8_VERSION "031405") endif() endif() diff --git a/src/uscxml/Common.h b/src/uscxml/Common.h index abe4921..7d254be 100644 --- a/src/uscxml/Common.h +++ b/src/uscxml/Common.h @@ -26,7 +26,9 @@ #define ELPP_STACKTRACE_ON_CRASH 1 #endif -#if __cplusplus >= 201402L +#if defined(SWIGIMPORTED) || defined(SWIG) +#define DEPRECATED +#elif __cplusplus >= 201402L #define DEPRECATED [[deprecated]] #elif defined(__GNUC__) #define DEPRECATED __attribute__((deprecated)) @@ -37,6 +39,7 @@ #define DEPRECATED(alternative) #endif + #if defined(_WIN32) && !defined(USCXML_STATIC) # ifdef USCXML_EXPORT # define USCXML_API __declspec(dllexport) diff --git a/src/uscxml/debug/DebugSession.cpp b/src/uscxml/debug/DebugSession.cpp index 42973fc..b5c1605 100644 --- a/src/uscxml/debug/DebugSession.cpp +++ b/src/uscxml/debug/DebugSession.cpp @@ -20,6 +20,7 @@ #include "uscxml/debug/DebugSession.h" #include "uscxml/debug/Debugger.h" #include "uscxml/util/Predicates.h" +#include "uscxml/util/DOM.h" #include "uscxml/interpreter/Logging.h" @@ -440,7 +441,7 @@ Data DebugSession::debugEval(const Data& data) { replyData.compound["reason"] = Data("No datamodel available", Data::VERBATIM); } else { try { - replyData.compound["eval"] = _interpreter.getImpl()->getAsData(expr); + replyData.compound["eval"] = _interpreter.getImpl()->evalAsData(expr); } catch (Event e) { replyData.compound["eval"] = e.data; replyData.compound["eval"].compound["error"] = Data(e.name, Data::VERBATIM); @@ -450,6 +451,37 @@ Data DebugSession::debugEval(const Data& data) { return replyData; } +Data DebugSession::debugEvent(const Data& data) { + Data replyData; + + if (!_interpreter) { + replyData.compound["status"] = Data("failure", Data::VERBATIM); + replyData.compound["reason"] = Data("No interpreter running", Data::VERBATIM); + } else if (!data.hasKey("name")) { + replyData.compound["status"] = Data("failure", Data::VERBATIM); + replyData.compound["reason"] = Data("No event name given", Data::VERBATIM); + return replyData; + } + try { + Event event(data.at("name").atom); + if (data.hasKey("data")) { + event.data = data.at("data"); + } + // TODO: this should not be necessary - initialize lazily + if (_interpreter.getState() == USCXML_INSTANTIATED) { + _interpreter.step(); + } + _interpreter.receive(event); + + } catch (Event e) { + replyData.compound["eval"] = e.data; + replyData.compound["eval"].compound["error"] = Data(e.name, Data::VERBATIM); + } + replyData.compound["status"] = Data("success", Data::VERBATIM); + + return replyData; +} + std::shared_ptr DebugSession::create() { return shared_from_this(); } diff --git a/src/uscxml/debug/DebugSession.h b/src/uscxml/debug/DebugSession.h index e258568..ab4d79d 100644 --- a/src/uscxml/debug/DebugSession.h +++ b/src/uscxml/debug/DebugSession.h @@ -68,6 +68,7 @@ public: Data disableAllBreakPoints(); Data getIssues(); Data debugEval(const Data& data); + Data debugEvent(const Data& data); void setDebugger(Debugger* debugger) { _debugger = debugger; diff --git a/src/uscxml/debug/DebuggerServlet.cpp b/src/uscxml/debug/DebuggerServlet.cpp index 74853f4..8a7e087 100644 --- a/src/uscxml/debug/DebuggerServlet.cpp +++ b/src/uscxml/debug/DebuggerServlet.cpp @@ -106,8 +106,8 @@ bool DebuggerServlet::requestFromHTTP(const HTTPServer::Request& request) { } else if (boost::istarts_with(request.data.at("path").atom, "/debug/connect")) { processConnect(request); return true; - } else if (boost::starts_with(request.data.at("path").atom, "/debug/sessions")) { - processListSessions(request); + } else if (boost::starts_with(request.data.at("path").atom, "/debug/instances")) { + processListInstances(request); return true; } @@ -168,6 +168,8 @@ bool DebuggerServlet::requestFromHTTP(const HTTPServer::Request& request) { replyData = session->debugResume(request.data["content"]); } else if (boost::starts_with(request.data.at("path").atom, "/debug/eval")) { replyData = session->debugEval(request.data["content"]); + } else if (boost::starts_with(request.data.at("path").atom, "/debug/event")) { + replyData = session->debugEvent(request.data["content"]); } if (!replyData.empty()) { @@ -220,7 +222,7 @@ void DebuggerServlet::processDisconnect(const HTTPServer::Request& request) { returnData(request, replyData); } -void DebuggerServlet::processListSessions(const HTTPServer::Request& request) { +void DebuggerServlet::processListInstances(const HTTPServer::Request& request) { Data replyData; std::map > instances = InterpreterImpl::getInstances(); @@ -234,7 +236,7 @@ void DebuggerServlet::processListSessions(const HTTPServer::Request& request) { sessionData.compound["source"] = Data(instance->getBaseURL(), Data::VERBATIM); sessionData.compound["xml"].node = instance->getDocument(); - replyData.compound["sessions"].array.push_back(sessionData); + replyData.compound["instances"].array.push_back(sessionData); } } diff --git a/src/uscxml/debug/DebuggerServlet.h b/src/uscxml/debug/DebuggerServlet.h index 4cd04bb..674d842 100644 --- a/src/uscxml/debug/DebuggerServlet.h +++ b/src/uscxml/debug/DebuggerServlet.h @@ -48,7 +48,7 @@ public: void processDisconnect(const HTTPServer::Request& request); void processConnect(const HTTPServer::Request& request); - void processListSessions(const HTTPServer::Request& request); + void processListInstances(const HTTPServer::Request& request); void processIssues(const HTTPServer::Request& request); diff --git a/src/uscxml/debug/InterpreterIssue.cpp b/src/uscxml/debug/InterpreterIssue.cpp index 346c0f6..f3620be 100644 --- a/src/uscxml/debug/InterpreterIssue.cpp +++ b/src/uscxml/debug/InterpreterIssue.cpp @@ -767,7 +767,9 @@ NEXT_SET: for (auto iter = scripts.begin(); iter != scripts.end(); iter++) { DOMElement* script = *iter; - if (HAS_ATTR(script, kXMLCharSource) && script->getChildNodes()->getLength() > 0) { + if (HAS_ATTR(script, kXMLCharSource) && + script->getChildNodes()->getLength() > 0 && + script->getUserData(X("downladed")) == NULL) { issues.push_back(InterpreterIssue("Script element cannot have src attribute and children", script, InterpreterIssue::USCXML_ISSUE_WARNING)); } } diff --git a/src/uscxml/interpreter/BasicContentExecutor.cpp b/src/uscxml/interpreter/BasicContentExecutor.cpp index 87c2180..7b62fd4 100644 --- a/src/uscxml/interpreter/BasicContentExecutor.cpp +++ b/src/uscxml/interpreter/BasicContentExecutor.cpp @@ -251,7 +251,7 @@ void BasicContentExecutor::processAssign(XERCESC_NS::DOMElement* content) { additionalAttr[X(attr->getNodeName()).str()] = X(attr->getNodeValue()).str(); } - _callbacks->assign(location, elementAsData(content, true), additionalAttr); + _callbacks->assign(location, elementAsData(content), additionalAttr); } void BasicContentExecutor::processForeach(XERCESC_NS::DOMElement* content) { @@ -545,7 +545,12 @@ void BasicContentExecutor::raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC // content std::list contents = DOMUtils::filterChildElements(XML_PREFIX(doneData).str() + "content", doneData); if (contents.size() > 0) { - doneEvent.data = elementAsData(contents.front()); + if (HAS_ATTR(contents.front(), kXMLCharExpr) && + !_callbacks->isLegalDataValue(ATTR(contents.front(), kXMLCharExpr))) { + ERROR_EXECUTION_THROW2("Expression '" + ATTR(contents.front(), kXMLCharExpr) + "' is not a legal data value", contents.front()); + } else { + doneEvent.data = elementAsData(contents.front()); + } } } catch (ErrorEvent e) { ERROR_EXECUTION_RETHROW(e, "Syntax error in donedata element content", doneData); @@ -594,15 +599,14 @@ void BasicContentExecutor::processParams(std::multimap& param } } -Data BasicContentExecutor::elementAsData(XERCESC_NS::DOMElement* element, bool asExpression) { +Data BasicContentExecutor::elementAsData(XERCESC_NS::DOMElement* element) { // element with expr if (HAS_ATTR(element, kXMLCharExpr)) { - std::string expr = ATTR(element, kXMLCharExpr); - if (_callbacks->isLegalDataValue(expr)) { - return Data(expr, Data::INTERPRETED); - } else { - ERROR_EXECUTION_THROW2("Expression '" + expr + "' is not a legal data value", element); - } + // we cannot throw here: + // - with init, we need to check in the datamodel + // - with content, we need to invoke isLegalDataValue later + // test 277, 528 + return Data(ATTR(element, kXMLCharExpr), Data::INTERPRETED); } // element with external src - this ought to behave just as with child nodes below diff --git a/src/uscxml/interpreter/BasicContentExecutor.h b/src/uscxml/interpreter/BasicContentExecutor.h index 469c28e..de756dc 100644 --- a/src/uscxml/interpreter/BasicContentExecutor.h +++ b/src/uscxml/interpreter/BasicContentExecutor.h @@ -53,7 +53,7 @@ public: virtual void uninvoke(XERCESC_NS::DOMElement* invoke); virtual void raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC_NS::DOMElement* doneData); - virtual Data elementAsData(XERCESC_NS::DOMElement* element, bool asExpression = false); + virtual Data elementAsData(XERCESC_NS::DOMElement* element); protected: void processNameLists(std::map& nameMap, XERCESC_NS::DOMElement* element); diff --git a/src/uscxml/interpreter/ContentExecutor.cpp b/src/uscxml/interpreter/ContentExecutor.cpp index 4aa6eb4..3e20e50 100644 --- a/src/uscxml/interpreter/ContentExecutor.cpp +++ b/src/uscxml/interpreter/ContentExecutor.cpp @@ -35,8 +35,8 @@ void ContentExecutor::uninvoke(XERCESC_NS::DOMElement* invoke) { _impl->uninvoke(invoke); } -Data ContentExecutor::elementAsData(XERCESC_NS::DOMElement* element, bool asExpression) { - return _impl->elementAsData(element, asExpression); +Data ContentExecutor::elementAsData(XERCESC_NS::DOMElement* element) { + return _impl->elementAsData(element); } void ContentExecutor::raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC_NS::DOMElement* doneData) { diff --git a/src/uscxml/interpreter/ContentExecutor.h b/src/uscxml/interpreter/ContentExecutor.h index 78fdf94..64d1da6 100644 --- a/src/uscxml/interpreter/ContentExecutor.h +++ b/src/uscxml/interpreter/ContentExecutor.h @@ -46,7 +46,7 @@ public: virtual void process(XERCESC_NS::DOMElement* block); virtual void invoke(XERCESC_NS::DOMElement* invoke); virtual void uninvoke(XERCESC_NS::DOMElement* invoke); - virtual Data elementAsData(XERCESC_NS::DOMElement* element, bool asExpression = false); + virtual Data elementAsData(XERCESC_NS::DOMElement* element); virtual void raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC_NS::DOMElement* doneData); virtual std::shared_ptr getImpl() const; diff --git a/src/uscxml/interpreter/ContentExecutorImpl.h b/src/uscxml/interpreter/ContentExecutorImpl.h index 8221591..42ef738 100644 --- a/src/uscxml/interpreter/ContentExecutorImpl.h +++ b/src/uscxml/interpreter/ContentExecutorImpl.h @@ -100,7 +100,7 @@ public: virtual void uninvoke(XERCESC_NS::DOMElement* invoke) = 0; virtual void raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC_NS::DOMElement* doneData) = 0; - virtual Data elementAsData(XERCESC_NS::DOMElement* element, bool asExpression = false) = 0; + virtual Data elementAsData(XERCESC_NS::DOMElement* element) = 0; protected: ContentExecutorCallbacks* _callbacks; diff --git a/src/uscxml/interpreter/InterpreterImpl.cpp b/src/uscxml/interpreter/InterpreterImpl.cpp index 185ad75..5d6ced1 100644 --- a/src/uscxml/interpreter/InterpreterImpl.cpp +++ b/src/uscxml/interpreter/InterpreterImpl.cpp @@ -142,7 +142,7 @@ void InterpreterImpl::reset() { if (_microStepper) _microStepper.reset(); -// _isInitialized = false; + _isInitialized = false; _state = USCXML_INSTANTIATED; // _dataModel.reset(); if (_delayQueue) @@ -320,7 +320,12 @@ SCXML_STOP_SEARCH: XERCESC_NS::DOMText* scriptText = _document->createTextNode(X(contents)); XERCESC_NS::DOMNode* newNode = _document->importNode(scriptText, true); script->appendChild(newNode); - script->removeAttribute(kXMLCharSource); // remove attribute for validation: see issue 141 + /** + * We nees to download all scripts (issue134) but also fail validation when there + * are child nodes with the src attribute present (issue141). Make a note that we + * already downloaded the content. + */ + script->setUserData(X("downloaded"), newNode, NULL); } } @@ -378,7 +383,6 @@ void InterpreterImpl::init() { // do not override if already set if (_ioProcs.find(ioProcIter->first) != _ioProcs.end()) { - ioProcIter++; continue; } @@ -438,15 +442,12 @@ void InterpreterImpl::initData(XERCESC_NS::DOMElement* root) { } else if (_invokeReq.namelist.find(id) != _invokeReq.namelist.end()) { _dataModel.init(id, _invokeReq.namelist[id], additionalAttr); } else { - try { - _dataModel.init(id, _execContent.elementAsData(root), additionalAttr); - } catch (ErrorEvent e) { - // test 453 - _dataModel.init(id, _execContent.elementAsData(root, true), additionalAttr); - } + _dataModel.init(id, _execContent.elementAsData(root), additionalAttr); } } catch(ErrorEvent e) { // test 277 + e.data.compound["xpath"] = uscxml::Data(DOMUtils::xPathForNode(root), uscxml::Data::VERBATIM); + \ enqueueInternal(e); } } diff --git a/src/uscxml/plugins/DataModel.h b/src/uscxml/plugins/DataModel.h index b5ab31c..f8f19c4 100644 --- a/src/uscxml/plugins/DataModel.h +++ b/src/uscxml/plugins/DataModel.h @@ -79,13 +79,13 @@ public: const std::map& attr = std::map()); /// @copydoc DataModelImpl::isDeclared() - virtual bool isDeclared(const std::string& expr); + DEPRECATED virtual bool isDeclared(const std::string& expr); /// @copydoc DataModelImpl::replaceExpressions() - size_t replaceExpressions(std::string& content); + DEPRECATED size_t replaceExpressions(std::string& content); /// @copydoc DataModelImpl::addExtension() - virtual void addExtension(DataModelExtension* ext); + DEPRECATED virtual void addExtension(DataModelExtension* ext); protected: std::shared_ptr _impl; diff --git a/src/uscxml/plugins/DataModelImpl.h b/src/uscxml/plugins/DataModelImpl.h index afb41bc..1df965d 100644 --- a/src/uscxml/plugins/DataModelImpl.h +++ b/src/uscxml/plugins/DataModelImpl.h @@ -149,7 +149,7 @@ public: * @param content The string with tokens to replace. * @return How many occurences where replaced. */ - size_t replaceExpressions(std::string& content); + DEPRECATED size_t replaceExpressions(std::string& content); /** * Evaluate the given expression as something iterable and return its length. @@ -206,7 +206,7 @@ public: * @param expr The variable / location to check. * @todo Is this still used? */ - virtual bool isDeclared(const std::string& expr) = 0; + DEPRECATED virtual bool isDeclared(const std::string& expr) = 0; /** * Assign a data object to a location in the data-model. @@ -248,7 +248,7 @@ public: * Register an extension to get data into and out of the data-model. * @todo This is currently unsupported */ - virtual void addExtension(DataModelExtension* ext); + DEPRECATED virtual void addExtension(DataModelExtension* ext); protected: DataModelCallbacks* _callbacks; diff --git a/src/uscxml/plugins/Factory.cpp b/src/uscxml/plugins/Factory.cpp index 9e885e5..8269e48 100644 --- a/src/uscxml/plugins/Factory.cpp +++ b/src/uscxml/plugins/Factory.cpp @@ -38,6 +38,8 @@ #include "uscxml/interpreter/FastMicroStep.h" #endif +#undef WITH_DM_ECMA_V8 + #if 0 #include #include @@ -72,10 +74,14 @@ #include "uscxml/plugins/datamodel/null/NullDataModel.h" #if defined WITH_DM_ECMA_V8 -# include "uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h" -#endif - -#ifdef WITH_DM_ECMA_JSC +# if (V8_VERSION == 032317) +# include "uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.h" +# endif +# if (V8_VERSION == 031405) +# include "uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.h" +# endif + +#elif defined(WITH_DM_ECMA_JSC) # include "uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.h" #endif @@ -219,15 +225,15 @@ void Factory::registerPlugins() { V8DataModel* dataModel = new V8DataModel(); registerDataModel(dataModel); } -#endif -#ifdef WITH_DM_ECMA_JSC +#elif defined(WITH_DM_ECMA_JSC) { JSCDataModel* dataModel = new JSCDataModel(); registerDataModel(dataModel); } #endif + #ifdef WITH_DM_LUA { LuaDataModel* dataModel = new LuaDataModel(); diff --git a/src/uscxml/plugins/datamodel/CMakeLists.txt b/src/uscxml/plugins/datamodel/CMakeLists.txt index 05feb11..2d1a928 100644 --- a/src/uscxml/plugins/datamodel/CMakeLists.txt +++ b/src/uscxml/plugins/datamodel/CMakeLists.txt @@ -49,8 +49,8 @@ if (V8_FOUND) set(USCXML_DATAMODELS "ecmascript(V8) ${USCXML_DATAMODELS}") # JavaScriptCore ecmascript datamodel file(GLOB V8_DATAMODEL - ecmascript/v8/*.cpp - ecmascript/v8/*.h + ecmascript/v8/${V8_VERSION}/*.cpp + ecmascript/v8/${V8_VERSION}/*.h ecmascript/*.cpp ecmascript/*.h ) @@ -132,9 +132,6 @@ if (WITH_DM_PROMELA) uscxml ) # SET_SOURCE_FILES_PROPERTIES is directory scope - if (${CMAKE_CXX_COMPILER_ID} STREQUAL Clang) - SET_SOURCE_FILES_PROPERTIES(promela/parser/promela.lex.yy.cpp PROPERTIES COMPILE_FLAGS -Wno-deprecated-register ) - endif() set_target_properties(datamodel_promela PROPERTIES FOLDER "Plugins//DataModel") set_target_properties(datamodel_promela PROPERTIES COMPILE_FLAGS "-DPLUMA_EXPORTS") set_target_properties(datamodel_promela PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/plugins") diff --git a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp index 69ed632..6f48631 100644 --- a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp +++ b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp @@ -709,20 +709,6 @@ JSValueRef JSCDataModel::getNodeAsValue(const DOMNode* node) { SWIG_as_voidptrptr(&node)), 0); -// switch (node->getNodeType()) { -// case DOMNode::ELEMENT_NODE: -// return SWIG_JSC_NewPointerObj(_ctx, (void*)node, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0); -// break; -// -// case DOMNode::COMMENT_NODE: -// return SWIG_JSC_NewPointerObj(_ctx, (void*)node, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, 0); -// break; -// -// // TODO: We need to dispatch more types here! -// default: -// return SWIG_JSC_NewPointerObj(_ctx, (void*)node, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0); -// break; -// } } #endif diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.cpp new file mode 100644 index 0000000..5c76b8b --- /dev/null +++ b/src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.cpp @@ -0,0 +1,863 @@ +/** + * @file + * @author 2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see . + * @endcond + */ + +/* + * Later v8 changed API considerably, have a look at the node.js(!) documentatio for an overview: + * http://strongloop.com/strongblog/node-js-v0-12-c-apis-breaking/ + */ + +#include "uscxml/Common.h" +#include "uscxml/util/URL.h" +#include "uscxml/util/String.h" + +#include "V8DataModel.h" + +#include "uscxml/messages/Event.h" +#ifndef NO_XERCESC +#include "uscxml/util/DOM.h" +#endif +#include "uscxml/interpreter/Logging.h" + +#include + +#ifdef BUILD_AS_PLUGINS +#include +#endif + +using namespace XERCESC_NS; + +#define SWIG_V8_VERSION 0x031400 + +#ifndef NO_XERCESC +static v8::Local XMLString2JS(const XMLCh* input) { + char* res = XERCESC_NS::XMLString::transcode(input); + v8::Local handle = v8::String::New(res); + return handle; +} + +static XMLCh* JS2XMLString(const v8::Local& value) { + v8::String::AsciiValue s(value); + XMLCh* ret = XERCESC_NS::XMLString::transcode(*s); + return(ret); +} + +// this is the version we support here + +#include "../V8DOM.cpp.inc" +#else +#include "../V8Event.cpp.inc" +#endif + +namespace uscxml { + +#ifdef BUILD_AS_PLUGINS +PLUMA_CONNECTOR +bool pluginConnect(pluma::Host& host) { + host.add( new V8DataModelProvider() ); + return true; +} +#endif + +V8DataModel::V8DataModel() { +// _contexts.push_back(v8::Context::New()); +} + +V8DataModel::~V8DataModel() { + _context.Dispose(); +// if (_isolate != NULL) { +// _isolate->Dispose(); +// } +} + +void V8DataModel::addExtension(DataModelExtension* ext) { +#if 0 + if (_extensions.find(ext) != _extensions.end()) + return; + + ext->dm = this; + _extensions.insert(ext); + + v8::Locker locker; + v8::HandleScope scope; + v8::Context::Scope contextScope(_contexts.front()); + v8::Local currScope = _contexts.front()->Global(); + + std::list locPath = tokenize(ext->provides(), '.'); + std::list::iterator locIter = locPath.begin(); + while(true) { + std::string pathComp = *locIter; + v8::Local pathCompJS = v8::String::New(locIter->c_str()); + + if (++locIter != locPath.end()) { + // just another intermediate step + if (!currScope->Has(pathCompJS)) { + currScope->Set(pathCompJS, v8::Object::New()); + } + + v8::Local newScope = currScope->Get(pathCompJS); + if (newScope->IsObject()) { + currScope = newScope->ToObject(); + } else { + throw "Cannot add datamodel extension in non-object"; + } + } else { + // this is the function! + currScope->Set(pathCompJS, v8::FunctionTemplate::New(jsExtension, v8::External::New(reinterpret_cast(ext)))->GetFunction(), v8::ReadOnly); + break; + } + } +#endif +} + +v8::Handle V8DataModel::jsExtension(const v8::Arguments& args) { +#if 0 + DataModelExtension* extension = static_cast(v8::External::Unwrap(args.Data())); + + v8::Local memberJS; + std::string memberName; + + if (args.Length() > 0 && args[0]->IsString()) { + memberJS = args[0]->ToString(); + memberName = *v8::String::AsciiValue(memberJS); + } + + if (args.Length() > 1) { + // setter + Data data = ((V8DataModel*)(extension->dm))->getValueAsData(args[1]); + extension->setValueOf(memberName, data); + return v8::Undefined(); + } + + if (args.Length() == 1) { + // getter + return ((V8DataModel*)(extension->dm))->getDataAsValue(extension->getValueOf(memberName)); + } +#endif + return v8::Undefined(); +} + +std::mutex V8DataModel::_initMutex; + +//v8::Isolate* V8DataModel::_isolate = NULL; + +#ifndef NO_XERCESC +v8::Handle V8NodeListIndexedPropertyHandler(uint32_t index, const v8::AccessorInfo &info) { + XERCESC_NS::DOMNodeList* list = NULL; + SWIG_V8_GetInstancePtr(info.Holder(), (void**)&list); + + if (list != NULL && list->getLength() >= index) { + XERCESC_NS::DOMNode* node = list->item(index); + + v8::Handle val = SWIG_NewPointerObj(SWIG_as_voidptr(node), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&node)), 0 | 0 ); + return val; + } + return v8::Undefined(); + +} +#endif + +std::shared_ptr V8DataModel::create(DataModelCallbacks* callbacks) { + std::shared_ptr dm(new V8DataModel()); + dm->_callbacks = callbacks; + dm->setup(); + return dm; +} + +void V8DataModel::setup() { + // TODO: we cannot use one isolate per thread as swig's type will be unknown :( + // We could register them by hand and avoid the _export_ globals in swig? + + v8::Locker locker; + v8::HandleScope scope; + + // Create a template for the global object where we set the built-in global functions. + v8::Local global = v8::ObjectTemplate::New(); + + // some free functions + global->Set(v8::String::New("In"), + v8::FunctionTemplate::New(jsIn, v8::External::New(reinterpret_cast(this))), v8::ReadOnly); + global->Set(v8::String::New("print"), + v8::FunctionTemplate::New(jsPrint, v8::External::New(reinterpret_cast(this))), v8::ReadOnly); + + _context = v8::Context::New(0, global); + v8::Context::Scope contextScope(_context); + +#ifndef NO_XERCESC + + // not thread safe! + { + std::lock_guard lock(_initMutex); + SWIGV8_INIT(_context->Global()); + + // register subscript operator with nodelist + v8::Handle _exports_DOMNodeList_class = SWIGV8_CreateClassTemplate("_exports_DOMNodeList"); + + _exports_DOMNodeList_class->InstanceTemplate()->SetIndexedPropertyHandler(V8NodeListIndexedPropertyHandler); + SWIGV8_AddMemberFunction(_exports_DOMNodeList_class, "item", _wrap_DOMNodeList_item); + SWIGV8_AddMemberFunction(_exports_DOMNodeList_class, "getLength", _wrap_DOMNodeList_getLength); + + SWIGV8_SET_CLASS_TEMPL(_exports_DOMNodeList_clientData.class_templ, _exports_DOMNodeList_class); + + } +#endif + + _context->Global()->SetAccessor(v8::String::NewSymbol("_sessionid"), + V8DataModel::getAttribute, + V8DataModel::setWithException, + v8::String::New(_callbacks->getSessionId().c_str())); + _context->Global()->SetAccessor(v8::String::NewSymbol("_name"), + V8DataModel::getAttribute, + V8DataModel::setWithException, + v8::String::New(_callbacks->getName().c_str())); + _context->Global()->SetAccessor(v8::String::NewSymbol("_ioprocessors"), + V8DataModel::getIOProcessors, + V8DataModel::setWithException, + v8::External::New(reinterpret_cast(this))); + _context->Global()->SetAccessor(v8::String::NewSymbol("_invokers"), + V8DataModel::getInvokers, + V8DataModel::setWithException, + v8::External::New(reinterpret_cast(this))); + +// v8::Persistent > persistent(_isolate, context); + +#if 0 + + // instantiate the document function + v8::Local docCtor = V8Document::getTmpl()->GetFunction(); + v8::Local docObj = docCtor->NewInstance(); + + V8Document::V8DocumentPrivate* privData = new V8Document::V8DocumentPrivate(); + privData->nativeObj = new Document(interpreter->getDocument()); + privData->dom = _dom; + docObj->SetInternalField(0, V8DOM::toExternal(privData)); + + context->Global()->Set(v8::String::New("document"), docObj); + + // setup constructors + context->Global()->Set(v8::String::New("ArrayBuffer"), V8ArrayBuffer::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Int8Array"), V8Int8Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint8Array"), V8Uint8Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint8ClampedArray"), V8Uint8ClampedArray::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Int16Array"), V8Int16Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint16Array"), V8Uint16Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Int32Array"), V8Int32Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint32Array"), V8Uint32Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Float32Array"), V8Float32Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Float64Array"), V8Float64Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("DataView"), V8DataView::getConstructor()->GetFunction()); + + + + // instantiate objects - we have to have a context for that! + eval(Element(), "_x = {};"); +#endif + +} + +v8::Handle V8DataModel::getAttribute(v8::Local property, const v8::AccessorInfo& info) { + return info.Data(); +} + +void V8DataModel::setWithException(v8::Local property, v8::Local value, const v8::AccessorInfo& info) { + v8::String::AsciiValue data(property); + std::string msg = "Cannot set " + std::string(*data); + v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(msg.c_str()))); +} + +v8::Handle V8DataModel::getIOProcessors(v8::Local property, const v8::AccessorInfo& info) { + v8::Local field = v8::Local::Cast(info.Data()); + V8DataModel* dataModel = (V8DataModel*)field->Value(); + + if (dataModel->_ioProcessors.IsEmpty()) { + + dataModel->_ioProcessors = v8::Persistent::New(v8::Object::New()); + //v8::Handle ioProcessorObj = v8::Object::New(); + std::map ioProcessors = dataModel->_callbacks->getIOProcessors(); + std::map::const_iterator ioProcIter = ioProcessors.begin(); + while(ioProcIter != ioProcessors.end()) { + // std::cout << ioProcIter->first << std::endl; + dataModel->_ioProcessors->Set(v8::String::New(ioProcIter->first.c_str()), + dataModel->getDataAsValue(ioProcIter->second.getDataModelVariables())); + ioProcIter++; + } + } + return dataModel->_ioProcessors; +} + +v8::Handle V8DataModel::getInvokers(v8::Local property, const v8::AccessorInfo& info) { + v8::Local field = v8::Local::Cast(info.Data()); + V8DataModel* dataModel = (V8DataModel*)field->Value(); + + if (dataModel->_invokers.IsEmpty()) { + dataModel->_invokers = v8::Persistent::New(v8::Object::New()); + //v8::Handle ioProcessorObj = v8::Object::New(); + std::map invokers = dataModel->_callbacks->getInvokers(); + std::map::const_iterator invokerIter = invokers.begin(); + while(invokerIter != invokers.end()) { + // std::cout << ioProcIter->first << std::endl; + dataModel->_invokers->Set(v8::String::New(invokerIter->first.c_str()), + dataModel->getDataAsValue(invokerIter->second.getDataModelVariables())); + invokerIter++; + } + + } + return dataModel->_invokers; +} + +void V8DataModel::setEvent(const Event& event) { + + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + v8::Handle global = _context->Global(); + +#if 0 + // this would work as swig_exports_ will get redefined per isolate + { + std::lock_guard lock(_initMutex); + SWIGV8_INIT(context->Global()); + } +#endif + + Event* evPtr = new Event(event); + +// v8::Handle classTmpl = v8::Local::New(_isolate, V8SCXMLEvent::getTmpl()); +// v8::Local eventObj = classTmpl->InstanceTemplate()->NewInstance(); +// eventObj->SetAlignedPointerInInternalField(0, (void*)evPtr); +// assert(eventObj->GetAlignedPointerFromInternalField(0) == evPtr); + + v8::Handle eventVal = SWIG_V8_NewPointerObj(evPtr, SWIGTYPE_p_uscxml__Event, SWIG_POINTER_OWN); + v8::Handle eventObj = v8::Handle::Cast(eventVal); + + /* + v8::Local properties = eventObj->GetPropertyNames(); + for (int i = 0; i < properties->Length(); i++) { + assert(properties->Get(i)->IsString()); + v8::String::AsciiValue key(v8::Local::Cast(properties->Get(i))); + std::cout << *key << std::endl; + } + */ + + // test333 + if (event.origintype.size() > 0) { + eventObj->Set(v8::String::NewSymbol("origintype"),v8::String::New(event.origintype.c_str())); + } else { + eventObj->Set(v8::String::NewSymbol("origintype"),v8::Undefined()); + } + // test335 + if (event.origin.size() > 0) { + eventObj->Set(v8::String::NewSymbol("origin"),v8::String::New(event.origin.c_str())); + } else { + eventObj->Set(v8::String::NewSymbol("origin"),v8::Undefined()); + } + // test337 + if (!event.hideSendId) { + eventObj->Set(v8::String::NewSymbol("sendid"),v8::String::New(event.sendid.c_str())); + } else { + eventObj->Set(v8::String::NewSymbol("sendid"),v8::Undefined()); + } + // test339 + if (event.invokeid.size() > 0) { + eventObj->Set(v8::String::NewSymbol("invokeid"),v8::String::New(event.invokeid.c_str())); + } else { + eventObj->Set(v8::String::NewSymbol("invokeid"),v8::Undefined()); + } + + // test 331 + switch (event.eventType) { + case Event::EXTERNAL: + eventObj->Set(v8::String::NewSymbol("type"), v8::String::New("external")); + break; + case Event::INTERNAL: + eventObj->Set(v8::String::NewSymbol("type"), v8::String::New("internal")); + break; + case Event::PLATFORM: + eventObj->Set(v8::String::NewSymbol("type"), v8::String::New("platform")); + break; + } + + if (event.data.node) { +#ifndef NO_XERCESC + eventObj->Set(v8::String::NewSymbol("data"), getNodeAsValue(event.data.node)); +#else + ERROR_EXECUTION_THROW("Compiled without DOM support"); +#endif + } else { + // _event.data is KVP + Data data = event.data; + if (!event.params.empty()) { + Event::params_t::const_iterator paramIter = event.params.begin(); + while(paramIter != event.params.end()) { + data.compound[paramIter->first] = paramIter->second; + paramIter++; + } + } + if (!event.namelist.empty()) { + Event::namelist_t::const_iterator nameListIter = event.namelist.begin(); + while(nameListIter != event.namelist.end()) { + data.compound[nameListIter->first] = nameListIter->second; + nameListIter++; + } + } + if (!data.empty()) { +// std::cout << Data::toJSON(data); + eventObj->Set(v8::String::NewSymbol("data"), getDataAsValue(data)); // set data part of _event + } else { + // test 343 / test 488 + eventObj->Set(v8::String::NewSymbol("data"), v8::Undefined()); // set data part of _event + } + } + // we cannot make _event v8::ReadOnly as it will ignore subsequent setEvents + global->Set(v8::String::NewSymbol("_event"), eventObj); + +// _event.Reset(_isolate, eventObj); +// _event = eventObj; +} + +Data V8DataModel::getAsData(const std::string& content) { + Data d = Data::fromJSON(content); + if (!d.empty()) + return d; + + std::string trimmed = boost::trim_copy(content); + if (trimmed.length() > 0) { + if (isNumeric(trimmed.c_str(), 10)) { + d = Data(trimmed, Data::INTERPRETED); + } else if (trimmed.length() >= 2 && + ((trimmed[0] == '"' && trimmed[trimmed.length() - 1] == '"') || + (trimmed[0] == '\'' && trimmed[trimmed.length() - 1] == '\''))) { + d = Data(trimmed.substr(1, trimmed.length() - 2), Data::VERBATIM); + } else { + // test558, test562 + ERROR_EXECUTION(e, "Given content cannot be interpreted as data"); + e.data.compound["literal"] = Data(trimmed, Data::VERBATIM); + throw e; + } + } + return d; +} + +Data V8DataModel::evalAsData(const std::string& content) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + + v8::Handle result = evalAsValue(content); + Data data = getValueAsData(result); + return data; +} + +Data V8DataModel::getValueAsData(const v8::Handle& value) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + + std::set foo = std::set(); + return getValueAsData(value, foo); +} + +Data V8DataModel::getValueAsData(const v8::Handle& value, std::set& alreadySeen) { + + v8::Context::Scope contextScope(_context); + + Data data; + + /// TODO: Breaking cycles does not work yet + if (alreadySeen.find(*value) != alreadySeen.end()) + return data; + alreadySeen.insert(*value); + + if (false) { + } else if (value->IsArray()) { + v8::Handle array = v8::Handle::Cast(value); + for (unsigned int i = 0; i < array->Length(); i++) { + data.array.push_back(getValueAsData(array->Get(i), alreadySeen)); + } + } else if (value->IsBoolean()) { + data.atom = (value->ToBoolean()->Value() ? "true" : "false"); + } else if (value->IsBooleanObject()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsBooleanObject is unimplemented" << std::endl; + } else if (value->IsDate()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsDate is unimplemented" << std::endl; + } else if (value->IsExternal()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsExternal is unimplemented" << std::endl; + } else if (value->IsFalse()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsFalse is unimplemented" << std::endl; + } else if (value->IsFunction()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsFunction is unimplemented" << std::endl; + } else if (value->IsInt32()) { + int32_t prop = value->Int32Value(); + data.atom = toStr(prop); + } else if (value->IsNativeError()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNativeError is unimplemented" << std::endl; + } else if (value->IsNull()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNull is unimplemented" << std::endl; + } else if (value->IsNumber()) { + v8::String::AsciiValue prop(v8::Handle::Cast(v8::Handle::Cast(value))); + data.atom = *prop; + } else if (value->IsNumberObject()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNumberObject is unimplemented" << std::endl; + } else if (value->IsObject()) { + +// if (V8ArrayBuffer::hasInstance(value)) { +// uscxml::V8ArrayBuffer::V8ArrayBufferPrivate* privObj = V8DOM::toClassPtr(value->ToObject()->GetInternalField(0)); +// data.binary = privObj->nativeObj->_blob; +// return data; +// } +#ifndef NO_XERCESC + + v8::Local tmpl = v8::Local::New(_exports_DOMNode_clientData.class_templ); + if (tmpl->HasInstance(value)) { + SWIG_V8_GetInstancePtr(value, (void**)&(data.node)); + return data; + } +#endif + v8::Handle object = v8::Handle::Cast(value); + v8::Local properties = object->GetPropertyNames(); + for (unsigned int i = 0; i < properties->Length(); i++) { + assert(properties->Get(i)->IsString()); + v8::String::AsciiValue key(v8::Local::Cast(properties->Get(i))); + v8::Local property = object->Get(properties->Get(i)); + data.compound[*key] = getValueAsData(property, alreadySeen); + } + } else if (value->IsRegExp()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsRegExp is unimplemented" << std::endl; + } else if(value->IsString()) { + v8::String::AsciiValue property(v8::Handle::Cast(value)); + data.atom = *property; + data.type = Data::VERBATIM; + } else if(value->IsStringObject()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsStringObject is unimplemented" << std::endl; + } else if(value->IsTrue()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsTrue is unimplemented" << std::endl; + } else if(value->IsUint32()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsUint32 is unimplemented" << std::endl; + } else if(value->IsUndefined()) { + data.atom = "undefined"; + } else { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "Value's type is unknown!" << std::endl; + } + return data; +} + +#ifndef NO_XERCESC +v8::Handle V8DataModel::getNodeAsValue(const XERCESC_NS::DOMNode* node) { + return SWIG_NewPointerObj(SWIG_as_voidptr(node), + SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, + SWIG_as_voidptrptr(&node)), + 0); +} +#endif + +v8::Handle V8DataModel::getDataAsValue(const Data& data) { + + if (data.compound.size() > 0) { + v8::Local value = v8::Object::New(); + std::map::const_iterator compoundIter = data.compound.begin(); + while(compoundIter != data.compound.end()) { + value->Set(v8::String::NewSymbol(compoundIter->first.c_str()), getDataAsValue(compoundIter->second)); + compoundIter++; + } + return value; + } + if (data.array.size() > 0) { + v8::Local value = v8::Array::New(data.array.size()); + std::list::const_iterator arrayIter = data.array.begin(); + uint32_t index = 0; + while(arrayIter != data.array.end()) { + value->Set(index++, getDataAsValue(*arrayIter)); + arrayIter++; + } + return value; + } + if (data.atom.length() > 0) { + switch (data.type) { + case Data::VERBATIM: + return v8::String::New(data.atom.c_str()); + break; + case Data::INTERPRETED: + return evalAsValue(data.atom); + break; + } + } + if (data.node) { +#ifndef NO_XERCESC + return getNodeAsValue(data.node); +#else + ERROR_EXECUTION_THROW("Compiled without DOM support"); +#endif + } + +// if (data.binary) { +// uscxml::ArrayBuffer* arrBuffer = new uscxml::ArrayBuffer(data.binary); +// v8::Local retCtor = V8ArrayBuffer::getTmpl()->GetFunction(); +// v8::Persistent retObj = v8::Persistent::New(retCtor->NewInstance()); +// +// struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate(); +// retPrivData->nativeObj = arrBuffer; +// retObj->SetInternalField(0, V8DOM::toExternal(retPrivData)); +// +// retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor); +// return retObj; +// } + // this will never be reached + return v8::Undefined(); +} + +v8::Handle V8DataModel::jsPrint(const v8::Arguments& args) { + if (args.Length() > 0) { + v8::String::AsciiValue printMsg(args[0]->ToString()); + V8DataModel* dataModel = static_cast(v8::External::Unwrap(args.Data())); + dataModel->_callbacks->getLogger().log(USCXML_LOG) << *printMsg; + } + return v8::Undefined(); +} + +v8::Handle V8DataModel::jsIn(const v8::Arguments& args) { + V8DataModel* INSTANCE = static_cast(v8::External::Unwrap(args.Data())); + for (auto i = 0; i < args.Length(); i++) { + if (args[i]->IsString()) { + std::string stateName(*v8::String::AsciiValue(args[i]->ToString())); + if (INSTANCE->_callbacks->isInState(stateName)) { + continue; + } + } + return v8::Boolean::New(false); + } + return v8::Boolean::New(true); +} + +bool V8DataModel::isLegalDataValue(const std::string& expr) { + return isValidSyntax("var __tmp = " + expr); +} + +bool V8DataModel::isValidSyntax(const std::string& expr) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::TryCatch tryCatch; + v8::Context::Scope contextScope(_context); + + v8::Handle source = v8::String::New(expr.c_str()); + v8::Handle script = v8::Script::Compile(source); + + if (script.IsEmpty() || tryCatch.HasCaught()) { + return false; + } + + return true; +} + +uint32_t V8DataModel::getLength(const std::string& expr) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::TryCatch tryCatch; + v8::Context::Scope contextScope(_context); + + v8::Handle result = evalAsValue(expr); + + if (!result.IsEmpty() && result->IsArray()) + return result.As()->Length(); + + ERROR_EXECUTION_THROW("'" + expr + "' does not evaluate to an array.") +} + +void V8DataModel::setForeach(const std::string& item, + const std::string& array, + const std::string& index, + uint32_t iteration) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + + if (!isDeclared(item)) { + assign(item, Data()); + } + + +// v8::Local ctx = v8::Local::New(_isolate, _context); +// v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + // assign array element to item + std::stringstream ss; + ss << item << " = " << array << "[" << iteration << "]"; +// assign(item, Data(ss.str(), Data::INTERPRETED)); + // test152: we need "'continue' = array[index]" to throw + evalAsValue(ss.str()); + if (index.length() > 0) { + // assign iteration element to index + std::stringstream ss; + ss << iteration; + assign(index, Data(ss.str(), Data::INTERPRETED)); + } +} + +bool V8DataModel::isDeclared(const std::string& expr) { + /** + * Undeclared variables can be checked by trying to access them and catching + * a reference error. + */ + + v8::Locker locker(); + v8::HandleScope scope(); + v8::Context::Scope contextScope(_context); // segfaults at newinstance without! + + v8::Local source = v8::String::New(expr.c_str()); + v8::Local script = v8::Script::Compile(source); + + v8::Local result; + if (!script.IsEmpty()) + result = script->Run(); + + if (result.IsEmpty()) + return false; + + return true; +} + +bool V8DataModel::evalAsBool(const std::string& expr) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + + v8::Handle result = evalAsValue(expr); + return(result->ToBoolean()->BooleanValue()); +} + + +void V8DataModel::assign(const std::string& location, const Data& data, const std::map& attr) { + + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + +#ifndef NO_XERCESC + v8::Local global = _context->Global(); +#endif + + if (location.compare("_sessionid") == 0) // test 322 + ERROR_EXECUTION_THROW("Cannot assign to _sessionId"); + if (location.compare("_name") == 0) + ERROR_EXECUTION_THROW("Cannot assign to _name"); + if (location.compare("_ioprocessors") == 0) // test 326 + ERROR_EXECUTION_THROW("Cannot assign to _ioprocessors"); + if (location.compare("_invokers") == 0) + ERROR_EXECUTION_THROW("Cannot assign to _invokers"); + if (location.compare("_event") == 0) + ERROR_EXECUTION_THROW("Cannot assign to _event"); + + if (data.node) { +#ifndef NO_XERCESC + global->Set(v8::String::NewSymbol(location.c_str()), getNodeAsValue(data.node)); +#else + ERROR_EXECUTION_THROW("Compiled without DOM support"); +#endif + } else { + evalAsValue(location + " = " + Data::toJSON(data)); + } +} + +void V8DataModel::init(const std::string& location, const Data& data, const std::map& attr) { + v8::Locker locker; + v8::HandleScope handleScope; + v8::Context::Scope contextScope(_context); + + try { + assign(location, data); + } catch (ErrorEvent e) { + // test 277 + evalAsValue(location + " = undefined", true); + + // we need to get error.execution into the queue + throw e; + } +} + +v8::Handle V8DataModel::evalAsValue(const std::string& expr, bool dontThrow) { + +// v8::Locker locker(_isolate); +// v8::Isolate::Scope isoScope(_isolate); +// +// v8::HandleScope scope(_isolate); +// v8::EscapableHandleScope escape(_isolate); +// v8::Local ctx = v8::Local::New(_isolate, _context); +// v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::TryCatch tryCatch; + + v8::Local source = v8::String::New(expr.c_str()); + v8::Local script = v8::Script::Compile(source); + + v8::Local result; + if (!script.IsEmpty()) + result = script->Run(); + + if (script.IsEmpty() || result.IsEmpty()) { + // throw an exception + if (tryCatch.HasCaught() && !dontThrow) + throwExceptionEvent(tryCatch); + } + + return result; +} + +void V8DataModel::throwExceptionEvent(const v8::TryCatch& tryCatch) { + assert(tryCatch.HasCaught()); + ErrorEvent exceptionEvent; + exceptionEvent.name = "error.execution"; + exceptionEvent.eventType = Event::PLATFORM; + + std::string exceptionString(*v8::String::AsciiValue(tryCatch.Exception())); + exceptionEvent.data.compound["cause"] = Data(exceptionString, Data::VERBATIM);; + + v8::Local message = tryCatch.Message(); + if (!message.IsEmpty()) { + std::string filename(*v8::String::AsciiValue(message->GetScriptResourceName())); + exceptionEvent.data.compound["filename"] = Data(filename, Data::VERBATIM); + + std::string sourceLine(*v8::String::AsciiValue(message->GetSourceLine())); + size_t startpos = sourceLine.find_first_not_of(" \t"); + if(std::string::npos != startpos) // remove leading white space + sourceLine = sourceLine.substr(startpos); + + exceptionEvent.data.compound["sourceline"] = Data(sourceLine, Data::VERBATIM); + + std::stringstream ssLineNumber; + int lineNumber = message->GetLineNumber(); + ssLineNumber << lineNumber; + exceptionEvent.data.compound["linenumber"] = Data(ssLineNumber.str(), Data::INTERPRETED); + + int startColumn = message->GetStartColumn(); + int endColumn = message->GetEndColumn(); + std::stringstream ssUnderline; + for (int i = 0; i < startColumn; i++) + ssUnderline << " "; + for (int i = startColumn; i < endColumn; i++) + ssUnderline << "^"; + exceptionEvent.data.compound["sourcemark"] = Data(ssUnderline.str(), Data::VERBATIM); + + std::string stackTrace(*v8::String::AsciiValue(tryCatch.StackTrace())); + exceptionEvent.data.compound["stacktrace"] = Data(stackTrace, Data::VERBATIM); + + } + +// _interpreter->receiveInternal(exceptionEvent); + throw(exceptionEvent); +} + +} diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.h b/src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.h new file mode 100644 index 0000000..b129082 --- /dev/null +++ b/src/uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.h @@ -0,0 +1,126 @@ +/** + * @file + * @author 2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see . + * @endcond + */ + +#ifndef V8DATAMODEL_H_KN8TWG0V +#define V8DATAMODEL_H_KN8TWG0V + +#include "uscxml/config.h" +#include "uscxml/plugins/DataModelImpl.h" + +#include +#include +#include +#include + +#ifdef BUILD_AS_PLUGINS +#include "uscxml/plugins/Plugins.h" +#endif + +namespace uscxml { +class Event; +class Data; +} + +namespace uscxml { + +/** + * @ingroup datamodel + * ECMAScript data-model via Google's V8. + */ + +class V8DataModel : public DataModelImpl { +public: + V8DataModel(); + virtual ~V8DataModel(); + virtual std::shared_ptr create(DataModelCallbacks* callbacks); + + virtual void addExtension(DataModelExtension* ext); + + virtual std::list getNames() { + std::list names; + names.push_back("ecmascript"); + return names; + } + + virtual bool isValidSyntax(const std::string& expr); + virtual bool isLegalDataValue(const std::string& expr); + + virtual void setEvent(const Event& event); + + // foreach + virtual uint32_t getLength(const std::string& expr); + virtual void setForeach(const std::string& item, + const std::string& array, + const std::string& index, + uint32_t iteration); + + virtual bool evalAsBool(const std::string& expr); + virtual Data evalAsData(const std::string& expr); + virtual Data getAsData(const std::string& content); + + virtual bool isDeclared(const std::string& expr); + + virtual void assign(const std::string& location, + const Data& data, + const std::map& attr = std::map()); + virtual void init(const std::string& location, + const Data& data, + const std::map& attr = std::map()); + +protected: + virtual void setup(); + + static v8::Handle jsExtension(const v8::Arguments& args); + static v8::Handle jsIn(const v8::Arguments& args); + static v8::Handle jsPrint(const v8::Arguments& args); + + //v8::Local _event; // Persistent events leak .. + v8::Persistent _context; + //static v8::Isolate* _isolate; + + v8::Persistent _ioProcessors; + v8::Persistent _invokers; + + static v8::Handle getIOProcessors(v8::Local property, const v8::AccessorInfo& info); + static v8::Handle getInvokers(v8::Local property, const v8::AccessorInfo& info); + static v8::Handle getAttribute(v8::Local property, const v8::AccessorInfo& info); + static void setWithException(v8::Local property, v8::Local value, const v8::AccessorInfo& info); + + v8::Handle evalAsValue(const std::string& expr, bool dontThrow = false); + v8::Handle getDataAsValue(const Data& data); + Data getValueAsData(const v8::Handle& value); + v8::Handle getNodeAsValue(const XERCESC_NS::DOMNode* node); + void throwExceptionEvent(const v8::TryCatch& tryCatch); + + std::set _extensions; + +private: + Data getValueAsData(const v8::Handle& value, std::set& alreadySeen); + + static std::mutex _initMutex; + +}; + +#ifdef BUILD_AS_PLUGINS +PLUMA_INHERIT_PROVIDER(V8DataModel, DataModelImpl); +#endif + +} + +#endif /* end of include guard: V8DATAMODEL_H_KN8TWG0V */ diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.cpp new file mode 100644 index 0000000..c245b67 --- /dev/null +++ b/src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.cpp @@ -0,0 +1,898 @@ +/** + * @file + * @author 2012-2017 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see . + * @endcond + */ + +/* + * This file will compile for v8 version 3.23.17 as it was disributed e.g. by MacPorts for a while. + * + * Later v8 changed API considerably, have a look at the node.js(!) documentation for an overview: + * http://strongloop.com/strongblog/node-js-v0-12-c-apis-breaking/ + */ + +#include "uscxml/Common.h" +#include "uscxml/util/URL.h" +#include "uscxml/util/String.h" + +#include "V8DataModel.h" + +#include "uscxml/messages/Event.h" +#ifndef NO_XERCESC +#include "uscxml/util/DOM.h" +#endif +#include "uscxml/interpreter/Logging.h" + +#include + +#ifdef BUILD_AS_PLUGINS +#include +#endif + +using namespace XERCESC_NS; + +#define SWIG_V8_VERSION 0x032317 + +#ifndef NO_XERCESC +static v8::Local XMLString2JS(const XMLCh* input) { + char* res = XERCESC_NS::XMLString::transcode(input); + v8::Local handle = v8::String::New(res); + free(res); + return handle; +} + +static XMLCh* JS2XMLString(const v8::Local& value) { + v8::String::AsciiValue s(value); + XMLCh* ret = XERCESC_NS::XMLString::transcode(*s); + return(ret); +} + +// this is the version we support here + +#include "../V8DOM.cpp.inc" +#else +#include "../V8Event.cpp.inc" +#endif + +namespace uscxml { + +#ifdef BUILD_AS_PLUGINS +PLUMA_CONNECTOR +bool pluginConnect(pluma::Host& host) { + host.add( new V8DataModelProvider() ); + return true; +} +#endif + +V8DataModel::V8DataModel() { +// _contexts.push_back(v8::Context::New()); +} + +V8DataModel::~V8DataModel() { + _context.Dispose(); +// if (_isolate != NULL) { +// _isolate->Dispose(); +// } +} + +void V8DataModel::addExtension(DataModelExtension* ext) { +#if 0 + if (_extensions.find(ext) != _extensions.end()) + return; + + ext->dm = this; + _extensions.insert(ext); + + v8::Locker locker; + v8::HandleScope scope; + v8::Context::Scope contextScope(_contexts.front()); + v8::Local currScope = _contexts.front()->Global(); + + std::list locPath = tokenize(ext->provides(), '.'); + std::list::iterator locIter = locPath.begin(); + while(true) { + std::string pathComp = *locIter; + v8::Local pathCompJS = v8::String::New(locIter->c_str()); + + if (++locIter != locPath.end()) { + // just another intermediate step + if (!currScope->Has(pathCompJS)) { + currScope->Set(pathCompJS, v8::Object::New()); + } + + v8::Local newScope = currScope->Get(pathCompJS); + if (newScope->IsObject()) { + currScope = newScope->ToObject(); + } else { + throw "Cannot add datamodel extension in non-object"; + } + } else { + // this is the function! + currScope->Set(pathCompJS, v8::FunctionTemplate::New(jsExtension, v8::External::New(reinterpret_cast(ext)))->GetFunction(), v8::ReadOnly); + break; + } + } +#endif +} + +void V8DataModel::jsExtension(const v8::FunctionCallbackInfo& info) { +#if 0 + DataModelExtension* extension = static_cast(v8::External::Unwrap(args.Data())); + + v8::Local memberJS; + std::string memberName; + + if (args.Length() > 0 && args[0]->IsString()) { + memberJS = args[0]->ToString(); + memberName = *v8::String::AsciiValue(memberJS); + } + + if (args.Length() > 1) { + // setter + Data data = ((V8DataModel*)(extension->dm))->getValueAsData(args[1]); + extension->setValueOf(memberName, data); + return v8::Undefined(); + } + + if (args.Length() == 1) { + // getter + return ((V8DataModel*)(extension->dm))->getDataAsValue(extension->getValueOf(memberName)); + } + return v8::Undefined(); +#endif +} + +std::mutex V8DataModel::_initMutex; + +v8::Isolate* V8DataModel::_isolate = NULL; + +#ifndef NO_XERCESC +void V8NodeListIndexedPropertyHandler(uint32_t index, const v8::PropertyCallbackInfo& info) { + XERCESC_NS::DOMNodeList* list; + SWIG_V8_GetInstancePtr(info.Holder(), (void**)&list); + + if (list->getLength() >= index) { + XERCESC_NS::DOMNode* node = list->item(index); + + v8::Handle val = SWIG_NewPointerObj(SWIG_as_voidptr(node), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&node)), 0 | 0 ); + info.GetReturnValue().Set(val); + return; + } + info.GetReturnValue().Set(v8::Undefined()); + +} +#endif + +std::shared_ptr V8DataModel::create(DataModelCallbacks* callbacks) { + std::shared_ptr dm(new V8DataModel()); + dm->_callbacks = callbacks; + dm->setup(); + return dm; +} + +void V8DataModel::setup() { + // TODO: we cannot use one isolate per thread as swig's type will be unknown :( + // We could register them by hand and avoid the _export_ globals in swig? + if (_isolate == NULL) { + _isolate = v8::Isolate::New(); + } + + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + + // Create a handle scope to hold the temporary references. + v8::HandleScope scope(_isolate); + + // Create a template for the global object where we set the built-in global functions. + v8::Local global = v8::ObjectTemplate::New(); + + // some free functions + global->Set(v8::String::NewSymbol("print"), + v8::FunctionTemplate::New(_isolate, jsPrint,v8::External::New(reinterpret_cast(this)))); + global->Set(v8::String::NewSymbol("In"), + v8::FunctionTemplate::New(_isolate, jsIn, v8::External::New(reinterpret_cast(this)))); + + v8::Local context = v8::Context::New(_isolate, NULL, global); + + _context.Reset(_isolate, context); + + // Enter the new context so all the following operations take place within it. + v8::Context::Scope contextScope(context); + assert(_isolate->GetCurrentContext() == context); + +#ifndef NO_XERCESC + + // not thread safe! + { + std::lock_guard lock(_initMutex); + SWIGV8_INIT(context->Global()); + + // register subscript operator with nodelist + v8::Handle _exports_DOMNodeList_class = SWIGV8_CreateClassTemplate("_exports_DOMNodeList"); + + _exports_DOMNodeList_class->InstanceTemplate()->SetIndexedPropertyHandler(V8NodeListIndexedPropertyHandler); + SWIGV8_AddMemberFunction(_exports_DOMNodeList_class, "item", _wrap_DOMNodeList_item); + SWIGV8_AddMemberFunction(_exports_DOMNodeList_class, "getLength", _wrap_DOMNodeList_getLength); + + SWIGV8_SET_CLASS_TEMPL(_exports_DOMNodeList_clientData.class_templ, _exports_DOMNodeList_class); + + } +#endif + + context->Global()->SetAccessor(v8::String::NewSymbol("_sessionid"), + V8DataModel::getAttribute, + V8DataModel::setWithException, + v8::String::New(_callbacks->getSessionId().c_str())); + context->Global()->SetAccessor(v8::String::NewSymbol("_name"), + V8DataModel::getAttribute, + V8DataModel::setWithException, + v8::String::New(_callbacks->getName().c_str())); + context->Global()->SetAccessor(v8::String::NewSymbol("_ioprocessors"), + V8DataModel::getIOProcessors, + V8DataModel::setWithException, + v8::External::New(reinterpret_cast(this))); + context->Global()->SetAccessor(v8::String::NewSymbol("_invokers"), + V8DataModel::getInvokers, + V8DataModel::setWithException, + v8::External::New(reinterpret_cast(this))); + +// v8::Persistent > persistent(_isolate, context); + +#if 0 + + // instantiate the document function + v8::Local docCtor = V8Document::getTmpl()->GetFunction(); + v8::Local docObj = docCtor->NewInstance(); + + V8Document::V8DocumentPrivate* privData = new V8Document::V8DocumentPrivate(); + privData->nativeObj = new Document(interpreter->getDocument()); + privData->dom = _dom; + docObj->SetInternalField(0, V8DOM::toExternal(privData)); + + context->Global()->Set(v8::String::New("document"), docObj); + + // setup constructors + context->Global()->Set(v8::String::New("ArrayBuffer"), V8ArrayBuffer::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Int8Array"), V8Int8Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint8Array"), V8Uint8Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint8ClampedArray"), V8Uint8ClampedArray::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Int16Array"), V8Int16Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint16Array"), V8Uint16Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Int32Array"), V8Int32Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Uint32Array"), V8Uint32Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Float32Array"), V8Float32Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("Float64Array"), V8Float64Array::getConstructor()->GetFunction()); + context->Global()->Set(v8::String::New("DataView"), V8DataView::getConstructor()->GetFunction()); + + + + // instantiate objects - we have to have a context for that! + eval(Element(), "_x = {};"); +#endif + +} + +void V8DataModel::getAttribute(v8::Local property, const v8::PropertyCallbackInfo& info) { + info.GetReturnValue().Set(info.Data()); +} + +void V8DataModel::setWithException(v8::Local property, + v8::Local value, + const v8::PropertyCallbackInfo& info) { + v8::String::AsciiValue data(property); + std::string msg = "Cannot set " + std::string(*data); + v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(msg.c_str()))); +} + +void V8DataModel::getIOProcessors(v8::Local property, const v8::PropertyCallbackInfo& info) { + v8::Local field = v8::Local::Cast(info.Data()); + V8DataModel* dataModel = (V8DataModel*)field->Value(); + + if (dataModel->_ioProcessors.IsEmpty()) { + + v8::Local ioProcs = v8::Local::New(v8::Isolate::GetCurrent(), v8::Object::New()); + //v8::Local ioProcessorObj = v8::Object::New(); + std::map ioProcessors = dataModel->_callbacks->getIOProcessors(); + std::map::const_iterator ioProcIter = ioProcessors.begin(); + while(ioProcIter != ioProcessors.end()) { + // std::cout << ioProcIter->first << std::endl; + ioProcs->Set(v8::String::New(ioProcIter->first.c_str()), + dataModel->getDataAsValue(ioProcIter->second.getDataModelVariables())); + ioProcIter++; + } + dataModel->_ioProcessors.Reset(v8::Isolate::GetCurrent(), ioProcs); + } + info.GetReturnValue().Set(dataModel->_ioProcessors); +} + +void V8DataModel::getInvokers(v8::Local property, const v8::PropertyCallbackInfo& info) { + v8::Local field = v8::Local::Cast(info.Data()); + V8DataModel* dataModel = (V8DataModel*)field->Value(); + + if (dataModel->_invokers.IsEmpty()) { + v8::Local invoks = v8::Local::New(v8::Isolate::GetCurrent(), v8::Object::New()); + //v8::Local ioProcessorObj = v8::Object::New(); + std::map invokers = dataModel->_callbacks->getInvokers(); + std::map::const_iterator invokerIter = invokers.begin(); + while(invokerIter != invokers.end()) { + // std::cout << ioProcIter->first << std::endl; + invoks->Set(v8::String::New(invokerIter->first.c_str()), + dataModel->getDataAsValue(invokerIter->second.getDataModelVariables())); + invokerIter++; + } + dataModel->_invokers.Reset(v8::Isolate::GetCurrent(), invoks); + + } + info.GetReturnValue().Set(dataModel->_invokers); +} + +void V8DataModel::setEvent(const Event& event) { + + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + + v8::HandleScope scope(_isolate); + v8::Local ctx = v8::Local::New(_isolate, _context); + + v8::Local global = ctx->Global(); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + assert(_isolate->GetCurrentContext() == ctx); // only valid in context::scope + + +#if 0 + // this would work as swig_exports_ will get redefined per isolate + { + std::lock_guard lock(_initMutex); + SWIGV8_INIT(context->Global()); + } +#endif + + Event* evPtr = new Event(event); + + v8::Local eventVal = SWIG_V8_NewPointerObj(evPtr, SWIGTYPE_p_uscxml__Event, SWIG_POINTER_OWN); + v8::Local eventObj = v8::Local::Cast(eventVal); + + /* + v8::Local properties = eventObj->GetPropertyNames(); + for (int i = 0; i < properties->Length(); i++) { + assert(properties->Get(i)->IsString()); + v8::String::AsciiValue key(v8::Local::Cast(properties->Get(i))); + std::cout << *key << std::endl; + } + */ + +#define V8_SET_FROMEVENT_OR_UNDEF(test, field) \ +if (test) { \ + eventObj->Set(v8::String::NewSymbol(#field),v8::String::NewFromUtf8(_isolate, event.field.c_str())); \ +} else { \ + eventObj->Set(v8::String::NewSymbol(#field),v8::Undefined(_isolate)); \ +} + + V8_SET_FROMEVENT_OR_UNDEF(event.origintype.size() > 0, origintype); // test333 + V8_SET_FROMEVENT_OR_UNDEF(event.origin.size() > 0, origin); // test335 + V8_SET_FROMEVENT_OR_UNDEF(!event.hideSendId, sendid); // test337 + V8_SET_FROMEVENT_OR_UNDEF(event.invokeid.size() > 0, invokeid); // test339 + + // test 331 + switch (event.eventType) { + case Event::EXTERNAL: + eventObj->Set(v8::String::NewSymbol("type"), v8::String::NewFromUtf8(_isolate, "external")); + break; + case Event::INTERNAL: + eventObj->Set(v8::String::NewSymbol("type"), v8::String::NewFromUtf8(_isolate, "internal")); + break; + case Event::PLATFORM: + eventObj->Set(v8::String::NewSymbol("type"), v8::String::NewFromUtf8(_isolate, "platform")); + break; + } + + if (event.data.node) { +#ifndef NO_XERCESC + eventObj->Set(v8::String::NewSymbol("data"), getNodeAsValue(event.data.node)); +#else + ERROR_EXECUTION_THROW("Compiled without DOM support"); +#endif + } else { + // _event.data is KVP + Data data = event.data; + if (!event.params.empty()) { + Event::params_t::const_iterator paramIter = event.params.begin(); + while(paramIter != event.params.end()) { + data.compound[paramIter->first] = paramIter->second; + paramIter++; + } + } + if (!event.namelist.empty()) { + Event::namelist_t::const_iterator nameListIter = event.namelist.begin(); + while(nameListIter != event.namelist.end()) { + data.compound[nameListIter->first] = nameListIter->second; + nameListIter++; + } + } + if (!data.empty()) { + eventObj->Set(v8::String::NewSymbol("data"), getDataAsValue(data)); // set data part of _event + } else { + // test 343 / test 488 + eventObj->Set(v8::String::NewSymbol("data"), v8::Undefined()); // set data part of _event + } + } + // we cannot make _event v8::ReadOnly as it will ignore subsequent setEvents + global->Set(v8::String::NewSymbol("_event"), eventObj); + +} + +Data V8DataModel::getAsData(const std::string& content) { + Data d = Data::fromJSON(content); + if (!d.empty()) + return d; + + std::string trimmed = boost::trim_copy(content); + if (trimmed.length() > 0) { + if (isNumeric(trimmed.c_str(), 10)) { + d = Data(trimmed, Data::INTERPRETED); + } else if (trimmed.length() >= 2 && + ((trimmed[0] == '"' && trimmed[trimmed.length() - 1] == '"') || + (trimmed[0] == '\'' && trimmed[trimmed.length() - 1] == '\''))) { + d = Data(trimmed.substr(1, trimmed.length() - 2), Data::VERBATIM); + } else { + // test558, test562 + ERROR_EXECUTION(e, "Given content cannot be interpreted as data"); + e.data.compound["literal"] = Data(trimmed, Data::VERBATIM); + throw e; + } + } + return d; +} + +Data V8DataModel::evalAsData(const std::string& content) { + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + + v8::HandleScope scope(_isolate); + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::Local result = evalAsValue(content); + Data data = getValueAsData(result); + return data; +} + +Data V8DataModel::getValueAsData(const v8::Local& value) { + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + v8::HandleScope scope(_isolate); + + std::set foo = std::set(); + return getValueAsData(value, foo); +} + +Data V8DataModel::getValueAsData(const v8::Local& value, std::set& alreadySeen) { + + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + Data data; + + /// TODO: Breaking cycles does not work yet + if (alreadySeen.find(*value) != alreadySeen.end()) + return data; + alreadySeen.insert(*value); + + if (false) { + } else if (value->IsArray()) { + v8::Local array = v8::Local::Cast(value); + for (int i = 0; i < array->Length(); i++) { + data.array.push_back(getValueAsData(array->Get(i), alreadySeen)); + } + } else if (value->IsBoolean()) { + data.atom = (value->ToBoolean()->Value() ? "true" : "false"); + } else if (value->IsBooleanObject()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsBooleanObject is unimplemented" << std::endl; + } else if (value->IsDate()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsDate is unimplemented" << std::endl; + } else if (value->IsExternal()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsExternal is unimplemented" << std::endl; + } else if (value->IsFalse()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsFalse is unimplemented" << std::endl; + } else if (value->IsFunction()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsFunction is unimplemented" << std::endl; + } else if (value->IsInt32()) { + int32_t prop = value->Int32Value(); + data.atom = toStr(prop); + } else if (value->IsNativeError()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNativeError is unimplemented" << std::endl; + } else if (value->IsNull()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNull is unimplemented" << std::endl; + } else if (value->IsNumber()) { + v8::String::AsciiValue prop(v8::Local::Cast(v8::Local::Cast(value))); + data.atom = *prop; + } else if (value->IsNumberObject()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNumberObject is unimplemented" << std::endl; + } else if (value->IsObject()) { + +// if (V8ArrayBuffer::hasInstance(value)) { +// uscxml::V8ArrayBuffer::V8ArrayBufferPrivate* privObj = V8DOM::toClassPtr(value->ToObject()->GetInternalField(0)); +// data.binary = privObj->nativeObj->_blob; +// return data; +// } + +#ifndef NO_XERCESC + + v8::Local tmpl = v8::Local::New(_isolate, _exports_DOMNode_clientData.class_templ); + if (tmpl->HasInstance(value)) { + SWIG_V8_GetInstancePtr(value, (void**)&(data.node)); + return data; + } +#endif + v8::Local object = v8::Local::Cast(value); + v8::Local properties = object->GetPropertyNames(); + for (int i = 0; i < properties->Length(); i++) { + assert(properties->Get(i)->IsString()); + v8::String::AsciiValue key(v8::Local::Cast(properties->Get(i))); + v8::Local property = object->Get(properties->Get(i)); + data.compound[*key] = getValueAsData(property, alreadySeen); + } + } else if (value->IsRegExp()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsRegExp is unimplemented" << std::endl; + } else if(value->IsString()) { + v8::String::AsciiValue property(v8::Local::Cast(value)); + data.atom = *property; + data.type = Data::VERBATIM; + } else if(value->IsStringObject()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsStringObject is unimplemented" << std::endl; + } else if(value->IsTrue()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsTrue is unimplemented" << std::endl; + } else if(value->IsUint32()) { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsUint32 is unimplemented" << std::endl; + } else if(value->IsUndefined()) { + data.atom = "undefined"; + } else { + LOG(_callbacks->getLogger(), USCXML_ERROR) << "Value's type is unknown!" << std::endl; + } + return data; +} + +#ifndef NO_XERCESC +v8::Local V8DataModel::getNodeAsValue(const XERCESC_NS::DOMNode* node) { + return SWIG_NewPointerObj(SWIG_as_voidptr(node), + SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, + SWIG_as_voidptrptr(&node)), + 0); +} +#endif + +v8::Local V8DataModel::getDataAsValue(const Data& data) { + + if (data.compound.size() > 0) { + v8::Local value = v8::Object::New(); + std::map::const_iterator compoundIter = data.compound.begin(); + while(compoundIter != data.compound.end()) { + value->Set(v8::String::NewSymbol(compoundIter->first.c_str()), getDataAsValue(compoundIter->second)); + compoundIter++; + } + return value; + } + if (data.array.size() > 0) { + v8::Local value = v8::Array::New(_isolate, data.array.size()); + std::list::const_iterator arrayIter = data.array.begin(); + uint32_t index = 0; + while(arrayIter != data.array.end()) { + value->Set(index++, getDataAsValue(*arrayIter)); + arrayIter++; + } + return value; + } + if (data.atom.length() > 0) { + switch (data.type) { + case Data::VERBATIM: + return v8::String::New(data.atom.c_str()); + break; + case Data::INTERPRETED: + return evalAsValue(data.atom); + break; + } + } + if (data.node) { +#ifndef NO_XERCESC + return getNodeAsValue(data.node); +#else + ERROR_EXECUTION_THROW("Compiled without DOM support"); +#endif + } + +// if (data.binary) { +// uscxml::ArrayBuffer* arrBuffer = new uscxml::ArrayBuffer(data.binary); +// v8::Local retCtor = V8ArrayBuffer::getTmpl()->GetFunction(); +// v8::Persistent retObj = v8::Persistent::New(retCtor->NewInstance()); +// +// struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate(); +// retPrivData->nativeObj = arrBuffer; +// retObj->SetInternalField(0, V8DOM::toExternal(retPrivData)); +// +// retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor); +// return retObj; +// } + + return v8::Undefined(); +} + +void V8DataModel::jsPrint(const v8::FunctionCallbackInfo& info) { + if (info.Length() > 0) { + v8::String::AsciiValue printMsg(info[0]->ToString()); + v8::Local field = v8::Local::Cast(info.Data()); + V8DataModel* dataModel = (V8DataModel*)field->Value(); + dataModel->_callbacks->getLogger().log(USCXML_LOG) << *printMsg; + } +} + +void V8DataModel::jsIn(const v8::FunctionCallbackInfo& info) { + v8::Local field = v8::Local::Cast(info.Data()); + V8DataModel* dataModel = (V8DataModel*)field->Value(); + + for (unsigned int i = 0; i < info.Length(); i++) { + if (info[i]->IsString()) { + std::string stateName(*v8::String::AsciiValue(info[i]->ToString())); + if (dataModel->_callbacks->isInState(stateName)) { + continue; + } + } + info.GetReturnValue().Set(false); + return; + } + info.GetReturnValue().Set(true); +} + +bool V8DataModel::isLegalDataValue(const std::string& expr) { + return isValidSyntax("var __tmp = " + expr); +} + +bool V8DataModel::isValidSyntax(const std::string& expr) { + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + v8::HandleScope scope(_isolate); + + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::TryCatch tryCatch; + + v8::Local source = v8::String::New(expr.c_str()); + if (tryCatch.HasCaught() || source.IsEmpty()) { + return false; + } + + v8::Local script = v8::Script::Compile(source); + if (tryCatch.HasCaught() || script.IsEmpty()) { + return false; + } + + return true; +} + +uint32_t V8DataModel::getLength(const std::string& expr) { + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + v8::HandleScope scope(_isolate); + + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::Local result = evalAsValue(expr); + if (!result.IsEmpty() && result->IsArray()) + return result.As()->Length(); + + ERROR_EXECUTION_THROW("'" + expr + "' does not evaluate to an array.") +} + +void V8DataModel::setForeach(const std::string& item, + const std::string& array, + const std::string& index, + uint32_t iteration) { + if (!isDeclared(item)) { + assign(item, Data()); + } + + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + v8::HandleScope scope(_isolate); + + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + // assign array element to item + std::stringstream ss; + ss << item << " = " << array << "[" << iteration << "]"; +// assign(item, Data(ss.str(), Data::INTERPRETED)); + // test152: we need "'continue' = array[index]" to throw + evalAsValue(ss.str()); + if (index.length() > 0) { + // assign iteration element to index + std::stringstream ss; + ss << iteration; + assign(index, Data(ss.str(), Data::INTERPRETED)); + } +} + +bool V8DataModel::isDeclared(const std::string& expr) { + /** + * Undeclared variables can be checked by trying to access them and catching + * a reference error. + */ + + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + + v8::HandleScope scope(_isolate); + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::Local source = v8::String::New(expr.c_str()); + v8::Local script = v8::Script::Compile(source); + + v8::Local result; + if (!script.IsEmpty()) + result = script->Run(); + + if (result.IsEmpty()) + return false; + + return true; +} + +bool V8DataModel::evalAsBool(const std::string& expr) { + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + + v8::HandleScope scope(_isolate); + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::Local result = evalAsValue(expr); + return(result->ToBoolean()->BooleanValue()); +} + + +void V8DataModel::assign(const std::string& location, const Data& data, const std::map& attr) { + + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + v8::HandleScope scope(_isolate); + + v8::Local ctx = v8::Local::New(_isolate, _context); +#ifndef NO_XERCESC + v8::Local global = ctx->Global(); +#endif + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + if (location.compare("_sessionid") == 0) // test 322 + ERROR_EXECUTION_THROW("Cannot assign to _sessionId"); + if (location.compare("_name") == 0) + ERROR_EXECUTION_THROW("Cannot assign to _name"); + if (location.compare("_ioprocessors") == 0) // test 326 + ERROR_EXECUTION_THROW("Cannot assign to _ioprocessors"); + if (location.compare("_invokers") == 0) + ERROR_EXECUTION_THROW("Cannot assign to _invokers"); + if (location.compare("_event") == 0) + ERROR_EXECUTION_THROW("Cannot assign to _event"); + + if (data.node) { +#ifndef NO_XERCESC + global->Set(v8::String::NewSymbol(location.c_str()), getNodeAsValue(data.node)); +#else + ERROR_EXECUTION_THROW("Compiled without DOM support"); +#endif + } else { + evalAsValue(location + " = " + Data::toJSON(data)); + } +} + +void V8DataModel::init(const std::string& location, const Data& data, const std::map& attr) { + v8::Locker locker(_isolate); + v8::Isolate::Scope isoScope(_isolate); + v8::HandleScope scope(_isolate); + + v8::Local ctx = v8::Local::New(_isolate, _context); + v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + try { + if (data.empty()) { + // test 277 + evalAsValue(location + " = undefined", true); + } else { + assign(location, data); + } + } catch (ErrorEvent e) { + // test 277 (before PROMELA init changes) + evalAsValue(location + " = undefined", true); + + // we need to get error.execution into the queue + throw e; + } +} + +v8::Local V8DataModel::evalAsValue(const std::string& expr, bool dontThrow) { + +// v8::Locker locker(_isolate); +// v8::Isolate::Scope isoScope(_isolate); +// +// v8::HandleScope scope(_isolate); +// v8::EscapableHandleScope escape(_isolate); +// v8::Local ctx = v8::Local::New(_isolate, _context); +// v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! + + v8::TryCatch tryCatch; + + v8::Local source = v8::String::New(expr.c_str()); + v8::Local script = v8::Script::Compile(source); + + v8::Local result; + if (!script.IsEmpty()) + result = script->Run(); + + if (script.IsEmpty() || result.IsEmpty()) { + // throw an exception + if (tryCatch.HasCaught() && !dontThrow) + throwExceptionEvent(tryCatch); + } + + return result; +} + +void V8DataModel::throwExceptionEvent(const v8::TryCatch& tryCatch) { + assert(tryCatch.HasCaught()); + ErrorEvent exceptionEvent; + exceptionEvent.name = "error.execution"; + exceptionEvent.eventType = Event::PLATFORM; + + std::string exceptionString(*v8::String::AsciiValue(tryCatch.Exception())); + exceptionEvent.data.compound["cause"] = Data(exceptionString, Data::VERBATIM);; + + v8::Local message = tryCatch.Message(); + if (!message.IsEmpty()) { + std::string filename(*v8::String::AsciiValue(message->GetScriptResourceName())); + exceptionEvent.data.compound["filename"] = Data(filename, Data::VERBATIM); + + std::string sourceLine(*v8::String::AsciiValue(message->GetSourceLine())); + size_t startpos = sourceLine.find_first_not_of(" \t"); + if(std::string::npos != startpos) // remove leading white space + sourceLine = sourceLine.substr(startpos); + + exceptionEvent.data.compound["sourceline"] = Data(sourceLine, Data::VERBATIM); + + std::stringstream ssLineNumber; + int lineNumber = message->GetLineNumber(); + ssLineNumber << lineNumber; + exceptionEvent.data.compound["linenumber"] = Data(ssLineNumber.str(), Data::INTERPRETED); + + int startColumn = message->GetStartColumn(); + int endColumn = message->GetEndColumn(); + std::stringstream ssUnderline; + for (int i = 0; i < startColumn; i++) + ssUnderline << " "; + for (int i = startColumn; i < endColumn; i++) + ssUnderline << "^"; + exceptionEvent.data.compound["sourcemark"] = Data(ssUnderline.str(), Data::VERBATIM); + + std::string stackTrace(*v8::String::AsciiValue(tryCatch.StackTrace())); + exceptionEvent.data.compound["stacktrace"] = Data(stackTrace, Data::VERBATIM); + + } + +// _interpreter->receiveInternal(exceptionEvent); + throw(exceptionEvent); +} + +} diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.h b/src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.h new file mode 100644 index 0000000..bee59bf --- /dev/null +++ b/src/uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.h @@ -0,0 +1,127 @@ +/** + * @file + * @author 2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see . + * @endcond + */ + +#ifndef V8DATAMODEL_H_KN8TWG0V +#define V8DATAMODEL_H_KN8TWG0V + +#include "uscxml/config.h" +#include "uscxml/plugins/DataModelImpl.h" + +#include +#include +#include + +#ifdef BUILD_AS_PLUGINS +#include "uscxml/plugins/Plugins.h" +#endif + +namespace uscxml { +class Event; +class Data; +} + +namespace uscxml { + +/** + * @ingroup datamodel + * ECMAScript data-model via Google's V8. + */ + +class V8DataModel : public DataModelImpl { +public: + V8DataModel(); + virtual ~V8DataModel(); + virtual std::shared_ptr create(DataModelCallbacks* callbacks); + + virtual void addExtension(DataModelExtension* ext); + + virtual std::list getNames() { + std::list names; + names.push_back("ecmascript"); + return names; + } + + virtual bool isValidSyntax(const std::string& expr); + virtual bool isLegalDataValue(const std::string& expr); + + virtual void setEvent(const Event& event); + + // foreach + virtual uint32_t getLength(const std::string& expr); + virtual void setForeach(const std::string& item, + const std::string& array, + const std::string& index, + uint32_t iteration); + + virtual bool evalAsBool(const std::string& expr); + virtual Data evalAsData(const std::string& expr); + virtual Data getAsData(const std::string& content); + + virtual bool isDeclared(const std::string& expr); + + virtual void assign(const std::string& location, + const Data& data, + const std::map& attr = std::map()); + virtual void init(const std::string& location, + const Data& data, + const std::map& attr = std::map()); + +protected: + virtual void setup(); + + static void jsExtension(const v8::FunctionCallbackInfo& info); + static void jsIn(const v8::FunctionCallbackInfo& info); + static void jsPrint(const v8::FunctionCallbackInfo& info); + + //v8::Local _event; // Persistent events leak .. + v8::Persistent _context; + static v8::Isolate* _isolate; + + v8::Persistent _ioProcessors; + v8::Persistent _invokers; + + static void getIOProcessors(v8::Local property, const v8::PropertyCallbackInfo& info); + static void getInvokers(v8::Local property, const v8::PropertyCallbackInfo& info); + static void getAttribute(v8::Local property, const v8::PropertyCallbackInfo& info); + static void setWithException(v8::Local property, + v8::Local value, + const v8::PropertyCallbackInfo& info); + + v8::Local evalAsValue(const std::string& expr, bool dontThrow = false); + v8::Local getDataAsValue(const Data& data); + Data getValueAsData(const v8::Local& value); + v8::Local getNodeAsValue(const XERCESC_NS::DOMNode* node); + void throwExceptionEvent(const v8::TryCatch& tryCatch); + + std::set _extensions; + +private: + Data getValueAsData(const v8::Local& value, std::set& alreadySeen); + + static std::mutex _initMutex; + +}; + +#ifdef BUILD_AS_PLUGINS +PLUMA_INHERIT_PROVIDER(V8DataModel, DataModelImpl); +#endif + +} + +#endif /* end of include guard: V8DATAMODEL_H_KN8TWG0V */ diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp deleted file mode 100644 index a7942a1..0000000 --- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp +++ /dev/null @@ -1,906 +0,0 @@ -/** - * @file - * @author 2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) - * @copyright Simplified BSD - * - * @cond - * This program is free software: you can redistribute it and/or modify - * it under the terms of the FreeBSD license as published by the FreeBSD - * project. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the FreeBSD license along with this - * program. If not, see . - * @endcond - */ - -/* - * Later v8 changed API considerably, have a look at the node.js(!) documentatio for an overview: - * http://strongloop.com/strongblog/node-js-v0-12-c-apis-breaking/ - */ - -#include "uscxml/Common.h" -#include "uscxml/util/URL.h" -#include "uscxml/util/String.h" - -#include "V8DataModel.h" - -#include "uscxml/messages/Event.h" -#ifndef NO_XERCESC -#include "uscxml/util/DOM.h" -#endif -#include "uscxml/interpreter/Logging.h" - -#include - -#ifdef BUILD_AS_PLUGINS -#include -#endif - -using namespace XERCESC_NS; - -#define SWIG_V8_VERSION 0x032317 - -#ifndef NO_XERCESC -static v8::Local XMLString2JS(const XMLCh* input) { - char* res = XERCESC_NS::XMLString::transcode(input); - v8::Local handle = v8::String::New(res); - return handle; -} - -static XMLCh* JS2XMLString(const v8::Local& value) { - v8::String::AsciiValue s(value); - XMLCh* ret = XERCESC_NS::XMLString::transcode(*s); - return(ret); -} - -// this is the version we support here - -#include "V8DOM.cpp.inc" -#else -#include "V8Event.cpp.inc" -#endif - -namespace uscxml { - -#ifdef BUILD_AS_PLUGINS -PLUMA_CONNECTOR -bool pluginConnect(pluma::Host& host) { - host.add( new V8DataModelProvider() ); - return true; -} -#endif - -V8DataModel::V8DataModel() { -// _contexts.push_back(v8::Context::New()); -} - -V8DataModel::~V8DataModel() { - _context.Dispose(); -// if (_isolate != NULL) { -// _isolate->Dispose(); -// } -} - -void V8DataModel::addExtension(DataModelExtension* ext) { -#if 0 - if (_extensions.find(ext) != _extensions.end()) - return; - - ext->dm = this; - _extensions.insert(ext); - - v8::Locker locker; - v8::HandleScope scope; - v8::Context::Scope contextScope(_contexts.front()); - v8::Local currScope = _contexts.front()->Global(); - - std::list locPath = tokenize(ext->provides(), '.'); - std::list::iterator locIter = locPath.begin(); - while(true) { - std::string pathComp = *locIter; - v8::Local pathCompJS = v8::String::New(locIter->c_str()); - - if (++locIter != locPath.end()) { - // just another intermediate step - if (!currScope->Has(pathCompJS)) { - currScope->Set(pathCompJS, v8::Object::New()); - } - - v8::Local newScope = currScope->Get(pathCompJS); - if (newScope->IsObject()) { - currScope = newScope->ToObject(); - } else { - throw "Cannot add datamodel extension in non-object"; - } - } else { - // this is the function! - currScope->Set(pathCompJS, v8::FunctionTemplate::New(jsExtension, v8::External::New(reinterpret_cast(ext)))->GetFunction(), v8::ReadOnly); - break; - } - } -#endif -} - -void V8DataModel::jsExtension(const v8::FunctionCallbackInfo& info) { -#if 0 - DataModelExtension* extension = static_cast(v8::External::Unwrap(args.Data())); - - v8::Local memberJS; - std::string memberName; - - if (args.Length() > 0 && args[0]->IsString()) { - memberJS = args[0]->ToString(); - memberName = *v8::String::AsciiValue(memberJS); - } - - if (args.Length() > 1) { - // setter - Data data = ((V8DataModel*)(extension->dm))->getValueAsData(args[1]); - extension->setValueOf(memberName, data); - return v8::Undefined(); - } - - if (args.Length() == 1) { - // getter - return ((V8DataModel*)(extension->dm))->getDataAsValue(extension->getValueOf(memberName)); - } - return v8::Undefined(); -#endif -} - -std::mutex V8DataModel::_initMutex; - -v8::Isolate* V8DataModel::_isolate = NULL; - -#ifndef NO_XERCESC -void V8NodeListIndexedPropertyHandler(uint32_t index, const v8::PropertyCallbackInfo& info) { - XERCESC_NS::DOMNodeList* list; - SWIG_V8_GetInstancePtr(info.Holder(), (void**)&list); - - if (list->getLength() >= index) { - XERCESC_NS::DOMNode* node = list->item(index); - - v8::Handle val = SWIG_NewPointerObj(SWIG_as_voidptr(node), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&node)), 0 | 0 ); - info.GetReturnValue().Set(val); - return; - } - info.GetReturnValue().Set(v8::Undefined()); - -} -#endif - -std::shared_ptr V8DataModel::create(DataModelCallbacks* callbacks) { - std::shared_ptr dm(new V8DataModel()); - dm->_callbacks = callbacks; - dm->setup(); - return dm; -} - -void V8DataModel::setup() { - // TODO: we cannot use one isolate per thread as swig's type will be unknown :( - // We could register them by hand and avoid the _export_ globals in swig? - if (_isolate == NULL) { - _isolate = v8::Isolate::New(); - } - - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - - // Create a handle scope to hold the temporary references. - v8::HandleScope scope(_isolate); - - // Create a template for the global object where we set the built-in global functions. - v8::Local global = v8::ObjectTemplate::New(); - - // some free functions - global->Set(v8::String::NewSymbol("print"), - v8::FunctionTemplate::New(_isolate, jsPrint,v8::External::New(reinterpret_cast(this)))); - global->Set(v8::String::NewSymbol("In"), - v8::FunctionTemplate::New(_isolate, jsIn, v8::External::New(reinterpret_cast(this)))); - - v8::Local context = v8::Context::New(_isolate, NULL, global); - - _context.Reset(_isolate, context); - - // Enter the new context so all the following operations take place within it. - v8::Context::Scope contextScope(context); - assert(_isolate->GetCurrentContext() == context); - -#ifndef NO_XERCESC - - // not thread safe! - { - std::lock_guard lock(_initMutex); - SWIGV8_INIT(context->Global()); - - // register subscript operator with nodelist - v8::Handle _exports_DOMNodeList_class = SWIGV8_CreateClassTemplate("_exports_DOMNodeList"); - - _exports_DOMNodeList_class->InstanceTemplate()->SetIndexedPropertyHandler(V8NodeListIndexedPropertyHandler); - SWIGV8_AddMemberFunction(_exports_DOMNodeList_class, "item", _wrap_DOMNodeList_item); - SWIGV8_AddMemberFunction(_exports_DOMNodeList_class, "getLength", _wrap_DOMNodeList_getLength); - - SWIGV8_SET_CLASS_TEMPL(_exports_DOMNodeList_clientData.class_templ, _exports_DOMNodeList_class); - - } -#endif - - context->Global()->SetAccessor(v8::String::NewSymbol("_sessionid"), - V8DataModel::getAttribute, - V8DataModel::setWithException, - v8::String::New(callbacks->getSessionId().c_str())); - context->Global()->SetAccessor(v8::String::NewSymbol("_name"), - V8DataModel::getAttribute, - V8DataModel::setWithException, - v8::String::New(callbacks->getName().c_str())); - context->Global()->SetAccessor(v8::String::NewSymbol("_ioprocessors"), - V8DataModel::getIOProcessors, - V8DataModel::setWithException, - v8::External::New(reinterpret_cast(this))); - context->Global()->SetAccessor(v8::String::NewSymbol("_invokers"), - V8DataModel::getInvokers, - V8DataModel::setWithException, - v8::External::New(reinterpret_cast(this))); - -// v8::Persistent > persistent(_isolate, context); - -#if 0 - - // instantiate the document function - v8::Local docCtor = V8Document::getTmpl()->GetFunction(); - v8::Local docObj = docCtor->NewInstance(); - - V8Document::V8DocumentPrivate* privData = new V8Document::V8DocumentPrivate(); - privData->nativeObj = new Document(interpreter->getDocument()); - privData->dom = _dom; - docObj->SetInternalField(0, V8DOM::toExternal(privData)); - - context->Global()->Set(v8::String::New("document"), docObj); - - // setup constructors - context->Global()->Set(v8::String::New("ArrayBuffer"), V8ArrayBuffer::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Int8Array"), V8Int8Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Uint8Array"), V8Uint8Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Uint8ClampedArray"), V8Uint8ClampedArray::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Int16Array"), V8Int16Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Uint16Array"), V8Uint16Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Int32Array"), V8Int32Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Uint32Array"), V8Uint32Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Float32Array"), V8Float32Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("Float64Array"), V8Float64Array::getConstructor()->GetFunction()); - context->Global()->Set(v8::String::New("DataView"), V8DataView::getConstructor()->GetFunction()); - - - - // instantiate objects - we have to have a context for that! - eval(Element(), "_x = {};"); -#endif - -} - -void V8DataModel::getAttribute(v8::Local property, const v8::PropertyCallbackInfo& info) { - info.GetReturnValue().Set(info.Data()); -} - -void V8DataModel::setWithException(v8::Local property, - v8::Local value, - const v8::PropertyCallbackInfo& info) { - v8::String::AsciiValue data(property); - std::string msg = "Cannot set " + std::string(*data); - v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(msg.c_str()))); -} - -void V8DataModel::getIOProcessors(v8::Local property, const v8::PropertyCallbackInfo& info) { - v8::Local field = v8::Local::Cast(info.Data()); - V8DataModel* dataModel = (V8DataModel*)field->Value(); - - if (dataModel->_ioProcessors.IsEmpty()) { - - v8::Local ioProcs = v8::Local::New(v8::Isolate::GetCurrent(), v8::Object::New()); - //v8::Local ioProcessorObj = v8::Object::New(); - std::map ioProcessors = dataModel->_callbacks->getIOProcessors(); - std::map::const_iterator ioProcIter = ioProcessors.begin(); - while(ioProcIter != ioProcessors.end()) { - // std::cout << ioProcIter->first << std::endl; - ioProcs->Set(v8::String::New(ioProcIter->first.c_str()), - dataModel->getDataAsValue(ioProcIter->second.getDataModelVariables())); - ioProcIter++; - } - dataModel->_ioProcessors.Reset(v8::Isolate::GetCurrent(), ioProcs); - } - info.GetReturnValue().Set(dataModel->_ioProcessors); -} - -void V8DataModel::getInvokers(v8::Local property, const v8::PropertyCallbackInfo& info) { - v8::Local field = v8::Local::Cast(info.Data()); - V8DataModel* dataModel = (V8DataModel*)field->Value(); - - if (dataModel->_invokers.IsEmpty()) { - v8::Local invoks = v8::Local::New(v8::Isolate::GetCurrent(), v8::Object::New()); - //v8::Local ioProcessorObj = v8::Object::New(); - std::map invokers = dataModel->_callbacks->getInvokers(); - std::map::const_iterator invokerIter = invokers.begin(); - while(invokerIter != invokers.end()) { - // std::cout << ioProcIter->first << std::endl; - invoks->Set(v8::String::New(invokerIter->first.c_str()), - dataModel->getDataAsValue(invokerIter->second.getDataModelVariables())); - invokerIter++; - } - dataModel->_invokers.Reset(v8::Isolate::GetCurrent(), invoks); - - } - info.GetReturnValue().Set(dataModel->_invokers); -} - -void V8DataModel::setEvent(const Event& event) { - - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - - v8::HandleScope scope(_isolate); - v8::Local ctx = v8::Local::New(_isolate, _context); - - v8::Local global = ctx->Global(); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - assert(_isolate->GetCurrentContext() == ctx); // only valid in context::scope - - -#if 0 - // this would work as swig_exports_ will get redefined per isolate - { - std::lock_guard lock(_initMutex); - SWIGV8_INIT(context->Global()); - } -#endif - - Event* evPtr = new Event(event); - -// v8::Handle classTmpl = v8::Local::New(_isolate, V8SCXMLEvent::getTmpl()); -// v8::Local eventObj = classTmpl->InstanceTemplate()->NewInstance(); -// eventObj->SetAlignedPointerInInternalField(0, (void*)evPtr); -// assert(eventObj->GetAlignedPointerFromInternalField(0) == evPtr); - - v8::Local eventVal = SWIG_V8_NewPointerObj(evPtr, SWIGTYPE_p_uscxml__Event, SWIG_POINTER_OWN); - v8::Local eventObj = v8::Local::Cast(eventVal); - - /* - v8::Local properties = eventObj->GetPropertyNames(); - for (int i = 0; i < properties->Length(); i++) { - assert(properties->Get(i)->IsString()); - v8::String::AsciiValue key(v8::Local::Cast(properties->Get(i))); - std::cout << *key << std::endl; - } - */ - - // test333 - if (event.origintype.size() > 0) { - eventObj->Set(v8::String::NewSymbol("origintype"),v8::String::NewFromUtf8(_isolate, event.origintype.c_str())); - } else { - eventObj->Set(v8::String::NewSymbol("origintype"),v8::Undefined(_isolate)); - } - // test335 - if (event.origin.size() > 0) { - eventObj->Set(v8::String::NewSymbol("origin"),v8::String::NewFromUtf8(_isolate, event.origin.c_str())); - } else { - eventObj->Set(v8::String::NewSymbol("origin"),v8::Undefined(_isolate)); - } - // test337 - if (!event.hideSendId) { - eventObj->Set(v8::String::NewSymbol("sendid"),v8::String::NewFromUtf8(_isolate, event.sendid.c_str())); - } else { - eventObj->Set(v8::String::NewSymbol("sendid"),v8::Undefined(_isolate)); - } - // test339 - if (event.invokeid.size() > 0) { - eventObj->Set(v8::String::NewSymbol("invokeid"),v8::String::NewFromUtf8(_isolate, event.invokeid.c_str())); - } else { - eventObj->Set(v8::String::NewSymbol("invokeid"),v8::Undefined(_isolate)); - } - - // test 331 - switch (event.eventType) { - case Event::EXTERNAL: - eventObj->Set(v8::String::NewSymbol("type"), v8::String::NewFromUtf8(_isolate, "external")); - break; - case Event::INTERNAL: - eventObj->Set(v8::String::NewSymbol("type"), v8::String::NewFromUtf8(_isolate, "internal")); - break; - case Event::PLATFORM: - eventObj->Set(v8::String::NewSymbol("type"), v8::String::NewFromUtf8(_isolate, "platform")); - break; - } - - if (event.data.node) { -#ifndef NO_XERCESC - eventObj->Set(v8::String::NewSymbol("data"), getNodeAsValue(event.data.node)); -#else - ERROR_EXECUTION_THROW("Compiled without DOM support"); -#endif - } else { - // _event.data is KVP - Data data = event.data; - if (!event.params.empty()) { - Event::params_t::const_iterator paramIter = event.params.begin(); - while(paramIter != event.params.end()) { - data.compound[paramIter->first] = paramIter->second; - paramIter++; - } - } - if (!event.namelist.empty()) { - Event::namelist_t::const_iterator nameListIter = event.namelist.begin(); - while(nameListIter != event.namelist.end()) { - data.compound[nameListIter->first] = nameListIter->second; - nameListIter++; - } - } - if (!data.empty()) { -// std::cout << Data::toJSON(data); - eventObj->Set(v8::String::NewSymbol("data"), getDataAsValue(data)); // set data part of _event - } else { - // test 343 / test 488 - eventObj->Set(v8::String::NewSymbol("data"), v8::Undefined()); // set data part of _event - } - } - // we cannot make _event v8::ReadOnly as it will ignore subsequent setEvents - global->Set(v8::String::NewSymbol("_event"), eventObj); - -// _event.Reset(_isolate, eventObj); -// _event = eventObj; -} - -Data V8DataModel::getAsData(const std::string& content) { - Data d = Data::fromJSON(content); - if (!d.empty()) - return d; - - std::string trimmed = boost::trim_copy(content); - if (trimmed.length() > 0) { - if (isNumeric(trimmed.c_str(), 10)) { - d = Data(trimmed, Data::INTERPRETED); - } else if (trimmed.length() >= 2 && - ((trimmed[0] == '"' && trimmed[trimmed.length() - 1] == '"') || - (trimmed[0] == '\'' && trimmed[trimmed.length() - 1] == '\''))) { - d = Data(trimmed.substr(1, trimmed.length() - 2), Data::VERBATIM); - } else { - // test558, test562 - ERROR_EXECUTION(e, "Given content cannot be interpreted as data"); - e.data.compound["literal"] = Data(trimmed, Data::VERBATIM); - throw e; - } - } - return d; -} - -Data V8DataModel::evalAsData(const std::string& content) { - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - - v8::HandleScope scope(_isolate); - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - v8::Local result = evalAsValue(content); - Data data = getValueAsData(result); - return data; -} - -Data V8DataModel::getValueAsData(const v8::Local& value) { - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - v8::HandleScope scope(_isolate); - - std::set foo = std::set(); - return getValueAsData(value, foo); -} - -Data V8DataModel::getValueAsData(const v8::Local& value, std::set& alreadySeen) { - - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - Data data; - - /// TODO: Breaking cycles does not work yet - if (alreadySeen.find(*value) != alreadySeen.end()) - return data; - alreadySeen.insert(*value); - - if (false) { - } else if (value->IsArray()) { - v8::Local array = v8::Local::Cast(value); - for (int i = 0; i < array->Length(); i++) { - data.array.push_back(getValueAsData(array->Get(i), alreadySeen)); - } - } else if (value->IsBoolean()) { - data.atom = (value->ToBoolean()->Value() ? "true" : "false"); - } else if (value->IsBooleanObject()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsBooleanObject is unimplemented" << std::endl; - } else if (value->IsDate()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsDate is unimplemented" << std::endl; - } else if (value->IsExternal()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsExternal is unimplemented" << std::endl; - } else if (value->IsFalse()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsFalse is unimplemented" << std::endl; - } else if (value->IsFunction()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsFunction is unimplemented" << std::endl; - } else if (value->IsInt32()) { - int32_t prop = value->Int32Value(); - data.atom = toStr(prop); - } else if (value->IsNativeError()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNativeError is unimplemented" << std::endl; - } else if (value->IsNull()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNull is unimplemented" << std::endl; - } else if (value->IsNumber()) { - v8::String::AsciiValue prop(v8::Local::Cast(v8::Local::Cast(value))); - data.atom = *prop; - } else if (value->IsNumberObject()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsNumberObject is unimplemented" << std::endl; - } else if (value->IsObject()) { - -// if (V8ArrayBuffer::hasInstance(value)) { -// uscxml::V8ArrayBuffer::V8ArrayBufferPrivate* privObj = V8DOM::toClassPtr(value->ToObject()->GetInternalField(0)); -// data.binary = privObj->nativeObj->_blob; -// return data; -// } -#ifndef NO_XERCESC - - v8::Local tmpl = v8::Local::New(_isolate, _exports_DOMNode_clientData.class_templ); - if (tmpl->HasInstance(value)) { - SWIG_V8_GetInstancePtr(value, (void**)&(data.node)); - return data; - } -#endif - v8::Local object = v8::Local::Cast(value); - v8::Local properties = object->GetPropertyNames(); - for (int i = 0; i < properties->Length(); i++) { - assert(properties->Get(i)->IsString()); - v8::String::AsciiValue key(v8::Local::Cast(properties->Get(i))); - v8::Local property = object->Get(properties->Get(i)); - data.compound[*key] = getValueAsData(property, alreadySeen); - } - } else if (value->IsRegExp()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsRegExp is unimplemented" << std::endl; - } else if(value->IsString()) { - v8::String::AsciiValue property(v8::Local::Cast(value)); - data.atom = *property; - data.type = Data::VERBATIM; - } else if(value->IsStringObject()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsStringObject is unimplemented" << std::endl; - } else if(value->IsTrue()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsTrue is unimplemented" << std::endl; - } else if(value->IsUint32()) { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "IsUint32 is unimplemented" << std::endl; - } else if(value->IsUndefined()) { - data.atom = "undefined"; - } else { - LOG(_callbacks->getLogger(), USCXML_ERROR) << "Value's type is unknown!" << std::endl; - } - return data; -} - -#ifndef NO_XERCESC -v8::Local V8DataModel::getNodeAsValue(const XERCESC_NS::DOMNode* node) { - return SWIG_NewPointerObj(SWIG_as_voidptr(node), - SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, - SWIG_as_voidptrptr(&node)), - 0); -} -#endif - -v8::Local V8DataModel::getDataAsValue(const Data& data) { - - if (data.compound.size() > 0) { - v8::Local value = v8::Object::New(); - std::map::const_iterator compoundIter = data.compound.begin(); - while(compoundIter != data.compound.end()) { - value->Set(v8::String::NewSymbol(compoundIter->first.c_str()), getDataAsValue(compoundIter->second)); - compoundIter++; - } - return value; - } - if (data.array.size() > 0) { - v8::Local value = v8::Array::New(_isolate, data.array.size()); - std::list::const_iterator arrayIter = data.array.begin(); - uint32_t index = 0; - while(arrayIter != data.array.end()) { - value->Set(index++, getDataAsValue(*arrayIter)); - arrayIter++; - } - return value; - } - if (data.atom.length() > 0) { - switch (data.type) { - case Data::VERBATIM: - return v8::String::New(data.atom.c_str()); - break; - case Data::INTERPRETED: - return evalAsValue(data.atom); - break; - } - } - if (data.node) { -#ifndef NO_XERCESC - return getNodeAsValue(data.node); -#else - ERROR_EXECUTION_THROW("Compiled without DOM support"); -#endif - } - -// if (data.binary) { -// uscxml::ArrayBuffer* arrBuffer = new uscxml::ArrayBuffer(data.binary); -// v8::Local retCtor = V8ArrayBuffer::getTmpl()->GetFunction(); -// v8::Persistent retObj = v8::Persistent::New(retCtor->NewInstance()); -// -// struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate(); -// retPrivData->nativeObj = arrBuffer; -// retObj->SetInternalField(0, V8DOM::toExternal(retPrivData)); -// -// retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor); -// return retObj; -// } - // this will never be reached - return v8::Undefined(); -} - -void V8DataModel::jsPrint(const v8::FunctionCallbackInfo& info) { - if (info.Length() > 0) { - v8::String::AsciiValue printMsg(info[0]->ToString()); - v8::Local field = v8::Local::Cast(info.Data()); - V8DataModel* dataModel = (V8DataModel*)field->Value(); - dataModel->_callbacks->getLogger().log(USCXML_LOG) << *printMsg; - } -} - -void V8DataModel::jsIn(const v8::FunctionCallbackInfo& info) { - v8::Local field = v8::Local::Cast(info.Data()); - V8DataModel* dataModel = (V8DataModel*)field->Value(); - - for (unsigned int i = 0; i < info.Length(); i++) { - if (info[i]->IsString()) { - std::string stateName(*v8::String::AsciiValue(info[i]->ToString())); - if (dataModel->_callbacks->isInState(stateName)) { - continue; - } - } - info.GetReturnValue().Set(false); - return; - } - info.GetReturnValue().Set(true); -} - -bool V8DataModel::isValidSyntax(const std::string& expr) { - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - v8::HandleScope scope(_isolate); - - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - v8::TryCatch tryCatch; - - v8::Local source = v8::String::New(expr.c_str()); - if (tryCatch.HasCaught() || source.IsEmpty()) { - return false; - } - - v8::Local script = v8::Script::Compile(source); - if (tryCatch.HasCaught() || script.IsEmpty()) { - return false; - } - - return true; -} - -uint32_t V8DataModel::getLength(const std::string& expr) { - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - v8::HandleScope scope(_isolate); - - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - v8::Local result = evalAsValue(expr); - if (!result.IsEmpty() && result->IsArray()) - return result.As()->Length(); - - ERROR_EXECUTION_THROW("'" + expr + "' does not evaluate to an array.") -} - -void V8DataModel::setForeach(const std::string& item, - const std::string& array, - const std::string& index, - uint32_t iteration) { - if (!isDeclared(item)) { - assign(item, Data()); - } - - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - v8::HandleScope scope(_isolate); - - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - // assign array element to item - std::stringstream ss; - ss << item << " = " << array << "[" << iteration << "]"; -// assign(item, Data(ss.str(), Data::INTERPRETED)); - // test152: we need "'continue' = array[index]" to throw - evalAsValue(ss.str()); - if (index.length() > 0) { - // assign iteration element to index - std::stringstream ss; - ss << iteration; - assign(index, Data(ss.str(), Data::INTERPRETED)); - } -} - -bool V8DataModel::isDeclared(const std::string& expr) { - /** - * Undeclared variables can be checked by trying to access them and catching - * a reference error. - */ - - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - - v8::HandleScope scope(_isolate); - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - v8::Local source = v8::String::New(expr.c_str()); - v8::Local script = v8::Script::Compile(source); - - v8::Local result; - if (!script.IsEmpty()) - result = script->Run(); - - if (result.IsEmpty()) - return false; - - return true; -} - -bool V8DataModel::evalAsBool(const std::string& expr) { - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - - v8::HandleScope scope(_isolate); - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - v8::Local result = evalAsValue(expr); - return(result->ToBoolean()->BooleanValue()); -} - - -void V8DataModel::assign(const std::string& location, const Data& data, const std::map& attr) { - - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - v8::HandleScope scope(_isolate); - - v8::Local ctx = v8::Local::New(_isolate, _context); -#ifndef NO_XERCESC - v8::Local global = ctx->Global(); -#endif - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - if (location.compare("_sessionid") == 0) // test 322 - ERROR_EXECUTION_THROW("Cannot assign to _sessionId"); - if (location.compare("_name") == 0) - ERROR_EXECUTION_THROW("Cannot assign to _name"); - if (location.compare("_ioprocessors") == 0) // test 326 - ERROR_EXECUTION_THROW("Cannot assign to _ioprocessors"); - if (location.compare("_invokers") == 0) - ERROR_EXECUTION_THROW("Cannot assign to _invokers"); - if (location.compare("_event") == 0) - ERROR_EXECUTION_THROW("Cannot assign to _event"); - - if (data.node) { -#ifndef NO_XERCESC - global->Set(v8::String::NewSymbol(location.c_str()), getNodeAsValue(data.node)); -#else - ERROR_EXECUTION_THROW("Compiled without DOM support"); -#endif - } else { - evalAsValue(location + " = " + Data::toJSON(data)); - } -} - -void V8DataModel::init(const std::string& location, const Data& data, const std::map& attr) { - v8::Locker locker(_isolate); - v8::Isolate::Scope isoScope(_isolate); - v8::HandleScope scope(_isolate); - - v8::Local ctx = v8::Local::New(_isolate, _context); - v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - try { - assign(location, data); - } catch (ErrorEvent e) { - // test 277 - evalAsValue(location + " = undefined", true); - - // we need to get error.execution into the queue - throw e; - } -} - -v8::Local V8DataModel::evalAsValue(const std::string& expr, bool dontThrow) { - -// v8::Locker locker(_isolate); -// v8::Isolate::Scope isoScope(_isolate); -// -// v8::HandleScope scope(_isolate); -// v8::EscapableHandleScope escape(_isolate); -// v8::Local ctx = v8::Local::New(_isolate, _context); -// v8::Context::Scope contextScope(ctx); // segfaults at newinstance without! - - v8::TryCatch tryCatch; - - v8::Local source = v8::String::New(expr.c_str()); - v8::Local script = v8::Script::Compile(source); - - v8::Local result; - if (!script.IsEmpty()) - result = script->Run(); - - if (script.IsEmpty() || result.IsEmpty()) { - // throw an exception - if (tryCatch.HasCaught() && !dontThrow) - throwExceptionEvent(tryCatch); - } - - return result; -} - -void V8DataModel::throwExceptionEvent(const v8::TryCatch& tryCatch) { - assert(tryCatch.HasCaught()); - ErrorEvent exceptionEvent; - exceptionEvent.name = "error.execution"; - exceptionEvent.eventType = Event::PLATFORM; - - std::string exceptionString(*v8::String::AsciiValue(tryCatch.Exception())); - exceptionEvent.data.compound["cause"] = Data(exceptionString, Data::VERBATIM);; - - v8::Local message = tryCatch.Message(); - if (!message.IsEmpty()) { - std::string filename(*v8::String::AsciiValue(message->GetScriptResourceName())); - exceptionEvent.data.compound["filename"] = Data(filename, Data::VERBATIM); - - std::string sourceLine(*v8::String::AsciiValue(message->GetSourceLine())); - size_t startpos = sourceLine.find_first_not_of(" \t"); - if(std::string::npos != startpos) // remove leading white space - sourceLine = sourceLine.substr(startpos); - - exceptionEvent.data.compound["sourceline"] = Data(sourceLine, Data::VERBATIM); - - std::stringstream ssLineNumber; - int lineNumber = message->GetLineNumber(); - ssLineNumber << lineNumber; - exceptionEvent.data.compound["linenumber"] = Data(ssLineNumber.str(), Data::INTERPRETED); - - int startColumn = message->GetStartColumn(); - int endColumn = message->GetEndColumn(); - std::stringstream ssUnderline; - for (int i = 0; i < startColumn; i++) - ssUnderline << " "; - for (int i = startColumn; i < endColumn; i++) - ssUnderline << "^"; - exceptionEvent.data.compound["sourcemark"] = Data(ssUnderline.str(), Data::VERBATIM); - - std::string stackTrace(*v8::String::AsciiValue(tryCatch.StackTrace())); - exceptionEvent.data.compound["stacktrace"] = Data(stackTrace, Data::VERBATIM); - - } - -// _interpreter->receiveInternal(exceptionEvent); - throw(exceptionEvent); -} - -} diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h deleted file mode 100644 index e286c56..0000000 --- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h +++ /dev/null @@ -1,126 +0,0 @@ -/** - * @file - * @author 2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) - * @copyright Simplified BSD - * - * @cond - * This program is free software: you can redistribute it and/or modify - * it under the terms of the FreeBSD license as published by the FreeBSD - * project. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the FreeBSD license along with this - * program. If not, see . - * @endcond - */ - -#ifndef V8DATAMODEL_H_KN8TWG0V -#define V8DATAMODEL_H_KN8TWG0V - -#include "uscxml/config.h" -#include "uscxml/plugins/DataModelImpl.h" - -#include -#include -#include - -#ifdef BUILD_AS_PLUGINS -#include "uscxml/plugins/Plugins.h" -#endif - -namespace uscxml { -class Event; -class Data; -} - -namespace uscxml { - -/** - * @ingroup datamodel - * ECMAScript data-model via Google's V8. - */ - -class V8DataModel : public DataModelImpl { -public: - V8DataModel(); - virtual ~V8DataModel(); - virtual std::shared_ptr create(DataModelCallbacks* callbacks); - - virtual void addExtension(DataModelExtension* ext); - - virtual std::list getNames() { - std::list names; - names.push_back("ecmascript"); - return names; - } - - virtual bool isValidSyntax(const std::string& expr); - - virtual void setEvent(const Event& event); - - // foreach - virtual uint32_t getLength(const std::string& expr); - virtual void setForeach(const std::string& item, - const std::string& array, - const std::string& index, - uint32_t iteration); - - virtual bool evalAsBool(const std::string& expr); - virtual Data evalAsData(const std::string& expr); - virtual Data getAsData(const std::string& content); - - virtual bool isDeclared(const std::string& expr); - - virtual void assign(const std::string& location, - const Data& data, - const std::map& attr = std::map()); - virtual void init(const std::string& location, - const Data& data, - const std::map& attr = std::map()); - -protected: - virtual void setup(); - - static void jsExtension(const v8::FunctionCallbackInfo& info); - static void jsIn(const v8::FunctionCallbackInfo& info); - static void jsPrint(const v8::FunctionCallbackInfo& info); - - //v8::Local _event; // Persistent events leak .. - v8::Persistent _context; - static v8::Isolate* _isolate; - - v8::Persistent _ioProcessors; - v8::Persistent _invokers; - - static void getIOProcessors(v8::Local property, const v8::PropertyCallbackInfo& info); - static void getInvokers(v8::Local property, const v8::PropertyCallbackInfo& info); - static void getAttribute(v8::Local property, const v8::PropertyCallbackInfo& info); - static void setWithException(v8::Local property, - v8::Local value, - const v8::PropertyCallbackInfo& info); - - v8::Local evalAsValue(const std::string& expr, bool dontThrow = false); - v8::Local getDataAsValue(const Data& data); - Data getValueAsData(const v8::Local& value); - v8::Local getNodeAsValue(const XERCESC_NS::DOMNode* node); - void throwExceptionEvent(const v8::TryCatch& tryCatch); - - std::set _extensions; - -private: - Data getValueAsData(const v8::Local& value, std::set& alreadySeen); - - static std::mutex _initMutex; - -}; - -#ifdef BUILD_AS_PLUGINS -PLUMA_INHERIT_PROVIDER(V8DataModel, DataModelImpl); -#endif - -} - -#endif /* end of include guard: V8DATAMODEL_H_KN8TWG0V */ diff --git a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp index c12491b..d7fe2a5 100644 --- a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp +++ b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.cpp @@ -175,6 +175,13 @@ void PromelaDataModel::setEvent(const Event& event) { return; } + if (data.atom.length() > 0 && data.type == Data::INTERPRETED) { + // test 577 -> interpreted:'foo' + data.atom = evaluateExpr(data.atom); + data.type = Data::VERBATIM; + return; + } + if (data.array.size() > 0) { for (std::list::iterator iter = data.array.begin(); iter != data.array.end(); iter++) { adaptType(*iter); @@ -188,7 +195,10 @@ void PromelaDataModel::setEvent(const Event& event) { } return; } + } + bool PromelaDataModel::isLegalDataValue(const std::string& expr) { + return isValidSyntax("__tmp = " + expr); } bool PromelaDataModel::isValidSyntax(const std::string& expr) { @@ -269,7 +279,8 @@ void PromelaDataModel::setEvent(const Event& event) { Data PromelaDataModel::getAsData(const std::string& content) { try { - return evalAsData(content); + evaluateExpr("__tmp = " + content); + return evalAsData("__tmp"); } catch (ErrorEvent e) { return Data::fromJSON(content); } @@ -408,11 +419,13 @@ void PromelaDataModel::setEvent(const Event& event) { return Data(strTo(node->value)); case PML_NAME: { Data d = getVariable(node); +#if 0 if (d.atom.size() != 0) - // fixes issue 127 + // fixes issue 127, breaks test277 if (isNumeric(d.atom.c_str(), 10)) { return Data(d.atom, Data::VERBATIM); } +#endif return d; // if (d.type == Data::INTERPRETED && d.atom[0] == '\'' && d.atom[d.atom.size() - 1] == '\'') // return Data(d.atom.substr(1, d.atom.size() - 2), Data::VERBATIM); @@ -628,7 +641,9 @@ void PromelaDataModel::setEvent(const Event& event) { switch(node->type) { case PML_NAME: if (_variables.compound.find(node->value) == _variables.compound.end()) { - ERROR_EXECUTION_THROW("No variable " + node->value + " was declared"); + // test 277 + return Data("false", Data::INTERPRETED); +// ERROR_EXECUTION_THROW("No variable " + node->value + " was declared"); } // if (_variables[node->value].compound.find("size") != _variables[node->value].compound.end()) { // ERROR_EXECUTION_THROW("Type error: Variable " + node->value + " is an array"); @@ -637,6 +652,11 @@ void PromelaDataModel::setEvent(const Event& event) { case PML_VAR_ARRAY: { PromelaParserNode* name = *opIter++; PromelaParserNode* expr = *opIter++; + // the in predicate is called config with promela dm + if (name->value == "config") { + return Data(_callbacks->isInState(expr->value) ? "true" : "false", Data::INTERPRETED); + } + int index = dataToInt(evaluateExpr(expr)); if (_variables.compound.find(name->value) == _variables.compound.end()) { @@ -735,7 +755,8 @@ void PromelaDataModel::setEvent(const Event& event) { Data d = Data::fromJSON(data); if (!d.empty()) setVariable(parser.ast, Data::fromJSON(data)); - setVariable(parser.ast, data); + // var1 = _sessionid + setVariable(parser.ast, evalAsData(data.atom)); } else { setVariable(parser.ast, data); } diff --git a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h index 80f6b34..1e980c3 100644 --- a/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h +++ b/src/uscxml/plugins/datamodel/promela/PromelaDataModel.h @@ -44,6 +44,7 @@ public: virtual void addExtension(DataModelExtension* ext); + virtual bool isLegalDataValue(const std::string& expr); virtual bool isValidSyntax(const std::string& expr); virtual void setEvent(const Event& event); diff --git a/src/uscxml/plugins/datamodel/promela/parser/promela.l b/src/uscxml/plugins/datamodel/promela/parser/promela.l index 1edc625..92f8c1f 100644 --- a/src/uscxml/plugins/datamodel/promela/parser/promela.l +++ b/src/uscxml/plugins/datamodel/promela/parser/promela.l @@ -53,6 +53,7 @@ false|skip|true { yylval->value = strdup(yytext); return PML_CONST; } printf { return PML_PRINT; } typedef { return PML_TYPEDEF; } assert { return PML_ASSERT; } +return { return PML_RETURN; } "!" { return PML_NEG; } "~" { return PML_COMPL; } @@ -103,7 +104,7 @@ assert { return PML_ASSERT; } L?\"(\\.|[^\\"])*\" { yylval->value = strdup(yytext); return(PML_STRING); } -L?'(\\.|[^\'])*\' { +L?\'(\\.|[^\'])*\' { /* Non PROMELA extension for single quoted string literals */ yylval->value = strdup(yytext); return(PML_STRING); } @@ -114,4 +115,4 @@ L?'(\\.|[^\'])*\' { [ \t\n]+ /* eat up whitespace */ -. { /*printf( "Unrecognized character: %s\n", yytext ); */ } +. { return PML_UNREC; } diff --git a/src/uscxml/plugins/datamodel/promela/parser/promela.lex.yy.cpp b/src/uscxml/plugins/datamodel/promela/parser/promela.lex.yy.cpp index 1f2fd72..96e44f7 100644 --- a/src/uscxml/plugins/datamodel/promela/parser/promela.lex.yy.cpp +++ b/src/uscxml/plugins/datamodel/promela/parser/promela.lex.yy.cpp @@ -1,6 +1,3 @@ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdeprecated-register" - #line 2 "promela.lex.yy.cpp" #line 4 "promela.lex.yy.cpp" @@ -19,8 +16,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 35 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 1 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -74,7 +71,6 @@ typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; -typedef uint64_t flex_uint64_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; @@ -82,7 +78,6 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; -#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -113,6 +108,8 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#endif /* ! C99 */ + #endif /* ! FLEXINT_H */ /* %endif */ @@ -120,25 +117,13 @@ typedef unsigned int flex_uint32_t; /* %if-c++-only */ /* %endif */ -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ - -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) - -#define YY_USE_CONST - -#endif /* defined (__STDC__) */ -#endif /* ! __cplusplus */ - -#ifdef YY_USE_CONST +/* TODO: this is always defined, so inline it */ #define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) #else -#define yyconst +#define yynoreturn #endif /* %not-for-header */ @@ -204,7 +189,15 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else #define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -242,11 +235,18 @@ typedef size_t yy_size_t; */ #define YY_LESS_LINENO(n) \ do { \ - yy_size_t yyl;\ + int yyl;\ for ( yyl = n; yyl < yyleng; ++yyl )\ if ( yytext[yyl] == '\n' )\ --yylineno;\ }while(0) +#define YY_LINENO_REWIND_TO(dst) \ + do {\ + const char *p;\ + for ( p = yy_cp-1; p >= (dst); --p)\ + if ( *p == '\n' )\ + --yylineno;\ + }while(0) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ @@ -280,12 +280,12 @@ struct yy_buffer_state { /* Size of input buffer in bytes, not including room for EOB * characters. */ - yy_size_t yy_buf_size; + int yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -382,7 +382,7 @@ static void promela__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscann YY_BUFFER_STATE promela__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE promela__scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); -YY_BUFFER_STATE promela__scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); +YY_BUFFER_STATE promela__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); /* %endif */ @@ -416,7 +416,7 @@ void promela_free (void * ,yyscan_t yyscanner ); /* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ -#define promela_wrap(n) 1 +#define promela_wrap(yyscanner) (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP #define FLEX_DEBUG @@ -427,12 +427,14 @@ typedef int yy_state_type; #define yytext_ptr yytext_r +/* %% [1.5] DFA */ + /* %if-c-only Standard (non-C++) definition */ static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); -static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); +static void yynoreturn yy_fatal_error (yyconst char* msg ,yyscan_t yyscanner ); /* %endif */ @@ -442,40 +444,41 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); #define YY_DO_BEFORE_ACTION \ yyg->yytext_ptr = yy_bp; \ /* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ - yyleng = (yy_size_t) (yy_cp - yy_bp); \ + yyleng = (int) (yy_cp - yy_bp); \ yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ /* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ yyg->yy_c_buf_p = yy_cp; /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ -#define YY_NUM_RULES 46 -#define YY_END_OF_BUFFER 47 +#define YY_NUM_RULES 47 +#define YY_END_OF_BUFFER 48 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info { flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[126] = { +static yyconst flex_int16_t yy_accept[132] = { 0, - 0, 0, 47, 45, 44, 44, 8, 45, 14, 25, - 45, 33, 34, 12, 15, 31, 16, 30, 13, 42, - 32, 21, 39, 22, 43, 43, 35, 36, 26, 43, - 43, 43, 43, 43, 43, 43, 43, 43, 43, 37, - 27, 38, 9, 44, 23, 0, 40, 0, 28, 0, - 41, 0, 10, 11, 0, 42, 17, 19, 24, 20, - 18, 43, 0, 0, 43, 43, 43, 43, 43, 43, - 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, - 29, 0, 41, 0, 0, 0, 43, 43, 2, 43, - 43, 43, 3, 43, 43, 43, 43, 43, 43, 43, - - 43, 0, 1, 43, 43, 43, 43, 43, 4, 43, - 43, 43, 1, 43, 43, 43, 43, 43, 7, 5, - 43, 43, 6, 43, 0 + 0, 0, 48, 46, 45, 45, 9, 46, 15, 26, + 46, 34, 35, 13, 16, 32, 17, 31, 14, 43, + 33, 22, 40, 23, 44, 44, 36, 37, 27, 44, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 38, 28, 39, 10, 45, 24, 0, 41, 0, 29, + 0, 42, 0, 11, 12, 0, 43, 18, 20, 25, + 21, 19, 44, 0, 0, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 30, 0, 42, 0, 0, 0, 44, 44, + 2, 44, 44, 44, 3, 44, 44, 44, 44, 44, + + 44, 44, 44, 44, 0, 1, 44, 44, 44, 44, + 44, 44, 4, 44, 44, 44, 1, 44, 44, 44, + 44, 44, 44, 7, 5, 8, 44, 44, 6, 44, + 0 } ; -static yyconst flex_int32_t yy_ec[256] = { +static yyconst YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -507,7 +510,7 @@ static yyconst flex_int32_t yy_ec[256] = { 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[51] = { +static yyconst YY_CHAR yy_meta[51] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, @@ -516,72 +519,74 @@ static yyconst flex_int32_t yy_meta[51] = { 2, 2, 2, 2, 2, 2, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[131] = { +static yyconst flex_uint16_t yy_base[137] = { 0, - 0, 0, 172, 173, 49, 51, 151, 50, 173, 163, - 48, 173, 173, 173, 157, 173, 154, 173, 156, 149, - 173, 38, 145, 39, 0, 56, 173, 173, 173, 20, - 31, 136, 124, 131, 117, 118, 34, 30, 120, 173, - 110, 173, 173, 77, 173, 57, 173, 154, 173, 59, - 173, 66, 173, 173, 145, 138, 173, 173, 173, 173, - 173, 0, 76, 75, 111, 109, 108, 111, 106, 112, - 104, 108, 100, 110, 104, 108, 100, 96, 99, 96, - 173, 77, 78, 84, 127, 77, 106, 96, 0, 98, - 103, 90, 0, 91, 92, 88, 88, 93, 96, 95, - - 90, 78, 173, 82, 92, 91, 77, 76, 0, 80, - 88, 75, 96, 62, 73, 71, 68, 59, 0, 0, - 65, 65, 0, 65, 173, 109, 111, 88, 113, 115 + 0, 0, 177, 178, 49, 51, 156, 50, 178, 168, + 48, 178, 178, 178, 162, 178, 159, 178, 161, 154, + 178, 38, 150, 39, 0, 56, 178, 178, 178, 20, + 31, 141, 129, 136, 122, 123, 133, 34, 30, 124, + 178, 114, 178, 178, 77, 178, 57, 178, 158, 178, + 59, 178, 66, 178, 178, 149, 142, 178, 178, 178, + 178, 178, 0, 76, 75, 115, 113, 112, 115, 110, + 116, 108, 112, 104, 114, 104, 107, 111, 103, 99, + 102, 99, 178, 77, 78, 84, 130, 77, 109, 99, + 0, 101, 106, 93, 0, 94, 95, 88, 90, 90, + + 95, 98, 97, 92, 78, 178, 84, 94, 93, 79, + 80, 77, 0, 81, 89, 85, 97, 63, 74, 66, + 71, 68, 59, 0, 0, 0, 65, 65, 0, 65, + 178, 109, 111, 88, 113, 115 } ; -static yyconst flex_int16_t yy_def[131] = { +static yyconst flex_int16_t yy_def[137] = { 0, - 125, 1, 125, 125, 125, 125, 125, 126, 125, 125, - 127, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 128, 128, 125, 125, 125, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 125, - 125, 125, 125, 125, 125, 126, 125, 126, 125, 127, - 125, 129, 125, 125, 130, 125, 125, 125, 125, 125, - 125, 128, 126, 127, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 125, 127, 127, 129, 130, 130, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - - 128, 130, 125, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 130, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 0, 125, 125, 125, 125, 125 + 131, 1, 131, 131, 131, 131, 131, 132, 131, 131, + 133, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 134, 134, 131, 131, 131, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 131, 131, 131, 131, 131, 131, 132, 131, 132, 131, + 133, 131, 135, 131, 131, 136, 131, 131, 131, 131, + 131, 131, 134, 132, 133, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 131, 133, 133, 135, 136, 136, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + + 134, 134, 134, 134, 136, 131, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 136, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 0, 131, 131, 131, 131, 131 } ; -static yyconst flex_int16_t yy_nxt[224] = { +static yyconst flex_uint16_t yy_nxt[229] = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 4, 28, 29, 30, 31, 25, 25, 32, 25, 25, 33, 25, 34, 35, 25, 25, - 36, 25, 37, 38, 39, 25, 40, 41, 42, 43, - 44, 44, 44, 44, 47, 51, 57, 58, 60, 61, - 63, 47, 65, 64, 66, 67, 51, 75, 50, 76, - 68, 78, 52, 83, 48, 79, 69, 77, 44, 44, - 47, 48, 51, 52, 51, 51, 50, 102, 86, 62, - 84, 83, 103, 113, 89, 124, 123, 122, 121, 52, - - 48, 52, 52, 89, 120, 119, 86, 118, 84, 46, - 46, 50, 50, 82, 82, 85, 85, 117, 116, 89, - 115, 89, 109, 114, 112, 111, 109, 110, 109, 108, - 107, 106, 105, 89, 89, 89, 104, 86, 101, 100, - 99, 98, 97, 96, 95, 94, 93, 89, 92, 91, - 90, 89, 88, 87, 56, 86, 125, 81, 80, 74, - 73, 72, 71, 70, 59, 56, 55, 54, 53, 49, - 45, 125, 3, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125 + 36, 37, 38, 39, 40, 25, 41, 42, 43, 44, + 45, 45, 45, 45, 48, 52, 58, 59, 61, 62, + 64, 48, 66, 65, 67, 68, 52, 77, 51, 78, + 69, 80, 53, 85, 49, 81, 70, 79, 45, 45, + 48, 49, 52, 53, 52, 52, 51, 105, 88, 63, + 86, 85, 106, 117, 91, 130, 129, 128, 127, 53, + + 49, 53, 53, 91, 126, 125, 124, 88, 86, 47, + 47, 51, 51, 84, 84, 87, 87, 123, 122, 121, + 91, 120, 119, 91, 113, 118, 116, 115, 113, 114, + 113, 112, 111, 110, 109, 108, 91, 91, 91, 107, + 88, 104, 103, 102, 101, 100, 99, 98, 97, 96, + 95, 91, 94, 93, 92, 91, 90, 89, 57, 88, + 131, 83, 82, 76, 75, 74, 73, 72, 71, 60, + 57, 56, 55, 54, 50, 46, 131, 3, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131 } ; -static yyconst flex_int16_t yy_chk[224] = { +static yyconst flex_int16_t yy_chk[229] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -589,42 +594,42 @@ static yyconst flex_int16_t yy_chk[224] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 6, 6, 8, 11, 22, 22, 24, 24, - 26, 46, 30, 26, 30, 31, 50, 37, 52, 37, - 31, 38, 11, 52, 8, 38, 31, 37, 44, 44, - 63, 46, 64, 50, 82, 83, 84, 86, 102, 128, - 52, 84, 86, 102, 124, 122, 121, 118, 117, 64, - - 63, 82, 83, 116, 115, 114, 113, 112, 84, 126, - 126, 127, 127, 129, 129, 130, 130, 111, 110, 108, - 107, 106, 105, 104, 101, 100, 99, 98, 97, 96, - 95, 94, 92, 91, 90, 88, 87, 85, 80, 79, - 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, - 68, 67, 66, 65, 56, 55, 48, 41, 39, 36, - 35, 34, 33, 32, 23, 20, 19, 17, 15, 10, - 7, 3, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 125, 125, 125 + 26, 47, 30, 26, 30, 31, 51, 38, 53, 38, + 31, 39, 11, 53, 8, 39, 31, 38, 45, 45, + 64, 47, 65, 51, 84, 85, 86, 88, 105, 134, + 53, 86, 88, 105, 130, 128, 127, 123, 122, 65, + + 64, 84, 85, 121, 120, 119, 118, 117, 86, 132, + 132, 133, 133, 135, 135, 136, 136, 116, 115, 114, + 112, 111, 110, 109, 108, 107, 104, 103, 102, 101, + 100, 99, 98, 97, 96, 94, 93, 92, 90, 89, + 87, 82, 81, 80, 79, 78, 77, 76, 75, 74, + 73, 72, 71, 70, 69, 68, 67, 66, 57, 56, + 49, 42, 40, 37, 36, 35, 34, 33, 32, 23, + 20, 19, 17, 15, 10, 7, 3, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 131, 131, 131, 131, 131 } ; /* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[47] = { +static yyconst flex_int32_t yy_rule_can_match_eol[48] = { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 0, 0, }; -static yyconst flex_int16_t yy_rule_linenum[46] = { +static yyconst flex_int16_t yy_rule_linenum[47] = { 0, - 44, 46, 51, 52, 53, 54, 55, 57, 58, 59, - 60, 62, 63, 64, 66, 67, 69, 70, 72, 73, - 74, 75, 77, 78, 80, 81, 82, 85, 86, 88, - 89, 90, 92, 93, 95, 96, 98, 99, 101, 103, - 106, 111, 112, 114, 117 + 44, 46, 51, 52, 53, 54, 55, 56, 58, 59, + 60, 61, 63, 64, 65, 67, 68, 70, 71, 73, + 74, 75, 76, 78, 79, 81, 82, 83, 86, 87, + 89, 90, 91, 93, 94, 96, 97, 99, 100, 102, + 104, 107, 112, 113, 115, 118 } ; /* The intent behind this definition is that it'll catch @@ -659,7 +664,7 @@ static yyconst flex_int16_t yy_rule_linenum[46] = { yycolumn = yycolumn + yyleng; \ } -#line 661 "promela.lex.yy.cpp" +#line 669 "promela.lex.yy.cpp" #define INITIAL 0 @@ -694,8 +699,8 @@ struct yyguts_t { size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; - yy_size_t yy_n_chars; - yy_size_t yyleng_r; + int yy_n_chars; + int yyleng_r; char *yy_c_buf_p; int yy_init; int yy_start; @@ -756,19 +761,23 @@ void promela_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); FILE *promela_get_in (yyscan_t yyscanner ); -void promela_set_in (FILE * in_str ,yyscan_t yyscanner ); +void promela_set_in (FILE * _in_str ,yyscan_t yyscanner ); FILE *promela_get_out (yyscan_t yyscanner ); -void promela_set_out (FILE * out_str ,yyscan_t yyscanner ); +void promela_set_out (FILE * _out_str ,yyscan_t yyscanner ); -yy_size_t promela_get_leng (yyscan_t yyscanner ); +int promela_get_leng (yyscan_t yyscanner ); char *promela_get_text (yyscan_t yyscanner ); int promela_get_lineno (yyscan_t yyscanner ); -void promela_set_lineno (int line_number ,yyscan_t yyscanner ); +void promela_set_lineno (int _line_number ,yyscan_t yyscanner ); + +int promela_get_column (yyscan_t yyscanner ); + +void promela_set_column (int _column_no ,yyscan_t yyscanner ); /* %if-bison-bridge */ @@ -796,8 +805,11 @@ extern int promela_wrap (yyscan_t yyscanner ); /* %not-for-header */ +#ifndef YY_NO_UNPUT + static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner); +#endif /* %ok-for-header */ /* %endif */ @@ -830,7 +842,12 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else #define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -839,7 +856,7 @@ static int input (yyscan_t yyscanner ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ @@ -854,7 +871,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - yy_size_t n; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -867,7 +884,7 @@ static int input (yyscan_t yyscanner ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -945,7 +962,7 @@ extern int promela_lex \ /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK /*LINTED*/break; #endif /* %% [6.0] YY_RULE_SETUP definition goes here */ @@ -957,17 +974,11 @@ extern int promela_lex \ /** The main scanner function which does all the work. */ YY_DECL { - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - /* %% [7.0] user's declarations go here */ -#line 42 "promela.l" - - -#line 970 "promela.lex.yy.cpp" - yylval = yylval_param; yylloc = yylloc_param; @@ -1005,452 +1016,469 @@ YY_DECL { promela__load_buffer_state(yyscanner ); } - while ( 1 ) { /* loops until end-of-file is reached */ - /* %% [8.0] yymore()-related code goes here */ - yy_cp = yyg->yy_c_buf_p; + { + /* %% [7.0] user's declarations go here */ +#line 42 "promela.l" - /* Support of yytext. */ - *yy_cp = yyg->yy_hold_char; - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; +#line 1029 "promela.lex.yy.cpp" - /* %% [9.0] code to set up and find next match goes here */ - yy_current_state = yyg->yy_start; + while ( /*CONSTCOND*/1 ) { /* loops until end-of-file is reached */ + /* %% [8.0] yymore()-related code goes here */ + yy_cp = yyg->yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yyg->yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + /* %% [9.0] code to set up and find next match goes here */ + yy_current_state = yyg->yy_start; yy_match: - do { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; - if ( yy_accept[yy_current_state] ) { - yyg->yy_last_accepting_state = yy_current_state; - yyg->yy_last_accepting_cpos = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 126 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - ++yy_cp; - } while ( yy_current_state != 125 ); - yy_cp = yyg->yy_last_accepting_cpos; - yy_current_state = yyg->yy_last_accepting_state; + do { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 132 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; + ++yy_cp; + } while ( yy_current_state != 131 ); + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; yy_find_action: - /* %% [10.0] code to find the action number goes here */ - yy_act = yy_accept[yy_current_state]; + /* %% [10.0] code to find the action number goes here */ + yy_act = yy_accept[yy_current_state]; - YY_DO_BEFORE_ACTION; + YY_DO_BEFORE_ACTION; - /* %% [11.0] code for yylineno update goes here */ + /* %% [11.0] code for yylineno update goes here */ - if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) { - yy_size_t yyl; - for ( yyl = 0; yyl < yyleng; ++yyl ) - if ( yytext[yyl] == '\n' ) + if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) { + yy_size_t yyl; + for ( yyl = 0; yyl < yyleng; ++yyl ) + if ( yytext[yyl] == '\n' ) - do { - yylineno++; - yycolumn=0; - } while(0) - ; - } + do { + yylineno++; + yycolumn=0; + } while(0) + ; + } do_action: /* This label is used only to access EOF actions. */ - /* %% [12.0] debug code goes here */ - if ( yy_flex_debug ) { - if ( yy_act == 0 ) - fprintf( stderr, "--scanner backing up\n" ); - else if ( yy_act < 46 ) - fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], yytext ); - else if ( yy_act == 46 ) - fprintf( stderr, "--accepting default rule (\"%s\")\n", - yytext ); - else if ( yy_act == 47 ) - fprintf( stderr, "--(end of buffer or a NUL)\n" ); - else - fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); - } - - switch ( yy_act ) { - /* beginning of action switch */ - /* %% [13.0] actions go here */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = yyg->yy_hold_char; - yy_cp = yyg->yy_last_accepting_cpos; - yy_current_state = yyg->yy_last_accepting_state; - goto yy_find_action; + /* %% [12.0] debug code goes here */ + if ( yy_flex_debug ) { + if ( yy_act == 0 ) + fprintf( stderr, "--scanner backing up\n" ); + else if ( yy_act < 47 ) + fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", + (long)yy_rule_linenum[yy_act], yytext ); + else if ( yy_act == 47 ) + fprintf( stderr, "--accepting default rule (\"%s\")\n", + yytext ); + else if ( yy_act == 48 ) + fprintf( stderr, "--(end of buffer or a NUL)\n" ); + else + fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); + } - case 1: - /* rule 1 can match eol */ - YY_RULE_SETUP + switch ( yy_act ) { + /* beginning of action switch */ + /* %% [13.0] actions go here */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yyg->yy_hold_char; + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; + goto yy_find_action; + + case 1: + /* rule 1 can match eol */ + YY_RULE_SETUP #line 44 "promela.l" - /* multiline comments */ - YY_BREAK - case 2: - YY_RULE_SETUP + /* multiline comments */ + YY_BREAK + case 2: + YY_RULE_SETUP #line 46 "promela.l" - { - yylval->value = strdup(yytext); - return PML_TYPE; - } - YY_BREAK - case 3: - YY_RULE_SETUP + { + yylval->value = strdup(yytext); + return PML_TYPE; + } + YY_BREAK + case 3: + YY_RULE_SETUP #line 51 "promela.l" - { return PML_LEN; } - YY_BREAK - case 4: - YY_RULE_SETUP + { return PML_LEN; } + YY_BREAK + case 4: + YY_RULE_SETUP #line 52 "promela.l" - { yylval->value = strdup(yytext); return PML_CONST; } - YY_BREAK - case 5: - YY_RULE_SETUP + { yylval->value = strdup(yytext); return PML_CONST; } + YY_BREAK + case 5: + YY_RULE_SETUP #line 53 "promela.l" - { return PML_PRINT; } - YY_BREAK - case 6: - YY_RULE_SETUP + { return PML_PRINT; } + YY_BREAK + case 6: + YY_RULE_SETUP #line 54 "promela.l" - { return PML_TYPEDEF; } - YY_BREAK - case 7: - YY_RULE_SETUP + { return PML_TYPEDEF; } + YY_BREAK + case 7: + YY_RULE_SETUP #line 55 "promela.l" - { return PML_ASSERT; } - YY_BREAK - case 8: - YY_RULE_SETUP -#line 57 "promela.l" - { return PML_NEG; } - YY_BREAK - case 9: - YY_RULE_SETUP + { return PML_ASSERT; } + YY_BREAK + case 8: + YY_RULE_SETUP +#line 56 "promela.l" + { return PML_RETURN; } + YY_BREAK + case 9: + YY_RULE_SETUP #line 58 "promela.l" - { return PML_COMPL; } - YY_BREAK - case 10: - YY_RULE_SETUP + { return PML_NEG; } + YY_BREAK + case 10: + YY_RULE_SETUP #line 59 "promela.l" - { return PML_INCR; } - YY_BREAK - case 11: - YY_RULE_SETUP + { return PML_COMPL; } + YY_BREAK + case 11: + YY_RULE_SETUP #line 60 "promela.l" - { return PML_DECR; } - YY_BREAK - case 12: - YY_RULE_SETUP -#line 62 "promela.l" - { return PML_TIMES; } - YY_BREAK - case 13: - YY_RULE_SETUP + { return PML_INCR; } + YY_BREAK + case 12: + YY_RULE_SETUP +#line 61 "promela.l" + { return PML_DECR; } + YY_BREAK + case 13: + YY_RULE_SETUP #line 63 "promela.l" - { return PML_DIVIDE; } - YY_BREAK - case 14: - YY_RULE_SETUP + { return PML_TIMES; } + YY_BREAK + case 14: + YY_RULE_SETUP #line 64 "promela.l" - { return PML_MODULO; } - YY_BREAK - case 15: - YY_RULE_SETUP -#line 66 "promela.l" - { return PML_PLUS; } - YY_BREAK - case 16: - YY_RULE_SETUP + { return PML_DIVIDE; } + YY_BREAK + case 15: + YY_RULE_SETUP +#line 65 "promela.l" + { return PML_MODULO; } + YY_BREAK + case 16: + YY_RULE_SETUP #line 67 "promela.l" - { return PML_MINUS; } - YY_BREAK - case 17: - YY_RULE_SETUP -#line 69 "promela.l" - { return PML_LSHIFT; } - YY_BREAK - case 18: - YY_RULE_SETUP + { return PML_PLUS; } + YY_BREAK + case 17: + YY_RULE_SETUP +#line 68 "promela.l" + { return PML_MINUS; } + YY_BREAK + case 18: + YY_RULE_SETUP #line 70 "promela.l" - { return PML_RSHIFT; } - YY_BREAK - case 19: - YY_RULE_SETUP -#line 72 "promela.l" - { return PML_LE; } - YY_BREAK - case 20: - YY_RULE_SETUP + { return PML_LSHIFT; } + YY_BREAK + case 19: + YY_RULE_SETUP +#line 71 "promela.l" + { return PML_RSHIFT; } + YY_BREAK + case 20: + YY_RULE_SETUP #line 73 "promela.l" - { return PML_GE; } - YY_BREAK - case 21: - YY_RULE_SETUP + { return PML_LE; } + YY_BREAK + case 21: + YY_RULE_SETUP #line 74 "promela.l" - { return PML_LT; } - YY_BREAK - case 22: - YY_RULE_SETUP + { return PML_GE; } + YY_BREAK + case 22: + YY_RULE_SETUP #line 75 "promela.l" - { return PML_GT; } - YY_BREAK - case 23: - YY_RULE_SETUP -#line 77 "promela.l" - { return PML_NE; } - YY_BREAK - case 24: - YY_RULE_SETUP + { return PML_LT; } + YY_BREAK + case 23: + YY_RULE_SETUP +#line 76 "promela.l" + { return PML_GT; } + YY_BREAK + case 24: + YY_RULE_SETUP #line 78 "promela.l" - { return PML_EQ; } - YY_BREAK - case 25: - YY_RULE_SETUP -#line 80 "promela.l" - { return PML_BITAND; } - YY_BREAK - case 26: - YY_RULE_SETUP + { return PML_NE; } + YY_BREAK + case 25: + YY_RULE_SETUP +#line 79 "promela.l" + { return PML_EQ; } + YY_BREAK + case 26: + YY_RULE_SETUP #line 81 "promela.l" - { return PML_BITXOR; } - YY_BREAK - case 27: - YY_RULE_SETUP + { return PML_BITAND; } + YY_BREAK + case 27: + YY_RULE_SETUP #line 82 "promela.l" - { return PML_BITOR; } - YY_BREAK - case 28: - YY_RULE_SETUP -#line 85 "promela.l" - { return PML_AND; } - YY_BREAK - case 29: - YY_RULE_SETUP + { return PML_BITXOR; } + YY_BREAK + case 28: + YY_RULE_SETUP +#line 83 "promela.l" + { return PML_BITOR; } + YY_BREAK + case 29: + YY_RULE_SETUP #line 86 "promela.l" - { return PML_OR; } - YY_BREAK - case 30: - YY_RULE_SETUP -#line 88 "promela.l" - { return PML_DOT; } - YY_BREAK - case 31: - YY_RULE_SETUP + { return PML_AND; } + YY_BREAK + case 30: + YY_RULE_SETUP +#line 87 "promela.l" + { return PML_OR; } + YY_BREAK + case 31: + YY_RULE_SETUP #line 89 "promela.l" - { return PML_COMMA; } - YY_BREAK - case 32: - YY_RULE_SETUP + { return PML_DOT; } + YY_BREAK + case 32: + YY_RULE_SETUP #line 90 "promela.l" - { return PML_SEMI; } - YY_BREAK - case 33: - YY_RULE_SETUP -#line 92 "promela.l" - { return '('; } - YY_BREAK - case 34: - YY_RULE_SETUP + { return PML_COMMA; } + YY_BREAK + case 33: + YY_RULE_SETUP +#line 91 "promela.l" + { return PML_SEMI; } + YY_BREAK + case 34: + YY_RULE_SETUP #line 93 "promela.l" - { return ')'; } - YY_BREAK - case 35: - YY_RULE_SETUP -#line 95 "promela.l" - { return '['; } - YY_BREAK - case 36: - YY_RULE_SETUP + { return '('; } + YY_BREAK + case 35: + YY_RULE_SETUP +#line 94 "promela.l" + { return ')'; } + YY_BREAK + case 36: + YY_RULE_SETUP #line 96 "promela.l" - { return ']'; } - YY_BREAK - case 37: - YY_RULE_SETUP -#line 98 "promela.l" - { return '{'; } - YY_BREAK - case 38: - YY_RULE_SETUP + { return '['; } + YY_BREAK + case 37: + YY_RULE_SETUP +#line 97 "promela.l" + { return ']'; } + YY_BREAK + case 38: + YY_RULE_SETUP #line 99 "promela.l" - { return '}'; } - YY_BREAK - case 39: - YY_RULE_SETUP -#line 101 "promela.l" - { return PML_ASGN; } - YY_BREAK - case 40: - /* rule 40 can match eol */ - YY_RULE_SETUP -#line 103 "promela.l" - { yylval->value = strdup(yytext); return(PML_STRING); } - YY_BREAK - case 41: - /* rule 41 can match eol */ - YY_RULE_SETUP -#line 106 "promela.l" - { - /* Non PROMELA extension for single quoted string literals */ - yylval->value = strdup(yytext); - return(PML_STRING); - } - YY_BREAK - case 42: - YY_RULE_SETUP -#line 111 "promela.l" - { yylval->value = strdup(yytext); return PML_CONST; } - YY_BREAK - case 43: - YY_RULE_SETUP + { return '{'; } + YY_BREAK + case 39: + YY_RULE_SETUP +#line 100 "promela.l" + { return '}'; } + YY_BREAK + case 40: + YY_RULE_SETUP +#line 102 "promela.l" + { return PML_ASGN; } + YY_BREAK + case 41: + /* rule 41 can match eol */ + YY_RULE_SETUP +#line 104 "promela.l" + { yylval->value = strdup(yytext); return(PML_STRING); } + YY_BREAK + case 42: + /* rule 42 can match eol */ + YY_RULE_SETUP +#line 107 "promela.l" + { + /* Non PROMELA extension for single quoted string literals */ + yylval->value = strdup(yytext); + return(PML_STRING); + } + YY_BREAK + case 43: + YY_RULE_SETUP #line 112 "promela.l" - { yylval->value = strdup(yytext); return PML_NAME; } - YY_BREAK - case 44: - /* rule 44 can match eol */ - YY_RULE_SETUP -#line 114 "promela.l" - /* eat up whitespace */ - YY_BREAK - case 45: - YY_RULE_SETUP -#line 117 "promela.l" - { /*printf( "Unrecognized character: %s\n", yytext ); */ } - YY_BREAK - case 46: - YY_RULE_SETUP -#line 118 "promela.l" - ECHO; - YY_BREAK -#line 1336 "promela.lex.yy.cpp" - case YY_STATE_EOF(INITIAL): - yyterminate(); - - case YY_END_OF_BUFFER: { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = yyg->yy_hold_char; - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * promela_lex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) { - /* This was really a NUL. */ - yy_state_type yy_next_state; - - yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( yyscanner ); + { yylval->value = strdup(yytext); return PML_CONST; } + YY_BREAK + case 44: + YY_RULE_SETUP +#line 113 "promela.l" + { yylval->value = strdup(yytext); return PML_NAME; } + YY_BREAK + case 45: + /* rule 45 can match eol */ + YY_RULE_SETUP +#line 115 "promela.l" + /* eat up whitespace */ + YY_BREAK + case 46: + YY_RULE_SETUP +#line 118 "promela.l" + { return PML_UNREC; } + YY_BREAK + case 47: + YY_RULE_SETUP +#line 119 "promela.l" + ECHO; + YY_BREAK +#line 1362 "promela.lex.yy.cpp" + case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yyg->yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * promela_lex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + /* %if-c-only */ + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + /* %endif */ + /* %if-c++-only */ + /* %endif */ + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). */ + if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) { + /* This was really a NUL. */ + yy_state_type yy_next_state; + + yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; - yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); + yy_current_state = yy_get_previous_state( yyscanner ); - yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ - if ( yy_next_state ) { - /* Consume the NUL. */ - yy_cp = ++yyg->yy_c_buf_p; - yy_current_state = yy_next_state; - goto yy_match; - } + yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); - else { - /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ - yy_cp = yyg->yy_last_accepting_cpos; - yy_current_state = yyg->yy_last_accepting_state; - goto yy_find_action; - } - } + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; - else switch ( yy_get_next_buffer( yyscanner ) ) { - case EOB_ACT_END_OF_FILE: { - yyg->yy_did_buffer_switch_on_eof = 0; - - if ( promela_wrap(yyscanner ) ) { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; + if ( yy_next_state ) { + /* Consume the NUL. */ + yy_cp = ++yyg->yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; } else { - if ( ! yyg->yy_did_buffer_switch_on_eof ) - YY_NEW_FILE; + /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; + goto yy_find_action; } - break; } - case EOB_ACT_CONTINUE_SCAN: - yyg->yy_c_buf_p = - yyg->yytext_ptr + yy_amount_of_matched_text; + else switch ( yy_get_next_buffer( yyscanner ) ) { + case EOB_ACT_END_OF_FILE: { + yyg->yy_did_buffer_switch_on_eof = 0; + + if ( promela_wrap(yyscanner ) ) { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else { + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } - yy_current_state = yy_get_previous_state( yyscanner ); + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = + yyg->yytext_ptr + yy_amount_of_matched_text; - yy_cp = yyg->yy_c_buf_p; - yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; - goto yy_match; + yy_current_state = yy_get_previous_state( yyscanner ); - case EOB_ACT_LAST_MATCH: - yyg->yy_c_buf_p = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_match; - yy_current_state = yy_get_previous_state( yyscanner ); + case EOB_ACT_LAST_MATCH: + yyg->yy_c_buf_p = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; - yy_cp = yyg->yy_c_buf_p; - yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ } /* end of promela_lex */ /* %ok-for-header */ @@ -1475,9 +1503,9 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* %endif */ { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = yyg->yytext_ptr; - register int number_to_move, i; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = yyg->yytext_ptr; + yy_size_t number_to_move, i; int ret_val; if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) @@ -1504,7 +1532,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; + number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); @@ -1516,20 +1544,20 @@ static int yy_get_next_buffer (yyscan_t yyscanner) YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; else { - yy_size_t num_to_read = + int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; int yy_c_buf_p_offset = (int) (yyg->yy_c_buf_p - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { - yy_size_t new_size = b->yy_buf_size * 2; + int new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1541,7 +1569,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) promela_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); } else /* Can't grow it, we don't own it. */ - b->yy_ch_buf = 0; + b->yy_ch_buf = NULL; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( @@ -1580,9 +1608,9 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) promela_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); @@ -1607,8 +1635,8 @@ static yy_state_type yy_get_previous_state (yyscan_t yyscanner) /* %if-c++-only */ /* %endif */ { - register yy_state_type yy_current_state; - register char *yy_cp; + yy_state_type yy_current_state; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* %% [15.0] code to get the start state into yy_current_state goes here */ @@ -1616,17 +1644,17 @@ static yy_state_type yy_get_previous_state (yyscan_t yyscanner) for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) { /* %% [16.0] code to find the next state goes here */ - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 126 ) + if ( yy_current_state >= 132 ) yy_c = yy_meta[(unsigned int) yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; } return yy_current_state; @@ -1643,35 +1671,37 @@ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_ /* %if-c++-only */ /* %endif */ { - register int yy_is_jam; + int yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */ - register char *yy_cp = yyg->yy_c_buf_p; + char *yy_cp = yyg->yy_c_buf_p; - register YY_CHAR yy_c = 1; + YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 126 ) + if ( yy_current_state >= 132 ) yy_c = yy_meta[(unsigned int) yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 125); + yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; + yy_is_jam = (yy_current_state == 131); + (void)yyg; return yy_is_jam ? 0 : yy_current_state; } +#ifndef YY_NO_UNPUT /* %if-c-only */ -static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) +static void yyunput (int c, char * yy_bp , yyscan_t yyscanner) /* %endif */ /* %if-c++-only */ /* %endif */ { - register char *yy_cp; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_cp = yyg->yy_c_buf_p; @@ -1682,10 +1712,10 @@ static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - register yy_size_t number_to_move = yyg->yy_n_chars + 2; - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - register char *source = + int number_to_move = yyg->yy_n_chars + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) @@ -1694,7 +1724,7 @@ static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); @@ -1715,6 +1745,7 @@ static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) /* %if-c-only */ /* %endif */ +#endif /* %if-c-only */ #ifndef YY_NO_INPUT @@ -1744,7 +1775,7 @@ static int input (yyscan_t yyscanner) else { /* need more input */ - yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr; + int offset = yyg->yy_c_buf_p - yyg->yytext_ptr; ++yyg->yy_c_buf_p; switch ( yy_get_next_buffer( yyscanner ) ) { @@ -1826,6 +1857,9 @@ void promela_restart (FILE * input_file , yyscan_t yyscanner) promela__load_buffer_state(yyscanner ); } +/* %if-c++-only */ +/* %endif */ + /** Switch to a different input buffer. * @param new_buffer The new input buffer. * @param yyscanner The scanner object. @@ -1874,7 +1908,11 @@ static void promela__load_buffer_state (yyscan_t yyscanner) struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + /* %if-c-only */ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + /* %endif */ + /* %if-c++-only */ + /* %endif */ yyg->yy_hold_char = *yyg->yy_c_buf_p; } @@ -1896,7 +1934,7 @@ YY_BUFFER_STATE promela__create_buffer (FILE * file, int size , yyscan_t yysca if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in promela__create_buffer()" ); - b->yy_buf_size = size; + b->yy_buf_size = (yy_size_t)size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. @@ -1912,6 +1950,9 @@ YY_BUFFER_STATE promela__create_buffer (FILE * file, int size , yyscan_t yysca return b; } +/* %if-c++-only */ +/* %endif */ + /** Destroy the buffer. * @param b a buffer created with promela__create_buffer() * @param yyscanner The scanner object. @@ -1936,13 +1977,6 @@ void promela__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) promela_free((void *) b ,yyscanner ); } -/* %if-c-only */ - -/* %endif */ - -/* %if-c++-only */ -/* %endif */ - /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a promela_restart() or at EOF. @@ -1959,7 +1993,11 @@ static void promela__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yy promela__flush_buffer(b ,yyscanner); + /* %if-c-only */ b->yy_input_file = file; + /* %endif */ + /* %if-c++-only */ + /* %endif */ b->yy_fill_buffer = 1; /* If b is the current buffer, then promela__init_buffer was _probably_ @@ -2088,7 +2126,7 @@ static void promela_ensure_buffer_stack (yyscan_t yyscanner) /* %if-c++-only */ /* %endif */ { - yy_size_t num_to_alloc; + int num_to_alloc; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!yyg->yy_buffer_stack) { @@ -2097,7 +2135,7 @@ static void promela_ensure_buffer_stack (yyscan_t yyscanner) * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ - num_to_alloc = 1; + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ yyg->yy_buffer_stack = (struct yy_buffer_state**)promela_alloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); @@ -2114,7 +2152,7 @@ static void promela_ensure_buffer_stack (yyscan_t yyscanner) if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1) { /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; + yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = yyg->yy_buffer_stack_max + grow_size; yyg->yy_buffer_stack = (struct yy_buffer_state**)promela_realloc @@ -2145,7 +2183,7 @@ YY_BUFFER_STATE promela__scan_buffer (char * base, yy_size_t size , yyscan_t y base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ - return 0; + return NULL; b = (YY_BUFFER_STATE) promela_alloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b ) @@ -2154,7 +2192,7 @@ YY_BUFFER_STATE promela__scan_buffer (char * base, yy_size_t size , yyscan_t y b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; - b->yy_input_file = 0; + b->yy_input_file = NULL; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; @@ -2178,25 +2216,26 @@ YY_BUFFER_STATE promela__scan_buffer (char * base, yy_size_t size , yyscan_t y */ YY_BUFFER_STATE promela__scan_string (yyconst char * yystr , yyscan_t yyscanner) { - return promela__scan_bytes(yystr,strlen(yystr) ,yyscanner); + return promela__scan_bytes(yystr,(int) strlen(yystr) ,yyscanner); } /* %endif */ /* %if-c-only */ /** Setup the input buffer state to scan the given bytes. The next call to promela_lex() will * scan from a @e copy of @a bytes. - * @param bytes the byte buffer to scan - * @param len the number of bytes in the buffer pointed to by @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE promela__scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner) { +YY_BUFFER_STATE promela__scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner) { YY_BUFFER_STATE b; char *buf; - yy_size_t n, i; + yy_size_t n; + yy_size_t i; /* Get memory for full buffer, including space for trailing EOB's. */ - n = _yybytes_len + 2; + n = (yy_size_t) _yybytes_len + 2; buf = (char *) promela_alloc(n ,yyscanner ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in promela__scan_bytes()" ); @@ -2224,7 +2263,9 @@ YY_BUFFER_STATE promela__scan_bytes (yyconst char * yybytes, yy_size_t _yybyte #endif /* %if-c-only */ -static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) { +static void yynoreturn yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -2307,7 +2348,7 @@ FILE *promela_get_out (yyscan_t yyscanner) { /** Get the length of the current token. * @param yyscanner The scanner object. */ -yy_size_t promela_get_leng (yyscan_t yyscanner) { +int promela_get_leng (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyleng; } @@ -2335,47 +2376,47 @@ void promela_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) { /* %endif */ /** Set the current line number. - * @param line_number + * @param _line_number line number * @param yyscanner The scanner object. */ -void promela_set_lineno (int line_number , yyscan_t yyscanner) { +void promela_set_lineno (int _line_number , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* lineno is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "promela_set_lineno called with no buffer" , yyscanner); + YY_FATAL_ERROR( "promela_set_lineno called with no buffer" ); - yylineno = line_number; + yylineno = _line_number; } /** Set the current column. - * @param line_number + * @param _column_no column number * @param yyscanner The scanner object. */ -void promela_set_column (int column_no , yyscan_t yyscanner) { +void promela_set_column (int _column_no , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* column is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "promela_set_column called with no buffer" , yyscanner); + YY_FATAL_ERROR( "promela_set_column called with no buffer" ); - yycolumn = column_no; + yycolumn = _column_no; } /** Set the input stream. This does not discard the current * input buffer. - * @param in_str A readable stream. + * @param _in_str A readable stream. * @param yyscanner The scanner object. * @see promela__switch_to_buffer */ -void promela_set_in (FILE * in_str , yyscan_t yyscanner) { +void promela_set_in (FILE * _in_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyin = in_str ; + yyin = _in_str ; } -void promela_set_out (FILE * out_str , yyscan_t yyscanner) { +void promela_set_out (FILE * _out_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyout = out_str ; + yyout = _out_str ; } int promela_get_debug (yyscan_t yyscanner) { @@ -2383,9 +2424,9 @@ int promela_get_debug (yyscan_t yyscanner) { return yy_flex_debug; } -void promela_set_debug (int bdebug , yyscan_t yyscanner) { +void promela_set_debug (int _bdebug , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yy_flex_debug = bdebug ; + yy_flex_debug = _bdebug ; } /* %endif */ @@ -2490,10 +2531,10 @@ static int yy_init_globals (yyscan_t yyscanner) { * This function is called from promela_lex_destroy(), so don't allocate here. */ - yyg->yy_buffer_stack = 0; + yyg->yy_buffer_stack = NULL; yyg->yy_buffer_stack_top = 0; yyg->yy_buffer_stack_max = 0; - yyg->yy_c_buf_p = (char *) 0; + yyg->yy_c_buf_p = NULL; yyg->yy_init = 0; yyg->yy_start = 0; @@ -2506,8 +2547,8 @@ static int yy_init_globals (yyscan_t yyscanner) { yyin = stdin; yyout = stdout; #else - yyin = (FILE *) 0; - yyout = (FILE *) 0; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by @@ -2556,7 +2597,10 @@ int promela_lex_destroy (yyscan_t yyscanner) { #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) { - register int i; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } @@ -2564,7 +2608,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yysca #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) { - register int n; + int n; for ( n = 0; s[n]; ++n ) ; @@ -2573,10 +2617,15 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) { #endif void *promela_alloc (yy_size_t size , yyscan_t yyscanner) { - return (void *) malloc( size ); + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + return malloc(size); } void *promela_realloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -2584,10 +2633,12 @@ void *promela_realloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ - return (void *) realloc( (char *) ptr, size ); + return realloc(ptr, size); } void promela_free (void * ptr , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; free( (char *) ptr ); /* see promela_realloc() for (char *) cast */ } @@ -2598,4 +2649,4 @@ void promela_free (void * ptr , yyscan_t yyscanner) { /* %ok-for-header */ -#line 118 "promela.l" +#line 119 "promela.l" diff --git a/src/uscxml/plugins/datamodel/promela/parser/promela.tab.cpp b/src/uscxml/plugins/datamodel/promela/parser/promela.tab.cpp index 098c890..eddb963 100644 --- a/src/uscxml/plugins/datamodel/promela/parser/promela.tab.cpp +++ b/src/uscxml/plugins/datamodel/promela/parser/promela.tab.cpp @@ -1,8 +1,8 @@ -/* A Bison parser, made by GNU Bison 2.7.12-4996. */ +/* A Bison parser, made by GNU Bison 3.0.4. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -44,7 +44,7 @@ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "2.7.12-4996" +#define YYBISON_VERSION "3.0.4" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -65,15 +65,12 @@ #define yyparse promela_parse #define yylex promela_lex #define yyerror promela_error -#define yylval promela_lval -#define yychar promela_char #define yydebug promela_debug #define yynerrs promela_nerrs -#define yylloc promela_lloc + /* Copy the first part of user declarations. */ -/* Line 371 of yacc.c */ -#line 14 "promela.ypp" +#line 14 "promela.ypp" /* yacc.c:339 */ #include "../PromelaParser.h" #include "promela.tab.hpp" @@ -88,14 +85,13 @@ extern int promela_lex (PROMELA_STYPE* yylval_param, PROMELA_LTYPE* yylloc_param using namespace uscxml; -/* Line 371 of yacc.c */ -#line 93 "promela.tab.cpp" +#line 89 "promela.tab.cpp" /* yacc.c:339 */ -# ifndef YY_NULL +# ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULL nullptr +# define YY_NULLPTR nullptr # else -# define YY_NULL 0 +# define YY_NULLPTR 0 # endif # endif @@ -111,10 +107,10 @@ using namespace uscxml; by #include "promela.tab.hpp". */ #ifndef YY_PROMELA_PROMELA_TAB_HPP_INCLUDED # define YY_PROMELA_PROMELA_TAB_HPP_INCLUDED -/* Enabling traces. */ +/* Debug traces. */ #ifndef PROMELA_DEBUG # if defined YYDEBUG -# if YYDEBUG +#if YYDEBUG # define PROMELA_DEBUG 1 # else # define PROMELA_DEBUG 0 @@ -127,11 +123,9 @@ using namespace uscxml; extern int promela_debug; #endif -/* Tokens. */ +/* Token type. */ #ifndef PROMELA_TOKENTYPE # define PROMELA_TOKENTYPE -/* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ enum promela_tokentype { PML_VAR_ARRAY = 258, PML_VARLIST = 259, @@ -181,85 +175,74 @@ enum promela_tokentype { PML_INIT = 303, PML_LTL = 304, PML_COMMA = 305, - PML_ASGN = 306, - PML_AND = 307, + PML_UNREC = 306, + PML_ASGN = 307, PML_OR = 308, - PML_BITAND = 309, - PML_BITXOR = 310, - PML_BITOR = 311, - PML_NE = 312, + PML_AND = 309, + PML_BITOR = 310, + PML_BITXOR = 311, + PML_BITAND = 312, PML_EQ = 313, - PML_LE = 314, - PML_GE = 315, + PML_NE = 314, + PML_GT = 315, PML_LT = 316, - PML_GT = 317, - PML_RSHIFT = 318, + PML_GE = 317, + PML_LE = 318, PML_LSHIFT = 319, - PML_MINUS = 320, + PML_RSHIFT = 320, PML_PLUS = 321, - PML_MODULO = 322, - PML_DIVIDE = 323, - PML_TIMES = 324, - PML_DECR = 325, + PML_MINUS = 322, + PML_TIMES = 323, + PML_DIVIDE = 324, + PML_MODULO = 325, PML_INCR = 326, - PML_COMPL = 327, - PML_NEG = 328, - PML_CMPND = 329, - PML_DOT = 330 + PML_DECR = 327, + PML_COMPL = 328, + PML_NEG = 329, + PML_DOT = 330, + PML_CMPND = 331 }; #endif - +/* Value type. */ #if ! defined PROMELA_STYPE && ! defined PROMELA_STYPE_IS_DECLARED -typedef union PROMELA_STYPE { - /* Line 387 of yacc.c */ -#line 39 "promela.ypp" + +union PROMELA_STYPE { +#line 39 "promela.ypp" /* yacc.c:355 */ uscxml::PromelaParserNode* node; char* value; +#line 219 "promela.tab.cpp" /* yacc.c:355 */ +}; - /* Line 387 of yacc.c */ -#line 225 "promela.tab.cpp" -} PROMELA_STYPE; +typedef union PROMELA_STYPE PROMELA_STYPE; # define PROMELA_STYPE_IS_TRIVIAL 1 -# define promela_stype PROMELA_STYPE /* obsolescent; will be withdrawn */ # define PROMELA_STYPE_IS_DECLARED 1 #endif +/* Location type. */ #if ! defined PROMELA_LTYPE && ! defined PROMELA_LTYPE_IS_DECLARED -typedef struct PROMELA_LTYPE { +typedef struct PROMELA_LTYPE PROMELA_LTYPE; +struct PROMELA_LTYPE { int first_line; int first_column; int last_line; int last_column; -} PROMELA_LTYPE; -# define promela_ltype PROMELA_LTYPE /* obsolescent; will be withdrawn */ +}; # define PROMELA_LTYPE_IS_DECLARED 1 # define PROMELA_LTYPE_IS_TRIVIAL 1 #endif -#ifdef YYPARSE_PARAM -#if defined __STDC__ || defined __cplusplus -int promela_parse (void *YYPARSE_PARAM); -#else -int promela_parse (); -#endif -#else /* ! YYPARSE_PARAM */ -#if defined __STDC__ || defined __cplusplus + int promela_parse (uscxml::PromelaParser* ctx, void * scanner); -#else -int promela_parse (); -#endif -#endif /* ! YYPARSE_PARAM */ #endif /* !YY_PROMELA_PROMELA_TAB_HPP_INCLUDED */ /* Copy the second part of user declarations. */ -/* Line 390 of yacc.c */ -#line 265 "promela.tab.cpp" +#line 249 "promela.tab.cpp" /* yacc.c:358 */ #ifdef short # undef short @@ -273,11 +256,8 @@ typedef unsigned char yytype_uint8; #ifdef YYTYPE_INT8 typedef YYTYPE_INT8 yytype_int8; -#elif (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -typedef signed char yytype_int8; #else -typedef short int yytype_int8; +typedef signed char yytype_int8; #endif #ifdef YYTYPE_UINT16 @@ -297,8 +277,7 @@ typedef short int yytype_int16; # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t -# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) +# elif ! defined YYSIZE_T # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else @@ -320,11 +299,30 @@ typedef short int yytype_int16; # endif #endif -#ifndef __attribute__ -/* This feature is available in gcc versions 2.5 and later. */ -# if (! defined __GNUC__ || __GNUC__ < 2 \ - || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) -# define __attribute__(Spec) /* empty */ +#ifndef YY_ATTRIBUTE +# if (defined __GNUC__ \ + && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ + || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C +# define YY_ATTRIBUTE(Spec) __attribute__(Spec) +# else +# define YY_ATTRIBUTE(Spec) /* empty */ +# endif +#endif + +#ifndef YY_ATTRIBUTE_PURE +# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) +#endif + +#if !defined _Noreturn \ + && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) +# if defined _MSC_VER && 1200 <= _MSC_VER +# define _Noreturn __declspec (noreturn) +# else +# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) # endif #endif @@ -335,25 +333,26 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -# define YYID(N) (N) -#else -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static int -YYID (int yyi) +#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") #else -static int -YYID (yyi) -int yyi; +# define YY_INITIAL_VALUE(Value) Value #endif -{ - return yyi; -} +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif + #if ! defined yyoverflow || YYERROR_VERBOSE /* The parser invokes alloca or malloc; define the necessary symbols. */ @@ -371,8 +370,7 @@ int yyi; # define alloca _alloca # else # define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS # include /* INFRINGES ON USER NAME SPACE */ /* Use EXIT_SUCCESS as a witness for stdlib.h. */ # ifndef EXIT_SUCCESS @@ -384,8 +382,8 @@ int yyi; # endif # ifdef YYSTACK_ALLOC -/* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +/* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) # ifndef YYSTACK_ALLOC_MAXIMUM /* The OS might guarantee only one guard page at the bottom of the stack, and a page size can be as small as 4096 bytes. So we cannot safely @@ -401,7 +399,7 @@ int yyi; # endif # if (defined __cplusplus && ! defined EXIT_SUCCESS \ && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) + && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ # ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 @@ -409,15 +407,13 @@ int yyi; # endif # ifndef YYMALLOC # define YYMALLOC malloc -# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) +# if ! defined malloc && ! defined EXIT_SUCCESS void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free -# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) +# if ! defined free && ! defined EXIT_SUCCESS void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif @@ -427,8 +423,8 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ #if (! defined yyoverflow \ && (! defined __cplusplus \ - || (defined PROMELA_LTYPE_IS_TRIVIAL && PROMELA_LTYPE_IS_TRIVIAL \ - && defined PROMELA_STYPE_IS_TRIVIAL && PROMELA_STYPE_IS_TRIVIAL))) + || (defined PROMELA_LTYPE_IS_TRIVIAL && PROMELA_LTYPE_IS_TRIVIAL \ + && defined PROMELA_STYPE_IS_TRIVIAL && PROMELA_STYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { @@ -453,16 +449,16 @@ union yyalloc { elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ -# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ - Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (YYID (0)) +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) #endif @@ -481,7 +477,7 @@ union yyalloc { for (yyi = 0; yyi < (Count); yyi++) \ (Dst)[yyi] = (Src)[yyi]; \ } \ - while (YYID (0)) + while (0) # endif # endif #endif /* !YYCOPY_NEEDED */ @@ -489,25 +485,27 @@ union yyalloc { /* YYFINAL -- State number of the termination state. */ #define YYFINAL 32 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 285 +#define YYLAST 288 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 82 +#define YYNTOKENS 83 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 21 /* YYNRULES -- Number of rules. */ #define YYNRULES 81 -/* YYNRULES -- Number of states. */ +/* YYNSTATES -- Number of states. */ #define YYNSTATES 143 -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned + by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 330 +#define YYMAXUTOK 331 -#define YYTRANSLATE(YYX) \ +#define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, without out-of-bounds checking. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -542,56 +540,11 @@ static const yytype_uint8 yytranslate[] = { 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81 + 81, 82 }; #if PROMELA_DEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const yytype_uint16 yyprhs[] = { - 0, 0, 3, 5, 7, 9, 11, 13, 18, 21, - 22, 25, 29, 33, 37, 41, 45, 49, 53, 57, - 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, - 101, 104, 107, 112, 114, 116, 118, 119, 121, 123, - 125, 129, 133, 140, 143, 149, 151, 154, 158, 160, - 164, 166, 170, 172, 176, 181, 183, 186, 190, 194, - 198, 202, 206, 210, 212, 215, 218, 220, 223, 227, - 229, 233, 236, 239, 245, 250, 255, 258, 260, 261, - 264, 266 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yytype_int8 yyrhs[] = { - 83, 0, -1, 92, -1, 88, -1, 98, -1, 86, - -1, 48, -1, 48, 13, 88, 14, -1, 85, 87, - -1, -1, 81, 86, -1, 11, 88, 12, -1, 88, - 72, 88, -1, 88, 71, 88, -1, 88, 75, 88, - -1, 88, 74, 88, -1, 88, 73, 88, -1, 88, - 60, 88, -1, 88, 61, 88, -1, 88, 62, 88, - -1, 88, 68, 88, -1, 88, 67, 88, -1, 88, - 66, 88, -1, 88, 65, 88, -1, 88, 64, 88, - -1, 88, 63, 88, -1, 88, 58, 88, -1, 88, - 59, 88, -1, 88, 70, 88, -1, 88, 69, 88, - -1, 79, 88, -1, 71, 88, -1, 20, 11, 84, - 12, -1, 84, -1, 45, -1, 21, -1, -1, 42, - -1, 43, -1, 44, -1, 89, 46, 93, -1, 89, - 49, 93, -1, 89, 46, 57, 15, 97, 16, -1, - 89, 91, -1, 22, 48, 15, 92, 16, -1, 90, - -1, 90, 31, -1, 90, 31, 92, -1, 94, -1, - 94, 56, 93, -1, 95, -1, 95, 57, 88, -1, - 48, -1, 48, 8, 45, -1, 48, 13, 96, 14, - -1, 45, -1, 71, 96, -1, 11, 96, 12, -1, - 96, 72, 96, -1, 96, 71, 96, -1, 96, 75, - 96, -1, 96, 74, 96, -1, 96, 73, 96, -1, - 48, -1, 97, 48, -1, 97, 56, -1, 99, -1, - 99, 31, -1, 99, 31, 98, -1, 100, -1, 84, - 57, 88, -1, 84, 77, -1, 84, 76, -1, 18, - 11, 21, 101, 12, -1, 18, 11, 84, 12, -1, - 18, 11, 45, 12, -1, 17, 88, -1, 88, -1, - -1, 56, 102, -1, 88, -1, 88, 56, 102, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint8 yyrline[] = { 0, 85, 85, 89, 93, 99, 102, 103, 106, 121, 122, 132, 133, 134, 135, 136, 137, 138, 139, 140, @@ -619,20 +572,20 @@ static const char *const yytname[] = { "PML_SEP", "PML_DOTDOT", "PML_HIDDEN", "PML_SHOW", "PML_ISLOCAL", "PML_CONST", "PML_TYPE", "PML_XU", "PML_NAME", "PML_UNAME", "PML_PNAME", "PML_INAME", "PML_CLAIM", "PML_TRACE", "PML_INIT", "PML_LTL", - "PML_COMMA", "PML_ASGN", "PML_AND", "PML_OR", "PML_BITAND", "PML_BITXOR", - "PML_BITOR", "PML_NE", "PML_EQ", "PML_LE", "PML_GE", "PML_LT", "PML_GT", - "PML_RSHIFT", "PML_LSHIFT", "PML_MINUS", "PML_PLUS", "PML_MODULO", - "PML_DIVIDE", "PML_TIMES", "PML_DECR", "PML_INCR", "PML_COMPL", - "PML_NEG", "PML_CMPND", "PML_DOT", "$accept", "program", "varref", - "pfld", "cmpnd", "sfld", "expr", "vis", "one_decl", "utype", "decl_lst", - "var_list", "ivar", "vardcl", "const_expr", "nlst", "stmnt_lst", "stmnt", - "Stmnt", "prargs", "arg", YY_NULL + "PML_COMMA", "PML_UNREC", "PML_ASGN", "PML_OR", "PML_AND", "PML_BITOR", + "PML_BITXOR", "PML_BITAND", "PML_EQ", "PML_NE", "PML_GT", "PML_LT", + "PML_GE", "PML_LE", "PML_LSHIFT", "PML_RSHIFT", "PML_PLUS", "PML_MINUS", + "PML_TIMES", "PML_DIVIDE", "PML_MODULO", "PML_INCR", "PML_DECR", + "PML_COMPL", "PML_NEG", "PML_DOT", "PML_CMPND", "$accept", "program", + "varref", "pfld", "cmpnd", "sfld", "expr", "vis", "one_decl", "utype", + "decl_lst", "var_list", "ivar", "vardcl", "const_expr", "nlst", + "stmnt_lst", "stmnt", "Stmnt", "prargs", "arg", YY_NULLPTR }; #endif # ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ +/* YYTOKNUM[NUM] -- (External) token number corresponding to the + (internal) symbol number NUM (which must be that of a token). */ static const yytype_uint16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 40, 41, 91, 93, 123, 125, 266, 267, 268, @@ -642,55 +595,66 @@ static const yytype_uint16 yytoknum[] = { 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330 + 329, 330, 331 }; # endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = { - 0, 82, 83, 83, 83, 84, 85, 85, 86, 87, - 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, - 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, - 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, - 90, 90, 90, 90, 91, 92, 92, 92, 93, 93, - 94, 94, 95, 95, 95, 96, 96, 96, 96, 96, - 96, 96, 96, 97, 97, 97, 98, 98, 98, 99, - 100, 100, 100, 100, 100, 100, 100, 100, 101, 101, - 102, 102 -}; +#define YYPACT_NINF -112 -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = { - 0, 2, 1, 1, 1, 1, 1, 4, 2, 0, - 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 2, 2, 4, 1, 1, 1, 0, 1, 1, 1, - 3, 3, 6, 2, 5, 1, 2, 3, 1, 3, - 1, 3, 1, 3, 4, 1, 2, 3, 3, 3, - 3, 3, 3, 1, 2, 2, 1, 2, 3, 1, - 3, 2, 2, 5, 4, 4, 2, 1, 0, 2, - 1, 3 +#define yypact_value_is_default(Yystate) \ + (!!((Yystate) == (-112))) + +#define YYTABLE_NINF -78 + +#define yytable_value_is_error(Yytable_value) \ + 0 + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +static const yytype_int16 yypact[] = { + 14, 54, 54, -6, -3, -112, -112, -112, -112, -112, + 2, 54, 54, 24, -51, -53, -112, 140, 64, 5, + -112, -112, 6, -112, -112, 76, 182, 69, 41, 54, + 30, -112, -112, 54, -112, -112, 41, -112, 54, 54, + 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, + 54, 54, 54, 54, 54, 54, 43, -45, 45, -112, + 175, 52, -112, 11, 86, 89, 95, 94, 182, -112, + 198, 198, 112, 112, 112, 209, 209, 48, 48, 48, + 48, 120, 120, 30, 30, -112, -112, -112, 97, 1, + 100, -112, 60, 70, -112, -112, 182, -112, 54, 114, + -112, -112, -112, -112, 130, 85, 19, 83, 45, 54, + 164, -112, -112, 117, -112, 19, -112, 19, 9, -112, + 55, -112, 182, 54, -112, 4, 212, -112, 19, 19, + 19, 19, 19, -112, -112, -112, -112, -112, 212, 212, + -112, -112, -112 }; -/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. - Performed when YYTABLE doesn't specify something else to do. Zero +/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ static const yytype_uint8 yydefact[] = { 36, 0, 0, 0, 0, 35, 37, 38, 39, 34, - 6, 0, 0, 0, 33, 9, 5, 3, 0, 45, - 2, 4, 66, 69, 33, 0, 76, 0, 0, 0, - 31, 30, 1, 0, 72, 71, 0, 8, 0, 0, + 6, 0, 0, 0, 33, 9, 5, 4, 0, 45, + 2, 3, 66, 69, 33, 0, 76, 0, 0, 0, + 31, 30, 1, 0, 71, 72, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 36, 67, 11, 78, 0, 0, 0, 0, 70, 10, - 26, 27, 17, 18, 19, 25, 24, 23, 22, 21, - 20, 29, 28, 13, 12, 16, 15, 14, 0, 52, + 27, 26, 19, 18, 17, 24, 25, 20, 21, 22, + 23, 28, 29, 12, 13, 14, 15, 16, 0, 52, 0, 40, 48, 50, 41, 47, 77, 68, 0, 0, 75, 74, 32, 7, 36, 0, 0, 0, 0, 0, 80, 79, 73, 0, 53, 0, 55, 0, 0, 63, 0, 49, 51, 0, 44, 0, 56, 54, 0, 0, - 0, 0, 0, 42, 64, 65, 81, 57, 59, 58, - 62, 61, 60 + 0, 0, 0, 42, 64, 65, 81, 57, 58, 59, + 60, 61, 62 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = { + -112, -112, 68, -112, 153, -112, 0, -112, -112, -112, + -38, -48, -112, -112, -111, -112, 129, -112, -112, -112, + 74 }; /* YYDEFGOTO[NTERM-NUM]. */ @@ -700,152 +664,129 @@ static const yytype_int8 yydefgoto[] = { 111 }; -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -112 -static const yytype_int16 yypact[] = { - 14, 53, 53, 3, 13, -112, -112, -112, -112, -112, - 15, 53, 53, 26, 34, -51, -112, 138, 81, 5, - -112, -112, 58, -112, -112, 75, 160, 169, 42, 53, - -66, -112, -112, 53, -112, -112, 42, -112, 53, 53, - 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, - 53, 53, 53, 53, 53, 53, 44, -35, 51, -112, - 72, 49, -112, 46, 88, 96, 100, 93, 160, -112, - 176, 176, 189, 189, 189, 200, 200, 207, 207, 207, - 207, 120, 120, -66, -66, -112, -112, -112, 98, -3, - 102, -112, 63, 74, -112, -112, 160, -112, 53, 113, - -112, -112, -112, -112, 62, 126, -8, 167, 51, 53, - 114, -112, -112, 267, -112, -8, -112, -8, 9, -112, - 70, -112, 160, 53, -112, 4, 48, -112, -8, -8, - -8, -8, -8, -112, -112, -112, -112, -112, 48, 48, - -112, -112, -112 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int16 yypgoto[] = { - -112, -112, 68, -112, 180, -112, 0, -112, -112, -112, - -33, -43, -112, -112, -111, -112, 223, -112, -112, -112, - 162 -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which +/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -78 static const yytype_int16 yytable[] = { - 17, 25, 26, 115, 125, 105, 126, 53, 54, 55, - 106, 30, 31, 89, 27, 94, 137, 138, 139, 140, - 141, 142, 90, 127, 28, 1, 32, 95, 29, 67, - 36, 2, 3, 68, 4, 5, 60, 116, 70, 71, + 17, 25, 26, 89, 125, 27, 126, 33, 28, 105, + 94, 30, 31, 90, 106, 29, 137, 138, 139, 140, + 141, 142, 95, 127, 32, 1, 34, 35, 36, 67, + 115, 2, 3, 68, 4, 5, 60, 61, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 6, 7, 8, 9, - 1, 96, 10, 117, 1, 121, 2, 3, 14, 4, - 5, 113, -46, 4, 5, 128, 129, 130, 131, 132, - 128, 129, 130, 131, 132, 11, 133, 62, -46, 61, - 10, 33, 88, 12, 9, 65, 66, 10, 9, 89, - 100, 10, 98, 56, 6, 7, 8, 103, 101, 122, - 34, 35, 102, 104, 6, 7, 8, 107, 134, 108, - 11, 130, 131, 132, 11, 112, 135, 57, 12, 14, - 58, 109, 12, 38, 39, 40, 41, 42, 43, 44, + 121, 96, 10, 1, 116, 1, 113, 98, 14, 2, + 3, 133, 4, 5, 4, 5, 128, 129, 130, 131, + 132, 128, 129, 130, 131, 132, 56, 11, 62, 10, + 63, 88, 117, 89, 12, 65, 66, 9, 100, 9, + 10, 101, 10, 134, 53, 54, 55, 102, 103, 122, + 57, 135, 104, 58, 64, 107, 108, 10, 49, 50, + 51, 52, 53, 54, 55, 11, 112, 11, 109, 14, + 114, 119, 12, 124, 12, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, -77, 6, 7, 8, -46, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 69, + 97, -46, 51, 52, 53, 54, 55, 136, 0, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 6, 7, 8, + 123, 0, 0, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, -77, - 123, 114, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 63, 51, 52, 53, 54, 55, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 64, 119, 69, 10, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 43, 44, 45, 46, 47, 48, 49, 50, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 49, 50, 51, 52, - 53, 54, 55, 124, 97, 136 + 50, 51, 52, 53, 54, 55, 130, 131, 132 }; -#define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-112))) - -#define yytable_value_is_error(Yytable_value) \ - YYID (0) - -static const yytype_uint8 yycheck[] = { - 0, 1, 2, 11, 115, 8, 117, 73, 74, 75, - 13, 11, 12, 48, 11, 58, 12, 128, 129, 130, - 131, 132, 57, 14, 11, 11, 0, 60, 13, 29, - 81, 17, 18, 33, 20, 21, 31, 45, 38, 39, +static const yytype_int16 yycheck[] = { + 0, 1, 2, 48, 115, 11, 117, 58, 11, 8, + 58, 11, 12, 58, 13, 13, 12, 128, 129, 130, + 131, 132, 60, 14, 0, 11, 77, 78, 81, 29, + 11, 17, 18, 33, 20, 21, 31, 31, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 42, 43, 44, 45, - 11, 61, 48, 71, 11, 108, 17, 18, 0, 20, - 21, 104, 0, 20, 21, 71, 72, 73, 74, 75, - 71, 72, 73, 74, 75, 71, 16, 12, 16, 31, - 48, 57, 48, 79, 45, 27, 28, 48, 45, 48, - 12, 48, 56, 22, 42, 43, 44, 14, 12, 109, - 76, 77, 12, 15, 42, 43, 44, 15, 48, 56, - 71, 73, 74, 75, 71, 12, 56, 46, 79, 61, - 49, 57, 79, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 31, - 56, 45, 58, 59, 60, 61, 62, 63, 64, 65, + 108, 61, 48, 11, 45, 11, 104, 56, 0, 17, + 18, 16, 20, 21, 20, 21, 72, 73, 74, 75, + 76, 72, 73, 74, 75, 76, 22, 73, 12, 48, + 21, 48, 73, 48, 80, 27, 28, 45, 12, 45, + 48, 12, 48, 48, 74, 75, 76, 12, 14, 109, + 46, 56, 15, 49, 45, 15, 56, 48, 70, 71, + 72, 73, 74, 75, 76, 73, 12, 73, 58, 61, + 45, 48, 80, 16, 80, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 21, 71, 72, 73, 74, 75, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 45, 48, 36, 48, 58, 59, + 76, 31, 42, 43, 44, 0, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 36, + 61, 16, 72, 73, 74, 75, 76, 123, -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 69, 70, 71, 72, - 73, 74, 75, 16, 61, 123 + 70, 71, 72, 73, 74, 75, 76, 42, 43, 44, + 56, -1, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 74, 75, 76 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { 0, 11, 17, 18, 20, 21, 42, 43, 44, 45, - 48, 71, 79, 83, 84, 85, 86, 88, 89, 90, - 92, 98, 99, 100, 84, 88, 88, 11, 11, 13, - 88, 88, 0, 57, 76, 77, 81, 87, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 22, 46, 49, 91, - 31, 31, 12, 21, 45, 84, 84, 88, 88, 86, - 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, - 88, 88, 88, 88, 88, 88, 88, 88, 48, 48, - 57, 93, 94, 95, 93, 92, 88, 98, 56, 101, - 12, 12, 12, 14, 15, 8, 13, 15, 56, 57, - 88, 102, 12, 92, 45, 11, 45, 71, 96, 48, - 97, 93, 88, 56, 16, 96, 96, 14, 71, 72, - 73, 74, 75, 16, 48, 56, 102, 12, 96, 96, - 96, 96, 96 + 48, 73, 80, 84, 85, 86, 87, 89, 90, 91, + 93, 99, 100, 101, 85, 89, 89, 11, 11, 13, + 89, 89, 0, 58, 77, 78, 81, 88, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 22, 46, 49, 92, + 31, 31, 12, 21, 45, 85, 85, 89, 89, 87, + 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, + 89, 89, 89, 89, 89, 89, 89, 89, 48, 48, + 58, 94, 95, 96, 94, 93, 89, 99, 56, 102, + 12, 12, 12, 14, 15, 8, 13, 15, 56, 58, + 89, 103, 12, 93, 45, 11, 45, 73, 97, 48, + 98, 94, 89, 56, 16, 97, 97, 14, 72, 73, + 74, 75, 76, 16, 48, 56, 103, 12, 97, 97, + 97, 97, 97 +}; + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = { + 0, 83, 84, 84, 84, 85, 86, 86, 87, 88, + 88, 89, 89, 89, 89, 89, 89, 89, 89, 89, + 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, + 89, 89, 89, 89, 89, 89, 90, 90, 90, 90, + 91, 91, 91, 91, 92, 93, 93, 93, 94, 94, + 95, 95, 96, 96, 96, 97, 97, 97, 97, 97, + 97, 97, 97, 98, 98, 98, 99, 99, 99, 100, + 101, 101, 101, 101, 101, 101, 101, 101, 102, 102, + 103, 103 +}; + +/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = { + 0, 2, 1, 1, 1, 1, 1, 4, 2, 0, + 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 2, 2, 4, 1, 1, 1, 0, 1, 1, 1, + 3, 3, 6, 2, 5, 1, 2, 3, 1, 3, + 1, 3, 1, 3, 4, 1, 2, 3, 3, 3, + 3, 3, 3, 1, 2, 2, 1, 2, 3, 1, + 3, 2, 2, 5, 4, 4, 2, 1, 0, 2, + 1, 3 }; -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. However, - YYFAIL appears to be in use. Nevertheless, it is formally deprecated - in Bison 2.4.2's NEWS entry, where a plan to phase it out is - discussed. */ - -#define YYFAIL goto yyerrlab -#if defined YYFAIL -/* This is here to suppress warnings from the GCC cpp's - -Wunused-macros. Normally we don't worry about that warning, but - some users do, and we want to make it easy for users to remove - YYFAIL uses, which will produce warnings from Bison 2.5. */ -#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + #define YYRECOVERING() (!!yyerrstatus) @@ -862,13 +803,13 @@ do \ else \ { \ yyerror (&yylloc, ctx, scanner, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (YYID (0)) + YYERROR; \ + } \ +while (0) /* Error token number */ -#define YYTERROR 1 -#define YYERRCODE 256 +#define YYTERROR 1 +#define YYERRCODE 256 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. @@ -878,7 +819,7 @@ while (YYID (0)) #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ - if (YYID (N)) \ + if (N) \ { \ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ @@ -892,12 +833,27 @@ while (YYID (0)) (Current).first_column = (Current).last_column = \ YYRHSLOC (Rhs, 0).last_column; \ } \ - while (YYID (0)) + while (0) #endif #define YYRHSLOC(Rhs, K) ((Rhs)[K]) +/* Enable debugging if requested. */ +#if PROMELA_DEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + + /* YY_LOCATION_PRINT -- Print the location on the stream. This macro was not mandated originally: define only if we know we won't break user code: when these are the locations we know. */ @@ -907,32 +863,23 @@ while (YYID (0)) /* Print *YYLOCP on YYO. Private, do not rely on its existence. */ -__attribute__((__unused__)) -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) +YY_ATTRIBUTE_UNUSED static unsigned -yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) -#else -static unsigned -yy_location_print_ (yyo, yylocp) -FILE *yyo; -YYLTYPE const * const yylocp; -#endif -{ +yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) { unsigned res = 0; int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; if (0 <= yylocp->first_line) { - res += fprintf (yyo, "%d", yylocp->first_line); + res += YYFPRINTF (yyo, "%d", yylocp->first_line); if (0 <= yylocp->first_column) - res += fprintf (yyo, ".%d", yylocp->first_column); + res += YYFPRINTF (yyo, ".%d", yylocp->first_column); } if (0 <= yylocp->last_line) { if (yylocp->first_line < yylocp->last_line) { - res += fprintf (yyo, "-%d", yylocp->last_line); + res += YYFPRINTF (yyo, "-%d", yylocp->last_line); if (0 <= end_col) - res += fprintf (yyo, ".%d", end_col); + res += YYFPRINTF (yyo, ".%d", end_col); } else if (0 <= end_col && yylocp->first_column < end_col) - res += fprintf (yyo, "-%d", end_col); + res += YYFPRINTF (yyo, "-%d", end_col); } return res; } @@ -946,71 +893,34 @@ YYLTYPE const * const yylocp; #endif -/* YYLEX -- calling `yylex' with the right arguments. */ -#ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) -#else -# define YYLEX yylex (&yylval, &yylloc, scanner) -#endif - -/* Enable debugging if requested. */ -#if PROMELA_DEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value, Location, ctx, scanner); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, \ - Type, Value, Location, ctx, scanner); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (YYID (0)) +/*----------------------------------------. +| Print this symbol's value on YYOUTPUT. | +`----------------------------------------*/ -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, uscxml::PromelaParser* ctx, void * scanner) -#else -static void -yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, ctx, scanner) -FILE *yyoutput; -int yytype; -YYSTYPE const * const yyvaluep; -YYLTYPE const * const yylocationp; -uscxml::PromelaParser* ctx; -void * scanner; -#endif -{ +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, uscxml::PromelaParser* ctx, void * scanner) { FILE *yyo = yyoutput; YYUSE (yyo); - if (!yyvaluep) - return; YYUSE (yylocationp); YYUSE (ctx); YYUSE (scanner); + if (!yyvaluep) + return; # ifdef YYPRINT if (yytype < YYNTOKENS) YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# else - YYUSE (yyoutput); # endif YYUSE (yytype); } @@ -1020,25 +930,10 @@ void * scanner; | Print this symbol on YYOUTPUT. | `--------------------------------*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, uscxml::PromelaParser* ctx, void * scanner) -#else static void -yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, ctx, scanner) -FILE *yyoutput; -int yytype; -YYSTYPE const * const yyvaluep; -YYLTYPE const * const yylocationp; -uscxml::PromelaParser* ctx; -void * scanner; -#endif -{ - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, uscxml::PromelaParser* ctx, void * scanner) { + YYFPRINTF (yyoutput, "%s %s (", + yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); YY_LOCATION_PRINT (yyoutput, *yylocationp); YYFPRINTF (yyoutput, ": "); @@ -1051,17 +946,8 @@ void * scanner; | TOP (included). | `------------------------------------------------------------------*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) static void -yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) -#else -static void -yy_stack_print (yybottom, yytop) -yytype_int16 *yybottom; -yytype_int16 *yytop; -#endif -{ +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) { int yybot = *yybottom; @@ -1070,51 +956,40 @@ yytype_int16 *yytop; YYFPRINTF (stderr, "\n"); } -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (YYID (0)) +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) static void -yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, uscxml::PromelaParser* ctx, void * scanner) -#else -static void -yy_reduce_print (yyvsp, yylsp, yyrule, ctx, scanner) -YYSTYPE *yyvsp; -YYLTYPE *yylsp; -int yyrule; -uscxml::PromelaParser* ctx; -void * scanner; -#endif -{ +yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, uscxml::PromelaParser* ctx, void * scanner) { + unsigned long int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - unsigned long int yylno = yyrline[yyrule]; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + yy_symbol_print (stderr, + yystos[yyssp[yyi + 1 - yynrhs]], &(yyvsp[(yyi + 1) - (yynrhs)]) - , &(yylsp[(yyi + 1) - (yynrhs)]) , ctx, scanner); + , &(yylsp[(yyi + 1) - (yynrhs)]) , ctx, scanner); YYFPRINTF (stderr, "\n"); } } -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (yyvsp, yylsp, Rule, ctx, scanner); \ -} while (YYID (0)) +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, yylsp, Rule, ctx, scanner); \ +} while (0) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ @@ -1128,7 +1003,7 @@ int yydebug; /* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH +#ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif @@ -1151,16 +1026,8 @@ int yydebug; # define yystrlen strlen # else /* Return the length of YYSTR. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) static YYSIZE_T -yystrlen (const char *yystr) -#else -static YYSIZE_T -yystrlen (yystr) -const char *yystr; -#endif -{ +yystrlen (const char *yystr) { YYSIZE_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; @@ -1175,17 +1042,8 @@ const char *yystr; # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) static char * -yystpcpy (char *yydest, const char *yysrc) -#else -static char * -yystpcpy (yydest, yysrc) -char *yydest; -const char *yysrc; -#endif -{ +yystpcpy (char *yydest, const char *yysrc) { char *yyd = yydest; const char *yys = yysrc; @@ -1254,11 +1112,11 @@ do_not_strip_quotes: static int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken) { - YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); + YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); YYSIZE_T yysize = yysize0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; /* Internationalized format string. */ - const char *yyformat = YY_NULL; + const char *yyformat = YY_NULLPTR; /* Arguments of yyformat. */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; /* Number of reported tokens (one for the "unexpected", one per @@ -1266,10 +1124,6 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, int yycount = 0; /* There are many possibilities here to consider: - - Assume YYFAIL is not used. It's too flawed to consider. See - - for details. YYERROR is fine as it does not invoke this - function. - If this state is a consistent state with a default action, then the only way this function was invoked is if the default action is an error action. In that case, don't check for expected @@ -1315,7 +1169,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } yyarg[yycount++] = yytname[yyx]; { - YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) return 2; @@ -1377,32 +1231,19 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, | Release the memory associated to this symbol. | `-----------------------------------------------*/ -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) static void -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, uscxml::PromelaParser* ctx, void * scanner) -#else -static void -yydestruct (yymsg, yytype, yyvaluep, yylocationp, ctx, scanner) -const char *yymsg; -int yytype; -YYSTYPE *yyvaluep; -YYLTYPE *yylocationp; -uscxml::PromelaParser* ctx; -void * scanner; -#endif -{ +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, uscxml::PromelaParser* ctx, void * scanner) { YYUSE (yyvaluep); YYUSE (yylocationp); YYUSE (ctx); YYUSE (scanner); - if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YYUSE (yytype); + YY_IGNORE_MAYBE_UNINITIALIZED_END } @@ -1412,67 +1253,26 @@ void * scanner; | yyparse. | `----------*/ -#ifdef YYPARSE_PARAM -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int -yyparse (void *YYPARSE_PARAM) -#else -int -yyparse (YYPARSE_PARAM) -void *YYPARSE_PARAM; -#endif -#else /* ! YYPARSE_PARAM */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int -yyparse (uscxml::PromelaParser* ctx, void * scanner) -#else int -yyparse (ctx, scanner) -uscxml::PromelaParser* ctx; -void * scanner; -#endif -#endif -{ +yyparse (uscxml::PromelaParser* ctx, void * scanner) { /* The lookahead symbol. */ int yychar; -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ - /* Suppress an incorrect diagnostic about yylval being uninitialized. */ -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ - _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ - _Pragma ("GCC diagnostic pop") -#else + /* The semantic value of the lookahead symbol. */ /* Default value used for initialization, for pacifying older GCCs or non-GCC compilers. */ - static YYSTYPE yyval_default; -# define YY_INITIAL_VALUE(Value) = Value -#endif + YY_INITIAL_VALUE (static YYSTYPE yyval_default;) + YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); + + /* Location data for the lookahead symbol. */ static YYLTYPE yyloc_default # if defined PROMELA_LTYPE_IS_TRIVIAL && PROMELA_LTYPE_IS_TRIVIAL = { 1, 1, 1, 1 } # endif ; -#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_END -#endif -#ifndef YY_INITIAL_VALUE -# define YY_INITIAL_VALUE(Value) /* Nothing. */ -#endif - - /* The semantic value of the lookahead symbol. */ - YYSTYPE yylval YY_INITIAL_VALUE(yyval_default); - - /* Location data for the lookahead symbol. */ YYLTYPE yylloc = yyloc_default; - /* Number of syntax errors so far. */ int yynerrs; @@ -1481,9 +1281,9 @@ void * scanner; int yyerrstatus; /* The stacks and their tools: - `yyss': related to states. - `yyvs': related to semantic values. - `yyls': related to locations. + 'yyss': related to states. + 'yyvs': related to semantic values. + 'yyls': related to locations. Refer to the stacks through separate pointers, to allow yyoverflow to reallocate them elsewhere. */ @@ -1645,7 +1445,7 @@ yybackup: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; + yychar = yylex (&yylval, &yylloc, scanner); } if (yychar <= YYEOF) { @@ -1706,7 +1506,7 @@ yyreduce: yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. + '$$ = $1'. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison @@ -1720,690 +1520,689 @@ yyreduce: YY_REDUCE_PRINT (yyn); switch (yyn) { case 2: - /* Line 1787 of yacc.c */ -#line 85 "promela.ypp" +#line 85 "promela.ypp" /* yacc.c:1646 */ { - ctx->ast = (yyvsp[(1) - (1)].node); + ctx->ast = (yyvsp[0].node); ctx->type = PromelaParser::PROMELA_DECL; } +#line 1580 "promela.tab.cpp" /* yacc.c:1646 */ break; case 3: - /* Line 1787 of yacc.c */ -#line 89 "promela.ypp" +#line 89 "promela.ypp" /* yacc.c:1646 */ { - ctx->ast = (yyvsp[(1) - (1)].node); - ctx->type = PromelaParser::PROMELA_EXPR; + ctx->ast = (yyvsp[0].node); + ctx->type = PromelaParser::PROMELA_STMNT; } +#line 1589 "promela.tab.cpp" /* yacc.c:1646 */ break; case 4: - /* Line 1787 of yacc.c */ -#line 93 "promela.ypp" +#line 93 "promela.ypp" /* yacc.c:1646 */ { - ctx->ast = (yyvsp[(1) - (1)].node); - ctx->type = PromelaParser::PROMELA_STMNT; + ctx->ast = (yyvsp[0].node); + ctx->type = PromelaParser::PROMELA_EXPR; } +#line 1598 "promela.tab.cpp" /* yacc.c:1646 */ break; case 5: - /* Line 1787 of yacc.c */ -#line 99 "promela.ypp" +#line 99 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1604 "promela.tab.cpp" /* yacc.c:1646 */ break; case 6: - /* Line 1787 of yacc.c */ -#line 102 "promela.ypp" +#line 102 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->value(PML_NAME, (void*)&((yylsp[(1) - (1)])), (yyvsp[(1) - (1)].value)); - free((yyvsp[(1) - (1)].value)); + (yyval.node) = ctx->value(PML_NAME, (void*)&((yylsp[0])), (yyvsp[0].value)); + free((yyvsp[0].value)); } +#line 1610 "promela.tab.cpp" /* yacc.c:1646 */ break; case 7: - /* Line 1787 of yacc.c */ -#line 103 "promela.ypp" +#line 103 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_VAR_ARRAY, 2, ctx->value(PML_NAME, (void*)&((yylsp[(1) - (4)])), (yyvsp[(1) - (4)].value)), (yyvsp[(3) - (4)].node)); - free((yyvsp[(1) - (4)].value)); + (yyval.node) = ctx->node(PML_VAR_ARRAY, 2, ctx->value(PML_NAME, (void*)&((yylsp[-3])), (yyvsp[-3].value)), (yyvsp[-1].node)); + free((yyvsp[-3].value)); } +#line 1616 "promela.tab.cpp" /* yacc.c:1646 */ break; case 8: - /* Line 1787 of yacc.c */ -#line 107 "promela.ypp" - { - if ((yyvsp[(2) - (2)].node) != NULL) { - if ((yyvsp[(2) - (2)].node)->type == PML_CMPND) { - (yyval.node) = ctx->node(PML_CMPND, 1, (yyvsp[(1) - (2)].node)); - (yyval.node)->merge((yyvsp[(2) - (2)].node)); - delete (yyvsp[(2) - (2)].node); +#line 107 "promela.ypp" /* yacc.c:1646 */ + { + if ((yyvsp[0].node) != NULL) { + if ((yyvsp[0].node)->type == PML_CMPND) { + (yyval.node) = ctx->node(PML_CMPND, 1, (yyvsp[-1].node)); + (yyval.node)->merge((yyvsp[0].node)); + delete (yyvsp[0].node); } else { - (yyval.node) = ctx->node(PML_CMPND, 2, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + (yyval.node) = ctx->node(PML_CMPND, 2, (yyvsp[-1].node), (yyvsp[0].node)); } } else { - (yyval.node) = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[-1].node); } } +#line 1633 "promela.tab.cpp" /* yacc.c:1646 */ break; case 9: - /* Line 1787 of yacc.c */ -#line 121 "promela.ypp" +#line 121 "promela.ypp" /* yacc.c:1646 */ { (yyval.node) = NULL; } +#line 1639 "promela.tab.cpp" /* yacc.c:1646 */ break; case 10: - /* Line 1787 of yacc.c */ -#line 122 "promela.ypp" +#line 122 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(2) - (2)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1645 "promela.tab.cpp" /* yacc.c:1646 */ break; case 11: - /* Line 1787 of yacc.c */ -#line 132 "promela.ypp" +#line 132 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(2) - (3)].node); + (yyval.node) = (yyvsp[-1].node); } +#line 1651 "promela.tab.cpp" /* yacc.c:1646 */ break; case 12: - /* Line 1787 of yacc.c */ -#line 133 "promela.ypp" +#line 133 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_PLUS, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_PLUS, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1657 "promela.tab.cpp" /* yacc.c:1646 */ break; case 13: - /* Line 1787 of yacc.c */ -#line 134 "promela.ypp" +#line 134 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_MINUS, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_MINUS, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1663 "promela.tab.cpp" /* yacc.c:1646 */ break; case 14: - /* Line 1787 of yacc.c */ -#line 135 "promela.ypp" +#line 135 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_TIMES, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_TIMES, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1669 "promela.tab.cpp" /* yacc.c:1646 */ break; case 15: - /* Line 1787 of yacc.c */ -#line 136 "promela.ypp" +#line 136 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_DIVIDE, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_DIVIDE, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1675 "promela.tab.cpp" /* yacc.c:1646 */ break; case 16: - /* Line 1787 of yacc.c */ -#line 137 "promela.ypp" +#line 137 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_MODULO, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_MODULO, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1681 "promela.tab.cpp" /* yacc.c:1646 */ break; case 17: - /* Line 1787 of yacc.c */ -#line 138 "promela.ypp" +#line 138 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_BITAND, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_BITAND, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1687 "promela.tab.cpp" /* yacc.c:1646 */ break; case 18: - /* Line 1787 of yacc.c */ -#line 139 "promela.ypp" +#line 139 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_BITXOR, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_BITXOR, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1693 "promela.tab.cpp" /* yacc.c:1646 */ break; case 19: - /* Line 1787 of yacc.c */ -#line 140 "promela.ypp" +#line 140 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_BITOR, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_BITOR, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1699 "promela.tab.cpp" /* yacc.c:1646 */ break; case 20: - /* Line 1787 of yacc.c */ -#line 141 "promela.ypp" +#line 141 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_GT, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_GT, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1705 "promela.tab.cpp" /* yacc.c:1646 */ break; case 21: - /* Line 1787 of yacc.c */ -#line 142 "promela.ypp" +#line 142 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_LT, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_LT, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1711 "promela.tab.cpp" /* yacc.c:1646 */ break; case 22: - /* Line 1787 of yacc.c */ -#line 143 "promela.ypp" +#line 143 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_GE, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_GE, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1717 "promela.tab.cpp" /* yacc.c:1646 */ break; case 23: - /* Line 1787 of yacc.c */ -#line 144 "promela.ypp" +#line 144 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_LE, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_LE, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1723 "promela.tab.cpp" /* yacc.c:1646 */ break; case 24: - /* Line 1787 of yacc.c */ -#line 145 "promela.ypp" +#line 145 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_EQ, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_EQ, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1729 "promela.tab.cpp" /* yacc.c:1646 */ break; case 25: - /* Line 1787 of yacc.c */ -#line 146 "promela.ypp" +#line 146 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_NE, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_NE, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1735 "promela.tab.cpp" /* yacc.c:1646 */ break; case 26: - /* Line 1787 of yacc.c */ -#line 147 "promela.ypp" +#line 147 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_AND, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_AND, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1741 "promela.tab.cpp" /* yacc.c:1646 */ break; case 27: - /* Line 1787 of yacc.c */ -#line 148 "promela.ypp" +#line 148 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_OR, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_OR, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1747 "promela.tab.cpp" /* yacc.c:1646 */ break; case 28: - /* Line 1787 of yacc.c */ -#line 149 "promela.ypp" +#line 149 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_LSHIFT, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_LSHIFT, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1753 "promela.tab.cpp" /* yacc.c:1646 */ break; case 29: - /* Line 1787 of yacc.c */ -#line 150 "promela.ypp" +#line 150 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_RSHIFT, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_RSHIFT, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1759 "promela.tab.cpp" /* yacc.c:1646 */ break; case 30: - /* Line 1787 of yacc.c */ -#line 151 "promela.ypp" +#line 151 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_NEG, 1, (yyvsp[(2) - (2)].node)); + (yyval.node) = ctx->node(PML_NEG, 1, (yyvsp[0].node)); } +#line 1765 "promela.tab.cpp" /* yacc.c:1646 */ break; case 31: - /* Line 1787 of yacc.c */ -#line 152 "promela.ypp" +#line 152 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_MINUS, 1, (yyvsp[(2) - (2)].node)); + (yyval.node) = ctx->node(PML_MINUS, 1, (yyvsp[0].node)); } +#line 1771 "promela.tab.cpp" /* yacc.c:1646 */ break; case 32: - /* Line 1787 of yacc.c */ -#line 154 "promela.ypp" +#line 154 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_LEN, 1, (yyvsp[(3) - (4)].node)); + (yyval.node) = ctx->node(PML_LEN, 1, (yyvsp[-1].node)); } +#line 1777 "promela.tab.cpp" /* yacc.c:1646 */ break; case 33: - /* Line 1787 of yacc.c */ -#line 155 "promela.ypp" +#line 155 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1783 "promela.tab.cpp" /* yacc.c:1646 */ break; case 34: - /* Line 1787 of yacc.c */ -#line 156 "promela.ypp" +#line 156 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->value(PML_CONST, (void*)&((yylsp[(1) - (1)])), (yyvsp[(1) - (1)].value)); - free((yyvsp[(1) - (1)].value)); + (yyval.node) = ctx->value(PML_CONST, (void*)&((yylsp[0])), (yyvsp[0].value)); + free((yyvsp[0].value)); } +#line 1789 "promela.tab.cpp" /* yacc.c:1646 */ break; case 35: - /* Line 1787 of yacc.c */ -#line 157 "promela.ypp" +#line 157 "promela.ypp" /* yacc.c:1646 */ { /* Non standard promela for string literals */ - (yyval.node) = ctx->value(PML_STRING, (void*)&((yylsp[(1) - (1)])), (yyvsp[(1) - (1)].value)); - free((yyvsp[(1) - (1)].value)); + (yyval.node) = ctx->value(PML_STRING, (void*)&((yylsp[0])), (yyvsp[0].value)); + free((yyvsp[0].value)); } +#line 1797 "promela.tab.cpp" /* yacc.c:1646 */ break; case 36: - /* Line 1787 of yacc.c */ -#line 163 "promela.ypp" +#line 163 "promela.ypp" /* yacc.c:1646 */ { (yyval.node) = ctx->node(PML_SHOW, 0); } +#line 1803 "promela.tab.cpp" /* yacc.c:1646 */ break; case 37: - /* Line 1787 of yacc.c */ -#line 164 "promela.ypp" +#line 164 "promela.ypp" /* yacc.c:1646 */ { (yyval.node) = ctx->node(PML_HIDDEN, 0); } +#line 1809 "promela.tab.cpp" /* yacc.c:1646 */ break; case 38: - /* Line 1787 of yacc.c */ -#line 165 "promela.ypp" +#line 165 "promela.ypp" /* yacc.c:1646 */ { (yyval.node) = ctx->node(PML_SHOW, 0); } +#line 1815 "promela.tab.cpp" /* yacc.c:1646 */ break; case 39: - /* Line 1787 of yacc.c */ -#line 166 "promela.ypp" +#line 166 "promela.ypp" /* yacc.c:1646 */ { (yyval.node) = ctx->node(PML_ISLOCAL, 0); } +#line 1821 "promela.tab.cpp" /* yacc.c:1646 */ break; case 40: - /* Line 1787 of yacc.c */ -#line 169 "promela.ypp" +#line 169 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_DECL, 3, (yyvsp[(1) - (3)].node), ctx->value(PML_TYPE, (void*)&((yylsp[(2) - (3)])), (yyvsp[(2) - (3)].value)), (yyvsp[(3) - (3)].node)); - free((yyvsp[(2) - (3)].value)); + (yyval.node) = ctx->node(PML_DECL, 3, (yyvsp[-2].node), ctx->value(PML_TYPE, (void*)&((yylsp[-1])), (yyvsp[-1].value)), (yyvsp[0].node)); + free((yyvsp[-1].value)); } +#line 1827 "promela.tab.cpp" /* yacc.c:1646 */ break; case 41: - /* Line 1787 of yacc.c */ -#line 170 "promela.ypp" +#line 170 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_UNAME, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_UNAME, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1833 "promela.tab.cpp" /* yacc.c:1646 */ break; case 42: - /* Line 1787 of yacc.c */ -#line 171 "promela.ypp" +#line 171 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_DECL, 3, (yyvsp[(1) - (6)].node), ctx->value(PML_TYPE, (void*)&((yylsp[(2) - (6)])), (yyvsp[(2) - (6)].value)), (yyvsp[(5) - (6)].node)); - free((yyvsp[(2) - (6)].value)); + (yyval.node) = ctx->node(PML_DECL, 3, (yyvsp[-5].node), ctx->value(PML_TYPE, (void*)&((yylsp[-4])), (yyvsp[-4].value)), (yyvsp[-1].node)); + free((yyvsp[-4].value)); } +#line 1839 "promela.tab.cpp" /* yacc.c:1646 */ break; case 43: - /* Line 1787 of yacc.c */ -#line 172 "promela.ypp" +#line 172 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(2) - (2)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1845 "promela.tab.cpp" /* yacc.c:1646 */ break; case 44: - /* Line 1787 of yacc.c */ -#line 175 "promela.ypp" +#line 175 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_TYPEDEF, 2, ctx->value(PML_NAME, (void*)&((yylsp[(2) - (5)])), (yyvsp[(2) - (5)].value)), (yyvsp[(4) - (5)].node)); + (yyval.node) = ctx->node(PML_TYPEDEF, 2, ctx->value(PML_NAME, (void*)&((yylsp[-3])), (yyvsp[-3].value)), (yyvsp[-1].node)); } +#line 1851 "promela.tab.cpp" /* yacc.c:1646 */ break; case 45: - /* Line 1787 of yacc.c */ -#line 178 "promela.ypp" +#line 178 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1857 "promela.tab.cpp" /* yacc.c:1646 */ break; case 46: - /* Line 1787 of yacc.c */ -#line 179 "promela.ypp" +#line 179 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[-1].node); } +#line 1863 "promela.tab.cpp" /* yacc.c:1646 */ break; case 47: - /* Line 1787 of yacc.c */ -#line 180 "promela.ypp" +#line 180 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_DECLLIST, 1, (yyvsp[(1) - (3)].node)); - if((yyvsp[(3) - (3)].node)->type == PML_DECLLIST) { - (yyval.node)->merge((yyvsp[(3) - (3)].node)); - delete (yyvsp[(3) - (3)].node); + (yyval.node) = ctx->node(PML_DECLLIST, 1, (yyvsp[-2].node)); + if((yyvsp[0].node)->type == PML_DECLLIST) { + (yyval.node)->merge((yyvsp[0].node)); + delete (yyvsp[0].node); } else { - (yyval.node)->push((yyvsp[(3) - (3)].node)); + (yyval.node)->push((yyvsp[0].node)); } } +#line 1876 "promela.tab.cpp" /* yacc.c:1646 */ break; case 48: - /* Line 1787 of yacc.c */ -#line 190 "promela.ypp" +#line 190 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_VARLIST, 1, (yyvsp[(1) - (1)].node)); + (yyval.node) = ctx->node(PML_VARLIST, 1, (yyvsp[0].node)); } +#line 1882 "promela.tab.cpp" /* yacc.c:1646 */ break; case 49: - /* Line 1787 of yacc.c */ -#line 191 "promela.ypp" +#line 191 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_VARLIST, 1, (yyvsp[(1) - (3)].node)); - (yyval.node)->merge((yyvsp[(3) - (3)].node)); - delete (yyvsp[(3) - (3)].node); + (yyval.node) = ctx->node(PML_VARLIST, 1, (yyvsp[-2].node)); + (yyval.node)->merge((yyvsp[0].node)); + delete (yyvsp[0].node); } +#line 1888 "promela.tab.cpp" /* yacc.c:1646 */ break; case 50: - /* Line 1787 of yacc.c */ -#line 194 "promela.ypp" +#line 194 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1894 "promela.tab.cpp" /* yacc.c:1646 */ break; case 51: - /* Line 1787 of yacc.c */ -#line 195 "promela.ypp" +#line 195 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_ASGN, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_ASGN, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1900 "promela.tab.cpp" /* yacc.c:1646 */ break; case 52: - /* Line 1787 of yacc.c */ -#line 198 "promela.ypp" +#line 198 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->value(PML_NAME, (void*)&((yylsp[(1) - (1)])), (yyvsp[(1) - (1)].value)); - free((yyvsp[(1) - (1)].value)); + (yyval.node) = ctx->value(PML_NAME, (void*)&((yylsp[0])), (yyvsp[0].value)); + free((yyvsp[0].value)); } +#line 1906 "promela.tab.cpp" /* yacc.c:1646 */ break; case 53: - /* Line 1787 of yacc.c */ -#line 199 "promela.ypp" +#line 199 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_COLON, 2, ctx->value(PML_NAME, (void*)&((yylsp[(1) - (3)])), (yyvsp[(1) - (3)].value)), ctx->value(PML_CONST, (void*)&((yylsp[(3) - (3)])), (yyvsp[(3) - (3)].value))); - free((yyvsp[(1) - (3)].value)); - free((yyvsp[(3) - (3)].value)); + (yyval.node) = ctx->node(PML_COLON, 2, ctx->value(PML_NAME, (void*)&((yylsp[-2])), (yyvsp[-2].value)), ctx->value(PML_CONST, (void*)&((yylsp[0])), (yyvsp[0].value))); + free((yyvsp[-2].value)); + free((yyvsp[0].value)); } +#line 1912 "promela.tab.cpp" /* yacc.c:1646 */ break; case 54: - /* Line 1787 of yacc.c */ -#line 200 "promela.ypp" +#line 200 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_VAR_ARRAY, 2, ctx->value(PML_NAME, (void*)&((yylsp[(1) - (4)])), (yyvsp[(1) - (4)].value)), (yyvsp[(3) - (4)].node)); - free((yyvsp[(1) - (4)].value)); + (yyval.node) = ctx->node(PML_VAR_ARRAY, 2, ctx->value(PML_NAME, (void*)&((yylsp[-3])), (yyvsp[-3].value)), (yyvsp[-1].node)); + free((yyvsp[-3].value)); } +#line 1918 "promela.tab.cpp" /* yacc.c:1646 */ break; case 55: - /* Line 1787 of yacc.c */ -#line 203 "promela.ypp" +#line 203 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->value(PML_CONST, (void*)&((yylsp[(1) - (1)])), (yyvsp[(1) - (1)].value)); - free((yyvsp[(1) - (1)].value)); + (yyval.node) = ctx->value(PML_CONST, (void*)&((yylsp[0])), (yyvsp[0].value)); + free((yyvsp[0].value)); } +#line 1924 "promela.tab.cpp" /* yacc.c:1646 */ break; case 56: - /* Line 1787 of yacc.c */ -#line 204 "promela.ypp" +#line 204 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_MINUS, 1, (yyvsp[(2) - (2)].node)); + (yyval.node) = ctx->node(PML_MINUS, 1, (yyvsp[0].node)); } +#line 1930 "promela.tab.cpp" /* yacc.c:1646 */ break; case 57: - /* Line 1787 of yacc.c */ -#line 205 "promela.ypp" +#line 205 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(2) - (3)].node); + (yyval.node) = (yyvsp[-1].node); } +#line 1936 "promela.tab.cpp" /* yacc.c:1646 */ break; case 58: - /* Line 1787 of yacc.c */ -#line 206 "promela.ypp" +#line 206 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_PLUS, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_PLUS, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1942 "promela.tab.cpp" /* yacc.c:1646 */ break; case 59: - /* Line 1787 of yacc.c */ -#line 207 "promela.ypp" +#line 207 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_MINUS, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_MINUS, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1948 "promela.tab.cpp" /* yacc.c:1646 */ break; case 60: - /* Line 1787 of yacc.c */ -#line 208 "promela.ypp" +#line 208 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_TIMES, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_TIMES, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1954 "promela.tab.cpp" /* yacc.c:1646 */ break; case 61: - /* Line 1787 of yacc.c */ -#line 209 "promela.ypp" +#line 209 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_DIVIDE, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_DIVIDE, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1960 "promela.tab.cpp" /* yacc.c:1646 */ break; case 62: - /* Line 1787 of yacc.c */ -#line 210 "promela.ypp" +#line 210 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_MODULO, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_MODULO, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 1966 "promela.tab.cpp" /* yacc.c:1646 */ break; case 63: - /* Line 1787 of yacc.c */ -#line 213 "promela.ypp" +#line 213 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->value(PML_NAME, (void*)&((yylsp[(1) - (1)])), (yyvsp[(1) - (1)].value)); - free((yyvsp[(1) - (1)].value)); + (yyval.node) = ctx->value(PML_NAME, (void*)&((yylsp[0])), (yyvsp[0].value)); + free((yyvsp[0].value)); } +#line 1972 "promela.tab.cpp" /* yacc.c:1646 */ break; case 64: - /* Line 1787 of yacc.c */ -#line 214 "promela.ypp" +#line 214 "promela.ypp" /* yacc.c:1646 */ { - if ((yyvsp[(1) - (2)].node)->type == PML_NAME) { - (yyval.node) = ctx->node(PML_NAMELIST, 1, (yyvsp[(1) - (2)].node)); - (yyval.node)->push(ctx->value(PML_NAME, (void*)&((yylsp[(2) - (2)])), (yyvsp[(2) - (2)].value))); + if ((yyvsp[-1].node)->type == PML_NAME) { + (yyval.node) = ctx->node(PML_NAMELIST, 1, (yyvsp[-1].node)); + (yyval.node)->push(ctx->value(PML_NAME, (void*)&((yylsp[0])), (yyvsp[0].value))); } else { - (yyvsp[(1) - (2)].node)->push(ctx->value(PML_NAME, (void*)&((yylsp[(2) - (2)])), (yyvsp[(2) - (2)].value))); + (yyvsp[-1].node)->push(ctx->value(PML_NAME, (void*)&((yylsp[0])), (yyvsp[0].value))); } - free((yyvsp[(2) - (2)].value)); + free((yyvsp[0].value)); } +#line 1986 "promela.tab.cpp" /* yacc.c:1646 */ break; case 65: - /* Line 1787 of yacc.c */ -#line 223 "promela.ypp" +#line 223 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[-1].node); } +#line 1992 "promela.tab.cpp" /* yacc.c:1646 */ break; case 66: - /* Line 1787 of yacc.c */ -#line 226 "promela.ypp" +#line 226 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 1998 "promela.tab.cpp" /* yacc.c:1646 */ break; case 67: - /* Line 1787 of yacc.c */ -#line 227 "promela.ypp" +#line 227 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[-1].node); } +#line 2004 "promela.tab.cpp" /* yacc.c:1646 */ break; case 68: - /* Line 1787 of yacc.c */ -#line 228 "promela.ypp" +#line 228 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_STMNT, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_STMNT, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 2010 "promela.tab.cpp" /* yacc.c:1646 */ break; case 69: - /* Line 1787 of yacc.c */ -#line 231 "promela.ypp" +#line 231 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 2016 "promela.tab.cpp" /* yacc.c:1646 */ break; case 70: - /* Line 1787 of yacc.c */ -#line 234 "promela.ypp" +#line 234 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_ASGN, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(PML_ASGN, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 2022 "promela.tab.cpp" /* yacc.c:1646 */ break; case 71: - /* Line 1787 of yacc.c */ -#line 235 "promela.ypp" +#line 235 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_INCR, 1, (yyvsp[(1) - (2)].node)); + (yyval.node) = ctx->node(PML_INCR, 1, (yyvsp[-1].node)); } +#line 2028 "promela.tab.cpp" /* yacc.c:1646 */ break; case 72: - /* Line 1787 of yacc.c */ -#line 236 "promela.ypp" +#line 236 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_DECR, 1, (yyvsp[(1) - (2)].node)); + (yyval.node) = ctx->node(PML_DECR, 1, (yyvsp[-1].node)); } +#line 2034 "promela.tab.cpp" /* yacc.c:1646 */ break; case 73: - /* Line 1787 of yacc.c */ -#line 237 "promela.ypp" +#line 237 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_PRINT, 2, ctx->value(PML_STRING, (void*)&((yylsp[(3) - (5)])), (yyvsp[(3) - (5)].value)), (yyvsp[(4) - (5)].node)); - free((yyvsp[(3) - (5)].value)); + (yyval.node) = ctx->node(PML_PRINT, 2, ctx->value(PML_STRING, (void*)&((yylsp[-2])), (yyvsp[-2].value)), (yyvsp[-1].node)); + free((yyvsp[-2].value)); } +#line 2040 "promela.tab.cpp" /* yacc.c:1646 */ break; case 74: - /* Line 1787 of yacc.c */ -#line 238 "promela.ypp" +#line 238 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_PRINT, 1, (yyvsp[(3) - (4)].node)); + (yyval.node) = ctx->node(PML_PRINT, 1, (yyvsp[-1].node)); } +#line 2046 "promela.tab.cpp" /* yacc.c:1646 */ break; case 75: - /* Line 1787 of yacc.c */ -#line 239 "promela.ypp" +#line 239 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_PRINT, 1, ctx->value(PML_CONST, (void*)&((yylsp[(3) - (4)])), (yyvsp[(3) - (4)].value))); - free((yyvsp[(3) - (4)].value)); + (yyval.node) = ctx->node(PML_PRINT, 1, ctx->value(PML_CONST, (void*)&((yylsp[-1])), (yyvsp[-1].value))); + free((yyvsp[-1].value)); } +#line 2052 "promela.tab.cpp" /* yacc.c:1646 */ break; case 76: - /* Line 1787 of yacc.c */ -#line 240 "promela.ypp" +#line 240 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(PML_ASSERT, 1, (yyvsp[(2) - (2)].node)); + (yyval.node) = ctx->node(PML_ASSERT, 1, (yyvsp[0].node)); } +#line 2058 "promela.tab.cpp" /* yacc.c:1646 */ break; case 77: - /* Line 1787 of yacc.c */ -#line 241 "promela.ypp" +#line 241 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 2064 "promela.tab.cpp" /* yacc.c:1646 */ break; case 78: - /* Line 1787 of yacc.c */ -#line 244 "promela.ypp" +#line 244 "promela.ypp" /* yacc.c:1646 */ { (yyval.node) = ctx->value(0, NULL, ""); } +#line 2070 "promela.tab.cpp" /* yacc.c:1646 */ break; case 79: - /* Line 1787 of yacc.c */ -#line 245 "promela.ypp" +#line 245 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(2) - (2)].node); + (yyval.node) = (yyvsp[0].node); } +#line 2076 "promela.tab.cpp" /* yacc.c:1646 */ break; case 80: - /* Line 1787 of yacc.c */ -#line 248 "promela.ypp" +#line 248 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = (yyvsp[(1) - (1)].node); + (yyval.node) = (yyvsp[0].node); } +#line 2082 "promela.tab.cpp" /* yacc.c:1646 */ break; case 81: - /* Line 1787 of yacc.c */ -#line 249 "promela.ypp" +#line 249 "promela.ypp" /* yacc.c:1646 */ { - (yyval.node) = ctx->node(0, 2, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + (yyval.node) = ctx->node(0, 2, (yyvsp[-2].node), (yyvsp[0].node)); } +#line 2088 "promela.tab.cpp" /* yacc.c:1646 */ break; - /* Line 1787 of yacc.c */ -#line 2285 "promela.tab.cpp" +#line 2092 "promela.tab.cpp" /* yacc.c:1646 */ default: break; } @@ -2427,7 +2226,7 @@ yyreduce: *++yyvsp = yyval; *++yylsp = yyloc; - /* Now `shift' the result of the reduction. Determine what state + /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ @@ -2442,9 +2241,9 @@ yyreduce: goto yynewstate; - /*------------------------------------. - | yyerrlab -- here on detecting error | - `------------------------------------*/ + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ yyerrlab: /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ @@ -2489,7 +2288,7 @@ yyerrlab: if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an - error, discard it. */ + error, discard it. */ if (yychar <= YYEOF) { /* Return failure if at end of input. */ @@ -2519,7 +2318,7 @@ yyerrorlab: goto yyerrorlab; yyerror_range[1] = yylsp[1-yylen]; - /* Do not reclaim the symbols of the rule which action triggered + /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ YYPOPSTACK (yylen); yylen = 0; @@ -2532,7 +2331,7 @@ yyerrorlab: | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ + yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact[yystate]; @@ -2606,7 +2405,7 @@ yyreturn: yydestruct ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc, ctx, scanner); } - /* Do not reclaim the symbols of the rule which action triggered + /* Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); YY_STACK_PRINT (yyss, yyssp); @@ -2623,12 +2422,8 @@ yyreturn: if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif - /* Make sure YYID is used. */ - return YYID (yyresult); + return yyresult; } - - -/* Line 2050 of yacc.c */ -#line 253 "promela.ypp" +#line 253 "promela.ypp" /* yacc.c:1906 */ diff --git a/src/uscxml/plugins/datamodel/promela/parser/promela.tab.hpp b/src/uscxml/plugins/datamodel/promela/parser/promela.tab.hpp index a48031a..c609868 100644 --- a/src/uscxml/plugins/datamodel/promela/parser/promela.tab.hpp +++ b/src/uscxml/plugins/datamodel/promela/parser/promela.tab.hpp @@ -1,19 +1,19 @@ -/* A Bison parser, made by GNU Bison 2.7.12-4996. */ +/* A Bison parser, made by GNU Bison 3.0.4. */ /* Bison interface for Yacc-like parsers in C - - Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc. - + + Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program. If not, see . */ @@ -26,16 +26,16 @@ special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. - + This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ #ifndef YY_PROMELA_PROMELA_TAB_HPP_INCLUDED # define YY_PROMELA_PROMELA_TAB_HPP_INCLUDED -/* Enabling traces. */ +/* Debug traces. */ #ifndef PROMELA_DEBUG # if defined YYDEBUG -# if YYDEBUG +#if YYDEBUG # define PROMELA_DEBUG 1 # else # define PROMELA_DEBUG 0 @@ -48,133 +48,122 @@ extern int promela_debug; #endif -/* Tokens. */ +/* Token type. */ #ifndef PROMELA_TOKENTYPE # define PROMELA_TOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum promela_tokentype { - PML_VAR_ARRAY = 258, - PML_VARLIST = 259, - PML_DECL = 260, - PML_DECLLIST = 261, - PML_STMNT = 262, - PML_COLON = 263, - PML_EXPR = 264, - PML_NAMELIST = 265, - PML_ASSERT = 266, - PML_PRINT = 267, - PML_PRINTM = 268, - PML_LEN = 269, - PML_STRING = 270, - PML_TYPEDEF = 271, - PML_MTYPE = 272, - PML_INLINE = 273, - PML_RETURN = 274, - PML_LABEL = 275, - PML_OF = 276, - PML_GOTO = 277, - PML_BREAK = 278, - PML_ELSE = 279, - PML_SEMI = 280, - PML_ARROW = 281, - PML_IF = 282, - PML_FI = 283, - PML_DO = 284, - PML_OD = 285, - PML_FOR = 286, - PML_SELECT = 287, - PML_IN = 288, - PML_SEP = 289, - PML_DOTDOT = 290, - PML_HIDDEN = 291, - PML_SHOW = 292, - PML_ISLOCAL = 293, - PML_CONST = 294, - PML_TYPE = 295, - PML_XU = 296, - PML_NAME = 297, - PML_UNAME = 298, - PML_PNAME = 299, - PML_INAME = 300, - PML_CLAIM = 301, - PML_TRACE = 302, - PML_INIT = 303, - PML_LTL = 304, - PML_COMMA = 305, - PML_ASGN = 306, - PML_AND = 307, - PML_OR = 308, - PML_BITAND = 309, - PML_BITXOR = 310, - PML_BITOR = 311, - PML_NE = 312, - PML_EQ = 313, - PML_LE = 314, - PML_GE = 315, - PML_LT = 316, - PML_GT = 317, - PML_RSHIFT = 318, - PML_LSHIFT = 319, - PML_MINUS = 320, - PML_PLUS = 321, - PML_MODULO = 322, - PML_DIVIDE = 323, - PML_TIMES = 324, - PML_DECR = 325, - PML_INCR = 326, - PML_COMPL = 327, - PML_NEG = 328, - PML_CMPND = 329, - PML_DOT = 330 - }; + enum promela_tokentype + { + PML_VAR_ARRAY = 258, + PML_VARLIST = 259, + PML_DECL = 260, + PML_DECLLIST = 261, + PML_STMNT = 262, + PML_COLON = 263, + PML_EXPR = 264, + PML_NAMELIST = 265, + PML_ASSERT = 266, + PML_PRINT = 267, + PML_PRINTM = 268, + PML_LEN = 269, + PML_STRING = 270, + PML_TYPEDEF = 271, + PML_MTYPE = 272, + PML_INLINE = 273, + PML_RETURN = 274, + PML_LABEL = 275, + PML_OF = 276, + PML_GOTO = 277, + PML_BREAK = 278, + PML_ELSE = 279, + PML_SEMI = 280, + PML_ARROW = 281, + PML_IF = 282, + PML_FI = 283, + PML_DO = 284, + PML_OD = 285, + PML_FOR = 286, + PML_SELECT = 287, + PML_IN = 288, + PML_SEP = 289, + PML_DOTDOT = 290, + PML_HIDDEN = 291, + PML_SHOW = 292, + PML_ISLOCAL = 293, + PML_CONST = 294, + PML_TYPE = 295, + PML_XU = 296, + PML_NAME = 297, + PML_UNAME = 298, + PML_PNAME = 299, + PML_INAME = 300, + PML_CLAIM = 301, + PML_TRACE = 302, + PML_INIT = 303, + PML_LTL = 304, + PML_COMMA = 305, + PML_UNREC = 306, + PML_ASGN = 307, + PML_OR = 308, + PML_AND = 309, + PML_BITOR = 310, + PML_BITXOR = 311, + PML_BITAND = 312, + PML_EQ = 313, + PML_NE = 314, + PML_GT = 315, + PML_LT = 316, + PML_GE = 317, + PML_LE = 318, + PML_LSHIFT = 319, + PML_RSHIFT = 320, + PML_PLUS = 321, + PML_MINUS = 322, + PML_TIMES = 323, + PML_DIVIDE = 324, + PML_MODULO = 325, + PML_INCR = 326, + PML_DECR = 327, + PML_COMPL = 328, + PML_NEG = 329, + PML_DOT = 330, + PML_CMPND = 331 + }; #endif - +/* Value type. */ #if ! defined PROMELA_STYPE && ! defined PROMELA_STYPE_IS_DECLARED -typedef union PROMELA_STYPE + +union PROMELA_STYPE { -/* Line 2053 of yacc.c */ -#line 39 "promela.ypp" +#line 39 "promela.ypp" /* yacc.c:1909 */ uscxml::PromelaParserNode* node; char* value; +#line 144 "promela.tab.hpp" /* yacc.c:1909 */ +}; -/* Line 2053 of yacc.c */ -#line 146 "promela.tab.hpp" -} PROMELA_STYPE; +typedef union PROMELA_STYPE PROMELA_STYPE; # define PROMELA_STYPE_IS_TRIVIAL 1 -# define promela_stype PROMELA_STYPE /* obsolescent; will be withdrawn */ # define PROMELA_STYPE_IS_DECLARED 1 #endif +/* Location type. */ #if ! defined PROMELA_LTYPE && ! defined PROMELA_LTYPE_IS_DECLARED -typedef struct PROMELA_LTYPE +typedef struct PROMELA_LTYPE PROMELA_LTYPE; +struct PROMELA_LTYPE { int first_line; int first_column; int last_line; int last_column; -} PROMELA_LTYPE; -# define promela_ltype PROMELA_LTYPE /* obsolescent; will be withdrawn */ +}; # define PROMELA_LTYPE_IS_DECLARED 1 # define PROMELA_LTYPE_IS_TRIVIAL 1 #endif -#ifdef YYPARSE_PARAM -#if defined __STDC__ || defined __cplusplus -int promela_parse (void *YYPARSE_PARAM); -#else -int promela_parse (); -#endif -#else /* ! YYPARSE_PARAM */ -#if defined __STDC__ || defined __cplusplus + int promela_parse (uscxml::PromelaParser* ctx, void * scanner); -#else -int promela_parse (); -#endif -#endif /* ! YYPARSE_PARAM */ #endif /* !YY_PROMELA_PROMELA_TAB_HPP_INCLUDED */ diff --git a/src/uscxml/plugins/datamodel/promela/parser/promela.ypp b/src/uscxml/plugins/datamodel/promela/parser/promela.ypp index d76b24a..f26eb46 100644 --- a/src/uscxml/plugins/datamodel/promela/parser/promela.ypp +++ b/src/uscxml/plugins/datamodel/promela/parser/promela.ypp @@ -61,7 +61,7 @@ using namespace uscxml; %token PML_CONST PML_TYPE PML_XU /* val */ %token PML_NAME PML_UNAME PML_PNAME PML_INAME /* sym */ %token PML_CLAIM PML_TRACE PML_INIT PML_LTL /* sym */ -%token PML_COMMA +%token PML_COMMA PML_UNREC %right PML_ASGN %left PML_OR PML_AND @@ -86,14 +86,14 @@ program : ctx->ast = $1; ctx->type = PromelaParser::PROMELA_DECL; } - | expr { - ctx->ast = $1; - ctx->type = PromelaParser::PROMELA_EXPR; - } | stmnt_lst { ctx->ast = $1; ctx->type = PromelaParser::PROMELA_STMNT; } + | expr { + ctx->ast = $1; + ctx->type = PromelaParser::PROMELA_EXPR; + } ; varref : cmpnd { $$ = $1; } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 89962f9..614c85c 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -72,6 +72,7 @@ endif() if (NOT BUILD_AS_PLUGINS) USCXML_TEST_COMPILE( + BUILD_ONLY NAME test-serialization LABEL general/test-serialization FILES src/test-serialization.cpp ../contrib/src/uscxml/PausableDelayedEventQueue.cpp @@ -171,7 +172,7 @@ else() if (${WITH_DM_ECMA_V8}) list (APPEND TEST_GEN_C_DEFINITIONS "WITH_DM_ECMA_V8") - list (APPEND TEST_GEN_C_FILES ${PROJECT_SOURCE_DIR}/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp) + list (APPEND TEST_GEN_C_FILES ${PROJECT_SOURCE_DIR}/src/uscxml/plugins/datamodel/ecmascript/v8/${V8_VERSION}/V8DataModel.cpp) list (APPEND TEST_GEN_C_LIBRARIES ${V8_LIBRARY}) endif() if (${WITH_DM_ECMA_JSC}) diff --git a/test/ctest/CTestCustom.ctest.in b/test/ctest/CTestCustom.ctest.in index d6a5884..0dca21e 100644 --- a/test/ctest/CTestCustom.ctest.in +++ b/test/ctest/CTestCustom.ctest.in @@ -34,7 +34,11 @@ set(CTEST_CUSTOM_TESTS_IGNORE "w3c/ecma/test301.scxml" # Invalid script URL - PASSED "w3c/ecma/test436.scxml" # Tests NULL datamodel - PASSED + "w3c/namespace/test178.scxml" # Manual - PASSED + "w3c/namespace/test230.scxml" # Manual - PASSED + "w3c/namespace/test250.scxml" # Manual - PASSED "w3c/namespace/test301.scxml" # Invalid script URL - PASSED + "w3c/namespace/test415.scxml" # Manual - PASSED ### Just ignore the XPath datamodel tests that hang, most of the rest fails as well @@ -81,17 +85,21 @@ set(CTEST_CUSTOM_TESTS_IGNORE "w3c/promela/test178.scxml" # two identical params in _event.raw - FAILED "w3c/promela/test230.scxml" # autoforwarded events are identical - PASSED "w3c/promela/test250.scxml" # no onexit in cancelled invoker - PASSED + "w3c/promela/test302.scxml" # variable definition / declaration in script - NOT SUPPORTED + "w3c/promela/test304.scxml" # variable definition / declaration in script - NOT SUPPORTED "w3c/promela/test307.scxml" # late data-binding - PASSED "w3c/promela/test313.scxml" # Manual - PASSED - "w3c/promela/test314.scxml" # Manual - PASSED + "w3c/promela/test314.scxml" # Manual - PASSED + "w3c/promela/test350.scxml" # String concatenation - NOT SUPPORTED "w3c/promela/test415.scxml" # terminate on toplevel final - PASSED + "w3c/promela/test525.scxml" # shallow copy in foreach, test not expressible as such # "w3c/promela/test513.txt" # manual test - PASSED "w3c/promela/test301.scxml" # reject invalid script - PASSED "w3c/promela/test436.scxml" # Tests NULL datamodel - PASSED - # "w3c/promela/test190.scxml" # string concatenation + "w3c/promela/test190.scxml" # string concatenation "w3c/promela/test224.scxml" # string operation startWith # "w3c/promela/test280.scxml" # no runtime checks for undeclared variables # "w3c/promela/test350.scxml" # string concatenation diff --git a/test/src/test-gen-c.cpp b/test/src/test-gen-c.cpp index 0f83da3..4d5514d 100644 --- a/test/src/test-gen-c.cpp +++ b/test/src/test-gen-c.cpp @@ -21,25 +21,25 @@ #ifndef AUTOINCLUDE_TEST #include "test-c-machine.scxml.c" -//#include "/Users/sradomski/Documents/TK/Code/uscxml/build/cli/test/gen/c/lua/test192.scxml.machine.c" +//#include "/Users/sradomski/Documents/TK/Code/uscxml/build/cli-debug/test/gen/c/ecma/test-enc-ISO-8859-1.scxml.machine.c" #endif -//#include "uscxml/util/URL.h" -//#include "uscxml/concurrency/Timer.h" -//#include "uscxml/dom/DOMUtils.h" #include "uscxml/plugins/Factory.h" #include "uscxml/plugins/IOProcessorImpl.h" #include "uscxml/plugins/InvokerImpl.h" -//#include "uscxml/Interpreter.h" #include "uscxml/util/UUID.h" -//#include "uscxml/server/HTTPServer.h" //#include "uscxml/plugins/invoker/dirmon/DirMonInvoker.h" #include "uscxml/plugins/datamodel/promela/PromelaDataModel.h" #ifdef FEATS_ON_CMD #ifdef WITH_DM_ECMA_V8 -#include "uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h" +# if (V8_VERSION == 032317) +# include "uscxml/plugins/datamodel/ecmascript/v8/032317/V8DataModel.h" +# endif +# if (V8_VERSION == 031405) +# include "uscxml/plugins/datamodel/ecmascript/v8/031405/V8DataModel.h" +# endif #endif #ifdef WITH_DM_ECMA_JSC #include "uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.h" diff --git a/test/src/test-http-debugger.pl b/test/src/test-http-debugger.pl index fcc675f..4a28a52 100755 --- a/test/src/test-http-debugger.pl +++ b/test/src/test-http-debugger.pl @@ -9,10 +9,11 @@ use JSON qw(from_json to_json); use LWP; use HTTP::Request::Common qw(POST GET); use Data::Dumper; +use Term::ANSIColor 4.00 qw(RESET :constants); -my $scxmlBin = abs_path(shift); +my $scxmlBin = shift; die ("First argument needs to be path to uscxml-browser binary") if (!$scxmlBin); -die("'" . $scxmlBin . "' is not an executable file") if (! -x $scxmlBin); +die("'" . $scxmlBin . "' is not an executable file") if (! -x $scxmlBin || ! -f $scxmlBin); my $baseDir = File::Spec->canonpath(dirname($0)); chdir $baseDir; @@ -25,44 +26,103 @@ my @breakpointSeq; my $pid = fork; +# child process to run the interpreter if (!$pid) { - exec("$scxmlBin -t4088 -d"); + open STDOUT, ">", "/dev/null" or die "$0: open: $!"; + open STDERR, ">&", \*STDOUT or exit 1; + exec("$scxmlBin -t4088 -d test-http-debugger.scxml"); exit; } my $baseURL = 'http://localhost:4088/debug'; # my $baseURL = 'http://localhost:5080/debug'; +sleep(1); + +sub dumpRequest { + # http://search.cpan.org/~oalders/HTTP-Message-6.13/lib/HTTP/Request.pm + my $request = shift; + return + "\tURI: " . $request->uri() . "\n" . + "\tCONTENT: " . $request->content() . "\n"; +} + +sub dumpResponse { + # http://search.cpan.org/~oalders/HTTP-Message-6.13/lib/HTTP/Response.pm + my $response = shift; + return + "\tCONTENT: " . $response->content() . "\n"; +} sub assertSuccess { my $response = shift; my $message = shift; - print "-----\n"; - print $response->content(); - print "-----\n"; from_json($response->content())->{'status'} eq "success" or die($message); } -sub prepareSession { - my $xml = shift; +sub attachSession { + my $docName = shift; + + $request = POST $baseURL.'/instances'; + print FAINT RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print FAINT CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not get running sessions"); + + my $attach = ""; + my $sessions = from_json($response->content())->{'instances'}; + foreach my $instance (@{$sessions}) { + if ($instance->{'name'} eq $docName) { + $attach = $instance->{'id'}; + last; + } + } + $attach or die("Could not attach to instance named $docName\n"); ### Get a session my $request = GET $baseURL.'/connect'; + print FAINT RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print FAINT CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not connect"); my $session = from_json($response->content())->{'session'}; die("Cannot acquire session from server") if (!$session); - ### Prepare an SCXML interpreter - $request = POST $baseURL.'/prepare', + $request = POST $baseURL.'/attach', [ + 'attach' => $attach, 'session' => $session, - 'url' => 'http://localhost/anonymous.scxml', - 'xml' => $xml ]; + print FAINT RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print FAINT CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not get attach to session"); + print BOLD BLACK . "Session attached!" . RESET . "\n\n"; + return $session; +} + +sub prepareSession { + my $source = shift; + + ### Get a session + my $request = GET $baseURL.'/connect'; + print FAINT RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print FAINT CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not connect"); + + my $session = from_json($response->content())->{'session'}; + die("Cannot acquire session from server") if (!$session); + + $source->{'session'} = $session; + + ### Prepare an SCXML interpreter + $request = POST $baseURL.'/prepare', $source; + print FAINT RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print FAINT CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not prepare SCXML"); - + print BOLD BLACK . "Session prepared!" . RESET . "\n\n"; return $session; } @@ -74,8 +134,11 @@ sub finishSession { [ 'session' => $session, ]; + print FAINT RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print FAINT CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not disconnect session"); + print BOLD BLACK . "Session terminated!" . RESET . "\n\n"; } sub popAndCompare { @@ -88,11 +151,15 @@ sub popAndCompare { die("Expected different breakpoint"); } } - print "SUCCESS\n"; + print BOLD BLACK . "OK!" . RESET . "\n\n"; } sub testSimpleStepping { + print BOLD WHITE ON_RED . " " . RESET ."\n"; + print BOLD WHITE ON_RED . " testSimpleStepping " . RESET ."\n"; + print BOLD WHITE ON_RED . " " . RESET ."\n\n"; + my $xml = << 'END_SCXML'; @@ -111,10 +178,10 @@ END_SCXML @breakpointSeq = ( { subject => "microstep", when => "before" }, { subject => "state", when => "before", action => "enter" }, - { subject => "state", when => "after", action => "enter" }, + { subject => "state", when => "after", action => "enter" }, { subject => "state", when => "before", action => "enter", stateId => "s1" }, { subject => "executable", when => "before", execName => "log" }, - { subject => "executable", when => "after", execName => "log" }, + { subject => "executable", when => "after", execName => "log" }, { subject => "state", when => "after", action => "enter", stateId => "s1" }, { subject => "microstep", when => "after" }, { subject => "microstep", when => "before" }, @@ -136,18 +203,24 @@ END_SCXML ); - my $session = &prepareSession($xml); + my $session = &prepareSession({'xml' => $xml}); + print BOLD . "Testing sequence of breakpoints being raised via step". RESET . "\n"; + while(@breakpointSeq > 0) { ### Take a step $request = POST $baseURL.'/step', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not step"); # this will cause the interpreter to pause execution ### Get the pending messages $request = POST $baseURL.'/poll', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not get breakpoint after step"); # compare to what we expect @@ -157,12 +230,16 @@ END_SCXML ### last step will finalize the interpreter $request = POST $baseURL.'/step', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not get breakpoint after step"); ### get the pending server push reply $request = POST $baseURL.'/poll', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not get breakpoint after step"); $data = from_json($response->content()); @@ -172,6 +249,11 @@ END_SCXML } sub testBreakpoint { + + print BOLD WHITE ON_RED . " " . RESET ."\n"; + print BOLD WHITE ON_RED . " testBreakpoint " . RESET ."\n"; + print BOLD WHITE ON_RED . " " . RESET ."\n\n"; + my $xml = << 'END_SCXML'; @@ -187,10 +269,11 @@ sub testBreakpoint { END_SCXML - my $session = prepareSession($xml); + my $session = &prepareSession({'xml' => $xml}); - ### Skip to breakpoint - $request = POST $baseURL.'/breakpoint/skipto', + print BOLD . "Adding a dedicated breakpoint". RESET . "\n"; + + $request = POST $baseURL.'/breakpoint/add', [ 'session' => $session, 'when' => 'after', @@ -198,12 +281,46 @@ END_SCXML 'subject' => 'state', 'stateId' => 's1' ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not add breakpoint"); - - ### get the pending server push reply + + print BOLD . "Starting interpretation (will run into breakpoint)". RESET . "\n"; + + $request = POST $baseURL.'/start', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not add breakpoint"); + + print BOLD . "Polling asynchronously for breakpoint hit by interpreter". RESET . "\n"; + + $request = POST $baseURL.'/poll', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not poll for breakpoint"); + + print BOLD . "Skipping to implicit breakpoint". RESET . "\n"; + $request = POST $baseURL.'/breakpoint/skipto', + [ + 'session' => $session, + 'when' => 'before', + 'action' => 'enter', + 'subject' => 'state', + 'stateId' => 's2' + ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not add breakpoint"); + + print BOLD . "Polling asynchronously for breakpoint hit by interpreter". RESET . "\n"; $request = POST $baseURL.'/poll', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not get breakpoint after step"); $data = from_json($response->content()); @@ -213,6 +330,11 @@ END_SCXML } sub testIssueReporting { + + print BOLD WHITE ON_RED . " " . RESET ."\n"; + print BOLD WHITE ON_RED . " testIssueReporting " . RESET ."\n"; + print BOLD WHITE ON_RED . " " . RESET ."\n\n"; + my $xml = << 'END_SCXML'; @@ -233,14 +355,18 @@ sub testIssueReporting { END_SCXML - my $session = prepareSession($xml); + my $session = prepareSession({'xml' => $xml}); + print BOLD . "Getting a list of issues with the document". RESET . "\n"; + ### Get a list of issues $request = POST $baseURL.'/issues', [ 'session' => $session ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; assertSuccess($response, "Could not get issues for prepared SCXML document"); $data = from_json($response->content()); @@ -250,8 +376,135 @@ END_SCXML } +sub testDataModelInspection { + + print BOLD WHITE ON_RED . " " . RESET ."\n"; + print BOLD WHITE ON_RED . " testDataModelInspection " . RESET ."\n"; + print BOLD WHITE ON_RED . " " . RESET ."\n\n"; + + my $session = prepareSession({'url' => 'https://raw.githubusercontent.com/tklab-tud/uscxml/master/test/w3c/ecma/test144.scxml'}); + + print BOLD . "Skipping to first transition". RESET . "\n"; + $request = POST $baseURL.'/breakpoint/skipto', + [ + 'session' => $session, + 'when' => 'before', + 'subject' => 'transition', + 'target' => 's1' + ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not add breakpoint"); + + print BOLD . "Polling asynchronously for breakpoint hit by interpreter". RESET . "\n"; + $request = POST $baseURL.'/poll', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not get breakpoint after step"); + + + print BOLD . "Evaluating expression '_event' on the datamodel". RESET . "\n"; + $request = POST $baseURL.'/eval', + [ + 'session' => $session, + 'expression' => '_event', + ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not evaluate expression"); + + print BOLD . "Evaluating expression '_ioprocessors' on the datamodel". RESET . "\n"; + $request = POST $baseURL.'/eval', + [ + 'session' => $session, + 'expression' => '_ioprocessors', + ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not evaluate expression"); + + + &finishSession($session); + +} + +sub testSessionAttaching { + + print BOLD WHITE ON_RED . " " . RESET ."\n"; + print BOLD WHITE ON_RED . " testSessionAttaching " . RESET ."\n"; + print BOLD WHITE ON_RED . " " . RESET ."\n\n"; + + my $session = attachSession("test-http-debugger.scxml"); + + print BOLD . "Skipping to first transition". RESET . "\n"; + $request = POST $baseURL.'/breakpoint/skipto', + [ + 'session' => $session, + 'when' => 'before', + 'subject' => 'transition', + 'target' => 's1' + ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not add breakpoint"); + + print BOLD . "Polling asynchronously for breakpoint hit by interpreter". RESET . "\n"; + $request = POST $baseURL.'/poll', ['session' => $session]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not get breakpoint after step"); + + &finishSession($session); + +} + +sub testEventInsertion { + + print BOLD WHITE ON_RED . " " . RESET ."\n"; + print BOLD WHITE ON_RED . " testEventInsertion " . RESET ."\n"; + print BOLD WHITE ON_RED . " " . RESET ."\n\n"; + + my $xml = << 'END_SCXML'; + + + + + + + + + +END_SCXML + + my $session = prepareSession({'xml' => $xml}); + + print BOLD . "Sending event" . RESET . "\n"; + $request = POST $baseURL.'/event', + [ + 'session' => $session, + 'name' => 'foo', + ]; + print RED . "-> SEND === line:" . __LINE__ . "\n" . dumpRequest($request) . RESET . "\n"; + $response = $ua->request($request); + print CYAN . "<- RCVD === line:" . __LINE__ . "\n" . dumpResponse($response) . RESET . "\n"; + assertSuccess($response, "Could not send event"); + + &finishSession($session); + +} + &testSimpleStepping(); &testBreakpoint(); &testIssueReporting(); +&testDataModelInspection(); +&testSessionAttaching(); +&testEventInsertion(); + kill('TERM', $pid); \ No newline at end of file diff --git a/test/src/test-http-debugger.scxml b/test/src/test-http-debugger.scxml new file mode 100644 index 0000000..842390d --- /dev/null +++ b/test/src/test-http-debugger.scxml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/test/src/test-lifecycle.cpp b/test/src/test-lifecycle.cpp index 6b30c96..04c1d27 100644 --- a/test/src/test-lifecycle.cpp +++ b/test/src/test-lifecycle.cpp @@ -341,6 +341,7 @@ int main(int argc, char** argv) { assert(interpreter.getState() == USCXML_INSTANTIATED); assert(interpreter.step() == USCXML_INITIALIZED); assert(interpreter.step() == USCXML_MICROSTEPPED); + assert(interpreter.step() == USCXML_MICROSTEPPED); assert(interpreter.step() == USCXML_MACROSTEPPED); assert(interpreter.step(0) == USCXML_IDLE); assert(interpreter.step() == USCXML_MICROSTEPPED); diff --git a/test/src/test-performance.cpp b/test/src/test-performance.cpp index c312b70..188f4b2 100644 --- a/test/src/test-performance.cpp +++ b/test/src/test-performance.cpp @@ -57,6 +57,7 @@ int main(int argc, char** argv) { start = now; report = start + seconds(1); endTime = start + seconds(10); + std::cout << "\"Init (ms)\", \"Steps/s\"" << std::endl; while(true) { sc.step(); diff --git a/test/src/test-promela-parser.cpp b/test/src/test-promela-parser.cpp index f0a019e..c294e6f 100644 --- a/test/src/test-promela-parser.cpp +++ b/test/src/test-promela-parser.cpp @@ -63,6 +63,7 @@ void testInlinePromela() { } +#if 0 { Interpreter interpreter = Interpreter::fromURL("/Users/sradomski/Documents/TK/Code/uscxml/test/uscxml/promela/test-event-source-auto.scxml"); assert(interpreter); @@ -71,7 +72,7 @@ void testInlinePromela() { assert(inls.getAllOfType(PromelaInline::PROMELA_EVENT_ONLY).size() == 2); assert(inls.getAllOfType(PromelaInline::PROMELA_EVENT_ALL_BUT).size() == 1); } - +#endif #if 0 { std::string test = "\ @@ -309,6 +310,13 @@ void testPromelaParser() { } #endif + { + try { + PromelaParser ast("\"foo"); + assert(false); + } catch(...) { + } + } } int main(int argc, char** argv) { @@ -320,4 +328,4 @@ int main(int argc, char** argv) { testInlinePromela(); testPromelaParser(); -} \ No newline at end of file +} diff --git a/test/src/test-stress.cpp b/test/src/test-stress.cpp index e034e87..d0c15fd 100644 --- a/test/src/test-stress.cpp +++ b/test/src/test-stress.cpp @@ -80,7 +80,8 @@ int main(int argc, char** argv) { lastTransitionAt = time(NULL); Interpreter interpreter = Interpreter::fromURL(std::string(argv[optind]) + PATH_SEPERATOR + entryIter->first); -// Interpreter interpreter = Interpreter::fromURL("/Users/sradomski/Documents/TK/Code/uscxml/test/w3c/ecma/test422.scxml"); +// Interpreter interpreter = Interpreter::fromURL("/Users/sradomski/Documents/TK/Code/uscxml/test/w3c/ecma/test159.scxml"); + LOGD(USCXML_INFO) << "Processing " << interpreter.getImpl()->getBaseURL() << std::endl; if (interpreter) { @@ -100,9 +101,9 @@ int main(int argc, char** argv) { entryIter++; // forever -// if (entryIter == entries.end()) { -// entryIter = entries.begin(); -// } + if (entryIter == entries.end()) { + entryIter = entries.begin(); + } } delete watcher; diff --git a/test/src/test-validating.cpp b/test/src/test-validating.cpp index a0fd6dd..19897a1 100644 --- a/test/src/test-validating.cpp +++ b/test/src/test-validating.cpp @@ -356,13 +356,16 @@ bool attributeConstraints() { "" " " " " - " " " " " " ""; std::set issueLocations = issueLocationsForXML(xml); - assert(issueLocations.size() == 0); + assert(issueLocations.find("//state[@id=\"start\"]/onentry[1]/script[1]") != issueLocations.end()); + assert(issueLocations.size() == 1); } diff --git a/test/w3c/confPromela.xsl b/test/w3c/confPromela.xsl index 37920a5..44395d6 100644 --- a/test/w3c/confPromela.xsl +++ b/test/w3c/confPromela.xsl @@ -542,7 +542,7 @@ is the second argument --> - config[] + config[] diff --git a/test/w3c/promela/test310.scxml b/test/w3c/promela/test310.scxml index 2428dcd..43d80f0 100644 --- a/test/w3c/promela/test310.scxml +++ b/test/w3c/promela/test310.scxml @@ -3,7 +3,7 @@ - + diff --git a/test/w3c/promela/test411.scxml b/test/w3c/promela/test411.scxml index 317b8c4..4b8da3e 100644 --- a/test/w3c/promela/test411.scxml +++ b/test/w3c/promela/test411.scxml @@ -16,7 +16,7 @@ timeout also indicates failure --> - + diff --git a/test/w3c/promela/test413.scxml b/test/w3c/promela/test413.scxml index f4c983d..70d5bed 100644 --- a/test/w3c/promela/test413.scxml +++ b/test/w3c/promela/test413.scxml @@ -16,7 +16,7 @@ states we should not enter all have immediate transitions to failure in them --> - + @@ -25,7 +25,7 @@ states we should not enter all have immediate transitions to failure in them --> - + -- cgit v0.12