@h2loop/autosar 1.2.1 → 1.4.0

package/python/ecuc_engine/arxml_edit.py

@@ -7,6 +7,10 @@ Ops (paths are AUTOSAR paths of identifiables; tags are XML element names):
   {"op": "set", "path": "/Communication/Pdus/P/X", "element": "START-POSITION", "value": 40}
   {"op": "remove", "path": "/Communication/ISignals/X"}
 
+- A parent_path that does not exist yet is created as AR-PACKAGEs below its deepest existing package (or at the
+  top level of ``file``, or of the only non-ECUC ARXML file), so a new file from arxml_new can be filled
+  directly. Only packages are created: a missing path below a non-package (a typo in a SWC path) is an error.
+- The ecuc_edit shape is accepted for add ({"path": parent, "container": "TAG:Name"}) and rewritten, with a note.
 - The aggregating collection (ELEMENTS, I-SIGNAL-TO-PDU-MAPPINGS, ...) is inferred from the AUTOSAR schema
   (autosar-data) when not given; children are written in schema order.
 - Every *-REF / *-TREF gets its DEST from the referenced element's actual tag ("->/path"), looked up in all
@@ -95,6 +99,7 @@ class ArxmlEditor:
         self.files: dict = {}
         self.original: dict = {}
         self.added_tags: dict = {}  # path -> tag of elements added in this call
+        self.created_packages: list = []
 
     # ---------- files / lookup ----------
     def tree_for(self, path: str) -> tuple:
@@ -115,6 +120,53 @@ class ArxmlEditor:
             raise ArxmlEditError(f"{path} not found in {self.p.rel(f)}")
         return ft, ft.by_path[path]
 
+    def root_of(self, file: Optional[str]) -> tuple:
+        """(FileTree, AUTOSAR root node) for a top-level package: ``file`` or the only non-ECUC ARXML."""
+        if file:
+            f = os.path.realpath(os.path.join(self.p.root, file))
+            known = [os.path.realpath(x) for x in self.p.sources.input + self.p.sources.config]
+            if f not in known:
+                raise ArxmlEditError(f"file {file!r} is not an ARXML file of this project (create it with arxml_new)")
+            ft = self.load(next(x for x in self.p.sources.input + self.p.sources.config if os.path.realpath(x) == f))
+            return ft, ft.root
+        cands = list(self.p.sources.input)
+        if len(cands) == 1:
+            ft = self.load(cands[0])
+            return ft, ft.root
+        if not cands:
+            raise ArxmlEditError("no non-ECUC ARXML file in this project to put a new top-level package in; create "
+                                 "one with arxml_new first")
+        raise ArxmlEditError("a new top-level package needs \"file\" (which ARXML file to put it in); one of: "
+                             + ", ".join(self.p.rel(c) for c in cands[:20]))
+
+    def parent_for(self, parent_path: str, file: Optional[str]) -> tuple:
+        """(FileTree, node) of parent_path, creating missing AR-PACKAGEs below the deepest existing package."""
+        pp = parent_path.rstrip("/")
+        if pp == "":
+            return self.root_of(file)
+        try:
+            return self.tree_for(pp)
+        except ArxmlEditError:
+            pass
+        segs = [s for s in pp.split("/") if s]
+        anc, k = "", 0
+        for i in range(len(segs) - 1, 0, -1):
+            cand = "/" + "/".join(segs[:i])
+            try:
+                _, node = self.tree_for(cand)
+            except ArxmlEditError:
+                continue
+            if node.tag != "AR-PACKAGE":
+                raise ArxmlEditError(f"{pp} does not exist, and {cand} is a {node.tag}, not a package (only missing "
+                                     "packages are created; check the path)")
+            anc, k = cand, i
+            break
+        for s in segs[k:]:
+            self.op_add({"parent_path": anc or "/", "element": "AR-PACKAGE", "short_name": s, "file": file})
+            anc = f"{anc}/{s}"
+            self.created_packages.append(anc)
+        return self.tree_for(pp)
+
     def load(self, f: str) -> FileTree:
         if f not in self.files:
             with open(f, "rb") as fh:
@@ -208,8 +260,9 @@ class ArxmlEditor:
     def op_add(self, op: dict):
         parent_path, tag = op.get("parent_path"), op.get("element")
         if not parent_path or not tag:
-            raise ArxmlEditError("add needs parent_path and element")
-        ft, parent = self.tree_for(parent_path.rstrip("/"))
+            raise ArxmlEditError("add needs parent_path (the package or element to add under) and element (the XML "
+                                 "tag), e.g. " + ADD_EXAMPLE)
+        ft, parent = self.parent_for(parent_path, op.get("file"))
         version = _version(ft.data)
         ptype = _etype(ft.chain(parent), version)
         coll = op.get("collection")
@@ -221,7 +274,8 @@ class ArxmlEditor:
                         coll = c
                         break
                 if coll is None:
-                    raise ArxmlEditError(f"{tag} cannot be placed under {parent.tag} {parent_path} in this schema")
+                    raise ArxmlEditError(f"{tag} cannot be placed under {parent.tag} {parent_path} in this schema; "
+                                         f"{parent.tag} takes: {', '.join(_placeable(ptype, version))[:600]}")
         elif coll is None:
             coll = "ELEMENTS" if parent.tag == "AR-PACKAGE" else None
         sn = op.get("short_name")
@@ -342,13 +396,63 @@ class ArxmlEditor:
         return problems
 
 
+ADD_EXAMPLE = ('{"op": "add", "parent_path": "/Interfaces", "element": "SENDER-RECEIVER-INTERFACE", '
+               '"short_name": "If_X", "values": {"DATA-ELEMENTS": {"VARIABLE-DATA-PROTOTYPE": {"SHORT-NAME": "Val", '
+               '"TYPE-TREF": "->/DataTypes/uint8"}}}}')
+_TAG = re.compile(r"[A-Z][A-Z0-9-]*\Z")
+
+
+def _placeable(ptype, version) -> list:
+    """Tags that can be added under an element: direct children and the children of its collections."""
+    out = []
+    for c in _order(ptype):
+        if c == "SHORT-NAME":
+            continue
+        ct = ptype.find_sub_element(c, version)
+        subs = [s for s in _order(ct)] if ct is not None else []
+        out.append(f"{c} ({'/'.join(subs[:6])}{'/...' if len(subs) > 6 else ''})" if subs else c)
+    return out
+
+
+def normalize(op: dict, notes: list, i: int) -> dict:
+    """Accept the shapes agents mix up (ecuc_edit's path/container, name/tag) for add; note each rewrite."""
+    if op.get("op") != "add":
+        return op
+    op = dict(op)
+    if not op.get("parent_path") and op.get("path"):
+        op["parent_path"] = op.pop("path")
+        notes.append(f"op {i}: 'path' read as parent_path")
+    cont = op.get("container")
+    if not op.get("element") and isinstance(cont, str):
+        tag, _, sn = cont.partition(":")
+        if _TAG.match(tag):
+            op.pop("container")
+            op["element"] = tag
+            if sn and not op.get("short_name"):
+                op["short_name"] = sn
+            notes.append(f"op {i}: container {cont!r} read as element {tag!r}" + (f", short_name {sn!r}" if sn else ""))
+    for alias, key in (("tag", "element"), ("name", "short_name"), ("shortName", "short_name")):
+        if alias in op and not op.get(key):
+            op[key] = op.pop(alias)
+            notes.append(f"op {i}: {alias!r} read as {key!r}")
+    vals = op.get("values")
+    if isinstance(vals, dict) and "SHORT-NAME" in vals and not op.get("short_name"):
+        vals = dict(vals)
+        op["short_name"] = vals.pop("SHORT-NAME")
+        op["values"] = vals
+        notes.append(f"op {i}: values.SHORT-NAME read as short_name")
+    return op
+
+
 def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
     if isinstance(ops, dict):
         ops = [ops]
     if not isinstance(ops, list) or not ops or not all(isinstance(o, dict) for o in ops):
-        return {"ok": False, "error": "ops must be a non-empty list of op objects"}
+        return {"ok": False, "error": "ops must be a non-empty list of op objects, e.g. [" + ADD_EXAMPLE + "]"}
     ed = ArxmlEditor(project)
     created = []
+    notes: list = []
+    ops = [normalize(o, notes, i) for i, o in enumerate(ops)]
     try:
         for i, op in enumerate(ops):
             kind = op.get("op")
@@ -364,7 +468,7 @@ def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
             except ArxmlEditError as e:
                 raise ArxmlEditError(f"op {i} ({kind} {op.get('path') or op.get('parent_path')}): {e}") from None
     except ArxmlEditError as e:
-        return {"ok": False, "error": str(e), "written": False}
+        return {"ok": False, "error": str(e), "written": False, "notes": notes}
     problems = ed.check()
     changes = []
     for f, ft in ed.files.items():
@@ -375,7 +479,7 @@ def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
             changes.append({"file": rel, "diff": "".join(difflib.unified_diff(a, b, f"a/{rel}", f"b/{rel}", n=1))})
     if problems:
         return {"ok": False, "error": "edit rejected; nothing written", "problems": problems, "changes": changes,
-                "written": False}
+                "written": False, "notes": notes}
     if not dry_run:
         for f, ft in ed.files.items():
             if ft.data != ed.original[f]:
@@ -383,5 +487,57 @@ def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
                 with open(tmp, "wb") as fh:
                     fh.write(ft.data)
                 os.replace(tmp, f)
-    return {"ok": True, "written": not dry_run, "created": [c for c in created if c], "changes": changes,
+    return {"ok": True, "written": not dry_run, "created": [c for c in created if c],
+            "createdPackages": ed.created_packages, "notes": notes, "changes": changes,
             "schemaChecked": _ad() is not None}
+
+
+def arxml_check(project: Project, files: Optional[list] = None) -> dict:
+    """Verify non-ECUC ARXML on demand: strict schema load, every *-REF resolves, DEST = the target's real tag.
+
+    The verify step of the loop for System-extract / SWC / interface files (ecuc_validate covers ECUC values).
+    ``files``: project-relative paths or substrings to limit the check; default all non-ECUC files.
+    """
+    from .edit import schema_check
+    srcs = list(project.sources.input)
+    if files:
+        want = [str(x).strip().lstrip("./") for x in files if str(x).strip()]
+        srcs = [f for f in srcs if any(w in project.rel(f) for w in want)]
+        if not srcs:
+            return {"ok": False, "error": f"no non-ECUC ARXML file matches {files}; files: "
+                                          + ", ".join(project.rel(f) for f in project.sources.input[:30])}
+    trees = {}
+    for f in project.sources.input:
+        try:
+            with open(f, "rb") as fh:
+                trees[f] = FileTree(f, fh.read())
+        except Exception as e:  # noqa: BLE001
+            trees[f] = e
+    known = {p: v[0] for p, v in project.identifiables.items()}
+    for ft in trees.values():
+        if isinstance(ft, FileTree):
+            for p, n in ft.by_path.items():
+                known.setdefault(p, n.tag)
+    problems, refs = [], 0
+    for f in srcs:
+        ft = trees[f]
+        rel = project.rel(f)
+        if not isinstance(ft, FileTree):
+            problems.append(f"{rel}: not well-formed XML: {ft}")
+            continue
+        err = schema_check(f, ft.data)
+        if err:
+            problems.append(f"{rel}: schema: {err}")
+        for n in ft.root.iter():
+            if not (n.tag.endswith("-REF") or n.tag.endswith("-TREF")) or n.children:
+                continue
+            refs += 1
+            tgt, dest = n.text.strip(), n.attrs.get("DEST")
+            if not dest:
+                problems.append(f"{rel}:{n.line} {n.tag} -> {tgt}: missing DEST attribute")
+            if tgt not in known:
+                problems.append(f"{rel}:{n.line} {n.tag} -> {tgt}: target does not exist in the project")
+            elif dest and known[tgt] != dest:
+                problems.append(f"{rel}:{n.line} {n.tag} DEST={dest} but {tgt} is a {known[tgt]}")
+    return {"ok": True, "clean": not problems, "files": [project.rel(f) for f in srcs], "references": refs,
+            "problems": problems, "schemaChecked": _ad() is not None}

package/python/ecuc_engine/arxml_new.py

@@ -0,0 +1,113 @@
+"""Create a new, empty ARXML file that arxml_edit can then fill.
+
+The .arxml guard blocks hand-written ARXML, and arxml_edit only adds under an existing package, so without
+this an agent on a project with no ARXML yet (or one that needs a new SWC / extract file) has no way in.
+
+    arxml_new(root, "Input/SWC_DoorMonitor.arxml", ["/Swcs/DoorMonitor", "/Interfaces"])
+
+writes the R25-11 (AUTOSAR_00054) header and the given AR-PACKAGE tree, nothing else, strictly re-loads it
+with autosar-data, and refuses to overwrite an existing file or to write outside the project.
+"""
+from __future__ import annotations
+
+import os
+import re
+from typing import Optional
+
+from .edit import schema_check
+from .xmltree import escape
+
+NS = "http://autosar.org/schema/r4.0"
+# The release this pack targets (R25-11 = AUTOSAR_00054); older ones only on request.
+DEFAULT_SCHEMA = "AUTOSAR_00054"
+_NAME = re.compile(r"[A-Za-z][A-Za-z0-9_]{0,127}\Z")  # SHORT-NAME (TPS_GST: identifier, starts with a letter)
+
+
+def _schema(version: Optional[str]) -> str:
+    v = (version or DEFAULT_SCHEMA).strip()
+    if re.fullmatch(r"\d{5}", v):
+        v = "AUTOSAR_" + v
+    if not re.fullmatch(r"AUTOSAR_\d{5}", v):
+        raise ValueError(f"schema {version!r}: expected AUTOSAR_000NN (default {DEFAULT_SCHEMA} = R25-11)")
+    return v
+
+
+def _tree(packages: list) -> dict:
+    """{"Swcs": {"DoorMonitor": {}}, ...} from AUTOSAR package paths."""
+    tree: dict = {}
+    for p in packages:
+        segs = [s for s in str(p).strip().strip("/").split("/") if s]
+        if not segs:
+            raise ValueError(f"package path {p!r} is empty")
+        for s in segs:
+            if not _NAME.match(s):
+                raise ValueError(f"package {p!r}: {s!r} is not a valid SHORT-NAME (letters, digits, _; starts with "
+                                 "a letter)")
+        node = tree
+        for s in segs:
+            node = node.setdefault(s, {})
+    return tree
+
+
+def render(packages: list, schema: str = DEFAULT_SCHEMA) -> str:
+    lines = ['<?xml version="1.0" encoding="UTF-8"?>',
+             f'<AUTOSAR xmlns="{NS}" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
+             f'xsi:schemaLocation="{NS} {schema}.xsd">']
+
+    def pkgs(tree: dict, depth: int):
+        lines.append("  " * depth + "<AR-PACKAGES>")
+        for name, sub in tree.items():
+            lines.append("  " * (depth + 1) + "<AR-PACKAGE>")
+            lines.append("  " * (depth + 2) + f"<SHORT-NAME>{escape(name)}</SHORT-NAME>")
+            if sub:
+                pkgs(sub, depth + 2)
+            lines.append("  " * (depth + 1) + "</AR-PACKAGE>")
+        lines.append("  " * depth + "</AR-PACKAGES>")
+
+    pkgs(_tree(packages), 1)
+    lines.append("</AUTOSAR>")
+    return "\n".join(lines) + "\n"
+
+
+def arxml_new(root: str, file: str, packages: list, schema: Optional[str] = None, dry_run: bool = False) -> dict:
+    if not file:
+        return {"ok": False, "error": "file is required (project-relative path ending in .arxml)"}
+    if not str(file).lower().endswith(".arxml"):
+        return {"ok": False, "error": f"{file}: the file name must end in .arxml"}
+    if isinstance(packages, str):
+        packages = [packages]
+    if not packages:
+        return {"ok": False, "error": "give at least one package path, e.g. [\"/Swcs\", \"/Interfaces\"] -- an ARXML "
+                                      "file needs an AR-PACKAGE to hold elements"}
+    root_abs = os.path.realpath(root)
+    path = os.path.realpath(os.path.join(root_abs, file))
+    if os.path.commonpath([root_abs, path]) != root_abs:
+        return {"ok": False, "error": f"{file} is outside the project directory {root}"}
+    rel = os.path.relpath(path, root_abs)
+    if os.path.exists(path):
+        return {"ok": False, "error": f"{rel} already exists; add to it with arxml_edit instead"}
+    try:
+        text = render(packages, _schema(schema))
+    except ValueError as e:
+        return {"ok": False, "error": str(e)}
+    err = schema_check(path, text.encode("utf-8"))
+    if err:  # a bug here, not the caller's: never write a file that does not load
+        return {"ok": False, "error": f"internal: generated file does not load: {err}"}
+    if not dry_run:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        tmp = path + ".arxml-tmp"
+        with open(tmp, "w", encoding="utf-8", newline="\n") as fh:
+            fh.write(text)
+        os.replace(tmp, path)
+    pk = sorted({"/" + "/".join(s.strip("/").split("/")[:i + 1])
+                 for s in packages for i in range(len([x for x in str(s).strip("/").split("/") if x]))})
+    return {"ok": True, "written": not dry_run, "file": rel, "schema": _schema(schema), "packages": pk,
+            "schemaChecked": err is None and _has_ad(), "content": text}
+
+
+def _has_ad() -> bool:
+    try:
+        import autosar_data  # type: ignore # noqa: F401
+        return True
+    except Exception:  # noqa: BLE001
+        return False

package/python/ecuc_engine/cli.py

@@ -71,6 +71,13 @@ def main(argv=None) -> int:
     ae = sub.add_parser("arxml-edit")
     ae.add_argument("--ops", required=True)
     ae.add_argument("--dry-run", action="store_true")
+    an = sub.add_parser("arxml-new", help="create an empty ARXML file (header + AR-PACKAGE tree) for arxml-edit")
+    an.add_argument("--file", required=True, help="project-relative path, ending in .arxml")
+    an.add_argument("--package", action="append", default=[], help="AUTOSAR package path, e.g. /Swcs/DoorMonitor")
+    an.add_argument("--schema", help="AUTOSAR_000NN (default AUTOSAR_00054 = R25-11)")
+    an.add_argument("--dry-run", action="store_true")
+    ac = sub.add_parser("arxml-check", help="verify non-ECUC ARXML: strict schema + every reference and its DEST")
+    ac.add_argument("--file", action="append", default=[], help="limit to files whose path contains this")
     fd = sub.add_parser("find")
     fd.add_argument("--module")
     fd.add_argument("--container-def", dest="container_def")
@@ -116,7 +123,7 @@ def main(argv=None) -> int:
     bc.add_argument("--task", required=True, help="task text, @file, or - for stdin")
     bc.add_argument("--budget-tokens", dest="budget_tokens", type=int, default=24000)
     bc.add_argument("--no-history", dest="history", action="store_false")
-    for p in (r, e, v, d, au, so, vs, si, fd, cx, ae, asg, cg, cd, ra, vr, bc):  # allow --json after the subcommand too
+    for p in (r, e, v, d, au, so, vs, si, fd, cx, ae, an, ac, 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()
@@ -135,8 +142,16 @@ def run(a) -> dict:
     if a.cmd in ("edit", "arxml-edit"):
         try:
             a.ops = _ops(a.ops)
+        except json.JSONDecodeError as ex:
+            at = f" near: ...{ex.doc[max(0, ex.pos - 80):ex.pos]} <<HERE>> {ex.doc[ex.pos:ex.pos + 40]}..." if ex.doc else ""
+            return {"error": f"ops is not valid JSON ({ex.msg} at char {ex.pos}){at}. Nothing was changed. Send ops "
+                             "as a JSON array of objects (not one long string), and split a very large edit into "
+                             "several calls."}
         except (ValueError, OSError) as ex:
             return {"error": f"ops is not valid JSON: {ex}"}
+    if a.cmd == "arxml-new":  # no Project: the directory may hold no ARXML at all yet
+        from .arxml_new import arxml_new
+        return arxml_new(a.root, a.file, a.package, schema=a.schema, dry_run=a.dry_run)
     if a.cmd == "diff":
         from .diff import diff
         root = os.path.abspath(a.root)
@@ -178,7 +193,7 @@ def run(a) -> dict:
         from .specids import check_ids
         return check_ids(os.path.abspath(a.root), a.ids, docs=a.docs)
     from .model import Project
-    project = Project(a.root, config_files=a.config, def_files=a.defs, load_input=a.cmd in ("validate", "edit", "find", "crosscheck", "signal-owners", "arxml-edit", "add-signal"))
+    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", "arxml-check"))
     if a.cmd == "add-signal":
         from .add_signal import AddSignalError, add_signal
         try:
@@ -187,6 +202,9 @@ def run(a) -> dict:
                               transfer_property=a.transfer_property, dry_run=a.dry_run)
         except AddSignalError as ex:
             return {"error": str(ex), "written": False}
+    if a.cmd == "arxml-check":
+        from .arxml_edit import arxml_check
+        return arxml_check(project, a.file or None)
     if a.cmd == "arxml-edit":
         from .arxml_edit import arxml_edit
         return arxml_edit(project, a.ops, dry_run=a.dry_run)

package/python/ecuc_engine/codegen/binding.py

@@ -19,6 +19,9 @@ Path language (a list of steps, evaluated left to right from the row container):
                         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)
+  child                 the one chosen sub-container of a choice container (any def)
+  def                   def short name of the current container (terminal), e.g. which choice is configured
+  count:<Def>           number of direct sub-containers of def <Def> (terminal)
   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.
@@ -29,7 +32,12 @@ Module binding keys besides tables/objects/macros:
   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}),
+Table keys besides name/type/rows/fields: order (sort param), contiguous (that param must be exactly
+  0..n-1 after sorting, e.g. a position index), designated, per (<ParentDef>: one table per parent instance,
+  rows = its direct <Def> children, "{}" in name = parent SHORT-NAME; a parent with no rows is an error,
+  C has no empty arrays). unsupported entries may set "max": N (more than N containers is the error).
+Field keys: path, default, enum (literal or token -> C token), scale (multiply, must give an integer:
+  seconds -> ms), 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>}).
 """
@@ -147,6 +155,16 @@ class Eval:
                         (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 == "child":
+                kids = list(cur.children)
+                if len(kids) > 1:
+                    raise BindingError(f"{cur.path}: path step child: {len(kids)} sub-containers, expected the one "
+                                       "chosen sub-container of a choice container")
+                cur = kids[0] if kids else None
+            elif op == "def":
+                return ("token", cur.def_name)
+            elif op == "count":
+                return ("token", W.c_uint(len(cur.sub(arg))))
             elif op == "sym":
                 s = self.cg.symbol(cur)
                 if s and self.ctx is not None:
@@ -231,6 +249,12 @@ class Eval:
                 s = self.ctx.xsym(v, self.mc, self.used_mips)
             return (s, "")
         if kind == "token":
+            if "enum" in spec:
+                if v not in spec["enum"]:
+                    raise BindingError(f"{row.path}: {spec['path']} = {v} is not supported by the static code "
+                                       f"(the {self.mc.name} binding maps only {', '.join(spec['enum'])})")
+                e = spec["enum"][v]
+                return (W.c_uint(e) if isinstance(e, int) else str(e), v)
             if fmt and fmt not in ("hex", "int"):
                 return (fmt.replace("{MIP}", v.upper()).replace("{Mip}", v).replace("{}", v), "")
             return (v, "")
@@ -244,6 +268,8 @@ class Eval:
             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 "scale" in spec:
+            return (self._scaled(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:
@@ -261,6 +287,20 @@ class Eval:
             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 _scaled(self, row: Container, raw, spec: dict) -> str:
+        """value * scale as an integer (e.g. LinIfDelay seconds -> ms); a value that is not a whole multiple is
+        an error, never rounded silently."""
+        from ..values import parse_float
+        v = parse_float(str(raw).strip())
+        if v is None:
+            raise BindingError(f"{row.path}: {spec.get('name')} = {raw} is not a number")
+        x = v * spec["scale"]
+        n = int(round(x))
+        if abs(x - n) > 1e-6 * max(1.0, abs(x)):
+            raise BindingError(f"{row.path}: {spec['path']} = {str(raw).strip()} is not a whole multiple of "
+                               f"1/{spec['scale']}; the static code's {spec.get('name')} field holds an integer")
+        return W.c_uint(n)
+
     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)."""

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

@@ -373,6 +373,124 @@
           "init": ["Com_TxSignalInfo", "Com_RxSignalInfo", "Com_TxIPduInfo", "Com_RxIPduInfo"]
         }
       ]
+    },
+    "LinIf": {
+      "detect": {"header": "LinIf.h", "contains": "LinIf_FrameType"},
+      "sourceIncludes": ["LinIf.h"],
+      "sets": {"TxPdus": {"rows": "LinIfTxPdu"}},
+      "handleLayout": [{"param": "LinIfTxPduId", "sets": ["TxPdus"]}],
+      "require": [
+        {
+          "rows": "LinIfFrame",
+          "path": "param:LinIfFrameType",
+          "in": ["UNCONDITIONAL"],
+          "why": "LinIf_FrameType has no frame type: LinIf.c sends every slot as an unconditional frame (no sporadic, event-triggered, diagnostic MRF/SRF or node configuration frames)"
+        },
+        {
+          "rows": "LinIfFrame",
+          "path": ["sub:LinIfPduDirection", "child", "def"],
+          "in": ["LinIfTxPdu", "LinIfRxPdu"],
+          "why": "LinIf_FrameType.Direction is LINIF_DIR_TX or LINIF_DIR_RX only (no slave-to-slave or internal PDUs)"
+        },
+        {
+          "rows": "LinIfScheduleTable",
+          "path": "param:LinIfRunMode",
+          "in": ["RUN_CONTINUOUS"],
+          "why": "LinIf_ScheduleType has no run mode: LinIf_MainFunction cycles its entries continuously"
+        }
+      ],
+      "unsupported": [
+        {
+          "rows": "LinIfChannel",
+          "max": 1,
+          "why": "LinIf_ConfigType has one frame and one schedule list and no channel field"
+        },
+        {"rows": "LinIfSlave", "why": "LinIf.h is a master-node LinIf (LinIf_MainFunction runs the schedule)"},
+        {"rows": "LinIfSubstitutionFrames", "why": "LinIf_FrameType has no substitution frame list"},
+        {"rows": "LinIfFixedFrameSdu", "why": "LinIf_FrameType has no fixed response SDU"}
+      ],
+      "macros": [
+        {"name": "LINIF_NUMBER_OF_CHANNELS", "value": "count:LinIfChannel"},
+        {"name": "LINIF_NUMBER_OF_TX_PDUS", "value": "count:LinIfTxPdu"},
+        {"name": "LINIF_NUMBER_OF_FRAMES", "value": "count:LinIfFrame"},
+        {"name": "LINIF_NUMBER_OF_SCHEDULES", "value": "count:LinIfScheduleTable"}
+      ],
+      "tables": [
+        {
+          "name": "LinIf_Frames",
+          "type": "LinIf_FrameType",
+          "qualifier": "LINIF_CONST",
+          "static": true,
+          "rows": "LinIfFrame",
+          "size": "LINIF_NUMBER_OF_FRAMES",
+          "doc": "LinIfFrame in configuration order; LinIf_EntryType.FrameIndex indexes this table",
+          "fields": [
+            {"name": "FrameId", "path": "param:LinIfFrameId", "fmt": "hex"},
+            {
+              "name": "Length",
+              "path": [
+                ["sub:LinIfPduDirection", "sub:LinIfTxPdu", "ref:LinIfTxPduRef", "param:PduLength"],
+                ["sub:LinIfPduDirection", "sub:LinIfRxPdu", "ref:LinIfRxPduRef", "param:PduLength"]
+              ]
+            },
+            {
+              "name": "Checksum",
+              "path": "param:LinIfChecksumType",
+              "enum": {"CLASSIC": "LINIF_CHECKSUM_CLASSIC", "ENHANCED": "LINIF_CHECKSUM_ENHANCED"}
+            },
+            {
+              "name": "Direction",
+              "path": ["sub:LinIfPduDirection", "child", "def"],
+              "enum": {"LinIfTxPdu": "LINIF_DIR_TX", "LinIfRxPdu": "LINIF_DIR_RX"}
+            },
+            {
+              "name": "PduRPduId",
+              "path": [
+                ["sub:LinIfPduDirection", "sub:LinIfTxPdu", "peer:LinIfTxPduRef@PduR/PduRDestPdu", "sym"],
+                ["sub:LinIfPduDirection", "sub:LinIfRxPdu", "peer:LinIfRxPduRef@PduR/PduRSrcPdu", "sym"]
+              ]
+            }
+          ]
+        },
+        {
+          "name": "LinIf_Entries_{}",
+          "type": "LinIf_EntryType",
+          "qualifier": "LINIF_CONST",
+          "static": true,
+          "per": "LinIfScheduleTable",
+          "rows": "LinIfEntry",
+          "order": "LinIfEntryIndex",
+          "contiguous": true,
+          "doc": "{} slots in LinIfEntryIndex order (ECUC_LinIf_00011: position in the schedule table)",
+          "fields": [
+            {"name": "FrameIndex", "path": ["ref:LinIfFrameRef", "index"]},
+            {"name": "DelayMs", "path": "param:LinIfDelay", "scale": 1000}
+          ]
+        },
+        {
+          "name": "LinIf_Schedules",
+          "type": "LinIf_ScheduleType",
+          "qualifier": "LINIF_CONST",
+          "static": true,
+          "rows": "LinIfScheduleTable",
+          "size": "LINIF_NUMBER_OF_SCHEDULES",
+          "designated": true,
+          "doc": "indexed by LinIfScheduleTableIndex",
+          "comment": "name",
+          "fields": [
+            {"name": "Entries", "path": "name", "fmt": "LinIf_Entries_{}"},
+            {"name": "NumEntries", "path": "count:LinIfEntry"}
+          ]
+        }
+      ],
+      "objects": [
+        {
+          "name": "LinIf_Config",
+          "type": "LinIf_ConfigType",
+          "qualifier": "LINIF_CONST",
+          "init": ["LinIf_Frames", "LinIf_Schedules", "LINIF_NUMBER_OF_FRAMES", "LINIF_NUMBER_OF_SCHEDULES"]
+        }
+      ]
     }
   }
 }