efrog 0.4.0__py3-none-any.whl

efrog/__init__.py

@@ -0,0 +1,46 @@
+"""eFrog — universal decompiler for the EML substrate.
+
+    Forge compiles math into everything.
+    eFrog compiles everything into math.
+
+Phase E1 ships the Python AST decompiler. Later phases add C / Rust /
+JS / MATLAB / CUDA / shaders / Verilog / Solidity, then symbolic
+extraction with loops + conditionals, then live-audio decomposition.
+"""
+
+__version__ = "0.4.0a0"
+
+from .decompilers.c import decompile_c_source
+from .decompilers.javascript import decompile_javascript_source
+from .decompilers.matlab import decompile_matlab_source
+from .decompilers.python import decompile_python_source
+from .decompilers.rust import decompile_rust_source
+from .genome import classify_function, classify_module, render_genome
+from .lean import render_lean
+from .mic import decompose_buffer, decompose_microphone, render_mic
+from .optimize import optimize_function, optimize_module, render_optimize
+from .profile import profile_module, render_profile
+from .verify import render_verify, verify_python_file
+
+__all__ = [
+    "__version__",
+    "decompile_python_source",
+    "decompile_c_source",
+    "decompile_javascript_source",
+    "decompile_matlab_source",
+    "decompile_rust_source",
+    "profile_module",
+    "render_profile",
+    "verify_python_file",
+    "render_verify",
+    "classify_module",
+    "classify_function",
+    "render_genome",
+    "render_lean",
+    "optimize_module",
+    "optimize_function",
+    "render_optimize",
+    "decompose_microphone",
+    "decompose_buffer",
+    "render_mic",
+]

efrog/cli.py

@@ -0,0 +1,232 @@
+"""eFrog CLI entry point. E1: Python. E2: + C, --profile, --verify."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from typing import Sequence
+
+from . import __version__
+from .decompilers.c import decompile_c_file
+from .decompilers.javascript import decompile_javascript_file
+from .decompilers.matlab import decompile_matlab_file
+from .decompilers.python import EFrogError, decompile_python_file
+from .decompilers.rust import decompile_rust_file
+from .genome import render_genome
+from .lean import render_lean
+from .mic import decompose_microphone, render_mic
+from .optimize import optimize_module, render_optimize
+from .profile import render_profile
+from .verify import render_verify, verify_python_file
+
+
+_LANG_BY_EXT = {
+    ".py":    "python",
+    ".c":     "c",
+    ".js":    "javascript",
+    ".mjs":   "javascript",
+    ".ts":    "javascript",   # TS is parsed as JS — annotations not yet handled
+    ".rs":    "rust",
+    ".m":     "matlab",
+    # Future-phase stubs — the dispatcher knows the language but the
+    # decompiler isn't shipped yet. They get a clear error message
+    # instead of silently falling back to Python.
+    ".cpp":   "cpp",
+    ".cu":    "cuda",
+    ".m":     "matlab",
+    ".hlsl":  "hlsl",
+    ".glsl":  "glsl",
+    ".v":     "verilog",
+    ".sv":    "systemverilog",
+    ".sol":   "solidity",
+}
+
+
+def _detect_language(path: str, override: str | None) -> str:
+    if override:
+        return override
+    ext = os.path.splitext(path)[1].lower()
+    return _LANG_BY_EXT.get(ext, "")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="efrog",
+        description=(
+            "eFrog — extract EML from any source. "
+            "E2.5 supports Python / C / JavaScript / Rust / MATLAB; "
+            "E3+ adds shaders / Verilog / Solidity."
+        ),
+    )
+    parser.add_argument("input", nargs="?", help="source file (omit when using --mic)")
+    parser.add_argument(
+        "-o", "--output",
+        help="write EML to this path (default: stdout)",
+    )
+    parser.add_argument(
+        "--lang",
+        help="force a language instead of inferring from extension",
+    )
+    parser.add_argument(
+        "--module",
+        help="override the emitted `module name;` (default: filename stem)",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"efrog {__version__}",
+    )
+    # Hidden-for-now flags that point at future phases. Surfaced so
+    # `--help` is honest about what's coming, but they error politely.
+    parser.add_argument("--profile", action="store_true",
+                        help="print per-function chain order, transcendental "
+                             "count, node count, drift risk")
+    parser.add_argument("--verify", action="store_true",
+                        help="round-trip the extracted EML through a Python "
+                             "shim and compare numerically against the original "
+                             "(E3 partial — Lean proofs land in full E3)")
+    parser.add_argument("--samples", type=int, default=100,
+                        help="number of random input samples for --verify "
+                             "(default 100)")
+    parser.add_argument("--seed", type=int, default=42,
+                        help="RNG seed for --verify sampling (default 42)")
+    parser.add_argument("--mic", action="store_true",
+                        help="capture a short audio buffer from the default "
+                             "input device and emit a single-sine EML fit "
+                             "(E4 scaffolding — multi-tone + envelope land later)")
+    parser.add_argument("--mic-duration", type=float, default=0.5,
+                        help="seconds of audio to capture (default 0.5)")
+    parser.add_argument("--mic-rate", type=int, default=44_100,
+                        help="sample rate in Hz (default 44100)")
+    parser.add_argument("--genome", action="store_true",
+                        help="classify each decompiled function against a small "
+                             "bundled corpus of canonical math patterns "
+                             "(gaussian, sigmoid, softplus, polynomial, …)")
+    parser.add_argument("--genome-top", type=int, default=5,
+                        help="how many genome matches to print per function "
+                             "(default 5)")
+    parser.add_argument("--lean", action="store_true",
+                        help="emit a Lean 4 theorem skeleton for each "
+                             "decompiled function (Mathlib-style; bodies "
+                             "are sorry-bodied scaffolds)")
+    parser.add_argument("--optimize", action="store_true",
+                        help="run a conservative algebraic simplifier "
+                             "(x+0, x*1, exp(0), x**2 → x*x, …) before "
+                             "emitting EML")
+    parser.add_argument("--optimize-report", action="store_true",
+                        help="print the per-function rewrite count "
+                             "alongside --optimize output")
+
+    args = parser.parse_args(argv)
+
+    if args.mic:
+        try:
+            result = decompose_microphone(
+                duration=args.mic_duration,
+                sample_rate=args.mic_rate,
+            )
+        except RuntimeError as exc:
+            print(f"efrog: {exc}", file=sys.stderr)
+            return 1
+        out_text = render_mic(result)
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(out_text)
+        else:
+            sys.stdout.write(out_text)
+        return 0
+
+    if not args.input:
+        parser.error("input file required (or use --mic in E4)")
+
+    path = args.input
+    if not os.path.isfile(path):
+        print(f"efrog: no such file: {path}", file=sys.stderr)
+        return 1
+
+    lang = _detect_language(path, args.lang)
+    decompiler = _DECOMPILERS.get(lang)
+    if decompiler is None:
+        if not lang:
+            print(
+                f"efrog: can't infer language from {path!r}; pass --lang",
+                file=sys.stderr,
+            )
+            return 1
+        print(
+            f"efrog: language `{lang}` ships in a later phase. "
+            f"E2.5 supports python, c, javascript/typescript, rust, and matlab. "
+            f"See ROADMAP.md.",
+            file=sys.stderr,
+        )
+        return 2
+
+    try:
+        mod = decompiler(path)
+    except EFrogError as exc:
+        print(f"efrog: {exc}", file=sys.stderr)
+        return 1
+
+    if args.module:
+        mod.name = args.module
+
+    if args.optimize:
+        reports = optimize_module(mod)
+        if args.optimize_report:
+            sys.stderr.write(render_optimize(reports))
+
+    if args.profile:
+        sys.stdout.write(render_profile(mod))
+        return 0
+
+    if args.genome:
+        sys.stdout.write(render_genome(mod, top_k=args.genome_top))
+        return 0
+
+    if args.lean:
+        out_text = render_lean(mod)
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(out_text)
+        else:
+            sys.stdout.write(out_text)
+        return 0
+
+    if args.verify:
+        # --verify is currently Python-only because the round-trip
+        # needs to run the original source. C round-trip lands when
+        # we can host a tiny Tiny C interpreter or shell out to gcc.
+        if lang != "python":
+            print(
+                f"efrog: --verify currently supports python only "
+                f"(your file is {lang}); the C round-trip needs a runtime",
+                file=sys.stderr,
+            )
+            return 2
+        result = verify_python_file(
+            path, n_samples=args.samples, seed=args.seed
+        )
+        sys.stdout.write(render_verify(result))
+        return 0 if result.passed else 1
+
+    eml = mod.to_eml()
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as f:
+            f.write(eml)
+    else:
+        sys.stdout.write(eml)
+    return 0
+
+
+_DECOMPILERS = {
+    "python":     decompile_python_file,
+    "c":          decompile_c_file,
+    "javascript": decompile_javascript_file,
+    "rust":       decompile_rust_file,
+    "matlab":     decompile_matlab_file,
+}
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

efrog/decompilers/__init__.py

@@ -0,0 +1 @@
+"""Per-language decompilers. E1 ships Python; E2 adds C/Rust/JS/MATLAB."""

efrog/decompilers/c.py

@@ -0,0 +1,339 @@
+"""C → EML.
+
+Phase E2 introduces C support — the second decompiler. We wrap
+:mod:`pycparser` (pure Python, no native deps) and walk the same
+shape we accept in Python: a function declaration with a parameter
+list and a body that evaluates a single expression returned at the
+end.
+
+What we accept in E2:
+
+  - ``double f(double x, double y) { return <expr>; }``
+  - ``float`` and ``double`` parameter types (mapped to ``Real``)
+  - ``int`` parameters (mapped to ``Real`` — signed-as-real)
+  - Local declarations like ``double dx = x - mu;`` → ``let`` bindings
+  - ``math.h`` calls (``exp``, ``log``, ``sin``, …, ``fabs``, ``pow``)
+  - Arithmetic operators with C precedence
+  - Numeric literals (``1.5``, ``2.0``, ``1e-3``, ``42``)
+  - ``M_PI`` / ``M_E`` constants from ``math.h`` (inlined)
+
+What we don't (yet):
+
+  - Pointers, arrays, structs (E2.5+)
+  - ``if`` / ``for`` / ``while`` (E3 — symbolic execution + unrolling)
+  - Macros (we strip ``#``-lines but don't expand them)
+  - Function calls to anything outside ``math.h``
+
+Anything else raises :class:`EFrogError` pointing at later phases.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+from pycparser import CParser, c_ast
+
+from .python import (  # reuse the EML-side dataclasses + estimator
+    DecompiledFunction,
+    DecompiledModule,
+    EFrogError,
+    _BUILTIN_FUNCS,
+    _PYTHON_TO_EML_FN,
+    _chain_order,
+    _emit_float,
+)
+
+
+# ── Public entry points ──────────────────────────────────────────────
+
+
+def decompile_c_source(
+    source: str,
+    *,
+    source_path: Optional[str] = None,
+    module_name_override: Optional[str] = None,
+) -> DecompiledModule:
+    cleaned = _strip_preprocessor(source)
+    parser = CParser()
+    try:
+        # parse() returns a FileAST. Synthetic <stdin> filename for nicer errors.
+        ast_root = parser.parse(cleaned, filename=source_path or "<stdin>")
+    except Exception as exc:  # pycparser raises ParseError, base Exception is safest
+        raise EFrogError(f"C parse error: {exc}") from exc
+
+    module_name = (
+        module_name_override
+        or _module_name_from_path(source_path)
+        or "module"
+    )
+    mod = DecompiledModule(name=module_name, source_path=source_path)
+
+    for ext in ast_root.ext:
+        if isinstance(ext, c_ast.FuncDef):
+            mod.functions.append(_decompile_funcdef(ext))
+        else:
+            # Top-level decls/typedefs/forward-decls — silently skip in E2.
+            continue
+
+    if not mod.functions:
+        raise EFrogError("no function definitions found — nothing to decompile")
+    return mod
+
+
+def decompile_c_file(path: str) -> DecompiledModule:
+    with open(path, "r", encoding="utf-8") as f:
+        return decompile_c_source(f.read(), source_path=path)
+
+
+# ── Preprocessor + module-name helpers ──────────────────────────────
+
+
+_PREPROC_LINE = re.compile(r"^\s*#.*$", re.MULTILINE)
+# Strip `/* ... */` block comments and `// ...` line comments —
+# pycparser does NOT accept either by design.
+_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
+_LINE_COMMENT = re.compile(r"//[^\n]*")
+
+# Standard math.h constants we know how to inline.
+_C_CONSTANTS = {
+    "M_PI":      3.141592653589793,
+    "M_E":       2.718281828459045,
+    "M_TAU":     6.283185307179586,
+    "M_SQRT2":   1.4142135623730951,
+    "M_LN2":     0.6931471805599453,
+    "M_LN10":    2.302585092994046,
+    "M_LOG2E":   1.4426950408889634,
+    "M_LOG10E":  0.4342944819032518,
+    "M_PI_2":    1.5707963267948966,
+    "M_PI_4":    0.7853981633974483,
+    "M_1_PI":    0.3183098861837907,
+    "M_2_PI":    0.6366197723675814,
+    "M_SQRT1_2": 0.7071067811865476,
+}
+
+
+def _strip_preprocessor(source: str) -> str:
+    """Remove `#`-lines and C comments so pycparser is happy with
+    bare C. We don't expand macros — callers that need them should
+    pre-process with ``cpp`` first."""
+    s = _BLOCK_COMMENT.sub(" ", source)
+    s = _LINE_COMMENT.sub("", s)
+    s = _PREPROC_LINE.sub("", s)
+    return s
+
+
+def _module_name_from_path(path: Optional[str]) -> Optional[str]:
+    if not path:
+        return None
+    return os.path.splitext(os.path.basename(path))[0] or None
+
+
+# ── Function decompilation ──────────────────────────────────────────
+
+
+def _decompile_funcdef(node: c_ast.FuncDef) -> DecompiledFunction:
+    decl = node.decl
+    name = decl.name
+    func_decl = decl.type
+    if not isinstance(func_decl, c_ast.FuncDecl):
+        raise EFrogError(f"`{name}` is not a function definition")
+
+    args = _decode_params(func_decl.args)
+    return_type = _emit_type(func_decl.type)
+
+    let_bindings, body_expr = _decompile_body(node.body)
+
+    chain = _chain_order(body_expr)
+    for _, e in let_bindings:
+        chain = max(chain, _chain_order(e))
+
+    return DecompiledFunction(
+        name=name,
+        args=args,
+        return_type=return_type,
+        chain_order=chain,
+        let_bindings=let_bindings,
+        body_expr=body_expr,
+    )
+
+
+def _decode_params(params: Optional[c_ast.ParamList]) -> List[Tuple[str, str]]:
+    if params is None or params.params is None:
+        return []
+    out: List[Tuple[str, str]] = []
+    for p in params.params:
+        # `f(void)` is represented by pycparser as a single Typename
+        # entry with an `IdentifierType(['void'])` — skip it cleanly.
+        if isinstance(p, c_ast.Typename):
+            t = p.type
+            if (
+                isinstance(t, c_ast.TypeDecl)
+                and isinstance(t.type, c_ast.IdentifierType)
+                and t.type.names == ["void"]
+            ):
+                continue
+            raise EFrogError(
+                f"abstract param `{type(p).__name__}` unsupported in E2"
+            )
+        if not isinstance(p, c_ast.Decl):
+            raise EFrogError(f"unsupported param node: {type(p).__name__}")
+        out.append((p.name or "_", _emit_type(p.type)))
+    return out
+
+
+def _emit_type(t: c_ast.Node) -> str:
+    """Map a C type node to the EML type name."""
+    if isinstance(t, c_ast.TypeDecl):
+        return _emit_type(t.type)
+    if isinstance(t, c_ast.IdentifierType):
+        names = " ".join(t.names)
+        return _C_TYPE_TO_EML.get(names, names)
+    if isinstance(t, c_ast.PtrDecl):
+        raise EFrogError("pointer / array params unsupported in E2")
+    raise EFrogError(f"unsupported C type: {type(t).__name__}")
+
+
+_C_TYPE_TO_EML = {
+    "double": "Real",
+    "float":  "Real",
+    "long double": "Real",
+    "int":    "Real",
+    "long":   "Real",
+    "long long": "Real",
+    "short":  "Real",
+    "signed": "Real",
+    "unsigned int": "Real",
+    "unsigned long": "Real",
+    "unsigned": "Real",
+    "void":   "Unit",
+}
+
+
+def _decompile_body(
+    block: c_ast.Compound,
+) -> Tuple[List[Tuple[str, str]], str]:
+    if block is None or block.block_items is None:
+        raise EFrogError("function body is empty")
+
+    let_bindings: List[Tuple[str, str]] = []
+    return_expr: Optional[str] = None
+    seen_return = False
+
+    for item in block.block_items:
+        if seen_return:
+            raise EFrogError("statements after return not supported")
+
+        if isinstance(item, c_ast.Decl):
+            if item.init is None:
+                raise EFrogError(f"local `{item.name}` declared without initializer")
+            let_bindings.append((item.name, _expr(item.init)))
+            continue
+
+        if isinstance(item, c_ast.Assignment):
+            if not isinstance(item.lvalue, c_ast.ID):
+                raise EFrogError("only assignments to a name supported in E2")
+            if item.op == "=":
+                let_bindings.append((item.lvalue.name, _expr(item.rvalue)))
+            elif item.op in _COMPOUND_ASSIGN:
+                op = _COMPOUND_ASSIGN[item.op]
+                rhs = _expr(item.rvalue)
+                let_bindings.append(
+                    (item.lvalue.name, f"{item.lvalue.name} {op} {rhs}")
+                )
+            else:
+                raise EFrogError(f"compound assign `{item.op}` unsupported")
+            continue
+
+        if isinstance(item, c_ast.Return):
+            if item.expr is None:
+                raise EFrogError("bare `return;` not supported")
+            return_expr = _expr(item.expr)
+            seen_return = True
+            continue
+
+        raise EFrogError(
+            f"{type(item).__name__} not supported in E2 "
+            f"(if/for/while go to E3+)"
+        )
+
+    if return_expr is None:
+        raise EFrogError("function has no `return` statement")
+    return let_bindings, return_expr
+
+
+_COMPOUND_ASSIGN = {
+    "+=": "+", "-=": "-", "*=": "*", "/=": "/", "%=": "%",
+}
+
+
+# ── Expression printer ──────────────────────────────────────────────
+
+
+_C_BIN_PREC = {
+    "+": 10, "-": 10,
+    "*": 20, "/": 20, "%": 20,
+}
+
+_C_BIN_OP = {
+    "+": "+", "-": "-", "*": "*", "/": "/", "%": "%",
+}
+
+
+def _expr(node: c_ast.Node, parent_prec: int = 0) -> str:
+    if isinstance(node, c_ast.Constant):
+        return _emit_constant(node)
+    if isinstance(node, c_ast.ID):
+        if node.name in _C_CONSTANTS:
+            return _emit_float(_C_CONSTANTS[node.name])
+        return node.name
+    if isinstance(node, c_ast.UnaryOp):
+        if node.op == "-":
+            inner = _expr(node.expr, _C_BIN_PREC["*"])
+            return _wrap(f"-{inner}", _C_BIN_PREC["*"], parent_prec)
+        if node.op == "+":
+            return _expr(node.expr, parent_prec)
+        raise EFrogError(f"unary `{node.op}` unsupported in E2")
+    if isinstance(node, c_ast.BinaryOp):
+        if node.op not in _C_BIN_OP:
+            raise EFrogError(f"binary `{node.op}` unsupported in E2")
+        prec = _C_BIN_PREC[node.op]
+        left  = _expr(node.left,  prec)
+        right = _expr(node.right, prec + 1)  # left-assoc
+        return _wrap(f"{left} {_C_BIN_OP[node.op]} {right}", prec, parent_prec)
+    if isinstance(node, c_ast.Cast):
+        # `(double) x` etc. — strip the cast, keep the expression.
+        return _expr(node.expr, parent_prec)
+    if isinstance(node, c_ast.FuncCall):
+        return _emit_call(node)
+    raise EFrogError(f"{type(node).__name__} unsupported in C decompiler")
+
+
+def _wrap(s: str, my_prec: int, parent_prec: int) -> str:
+    return f"({s})" if my_prec < parent_prec else s
+
+
+def _emit_constant(node: c_ast.Constant) -> str:
+    v = node.value
+    # Strip C numeric suffixes: 1.0f, 2.5L, 42u, 1e3F …
+    cleaned = re.sub(r"[uUlLfF]+$", "", v)
+    try:
+        f = float(cleaned)
+    except ValueError as exc:
+        raise EFrogError(f"can't parse C literal {v!r}: {exc}") from exc
+    return _emit_float(f)
+
+
+def _emit_call(node: c_ast.FuncCall) -> str:
+    if not isinstance(node.name, c_ast.ID):
+        raise EFrogError("call through non-name target unsupported in E2")
+    name = node.name.name
+    if name not in _BUILTIN_FUNCS:
+        raise EFrogError(
+            f"call to non-math function `{name}` unsupported in E2"
+        )
+    eml_name = _PYTHON_TO_EML_FN.get(name, name)
+    args = ", ".join(_expr(a) for a in (node.args.exprs if node.args else []))
+    return f"{eml_name}({args})"