FpySequencer.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FpySequencer.hpp
// \author zimri.leisher
// \brief  hpp file for FpySequencer component implementation class
// ======================================================================

#ifndef FpySequencer_HPP
#define FpySequencer_HPP

#include "Fw/Types/MemAllocator.hpp"
#include "Fw/Types/StringBase.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"
#include "Fw/Types/WaitEnumAc.hpp"
#include "Os/File.hpp"
#include "Svc/FpySequencer/DirectiveIdEnumAc.hpp"
#include "Svc/FpySequencer/FlagIdEnumAc.hpp"
#include "Svc/FpySequencer/FooterSerializableAc.hpp"
#include "Svc/FpySequencer/FppConstantsAc.hpp"
#include "Svc/FpySequencer/FpySequencerComponentAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GoalStateEnumAc.hpp"
#include "Svc/FpySequencer/HeaderSerializableAc.hpp"
#include "Svc/FpySequencer/SequenceSerializableAc.hpp"
#include "Svc/FpySequencer/StatementSerializableAc.hpp"
#include "config/FppConstantsAc.hpp"

static_assert(Svc::Fpy::MAX_SEQUENCE_ARG_COUNT <= std::numeric_limits<U8>::max(),
              "Sequence arg count must be below U8 max");
static_assert(Svc::Fpy::MAX_SEQUENCE_STATEMENT_COUNT <= std::numeric_limits<U16>::max(),
              "Sequence statement count must be below U16 max");
static_assert(Svc::Fpy::MAX_STACK_SIZE <= std::numeric_limits<Svc::Fpy::StackSizeType>::max(),
              "Max stack size must be below Svc::Fpy::StackSizeType max");
static_assert(Svc::Fpy::MAX_STACK_SIZE >= FW_TLM_BUFFER_MAX_SIZE,
              "Max stack size must be greater than max tlm buffer size");
static_assert(Svc::Fpy::MAX_STACK_SIZE >= FW_PARAM_BUFFER_MAX_SIZE,
              "Max stack size must be greater than max prm buffer size");
static_assert(Svc::Fpy::FLAG_COUNT < std::numeric_limits<U8>::max(), "Flag count must be less than U8 max");

namespace Svc {

using Signal = FpySequencer_SequencerStateMachineStateMachineBase::Signal;
using State = FpySequencer_SequencerStateMachineStateMachineBase::State;
using DirectiveError = FpySequencer_DirectiveErrorCode;

class FpySequencer : public FpySequencerComponentBase {
    friend class FpySequencerTester;

  public:
    union DirectiveUnion {
        FpySequencer_WaitRelDirective waitRel;
        FpySequencer_WaitAbsDirective waitAbs;
        FpySequencer_GotoDirective gotoDirective;
        FpySequencer_IfDirective ifDirective;
        FpySequencer_NoOpDirective noOp;
        FpySequencer_StoreTlmValDirective storeTlmVal;
        FpySequencer_PushTlmValAndTimeDirective pushTlmValAndTime;
        FpySequencer_StorePrmDirective storePrm;
        FpySequencer_ConstCmdDirective constCmd;
        FpySequencer_StackOpDirective stackOp;
        FpySequencer_ExitDirective exit;
        FpySequencer_AllocateDirective allocate;
        FpySequencer_StoreDirective store;
        FpySequencer_LoadDirective load;
        FpySequencer_PushValDirective pushVal;
        FpySequencer_DiscardDirective discard;
        FpySequencer_MemCmpDirective memCmp;
        FpySequencer_StackCmdDirective stackCmd;
        FpySequencer_PushTimeDirective pushTime;
        FpySequencer_SetFlagDirective setFlag;
        FpySequencer_GetFlagDirective getFlag;

        DirectiveUnion() {}
        ~DirectiveUnion() {}
    };

    // ----------------------------------------------------------------------
    // Construction, initialization, and destruction
    // ----------------------------------------------------------------------

    FpySequencer(const char* const compName 
    );

    ~FpySequencer();

  private:
    void RUN_cmdHandler(FwOpcodeType opCode,               
                        U32 cmdSeq,                        
                        const Fw::CmdStringArg& fileName,  
                        FpySequencer_BlockState block      
                        ) override;

    void VALIDATE_cmdHandler(FwOpcodeType opCode,              
                             U32 cmdSeq,                       
                             const Fw::CmdStringArg& fileName  
                             ) override;

    void RUN_VALIDATED_cmdHandler(FwOpcodeType opCode,           
                                  U32 cmdSeq,                    
                                  FpySequencer_BlockState block  
                                  ) override;

    void CANCEL_cmdHandler(FwOpcodeType opCode,  
                           U32 cmdSeq            
                           ) override;

    void SET_BREAKPOINT_cmdHandler(FwOpcodeType opCode,  
                                   U32 cmdSeq,           
                                   U32 stmtIdx,          
                                   bool breakOnce        
                                   ) override;

    void BREAK_cmdHandler(FwOpcodeType opCode,  
                          U32 cmdSeq            
                          ) override;

    void CONTINUE_cmdHandler(FwOpcodeType opCode,  
                             U32 cmdSeq            
                             ) override;

    void CLEAR_BREAKPOINT_cmdHandler(FwOpcodeType opCode,  
                                     U32 cmdSeq            
                                     ) override;

    void STEP_cmdHandler(FwOpcodeType opCode,  
                         U32 cmdSeq            
                         ) override;

    void SET_FLAG_cmdHandler(FwOpcodeType opCode,  
                             U32 cmdSeq,           
                             Svc::Fpy::FlagId flag,
                             bool value) override;

    // ----------------------------------------------------------------------
    // Functions to implement for internal state machine actions
    // ----------------------------------------------------------------------

    void Svc_FpySequencer_SequencerStateMachine_action_signalEntered(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceFilePath(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceBlockState(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_validate(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqSucceeded(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqCancelled(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_RUNNING(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_VALID(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_IDLE(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_OK(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_EXECUTION_ERROR(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_dispatchStatement(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearSequenceFile(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_checkShouldWake(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_resetRuntime(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_checkStatementTimeout(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_incrementSequenceCounter(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearBreakpoint(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqBroken(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setBreakpoint(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_BreakpointArgs& value           
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setBreakBeforeNextLine(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearBreakBeforeNextLine(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqFailed(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqStarted(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

  protected:
    // ----------------------------------------------------------------------
    // Functions to implement for internal state machine guards
    // ----------------------------------------------------------------------

    bool Svc_FpySequencer_SequencerStateMachine_guard_goalStateIs_RUNNING(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
    ) const override;

    bool Svc_FpySequencer_SequencerStateMachine_guard_shouldBreak(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
    ) const override;

    bool Svc_FpySequencer_SequencerStateMachine_guard_breakOnce(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
    ) const override;

    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------

    void checkTimers_handler(FwIndexType portNum,  
                             U32 context           
                             ) override;

    void cmdResponseIn_handler(FwIndexType portNum,             
                               FwOpcodeType opCode,             
                               U32 cmdSeq,                      
                               const Fw::CmdResponse& response  
                               ) override;

    void seqRunIn_handler(FwIndexType portNum, const Fw::StringBase& filename) override;

    void pingIn_handler(FwIndexType portNum,  
                        U32 key               
                        ) override;

    void tlmWrite_handler(FwIndexType portNum,  
                          U32 context           
                          ) override;

    void directive_waitAbs_internalInterfaceHandler(const FpySequencer_WaitAbsDirective& directive) override;

    void directive_waitRel_internalInterfaceHandler(const FpySequencer_WaitRelDirective& directive) override;

    void directive_goto_internalInterfaceHandler(const Svc::FpySequencer_GotoDirective& directive) override;

    void directive_if_internalInterfaceHandler(const Svc::FpySequencer_IfDirective& directive) override;

    void directive_noOp_internalInterfaceHandler(const Svc::FpySequencer_NoOpDirective& directive) override;

    void directive_storeTlmVal_internalInterfaceHandler(
        const Svc::FpySequencer_StoreTlmValDirective& directive) override;

    void directive_pushTlmValAndTime_internalInterfaceHandler(
        const Svc::FpySequencer_PushTlmValAndTimeDirective& directive) override;

    void directive_storePrm_internalInterfaceHandler(const Svc::FpySequencer_StorePrmDirective& directive) override;

    void directive_constCmd_internalInterfaceHandler(const Svc::FpySequencer_ConstCmdDirective& directive) override;

    void directive_stackOp_internalInterfaceHandler(const Svc::FpySequencer_StackOpDirective& directive) override;

    void directive_exit_internalInterfaceHandler(const Svc::FpySequencer_ExitDirective& directive) override;

    void directive_allocate_internalInterfaceHandler(const Svc::FpySequencer_AllocateDirective& directive) override;

    void directive_store_internalInterfaceHandler(const Svc::FpySequencer_StoreDirective& directive) override;

    void directive_load_internalInterfaceHandler(const Svc::FpySequencer_LoadDirective& directive) override;

    void directive_pushVal_internalInterfaceHandler(const Svc::FpySequencer_PushValDirective& directive) override;

    void directive_discard_internalInterfaceHandler(const Svc::FpySequencer_DiscardDirective& directive) override;

    void directive_memCmp_internalInterfaceHandler(const Svc::FpySequencer_MemCmpDirective& directive) override;

    void directive_stackCmd_internalInterfaceHandler(const Svc::FpySequencer_StackCmdDirective& directive) override;

    void directive_pushTime_internalInterfaceHandler(const Svc::FpySequencer_PushTimeDirective& directive) override;

    void directive_setFlag_internalInterfaceHandler(const Svc::FpySequencer_SetFlagDirective& directive) override;

    void directive_getFlag_internalInterfaceHandler(const Svc::FpySequencer_GetFlagDirective& directive) override;

    void parametersLoaded() override;
    void parameterUpdated(FwPrmIdType id) override;

  public:
    void allocateBuffer(FwEnumStoreType identifier, Fw::MemAllocator& allocator, FwSizeType bytes);

    void deallocateBuffer(Fw::MemAllocator& allocator);

  private:
    static constexpr U32 CRC_INITIAL_VALUE = 0xFFFFFFFFU;

    // allocated at startup
    Fw::ExternalSerializeBuffer m_sequenceBuffer;
    // id of allocator that gave us m_sequenceBuffer
    FwEnumStoreType m_allocatorId;

    // assigned by the user via cmd
    Fw::String m_sequenceFilePath;
    // the sequence, loaded in memory
    Fpy::Sequence m_sequenceObj;
    // live running computation of CRC (updated as we read)
    U32 m_computedCRC;

    // whether or not the sequence we're about to run should return immediately or
    // block on completion
    FpySequencer_BlockState m_sequenceBlockState;
    // if we are to block on completion, save the opCode and cmdSeq we should
    // return
    FwOpcodeType m_savedOpCode;
    U32 m_savedCmdSeq;

    // the goal state is the state that we're trying to reach in the sequencer
    // if it's RUNNING, then we should promptly go to RUNNING once we validate the
    // sequence. if it's VALID, we should wait after VALIDATING
    FpySequencer_GoalState m_goalState;

    // the total number of sequences this sequencer has started since construction
    U64 m_sequencesStarted;
    // the total number of statements this sequencer has dispatched, successfully or
    // otherwise, since construction
    U64 m_statementsDispatched;

    // the runtime state of the sequence. encapsulates all state
    // needed to run the sequence.
    // this is distinct from the state of the sequencer. the
    // sequencer and all its state is really just a shell to load
    // and execute this runtime.
    struct Runtime {
        // the index of the next statement to be executed
        U32 nextStatementIndex = 0;

        // the opcode of the statement that is currently executing
        U8 currentStatementOpcode = Fpy::DirectiveId::INVALID;
        // the opcode of the command that we are currently awaiting, or 0 if we are executing a directive
        FwOpcodeType currentCmdOpcode = 0;
        // the time we dispatched the statement that is currently executing
        Fw::Time currentStatementDispatchTime = Fw::Time();

        // the absolute time we should wait for until returning
        // a statement response
        Fw::Time wakeupTime = Fw::Time();

        // the byte array of the program stack, storing lvars, operands and function calls
        U8 stack[Fpy::MAX_STACK_SIZE] = {0};
        // how many bytes high the stack is
        Fpy::StackSizeType stackSize = 0;

        // the sequencer runtime flags. these are modifiable by the sequence and control
        // various aspects of the sequencer.
        // these get set to a default value from FpySequencerCfg
        bool flags[Fpy::FLAG_COUNT] = {0};
    } m_runtime;

    // the state of the debugger. debugger is separate from runtime
    // because it can be set up before running the sequence.
    struct BreakpointInfo {
        // whether or not to break at the debug breakpoint index
        bool breakpointInUse = false;
        // whether or not to remove the breakpoint after breaking on it
        bool breakOnlyOnceOnBreakpoint = false;
        // the statement index at which to break, before dispatching
        U32 breakpointIndex = 0;
        // whether or not to break before dispatching the next line,
        // independent of what line it is.
        // can be used in combination with breakpointIndex
        bool breakBeforeNextLine = false;
    } m_breakpoint;

    // debug information about the sequence. only valid in the PAUSED state
    // which you can access via BREAK or SET_BREAKPOINT cmds
    struct DebugInfo {
        // true if there are no statements remaining in the sequence file
        bool reachedEndOfFile = false;
        // true if we were able to deserialize the next statement successfully
        bool nextStatementReadSuccess = false;
        // the opcode of the next statement to dispatch.
        U8 nextStatementOpcode = 0;
        // if the next statement is a cmd directive, the opcode of that cmd
        FwOpcodeType nextCmdOpcode = 0;
    } m_debug;

    struct Telemetry {
        // the number of statements that failed to execute
        U64 statementsFailed = 0;
        // the number of sequences successfully completed
        U64 sequencesSucceeded = 0;
        // the number of sequences that failed to validate or execute
        U64 sequencesFailed = 0;
        // the number of sequences that have been cancelled
        U64 sequencesCancelled = 0;

        // the error code of the last directive that ran
        DirectiveError lastDirectiveError = DirectiveError::NO_ERROR;
        // the index of the last directive that errored
        U64 directiveErrorIndex = 0;
        // the opcode of the last directive that errored
        Fpy::DirectiveId directiveErrorId = Fpy::DirectiveId::INVALID;
    } m_tlm;

    // ----------------------------------------------------------------------
    // Validation state
    // ----------------------------------------------------------------------

    static void updateCrc(U32& crc,              
                          const U8* buffer,      
                          FwSizeType bufferSize  
    );

    // loads the sequence in memory, and does header/crc/integrity checks.
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success validate();
    // reads and validates the header from the m_sequenceBuffer
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success readHeader();
    // reads and validates the body from the m_sequenceBuffer
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success readBody();
    // reads and validates the footer from the m_sequenceBuffer
    // return SUCCESS if sequence is valid, FAILURE otherwise
    Fw::Success readFooter();

    // reads some bytes from the open file into the m_sequenceBuffer.
    // updates the CRC by default, but can be turned off if the contents
    // aren't included in CRC.
    // return success if successful
    Fw::Success readBytes(Os::File& file,
                          FwSizeType readLen,
                          const FpySequencer_FileReadStage& readStage,
                          bool updateCrc = true);

    // ----------------------------------------------------------------------
    // Run state
    // ----------------------------------------------------------------------

    // utility method for updating telemetry based on a directive error code
    void handleDirectiveErrorCode(Fpy::DirectiveId id, DirectiveError err);

    // dispatches the next statement
    Signal dispatchStatement();

    // deserializes a directive from bytes into the Fpy type
    // returns success if able to deserialize, and returns the Fpy type object
    // as a reference, in a union of all the possible directive type objects
    Fw::Success deserializeDirective(const Fpy::Statement& stmt, DirectiveUnion& deserializedDirective);

    // dispatches a deserialized sequencer directive to the right handler.
    void dispatchDirective(const DirectiveUnion& directive, const Fpy::DirectiveId& id);

    // checks whether the currently executing statement timed out
    Signal checkStatementTimeout();

    // checks whether the sequencer should wake from sleeping
    Signal checkShouldWake();

    // return true if state is a substate of RUNNING
    bool isRunningState(State state);

    // update a struct containing debug telemetry, or defaults if not in debug break
    void updateDebugTelemetryStruct();

    // ----------------------------------------------------------------------
    // Directives
    // ----------------------------------------------------------------------

    // sends a signal based on a signal id
    void sendSignal(Signal signal);

    // dispatches a command, returns whether successful or not
    Fw::Success sendCmd(FwOpcodeType opcode, const U8* argBuf, FwSizeType argBufSize);

    // pops a value off of the top of the stack
    // converts it from big endian
    template <typename T>
    T pop();

    // pushes a value onto the top of the stack
    // converts it to big endian
    template <typename T>
    void push(T val);

    // returns a pointer to the next unused byte at the top of the stack
    U8* top();
    // returns a pointer to the first byte of the lvars array
    U8* lvars();
    // returns the stack height at which the lvar array begins
    Fpy::StackSizeType lvarOffset();
    // returns the index of the current statement
    U32 currentStatementIdx();

    // we split these functions up into the internalInterfaceInvoke and these custom member funcs
    // so that we can unit test them easier
    Signal waitRel_directiveHandler(const FpySequencer_WaitRelDirective& directive, DirectiveError& error);
    Signal waitAbs_directiveHandler(const FpySequencer_WaitAbsDirective& directive, DirectiveError& error);
    Signal goto_directiveHandler(const FpySequencer_GotoDirective& directive, DirectiveError& error);
    Signal if_directiveHandler(const FpySequencer_IfDirective& directive, DirectiveError& error);
    Signal noOp_directiveHandler(const FpySequencer_NoOpDirective& directive, DirectiveError& error);
    Signal storeTlmVal_directiveHandler(const FpySequencer_StoreTlmValDirective& directive, DirectiveError& error);
    Signal pushTlmValAndTime_directiveHandler(const FpySequencer_PushTlmValAndTimeDirective& directive,
                                              DirectiveError& error);
    Signal storePrm_directiveHandler(const FpySequencer_StorePrmDirective& directive, DirectiveError& error);
    Signal constCmd_directiveHandler(const FpySequencer_ConstCmdDirective& directive, DirectiveError& error);
    Signal stackOp_directiveHandler(const FpySequencer_StackOpDirective& directive, DirectiveError& error);

    DirectiveError op_or();
    DirectiveError op_and();
    DirectiveError op_ieq();
    DirectiveError op_ine();
    DirectiveError op_ult();
    DirectiveError op_ule();
    DirectiveError op_ugt();
    DirectiveError op_uge();
    DirectiveError op_slt();
    DirectiveError op_sle();
    DirectiveError op_sgt();
    DirectiveError op_sge();
    DirectiveError op_feq();
    DirectiveError op_fne();
    DirectiveError op_flt();
    DirectiveError op_fle();
    DirectiveError op_fgt();
    DirectiveError op_fge();
    DirectiveError op_not();
    DirectiveError op_fpext();
    DirectiveError op_fptrunc();
    DirectiveError op_fptoui();
    DirectiveError op_fptosi();
    DirectiveError op_sitofp();
    DirectiveError op_uitofp();
    DirectiveError op_iadd();
    DirectiveError op_isub();
    DirectiveError op_imul();
    DirectiveError op_udiv();
    DirectiveError op_sdiv();
    DirectiveError op_umod();
    DirectiveError op_smod();
    DirectiveError op_fadd();
    DirectiveError op_fsub();
    DirectiveError op_fmul();
    DirectiveError op_fdiv();
    DirectiveError op_float_floor_div();
    DirectiveError op_fpow();
    DirectiveError op_flog();
    DirectiveError op_fmod();
    DirectiveError op_siext_8_64();
    DirectiveError op_siext_16_64();
    DirectiveError op_siext_32_64();
    DirectiveError op_ziext_8_64();
    DirectiveError op_ziext_16_64();
    DirectiveError op_ziext_32_64();
    DirectiveError op_itrunc_64_8();
    DirectiveError op_itrunc_64_16();
    DirectiveError op_itrunc_64_32();

    Signal exit_directiveHandler(const FpySequencer_ExitDirective& directive, DirectiveError& error);
    Signal allocate_directiveHandler(const FpySequencer_AllocateDirective& directive, DirectiveError& error);
    Signal store_directiveHandler(const FpySequencer_StoreDirective& directive, DirectiveError& error);
    Signal load_directiveHandler(const FpySequencer_LoadDirective& directive, DirectiveError& error);
    Signal pushVal_directiveHandler(const FpySequencer_PushValDirective& directive, DirectiveError& error);
    Signal discard_directiveHandler(const FpySequencer_DiscardDirective& directive, DirectiveError& error);
    Signal memCmp_directiveHandler(const FpySequencer_MemCmpDirective& directive, DirectiveError& error);
    Signal stackCmd_directiveHandler(const FpySequencer_StackCmdDirective& directive, DirectiveError& error);
    Signal pushTime_directiveHandler(const FpySequencer_PushTimeDirective& directive, DirectiveError& error);
    Signal setFlag_directiveHandler(const FpySequencer_SetFlagDirective& directive, DirectiveError& error);
    Signal getFlag_directiveHandler(const FpySequencer_GetFlagDirective& directive, DirectiveError& error);
};

}  // namespace Svc

#endif