cseq 0.0.1__py3-none-any.whl

cseq/compile_db.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+import shlex
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class CompileCommand:
+    file: Path
+    directory: Path
+    arguments: tuple[str, ...]
+
+
+class CompilationDatabase:
+    def __init__(self, entries: dict[Path, CompileCommand], source_path: Path) -> None:
+        self._entries = entries
+        self.source_path = source_path
+
+    @classmethod
+    def load(cls, path: str | Path) -> "CompilationDatabase":
+        p = Path(path).resolve()
+        raw = json.loads(p.read_text(encoding="utf-8"))
+        if not isinstance(raw, list):
+            raise ValueError("compile_commands.json must contain a JSON array")
+        entries: dict[Path, CompileCommand] = {}
+        for item in raw:
+            if not isinstance(item, dict) or "file" not in item:
+                continue
+            directory = Path(item.get("directory") or p.parent)
+            if not directory.is_absolute():
+                directory = (p.parent / directory).resolve()
+            else:
+                directory = directory.resolve()
+            file_path = Path(str(item["file"]))
+            if not file_path.is_absolute():
+                file_path = (directory / file_path).resolve()
+            else:
+                file_path = file_path.resolve()
+            args = item.get("arguments")
+            if isinstance(args, list):
+                tokens = [str(x) for x in args]
+            elif isinstance(item.get("command"), str):
+                tokens = shlex.split(str(item["command"]), posix=True)
+            else:
+                continue
+            cleaned = _clean_compile_arguments(tokens, file_path, directory)
+            entries[file_path] = CompileCommand(file=file_path, directory=directory, arguments=tuple(cleaned))
+        return cls(entries, p)
+
+    def lookup(self, file: str | Path) -> CompileCommand | None:
+        try:
+            key = Path(file).resolve()
+        except OSError:
+            key = Path(file)
+        return self._entries.get(key)
+
+    def __len__(self) -> int:
+        return len(self._entries)
+
+
+def _same_path_token(token: str, file_path: Path, directory: Path) -> bool:
+    p = Path(token)
+    try:
+        candidate = (directory / p).resolve() if not p.is_absolute() else p.resolve()
+        return candidate == file_path
+    except OSError:
+        return False
+
+
+def _clean_compile_arguments(tokens: list[str], file_path: Path, directory: Path) -> list[str]:
+    """Keep semantic compile flags while dropping build-output/dependency side effects."""
+    if tokens:
+        # The first token is normally the compiler executable.
+        tokens = tokens[1:]
+    out: list[str] = []
+    i = 0
+    takes_value_and_drop = {"-o", "-MF", "-MT", "-MQ", "-MJ"}
+    standalone_drop = {"-c", "-MD", "-MMD", "-MP", "-MG", "-MM", "-M", "-E", "-S"}
+    while i < len(tokens):
+        tok = tokens[i]
+        if tok in takes_value_and_drop:
+            i += 2
+            continue
+        if tok in standalone_drop:
+            i += 1
+            continue
+        if any(tok.startswith(prefix) and tok != prefix for prefix in ("-o", "-MF", "-MT", "-MQ", "-MJ")):
+            i += 1
+            continue
+        if _same_path_token(tok, file_path, directory):
+            i += 1
+            continue
+        out.append(tok)
+        i += 1
+    return out

cseq/config.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import tomllib
+
+
+@dataclass(frozen=True, slots=True)
+class CpuPreprocessorRule:
+    when_defined: str
+    assign_group: str | None = None
+    assign_cpu: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class CpuPathRule:
+    glob: str
+    assign_group: str | None = None
+    assign_cpu: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class CpuOverrideRule:
+    file: str
+    assign_group: str | None = None
+    assign_cpu: str | None = None
+
+
+@dataclass(slots=True)
+class CseqConfig:
+    path: Path | None = None
+    cpu_groups: dict[str, tuple[str, ...]] = field(default_factory=dict)
+    preprocessor_rules: list[CpuPreprocessorRule] = field(default_factory=list)
+    path_rules: list[CpuPathRule] = field(default_factory=list)
+    override_rules: list[CpuOverrideRule] = field(default_factory=list)
+    configurations: dict[str, tuple[str, ...]] = field(default_factory=dict)
+    plugins_enabled: tuple[str, ...] = ()
+
+    @classmethod
+    def empty(cls) -> "CseqConfig":
+        return cls()
+
+    @classmethod
+    def load(cls, path: str | Path) -> "CseqConfig":
+        p = Path(path)
+        data = tomllib.loads(p.read_text(encoding="utf-8"))
+        cfg = cls(path=p.resolve())
+        for name, value in (data.get("cpu_groups") or {}).items():
+            cfg.cpu_groups[str(name)] = tuple(str(x) for x in (value or {}).get("members", []))
+        cpu_rules = data.get("cpu_rules") or {}
+        for r in cpu_rules.get("preprocessor", []) or []:
+            cfg.preprocessor_rules.append(CpuPreprocessorRule(str(r["when_defined"]), _opt(r, "assign_group"), _opt(r, "assign_cpu")))
+        for r in cpu_rules.get("path", []) or []:
+            cfg.path_rules.append(CpuPathRule(str(r["glob"]), _opt(r, "assign_group"), _opt(r, "assign_cpu")))
+        for r in cpu_rules.get("override", []) or []:
+            cfg.override_rules.append(CpuOverrideRule(str(r["file"]), _opt(r, "assign_group"), _opt(r, "assign_cpu")))
+        for name, value in (data.get("configurations") or {}).items():
+            cfg.configurations[str(name)] = tuple(str(x) for x in (value or {}).get("defines", []))
+        plugins = data.get("plugins") or {}
+        cfg.plugins_enabled = tuple(str(x) for x in (plugins.get("enabled") or []))
+        return cfg
+
+    def defines_for(self, configuration: str | None, extra_defines: tuple[str, ...] = ()) -> tuple[str, ...]:
+        merged: list[str] = []
+        if configuration:
+            if configuration not in self.configurations:
+                raise ValueError(f"unknown configuration: {configuration}")
+            merged.extend(self.configurations[configuration])
+        merged.extend(extra_defines)
+        return tuple(dict.fromkeys(merged))
+
+
+def _opt(mapping: dict, key: str) -> str | None:
+    value = mapping.get(key)
+    return str(value) if value is not None else None
+
+
+def validate_config(config: CseqConfig) -> list[dict[str, str]]:
+    """Return structured configuration diagnostics without mutating the config."""
+    issues: list[dict[str, str]] = []
+    known_groups = set(config.cpu_groups)
+    for kind, rules in (
+        ("preprocessor", config.preprocessor_rules),
+        ("path", config.path_rules),
+        ("override", config.override_rules),
+    ):
+        seen: set[tuple[str, str | None, str | None]] = set()
+        for rule in rules:
+            selector = getattr(rule, "when_defined", None) or getattr(rule, "glob", None) or getattr(rule, "file", None) or ""
+            key = (str(selector), getattr(rule, "assign_group", None), getattr(rule, "assign_cpu", None))
+            if key in seen:
+                issues.append({"severity": "warning", "code": "DUPLICATE_RULE", "message": f"duplicate {kind} rule: {selector}"})
+            seen.add(key)
+            group = getattr(rule, "assign_group", None)
+            cpu = getattr(rule, "assign_cpu", None)
+            if group and group not in known_groups:
+                issues.append({"severity": "error", "code": "UNKNOWN_CPU_GROUP", "message": f"{kind} rule references unknown group: {group}"})
+            if group and cpu:
+                issues.append({"severity": "error", "code": "AMBIGUOUS_ASSIGNMENT", "message": f"{kind} rule assigns both group and cpu: {selector}"})
+            if not group and not cpu:
+                issues.append({"severity": "error", "code": "MISSING_ASSIGNMENT", "message": f"{kind} rule has no assignment: {selector}"})
+    for name, members in config.cpu_groups.items():
+        if not members:
+            issues.append({"severity": "warning", "code": "EMPTY_CPU_GROUP", "message": f"CPU group has no members: {name}"})
+    return issues
+
+
+def default_config_text(*, compile_commands_present: bool = False) -> str:
+    lines = [
+        '# cseq configuration',
+        '# Generated conservatively. Company-specific CPU/RTOS semantics are not guessed.',
+        '',
+        '[project]',
+        'entries = ["main"]',
+        '',
+        '[parser]',
+        'dialect = "auto"',
+        f'compile_commands = "{"auto" if compile_commands_present else "none"}"',
+        'tolerant = true',
+        '',
+        '[analysis]',
+        'indirect_calls = true',
+        '',
+        '[sequence]',
+        'external_calls = "self"',
+        '',
+        '[html]',
+        'mode = "auto"',
+        '',
+        '[plugins]',
+        'enabled = []',
+        '',
+        '# Example only; uncomment and rename if needed.',
+        '# [cpu_groups.CPU_GROUP_A]',
+        '# members = ["CPU_A1", "CPU_A2"]',
+        '',
+    ]
+    return '\n'.join(lines)

cseq/cpu_rules.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+
+from .config import CseqConfig
+from .model import CpuEvidenceLayer, CpuEvidenceRecord, CpuValueKind, ProjectIndex
+
+
+def apply_cpu_rules(index: ProjectIndex, config: CseqConfig, defined_macros: tuple[str, ...]) -> None:
+    if not config.path_rules and not config.override_rules and not config.preprocessor_rules:
+        return
+    defined_names = {_macro_name(x) for x in defined_macros}
+
+    for fn in index.functions():
+        path = fn.source_path.replace("\\", "/")
+        static_records: list[CpuEvidenceRecord] = []
+        for rule in config.path_rules:
+            if PurePosixPath(path).match(rule.glob):
+                rec = _record(fn.qualified_id, CpuEvidenceLayer.STATIC_AFFINITY, rule.assign_group, rule.assign_cpu, f"path:{rule.glob}")
+                if rec:
+                    static_records.append(rec)
+
+        # An explicit file override wins *within the static-affinity layer*.
+        override_records: list[CpuEvidenceRecord] = []
+        for rule in config.override_rules:
+            if path == rule.file.replace("\\", "/"):
+                rec = _record(fn.qualified_id, CpuEvidenceLayer.STATIC_AFFINITY, rule.assign_group, rule.assign_cpu, f"override:{rule.file}", True)
+                if rec:
+                    override_records.append(rec)
+        index.cpu_evidence.extend(override_records or static_records)
+
+        for rule in config.preprocessor_rules:
+            if rule.when_defined in defined_names:
+                rec = _record(fn.qualified_id, CpuEvidenceLayer.BUILD_DOMAIN, rule.assign_group, rule.assign_cpu, f"define:{rule.when_defined}")
+                if rec:
+                    index.cpu_evidence.append(rec)
+
+
+def _record(function_id: str, layer: CpuEvidenceLayer, group: str | None, cpu: str | None, provenance: str, override: bool = False) -> CpuEvidenceRecord | None:
+    if cpu:
+        return CpuEvidenceRecord(function_id, layer, CpuValueKind.CPU, cpu, provenance, override)
+    if group:
+        return CpuEvidenceRecord(function_id, layer, CpuValueKind.CPU_GROUP, group, provenance, override)
+    return None
+
+
+def _macro_name(value: str) -> str:
+    return value.split("=", 1)[0]

cseq/dependencies.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from hashlib import sha256
+from pathlib import Path
+import json
+import re
+
+from .model import TranslationUnit
+from .source_index import SourceFingerprintIndex
+
+_INCLUDE_RE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]+)[>"]', re.MULTILINE)
+
+
+@dataclass(frozen=True, slots=True)
+class IncludeDependency:
+    spelling: str
+    resolved_path: str | None
+    content_hash: str | None
+    quoted: bool = False
+    absolute_path: str | None = None
+
+
+def _hash_file(path: Path) -> str:
+    h = sha256()
+    with path.open('rb') as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _include_dirs(tu: TranslationUnit) -> list[Path]:
+    result: list[Path] = []
+    args = list(tu.arguments)
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        value: str | None = None
+        if arg in {'-I', '-isystem'} and i + 1 < len(args):
+            value = args[i + 1]
+            i += 1
+        elif arg.startswith('-I') and len(arg) > 2:
+            value = arg[2:]
+        elif arg.startswith('-isystem') and len(arg) > len('-isystem'):
+            value = arg[len('-isystem'):]
+        if value:
+            p = Path(value)
+            if not p.is_absolute():
+                p = (tu.working_directory or tu.source.path.parent) / p
+            result.append(p.resolve())
+        i += 1
+    return result
+
+
+def _resolve_include(name: str, quoted: bool, current: Path, tu: TranslationUnit) -> Path | None:
+    candidates: list[Path] = []
+    if quoted:
+        candidates.append(current.parent / name)
+    candidates.extend(p / name for p in _include_dirs(tu))
+    if tu.working_directory is not None:
+        candidates.append(tu.working_directory / name)
+    for candidate in candidates:
+        try:
+            if candidate.is_file():
+                return candidate.resolve()
+        except OSError:
+            continue
+    return None
+
+
+def _context_hash(tu: TranslationUnit) -> str:
+    payload = {
+        'working_directory': str((tu.working_directory or tu.source.path.parent).resolve()),
+        'arguments': list(tu.arguments),
+        'configuration': tu.configuration_name,
+    }
+    return sha256(json.dumps(payload, sort_keys=True, separators=(',', ':')).encode('utf-8')).hexdigest()
+
+
+def collect_include_dependencies(
+    tu: TranslationUnit,
+    fingerprint_index: SourceFingerprintIndex | None = None,
+) -> tuple[IncludeDependency, ...]:
+    """Collect reachable textual include dependencies for cache invalidation."""
+    visited: set[Path] = set()
+    records: dict[tuple[str, str | None], IncludeDependency] = {}
+
+    def visit(path: Path) -> None:
+        try:
+            real = path.resolve()
+        except OSError:
+            real = path
+        if real in visited:
+            return
+        visited.add(real)
+        try:
+            if real == tu.source.path.resolve() and tu.source_text is not None:
+                text = tu.source_text
+            else:
+                text = real.read_text(encoding='utf-8', errors='replace')
+        except OSError:
+            return
+        for m in _INCLUDE_RE.finditer(text):
+            quoted = m.group(1) == '"'
+            spelling = m.group(2).strip()
+            resolved = _resolve_include(spelling, quoted, real, tu)
+            if resolved is None:
+                rec = IncludeDependency(
+                    spelling=spelling, resolved_path=None, content_hash=None,
+                    quoted=quoted, absolute_path=None,
+                )
+                records[(spelling, None)] = rec
+                continue
+            try:
+                rel = resolved.relative_to(tu.working_directory).as_posix() if tu.working_directory else str(resolved)
+            except ValueError:
+                rel = str(resolved)
+            digest = fingerprint_index.content_hash(resolved) if fingerprint_index is not None else _hash_file(resolved)
+            rec = IncludeDependency(
+                spelling=spelling, resolved_path=rel, content_hash=digest,
+                quoted=quoted, absolute_path=str(resolved),
+            )
+            records[(spelling, rel)] = rec
+            visit(resolved)
+
+    visit(tu.source.path)
+    return tuple(sorted(records.values(), key=lambda r: (r.resolved_path or '', r.spelling)))
+
+
+def _fingerprint(deps: tuple[IncludeDependency, ...]) -> str:
+    h = sha256()
+    for dep in deps:
+        h.update(dep.spelling.encode('utf-8', errors='surrogatepass'))
+        h.update(b'\0')
+        h.update((dep.resolved_path or '<unresolved>').encode('utf-8', errors='surrogatepass'))
+        h.update(b'\0')
+        h.update((dep.content_hash or '<missing>').encode('ascii'))
+        h.update(b'\n')
+    return h.hexdigest()
+
+
+def _snapshot_records(deps: tuple[IncludeDependency, ...]) -> list[dict]:
+    return [
+        {
+            'spelling': d.spelling,
+            'resolved_path': d.resolved_path,
+            'absolute_path': d.absolute_path,
+            'content_hash': d.content_hash,
+            'quoted': d.quoted,
+        }
+        for d in deps
+    ]
+
+
+def _snapshot_valid(tu: TranslationUnit, records: list[dict], index: SourceFingerprintIndex) -> bool:
+    for rec in records:
+        spelling = str(rec.get('spelling') or '')
+        quoted = bool(rec.get('quoted'))
+        absolute = rec.get('absolute_path')
+        old_hash = rec.get('content_hash')
+        if absolute:
+            path = Path(str(absolute))
+            try:
+                if not path.is_file() or index.content_hash(path) != old_hash:
+                    return False
+            except OSError:
+                return False
+        else:
+            # Missing includes are part of cache identity. If they become
+            # resolvable, invalidate the old snapshot without reading source.
+            if _resolve_include(spelling, quoted, tu.source.path, tu) is not None:
+                return False
+    return True
+
+
+def include_dependency_fingerprint(
+    tu: TranslationUnit,
+    fingerprint_index: SourceFingerprintIndex | None = None,
+) -> str:
+    if fingerprint_index is not None:
+        context_hash = _context_hash(tu)
+        snapshot = fingerprint_index.dependency_snapshot(
+            tu.source.project_relative_path, context_hash, tu.source.content_hash
+        )
+        if snapshot is not None:
+            fingerprint, records = snapshot
+            if _snapshot_valid(tu, records, fingerprint_index):
+                fingerprint_index.note_dependency_hit()
+                return fingerprint
+            fingerprint_index.note_dependency_miss()
+        deps = collect_include_dependencies(tu, fingerprint_index)
+        fingerprint = _fingerprint(deps)
+        fingerprint_index.put_dependency_snapshot(
+            tu.source.project_relative_path,
+            context_hash,
+            tu.source.content_hash,
+            fingerprint,
+            _snapshot_records(deps),
+        )
+        fingerprint_index.commit()
+        return fingerprint
+    return _fingerprint(collect_include_dependencies(tu))

cseq/docs.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from importlib import resources
+from pathlib import Path
+import sys
+_DOCS={"readme":("README.md","README.md"),"design":("design.md","シーケンス解析_設計書.md"),"report":("verification_report.html","実装・検証成績書.html")}
+def document_bytes(kind:str)->bytes:
+    try: resource_name,_=_DOCS[kind]
+    except KeyError as exc: raise ValueError(f"unknown document kind: {kind}") from exc
+    return resources.files("cseq").joinpath("resources",resource_name).read_bytes()
+def export_document(kind:str,output:str|Path|None=None)->Path|None:
+    data=document_bytes(kind)
+    if output is None:
+        if hasattr(sys.stdout,"buffer"): sys.stdout.buffer.write(data)
+        else: sys.stdout.write(data.decode("utf-8"))
+        return None
+    out=Path(output); out.parent.mkdir(parents=True,exist_ok=True); out.write_bytes(data); return out
+def export_all(output_dir:str|Path)->list[Path]:
+    root=Path(output_dir); root.mkdir(parents=True,exist_ok=True); out=[]
+    for kind,(_,filename) in _DOCS.items():
+        p=root/filename; export_document(kind,p); out.append(p)
+    return out

cseq/dwarf.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import bisect
+import re
+import subprocess
+import shutil
+import os
+
+from .model import DwarfEvidenceRecord, ProjectIndex
+
+_LINE_RE = re.compile(r"^(.+?)\s+(\d+|-)\s+0x([0-9A-Fa-f]+)(?:\s+.*)?$")
+
+
+@dataclass(frozen=True, slots=True)
+class DwarfLineEntry:
+    file: str
+    line: int | None
+    address: int
+
+
+@dataclass(frozen=True, slots=True)
+class DwarfLineIndex:
+    path: str
+    entries: tuple[DwarfLineEntry, ...]
+
+    def resolve_address(self, runtime_address: int, *, load_bias: int = 0) -> DwarfLineEntry | None:
+        address = int(runtime_address) - int(load_bias)
+        starts = [e.address for e in self.entries]
+        pos = bisect.bisect_right(starts, address) - 1
+        if pos < 0:
+            return None
+        entry = self.entries[pos]
+        if entry.line is None:
+            return None
+        if pos + 1 < len(self.entries) and address >= self.entries[pos + 1].address:
+            return None
+        return entry
+
+
+def _existing_executable_path(path: str | Path) -> Path:
+    p = Path(path)
+    if p.exists():
+        return p
+    if os.name == "nt":
+        candidate = Path(str(p) + ".exe")
+        if candidate.exists():
+            return candidate
+    return p
+
+
+def load_dwarf_lines(path: str | Path, *, readelf: str = "readelf") -> DwarfLineIndex:
+    p = _existing_executable_path(path)
+    is_pe = p.read_bytes()[:2] == b"MZ"
+    if is_pe:
+        tool = shutil.which("objdump") or shutil.which("llvm-objdump") or "objdump"
+        command = [tool, "--dwarf=decodedline", str(p)]
+    else:
+        tool = shutil.which(readelf) or (shutil.which("llvm-readelf") if readelf == "readelf" else None) or readelf
+        command = [tool, "--debug-dump=decodedline", str(p)]
+    proc = subprocess.run(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        raise RuntimeError(f"DWARF line reader failed for {p}: {proc.stderr.strip()}")
+    entries: list[DwarfLineEntry] = []
+    for raw in proc.stdout.splitlines():
+        m = _LINE_RE.match(raw.rstrip())
+        if not m:
+            continue
+        file = m.group(1).strip()
+        line = None if m.group(2) == "-" else int(m.group(2))
+        entries.append(DwarfLineEntry(file=file, line=line, address=int(m.group(3), 16)))
+    entries.sort(key=lambda x: x.address)
+    return DwarfLineIndex(str(p), tuple(entries))
+
+
+def apply_dwarf_evidence(index: ProjectIndex, dwarf: DwarfLineIndex) -> list[DwarfEvidenceRecord]:
+    """Bind DWARF line rows to source functions only when file/range is unambiguous."""
+    functions = list(index.functions())
+    out: list[DwarfEvidenceRecord] = []
+    seen: set[tuple[str, int]] = set()
+    for entry in dwarf.entries:
+        if entry.line is None:
+            continue
+        basename = Path(entry.file).name
+        matches = [
+            f for f in functions
+            if Path(f.source_path).name == basename
+            and f.source_range.start_line is not None
+            and f.source_range.end_line is not None
+            and f.source_range.start_line <= entry.line <= f.source_range.end_line
+        ]
+        if len(matches) != 1:
+            continue
+        fn = matches[0]
+        key = (fn.qualified_id, entry.address)
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(DwarfEvidenceRecord(
+            function_id=fn.qualified_id,
+            source_path=fn.source_path,
+            line=entry.line,
+            address=entry.address,
+            dwarf_file=entry.file,
+            provenance=f"dwarf:{dwarf.path}",
+        ))
+    index.dwarf_evidence.extend(out)
+    return out