@h2loop/autosar 0.1.2 → 1.1.0

package/python/ecuc_engine/rules/__init__.py

@@ -74,9 +74,11 @@ class RuleContext:
 
 
 def run_rules(project: Project) -> Iterable[dict]:
-    from . import com, handles  # noqa: F401  (registers the packs)
+    from . import com, handles, mem, nvm, pdur, system  # noqa: F401  (registers the packs)
     ctx = RuleContext(project)
     for r in RULES:
-        for e, line, msg, def_ref in r.fn(ctx):
+        for item in r.fn(ctx):
+            e, line, msg, def_ref = item[:4]
+            sev = item[4] if len(item) > 4 else r.severity  # a rule may downgrade one finding (e.g. NOT CHECKED -> info)
             yield {"file": project.rel(e.file), "line": line, "path": e.path, "rule": r.id,
-                   "severity": r.severity, "message": f"{msg} [{r.cite}]", "defRef": def_ref}
+                   "severity": sev, "message": f"{msg} [{r.cite}]", "defRef": def_ref}

package/python/ecuc_engine/rules/mem.py

@@ -0,0 +1,84 @@
+"""H2L-MEM-001: do the Fee/Ea blocks fit the memory they are configured to use?
+
+Followed generically: each Fee/Ea block -> its address-area reference (MemAcc address area) -> sub address
+areas -> sector batch (number of sectors x erase sector size). Per-block cost = blockSize + block overhead,
+rounded up to the virtual page size (FeeBlockOverhead/FeeVirtualPageSize from the Fee config when present),
+times the number of NV instances NvM keeps (NvMNvBlockNum of the referencing NvM block). Fee/Ea need spare
+space for sector switching / garbage collection, so the check compares against half the area (warning).
+"""
+from __future__ import annotations
+
+from . import rule
+from ..values import parse_int
+
+CITE = ("ECUC_Fee_00148 FeeBlockSize, FeeBlockOverhead/FeeVirtualPageSize; ECUC_NvM_00479 NvMNvBlockNum; MemAcc "
+        "address area / Mem sector batch sizes (SWS_MemAcc, SWS_Mem)")
+
+
+def _up(n: int, page: int) -> int:
+    return n if page <= 1 else ((n + page - 1) // page) * page
+
+
+def _first(ctx, rel):
+    c = ctx.containers(rel)
+    return c[0] if c else None
+
+
+@rule("H2L-MEM-001", "warning", CITE, "Fee/Ea blocks fit their configured memory area")
+def capacity(ctx):
+    for mod, blkdef, size_p in (("Fee", "Fee/FeeBlockConfiguration", "FeeBlockSize"),
+                                ("Ea", "Ea/EaBlockConfiguration", "EaBlockSize")):
+        blocks = ctx.containers(blkdef)
+        if not blocks:
+            continue
+        gen = _first(ctx, f"{mod}/{mod}General")
+        pub = _first(ctx, f"{mod}/{mod}PublishedInformation")
+        page = parse_int(ctx.text(gen, f"{mod}VirtualPageSize") or "") if gen is not None else None
+        over = parse_int(ctx.text(pub, f"{mod}BlockOverhead") or "") if pub is not None else None
+        instances: dict = {}
+        for nb in ctx.containers("NvM/NvMBlockDescriptor"):
+            stack = [nb]
+            n = parse_int(ctx.text(nb, "NvMNvBlockNum") or "") or 1
+            while stack:
+                e = stack.pop()
+                for g in ctx.p.find(e.path):
+                    stack.extend(g.children)
+                    for pv in g.params:
+                        if pv.is_ref and pv.value:
+                            instances[pv.value.strip()] = max(instances.get(pv.value.strip(), 1), n)
+        per_area: dict = {}
+        for b in blocks:
+            size = parse_int(ctx.text(b, size_p) or "")
+            if size is None:
+                continue
+            area = None
+            for g in ctx.p.find(b.path):
+                for pv in g.params:
+                    t = ctx.target(pv) if pv.is_ref else None
+                    if t is not None and "AddressArea" in (t.def_ref or ""):
+                        area = t
+            cost = _up(size + (over or 0), page or 1) * instances.get(b.path, 1)
+            key = area.path if area is not None else None
+            per_area.setdefault(key, [0, 0, area])
+            per_area[key][0] += cost
+            per_area[key][1] += 1
+        for key, (need, count, area) in per_area.items():
+            if area is None:
+                continue
+            cap, parts = 0, []
+            for sub in ctx.p.find(area.path)[0].children:
+                ns = parse_int(ctx.text(sub, f"MemAccNumberOfSectors") or "")
+                batch = ctx.target(ctx.value(sub, "MemAccSectorBatchRef"))
+                ss = parse_int(ctx.text(batch, "MemEraseSectorSize") or "") if batch is not None else None
+                if ns and ss:
+                    cap += ns * ss
+                    parts.append(f"{sub.name}: {ns} x {ss} B")
+            if not cap:
+                continue
+            usable = cap // 2
+            if need > usable:
+                anchor = ctx.value(blocks[0], size_p)
+                yield blocks[0], anchor.node.line if anchor else blocks[0].line, (
+                    f"{count} {mod} block(s) on {area.name} need {need} B (size + overhead {over or 0} B, rounded to "
+                    f"{page or 1} B pages, x NV instances) but the area holds {cap} B ({', '.join(parts)}); with space "
+                    f"for sector switching only ~{usable} B are usable"), anchor.def_ref if anchor else None

package/python/ecuc_engine/rules/nvm.py

@@ -0,0 +1,131 @@
+"""NvM block length vs the C object behind its permanent RAM block, and the Fee/Ea block that stores it.
+
+NvMRamBlockDataAddress names a C object; its size comes from a compile-only sizeof probe built with the
+project's own compiler/flags (ecuc_engine/probe.py). NvMNvBlockLength is the NV *data* length
+(ECUC_NvM_00479: "NV block data length in bytes"; CRC is managed by NvM on top). The Fee/Ea block is found by
+following the block's references to a FeeBlockConfiguration / EaBlockConfiguration.
+"""
+from __future__ import annotations
+
+import os
+import re
+
+from . import rule
+from .. import paths, probe
+from ..values import parse_int
+
+CITE = ("ECUC_NvM_00479 NvMNvBlockLength (NV block data length), ECUC_NvM_00482 NvMRamBlockDataAddress, "
+        "ECUC_Fee_00148 FeeBlockSize / ECUC_Ea_00128 EaBlockSize")
+SYMBOL = re.compile(r"^[&(\s]*(?:\(\s*\w+\s*\*?\s*\)\s*)?&?\s*([A-Za-z_]\w*)")
+
+
+def _storage_blocks(ctx, blk):
+    """Fee/Ea block configurations referenced (at any depth) from an NvM block descriptor."""
+    out = []
+    stack = [blk]
+    while stack:
+        e = stack.pop()
+        for g in ctx.p.find(e.path):
+            stack.extend(g.children)
+            for pv in g.params:
+                if pv.is_ref and pv.value:
+                    t = ctx.target(pv)
+                    if t is not None and (t.def_ref or "").endswith(("/FeeBlockConfiguration", "/EaBlockConfiguration")):
+                        out.append(t)
+    return out
+
+
+def blocks_with_ram(ctx):
+    for blk in ctx.containers("NvM/NvMBlockDescriptor"):
+        addr = (ctx.text(blk, "NvMRamBlockDataAddress") or "").strip()
+        m = SYMBOL.match(addr)
+        if m:
+            yield blk, addr, m.group(1)
+
+
+def probe_sizes(ctx):
+    """{block path: (size|None, Decl|None)} and notes; cached on the context."""
+    if getattr(ctx, "_nvm_sizes", None) is not None:
+        return ctx._nvm_sizes
+    root = ctx.p.root
+    tree = paths.walk(root, paths.is_c).files
+    from ..audit import is_generated
+    own = [f for f in tree if not is_generated(f)]
+    headers = [f for f in own if f.lower().endswith(".h")] + [f for f in tree if f.lower().endswith(".h") and f not in own]
+    cfiles = [f for f in own if f.lower().endswith(".c")]
+    decls, where = {}, {}
+    for blk, _addr, sym in blocks_with_ram(ctx):
+        d = probe.find_decl(sym, cfiles, headers)
+        where[blk.path] = d
+        if d is not None:
+            if not d.header:
+                d.header = probe.type_header(d.type, headers)
+                if d.header is None and d.type not in ("uint8", "uint16", "uint32", "sint8", "sint16", "sint32", "boolean",
+                                                         "char", "int", "short", "long", "float", "double"):
+                    continue
+            decls[blk.path] = d
+    ctx._nvm_probed = set(decls)
+    found, notes, tc = probe.sizes(root, probe.load_cfg(root), decls) if decls else ({}, [], None)
+    ctx._nvm_sizes = ({k: (found.get(k), where.get(k)) for k in where}, notes, tc)
+    return ctx._nvm_sizes
+
+
+@rule("H2L-NVM-001", "error", CITE, "NvM block length / Fee-Ea block size match the RAM block's C object size")
+def nvm_length_vs_c(ctx):
+    """Every NvM block descriptor gets an outcome: a size verdict (error on mismatch), or a NOT CHECKED info that
+    says why. A summary info is always emitted, so the rule never yields nothing when NvM is configured."""
+    blocks = ctx.containers("NvM/NvMBlockDescriptor")
+    if not blocks:
+        return
+    first = blocks[0]
+    with_ram = list(blocks_with_ram(ctx))
+    if not with_ram:
+        yield first, first.line, (f"NOT CHECKED: none of the {len(blocks)} NvM block(s) has an NvMRamBlockDataAddress "
+                                  "naming a C object"), None, "info"
+        return
+    table, notes, tc = probe_sizes(ctx)
+    for n in notes:
+        yield first, first.line, f"NOT CHECKED: {n}", None, "info"
+    checked = mism = 0
+    unchecked = []
+    for blk, addr, sym in with_ram:
+        size, decl = table.get(blk.path, (None, None))
+        if size is None:
+            why = ("not declared in any C source" if decl is None else
+                   f"{decl.type} has no header defining it" if blk.path not in getattr(ctx, "_nvm_probed", {blk.path})
+                   else "compiler did not report its size")
+            unchecked.append(blk.name)
+            yield blk, blk.line, f"NOT CHECKED: {blk.name}: sizeof({sym}) undetermined ({why})", None, "info"
+            continue
+        checked += 1
+        where = f"{os.path.relpath(decl.file, ctx.p.root)}:{decl.line}" if decl else "?"
+        ln = parse_int(ctx.text(blk, "NvMNvBlockLength") or "")
+        pv = ctx.value(blk, "NvMNvBlockLength")
+        crc = (ctx.text(blk, "NvMBlockUseCrc") or "").lower() == "true"
+        tail = f" (RAM block {addr}: {decl.type if decl else '?'} at {where}, sizeof = {size} via {tc.origin if tc else '?'}" \
+               f"{'; CRC ' + (ctx.text(blk, 'NvMBlockCrcType') or '') + ' is added by NvM on top' if crc else ''})"
+        if ln is not None and ln != size:
+            mism += 1
+            yield blk, pv.node.line, f"{blk.name}: NvMNvBlockLength={ln} but sizeof({sym}) = {size}" + tail, pv.def_ref
+        for st in _storage_blocks(ctx, blk):
+            sname = "FeeBlockSize" if (st.def_ref or "").endswith("/FeeBlockConfiguration") else "EaBlockSize"
+            bs = parse_int(ctx.text(st, sname) or "")
+            spv = ctx.value(st, sname)
+            if bs is not None and bs < size:
+                mism += 1
+                yield st, spv.node.line, (f"{st.name}: {sname}={bs} cannot hold the {size}-byte RAM block of {blk.name}"
+                                          + tail), spv.def_ref
+    yield first, first.line, (f"sizeof check: {checked} of {len(with_ram)} RAM block(s) sized via "
+                              f"{tc.origin if tc else 'no probe'}, {mism} mismatch(es), {len(unchecked)} NOT CHECKED"), None, "info"
+
+
+@rule("H2L-NVM-000", "info", "NvM RAM block coverage", "RAM blocks whose C object could not be found")
+def nvm_unresolved(ctx):
+    if not ctx.containers("NvM/NvMBlockDescriptor"):
+        return
+    table, _notes, _tc = probe_sizes(ctx)
+    miss = [p for p, (s, d) in table.items() if d is None]
+    if miss:
+        first = ctx.containers("NvM/NvMBlockDescriptor")[0]
+        yield first, first.line, (f"{len(miss)} NvM RAM block symbol(s) not declared in any C source "
+                                  f"(e.g. {', '.join(miss[:3])}); H2L-NVM-001 skipped for them"), None

package/python/ecuc_engine/rules/pdur.py

@@ -0,0 +1,87 @@
+"""PduR routing vs the System / ECU extract.
+
+A routing path forwards one I-PDU: its source and destination EcuC Pdus must stand for the same system
+I-PDU (the same IPdu triggered on two channels, or an I-PDU with the same I-SIGNAL content), or for a
+source/target pair of an extract GATEWAY I-PDU-MAPPING when the extract has one.
+"""
+from __future__ import annotations
+
+from . import rule
+from .system import channels, foreign_targets, system_ipdus
+
+CITE = ("SWS_PduR routing path (PduRSrcPdu/PduRDestPdu); System Template Gateway.iPduMappings / IPdu triggered on "
+        "source and target channels")
+
+
+def _pdu(ctx, container, ref_name):
+    return ctx.target(ctx.value(container, ref_name)) if container is not None else None
+
+
+def _gateway_map(ctx) -> dict:
+    """source PDU-TRIGGERING -> {target PDU-TRIGGERING} from extract I-PDU-MAPPINGs (if any)."""
+    out: dict = {}
+    for m in ctx.p.system.tags("I-PDU-MAPPING"):
+        src = m.values.get("SOURCE-I-PDU-REF", [])
+        tgt = m.values.get("TARGET-I-PDU-REF", [])
+        for s in src:
+            out.setdefault(s, set()).update(tgt)
+    return out
+
+
+def _paths(ctx):
+    for rp in ctx.containers("PduR/PduRRoutingPaths/PduRRoutingPath"):
+        src = ctx.target(ctx.value(rp, "PduRSrcPduRRef"))
+        dests = [ctx.target(pv) for pv in ctx.values(rp, "PduRDestPduRRef")]
+        yield rp, src, [d for d in dests if d is not None]
+
+
+@rule("H2L-PDUR-001", "error", CITE, "a routing path's destination carries the same I-PDU as its source")
+def route_vs_extract(ctx):
+    if not ctx.p.system.by_path:
+        return
+    gw = _gateway_map(ctx)
+    sysi = ctx.p.system
+    for rp, src, dests in _paths(ctx):
+        spdu = _pdu(ctx, src, "PduRSrcPduRef")
+        s_ip = system_ipdus(ctx, spdu)
+        if not s_ip:
+            continue
+        s_sig = {x for ip in s_ip for x in sysi.signals_of_ipdu(ip)}
+        for d in dests:
+            dpdu = _pdu(ctx, d, "PduRDestPduRef")
+            d_ip = system_ipdus(ctx, dpdu)
+            if not d_ip or set(d_ip) & set(s_ip):
+                continue
+            d_sig = {x for ip in d_ip for x in sysi.signals_of_ipdu(ip)}
+            if s_sig and s_sig == d_sig:
+                continue
+            src_trig = [t.path for _pv, t in foreign_targets(ctx, spdu)]
+            if any(t in gw for t in src_trig):
+                allowed = set().union(*(gw[t] for t in src_trig if t in gw))
+                dst_trig = {t.path for _pv, t in foreign_targets(ctx, dpdu)}
+                if allowed & dst_trig:
+                    continue
+            pv = ctx.value(rp, "PduRDestPduRRef")
+            others = [o.name for o, s2, ds in _paths(ctx) if o.path != rp.path and any(x.path == d.path for x in ds)]
+            yield rp, pv.node.line, (
+                f"{rp.name}: source {spdu.name if spdu else src.name} carries system I-PDU {', '.join(s_ip)} "
+                f"(channel {', '.join(channels(ctx, spdu)) or '?'}) but destination {d.name} -> "
+                f"{dpdu.name if dpdu else '?'} carries {', '.join(d_ip)} (channel {', '.join(channels(ctx, dpdu)) or '?'}), "
+                f"with different I-SIGNALs ({len(s_sig)} vs {len(d_sig)}, {len(s_sig & d_sig)} shared)"
+                + (f"; that destination is also the target of {', '.join(others)}" if others else "")), pv.def_ref
+
+
+@rule("H2L-PDUR-002", "warning", "SWS_PduR routing path (one source per destination PDU)",
+      "a destination PDU is fed by more than one routing path")
+def fan_in(ctx):
+    feeds: dict = {}
+    for rp, src, dests in _paths(ctx):
+        for d in dests:
+            feeds.setdefault(d.path, []).append((rp, src))
+    for dpath, rps in feeds.items():
+        srcs = {s.path for _r, s in rps if s is not None}
+        if len(srcs) > 1:
+            for rp, _s in rps:
+                pv = ctx.value(rp, "PduRDestPduRRef")
+                yield rp, pv.node.line, (f"{rp.name}: destination {dpath} is also fed by "
+                                         f"{', '.join(r.name for r, _ in rps if r.path != rp.path)} (different sources)"), pv.def_ref

package/python/ecuc_engine/rules/system.py

@@ -0,0 +1,162 @@
+"""ECU configuration vs the System / ECU extract (the ECUC must agree with the extract it was derived from).
+
+Links are discovered from the configuration's own foreign references and the extract's metaclasses:
+ComSignal --(any foreign ref: I-SIGNAL-TO-I-PDU-MAPPING | I-SIGNAL | SYSTEM-SIGNAL)--> mapping;
+EcuC Pdu --(any foreign ref: PDU-TRIGGERING | *FRAME-TRIGGERING | *I-PDU)--> system I-PDU.
+No element names are assumed.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from . import rule
+from ..values import parse_int
+
+ENDIAN = {"MOST-SIGNIFICANT-BYTE-LAST": "LITTLE_ENDIAN", "MOST-SIGNIFICANT-BYTE-FIRST": "BIG_ENDIAN", "OPAQUE": "OPAQUE"}
+CITE_SIG = ("System Template ISignalToIPduMapping.startPosition/packingByteOrder, ISignal.length vs "
+            "ECUC_Com_00259 ComBitPosition, ECUC_Com_00158 ComBitSize, ECUC_Com_00157 ComSignalEndianness")
+CITE_PDU = "System Template IPdu.length vs ECUC_EcuC_00003 PduLength"
+
+
+def foreign_targets(ctx, e):
+    """(param value, system Ident) for every reference of an ECUC element that lands in the system index."""
+    out = []
+    for g in ctx.p.find(e.path):
+        for pv in g.params:
+            if pv.is_ref and pv.value:
+                t = ctx.p.system.get(pv.value)
+                if t is not None:
+                    out.append((pv, t))
+    return out
+
+
+def system_ipdus(ctx, pdu) -> list:
+    """EcuC Pdu container -> system I-PDU paths it stands for."""
+    if pdu is None:
+        return []
+    out = []
+    for _pv, t in foreign_targets(ctx, pdu):
+        if t.tag.endswith("TRIGGERING"):
+            out.extend(ctx.p.system.ipdus_of_triggering(t.path))
+        elif t.tag.endswith("PDU"):
+            out.append(t.path)
+    return sorted(set(out))
+
+
+def channels(ctx, pdu) -> list:
+    if pdu is None:
+        return []
+    return sorted({ctx.p.system.channel_of(t.path) for _pv, t in foreign_targets(ctx, pdu)
+                   if t.tag.endswith("TRIGGERING") and ctx.p.system.channel_of(t.path)})
+
+
+def owning_ipdus(ctx):
+    """ComSignal path -> list of ComIPdu Elems that reference it."""
+    own: dict = {}
+    for ip in ctx.containers("Com/ComConfig/ComIPdu"):
+        for pv in ctx.values(ip, "ComIPduSignalRef"):
+            if pv.value:
+                own.setdefault(pv.value.strip(), []).append(ip)
+    return own
+
+
+def mappings_for(ctx, sig, sys_ipdus: list) -> list:
+    sysi = ctx.p.system
+    out = []
+    for _pv, t in foreign_targets(ctx, sig):
+        if t.tag == "I-SIGNAL-TO-I-PDU-MAPPING":
+            out.append(t)
+        elif t.tag in ("I-SIGNAL", "SYSTEM-SIGNAL"):
+            isigs = [t.path] if t.tag == "I-SIGNAL" else [i.path for i in sysi.refs_to(t.path) if i.tag == "I-SIGNAL"]
+            for isig in isigs:
+                for m in sysi.refs_to(isig):
+                    if m.tag == "I-SIGNAL-TO-I-PDU-MAPPING" and (not sys_ipdus or m.parent in sys_ipdus):
+                        out.append(m)
+    return out
+
+
+def _motorola_msb(lsb: int, size: int) -> int:
+    b = lsb
+    for _ in range(size - 1):
+        b = b + 1 if b % 8 != 7 else b - 15
+    return b
+
+
+def _line(m) -> str:
+    return f"{m.file.rsplit('/', 1)[-1]}:{m.line}"
+
+
+@rule("H2L-SYS-001", "error", CITE_SIG, "ComSignal layout and I-PDU agree with the system extract mapping")
+def signal_vs_extract(ctx):
+    if not ctx.p.system.by_path:
+        return
+    own = owning_ipdus(ctx)
+    for sig in ctx.containers("Com/ComConfig/ComSignal") + ctx.containers("Com/ComConfig/ComSignalGroup/ComGroupSignal"):
+        ipdus = own.get(sig.path, [])
+        sys_ipdus = sorted({x for ip in ipdus for x in system_ipdus(ctx, ctx.target(ctx.value(ip, "ComPduIdRef")))})
+        maps = mappings_for(ctx, sig, sys_ipdus)
+        if not maps:
+            continue  # no link: counted by the info rule below
+        m = maps[0]
+        isig = ctx.p.system.get(m.one("I-SIGNAL-REF"))
+        pos, size = parse_int(ctx.text(sig, "ComBitPosition") or ""), parse_int(ctx.text(sig, "ComBitSize") or "")
+        if size is None:
+            n = parse_int(ctx.text(sig, "ComSignalLength") or "")
+            size = n * 8 if n is not None else None
+        start = parse_int(m.one("START-POSITION") or "")
+        length = parse_int(isig.one("LENGTH") or "") if isig is not None else None
+        order = m.one("PACKING-BYTE-ORDER")
+        endian = (ctx.text(sig, "ComSignalEndianness") or "").strip()
+        anchor = ctx.value(sig, "ComBitPosition") or ctx.value(sig, "ComBitSize")
+        line = anchor.node.line if anchor is not None else sig.line
+        ev = f"extract {m.path} ({_line(m)}): START-POSITION={start}, PACKING-BYTE-ORDER={order}, " \
+             f"I-SIGNAL LENGTH={length}"
+        if pos is not None and start is not None and size:
+            ok = pos == start
+            if order == "MOST-SIGNIFICANT-BYTE-FIRST":
+                ok = ok or start == _motorola_msb(pos, size) or pos == _motorola_msb(start, size)
+            if not ok:
+                yield sig, line, f"{sig.name}: ComBitPosition={pos} but the system extract maps it at START-POSITION={start}; {ev}", \
+                    ctx.value(sig, "ComBitPosition").def_ref
+        if size is not None and length is not None and size != length:
+            yield sig, line, f"{sig.name}: ComBitSize={size} but I-SIGNAL LENGTH={length} bits; {ev}", \
+                (ctx.value(sig, "ComBitSize") or ctx.value(sig, "ComSignalLength")).def_ref
+        if order in ENDIAN and endian and ENDIAN[order] != endian:
+            yield sig, line, f"{sig.name}: ComSignalEndianness={endian} but PACKING-BYTE-ORDER={order} ({ENDIAN[order]}); {ev}", \
+                ctx.value(sig, "ComSignalEndianness").def_ref
+        if sys_ipdus and m.parent not in sys_ipdus:
+            yield sig, sig.line, (f"{sig.name} is in ComIPdu {', '.join(i.name for i in ipdus)} (system I-PDU "
+                                  f"{', '.join(sys_ipdus)}) but the extract maps its I-SIGNAL into {m.parent} ({_line(m)})"), sig.def_ref
+
+
+@rule("H2L-SYS-002", "error", CITE_PDU, "EcuC PduLength agrees with the system I-PDU LENGTH")
+def pdu_length_vs_extract(ctx):
+    if not ctx.p.system.by_path:
+        return
+    for pdu in ctx.containers("EcuC/EcucConfigSet/EcucPduCollection/Pdu"):
+        length = parse_int(ctx.text(pdu, "PduLength") or "")
+        if length is None:
+            continue
+        for ip in system_ipdus(ctx, pdu):
+            si = ctx.p.system.get(ip)
+            sl = parse_int(si.one("LENGTH") or "") if si is not None else None
+            if sl is not None and sl != length:
+                pv = ctx.value(pdu, "PduLength")
+                yield pdu, pv.node.line, (f"{pdu.name}: PduLength={length} but system I-PDU {ip} has LENGTH={sl} "
+                                          f"({_line(si)})"), pv.def_ref
+
+
+@rule("H2L-SYS-000", "info", "ECU extract link coverage", "how much of the config could be linked to the extract")
+def coverage(ctx):
+    first: Optional[object] = next((m for m in ctx.p.modules if (m.def_ref or "").endswith("/Com")), None)
+    if first is None:
+        return
+    if not ctx.p.system.by_path:
+        yield first, first.line, ("no System/ECU extract loaded (no non-ECUC .arxml found or configured as 'input'); "
+                                  "H2L-SYS/H2L-PDUR cross-checks were skipped"), None
+        return
+    sigs = ctx.containers("Com/ComConfig/ComSignal")
+    unlinked = [s for s in sigs if not mappings_for(ctx, s, [])]
+    if unlinked:
+        yield first, first.line, (f"{len(unlinked)} of {len(sigs)} ComSignal(s) have no reference into the loaded "
+                                  f"extract (e.g. {', '.join(s.path for s in unlinked[:3])}); H2L-SYS-001 skipped for them"), None

package/python/ecuc_engine/sysmodel.py

@@ -0,0 +1,152 @@
+"""Index of the non-ECUC ARXML (System / ECU extract, SWCs, BSWMD) for cross-checks.
+
+One expat pass per file. Every identifiable (element with a SHORT-NAME) becomes an Ident with its tag,
+file, line, the identifiable children, and the leaf values *of its own* (descendants that are not
+inside a nested identifiable): e.g. an I-SIGNAL-TO-I-PDU-MAPPING gets {"I-SIGNAL-REF": [...],
+"START-POSITION": ["16"], "PACKING-BYTE-ORDER": [...]}. References keep their DEST type.
+Nothing is keyed by project-specific names; rules navigate by AUTOSAR metaclass and reference.
+"""
+from __future__ import annotations
+
+import xml.parsers.expat as expat
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Ident:
+    path: str
+    tag: str
+    file: str
+    line: int
+    values: dict = field(default_factory=dict)  # leaf tag -> [text]
+    dests: dict = field(default_factory=dict)  # ref tag -> [DEST]
+    children: list = field(default_factory=list)  # child identifiable paths
+    parent: Optional[str] = None
+
+    def one(self, tag: str) -> Optional[str]:
+        v = self.values.get(tag)
+        return v[0] if v else None
+
+
+class SystemIndex:
+    def __init__(self):
+        self.by_path: dict = {}
+        self.by_tag: dict = {}
+        self._refs_to: Optional[dict] = None
+
+    def add_file(self, path: str):
+        try:
+            with open(path, "rb") as fh:
+                data = fh.read()
+        except OSError:
+            return
+        p = expat.ParserCreate()
+        p.buffer_text = True
+        stack: list = []  # [tag, Ident|None, text parts, attrs, line]
+        idents: list = []  # current chain of Idents
+
+        def start(name, attrs):
+            stack.append([name.rsplit(":", 1)[-1], None, [], attrs, p.CurrentLineNumber])
+
+        def chars(t):
+            if stack:
+                stack[-1][2].append(t)
+
+        def end(name):
+            tag, ident, text, attrs, line = stack.pop()
+            if tag == "SHORT-NAME" and stack:
+                owner = stack[-1]
+                if owner[1] is None:
+                    parent = idents[-1] if idents else None
+                    sn = "".join(text).strip()
+                    ip = f"{parent.path if parent else ''}/{sn}"
+                    owner[1] = Ident(ip, owner[0], path, owner[4], parent=parent.path if parent else None)
+                    if parent is not None:
+                        parent.children.append(ip)
+                    idents.append(owner[1])
+                    self.by_path.setdefault(ip, owner[1])
+                    self.by_tag.setdefault(owner[0], []).append(owner[1])
+                return
+            if ident is not None:
+                idents.pop()
+                return
+            if idents:  # a leaf value of the innermost enclosing identifiable
+                txt = "".join(text).strip()
+                if txt:
+                    cur = idents[-1]
+                    cur.values.setdefault(tag, []).append(txt)
+                    if "DEST" in attrs:
+                        cur.dests.setdefault(tag, []).append(attrs["DEST"])
+
+        p.StartElementHandler = start
+        p.EndElementHandler = end
+        p.CharacterDataHandler = chars
+        try:
+            p.Parse(data, True)
+        except expat.ExpatError:
+            pass
+        self._refs_to = None
+
+    def get(self, path: Optional[str]) -> Optional[Ident]:
+        return self.by_path.get(path.strip()) if path else None
+
+    def tags(self, tag: str) -> list:
+        return self.by_tag.get(tag, [])
+
+    def refs_to(self, path: str) -> list:
+        """Idents that reference ``path`` (any *-REF leaf)."""
+        if self._refs_to is None:
+            idx: dict = {}
+            for i in self.by_path.values():
+                for t, vals in i.values.items():
+                    if t.endswith("-REF") or t.endswith("-TREF"):
+                        for v in vals:
+                            idx.setdefault(v, []).append(i)
+            self._refs_to = idx
+        return self._refs_to.get(path, [])
+
+    def foreign(self) -> dict:
+        return {p: (i.tag, i.line, i.file) for p, i in self.by_path.items()}
+
+    # ---- navigation helpers (by metaclass, not by name) ----
+    def ipdus_of_triggering(self, path: Optional[str]) -> list:
+        """A PDU-TRIGGERING or FRAME-TRIGGERING (any bus) -> system I-PDU paths it carries."""
+        t = self.get(path)
+        if t is None:
+            return []
+        out = []
+        for ref in t.values.get("I-PDU-REF", []):
+            out.append(ref)
+        for pt in t.values.get("PDU-TRIGGERING-REF", []):
+            out.extend(self.ipdus_of_triggering(pt))
+        if not out:
+            fr = self.get(t.one("FRAME-REF"))
+            if fr is not None:
+                for m in fr.children:
+                    mi = self.get(m)
+                    if mi is not None:
+                        out.extend(mi.values.get("PDU-REF", []))
+        seen, res = set(), []
+        for x in out:
+            if x not in seen:
+                seen.add(x)
+                res.append(x)
+        return res
+
+    def channel_of(self, path: Optional[str]) -> Optional[str]:
+        """Physical channel (the identifiable holding the triggering) of a PDU/FRAME-TRIGGERING."""
+        t = self.get(path)
+        return t.parent if t is not None else None
+
+    def signals_of_ipdu(self, ipdu: str) -> list:
+        """I-SIGNAL paths mapped into a system I-PDU (via its I-SIGNAL-TO-I-PDU-MAPPING children)."""
+        i = self.get(ipdu)
+        if i is None:
+            return []
+        out = []
+        for c in i.children:
+            ci = self.get(c)
+            if ci is not None and ci.values.get("I-SIGNAL-REF"):
+                out.extend(ci.values["I-SIGNAL-REF"])
+        return sorted(set(out))