@h2loop/autosar 1.0.1 → 1.1.0

package/python/ecuc_engine/cli.py

@@ -1,4 +1,5 @@
-"""CLI: python -m ecuc_engine [--root DIR] <info|read|edit|validate|diff> ... --json
+"""CLI: python -m ecuc_engine [--root DIR] <info|read|edit|validate|diff|audit|codegen|codegen-diff|rte-api|verify-rte|
+                                          build-context> ... --json
 
 Always prints one JSON object on stdout. {"ok": false, "error": ...} on failure (exit code 0 for
 handled errors, so callers parse stdout rather than the status).
@@ -49,16 +50,68 @@ def main(argv=None) -> int:
     v = sub.add_parser("validate")
     v.add_argument("--file", action="append")
     v.add_argument("--module")
+    v.add_argument("--check-generated", dest="check_generated", action="store_true", default=None,
+                   help="regenerate in a scratch copy and report stale generated files (H2L-GEN-001)")
+    v.add_argument("--no-check-generated", dest="check_generated", action="store_false")
+    v.add_argument("--no-code", dest="code", action="store_false", help="skip the C-usage completeness check")
     v.add_argument("--max", type=int, default=0, help="cap the number of diagnostics returned (0 = all)")
     au = sub.add_parser("audit")
     au.add_argument("paths", nargs="*", help="C files/dirs to scan (default: audit.paths in .hydron/autosar.json, else Source/)")
     au.add_argument("--headers", action="append", help="generated header dirs for symbols and RTE macros (default Output/)")
+    asg = sub.add_parser("add-signal")
+    asg.add_argument("--name", required=True)
+    asg.add_argument("--ipdu", required=True)
+    asg.add_argument("--bit-size", dest="bit_size", type=int)
+    asg.add_argument("--type", dest="signal_type", default="UINT8")
+    asg.add_argument("--bit-position", dest="bit_position", type=int)
+    asg.add_argument("--endianness", default="LITTLE_ENDIAN")
+    asg.add_argument("--init", default="0")
+    asg.add_argument("--transfer-property", dest="transfer_property")
+    asg.add_argument("--dry-run", action="store_true")
+    ae = sub.add_parser("arxml-edit")
+    ae.add_argument("--ops", required=True)
+    ae.add_argument("--dry-run", action="store_true")
+    fd = sub.add_parser("find")
+    fd.add_argument("--module")
+    fd.add_argument("--container-def", dest="container_def")
+    fd.add_argument("--where", help='"Param=Value, Other>3" or a JSON object')
+    fd.add_argument("--ref-to", dest="ref_to")
+    fd.add_argument("--referenced-by", dest="referenced_by")
+    fd.add_argument("--limit", type=int, default=50)
+    cx = sub.add_parser("crosscheck")
+    cx.add_argument("module")
     so = sub.add_parser("signal-owners")
     so.add_argument("paths", nargs="+")
     d = sub.add_parser("diff")
     d.add_argument("a")
     d.add_argument("b")
-    for p in (r, e, v, d, au, so):  # allow --json after the subcommand too
+    cg = sub.add_parser("codegen", help="deterministic config code generation")
+    cg.add_argument("--module", action="append", help="module to generate (repeatable; default: all registered ones configured)")
+    cg.add_argument("--out", help="output dir (default: .hydron/codegen/out scratch; 'project' = codegen.outDir, else Output)")
+    cg.add_argument("--no-write-back", action="store_true", help="do not write assigned handle IDs into the ECUC ARXML")
+    cg.add_argument("--binding", help="static-code binding name ('none' = generic tables only)")
+    cd = sub.add_parser("codegen-diff", help="semantic diff of generated C against a reference dir")
+    cd.add_argument("reference")
+    cd.add_argument("generated", nargs="?", help="default: the codegen scratch dir")
+    cd.add_argument("--module", action="append")
+    cd.add_argument("--max", type=int, default=50, help="max element mismatches listed per object")
+    ra = sub.add_parser("rte-api", help="expected RTE API per SW-C / runnable (SWS_RTE naming and signatures)")
+    ra.add_argument("--swc")
+    ra.add_argument("--runnable")
+    ra.add_argument("--no-header", action="store_true", help="skip matching against Rte_<Swc>.h")
+    vr = sub.add_parser("verify-rte", help="classify Rte_* calls in C per runnable: OK / NOT-ALLOWED / INVENTED")
+    vr.add_argument("paths", nargs="*", help="C files/dirs/globs (default: all in-house C)")
+    vr.add_argument("--diff-against", dest="diff_against", help="only calls on lines changed since this git ref")
+    vr.add_argument("--swc")
+    vr.add_argument("--runnable")
+    vr.add_argument("--no-check-ops", dest="check_ops", action="store_false")
+    bc = sub.add_parser("build-context", help="deterministic context for implementing/changing a runnable")
+    bc.add_argument("--swc", required=True)
+    bc.add_argument("--runnable")
+    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
         p.add_argument("--json", action="store_true", help=argparse.SUPPRESS)
     a = ap.parse_args(argv)
     t0 = time.time()
@@ -74,7 +127,7 @@ def main(argv=None) -> int:
 
 
 def run(a) -> dict:
-    if a.cmd == "edit":
+    if a.cmd in ("edit", "arxml-edit"):
         try:
             a.ops = _ops(a.ops)
         except (ValueError, OSError) as ex:
@@ -87,8 +140,64 @@ def run(a) -> dict:
             return diff(a.a, a.b, rel, root)
         except FileNotFoundError as ex:
             return {"error": str(ex)}
+    if a.cmd == "codegen-diff":
+        from .codegen import SCRATCH
+        from .codegen.cdiff import diff_dirs
+        root = os.path.abspath(a.root)
+        ab = lambda p: p if os.path.isabs(p) else os.path.join(root, p)  # noqa: E731
+        ref, gen = ab(a.reference), ab(a.generated or SCRATCH)
+        for p in (ref, gen):
+            if not os.path.exists(p):
+                return {"error": f"{p} does not exist" + (" (run codegen first)" if p == gen else "")}
+        res = diff_dirs(ref, gen, modules=a.module, max_items=a.max)
+        res.update({"reference": ref, "generated": gen})
+        return res
+    if a.cmd == "rte-api":
+        from .rte_api import rte_api
+        return rte_api(os.path.abspath(a.root), swc=a.swc, runnable=a.runnable, header=not a.no_header)
+    if a.cmd == "verify-rte":
+        from .verify_rte import verify
+        return verify(os.path.abspath(a.root), files=a.paths or None, diff_against=a.diff_against, swc=a.swc,
+                      runnable=a.runnable, check_ops=a.check_ops)
+    if a.cmd == "build-context":
+        from .context import build_context
+        task = a.task
+        if task == "-":
+            task = sys.stdin.read()
+        elif task.startswith("@"):
+            with open(task[1:]) as fh:
+                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)
     from .model import Project
-    project = Project(a.root, config_files=a.config, def_files=a.defs, load_input=a.cmd in ("validate", "edit"))
+    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":
+        from .add_signal import AddSignalError, add_signal
+        try:
+            return add_signal(project, a.name, a.ipdu, bit_size=a.bit_size, signal_type=a.signal_type,
+                              bit_position=a.bit_position, endianness=a.endianness, init=a.init,
+                              transfer_property=a.transfer_property, dry_run=a.dry_run)
+        except AddSignalError as ex:
+            return {"error": str(ex), "written": False}
+    if a.cmd == "arxml-edit":
+        from .arxml_edit import arxml_edit
+        return arxml_edit(project, a.ops, dry_run=a.dry_run)
+    if a.cmd == "find":
+        from .find import find
+        where = a.where
+        if where and where.strip().startswith("{"):
+            where = json.loads(where)
+        return find(project, module=a.module, container_def=a.container_def, where=where, ref_to=a.ref_to,
+                    referenced_by=a.referenced_by, limit=a.limit)
+    if a.cmd == "crosscheck":
+        from .find import crosscheck
+        return crosscheck(project, a.module)
+    if a.cmd == "codegen":
+        from .codegen import generate
+        res = generate(project, modules=a.module, out_dir=a.out, write_back=not a.no_write_back, binding=a.binding)
+        if project.warnings:
+            res["warnings"] = project.warnings
+        return res
     if a.cmd == "signal-owners":
         from .audit import signal_owners
         return {"owners": signal_owners(project, a.paths)}
@@ -115,7 +224,7 @@ def run(a) -> dict:
         return res
     if a.cmd == "validate":
         from .validate import validate
-        res = validate(project, files=a.file, module=a.module)
+        res = validate(project, files=a.file, module=a.module, check_generated=a.check_generated, code=a.code)
         if a.max and len(res["diagnostics"]) > a.max:
             res["truncated"] = len(res["diagnostics"]) - a.max
             res["diagnostics"] = res["diagnostics"][: a.max]

package/python/ecuc_engine/codegen/__init__.py

@@ -0,0 +1,185 @@
+"""Deterministic ECUC -> C configuration code generation.
+
+Same ECUC ARXML + same param defs -> byte-identical C. No LLM is involved: every line comes from
+the param defs (generic emitter), a module generator (codegen/modules/, only for what the defs
+cannot express), or a static-code binding (codegen/bindings/*.json, the vendor struct layout).
+
+Entry point: generate(project, modules=None, out_dir=None, write_back=True).
+Project options (.hydron/autosar.json, key "codegen"):
+  {"outDir": "Output",             # the project's generated-code folder (used when out_dir="project")
+   "binding": "sip-standin",       # force a static-code binding ("none" = generic tables only)
+   "mip": {"Eep": "Eep_21_LDExt"}, # module implementation prefixes (vendorId/vendorApiInfix)
+   "memmap": {"pragmas": {"CODE": {"start": "#pragma ...", "stop": "#pragma ..."}}},
+   "mcal": {"silicon": "tc4d", "pinMap": "mcal/pins.json"}}
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import time
+from typing import Optional
+
+from .. import paths as P
+from ..model import PROJECT_CONFIG, Project
+from . import binding as B
+from . import handles as H
+from . import schm_memmap as S
+from .emit import Ctx
+from .model import CgModel
+from .registry import generator_for, registered
+
+SCRATCH = os.path.join(".hydron", "codegen", "out")
+
+
+def project_options(root: str) -> dict:
+    f = os.path.join(root, PROJECT_CONFIG)
+    if not os.path.isfile(f):
+        return {}
+    try:
+        with open(f) as fh:
+            return json.load(fh).get("codegen", {}) or {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _scan_c(root: str, exclude: list) -> tuple:
+    """(headers basename->path, source files) of the project's static/in-house C, excluding generator output."""
+    from ..audit import is_generated
+    ex = [os.path.realpath(e) + os.sep for e in exclude if e]
+    w = P.walk(root, lambda n: n.endswith((".h", ".c")))
+    headers: dict = {}
+    sources: list = []
+    for f in w.files:
+        rf = os.path.realpath(f)
+        if any(rf.startswith(e) for e in ex):
+            continue
+        if f.endswith(".h"):
+            headers.setdefault(os.path.basename(f), f)
+        if not is_generated(f):
+            sources.append(f)
+    return headers, sources
+
+
+def resolve_out(root: str, out_dir: Optional[str], opts: dict) -> str:
+    if not out_dir:
+        return os.path.join(root, SCRATCH)
+    if out_dir == "project":
+        out_dir = opts.get("outDir", "Output")
+    return out_dir if os.path.isabs(out_dir) else os.path.join(root, out_dir)
+
+
+def generate(project: Project, modules: Optional[list] = None, out_dir: Optional[str] = None,
+             write_back: bool = True, binding: Optional[str] = None) -> dict:
+    t0 = time.time()
+    root = project.root
+    opts = project_options(root)
+    out = resolve_out(root, out_dir, opts)
+    binding = binding or opts.get("binding")
+    timings: dict = {}
+
+    cg = CgModel(project, opts.get("mip"))
+    configured = sorted(cg.modules)
+    if modules:
+        want = []
+        for m in modules:
+            hit = [x for x in configured if x.lower() == m.lower()]
+            if not hit:
+                return {"ok": False, "error": f"module {m!r} is not configured (configured: {', '.join(configured)})"}
+            want.append(hit[0])
+    else:
+        want = [m for m in registered() if m in cg.modules]
+    if not project.defs:
+        return {"ok": False, "error": "code generation needs the ECUC param defs (paramDefs in .hydron/autosar.json "
+                                      "or $AUTOSAR_PARAMDEFS): config classes and types come from them"}
+    timings["load_ms"] = int((time.time() - t0) * 1000)
+
+    # 1. handle IDs (TPS_ECUC_02107): assign, write back (or patch in memory only)
+    t1 = time.time()
+    pl = H.plan(cg, want)
+    if pl["errors"]:
+        return {"ok": False, "error": "handle-ID conflicts; fix the configuration first", "handleErrors": pl["errors"]}
+    wb = H.apply(project, pl["assign"], write=write_back)
+    if pl["assign"]:
+        cg = CgModel(project, opts.get("mip"))
+    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(),
+              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())
+    files: dict = {}
+    report: dict = {}
+    memmaps = []
+    notes = list(pl["notes"])
+    for name in want:
+        mc = cg.module(name)
+        gen = generator_for(name)(ctx, mc)
+        mo = gen.run()
+        rendered = mo.render()
+        n, text = S.schm_header(ctx, mo)
+        rendered[n] = text
+        mm = f"{mo.mip}_MemMap.h"
+        if mm in headers:
+            notes.append(f"{name}: project provides {P_rel(root, headers[mm])}; {mm} not generated")
+        else:
+            n, text, sections = S.module_memmap(ctx, mo, (opts.get("memmap") or {}).get("pragmas", {}))
+            rendered[n] = text
+            memmaps.append((mo.mip, sections))
+        files.update(rendered)
+        report[name] = {
+            "variant": mc.variant,
+            "binding": (mo.binding or {}).get("_binding"),
+            "files": sorted(rendered),
+            "symbols": len(mo.symbols),
+            "notes": mo.notes,
+        }
+    if memmaps and "MemMap.h" not in headers:
+        files["MemMap.h"] = S.aggregate_memmap(ctx, memmaps)
+    elif memmaps:
+        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)
+
+    # 3. write
+    os.makedirs(out, exist_ok=True)
+    manifest = []
+    for name in sorted(files):
+        data = files[name].encode("utf-8")
+        path = os.path.join(out, name)
+        with open(path, "wb") as fh:
+            fh.write(data)
+        manifest.append({"file": name, "bytes": len(data), "sha256": hashlib.sha256(data).hexdigest()[:16]})
+    std = _std_types_release(headers)
+    if std and std[:2] != ctx.release[:2]:
+        notes.append(f"Std_Types.h in the project is AUTOSAR {std[0]}.{std[1]}.x but the configuration is "
+                     f"{ctx.release[0]}.{ctx.release[1]}.x (schema); the release check against <Mip>.h may fail")
+    timings["total_ms"] = int((time.time() - t0) * 1000)
+    return {"ok": True, "outDir": out, "modules": report, "files": manifest,
+            "handles": {"assigned": pl["assign"], "writtenBack": wb["written"], "changes": wb["changes"]},
+            "notes": notes, "timings": timings, "release": ".".join(map(str, ctx.release))}
+
+
+def P_rel(root: str, f: str) -> str:
+    r = os.path.relpath(f, root)
+    return f if r.startswith("..") else r
+
+
+def _std_types_release(headers: dict) -> Optional[tuple]:
+    f = headers.get("Std_Types.h")
+    if not f:
+        return None
+    try:
+        with open(f, errors="replace") as fh:
+            t = fh.read()
+    except OSError:
+        return None
+    m1 = re.search(r"STD_TYPES_AR_RELEASE_MAJOR_VERSION\s+\(?(\d+)", t)
+    m2 = re.search(r"STD_TYPES_AR_RELEASE_MINOR_VERSION\s+\(?(\d+)", t)
+    return (int(m1.group(1)), int(m2.group(1))) if m1 and m2 else None

package/python/ecuc_engine/codegen/binding.py

@@ -0,0 +1,210 @@
+"""Static-code bindings: the data contract between generated tables and a BSW implementation.
+
+The ECUC param defs say WHAT is configured; they do not say how a given implementation's static
+code lays out its configuration structs (`NvM_BlockDescriptorType`, `PduR_RoutingPathType`, ...).
+That layout belongs to the BSW vendor (SIP). A binding is a JSON file that maps those structs,
+field by field, onto ECUC values with a small path language, so no layout is hard-coded in Python.
+
+Bundled bindings live in `codegen/bindings/*.json`; a project adds or overrides them in
+`.hydron/codegen/bindings/*.json`. A module binding is used when its `detect` header is found in
+the project (or when the binding is named explicitly).
+
+Path language (a list of steps, evaluated left to right from the row container):
+  param:<P>             value of parameter/reference P in the current container (terminal)
+  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)
+  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.
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+from typing import Optional
+
+from ..values import parse_int
+from . import cwriter as W
+from .model import CgModel, Container, ModuleCfg
+
+HERE = os.path.dirname(__file__)
+
+
+class BindingError(Exception):
+    pass
+
+
+def load_all(root: str) -> dict:
+    """name -> binding dict; project bindings override bundled ones of the same name."""
+    out: dict = {}
+    for f in sorted(glob.glob(os.path.join(HERE, "bindings", "*.json"))) + sorted(
+            glob.glob(os.path.join(root, ".hydron", "codegen", "bindings", "*.json"))):
+        with open(f) as fh:
+            b = json.load(fh)
+        b["_file"] = f
+        out[b["name"]] = b
+    return out
+
+
+def select(bindings: dict, module: str, headers: dict, explicit: Optional[str]) -> Optional[dict]:
+    """The module binding to use: the explicitly named binding, else the first whose detect header matches."""
+    if explicit == "none":
+        return None
+    names = [explicit] if explicit else sorted(bindings)
+    for n in names:
+        b = bindings.get(n)
+        if b is None:
+            raise BindingError(f"unknown binding {n!r} (known: {', '.join(sorted(bindings)) or 'none'})")
+        mb = b.get("modules", {}).get(module)
+        if mb is None:
+            continue
+        det = mb.get("detect")
+        if explicit or det is None or _detect(det, headers):
+            return dict(mb, _binding=n)
+    return None
+
+
+def _detect(det: dict, headers: dict) -> bool:
+    path = headers.get(det["header"])
+    if not path:
+        return False
+    try:
+        with open(path, errors="replace") as f:
+            text = f.read()
+    except OSError:
+        return False
+    return all(t in text for t in ([det["contains"]] if isinstance(det.get("contains"), str) else det.get("contains", [])))
+
+
+class Eval:
+    """Evaluates binding paths against one module; records touched params (config class) and used modules."""
+
+    def __init__(self, cg: CgModel, mc: ModuleCfg, ctx=None):
+        self.ctx = ctx
+        self.cg = cg
+        self.mc = mc
+        self.rank = 1
+        self.used_mips: set = set()
+
+    def steps(self, start: Container, steps) -> tuple:
+        """-> ("container", Container) | ("value", (raw, def, owner)) | ("token", str) | (None, None)"""
+        if isinstance(steps, str):
+            steps = [steps]
+        cur = start
+        for i, st in enumerate(steps):
+            op, _, arg = st.partition(":")
+            last = i == len(steps) - 1
+            if op == "param":
+                pv = cur.value(arg)
+                d = self.cg.param_def(cur, arg)
+                self._touch(cur, d)
+                if pv is not None and pv.is_ref:
+                    if last:
+                        return ("value", (pv.value, d, cur))
+                    cur = self.cg.target(pv)
+                else:
+                    return ("value", (pv.value if pv is not None else None, d, cur)) if last else (None, None)
+            elif op == "sub":
+                subs = cur.sub(arg)
+                cur = subs[0] if subs else None
+            elif op == "ref":
+                self._touch(cur, self.cg.param_def(cur, arg))
+                cur = self.cg.target(cur.value(arg))
+            elif op == "back":
+                dname, _, rname = arg.partition("/")
+                hits = [c for c in self.cg.referrers(cur, ref=rname) if c.def_name == dname]
+                cur = hits[0] if hits else None
+                if cur is not None:
+                    self._touch(cur, self.cg.param_def(cur, rname))
+            elif op == "peer":
+                rname, _, want = arg.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)]
+                hits.sort(key=lambda c: (c.module.name, self.cg.by_path_index(c)))
+                cur = hits[0] if hits else None
+            elif op == "sym":
+                s = self.cg.symbol(cur)
+                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 == "module":
+                return ("token", cur.module.mip)
+            elif op == "name":
+                return ("token", cur.name)
+            elif op == "index":
+                return ("token", W.c_uint(self.cg.index_of(cur)))
+            else:
+                raise BindingError(f"unknown path step {st!r}")
+            if cur is None:
+                return (None, None)
+        return ("container", cur)
+
+    def _touch(self, c: Container, d):
+        if c.module is self.mc:
+            self.rank = max(self.rank, self.cg.eff_class(self.mc, d))
+
+    def field(self, row: Container, spec: dict) -> tuple:
+        """(C initialiser, comment) for one struct field."""
+        when = spec.get("when")
+        if when is not None:
+            kind, v = self.steps(row, when)
+            ok = kind == "value" and (v[0] or "").strip().lower() in ("true", "1")
+            if not ok:
+                return (spec.get("default", "0u"), "")
+        paths = spec["path"]
+        alts = paths if isinstance(paths, list) and paths and isinstance(paths[0], list) else [paths]
+        kind, v = None, None
+        for alt in alts:  # alternatives: the first path that yields a value wins
+            kind, v = self.steps(row, alt)
+            if kind is not None and not (kind == "value" and v[0] is None):
+                break
+        default = spec.get("default")
+        fmt = spec.get("fmt")
+        if kind is None or (kind == "value" and v[0] is None):
+            if default is None:
+                raise BindingError(f"{row.path}: field {spec.get('name')} ({spec['path']}) has no value and no default")
+            return (default, "")
+        if kind == "container":
+            s = self.cg.symbol(v)
+            if s is None:
+                return (W.c_uint(self.cg.index_of(v)), v.name)
+            if self.ctx is not None:
+                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), "")
+            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())
+        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())
+        if not m:
+            raise BindingError(f"bad macro expression {expr!r} (count:<Def> | max:<Def>/<Param> [+N])")
+        op, dname, pname, off = m.groups()
+        insts = self.cg.instances(self.mc, dname)
+        if op == "count":
+            v = len(insts)
+        else:
+            vals = [parse_int(c.text(pname) or "") for c in insts]
+            vals = [x for x in vals if x is not None]
+            v = max(vals) if vals else 0
+        if off:
+            v += int(off.replace(" ", ""))
+        return W.c_uint(v)

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

@@ -0,0 +1,111 @@
+{
+  "name": "sip-standin",
+  "description": "Struct layout of the fixture's SIP stand-in static code (fixtures/*/SIP/include). Every type, field and macro below is taken from those headers; the values come from the ECUC via the path language (see codegen/binding.py). Enumeration fields without an 'enum' map use the def literal order.",
+  "modules": {
+    "NvM": {
+      "detect": {"header": "NvM.h", "contains": "NvM_BlockDescriptorType"},
+      "sourceIncludes": ["NvM.h"],
+      "macros": [
+        {"name": "NVM_TOTAL_NUM_OF_NVRAM_BLOCKS", "value": "max:NvMBlockDescriptor/NvMNvramBlockIdentifier+1"}
+      ],
+      "tables": [
+        {
+          "name": "NvM_BlockDescriptorTable", "type": "NvM_BlockDescriptorType", "qualifier": "NVM_CONST",
+          "rows": "NvMBlockDescriptor", "size": "NVM_TOTAL_NUM_OF_NVRAM_BLOCKS", "designated": true,
+          "doc": "indexed by NvMNvramBlockIdentifier (0 and 1 are reserved, SWS_NvM_00478)",
+          "fields": [
+            {"name": "RamBlockDataAddress", "path": "param:NvMRamBlockDataAddress", "default": "NULL_PTR",
+             "extern": "VAR(uint8, NVM_APPL_DATA) {}[]"},
+            {"name": "NvBlockLength", "path": "param:NvMNvBlockLength"},
+            {"name": "FeeBlockNumber", "path": [["sub:NvMTargetBlockReference", "sub:NvMFeeRef", "ref:NvMNameOfFeeBlock", "param:FeeBlockNumber"],
+                                                 ["sub:NvMTargetBlockReference", "sub:NvMEaRef", "ref:NvMNameOfEaBlock", "param:EaBlockNumber"]]},
+            {"name": "ManagementType", "path": "param:NvMBlockManagementType"},
+            {"name": "UseCrc", "path": "param:NvMBlockUseCrc"},
+            {"name": "SingleBlockCallback", "path": ["sub:NvMSingleBlockCallback", "param:NvMSingleBlockCallbackFnc"],
+             "default": "NULL_PTR",
+             "extern": "FUNC(Std_ReturnType, NVM_APPL_CODE) {}(NvM_BlockRequestType BlockRequest, NvM_RequestResultType JobResult)"}
+          ]
+        }
+      ]
+    },
+    "Dem": {
+      "detect": {"header": "Dem.h", "contains": "Dem_EventIdType"},
+      "genericTables": true,
+      "macros": [
+        {"name": "DEM_NUMBER_OF_EVENTS", "value": "max:DemEventParameter/DemEventId"}
+      ]
+    },
+    "PduR": {
+      "detect": {"header": "PduR.h", "contains": "PduR_RoutingPathType"},
+      "sourceIncludes": ["PduR.h"],
+      "macros": [
+        {"name": "PDUR_NUMBER_OF_SRC_PDUS", "value": "count:PduRSrcPdu"},
+        {"name": "PDUR_NUMBER_OF_DEST_PDUS", "value": "count:PduRDestPdu"}
+      ],
+      "tables": [
+        {
+          "name": "PduR_RoutingPaths", "type": "PduR_RoutingPathType", "qualifier": "PDUR_CONST", "static": true,
+          "rows": "PduRSrcPdu", "size": "PDUR_NUMBER_OF_SRC_PDUS",
+          "doc": "indexed by PduRSourcePduHandleId", "comment": "name",
+          "fields": [
+            {"name": "DestModule", "path": ["back:PduRRoutingPath/PduRSrcPduRRef", "ref:PduRDestPduRRef", "peer:PduRDestPduRef", "module"],
+             "fmt": "PDUR_DEST_{MIP}"},
+            {"name": "DestLowerPduId", "path": ["back:PduRRoutingPath/PduRSrcPduRRef", "ref:PduRDestPduRRef", "peer:PduRDestPduRef", "sym"]},
+            {"name": "DestPduRPduId", "path": ["back:PduRRoutingPath/PduRSrcPduRRef", "ref:PduRDestPduRRef", "sym"]}
+          ]
+        },
+        {
+          "name": "PduR_TxConfUpperPduId", "type": "PduIdType", "qualifier": "PDUR_CONST", "static": true, "scalar": true,
+          "rows": "PduRDestPdu", "size": "PDUR_NUMBER_OF_DEST_PDUS",
+          "doc": "indexed by PduRDestPduHandleId: the upper (Com) I-PDU to confirm when the source PDU asks for it (PduRSrcPduUpTxConf)",
+          "fields": [
+            {"name": "UpperPduId", "path": ["back:PduRRoutingPath/PduRDestPduRRef", "ref:PduRSrcPduRRef", "peer:PduRSrcPduRef@Com", "sym"],
+             "when": ["back:PduRRoutingPath/PduRDestPduRRef", "ref:PduRSrcPduRRef", "param:PduRSrcPduUpTxConf"],
+             "default": "COMSTACK_INVALID_PDUID"}
+          ]
+        }
+      ],
+      "objects": [
+        {"name": "PduR_Config", "type": "PduR_PBConfigType", "qualifier": "PDUR_CONST",
+         "init": ["PduR_RoutingPaths", "PduR_TxConfUpperPduId", "PDUR_NUMBER_OF_SRC_PDUS", "PDUR_NUMBER_OF_DEST_PDUS"]}
+      ]
+    },
+    "CanIf": {
+      "detect": {"header": "CanIf.h", "contains": "CanIf_TxPduConfigType"},
+      "sourceIncludes": ["CanIf.h"],
+      "macros": [
+        {"name": "CANIF_NUMBER_OF_TX_PDUS", "value": "count:CanIfTxPduCfg"},
+        {"name": "CANIF_NUMBER_OF_RX_PDUS", "value": "count:CanIfRxPduCfg"}
+      ],
+      "tables": [
+        {
+          "name": "CanIf_TxPduConfig", "type": "CanIf_TxPduConfigType", "qualifier": "CANIF_CONST", "static": true,
+          "rows": "CanIfTxPduCfg", "size": "CANIF_NUMBER_OF_TX_PDUS", "comment": "sym",
+          "doc": "indexed by CanIfTxPduId",
+          "fields": [
+            {"name": "CanId", "path": "param:CanIfTxPduCanId", "fmt": "hex"},
+            {"name": "Dlc", "path": ["ref:CanIfTxPduRef", "param:PduLength"]},
+            {"name": "Hth", "path": ["ref:CanIfTxPduBufferRef", "ref:CanIfBufferHthRef", "ref:CanIfHthIdSymRef", "sym"]},
+            {"name": "UpperPduId", "path": ["peer:CanIfTxPduRef@PduR", "sym"]}
+          ]
+        },
+        {
+          "name": "CanIf_RxPduConfig", "type": "CanIf_RxPduConfigType", "qualifier": "CANIF_CONST", "static": true,
+          "rows": "CanIfRxPduCfg", "size": "CANIF_NUMBER_OF_RX_PDUS", "comment": "sym",
+          "doc": "indexed by CanIfRxPduId",
+          "fields": [
+            {"name": "CanId", "path": "param:CanIfRxPduCanId", "fmt": "hex"},
+            {"name": "CanIdMask", "path": "param:CanIfRxPduCanIdMask", "fmt": "hex"},
+            {"name": "Dlc", "path": "param:CanIfRxPduDataLength"},
+            {"name": "Hrh", "path": ["ref:CanIfRxPduHrhIdRef", "ref:CanIfHrhIdSymRef", "sym"]},
+            {"name": "UpperPduId", "path": ["peer:CanIfRxPduRef@PduR", "sym"]}
+          ]
+        }
+      ],
+      "objects": [
+        {"name": "CanIf_Config", "type": "CanIf_ConfigType", "qualifier": "CANIF_CONST",
+         "init": ["CanIf_TxPduConfig", "CanIf_RxPduConfig", "CANIF_NUMBER_OF_TX_PDUS", "CANIF_NUMBER_OF_RX_PDUS"]}
+      ]
+    }
+  }
+}