declib 3.8.0__py3-none-any.whl

declib/api/server_registry.py

@@ -0,0 +1,171 @@
+"""
+Server registry for declib DecompilerServer instances.
+
+Each running server writes a small JSON descriptor into a shared registry
+directory so that the `decompiler` CLI (and DecompilerClient.discover) can
+find, filter, and connect to the right server instance. Stale records
+(servers whose process has exited or whose socket has vanished) are pruned
+on read.
+"""
+import json
+import logging
+import os
+import tempfile
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import psutil
+from platformdirs import user_state_dir
+
+_l = logging.getLogger(__name__)
+
+
+def _registry_dir() -> Path:
+    """Return the registry directory, creating it if missing."""
+    env_override = os.environ.get("DECLIB_SERVER_REGISTRY")
+    if env_override:
+        path = Path(env_override)
+    else:
+        path = Path(user_state_dir("declib")) / "servers"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def new_server_id() -> str:
+    """Generate a short unique ID for a new server."""
+    return uuid.uuid4().hex[:10]
+
+
+def default_socket_path(server_id: str) -> str:
+    """Compute a default socket path for a server with the given ID."""
+    temp_dir = Path(tempfile.gettempdir()) / f"declib_server_{server_id}"
+    temp_dir.mkdir(parents=True, exist_ok=True)
+    return str(temp_dir / "decompiler.sock")
+
+
+def registry_path(server_id: str) -> Path:
+    return _registry_dir() / f"{server_id}.json"
+
+
+def register_server(info: Dict) -> Path:
+    """Write a server descriptor into the registry. Required keys: id, socket_path."""
+    server_id = info["id"]
+    path = registry_path(server_id)
+    payload = dict(info)
+    payload.setdefault("started_at", time.time())
+    payload.setdefault("pid", os.getpid())
+    tmp_path = path.with_suffix(".json.tmp")
+    with open(tmp_path, "w") as f:
+        json.dump(payload, f, indent=2, default=str)
+    os.replace(tmp_path, path)
+    return path
+
+
+def unregister_server(server_id: str) -> bool:
+    path = registry_path(server_id)
+    try:
+        path.unlink()
+        return True
+    except FileNotFoundError:
+        return False
+
+
+def _is_record_live(record: Dict) -> bool:
+    pid = record.get("pid")
+    socket_path = record.get("socket_path")
+    if not socket_path or not os.path.exists(socket_path):
+        return False
+    if pid is not None:
+        try:
+            if not psutil.pid_exists(int(pid)):
+                return False
+        except Exception:
+            return False
+    return True
+
+
+def list_servers(prune_stale: bool = True) -> List[Dict]:
+    """Return all server records, optionally dropping and removing stale entries."""
+    records: List[Dict] = []
+    try:
+        entries = sorted(_registry_dir().glob("*.json"))
+    except FileNotFoundError:
+        return []
+
+    for entry in entries:
+        try:
+            with open(entry, "r") as f:
+                record = json.load(f)
+        except Exception as exc:
+            _l.debug("Failed to read server registry file %s: %s", entry, exc)
+            continue
+
+        if prune_stale and not _is_record_live(record):
+            try:
+                entry.unlink()
+            except FileNotFoundError:
+                pass
+            except Exception as exc:
+                _l.debug("Failed to remove stale registry entry %s: %s", entry, exc)
+            continue
+
+        records.append(record)
+    return records
+
+
+def find_server(
+    server_id: Optional[str] = None,
+    binary_path: Optional[str] = None,
+    binary_hash: Optional[str] = None,
+    backend: Optional[str] = None,
+) -> Optional[Dict]:
+    """Return the first server record matching all provided filters, else None."""
+    binary_path_resolved = str(Path(binary_path).expanduser().resolve()) if binary_path else None
+    for record in list_servers():
+        if server_id and record.get("id") != server_id:
+            continue
+        if binary_path_resolved:
+            record_path = record.get("binary_path")
+            if not record_path:
+                continue
+            try:
+                if str(Path(record_path).expanduser().resolve()) != binary_path_resolved:
+                    continue
+            except Exception:
+                if record_path != binary_path_resolved:
+                    continue
+        if binary_hash and record.get("binary_hash") != binary_hash:
+            continue
+        if backend and record.get("backend") != backend:
+            continue
+        return record
+    return None
+
+
+def find_servers(
+    binary_path: Optional[str] = None,
+    binary_hash: Optional[str] = None,
+    backend: Optional[str] = None,
+) -> List[Dict]:
+    """Return all server records matching the provided filters."""
+    matches: List[Dict] = []
+    binary_path_resolved = str(Path(binary_path).expanduser().resolve()) if binary_path else None
+    for record in list_servers():
+        if binary_path_resolved:
+            record_path = record.get("binary_path")
+            if not record_path:
+                continue
+            try:
+                if str(Path(record_path).expanduser().resolve()) != binary_path_resolved:
+                    continue
+            except Exception:
+                if record_path != binary_path_resolved:
+                    continue
+        if binary_hash and record.get("binary_hash") != binary_hash:
+            continue
+        if backend and record.get("backend") != backend:
+            continue
+        matches.append(record)
+    return matches

declib/api/type_definition_parser.py

@@ -0,0 +1,201 @@
+"""
+Parse a single C type *definition* string into the matching declib artifact.
+
+Unlike ``CTypeParser`` (declib/api/type_parser.py), which is deliberately scoped to
+type *expressions* ("int *", "struct Foo *"), this module handles full type
+*definitions* with bodies:
+
+  - ``struct Name { <members> };`` -> :class:`declib.artifacts.Struct`
+  - ``enum Name { A, B=5, C };``    -> :class:`declib.artifacts.Enum`
+  - ``typedef <type> Name;``        -> :class:`declib.artifacts.Typedef`
+
+It is intentionally decompiler-free and unit-testable: the heavy lifting is done by
+``pycparser`` (already a declib dependency) for the AST and member type-string
+rendering, and by ``CTypeParser`` for member sizing. The resulting artifact is then
+applied to a decompiler via the normal ``deci.structs[name] = struct`` /
+``deci.set_artifact(...)`` path, which is portable across every backend.
+"""
+import logging
+import re
+from typing import Optional, Union
+
+import pycparser
+from pycparser import c_ast, c_generator
+from pycparser.c_parser import ParseError
+
+from declib.artifacts import Struct, StructMember, Enum, Typedef
+from declib.api.type_parser import CTypeParser
+
+_l = logging.getLogger(__name__)
+
+# Reuse single instances; both are stateless across parses.
+_GENERATOR = c_generator.CGenerator()
+_PARSER = pycparser.CParser()
+_DEFAULT_TYPE_PARSER = CTypeParser()
+
+# Member natural alignment is its own size in System V, capped at the platform
+# word width (pointers/long are 8 in CTypeParser's defaults).
+_MAX_ALIGN = 8
+
+
+class TypeDefinitionParseError(ValueError):
+    """Raised when a C type-definition string cannot be turned into a declib artifact."""
+
+
+def parse_type_definition(
+    text: str,
+    type_parser: Optional[CTypeParser] = None,
+) -> Union[Struct, Enum, Typedef]:
+    """
+    Parse a single C type *definition* into the matching declib artifact.
+
+    Supports exactly one top-level definition: a named ``struct``, ``enum``, or
+    ``typedef``. Raises :class:`TypeDefinitionParseError` on anything unparseable,
+    anonymous, multi-definition, or otherwise unsupported.
+
+    >>> parse_type_definition("struct Point { int x; int y; }")
+    <Struct: Point membs=2 (0x8)>
+    """
+    tp = type_parser or _DEFAULT_TYPE_PARSER
+    ast = _parse_ast(_normalize(text))
+    top = ast.ext[0]
+
+    if isinstance(top, c_ast.Typedef):
+        return _typedef_from_ast(top)
+
+    # struct/enum arrive wrapped in a Decl whose .type is the Struct/Enum node
+    if isinstance(top, c_ast.Decl):
+        inner = top.type
+        if isinstance(inner, c_ast.Struct):
+            return _struct_from_ast(inner, tp)
+        if isinstance(inner, c_ast.Enum):
+            return _enum_from_ast(inner, tp)
+
+    raise TypeDefinitionParseError(
+        f"Unsupported top-level definition: {type(top).__name__}. "
+        "Expected a named struct, enum, or typedef."
+    )
+
+
+def _normalize(text: str) -> str:
+    if not text or not text.strip():
+        raise TypeDefinitionParseError("Empty type definition.")
+    # strip C comments (same approach as CTypeParser.parse_type_with_name)
+    text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
+    text = re.sub(r"//.*?$", "", text, flags=re.MULTILINE)
+    text = text.strip()
+    if not text.endswith(";"):
+        text += ";"
+    return text
+
+
+def _parse_ast(text: str) -> c_ast.FileAST:
+    try:
+        ast = _PARSER.parse(text)
+    except ParseError as exc:
+        raise TypeDefinitionParseError(f"could not parse C definition: {exc}")
+    if not ast.ext:
+        raise TypeDefinitionParseError("no type definition found.")
+    if len(ast.ext) != 1:
+        raise TypeDefinitionParseError(
+            "expected exactly one type definition, got "
+            f"{len(ast.ext)}. Define one type at a time."
+        )
+    return ast
+
+
+def _render_type(node) -> str:
+    """Render a member/typedef type node back to a C type string, e.g. "char *"."""
+    rendered = _GENERATOR.visit(node).strip()
+    if "\n" in rendered or "{" in rendered:
+        raise TypeDefinitionParseError(
+            "inline/nested type definitions are unsupported here; define the "
+            "inner type separately and reference it by name."
+        )
+    return rendered
+
+
+def _member_size(tp: CTypeParser, type_str: str) -> int:
+    ct = tp.parse_type(type_str)
+    if ct is None or not ct.size:
+        # Unknown, user-defined non-pointer type (e.g. "struct Bar" before Bar
+        # exists): we cannot reliably size it, so reject rather than emit a
+        # 0-size member that would corrupt every subsequent offset.
+        raise TypeDefinitionParseError(
+            f"could not determine the size of member type {type_str!r}. "
+            "Define referenced types first, or use a pointer/primitive."
+        )
+    return ct.size
+
+
+def _struct_from_ast(struct_node: c_ast.Struct, tp: CTypeParser) -> Struct:
+    if not struct_node.name:
+        raise TypeDefinitionParseError(
+            "anonymous structs are not supported; give the struct a name."
+        )
+    if not struct_node.decls:
+        raise TypeDefinitionParseError(
+            f"struct {struct_node.name!r} has no members to define."
+        )
+
+    members = {}
+    offset = 0
+    max_align = 1
+    for decl in struct_node.decls:
+        if decl.name is None:
+            raise TypeDefinitionParseError(
+                f"unnamed member in struct {struct_node.name!r} is unsupported."
+            )
+        type_str = _render_type(decl.type)
+        size = _member_size(tp, type_str)
+        align = min(size, _MAX_ALIGN) if size else 1
+        # round the running offset up to this member's natural alignment
+        if align > 1 and offset % align:
+            offset += align - (offset % align)
+        members[offset] = StructMember(
+            name=decl.name, offset=offset, type_=type_str, size=size,
+        )
+        offset += size
+        max_align = max(max_align, align)
+
+    total = offset
+    if max_align > 1 and total % max_align:
+        total += max_align - (total % max_align)
+
+    return Struct(name=struct_node.name, size=total, members=members)
+
+
+def _enum_from_ast(enum_node: c_ast.Enum, tp: CTypeParser) -> Enum:
+    if not enum_node.name:
+        raise TypeDefinitionParseError(
+            "anonymous enums are not supported; give the enum a name."
+        )
+    if not enum_node.values or not enum_node.values.enumerators:
+        raise TypeDefinitionParseError(
+            f"enum {enum_node.name!r} has no members to define."
+        )
+
+    members = {}
+    next_val = 0
+    for en in enum_node.values.enumerators:
+        if en.value is None:
+            val = next_val
+        else:
+            try:
+                val = tp._parse_const(en.value)
+            except Exception:
+                raise TypeDefinitionParseError(
+                    f"could not evaluate enum value for {en.name!r}."
+                )
+        members[en.name] = val
+        next_val = val + 1
+
+    return Enum(name=enum_node.name, members=members)
+
+
+def _typedef_from_ast(typedef_node: c_ast.Typedef) -> Typedef:
+    name = typedef_node.name
+    if not name:
+        raise TypeDefinitionParseError("typedef is missing a name.")
+    type_str = _render_type(typedef_node.type)
+    return Typedef(name=name, type_=type_str)