@h2loop/autosar 1.1.0 → 1.2.0

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: