@anik-2/autosar 0.0.0-stage → 0.1.1

package/python/ecuc_engine/model.py

@@ -0,0 +1,330 @@
+"""Project discovery + the ECUC value model.
+
+Files are classified by content, not by name or folder: a file holding ECUC-MODULE-DEF is a
+param-def source, one holding ECUC-MODULE-CONFIGURATION-VALUES is configuration, any other .arxml
+is "input" (System extract, SWCs, BSWMD) and only indexed for foreign-reference resolution.
+`.hydron/autosar.json` can pin each set with globs: {"paramDefs": [...], "config": [...], "input": [...]}.
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import Optional
+
+from . import defs as D
+from .xmltree import Node, parse
+
+SKIP_DIRS = {".git", "node_modules", ".hydron", ".venv", "__pycache__", ".cache", ".idea", ".vscode"}
+PROJECT_CONFIG = os.path.join(".hydron", "autosar.json")
+
+MODULE_VALUES = "ECUC-MODULE-CONFIGURATION-VALUES"
+CONTAINER_VALUE = "ECUC-CONTAINER-VALUE"
+PARAM_VALUE_TAGS = {"ECUC-NUMERICAL-PARAM-VALUE", "ECUC-TEXTUAL-PARAM-VALUE", "ECUC-ADD-INFO-PARAM-VALUE"}
+REF_VALUE_TAGS = {"ECUC-REFERENCE-VALUE", "ECUC-INSTANCE-REFERENCE-VALUE"}
+
+
+@dataclass
+class ParamVal:
+    node: Node
+    def_ref: Optional[str]
+    def_dest: Optional[str]
+    tag: str
+    value: Optional[str]  # VALUE text / VALUE-REF text / None
+    value_node: Optional[Node]
+    dest: Optional[str] = None  # VALUE-REF DEST
+    is_auto: bool = False
+
+    @property
+    def name(self) -> str:
+        return (self.def_ref or "?").rsplit("/", 1)[-1]
+
+    @property
+    def is_ref(self) -> bool:
+        return self.tag in REF_VALUE_TAGS
+
+
+@dataclass
+class Elem:
+    """A module configuration (ECUC-MODULE-CONFIGURATION-VALUES) or a container value."""
+    node: Node
+    file: str
+    path: str
+    name: str
+    kind: str  # "module" | "container"
+    def_ref: Optional[str]
+    def_dest: Optional[str]
+    params: list = field(default_factory=list)  # ParamVal (params and refs)
+    children: list = field(default_factory=list)  # Elem
+    parent: Optional["Elem"] = None
+
+    @property
+    def line(self) -> int:
+        return self.node.line
+
+
+@dataclass
+class FileModel:
+    path: str
+    data: bytes
+    root: Node
+    elems: list  # top-level module Elems
+    identifiables: dict  # path -> (tag, line)
+    newline: bytes = b"\n"
+
+
+_MARKERS = {
+    "defs": re.compile(rb"<(?:[\w.-]+:)?ECUC-MODULE-DEF[\s>]"),
+    "config": re.compile(rb"<(?:[\w.-]+:)?ECUC-MODULE-CONFIGURATION-VALUES[\s>]"),
+}
+
+
+def _scan_markers(path: str) -> set:
+    """Which element kinds a file holds (element starts only; DEST="ECUC-MODULE-DEF" text does not count)."""
+    found = set()
+    tail = b""
+    try:
+        with open(path, "rb") as f:
+            while len(found) < len(_MARKERS):
+                chunk = f.read(1 << 20)
+                if not chunk:
+                    break
+                buf = tail + chunk
+                for k, rx in _MARKERS.items():
+                    if k not in found and rx.search(buf):
+                        found.add(k)
+                tail = buf[-96:]
+    except OSError:
+        pass
+    return found
+
+
+def _walk_arxml(root: str):
+    for dp, dns, fns in os.walk(root):
+        dns[:] = [d for d in dns if d not in SKIP_DIRS and not d.startswith(".")]
+        for fn in fns:
+            if fn.lower().endswith(".arxml"):
+                yield os.path.join(dp, fn)
+
+
+def _globs(root: str, pats) -> list:
+    out = []
+    for p in pats or []:
+        p = os.path.expanduser(p)
+        full = p if os.path.isabs(p) else os.path.join(root, p)
+        if os.path.isdir(full):
+            out.extend(_walk_arxml(full))
+        else:
+            out.extend(sorted(glob.glob(full, recursive=True)))
+    seen, res = set(), []
+    for f in out:
+        a = os.path.abspath(f)
+        if a not in seen and os.path.isfile(a):
+            seen.add(a)
+            res.append(a)
+    return res
+
+
+@dataclass
+class Sources:
+    root: str
+    config: list
+    defs: list
+    input: list
+    warnings: list
+    origin: dict  # which mechanism found each set
+
+
+def discover(root: str, config_files: Optional[list] = None, def_files: Optional[list] = None) -> Sources:
+    root = os.path.abspath(root)
+    cfg = {}
+    cfg_path = os.path.join(root, PROJECT_CONFIG)
+    warnings: list = []
+    if os.path.isfile(cfg_path):
+        try:
+            with open(cfg_path) as f:
+                cfg = json.load(f)
+        except Exception as e:
+            warnings.append(f"{PROJECT_CONFIG} is not valid JSON ({e}); ignoring it")
+    origin = {}
+    scanned = None
+
+    def scan():
+        nonlocal scanned
+        if scanned is None:
+            scanned = {f: _scan_markers(f) for f in _walk_arxml(root)}
+        return scanned
+
+    if def_files:
+        dfiles, origin["defs"] = _globs(root, def_files), "argument"
+    elif cfg.get("paramDefs"):
+        dfiles, origin["defs"] = _globs(root, cfg["paramDefs"]), PROJECT_CONFIG
+    else:
+        dfiles, origin["defs"] = [f for f, m in scan().items() if "defs" in m], "auto-discovered"
+        if not dfiles and os.environ.get("AUTOSAR_PARAMDEFS"):
+            dfiles = _globs(root, os.environ["AUTOSAR_PARAMDEFS"].split(os.pathsep))
+            origin["defs"] = "AUTOSAR_PARAMDEFS"
+    if config_files:
+        cfiles, origin["config"] = _globs(root, config_files), "argument"
+    elif cfg.get("config"):
+        cfiles, origin["config"] = _globs(root, cfg["config"]), PROJECT_CONFIG
+    else:
+        cfiles, origin["config"] = [f for f, m in scan().items() if "config" in m], "auto-discovered"
+    if cfg.get("input"):
+        ifiles, origin["input"] = _globs(root, cfg["input"]), PROJECT_CONFIG
+    else:
+        known = set(cfiles) | set(dfiles)
+        ifiles, origin["input"] = [f for f in scan() if f not in known], "auto-discovered"
+    if not dfiles:
+        warnings.append(
+            "No ECUC param definitions found (no ECUC-MODULE-DEF in the project, no paramDefs in "
+            f"{PROJECT_CONFIG}, AUTOSAR_PARAMDEFS unset). Values are readable but NOT validated, and edits "
+            "cannot add new elements. Point paramDefs at the AUTOSAR / vendor BSWMD param-def ARXML.")
+    return Sources(root, cfiles, dfiles, ifiles, warnings, origin)
+
+
+def _dest(n: Optional[Node]) -> Optional[str]:
+    return n.attrs.get("DEST") if n is not None else None
+
+
+def build_file_model(path: str, data: bytes) -> FileModel:
+    root = parse(data)
+    elems: list = []
+    idents: dict = {}
+
+    def visit(node: Node, prefix: str, parent: Optional[Elem]):
+        sn = node.short_name
+        path_here = prefix
+        if sn is not None:
+            path_here = f"{prefix}/{sn}"
+            idents.setdefault(path_here, (node.tag, node.line))
+        if node.tag in (MODULE_VALUES, CONTAINER_VALUE) and sn is not None:
+            dr = node.child("DEFINITION-REF")
+            e = Elem(node=node, file=path, path=path_here, name=sn,
+                     kind="module" if node.tag == MODULE_VALUES else "container",
+                     def_ref=dr.text.strip() if dr is not None else None, def_dest=_dest(dr), parent=parent)
+            for coll in node.children:
+                if coll.tag in ("PARAMETER-VALUES", "REFERENCE-VALUES"):
+                    for pv in coll.children:
+                        e.params.append(_param(pv))
+            if parent is not None:
+                parent.children.append(e)
+            else:
+                elems.append(e)
+            for coll in node.children:
+                if coll.tag in ("CONTAINERS", "SUB-CONTAINERS"):
+                    for c in coll.children:
+                        visit(c, path_here, e)
+            return
+        for c in node.children:
+            if c.tag in ("SHORT-NAME", "DESC", "ADMIN-DATA", "INTRODUCTION", "ANNOTATIONS"):
+                continue
+            visit(c, path_here, parent if sn is None else None)
+
+    visit(root, "", None)
+    nl = b"\r\n" if b"\r\n" in data[:4096] else b"\n"
+    return FileModel(path, data, root, elems, idents, nl)
+
+
+def _param(pv: Node) -> ParamVal:
+    dr = pv.child("DEFINITION-REF")
+    vn = pv.child("VALUE") if pv.tag in PARAM_VALUE_TAGS else pv.child("VALUE-REF") or pv.child("VALUE-IREF")
+    val = None
+    if vn is not None:
+        val = vn.text.strip() if vn.tag != "VALUE-IREF" else "(instance-ref)"
+        if pv.tag == "ECUC-ADD-INFO-PARAM-VALUE":
+            val = " ".join(vn.text.split())
+    auto = (pv.child_text("IS-AUTO-VALUE") or "").lower() == "true"
+    return ParamVal(node=pv, def_ref=dr.text.strip() if dr is not None else None, def_dest=_dest(dr), tag=pv.tag,
+                    value=val, value_node=vn, dest=_dest(vn) if vn is not None and vn.tag == "VALUE-REF" else None,
+                    is_auto=auto)
+
+
+def index_identifiables(path: str) -> dict:
+    """Fast path -> (tag, line=0) index of a non-config ARXML (System, SWC, BSWMD) for foreign refs."""
+    out: dict = {}
+    stack: list = []  # (short_name or None)
+    pending: list = []
+    try:
+        for ev, el in ET.iterparse(path, events=("start", "end")):
+            tag = el.tag.rsplit("}", 1)[-1]
+            if ev == "start":
+                stack.append(None)
+                pending.append(tag)
+            else:
+                if tag == "SHORT-NAME" and len(stack) >= 2:
+                    stack[-2] = (el.text or "").strip()
+                    p = "/" + "/".join(s for s in stack[:-1] if s)
+                    out.setdefault(p, (pending[-2], 0))
+                stack.pop()
+                pending.pop()
+                el.clear()
+    except ET.ParseError:
+        pass
+    return out
+
+
+class Project:
+    def __init__(self, root: str, config_files=None, def_files=None, load_input: bool = True):
+        self.sources = discover(root, config_files, def_files)
+        self.root = self.sources.root
+        self.warnings = list(self.sources.warnings)
+        self.defs = D.load_defs(self.sources.defs) if self.sources.defs else D.DefIndex()
+        if self.sources.defs and not self.defs:
+            self.warnings.append("param-def files were found but contain no ECUC-MODULE-DEF")
+        self.files: dict[str, FileModel] = {}
+        for f in self.sources.config:
+            self._load(f)
+        self.foreign: dict = {}
+        self.input_loaded = False
+        if load_input:
+            for f in self.sources.input:
+                self.foreign.update(index_identifiables(f))
+            self.input_loaded = bool(self.sources.input)
+        self.reindex()
+
+    def _load(self, f: str, data: Optional[bytes] = None):
+        if data is None:
+            with open(f, "rb") as fh:
+                data = fh.read()
+        try:
+            self.files[f] = build_file_model(f, data)
+        except Exception as e:
+            self.warnings.append(f"{self.rel(f)}: XML parse error: {e}")
+
+    def reload(self, f: str, data: bytes):
+        self._load(f, data)
+        self.reindex()
+
+    def reindex(self):
+        self.by_path: dict[str, list] = {}
+        self.modules: list = []
+        self.identifiables: dict = dict(self.foreign)
+        for fm in self.files.values():
+            for p, v in fm.identifiables.items():
+                self.identifiables.setdefault(p, v + (fm.path,))
+            for m in fm.elems:
+                self.modules.append(m)
+                for e in _iter_elems(m):
+                    self.by_path.setdefault(e.path, []).append(e)
+
+    def rel(self, f: str) -> str:
+        try:
+            r = os.path.relpath(f, self.root)
+            return f if r.startswith("..") else r
+        except ValueError:
+            return f
+
+    def find(self, path: str) -> list:
+        return self.by_path.get(path.rstrip("/"), [])
+
+
+def _iter_elems(e: Elem):
+    stack = [e]
+    while stack:
+        x = stack.pop()
+        yield x
+        stack.extend(reversed(x.children))

package/python/ecuc_engine/rules/__init__.py

@@ -0,0 +1,82 @@
+"""Hand-written semantic rule packs (the "H" checks the param defs cannot express).
+
+A rule is a function registered with @rule(...). It receives a RuleContext and yields
+(elem, line, message, def_ref) tuples; the registry adds the rule id, severity and spec citation.
+Rules are keyed by module-relative DEFINITION-REFs ("Com/ComConfig/ComSignal/ComBitPosition"), so
+they work for /AUTOSAR/EcucDefs/... and vendor-relocated defs alike, and run with or without the
+param defs loaded. To add a pack: create a module here with @rule functions and import it below.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Iterable, Optional
+
+from ..model import Elem, ParamVal, Project
+
+
+@dataclass
+class Rule:
+    id: str
+    severity: str
+    cite: str
+    title: str
+    fn: Callable
+
+
+RULES: list = []
+
+
+def rule(id: str, severity: str, cite: str, title: str):
+    def deco(fn):
+        RULES.append(Rule(id, severity, cite, title, fn))
+        return fn
+    return deco
+
+
+class RuleContext:
+    def __init__(self, project: Project):
+        self.p = project
+        self.defs = project.defs
+        self._by_rel: Optional[dict] = None
+
+    def rel(self, def_ref: Optional[str]) -> str:
+        return self.defs.rel(def_ref) if def_ref else ""
+
+    def containers(self, rel_def: str) -> list:
+        """All container values (first fragment per path) whose def is ``rel_def`` (module-relative)."""
+        if self._by_rel is None:
+            self._by_rel = {}
+            for path, group in self.p.by_path.items():
+                self._by_rel.setdefault(self.rel(group[0].def_ref), []).append(group[0])
+        return self._by_rel.get(rel_def, [])
+
+    def values(self, e: Elem, name: str) -> list:
+        return [pv for g in self.p.find(e.path) for pv in g.params if pv.name == name]
+
+    def value(self, e: Elem, name: str) -> Optional[ParamVal]:
+        v = self.values(e, name)
+        return v[0] if v else None
+
+    def text(self, e: Elem, name: str) -> Optional[str]:
+        v = self.value(e, name)
+        return v.value if v is not None else None
+
+    def target(self, pv: Optional[ParamVal]) -> Optional[Elem]:
+        if pv is None or not pv.value:
+            return None
+        hit = self.p.find(pv.value.strip())
+        return hit[0] if hit else None
+
+    def module_of(self, e: Elem) -> Elem:
+        while e.parent is not None:
+            e = e.parent
+        return e
+
+
+def run_rules(project: Project) -> Iterable[dict]:
+    from . import com, handles  # noqa: F401  (registers the packs)
+    ctx = RuleContext(project)
+    for r in RULES:
+        for e, line, msg, def_ref in r.fn(ctx):
+            yield {"file": project.rel(e.file), "line": line, "path": e.path, "rule": r.id,
+                   "severity": r.severity, "message": f"{msg} [{r.cite}]", "defRef": def_ref}

package/python/ecuc_engine/rules/com.py

@@ -0,0 +1,107 @@
+"""COM I-PDU packing rules: signals inside the I-PDU, no overlapping signals."""
+from __future__ import annotations
+
+from typing import Optional
+
+from . import rule
+from ..values import parse_int
+
+TYPE_BITS = {"BOOLEAN": 1, "UINT8": 8, "SINT8": 8, "UINT16": 16, "SINT16": 16, "UINT32": 32, "SINT32": 32,
+             "UINT64": 64, "SINT64": 64, "FLOAT32": 32, "FLOAT64": 64}
+CITE_BOUNDS = "ECUC_Com_00259 ComBitPosition (position within the I-PDU), ECUC_Com_00158 ComBitSize, ECUC_EcuC_00003 PduLength"
+CITE_OVERLAP = "SWS_Com_CONSTR_00102 Signals Separated in I-PDU"
+
+
+def _size(ctx, s) -> Optional[int]:
+    bs = parse_int(ctx.text(s, "ComBitSize") or "")
+    if bs is not None:
+        return bs
+    typ = (ctx.text(s, "ComSignalType") or "").strip()
+    if typ in ("UINT8_N", "UINT8_DYN"):
+        n = parse_int(ctx.text(s, "ComSignalLength") or "")
+        return n * 8 if n is not None else None
+    return TYPE_BITS.get(typ)
+
+
+def bits(pos: int, size: int, endian: str) -> list:
+    """Occupied bit indices (byte*8 + bit). ComBitPosition is the LSB. BIG_ENDIAN (Motorola) walks
+    toward the MSB by going up within a byte, then to bit 0 of the previous byte."""
+    if endian == "BIG_ENDIAN":
+        out, b = [], pos
+        for _ in range(size):
+            out.append(b)
+            b = b + 1 if b % 8 != 7 else b - 15
+        return out
+    return list(range(pos, pos + size))  # LITTLE_ENDIAN and OPAQUE (bit0 of first byte, little-endian order)
+
+
+def _ipdus(ctx):
+    """(ipdu, length_bytes|None, [(member, kind)]) for every ComIPdu."""
+    for ipdu in ctx.containers("Com/ComConfig/ComIPdu"):
+        pdu = ctx.target(ctx.value(ipdu, "ComPduIdRef"))
+        length = parse_int(ctx.text(pdu, "PduLength") or "") if pdu is not None else None
+        members = []
+        for ref in ctx.values(ipdu, "ComIPduSignalRef"):
+            s = ctx.target(ref)
+            if s is not None:
+                members.append(s)
+        for ref in ctx.values(ipdu, "ComIPduSignalGroupRef"):
+            grp = ctx.target(ref)
+            if grp is None:
+                continue
+            members.extend(c for g in ctx.p.find(grp.path) for c in g.children
+                           if ctx.rel(c.def_ref).endswith("/ComGroupSignal"))
+            members.append(grp)  # contributes only its update bit
+        yield ipdu, length, pdu, members
+
+
+def _layout(ctx, s):
+    """[(label, bitset, line)] a signal/group occupies: its value bits and its update bit."""
+    out = []
+    pos = parse_int(ctx.text(s, "ComBitPosition") or "")
+    size = _size(ctx, s)
+    if pos is not None and size:
+        endian = (ctx.text(s, "ComSignalEndianness") or "LITTLE_ENDIAN").strip()
+        out.append((s.name, bits(pos, size, endian), ctx.value(s, "ComBitPosition").node.line, pos, size, endian))
+    ub = parse_int(ctx.text(s, "ComUpdateBitPosition") or "")
+    if ub is not None:
+        out.append((f"{s.name}.updateBit", [ub], ctx.value(s, "ComUpdateBitPosition").node.line, ub, 1, "LITTLE_ENDIAN"))
+    return out
+
+
+@rule("H2L-COM-001", "error", CITE_BOUNDS, "signal bits lie inside its I-PDU (PduLength * 8)")
+def signal_in_pdu(ctx):
+    for ipdu, length, pdu, members in _ipdus(ctx):
+        if length is None:
+            continue
+        limit = length * 8
+        for s in members:
+            for label, bs, line, pos, size, endian in _layout(ctx, s):
+                lo, hi = min(bs), max(bs)
+                if lo < 0 or hi >= limit:
+                    yield s, line, (f"{label}: ComBitPosition={pos} ComBitSize={size} ({endian}) occupies bits {lo}..{hi}, "
+                                    f"outside I-PDU {ipdu.name} ({pdu.path} PduLength={length} bytes = bits 0..{limit - 1})"), \
+                        (ctx.value(s, "ComBitPosition") or ctx.value(s, "ComUpdateBitPosition")).def_ref
+
+
+@rule("H2L-COM-002", "error", CITE_OVERLAP, "signals of one I-PDU do not overlap")
+def no_overlap(ctx):
+    for ipdu, length, pdu, members in _ipdus(ctx):
+        owner: dict = {}
+        reported = set()
+        for s in members:
+            for label, bs, line, pos, size, endian in _layout(ctx, s):
+                for b in bs:
+                    prev = owner.get(b)
+                    if prev is None:
+                        owner[b] = (label, s)
+                        continue
+                    if prev[0] == label:
+                        continue
+                    key = tuple(sorted((prev[0], label)))
+                    if key in reported:
+                        continue
+                    reported.add(key)
+                    yield s, line, (f"{label} overlaps {prev[0]} at bit {b} in I-PDU {ipdu.name} "
+                                    f"({label}: pos {pos} size {size} {endian})"), \
+                        (ctx.value(s, "ComBitPosition") or ctx.value(s, "ComUpdateBitPosition")).def_ref

package/python/ecuc_engine/rules/handles.py

@@ -0,0 +1,42 @@
+"""Handle-ID uniqueness (TPS_ECUConfiguration 3.4.1.1 "Handle ID concept")."""
+from __future__ import annotations
+
+import re
+
+from . import rule
+from ..values import parse_int
+
+# Handle-ID params by name when no defs say so; with defs, any SYMBOLIC-NAME-VALUE integer counts.
+NAME = re.compile(r"(HandleId|^CanIfTxPduId|^CanIfRxPduId)$")
+
+
+@rule("H2L-HID-001", "error",
+      "TPS_ECUConfiguration 3.4.1.1 Handle ID concept; ECUC_Com_00165/00175, ECUC_PduR_00322, ECUC_CanIf_00591/00597",
+      "handle IDs are unique per module and handle-ID parameter")
+def unique_handle_ids(ctx):
+    seen: dict = {}  # (module path, rel def) -> {value: [(elem, pv)]}
+    for path, group in ctx.p.by_path.items():
+        e = group[0]
+        if e.kind != "container":
+            continue
+        mod = ctx.module_of(e)
+        for g in group:
+            for pv in g.params:
+                if pv.is_ref or pv.value is None:
+                    continue
+                d = ctx.defs.get(pv.def_ref)
+                is_handle = (d.kind == "INTEGER" and d.symbolic_name) if d is not None else False
+                if not is_handle and not NAME.search(pv.name):
+                    continue
+                v = parse_int(pv.value)
+                if v is None:
+                    continue
+                key = (mod.path, ctx.rel(pv.def_ref))
+                seen.setdefault(key, {}).setdefault(v, []).append((g, pv))
+    for (mod, rel), by_val in seen.items():
+        for v, hits in by_val.items():
+            if len(hits) < 2:
+                continue
+            names = ", ".join(sorted({h[0].name for h in hits}))
+            for g, pv in hits:
+                yield g, pv.node.line, f"{pv.name}={v} is used by {len(hits)} containers in {mod} ({names}); handle IDs must be unique", pv.def_ref