| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtScxml module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #ifndef QSCXMLEXECUTABLECONTENT_P_H |
| #define QSCXMLEXECUTABLECONTENT_P_H |
| |
| // |
| // W A R N I N G |
| // ------------- |
| // |
| // This file is not part of the Qt API. It exists purely as an |
| // implementation detail. This header file may change from version to |
| // version without notice, or even be removed. |
| // |
| // We mean it. |
| // |
| |
| #include <QtScxml/qscxmlexecutablecontent.h> |
| #include <QtScxml/private/qscxmltabledata_p.h> |
| #include <QtScxml/private/qscxmlcompiler_p.h> |
| #include <QtCore/qtextstream.h> |
| |
| #ifndef BUILD_QSCXMLC |
| #include <QtScxml/qscxmldatamodel.h> |
| #include <QtScxml/qscxmlstatemachine.h> |
| #endif // BUILD_QSCXMLC |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace QScxmlExecutableContent { |
| |
| static inline bool operator<(const EvaluatorInfo &ei1, const EvaluatorInfo &ei2) |
| { |
| if (ei1.expr != ei2.expr) |
| return ei1.expr < ei2.expr; |
| else |
| return ei1.context < ei2.context; |
| } |
| |
| static inline bool operator<(const AssignmentInfo &ai1, const AssignmentInfo &ai2) |
| { |
| if (ai1.dest != ai2.dest) |
| return ai1.dest < ai2.dest; |
| else if (ai1.expr != ai2.expr) |
| return ai1.expr < ai2.expr; |
| else |
| return ai1.context < ai2.context; |
| } |
| |
| static inline bool operator<(const ForeachInfo &fi1, const ForeachInfo &fi2) |
| { |
| if (fi1.array != fi2.array) return fi1.array < fi2.array; |
| if (fi1.item != fi2.item) return fi1.item < fi2.item; |
| if (fi1.index != fi2.index) return fi1.index < fi2.index; |
| return fi1.context < fi2.context; |
| } |
| |
| #if defined(Q_CC_MSVC) || defined(Q_CC_GNU) |
| #pragma pack(push, 4) // 4 == sizeof(qint32) |
| #endif |
| |
| template <typename T> |
| struct Array |
| { |
| qint32 count; |
| // T[] data; |
| T *data() { return const_cast<T *>(const_data()); } |
| const T *const_data() const { return reinterpret_cast<const T *>(reinterpret_cast<const char *>(this) + sizeof(Array<T>)); } |
| |
| const T &at(int pos) const { return *(const_data() + pos); } |
| int dataSize() const { return count * sizeof(T) / sizeof(qint32); } |
| int size() const { return sizeof(Array<T>) / sizeof(qint32) + dataSize(); } |
| }; |
| |
| struct Q_SCXML_EXPORT Instruction |
| { |
| enum InstructionType: qint32 { |
| Sequence = 1, |
| Sequences, |
| Send, |
| Raise, |
| Log, |
| JavaScript, |
| Assign, |
| Initialize, |
| If, |
| Foreach, |
| Cancel, |
| DoneData |
| } instructionType; |
| }; |
| |
| struct Q_SCXML_EXPORT DoneData: Instruction |
| { |
| StringId location; |
| StringId contents; |
| EvaluatorId expr; |
| Array<ParameterInfo> params; |
| |
| static InstructionType kind() { return Instruction::DoneData; } |
| }; |
| |
| struct Q_SCXML_EXPORT InstructionSequence: Instruction |
| { |
| qint32 entryCount; // the amount of qint32's that the instructions take up |
| // Instruction[] instructions; |
| |
| static InstructionType kind() { return Instruction::Sequence; } |
| const InstructionId *instructions() const |
| { |
| return reinterpret_cast<const InstructionId *>(this) |
| + sizeof(InstructionSequence) / sizeof(qint32); |
| } |
| int size() const { return sizeof(InstructionSequence) / sizeof(qint32) + entryCount; } |
| }; |
| |
| struct Q_SCXML_EXPORT InstructionSequences: Instruction |
| { |
| qint32 sequenceCount; |
| qint32 entryCount; // the amount of qint32's that the sequences take up |
| // InstructionSequence[] sequences; |
| |
| static InstructionType kind() { return Instruction::Sequences; } |
| const InstructionSequence *sequences() const { |
| return reinterpret_cast<const InstructionSequence *>( |
| reinterpret_cast<const InstructionId *>(this) |
| + sizeof(InstructionSequences) / sizeof(qint32)); |
| } |
| int size() const { return sizeof(InstructionSequences)/sizeof(qint32) + entryCount; } |
| const InstructionId *at(int pos) const |
| { |
| const InstructionId *seq = reinterpret_cast<const InstructionId *>(sequences()); |
| while (pos--) { |
| seq += reinterpret_cast<const InstructionSequence *>(seq)->size(); |
| } |
| return seq; |
| } |
| }; |
| |
| struct Q_SCXML_EXPORT Send: Instruction |
| { |
| StringId instructionLocation; |
| StringId event; |
| EvaluatorId eventexpr; |
| StringId type; |
| EvaluatorId typeexpr; |
| StringId target; |
| EvaluatorId targetexpr; |
| StringId id; |
| StringId idLocation; |
| StringId delay; |
| EvaluatorId delayexpr; |
| StringId content; |
| EvaluatorId contentexpr; |
| Array<StringId> namelist; |
| // Array<Param> params; |
| |
| static InstructionType kind() { return Instruction::Send; } |
| |
| int paramsOffset() const |
| { |
| return sizeof(Send) / sizeof(qint32) + namelist.dataSize(); |
| } |
| |
| int size() const |
| { |
| return paramsOffset() + params()->size(); |
| } |
| |
| const Array<ParameterInfo> *params() const { |
| return reinterpret_cast<const Array<ParameterInfo> *>( |
| reinterpret_cast<const InstructionId *>(this) + paramsOffset()); |
| } |
| |
| Array<ParameterInfo> *params() { |
| return reinterpret_cast<Array<ParameterInfo> *>( |
| reinterpret_cast<InstructionId *>(this) + paramsOffset()); |
| } |
| |
| static int calculateExtraSize(int paramCount, int nameCount) { |
| return 1 + paramCount * sizeof(ParameterInfo) / sizeof(qint32) |
| + nameCount * sizeof(StringId) / sizeof(qint32); |
| } |
| }; |
| |
| struct Q_SCXML_EXPORT Raise: Instruction |
| { |
| StringId event; |
| |
| static InstructionType kind() { return Instruction::Raise; } |
| int size() const { return sizeof(Raise) / sizeof(qint32); } |
| }; |
| |
| struct Q_SCXML_EXPORT Log: Instruction |
| { |
| StringId label; |
| EvaluatorId expr; |
| |
| static InstructionType kind() { return Instruction::Log; } |
| int size() const { return sizeof(Log) / sizeof(qint32); } |
| }; |
| |
| struct Q_SCXML_EXPORT JavaScript: Instruction |
| { |
| EvaluatorId go; |
| |
| static InstructionType kind() { return Instruction::JavaScript; } |
| int size() const { return sizeof(JavaScript) / sizeof(qint32); } |
| }; |
| |
| struct Q_SCXML_EXPORT Assign: Instruction |
| { |
| EvaluatorId expression; |
| |
| static InstructionType kind() { return Instruction::Assign; } |
| int size() const { return sizeof(Assign) / sizeof(qint32); } |
| }; |
| |
| struct Q_SCXML_EXPORT Initialize: Instruction |
| { |
| EvaluatorId expression; |
| |
| static InstructionType kind() { return Instruction::Initialize; } |
| int size() const { return sizeof(Initialize) / sizeof(qint32); } |
| }; |
| |
| struct Q_SCXML_EXPORT If: Instruction |
| { |
| Array<EvaluatorId> conditions; |
| // InstructionSequences blocks; |
| const InstructionSequences *blocks() const { |
| return reinterpret_cast<const InstructionSequences *>( |
| reinterpret_cast<const InstructionId *>(this) + sizeof(If) / sizeof(qint32) |
| + conditions.dataSize()); |
| } |
| |
| static InstructionType kind() { return Instruction::If; } |
| int size() const |
| { |
| return sizeof(If) / sizeof(qint32) + blocks()->size() + conditions.dataSize(); |
| } |
| }; |
| |
| struct Q_SCXML_EXPORT Foreach: Instruction |
| { |
| EvaluatorId doIt; |
| InstructionSequence block; |
| |
| static InstructionType kind() { return Instruction::Foreach; } |
| int size() const { return sizeof(Foreach) / sizeof(qint32) + block.entryCount; } |
| const InstructionId *blockstart() const |
| { |
| return reinterpret_cast<const InstructionId *>(&block); |
| } |
| }; |
| |
| struct Q_SCXML_EXPORT Cancel: Instruction |
| { |
| StringId sendid; |
| EvaluatorId sendidexpr; |
| |
| static InstructionType kind() { return Instruction::Cancel; } |
| int size() const { return sizeof(Cancel) / sizeof(qint32); } |
| }; |
| |
| struct StateTable { |
| int version; |
| int name; |
| enum: int { |
| InvalidDataModel = -1, |
| NullDataModel = 0, |
| EcmaScriptDataModel = 1, |
| CppDataModel = 2 |
| } dataModel; |
| int childStates; // offset into offsets |
| int initialTransition; |
| int initialSetup; |
| enum: int { InvalidBinding = -1, EarlyBinding = 0, LateBinding = 1 } binding; |
| int maxServiceId; |
| int stateOffset, stateCount; |
| int transitionOffset, transitionCount; |
| int arrayOffset, arraySize; |
| |
| enum { terminator = 0xc0ff33 }; |
| enum { InvalidIndex = -1 }; |
| |
| struct State { |
| int name; |
| int parent; |
| enum: int { |
| Invalid = -1, |
| Normal = 0, |
| Parallel = 1, |
| Final = 2, |
| ShallowHistory = 3, |
| DeepHistory = 4 |
| } type; |
| int initialTransition; |
| int initInstructions; |
| int entryInstructions; |
| int exitInstructions; |
| int doneData; |
| int childStates; // offset into arrays |
| int transitions; // offset into arrays |
| int serviceFactoryIds; // offset into arrays |
| |
| State() |
| : name(InvalidIndex) |
| , parent(InvalidIndex) |
| , type(Invalid) |
| , initialTransition(InvalidIndex) |
| , initInstructions(InvalidIndex) |
| , entryInstructions(InvalidIndex) |
| , exitInstructions(InvalidIndex) |
| , doneData(InvalidIndex) |
| , childStates(InvalidIndex) |
| , transitions(InvalidIndex) |
| , serviceFactoryIds(InvalidIndex) |
| {} |
| |
| bool isAtomic() const |
| { return childStates == InvalidIndex; } |
| |
| bool isCompound() const |
| { return type == Normal && childStates != InvalidIndex; } |
| |
| bool parentIsScxmlElement() const |
| { return parent == InvalidIndex; } |
| |
| bool isHistoryState() const |
| { return type == ShallowHistory || type == DeepHistory; } |
| |
| bool isParallel() const |
| { return type == Parallel; } |
| }; |
| |
| struct Transition { |
| int events; // offset into offsets |
| int condition; |
| enum: int { |
| Invalid = -1, |
| Internal = 0, |
| External = 1, |
| Synthetic = 2 |
| } type; |
| int source; |
| int targets; // offset into offsets |
| int transitionInstructions; |
| |
| Transition() |
| : events(InvalidIndex) |
| , condition(InvalidIndex) |
| , type(Invalid) |
| , source(InvalidIndex) |
| , targets(InvalidIndex) |
| , transitionInstructions(InvalidIndex) |
| {} |
| }; |
| |
| struct Array { |
| Array(const int *start): start(start) {} |
| int size() const { return *start; } |
| bool isValid() const { return start != nullptr; } |
| |
| int operator[](int idx) const { |
| Q_ASSERT(idx >= 0); |
| Q_ASSERT(idx < size()); |
| return *(start + idx + 1); |
| } |
| |
| struct const_iterator: public std::iterator<std::forward_iterator_tag, int, ptrdiff_t, |
| const int *, const int &> |
| { |
| const_iterator(const Array &a, int pos): a(a), pos(pos) {} |
| |
| const_iterator &operator++() { |
| if (pos < a.size()) ++pos; |
| return *this; |
| } |
| |
| bool operator==(const const_iterator &other) const |
| { return &other.a == &a && other.pos == pos; } |
| |
| bool operator!=(const StateTable::Array::const_iterator &other) |
| { return !this->operator==(other); } |
| |
| int operator*() const { |
| if (pos < a.size()) |
| return a[pos]; |
| else |
| return -1; |
| } |
| |
| private: |
| const Array &a; |
| int pos; |
| }; |
| |
| const_iterator begin() const |
| { return const_iterator(*this, 0); } |
| |
| const_iterator end() const |
| { return const_iterator(*this, size()); } |
| |
| private: |
| const int *start; |
| }; |
| |
| StateTable() |
| : version(InvalidIndex) |
| , name(InvalidIndex) |
| , dataModel(InvalidDataModel) |
| , childStates(InvalidIndex) |
| , initialTransition(InvalidIndex) |
| , initialSetup(InvalidIndex) |
| , binding(InvalidBinding) |
| , maxServiceId(InvalidIndex) |
| , stateOffset(InvalidIndex), stateCount(InvalidIndex) |
| , transitionOffset(InvalidIndex), transitionCount(InvalidIndex) |
| , arrayOffset(InvalidIndex), arraySize(InvalidIndex) |
| {} |
| |
| const State &state(int idx) const |
| { |
| Q_ASSERT(idx >= 0); |
| Q_ASSERT(idx < stateCount); |
| return reinterpret_cast<const State *>( |
| reinterpret_cast<const int *>(this) + stateOffset)[idx]; |
| } |
| |
| const Transition &transition(int idx) const |
| { |
| Q_ASSERT(idx >= 0); |
| Q_ASSERT(idx < transitionCount); |
| return reinterpret_cast<const Transition *>( |
| reinterpret_cast<const int *>(this) + transitionOffset)[idx]; |
| } |
| |
| const Array array(int idx) const |
| { |
| Q_ASSERT(idx < arraySize); |
| if (idx >= 0) { |
| const int *start = reinterpret_cast<const int *>(this) + arrayOffset + idx; |
| Q_ASSERT(*start + idx < arraySize); |
| return Array(start); |
| } else { |
| return Array(nullptr); |
| } |
| } |
| }; |
| |
| #if defined(Q_CC_MSVC) || defined(Q_CC_GNU) |
| #pragma pack(pop) |
| #endif |
| |
| } // QScxmlExecutableContent namespace |
| |
| class QScxmlExecutionEngine |
| { |
| Q_DISABLE_COPY(QScxmlExecutionEngine) |
| |
| public: |
| QScxmlExecutionEngine(QScxmlStateMachine *stateMachine); |
| |
| bool execute(QScxmlExecutableContent::ContainerId ip, const QVariant &extraData = QVariant()); |
| |
| private: |
| const QScxmlExecutableContent::InstructionId *step( |
| const QScxmlExecutableContent::InstructionId *ip, bool *ok); |
| |
| QScxmlStateMachine *stateMachine; |
| QVariant extraData; |
| }; |
| |
| QT_END_NAMESPACE |
| |
| #endif // QSCXMLEXECUTABLECONTENT_P_H |