@h2loop/autosar 1.0.1 → 1.2.0

package/python/ecuc_engine/sysmodel.py

@@ -0,0 +1,152 @@
+"""Index of the non-ECUC ARXML (System / ECU extract, SWCs, BSWMD) for cross-checks.
+
+One expat pass per file. Every identifiable (element with a SHORT-NAME) becomes an Ident with its tag,
+file, line, the identifiable children, and the leaf values *of its own* (descendants that are not
+inside a nested identifiable): e.g. an I-SIGNAL-TO-I-PDU-MAPPING gets {"I-SIGNAL-REF": [...],
+"START-POSITION": ["16"], "PACKING-BYTE-ORDER": [...]}. References keep their DEST type.
+Nothing is keyed by project-specific names; rules navigate by AUTOSAR metaclass and reference.
+"""
+from __future__ import annotations
+
+import xml.parsers.expat as expat
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Ident:
+    path: str
+    tag: str
+    file: str
+    line: int
+    values: dict = field(default_factory=dict)  # leaf tag -> [text]
+    dests: dict = field(default_factory=dict)  # ref tag -> [DEST]
+    children: list = field(default_factory=list)  # child identifiable paths
+    parent: Optional[str] = None
+
+    def one(self, tag: str) -> Optional[str]:
+        v = self.values.get(tag)
+        return v[0] if v else None
+
+
+class SystemIndex:
+    def __init__(self):
+        self.by_path: dict = {}
+        self.by_tag: dict = {}
+        self._refs_to: Optional[dict] = None
+
+    def add_file(self, path: str):
+        try:
+            with open(path, "rb") as fh:
+                data = fh.read()
+        except OSError:
+            return
+        p = expat.ParserCreate()
+        p.buffer_text = True
+        stack: list = []  # [tag, Ident|None, text parts, attrs, line]
+        idents: list = []  # current chain of Idents
+
+        def start(name, attrs):
+            stack.append([name.rsplit(":", 1)[-1], None, [], attrs, p.CurrentLineNumber])
+
+        def chars(t):
+            if stack:
+                stack[-1][2].append(t)
+
+        def end(name):
+            tag, ident, text, attrs, line = stack.pop()
+            if tag == "SHORT-NAME" and stack:
+                owner = stack[-1]
+                if owner[1] is None:
+                    parent = idents[-1] if idents else None
+                    sn = "".join(text).strip()
+                    ip = f"{parent.path if parent else ''}/{sn}"
+                    owner[1] = Ident(ip, owner[0], path, owner[4], parent=parent.path if parent else None)
+                    if parent is not None:
+                        parent.children.append(ip)
+                    idents.append(owner[1])
+                    self.by_path.setdefault(ip, owner[1])
+                    self.by_tag.setdefault(owner[0], []).append(owner[1])
+                return
+            if ident is not None:
+                idents.pop()
+                return
+            if idents:  # a leaf value of the innermost enclosing identifiable
+                txt = "".join(text).strip()
+                if txt:
+                    cur = idents[-1]
+                    cur.values.setdefault(tag, []).append(txt)
+                    if "DEST" in attrs:
+                        cur.dests.setdefault(tag, []).append(attrs["DEST"])
+
+        p.StartElementHandler = start
+        p.EndElementHandler = end
+        p.CharacterDataHandler = chars
+        try:
+            p.Parse(data, True)
+        except expat.ExpatError:
+            pass
+        self._refs_to = None
+
+    def get(self, path: Optional[str]) -> Optional[Ident]:
+        return self.by_path.get(path.strip()) if path else None
+
+    def tags(self, tag: str) -> list:
+        return self.by_tag.get(tag, [])
+
+    def refs_to(self, path: str) -> list:
+        """Idents that reference ``path`` (any *-REF leaf)."""
+        if self._refs_to is None:
+            idx: dict = {}
+            for i in self.by_path.values():
+                for t, vals in i.values.items():
+                    if t.endswith("-REF") or t.endswith("-TREF"):
+                        for v in vals:
+                            idx.setdefault(v, []).append(i)
+            self._refs_to = idx
+        return self._refs_to.get(path, [])
+
+    def foreign(self) -> dict:
+        return {p: (i.tag, i.line, i.file) for p, i in self.by_path.items()}
+
+    # ---- navigation helpers (by metaclass, not by name) ----
+    def ipdus_of_triggering(self, path: Optional[str]) -> list:
+        """A PDU-TRIGGERING or FRAME-TRIGGERING (any bus) -> system I-PDU paths it carries."""
+        t = self.get(path)
+        if t is None:
+            return []
+        out = []
+        for ref in t.values.get("I-PDU-REF", []):
+            out.append(ref)
+        for pt in t.values.get("PDU-TRIGGERING-REF", []):
+            out.extend(self.ipdus_of_triggering(pt))
+        if not out:
+            fr = self.get(t.one("FRAME-REF"))
+            if fr is not None:
+                for m in fr.children:
+                    mi = self.get(m)
+                    if mi is not None:
+                        out.extend(mi.values.get("PDU-REF", []))
+        seen, res = set(), []
+        for x in out:
+            if x not in seen:
+                seen.add(x)
+                res.append(x)
+        return res
+
+    def channel_of(self, path: Optional[str]) -> Optional[str]:
+        """Physical channel (the identifiable holding the triggering) of a PDU/FRAME-TRIGGERING."""
+        t = self.get(path)
+        return t.parent if t is not None else None
+
+    def signals_of_ipdu(self, ipdu: str) -> list:
+        """I-SIGNAL paths mapped into a system I-PDU (via its I-SIGNAL-TO-I-PDU-MAPPING children)."""
+        i = self.get(ipdu)
+        if i is None:
+            return []
+        out = []
+        for c in i.children:
+            ci = self.get(c)
+            if ci is not None and ci.values.get("I-SIGNAL-REF"):
+                out.extend(ci.values["I-SIGNAL-REF"])
+        return sorted(set(out))

package/python/ecuc_engine/validate.py

@@ -64,7 +64,8 @@ def _resolve_def(defs: D.DefIndex, ref: Optional[str]) -> Optional[D.DefNode]:
     return None
 
 
-def validate(project: Project, files: Optional[list] = None, module: Optional[str] = None) -> dict:
+def validate(project: Project, files: Optional[list] = None, module: Optional[str] = None,
+             check_generated: Optional[bool] = None, code: bool = True) -> dict:
     defs = project.defs
     dg = Diags(project)
     warned_modules = set()
@@ -211,6 +212,18 @@ def validate(project: Project, files: Optional[list] = None, module: Optional[st
 
     from .rules import run_rules
     dg.items.extend(run_rules(project))
+    from .probe import load_cfg
+    cfg = load_cfg(project.root)
+    if code:  # configuration completeness seen from the C code: handles used but not configured
+        from .audit import audit
+        for f in audit(project).get("findings", []):
+            if f["rule"] == "H2L-API-002":
+                dg.items.append({"file": f["file"], "line": f["line"], "path": "", "rule": f["rule"],
+                                 "severity": f["severity"], "message": f"{f['call']}: {f['message']} [{f['cite']}]",
+                                 "defRef": None})
+    from . import gen
+    if check_generated if check_generated is not None else gen.default_on(project, cfg):
+        dg.items.extend(gen.check(project, cfg))
 
     items = dg.items
     loaded = sorted(project.files)
@@ -228,7 +241,7 @@ def validate(project: Project, files: Optional[list] = None, module: Optional[st
                                              f"file(s) [{sample or 'none'}]; NOTHING was validated for it. Pass a file, "
                                              f"directory or glob relative to {project.root}, or omit 'files'."))
         want = {project.rel(f) for f in matched}
-        items = [i for i in items if i["file"] in want]
+        items = [i for i in items if i["file"] in want or not i["file"].lower().endswith(".arxml")]
         scope["filter"] = {"files": list(files), "matched": sorted(want)[:200], "matchedCount": len(want)}
     if module:
         names = {m.name for m in project.modules} | {(m.def_ref or "").rsplit("/", 1)[-1] for m in project.modules}

package/python/ecuc_engine/values.py

@@ -144,3 +144,29 @@ def from_json(d: Optional[DefNode], v) -> str:
     if d is not None and d.kind == "BOOLEAN" and s.lower() in ("true", "false"):
         s = s.lower()
     return s
+
+
+def hex_str(v: int) -> str:
+    return f"-0x{-v:X}" if v < 0 else f"0x{v:X}"
+
+
+DEST_KIND = {"ECUC-INTEGER-PARAM-DEF": "INTEGER", "ECUC-FLOAT-PARAM-DEF": "FLOAT", "ECUC-BOOLEAN-PARAM-DEF": "BOOLEAN"}
+
+
+def int_forms(d: Optional[DefNode], raw: Optional[str], is_ref: bool, numerical: bool,
+              dest: Optional[str] = None) -> Optional[dict]:
+    """{"dec": int, "hex": "0x..."} for an integer-typed value (def kind INTEGER; without loaded defs the
+    DEFINITION-REF DEST, else a numerical value whose text is an integer), else None. Computed here so answers
+    never convert bases by hand."""
+    if raw is None or is_ref:
+        return None
+    k = d.kind if d is not None else DEST_KIND.get(dest or "") or ("NUMBER" if numerical else None)
+    if k not in ("INTEGER", "NUMBER"):
+        return None
+    t = raw.strip()
+    if t.lower() in ("true", "false"):
+        return None
+    v = parse_int(t)
+    if v is None:
+        return None
+    return {"dec": v, "hex": hex_str(v)}