cg-code-graph 0.23.6__tar.gz → 0.23.8__tar.gz

{cg_code_graph-0.23.6/cg_code_graph.egg-info → cg_code_graph-0.23.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.6
+Version: 0.23.8
 Summary: cg: a code graph of routes, calls, data access and platform boundaries for agents and humans (CLI + MCP server)
 Author: cyberchronos00
 License-Expression: MIT

{cg_code_graph-0.23.6 → cg_code_graph-0.23.8}/cg_code_graph/__init__.py

@@ -1,2 +1,2 @@
 """code-graph: deterministic code knowledge graph (beta)."""
-__version__ = "0.23.6"
+__version__ = "0.23.8"

{cg_code_graph-0.23.6 → cg_code_graph-0.23.8}/cg_code_graph/bridges.py

@@ -31,6 +31,9 @@ Process protocols (one app, two processes; receivers carry attrs.process instead
   tauri              endpoint:tauri:<command> (plugin commands: endpoint:tauri:plugin:<name>|<command>, external
                      tauri-plugin-<name> unless the plugin crate is in the repo); invoke('cmd') from @tauri-apps/api ->
                      #[tauri::command] fn in the Rust core; check unregistered: not listed in generate_handler!
+  tauri-event        endpoint:tauri-event:<name>; emit / emit_to / emit_str / emit_filter with a literal name (Rust
+                     `app.emit("x", ..)`, webview `emit('x')`, `getCurrentWindow().emit('x')`, `emitTo(label, 'x')`)
+                     -> listen / listen_any / once (Rust closures, webview callbacks); `tauri://` names are Tauri's own
 no_receiver for these: the other side is in the repo (some channel / command is received) but not this one.
 """
 from __future__ import annotations
@@ -55,6 +58,8 @@ PROTOCOLS = {
                     "ipcRenderer.on)",
     "electron-preload": "Electron context bridge member (window.<key>.<member>() -> contextBridge.exposeInMainWorld)",
     "tauri": "Tauri command (invoke('cmd') -> #[tauri::command] fn cmd registered in generate_handler!)",
+    "tauri-event": "Tauri event (emit / emit_to('name') in Rust or the webview -> listen / once('name') on the other "
+                   "side; `tauri://` events are emitted by Tauri itself)",
     "react-native-event": "React Native event (native sendEvent / RCTDeviceEventEmitter.emit / sendEventWithName / Expo "
                           "sendEvent -> NativeEventEmitter / DeviceEventEmitter addListener in JS)",
     "capacitor-event": "Capacitor plugin event (native notifyListeners('evt') -> Plugin.addListener('evt') in JS)",
@@ -64,8 +69,8 @@ PROTOCOLS = {
 # native -> app events: the JS listener is the receiver; no_sender only where the repo sends some event natively
 EVENT_PROTOCOLS = ("react-native-event", "capacitor-event")
 # protocols between processes of one app (no per-platform receivers)
-PROCESS_PROTOCOLS = ("electron-ipc", "electron-preload", "tauri")
-TRANSPORT = {"electron-ipc": "ipc", "tauri": "ipc", "electron-preload": "local"}
+PROCESS_PROTOCOLS = ("electron-ipc", "electron-preload", "tauri", "tauri-event")
+TRANSPORT = {"electron-ipc": "ipc", "tauri": "ipc", "tauri-event": "ipc", "electron-preload": "local"}
 MOBILE = ("android", "ios", "macos")
 APP_LANGS = ("dart", "ts")          # the app side of a bridge (receivers there: a native -> app call)
 # Capacitor Plugin / CAPPlugin base-class methods: handled by the bridge on every platform unless a plugin overrides them
@@ -1162,11 +1167,134 @@ def tauri_receivers(project, builder) -> dict:
     return {"commands": n, "registered": len(registered)} if n else {}
 
 
+TAURI_EV_RS_SEND = re.compile(r"\.\s*(emit|emit_str|emit_all)\s*\(\s*\"([^\"]+)\"|"
+                              r"\.\s*(emit_to|emit_str_to|emit_filter|emit_str_filter)\s*\(\s*(?:[^,()]|\([^()]*\))+,\s*\"([^\"]+)\"")
+TAURI_EV_RS_RECV = re.compile(r"\.\s*(listen|listen_any|once|once_any)\s*\(\s*\"([^\"]+)\"\s*,\s*(?:move\s*)?(\|[^|]*\||[A-Za-z_][\w:]*)?")
+TAURI_EV_JS_SEND = re.compile(r"""(?<![\w$])(?:\.\s*)?(emit)\s*\(\s*(['"`])([^'"`$\n]+)\2|"""
+                              r"""(?<![\w$])(?:\.\s*)?(emitTo)\s*\(\s*[^,()]+,\s*(['"`])([^'"`$\n]+)\5""")
+TAURI_EV_JS_RECV = re.compile(r"""(?<![\w$])(?:\.\s*)?(listen|once)\s*(?:<[^>()]*>)?\s*\(\s*(['"`])([^'"`$\n]+)\2\s*,\s*([A-Za-z_$][\w$]*)?""")
+TAURI_EV_DYN_SEND = re.compile(r"""(?<![\w$])(?:\.\s*)?(?:emit|emit_str|emit_all)\s*\(\s*&?[A-Za-z_$][\w$.]*\s*[,)]""")
+TAURI_EV_DYN_RECV = re.compile(r"""(?<![\w$])(?:\.\s*)?(?:listen|listen_any|once)\s*(?:<[^>()]*>)?\s*\(\s*&?[A-Za-z_$][\w$.]*\s*,""")
+_JS_TOKEN = re.compile(r"""'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`|//[^\n]*|/\*.*?\*/""", re.S)
+JS_LIKE = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".svelte")
+
+
+def _innermost(builder, by_file: dict, rel: str, line: int) -> str | None:
+    """The innermost function / method / component node of `rel` around `line`, else its module / file node."""
+    best, size = None, None
+    for n in by_file.get(rel, ()):
+        if n.line is None or n.line > line or (n.end_line or n.line) < line:
+            continue
+        sz = (n.end_line or n.line) - n.line
+        if size is None or sz < size:
+            best, size = n.id, sz
+    return best
+
+
+def _uses_tauri(root: Path, depth: int = 4) -> bool:
+    """A Cargo.toml depending on tauri or a package.json depending on @tauri-apps/* within `depth` directories."""
+    from . import presets
+    skip = presets.skip_dirs("common")
+    for dp, dn, fn in os.walk(root):
+        rel = Path(dp).relative_to(root)
+        dn[:] = [] if len(rel.parts) >= depth else [d for d in dn if d not in skip and not d.startswith(".")]
+        for name, rx in (("Cargo.toml", r"^\s*tauri\s*="), ("package.json", r'"@tauri-apps/')):
+            if name in fn:
+                try:
+                    if re.search(rx, (Path(dp) / name).read_text(encoding="utf-8", errors="replace"), re.M):
+                        return True
+                except OSError:
+                    pass
+    return False
+
+
+def tauri_events(project, builder) -> dict:
+    """Tauri events (#111): a literal event name emitted on one side (Rust core or webview) and listened to on the
+    other -> SENDS_TO / RECEIVED_BY over endpoint:tauri-event:<name>. The receiver is the named callback when the
+    listener passes a function by name, else the function that registers the listener. Names built at run time
+    (`window.emit(event_name, ..)`) are not followed."""
+    root = Path(project.root)
+    if not _uses_tauri(root):
+        return {}
+    by_file: dict[str, list] = defaultdict(list)
+    kinds = ("function", "method", "component", "page", "layout", "module", "file", "closure")
+    for n in builder.nodes.values():
+        if n.file and n.kind in kinds:
+            by_file[n.file].append(n)
+    named: dict[str, dict[str, str]] = defaultdict(dict)
+    for f, ns in by_file.items():
+        for n in ns:
+            if n.kind in ("function", "method"):
+                named[f].setdefault(n.name.rsplit("::", 1)[-1].rsplit(".", 1)[-1], n.id)
+    sent = recv = 0
+    dyn = {"send": 0, "recv": 0}           # names passed in a variable: a helper forwards them (`listen(eventName, ..)`)
+    eps = set()
+    for rel in sorted(by_file):
+        is_rs = rel.endswith(".rs")
+        if not (is_rs or rel.endswith(JS_LIKE)) or rel.endswith(".d.ts"):
+            continue
+        try:
+            raw = (root / rel).read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        if is_rs:
+            if "emit" not in raw and "listen" not in raw and "once" not in raw:
+                continue
+            src = strip_comments(raw)
+            if not re.search(r"\btauri\b", src):
+                continue
+        else:
+            if "@tauri-apps/api" not in raw and "__TAURI__" not in raw:
+                continue
+            src = _JS_TOKEN.sub(lambda m: m.group(0) if m.group(0)[0] in "'\"`" else re.sub(r"[^\n]", " ", m.group(0)), raw)
+        side = "core" if is_rs else "webview"
+        lines = lambda pos: src.count("\n", 0, pos) + 1          # noqa: E731
+        dyn["send"] += len(TAURI_EV_DYN_SEND.findall(src))
+        dyn["recv"] += len(TAURI_EV_DYN_RECV.findall(src))
+        for m in (TAURI_EV_RS_SEND if is_rs else TAURI_EV_JS_SEND).finditer(src):
+            name = (m.group(2) or m.group(4)) if is_rs else (m.group(3) or m.group(6))
+            ln = lines(m.start())
+            who = _innermost(builder, by_file, rel, ln)
+            if not who or not name:
+                continue
+            nid = protocol_send(builder, "tauri-event", name, None, who, rel, ln, "exact", process=side,
+                                via=(m.group(1) or m.group(3)) if is_rs else (m.group(1) or m.group(4)))
+            if name.startswith("tauri://"):
+                builder.nodes[nid].attrs["builtin"] = True
+            eps.add(nid)
+            sent += 1
+        for m in (TAURI_EV_RS_RECV if is_rs else TAURI_EV_JS_RECV).finditer(src):
+            name = m.group(2) if is_rs else m.group(3)
+            cb = (m.group(3) or "") if is_rs else (m.group(4) or "")
+            ln = lines(m.start())
+            h = named[rel].get(cb.rsplit("::", 1)[-1]) if cb and not cb.startswith("|") else None
+            h = h or _innermost(builder, by_file, rel, ln)
+            if not h:
+                continue
+            nid = protocol_receive(builder, "tauri-event", name, None, h, rel, ln, "exact", process=side,
+                                   via=m.group(1))
+            if name.startswith("tauri://"):
+                builder.nodes[nid].attrs["builtin"] = True
+            eps.add(nid)
+            recv += 1
+    if dyn["send"] or dyn["recv"]:
+        # the other side may be one of those: no no_receiver / no_sender claim for the literal names
+        for nid in eps:
+            builder.nodes[nid].attrs["dynamic_names"] = dict(dyn)
+    out = {"event_sends": sent, "event_listeners": recv}
+    if dyn["send"] or dyn["recv"]:
+        out["event_dynamic_names"] = dyn
+    return out if sent or recv else {}
+
+
 def apply(project, builder, scanned=None, sends_only: bool = False) -> dict:
     """Index pass: native receivers of every bridge protocol -> RECEIVED_BY edges (+ stub nodes for Java / ObjC) and
     platform marks on their files. Returns the bridges stats (empty when there is no bridge code)."""
     from .platforms import BIG, Cond, _plat_atom, mark
     tauri = tauri_receivers(project, builder)
+    ev = tauri_events(project, builder)
+    if ev:
+        tauri = {**(tauri or {}), **ev}
     st0 = {"tauri": tauri} if tauri else {}
     st = _apply(project, builder, scanned, sends_only, mark, BIG, Cond, _plat_atom)
     if st0 or st:
@@ -1406,9 +1534,31 @@ def project_targets(project, builder) -> list[str]:
         return []
 
 
-def _process_roles(builder, eps, recv, send) -> None:
+def _declared_role(declared: dict, f: str | None) -> str | None:
+    if not f or not declared:
+        return None
+    return next((r for g, r in declared.items() if fnmatch.fnmatch(f, g)), None)
+
+
+def _process_roles(builder, eps, recv, send, declared: dict | None = None) -> None:
     """Electron / Tauri: process role of each file taking part in IPC (attrs.process on its module node): main,
-    preload (exposes a context bridge), renderer (Electron), webview / core (Tauri)."""
+    preload (exposes a context bridge), renderer (Electron), webview / core (Tauri). `.cg.yaml`
+    platforms.processes (glob -> role) wins over the inferred role, for the module and for each send / receive edge
+    in its files (attrs.process_from: config)."""
+    declared = declared or {}
+    if declared:
+        for nid, n in eps.items():
+            if n.attrs.get("protocol") not in PROCESS_PROTOCOLS:
+                continue
+            for e in recv[nid]:
+                dn = builder.nodes.get(e.dst)
+                r = _declared_role(declared, dn.file if dn else None)
+                if r:
+                    e.attrs = {**(e.attrs or {}), "process": r, "process_from": "config"}
+            for e in send[nid]:
+                r = _declared_role(declared, e.file)
+                if r:
+                    e.attrs = {**(e.attrs or {}), "process": r, "process_from": "config"}
     roles = defaultdict(set)
     for nid, n in eps.items():
         if n.attrs.get("protocol") not in PROCESS_PROTOCOLS:
@@ -1421,10 +1571,16 @@ def _process_roles(builder, eps, recv, send) -> None:
             sn = builder.nodes.get(e.src)
             if sn and sn.file and e.attrs.get("process"):
                 roles[sn.file].add(e.attrs["process"])
-    if not roles:
+    if not roles and not declared:
         return
     for n in builder.nodes.values():
-        if n.kind in ("module", "file", "mod", "crate") and n.file in roles:
+        if n.kind not in ("module", "file", "mod", "crate", "component"):
+            continue
+        d = _declared_role(declared, n.file)
+        if d:
+            # declared: also files that take no part in IPC themselves (the renderer's components, the core's services)
+            n.attrs["process"], n.attrs["process_from"] = d, "config"
+        elif n.file in roles and n.kind != "component":
             r = roles[n.file]
             n.attrs["process"] = "preload" if "preload" in r else next(iter(r)) if len(r) == 1 else "+".join(sorted(r))
 
@@ -1457,7 +1613,7 @@ def finalize(project, builder, st: dict, targets: list[str] | None) -> dict:
     proto_recv = defaultdict(set)
     for nid in recv:
         proto_recv[eps[nid].attrs["protocol"]].add(None)
-    _process_roles(builder, eps, recv, send)
+    _process_roles(builder, eps, recv, send, ((project.options.get("config") or {}).get("platforms") or {}).get("processes"))
     # macOS counts only where some bridge module is implemented for it (a Flutter macos/ runner)
     used = {e.attrs.get("platform") for es in recv.values() for e in es}
     mobile = [p for p in (targets or []) if p in ("android", "ios") or (p == "macos" and p in used)]
@@ -1487,7 +1643,8 @@ def finalize(project, builder, st: dict, targets: list[str] | None) -> dict:
             # one app, two processes: a receiver-less channel is a miss when the other side is in the repo at all
             ext_pkg = any(e.attrs.get("external") for e in send[nid] + tsend[nid])
             impl = None if ext_pkg else (proto_recv.get(a["protocol"]) or None)
-        base = a.get("method") in BASE_METHODS.get(a["protocol"], ())
+        base = (a.get("method") in BASE_METHODS.get(a["protocol"], ()) or bool(a.get("builtin"))
+                or bool(a.get("dynamic_names")))
         if base:
             a["base_method"] = True        # the framework's base class implements it on every platform; a module may override
         if a["protocol"] in EVENT_PROTOCOLS and (send[nid] or tsend[nid]) and not recv[nid]:

{cg_code_graph-0.23.6 → cg_code_graph-0.23.8}/cg_code_graph/cli.py

@@ -186,8 +186,9 @@ def main(argv=None):
                                          "(variants missing a target, API differences, references to code missing on a target)")
     p.add_argument("action", nargs="?", default="summary", choices=["summary", "divergence"])
     p.add_argument("--db", required=True); p.add_argument("--target", help="divergence: only findings that affect this target")
-    p.add_argument("--kind", choices=["variants", "api_surface", "missing_callee", "missing_callee_tests"],
-                   help="divergence: one finding kind (missing_callee_tests: from test code on the project-default platforms)")
+    p.add_argument("--kind", choices=["variants", "api_surface", "missing_callee", "missing_callee_tests", "dead_branch"],
+                   help="divergence: one finding kind (missing_callee_tests: from test code on the project-default platforms; "
+                        "dead_branch: nested conditions no target meets together)")
     p.add_argument("--max-items", type=int, default=40); p.add_argument("--json", action="store_true")
     p = sub.add_parser("resolutions", help="every place a concept (e.g. timezone) is resolved, with fallback chains and divergence")
     p.add_argument("concept"); p.add_argument("--db", required=True); p.add_argument("--within", help="substring filter on the owning function fqn (e.g. Report)")
@@ -300,9 +301,12 @@ def main(argv=None):
     p.add_argument("--strip-prefix", action="append", default=[], help="a name prefix one side adds (`Vault` in "
                    "VaultAddEditState for AddEditState), ignored when matching (repeatable)")
     p.add_argument("--structure", action="store_true", help="also pair symbols whose names differ by what they use: "
-                   "shared strings, localization keys, endpoints and already-paired callees, plus rename rules learned "
-                   "from the pairs found (#93); matches carry their evidence")
+                   "shared strings, localization keys, resources, endpoints and already-paired callees, then types by "
+                   "their declared fields, plus rename rules learned from the pairs found (#93); matches carry their "
+                   "evidence")
     p.add_argument("--no-learn", action="store_true", help="with --structure: no learned rename rules")
+    p.add_argument("--both-sides", action="store_true", help="also list the matched pairs and what only --against "
+                   "has (target symbols no source symbol matched)")
     p.add_argument("--write-map", help="with --structure: write the inferred pairs as a --map JSON file to review")
     p.add_argument("--json", action="store_true"); p.add_argument("--max-items", type=int, default=200)
     p = sub.add_parser("lint", help="heuristic lints (#88): `lint async-state` flags stale async results, state with "
@@ -573,7 +577,7 @@ def main(argv=None):
         from . import parity as PA
         mapping = json.loads(open(a.map, encoding="utf-8").read()) if a.map else None
         res = PA.parity(a.db, a.against, mapping=mapping, fuzzy=not a.no_fuzzy, strip_prefixes=a.strip_prefix,
-                        structure=a.structure, learn=not a.no_learn)
+                        structure=a.structure, learn=not a.no_learn, both_sides=a.both_sides)
         if a.write_map:
             with open(a.write_map, "w", encoding="utf-8") as fh:
                 json.dump(PA.rename_map(res), fh, indent=1, sort_keys=True)

cg_code_graph-0.23.8/cg_code_graph/cmake_sources.py

@@ -0,0 +1,322 @@
+"""Per-platform C / C++ source lists from CMake (#111): `if(WIN32) list(APPEND srcs src/win/fs.c)`,
+`if(CMAKE_SYSTEM_NAME MATCHES "Android|Linux") ...`, `target_sources(...)` under a condition. A source file that every
+CMakeLists.txt mentions only under platform conditions is built only where one of them holds; that is the build's own
+answer, so it replaces the directory / file-name guess (src/unix/, linux.c) for that file.
+
+Read without running CMake: `if` / `elseif` / `else` / `endif` over WIN32, APPLE, UNIX, ANDROID, IOS, EMSCRIPTEN,
+MSVC, MINGW, CYGWIN and `CMAKE_SYSTEM_NAME STREQUAL / MATCHES`, with NOT / AND / OR and parentheses. Anything else (an
+option, a version check) is unknown and keeps the file live. Files are named in `list(APPEND|PREPEND ...)`, `set(...)`,
+`target_sources(...)`, `add_library(...)` and `add_executable(...)`, relative to the CMakeLists.txt (a
+`${CMAKE_CURRENT_SOURCE_DIR}/` prefix is understood); names built from other variables are not followed.
+
+compile_db_membership: `.cg.yaml` platforms.compile_commands, one compile_commands.json per target build, is the exact
+answer and wins over the CMake lists."""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+from . import presets
+
+SYSTEM_NAME = {"windows": "Windows", "linux": "Linux", "macos": "Darwin", "ios": "iOS", "android": "Android",
+               "web": "Emscripten", "tvos": "tvOS", "watchos": "watchOS", "visionos": "visionOS"}
+# operating systems outside the known targets, to tell whether a source list also builds the file there
+OTHER = tuple("other:" + n for n in ("FreeBSD", "OpenBSD", "NetBSD", "DragonFly", "AIX", "SunOS", "OS390", "QNX",
+                                     "Haiku", "CYGWIN", "MSYS", "GNU", "OS400"))
+BSDS = {"other:FreeBSD", "other:OpenBSD", "other:NetBSD", "other:DragonFly"}
+SRC = re.compile(r"\.(c|cc|cpp|cxx|m|mm|h|hh|hpp|hxx)$", re.I)
+LISTS = {"list", "set", "target_sources", "add_library", "add_executable"}
+
+
+def _strip_comments(text: str) -> str:
+    text = re.sub(r"#\[(=*)\[.*?\]\1\]", " ", text, flags=re.S)       # bracket comments
+    out = []
+    for line in text.split("\n"):
+        q = False
+        for i, ch in enumerate(line):
+            if ch == '"':
+                q = not q
+            elif ch == "#" and not q:
+                line = line[:i]
+                break
+        out.append(line)
+    return "\n".join(out)
+
+
+def _commands(text: str):
+    """(name, args text, line) for every command call, args with nested parentheses."""
+    i, n = 0, len(text)
+    rx = re.compile(r"([A-Za-z_]\w*)\s*\(")
+    while True:
+        m = rx.search(text, i)
+        if not m:
+            return
+        depth, j, q = 1, m.end(), False
+        while j < n and depth:
+            ch = text[j]
+            if ch == '"':
+                q = not q
+            elif not q and ch == "(":
+                depth += 1
+            elif not q and ch == ")":
+                depth -= 1
+            j += 1
+        yield m.group(1).lower(), text[m.end():j - 1], text.count("\n", 0, m.start()) + 1
+        i = j
+
+
+def _tokens(args: str) -> list[str]:
+    return [a[1:-1] if a.startswith('"') else a for a in re.findall(r'"[^"]*"|\(|\)|[^\s()"]+', args)]
+
+
+# ------------------------------------------------------------------ three-valued condition evaluation per target
+def _var(name: str, p: str):
+    name = re.sub(r"^\$\{(.*)\}$", r"\1", name)
+    u = name.upper()
+    if p.startswith("other:"):
+        if u in ("WIN32", "APPLE", "ANDROID", "IOS", "EMSCRIPTEN", "MSVC", "MINGW", "CMAKE_CL_64", "LINUX"):
+            return False
+        if u == "UNIX":
+            return True
+        if u in ("CYGWIN", "MSYS"):
+            return p == "other:" + u
+        if u == "BSD":
+            return p in BSDS
+    if u == "WIN32":
+        return p == "windows"
+    if u == "APPLE":
+        return p in ("macos", "ios", "tvos", "watchos", "visionos")
+    if u == "UNIX":
+        return p != "windows"
+    if u == "ANDROID":
+        return p == "android"
+    if u == "IOS":
+        return p == "ios"
+    if u == "EMSCRIPTEN":
+        return p == "web"
+    if u in ("MSVC", "MINGW", "CMAKE_CL_64"):
+        return None if p == "windows" else False
+    if u in ("CYGWIN", "MSYS", "BSD"):
+        return False
+    if u == "LINUX":
+        return p == "linux"
+    if u in ("ON", "TRUE", "YES", "Y") or (u.isdigit() and u != "0"):
+        return True
+    if u in ("OFF", "FALSE", "NO", "N", "0", "IGNORE", "NOTFOUND", ""):
+        return False
+    return None
+
+
+def _system(tok: str) -> bool:
+    return re.sub(r"^\$\{(.*)\}$", r"\1", tok) == "CMAKE_SYSTEM_NAME"
+
+
+class _Cond:
+    def __init__(self, toks: list[str]):
+        self.t, self.i = toks, 0
+
+    def peek(self):
+        return self.t[self.i] if self.i < len(self.t) else None
+
+    def take(self):
+        self.i += 1
+        return self.t[self.i - 1]
+
+    def parse(self, p: str):
+        self.i = 0
+        try:
+            v = self.p_or(p)
+        except (IndexError, re.error):
+            return None
+        return v if self.i >= len(self.t) else None
+
+    def p_or(self, p):
+        v = self.p_and(p)
+        while self.peek() == "OR":
+            self.take()
+            w = self.p_and(p)
+            v = True if (v is True or w is True) else (False if (v is False and w is False) else None)
+        return v
+
+    def p_and(self, p):
+        v = self.p_not(p)
+        while self.peek() == "AND":
+            self.take()
+            w = self.p_not(p)
+            v = False if (v is False or w is False) else (True if (v is True and w is True) else None)
+        return v
+
+    def p_not(self, p):
+        if self.peek() == "NOT":
+            self.take()
+            v = self.p_not(p)
+            return None if v is None else not v
+        return self.p_bin(p)
+
+    def p_bin(self, p):
+        tok = self.take()
+        if tok == "(":
+            v = self.p_or(p)
+            if self.take() != ")":
+                raise IndexError
+            return v
+        if tok in ("DEFINED", "EXISTS", "COMMAND", "TARGET", "POLICY", "IS_DIRECTORY", "IS_ABSOLUTE"):
+            self.take()
+            return None
+        op = self.peek()
+        if op in ("STREQUAL", "MATCHES", "EQUAL", "STRLESS", "STRGREATER", "LESS", "GREATER", "IN_LIST",
+                  "VERSION_LESS", "VERSION_GREATER", "VERSION_EQUAL", "VERSION_GREATER_EQUAL", "VERSION_LESS_EQUAL",
+                  "LESS_EQUAL", "GREATER_EQUAL", "STRLESS_EQUAL", "STRGREATER_EQUAL"):
+            self.take()
+            rhs = self.take()
+            sysname = SYSTEM_NAME.get(p) or p.split(":", 1)[-1]
+            if _system(tok) and op == "STREQUAL":
+                return sysname == rhs
+            if _system(tok) and op == "MATCHES":
+                return re.search(rhs, sysname) is not None
+            return None
+        return _var(tok, p)
+
+
+def _values(toks: list[str]) -> dict:
+    from .platforms import KNOWN
+    c = _Cond(toks)
+    return {p: c.parse(p) for p in KNOWN + OTHER}
+
+
+def _and(a: dict, b: dict) -> dict:
+    return {p: False if (a[p] is False or b[p] is False) else (True if (a[p] is True and b[p] is True) else None) for p in a}
+
+
+def _not(a: dict) -> dict:
+    return {p: None if v is None else not v for p, v in a.items()}
+
+
+def _or(a: dict, b: dict) -> dict:
+    return {p: True if (a[p] is True or b[p] is True) else (False if (a[p] is False and b[p] is False) else None) for p in a}
+
+
+# ------------------------------------------------------------------ source membership
+def membership(root: Path, files: set[str]) -> dict[str, dict]:
+    """rel file -> {"values": {target: True / False / None}, "text": first condition, "at": "CMakeLists.txt:12",
+    "mentions": n, "elsewhere": also built on another OS} for the indexed files the CMake lists mention only under
+    platform conditions."""
+    from .platforms import KNOWN
+    root = Path(root)
+    every = {p: True for p in KNOWN + OTHER}
+    skip = presets.skip_dirs("common")
+    seen: dict[str, dict] = {}
+    for d, dirs, names in os.walk(root):
+        dirs[:] = [x for x in dirs if x not in skip and not x.startswith(".")]
+        if "CMakeLists.txt" not in names and not any(n.endswith(".cmake") for n in names):
+            continue
+        for name in sorted(n for n in names if n == "CMakeLists.txt" or n.endswith(".cmake")):
+            path = Path(d) / name
+            try:
+                text = _strip_comments(path.read_text(encoding="utf-8", errors="replace"))
+            except OSError:
+                continue
+            base = Path(d).relative_to(root).as_posix()
+            rel_cm = path.relative_to(root).as_posix()
+            stack: list[list] = []          # [current branch values, values of previous branches, text]
+            body = 0                        # inside function() / macro(): the lists are built where it is called
+            for cmd, args, line in _commands(text):
+                if cmd in ("function", "macro"):
+                    body += 1
+                    continue
+                if cmd in ("endfunction", "endmacro"):
+                    body = max(0, body - 1)
+                    continue
+                if body:
+                    continue
+                if cmd == "if":
+                    v = _values(_tokens(args))
+                    stack.append([v, [v], f"if({args.strip()})"[:120]])
+                elif cmd == "elseif" and stack:
+                    v = _values(_tokens(args))
+                    prev = stack[-1][1]
+                    cur = v
+                    for pv in prev:
+                        cur = _and(cur, _not(pv))
+                    stack[-1] = [cur, prev + [v], f"elseif({args.strip()})"[:120]]
+                elif cmd == "else" and stack:
+                    cur = dict(every)
+                    for pv in stack[-1][1]:
+                        cur = _and(cur, _not(pv))
+                    stack[-1] = [cur, stack[-1][1], "else() of " + stack[-1][2]]
+                elif cmd == "endif" and stack:
+                    stack.pop()
+                elif cmd in LISTS:
+                    cond = dict(every)
+                    for v, _, _ in stack:
+                        cond = _and(cond, v)
+                    for tok in _tokens(args):
+                        tok = re.sub(r"^\$\{(?:CMAKE_CURRENT_SOURCE_DIR|CMAKE_CURRENT_LIST_DIR)\}/", "", tok)
+                        if "$" in tok or not SRC.search(tok) or tok.startswith("/"):
+                            continue
+                        rel = os.path.normpath(os.path.join(base, tok)).replace(os.sep, "/") if base != "." else os.path.normpath(tok).replace(os.sep, "/")
+                        if rel not in files:
+                            continue
+                        s = seen.get(rel)
+                        text_c = " && ".join(t for _, _, t in stack) or "unconditional"
+                        if s is None:
+                            seen[rel] = {"values": cond, "text": text_c, "at": f"{rel_cm}:{line}", "mentions": 1}
+                        else:
+                            s["values"] = _or(s["values"], cond)
+                            s["mentions"] += 1
+    out = {}
+    for f, s in seen.items():
+        vals = {p: s["values"][p] for p in KNOWN}
+        if any(v is False for v in vals.values()):
+            # also built on an OS outside the known targets (a BSD, AIX, Cygwin): its #else branches are live there
+            out[f] = {**s, "values": vals, "elsewhere": any(s["values"][p] is not False for p in OTHER)}
+    return out
+
+
+def tree(values: dict):
+    """A platforms.Cond tree with these per-target values: True where it holds, unknown where it may."""
+    parts = [("atom", "platform", p) for p, v in values.items() if v is True]
+    parts += [("atom", "unknown_on", p) for p, v in values.items() if v is None]
+    if not parts:
+        return ("atom", "never", None)
+    return parts[0] if len(parts) == 1 else ("any", parts)
+
+
+# ------------------------------------------------------------------ compile databases per target
+def compile_db_membership(root: Path, dbs: dict[str, str], files: set[str]) -> dict[str, dict]:
+    """`.cg.yaml` platforms.compile_commands (target -> compile_commands.json of that target's build): a source file
+    is built on the targets whose database compiles it, not on the other listed targets, and unknown on targets
+    without a database. Headers are not compiled on their own and are left out."""
+    from .platforms import KNOWN
+    root = Path(root).resolve()
+    compiled: dict[str, set[str]] = {}
+    for target, path in dbs.items():
+        p = (root / path) if not os.path.isabs(path) else Path(path)
+        try:
+            entries = __import__("json").loads(p.read_text(encoding="utf-8", errors="replace"))
+        except (OSError, ValueError):
+            continue
+        got = set()
+        for e in entries if isinstance(entries, list) else ():
+            f = e.get("file") if isinstance(e, dict) else None
+            if not f:
+                continue
+            fp = Path(f) if os.path.isabs(f) else Path(e.get("directory") or root) / f
+            try:
+                rel = Path(os.path.normpath(fp)).resolve().relative_to(root).as_posix()
+            except (ValueError, OSError):
+                continue
+            got.add(rel)
+        compiled[target] = got
+    if not compiled:
+        return {}
+    out = {}
+    for f in files:
+        if not re.search(r"\.(c|cc|cpp|cxx|c\+\+|m|mm)$", f, re.I):
+            continue
+        vals = {p: (f in compiled[p]) if p in compiled else None for p in KNOWN}
+        if any(v is False for v in vals.values()):
+            on = [p for p in KNOWN if vals[p]]
+            out[f] = {"values": vals, "text": f"compile_commands ({', '.join(on) or 'no listed target'})"}
+    return out