fprime-gds 4.0.2a3__py3-none-any.whl → 4.0.2a5__py3-none-any.whl

fprime_gds/common/fpy/bytecode/directives.py

@@ -1,89 +1,153 @@
-from dataclasses import astuple, dataclass
+from __future__ import annotations
+import typing
+from typing import Any
+
+# This makes the code forward-compatible. In Python 3.10+, the `|` operator
+# creates a types.UnionType. In 3.9, only typing.Union exists.
+try:
+    from types import UnionType
+
+    UNION_TYPES = (typing.Union, UnionType)
+except ImportError:
+    UNION_TYPES = (typing.Union,)
+
+from dataclasses import dataclass, fields, astuple
+from typing import ClassVar
+import typing
+from typing import Union
 from pathlib import Path
 import struct
-from typing import ClassVar
 import zlib
-from fprime.common.models.serialize.time_type import TimeType
+from fprime.common.models.serialize.type_base import BaseType
 from fprime.common.models.serialize.numerical_types import (
     U32Type,
     U16Type,
     U64Type,
     U8Type,
     I64Type,
+    I16Type,
+    I32Type,
+    I8Type,
+    F32Type,
+    F64Type,
 )
 from fprime.common.models.serialize.bool_type import BoolType
 from enum import Enum
 
+
+def get_union_members(type_hint: type) -> list[type]:
+    """
+    If the type_hint is a Union, returns a list of its member types.
+    Otherwise, returns the original type_hint.
+    """
+    # get_origin returns the base type (e.g., Union for Union[int, str])
+    # or None if it's a simple type like int.
+    origin = typing.get_origin(type_hint)
+
+    if origin in UNION_TYPES:
+        # get_args returns the type arguments (e.g., (int, str))
+        return list(typing.get_args(type_hint))
+
+    # Not a Union, so return the type itself
+    return [type_hint]
+
+
 FwSizeType = U64Type
 FwChanIdType = U32Type
 FwPrmIdType = U32Type
 FwOpcodeType = U32Type
 
-MAX_SERIALIZABLE_REGISTER_SIZE = 512 - 4 - 4
-
 
-class DirectiveOpcode(Enum):
+class DirectiveId(Enum):
     INVALID = 0
     WAIT_REL = 1
     WAIT_ABS = 2
-    SET_SER_REG = 3
     GOTO = 4
     IF = 5
     NO_OP = 6
-    GET_TLM = 7
-    GET_PRM = 8
-    CMD = 9
-    SET_REG = 10
-    DESER_SER_REG_8 = 11
-    DESER_SER_REG_4 = 12
-    DESER_SER_REG_2 = 13
-    DESER_SER_REG_1 = 14
-    # binary reg op directives
-    # all of these are handled at the CPP level by one BinaryRegOpDirective
+    STORE_TLM_VAL = 7
+    STORE_PRM = 8
+    CONST_CMD = 9
+    # stack op directives
+    # all of these are handled at the CPP level by one StackOpDirective
     # boolean ops
-    OR = 15
-    AND = 16
+    OR = 10
+    AND = 11
     # integer equalities
-    IEQ = 17
-    INE = 18
+    IEQ = 12
+    INE = 13
     # unsigned integer inequalities
-    ULT = 19
-    ULE = 20
-    UGT = 21
-    UGE = 22
+    ULT = 14
+    ULE = 15
+    UGT = 16
+    UGE = 17
     # signed integer inequalities
-    SLT = 23
-    SLE = 24
-    SGT = 25
-    SGE = 26
+    SLT = 18
+    SLE = 19
+    SGT = 20
+    SGE = 21
     # floating point equalities
-    FEQ = 27
-    FNE = 28
+    FEQ = 22
+    FNE = 23
     # floating point inequalities
-    FLT = 29
-    FLE = 30
-    FGT = 31
-    FGE = 32
-    # end binary reg op directives
-
-    # unary reg op dirs
-    NOT = 33
-    # floating point extension and truncation
-    FPEXT = 34
-    FPTRUNC = 35
+    FLT = 24
+    FLE = 25
+    FGT = 26
+    FGE = 27
+    NOT = 28
     # floating point conversion to signed/unsigned integer,
     # and vice versa
-    FPTOSI = 36
-    FPTOUI = 37
-    SITOFP = 38
-    UITOFP = 39
-    # end unary reg op dirs
-
-    EXIT = 40
+    FPTOSI = 29
+    FPTOUI = 30
+    SITOFP = 31
+    UITOFP = 32
+    # integer arithmetic
+    IADD = 33
+    ISUB = 34
+    IMUL = 35
+    UDIV = 36
+    SDIV = 37
+    UMOD = 38
+    SMOD = 39
+    # float arithmetic
+    FADD = 40
+    FSUB = 41
+    FMUL = 42
+    FDIV = 43
+    FLOAT_FLOOR_DIV = 44
+    FPOW = 45
+    FLOG = 46
+    FMOD = 47
+    # floating point bitwidth conversions
+    FPEXT = 48
+    FPTRUNC = 49
+    # integer bitwidth conversions
+    # signed integer extend
+    SIEXT_8_64 = 50
+    SIEXT_16_64 = 51
+    SIEXT_32_64 = 52
+    # zero (unsigned) integer extend
+    ZIEXT_8_64 = 53
+    ZIEXT_16_64 = 54
+    ZIEXT_32_64 = 55
+    # integer truncate
+    ITRUNC_64_8 = 56
+    ITRUNC_64_16 = 57
+    ITRUNC_64_32 = 58
+    # end stack op dirs
+
+    EXIT = 59
+    ALLOCATE = 60
+    STORE = 61
+    LOAD = 62
+    PUSH_VAL = 63
+    DISCARD = 64
+    MEMCMP = 65
+    STACK_CMD = 66
 
 
 class Directive:
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.INVALID
+    opcode: ClassVar[DirectiveId] = DirectiveId.INVALID
 
     def serialize(self) -> bytes:
         arg_bytes = self.serialize_args()
@@ -95,396 +159,658 @@ class Directive:
         return output
 
     def serialize_args(self) -> bytes:
-        raise NotImplementedError("serialize_args not implemented")
+        output = bytes()
+
+        for field in fields(self):
+            value = getattr(self, field.name)
+            if isinstance(value, BaseType):
+                # it is already an fprime type instance
+                # so we can serialize it
+                output += value.serialize()
+                continue
+
+            if isinstance(value, bytes):
+                # it is just raw bytes
+                output += value
+                continue
+
+            # okay, it is not a primitive type or bytes
+            field_type = typing.get_type_hints(self.__class__)[field.name]
+            union_members = get_union_members(field_type)
+            primitive_type = None
+            # find out which primitive type it is
+            for arg in union_members:
+                if issubclass(arg, BaseType):
+                    # it is a primitive type
+                    primitive_type = arg
+                    break
+            if primitive_type is None:
+                raise NotImplementedError(
+                    "Unknown how to serialize field", field.name, "for", self
+                )
+
+            output += primitive_type(value).serialize()
 
+        return output
 
-HEADER_FORMAT = "!BBBBBHI"
-HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+    def __repr__(self):
+        r = self.__class__.__old_repr__(self)
+        name = self.__class__.__name__.replace("Directive", "").upper()
+        value = "".join(r.split("(")[1:])
+        return name + "(" + value
+
+    @classmethod
+    def deserialize(cls, data: bytes, offset: int) -> tuple[int, "Directive"] | None:
+        if len(data) - offset < 3:
+            # insufficient space
+            return None
+        opcode = struct.unpack_from(">B", data, offset)[0]
+        arg_size = struct.unpack_from(">H", data, offset + 1)[0]
+        offset += 3
+        if len(data) - offset < arg_size:
+            # insufficient space
+            return None
+        args = data[offset : (offset + arg_size)]
+        offset += arg_size
+        dir_type = [
+            c
+            for c in (Directive.__subclasses__() + StackOpDirective.__subclasses__())
+            if c.opcode.value == opcode
+        ]
+        if len(dir_type) != 1:
+            return None
+
+        arg_offset = 0
+        dir_type = dir_type[0]
+        arg_values = []
+
+        # go through each field in the type of the directive
+        for field in fields(dir_type):
+            field_type = typing.get_type_hints(dir_type)[field.name]
+            # get a list of all union members of the field type
+            # or a list containing just the type if it is not a union
+            union_types = get_union_members(field_type)
+
+            base_type = None
+            for t in union_types:
+                if issubclass(t, BaseType):
+                    base_type = t
+
+            # if one of the members of the union was a sub of basetype
+            if base_type is not None:
+                # deserialize using that basetype and add to arg value list
+                instance = base_type()
+                instance.deserialize(args, arg_offset)
+                arg_values.append(instance.val)
+                arg_offset += instance.getSize()
+                continue
+            # none of the args were base types. the only other thing we could be
+            # is a byte array. assert that that's true
+            assert len(union_types) == 1 and union_types[0] == bytes
+            # it is just raw bytes. deserialize until the end
+            arg_values.append(args[arg_offset:])
+            arg_offset = len(args)
+            continue
+
+        dir = dir_type(*arg_values)
+        return offset, dir
 
 
 @dataclass
-class Header:
-    majorVersion: int
-    minorVersion: int
-    patchVersion: int
-    schemaVersion: int
-    argumentCount: int
-    statementCount: int
-    bodySize: int
+class StackOpDirective(Directive):
+    """the argument types this dir pops off the stack"""
+
+    stack_output_type: ClassVar[type[BaseType]] = BaseType
+    """the type this dir pushes to the stack"""
 
 
-FOOTER_FORMAT = "!I"
-FOOTER_SIZE = struct.calcsize(FOOTER_FORMAT)
+@dataclass
+class StackCmdDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.STACK_CMD
+
+    args_size: Union[int, U32Type]
 
 
 @dataclass
-class Footer:
-    crc: int
+class MemCompareDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.MEMCMP
+    size: Union[int, U32Type]
 
 
-def serialize_directives(dirs: list[Directive], output: Path = None):
-    output_bytes = bytes()
+@dataclass
+class LoadDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.LOAD
 
-    for dir in dirs:
-        output_bytes += dir.serialize()
+    lvar_offset: Union[int, U32Type]
+    size: Union[int, U32Type]
 
-    header = Header(0, 0, 0, 1, 0, len(dirs), len(output_bytes))
-    output_bytes = struct.pack(HEADER_FORMAT, *astuple(header)) + output_bytes
 
-    crc = zlib.crc32(output_bytes) % (1 << 32)
-    footer = Footer(crc)
-    output_bytes += struct.pack(FOOTER_FORMAT, *astuple(footer))
+@dataclass
+class IntegerSignedExtend8To64Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SIEXT_8_64
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
-    if output is None:
-        output = input.with_suffix(".bin")
 
-    output.write_bytes(output_bytes)
+@dataclass
+class IntegerSignedExtend16To64Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SIEXT_16_64
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
 @dataclass
-class WaitRelDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.WAIT_REL
-    seconds: int
-    useconds: int
+class IntegerSignedExtend32To64Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SIEXT_32_64
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
-    def serialize_args(self) -> bytes:
-        return U32Type(self.seconds).serialize() + U32Type(self.useconds).serialize()
+
+@dataclass
+class IntegerZeroExtend8To64Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ZIEXT_8_64
+    stack_output_type: ClassVar[type[BaseType]] = U64Type
 
 
 @dataclass
-class WaitAbsDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.WAIT_ABS
-    wakeup_time: TimeType
+class IntegerZeroExtend16To64Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ZIEXT_16_64
+    stack_output_type: ClassVar[type[BaseType]] = U64Type
 
-    def serialize_args(self) -> bytes:
-        return self.wakeup_time.serialize()
+
+@dataclass
+class IntegerZeroExtend32To64Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ZIEXT_32_64
+    stack_output_type: ClassVar[type[BaseType]] = U64Type
 
 
 @dataclass
-class SetSerRegDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SET_SER_REG
+class IntegerTruncate64To8Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ITRUNC_64_8
+    stack_output_type: ClassVar[type[BaseType]] = I8Type
 
-    index: int
-    """U8: The index of the local variable to set."""
-    value: bytes
-    """[Fpy.MAX_SERIALIZABLE_REGISTER_SIZE] U8: The value of the local variable."""
 
-    def serialize_args(self) -> bytes:
-        data = bytearray()
-        data.extend(U8Type(self.index).serialize())
-        data.extend(self.value)
-        return bytes(data)
+@dataclass
+class IntegerTruncate64To16Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ITRUNC_64_16
+    stack_output_type: ClassVar[type[BaseType]] = I16Type
 
 
 @dataclass
-class GotoDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.GOTO
-    statement_index: int
-    """U32: The statement index to execute next."""
+class IntegerTruncate64To32Directive(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ITRUNC_64_32
+    stack_output_type: ClassVar[type[BaseType]] = I32Type
 
-    def serialize_args(self) -> bytes:
-        return U32Type(self.statement_index).serialize()
+
+@dataclass
+class AllocateDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ALLOCATE
+
+    size: Union[int, U32Type]
 
 
 @dataclass
-class IfDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.IF
-    conditional_reg: int
-    """U8: The register to branch based off of (interpreted as a C++ boolean)."""
-    false_goto_stmt_index: int
-    """U32: The statement index to go to if the register is false."""
+class StoreDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.STORE
 
-    def serialize_args(self) -> bytes:
-        return (
-            U8Type(self.conditional_reg).serialize()
-            + U32Type(self.false_goto_stmt_index).serialize()
-        )
+    lvar_offset: Union[int, U32Type]
+    size: Union[int, U32Type]
 
 
 @dataclass
-class NoOpDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.NO_OP
+class DiscardDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.DISCARD
 
-    def serialize_args(self) -> bytes:
-        return bytes()
+    size: Union[int, U32Type]
 
 
 @dataclass
-class GetTlmDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.GET_TLM
-    value_dest_sreg: int
-    """U8: The local variable to store the telemetry value in."""
-    time_dest_sreg: int
-    """U8: The local variable to store the telemetry time in."""
-    chan_id: int
-    """FwChanIdType: The telemetry channel ID to get."""
+class PushValDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.PUSH_VAL
 
-    def serialize_args(self) -> bytes:
-        data = bytearray()
-        data.extend(U8Type(self.value_dest_sreg).serialize())
-        data.extend(U8Type(self.time_dest_sreg).serialize())
-        data.extend(FwChanIdType(self.chan_id).serialize())
-        return bytes(data)
+    val: bytes
 
 
 @dataclass
-class GetPrmDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.GET_PRM
-    dest_sreg_index: int
-    """U8: The local variable to store the parameter value in."""
-    prm_id: int
-    """FwPrmIdType: The parameter ID to get the value of."""
+class ConstCmdDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.CONST_CMD
 
-    def serialize_args(self) -> bytes:
-        return (
-            U8Type(self.dest_sreg_index).serialize()
-            + FwPrmIdType(self.prm_id).serialize()
-        )
+    cmd_opcode: Union[int, FwOpcodeType]
+    args: bytes
 
 
 @dataclass
-class CmdDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.CMD
-    op_code: int
-    """FwOpcodeType: The opcode of the command."""
-    arg_buf: bytes
-    """[Fpy.MAX_SERIALIZABLE_REGISTER_SIZE] U8: The argument buffer of the command."""
+class FloatModuloDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FMOD
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
 
-    def serialize_args(self) -> bytes:
-        data = bytearray()
-        data.extend(FwOpcodeType(self.op_code).serialize())
-        data.extend(self.arg_buf)
-        return bytes(data)
+
+@dataclass
+class SignedModuloDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SMOD
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
 @dataclass
-class _DeserSerRegDirective(Directive):
-    """
-    Deserializes up to 8 bytes from a local variable into a register.
-    """
+class UnsignedModuloDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.UMOD
+    stack_output_type: ClassVar[type[BaseType]] = U64Type
 
-    src_sreg_idx: int
-    """U8: The local variable to deserialize from."""
-    src_offset: int
-    """FwSizeType: The starting offset to deserialize from."""
-    dest_reg: int
-    """U8: The destination register to deserialize into."""
 
-    def serialize_args(self) -> bytes:
-        data = bytearray()
-        data.extend(U8Type(self.src_sreg_idx).serialize())
-        data.extend(FwSizeType(self.src_offset).serialize())
-        data.extend(U8Type(self.dest_reg).serialize())
-        return bytes(data)
+@dataclass
+class IntAddDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.IADD
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
-class DeserSerReg8Directive(_DeserSerRegDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.DESER_SER_REG_8
+@dataclass
+class IntSubtractDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ISUB
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
-class DeserSerReg4Directive(_DeserSerRegDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.DESER_SER_REG_4
+@dataclass
+class IntMultiplyDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.IMUL
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
-class DeserSerReg2Directive(_DeserSerRegDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.DESER_SER_REG_2
+@dataclass
+class UnsignedIntDivideDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.UDIV
+    stack_output_type: ClassVar[type[BaseType]] = U64Type
 
 
-class DeserSerReg1Directive(_DeserSerRegDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.DESER_SER_REG_1
+@dataclass
+class SignedIntDivideDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SDIV
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
 @dataclass
-class SetRegDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SET_REG
+class FloatAddDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FADD
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
 
-    dest: int
-    """U8: The register to store the value in."""
-    value: int
-    """I64: The value to store in the register."""
 
-    def serialize_args(self) -> bytes:
-        return U8Type(self.dest).serialize() + I64Type(self.value).serialize()
+@dataclass
+class FloatSubtractDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FSUB
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
 
 
 @dataclass
-class _BinaryRegOpDirective(Directive):
-    lhs: int
-    """U8: The left-hand side register for comparison."""
-    rhs: int
-    """U8: The right-hand side register for comparison."""
-    res: int
-    """U8: The destination register for the boolean result."""
+class FloatMultiplyDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FMUL
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
+
+
+@dataclass
+class FloatExponentDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FPOW
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
+
+
+@dataclass
+class FloatDivideDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FDIV
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
+
+
+@dataclass
+class FloatFloorDivideDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FLOAT_FLOOR_DIV
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
+
+
+@dataclass
+class FloatLogDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FLOG
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
 
-    def serialize_args(self) -> bytes:
-        data = bytearray()
-        data.extend(U8Type(self.lhs).serialize())
-        data.extend(U8Type(self.rhs).serialize())
-        data.extend(U8Type(self.res).serialize())
-        return bytes(data)
+
+@dataclass
+class WaitRelDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.WAIT_REL
+    # seconds and useconds are implicit
+
+
+@dataclass
+class WaitAbsDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.WAIT_ABS
+    # time base, time context, seconds and useconds are implicit
 
 
-class OrDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.OR
+@dataclass
+class GotoDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.GOTO
+    dir_idx: Union[int, U32Type]
 
 
-class AndDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.AND
+@dataclass
+class IfDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.IF
+    false_goto_dir_index: Union[int, U32Type]
+    """U32: The dir index to go to if the top of stack is false."""
 
 
-class IntEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.IEQ
+@dataclass
+class NoOpDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.NO_OP
 
 
-class IntNotEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.INE
+@dataclass
+class StoreTlmValDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.STORE_TLM_VAL
+    chan_id: Union[int, FwChanIdType]
+    """FwChanIdType: The telemetry channel ID to get."""
+    lvar_offset: Union[int, U32Type]
 
 
-class UnsignedLessThanDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.ULT
+@dataclass
+class StorePrmDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.STORE_PRM
+    prm_id: Union[int, FwPrmIdType]
+    """FwPrmIdType: The parameter ID to get the value of."""
+    lvar_offset: Union[int, U32Type]
 
 
-class UnsignedLessThanOrEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.ULE
+@dataclass
+class OrDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.OR
+    stack_args: ClassVar[list[type[BaseType]]] = [BoolType, BoolType]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class UnsignedGreaterThanDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.UGT
+@dataclass
+class AndDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.AND
+    stack_args: ClassVar[list[type[BaseType]]] = [BoolType, BoolType]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class UnsignedGreaterThanOrEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.UGE
+@dataclass
+class IntEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.IEQ
+    stack_args: ClassVar[list[type[BaseType]]] = [
+        Union[I64Type, U64Type],
+        Union[I64Type, U64Type],
+    ]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class SignedLessThanDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SLT
+@dataclass
+class IntNotEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.INE
+    stack_args: ClassVar[list[type[BaseType]]] = [
+        Union[I64Type, U64Type],
+        Union[I64Type, U64Type],
+    ]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class SignedLessThanOrEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SLE
+@dataclass
+class UnsignedLessThanDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ULT
+    stack_args: ClassVar[list[type[BaseType]]] = [U64Type, U64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class SignedGreaterThanDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SGT
+@dataclass
+class UnsignedLessThanOrEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.ULE
+    stack_args: ClassVar[list[type[BaseType]]] = [U64Type, U64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class SignedGreaterThanOrEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SGE
+@dataclass
+class UnsignedGreaterThanDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.UGT
+    stack_args: ClassVar[list[type[BaseType]]] = [U64Type, U64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class FloatGreaterThanOrEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FGE
+@dataclass
+class UnsignedGreaterThanOrEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.UGE
+    stack_args: ClassVar[list[type[BaseType]]] = [U64Type, U64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class FloatLessThanOrEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FLE
+@dataclass
+class SignedLessThanDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SLT
+    stack_args: ClassVar[list[type[BaseType]]] = [I64Type, I64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class FloatLessThanDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FLT
+@dataclass
+class SignedLessThanOrEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SLE
+    stack_args: ClassVar[list[type[BaseType]]] = [I64Type, I64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class FloatGreaterThanDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FGT
+@dataclass
+class SignedGreaterThanDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SGT
+    stack_args: ClassVar[list[type[BaseType]]] = [I64Type, I64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class FloatEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FEQ
+@dataclass
+class SignedGreaterThanOrEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SGE
+    stack_args: ClassVar[list[type[BaseType]]] = [I64Type, I64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
-class FloatNotEqualDirective(_BinaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FNE
+@dataclass
+class FloatGreaterThanOrEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FGE
+    stack_args: ClassVar[list[type[BaseType]]] = [F64Type, F64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
 @dataclass
-class _UnaryRegOpDirective(Directive):
-    src: int
-    res: int
+class FloatLessThanOrEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FLE
+    stack_args: ClassVar[list[type[BaseType]]] = [F64Type, F64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
-    def serialize_args(self) -> bytes:
-        data = bytearray()
-        data.extend(U8Type(self.src).serialize())
-        data.extend(U8Type(self.res).serialize())
-        return bytes(data)
+
+@dataclass
+class FloatLessThanDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FLT
+    stack_args: ClassVar[list[type[BaseType]]] = [F64Type, F64Type]
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
 @dataclass
-class NotDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.NOT
+class FloatGreaterThanDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FGT
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
 @dataclass
-class FloatTruncateDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FPTRUNC
+class FloatEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FEQ
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
 @dataclass
-class FloatExtendDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FPEXT
+class FloatNotEqualDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FNE
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
 @dataclass
-class FloatToSignedIntDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FPTOSI
+class NotDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.NOT
+    stack_output_type: ClassVar[type[BaseType]] = BoolType
 
 
 @dataclass
-class SignedIntToFloatDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.SITOFP
+class FloatTruncateDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FPTRUNC
+    stack_output_type: ClassVar[type[BaseType]] = F32Type
 
 
 @dataclass
-class FloatToUnsignedIntDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.FPTOUI
+class FloatExtendDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FPEXT
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
 
 
 @dataclass
-class UnsignedIntToFloatDirective(_UnaryRegOpDirective):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.UITOFP
+class FloatToSignedIntDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FPTOSI
+    stack_output_type: ClassVar[type[BaseType]] = I64Type
 
 
 @dataclass
-class ExitDirective(Directive):
-    opcode: ClassVar[DirectiveOpcode] = DirectiveOpcode.EXIT
-    success: bool
+class SignedIntToFloatDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.SITOFP
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
 
-    def serialize_args(self):
-        return BoolType(self.success).serialize()
 
+@dataclass
+class FloatToUnsignedIntDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.FPTOUI
+    stack_output_type: ClassVar[type[BaseType]] = U64Type
 
-INT_EQUALITY_DIRECTIVES: dict[str, type[_BinaryRegOpDirective]] = {
-    "==": IntEqualDirective,
-    "!=": IntNotEqualDirective,
-}
 
-FLOAT_EQUALITY_DIRECTIVES: dict[str, type[_BinaryRegOpDirective]] = {
-    "==": FloatEqualDirective,
-    "!=": FloatNotEqualDirective,
-}
+@dataclass
+class UnsignedIntToFloatDirective(StackOpDirective):
+    opcode: ClassVar[DirectiveId] = DirectiveId.UITOFP
+    stack_output_type: ClassVar[type[BaseType]] = F64Type
+    # src implied
 
 
-INT_SIGNED_INEQUALITY_DIRECTIVES: dict[str, type[_BinaryRegOpDirective]] = {
-    ">": SignedGreaterThanDirective,
-    "<": SignedLessThanDirective,
-    ">=": SignedGreaterThanOrEqualDirective,
-    "<=": SignedLessThanOrEqualDirective,
-}
-INT_UNSIGNED_INEQUALITY_DIRECTIVES: dict[str, type[_BinaryRegOpDirective]] = {
-    ">": UnsignedGreaterThanDirective,
-    "<": UnsignedLessThanDirective,
-    ">=": UnsignedGreaterThanOrEqualDirective,
-    "<=": UnsignedLessThanOrEqualDirective,
+@dataclass
+class ExitDirective(Directive):
+    opcode: ClassVar[DirectiveId] = DirectiveId.EXIT
+
+
+for cls in Directive.__subclasses__():
+    cls.__old_repr__ = cls.__repr__
+    cls.__repr__ = Directive.__repr__
+
+for cls in StackOpDirective.__subclasses__():
+    cls.__old_repr__ = cls.__repr__
+    cls.__repr__ = Directive.__repr__
+
+
+class UnaryStackOp(str, Enum):
+    NOT = "not"
+    IDENTITY = "+"
+    NEGATE = "-"
+
+
+class BinaryStackOp(str, Enum):
+    EXPONENT = "**"
+    MODULUS = "%"
+    ADD = "+"
+    SUBTRACT = "-"
+    MULTIPLY = "*"
+    DIVIDE = "/"
+    FLOOR_DIVIDE = "//"
+    GREATER_THAN = ">"
+    GREATER_THAN_OR_EQUAL = ">="
+    LESS_THAN_OR_EQUAL = "<="
+    LESS_THAN = "<"
+    EQUAL = "=="
+    NOT_EQUAL = "!="
+    OR = "or"
+    AND = "and"
+
+
+NUMERIC_OPERATORS = {
+    UnaryStackOp.IDENTITY,
+    UnaryStackOp.NEGATE,
+    BinaryStackOp.ADD,
+    BinaryStackOp.SUBTRACT,
+    BinaryStackOp.MULTIPLY,
+    BinaryStackOp.DIVIDE,
+    BinaryStackOp.MODULUS,
+    BinaryStackOp.EXPONENT,
+    BinaryStackOp.FLOOR_DIVIDE,
 }
-FLOAT_INEQUALITY_DIRECTIVES: dict[str, type[_BinaryRegOpDirective]] = {
-    ">": FloatGreaterThanDirective,
-    "<": FloatLessThanDirective,
-    ">=": FloatGreaterThanOrEqualDirective,
-    "<=": FloatLessThanOrEqualDirective,
+BOOLEAN_OPERATORS = {UnaryStackOp.NOT, BinaryStackOp.OR, BinaryStackOp.AND}
+
+UNARY_STACK_OPS: dict[str, dict[type[BaseType], type[StackOpDirective]]] = {
+    UnaryStackOp.NOT: {BoolType: NotDirective},
+    UnaryStackOp.IDENTITY: {
+        I64Type: NoOpDirective,
+        U64Type: NoOpDirective,
+        F64Type: NoOpDirective,
+    },
+    UnaryStackOp.NEGATE: {
+        I64Type: IntMultiplyDirective,
+        U64Type: IntMultiplyDirective,
+        F64Type: FloatMultiplyDirective
+    },
 }
 
-BINARY_COMPARISON_DIRECTIVES = {}
-BINARY_COMPARISON_DIRECTIVES.update(INT_EQUALITY_DIRECTIVES)
-BINARY_COMPARISON_DIRECTIVES.update(INT_SIGNED_INEQUALITY_DIRECTIVES)
-BINARY_COMPARISON_DIRECTIVES.update(INT_UNSIGNED_INEQUALITY_DIRECTIVES)
-BINARY_COMPARISON_DIRECTIVES.update(FLOAT_EQUALITY_DIRECTIVES)
-BINARY_COMPARISON_DIRECTIVES.update(FLOAT_INEQUALITY_DIRECTIVES)
+BINARY_STACK_OPS: dict[str, dict[type[BaseType], type[StackOpDirective]]] = {
+    BinaryStackOp.EXPONENT: {F64Type: FloatExponentDirective},
+    BinaryStackOp.MODULUS: {
+        I64Type: SignedModuloDirective,
+        U64Type: UnsignedModuloDirective,
+        F64Type: FloatModuloDirective,
+    },
+    BinaryStackOp.ADD: {
+        I64Type: IntAddDirective,
+        U64Type: IntAddDirective,
+        F64Type: FloatAddDirective,
+    },
+    BinaryStackOp.SUBTRACT: {
+        I64Type: IntSubtractDirective,
+        U64Type: IntSubtractDirective,
+        F64Type: FloatSubtractDirective,
+    },
+    BinaryStackOp.MULTIPLY: {
+        I64Type: IntMultiplyDirective,
+        U64Type: IntMultiplyDirective,
+        F64Type: FloatMultiplyDirective,
+    },
+    BinaryStackOp.DIVIDE: {
+        I64Type: SignedIntDivideDirective,
+        U64Type: UnsignedIntDivideDirective,
+        F64Type: FloatDivideDirective,
+    },
+    BinaryStackOp.FLOOR_DIVIDE: {
+        I64Type: SignedIntDivideDirective,
+        U64Type: UnsignedIntDivideDirective,
+        F64Type: FloatFloorDivideDirective,
+    },
+    BinaryStackOp.GREATER_THAN: {
+        I64Type: SignedGreaterThanDirective,
+        U64Type: UnsignedGreaterThanDirective,
+        F64Type: FloatGreaterThanDirective,
+    },
+    BinaryStackOp.GREATER_THAN_OR_EQUAL: {
+        I64Type: SignedGreaterThanOrEqualDirective,
+        U64Type: UnsignedGreaterThanOrEqualDirective,
+        F64Type: FloatGreaterThanOrEqualDirective,
+    },
+    BinaryStackOp.LESS_THAN_OR_EQUAL: {
+        I64Type: SignedLessThanOrEqualDirective,
+        U64Type: UnsignedLessThanOrEqualDirective,
+        F64Type: FloatLessThanOrEqualDirective,
+    },
+    BinaryStackOp.LESS_THAN: {
+        I64Type: SignedLessThanDirective,
+        U64Type: UnsignedLessThanDirective,
+        F64Type: FloatLessThanDirective,
+    },
+    BinaryStackOp.EQUAL: {
+        I64Type: IntEqualDirective,
+        U64Type: IntEqualDirective,
+        F64Type: FloatEqualDirective,
+    },
+    BinaryStackOp.NOT_EQUAL: {
+        I64Type: IntNotEqualDirective,
+        U64Type: IntNotEqualDirective,
+        F64Type: FloatNotEqualDirective,
+    },
+    BinaryStackOp.OR: {BoolType: OrDirective},
+    BinaryStackOp.AND: {BoolType: AndDirective},
+}