@h2loop/autosar 1.0.1 → 1.2.0

package/python/ecuc_engine/codegen/binding.py

@@ -0,0 +1,305 @@
+"""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>[/<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> | 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
+
+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()
+        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)"""
+        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("@")
+                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) 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":
+                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 == "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":
+                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 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))
+
+    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"), "")
+        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
+        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 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']} = {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 _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> | count:@<Set> | max:<Def>/<Param> [+N])")
+        op, dname, pname, off = m.groups()
+        insts = self.rows(dname, sets or {}) if dname.startswith("@") else 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)