FpySequencerDirectives.cpp

Go to the documentation of this file.

#include <algorithm>
#include <cmath>
#include <cstring>
#include <type_traits>
#include "Fw/Com/ComPacket.hpp"
#include "Svc/FpySequencer/FpySequencer.hpp"
#include "config/SerialPortIndexEnumAc.hpp"

namespace Svc {

void FpySequencer::sendSignal(Signal signal) {
    switch (signal) {
        case Signal::stmtResponse_beginSleep: {
            this->sequencer_sendSignal_stmtResponse_beginSleep();
            break;
        }
        case Signal::stmtResponse_success: {
            this->sequencer_sendSignal_stmtResponse_success();
            break;
        }
        case Signal::stmtResponse_failure: {
            this->sequencer_sendSignal_stmtResponse_failure();
            break;
        }
        case Signal::stmtResponse_keepWaiting: {
            this->sequencer_sendSignal_stmtResponse_keepWaiting();
            break;
        }
        default: {
            FW_ASSERT(false, static_cast<FwAssertArgType>(signal));
        }
    }
}

// utility method for updating telemetry based on a directive error code
void FpySequencer::handleDirectiveErrorCode(Fpy::DirectiveId id, DirectiveError err) {
    this->m_tlm.lastDirectiveError = err;
    if (err != DirectiveError::NO_ERROR) {
        this->m_tlm.directiveErrorIndex = this->currentStatementIdx();
        this->m_tlm.directiveErrorId = id;
    }
}

Fw::Success FpySequencer::sendCmd(FwOpcodeType opcode, const U8* argBuf, FwSizeType argBufSize) {
    Fw::ComBuffer cmdBuf;
    Fw::SerializeStatus stat =
        cmdBuf.serializeFrom(static_cast<FwPacketDescriptorType>(Fw::ComPacketType::FW_PACKET_COMMAND));
    // TODO should I assert here? this really shouldn't fail, I should just add a static assert
    // on com buf size and then assert here
    if (stat != Fw::SerializeStatus::FW_SERIALIZE_OK) {
        return Fw::Success::FAILURE;
    }
    stat = cmdBuf.serializeFrom(opcode);
    if (stat != Fw::SerializeStatus::FW_SERIALIZE_OK) {
        return Fw::Success::FAILURE;
    }
    stat = cmdBuf.serializeFrom(argBuf, argBufSize, Fw::Serialization::OMIT_LENGTH);
    if (stat != Fw::SerializeStatus::FW_SERIALIZE_OK) {
        return Fw::Success::FAILURE;
    }

    // calculate the unique command identifier:
    // cmd UID is formatted like XXYY, where XX are the first two bytes of the m_sequencesStarted counter
    // and YY are the first two bytes of the m_statementsDispatched counter.
    // this way, we know when we get a cmd back A) whether or not it's from this sequence (modulo 2^16) and B)
    // whether or not it's this specific instance of the cmd in the sequence, and not another one with the same opcode
    // somewhere else in the file.
    // if we put this uid in the context we send to the cmdDisp, we will get it back when the cmd returns
    U32 cmdUid =
        static_cast<U32>(((this->m_sequencesStarted & 0xFFFF) << 16) | (this->m_statementsDispatched & 0xFFFF));

    this->cmdOut_out(0, cmdBuf, cmdUid);

    return Fw::Success::SUCCESS;
}

// returns true if a directive can be executed. a directive is only ever dispatched in
// RUNNING.DISPATCH_STATEMENT, after which the sequencer waits in RUNNING.AWAITING_STATEMENT_RESPONSE.
// CANCEL and RUN are higher priority than directives, so a sequence can be cancelled while its directive is
// still queued, and a new sequence can be started and dispatch its first statement before that directive is
// serviced. neither of those directives may execute
bool FpySequencer::checkDirectiveExpected(Fpy::DirectiveId directive, U64 sequenceIndex) {
    if (this->sequencer_getState() != State::RUNNING_AWAITING_STATEMENT_RESPONSE) {
        this->log_WARNING_LO_DirectiveWhileNotAwaiting(directive, static_cast<I32>(this->sequencer_getState()));
        return false;
    }
    if (sequenceIndex != this->m_sequencesStarted) {
        this->log_WARNING_LO_DirectiveFromOldSequence(directive, sequenceIndex, this->m_sequencesStarted);
        return false;
    }
    return true;
}

void FpySequencer::directive_waitRel_internalInterfaceHandler(const FpySequencer_WaitRelDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::WAIT_REL, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->waitRel_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::WAIT_REL, error);
}

void FpySequencer::directive_waitAbs_internalInterfaceHandler(const FpySequencer_WaitAbsDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::WAIT_ABS, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->waitAbs_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::WAIT_ABS, error);
}

void FpySequencer::directive_goto_internalInterfaceHandler(const Svc::FpySequencer_GotoDirective& directive,
                                                           U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::GOTO, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->goto_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::GOTO, error);
}

void FpySequencer::directive_if_internalInterfaceHandler(const Svc::FpySequencer_IfDirective& directive,
                                                         U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::IF, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->if_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::IF, error);
}

void FpySequencer::directive_noOp_internalInterfaceHandler(const Svc::FpySequencer_NoOpDirective& directive,
                                                           U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::NO_OP, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->noOp_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::NO_OP, error);
}

void FpySequencer::directive_pushTlmVal_internalInterfaceHandler(const Svc::FpySequencer_PushTlmValDirective& directive,
                                                                 U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PUSH_TLM_VAL, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->pushTlmVal_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PUSH_TLM_VAL, error);
}

void FpySequencer::directive_pushTlmValAndTime_internalInterfaceHandler(
    const Svc::FpySequencer_PushTlmValAndTimeDirective& directive,
    U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PUSH_TLM_VAL_AND_TIME, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->pushTlmValAndTime_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PUSH_TLM_VAL_AND_TIME, error);
}

void FpySequencer::directive_pushPrm_internalInterfaceHandler(const Svc::FpySequencer_PushPrmDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PUSH_PRM, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->pushPrm_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PUSH_PRM, error);
}

void FpySequencer::directive_constCmd_internalInterfaceHandler(const Svc::FpySequencer_ConstCmdDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::CONST_CMD, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->constCmd_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::CONST_CMD, error);
}

void FpySequencer::directive_stackOp_internalInterfaceHandler(const Svc::FpySequencer_StackOpDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(directive.get__op(), sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->stackOp_directiveHandler(directive, error));
    handleDirectiveErrorCode(directive.get__op(), error);
}

void FpySequencer::directive_exit_internalInterfaceHandler(const Svc::FpySequencer_ExitDirective& directive,
                                                           U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::EXIT, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->exit_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::EXIT, error);
}

void FpySequencer::directive_allocate_internalInterfaceHandler(const Svc::FpySequencer_AllocateDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::ALLOCATE, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->allocate_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::ALLOCATE, error);
}

void FpySequencer::directive_storeRelConstOffset_internalInterfaceHandler(
    const Svc::FpySequencer_StoreRelConstOffsetDirective& directive,
    U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::STORE_REL_CONST_OFFSET, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->storeRelConstOffset_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::STORE_REL_CONST_OFFSET, error);
}

void FpySequencer::directive_pushVal_internalInterfaceHandler(const Svc::FpySequencer_PushValDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PUSH_VAL, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->pushVal_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PUSH_VAL, error);
}

void FpySequencer::directive_loadRel_internalInterfaceHandler(const Svc::FpySequencer_LoadRelDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::LOAD_REL, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->loadRel_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::LOAD_REL, error);
}

void FpySequencer::directive_discard_internalInterfaceHandler(const Svc::FpySequencer_DiscardDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::DISCARD, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->discard_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::DISCARD, error);
}

void FpySequencer::directive_memCmp_internalInterfaceHandler(const Svc::FpySequencer_MemCmpDirective& directive,
                                                             U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::MEMCMP, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->memCmp_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::MEMCMP, error);
}

void FpySequencer::directive_stackCmd_internalInterfaceHandler(const Svc::FpySequencer_StackCmdDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::STACK_CMD, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->stackCmd_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::STACK_CMD, error);
}

void FpySequencer::directive_pushTime_internalInterfaceHandler(const Svc::FpySequencer_PushTimeDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PUSH_TIME, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->pushTime_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PUSH_TIME, error);
}

void FpySequencer::directive_setSeed_internalInterfaceHandler(const Svc::FpySequencer_SetSeedDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::SET_SEED, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->setSeed_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::SET_SEED, error);
}

void FpySequencer::directive_pushRand_internalInterfaceHandler(const Svc::FpySequencer_PushRandDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PUSH_RAND, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->pushRand_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PUSH_RAND, error);
}

void FpySequencer::directive_getField_internalInterfaceHandler(const Svc::FpySequencer_GetFieldDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::GET_FIELD, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->getField_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::GET_FIELD, error);
}

void FpySequencer::directive_peek_internalInterfaceHandler(const Svc::FpySequencer_PeekDirective& directive,
                                                           U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::PEEK, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->peek_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::PEEK, error);
}

void FpySequencer::directive_storeRel_internalInterfaceHandler(const Svc::FpySequencer_StoreRelDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::STORE_REL, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->storeRel_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::STORE_REL, error);
}

void FpySequencer::directive_call_internalInterfaceHandler(const Svc::FpySequencer_CallDirective& directive,
                                                           U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::CALL, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->call_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::CALL, error);
}

void FpySequencer::directive_return_internalInterfaceHandler(const Svc::FpySequencer_ReturnDirective& directive,
                                                             U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::RETURN, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->return_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::RETURN, error);
}

void FpySequencer::directive_loadAbs_internalInterfaceHandler(const Svc::FpySequencer_LoadAbsDirective& directive,
                                                              U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::LOAD_ABS, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->loadAbs_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::LOAD_ABS, error);
}

void FpySequencer::directive_storeAbs_internalInterfaceHandler(const Svc::FpySequencer_StoreAbsDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::STORE_ABS, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->storeAbs_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::STORE_ABS, error);
}

void FpySequencer::directive_storeAbsConstOffset_internalInterfaceHandler(
    const Svc::FpySequencer_StoreAbsConstOffsetDirective& directive,
    U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::STORE_ABS_CONST_OFFSET, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->storeAbsConstOffset_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::STORE_ABS_CONST_OFFSET, error);
}

void FpySequencer::directive_popEvent_internalInterfaceHandler(const Svc::FpySequencer_PopEventDirective& directive,
                                                               U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::POP_EVENT, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->popEvent_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::POP_EVENT, error);
}

void FpySequencer::directive_popSerializable_internalInterfaceHandler(
    const Svc::FpySequencer_PopSerializableDirective& directive,
    U64 sequenceIndex) {
    if (!this->checkDirectiveExpected(Fpy::DirectiveId::POP_SERIALIZABLE, sequenceIndex)) {
        return;
    }
    DirectiveError error = DirectiveError::NO_ERROR;
    this->sendSignal(this->popSerializable_directiveHandler(directive, error));
    handleDirectiveErrorCode(Fpy::DirectiveId::POP_SERIALIZABLE, error);
}

Signal FpySequencer::waitRel_directiveHandler(const FpySequencer_WaitRelDirective& directive, DirectiveError& error) {
    if (this->m_runtime.stack.size < 8) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    Fw::Time wakeupTime = this->getTime();

    U32 uSeconds = this->m_runtime.stack.pop<U32>();
    U32 seconds = this->m_runtime.stack.pop<U32>();

    if (uSeconds >= 1000000) {
        error = DirectiveError::INVALID_ARG;
        return Signal::stmtResponse_failure;
    }

    wakeupTime.add(seconds, uSeconds);
    this->m_runtime.wakeupTime = wakeupTime;
    return Signal::stmtResponse_beginSleep;
}

Signal FpySequencer::waitAbs_directiveHandler(const FpySequencer_WaitAbsDirective& directive, DirectiveError& error) {
    if (this->m_runtime.stack.size < 2 * sizeof(U32) + sizeof(FwTimeContextStoreType) + sizeof(FwTimeBaseStoreType)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    U32 uSeconds = this->m_runtime.stack.pop<U32>();
    U32 seconds = this->m_runtime.stack.pop<U32>();
    FwTimeContextStoreType ctx = this->m_runtime.stack.pop<FwTimeContextStoreType>();
    FwTimeBaseStoreType base = this->m_runtime.stack.pop<FwTimeBaseStoreType>();

    if (uSeconds >= 1000000) {
        error = DirectiveError::INVALID_ARG;
        return Signal::stmtResponse_failure;
    }

    this->m_runtime.wakeupTime = Fw::Time(static_cast<TimeBase::T>(base), ctx, seconds, uSeconds);
    return Signal::stmtResponse_beginSleep;
}

Signal FpySequencer::goto_directiveHandler(const FpySequencer_GotoDirective& directive, DirectiveError& error) {
    // check within sequence bounds, or at EOF (we allow == case cuz this just ends the sequence)
    if (directive.get_statementIndex() > m_sequenceObj.get_header().get_statementCount()) {
        error = DirectiveError::STMT_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    m_runtime.nextStatementIndex = directive.get_statementIndex();
    return Signal::stmtResponse_success;
}

Signal FpySequencer::if_directiveHandler(const FpySequencer_IfDirective& directive, DirectiveError& error) {
    if (this->m_runtime.stack.size < 1) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    // check within sequence bounds, or at EOF (we allow == case cuz this just ends the sequence)
    if (directive.get_falseGotoStmtIndex() > m_sequenceObj.get_header().get_statementCount()) {
        error = DirectiveError::STMT_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }

    if (this->m_runtime.stack.pop<U8>() != 0) {
        // proceed to next instruction
        return Signal::stmtResponse_success;
    }

    // conditional false case
    this->m_runtime.nextStatementIndex = directive.get_falseGotoStmtIndex();
    return Signal::stmtResponse_success;
}

Signal FpySequencer::noOp_directiveHandler(const FpySequencer_NoOpDirective& directive, DirectiveError& error) {
    return Signal::stmtResponse_success;
}

Signal FpySequencer::pushTlmVal_directiveHandler(const FpySequencer_PushTlmValDirective& directive,
                                                 DirectiveError& error) {
    if (!this->isConnected_getTlmChan_OutputPort(0)) {
        error = DirectiveError::TLM_GET_NOT_CONNECTED;
        return Signal::stmtResponse_failure;
    }
    Fw::Time tlmTime;
    Fw::TlmBuffer tlmValue;
    Fw::TlmValid valid = this->getTlmChan_out(0, directive.get_chanId(), tlmTime, tlmValue);

    if (valid != Fw::TlmValid::VALID) {
        // could not find this tlm chan
        error = DirectiveError::TLM_CHAN_NOT_FOUND;
        return Signal::stmtResponse_failure;
    }

    if (tlmValue.getSize() > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    this->m_runtime.stack.push(tlmValue.getBuffAddr(), static_cast<Fpy::StackSizeType>(tlmValue.getSize()));
    return Signal::stmtResponse_success;
}

Signal FpySequencer::pushTlmValAndTime_directiveHandler(const FpySequencer_PushTlmValAndTimeDirective& directive,
                                                        DirectiveError& error) {
    if (!this->isConnected_getTlmChan_OutputPort(0)) {
        error = DirectiveError::TLM_GET_NOT_CONNECTED;
        return Signal::stmtResponse_failure;
    }

    Fw::Time tlmTime;
    Fw::TlmBuffer tlmValue;
    Fw::TlmValid valid = this->getTlmChan_out(0, directive.get_chanId(), tlmTime, tlmValue);

    if (valid != Fw::TlmValid::VALID) {
        // could not find this tlm chan
        error = DirectiveError::TLM_CHAN_NOT_FOUND;
        return Signal::stmtResponse_failure;
    }

    U8 tlmTimeBuf[Fw::Time::SERIALIZED_SIZE] = {};
    Fw::ExternalSerializeBuffer timeEsb(tlmTimeBuf, Fw::Time::SERIALIZED_SIZE);
    Fw::SerializeStatus stat = timeEsb.serializeFrom(tlmTime);

    // coding error if this failed, we should have enough space
    FW_ASSERT(stat == Fw::SerializeStatus::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(stat));

    // check that our stack won't overflow if we put both val and time on it
    if (tlmValue.getSize() + timeEsb.getSize() > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }

    // push tlm to end of stack
    this->m_runtime.stack.push(tlmValue.getBuffAddr(), static_cast<Fpy::StackSizeType>(tlmValue.getSize()));
    // now push time to end of stack
    this->m_runtime.stack.push(timeEsb.getBuffAddr(), static_cast<Fpy::StackSizeType>(timeEsb.getSize()));
    return Signal::stmtResponse_success;
}

Signal FpySequencer::pushPrm_directiveHandler(const FpySequencer_PushPrmDirective& directive, DirectiveError& error) {
    if (!this->isConnected_getParam_OutputPort(0)) {
        error = DirectiveError::PRM_GET_NOT_CONNECTED;
        return Signal::stmtResponse_failure;
    }

    Fw::ParamBuffer prmValue;
    Fw::ParamValid valid = this->getParam_out(0, directive.get_prmId(), prmValue);

    if (valid != Fw::ParamValid::VALID) {
        // could not find this prm in the DB
        error = DirectiveError::PRM_NOT_FOUND;
        return Signal::stmtResponse_failure;
    }

    if (prmValue.getSize() > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }

    this->m_runtime.stack.push(prmValue.getBuffAddr(), static_cast<Fpy::StackSizeType>(prmValue.getSize()));
    return Signal::stmtResponse_success;
}

Signal FpySequencer::constCmd_directiveHandler(const FpySequencer_ConstCmdDirective& directive, DirectiveError& error) {
    // the cmd response code will be pushed to the stack when it comes back, so make sure
    // there is room for it now, before the cmd is dispatched
    if (sizeof(Fw::CmdResponse::SerialType) > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    if (this->sendCmd(directive.get_opCode(), directive.get_argBuf(), directive.get__argBufSize()) ==
        Fw::Success::FAILURE) {
        return Signal::stmtResponse_failure;
    } else {
        // now tell the SM to wait some more until we get the cmd response back
        // if we've already got the response back this should be harmless
        return Signal::stmtResponse_keepWaiting;
    }
}

DirectiveError FpySequencer::op_or() {
    if (this->m_runtime.stack.size < sizeof(U8) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<U8>(this->m_runtime.stack.pop<U8>() | this->m_runtime.stack.pop<U8>()));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_and() {
    if (this->m_runtime.stack.size < sizeof(U8) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<U8>(this->m_runtime.stack.pop<U8>() & this->m_runtime.stack.pop<U8>()));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ieq() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<U8>((this->m_runtime.stack.pop<I64>() == this->m_runtime.stack.pop<I64>())
                                                   ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                   : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ine() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<U8>((this->m_runtime.stack.pop<I64>() != this->m_runtime.stack.pop<I64>())
                                                   ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                   : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ult() {
    if (this->m_runtime.stack.size < sizeof(U64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 rhs = this->m_runtime.stack.pop<U64>();
    U64 lhs = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs < rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                           : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ule() {
    if (this->m_runtime.stack.size < sizeof(U64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 rhs = this->m_runtime.stack.pop<U64>();
    U64 lhs = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs <= rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                            : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ugt() {
    if (this->m_runtime.stack.size < sizeof(U64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 rhs = this->m_runtime.stack.pop<U64>();
    U64 lhs = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs > rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                           : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_uge() {
    if (this->m_runtime.stack.size < sizeof(U64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 rhs = this->m_runtime.stack.pop<U64>();
    U64 lhs = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs >= rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                            : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_slt() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs < rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                           : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_sle() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs <= rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                            : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_sgt() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs > rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                           : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_sge() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    this->m_runtime.stack.push(static_cast<U8>((lhs >= rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                            : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_feq() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    // eq is true if they are equal and neither is nan
    this->m_runtime.stack.push(static_cast<U8>((lhs == rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                            : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fne() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    // ne is true if they are not equal or either is nan
    this->m_runtime.stack.push(static_cast<U8>((lhs != rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                            : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_flt() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<U8>(std::isless(lhs, rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                                     : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fle() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<U8>(std::islessequal(lhs, rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                                          : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fgt() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<U8>(std::isgreater(lhs, rhs) ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                                        : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fge() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<U8>(std::isgreaterequal(lhs, rhs)
                                                   ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                   : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_not() {
    if (this->m_runtime.stack.size < sizeof(U8)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<U8>((this->m_runtime.stack.pop<U8>() == 0)
                                                   ? static_cast<U8>(FW_SERIALIZE_TRUE_VALUE)
                                                   : static_cast<U8>(FW_SERIALIZE_FALSE_VALUE)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fpext() {
    // convert F32 to F64
    if (this->m_runtime.stack.size < sizeof(F32)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<F64>(this->m_runtime.stack.pop<F32>()));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fptrunc() {
    // convert F64 to F32
    if (this->m_runtime.stack.size < sizeof(F64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<F32>(this->m_runtime.stack.pop<F64>()));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fptosi() {
    if (this->m_runtime.stack.size < sizeof(F64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 val = this->m_runtime.stack.pop<F64>();
    // NaN -> 0, out-of-range clamps, in-range truncates toward
    // zero. The raw static_cast is UB for NaN and out-of-range values.
    // 2^63 is exactly representable as F64 and is one past I64 max; -2^63
    // is exactly I64 min and in range.
    const F64 bound = std::ldexp(1.0, 63);
    I64 result;
    if (std::isnan(val)) {
        result = 0;
    } else if (val >= bound) {
        result = std::numeric_limits<I64>::max();
    } else if (val < -bound) {
        result = std::numeric_limits<I64>::min();
    } else {
        result = static_cast<I64>(val);
    }
    this->m_runtime.stack.push(result);
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_sitofp() {
    if (this->m_runtime.stack.size < sizeof(I64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<F64>(this->m_runtime.stack.pop<I64>()));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fptoui() {
    if (this->m_runtime.stack.size < sizeof(F64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 val = this->m_runtime.stack.pop<F64>();
    // NaN -> 0, negatives truncate to at most 0 and clamp there,
    // 2^64 (one past U64 max) and above clamp to U64 max. The raw
    // static_cast is UB for NaN and out-of-range values.
    const F64 bound = std::ldexp(1.0, 64);
    U64 result;
    if (std::isnan(val) || val < 0.0) {
        result = 0;
    } else if (val >= bound) {
        result = std::numeric_limits<U64>::max();
    } else {
        result = static_cast<U64>(val);
    }
    this->m_runtime.stack.push(result);
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_uitofp() {
    if (this->m_runtime.stack.size < sizeof(U64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<F64>(this->m_runtime.stack.pop<U64>()));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_add() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    // Check for overflow and underflow and return the appropriate error code
    // Overflow can only occur with both operands positive and occurs when one operand is greater than the maximum value
    // less the other operand.  If either operand is negative or zero, overflow cannot occur.
    if ((rhs > 0) && (lhs > 0) && ((std::numeric_limits<I64>::max() - rhs) < lhs)) {
        return DirectiveError::ARITHMETIC_OVERFLOW;
    }
    // Underflow can only occur with both operands negative and occurs when one operand is less than the minimum value
    // minus the other operand.  If either operand is positive or zero, underflow cannot occur.
    else if ((rhs < 0) && (lhs < 0) && ((std::numeric_limits<I64>::min() - rhs) > lhs)) {
        return DirectiveError::ARITHMETIC_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<I64>(lhs + rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_sub() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    // Check for overflow and underflow and return the appropriate error code
    // Overflow can only occur when the left operand is positive and the right operand is negative. It occurs when the
    // left (positive) operand is greater than the maximum value plus the other (negative) operand. If the right
    // operand is positive or zero, overflow cannot occur.
    if ((rhs < 0) && (lhs > 0) && ((std::numeric_limits<I64>::max() + rhs) < lhs)) {
        return DirectiveError::ARITHMETIC_OVERFLOW;
    }
    // Underflow can only occur when the left operand is negative and the right operand is positive. It occurs when the
    // left (negative) operand is less than the minimum value plus the other (positive) operand. If the right operand
    // is negative or zero, underflow cannot occur.
    else if ((rhs > 0) && (lhs < 0) && ((std::numeric_limits<I64>::min() + rhs) > lhs)) {
        return DirectiveError::ARITHMETIC_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<I64>(lhs - rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_mul() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    // Check for overflow and underflow and return the appropriate error code
    // Overflow can only occur with operands of matching signs and occurs when one operand is greater (or less) than the
    // maximum value divided by the other operand. Either operand being zero precludes overflow.
    // Check the both positive case.
    if ((rhs > 0) && (lhs > 0) && ((std::numeric_limits<I64>::max() / rhs) < lhs)) {
        return DirectiveError::ARITHMETIC_OVERFLOW;
    }
    // Check the both negative case. Compare without negation: negating a value of min is undefined behavior
    else if ((rhs < 0) && (lhs < 0) && (lhs < (std::numeric_limits<I64>::max() / rhs))) {
        return DirectiveError::ARITHMETIC_OVERFLOW;
    }
    // Underflow can occur with operands of differing signs and occurs when one operand is less than the minimum value
    // divided by the other operand. Either operand being zero precludes underflow.
    // Check the case where lhs is positive.
    else if ((rhs < 0) && (lhs > 0) && ((std::numeric_limits<I64>::min() / lhs) > rhs)) {
        return DirectiveError::ARITHMETIC_UNDERFLOW;
    }
    // Check the case where rhs is positive.
    else if ((rhs > 0) && (lhs < 0) && ((std::numeric_limits<I64>::min() / rhs) > lhs)) {
        return DirectiveError::ARITHMETIC_UNDERFLOW;
    }
    this->m_runtime.stack.push(static_cast<I64>(lhs * rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_udiv() {
    if (this->m_runtime.stack.size < sizeof(U64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 rhs = this->m_runtime.stack.pop<U64>();
    U64 lhs = this->m_runtime.stack.pop<U64>();
    // Prevent division by zero
    if (rhs == 0) {
        return DirectiveError::DOMAIN_ERROR;
    }
    this->m_runtime.stack.push(static_cast<U64>(lhs / rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_sdiv() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }

    I64 rhs = this->m_runtime.stack.pop<I64>();
    I64 lhs = this->m_runtime.stack.pop<I64>();
    // Prevent division by zero
    if (rhs == 0) {
        return DirectiveError::DOMAIN_ERROR;
    }
    // The one signed division that can overflow: |I64 min / -1| = 2^63 is not
    // representable (and the C++ expression is UB, SIGFPE on x86)
    if ((lhs == std::numeric_limits<I64>::min()) && (rhs == -1)) {
        return DirectiveError::ARITHMETIC_OVERFLOW;
    }
    // C++ / truncates toward zero; adjust to match Python's floored division:
    // an inexact quotient with differing operand signs floors one below the
    // truncated result. This mirrors op_smod.
    I64 quotient = lhs / rhs;
    if (((lhs % rhs) != 0) && ((lhs < 0) != (rhs < 0))) {
        quotient -= 1;
    }
    this->m_runtime.stack.push(quotient);
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_umod() {
    if (this->m_runtime.stack.size < sizeof(U64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 rhs = this->m_runtime.stack.pop<U64>();
    if (rhs == 0) {
        return DirectiveError::DOMAIN_ERROR;
    }
    U64 lhs = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U64>(lhs % rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_smod() {
    if (this->m_runtime.stack.size < sizeof(I64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 rhs = this->m_runtime.stack.pop<I64>();
    if (rhs == 0) {
        return DirectiveError::DOMAIN_ERROR;
    }
    I64 lhs = this->m_runtime.stack.pop<I64>();
    // I64 min % -1 is 0, the mathematical remainder (matching wasm i64.rem_s),
    // but the C++ expression is UB (SIGFPE on x86) so it must be special-cased
    if ((lhs == std::numeric_limits<I64>::min()) && (rhs == -1)) {
        this->m_runtime.stack.push(static_cast<I64>(0));
        return DirectiveError::NO_ERROR;
    }
    I64 res = static_cast<I64>(lhs % rhs);
    // in order to match Python's behavior,
    // if the signs of the remainder and divisor differ, adjust the result.
    // this happens when the result should be positive but is negative, or vice-versa.
    // credit Gemini 2.5 pro
    if ((res > 0 && rhs < 0) || (res < 0 && rhs > 0)) {
        res += rhs;
    }
    this->m_runtime.stack.push(res);
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fadd() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<F64>(lhs + rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fsub() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<F64>(lhs - rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fmul() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<F64>(lhs * rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fdiv() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<F64>(lhs / rhs));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fpow() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    this->m_runtime.stack.push(static_cast<F64>(pow(lhs, rhs)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_flog() {
    if (this->m_runtime.stack.size < sizeof(F64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 val = this->m_runtime.stack.pop<F64>();
    if (val <= 0.0) {
        return DirectiveError::DOMAIN_ERROR;
    }
    this->m_runtime.stack.push(static_cast<F64>(log(val)));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fmod() {
    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 rhs = this->m_runtime.stack.pop<F64>();
    F64 lhs = this->m_runtime.stack.pop<F64>();
    // std::fmod computes the exact truncated remainder (sign of lhs) with no
    // intermediate rounding. A zero divisor yields NaN, matching Rust and C#.
    F64 res = std::fmod(lhs, rhs);
    // Adjust to match Python's floored-modulo semantics: if the signs of the
    // remainder and divisor differ, add the divisor once. This mirrors op_smod
    // and is the exact frem + fadd the VM model computes (at most one rounded add).
    if ((res > 0 && rhs < 0) || (res < 0 && rhs > 0)) {
        res += rhs;
    } else if (res == 0) {
        // Python normalizes an exact-multiple result so the zero carries the
        // divisor's sign (CPython float_rem); fmod leaves the dividend's.
        res = std::copysign(0.0, rhs);
    }
    this->m_runtime.stack.push(res);
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_siext_8_64() {
    if (this->m_runtime.stack.size < sizeof(I8)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I8 src = this->m_runtime.stack.pop<I8>();
    this->m_runtime.stack.push(static_cast<I64>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_siext_16_64() {
    if (this->m_runtime.stack.size < sizeof(I16)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I16 src = this->m_runtime.stack.pop<I16>();
    this->m_runtime.stack.push(static_cast<I64>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_siext_32_64() {
    if (this->m_runtime.stack.size < sizeof(I32)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I32 src = this->m_runtime.stack.pop<I32>();
    this->m_runtime.stack.push(static_cast<I64>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ziext_8_64() {
    if (this->m_runtime.stack.size < sizeof(U8)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U8 src = this->m_runtime.stack.pop<U8>();
    this->m_runtime.stack.push(static_cast<U64>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ziext_16_64() {
    if (this->m_runtime.stack.size < sizeof(U16)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U16 src = this->m_runtime.stack.pop<U16>();
    this->m_runtime.stack.push(static_cast<U64>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ziext_32_64() {
    if (this->m_runtime.stack.size < sizeof(U32)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U32 src = this->m_runtime.stack.pop<U32>();
    this->m_runtime.stack.push(static_cast<U64>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_itrunc_64_8() {
    if (this->m_runtime.stack.size < sizeof(U64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 src = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U8>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_itrunc_64_16() {
    if (this->m_runtime.stack.size < sizeof(U64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 src = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U16>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_itrunc_64_32() {
    if (this->m_runtime.stack.size < sizeof(U64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    U64 src = this->m_runtime.stack.pop<U64>();
    this->m_runtime.stack.push(static_cast<U32>(src));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_ffloor() {
    if (this->m_runtime.stack.size < sizeof(F64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 val = this->m_runtime.stack.pop<F64>();
    // std::floor implements IEEE 754 roundToIntegralTowardNegative: +-0, +-inf
    // and NaN pass through, and the sign of a zero is preserved.
    this->m_runtime.stack.push(std::floor(val));
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_iabs() {
    if (this->m_runtime.stack.size < sizeof(I64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    I64 val = this->m_runtime.stack.pop<I64>();
    // abs(I64 min) is not representable in I64 (and -val on it is UB)
    if (val == std::numeric_limits<I64>::min()) {
        return DirectiveError::ARITHMETIC_OVERFLOW;
    }
    this->m_runtime.stack.push(val < 0 ? -val : val);
    return DirectiveError::NO_ERROR;
}
DirectiveError FpySequencer::op_fabs() {
    if (this->m_runtime.stack.size < sizeof(F64)) {
        return DirectiveError::STACK_UNDERFLOW;
    }
    F64 val = this->m_runtime.stack.pop<F64>();
    // IEEE 754 abs: clears the sign bit and changes nothing else, so NaN
    // payloads pass through.
    this->m_runtime.stack.push(std::fabs(val));
    return DirectiveError::NO_ERROR;
}
Signal FpySequencer::stackOp_directiveHandler(const FpySequencer_StackOpDirective& directive, DirectiveError& error) {
    // coding error, should not have gotten to this stack op handler
    FW_ASSERT((directive.get__op() >= Fpy::DirectiveId::OR && directive.get__op() <= Fpy::DirectiveId::ITRUNC_64_32) ||
                  (directive.get__op() >= Fpy::DirectiveId::FFLOOR && directive.get__op() <= Fpy::DirectiveId::FABS),
              static_cast<FwAssertArgType>(directive.get__op()));

    switch (directive.get__op()) {
        case Fpy::DirectiveId::OR:
            error = this->op_or();
            break;
        case Fpy::DirectiveId::AND:
            error = this->op_and();
            break;
        case Fpy::DirectiveId::IEQ:
            error = this->op_ieq();
            break;
        case Fpy::DirectiveId::INE:
            error = this->op_ine();
            break;
        case Fpy::DirectiveId::ULT:
            error = this->op_ult();
            break;
        case Fpy::DirectiveId::ULE:
            error = this->op_ule();
            break;
        case Fpy::DirectiveId::UGT:
            error = this->op_ugt();
            break;
        case Fpy::DirectiveId::UGE:
            error = this->op_uge();
            break;
        case Fpy::DirectiveId::SLT:
            error = this->op_slt();
            break;
        case Fpy::DirectiveId::SLE:
            error = this->op_sle();
            break;
        case Fpy::DirectiveId::SGT:
            error = this->op_sgt();
            break;
        case Fpy::DirectiveId::SGE:
            error = this->op_sge();
            break;
        case Fpy::DirectiveId::FEQ:
            error = this->op_feq();
            break;
        case Fpy::DirectiveId::FNE:
            error = this->op_fne();
            break;
        case Fpy::DirectiveId::FLT:
            error = this->op_flt();
            break;
        case Fpy::DirectiveId::FLE:
            error = this->op_fle();
            break;
        case Fpy::DirectiveId::FGT:
            error = this->op_fgt();
            break;
        case Fpy::DirectiveId::FGE:
            error = this->op_fge();
            break;
        case Fpy::DirectiveId::NOT:
            error = this->op_not();
            break;
        case Fpy::DirectiveId::FPEXT:
            error = this->op_fpext();
            break;
        case Fpy::DirectiveId::FPTRUNC:
            error = this->op_fptrunc();
            break;
        case Fpy::DirectiveId::FPTOSI:
            error = this->op_fptosi();
            break;
        case Fpy::DirectiveId::FPTOUI:
            error = this->op_fptoui();
            break;
        case Fpy::DirectiveId::SITOFP:
            error = this->op_sitofp();
            break;
        case Fpy::DirectiveId::UITOFP:
            error = this->op_uitofp();
            break;
        case Fpy::DirectiveId::ADD:
            error = this->op_add();
            break;
        case Fpy::DirectiveId::SUB:
            error = this->op_sub();
            break;
        case Fpy::DirectiveId::MUL:
            error = this->op_mul();
            break;
        case Fpy::DirectiveId::UDIV:
            error = this->op_udiv();
            break;
        case Fpy::DirectiveId::SDIV:
            error = this->op_sdiv();
            break;
        case Fpy::DirectiveId::UMOD:
            error = this->op_umod();
            break;
        case Fpy::DirectiveId::SMOD:
            error = this->op_smod();
            break;
        case Fpy::DirectiveId::FADD:
            error = this->op_fadd();
            break;
        case Fpy::DirectiveId::FSUB:
            error = this->op_fsub();
            break;
        case Fpy::DirectiveId::FMUL:
            error = this->op_fmul();
            break;
        case Fpy::DirectiveId::FDIV:
            error = this->op_fdiv();
            break;
        case Fpy::DirectiveId::FPOW:
            error = this->op_fpow();
            break;
        case Fpy::DirectiveId::FLOG:
            error = this->op_flog();
            break;
        case Fpy::DirectiveId::FMOD:
            error = this->op_fmod();
            break;
        case Fpy::DirectiveId::SIEXT_8_64:
            error = this->op_siext_8_64();
            break;
        case Fpy::DirectiveId::SIEXT_16_64:
            error = this->op_siext_16_64();
            break;
        case Fpy::DirectiveId::SIEXT_32_64:
            error = this->op_siext_32_64();
            break;
        case Fpy::DirectiveId::ZIEXT_8_64:
            error = this->op_ziext_8_64();
            break;
        case Fpy::DirectiveId::ZIEXT_16_64:
            error = this->op_ziext_16_64();
            break;
        case Fpy::DirectiveId::ZIEXT_32_64:
            error = this->op_ziext_32_64();
            break;
        case Fpy::DirectiveId::ITRUNC_64_8:
            error = this->op_itrunc_64_8();
            break;
        case Fpy::DirectiveId::ITRUNC_64_16:
            error = this->op_itrunc_64_16();
            break;
        case Fpy::DirectiveId::ITRUNC_64_32:
            error = this->op_itrunc_64_32();
            break;
        case Fpy::DirectiveId::FFLOOR:
            error = this->op_ffloor();
            break;
        case Fpy::DirectiveId::IABS:
            error = this->op_iabs();
            break;
        case Fpy::DirectiveId::FABS:
            error = this->op_fabs();
            break;
        default:
            FW_ASSERT(false, directive.get__op());
            break;
    }
    if (error != DirectiveError::NO_ERROR) {
        return Signal::stmtResponse_failure;
    }
    return Signal::stmtResponse_success;
}

Signal FpySequencer::exit_directiveHandler(const FpySequencer_ExitDirective& directive, DirectiveError& error) {
    if (this->m_runtime.stack.size < sizeof(I32)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    I32 errorCode = this->m_runtime.stack.pop<I32>();
    // exit(0), no error
    if (errorCode == 0) {
        // just goto the end of the sequence
        this->m_runtime.nextStatementIndex = this->m_sequenceObj.get_header().get_statementCount();
        return Signal::stmtResponse_success;
    }
    // otherwise, kill the sequence here
    // raise the user defined error code as an event
    this->log_WARNING_HI_SequenceExitedWithError(this->m_sequenceFilePath, errorCode);
    error = DirectiveError::EXIT_WITH_ERROR;
    return Signal::stmtResponse_failure;
}

Signal FpySequencer::allocate_directiveHandler(const FpySequencer_AllocateDirective& directive, DirectiveError& error) {
    if (directive.get_size() > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    this->m_runtime.stack.pushZeroes(directive.get_size());
    return Signal::stmtResponse_success;
}

Signal FpySequencer::storeHelper(Fpy::StackSizeType destOffset, Fpy::StackSizeType size, DirectiveError& error) {
    if (this->m_runtime.stack.size < size) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    // After popping the value, would the write go out of bounds?
    Fpy::StackSizeType newStackSize = this->m_runtime.stack.size - size;
    // Overflow-safe check: destOffset + size > newStackSize
    // Rewritten as: check destOffset <= newStackSize first, then size > newStackSize - destOffset
    if (destOffset > newStackSize || size > newStackSize - destOffset) {
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    // Copy value to the destination location
    this->m_runtime.stack.copy(destOffset, this->m_runtime.stack.size - size, size);
    this->m_runtime.stack.size = newStackSize;
    return Signal::stmtResponse_success;
}

Signal FpySequencer::loadHelper(Fpy::StackSizeType srcOffset, Fpy::StackSizeType size, DirectiveError& error) {
    if (size > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    // Overflow-safe check: srcOffset + size > stack.size
    // Rewritten as: check srcOffset <= stack.size first, then size > stack.size - srcOffset
    if (srcOffset > this->m_runtime.stack.size || size > this->m_runtime.stack.size - srcOffset) {
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    // Copy from source location to top of stack
    this->m_runtime.stack.copy(this->m_runtime.stack.size, srcOffset, size);
    this->m_runtime.stack.size += size;
    return Signal::stmtResponse_success;
}

Signal FpySequencer::storeRelConstOffset_directiveHandler(const FpySequencer_StoreRelConstOffsetDirective& directive,
                                                          DirectiveError& error) {
    I64 addr = static_cast<I64>(this->m_runtime.stack.currentFrameStart) + directive.get_lvarOffset();
    if (addr < 0 || addr > Fpy::MAX_STACK_SIZE) {
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    return this->storeHelper(static_cast<Fpy::StackSizeType>(addr), directive.get_size(), error);
}

Signal FpySequencer::loadRel_directiveHandler(const FpySequencer_LoadRelDirective& directive, DirectiveError& error) {
    I64 addr = static_cast<I64>(this->m_runtime.stack.currentFrameStart) + directive.get_lvarOffset();
    if (addr < 0 || addr > Fpy::MAX_STACK_SIZE) {
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    return this->loadHelper(static_cast<Fpy::StackSizeType>(addr), directive.get_size(), error);
}

Signal FpySequencer::pushVal_directiveHandler(const FpySequencer_PushValDirective& directive, DirectiveError& error) {
    if (directive.get__valSize() > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    // copy from the bytearray in the directive to the stack, add to stack size.
    this->m_runtime.stack.push(const_cast<U8*>(directive.get_val()),
                               static_cast<Fpy::StackSizeType>(directive.get__valSize()));
    return Signal::stmtResponse_success;
}

Signal FpySequencer::discard_directiveHandler(const FpySequencer_DiscardDirective& directive, DirectiveError& error) {
    if (this->m_runtime.stack.size < directive.get_size()) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    // drop the specified amount of bytes off the stack. simple as.
    this->m_runtime.stack.size -= directive.get_size();
    return Signal::stmtResponse_success;
}

Signal FpySequencer::memCmp_directiveHandler(const FpySequencer_MemCmpDirective& directive, DirectiveError& error) {
    // Overflow-safe check: we need size * 2 bytes on the stack
    // First check that size * 2 doesn't overflow: size > MAX/2 would overflow
    // MAX_STACK_SIZE is the upper bound for stack.size, so if size > MAX_STACK_SIZE/2, we definitely don't have enough
    if (directive.get_size() > Fpy::MAX_STACK_SIZE / 2) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    // Now safe to compute size * 2
    if (this->m_runtime.stack.size < directive.get_size() * 2) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // find the starting offsets of the two byte arrays
    U64 lhsOffset = this->m_runtime.stack.size - directive.get_size() * 2;
    U64 rhsOffset = this->m_runtime.stack.size - directive.get_size();

    // "officially" remove them from the stack
    // you have to do this before pushing to the stack, otherwise the result would get placed
    // after the byte arrays
    this->m_runtime.stack.size -= directive.get_size() * 2;

    // memcmp the two byte arrays, push FW_SERIALIZE_TRUE_VALUE if they were equal, FW_SERIALIZE_FALSE_VALUE otherwise
    if (memcmp(this->m_runtime.stack.bytes + lhsOffset, this->m_runtime.stack.bytes + rhsOffset,
               directive.get_size()) == 0) {
        this->m_runtime.stack.push<U8>(static_cast<U8>(FW_SERIALIZE_TRUE_VALUE));
    } else {
        this->m_runtime.stack.push<U8>(static_cast<U8>(FW_SERIALIZE_FALSE_VALUE));
    }
    return Signal::stmtResponse_success;
}

Signal FpySequencer::stackCmd_directiveHandler(const FpySequencer_StackCmdDirective& directive, DirectiveError& error) {
    // Overflow-safe check: need argsSize + sizeof(FwOpcodeType) bytes
    // Check stack.size >= sizeof(FwOpcodeType) first, then stack.size - sizeof(FwOpcodeType) >= argsSize
    if (this->m_runtime.stack.size < sizeof(FwOpcodeType) ||
        this->m_runtime.stack.size - sizeof(FwOpcodeType) < directive.get_argsSize()) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // pop the opcode of the cmd off the stack
    // note this means that, unlike the actual byte array that the dispatcher gets,
    // these cmds have opcode after the argument buffer
    FwOpcodeType opcode = this->m_runtime.stack.pop<FwOpcodeType>();
    U64 argBufOffset = this->m_runtime.stack.size - directive.get_argsSize();

    // update the opcode of the cmd we will await
    this->m_runtime.currentCmdOpcode = opcode;

    // also pop the args off the stack
    this->m_runtime.stack.size -= directive.get_argsSize();

    // the cmd response code will be pushed to the stack when it comes back, so make sure
    // there is room for it now, before the cmd is dispatched. popping the opcode above
    // frees some room, but FwOpcodeType is configurable so it may not be enough
    if (sizeof(Fw::CmdResponse::SerialType) > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }

    if (this->sendCmd(opcode, this->m_runtime.stack.bytes + argBufOffset, directive.get_argsSize()) ==
        Fw::Success::FAILURE) {
        return Signal::stmtResponse_failure;
    } else {
        // now tell the SM to wait some more until we get the cmd response back
        // if we've already got the response back this should be harmless
        return Signal::stmtResponse_keepWaiting;
    }

    return Signal::stmtResponse_success;
}

Signal FpySequencer::pushTime_directiveHandler(const FpySequencer_PushTimeDirective& directive, DirectiveError& error) {
    if (Fw::Time::SERIALIZED_SIZE > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }

    Fw::Time currentTime = this->getTime();

    U8 currentTimeBuf[Fw::Time::SERIALIZED_SIZE] = {};
    Fw::ExternalSerializeBuffer timeEsb(currentTimeBuf, Fw::Time::SERIALIZED_SIZE);
    Fw::SerializeStatus stat = timeEsb.serializeFrom(currentTime);

    // coding error if this failed, we should have enough space
    FW_ASSERT(stat == Fw::SerializeStatus::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(stat));

    // push time to end of stack
    this->m_runtime.stack.push(timeEsb.getBuffAddr(), static_cast<Fpy::StackSizeType>(timeEsb.getSize()));
    return Signal::stmtResponse_success;
}

Signal FpySequencer::setSeed_directiveHandler(const FpySequencer_SetSeedDirective& directive, DirectiveError& error) {
    if (this->m_runtime.stack.size < sizeof(U32)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    U32 seed = this->m_runtime.stack.pop<U32>();
    this->m_runtime.rng.seed(seed);
    this->m_runtime.rngSeeded = true;
    return Signal::stmtResponse_success;
}

Signal FpySequencer::pushRand_directiveHandler(const FpySequencer_PushRandDirective& directive, DirectiveError& error) {
    if (sizeof(U32) > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }

    if (!this->m_runtime.rngSeeded) {
        Fw::Time currentTime = this->getTime();
        std::seed_seq seedSeq{static_cast<U32>(currentTime.getTimeBase()), static_cast<U32>(currentTime.getContext()),
                              currentTime.getSeconds(), currentTime.getUSeconds()};
        this->m_runtime.rng.seed(seedSeq);
        this->m_runtime.rngSeeded = true;
    }

    U32 randVal = static_cast<U32>(this->m_runtime.rng());
    this->m_runtime.stack.push(randVal);
    return Signal::stmtResponse_success;
}

Signal FpySequencer::getField_directiveHandler(const FpySequencer_GetFieldDirective& directive, DirectiveError& error) {
    // Need sizeof(StackSizeType) for the offset AND parentSize for the parent data
    // Check we have enough for the offset first
    if (this->m_runtime.stack.size < sizeof(Fpy::StackSizeType)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    // After popping the offset, we need at least parentSize bytes remaining
    if (this->m_runtime.stack.size - sizeof(Fpy::StackSizeType) < directive.get_parentSize()) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    Fpy::StackSizeType offset = this->m_runtime.stack.pop<Fpy::StackSizeType>();

    // Overflow-safe check: offset + memberSize > parentSize
    // Rewritten as: check offset <= parentSize first, then memberSize > parentSize - offset
    if (offset > directive.get_parentSize() || directive.get_memberSize() > directive.get_parentSize() - offset) {
        // i think it's somewhat ambiguous whether this is a stack access out of bounds
        // but there isn't really an error code that better reflects this, and i guess
        // it's technically true
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }

    // the resulting bytes should move to the start of the parent array

    // Calculate the offset of the parent start in the stack
    Fpy::StackSizeType parentStartOffset = this->m_runtime.stack.size - directive.get_parentSize();
    // Overflow-safe: parentStartOffset + offset cannot overflow since offset <= parentSize
    // and parentStartOffset + parentSize == stack.size (which is bounded)
    this->m_runtime.stack.move(parentStartOffset, parentStartOffset + offset, directive.get_memberSize());
    // adjust stack size by the diff between the member and the parent
    this->m_runtime.stack.size -= (directive.get_parentSize() - directive.get_memberSize());
    return Signal::stmtResponse_success;
}

Signal FpySequencer::peek_directiveHandler(const FpySequencer_PeekDirective& directive, DirectiveError& error) {
    // must have at least two StackSizeType on stack
    if (this->m_runtime.stack.size < sizeof(Fpy::StackSizeType) * 2) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    Fpy::StackSizeType offset = this->m_runtime.stack.pop<Fpy::StackSizeType>();
    Fpy::StackSizeType byteCount = this->m_runtime.stack.pop<Fpy::StackSizeType>();

    // Check offset doesn't exceed stack size (after both pops)
    if (offset > this->m_runtime.stack.size) {
        // would access past the bottom of the stack
        // note we allow the equals case because the byteCount might be 0
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    if (byteCount > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        // we would overflow the stack if we pushed this many bytes to it
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    // Overflow-safe check: byteCount + offset > stack.size
    // Rewritten as: check offset <= stack.size (done above), then byteCount > stack.size - offset
    if (byteCount > this->m_runtime.stack.size - offset) {
        // would access past the bottom of the stack
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    // start copying from the lowest byte of the src array
    U8* src = this->m_runtime.stack.top() - offset - byteCount;
    this->m_runtime.stack.push(src, byteCount);
    return Signal::stmtResponse_success;
}

Signal FpySequencer::storeRel_directiveHandler(const FpySequencer_StoreRelDirective& directive, DirectiveError& error) {
    // Need enough bytes for the value and the offset (SignedStackSizeType = 4 bytes)
    // Overflow-safe: check stack.size >= sizeof(SignedStackSizeType) first, then stack.size -
    // sizeof(SignedStackSizeType) >= size
    if (this->m_runtime.stack.size < sizeof(Fpy::SignedStackSizeType) ||
        this->m_runtime.stack.size - sizeof(Fpy::SignedStackSizeType) < directive.get_size()) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Pop the signed offset from the stack
    Fpy::SignedStackSizeType lvarOffset = this->m_runtime.stack.pop<Fpy::SignedStackSizeType>();

    I64 addr = static_cast<I64>(this->m_runtime.stack.currentFrameStart) + lvarOffset;
    if (addr < 0 || addr > Fpy::MAX_STACK_SIZE) {
        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    return this->storeHelper(static_cast<Fpy::StackSizeType>(addr), directive.get_size(), error);
}

Signal FpySequencer::call_directiveHandler(const FpySequencer_CallDirective& directive, DirectiveError& error) {
    // Need at least 4 bytes for the target address
    if (this->m_runtime.stack.size < sizeof(U32)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Pop the target directive index from the stack
    U32 target = this->m_runtime.stack.pop<U32>();

    // Check if we have space to push return address and saved frame pointer (8 bytes total)
    if (this->m_runtime.stack.size + sizeof(Fpy::StackSizeType) + sizeof(U32) > Fpy::MAX_STACK_SIZE) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Check target is within bounds (will also be checked at execution time)
    if (target > m_sequenceObj.get_header().get_statementCount()) {
        error = DirectiveError::STMT_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }

    // Save the return address (next instruction after CALL)
    U32 returnAddr = this->m_runtime.nextStatementIndex;

    // Set the next instruction to the target
    this->m_runtime.nextStatementIndex = target;

    // Push the return address to the stack
    this->m_runtime.stack.push<U32>(returnAddr);

    // Push the current frame pointer to the stack
    this->m_runtime.stack.push<Fpy::StackSizeType>(this->m_runtime.stack.currentFrameStart);

    // Set the new frame pointer to the current top of stack
    this->m_runtime.stack.currentFrameStart = this->m_runtime.stack.size;

    return Signal::stmtResponse_success;
}

Signal FpySequencer::return_directiveHandler(const FpySequencer_ReturnDirective& directive, DirectiveError& error) {
    Fpy::StackSizeType returnValSize = directive.get_returnValSize();
    Fpy::StackSizeType callArgsSize = directive.get_callArgsSize();

    // Check we have enough bytes for the return value
    if (this->m_runtime.stack.size < returnValSize) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Remember where the return value lives; it is moved down the stack below rather than copied
    // through a local buffer, which at Fpy::MAX_STACK_SIZE would not fit a typical task stack
    const Fpy::StackSizeType returnValOffset = this->m_runtime.stack.size - returnValSize;

    // Truncate the stack to stack_frame_start (discard all local variables)
    if (this->m_runtime.stack.currentFrameStart > this->m_runtime.stack.size) {
        error = DirectiveError::FRAME_START_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    this->m_runtime.stack.size = this->m_runtime.stack.currentFrameStart;

    // Check we have enough bytes for saved frame pointer and return address
    if (this->m_runtime.stack.size < sizeof(Fpy::StackSizeType) + sizeof(U32)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Pop the saved frame pointer
    Fpy::StackSizeType savedFramePtr = this->m_runtime.stack.pop<Fpy::StackSizeType>();

    // Pop the return address
    U32 returnAddr = this->m_runtime.stack.pop<U32>();

    // Restore the frame pointer
    if (savedFramePtr > this->m_runtime.stack.size) {
        error = DirectiveError::FRAME_START_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }
    this->m_runtime.stack.currentFrameStart = savedFramePtr;

    // Validate the return address is within bounds
    if (returnAddr > m_sequenceObj.get_header().get_statementCount()) {
        error = DirectiveError::STMT_OUT_OF_BOUNDS;
        return Signal::stmtResponse_failure;
    }

    // Set the next instruction to the return address
    this->m_runtime.nextStatementIndex = returnAddr;

    // Check that we have enough bytes for the call arguments
    if (this->m_runtime.stack.size < callArgsSize) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    // Discard the function arguments
    this->m_runtime.stack.size -= callArgsSize;

    // Push the return value
    if (returnValSize > Fpy::MAX_STACK_SIZE - this->m_runtime.stack.size) {
        error = DirectiveError::STACK_OVERFLOW;
        return Signal::stmtResponse_failure;
    }
    if (returnValSize > 0) {
        // Not Stack::move: the source region sits above the truncated stack size, which
        // Stack::move rejects. Both regions were bounds-checked above against MAX_STACK_SIZE.
        (void)memmove(this->m_runtime.stack.top(), &this->m_runtime.stack.bytes[returnValOffset], returnValSize);
        this->m_runtime.stack.size += returnValSize;
    }

    return Signal::stmtResponse_success;
}

Signal FpySequencer::loadAbs_directiveHandler(const FpySequencer_LoadAbsDirective& directive, DirectiveError& error) {
    return this->loadHelper(directive.get_globalOffset(), directive.get_size(), error);
}

Signal FpySequencer::storeAbs_directiveHandler(const FpySequencer_StoreAbsDirective& directive, DirectiveError& error) {
    Fpy::StackSizeType size = directive.get_size();

    // Need enough bytes for the value and the offset
    // Overflow-safe: check stack.size >= sizeof(StackSizeType) first, then stack.size - sizeof >= size
    if (this->m_runtime.stack.size < sizeof(Fpy::StackSizeType) ||
        this->m_runtime.stack.size - sizeof(Fpy::StackSizeType) < size) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Pop the global offset from the stack
    Fpy::StackSizeType globalOffset = this->m_runtime.stack.pop<Fpy::StackSizeType>();

    return this->storeHelper(globalOffset, size, error);
}

Signal FpySequencer::storeAbsConstOffset_directiveHandler(const FpySequencer_StoreAbsConstOffsetDirective& directive,
                                                          DirectiveError& error) {
    return this->storeHelper(directive.get_globalOffset(), directive.get_size(), error);
}

Signal FpySequencer::popEvent_directiveHandler(const FpySequencer_PopEventDirective& directive, DirectiveError& error) {
    // Pop messageSize from the stack
    if (this->m_runtime.stack.size < sizeof(Fpy::StackSizeType)) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }
    Fpy::StackSizeType messageSize = this->m_runtime.stack.pop<Fpy::StackSizeType>();

    const Fpy::StackSizeType severitySize = static_cast<Fpy::StackSizeType>(sizeof(Fw::LogSeverity::SerialType));

    // Need message_size bytes + sizeof(LogSeverity serial type) for severity
    if (this->m_runtime.stack.size < severitySize || this->m_runtime.stack.size - severitySize < messageSize) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Pop message bytes first
    U8 messageBuf[FW_LOG_STRING_MAX_SIZE] = {};
    // don't read in more than (log string size) - 1 bytes
    Fpy::StackSizeType clampedSize = std::min(messageSize, static_cast<Fpy::StackSizeType>(FW_LOG_STRING_MAX_SIZE - 1));
    // If message is larger than buffer, discard the excess bytes first (from top of stack, which is the end of the
    // message)
    if (messageSize > clampedSize) {
        Fpy::StackSizeType excess = messageSize - clampedSize;
        FW_ASSERT(this->m_runtime.stack.size >= excess, static_cast<FwAssertArgType>(this->m_runtime.stack.size),
                  static_cast<FwAssertArgType>(excess));
        this->m_runtime.stack.size -= excess;
    }
    this->m_runtime.stack.pop(messageBuf, clampedSize);
    messageBuf[clampedSize] = '\0';

    // Pop severity
    Fw::LogSeverity::SerialType severity = this->m_runtime.stack.pop<Fw::LogSeverity::SerialType>();

    // Construct the message string
    Fw::String messageStr(reinterpret_cast<const char*>(messageBuf));

    // Emit the appropriate event based on severity
    switch (severity) {
        case Fw::LogSeverity::FATAL:
            this->log_FATAL_LogFatal(this->m_sequenceFilePath, messageStr);
            break;
        case Fw::LogSeverity::WARNING_HI:
            this->log_WARNING_HI_LogWarningHi(this->m_sequenceFilePath, messageStr);
            break;
        case Fw::LogSeverity::WARNING_LO:
            this->log_WARNING_LO_LogWarningLo(this->m_sequenceFilePath, messageStr);
            break;
        case Fw::LogSeverity::COMMAND:
            this->log_COMMAND_LogCommand(this->m_sequenceFilePath, messageStr);
            break;
        case Fw::LogSeverity::ACTIVITY_HI:
            this->log_ACTIVITY_HI_LogActivityHi(this->m_sequenceFilePath, messageStr);
            break;
        case Fw::LogSeverity::ACTIVITY_LO:
            this->log_ACTIVITY_LO_LogActivityLo(this->m_sequenceFilePath, messageStr);
            break;
        case Fw::LogSeverity::DIAGNOSTIC:
            this->log_DIAGNOSTIC_LogDiagnostic(this->m_sequenceFilePath, messageStr);
            break;
        default:
            error = DirectiveError::INVALID_ARG;
            return Signal::stmtResponse_failure;
    }

    return Signal::stmtResponse_success;
}

Signal FpySequencer::popSerializable_directiveHandler(const FpySequencer_PopSerializableDirective& directive,
                                                      DirectiveError& error) {
    // No size assertion here: an oversized size is untrusted sequence content and is rejected by
    // the stack check below, since the stack can never hold more than Fpy::MAX_STACK_SIZE bytes

    // Validate port index is in range (using enum constant value)
    constexpr FwIndexType MAX_PORTS = static_cast<FwIndexType>(Svc::Fpy::SerialPortIndex::MAX_SERIAL_PORTS);
    const FwIndexType portIndex = directive.get_portIndex();

    // Check for negative port index or out of bounds
    if (portIndex < 0 || portIndex >= MAX_PORTS) {
        error = DirectiveError::SERIAL_PORT_INVALID_INDEX;
        return Signal::stmtResponse_failure;
    }

    // Check port is connected
    if (!this->isConnected_serialOut_OutputPort(portIndex)) {
        error = DirectiveError::SERIAL_PORT_NOT_CONNECTED;
        return Signal::stmtResponse_failure;
    }

    // Validate data size on stack
    if (this->m_runtime.stack.size < directive.get_size()) {
        error = DirectiveError::STACK_UNDERFLOW;
        return Signal::stmtResponse_failure;
    }

    // Create external buffer referencing stack data (no copy)
    U8* dataPtr = this->m_runtime.stack.top() - directive.get_size();
    Fw::ExternalSerializeBuffer buf(dataPtr, directive.get_size());

    // Set buffer length and verify success
    Fw::SerializeStatus stat = buf.setBuffLen(directive.get_size());
    FW_ASSERT(stat == Fw::SerializeStatus::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(stat));

    // Call output port; a typed downstream port reports deserialize failures here, which is
    // untrusted sequence content (e.g. undersized payload), not an invariant to assert on
    Fw::SerializeStatus portStatus = this->serialOut_out(portIndex, buf);
    if (portStatus != Fw::SerializeStatus::FW_SERIALIZE_OK) {
        error = DirectiveError::SERIAL_PORT_DESERIALIZE_FAILURE;
        return Signal::stmtResponse_failure;
    }

    // Pop data from stack
    this->m_runtime.stack.size -= directive.get_size();

    return Signal::stmtResponse_success;
}

}  // namespace Svc