@h2loop/autosar 1.1.0 → 1.2.1

package/python/ecuc_engine/add_signal.py

@@ -18,7 +18,7 @@ import re
 from typing import Optional
 
 from . import paths
-from .arxml_edit import ArxmlEditError, ArxmlEditor
+from .arxml_edit import ArxmlEditError, ArxmlEditor, _ad, _etype, _version
 from .model import Project
 from .rules import RuleContext
 from .rules.com import _layout, bits
@@ -102,11 +102,11 @@ def add_signal(project: Project, name: str, ipdu: str, bit_size: Optional[int] =
     # ---------- system extract ----------
     sysi = project.system
     ref_pv = next((pv for g in project.find(sib.path) for pv in g.params if pv.is_ref and sysi.get(pv.value or "")), None)
-    sys_writes, new_mapping = {}, None
+    sys_writes, new_mapping, not_cloned = {}, None, []
     if ref_pv is not None and sysi.by_path:
         ed = ArxmlEditor(project)
         try:
-            new_mapping = _clone_system_chain(project, ed, sysi.get(ref_pv.value), sib.name, name)
+            new_mapping = _clone_system_chain(project, ed, sysi.get(ref_pv.value), sib.name, name, not_cloned)
             m_path = new_mapping
             ed.op_set({"path": m_path, "element": "START-POSITION", "value": pos})
             ed.op_set({"path": m_path, "element": "PACKING-BYTE-ORDER", "value": ORDER.get(endianness, endianness)})
@@ -127,6 +127,11 @@ def add_signal(project: Project, name: str, ipdu: str, bit_size: Optional[int] =
         if probs:
             raise AddSignalError("system extract edit would leave: " + "; ".join(probs[:5]))
         sys_writes = {f: ft.data for f, ft in ed.files.items() if ft.data != ed.original[f]}
+        for sk in not_cloned:
+            notes.append(f"not copied from {sib.name}: its {sk['ref']} in {sk['element']} ({sk['holder']}) is a "
+                         f"single-valued reference of the template's own relation. If {name} needs the same kind of "
+                         f"relation (e.g. a SWC data element mapped to it), add a new {sk['element']} with "
+                         f"{sk['ref']} = {sk['new']} (arxml_edit)")
     else:
         notes.append("no system-extract link on the template signal; extract not changed")
 
@@ -188,7 +193,8 @@ def add_signal(project: Project, name: str, ipdu: str, bit_size: Optional[int] =
     ecuc_writes = {f: project.files[f].data for f in ced.original if project.files[f].data != ced.original[f]}
 
     # ---------- DBC ----------
-    dbc_writes = _dbc_line(project, pdu, name, pos, size, endianness, signal_type, notes)
+    dbc_writes = _dbc_line(project, pdu, name, pos, size, endianness, signal_type, notes,
+                           {m.name for m in members if m is not None})
 
     writes = {**sys_writes, **ecuc_writes, **dbc_writes}
     originals = {f: open(f, "rb").read() for f in writes}
@@ -200,7 +206,8 @@ def add_signal(project: Project, name: str, ipdu: str, bit_size: Optional[int] =
     for f, b in writes.items():
         with open(f, "wb") as fh:
             fh.write(b)
-    after = validate(Project(project.root), check_generated=False)
+    # same inputs as `before` (explicit --defs/--config included), so only the edit's own findings count as new
+    after = validate(Project(project.root, project.sources.config, project.sources.defs), check_generated=False)
     new = [d for d in after["diagnostics"] if d["severity"] in ("error", "warning")
            and (d["rule"], d["path"], d["message"]) not in before]
     if new:
@@ -247,8 +254,24 @@ def _renamed(path, old: str, new: str) -> Optional[str]:
     return f"{head}/{last.replace(old, new)}" if old in last else None
 
 
-def _clone_system_chain(project: Project, ed: ArxmlEditor, mapping, old: str, new: str) -> str:
-    """Clone the sibling's extract chain under the new name; return the new mapping path."""
+def _repeatable(ft, wrap) -> bool:
+    """May wrap's parent hold another element like wrap? Schema content mode when autosar-data is available
+    (Bag = collection, Sequence/Choice = single slots); otherwise AUTOSAR's plural-wrapper naming or an existing
+    repetition of the same tag."""
+    parent = wrap.parent
+    if parent is None:
+        return False
+    et = _etype(ft.chain(parent), _version(ft.data))
+    if et is not None:
+        return et.content_mode == _ad().ContentMode.Bag
+    return parent.tag.endswith("S") or sum(c.tag == wrap.tag for c in parent.children) > 1
+
+
+def _clone_system_chain(project: Project, ed: ArxmlEditor, mapping, old: str, new: str,
+                        skipped: Optional[list] = None) -> str:
+    """Clone the sibling's extract chain under the new name; return the new mapping path. Reference entries
+    that cannot be duplicated (single-valued slots) are appended to `skipped` instead."""
+    skipped = [] if skipped is None else skipped
     sysi = project.system
     if mapping is None or mapping.tag != "I-SIGNAL-TO-I-PDU-MAPPING":
         raise ArxmlEditError("template signal's system reference is not an I-SIGNAL-TO-I-PDU-MAPPING")
@@ -293,7 +316,10 @@ def _clone_system_chain(project: Project, ed: ArxmlEditor, mapping, old: str, ne
         ed.patch(ft, node.end, node.end, ft.nl + ind + text.encode())
         if p == mapping.path:
             mapping_new = subst[p]
-    # reference entries held by shared elements (not renamed): clone the wrapper next to the original
+    # reference entries held by shared elements (not renamed): clone the wrapper next to the original, but only
+    # where the holder is a collection (FIBEX-ELEMENTS, I-SIGNAL-TRIGGERINGS, ...). A reference in a single-valued
+    # slot (SYSTEM-SIGNAL-REF of a SENDER-RECEIVER-TO-SIGNAL-MAPPING) belongs to the sibling's own relation, e.g.
+    # its SWC data element; duplicating it is a schema error and the relation does not carry over to a new signal.
     for p in chain:
         for r in sysi.refs_to(p):
             if r.path in chain:
@@ -306,6 +332,10 @@ def _clone_system_chain(project: Project, ed: ArxmlEditor, mapping, old: str, ne
                 while wrap.parent is not None and wrap.parent is not node and len(wrap.parent.children) == 1 \
                         and not wrap.parent.tag.endswith("S"):
                     wrap = wrap.parent
+                if not _repeatable(ft, wrap):
+                    skipped.append({"holder": r.path, "element": wrap.parent.tag if wrap.parent is not None else node.tag,
+                                    "ref": leaf.tag, "template": p, "new": subst[p]})
+                    continue
                 text = ft.data[wrap.start:wrap.end].decode().replace(f">{p}<", f">{subst[p]}<")
                 ind = line_indent(ft.data, wrap.start) or b""
                 ed.patch(ft, wrap.end, wrap.end, ft.nl + ind + text.encode())
@@ -314,7 +344,15 @@ def _clone_system_chain(project: Project, ed: ArxmlEditor, mapping, old: str, ne
     return mapping_new
 
 
-def _dbc_line(project: Project, pdu, name, pos, size, endian, typ, notes) -> dict:
+def _frame_signals(text: str, m) -> set:
+    body = text[m.end():].split("\n\n", 1)[0]
+    return set(re.findall(r"^\s*SG_ (\w+)", body, re.M))
+
+
+def _dbc_line(project: Project, pdu, name, pos, size, endian, typ, notes, members: set = frozenset()) -> dict:
+    """Add an SG_ line to the DBC frame of the I-PDU. CAN IDs are unique per bus only, so when several DBC files
+    have a frame with the ID, the frame that already carries the I-PDU's signals is the one; a frame that carries
+    none of them while another does belongs to another bus and is left alone."""
     from .audit import can_info
     infos = can_info(project, pdu.path if pdu is not None else None)
     dbcs = paths.walk(project.root, lambda n: n.lower().endswith(".dbc")).files
@@ -325,11 +363,21 @@ def _dbc_line(project: Project, pdu, name, pos, size, endian, typ, notes) -> dic
         cid = info.get("canId")
         if cid is None:
             continue
+        cands = []
         for f in dbcs:
             text = open(f, encoding="utf-8", errors="replace").read()
             m = re.search(rf"^BO_ ({cid}|{cid | 0x80000000}) (\w+)\s*:.*$", text, re.M)
-            if not m:
-                continue
+            if m:
+                cands.append((f, text, m))
+        owning = [c for c in cands if members & _frame_signals(c[1], c[2])]
+        if owning:
+            cands = owning
+        elif len(cands) > 1:
+            notes.append(f"DBC not changed: {len(cands)} frames have CAN ID {cid} "
+                         f"({', '.join(project.rel(c[0]) + ':' + c[2].group(2) for c in cands)}) and none carries "
+                         f"the I-PDU's signals")
+            cands = []
+        for f, text, m in cands:
             block_end = m.end()
             sg = list(re.finditer(r"^\s*SG_ .*$", text[m.end():].split("\n\n", 1)[0], re.M))
             recv = "Vector__XXX"

package/python/ecuc_engine/audit.py

@@ -22,7 +22,7 @@ from dataclasses import dataclass
 from typing import Optional
 
 from .model import Elem, Project
-from .values import parse_int
+from .values import hex_str, parse_int
 
 from . import paths
 
@@ -261,9 +261,31 @@ class Auditor:
         return list(self._owners.get(key, []))
 
     # ---------- findings ----------
+    def located(self, evidence):
+        """Evidence plus, computed (never left to the reader): <k>At = file:line of each configured element named
+        by AUTOSAR path, <Param>At = file:line of that parameter's VALUE element, and <k>Hex for integers."""
+        if not isinstance(evidence, dict):
+            return evidence
+        from .ecucjson import value_at
+        out = dict(evidence)
+        elems = []
+        for k, v in evidence.items():
+            if isinstance(v, str) and v.startswith("/"):
+                g = self.p.find(v)
+                if g:
+                    out[f"{k}At"] = ", ".join(f"{self.p.rel(e.file)}:{e.line}" for e in g)
+                    elems.extend(g)
+        for k, v in evidence.items():
+            if isinstance(v, int) and not isinstance(v, bool) and not k.lower().endswith("line"):
+                out[f"{k}Hex"] = hex_str(v)
+            sites = [value_at(self.p, e, pv) for e in elems for pv in e.params if pv.name == k]
+            if sites and f"{k}At" not in out:
+                out[f"{k}At"] = sites[0] if len(sites) == 1 else sites
+        return out
+
     def add(self, rule, sev, f, line, call, msg, cite, evidence, fix=None):
         d = {"rule": rule, "severity": sev, "file": self.p.rel(f), "line": line, "call": call,
-             "message": msg, "cite": cite, "evidence": evidence}
+             "message": msg, "cite": cite, "evidence": self.located(evidence)}
         if fix:
             d["fix"] = fix
         self.findings.append(d)

package/python/ecuc_engine/cli.py

@@ -82,6 +82,11 @@ def main(argv=None) -> int:
     cx.add_argument("module")
     so = sub.add_parser("signal-owners")
     so.add_argument("paths", nargs="+")
+    vs = sub.add_parser("value-sites", help="per AUTOSAR path: each value with its VALUE element file:line, dec/hex")
+    vs.add_argument("paths", nargs="+")
+    si = sub.add_parser("spec-ids", help="check requirement IDs against the configured spec text docs")
+    si.add_argument("ids", nargs="+")
+    si.add_argument("--docs", action="append", help="spec text file/dir/glob (default: specDocs / $AUTOSAR_SPEC_DOCS)")
     d = sub.add_parser("diff")
     d.add_argument("a")
     d.add_argument("b")
@@ -111,7 +116,7 @@ def main(argv=None) -> int:
     bc.add_argument("--task", required=True, help="task text, @file, or - for stdin")
     bc.add_argument("--budget-tokens", dest="budget_tokens", type=int, default=24000)
     bc.add_argument("--no-history", dest="history", action="store_false")
-    for p in (r, e, v, d, au, so, fd, cx, ae, asg, cg, cd, ra, vr, bc):  # allow --json after the subcommand too
+    for p in (r, e, v, d, au, so, vs, si, fd, cx, ae, asg, cg, cd, ra, vr, bc):  # allow --json after the subcommand too
         p.add_argument("--json", action="store_true", help=argparse.SUPPRESS)
     a = ap.parse_args(argv)
     t0 = time.time()
@@ -169,6 +174,9 @@ def run(a) -> dict:
                 task = fh.read()
         return build_context(os.path.abspath(a.root), a.swc, task, runnable=a.runnable,
                              budget_tokens=a.budget_tokens, history=a.history)
+    if a.cmd == "spec-ids":
+        from .specids import check_ids
+        return check_ids(os.path.abspath(a.root), a.ids, docs=a.docs)
     from .model import Project
     project = Project(a.root, config_files=a.config, def_files=a.defs, load_input=a.cmd in ("validate", "edit", "find", "crosscheck", "signal-owners", "arxml-edit", "add-signal"))
     if a.cmd == "add-signal":
@@ -198,6 +206,9 @@ def run(a) -> dict:
         if project.warnings:
             res["warnings"] = project.warnings
         return res
+    if a.cmd == "value-sites":
+        from .ecucjson import value_sites
+        return {"sites": value_sites(project, a.paths)}
     if a.cmd == "signal-owners":
         from .audit import signal_owners
         return {"owners": signal_owners(project, a.paths)}

package/python/ecuc_engine/codegen/__init__.py

@@ -103,25 +103,44 @@ def generate(project: Project, modules: Optional[list] = None, out_dir: Optional
     wb = H.apply(project, pl["assign"], write=write_back)
     if pl["assign"]:
         cg = CgModel(project, opts.get("mip"))
+    # handle layout the static code indexes by (binding "handleLayout"), only for withAuto handle params
+    proj_out = resolve_out(root, "project", opts)
+    headers, sources = _scan_c(root, [out, proj_out, os.path.join(root, ".hydron")])
+    bindings = B.load_all(root)
+    lay = H.layout(cg, want, {m: B.select(bindings, m, headers, binding) for m in want})
+    if lay["errors"]:
+        return {"ok": False, "error": "handle IDs do not fit the static code's table layout", "handleErrors": lay["errors"]}
+    if lay["assign"]:
+        wb2 = H.apply(project, lay["assign"], write=write_back)
+        wb = {"written": wb["written"] or wb2["written"], "changes": wb["changes"] + wb2["changes"]}
+        pl["assign"] += lay["assign"]
+        cg = CgModel(project, opts.get("mip"))
+    pl["notes"] += lay["notes"]
     timings["handles_ms"] = int((time.time() - t1) * 1000)
 
     # 2. emit
     t2 = time.time()
-    proj_out = resolve_out(root, "project", opts)
-    headers, sources = _scan_c(root, [out, proj_out, os.path.join(root, ".hydron")])
-    ctx = Ctx(cg=cg, headers=headers, bindings=B.load_all(root), binding_name=binding, release=cg.release(),
+    ctx = Ctx(cg=cg, headers=headers, bindings=bindings, binding_name=binding, release=cg.release(),
               sources=sources)
     ctx.options = opts
     ctx.generating = set(want)
     ctx.available = set(headers) | (set(os.listdir(proj_out)) if os.path.isdir(proj_out) else set())
+    ctx.out_headers = {f: os.path.join(proj_out, f) for f in sorted(os.listdir(proj_out))
+                       if f.endswith(".h")} if os.path.isdir(proj_out) else {}
     files: dict = {}
     report: dict = {}
     memmaps = []
     notes = list(pl["notes"])
+    errors: dict = {}
+    outputs = []
     for name in want:
         mc = cg.module(name)
         gen = generator_for(name)(ctx, mc)
         mo = gen.run()
+        if mo.errors:
+            errors[name] = mo.errors
+            continue
+        outputs.append(mo)
         rendered = mo.render()
         n, text = S.schm_header(ctx, mo)
         rendered[n] = text
@@ -146,6 +165,11 @@ def generate(project: Project, modules: Optional[list] = None, out_dir: Optional
         notes.append(f"project MemMap.h ({P_rel(root, headers['MemMap.h'])}) kept; generated code includes "
                      "<Mip>_MemMap.h (SWS_MemMap_00032)")
     timings["emit_ms"] = int((time.time() - t2) * 1000)
+    if errors:
+        return {"ok": False, "error": "the configuration cannot be represented by the static code's binding; "
+                                      "nothing was written", "moduleErrors": errors, "notes": notes,
+                "handles": {"assigned": pl["assign"], "writtenBack": wb["written"], "changes": wb["changes"]}}
+    notes += dangling_symbols(ctx, outputs)
 
     # 3. write
     os.makedirs(out, exist_ok=True)
@@ -166,6 +190,30 @@ def generate(project: Project, modules: Optional[list] = None, out_dir: Optional
             "notes": notes, "timings": timings, "release": ".".join(map(str, ctx.release))}
 
 
+def dangling_symbols(ctx, outputs: list) -> list:
+    """Symbolic names (<Mip>Conf_<Def>_<Name>) that the project's C uses but the configuration no longer has.
+    The old generated header may still define them, so the stale use only shows once this output replaces it."""
+    defined = {s for mo in outputs for s, _, _ in mo.symbols}
+    rx = re.compile(r"\b(" + "|".join(sorted(re.escape(mo.mip) for mo in outputs)) + r")Conf_\w+") if outputs else None
+    out = []
+    if rx is None:
+        return out
+    seen: dict = {}
+    for f in ctx.sources:
+        try:
+            with open(f, errors="replace") as fh:
+                text = fh.read()
+        except OSError:
+            continue
+        for m in rx.finditer(text):
+            if m.group(0) not in defined:
+                seen.setdefault(m.group(0), ctx.cg.p.rel(f))
+    for sym in sorted(seen):
+        out.append(f"{seen[sym]} uses {sym}, which the configuration does not define (container deleted or "
+                   "renamed?); the build will fail on it")
+    return out
+
+
 def P_rel(root: str, f: str) -> str:
     r = os.path.relpath(f, root)
     return f if r.startswith("..") else r

package/python/ecuc_engine/codegen/binding.py

@@ -14,12 +14,24 @@ Path language (a list of steps, evaluated left to right from the row container):
   sub:<Def>             first sub-container of def <Def>
   ref:<R>               follow ECUC reference R to its target container
   back:<Def>/<R>        the container of def <Def> (any module) whose reference R points here
-  peer:<R>[@<Module>]   follow R to target T, then the container that references T from another
-                        module (or from <Module>): how a module finds its neighbour's PDU handle
-                        (TPS_ECUC 3.4.1.3, via EcucPduCollection/Pdu)
+  peer:<R>[@<Module>[/<Def>]]  follow R to target T, then the container that references T from another
+                        module (or from <Module>, optionally only containers of def <Def>): how a module
+                        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)
   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> | max:<Def>/<Param>, optionally followed by +N or -N.
+Macro values: count:<Def> | count:@<Set> | max:<Def>/<Param>, optionally followed by +N or -N.
+
+Module binding keys besides tables/objects/macros:
+  sets      {"<Set>": {"rows": "<Def>", "where": [{"path": <path>, "in": [literal, ...]}]}}: named row
+            selections (e.g. the Tx signals: ComSignals whose I-PDU is SEND); tables use "rows": "@<Set>"
+  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}),
+  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>}).
 """
 from __future__ import annotations
 
@@ -91,6 +103,7 @@ class Eval:
         self.mc = mc
         self.rank = 1
         self.used_mips: set = set()
+        self.ext: dict = {}  # call:<name> resolvers contributed by the module generator
 
     def steps(self, start: Container, steps) -> tuple:
         """-> ("container", Container) | ("value", (raw, def, owner)) | ("token", str) | (None, None)"""
@@ -124,12 +137,14 @@ class Eval:
                     self._touch(cur, self.cg.param_def(cur, rname))
             elif op == "peer":
                 rname, _, want = arg.partition("@")
+                want, _, wdef = want.partition("/")
                 self._touch(cur, self.cg.param_def(cur, rname))
                 t = self.cg.target(cur.value(rname))
                 if t is None:
                     return (None, None)
                 hits = [c for c in self.cg.referrers(t) if c is not cur and
-                        (c.module.name == want if want else c.module is not cur.module)]
+                        (c.module.name == want if want else c.module is not cur.module) and
+                        (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 == "sym":
@@ -137,6 +152,12 @@ class Eval:
                 if s and self.ctx is not None:
                     s = self.ctx.xsym(cur, self.mc, self.used_mips)
                 return ("token", s) if s else (None, None)
+            elif op == "call":
+                fn = self.ext.get(arg)
+                if fn is None:
+                    raise BindingError(f"path step call:{arg}: the {self.mc.name} generator provides no such resolver")
+                v = fn(cur, self)
+                return ("token", v) if v else (None, None)
             elif op == "module":
                 return ("token", cur.module.mip)
             elif op == "name":
@@ -149,6 +170,32 @@ class Eval:
                 return (None, None)
         return ("container", cur)
 
+    def rows(self, spec: str, sets: dict) -> list:
+        """Rows of a table: a container def (ordered by symbolic handle) or a named set "@<Set>"."""
+        if not spec.startswith("@"):
+            return list(self.cg.sorted_instances(self.mc, spec))
+        st = sets.get(spec[1:])
+        if st is None:
+            raise BindingError(f"unknown row set {spec} (sets: {', '.join(sorted(sets)) or 'none'})")
+        return [r for r in self.cg.sorted_instances(self.mc, st["rows"]) if self.matches(r, st.get("where", []))]
+
+    def raw(self, row: Container, path) -> Optional[str]:
+        kind, v = self.steps(row, path)
+        if kind == "value":
+            return (v[0] or "").strip() if v[0] is not None else None
+        if kind == "token":
+            return v
+        return None
+
+    def matches(self, row: Container, where: list) -> bool:
+        for w in where:
+            v = self.raw(row, w["path"])
+            if "in" in w and v not in w["in"]:
+                return False
+            if "notIn" in w and v in w["notIn"]:
+                return False
+        return True
+
     def _touch(self, c: Container, d):
         if c.module is self.mc:
             self.rank = max(self.rank, self.cg.eff_class(self.mc, d))
@@ -161,6 +208,8 @@ class Eval:
             ok = kind == "value" and (v[0] or "").strip().lower() in ("true", "1")
             if not ok:
                 return (spec.get("default", "0u"), "")
+        if "agg" in spec:
+            return self._agg(row, spec)
         paths = spec["path"]
         alts = paths if isinstance(paths, list) and paths and isinstance(paths[0], list) else [paths]
         kind, v = None, None
@@ -182,23 +231,69 @@ class Eval:
                 s = self.ctx.xsym(v, self.mc, self.used_mips)
             return (s, "")
         if kind == "token":
-            if fmt:
-                return (fmt.replace("{MIP}", v.upper()).replace("{Mip}", v), "")
+            if fmt and fmt not in ("hex", "int"):
+                return (fmt.replace("{MIP}", v.upper()).replace("{Mip}", v).replace("{}", v), "")
             return (v, "")
         raw, d, owner = v
         if "enum" in spec and raw is not None:
             m = spec["enum"]
             if raw.strip() not in m:
-                raise BindingError(f"{row.path}: {spec['path']} literal {raw} not in the binding's enum map")
-            return (str(m[raw.strip()]), raw.strip())
+                raise BindingError(f"{row.path}: {spec['path']} = {raw.strip()} is not supported by the static code "
+                                   f"(the {self.mc.name} binding maps only {', '.join(m)})")
+            e = m[raw.strip()]
+            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 fmt == "int":  # a numeric value held in a STRING param (e.g. ComSignalInitValue)
+            n = parse_int(raw.strip())
+            if n is None:
+                raise BindingError(f"{row.path}: {spec['path']} = {raw.strip()!r} is not an integer; the static code's "
+                                   f"{spec.get('name')} field cannot hold it")
+            return (W.c_uint(n), "")
         return W.table_value(d, raw, hexa=fmt == "hex")
 
-    def macro(self, expr: str) -> str:
-        m = re.match(r"^(count|max):([\w]+)(?:/(\w+))?\s*([+-]\s*\d+)?$", expr.strip())
+    def _ticks(self, row: Container, raw, spec: dict) -> str:
+        from ..values import parse_float
+        v = parse_float(str(raw).strip())
+        base = self.raw(row, spec["divide"])
+        b = parse_float(base) if base is not None else None
+        if v is None or not b:
+            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 _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)."""
+        from ..values import parse_float
+        a = spec["agg"]
+        vals = []
+        for pv in row.values(a["over"]):
+            t = self.cg.target(pv)
+            if t is None or (a.get("skipIf") and t.value(a["skipIf"]) is not None):
+                continue
+            for p in a["params"]:
+                x = parse_float((t.text(p) or "").strip())
+                if x is not None:
+                    vals.append(x)
+        if a["op"] == "min_nonzero":
+            vals = [x for x in vals if x > 0]
+            v = min(vals) if vals else None
+        elif a["op"] == "max":
+            v = max(vals) if vals else None
+        else:
+            raise BindingError(f"unknown aggregate {a['op']!r}")
+        if v is None:
+            return (spec.get("default", "0u"), "")
+        if "divide" in spec:
+            return (self._ticks(row, repr(v), spec), "")
+        return (W.c_float(repr(v)), "")
+
+    def macro(self, expr: str, sets: Optional[dict] = None) -> str:
+        m = re.match(r"^(count|max):(@?[\w]+)(?:/(\w+))?\s*([+-]\s*\d+)?$", expr.strip())
         if not m:
-            raise BindingError(f"bad macro expression {expr!r} (count:<Def> | max:<Def>/<Param> [+N])")
+            raise BindingError(f"bad macro expression {expr!r} (count:<Def> | count:@<Set> | max:<Def>/<Param> [+N])")
         op, dname, pname, off = m.groups()
-        insts = self.cg.instances(self.mc, dname)
+        insts = self.rows(dname, sets or {}) if dname.startswith("@") else self.cg.instances(self.mc, dname)
         if op == "count":
             v = len(insts)
         else: