arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/php/emit.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""Эмиттер PHP. Тот же план и тот же контракт рантайма; модель — класс `Model`
+со статическими таблицами. Инициализатор статического свойства PHP допускает
+только константное выражение, поэтому константы §54 и собственные факты пакета
+— функции, которые раннер зовёт до фактов дела."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def ps(s: str) -> str:
+    """Литерал в одинарных кавычках: без интерполяции `$`, экранируются только
+    экран и кавычка, остальные байты идут как есть."""
+    return "'" + s.replace("\\", "\\\\").replace("'", "\\'") + "'"
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'$r{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT::money({ps(t["v"])}, {ps(t["cur"])})'
+        if t["t"] == "dec":
+            return f'RT::dec({ps(t["v"])})'
+        if t["t"] == "date":
+            return f'RT::date({ps(t["v"])})'
+        if t["t"] == "enum":
+            return f'RT::sym({ps(t["v"])})'
+        return ps(t["v"])
+    if k == "bin":
+        return f'RT::{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        return f'RT::{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ')'
+    raise AssertionError(k)
+
+
+def arr(items) -> str:
+    return "[" + ", ".join(items) + "]"
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["<?php", "declare(strict_types=1);", "", "final class Model", "{", "    public static array $TABLES = ["]
+    for t in plan["tables"]:
+        L.append(f'        {ps(t["pred"])} => [],')
+    L.append("    ];")
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(rule["head"]["pred"])
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(rule["head"]["pred"])
+    L.append("    // E-0210/E-0242: forward readers of a keyed relation.")
+    L.append("    public const KEY_READERS = [")
+    for source, consumers in sorted(readers.items()):
+        L.append(f'        {ps(source)} => {arr(ps(value) for value in sorted(consumers))},')
+    L.append("    ];")
+    L.append("    // Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("    public const PARAMS = [")
+    for t in plan["tables"]:
+        L.append(f'        {ps(t["pred"])} => {arr(ps(p) for p in t["params"])},')
+    L.append("    ];")
+    L.append("    // Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("    public const BASES = [")
+    for sub, base in plan["bases"].items():
+        L.append(f"        {ps(sub)} => {ps(base)},")
+    L.append("    ];")
+    L.append("    // Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("    public const KEYS = [")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'        {ps(t["pred"])} => {json.dumps(t["keys"])},')
+    L.append("    ];")
+    L.append("    private static array $seen = [];")
+    L.append("")
+    L.append("    // Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("    public static function consts(): array")
+    L.append("    {")
+    L.append("        return [")
+    for cid, c in plan["consts"].items():
+        L.append(f'            {ps(cid)} => [{ps(c["type"])}, {term(c["term"])}],')
+    L.append("        ];")
+    L.append("    }")
+    L.append("")
+    L.append("    private static function addRow(string $urn, array $row): bool")
+    L.append("    {")
+    L.append("        $k = RT::key($row);")
+    L.append("        if (isset(self::$seen[$urn][$k])) {")
+    L.append("            return false;")
+    L.append("        }")
+    L.append("        self::$seen[$urn][$k] = true;")
+    L.append("        self::$TABLES[$urn][] = $row;")
+    L.append("        return true;")
+    L.append("    }")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'    // {r["id"]}')
+        L.append(f'    private static function rule_{r["name"]}(): bool')
+        L.append("    {")
+        L.append("        $grew = false;")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'        if (strcmp(RT::legalTime(), {ps(r["window"]["start"])}) < 0) {{')
+                L.append("            return false;")
+                L.append("        }")
+            if r["window"].get("end"):
+                L.append(f'        if (strcmp(RT::legalTime(), {ps(r["window"]["end"])}) >= 0) {{')
+                L.append("            return false;")
+                L.append("        }")
+        ind = "        "
+        for i, a in enumerate(r["atoms"]):
+            # foreach по массиву PHP идёт по копии на входе: строки, добавленные
+            # этим же проходом, не перебираются.
+            L.append(f'{ind}foreach (self::$TABLES[{ps(a["pred"])}] as $r{i}) {{')
+            ind += "    "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f"{ind}if (!RT::cmp($r{ai}[{aj}], 'eq', $r{bi}[{bj}])) {{ continue; }}")
+        for f in r["filters"]:
+            L.append(f'{ind}if (!RT::eq($r{f["row"]}[{f["col"]}], {term(f["term"])})) {{ continue; }}')
+        for g in r["guards"]:
+            L.append(f'{ind}if (!RT::cmp({term(g["l"])}, {ps(g["op"])}, {term(g["r"])})) {{ continue; }}')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}if (self::addRow({ps(r["head"]["pred"])}, [{args}])) {{ $grew = true; }}')
+        for _ in r["atoms"]:
+            ind = ind[:-4]
+            L.append(ind + "}")
+        L.append("        return $grew;")
+        L.append("    }")
+        L.append("")
+    L.append("    public static function saturate(): void")
+    L.append("    {")
+    L.append("        $grew = true;")
+    L.append("        while ($grew) {")
+    L.append("            $grew = false;")
+    for r in plan["rules"]:
+        L.append(f'            if (self::rule_{r["name"]}()) {{ $grew = true; }}')
+    L.append("        }")
+    L.append("    }")
+    L.append("")
+    L.append("    public static function register(string $urn, array $row): bool")
+    L.append("    {")
+    L.append("        return self::addRow($urn, $row);")
+    L.append("    }")
+    L.append("")
+    L.append("    // KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("    public static function keyConflicts(): int")
+    L.append("    {")
+    L.append("        $n = 0;")
+    L.append("        foreach (self::KEYS as $urn => $keys) {")
+    L.append("            foreach ($keys as $key) {")
+    L.append("                $groups = [];")
+    L.append("                foreach (self::$TABLES[$urn] as $row) {")
+    L.append("                    $g = RT::key(array_map(fn($i) => $row[$i], $key));")
+    L.append("                    $groups[$g] = ($groups[$g] ?? 0) + 1;")
+    L.append("                }")
+    L.append("                $n += count(array_filter($groups, fn($c) => $c > 1));")
+    L.append("            }")
+    L.append("        }")
+    L.append("        return $n;")
+    L.append("    }")
+    L.append("")
+    L.append("    public static function keyConflictPredicates(): array")
+    L.append("    {")
+    L.append("        $out = [];")
+    L.append("        foreach (self::KEYS as $urn => $keys) foreach ($keys as $key) {")
+    L.append("            $groups = [];")
+    L.append("            foreach (self::$TABLES[$urn] as $row) { $g = RT::key(array_map(fn($i) => $row[$i], $key)); $groups[$g] = ($groups[$g] ?? 0) + 1; }")
+    L.append("            if (array_filter($groups, fn($c) => $c > 1)) $out[$urn] = true;")
+    L.append("        }")
+    L.append("        return array_keys($out);")
+    L.append("    }")
+    L.append("")
+    L.append("    // Собственные факты пакета: раннер кладёт их до фактов дела.")
+    L.append("    public static function packageFacts(): void")
+    L.append("    {")
+    for f in plan["facts"]:
+        L.append(f'        self::addRow({ps(f["pred"])}, [' + ", ".join(term(a) for a in f["args"]) + "]);")
+    L.append("    }")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "php"
+MODEL = "model.php"
+MAINS = {"runner": "runner.php", "cert": "cert.php"}
+
+
+def available():
+    php = shutil.which("php")
+    return (True, php) if php else (False, "нет php в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("runtime.php", "json.php", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    return None
+
+
+def run(proj, main: str):
+    return ["php", str(Path(proj) / MAINS[main])], None
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(HERE.parents[1]))
+    import plan as P
+    ir = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    Path(sys.argv[2]).write_text(emit(P.build_plan(ir)), encoding="utf-8")

arxo_codegen/targets/php/json.php

@@ -0,0 +1,144 @@
+<?php
+// Разбор JSON с числами ТЕКСТОМ: `json_decode` отдаёт дробную запись как
+// float (2.50 теряет масштаб, длинная дробь — цифры). Число здесь — JNum с
+// исходной записью; остальное — обычные значения PHP, объект — массив.
+declare(strict_types=1);
+
+final class JNum
+{
+    public function __construct(public readonly string $text) {}
+}
+
+final class JsonText
+{
+    private int $i = 0;
+
+    private function __construct(private readonly string $s) {}
+
+    public static function read(string $path): mixed
+    {
+        $s = file_get_contents($path);
+        if ($s === false) {
+            throw new RuntimeException("не прочитать $path");
+        }
+        $p = new JsonText($s);
+        $v = $p->value();
+        $p->ws();
+        if ($p->i !== strlen($s)) {
+            $p->fail('лишнее после значения');
+        }
+        return $v;
+    }
+
+    /** Текст значения JSON: строка как есть, число — его запись. */
+    public static function text(mixed $v): string
+    {
+        if ($v instanceof JNum) {
+            return $v->text;
+        }
+        if (is_bool($v)) {
+            return $v ? 'true' : 'false';
+        }
+        return $v === null || is_array($v) ? '' : (string) $v;
+    }
+
+    /** Строка JSON: UTF-8 как есть, экранируются только кавычка, экран и управляющие. */
+    public static function str(string $s): string
+    {
+        return json_encode($s, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
+    }
+
+    private function fail(string $what): never
+    {
+        throw new RuntimeException("JSON: $what в позиции {$this->i}");
+    }
+
+    private function ws(): void
+    {
+        $this->i += strspn($this->s, " \t\r\n", $this->i);
+    }
+
+    private function value(): mixed
+    {
+        $this->ws();
+        $c = $this->s[$this->i] ?? '';
+        if ($c === '{') {
+            $this->i++;
+            $obj = [];
+            $this->ws();
+            if (($this->s[$this->i] ?? '') === '}') {
+                $this->i++;
+                return $obj;
+            }
+            for (;;) {
+                $this->ws();
+                if (($this->s[$this->i] ?? '') !== '"') {
+                    $this->fail('ожидался ключ');
+                }
+                $k = $this->string();
+                $this->ws();
+                if (($this->s[$this->i] ?? '') !== ':') {
+                    $this->fail("ожидалось ':'");
+                }
+                $this->i++;
+                $obj[$k] = $this->value();
+                $this->ws();
+                $d = $this->s[$this->i] ?? '';
+                $this->i++;
+                if ($d === '}') {
+                    return $obj;
+                }
+                if ($d !== ',') {
+                    $this->fail("ожидалось ',' или '}'");
+                }
+            }
+        }
+        if ($c === '[') {
+            $this->i++;
+            $arr = [];
+            $this->ws();
+            if (($this->s[$this->i] ?? '') === ']') {
+                $this->i++;
+                return $arr;
+            }
+            for (;;) {
+                $arr[] = $this->value();
+                $this->ws();
+                $d = $this->s[$this->i] ?? '';
+                $this->i++;
+                if ($d === ']') {
+                    return $arr;
+                }
+                if ($d !== ',') {
+                    $this->fail("ожидалось ',' или ']'");
+                }
+            }
+        }
+        if ($c === '"') {
+            return $this->string();
+        }
+        foreach (['true' => true, 'false' => false, 'null' => null] as $word => $val) {
+            if (substr_compare($this->s, $word, $this->i, strlen($word)) === 0) {
+                $this->i += strlen($word);
+                return $val;
+            }
+        }
+        if (!preg_match('/\G-?\d+(\.\d+)?([eE][-+]?\d+)?/', $this->s, $m, 0, $this->i)) {
+            $this->fail('неизвестное значение');
+        }
+        $this->i += strlen($m[0]);
+        return new JNum($m[0]);
+    }
+
+    private function string(): string
+    {
+        // Отрезок от кавычки до закрывающей кавычки разбирает json_decode ядра:
+        // у строки JSON нет чисел, и её экраны он знает.
+        // Жадные без отката (`++`, `*+`): иначе длинная строка исчерпала бы стек PCRE.
+        if (!preg_match('/\G"(?:[^"\\\\]++|\\\\.)*+"/s', $this->s, $m, 0, $this->i)) {
+            $this->fail('строка не закрыта');
+        }
+        $this->i += strlen($m[0]);
+        return json_decode($m[0], false, 1, JSON_THROW_ON_ERROR);
+    }
+}

arxo_codegen/targets/php/runner.php

@@ -0,0 +1,189 @@
+<?php
+// Раннер PHP-бэкенда: тот же вход и тот же ответ, что у runner.rb.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3, текст побайтово одинаков между
+// целями; любое другое исключение — крах (код 255), который ворота валят.
+declare(strict_types=1);
+
+require __DIR__ . '/runtime.php';
+require __DIR__ . '/json.php';
+require __DIR__ . '/model.php';
+
+$ISSUES = [];
+$CONSTS = [];
+
+function arg(array $a): mixed
+{
+    global $CONSTS;
+    $kind = JsonText::text($a['kind'] ?? null);
+    if ($kind === 'entity_ref') {
+        return JsonText::text($a['id'] ?? null);
+    }
+    if ($kind === 'const_ref') {
+        // §54: разыменование предшествует исполнению; член перечисления §38 либо
+        // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+        $id = JsonText::text($a['id'] ?? null);
+        return array_key_exists($id, $CONSTS) ? $CONSTS[$id][1] : RT::sym($id);
+    }
+    if ($kind !== 'value') {
+        throw new Refused("аргумент вне среза раннера: $kind");
+    }
+    $t = JsonText::text($a['type']['name'] ?? null);
+    $v = JsonText::text($a['value'] ?? null);
+    return match ($t) {
+        'urn:law:std#Money' => RT::money($v, JsonText::text($a['currency'] ?? null)),
+        'urn:law:std#Decimal', 'urn:law:std#Integer' => RT::dec($v),
+        'urn:law:std#Text' => $v,
+        'urn:law:std#Date' => RT::date($v),
+        default => throw new Refused("аргумент вне среза раннера: $t"),
+    };
+}
+
+// Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+// константы; entity_ref типа не несёт (как у оракула).
+function arg_type(array $a): ?string
+{
+    global $CONSTS;
+    $kind = $a['kind'] ?? null;
+    if ($kind === 'value') {
+        return $a['type']['name'] ?? null;
+    }
+    if ($kind === 'const_ref') {
+        return $CONSTS[JsonText::text($a['id'] ?? null)][0] ?? null;
+    }
+    return null;
+}
+
+// Совпадение типа с наследованием сущностей вверх от фактического.
+function conforms(string $actual, string $expected): bool
+{
+    $seen = [];
+    $cur = $actual;
+    while ($cur !== null && !isset($seen[$cur])) {
+        if ($cur === $expected) {
+            return true;
+        }
+        $seen[$cur] = true;
+        $cur = Model::BASES[$cur] ?? null;
+    }
+    return false;
+}
+
+// Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+function well_typed(array $lit): bool
+{
+    global $ISSUES;
+    $params = Model::PARAMS[$lit['predicate']] ?? null;
+    if ($params === null) {
+        return true;
+    }
+    $args = $lit['args'] ?? [];
+    if (count($args) !== count($params)) {
+        $ISSUES[] = 'TYPE_ERROR';
+        return false;
+    }
+    foreach ($params as $i => $expected) {
+        $actual = arg_type($args[$i]);
+        if ($actual !== null && !conforms($actual, $expected)) {
+            $ISSUES[] = 'TYPE_ERROR';
+            return false;
+        }
+    }
+    return true;
+}
+
+// Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+// атома не находит — NEITHER без issue.
+function query_typed(array $lit): bool
+{
+    $params = Model::PARAMS[$lit['predicate']] ?? null;
+    if ($params === null) {
+        return false;
+    }
+    $args = $lit['args'] ?? [];
+    if (count($args) !== count($params)) {
+        return false;
+    }
+    foreach ($params as $i => $expected) {
+        $actual = arg_type($args[$i]);
+        if ($actual !== null && !conforms($actual, $expected)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function key_conflict_blocks(string $predicate): bool
+{
+    $tainted = [];
+    foreach (Model::keyConflictPredicates() as $source) $tainted[$source] = true;
+    $waiting = array_keys($tainted);
+    while ($waiting) {
+        $source = array_pop($waiting);
+        foreach (Model::KEY_READERS[$source] ?? [] as $consumer) {
+            if (!isset($tainted[$consumer])) { $tainted[$consumer] = true; $waiting[] = $consumer; }
+        }
+    }
+    return isset($tainted[$predicate]);
+}
+
+function main(array $argv): void
+{
+    global $ISSUES, $CONSTS;
+    $case = JsonText::read($argv[1]);
+    $query = JsonText::read($argv[2]);
+    RT::setLegalTime(JsonText::text($case['context']['legalTime'] ?? null));
+    $CONSTS = Model::consts();
+    Model::packageFacts();
+    foreach ($case['assertions'] as $a) {
+        $lit = $a['literal'];
+        if (($lit['polarity'] ?? null) !== 'positive') {
+            throw new Refused('§113: отрицательный факт вне L0-среза');
+        }
+        if (!well_typed($lit) || !array_key_exists($lit['predicate'], Model::PARAMS)) {
+            continue;
+        }
+        Model::register($lit['predicate'], array_map('arg', $lit['args']));
+    }
+    Model::saturate();
+    for ($n = Model::keyConflicts(); $n > 0; $n--) {
+        $ISSUES[] = 'KEY_CONFLICT';
+    }
+    $kind = JsonText::text($query['kind'] ?? null);
+    if ($kind !== 'truth') {
+        throw new Refused("вид запроса вне среза раннера: $kind");
+    }
+    $hit = false;
+    $ql = $query['literal'];
+    if (query_typed($ql)) {
+        $want = array_map('arg', $ql['args']);
+        foreach (Model::$TABLES[$ql['predicate']] ?? [] as $r) {
+            if (count($r) !== count($want)) {
+                continue;
+            }
+            $all = true;
+            foreach ($r as $i => $v) {
+                if (!RT::eq($v, $want[$i])) {
+                    $all = false;
+                    break;
+                }
+            }
+            if ($all) {
+                $hit = true;
+                break;
+            }
+        }
+    }
+    // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+    echo '{"queryId":' . JsonText::str(JsonText::text($query['queryId'] ?? null))
+        . ',"truthStatus":' . JsonText::str($hit ? 'TRUE_ONLY' : 'NEITHER')
+        . ',"evaluationStatus":' . JsonText::str(key_conflict_blocks($ql['predicate']) ? 'NON_EXECUTABLE' : 'COMPUTED') . ',"issues":[' . implode(',', array_map([JsonText::class, 'str'], $ISSUES)) . "]}\n";
+}
+
+try {
+    main($argv);
+} catch (Refused $e) {
+    echo '{"refused":' . JsonText::str($e->getMessage()) . "}\n";
+    exit(3);
+}