fprime-gds 4.0.2a2__py3-none-any.whl → 4.0.2a4__py3-none-any.whl

fprime_gds/common/fpy/codegen.py

@@ -1,44 +1,98 @@
 from __future__ import annotations
 from abc import ABC
 import inspect
-from dataclasses import dataclass, field, fields
+from dataclasses import astuple, dataclass, field, fields
+from pathlib import Path
+import struct
 import traceback
-from typing import Callable
 import typing
+from typing import Union, get_origin, get_args
+import zlib
+
+from fprime_gds.common.fpy.types import (
+    SPECIFIC_FLOAT_TYPES,
+    SPECIFIC_INTEGER_TYPES,
+    MACROS,
+    MAX_DIRECTIVE_SIZE,
+    MAX_DIRECTIVES_COUNT,
+    SPECIFIC_NUMERIC_TYPES,
+    SIGNED_INTEGER_TYPES,
+    UNSIGNED_INTEGER_TYPES,
+    CompileException,
+    CompileState,
+    FieldReference,
+    FppTypeClass,
+    FpyCallable,
+    FpyCmd,
+    FpyMacro,
+    FpyReference,
+    FpyScope,
+    FpyTypeCtor,
+    FpyVariable,
+    InternalIntType,
+    InternalStringType,
+    NothingType,
+    TopDownVisitor,
+    Visitor,
+    create_scope,
+    get_ref_fpp_type_class,
+    is_instance_compat,
+)
+
+# In Python 3.10+, the `|` operator creates a `types.UnionType`.
+# We need to handle this for forward compatibility, but it won't exist in 3.9.
+try:
+    from types import UnionType
+
+    UNION_TYPES = (Union, UnionType)
+except ImportError:
+    UNION_TYPES = (Union,)
 
 from fprime_gds.common.fpy.bytecode.directives import (
-    FLOAT_INEQUALITY_DIRECTIVES,
-    MAX_SERIALIZABLE_REGISTER_SIZE,
-    INT_SIGNED_INEQUALITY_DIRECTIVES,
-    INT_UNSIGNED_INEQUALITY_DIRECTIVES,
-    AndDirective,
-    CmdDirective,
-    DeserSerReg1Directive,
-    DeserSerReg2Directive,
-    DeserSerReg4Directive,
-    DeserSerReg8Directive,
+    BINARY_STACK_OPS,
+    BOOLEAN_OPERATORS,
+    NUMERIC_OPERATORS,
+    UNARY_STACK_OPS,
+    AllocateDirective,
+    BinaryStackOp,
+    ConstCmdDirective,
+    FloatMultiplyDirective,
+    FloatTruncateDirective,
+    IntMultiplyDirective,
+    MemCompareDirective,
+    NoOpDirective,
+    StackOpDirective,
+    IntegerTruncate64To16Directive,
+    IntegerTruncate64To32Directive,
+    IntegerTruncate64To8Directive,
+    FloatLogDirective,
+    IntegerSignedExtend16To64Directive,
+    IntegerSignedExtend32To64Directive,
+    IntegerSignedExtend8To64Directive,
+    StackCmdDirective,
+    StorePrmDirective,
+    IntegerZeroExtend16To64Directive,
+    IntegerZeroExtend32To64Directive,
+    IntegerZeroExtend8To64Directive,
     Directive,
     FloatExtendDirective,
-    IntEqualDirective,
     ExitDirective,
-    FloatEqualDirective,
-    FloatNotEqualDirective,
-    GetPrmDirective,
-    GetTlmDirective,
+    LoadDirective,
+    StoreTlmValDirective,
     GotoDirective,
     IfDirective,
     NotDirective,
-    IntNotEqualDirective,
-    OrDirective,
-    SetSerRegDirective,
-    SetRegDirective,
+    PushValDirective,
     SignedIntToFloatDirective,
+    StoreDirective,
+    UnaryStackOp,
     UnsignedIntToFloatDirective,
     WaitAbsDirective,
     WaitRelDirective,
 )
 from fprime_gds.common.loaders.ch_json_loader import ChJsonLoader
 from fprime_gds.common.loaders.cmd_json_loader import CmdJsonLoader
+from fprime_gds.common.loaders.event_json_loader import EventJsonLoader
 from fprime_gds.common.loaders.prm_json_loader import PrmJsonLoader
 from fprime_gds.common.templates.ch_template import ChTemplate
 from fprime_gds.common.templates.cmd_template import CmdTemplate
@@ -47,15 +101,13 @@ from fprime.common.models.serialize.time_type import TimeType
 from fprime.common.models.serialize.enum_type import EnumType
 from fprime.common.models.serialize.serializable_type import SerializableType
 from fprime.common.models.serialize.array_type import ArrayType
+from fprime.common.models.serialize.type_exceptions import TypeException
 from fprime.common.models.serialize.numerical_types import (
     U32Type,
     U16Type,
     U64Type,
     U8Type,
-    I16Type,
-    I32Type,
     I64Type,
-    I8Type,
     F32Type,
     F64Type,
     FloatType,
@@ -65,469 +117,29 @@ from fprime.common.models.serialize.numerical_types import (
 from fprime.common.models.serialize.string_type import StringType
 from fprime.common.models.serialize.bool_type import BoolType
 from fprime_gds.common.fpy.parser import (
-    AstAnd,
+    AstBinaryOp,
     AstBoolean,
-    AstComparison,
     AstElif,
     AstElifs,
     AstExpr,
     AstGetAttr,
     AstGetItem,
-    AstNot,
     AstNumber,
-    AstOr,
+    AstOp,
     AstReference,
+    AstScopedBody,
     AstString,
     Ast,
-    AstTest,
     AstBody,
     AstLiteral,
     AstIf,
     AstAssign,
     AstFuncCall,
+    AstUnaryOp,
     AstVar,
 )
 from fprime.common.models.serialize.type_base import BaseType as FppType
 
-NUMERIC_TYPES = (
-    U32Type,
-    U16Type,
-    U64Type,
-    U8Type,
-    I16Type,
-    I32Type,
-    I64Type,
-    I8Type,
-    F32Type,
-    F64Type,
-)
-INTEGER_TYPES = (
-    U32Type,
-    U16Type,
-    U64Type,
-    U8Type,
-    I16Type,
-    I32Type,
-    I64Type,
-    I8Type,
-)
-SIGNED_INTEGER_TYPES = (
-    I16Type,
-    I32Type,
-    I64Type,
-    I8Type,
-)
-UNSIGNED_INTEGER_TYPES = (
-    U32Type,
-    U16Type,
-    U64Type,
-    U8Type,
-)
-FLOAT_TYPES = (
-    F32Type,
-    F64Type,
-)
-
-
-# a value of type FppTypeClass is a Python `type` object representing
-# the type of an Fprime value
-FppTypeClass = type[FppType]
-
-
-class NothingType(ABC):
-    """a type which has no valid values in fprime. used to denote
-    a function which doesn't return a value"""
-    @classmethod
-    def __subclasscheck__(cls, subclass):
-        return False
-
-
-# the `type` object representing the NothingType class
-NothingTypeClass = type[NothingType]
-
-
-class CompileException(BaseException):
-    def __init__(self, msg, node: Ast):
-        self.msg = msg
-        self.node = node
-        self.stack_trace = "\n".join(traceback.format_stack(limit=8)[:-1])
-
-    def __str__(self):
-        return f'{self.stack_trace}\nAt line {self.node.meta.line} "{self.node.node_text}": {self.msg}'
-
-
-@dataclass
-class FpyCallable:
-    return_type: FppTypeClass | NothingTypeClass
-    args: list[tuple[str, FppTypeClass]]
-
-
-@dataclass
-class FpyCmd(FpyCallable):
-    cmd: CmdTemplate
-
-
-@dataclass
-class FpyMacro(FpyCallable):
-    instantiate_macro: Callable[[list[FppType]], list[Directive]]
-    """a function which instantiates the macro given the argument values"""
-
-
-MACROS: dict[str, FpyMacro] = {
-    "sleep": FpyMacro(
-        NothingType, [("seconds", F64Type)], lambda args: [WaitRelDirective(int(args[0].val), int(args[0].val * 1000000) % 1000000)]
-    ),
-    "sleep_until": FpyMacro(
-        NothingType, [("wakeup_time", TimeType)], lambda args: [WaitAbsDirective(args[0])]
-    ),
-    "exit": FpyMacro(NothingType, [("success", BoolType)], lambda args: [ExitDirective(args[0].val)]),
-}
-
-
-@dataclass
-class FpyTypeCtor(FpyCallable):
-    type: FppTypeClass
-
-
-@dataclass
-class FieldReference:
-    """a reference to a field/index of an fprime type"""
-
-    parent: "FpyReference"
-    """the qualifier"""
-    type: FppTypeClass
-    """the fprime type of this reference"""
-    offset: int
-    """the constant offset in the parent type at which to find this field"""
-    name: str = None
-    """the name of the field, if applicable"""
-    idx: int = None
-    """the index of the field, if applicable"""
-
-    def get_from(self, parent_val: FppType) -> FppType:
-        """gets the field value from the parent value"""
-        assert isinstance(parent_val, self.type)
-        assert self.name is not None or self.idx is not None
-        value = None
-        if self.name is not None:
-            if isinstance(parent_val, SerializableType):
-                value = parent_val.val[self.name]
-            elif isinstance(parent_val, TimeType):
-                if self.name == "seconds":
-                    value = parent_val.__secs
-                elif self.name == "useconds":
-                    value = parent_val.__usecs
-                elif self.name == "time_base":
-                    value = parent_val.__timeBase
-                elif self.name == "time_context":
-                    value = parent_val.__timeContext
-                else:
-                    assert False, self.name
-            else:
-                assert False, parent_val
-
-        else:
-
-            assert isinstance(parent_val, ArrayType), parent_val
-
-            value = parent_val._val[self.idx]
-
-        assert isinstance(value, self.type), (value, self.type)
-        return value
-
-
-# named variables can be tlm chans, prms, callables, or directly referenced consts (usually enums)
-@dataclass
-class FpyVariable:
-    """a mutable, typed value referenced by an unqualified name"""
-
-    type_ref: AstExpr
-    """the expression denoting the var's type"""
-    type: FppTypeClass | None = None
-    """the resolved type of the variable. None if type unsure at the moment"""
-    sreg_idx: int | None = None
-    """the index of the sreg it is stored in"""
-
-
-# a scope
-FpyScope = dict[str, "FpyReference"]
-
-
-def create_scope(
-    references: dict[str, "FpyReference"],
-) -> FpyScope:
-    """from a flat dict of strs to references, creates a hierarchical, scoped
-    dict. no two leaf nodes may have the same name"""
-
-    base = {}
-
-    for fqn, ref in references.items():
-        names_strs = fqn.split(".")
-
-        ns = base
-        while len(names_strs) > 1:
-            existing_child = ns.get(names_strs[0], None)
-            if existing_child is None:
-                # this scope is not defined atm
-                existing_child = {}
-                ns[names_strs[0]] = existing_child
-
-            if not isinstance(existing_child, dict):
-                # something else already has this name
-                print(
-                    f"WARNING: {fqn} is already defined as {existing_child}, tried to redefine it as {ref}"
-                )
-                break
-
-            ns = existing_child
-            names_strs = names_strs[1:]
-
-        if len(names_strs) != 1:
-            # broke early. skip this loop
-            continue
-
-        # okay, now ns is the complete scope of the attribute
-        # i.e. everything up until the last '.'
-        name = names_strs[0]
-
-        existing_child = ns.get(name, None)
-
-        if existing_child is not None:
-            # uh oh, something already had this name with a diff value
-            print(
-                f"WARNING: {fqn} is already defined as {existing_child}, tried to redefine it as {ref}"
-            )
-            continue
-
-        ns[name] = ref
-
-    return base
-
-
-def union_scope(lhs: FpyScope, rhs: FpyScope) -> FpyScope:
-    """returns the two scopes, joined into one. if there is a conflict, chooses lhs over rhs"""
-    lhs_keys = set(lhs.keys())
-    rhs_keys = set(rhs.keys())
-    common_keys = lhs_keys.intersection(rhs_keys)
-
-    only_lhs_keys = lhs_keys.difference(common_keys)
-    only_rhs_keys = rhs_keys.difference(common_keys)
-
-    new = FpyScope()
-
-    for key in common_keys:
-        if not isinstance(lhs[key], dict) or not isinstance(rhs[key], dict):
-            # cannot be merged cleanly. one of the two is not a scope
-            print(f"WARNING: {key} is defined as {lhs[key]}, ignoring {rhs[key]}")
-            new[key] = lhs[key]
-            continue
-
-        new[key] = union_scope(lhs[key], rhs[key])
-
-    for key in only_lhs_keys:
-        new[key] = lhs[key]
-    for key in only_rhs_keys:
-        new[key] = rhs[key]
-
-    return new
-
-
-FpyReference = (
-    ChTemplate
-    | PrmTemplate
-    | FppType
-    | FpyCallable
-    | FppTypeClass
-    | FpyVariable
-    | FieldReference
-    | dict  # FpyReference
-)
-"""some named concept in fpy"""
-
-
-def get_ref_fpp_type_class(ref: FpyReference) -> FppTypeClass:
-    """returns the fprime type of the ref, if it were to be evaluated as an expression"""
-    if isinstance(ref, ChTemplate):
-        result_type = ref.ch_type_obj
-    elif isinstance(ref, PrmTemplate):
-        result_type = ref.prm_type_obj
-    elif isinstance(ref, FppType):
-        # constant value
-        result_type = type(ref)
-    elif isinstance(ref, FpyCallable):
-        # a reference to a callable isn't a type in and of itself
-        # it has a return type but you have to call it (with an AstFuncCall)
-        # consider making a separate "reference" type
-        result_type = NothingType
-    elif isinstance(ref, FpyVariable):
-        result_type = ref.type
-    elif isinstance(ref, type):
-        # a reference to a type doesn't have a value, and so doesn't have a type,
-        # in and of itself. if this were a function call to the type's ctor then
-        # it would have a value and thus a type
-        result_type = NothingType
-    elif isinstance(ref, FieldReference):
-        result_type = ref.type
-    elif isinstance(ref, dict):
-        # reference to a scope. scopes don't have values
-        result_type = NothingType
-    else:
-        assert False, ref
-
-    return result_type
-
-
-@dataclass
-class CompileState:
-    """a collection of input, internal and output state variables and maps"""
-
-    types: FpyScope
-    """a scope whose leaf nodes are subclasses of BaseType"""
-    callables: FpyScope
-    """a scope whose leaf nodes are FpyCallable instances"""
-    tlms: FpyScope
-    """a scope whose leaf nodes are ChTemplates"""
-    prms: FpyScope
-    """a scope whose leaf nodes are PrmTemplates"""
-    consts: FpyScope
-    """a scope whose leaf nodes are instances of subclasses of BaseType"""
-    variables: FpyScope = field(default_factory=dict)
-    """a scope whose leaf nodes are FpyVariables"""
-    runtime_values: FpyScope = None
-    """a scope whose leaf nodes are tlms/prms/consts/variables, all of which
-    have some value at runtime."""
-
-    def __post_init__(self):
-        self.runtime_values = union_scope(
-            self.tlms,
-            union_scope(self.prms, union_scope(self.consts, self.variables)),
-        )
-
-    resolved_references: dict[AstReference, FpyReference] = field(
-        default_factory=dict, repr=False
-    )
-    """reference to its singular resolution"""
-
-    expr_types: dict[AstExpr, FppTypeClass | NothingTypeClass] = field(
-        default_factory=dict
-    )
-    """expr to its fprime type, or nothing type if none"""
-
-    expr_values: dict[AstExpr, FppType | NothingType | None] = field(
-        default_factory=dict
-    )
-    """expr to its fprime value, or nothing if no value, or None if unsure at compile time"""
-
-    expr_registers: dict[AstExpr, int] = field(default_factory=dict)
-    """expr to the register it's stored in"""
-
-    directives: dict[Ast, list[Directive] | None] = field(default_factory=dict)
-    """a list of code generated by each node, or None/empty list if no directives"""
-
-    node_dir_counts: dict[Ast, int] = field(default_factory=dict)
-    """node to the number of directives generated by it"""
-
-    next_register: int = 0
-    """the index of the next free register"""
-    next_sreg: int = 0
-    """the index of the next free serializable register"""
-
-    start_line_idx: dict[Ast, int] = field(default_factory=dict)
-    """the line index at which each node's directives will be included in the output"""
-
-    errors: list[CompileException] = field(default_factory=list)
-    """a list of all compile exceptions generated by passes"""
-
-    def err(self, msg, n):
-        """adds a compile exception to internal state"""
-        self.errors.append(CompileException(msg, n))
-
-
-class Visitor:
-    """visits each class, calling a custom visit function, if one is defined, for each
-    node type"""
-
-    def _find_custom_visit_func(self, node: Ast):
-        for name, func in inspect.getmembers(type(self), inspect.isfunction):
-            if not name.startswith("visit") or name == "visit_default":
-                # not a visitor, or the default visit func
-                continue
-            signature = inspect.signature(func)
-            params = list(signature.parameters.values())
-            assert len(params) == 3
-            assert params[1].annotation is not None
-            annotations = typing.get_type_hints(func)
-            param_type = annotations[params[1].name]
-            if isinstance(node, param_type):
-                return func
-        else:
-            # call the default
-            return type(self).visit_default
-
-    def _visit(self, node: Ast, state: CompileState):
-        visit_func = self._find_custom_visit_func(node)
-        visit_func(self, node, state)
-
-    def visit_default(self, node: Ast, state: CompileState):
-        pass
-
-    def run(self, start: Ast, state: CompileState):
-        """runs the visitor, starting at the given node, descending depth-first"""
-
-        def _descend(node: Ast):
-            if not isinstance(node, Ast):
-                return
-            children = []
-            for field in fields(node):
-                field_val = getattr(node, field.name)
-                if isinstance(field_val, list):
-                    children.extend(field_val)
-                else:
-                    children.append(field_val)
-
-            for child in children:
-                if not isinstance(child, Ast):
-                    continue
-                _descend(child)
-                if len(state.errors) != 0:
-                    break
-                self._visit(child, state)
-                if len(state.errors) != 0:
-                    break
-
-        _descend(start)
-        self._visit(start, state)
-
-
-class TopDownVisitor(Visitor):
-
-    def run(self, start: Ast, state: CompileState):
-        """runs the visitor, starting at the given node, descending breadth-first"""
-
-        def _descend(node: Ast):
-            if not isinstance(node, Ast):
-                return
-            children = []
-            for field in fields(node):
-                field_val = getattr(node, field.name)
-                if isinstance(field_val, list):
-                    children.extend(field_val)
-                else:
-                    children.append(field_val)
-
-            for child in children:
-                if not isinstance(child, Ast):
-                    continue
-                self._visit(child, state)
-                if len(state.errors) != 0:
-                    break
-                _descend(child)
-                if len(state.errors) != 0:
-                    break
-
-        self._visit(start, state)
-        _descend(start)
-
 
 class AssignIds(TopDownVisitor):
     """assigns a unique id to each node to allow it to be indexed in a dict"""
@@ -554,7 +166,7 @@ class CreateVariables(Visitor):
                 )
                 return
 
-            var = FpyVariable(node.var_type, None)
+            var = FpyVariable(node.var_type, node)
             # new var. put it in the table under this scope
             state.variables[node.variable.var] = var
             state.runtime_values[node.variable.var] = var
@@ -565,7 +177,7 @@ class CreateVariables(Visitor):
             return
 
 
-class ResolveReferences(Visitor):
+class ResolveReferences(TopDownVisitor):
     """for each reference, resolve it in a specific scope based on its
     syntactic position, or fail if could not resolve"""
 
@@ -604,7 +216,7 @@ class ResolveReferences(Visitor):
                 return None
             return attr
 
-        # parent is a ch, prm, const, var or field
+        # parent is a ch, prm, const, or field
 
         value_type = get_ref_fpp_type_class(parent)
 
@@ -656,7 +268,7 @@ class ResolveReferences(Visitor):
             state.err("Invalid syntax", node)
             return None
 
-        # parent is a ch, prm, const, var or field
+        # parent is a ch, prm, const, or field
 
         value_type = get_ref_fpp_type_class(parent)
 
@@ -672,7 +284,7 @@ class ResolveReferences(Visitor):
 
         if not self.is_type_constant_size(value_type):
             state.err(
-                f"{value_type} has non-constant sized members, cannot access members",
+                f"{value_type.__name__} has non-constant sized members, cannot access members",
                 node,
             )
             return None
@@ -689,18 +301,17 @@ class ResolveReferences(Visitor):
         )
         return None
 
-    def resolve_if_ref(
-        self, node: AstExpr, ns: FpyScope, state: CompileState
-    ) -> bool:
+    def resolve_if_ref(self, node: AstExpr, ns: FpyScope, state: CompileState) -> bool:
         """if the node is a reference, try to resolve it in the given scope, and return true if success.
-        otherwise, if it is not a reference, return true as it doesn't need to be resolved"""
-        if not isinstance(node, AstReference):
+        otherwise, if it is not a reference, return true as it doesn't need to be resolved
+        """
+        if not is_instance_compat(node, AstReference):
             return True
 
         return self.resolve_ref_in_ns(node, ns, state) is not None
 
     def resolve_ref_in_ns(
-        self, node: AstExpr, ns: FpyScope, state: CompileState
+        self, node: AstReference, ns: FpyScope, state: CompileState
     ) -> FpyReference | None:
         """recursively resolves a reference in a scope, returning the resolved ref
         or none if none could be found."""
@@ -735,19 +346,19 @@ class ResolveReferences(Visitor):
             return
 
         for arg in node.args if node.args is not None else []:
-            # arg value refs must be consts
-            if not self.resolve_if_ref(arg, state.consts, state):
-                state.err("Unknown const", arg)
+            # arg value refs must have values at runtime
+            if not self.resolve_if_ref(arg, state.runtime_values, state):
+                state.err("Unknown runtime value", arg)
                 return
 
-    def visit_AstIf_AstElif(self, node: AstIf | AstElif, state: CompileState):
+    def visit_AstIf_AstElif(self, node: Union[AstIf, AstElif], state: CompileState):
         # if condition expr refs must be "runtime values" (tlm/prm/const/etc)
         if not self.resolve_if_ref(node.condition, state.runtime_values, state):
             state.err("Unknown runtime value", node.condition)
             return
 
-    def visit_AstComparison(self, node: AstComparison, state: CompileState):
-        # lhs/rhs side of comparison, if they are refs, must be refs to "runtime vals"
+    def visit_AstBinaryOp(self, node: AstBinaryOp, state: CompileState):
+        # lhs/rhs side of stack op, if they are refs, must be refs to "runtime vals"
         if not self.resolve_if_ref(node.lhs, state.runtime_values, state):
             state.err("Unknown runtime value", node.lhs)
             return
@@ -755,15 +366,9 @@ class ResolveReferences(Visitor):
             state.err("Unknown runtime value", node.rhs)
             return
 
-    def visit_AstAnd_AstOr(self, node: AstAnd | AstOr, state: CompileState):
-        for val in node.values:
-            if not self.resolve_if_ref(val, state.runtime_values, state):
-                state.err("Unknown runtime value", val)
-                return
-
-    def visit_AstNot(self, node: AstNot, state: CompileState):
-        if not self.resolve_if_ref(node.value, state.runtime_values, state):
-            state.err("Unknown runtime value", node.value)
+    def visit_AstUnaryOp(self, node: AstUnaryOp, state: CompileState):
+        if not self.resolve_if_ref(node.val, state.runtime_values, state):
+            state.err("Unknown runtime value", node.val)
             return
 
     def visit_AstAssign(self, node: AstAssign, state: CompileState):
@@ -779,118 +384,201 @@ class ResolveReferences(Visitor):
                 return
             var.type = type
 
-        if not self.resolve_if_ref(node.value, state.consts, state):
-            state.err("Unknown const", node.value)
+        if not self.resolve_if_ref(node.value, state.runtime_values, state):
+            state.err("Unknown runtime value", node.value)
             return
 
+    def visit_AstReference(self, node: AstReference, state: CompileState):
+        # make sure that all refs are resolved when we get to them
+        if node not in state.resolved_references:
+            state.err("Unknown variable", node)
+            return
 
-class CalculateExprTypes(Visitor):
-    """stores in state the fprime type of each expression, or NothingType if the expr had no type"""
 
-    def visit_AstNumber(self, node: AstNumber, state: CompileState):
-        if isinstance(node.value, float):
-            result_type = FloatType
-        elif isinstance(node.value, int):
-            result_type = IntegerType
-        else:
-            assert False, node.value
-        state.expr_types[node] = result_type
+class CheckUseBeforeDeclare(Visitor):
 
-    def visit_AstString(self, node: AstString, state: CompileState):
-        state.expr_types[node] = StringType
+    def __init__(self):
+        self.currently_declared_vars: list[FpyVariable] = []
 
-    def visit_AstBoolean(self, node: AstBoolean, state: CompileState):
-        state.expr_types[node] = BoolType
+    def visit_AstAssign(self, node: AstAssign, state: CompileState):
+        var = state.resolved_references[node.variable]
+
+        if var.declaration != node:
+            # this is not the node that declares this variable
+            return
+
+        # this node declares this variable
+
+        self.currently_declared_vars.append(var)
 
     def visit_AstReference(self, node: AstReference, state: CompileState):
         ref = state.resolved_references[node]
-        state.expr_types[node] = get_ref_fpp_type_class(ref)
-
-    def visit_AstFuncCall(self, node: AstFuncCall, state: CompileState):
-        ref = state.resolved_references[node.func]
-        assert isinstance(ref, FpyCallable)
-        state.expr_types[node] = ref.return_type
+        if not isinstance(ref, FpyVariable):
+            return
 
-    def visit_AstOr_AstAnd_AstNot_AstComparison(
-        self, node: AstOr | AstAnd | AstNot | AstComparison, state: CompileState
-    ):
-        state.expr_types[node] = BoolType
+        if ref.declaration.variable == node:
+            # this is the initial name of the variable. don't crash
+            return
 
-    def visit_default(self, node, state):
-        # coding error, missed an expr
-        assert not isinstance(node, AstExpr), node
+        if ref not in self.currently_declared_vars:
+            state.err("Variable used before declared", node)
+            return
 
 
-class CheckAndResolveArgumentTypes(Visitor):
-    """for each syntactic node with arguments (ands/ors/nots/cmps/funcs), check that the argument
-    types are right"""
+class PickAndConvertTypes(Visitor):
+    """stores in state the fprime type of each expression, or NothingType if the expr had no type"""
 
-    def is_literal_convertible_to(
-        self, node: AstLiteral, to_type: FppTypeClass, state: CompileState
+    def coerce_expr_type(
+        self, node: AstExpr, type: FppTypeClass, state: CompileState
     ) -> bool:
+        node_type = state.expr_types[node]
+        if self.can_coerce_type(node_type, type):
+            state.type_coercions[node] = type
+            return True
+        state.err(f"Expected {type.__name__}, found {node_type.__name__}", node)
+        return False
+
+    def can_coerce_type(self, type: FppTypeClass, to_type: FppTypeClass) -> bool:
+        if type == to_type:
+            return True
+        if issubclass(type, IntegerType) and issubclass(to_type, NumericalType):
+            # we can coerce any integer into any other number
+            return True
+        if issubclass(type, FloatType) and issubclass(to_type, FloatType):
+            # we can convert any float into any float
+            return True
+        if type == InternalStringType and issubclass(to_type, StringType):
+            # we can convert the internal String type to any string type
+            return True
 
-        if isinstance(node, AstBoolean):
-            return to_type == BoolType
+        return False
+
+    def pick_intermediate_type(
+        self, arg_types: list[FppTypeClass], op: BinaryStackOp | UnaryStackOp
+    ) -> FppTypeClass:
+
+        if op in BOOLEAN_OPERATORS:
+            return BoolType
 
-        if isinstance(node, AstString):
-            return issubclass(to_type, StringType)
+        non_numeric = any(not issubclass(t, NumericalType) for t in arg_types)
+
+        if op == BinaryStackOp.EQUAL or op == BinaryStackOp.NOT_EQUAL:
+            if non_numeric:
+                if len(set(arg_types)) != 1:
+                    # can only compare equality between the same types
+                    return None
+                return arg_types[0]
+
+        # all arguments should be numeric
+        if non_numeric:
+            # cannot find intermediate type
+            return None
 
-        if isinstance(node, AstNumber):
-            if isinstance(node.value, float):
-                return issubclass(to_type, FloatType)
-            if isinstance(node.value, int):
-                # int literal can be converted into float or int
-                return issubclass(to_type, (FloatType, IntegerType))
+        if op == BinaryStackOp.DIVIDE or op == BinaryStackOp.EXPONENT:
+            # always do true division over floats, python style
+            return F64Type
 
-            assert False, node.value
+        float = any(issubclass(t, FloatType) for t in arg_types)
+        unsigned = any(t in UNSIGNED_INTEGER_TYPES for t in arg_types)
 
-        assert False, node
+        if float:
+            # at least one arg is a float
+            return F64Type
 
-    def visit_AstComparison(self, node: AstComparison, state: CompileState):
+        if unsigned:
+            # at least one arg is unsigned
+            return U64Type
+
+        return I64Type
+
+    def visit_AstNumber(self, node: AstNumber, state: CompileState):
+        # give a best guess as to the final type of this node. we don't actually know
+        # its bitwidth or signedness yet
+        if isinstance(node.value, float):
+            result_type = F64Type
+        else:
+            result_type = InternalIntType
+        state.expr_types[node] = result_type
 
+    def visit_AstBinaryOp(self, node: AstBinaryOp, state: CompileState):
         lhs_type = state.expr_types[node.lhs]
         rhs_type = state.expr_types[node.rhs]
 
-        if not issubclass(lhs_type, NumericalType):
-            state.err(f"Cannot compare non-numeric type {lhs_type}", node.lhs)
+        intermediate_type = self.pick_intermediate_type([lhs_type, rhs_type], node.op)
+        if intermediate_type is None:
+            state.err(
+                f"Op {node.op} undefined for {lhs_type.__name__}, {rhs_type.__name__}",
+                node,
+            )
+            return
+
+        if not self.coerce_expr_type(node.lhs, intermediate_type, state):
             return
-        if not issubclass(rhs_type, NumericalType):
-            state.err(f"Cannot compare non-numeric type {rhs_type}", node.rhs)
+        if not self.coerce_expr_type(node.rhs, intermediate_type, state):
             return
 
-        # args are both numeric
+        # okay now find which actual directive we're going to use based on this intermediate
+        # type, and save it
+
+        dir = None
+        if (
+            node.op == BinaryStackOp.EQUAL or node.op == BinaryStackOp.NOT_EQUAL
+        ) and intermediate_type not in SPECIFIC_NUMERIC_TYPES:
+            dir = MemCompareDirective
+        else:
+            dir = BINARY_STACK_OPS[node.op][intermediate_type]
+
+        state.stack_op_directives[node] = dir
+
+        result_type = None
+        if node.op in NUMERIC_OPERATORS:
+            result_type = intermediate_type
+        else:
+            result_type = BoolType
+        state.expr_types[node] = result_type
+
+    def visit_AstUnaryOp(self, node: AstUnaryOp, state: CompileState):
+        val_type = state.expr_types[node.val]
 
-        # if either is generic float, pick F64. we want F64 cuz otherwise we need
-        # an FPEXT to convert to F64
-        if lhs_type == FloatType:
-            state.expr_types[node.lhs] = F64Type
-        if rhs_type == FloatType:
-            state.expr_types[node.rhs] = F64Type
+        intermediate_type = self.pick_intermediate_type([val_type], node.op)
+        if intermediate_type is None:
+            state.err(f"Op {node.op} undefined for {val_type.__name__}", node)
+            return
 
-        if lhs_type == IntegerType and rhs_type == IntegerType:
-            # use i64
-            state.expr_types[node.lhs] = I64Type
-            state.expr_types[node.rhs] = I64Type
+        if not self.coerce_expr_type(node.val, intermediate_type, state):
             return
 
-        if lhs_type == IntegerType:
-            # try to interpret it as the rhs_type if rhs_type is integer
-            if issubclass(rhs_type, IntegerType):
-                state.expr_types[node.lhs] = state.expr_types[node.rhs]
-            else:
-                # otherwise rhs is a float. just use i64
-                state.expr_types[node.lhs] = I64Type
+        # okay now find which actual directive we're going to use based on this intermediate
+        # type, and save it
 
-        if rhs_type == IntegerType:
-            # try to interpret it as the rhs_type if rhs_type is integer
-            if issubclass(lhs_type, IntegerType):
-                state.expr_types[node.rhs] = state.expr_types[node.lhs]
-            else:
-                # otherwise lhs is a float. just use i64
-                state.expr_types[node.rhs] = I64Type
+        chosen_dir = UNARY_STACK_OPS[node.op][intermediate_type]
+
+        result_type = None
+        if node.op in NUMERIC_OPERATORS:
+            result_type = intermediate_type
+        else:
+            result_type = BoolType
+
+        state.stack_op_directives[node] = chosen_dir
+        state.expr_types[node] = result_type
+
+    def visit_AstString(self, node: AstString, state: CompileState):
+        state.expr_types[node] = InternalStringType
+
+    def visit_AstBoolean(self, node: AstBoolean, state: CompileState):
+        state.expr_types[node] = BoolType
+
+    def visit_AstReference(self, node: AstReference, state: CompileState):
+        ref = state.resolved_references[node]
+        state.expr_types[node] = get_ref_fpp_type_class(ref)
+        if isinstance(node, AstGetItem):
+            # the node of the index number has no expression value, it's an arg
+            # but only at syntax level
+            state.expr_types[node.item] = NothingType
 
     def visit_AstFuncCall(self, node: AstFuncCall, state: CompileState):
         func = state.resolved_references[node.func]
+        assert isinstance(func, FpyCallable)
         func_args = func.args
         node_args = node.args if node.args else []
 
@@ -914,84 +602,81 @@ class CheckAndResolveArgumentTypes(Visitor):
         for value_expr, arg in zip(node_args, func_args):
             arg_name, arg_type = arg
 
-            value_expr_type = state.expr_types[value_expr]
-
-            if value_expr_type == arg_type or (
-                isinstance(value_expr, AstLiteral)
-                and self.is_literal_convertible_to(value_expr, arg_type, state)
-            ):
-                # arg type is good!
-                state.expr_types[value_expr] = arg_type
-                continue
-
-            # it is not. these are not compatible
-            state.errors.append(
-                CompileException(
-                    f"Cannot convert {value_expr} ({value_expr_type}) to {arg_type}",
-                    value_expr,
-                )
-            )
-            return
+            if not self.coerce_expr_type(value_expr, arg_type, state):
+                return
 
         # got thru all args successfully
+        state.expr_types[node] = func.return_type
 
-    def visit_AstOr_AstAnd(self, node: AstOr | AstAnd, state: CompileState):
-        # "or/and" can have as many args as you want. they all need to be bools tho
-        for val in node.values:
-            val_type = state.expr_types[val]
-            if val_type != BoolType:
-                state.err(f"Arguments to 'and'/'or' must be booleans", val)
-                return
-            state.expr_types[val] = BoolType
+    def visit_AstAssign(self, node: AstAssign, state: CompileState):
+        var_type = state.resolved_references[node.variable].type
 
-    def visit_AstNot(self, node: AstNot, state: CompileState):
-        val_type = state.expr_types[node.value]
-        if val_type != BoolType:
-            state.err(f"Argument to 'not' must be boolean", node.value)
+        if not self.coerce_expr_type(node.value, var_type, state):
             return
-        state.expr_types[node.value] = BoolType
 
+    def visit_default(self, node, state):
+        # coding error, missed an expr
+        assert not is_instance_compat(node, AstExpr), node
+
+
+class AllocateVariables(Visitor):
     def visit_AstAssign(self, node: AstAssign, state: CompileState):
-        var_type = state.resolved_references[node.variable].type
-        value_type = state.expr_types[node.value]
-        if var_type != value_type:
-            if not (
-                isinstance(node.value, AstLiteral)
-                and self.is_literal_convertible_to(node.value, var_type, state)
-            ):
-                state.err(f"Cannot interpret {node.value} as {var_type}", node.value)
-                return
+        existing_var = state.resolved_references[node.variable]
 
-        state.expr_types[node.value] = var_type
+        assert existing_var is not None
+        assert existing_var.type is not None
 
-        if var_type.getMaxSize() > MAX_SERIALIZABLE_REGISTER_SIZE:
-            state.err(f"{var_type} is too big to fit in a variable", node)
-            return
+        value_size = existing_var.type.getMaxSize()
 
-    def visit_AstGetItem(self, node: AstGetItem, state: CompileState):
-        # the node of the index number has no expression value, it's an arg
-        # but only at syntax level
-        state.expr_types[node.item] = NothingType
+        if existing_var.lvar_offset is None:
+            # doesn't have an lvar idx, allocate one
+            lvar_offset = state.lvar_array_size_bytes
+            state.lvar_array_size_bytes += value_size
+            existing_var.lvar_offset = lvar_offset
 
 
-class CalculateExprValues(Visitor):
+class CalculateConstExprValues(Visitor):
     """for each expr, try to calculate its constant value and store it in a map. stores None if no value could be
     calculated at compile time, and NothingType if the expr had no value"""
 
+    def const_coerce_type(self, from_val: FppType, to_type: FppTypeClass) -> FppType:
+        if type(from_val) == to_type:
+            return from_val
+        if issubclass(to_type, StringType):
+            assert type(from_val) == InternalStringType, type(from_val)
+            return to_type(from_val.val)
+        if issubclass(to_type, FloatType):
+            assert issubclass(type(from_val), NumericalType), type(from_val)
+            return to_type(float(from_val.val))
+        if issubclass(to_type, IntegerType):
+            assert issubclass(type(from_val), IntegerType), type(from_val)
+            return to_type(int(from_val.val))
+        assert False, (from_val, type(from_val), to_type)
+
     def visit_AstLiteral(self, node: AstLiteral, state: CompileState):
         literal_type = state.expr_types[node]
-        if literal_type != NothingType:
-            assert (
-                literal_type in NUMERIC_TYPES
-                or issubclass(literal_type, StringType)
-                or literal_type == BoolType
-            ), literal_type
-            state.expr_values[node] = literal_type(node.value)
+
+        if literal_type == NothingType:
+            value = NothingType()
         else:
-            state.expr_values[node] = literal_type()
+            try:
+                value = literal_type(node.value)
+            except TypeException as e:
+                state.err(f"For type {literal_type.__name__}: {e}", node)
+                return
+
+        coerced_type = state.type_coercions.get(node, None)
+        if coerced_type is not None:
+            try:
+                value = self.const_coerce_type(value, coerced_type)
+            except TypeException as e:
+                state.err(f"For type {coerced_type.__name__}: {e}", node)
+                return
+        state.expr_values[node] = value
 
     def visit_AstReference(self, node: AstReference, state: CompileState):
         ref = state.resolved_references[node]
+        expr_type = state.expr_types[node]
 
         if isinstance(ref, (ChTemplate, PrmTemplate, FpyVariable)):
             # we do not try to calculate or predict these values at compile time
@@ -1022,10 +707,20 @@ class CalculateExprValues(Visitor):
         else:
             assert False, ref
 
-        assert expr_value is None or isinstance(expr_value, state.expr_types[node]), (
-            expr_value,
-            state.expr_types[node],
-        )
+        if expr_value is None:
+            # cannot calculate at compile time
+            state.expr_values[node] = None
+            return
+
+        assert isinstance(expr_value, expr_type), (expr_value, expr_type)
+
+        coerced_type = state.type_coercions.get(node, None)
+        if coerced_type is not None:
+            try:
+                expr_value = self.const_coerce_type(expr_value, coerced_type)
+            except TypeException as e:
+                state.err(f"For type {expr_type.__name__}: {e}", node)
+                return
         state.expr_values[node] = expr_value
 
     def visit_AstFuncCall(self, node: AstFuncCall, state: CompileState):
@@ -1037,9 +732,12 @@ class CalculateExprValues(Visitor):
         ]
         unknown_value = any(v for v in arg_values if v is None)
         if unknown_value:
+            # we will have to calculate this at runtime
             state.expr_values[node] = None
             return
 
+        expr_value = None
+
         if isinstance(func, FpyTypeCtor):
             # actually construct the type
             if issubclass(func.type, SerializableType):
@@ -1048,15 +746,15 @@ class CalculateExprValues(Visitor):
                 # t[0] is the arg name
                 arg_dict = {t[0]: v for t, v in zip(func.type.MEMBER_LIST, arg_values)}
                 instance._val = arg_dict
-                state.expr_values[node] = instance
+                expr_value = instance
 
             elif issubclass(func.type, ArrayType):
                 instance = func.type()
                 instance._val = arg_values
-                state.expr_values[node] = instance
+                expr_value = instance
 
             elif func.type == TimeType:
-                state.expr_values[node] = TimeType(*arg_values)
+                expr_value = TimeType(*arg_values)
 
             else:
                 # no other FppTypeClasses have ctors
@@ -1065,164 +763,170 @@ class CalculateExprValues(Visitor):
             # don't try to calculate the value of this function call
             # it's something like a cmd or macro
             state.expr_values[node] = None
+            return
+
+        assert isinstance(expr_value, func.return_type), (expr_value, func.return_type)
+
+        coerced_type = state.type_coercions.get(node, None)
+        if coerced_type is not None:
+            try:
+                expr_value = self.const_coerce_type(expr_value, coerced_type)
+            except TypeException as e:
+                state.err(f"For type {func.return_type.__name__}: {e}", node)
+                return
+        state.expr_values[node] = expr_value
 
-    def visit_AstTest(self, node: AstTest, state: CompileState):
-        # we do not calculate compile time value of or/and/nots/cmps at the moment
+    def visit_AstOp(self, node: AstOp, state: CompileState):
+        # we do not calculate compile time value of operators at the moment
         state.expr_values[node] = None
 
     def visit_default(self, node, state):
         # coding error, missed an expr
-        assert not isinstance(node, AstExpr), node
+        assert not is_instance_compat(node, AstExpr), node
 
 
-class GenerateVariableDirectives(Visitor):
-    """for each variable assignment or declaration, check the rhs was known
-    at compile time, and generate a directive"""
-
-    def visit_AstAssign(self, node: AstAssign, state: CompileState):
-        existing_var = state.resolved_references[node.variable]
-        # should already have been put in var table
-        assert existing_var is not None
-
-        # we should have type info about the variable
-        assert existing_var.type is not None
+class GenerateConstExprDirectives(Visitor):
+    """for each expr with a constant compile time value, generate
+    directives for how to put it in its register"""
 
-        value_type = state.expr_types[node.value]
-        value = state.expr_values[node.value]
+    def visit_AstExpr(self, node: AstExpr, state: CompileState):
+        if node in state.directives:
+            # already have directives associated with this node
+            return
 
-        # already type checked
-        assert value_type == type(value), (value_type, type(value))
+        expr_value = state.expr_values[node]
 
-        if value is None:
-            # expr value is unknown at this point in compile
-            state.err(
-                f"Cannot assign {node.variable.var}: {existing_var.type} to {node.value}, as its value was not known at compile time",
-                node.value,
-            )
+        if expr_value is None:
+            # no const value
             return
 
-        sreg_idx = existing_var.sreg_idx
-        if sreg_idx is None:
-            # doesn't have an sreg idx, allocate one
-            sreg_idx = state.next_sreg
-            state.next_sreg += 1
-            existing_var.sreg_idx = sreg_idx
-        val_bytes = value.serialize()
-        assert len(val_bytes) == value.getMaxSize(), (
-            len(val_bytes),
-            value.getMaxSize(),
-            value,
-        )
-        assert len(val_bytes) <= MAX_SERIALIZABLE_REGISTER_SIZE, len(val_bytes)
-        state.directives[node] = [SetSerRegDirective(sreg_idx, val_bytes)]
+        if isinstance(expr_value, NothingType):
+            # nothing type has no value
+            state.directives[node] = []
+            return
 
+        # it has a constant value at compile time
+        serialized_expr_value = expr_value.serialize()
 
-class GenerateConstCmdDirectives(Visitor):
-    """for each command or macro whose arguments were const at runtime (should be all at the moment),
-    generate a directive"""
-    def visit_AstFuncCall(self, node: AstFuncCall, state: CompileState):
-        func = state.resolved_references[node.func]
-        if isinstance(func, FpyCmd):
-            arg_bytes = bytes()
-            for arg_node in node.args if node.args is not None else []:
-                arg_value = state.expr_values[arg_node]
-                if arg_value is None:
-                    state.err(
-                        f"Only constant arguments to commands are allowed", arg_node
-                    )
-                    return
-                arg_bytes += arg_value.serialize()
-            state.directives[node] = [CmdDirective(func.cmd.get_op_code(), arg_bytes)]
-        elif isinstance(func, FpyMacro):
-            arg_values = []
-            for arg_node in node.args if node.args is not None else []:
-                arg_value = state.expr_values[arg_node]
-                if arg_value is None:
-                    state.err(
-                        f"Only constant arguments to macros are allowed", arg_node
-                    )
-                    return
-                arg_values.append(arg_value)
-
-            state.directives[node] = func.instantiate_macro(arg_values)
-        else:
-            state.directives[node] = None
-
-
-def put_sreg_in_nreg(
-    sreg_idx: int, sreg_offset: int, nreg_idx: int, size: int
-) -> list[Directive]:
-    if size > 4:
-        return [DeserSerReg8Directive(sreg_idx, sreg_offset, nreg_idx)]
-    elif size > 2:
-        return [DeserSerReg4Directive(sreg_idx, sreg_offset, nreg_idx)]
-    elif size > 1:
-        return [DeserSerReg2Directive(sreg_idx, sreg_offset, nreg_idx)]
-    elif size == 1:
-        return [DeserSerReg1Directive(sreg_idx, sreg_offset, nreg_idx)]
-    else:
-        assert False, size
-
-
-class AssignExprRegisters(Visitor):
-    """assign each expr a unique register"""
-    def visit_AstExpr(self, node: AstExpr, state: CompileState):
-        state.expr_registers[node] = state.next_register
-        state.next_register += 1
+        # push it to the stack
+        state.directives[node] = [PushValDirective(serialized_expr_value)]
 
 
-class GenerateConstExprDirectives(Visitor):
-    """for each expr with a constant compile time value, generate
-    directives for how to put it in its register"""
-    def visit_AstExpr(self, node: AstExpr, state: CompileState):
-        expr_type = state.expr_types[node]
+class GenerateExprMacrosAndCmds(Visitor):
+    """for each expr whose value is not known at compile time, but can be calculated at run time,
+    generate directives to calculate the value and put it in its register. for each command
+    or macro, generate directives for calling them with appropriate arg values"""
+
+    def get_64_bit_type(self, type: FppTypeClass) -> FppTypeClass:
+        assert type in SPECIFIC_NUMERIC_TYPES, type
+        return (
+            I64Type
+            if type in SIGNED_INTEGER_TYPES
+            else U64Type if type in UNSIGNED_INTEGER_TYPES else F64Type
+        )
 
-        if node in state.directives:
-            # already have directives associated with this node
-            return
+    def truncate_from_64_bits(
+        self, from_type: FppTypeClass, new_size: int
+    ) -> list[Directive]:
 
-        if expr_type == NothingType:
-            # impossible. nothing type has no value
-            state.directives[node] = None
-            return
+        assert new_size in (1, 2, 4, 8), new_size
+        assert from_type.getMaxSize() == 8, from_type.getMaxSize()
 
-        if expr_type.getMaxSize() > 8:
-            # bigger than 8 bytes
-            # impossible. can't fit in a register
-            state.directives[node] = None
-            return
+        if new_size == 8:
+            # already correct size
+            return []
 
-        # okay, it is not nothing and it is smaller than 8 bytes.
-        # should be able to put it in a reg
+        if from_type == F64Type:
+            # only one option for float trunc
+            assert new_size == 4, new_size
+            return [FloatTruncateDirective()]
 
-        register = state.expr_registers[node]
+        # must be an int
+        assert issubclass(from_type, IntegerType), from_type
 
-        expr_value = state.expr_values[node]
+        if new_size == 1:
+            return [IntegerTruncate64To8Directive()]
+        elif new_size == 2:
+            return [IntegerTruncate64To16Directive()]
 
-        if expr_value is None:
-            # no const value
-            return
+        return [IntegerTruncate64To32Directive()]
 
-        # it has a constant value at compile time
-        serialized_expr_value = expr_value.serialize()
-        assert len(serialized_expr_value) <= 8, len(serialized_expr_value)
-        val_as_i64_bytes = bytes(8 - len(serialized_expr_value))
-        val_as_i64_bytes += serialized_expr_value
+    def extend_to_64_bits(self, type: FppTypeClass) -> list[Directive]:
+        if type.getMaxSize() == 8:
+            # already 8 bytes
+            return []
+        if type == F32Type:
+            return [FloatExtendDirective()]
 
-        # reinterpret as an I64
-        val_as_i64 = I64Type()
-        val_as_i64.deserialize(val_as_i64_bytes, 0)
+        # must be an int
+        assert issubclass(type, IntegerType), type
 
-        state.directives[node] = [SetRegDirective(register, val_as_i64.val)]
+        from_size = type.getMaxSize()
+        assert from_size in (1, 2, 4, 8), from_size
 
+        if type in SIGNED_INTEGER_TYPES:
+            if from_size == 1:
+                return [IntegerSignedExtend8To64Directive()]
+            elif from_size == 2:
+                return [IntegerSignedExtend16To64Directive()]
+            else:
+                return [IntegerSignedExtend32To64Directive()]
+        else:
+            if from_size == 1:
+                return [IntegerZeroExtend8To64Directive()]
+            elif from_size == 2:
+                return [IntegerZeroExtend16To64Directive()]
+            else:
+                return [IntegerZeroExtend32To64Directive()]
+
+    def convert_type(
+        self, from_type: FppTypeClass, to_type: FppTypeClass
+    ) -> list[Directive]:
+        if from_type == to_type:
+            return []
+
+        # only valid runtime type conversion is between two numeric types
+        assert (
+            from_type in SPECIFIC_NUMERIC_TYPES and to_type in SPECIFIC_NUMERIC_TYPES
+        ), (
+            from_type,
+            to_type,
+        )
+        # also invalid to convert from a float to an integer at runtime due to loss of precision
+        assert not (
+            from_type in SPECIFIC_FLOAT_TYPES and to_type in SPECIFIC_INTEGER_TYPES
+        ), (
+            from_type,
+            to_type,
+        )
 
-class GenerateNonConstExprDirectives(Visitor):
-    """for each expr whose value is not known at compile time, but can be calculated at run time,
-    generate directives to calculate the value and put it in its register"""
+        dirs = []
+        # first go to 64 bit width
+        dirs.extend(self.extend_to_64_bits(from_type))
+        from_64_bit = self.get_64_bit_type(from_type)
+        to_64_bit = self.get_64_bit_type(to_type)
+
+        # now convert from int to float if necessary
+        if from_64_bit == U64Type and to_64_bit == F64Type:
+            dirs.append(UnsignedIntToFloatDirective())
+            from_64_bit = F64Type
+        elif from_64_bit == I64Type and to_64_bit == F64Type:
+            dirs.append(SignedIntToFloatDirective())
+            from_64_bit = F64Type
+        elif from_64_bit == U64Type or from_64_bit == I64Type:
+            assert to_64_bit == U64Type or to_64_bit == I64Type
+            # conversion from signed to unsigned int is implicit, doesn't need code gen
+            from_64_bit = to_64_bit
+
+        assert from_64_bit == to_64_bit, (from_64_bit, to_64_bit)
+
+        # now truncate back down to desired size
+        dirs.extend(self.truncate_from_64_bits(to_64_bit, to_type.getMaxSize()))
+        return dirs
 
     def visit_AstReference(self, node: AstReference, state: CompileState):
         if node in state.directives:
-            # already know how to put it in reg, or it is impossible
+            # already know how to put it on stack, or it is impossible
             return
 
         expr_type = state.expr_types[node]
@@ -1232,168 +936,178 @@ class GenerateNonConstExprDirectives(Visitor):
 
         # does not have a constant compile time value
 
-        # all references that don't have a compile time value have to go into an sreg first
-        # and then into an nreg
-
-        sreg_idx = None
+        # first, put it in an lvar. then load it from the lvar onto stack
 
-        offset = 0
+        # the offset of the field in the parent type
+        offset_in_parent_val = 0
+        # the offset of the lvar the parent type is stored in
+        offset_in_lvar_array = 0
 
         base_ref = ref
 
         # if it's a field ref, find the parent and the offset in the parent
         while isinstance(base_ref, FieldReference):
-            offset += base_ref.offset
+            offset_in_parent_val += base_ref.offset
             base_ref = base_ref.parent
 
-        if isinstance(base_ref, FpyVariable):
-            # already in an sreg
-            sreg_idx = base_ref.sreg_idx
+        if isinstance(base_ref, ChTemplate):
+            # put it in an lvar
+            offset_in_lvar_array = state.lvar_array_size_bytes
+            state.lvar_array_size_bytes += base_ref.get_type_obj().getMaxSize()
+            directives.append(
+                StoreTlmValDirective(base_ref.get_id(), offset_in_lvar_array)
+            )
+        elif isinstance(base_ref, PrmTemplate):
+            # put it in an lvar
+            offset_in_lvar_array = state.lvar_array_size_bytes
+            state.lvar_array_size_bytes += base_ref.get_type_obj().getMaxSize()
+            directives.append(
+                StorePrmDirective(base_ref.get_id(), offset_in_lvar_array)
+            )
+        elif isinstance(base_ref, FpyVariable):
+            # already should be in an lvar
+            offset_in_lvar_array = base_ref.lvar_offset
         else:
-            sreg_idx = state.next_sreg
-            state.next_sreg += 1
-
-            if isinstance(base_ref, ChTemplate):
-                tlm_time_sreg_idx = state.next_sreg
-                state.next_sreg += 1
-                directives.append(
-                    GetTlmDirective(sreg_idx, tlm_time_sreg_idx, base_ref.get_id())
-                )
-
-            elif isinstance(base_ref, PrmTemplate):
-                directives.append(GetPrmDirective(sreg_idx, base_ref.get_id()))
+            assert (
+                False
+            ), base_ref  # ref should either be impossible to put on stack or should have a compile time val
 
-            else:
-                assert (
-                    False
-                ), base_ref  # ref should either be impossible to put in a reg or should have a compile time val
-
-        # pull from sreg into nreg
-        directives.extend(
-            put_sreg_in_nreg(
-                sreg_idx, offset, state.expr_registers[node], expr_type.getMaxSize()
+        # load from the lvar
+        directives.append(
+            LoadDirective(
+                offset_in_lvar_array + offset_in_parent_val, expr_type.getMaxSize()
             )
         )
+        converted_type = state.type_coercions.get(node, None)
+        if converted_type is not None:
+            directives.extend(self.convert_type(expr_type, converted_type))
 
         state.directives[node] = directives
 
-    def visit_AstAnd_AstOr(self, node: AstAnd | AstOr, state: CompileState):
+    def visit_AstBinaryOp(self, node: AstBinaryOp, state: CompileState):
         if node in state.directives:
-            # already know how to put it in reg, or know that it's impossible
+            # already know how to put it on stack
             return
 
-        expr_reg = state.expr_registers[node]
         directives = []
 
-        registers_to_compare = []
-        for arg_value_expr in node.values:
-            arg_value_dirs = state.directives[arg_value_expr]
-            assert arg_value_dirs is not None
-            directives.extend(arg_value_dirs)
-            registers_to_compare.append(state.expr_registers[arg_value_expr])
-
-        assert len(registers_to_compare) >= 2, len(registers_to_compare)
-
-        # okay, now we have to "or" or "and" together all of the registers
-        # "or/and" the first two together, put in res.
-        # from then on, "or/and" the next with res
-
-        dir_type = OrDirective if isinstance(node, AstOr) else AndDirective
+        expr_type = state.expr_types[node]
 
-        directives.append(
-            dir_type(registers_to_compare[0], registers_to_compare[1], expr_reg)
-        )
+        lhs_dirs = state.directives[node.lhs]
+        rhs_dirs = state.directives[node.rhs]
+
+        # which variant of the op did we pick?
+        dir = state.stack_op_directives[node]
+
+        # generate the actual op itself
+        directives: list[Directive] = lhs_dirs + rhs_dirs
+        if dir == MemCompareDirective:
+            lhs_type = state.expr_types[node.lhs]
+            rhs_type = state.expr_types[node.rhs]
+            assert lhs_type == rhs_type, (lhs_type, rhs_type)
+            directives.append(dir(lhs_type.getMaxSize()))
+            if node.op == BinaryStackOp.NOT_EQUAL:
+                directives.append(NotDirective())
+        elif dir == NoOpDirective:
+            # don't include no op
+            pass
+        else:
+            directives.append(dir())
 
-        for i in range(2, len(registers_to_compare)):
-            directives.append(dir_type(expr_reg, registers_to_compare[i], expr_reg))
+        # and convert the result of the op into the desired result of this expr
+        converted_type = state.type_coercions.get(node, None)
+        if converted_type is not None:
+            directives.extend(self.convert_type(expr_type, converted_type))
 
         state.directives[node] = directives
 
-    def visit_AstNot(self, node: AstNot, state: CompileState):
+    def visit_AstUnaryOp(self, node: AstUnaryOp, state: CompileState):
         if node in state.directives:
-            # already know how to put it in reg
+            # already know how to put it on stack
             return
 
-        expr_reg = state.expr_registers[node]
         directives = []
-        arg_value_dirs = state.directives[node.value]
-        assert arg_value_dirs is not None
-        directives.extend(arg_value_dirs)
-        directives.append(NotDirective(state.expr_registers[node.value], expr_reg))
 
-        state.directives[node] = directives
+        expr_type = state.expr_types[node]
 
-    def visit_AstComparison(self, node: AstComparison, state: CompileState):
-        if node in state.directives:
-            # already know how to put it in reg
-            return
+        val_dirs = state.directives[node.val]
 
-        directives = []
+        # which variant of the op did we pick?
+        dir = state.stack_op_directives[node]
+        # generate the actual op itself
+        directives: list[Directive] = val_dirs
 
-        lhs_type = state.expr_types[node.lhs]
-        rhs_type = state.expr_types[node.rhs]
+        if node.op == UnaryStackOp.NEGATE:
+            # in this case, we also need to push -1
+            if dir == FloatMultiplyDirective:
+                directives.append(PushValDirective(F64Type(-1).serialize()))
+            elif dir == IntMultiplyDirective:
+                directives.append(PushValDirective(I64Type(-1).serialize()))
 
-        lhs_reg = state.expr_registers[node.lhs]
-        rhs_reg = state.expr_registers[node.rhs]
-        res_reg = state.expr_registers[node]
-
-        directives.extend(state.directives[node.lhs])
-        directives.extend(state.directives[node.rhs])
-
-        fp = False
-        if issubclass(lhs_type, FloatType) or issubclass(rhs_type, FloatType):
-            fp = True
-
-        if fp:
-            # need to convert both lhs and rhs into F64
-            # modify them in place
-
-            # convert int to float
-            if issubclass(lhs_type, IntegerType):
-                if lhs_type in UNSIGNED_INTEGER_TYPES:
-                    directives.append(UnsignedIntToFloatDirective(lhs_reg, lhs_reg))
-                else:
-                    directives.append(SignedIntToFloatDirective(lhs_reg, lhs_reg))
-            if issubclass(rhs_type, IntegerType):
-                if rhs_type in UNSIGNED_INTEGER_TYPES:
-                    directives.append(UnsignedIntToFloatDirective(rhs_reg, rhs_reg))
-                else:
-                    directives.append(SignedIntToFloatDirective(rhs_reg, rhs_reg))
-
-            # convert F32 to F64
-            if lhs_type == F32Type:
-                directives.append(FloatExtendDirective(lhs_reg, lhs_reg))
-            if rhs_type == F32Type:
-                directives.append(FloatExtendDirective(rhs_reg, rhs_reg))
-
-        if node.op.value == "==":
-            if fp:
-                directives.append(FloatEqualDirective(lhs_reg, rhs_reg, res_reg))
-            else:
-                directives.append(IntEqualDirective(lhs_reg, rhs_reg, res_reg))
-        elif node.op.value == "!=":
-            if fp:
-                directives.append(FloatNotEqualDirective(lhs_reg, rhs_reg, res_reg))
-            else:
-                directives.append(IntNotEqualDirective(lhs_reg, rhs_reg, res_reg))
-        else:
+        directives.append(dir())
+        # and convert the result of the op into the desired result of this expr
+        converted_type = state.type_coercions.get(node, None)
+        if converted_type is not None:
+            directives.extend(self.convert_type(expr_type, converted_type))
 
-            if fp:
-                dir_type = FLOAT_INEQUALITY_DIRECTIVES[node.op.value]
+        state.directives[node] = directives
+
+    def visit_AstFuncCall(self, node: AstFuncCall, state: CompileState):
+        node_args = node.args if node.args is not None else []
+        func = state.resolved_references[node.func]
+        dirs = state.directives.get(node, [])
+        if len(dirs) > 0:
+            # already know how to put this on the stack
+            return
+        if isinstance(func, FpyCmd):
+            const_args = not any(
+                state.expr_values[arg_node] is None for arg_node in node_args
+            )
+            if const_args:
+                # can just hardcode this cmd
+                arg_bytes = bytes()
+                for arg_node in node_args:
+                    arg_value = state.expr_values[arg_node]
+                    arg_bytes += arg_value.serialize()
+                dirs = [ConstCmdDirective(func.cmd.get_op_code(), arg_bytes)]
             else:
-                # if either is signed, consider both as signed
-                signed = (
-                    lhs_type in SIGNED_INTEGER_TYPES or rhs_type in SIGNED_INTEGER_TYPES
+                arg_byte_count = 0
+                # push all args to the stack
+                # keep track of how many bytes total we have pushed
+                for arg_node in node_args:
+                    node_dirs = state.directives[arg_node]
+                    assert len(node_dirs) >= 1
+                    dirs.extend(node_dirs)
+                    arg_byte_count = state.expr_types[arg_node].getMaxSize()
+                # then push cmd opcode to stack as u32
+                dirs.append(
+                    PushValDirective(U32Type(func.cmd.get_op_code()).serialize())
                 )
+                # now that all args are pushed to the stack, pop them and opcode off the stack
+                # as a command
+                dirs.append(StackCmdDirective(arg_byte_count))
+        elif isinstance(func, FpyMacro):
+            # put all arg values on stack
+            for arg_node in node_args:
+                node_dirs = state.directives[arg_node]
+                assert len(node_dirs) >= 1
+                dirs.extend(node_dirs)
 
-                if signed:
-                    dir_type = INT_SIGNED_INEQUALITY_DIRECTIVES[node.op.value]
-                else:
-                    dir_type = INT_UNSIGNED_INEQUALITY_DIRECTIVES[node.op.value]
+            dirs.append(func.dir())
+        else:
+            dirs = None
 
-            directives.append(dir_type(lhs_reg, rhs_reg, res_reg))
+        # perform type conversion if called for
+        coerced_type = state.type_coercions.get(node, None)
+        if coerced_type is not None:
+            dirs.extend(self.convert_type(func.return_type, coerced_type))
+        state.directives[node] = dirs
 
-        state.directives[node] = directives
+    def visit_AstAssign(self, node: AstAssign, state: CompileState):
+        var = state.resolved_references[node.variable]
+        state.directives[node] = state.directives[node.value] + [
+            StoreDirective(var.lvar_offset, var.type.getMaxSize())
+        ]
 
 
 class CountNodeDirectives(Visitor):
@@ -1437,8 +1151,11 @@ class CountNodeDirectives(Visitor):
 
         state.node_dir_counts[node] = count
 
-    def visit_AstBody(self, node: AstBody, state: CompileState):
+    def visit_AstBody(self, node: Union[AstBody, AstScopedBody], state: CompileState):
         count = 0
+        if isinstance(node, AstScopedBody):
+            # add one for lvar array alloc
+            count += 1
         for stmt in node.stmts:
             count += state.node_dir_counts[stmt]
 
@@ -1453,13 +1170,18 @@ class CountNodeDirectives(Visitor):
 class CalculateStartLineIdx(TopDownVisitor):
     """based on the number of directives generated by each node, calculate the start line idx
     of each node's directives"""
-    def visit_AstBody(self, node: AstBody, state: CompileState):
+
+    def visit_AstBody(self, node: Union[AstBody, AstScopedBody], state: CompileState):
         if node not in state.start_line_idx:
             state.start_line_idx[node] = 0
 
         start_idx = state.start_line_idx[node]
 
         line_idx = start_idx
+        if isinstance(node, AstScopedBody):
+            # include lvar alloc
+            line_idx += 1
+
         for stmt in node.stmts:
             state.start_line_idx[stmt] = line_idx
             line_idx += state.node_dir_counts[stmt]
@@ -1518,10 +1240,10 @@ class GenerateBodyDirectives(Visitor):
 
         for case in cases:
             case_dirs = []
-            # include the condition
+            # put the conditional on top of stack
             case_dirs.extend(state.directives[case[0]])
             # include if stmt (update the end idx later)
-            if_dir = IfDirective(state.expr_registers[case[0]], -1)
+            if_dir = IfDirective(-1)
 
             case_dirs.append(if_dir)
             # include body
@@ -1532,7 +1254,7 @@ class GenerateBodyDirectives(Visitor):
             goto_ends.append(goto_dir)
 
             # if false, skip the body and goto
-            if_dir.false_goto_stmt_index = (
+            if_dir.false_goto_dir_index = (
                 start_line_idx + len(all_dirs) + len(case_dirs)
             )
 
@@ -1542,12 +1264,14 @@ class GenerateBodyDirectives(Visitor):
             all_dirs.extend(state.directives[node.els])
 
         for goto in goto_ends:
-            goto.statement_index = start_line_idx + len(all_dirs)
+            goto.dir_idx = start_line_idx + len(all_dirs)
 
         state.directives[node] = all_dirs
 
-    def visit_AstBody(self, node: AstBody, state: CompileState):
+    def visit_AstBody(self, node: Union[AstBody, AstScopedBody], state: CompileState):
         dirs = []
+        if isinstance(node, AstScopedBody):
+            dirs.append(AllocateDirective(state.lvar_array_size_bytes))
         for stmt in node.stmts:
             stmt_dirs = state.directives.get(stmt, None)
             if stmt_dirs is not None:
@@ -1556,6 +1280,52 @@ class GenerateBodyDirectives(Visitor):
         state.directives[node] = dirs
 
 
+HEADER_FORMAT = "!BBBBBHI"
+HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+
+
+@dataclass
+class Header:
+    majorVersion: int
+    minorVersion: int
+    patchVersion: int
+    schemaVersion: int
+    argumentCount: int
+    statementCount: int
+    bodySize: int
+
+
+FOOTER_FORMAT = "!I"
+FOOTER_SIZE = struct.calcsize(FOOTER_FORMAT)
+
+
+@dataclass
+class Footer:
+    crc: int
+
+
+def serialize_directives(dirs: list[Directive], output: Path):
+    output_bytes = bytes()
+
+    for dir in dirs:
+        dir_bytes = dir.serialize()
+        if len(dir_bytes) > MAX_DIRECTIVE_SIZE:
+            raise CompileException(
+                f"Directive {dir} in sequence too large (expected less than {MAX_DIRECTIVE_SIZE}, was {len(dir_bytes)})",
+                None,
+            )
+        output_bytes += dir_bytes
+
+    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))
+
+    output.write_bytes(output_bytes)
+
+
 def get_base_compile_state(dictionary: str) -> CompileState:
     """return the initial state of the compiler, based on the given dict path"""
     cmd_json_dict_loader = CmdJsonLoader(dictionary)
@@ -1571,11 +1341,16 @@ def get_base_compile_state(dictionary: str) -> CompileState:
     (prm_id_dict, prm_name_dict, versions) = prm_json_dict_loader.construct_dicts(
         dictionary
     )
+    event_json_dict_loader = EventJsonLoader(dictionary)
+    (event_id_dict, event_name_dict, versions) = event_json_dict_loader.construct_dicts(
+        dictionary
+    )
     # the type name dict is a mapping of a fully qualified name to an fprime type
     # here we put into it all types found while parsing all cmds, params and tlm channels
     type_name_dict: dict[str, FppTypeClass] = cmd_json_dict_loader.parsed_types
     type_name_dict.update(ch_json_dict_loader.parsed_types)
     type_name_dict.update(prm_json_dict_loader.parsed_types)
+    type_name_dict.update(event_json_dict_loader.parsed_types)
 
     # enum const dict is a dict of fully qualified enum const name (like Ref.Choice.ONE) to its fprime value
     enum_const_name_dict: dict[str, FppType] = {}
@@ -1590,11 +1365,12 @@ def get_base_compile_state(dictionary: str) -> CompileState:
 
     # insert the implicit types into the dict
     type_name_dict["Fw.Time"] = TimeType
-    for typ in NUMERIC_TYPES:
+    for typ in SPECIFIC_NUMERIC_TYPES:
         type_name_dict[typ.get_canonical_name()] = typ
     type_name_dict["bool"] = BoolType
     # note no string type at the moment
 
+    cmd_response_type = type_name_dict["Fw.CmdResponse"]
     callable_name_dict: dict[str, FpyCallable] = {}
     # add all cmds to the callable dict
     for name, cmd in cmd_name_dict.items():
@@ -1602,8 +1378,8 @@ def get_base_compile_state(dictionary: str) -> CompileState:
         args = []
         for arg_name, _, arg_type in cmd.arguments:
             args.append((arg_name, arg_type))
-        # cmds are thought of as callables with a "NothingType" return value
-        callable_name_dict[name] = FpyCmd(NothingType, args, cmd)
+        # cmds are thought of as callables with a Fw.CmdResponse return value
+        callable_name_dict[name] = FpyCmd(cmd_response_type, args, cmd)
 
     # for each type in the dict, if it has a constructor, create an FpyTypeCtor
     # object to track the constructor and put it in the callable name dict
@@ -1641,7 +1417,7 @@ def get_base_compile_state(dictionary: str) -> CompileState:
     return state
 
 
-def compile(body: AstBody, dictionary: str) -> list[Directive]:
+def compile(body: AstScopedBody, dictionary: str) -> list[Directive]:
     state = get_base_compile_state(dictionary)
     passes: list[Visitor] = [
         AssignIds(),
@@ -1650,27 +1426,21 @@ def compile(body: AstBody, dictionary: str) -> list[Directive]:
         # now that variables have been defined, all names/attributes/indices (references)
         # should be defined
         ResolveReferences(),
+        CheckUseBeforeDeclare(),
         # now that we know what all refs point to, we should be able to figure out the type
         # of every expression
-        CalculateExprTypes(),
-        # now that we know the type of each expr, we can type check all function calls
-        # and also narrow down ambiguous argument types
-        CheckAndResolveArgumentTypes(),
+        PickAndConvertTypes(),
+        # now that expr types have been narrowed down, we can allocate lvar space for variables
+        AllocateVariables(),
         # okay, now that we're sure we're passing in all the right args to each func,
         # we can calculate values of type ctors etc etc
-        CalculateExprValues(),
-        # now that we know variable values, we can generate directives for vars
-        GenerateVariableDirectives(),
-        # give each expr its own register
-        AssignExprRegisters(),
-        # for cmds, which have constant arguments, generate the corresponding directives
-        GenerateConstCmdDirectives(),
+        CalculateConstExprValues(),
         # for expressions which have constant values, generate corresponding directives
-        # to put the expr in its register
+        # to put the expr on the stack
         GenerateConstExprDirectives(),
-        # for expressions which don't have constant values, generate directives to
-        # calculate the expr at runtime and put it in its register
-        GenerateNonConstExprDirectives(),
+        # generate directives to calculate exprs, macros and cmds at runtime and put them
+        # on the stack
+        GenerateExprMacrosAndCmds(),
         # count the number of directives generated by each node
         CountNodeDirectives(),
         # calculate the index that the node will correspond to in the output file
@@ -1684,4 +1454,11 @@ def compile(body: AstBody, dictionary: str) -> list[Directive]:
         for error in state.errors:
             raise error
 
-    return state.directives[body]
+    dirs = state.directives[body]
+    if len(dirs) > MAX_DIRECTIVES_COUNT:
+        raise CompileException(
+            f"Too many directives in sequence (expected less than {MAX_DIRECTIVES_COUNT}, had {len(dirs)})",
+            None,
+        )
+
+    return dirs