@h2loop/autosar 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h2loop/autosar",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "AUTOSAR Classic pack for Hydron: ECUC read/edit-in-place/validate/diff on ARXML, config-to-code trace, generator and build runners",
   "type": "module",
   "private": false,

package/python/ecuc_engine/codegen/binding.py

@@ -19,6 +19,9 @@ Path language (a list of steps, evaluated left to right from the row container):
                         finds its neighbour's PDU handle (TPS_ECUC 3.4.1.3, via EcucPduCollection/Pdu)
   call:<name>           a module generator's resolver (Generator.path_steps()) for what the defs cannot
                         express as a path, e.g. Com's notification callouts (terminal, token)
+  child                 the one chosen sub-container of a choice container (any def)
+  def                   def short name of the current container (terminal), e.g. which choice is configured
+  count:<Def>           number of direct sub-containers of def <Def> (terminal)
   sym                   TPS_ECUC_02108 symbol of the current container (terminal)
   module | name | index the current container's module name / SHORT-NAME / table index (terminal)
 Macro values: count:<Def> | count:@<Set> | max:<Def>/<Param>, optionally followed by +N or -N.
@@ -29,7 +32,12 @@ Module binding keys besides tables/objects/macros:
   vars      RAM objects per row that tables point to (e.g. I-PDU buffers), sized by a path
   require   [{"rows": "<Def>", "path": <path>, "in": [...], "why": "..."}]: what the static code supports;
             a configuration outside it is an error, never silently mis-generated
-Field keys: path, default, enum (literal -> C token), fmt ("hex" | "int" | template with {} / {MIP} / {Mip}),
+Table keys besides name/type/rows/fields: order (sort param), contiguous (that param must be exactly
+  0..n-1 after sorting, e.g. a position index), designated, per (<ParentDef>: one table per parent instance,
+  rows = its direct <Def> children, "{}" in name = parent SHORT-NAME; a parent with no rows is an error,
+  C has no empty arrays). unsupported entries may set "max": N (more than N containers is the error).
+Field keys: path, default, enum (literal or token -> C token), scale (multiply, must give an integer:
+  seconds -> ms), fmt ("hex" | "int" | template with {} / {MIP} / {Mip}),
   divide (a path from the row whose value divides this one, rounded: seconds -> main-function ticks),
   agg ({"over": <multi-ref>, "params": [...], "op": "min_nonzero" | "max", "skipIf": <param>}).
 """
@@ -147,6 +155,16 @@ class Eval:
                         (not wdef or c.def_name == wdef)]
                 hits.sort(key=lambda c: (c.module.name, self.cg.by_path_index(c)))
                 cur = hits[0] if hits else None
+            elif op == "child":
+                kids = list(cur.children)
+                if len(kids) > 1:
+                    raise BindingError(f"{cur.path}: path step child: {len(kids)} sub-containers, expected the one "
+                                       "chosen sub-container of a choice container")
+                cur = kids[0] if kids else None
+            elif op == "def":
+                return ("token", cur.def_name)
+            elif op == "count":
+                return ("token", W.c_uint(len(cur.sub(arg))))
             elif op == "sym":
                 s = self.cg.symbol(cur)
                 if s and self.ctx is not None:
@@ -231,6 +249,12 @@ class Eval:
                 s = self.ctx.xsym(v, self.mc, self.used_mips)
             return (s, "")
         if kind == "token":
+            if "enum" in spec:
+                if v not in spec["enum"]:
+                    raise BindingError(f"{row.path}: {spec['path']} = {v} is not supported by the static code "
+                                       f"(the {self.mc.name} binding maps only {', '.join(spec['enum'])})")
+                e = spec["enum"][v]
+                return (W.c_uint(e) if isinstance(e, int) else str(e), v)
             if fmt and fmt not in ("hex", "int"):
                 return (fmt.replace("{MIP}", v.upper()).replace("{Mip}", v).replace("{}", v), "")
             return (v, "")
@@ -244,6 +268,8 @@ class Eval:
             return (W.c_uint(e) if isinstance(e, int) else str(e), raw.strip())
         if "divide" in spec:
             return (self._ticks(row, raw, spec), "")
+        if "scale" in spec:
+            return (self._scaled(row, raw, spec), "")
         if fmt == "int":  # a numeric value held in a STRING param (e.g. ComSignalInitValue)
             n = parse_int(raw.strip())
             if n is None:
@@ -261,6 +287,20 @@ class Eval:
             raise BindingError(f"{row.path}: cannot convert {spec.get('name')} = {raw} to ticks of {spec['divide']} = {base}")
         return W.c_uint(int(round(v / b)))
 
+    def _scaled(self, row: Container, raw, spec: dict) -> str:
+        """value * scale as an integer (e.g. LinIfDelay seconds -> ms); a value that is not a whole multiple is
+        an error, never rounded silently."""
+        from ..values import parse_float
+        v = parse_float(str(raw).strip())
+        if v is None:
+            raise BindingError(f"{row.path}: {spec.get('name')} = {raw} is not a number")
+        x = v * spec["scale"]
+        n = int(round(x))
+        if abs(x - n) > 1e-6 * max(1.0, abs(x)):
+            raise BindingError(f"{row.path}: {spec['path']} = {str(raw).strip()} is not a whole multiple of "
+                               f"1/{spec['scale']}; the static code's {spec.get('name')} field holds an integer")
+        return W.c_uint(n)
+
     def _agg(self, row: Container, spec: dict) -> tuple:
         """Aggregate params over the targets of a multi-valued reference of the row (e.g. the smallest non-zero
         timeout of an I-PDU's signals, SWS_Com_00291)."""

package/python/ecuc_engine/codegen/bindings/sip_standin.json

@@ -373,6 +373,124 @@
           "init": ["Com_TxSignalInfo", "Com_RxSignalInfo", "Com_TxIPduInfo", "Com_RxIPduInfo"]
         }
       ]
+    },
+    "LinIf": {
+      "detect": {"header": "LinIf.h", "contains": "LinIf_FrameType"},
+      "sourceIncludes": ["LinIf.h"],
+      "sets": {"TxPdus": {"rows": "LinIfTxPdu"}},
+      "handleLayout": [{"param": "LinIfTxPduId", "sets": ["TxPdus"]}],
+      "require": [
+        {
+          "rows": "LinIfFrame",
+          "path": "param:LinIfFrameType",
+          "in": ["UNCONDITIONAL"],
+          "why": "LinIf_FrameType has no frame type: LinIf.c sends every slot as an unconditional frame (no sporadic, event-triggered, diagnostic MRF/SRF or node configuration frames)"
+        },
+        {
+          "rows": "LinIfFrame",
+          "path": ["sub:LinIfPduDirection", "child", "def"],
+          "in": ["LinIfTxPdu", "LinIfRxPdu"],
+          "why": "LinIf_FrameType.Direction is LINIF_DIR_TX or LINIF_DIR_RX only (no slave-to-slave or internal PDUs)"
+        },
+        {
+          "rows": "LinIfScheduleTable",
+          "path": "param:LinIfRunMode",
+          "in": ["RUN_CONTINUOUS"],
+          "why": "LinIf_ScheduleType has no run mode: LinIf_MainFunction cycles its entries continuously"
+        }
+      ],
+      "unsupported": [
+        {
+          "rows": "LinIfChannel",
+          "max": 1,
+          "why": "LinIf_ConfigType has one frame and one schedule list and no channel field"
+        },
+        {"rows": "LinIfSlave", "why": "LinIf.h is a master-node LinIf (LinIf_MainFunction runs the schedule)"},
+        {"rows": "LinIfSubstitutionFrames", "why": "LinIf_FrameType has no substitution frame list"},
+        {"rows": "LinIfFixedFrameSdu", "why": "LinIf_FrameType has no fixed response SDU"}
+      ],
+      "macros": [
+        {"name": "LINIF_NUMBER_OF_CHANNELS", "value": "count:LinIfChannel"},
+        {"name": "LINIF_NUMBER_OF_TX_PDUS", "value": "count:LinIfTxPdu"},
+        {"name": "LINIF_NUMBER_OF_FRAMES", "value": "count:LinIfFrame"},
+        {"name": "LINIF_NUMBER_OF_SCHEDULES", "value": "count:LinIfScheduleTable"}
+      ],
+      "tables": [
+        {
+          "name": "LinIf_Frames",
+          "type": "LinIf_FrameType",
+          "qualifier": "LINIF_CONST",
+          "static": true,
+          "rows": "LinIfFrame",
+          "size": "LINIF_NUMBER_OF_FRAMES",
+          "doc": "LinIfFrame in configuration order; LinIf_EntryType.FrameIndex indexes this table",
+          "fields": [
+            {"name": "FrameId", "path": "param:LinIfFrameId", "fmt": "hex"},
+            {
+              "name": "Length",
+              "path": [
+                ["sub:LinIfPduDirection", "sub:LinIfTxPdu", "ref:LinIfTxPduRef", "param:PduLength"],
+                ["sub:LinIfPduDirection", "sub:LinIfRxPdu", "ref:LinIfRxPduRef", "param:PduLength"]
+              ]
+            },
+            {
+              "name": "Checksum",
+              "path": "param:LinIfChecksumType",
+              "enum": {"CLASSIC": "LINIF_CHECKSUM_CLASSIC", "ENHANCED": "LINIF_CHECKSUM_ENHANCED"}
+            },
+            {
+              "name": "Direction",
+              "path": ["sub:LinIfPduDirection", "child", "def"],
+              "enum": {"LinIfTxPdu": "LINIF_DIR_TX", "LinIfRxPdu": "LINIF_DIR_RX"}
+            },
+            {
+              "name": "PduRPduId",
+              "path": [
+                ["sub:LinIfPduDirection", "sub:LinIfTxPdu", "peer:LinIfTxPduRef@PduR/PduRDestPdu", "sym"],
+                ["sub:LinIfPduDirection", "sub:LinIfRxPdu", "peer:LinIfRxPduRef@PduR/PduRSrcPdu", "sym"]
+              ]
+            }
+          ]
+        },
+        {
+          "name": "LinIf_Entries_{}",
+          "type": "LinIf_EntryType",
+          "qualifier": "LINIF_CONST",
+          "static": true,
+          "per": "LinIfScheduleTable",
+          "rows": "LinIfEntry",
+          "order": "LinIfEntryIndex",
+          "contiguous": true,
+          "doc": "{} slots in LinIfEntryIndex order (ECUC_LinIf_00011: position in the schedule table)",
+          "fields": [
+            {"name": "FrameIndex", "path": ["ref:LinIfFrameRef", "index"]},
+            {"name": "DelayMs", "path": "param:LinIfDelay", "scale": 1000}
+          ]
+        },
+        {
+          "name": "LinIf_Schedules",
+          "type": "LinIf_ScheduleType",
+          "qualifier": "LINIF_CONST",
+          "static": true,
+          "rows": "LinIfScheduleTable",
+          "size": "LINIF_NUMBER_OF_SCHEDULES",
+          "designated": true,
+          "doc": "indexed by LinIfScheduleTableIndex",
+          "comment": "name",
+          "fields": [
+            {"name": "Entries", "path": "name", "fmt": "LinIf_Entries_{}"},
+            {"name": "NumEntries", "path": "count:LinIfEntry"}
+          ]
+        }
+      ],
+      "objects": [
+        {
+          "name": "LinIf_Config",
+          "type": "LinIf_ConfigType",
+          "qualifier": "LINIF_CONST",
+          "init": ["LinIf_Frames", "LinIf_Schedules", "LINIF_NUMBER_OF_FRAMES", "LINIF_NUMBER_OF_SCHEDULES"]
+        }
+      ]
     }
   }
 }

package/python/ecuc_engine/codegen/modules/linif.py

@@ -0,0 +1,53 @@
+"""LinIf: LinIf_Cfg.h / LinIf_PBcfg.c.
+
+Def-driven (generic emitter): the LinIfGeneral switches and the TPS_ECUC_02108 / SWS_BSW_00200 symbols
+LinIfConf_LinIfTxPdu_<Pdu> (LinIfTxPduId, the handle PduR passes to LinIf_Transmit) and
+LinIfConf_LinIfScheduleTable_<Table> (LinIfScheduleTableIndex, used with LinIf_ScheduleRequest).
+
+The static LinIf's own layout (frame table, one entry list per schedule table, schedule table list,
+root config object) comes from its binding (bindings/*.json): channels, frames with their EcuC PDU
+length and PduR handle (via the shared EcucPduCollection/Pdu), schedule entries in LinIfEntryIndex
+order with LinIfDelay, schedule tables by LinIfScheduleTableIndex. Configuration the binding cannot
+represent (non-unconditional frames, slave nodes, more channels than the static code has, ...) is
+listed in the binding's `require` / `unsupported` and fails generation.
+
+This module adds only the SWS_LinIf consistency rules that hold for any static code:
+  * a schedule entry (LinIfEntry/LinIfFrameRef) must reference a frame of the schedule table's own
+    channel (ECUC_LinIf_00016; schedule tables are per channel, ECUC_LinIf_00365);
+  * the LinIfFrameId of the unconditional frames of a channel must be unique (one publisher per
+    frame identifier on a LIN cluster).
+"""
+from __future__ import annotations
+
+from ..registry import Generator, register
+
+
+def _channel(c):
+    while c is not None and c.def_name != "LinIfChannel":
+        c = c.parent
+    return c
+
+
+@register("LinIf")
+class LinIf(Generator):
+    std_header = "ComStack_Types.h"
+
+    def specific(self, mo):
+        for e in self.cg.instances(self.mc, "LinIfEntry"):
+            fr = self.cg.target(e.value("LinIfFrameRef"))
+            if fr is None:
+                mo.errors.append(f"{e.path}: LinIfFrameRef is not set or does not resolve to a LinIfFrame")
+            elif _channel(fr) is not _channel(e):
+                mo.errors.append(f"{e.path}: LinIfFrameRef points to {fr.path}, a frame of another channel "
+                                 f"(schedule tables are per channel, ECUC_LinIf_00365)")
+        for ch in self.cg.instances(self.mc, "LinIfChannel"):
+            seen: dict = {}
+            for fr in ch.sub("LinIfFrame"):
+                if (fr.text("LinIfFrameType") or "").strip() != "UNCONDITIONAL":
+                    continue
+                fid = (fr.text("LinIfFrameId") or "").strip()
+                if fid in seen:
+                    mo.errors.append(f"{fr.path}: LinIfFrameId {fid} is also used by {seen[fid]} on channel "
+                                     f"{ch.name}; unconditional frame identifiers must be unique per channel")
+                else:
+                    seen[fid] = fr.name

package/python/ecuc_engine/codegen/registry.py

@@ -98,10 +98,11 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
                              f"{', '.join('(not configured)' if x is None else str(x) for x in req['in'])}: {req.get('why', '')}")
     for un in mb.get("unsupported", []):
         rows = cg.instances(mo.mc, un["rows"])
-        if rows:
+        mx = un.get("max", 0)
+        if len(rows) > mx:
             mo.errors.append(f"{len(rows)} {un['rows']} container(s) configured ({', '.join(r.name for r in rows[:5])}"
                              f"{', ...' if len(rows) > 5 else ''}), which the {mb['_binding']} static code cannot "
-                             f"represent: {un.get('why', '')}")
+                             f"represent{f' (at most {mx})' if mx else ''}: {un.get('why', '')}")
     for inc in mb.get("sourceIncludes", []):
         mo.include(inc)
     macros = []
@@ -121,41 +122,9 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
             name = vs["name"].replace("{}", r.name)
             lines.append(f"{'static ' if vs.get('static') else ''}VAR({vs['type']}, {vs['qualifier']}) {name}[{size}];")
         pending.append(("var", ev.rank, vs.get("section", "VAR_NOINIT_UNSPECIFIED"), "\n".join(lines)))
-    for t in mb.get("tables", []):
-        ev.rank = 1
-        rows = ev.rows(t["rows"], sets)
-        if t.get("order"):
-            from ..values import parse_int
-            rows.sort(key=lambda r: (parse_int(r.text(t["order"]) or "") is None, parse_int(r.text(t["order"]) or "") or 0))
-        lines, externs = [], []
-        des = t.get("designated")
-        if des:
-            _check_index(cg, mo, t, rows, des, values)
-        for r in rows:
-            vals = []
-            for f in t["fields"]:
-                v, _ = ev.field(r, f)
-                vals.append(v)
-                if f.get("extern") and v not in ("NULL_PTR", "0", "0u") and not v.startswith('"'):
-                    m = re.search(r"[A-Za-z_]\w*", v)
-                    if m:
-                        ext_ = "extern " + f["extern"].replace("{}", m.group(0)) + ";"
-                        if ext_ not in externs:
-                            externs.append(ext_)
-            lead = ""
-            if des:
-                lead = f"[{des.replace('{sym}', cg.symbol(r)) if isinstance(des, str) else cg.symbol(r)}] = "
-            comment = t.get("comment", "name")
-            cm = {"name": r.name, "sym": cg.symbol(r) or r.name}.get(comment, r.name)
-            if t.get("scalar"):
-                lines.append(f"  {lead}{vals[0]} /* {cm} */")
-            else:
-                lines.append(f"  {lead}{{ {', '.join(vals)} }} /* {cm} */")
-        st = "static " if t.get("static") else ""
-        size = t.get("size", "")
-        body = (f"/* {t.get('doc', t['rows'])} */\n{st}CONST({t['type']}, {t['qualifier']}) {t['name']}[{size}] = {{\n" +
-                ",\n".join(lines) + "\n};")
-        pending.append(("table", ev.rank, body, externs))
+    for t0 in mb.get("tables", []):
+        for t, rows in _table_instances(cg, mo, ev, t0, sets):
+            _emit_table(cg, mo, ev, t, rows, values, pending)
     objects = mb.get("objects", [])
     if objects:
         # a root config object points at the (static) tables and buffers, so they all live in its file:
@@ -173,6 +142,67 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
     mo.used_mips |= ev.used_mips
 
 
+def _table_instances(cg, mo, ev, t: dict, sets: dict) -> list:
+    """[(table spec, rows)]: one table, or one per parent instance for a "per" table."""
+    from ..values import parse_int
+    num = lambda r: parse_int(r.text(t["order"]) or "")  # noqa: E731
+    out = []
+    if t.get("per"):
+        specs = []
+        for par in cg.sorted_instances(mo.mc, t["per"]):
+            rows = par.sub(t["rows"])
+            if not rows:
+                raise B.BindingError(f"{par.path}: no {t['rows']} configured; {t['name'].replace('{}', par.name)} "
+                                     "would be an empty array, which C does not allow")
+            specs.append((dict(t, name=t["name"].replace("{}", par.name),
+                               doc=t.get("doc", t["rows"]).replace("{}", par.name)), rows))
+    else:
+        specs = [(t, ev.rows(t["rows"], sets))]
+    for spec, rows in specs:
+        if t.get("order"):
+            rows = sorted(rows, key=lambda r: (num(r) is None, num(r) or 0))
+        if t.get("contiguous"):
+            got = [num(r) for r in rows]
+            if got != list(range(len(rows))):
+                raise B.BindingError(f"{spec['name']}: {t['order']} of the {len(rows)} {t['rows']} rows must be exactly "
+                                     f"0..{len(rows) - 1} (table position), got {', '.join(map(str, got))}")
+        out.append((spec, rows))
+    return out
+
+
+def _emit_table(cg, mo, ev, t: dict, rows: list, values: dict, pending: list):
+    ev.rank = 1
+    lines, externs = [], []
+    des = t.get("designated")
+    if des:
+        _check_index(cg, mo, t, rows, des, values)
+    for r in rows:
+        vals = []
+        for f in t["fields"]:
+            v, _ = ev.field(r, f)
+            vals.append(v)
+            if f.get("extern") and v not in ("NULL_PTR", "0", "0u") and not v.startswith('"'):
+                m = re.search(r"[A-Za-z_]\w*", v)
+                if m:
+                    ext_ = "extern " + f["extern"].replace("{}", m.group(0)) + ";"
+                    if ext_ not in externs:
+                        externs.append(ext_)
+        lead = ""
+        if des:
+            lead = f"[{des.replace('{sym}', cg.symbol(r)) if isinstance(des, str) else cg.symbol(r)}] = "
+        comment = t.get("comment", "name")
+        cm = {"name": r.name, "sym": cg.symbol(r) or r.name}.get(comment, r.name)
+        if t.get("scalar"):
+            lines.append(f"  {lead}{vals[0]} /* {cm} */")
+        else:
+            lines.append(f"  {lead}{{ {', '.join(vals)} }} /* {cm} */")
+    st = "static " if t.get("static") else ""
+    size = t.get("size", "")
+    body = (f"/* {t.get('doc', t['rows'])} */\n{st}CONST({t['type']}, {t['qualifier']}) {t['name']}[{size}] = {{\n" +
+            ",\n".join(lines) + "\n};")
+    pending.append(("table", ev.rank, body, externs))
+
+
 def _check_index(cg, mo, t: dict, rows: list, des, values: dict):
     """A designated table is indexed by handle (minus an offset): every row must land in [0, size) exactly once,
     or the static code's table lookup would be wrong. Reported as an error, never renumbered here."""

package/skills/autosar/references/codegen.md

@@ -37,12 +37,30 @@ ComUserCallback of type COM_RX_ACK / COM_TX_ACK; `call:comUserCallback`), or, fo
 callbacks, the RTE's `Rte_COMCbk_<sn>()` / `Rte_COMCbkTAck_<sn>()` when the RTE's Rte_Cbk.h declares it
 (`call:rteSignalCallback`). Nothing is bound from guesses: no declaration, no callback.
 
+## LinIf
+`LinIf_Cfg.h`: LinIfGeneral switches, `LinIfConf_LinIfTxPdu_*` (LinIfTxPduId, the handle PduR passes to `LinIf_Transmit`) and
+`LinIfConf_LinIfScheduleTable_*` (LinIfScheduleTableIndex) symbols (TPS_ECUC_02108 / SWS_BSW_00200), `LINIF_NUMBER_OF_*`.
+`LinIf_PBcfg.c` (binding): frame table in configuration order (LinIfFrameId, length from the EcuC Pdu, checksum, direction
+from the LinIfPduDirection choice, PduR dest (Tx) / src (Rx) handle via the shared EcuC Pdu), one entry list per schedule
+table (`per` table, LinIfEntryIndex order, which must be 0..n-1; FrameIndex = position of LinIfFrameRef's frame;
+LinIfDelay s -> ms, a non-whole ms is an error), schedule list indexed by LinIfScheduleTableIndex, root `LinIf_Config`.
+Tx PDU handles are laid out 0..n-1 (handleLayout; `LinIf_Transmit` range-checks them).
+Errors, never dropped: frame types other than UNCONDITIONAL, PDU directions other than Tx/Rx, RUN_ONCE schedules, more
+than one channel, slave nodes, substitution frames, fixed frame SDUs (stand-in binding); an entry whose frame belongs to
+another channel, duplicate unconditional LinIfFrameIds on a channel (any binding).
+
+Binding path/table additions used by LinIf: `child` (chosen sub-container of a choice), `def` (its def name, mapped with
+`enum`), `count:<Def>`, field `scale`, table `per` / `contiguous`, `unsupported[].max`.
+
 ## Known differences from the sample/large fixture oracle (all explained)
 | Item | Oracle | Ours | Why |
 |---|---|---|---|
 | `NvM_BlockDescriptorTable[*].RamBlockDataAddress` | `X` | `&X` (as configured) | ECUC_NvM_00482 value is the address expression; kept verbatim, same address for arrays |
 | Rx I-PDU `TimeoutTicks` with mixed signal timeouts | largest ComTimeout | smallest non-zero | SWS_Com_00291 |
 | `<MIP>_CFG_*` version macros, generic ComGeneral/NvMCommon/... switches, Dem/Fee tables | absent | extra | def-driven output the oracle does not emit |
+| LinIf entry list name | `LinIf_Sched_<Table>` | `LinIf_Entries_<Table>` | `static` table, internal linkage: not part of the LinIf.h contract |
+| `LinSMConf_LinSMSchedule_*` in `LinIf_Cfg.h` | present | absent (in `LinSM_Cfg.h`) | a `LinSMConf_` symbol belongs to the LinSM config header (SWS_BSW_00200) |
+| `LINIF_NUMBER_OF_SCHEDULES`, LinIfGeneral switches, version macros | absent | extra | def/binding-driven output the oracle does not emit |
 | SchM main function names | `Com_MainFunctionTx` | same | SWS_Com says `Com_MainFunctionTx_<shortName>`; the instance named like its def keeps the SIP's legacy name |
 
 ## Reading a diff