Add arg names to header and valid

Lex-ari · Lex-ari · commit 6930ce7fc9cb · 2026-04-16T18:58:39.000-05:00
diff --git a/Svc/FpySequencer/FpySequencer.hpp b/Svc/FpySequencer/FpySequencer.hpp
@@ -645,6 +645,9 @@ class FpySequencer : public FpySequencerComponentBase {
     // sequence arguments to push to stack when entering RUNNING state
     Svc::SeqArgs m_sequenceArgs{};
 
+    // the expected argument size from arg_specs (schema version 6+)
+    Fpy::StackSizeType m_expectedArgSize{0};
+
     // 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
@@ -746,6 +749,9 @@ class FpySequencer : public FpySequencerComponentBase {
     // reads and validates the header from the m_sequenceBuffer
     // return SUCCESS if sequence is valid, FAILURE otherwise
     Fw::Success readHeader();
+    // reads and parses arg_specs from the sequence file (schema version 6+)
+    // return SUCCESS if successful, FAILURE otherwise
+    Fw::Success readArgSpecs(Os::File& file);
     // reads and validates the body from the m_sequenceBuffer
     // return SUCCESS if sequence is valid, FAILURE otherwise
     Fw::Success readBody();
diff --git a/Svc/FpySequencer/FpySequencerEvents.fppi b/Svc/FpySequencer/FpySequencerEvents.fppi
@@ -215,6 +215,13 @@ event TooManySequenceDirectives(
     severity warning high \
     format "A sequence specified it had {} directives but the max was {}"
 
+event ArgSizeMismatch(
+    expected: Fpy.StackSizeType
+    actual: FwSizeType
+) \
+    severity warning high \
+    format "Expected {} bytes of arguments based on arg_specs, but received {}"
+
 event SequencePaused(
     stmtIdx: U32
 ) \
diff --git a/Svc/FpySequencer/FpySequencerStateMachine.cpp b/Svc/FpySequencer/FpySequencerStateMachine.cpp
@@ -305,6 +305,7 @@ void FpySequencer ::Svc_FpySequencer_SequencerStateMachine_action_clearSequenceA
     Svc_FpySequencer_SequencerStateMachine::Signal signal
 ) {
     this->m_sequenceArgs = {0, 0};
+    this->m_expectedArgSize = 0;
 }
 
 //! Implementation for action clearBreakpoint of state machine Svc_FpySequencer_SequencerStateMachine
diff --git a/Svc/FpySequencer/FpySequencerTypes.fpp b/Svc/FpySequencer/FpySequencerTypes.fpp
@@ -1,7 +1,7 @@
 module Svc {
     module Fpy {
         @ the current schema version (must be representable in U8)
-        constant SCHEMA_VERSION = 5;
+        constant SCHEMA_VERSION = 6;
 
         @ the type which everything referencing a size or offset on the stack is represented in
         # we use a U32 because U16 is too small (would only allow up to 65 kB max stack size)
@@ -130,6 +130,27 @@ module Svc {
             CMD_FAIL = 17
         }
 
+        @ Maximum length for argument or type names in arg_specs
+        @ Fpy serializes these as U8 length prefix, so max is 255
+        constant MAX_ARG_SPEC_NAME_LEN = 255
+
+        @ Argument specification describing an input argument's name, type, and stack size
+        @ NOTE: This struct does NOT use FPP's auto-generated serialization!
+        @ Serialization is handled manually in C++ to match Fpy's format:
+        @   [U8 argNameLen][argNameLen bytes][U8 typeNameLen][typeNameLen bytes][U32 size]
+        struct ArgSpec {
+            @ Length of the argument name (0-255)
+            argNameLen: U8
+            @ Argument name as UTF-8 bytes (not null-terminated)
+            argName: [MAX_ARG_SPEC_NAME_LEN] U8
+            @ Length of the type name (0-255)
+            typeNameLen: U8
+            @ Type name as UTF-8 bytes (not null-terminated)
+            typeName: [MAX_ARG_SPEC_NAME_LEN] U8
+            @ Size of this argument on the stack in bytes
+            size: StackSizeType
+        } default { argNameLen = 0, argName = [0], typeNameLen = 0, typeName = [0], size = 0 }
+
         struct Header {
             @ the major version of the FSW
             majorVersion: U8
@@ -149,6 +170,12 @@ module Svc {
 
             @ the size of the body in bytes
             bodySize: U32
+
+            @ Argument specifications (schema version 6+)
+            @ Only the first argumentCount entries are valid
+            @ NOTE: These are NOT included in SERIALIZED_SIZE as they are variable-length
+            @ and must be deserialized manually in C++
+            argSpecs: [MAX_SEQUENCE_ARG_COUNT] ArgSpec
         } default { majorVersion = 0, minorVersion = 0, patchVersion = 0, schemaVersion = 0, argumentCount = 0, statementCount = 0, bodySize = 0 }
 
         struct Footer {
diff --git a/Svc/FpySequencer/FpySequencerValidationState.cpp b/Svc/FpySequencer/FpySequencerValidationState.cpp
@@ -61,6 +61,17 @@ Fw::Success FpySequencer::validate() {
         return Fw::Success::FAILURE;
     }
 
+    // Read and parse arg_specs (schema version 6+)
+    if (this->m_sequenceObj.get_header().get_schemaVersion() >= 6) {
+        readStatus = this->readArgSpecs(sequenceFile);
+        if (readStatus != Fw::Success::SUCCESS) {
+            return Fw::Success::FAILURE;
+        }
+    } else {
+        // For older schema versions, no arg_specs validation needed
+        this->m_expectedArgSize = 0;
+    }
+
     readStatus =
         readBytes(sequenceFile, this->m_sequenceObj.get_header().get_bodySize(), FpySequencer_FileReadStage::BODY);
 
@@ -105,6 +116,14 @@ Fw::Success FpySequencer::validate() {
         return Fw::Success::FAILURE;
     }
 
+    // Validate argument size matches expected size from arg_specs (schema version 6+)
+    if (this->m_sequenceObj.get_header().get_schemaVersion() >= 6 && this->m_expectedArgSize > 0) {
+        if (this->m_sequenceArgs.get_size() != this->m_expectedArgSize) {
+            this->log_WARNING_HI_ArgSizeMismatch(this->m_expectedArgSize, this->m_sequenceArgs.get_size());
+            return Fw::Success::FAILURE;
+        }
+    }
+
     return Fw::Success::SUCCESS;
 }
 
@@ -141,6 +160,113 @@ Fw::Success FpySequencer::readHeader() {
     return Fw::Success::SUCCESS;
 }
 
+// reads and parses arg_specs from the sequence file (schema version 6+)
+// stores them in the Header struct and calculates the total expected argument size
+// return SUCCESS if successful, FAILURE otherwise
+Fw::Success FpySequencer::readArgSpecs(Os::File& file) {
+    FW_ASSERT(file.isOpen());
+
+    const U8 argumentCount = this->m_sequenceObj.get_header().get_argumentCount();
+
+    // If no arguments, no arg_specs to read
+    if (argumentCount == 0) {
+        this->m_expectedArgSize = 0;
+        return Fw::Success::SUCCESS;
+    }
+
+    Fpy::StackSizeType totalExpectedSize = 0;
+
+    for (U8 i = 0; i < argumentCount; i++) {
+        // Get reference to the ArgSpec we're populating
+        Fpy::ArgSpec& argSpec = this->m_sequenceObj.get_header().get_argSpecs()[i];
+
+        // Read arg_name length
+        Fw::Success readStatus = this->readBytes(file, 1, FpySequencer_FileReadStage::BODY);
+        if (readStatus != Fw::Success::SUCCESS) {
+            return Fw::Success::FAILURE;
+        }
+        U8 argNameLen = 0;
+        Fw::SerializeStatus deserStatus = this->m_sequenceBuffer.deserializeTo(argNameLen);
+        if (deserStatus != Fw::SerializeStatus::FW_SERIALIZE_OK) {
+            this->log_WARNING_HI_FileReadDeserializeError(
+                FpySequencer_FileReadStage::BODY, this->m_sequenceFilePath, static_cast<I32>(deserStatus),
+                this->m_sequenceBuffer.getDeserializeSizeLeft(), this->m_sequenceBuffer.getSize());
+            return Fw::Success::FAILURE;
+        }
+        argSpec.set_argNameLen(argNameLen);
+
+        // Read arg_name string and store it
+        if (argNameLen > 0) {
+            readStatus = this->readBytes(file, argNameLen, FpySequencer_FileReadStage::BODY);
+            if (readStatus != Fw::Success::SUCCESS) {
+                return Fw::Success::FAILURE;
+            }
+            // Store the arg_name bytes in the ArgSpec
+            for (U8 j = 0; j < argNameLen; j++) {
+                U8 byte;
+                deserStatus = this->m_sequenceBuffer.deserializeTo(byte);
+                if (deserStatus != Fw::SerializeStatus::FW_SERIALIZE_OK) {
+                    return Fw::Success::FAILURE;
+                }
+                argSpec.get_argName()[j] = byte;
+            }
+        }
+
+        // Read type_name length
+        readStatus = this->readBytes(file, 1, FpySequencer_FileReadStage::BODY);
+        if (readStatus != Fw::Success::SUCCESS) {
+            return Fw::Success::FAILURE;
+        }
+        U8 typeNameLen = 0;
+        deserStatus = this->m_sequenceBuffer.deserializeTo(typeNameLen);
+        if (deserStatus != Fw::SerializeStatus::FW_SERIALIZE_OK) {
+            this->log_WARNING_HI_FileReadDeserializeError(
+                FpySequencer_FileReadStage::BODY, this->m_sequenceFilePath, static_cast<I32>(deserStatus),
+                this->m_sequenceBuffer.getDeserializeSizeLeft(), this->m_sequenceBuffer.getSize());
+            return Fw::Success::FAILURE;
+        }
+        argSpec.set_typeNameLen(typeNameLen);
+
+        // Read type_name string and store it
+        if (typeNameLen > 0) {
+            readStatus = this->readBytes(file, typeNameLen, FpySequencer_FileReadStage::BODY);
+            if (readStatus != Fw::Success::SUCCESS) {
+                return Fw::Success::FAILURE;
+            }
+            // Store the type_name bytes in the ArgSpec
+            for (U8 j = 0; j < typeNameLen; j++) {
+                U8 byte;
+                deserStatus = this->m_sequenceBuffer.deserializeTo(byte);
+                if (deserStatus != Fw::SerializeStatus::FW_SERIALIZE_OK) {
+                    return Fw::Success::FAILURE;
+                }
+                argSpec.get_typeName()[j] = byte;
+            }
+        }
+
+        // Read size field (StackSizeType = U32, 4 bytes, big-endian)
+        readStatus = this->readBytes(file, sizeof(Fpy::StackSizeType), FpySequencer_FileReadStage::BODY);
+        if (readStatus != Fw::Success::SUCCESS) {
+            return Fw::Success::FAILURE;
+        }
+        Fpy::StackSizeType argSize = 0;
+        deserStatus = this->m_sequenceBuffer.deserializeTo(argSize);
+        if (deserStatus != Fw::SerializeStatus::FW_SERIALIZE_OK) {
+            this->log_WARNING_HI_FileReadDeserializeError(
+                FpySequencer_FileReadStage::BODY, this->m_sequenceFilePath, static_cast<I32>(deserStatus),
+                this->m_sequenceBuffer.getDeserializeSizeLeft(), this->m_sequenceBuffer.getSize());
+            return Fw::Success::FAILURE;
+        }
+        argSpec.set_size(argSize);
+
+        // Accumulate the expected argument size
+        totalExpectedSize += argSize;
+    }
+
+    this->m_expectedArgSize = totalExpectedSize;
+    return Fw::Success::SUCCESS;
+}
+
 // reads and validates the body from the m_sequenceBuffer
 // return SUCCESS if sequence is valid, FAILURE otherwise
 Fw::Success FpySequencer::readBody() {

Original file line number	Diff line number	Diff line change
`@@ -305,6 +305,7 @@ void FpySequencer ::Svc_FpySequencer_SequencerStateMachine_action_clearSequenceA`
`305`	`305`	`Svc_FpySequencer_SequencerStateMachine::Signal signal`
`306`	`306`	`) {`
`307`	`307`	`this->m_sequenceArgs = {0, 0};`
	`308`	`+ this->m_expectedArgSize = 0;`
`308`	`309`	`}`
`309`	`310`
`310`	`311`	`//! Implementation for action clearBreakpoint of state machine Svc_FpySequencer_SequencerStateMachine`