@h2loop/autosar 1.0.1 → 1.2.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/specids.py

@@ -0,0 +1,163 @@
+"""Requirement-ID check (autosar_spec_id_check) against the user's own AUTOSAR spec texts.
+
+No requirement IDs or spec text are bundled with the pack: AUTOSAR documents are licensed to the user, so the
+index is built at run time from text exports the project points at (`.hydron/autosar.json` "specDocs" globs, or
+$AUTOSAR_SPEC_DOCS, an os.pathsep-separated list of files/dirs/globs; .txt and .md files). The index is cached
+per file set (size + mtime) under $XDG_CACHE_HOME/h2loop-autosar.
+
+An ID is "defined" where a line starts with "[ID]" alone (optionally after a label such as "Signature:", as the
+RTE spec writes API requirements), followed within a few lines by the requirement
+bracket "⌈" or "Upstream requirements" (how SWS/TPS/SRS/ECUC requirements are introduced), and "mentioned" when
+it only occurs in running text or trace tables.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+from typing import Optional
+
+from . import paths
+
+ID = re.compile(r"\b([A-Z][A-Za-z]{1,7}_[A-Za-z0-9]+_\d{3,6})\b")
+# "SWS_NvM_00898/00899" -> both IDs
+SHORTHAND = re.compile(r"\b([A-Z][A-Za-z]{1,7}_[A-Za-z0-9]+_)(\d{3,6})((?:/\d{3,6})+)")
+DEF_LINE = re.compile(r"^\s*(?:[A-Z][A-Za-z ]{0,30}:\s*)?\[([A-Z][A-Za-z]{1,7}_[A-Za-z0-9]+_\d{3,6})\]")
+INDEX_VERSION = 3
+
+
+def expand_ids(text: str) -> list:
+    """Every requirement ID written in text, with "X_Mod_00001/00002" shorthand expanded, in order, unique."""
+    out: list = []
+    for m in SHORTHAND.finditer(text):
+        out.append(m.group(1) + m.group(2))
+        out.extend(m.group(1) + n for n in m.group(3).strip("/").split("/"))
+    out.extend(m.group(1) for m in ID.finditer(text))
+    seen: set = set()
+    return [x for x in out if not (x in seen or seen.add(x))]
+
+
+def _is_doc(f: str) -> bool:
+    return f.lower().endswith((".txt", ".md"))
+
+
+def doc_files(root: str, docs: Optional[list] = None) -> tuple:
+    """(files, origin) of the spec text docs to index."""
+    pats, origin = list(docs or []), "argument"
+    if not pats:
+        cfg = os.path.join(root, ".hydron", "autosar.json")
+        try:
+            with open(cfg) as fh:
+                spec = json.load(fh).get("specDocs")
+            if spec:
+                pats, origin = ([spec] if isinstance(spec, str) else list(spec)), ".hydron/autosar.json specDocs"
+        except (OSError, ValueError, AttributeError):
+            pass
+    if not pats and os.environ.get("AUTOSAR_SPEC_DOCS"):
+        pats, origin = os.environ["AUTOSAR_SPEC_DOCS"].split(os.pathsep), "AUTOSAR_SPEC_DOCS"
+    files: list = []
+    for p in paths.patterns(root, [x for x in pats if x]):
+        files.extend(f for f in p.expand(_is_doc) if _is_doc(f) and os.path.isfile(f))
+    return sorted({os.path.abspath(f) for f in files}), origin if pats else None
+
+
+def _cache_path(files: list) -> str:
+    h = hashlib.sha1(str(INDEX_VERSION).encode())
+    for f in files:
+        st = os.stat(f)
+        h.update(f"{f}\0{st.st_size}\0{int(st.st_mtime)}\n".encode())
+    base = os.environ.get("XDG_CACHE_HOME") or os.path.join(os.path.expanduser("~"), ".cache")
+    return os.path.join(base, "h2loop-autosar", f"specids-{h.hexdigest()[:16]}.json")
+
+
+def build_index(files: list) -> dict:
+    """ID -> [file index, line, defined] (the defining line when there is one, else the first mention)."""
+    idx: dict = {}
+    for fi, f in enumerate(files):
+        with open(f, encoding="utf-8", errors="replace") as fh:
+            lines = fh.readlines()
+        for i, line in enumerate(lines):
+            d = DEF_LINE.match(line)
+            if d and len(ID.findall(line)) == 1 and any(
+                    "⌈" in x or "Upstream requirements" in x for x in lines[i: i + 5]):
+                cur = idx.get(d.group(1))
+                if cur is None or not cur[2]:
+                    idx[d.group(1)] = [fi, i + 1, True]
+            for m in ID.finditer(line):
+                idx.setdefault(m.group(1), [fi, i + 1, False])
+    return idx
+
+
+def load_index(files: list) -> dict:
+    cache = _cache_path(files)
+    try:
+        with open(cache) as fh:
+            data = json.load(fh)
+        if data.get("files") == files:
+            return data["ids"]
+    except (OSError, ValueError):
+        pass
+    ids = build_index(files)
+    try:
+        os.makedirs(os.path.dirname(cache), exist_ok=True)
+        tmp = cache + ".tmp"
+        with open(tmp, "w") as fh:
+            json.dump({"files": files, "ids": ids}, fh)
+        os.replace(tmp, cache)
+    except OSError:
+        pass
+    return ids
+
+
+def _snippet(f: str, line: int, max_lines: int = 14, max_chars: int = 700) -> str:
+    out: list = []
+    with open(f, encoding="utf-8", errors="replace") as fh:
+        for ln, text in enumerate(fh, 1):
+            if ln < line:
+                continue
+            out.append(text.strip())
+            if "⌋" in text or len(out) >= max_lines:
+                break
+    s = re.sub(r"\s+", " ", " ".join(out)).strip()
+    return s if len(s) <= max_chars else s[: max_chars - 1] + "…"
+
+
+def check_ids(root: str, ids: list, docs: Optional[list] = None) -> dict:
+    files, origin = doc_files(root, docs)
+    wanted: list = []
+    for raw in ids:
+        got = expand_ids(str(raw))
+        wanted.extend(got or [str(raw).strip().strip("[]")])
+    if not files:
+        return {"error": "no AUTOSAR spec text docs configured, so no requirement ID can be confirmed. Set "
+                         "`specDocs` (globs of .txt/.md spec exports) in .hydron/autosar.json or $AUTOSAR_SPEC_DOCS. "
+                         "Until then cite only IDs that appear verbatim in a tool result or a spec text you read; "
+                         "otherwise describe the rule without an ID.",
+                "ids": wanted}
+    idx = load_index(files)
+    lower: dict = {}
+    for k in idx:
+        lower.setdefault(k.lower(), k)
+    results = []
+    for i in wanted:
+        hit = idx.get(i)
+        if hit is None:
+            alt = lower.get(i.lower())
+            r = {"id": i, "status": "NOT-FOUND"}
+            if not ID.fullmatch(i):
+                r["status"] = "MALFORMED"
+            if alt:
+                r["didYouMean"] = alt
+            results.append(r)
+            continue
+        f = files[hit[0]]
+        r = {"id": i, "status": "DEFINED" if hit[2] else "MENTIONED-ONLY",
+             "doc": os.path.basename(f), "line": hit[1]}
+        if hit[2]:
+            r["text"] = _snippet(f, hit[1])
+        results.append(r)
+    counts: dict = {}
+    for r in results:
+        counts[r["status"]] = counts.get(r["status"], 0) + 1
+    return {"docs": len(files), "docsOrigin": origin, "indexedIds": len(idx), "counts": counts, "results": results}