@h2loop/autosar 1.1.0 → 1.2.0

package/python/ecuc_engine/codegen/handles.py

@@ -10,6 +10,13 @@ Algorithm (stable by construction):
   * containers without a value get the lowest free integers >= max(def MIN, 0), in document order;
   * the scope is one container def within one module (the symbol namespace of TPS_ECUC_02108).
 Only INTEGER parameters are assigned. A missing STRING symbolic value is reported.
+
+Static-code layout (layout()): a static code that indexes its tables by handle (e.g. a Com whose
+signal table holds the Tx signals at 0..nTx-1 and the Rx signals after them) declares that order in
+its binding ("handleLayout"). When the configured values break it (a Tx signal added after the Rx
+ones), the generator renumbers that handle param, keeping the relative order inside each row set,
+but only for withAuto params (the def says the configuration tool computes the value); otherwise the
+mismatch is an error for the integrator.
 """
 from __future__ import annotations
 
@@ -74,16 +81,96 @@ def _plan_module(cg: CgModel, mc: ModuleCfg, out: dict):
             nxt += 1
 
 
+def layout(cg: CgModel, modules: list, selected: dict) -> dict:
+    """-> {"assign": [...], "errors": [...], "notes": [...]} renumbering handles to each binding's handleLayout."""
+    from .binding import Eval
+    out: dict = {"assign": [], "errors": [], "notes": []}
+    for name in modules:
+        mb, mc = selected.get(name), cg.module(name)
+        if not mb or mc is None:
+            continue
+        ev = Eval(cg, mc)
+        for hl in mb.get("handleLayout", []):
+            rows: list = []
+            for st in hl["sets"]:
+                rows += [r for r in ev.rows("@" + st, mb.get("sets", {})) if r not in rows]
+            insts = cg.instances(mc, mb["sets"][hl["sets"][0]]["rows"])
+            rows += [r for r in cg.sorted_instances(mc, insts[0].def_name) if r not in rows] if insts else []
+            if not rows:
+                continue
+            d = cg.symbolic_param(rows[0])
+            changes = [(r, i) for i, r in enumerate(rows) if parse_int(r.text(d.name) or "") != i]
+            if not changes:
+                continue
+            what = f"{d.name}: the {mb.get('_binding')} static code indexes its tables by handle in the order " \
+                   f"{' then '.join(hl['sets'])}"
+            if not d.with_auto:
+                out["errors"].append(f"{what}; {len(changes)} value(s) break that order and the def has no withAuto, "
+                                     f"so they are not renumbered (first: {changes[0][0].path}={changes[0][0].text(d.name)})")
+                continue
+            for r, i in changes:
+                out["assign"].append({"path": r.path, "param": d.name, "value": i, "def": d.path})
+            out["notes"].append(f"{what}; renumbered {len(changes)} {d.name} value(s) (withAuto, TPS_ECUC_02107), "
+                                f"e.g. {changes[0][0].name}: {changes[0][0].text(d.name)} -> {changes[0][1]}")
+    return out
+
+
 def apply(project, assignments: list, write: bool) -> dict:
-    """Write the assigned values into the ECUC ARXML in place (TPS_ECUC_02107) via the engine's editor.
+    """Write the assigned values into the ECUC ARXML in place (TPS_ECUC_02107).
 
-    write=False patches only the in-memory model (dry run), so the generated code still uses them.
+    Values that replace an existing VALUE are patched in one pass per file (only the VALUE text bytes change,
+    so a renumbering of thousands of handles stays linear); new values go through the engine's editor, which
+    places the element per the schema. write=False patches only the in-memory model (dry run), so the
+    generated code still uses them.
     """
     if not assignments:
         return {"written": False, "changes": []}
-    from ..edit import edit
-    ops = [{"op": "set", "path": a["path"], "param": a["param"], "value": a["value"]} for a in assignments]
-    res = edit(project, ops, dry_run=not write, run_validate=False)
-    if not res.get("ok"):
-        raise RuntimeError(f"handle-ID write-back failed: {res.get('error')}")
-    return {"written": bool(res.get("written")), "changes": res.get("changes", [])}
+    import difflib
+    import os
+    from ..xmltree import escape
+    by_path = {}
+    for e in _elems(project):
+        by_path.setdefault(e.path, []).append(e)
+    patches: dict = {}
+    rest = []
+    for a in assignments:
+        hits = [(e, pv) for e in by_path.get(a["path"], []) for pv in e.params if pv.name == a["param"]]
+        vn = hits[0][1].value_node if len(hits) == 1 else None
+        if vn is None or vn.cstart is None or vn.tag != "VALUE":
+            rest.append(a)
+            continue
+        patches.setdefault(hits[0][0].file, []).append((vn.cstart, vn.cend, escape(str(a["value"])).encode()))
+    changes = []
+    for f in sorted(patches):
+        before = project.files[f].data
+        after = bytearray(before)
+        for start, end, repl in sorted(patches[f], reverse=True):
+            after[start:end] = repl
+        after = bytes(after)
+        project.reload(f, after)
+        rel = project.rel(f)
+        a_, b_ = before.decode("utf-8", "replace").splitlines(True), after.decode("utf-8", "replace").splitlines(True)
+        changes.append({"file": rel, "diff": "".join(difflib.unified_diff(a_, b_, f"a/{rel}", f"b/{rel}", n=1))})
+        if write:
+            tmp = f + ".ecuc-tmp"
+            with open(tmp, "wb") as fh:
+                fh.write(after)
+            os.replace(tmp, f)
+    written = bool(patches) and write
+    if rest:
+        from ..edit import edit
+        ops = [{"op": "set", "path": a["path"], "param": a["param"], "value": a["value"]} for a in rest]
+        res = edit(project, ops, dry_run=not write, run_validate=False)
+        if not res.get("ok"):
+            raise RuntimeError(f"handle-ID write-back failed: {res.get('error')}")
+        written = written or bool(res.get("written"))
+        changes += res.get("changes", [])
+    return {"written": written, "changes": changes}
+
+
+def _elems(project):
+    stack = list(project.modules)
+    while stack:
+        e = stack.pop()
+        yield e
+        stack.extend(e.children)

package/python/ecuc_engine/codegen/model.py

@@ -28,8 +28,13 @@ SCHEMA_RELEASE = {
 
 
 def snake(name: str) -> str:
-    """CamelCase -> UPPER_SNAKE (NvMDevErrorDetect -> NVM_DEV_ERROR_DETECT)."""
+    """CamelCase -> UPPER_SNAKE (NvMDevErrorDetect -> NVM_DEV_ERROR_DETECT).
+
+    The AUTOSAR glossary terms I-PDU / N-PDU / L-PDU stay one word (ComSupportedIPduGroups ->
+    COM_SUPPORTED_IPDU_GROUPS), as the specifications spell them in identifiers (IPDUM, ..._IPDU_...).
+    """
     s = re.sub(r"(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", "_", name)
+    s = re.sub(r"(?<![A-Za-z])([INL])_(Pdu)", r"\1\2", s)
     return re.sub(r"_+", "_", s).upper()
 
 

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

@@ -0,0 +1,145 @@
+"""Com: Com_Cfg.h / Com_PBcfg.c.
+
+Def-driven (generic emitter): every ComGeneral switch, the TPS_ECUC_02108 symbols of ComSignal,
+ComSignalGroup, ComGroupSignal, ComIPdu and ComIPduGroup (handle IDs), and, without a static-code
+binding, one table per container def (I-PDUs, signals, signal groups, group signals with bit
+position / size / endianness / type / transfer property / timeouts / update bits).
+
+The static Com's own table layout (signal and I-PDU tables, buffers, Tx-mode ticks, deadline
+ticks) comes from its binding (bindings/*.json); this module only adds what neither the defs nor
+the binding path language can express:
+  * COM_DEV_ERROR_DETECT from ComConfigurationUseDet (ECUC_Com_00141 names that output macro);
+  * notification callouts, resolved for the binding through `call:` steps:
+      - `comUserCallback`: R25-11 Com users (SWS_Com 8.6.3.1, ECUC_Com_10034/10036): the ComUserModuleCnf
+        referenced by ComUserModule/ComUserModuleCnfRef, its ComUserSignal / ComUserSignalGroup with the
+        same system signal (group) as the ComSignal (Group), and the ComUserCallback of type COM_RX_ACK
+        (receiver) or COM_TX_ACK (sender). These callbacks take a ComUserCbkHandleId.
+      - `rteSignalCallback`: the per-signal RTE callback `Rte_COMCbk_<sn>()` (receiver) /
+        `Rte_COMCbkTAck_<sn>()` (sender), <sn> = ComSignal short name (SWS_Rte Figure 4.42), bound only
+        when the RTE's callback header (Rte_Cbk.h, from the project or the output dir) declares it with
+        a void(void) prototype; Com_PBcfg.c then includes that header;
+  * the headers named by ComGeneral/ComUserCbkHeaderFile (callback prototypes) in Com_PBcfg.c;
+  * notes for configuration a static Com may silently not implement.
+"""
+from __future__ import annotations
+
+import re
+
+from ..registry import Generator, register
+
+RX_ACK, TX_ACK = "COM_RX_ACK", "COM_TX_ACK"
+
+
+@register("Com")
+class Com(Generator):
+    std_header = "ComStack_Types.h"
+
+    def specific(self, mo):
+        gen = [c for c in self.mc.containers if c.def_name == "ComGeneral"]
+        g = gen[0] if gen else None
+        det = g.text("ComConfigurationUseDet") if g is not None else None
+        mo.group("Development error detection (ECUC_Com_00141: ComConfigurationUseDet -> COM_DEV_ERROR_DETECT)",
+                 [("COM_DEV_ERROR_DETECT", "STD_ON" if (det or "").strip().lower() in ("true", "1") else "STD_OFF")])
+        if g is not None:
+            for pv in g.values("ComUserCbkHeaderFile"):
+                h = (pv.value or "").strip().strip('"<>')
+                if h:
+                    mo.include(h)
+        self._dir = self._directions()
+        self._users = self._com_user_callbacks()
+        self._rte_text = self.ctx.header_text("Rte_Cbk.h")
+        self._limits(mo)
+
+    # ---------- call: resolvers for the binding ----------
+
+    def path_steps(self, mo) -> dict:
+        def com_user(c, ev):
+            hit = self._users.get((c.path, self._ack(c)))
+            if hit is None:
+                return None
+            name, header = hit
+            if header:
+                mo.include(header)
+            return name
+
+        def rte_signal(c, ev):
+            if c.def_name not in ("ComSignal", "ComSignalGroup") or not self._rte_text:
+                return None
+            name = ("Rte_COMCbk_" if self._ack(c) == RX_ACK else "Rte_COMCbkTAck_") + c.name
+            if not re.search(rf"\b{re.escape(name)}\s*\(\s*void\s*\)", self._rte_text):
+                if (c.path, self._ack(c)) in self._users:
+                    mo.notes.append(f"{c.path}: has a Com user callback ({self._users[(c.path, self._ack(c))][0]}), "
+                                    "which takes a ComUserCbkHandleId; the static code's notification type is "
+                                    "void(void), so it is not bound")
+                return None
+            mo.include("Rte_Cbk.h")
+            return name
+
+        return {"comUserCallback": com_user, "rteSignalCallback": rte_signal}
+
+    # ---------- helpers ----------
+
+    def _directions(self) -> dict:
+        """ComSignal / ComSignalGroup path -> ComIPduDirection of the I-PDU that carries it."""
+        out = {}
+        for ip in self.cg.instances(self.mc, "ComIPdu"):
+            d = (ip.text("ComIPduDirection") or "").strip()
+            for r in ("ComIPduSignalRef", "ComIPduSignalGroupRef"):
+                for pv in ip.values(r):
+                    if pv.value:
+                        out.setdefault(pv.value.strip(), d)
+        return out
+
+    def _ack(self, c) -> str:
+        return TX_ACK if self._dir.get(c.path) == "SEND" else RX_ACK
+
+    def _com_user_callbacks(self) -> dict:
+        """(ComSignal/ComSignalGroup path, callback type) -> (ComUserCallbackName, ComUserHeaderInclude)."""
+        by_sys: dict = {}
+        for c in self.mc.containers:
+            for p in ("ComSystemTemplateSystemSignalRef", "ComSystemTemplateSignalGroupRef"):
+                v = c.text(p)
+                if v and c.def_name in ("ComSignal", "ComSignalGroup"):
+                    by_sys.setdefault(v.strip(), c)
+        out: dict = {}
+        for um in self.cg.instances(self.mc, "ComUserModule"):
+            cnf = self.cg.target(um.value("ComUserModuleCnfRef"))
+            if cnf is None:
+                continue
+            header = (cnf.text("ComUserHeaderInclude") or "").strip().strip('"<>') or None
+            for u in cnf.children:
+                sysref = u.text("ComUserSystemTemplateSystemSignalRef") or u.text("ComUserSystemTemplateSignalGroupRef")
+                sig = by_sys.get((sysref or "").strip())
+                if sig is None:
+                    continue
+                for pv in u.values("ComUserCallbackRef"):
+                    cb = self.cg.target(pv)
+                    if cb is None:
+                        continue
+                    kind = (cb.text("ComUserCallbackType") or "").strip()
+                    name = (cb.text("ComUserCallbackName") or "").strip()
+                    if name:
+                        out.setdefault((sig.path, kind), (name, header))
+        return out
+
+    def _limits(self, mo):
+        """Configuration that is valid ECUC but that a static Com may not implement: say so, never drop it silently."""
+        if mo.binding is None:
+            return
+        cnt = lambda pred: sum(1 for c in self.mc.containers if pred(c))  # noqa: E731
+        notes = []
+        n = cnt(lambda c: c.def_name == "ComIPdu" and (c.text("ComIPduSignalProcessing") or "").strip() == "DEFERRED")
+        if n:
+            notes.append(f"{n} I-PDU(s) use ComIPduSignalProcessing=DEFERRED; the binding has no field for it "
+                         "(the static code decides when Rx notifications run)")
+        n = cnt(lambda c: c.def_name == "ComSignal" and (c.text("ComRxDataTimeoutAction") or "NONE").strip() != "NONE")
+        if n:
+            notes.append(f"{n} signal(s) configure ComRxDataTimeoutAction; the binding carries only the I-PDU "
+                         "deadline (TimeoutTicks), the action is up to the static code")
+        n = cnt(lambda c: c.def_name == "ComTxMode" and int(float(c.text("ComTxModeNumberOfRepetitions") or 0)) > 0)
+        if n:
+            notes.append(f"{n} Tx mode(s) configure ComTxModeNumberOfRepetitions > 0; the binding has no repetition field")
+        n = cnt(lambda c: c.def_name == "ComTxIPdu" and float(c.text("ComMinimumDelayTime") or 0) > 0)
+        if n:
+            notes.append(f"{n} Tx I-PDU(s) configure ComMinimumDelayTime > 0; the binding has no MDT field")
+        mo.notes += [f"{(mo.binding or {}).get('_binding')}: {x}" for x in notes]

package/python/ecuc_engine/codegen/registry.py

@@ -57,9 +57,16 @@ class Generator:
         if mb is None or mb.get("genericTables", False):
             E.generic_tables(self.cg, mo, set(self.skip_tables(mo)))
         if mb is not None:
-            apply_binding(self.cg, mo, mb)
+            try:
+                apply_binding(self.cg, mo, mb, self.path_steps(mo))
+            except B.BindingError as ex:
+                mo.errors.append(str(ex))
         return mo
 
+    def path_steps(self, mo) -> dict:
+        """call:<name> resolvers for the binding path language: {name: fn(container, Eval) -> token | None}."""
+        return {}
+
     def default_std_header(self) -> str:
         """ComStack_Types.h for modules that reference EcuC PDUs (communication stack), else Std_Types.h."""
         md = self.mc.defn
@@ -77,24 +84,53 @@ class Generator:
         """Module-specific emission (only what the param defs cannot express)."""
 
 
-def apply_binding(cg, mo: E.ModuleOutput, mb: dict):
+def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
     ev = B.Eval(cg, mo.mc, mo.ctx)
+    ev.ext = ext or {}
+    sets = mb.get("sets", {})
+    for req in mb.get("require", []):
+        bad = [r for r in ev.rows(req["rows"], sets) if not ev.matches(r, [req])]
+        if bad:
+            vals = sorted({str(ev.raw(r, req["path"])) for r in bad})
+            mo.errors.append(f"{len(bad)} {req['rows']} container(s) have {req['path']} = {', '.join(vals)} "
+                             f"({', '.join(r.name for r in bad[:5])}{', ...' if len(bad) > 5 else ''}); the "
+                             f"{mb['_binding']} static code supports only "
+                             f"{', '.join('(not configured)' if x is None else str(x) for x in req['in'])}: {req.get('why', '')}")
+    for un in mb.get("unsupported", []):
+        rows = cg.instances(mo.mc, un["rows"])
+        if rows:
+            mo.errors.append(f"{len(rows)} {un['rows']} container(s) configured ({', '.join(r.name for r in rows[:5])}"
+                             f"{', ...' if len(rows) > 5 else ''}), which the {mb['_binding']} static code cannot "
+                             f"represent: {un.get('why', '')}")
     for inc in mb.get("sourceIncludes", []):
         mo.include(inc)
     macros = []
+    values: dict = {}
     for m in mb.get("macros", []):
         val = m["value"]
-        macros.append((m["name"], ev.macro(val) if re.match(r"^(count|max):", val) else val))
+        v = ev.macro(val, sets) if re.match(r"^(count|max):", val) else val
+        macros.append((m["name"], v))
+        values[m["name"]] = v
     mo.group(f"Static-code interface ({mb['_binding']} binding)", macros)
-    ranks: dict = {}
     pending: list = []
+    for vs in mb.get("vars", []):
+        ev.rank = 1
+        lines = []
+        for r in ev.rows(vs["rows"], sets):
+            size, _ = ev.field(r, {"name": vs["name"], "path": vs["size"]})
+            name = vs["name"].replace("{}", r.name)
+            lines.append(f"{'static ' if vs.get('static') else ''}VAR({vs['type']}, {vs['qualifier']}) {name}[{size}];")
+        pending.append(("var", ev.rank, vs.get("section", "VAR_NOINIT_UNSPECIFIED"), "\n".join(lines)))
     for t in mb.get("tables", []):
         ev.rank = 1
-        rows = list(cg.sorted_instances(mo.mc, t["rows"]))
+        rows = ev.rows(t["rows"], sets)
         if t.get("order"):
             from ..values import parse_int
             rows.sort(key=lambda r: (parse_int(r.text(t["order"]) or "") is None, parse_int(r.text(t["order"]) or "") or 0))
         lines, externs = [], []
+        des = t.get("designated")
+        if des:
+            _check_index(cg, mo, t, rows, des, values)
         for r in rows:
             vals = []
             for f in t["fields"]:
@@ -103,10 +139,12 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict):
                 if f.get("extern") and v not in ("NULL_PTR", "0", "0u") and not v.startswith('"'):
                     m = re.search(r"[A-Za-z_]\w*", v)
                     if m:
-                        ext = "extern " + f["extern"].replace("{}", m.group(0)) + ";"
-                        if ext not in externs:
-                            externs.append(ext)
-            lead = f"[{cg.symbol(r)}] = " if t.get("designated") else ""
+                        ext_ = "extern " + f["extern"].replace("{}", m.group(0)) + ";"
+                        if ext_ not in externs:
+                            externs.append(ext_)
+            lead = ""
+            if des:
+                lead = f"[{des.replace('{sym}', cg.symbol(r)) if isinstance(des, str) else cg.symbol(r)}] = "
             comment = t.get("comment", "name")
             cm = {"name": r.name, "sym": cg.symbol(r) or r.name}.get(comment, r.name)
             if t.get("scalar"):
@@ -117,17 +155,54 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict):
         size = t.get("size", "")
         body = (f"/* {t.get('doc', t['rows'])} */\n{st}CONST({t['type']}, {t['qualifier']}) {t['name']}[{size}] = {{\n" +
                 ",\n".join(lines) + "\n};")
-        ranks[t["name"]] = ev.rank
-        pending.append((ev.rank, body, externs))
+        pending.append(("table", ev.rank, body, externs))
     objects = mb.get("objects", [])
     if objects:
-        # a root config object points at the (static) tables, so they all live in its file:
+        # a root config object points at the (static) tables and buffers, so they all live in its file:
         # the most dynamic config class among them (e.g. <Mip>_PBcfg.c for a post-build PduR_Config)
-        top = max([r for r, _, _ in pending] + [1])
-        pending = [(top, b, e) for _, b, e in pending]
+        top = max([p[1] for p in pending] + [1])
+        pending = [(p[0], top) + p[2:] for p in pending]
         for o in objects:
             body = (f"CONST({o['type']}, {o['qualifier']}) {o['name']} = {{\n  " + ", ".join(o["init"]) + "\n};")
-            pending.append((top, body, []))
-    for rank, body, externs in pending:
-        mo.table(rank, body, externs)
+            pending.append(("table", top, body, []))
+    for p in pending:
+        if p[0] == "var":
+            mo.var(p[1], p[2], p[3])
+        else:
+            mo.table(p[1], p[2], p[3])
     mo.used_mips |= ev.used_mips
+
+
+def _check_index(cg, mo, t: dict, rows: list, des, values: dict):
+    """A designated table is indexed by handle (minus an offset): every row must land in [0, size) exactly once,
+    or the static code's table lookup would be wrong. Reported as an error, never renumbered here."""
+    from ..values import parse_int
+    off_name = None
+    if isinstance(des, str):
+        m = re.fullmatch(r"\{sym\}\s*-\s*(\w+)", des.strip())
+        if not m:
+            return
+        off_name = m.group(1)
+    num = lambda v: parse_int(re.sub(r"[uUlL]+$", "", str(v)))  # noqa: E731
+    off = num(values.get(off_name, "0")) if off_name else 0
+    size = num(values[t["size"]]) if t.get("size") in values else len(rows)
+    seen: dict = {}
+    bad = 0
+    for r in rows:
+        h = parse_int(cg.symbol_value(r) or "")
+        if h is None:
+            continue
+        i = h - (off or 0)
+        if not 0 <= i < (size or 0) or i in seen:
+            bad += 1
+            if bad > 5:
+                continue
+            pm = cg.symbolic_param(r)
+            mo.errors.append(f"{r.path}: {pm.name if pm else 'handle'}={h} does not fit the static code's "
+                             f"{t['name']}[{t.get('size')}] indexed by {des if isinstance(des, str) else '{sym}'} "
+                             f"({'collides with ' + seen[i] if i in seen else f'index {i} outside 0..{(size or 0) - 1}'}); "
+                             f"the {t['rows']} handles must be contiguous in the order the static code expects")
+            continue
+        seen[i] = r.name
+    if bad > 5:
+        mo.errors.append(f"... {bad - 5} more {t['rows']} handle(s) outside {t['name']}")

package/python/ecuc_engine/ecucjson.py

@@ -8,6 +8,10 @@ Keyed by def names, not XML structure:
                                         "ComSignal:DoorLatch": {...}}}}}
 A container key is "<DefName>:<ShortName>", shortened to "<ShortName>" when the two are equal.
 Multi-valued parameters are arrays. References are "->/AUTOSAR/path".
+Every container carries "@at" (file:line of the container element). Every value is followed by
+"@at:<Param>" = file:line of its VALUE / VALUE-REF element, and integer-typed values by "@hex:<Param>"
+(and "@dec:<Param>" when the ARXML text is not decimal), so citations and base conversions are never guessed.
+Keys starting with "@" are metadata; ecuc_edit ignores them.
 """
 from __future__ import annotations
 
@@ -16,7 +20,7 @@ from typing import Optional
 from . import defs as D
 from .model import Elem, Project
 from .validate import _resolve_def
-from .values import to_json
+from .values import int_forms, to_json
 
 
 def key_of(e: Elem) -> str:
@@ -24,27 +28,55 @@ def key_of(e: Elem) -> str:
     return e.name if dn == e.name else f"{dn}:{e.name}"
 
 
+def value_at(project: Project, e: Elem, pv) -> str:
+    """file:line of a parameter's VALUE / VALUE-REF element (not its container)."""
+    n = pv.value_node if pv.value_node is not None else pv.node
+    return f"{project.rel(e.file)}:{n.line}"
+
+
+def value_info(project: Project, e: Elem, pv) -> dict:
+    """One configured value with its exact location and, for integers, both bases."""
+    pd = _resolve_def(project.defs, pv.def_ref)
+    numerical = pv.tag == "ECUC-NUMERICAL-PARAM-VALUE"
+    out = {"value": to_json(pd, pv.value, pv.is_ref, numerical), "at": value_at(project, e, pv)}
+    nums = int_forms(pd, pv.value, pv.is_ref, numerical, pv.def_dest)
+    if nums:
+        out.update(nums)
+    return out
+
+
+def _put(out: dict, name: str, items: list, multi: bool):
+    one = lambda xs: xs if multi else xs[0]  # noqa: E731
+    out[name] = one([x["value"] for x in items])
+    out[f"@at:{name}"] = one([x["at"] for x in items])
+    if any("hex" in x for x in items):
+        out[f"@hex:{name}"] = one([x.get("hex") for x in items])
+        if any("dec" in x and x["value"] != x["dec"] for x in items):
+            out[f"@dec:{name}"] = one([x.get("dec") for x in items])
+
+
+def annotated_values(project: Project, group: list) -> dict:
+    """{param: value, "@at:param": file:line, "@hex:param": ...} for the params of one element (all its files)."""
+    items: dict = {}
+    multi: dict = {}
+    for e in group:
+        for pv in e.params:
+            pd = _resolve_def(project.defs, pv.def_ref)
+            items.setdefault(pv.name, []).append(value_info(project, e, pv))
+            multi[pv.name] = multi.get(pv.name, False) or (pd is not None and (pd.upper is None or pd.upper > 1))
+    out: dict = {}
+    for name, xs in items.items():
+        _put(out, name, xs, multi[name] or len(xs) > 1)
+    return out
+
+
 def render(project: Project, group: list, depth: int, top: bool = True) -> dict:
-    defs = project.defs
     e0 = group[0]
     out: dict = {"@path": e0.path}
     if top:
         out["@def"] = e0.def_ref
-        out["@at"] = ", ".join(f"{project.rel(e.file)}:{e.line}" for e in group)
-    vals: dict = {}
-    for e in group:
-        for pv in e.params:
-            pd = _resolve_def(defs, pv.def_ref)
-            v = to_json(pd, pv.value, pv.is_ref, pv.tag == "ECUC-NUMERICAL-PARAM-VALUE")
-            name = pv.name
-            multi = pd is not None and (pd.upper is None or pd.upper > 1)
-            if name in vals:
-                if not isinstance(vals[name], list) or not multi:
-                    vals[name] = vals[name] if isinstance(vals[name], list) else [vals[name]]
-                vals[name].append(v)
-            else:
-                vals[name] = [v] if multi else v
-    out.update(vals)
+    out["@at"] = ", ".join(f"{project.rel(e.file)}:{e.line}" for e in group)
+    out.update(annotated_values(project, group))
     seen = set()
     for e in group:
         for c in e.children:
@@ -61,6 +93,24 @@ def render(project: Project, group: list, depth: int, top: bool = True) -> dict:
     return out
 
 
+def value_sites(project: Project, paths: list) -> dict:
+    """AUTOSAR path -> {"at": container file:line, "values": {param: {value, at, dec?, hex?} | [..]}} from the
+    local ECUC, or None when the element is not in the local checkout."""
+    out: dict = {}
+    for p in paths:
+        g = project.find(p)
+        if not g:
+            out[p] = None
+            continue
+        vals: dict = {}
+        for e in g:
+            for pv in e.params:
+                vals.setdefault(pv.name, []).append(value_info(project, e, pv))
+        out[p] = {"at": ", ".join(f"{project.rel(e.file)}:{e.line}" for e in g),
+                  "values": {k: (v[0] if len(v) == 1 else v) for k, v in vals.items()}}
+    return out
+
+
 def read(project: Project, path: Optional[str], depth: int = 2, schema: bool = False) -> dict:
     res: dict = {"defsLoaded": len(project.defs.modules)}
     if project.warnings:
@@ -101,12 +151,15 @@ def read(project: Project, path: Optional[str], depth: int = 2, schema: bool = F
     parent, _, last = path.rstrip("/").rpartition("/")
     pg = project.find(parent)
     if pg:
-        hits = [pv for e in pg for pv in e.params if pv.name == last]
+        hits = [(e, pv) for e in pg for pv in e.params if pv.name == last]
         if hits:
-            pd = _resolve_def(project.defs, hits[0].def_ref)
-            res["param"] = {"@path": path, "@def": hits[0].def_ref,
-                            "@at": [f"{project.rel(hits[0].node and pg[0].file)}:{h.node.line}" for h in hits],
-                            "value": [to_json(pd, h.value, h.is_ref, h.tag == "ECUC-NUMERICAL-PARAM-VALUE") for h in hits]}
+            pd = _resolve_def(project.defs, hits[0][1].def_ref)
+            info = [value_info(project, e, pv) for e, pv in hits]
+            res["param"] = {"@path": path, "@def": hits[0][1].def_ref,
+                            "@at": [x["at"] for x in info], "value": [x["value"] for x in info]}
+            if any("hex" in x for x in info):
+                res["param"]["dec"] = [x.get("dec") for x in info]
+                res["param"]["hex"] = [x.get("hex") for x in info]
             if pd is not None:
                 res["schema"] = D.describe(pd, project.defs)
             return res

package/python/ecuc_engine/find.py

@@ -73,7 +73,7 @@ def _refs(project: Project, e, depth: int) -> set:
 
 def find(project: Project, module: Optional[str] = None, container_def: Optional[str] = None, where=None,
          ref_to: Optional[str] = None, referenced_by: Optional[str] = None, limit: int = 50, depth: int = 2) -> dict:
-    from .ecucjson import resolve
+    from .ecucjson import annotated_values, resolve
     conds = _where(where)
     targets = None
     if ref_to:
@@ -116,9 +116,11 @@ def find(project: Project, module: Optional[str] = None, container_def: Optional
                 continue
         total += 1
         if len(hits) < limit:
-            hits.append({"path": path, "def": dname, "at": f"{project.rel(e.file)}:{e.line}",
-                         "values": {k: (v[0] if len(v) == 1 else v) for k, v in own.items()}})
-    return {"count": total, "returned": len(hits), "matches": hits}
+            hits.append({"path": path, "def": dname, "at": ", ".join(f"{project.rel(x.file)}:{x.line}" for x in group),
+                         "values": annotated_values(project, group)})
+    return {"count": total, "returned": len(hits), "matches": hits,
+            "legend": "at = container element; values[\"@at:P\"] = file:line of P's VALUE element; "
+                      "@hex:/@dec: = the same integer in the other base"}
 
 
 ELEMENTS = {