esolangs 0.1.0__py3-none-any.whl

esolangs/__init__.py

@@ -0,0 +1,188 @@
+"""Public API for the esolangs package.
+
+Provides ``generate`` (produce a program that prints a text), ``run``
+(execute a program through an interpreter), ``make_vm`` (a step-and-inspect
+wrapper around the step-capable interpreters), ``make_debugger`` (a
+breakpoint/watch layer over the VM), ``transpile`` (rewrite a
+program between languages), ``describe`` (a structured language summary),
+and ``list_languages``.
+"""
+
+import importlib
+import pathlib
+import signal
+import threading
+from collections.abc import Callable
+from typing import Any
+
+from esolangs.debug import Debugger, make_debugger
+from esolangs.exceptions import (
+    HaltError,
+    UnknownLanguageError,
+    UnsupportedTranspilationError,
+)
+from esolangs.interpreters.io import ScriptedIO
+from esolangs.registry import GENERATORS, LANGUAGES, RUNNERS
+from esolangs.tools.boolean import BOOLEAN
+from esolangs.tools.transpilers import TRANSPILERS
+from esolangs.tools.wrap import takes_width, wrap_program
+from esolangs.vm import VM, make_vm
+
+_EXAMPLES = pathlib.Path(__file__).resolve().parents[2] / "examples"
+
+# Interpreter module family -> state model name.
+_STATE_MODELS = {
+    "register_based": "register",
+    "tape_based": "tape",
+    "stack_based": "stack",
+    "grid_based": "grid",
+    "queue_based": "queue",
+    "other": "other",
+}
+
+
+def generate(language: str, text: str, width: int | None = None) -> str:
+    """Return a program in ``language`` that prints ``text``.
+
+    ``width`` bounds the program to that many columns for readability;
+    :data:`esolangs.tools.wrap.DEFAULT_WIDTH` is the conventional choice.
+    The default of ``None`` asks for no bound, so a caller that does not
+    want one gets exactly what the generator has always produced.
+
+    Most languages honour it by *wrapping* the finished program, breaking
+    only between whole tokens so it still means the same thing.  A few build
+    a shape rather than a line -- Clockwise lays its code around a
+    rectangle's perimeter -- and cannot be reflowed after the fact; those
+    generators take the width themselves and lay the program out to fit.
+
+    A language whose newlines are semantic (the 2D grid languages) or that
+    rejects them outright (NoComment) ignores ``width`` rather than raising,
+    so one width can be passed across every language.
+    """
+    try:
+        fn = GENERATORS[language]
+    except KeyError:
+        raise UnknownLanguageError(language) from None
+    if width is not None and takes_width(fn):
+        return str(fn(text, width))
+    return wrap_program(str(fn(text)), LANGUAGES[language].id, width)
+
+
+def run(
+    language: str,
+    program: str,
+    stdin: str = "",
+    timeout: float | None = None,
+) -> str:
+    """Execute ``program`` and return its output.
+
+    Input is fed to the program line by line from ``stdin``.  ``timeout``
+    bounds execution wall-clock: after ``timeout`` seconds the run raises
+    :class:`HaltError`.  The guard uses ``SIGALRM``, so it requires a Unix
+    main thread; elsewhere a ``timeout`` raises :class:`ValueError`.
+    """
+    if timeout is not None and timeout <= 0:
+        raise ValueError(f"timeout must be positive, got {timeout}")
+    try:
+        module, split, kwargs = RUNNERS[language]
+    except KeyError:
+        raise UnknownLanguageError(language) from None
+    run_fn = importlib.import_module("esolangs.interpreters." + module).run
+    io_obj = ScriptedIO(stdin)
+    program_args: str | list[str] = program.splitlines() if split else program
+    _run(run_fn, program_args, io_obj, timeout, dict(kwargs))
+    return io_obj.getvalue()
+
+
+def _run(
+    run_fn: Callable[..., Any],
+    program: str | list[str],
+    io_obj: ScriptedIO,
+    timeout: float | None,
+    kwargs: dict[str, int],
+) -> None:
+    """Run ``run_fn``, applying the wall-clock ``timeout`` guard when set."""
+    if timeout is None:
+        run_fn(program, io_obj, **kwargs)
+    elif threading.current_thread() is threading.main_thread() and hasattr(
+        signal, "SIGALRM"
+    ):
+        _run_timed_signal(run_fn, program, io_obj, timeout, kwargs)
+    else:
+        raise ValueError("the timeout guard uses SIGALRM and needs a Unix main thread")
+
+
+def _run_timed_signal(
+    run_fn: Callable[..., Any],
+    program: str | list[str],
+    io_obj: ScriptedIO,
+    timeout: float,
+    kwargs: dict[str, int],
+) -> None:
+    """Run ``run_fn`` under a ``SIGALRM`` wall-clock guard (main thread only)."""
+
+    def _timeout_handler(_signum: int, _frame: object) -> None:
+        # coverage cannot trace a raise inside a signal handler
+        raise HaltError(
+            f"execution exceeded the {timeout}-second timeout"
+        )  # pragma: no cover
+
+    old = signal.signal(signal.SIGALRM, _timeout_handler)
+    signal.setitimer(signal.ITIMER_REAL, timeout)
+    try:
+        run_fn(program, io_obj, **kwargs)
+    finally:
+        signal.setitimer(signal.ITIMER_REAL, 0)
+        signal.signal(signal.SIGALRM, old)
+
+
+def describe(language: str) -> dict[str, object]:
+    """Return a structured description of ``language``.
+
+    The summary carries the state model (derived from the interpreter's
+    module family), whether the language has text and boolean generators,
+    its transpilers, its example programs, and its esolangs.org page.
+    """
+    try:
+        lang = LANGUAGES[language]
+    except KeyError:
+        raise UnknownLanguageError(language) from None
+    module = RUNNERS.get(language)
+    family = module[0].split(".")[0] if module else None
+    examples = sorted(
+        str(p.relative_to(_EXAMPLES.parent)) for p in _EXAMPLES.glob(f"*/{lang.id}.txt")
+    )
+    transpilers = sorted(
+        (source, target)
+        for (source, target) in TRANSPILERS
+        if source == language or target == language
+    )
+    return {
+        "name": language,
+        "id": lang.id,
+        "state_model": _STATE_MODELS.get(family) if family else None,
+        "interpreter": lang.interpreter,
+        "text_generator": lang.generator is not None,
+        "boolean_generator": language in BOOLEAN,
+        "transpilers": transpilers,
+        "examples": examples,
+        "wiki_url": f"https://esolangs.org/wiki/{language.replace(' ', '_')}",
+    }
+
+
+def transpile(source: str, target: str, program: str, **kwargs: int) -> str:
+    """Rewrite a ``program`` in ``source`` into an equivalent one in ``target``.
+
+    Transpilers with extra options accept them as keyword arguments (for
+    example ``size`` when targeting Circlefuck).
+    """
+    try:
+        fn = TRANSPILERS[(source, target)]
+    except KeyError:
+        raise UnsupportedTranspilationError(source, target) from None
+    return fn(program, **kwargs)
+
+
+def list_languages() -> list[str]:
+    """Return the supported language names, sorted."""
+    return sorted(LANGUAGES)

esolangs/__main__.py

@@ -0,0 +1,6 @@
+"""Run the esolangs command-line interface."""
+
+from esolangs.cli import main
+
+if __name__ == "__main__":
+    main()

esolangs/cli.py

@@ -0,0 +1,145 @@
+"""Command-line interface for the esolangs package.
+
+Subcommands:
+    esolangs list                         list the supported languages
+    esolangs generate <language> <text>   print a program that outputs text
+                                          (``--width N`` wraps it to N columns)
+    esolangs run <language> <file>        run a program through its interpreter
+    esolangs transpile <from> <to> <file> rewrite a program into another language
+
+For anything else (compilers, tools), invoke the module directly with
+``python -m``, e.g. ``python -m esolangs.compilers.unsquare``.
+"""
+
+import sys
+
+from esolangs import generate, list_languages, run, transpile
+from esolangs.tools.wrap import DEFAULT_WIDTH
+
+USAGE = """usage: esolangs <command> [...]
+
+commands:
+  list                        list the supported languages
+  generate [--width N] <language> <text>
+                              print a program that outputs text
+                              (--width wraps it for readability)
+  run <language> <file>       run a program through its interpreter
+  transpile <from> <to> <file>  rewrite a program into another language
+
+examples:
+  esolangs list
+  esolangs generate Circlefuck "Hello, World!"
+  esolangs generate --width Polynomial "Hello, World!"
+  esolangs run Circlefuck hello.txt
+  esolangs transpile brainfuck Circlefuck hello.bf
+"""
+
+
+def _fail(message: str) -> None:
+    sys.stderr.write(message + "\n")
+    sys.exit(2)
+
+
+def _is_int(value: str) -> bool:
+    """Whether ``value`` parses as an integer."""
+    try:
+        int(value)
+    except ValueError:
+        return False
+    return True
+
+
+def _pop_width(rest: list[str]) -> tuple[list[str], int | None]:
+    """Split a ``--width N`` (or ``--width=N``) option out of ``rest``.
+
+    Returns the remaining positional arguments and the width, or ``None``
+    when the option is absent -- which leaves the program on one line, the
+    output ``generate`` has always produced.  A bare ``--width`` takes the
+    conventional :data:`DEFAULT_WIDTH`, so the common case needs no number;
+    an explicit value must be an integer, since silently reading the
+    language name as a width would generate the wrong thing.
+    """
+    args: list[str] = []
+    width: int | None = None
+    i = 0
+    while i < len(rest):
+        arg = rest[i]
+        if arg == "--width":
+            following = rest[i + 1] if i + 1 < len(rest) else None
+            if following is None or not _is_int(following):
+                width = DEFAULT_WIDTH
+                i += 1
+                continue
+            value = following
+            i += 2
+        elif arg.startswith("--width="):
+            value = arg.split("=", 1)[1]
+            i += 1
+        else:
+            args.append(arg)
+            i += 1
+            continue
+        try:
+            width = int(value)
+        except ValueError:
+            _fail(f"--width must be an integer, got {value!r}")
+        if width is not None and width <= 0:
+            _fail(f"--width must be positive, got {width}")
+    return args, width
+
+
+def main() -> None:
+    """Dispatch the ``esolangs`` subcommands."""
+    argv = sys.argv[1:]
+    if not argv:
+        sys.stderr.write(USAGE)
+        sys.exit(2)
+
+    cmd, rest = argv[0], argv[1:]
+    if cmd == "list":
+        for name in list_languages():
+            print(name)
+    elif cmd == "generate":
+        rest, width = _pop_width(rest)
+        if len(rest) < 2:
+            _fail("usage: esolangs generate [--width N] <language> <text>")
+        try:
+            program = generate(rest[0], rest[1], width)
+        except ValueError as exc:
+            _fail(str(exc))
+        print(program)
+    elif cmd == "run":
+        if len(rest) < 2:
+            _fail("usage: esolangs run <language> <program-file>")
+        language, path = rest[0], rest[1]
+        try:
+            with open(path) as f:
+                program = f.read()
+        except OSError as exc:
+            _fail(f"cannot read {path}: {exc}")
+        stdin = "" if sys.stdin.isatty() else sys.stdin.read()
+        try:
+            output = run(language, program, stdin)
+        except ValueError as exc:
+            _fail(str(exc))
+        sys.stdout.write(output)
+    elif cmd == "transpile":
+        if len(rest) < 3:
+            _fail("usage: esolangs transpile <from> <to> <program-file>")
+        source, target, path = rest[0], rest[1], rest[2]
+        try:
+            with open(path) as f:
+                program = f.read()
+        except OSError as exc:
+            _fail(f"cannot read {path}: {exc}")
+        try:
+            output = transpile(source, target, program)
+        except ValueError as exc:
+            _fail(str(exc))
+        sys.stdout.write(output)
+    else:
+        _fail(f"unknown command: {cmd}\n\n{USAGE}")
+
+
+if __name__ == "__main__":
+    main()

esolangs/compilers/__init__.py

@@ -0,0 +1 @@
+"""Compilers that turn esolang programs into RISC-V assembly."""

esolangs/compilers/_riscv_common.py

@@ -0,0 +1,143 @@
+"""Shared RISC-V assembly fragments for the OISC-style compilers.
+
+decleq, S*bleq, and AddSubJump all compile to a fetch-decode-execute loop
+over a ``.data`` array of 8-byte cells (their jump targets are computed at
+runtime, so unlike the token-unrolling compilers they can't emit static
+per-token blocks).  These three routines -- byte I/O and the final
+dword-per-row memory dump -- are copy-pasted identically between them;
+keeping one copy here is what the ``duplicate-code`` check in
+``scripts/verify.py`` enforces.
+"""
+
+GETBYTE = (
+    "# getbyte() -> a0; reads one byte of stdin, halts the program at EOF\n"
+    "# (matching the interpreter's EOFError, which unwinds the whole run)\n"
+    "getbyte:\n"
+    "    addi sp, sp, -16\n"
+    "    sd   ra, 8(sp)\n"
+    "    li   a7, 63\n"
+    "    li   a0, 0\n"
+    "    mv   a1, sp\n"
+    "    li   a2, 1\n"
+    "    ecall\n"
+    "    blez a0, .halt\n"
+    "    lbu  a0, 0(sp)\n"
+    "    ld   ra, 8(sp)\n"
+    "    addi sp, sp, 16\n"
+    "    ret\n"
+)
+
+READ_BYTE_OR_EOF = (
+    "    addi sp, sp, -16\n"
+    "    sd   ra, 8(sp)\n"
+    "    li   a7, 63\n"
+    "    li   a0, 0\n"
+    "    mv   a1, sp\n"
+    "    li   a2, 1\n"
+    "    ecall\n"
+    "    blez a0, .eof\n"
+    "    lbu  a0, 0(sp)\n"
+    "    ld   ra, 8(sp)\n"
+    "    addi sp, sp, 16\n"
+    "    ret\n"
+)
+
+PUTBYTE = (
+    "# putbyte(value: a0) -- write the low byte to stdout\n"
+    "putbyte:\n"
+    "    addi sp, sp, -16\n"
+    "    sd   ra, 8(sp)\n"
+    "    andi t0, a0, 0xff\n"
+    "    sb   t0, 0(sp)\n"
+    "    li   a7, 64\n"
+    "    li   a0, 1\n"
+    "    mv   a1, sp\n"
+    "    li   a2, 1\n"
+    "    ecall\n"
+    "    ld   ra, 8(sp)\n"
+    "    addi sp, sp, 16\n"
+    "    ret\n"
+)
+
+
+MUL32 = (
+    "# a0 *= a1 (unsigned 32-bit), result in a0\n"
+    "mul32:\n"
+    "\tmv   t4, a0\n"
+    "\tli   a0, 0\n"
+    ".mul_loop:\n"
+    "\tandi t5, a1, 1\n"
+    "\tbeqz t5, .mul_skip\n"
+    "\tadd  a0, a0, t4\n"
+    ".mul_skip:\n"
+    "\tslli t4, t4, 1\n"
+    "\tsrli a1, a1, 1\n"
+    "\tbnez a1, .mul_loop\n"
+    "\tret"
+)
+
+
+def start_preamble(num_cells_used: int) -> str:
+    """``.text``/``_start``: point ``s1`` at ``mem``, ``s2``/``s3`` at ip/length.
+
+    ``num_cells_used`` is the compiled program's cell count (``n``), not
+    the fixed buffer size -- ``s3`` bounds the fetch-decode-execute loop
+    to the program itself, with the rest of the buffer as zeroed scratch.
+    """
+    return (
+        "    .text\n"
+        "    .global _start\n"
+        "_start:\n"
+        "    la   s1, mem\n"
+        "    li   s2, 0\n"
+        f"    li   s3, {num_cells_used}\n"
+    )
+
+
+def cell_load_or_zero(num_cells: int) -> str:
+    """Range-check ``a0`` against the cell buffer, load it or return 0.
+
+    Expects ``s1`` = memory base.  Falls through from a caller that has
+    already ruled out its own special addresses, so this only needs the
+    generic bounds check every ``read_cell`` ends with.
+    """
+    return (
+        "    bltz a0, .zero_ret\n"
+        f"    li   t0, {num_cells}\n"
+        "    bge  a0, t0, .zero_ret\n"
+        "    slli t0, a0, 3\n"
+        "    add  t0, s1, t0\n"
+        "    ld   a0, 0(t0)\n"
+        "    ret\n"
+        ".zero_ret:\n"
+        "    li   a0, 0\n"
+        "    ret\n"
+    )
+
+
+def cell_store_or_drop(num_cells: int) -> str:
+    """Range-check ``a0`` against the cell buffer and store ``a1``, or drop.
+
+    Expects ``s1`` = memory base.  Like :func:`cell_load_or_zero`, this is
+    the generic bounds check a ``write_cell`` falls through to after its
+    own special addresses are ruled out.
+    """
+    return (
+        "    bltz a0, .no_write\n"
+        f"    li   t0, {num_cells}\n"
+        "    bge  a0, t0, .no_write\n"
+        "    slli t0, a0, 3\n"
+        "    add  t0, s1, t0\n"
+        "    sd   a1, 0(t0)\n"
+        ".no_write:\n"
+        "    ret\n"
+    )
+
+
+def dump_cells(cells: list[int], num_cells: int) -> str:
+    """Render ``.data``/``.align``/dword rows for a fixed-size cell buffer."""
+    res = "    .data\n    .align 3\nmem:\n"
+    for i in range(0, num_cells, 8):
+        row = cells[i : i + 8]
+        res += "    .dword " + ", ".join(str(v) for v in row) + "\n"
+    return res

esolangs/compilers/addsubjump.py

@@ -0,0 +1,178 @@
+"""Compiler that turns AddSubJump programs into RISC-V Linux assembly."""
+
+import sys
+
+from esolangs.compilers._riscv_common import (
+    READ_BYTE_OR_EOF,
+    cell_load_or_zero,
+    cell_store_or_drop,
+    dump_cells,
+    start_preamble,
+)
+from esolangs.interpreters.memory import parse_int_memory as _parse
+
+# Special addresses, matching esolangs.interpreters.register_based.addsubjump.
+_IO, _CF, _ZF, _NF, _OF, _ONE, _ZERO, _NEG, _FUM = -1, -2, -3, -4, -5, -6, -7, -8, -9
+
+# Fixed-size cell buffer: the interpreter's memory grows on out-of-range
+# writes, but a compiled program gets a generous preallocated word array
+# instead (the same tradeoff RAM0's compiler makes for its 256-cell RAM).
+_CELLS = 65536
+
+
+def comp(code: str) -> str:
+    """Compile an AddSubJump program to RISC-V assembly.
+
+    AddSubJump's memory is self-modifying and its jump target (``*c``) is
+    computed at runtime, so unlike the other compilers this cannot unroll
+    into static per-token blocks: it emits a real fetch-decode-execute loop
+    over a ``.data`` array of 8-byte cells.  Registers: ``s1`` = memory base,
+    ``s2`` = ip (in cells), ``s3`` = memory length (in cells), ``s4`` = flag
+    update mode, ``s5``/``s6`` = zero/negative flags.  ``read_cell`` and
+    ``write_cell`` centralize the special-address handling (``-1`` I/O,
+    ``-2``..``-5`` flags, ``-6``/``-7``/``-8`` constants, ``-9`` flag mode)
+    that both operand fetch and the write-back share.
+    """
+    cells = _parse(code)
+    n = len(cells)
+    if n < _CELLS:
+        cells = cells + [0] * (_CELLS - n)
+
+    res = (
+        start_preamble(n) + "    li   s4, 0\n"
+        "    li   s5, 0\n"
+        "    li   s6, 0\n"
+        ".loop:\n"
+        "    bltz s2, .halt\n"
+        "    bge  s2, s3, .halt\n"
+        "    slli t0, s2, 3\n"
+        "    add  t0, s1, t0\n"
+        "    ld   a0, 0(t0)\n"  # a
+        "    ld   a1, 8(t0)\n"  # b
+        "    ld   a2, 16(t0)\n"  # c
+        "    ld   a3, 24(t0)\n"  # d
+        "    mv   t1, a0\n"  # save a (write target) across calls
+        "    mv   t2, a2\n"  # save c (jump target)
+        "    mv   a0, a3\n"
+        "    call read_cell\n"  # vd = read(d)
+        "    mv   t3, a0\n"
+        "    mv   a0, a1\n"
+        "    call read_cell\n"  # vb = read(b)
+        "    mv   t4, a0\n"  # vb
+        "    li   t0, -1\n"
+        "    bne  t1, t0, .not_io\n"
+        "    mv   a0, t4\n"  # a == -1: write vb straight to I/O
+        "    j    .have_new\n"
+        ".not_io:\n"
+        "    mv   a0, t1\n"
+        "    call read_cell\n"  # read(a)
+        "    blez t3, .add\n"
+        "    sub  a0, a0, t4\n"
+        "    j    .have_new\n"
+        ".add:\n"
+        "    add  a0, a0, t4\n"
+        ".have_new:\n"
+        "    mv   t5, a0\n"  # new
+        "    mv   a1, t5\n"
+        "    mv   a0, t1\n"
+        "    call write_cell\n"
+        "    beqz s4, .no_flags\n"
+        "    seqz s5, t5\n"
+        "    sltz s6, t5\n"
+        ".no_flags:\n"
+        "    mv   a0, t2\n"
+        "    call read_cell\n"  # ip = read(c)
+        "    mv   s2, a0\n"
+        "    j    .loop\n"
+        ".halt:\n"
+        "    li   a0, 0\n"
+        "    li   a7, 93\n"
+        "    ecall\n"
+        "\n"
+        "# read_cell(addr: a0) -> a0\n"
+        "read_cell:\n"
+        f"    li   t0, {_IO}\n"
+        "    bne  a0, t0, 1f\n" + READ_BYTE_OR_EOF + "1:\n"
+        f"    li   t0, {_CF}\n"
+        "    bne  a0, t0, 2f\n"
+        "    li   a0, 0\n"
+        "    ret\n"
+        "2:\n"
+        f"    li   t0, {_ZF}\n"
+        "    bne  a0, t0, 3f\n"
+        "    mv   a0, s5\n"
+        "    ret\n"
+        "3:\n"
+        f"    li   t0, {_NF}\n"
+        "    bne  a0, t0, 4f\n"
+        "    mv   a0, s6\n"
+        "    ret\n"
+        "4:\n"
+        f"    li   t0, {_OF}\n"
+        "    bne  a0, t0, 5f\n"
+        "    li   a0, 0\n"
+        "    ret\n"
+        "5:\n"
+        f"    li   t0, {_ONE}\n"
+        "    bne  a0, t0, 6f\n"
+        "    li   a0, 1\n"
+        "    ret\n"
+        "6:\n"
+        f"    li   t0, {_ZERO}\n"
+        "    bne  a0, t0, 7f\n"
+        "    li   a0, 0\n"
+        "    ret\n"
+        "7:\n"
+        f"    li   t0, {_NEG}\n"
+        "    bne  a0, t0, 8f\n"
+        "    li   a0, -1\n"
+        "    ret\n"
+        "8:\n"
+        f"    li   t0, {_FUM}\n"
+        "    bne  a0, t0, 9f\n"
+        "    mv   a0, s4\n"
+        "    ret\n"
+        "9:\n" + cell_load_or_zero(_CELLS) + ".eof:\n"
+        "    li   a0, 1\n"
+        "    li   a7, 93\n"
+        "    ecall\n"
+        "\n"
+        "# write_cell(addr: a0, value: a1)\n"
+        "write_cell:\n"
+        f"    li   t0, {_IO}\n"
+        "    bne  a0, t0, 1f\n"
+        "    addi sp, sp, -16\n"
+        "    sd   ra, 8(sp)\n"
+        "    andi t0, a1, 0xff\n"
+        "    sb   t0, 0(sp)\n"
+        "    li   a7, 64\n"
+        "    li   a0, 1\n"
+        "    mv   a1, sp\n"
+        "    li   a2, 1\n"
+        "    ecall\n"
+        "    ld   ra, 8(sp)\n"
+        "    addi sp, sp, 16\n"
+        "    ret\n"
+        "1:\n"
+        f"    li   t0, {_FUM}\n"
+        "    bne  a0, t0, 2f\n"
+        "    mv   s4, a1\n"
+        "    ret\n"
+        "2:\n"
+        f"    li   t0, {_CF}\n"  # -8..-2 (NEG..CF): other specials are read-only
+        "    bgt  a0, t0, 3f\n"
+        f"    li   t1, {_NEG}\n"
+        "    blt  a0, t1, 3f\n"
+        "    j    .no_write\n"
+        "3:\n" + cell_store_or_drop(_CELLS)
+    )
+    return res + dump_cells(cells, _CELLS)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        with open(sys.argv[1]) as f:
+            data = f.read()
+
+        with open("output.asm", "w") as f:
+            f.write(comp(data))