@h2loop/autosar 1.2.1 → 1.4.0

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

@@ -0,0 +1,53 @@
+"""LinIf: LinIf_Cfg.h / LinIf_PBcfg.c.
+
+Def-driven (generic emitter): the LinIfGeneral switches and the TPS_ECUC_02108 / SWS_BSW_00200 symbols
+LinIfConf_LinIfTxPdu_<Pdu> (LinIfTxPduId, the handle PduR passes to LinIf_Transmit) and
+LinIfConf_LinIfScheduleTable_<Table> (LinIfScheduleTableIndex, used with LinIf_ScheduleRequest).
+
+The static LinIf's own layout (frame table, one entry list per schedule table, schedule table list,
+root config object) comes from its binding (bindings/*.json): channels, frames with their EcuC PDU
+length and PduR handle (via the shared EcucPduCollection/Pdu), schedule entries in LinIfEntryIndex
+order with LinIfDelay, schedule tables by LinIfScheduleTableIndex. Configuration the binding cannot
+represent (non-unconditional frames, slave nodes, more channels than the static code has, ...) is
+listed in the binding's `require` / `unsupported` and fails generation.
+
+This module adds only the SWS_LinIf consistency rules that hold for any static code:
+  * a schedule entry (LinIfEntry/LinIfFrameRef) must reference a frame of the schedule table's own
+    channel (ECUC_LinIf_00016; schedule tables are per channel, ECUC_LinIf_00365);
+  * the LinIfFrameId of the unconditional frames of a channel must be unique (one publisher per
+    frame identifier on a LIN cluster).
+"""
+from __future__ import annotations
+
+from ..registry import Generator, register
+
+
+def _channel(c):
+    while c is not None and c.def_name != "LinIfChannel":
+        c = c.parent
+    return c
+
+
+@register("LinIf")
+class LinIf(Generator):
+    std_header = "ComStack_Types.h"
+
+    def specific(self, mo):
+        for e in self.cg.instances(self.mc, "LinIfEntry"):
+            fr = self.cg.target(e.value("LinIfFrameRef"))
+            if fr is None:
+                mo.errors.append(f"{e.path}: LinIfFrameRef is not set or does not resolve to a LinIfFrame")
+            elif _channel(fr) is not _channel(e):
+                mo.errors.append(f"{e.path}: LinIfFrameRef points to {fr.path}, a frame of another channel "
+                                 f"(schedule tables are per channel, ECUC_LinIf_00365)")
+        for ch in self.cg.instances(self.mc, "LinIfChannel"):
+            seen: dict = {}
+            for fr in ch.sub("LinIfFrame"):
+                if (fr.text("LinIfFrameType") or "").strip() != "UNCONDITIONAL":
+                    continue
+                fid = (fr.text("LinIfFrameId") or "").strip()
+                if fid in seen:
+                    mo.errors.append(f"{fr.path}: LinIfFrameId {fid} is also used by {seen[fid]} on channel "
+                                     f"{ch.name}; unconditional frame identifiers must be unique per channel")
+                else:
+                    seen[fid] = fr.name

package/python/ecuc_engine/codegen/registry.py

@@ -98,10 +98,11 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
                              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:
+        mx = un.get("max", 0)
+        if len(rows) > mx:
             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', '')}")
+                             f"represent{f' (at most {mx})' if mx else ''}: {un.get('why', '')}")
     for inc in mb.get("sourceIncludes", []):
         mo.include(inc)
     macros = []
@@ -121,41 +122,9 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
             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 = 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"]:
-                v, _ = ev.field(r, f)
-                vals.append(v)
-                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 = ""
-            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"):
-                lines.append(f"  {lead}{vals[0]} /* {cm} */")
-            else:
-                lines.append(f"  {lead}{{ {', '.join(vals)} }} /* {cm} */")
-        st = "static " if t.get("static") else ""
-        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};")
-        pending.append(("table", ev.rank, body, externs))
+    for t0 in mb.get("tables", []):
+        for t, rows in _table_instances(cg, mo, ev, t0, sets):
+            _emit_table(cg, mo, ev, t, rows, values, pending)
     objects = mb.get("objects", [])
     if objects:
         # a root config object points at the (static) tables and buffers, so they all live in its file:
@@ -173,6 +142,67 @@ def apply_binding(cg, mo: E.ModuleOutput, mb: dict, ext: Optional[dict] = None):
     mo.used_mips |= ev.used_mips
 
 
+def _table_instances(cg, mo, ev, t: dict, sets: dict) -> list:
+    """[(table spec, rows)]: one table, or one per parent instance for a "per" table."""
+    from ..values import parse_int
+    num = lambda r: parse_int(r.text(t["order"]) or "")  # noqa: E731
+    out = []
+    if t.get("per"):
+        specs = []
+        for par in cg.sorted_instances(mo.mc, t["per"]):
+            rows = par.sub(t["rows"])
+            if not rows:
+                raise B.BindingError(f"{par.path}: no {t['rows']} configured; {t['name'].replace('{}', par.name)} "
+                                     "would be an empty array, which C does not allow")
+            specs.append((dict(t, name=t["name"].replace("{}", par.name),
+                               doc=t.get("doc", t["rows"]).replace("{}", par.name)), rows))
+    else:
+        specs = [(t, ev.rows(t["rows"], sets))]
+    for spec, rows in specs:
+        if t.get("order"):
+            rows = sorted(rows, key=lambda r: (num(r) is None, num(r) or 0))
+        if t.get("contiguous"):
+            got = [num(r) for r in rows]
+            if got != list(range(len(rows))):
+                raise B.BindingError(f"{spec['name']}: {t['order']} of the {len(rows)} {t['rows']} rows must be exactly "
+                                     f"0..{len(rows) - 1} (table position), got {', '.join(map(str, got))}")
+        out.append((spec, rows))
+    return out
+
+
+def _emit_table(cg, mo, ev, t: dict, rows: list, values: dict, pending: list):
+    ev.rank = 1
+    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"]:
+            v, _ = ev.field(r, f)
+            vals.append(v)
+            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 = ""
+        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"):
+            lines.append(f"  {lead}{vals[0]} /* {cm} */")
+        else:
+            lines.append(f"  {lead}{{ {', '.join(vals)} }} /* {cm} */")
+    st = "static " if t.get("static") else ""
+    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};")
+    pending.append(("table", ev.rank, body, externs))
+
+
 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."""

package/skills/autosar/SKILL.md

@@ -21,6 +21,8 @@ in `Output/` is derived from it; in-house code in `Source/` calls the generated
 1. **Never hand-write or hand-edit ARXML** (no `write`/`edit`/`sed` on `.arxml`; the pack blocks them). Every change goes
    through `ecuc_edit`, which picks the value element, DEFINITION-REF/DEST and VALUE-REF DEST from
    the param defs and patches only the changed bytes. Reading raw ARXML for context is fine; prefer `ecuc_read`.
+   A **new** System-extract / SWC / interface file is started with `arxml_new` and filled with `arxml_edit` (recipe
+   below). Do not write one with Python (`autosar_data` scripts, ElementTree) or a temp file renamed to `.arxml`.
 2. **Validate after every edit**: `ecuc_validate` (scoped with `files`/`module` if large). Fix
    every error you introduced before moving on; report pre-existing ones separately.
 3. **Cite** the AUTOSAR path, the DEFINITION-REF and file:line for every element you discuss or change —
@@ -60,6 +62,8 @@ in `Output/` is derived from it; in-house code in `Source/` calls the generated
 | Values of a module/container | `ecuc_read path=… depth=…` |
 | All containers matching a condition / referencing X / referenced by Y | `ecuc_find` |
 | Cross-check one module against the extract, C types and memory | `ecuc_crosscheck module=…` |
+| Start a NEW System extract / SWC / interface .arxml file | `arxml_new file=… packages=[…]` |
+| Verify extract / SWC / interface files (schema + every reference + DEST) | `arxml_check` |
 | Edit System extract / SWC / interface XML | `arxml_edit` (DEST inferred, schema-ordered, refs checked) |
 | Add a signal end to end (ECUC + extract + DBC) | `autosar_add_signal` |
 | What may be set/added here (types, ranges, literals, multiplicity) | `ecuc_read path=… schema=true`, or a def path `/AUTOSAR/EcucDefs/<Mod>/…` |
@@ -87,6 +91,54 @@ in `Output/` is derived from it; in-house code in `Source/` calls the generated
 5. **Never conclude "no faults" from a single validate call**, and never finish with a failing validation: after
    ANY edit run `ecuc_validate`; if it fails, fix it before answering.
 
+## Every change: ground → decide → change → verify until clean
+Do not decide what to change from memory or from the prompt alone. Each change goes through four steps, in order:
+1. **Ground (facts first).** Gather every fact the change depends on from the tools, not from recall:
+   `autosar_build_context` (for a runnable), `ecuc_read … schema=true` (what may be set: types, ranges, literals,
+   multiplicity), `ecuc_find` / `autosar_config_lookup` (what already exists and references what),
+   `ecuc_crosscheck` (extract ↔ ECUC ↔ C), the spec text (`autosar_spec_id_check` for any requirement ID you cite).
+   Write the facts down in a short list with their source (file:line or tool), including the existing elements you
+   will reuse or reference.
+2. **Decide.** From those facts only, write the plan as a todo list: every element to add/change, in dependency order
+   (reference targets first), and which tool does each. A link you could not ground (a value, an id, a target) is an
+   open question: look it up, or ask; never fill it in with a plausible guess.
+3. **Change** with the structured tools only (`ecuc_edit`, `arxml_new` + `arxml_edit`, `autosar_add_signal`). Prefer
+   one call per coherent change; nothing is written if any op fails.
+4. **Verify → fix → verify, until clean.** `arxml_check` (extract/SWC files) and `ecuc_validate` (ECUC), then
+   `autosar_generate` + `autosar_codegen_diff` / `autosar_build` and `autosar_verify_rte` where the project has them.
+   On any problem: read it, go back to step 1 for that fact, fix with the structured tools, verify again. Repeat until
+   every check is clean. Then re-read the request and tick each todo against the evidence. Never report done with a
+   failing or unrun check; if something cannot be made clean, say exactly what and why.
+
+## New ARXML file (SWC, interface, data types, extract) from nothing
+1. `arxml_new file="Input/SWC_X.arxml" packages=["/DataTypes", "/Interfaces", "/Swcs"]` — the R25-11 header and
+   empty packages, strictly checked. It refuses to overwrite; extend existing files with `arxml_edit` instead.
+2. ONE `arxml_edit` call with the elements in dependency order (a reference target must be added earlier in the same
+   call): base type → implementation data type → interface → SWC with ports → `SWC-INTERNAL-BEHAVIOR` → runnables
+   (with data accesses) → events. Each op is `{op:"add", parent_path, element:<XML tag>, short_name, values:{...}}`;
+   references are written `"->/Path/To/Target"` and get their DEST automatically. Example (shortened):
+   ```
+   {op:"add", parent_path:"/DataTypes", element:"SW-BASE-TYPE", short_name:"uint8_base",
+    values:{"CATEGORY":"FIXED_LENGTH", "BASE-TYPE-SIZE":8, "BASE-TYPE-ENCODING":"NONE"}}
+   {op:"add", parent_path:"/DataTypes", element:"IMPLEMENTATION-DATA-TYPE", short_name:"uint8",
+    values:{"CATEGORY":"VALUE", "SW-DATA-DEF-PROPS":{"SW-DATA-DEF-PROPS-VARIANTS":{"SW-DATA-DEF-PROPS-CONDITIONAL":
+      {"BASE-TYPE-REF":"->/DataTypes/uint8_base"}}}}}
+   {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"}]}}}
+   {op:"add", parent_path:"/Swcs", element:"APPLICATION-SW-COMPONENT-TYPE", short_name:"X",
+    values:{"PORTS":{"P-PORT-PROTOTYPE":{"SHORT-NAME":"PpX", "PROVIDED-INTERFACE-TREF":"->/Interfaces/If_X"}}}}
+   {op:"add", parent_path:"/Swcs/X", element:"SWC-INTERNAL-BEHAVIOR", short_name:"IB"}
+   {op:"add", parent_path:"/Swcs/X/IB", element:"RUNNABLE-ENTITY", short_name:"X_Run10ms", values:{"SYMBOL":"X_Run10ms",
+    "DATA-WRITE-ACCESSS":{"VARIABLE-ACCESS":{"SHORT-NAME":"W_Val", "ACCESSED-VARIABLE":{"AUTOSAR-VARIABLE-IREF":
+      {"PORT-PROTOTYPE-REF":"->/Swcs/X/PpX", "TARGET-DATA-PROTOTYPE-REF":"->/Interfaces/If_X/Val"}}}}}}
+   {op:"add", parent_path:"/Swcs/X/IB", element:"TIMING-EVENT", short_name:"TE_10ms",
+    values:{"START-ON-EVENT-REF":"->/Swcs/X/IB/X_Run10ms", "PERIOD":0.01}}
+   ```
+3. If an op is rejected, read the error: it names the allowed sub-elements of that parent. Fix that op and resend
+   the call (nothing was written). Do not fall back to writing XML.
+4. `arxml_check` until it says CLEAN (and `ecuc_validate` / `autosar_generate` / `autosar_build` when the project
+   has ECUC and a generator). Then tick every requested element against the file.
+
 ## The loop
 `ecuc_read (schema) → ecuc_edit → ecuc_validate → autosar_generate → arxml_diff / inspect Output → autosar_build → autosar_trace (impact on Source/)`.
 Details and failure handling: `references/workflow.md`.

package/skills/autosar/references/codegen.md

@@ -37,12 +37,30 @@ ComUserCallback of type COM_RX_ACK / COM_TX_ACK; `call:comUserCallback`), or, fo
 callbacks, the RTE's `Rte_COMCbk_<sn>()` / `Rte_COMCbkTAck_<sn>()` when the RTE's Rte_Cbk.h declares it
 (`call:rteSignalCallback`). Nothing is bound from guesses: no declaration, no callback.
 
+## LinIf
+`LinIf_Cfg.h`: LinIfGeneral switches, `LinIfConf_LinIfTxPdu_*` (LinIfTxPduId, the handle PduR passes to `LinIf_Transmit`) and
+`LinIfConf_LinIfScheduleTable_*` (LinIfScheduleTableIndex) symbols (TPS_ECUC_02108 / SWS_BSW_00200), `LINIF_NUMBER_OF_*`.
+`LinIf_PBcfg.c` (binding): frame table in configuration order (LinIfFrameId, length from the EcuC Pdu, checksum, direction
+from the LinIfPduDirection choice, PduR dest (Tx) / src (Rx) handle via the shared EcuC Pdu), one entry list per schedule
+table (`per` table, LinIfEntryIndex order, which must be 0..n-1; FrameIndex = position of LinIfFrameRef's frame;
+LinIfDelay s -> ms, a non-whole ms is an error), schedule list indexed by LinIfScheduleTableIndex, root `LinIf_Config`.
+Tx PDU handles are laid out 0..n-1 (handleLayout; `LinIf_Transmit` range-checks them).
+Errors, never dropped: frame types other than UNCONDITIONAL, PDU directions other than Tx/Rx, RUN_ONCE schedules, more
+than one channel, slave nodes, substitution frames, fixed frame SDUs (stand-in binding); an entry whose frame belongs to
+another channel, duplicate unconditional LinIfFrameIds on a channel (any binding).
+
+Binding path/table additions used by LinIf: `child` (chosen sub-container of a choice), `def` (its def name, mapped with
+`enum`), `count:<Def>`, field `scale`, table `per` / `contiguous`, `unsupported[].max`.
+
 ## Known differences from the sample/large fixture oracle (all explained)
 | Item | Oracle | Ours | Why |
 |---|---|---|---|
 | `NvM_BlockDescriptorTable[*].RamBlockDataAddress` | `X` | `&X` (as configured) | ECUC_NvM_00482 value is the address expression; kept verbatim, same address for arrays |
 | Rx I-PDU `TimeoutTicks` with mixed signal timeouts | largest ComTimeout | smallest non-zero | SWS_Com_00291 |
 | `<MIP>_CFG_*` version macros, generic ComGeneral/NvMCommon/... switches, Dem/Fee tables | absent | extra | def-driven output the oracle does not emit |
+| LinIf entry list name | `LinIf_Sched_<Table>` | `LinIf_Entries_<Table>` | `static` table, internal linkage: not part of the LinIf.h contract |
+| `LinSMConf_LinSMSchedule_*` in `LinIf_Cfg.h` | present | absent (in `LinSM_Cfg.h`) | a `LinSMConf_` symbol belongs to the LinSM config header (SWS_BSW_00200) |
+| `LINIF_NUMBER_OF_SCHEDULES`, LinIfGeneral switches, version macros | absent | extra | def/binding-driven output the oracle does not emit |
 | SchM main function names | `Com_MainFunctionTx` | same | SWS_Com says `Com_MainFunctionTx_<shortName>`; the instance named like its def keeps the SIP's legacy name |
 
 ## Reading a diff