@h2loop/autosar 1.0.1 → 1.2.0

package/python/ecuc_engine/codegen/cdiff.py

@@ -0,0 +1,395 @@
+"""Semantic diff of generated C configuration code (reference dir vs generated dir).
+
+Compared: `#define` names and values, and file-scope initialised objects (struct/array tables)
+element by element, including table ordering. Ignored: formatting, comments, banners, include
+order, MemMap/section boilerplate, storage qualifiers (static/CONST()/const).
+
+Values are normalised before comparison: integer literals by value (0x2A0u == 672), casts and
+outer parentheses dropped, macros resolved through the defines of the same side (falling back to
+the other side's defines for symbols a side does not define, e.g. ComConf_* from a Com_Cfg.h that
+was not regenerated), constant integer expressions folded. Designated initialisers
+(`[NvMConf_X] = {...}`) are placed at their resolved index.
+"""
+from __future__ import annotations
+
+import ast
+import os
+import re
+from typing import Optional
+
+BUILTINS = {"TRUE": "1", "FALSE": "0", "STD_ON": "1", "STD_OFF": "0", "STD_HIGH": "1", "STD_LOW": "0",
+            "E_OK": "0", "E_NOT_OK": "1"}
+
+TOKEN = re.compile(r"""
+    (?P<ws>\s+)
+  | (?P<str>"(?:\\.|[^"\\])*")
+  | (?P<chr>'(?:\\.|[^'\\])*')
+  | (?P<num>(?:0[xX][0-9A-Fa-f]+|\d+\.\d*(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?|\d+(?:[eE][+-]?\d+)?)[uUlLfF]*)
+  | (?P<id>[A-Za-z_]\w*)
+  | (?P<op>->|<<|>>|<=|>=|==|!=|&&|\|\||[-+*/%&|^~!<>=?:;,.\[\](){}#])
+""", re.X)
+
+
+def strip_comments(src: str) -> str:
+    out, i, n = [], 0, len(src)
+    while i < n:
+        c = src[i]
+        if c in "\"'":
+            j = i + 1
+            while j < n and src[j] != c:
+                j += 2 if src[j] == "\\" else 1
+            out.append(src[i:j + 1])
+            i = j + 1
+        elif src.startswith("/*", i):
+            j = src.find("*/", i + 2)
+            j = n if j < 0 else j + 2
+            out.append(" " + "\n" * src.count("\n", i, j))
+            i = j
+        elif src.startswith("//", i):
+            j = src.find("\n", i)
+            i = n if j < 0 else j
+        else:
+            out.append(c)
+            i += 1
+    return "".join(out)
+
+
+def tokenize(src: str) -> list:
+    toks, pos = [], 0
+    while pos < len(src):
+        m = TOKEN.match(src, pos)
+        if not m:
+            toks.append(src[pos])  # stray character (e.g. '@'): keep, never crash
+            pos += 1
+            continue
+        pos = m.end()
+        if m.lastgroup != "ws":
+            toks.append(m.group(m.lastgroup))
+    return toks
+
+
+def split_source(src: str) -> tuple:
+    """-> (defines {name: value-text}, code text without preprocessor lines)."""
+    src = strip_comments(src).replace("\\\r\n", " ").replace("\\\n", " ")
+    defines: dict = {}
+    code = []
+    for line in src.splitlines():
+        s = line.strip()
+        if s.startswith("#"):
+            m = re.match(r"#\s*define\s+([A-Za-z_]\w*)(\([^)]*\))?\s*(.*)$", s)
+            if m:
+                name = m.group(1) + (m.group(2) or "")
+                if m.group(1) not in defines and name not in defines:
+                    defines[name if m.group(2) else m.group(1)] = m.group(3).strip()
+            code.append("")
+            continue
+        code.append(line)
+    return defines, "\n".join(code)
+
+
+class Parser:
+    def __init__(self, toks: list):
+        self.t = toks
+        self.i = 0
+
+    def objects(self) -> dict:
+        """File-scope `<decl> name[...] = <init>;` -> {name: init-tree}."""
+        out: dict = {}
+        stmt_start = 0
+        depth = 0
+        t = self.t
+        i = 0
+        while i < len(t):
+            tok = t[i]
+            if tok in "({[":
+                depth += 1
+            elif tok in ")}]":
+                depth -= 1
+            elif tok == ";" and depth == 0:
+                stmt_start = i + 1
+            elif tok == "=" and depth == 0:
+                name = self._declarator(stmt_start, i)
+                self.i = i + 1
+                init = self._init()
+                if name:
+                    out[name] = init
+                while self.i < len(t) and t[self.i] != ";":
+                    self.i += 1
+                i = self.i
+                stmt_start = i + 1
+                depth = 0
+            i += 1
+        return out
+
+    def _declarator(self, start: int, eq: int) -> Optional[str]:
+        j = eq - 1
+        while j >= start and self.t[j] == "]":  # skip [size] groups
+            d = 0
+            while j >= start:
+                if self.t[j] == "]":
+                    d += 1
+                elif self.t[j] == "[":
+                    d -= 1
+                    if d == 0:
+                        break
+                j -= 1
+            j -= 1
+        if j >= start and re.match(r"^[A-Za-z_]\w*$", self.t[j]):
+            return self.t[j]
+        return None
+
+    def _init(self):
+        t = self.t
+        if self.i < len(t) and t[self.i] == "{":
+            self.i += 1
+            items = []
+            while self.i < len(t) and t[self.i] != "}":
+                desig = None
+                if t[self.i] == "[":
+                    j = self.i + 1
+                    d = 1
+                    while j < len(t) and d:
+                        d += {"[": 1, "]": -1}.get(t[j], 0)
+                        j += 1
+                    if j < len(t) and t[j] == "=":
+                        desig = ("index", t[self.i + 1:j - 1])
+                        self.i = j + 1
+                elif t[self.i] == "." and self.i + 2 < len(t) and t[self.i + 2] == "=":
+                    desig = ("field", t[self.i + 1])
+                    self.i += 3
+                val = self._init()
+                items.append((desig, val))
+                if self.i < len(t) and t[self.i] == ",":
+                    self.i += 1
+            self.i += 1  # '}'
+            return ("list", items)
+        start = self.i
+        d = 0
+        while self.i < len(t):
+            tok = t[self.i]
+            if tok in "([{":
+                d += 1
+            elif tok in ")]}":
+                if d == 0:
+                    break
+                d -= 1
+            elif tok in ",;" and d == 0:
+                break
+            self.i += 1
+        return ("expr", t[start:self.i])
+
+
+def parse_c(src: str) -> tuple:
+    defines, code = split_source(src)
+    return defines, Parser(tokenize(code)).objects()
+
+
+# ---------- normalisation ----------
+
+INT = re.compile(r"^(0[xX][0-9A-Fa-f]+|\d+)[uUlL]*$")
+
+
+class Resolver:
+    def __init__(self, own: dict, fallback: dict):
+        self.own = own
+        self.fallback = fallback
+
+    def lookup(self, name: str) -> Optional[str]:
+        if name in self.own:
+            return self.own[name]
+        if name in self.fallback:
+            return self.fallback[name]
+        return BUILTINS.get(name)
+
+    def norm_tokens(self, toks: list, depth: int = 0) -> str:
+        toks = list(toks)
+        out = []
+        for tk in toks:
+            if re.match(r"^[A-Za-z_]\w*$", tk) and depth < 24:
+                v = self.lookup(tk)
+                if v is not None and v != tk:
+                    out.append("(" + self.norm_tokens(tokenize(v), depth + 1) + ")")
+                    continue
+            m = INT.match(tk)
+            out.append(str(int(m.group(1), 0) if not m.group(1).startswith("0") or m.group(1) == "0"
+                           or m.group(1)[:2] in ("0x", "0X") else int(m.group(1), 8)) if m else tk)
+        return fold(" ".join(out))
+
+    def norm(self, toks: list) -> str:
+        return self.norm_tokens(toks)
+
+
+CAST = re.compile(r"\(\s*(?:const\s+)?[A-Za-z_]\w*(?:\s*\*)*\s*\)\s*(?=[\w(&-])")
+
+
+def fold(expr: str) -> str:
+    e = CAST.sub("", expr)
+    e = re.sub(r"\s+", " ", e).strip()
+    while e.startswith("(") and e.endswith(")") and _balanced(e[1:-1]):
+        e = e[1:-1].strip()
+    if re.fullmatch(r"[\d\s()+\-*/%<>&|^~]+", e or "x"):
+        try:
+            v = _eval(ast.parse(e, mode="eval").body)
+            if isinstance(v, int):
+                return str(v)
+        except Exception:  # noqa: BLE001
+            pass
+    return re.sub(r"\s*([()\[\],&*.])\s*", r"\1", e).replace("->", "->")
+
+
+def _balanced(s: str) -> bool:
+    d = 0
+    for ch in s:
+        d += {"(": 1, ")": -1}.get(ch, 0)
+        if d < 0:
+            return False
+    return d == 0
+
+
+def _eval(n):
+    if isinstance(n, ast.Constant) and isinstance(n.value, int):
+        return n.value
+    if isinstance(n, ast.UnaryOp):
+        v = _eval(n.operand)
+        return {ast.USub: lambda: -v, ast.UAdd: lambda: v, ast.Invert: lambda: ~v}[type(n.op)]()
+    if isinstance(n, ast.BinOp):
+        a, b = _eval(n.left), _eval(n.right)
+        ops = {ast.Add: lambda: a + b, ast.Sub: lambda: a - b, ast.Mult: lambda: a * b,
+               ast.FloorDiv: lambda: a // b, ast.Div: lambda: a // b, ast.Mod: lambda: a % b,
+               ast.LShift: lambda: a << b, ast.RShift: lambda: a >> b, ast.BitOr: lambda: a | b,
+               ast.BitAnd: lambda: a & b, ast.BitXor: lambda: a ^ b}
+        return ops[type(n.op)]()
+    raise ValueError("not constant")
+
+
+def flatten(tree, res: Resolver, prefix: str = "") -> dict:
+    """Init tree -> {path: normalised leaf}; designators resolved to indices / field names."""
+    kind, val = tree
+    if kind == "expr":
+        return {prefix or "=": res.norm(val)}
+    out: dict = {}
+    pos = 0
+    for desig, item in val:
+        if desig is None:
+            key = f"[{pos}]"
+            pos += 1
+        elif desig[0] == "index":
+            idx = res.norm(desig[1])
+            key = f"[{idx}]"
+            pos = int(idx) + 1 if idx.lstrip("-").isdigit() else pos + 1
+        else:
+            key = f".{desig[1]}"
+        out.update(flatten(item, res, prefix + key))
+    return out
+
+
+def rows(tree, res: Resolver) -> Optional[list]:
+    """Top-level elements of an array initialiser as (index key, normalised row) for order checks."""
+    kind, val = tree
+    if kind != "list":
+        return None
+    out = []
+    pos = 0
+    for desig, item in val:
+        if desig is not None and desig[0] == "index":
+            idx = res.norm(desig[1])
+            key = f"[{idx}]"
+            pos = int(idx) + 1 if idx.isdigit() else pos + 1
+        elif desig is None:
+            key = f"[{pos}]"
+            pos += 1
+        else:
+            return None
+        out.append((key, tuple(sorted(flatten(item, res).items()))))
+    return out
+
+
+# ---------- module grouping ----------
+
+def module_of(fname: str) -> str:
+    base = os.path.basename(fname)
+    if base.startswith("SchM_"):
+        return base[5:].rsplit(".", 1)[0]
+    stem = base.rsplit(".", 1)[0]
+    return stem.split("_", 1)[0]
+
+
+def load_dir(d: str) -> dict:
+    """{file basename: (defines, objects)} for *.h / *.c directly in d (or the single file d)."""
+    files = [d] if os.path.isfile(d) else [os.path.join(d, f) for f in sorted(os.listdir(d))]
+    out = {}
+    for f in files:
+        if not f.endswith((".h", ".c")) or not os.path.isfile(f):
+            continue
+        with open(f, errors="replace") as fh:
+            out[os.path.basename(f)] = parse_c(fh.read())
+    return out
+
+
+def diff_dirs(reference: str, generated: str, modules: Optional[list] = None, max_items: int = 200) -> dict:
+    ref, gen = load_dir(reference), load_dir(generated)
+    ref_defs = {k: v for _, (d, _) in sorted(ref.items()) for k, v in d.items()}
+    gen_defs = {k: v for _, (d, _) in sorted(gen.items()) for k, v in d.items()}
+    rr, gr = Resolver(ref_defs, gen_defs), Resolver(gen_defs, ref_defs)
+    mods_ref: dict = {}
+    mods_gen: dict = {}
+    for f in ref:
+        mods_ref.setdefault(module_of(f), []).append(f)
+    for f in gen:
+        mods_gen.setdefault(module_of(f), []).append(f)
+    names = sorted(set(mods_ref) & set(mods_gen))
+    if modules:
+        names = [m for m in names if m in modules]
+    report: dict = {"modules": {}, "notGenerated": sorted(set(mods_ref) - set(mods_gen)),
+                    "notInReference": sorted(set(mods_gen) - set(mods_ref))}
+    for m in names:
+        report["modules"][m] = _diff_module(m, mods_ref[m], mods_gen[m], ref, gen, rr, gr, max_items)
+    tot = {"matching": 0, "missing": 0, "extra": 0, "mismatches": 0}
+    for r in report["modules"].values():
+        for k in tot:
+            tot[k] += r["summary"][k]
+    report["total"] = tot
+    return report
+
+
+def _diff_module(m, rfiles, gfiles, ref, gen, rr: Resolver, gr: Resolver, cap: int) -> dict:
+    rd = {k: v for f in sorted(rfiles) for k, v in ref[f][0].items()}
+    gd = {k: v for f in sorted(gfiles) for k, v in gen[f][0].items()}
+    ro = {k: v for f in sorted(rfiles) for k, v in ref[f][1].items()}
+    go = {k: v for f in sorted(gfiles) for k, v in gen[f][1].items()}
+    skip = re.compile(r"(_H|_START_SEC_\w+|_STOP_SEC_\w+|MEMMAP_ERROR|\w*_MEMMAP_SEQUENCE_OPEN\w*)$")
+    rd = {k: v for k, v in rd.items() if not skip.search(k)}
+    gd = {k: v for k, v in gd.items() if not skip.search(k)}
+    dm = {"match": [], "missing": sorted(set(rd) - set(gd)), "extra": sorted(set(gd) - set(rd)), "mismatch": []}
+    for k in sorted(set(rd) & set(gd)):
+        a, b = rr.norm(tokenize(rd[k])), gr.norm(tokenize(gd[k]))
+        if a == b:
+            dm["match"].append(k)
+        else:
+            dm["mismatch"].append({"name": k, "reference": rd[k], "generated": gd[k], "normalised": [a, b]})
+    om = {"match": [], "missing": sorted(set(ro) - set(go)), "extra": sorted(set(go) - set(ro)), "mismatch": [],
+          "order": []}
+    elements = {"match": 0, "mismatch": 0}
+    for k in sorted(set(ro) & set(go)):
+        fa, fb = flatten(ro[k], rr), flatten(go[k], gr)
+        bad = [{"element": f"{k}{p}", "reference": fa.get(p), "generated": fb.get(p)}
+               for p in sorted(set(fa) | set(fb)) if fa.get(p) != fb.get(p)]
+        elements["match"] += sum(1 for p in fa if fb.get(p) == fa[p])
+        if not bad:
+            om["match"].append(k)
+            continue
+        ra, rb = rows(ro[k], rr), rows(go[k], gr)
+        if ra is not None and rb is not None and sorted(x[1] for x in ra) == sorted(x[1] for x in rb):
+            om["order"].append({"name": k, "reference": [x[0] for x in ra], "generated": [x[0] for x in rb],
+                                "note": "same rows, different table order"})
+            continue
+        elements["mismatch"] += len(bad)
+        om["mismatch"].append({"name": k, "elements": bad[:cap], "count": len(bad)})
+    summary = {"matching": len(dm["match"]) + len(om["match"]),
+               "missing": len(dm["missing"]) + len(om["missing"]),
+               "extra": len(dm["extra"]) + len(om["extra"]),
+               "mismatches": len(dm["mismatch"]) + len(om["mismatch"]) + len(om["order"])}
+    dm["match"] = len(dm["match"])
+    om["match"] = om["match"]
+    return {"files": {"reference": sorted(rfiles), "generated": sorted(gfiles)}, "defines": dm, "objects": om,
+            "elements": elements, "summary": summary}

package/python/ecuc_engine/codegen/cwriter.py

@@ -0,0 +1,150 @@
+"""C text rendering shared by every module generator (no module knowledge here).
+
+Rules implemented (cited where the standard sets them):
+  * generated-file banner (no timestamps, so output is byte-stable) and include guards;
+  * `#define` alignment, STD_ON/STD_OFF for booleans (SWS_Std_00010, SWS_BSW_00029);
+  * MemMap wrapping `<MIP>_START_SEC_<SECTION>` / `<MIP>_STOP_SEC_<SECTION>` + `#include "<Mip>_MemMap.h"`
+    (SWS_MemMap_00032, SWS_BSW_00006);
+  * C type of a parameter from its def (Platform_Types names, SWS_PlatformTypes).
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from .. import ENGINE_VERSION
+from .. import defs as D
+from ..values import parse_float, parse_int
+
+GENERATOR = f"Hydron AUTOSAR codegen {ENGINE_VERSION}"
+CONFIG_SECTION = "CONFIG_DATA_UNSPECIFIED"
+C_IDENT = re.compile(r"^[A-Za-z_]\w*$")
+C_EXPR = re.compile(r"^[&*(]*[A-Za-z_][\w.\[\]>-]*\)*$")  # &x, x[2], x.y, p->q, (x)
+
+
+def banner(name: str, mc_name: str, variant: str, release: tuple, inputs: list, digest: str) -> str:
+    rel = ".".join(str(x) for x in release)
+    lines = [
+        "/" + "*" * 78,
+        f" *  File:       {name}",
+        f" *  Module:     {mc_name} ({variant}, AUTOSAR R{rel})",
+        f" *  Generator:  {GENERATOR} (deterministic: same ECUC + param defs -> same file)",
+    ]
+    for i, f in enumerate(inputs[:8]):
+        lines.append(f" *  {'Inputs:' if i == 0 else '':11} {f}")
+    if len(inputs) > 8:
+        lines.append(f" *  {'':11} ... {len(inputs) - 8} more")
+    lines += [f" *  Input hash: {digest}", " *  DO NOT EDIT. Change the ECUC configuration and regenerate (autosar_codegen).",
+              " " + "*" * 78 + "/"]
+    return "\n".join(lines)
+
+
+def guard(name: str) -> str:
+    return re.sub(r"\W", "_", name).upper()
+
+
+def define(name: str, value: str, comment: str = "") -> str:
+    pad = max(1, 56 - len(name))
+    line = f"#define {name}{' ' * pad}{value}"
+    return f"{line}  /* {comment} */" if comment else line
+
+
+def memmap(mip: str, body: str, section: str = CONFIG_SECTION) -> str:
+    MIP = mip.upper()
+    return (f"#define {MIP}_START_SEC_{section}\n#include \"{mip}_MemMap.h\"\n\n{body.rstrip()}\n\n"
+            f"#define {MIP}_STOP_SEC_{section}\n#include \"{mip}_MemMap.h\"")
+
+
+def c_uint(v: int, hexa: bool = False) -> str:
+    if v < 0:
+        return f"({v})"
+    return f"0x{v:X}u" if hexa else f"{v}u"
+
+
+def c_float(raw: str) -> str:
+    f = parse_float(raw)
+    if f is None:
+        return raw
+    if f != f or f in (float("inf"), float("-inf")):
+        return "0.0"  # not representable in a C initialiser; the validator flags such values
+    s = repr(float(f))
+    return f"({s})" if s.startswith("-") else s
+
+
+def c_text(raw: str) -> str:
+    """STRING / FUNCTION-NAME / LINKER-SYMBOL value: a C identifier or expression verbatim, else a string literal."""
+    t = raw.strip()
+    if C_EXPR.match(t):
+        return t
+    return '"' + t.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def int_ctype(lo: Optional[int], hi: Optional[int]) -> str:
+    if lo is not None and lo < 0:
+        for bits in (8, 16, 32):
+            if (hi is None or hi < 2 ** (bits - 1)) and lo >= -(2 ** (bits - 1)):
+                return f"sint{bits}"
+        return "sint64"
+    if hi is None:
+        return "uint32"
+    for bits in (8, 16, 32):
+        if hi < 2 ** bits:
+            return f"uint{bits}"
+    return "uint64"
+
+
+def param_ctype(d: D.DefNode) -> Optional[str]:
+    """Platform type for a param def in a generated table, or None if it has no table representation."""
+    k = d.kind
+    if k == "INTEGER":
+        return int_ctype(parse_int(d.min) if d.min else None, parse_int(d.max) if d.max else None)
+    if k == "BOOLEAN":
+        return "boolean"
+    if k == "FLOAT":
+        return "float64"
+    if k == "ENUMERATION":
+        return "uint8" if len(d.literals) <= 256 else "uint16"
+    return None  # STRING / FUNCTION-NAME / LINKER-SYMBOL / MULTILINE-STRING bind to static-code prototypes
+
+
+def macro_value(d: Optional[D.DefNode], raw: str) -> str:
+    """Value of a pre-compile scalar #define."""
+    k = d.kind if d is not None else None
+    if k == "BOOLEAN":
+        return "STD_ON" if raw.strip().lower() in ("true", "1") else "STD_OFF"
+    if k == "INTEGER":
+        v = parse_int(raw)
+        return c_uint(v) if v is not None else raw
+    if k == "FLOAT":
+        return c_float(raw)
+    if k == "ENUMERATION":
+        return raw.strip() if C_IDENT.match(raw.strip()) else c_text(raw)
+    t = c_text(raw)
+    return t if C_IDENT.match(t) or t.startswith('"') or (t.startswith("(") and t.endswith(")")) else f"({t})"
+
+
+def table_value(d: Optional[D.DefNode], raw: Optional[str], hexa: bool = False) -> tuple:
+    """(C initialiser, comment) of a param value in a generated table."""
+    k = d.kind if d is not None else None
+    if raw is None:
+        raw = d.default if d is not None and d.default is not None else None
+    if raw is None:
+        return ({"BOOLEAN": "FALSE", "FLOAT": "0.0"}.get(k or "", "0u"), "not configured")
+    if k == "BOOLEAN":
+        return ("TRUE" if raw.strip().lower() in ("true", "1") else "FALSE", "")
+    if k == "INTEGER":
+        v = parse_int(raw)
+        return (c_uint(v, hexa) if v is not None else raw, "")
+    if k == "FLOAT":
+        return (c_float(raw), "")
+    if k == "ENUMERATION":
+        lit = raw.strip()
+        if lit in d.literals:
+            return (c_uint(d.literals.index(lit)), lit)
+        return ("0u", f"unknown literal {lit}")
+    return (c_text(raw), "")
+
+
+def initializer(values: list, comment: str = "", indent: str = "  ") -> str:
+    body = ", ".join(values)
+    return f"{indent}{{ {body} }}" + (f" /* {comment} */" if comment else "")