arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/php/runtime.php

@@ -0,0 +1,660 @@
+<?php
+// Рантайм L0 для PHP 8. Тот же контракт, что у runtime.rb: точная десятичная
+// арифметика §58, деньги с валютой, названный режим округления, календарный
+// день, член перечисления. Целых произвольной длины в ядре PHP нет (bcmath и
+// gmp — расширения, которых в сборке может не быть) — свои: модуль по
+// основанию 10^7 и знак.
+//
+// Ловушка PHP: `==` сравнивает строки, похожие на числа, как числа ("1.0" ==
+// "1", "1e3" == "1000"), поэтому текст сравнивается только `===`, а порядок
+// дня — `strcmp`.
+declare(strict_types=1);
+
+/** Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+ *  печатает его как JSON с кодом выхода 3; любое другое исключение — крах. */
+final class Refused extends Exception {}
+
+final class BigI
+{
+    public const BASE = 10000000;
+
+    /** @param int[] $m младшая конечность первой; ноль — пустой массив */
+    public function __construct(public readonly bool $neg, public readonly array $m) {}
+
+    public static function of(bool $neg, array $m): BigI
+    {
+        while ($m && end($m) === 0) {
+            array_pop($m);
+        }
+        return new BigI($m ? $neg : false, $m);
+    }
+
+    public static function int(int $n): BigI
+    {
+        $neg = $n < 0;
+        $n = abs($n);
+        $m = [];
+        while ($n > 0) {
+            $m[] = $n % self::BASE;
+            $n = intdiv($n, self::BASE);
+        }
+        return self::of($neg, $m);
+    }
+
+    public static function parse(string $s): BigI
+    {
+        $neg = str_starts_with($s, '-');
+        if ($neg) {
+            $s = substr($s, 1);
+        }
+        if (!preg_match('/^\d+$/', $s)) {
+            throw new RuntimeException("целое: не десятичная запись: $s");
+        }
+        $m = [];
+        for ($end = strlen($s); $end > 0; $end -= 7) {
+            $start = max(0, $end - 7);
+            $m[] = (int) substr($s, $start, $end - $start);
+        }
+        return self::of($neg, $m);
+    }
+
+    public function isZero(): bool { return !$this->m; }
+    public function abs(): BigI { return new BigI(false, $this->m); }
+    public function negate(): BigI { return self::of(!$this->neg, $this->m); }
+
+    public function str(): string
+    {
+        if (!$this->m) {
+            return '0';
+        }
+        $n = count($this->m);
+        $s = ($this->neg ? '-' : '') . $this->m[$n - 1];
+        for ($i = $n - 2; $i >= 0; $i--) {
+            $s .= str_pad((string) $this->m[$i], 7, '0', STR_PAD_LEFT);
+        }
+        return $s;
+    }
+
+    /** Малое целое: вызывающий обязан сперва проверить диапазон. */
+    public function small(): int
+    {
+        $n = 0;
+        for ($i = count($this->m) - 1; $i >= 0; $i--) {
+            $n = $n * self::BASE + $this->m[$i];
+        }
+        return $this->neg ? -$n : $n;
+    }
+
+    public static function magCmp(array $a, array $b): int
+    {
+        if (count($a) !== count($b)) {
+            return count($a) < count($b) ? -1 : 1;
+        }
+        for ($i = count($a) - 1; $i >= 0; $i--) {
+            if ($a[$i] !== $b[$i]) {
+                return $a[$i] < $b[$i] ? -1 : 1;
+            }
+        }
+        return 0;
+    }
+
+    private static function magAdd(array $a, array $b): array
+    {
+        $r = [];
+        $carry = 0;
+        $n = max(count($a), count($b));
+        for ($i = 0; $i < $n; $i++) {
+            $t = ($a[$i] ?? 0) + ($b[$i] ?? 0) + $carry;
+            $r[] = $t % self::BASE;
+            $carry = intdiv($t, self::BASE);
+        }
+        if ($carry > 0) {
+            $r[] = $carry;
+        }
+        return $r;
+    }
+
+    /** |a| >= |b|. */
+    private static function magSub(array $a, array $b): array
+    {
+        $r = [];
+        $borrow = 0;
+        foreach ($a as $i => $limb) {
+            $t = $limb - ($b[$i] ?? 0) - $borrow;
+            $borrow = $t < 0 ? 1 : 0;
+            $r[] = $t < 0 ? $t + self::BASE : $t;
+        }
+        while ($r && end($r) === 0) {
+            array_pop($r);
+        }
+        return $r;
+    }
+
+    private static function magMul(array $a, array $b): array
+    {
+        if (!$a || !$b) {
+            return [];
+        }
+        $r = array_fill(0, count($a) + count($b) + 1, 0);
+        foreach ($a as $i => $ai) {
+            $carry = 0;
+            foreach ($b as $j => $bj) {
+                $t = $r[$i + $j] + $ai * $bj + $carry;
+                $r[$i + $j] = $t % self::BASE;
+                $carry = intdiv($t, self::BASE);
+            }
+            for ($k = $i + count($b); $carry > 0; $k++) {
+                $t = $r[$k] + $carry;
+                $r[$k] = $t % self::BASE;
+                $carry = intdiv($t, self::BASE);
+            }
+        }
+        while ($r && end($r) === 0) {
+            array_pop($r);
+        }
+        return $r;
+    }
+
+    private static function magMulSmall(array $a, int $s): array
+    {
+        $r = [];
+        $carry = 0;
+        foreach ($a as $limb) {
+            $t = $limb * $s + $carry;
+            $r[] = $t % self::BASE;
+            $carry = intdiv($t, self::BASE);
+        }
+        while ($carry > 0) {
+            $r[] = $carry % self::BASE;
+            $carry = intdiv($carry, self::BASE);
+        }
+        while ($r && end($r) === 0) {
+            array_pop($r);
+        }
+        return $r;
+    }
+
+    /** Деление модулей в столбик: цифра частного по основанию 10^7 подбирается
+     *  двоичным поиском. Делитель ненулевой. */
+    private static function magDivMod(array $a, array $b): array
+    {
+        if (self::magCmp($a, $b) < 0) {
+            return [[], $a];
+        }
+        $q = array_fill(0, count($a), 0);
+        $rem = [];
+        for ($i = count($a) - 1; $i >= 0; $i--) {
+            array_unshift($rem, $a[$i]);
+            while ($rem && end($rem) === 0) {
+                array_pop($rem);
+            }
+            $lo = 0;
+            $hi = self::BASE - 1;
+            while ($lo < $hi) {
+                $mid = intdiv($lo + $hi + 1, 2);
+                if (self::magCmp(self::magMulSmall($b, $mid), $rem) <= 0) {
+                    $lo = $mid;
+                } else {
+                    $hi = $mid - 1;
+                }
+            }
+            if ($lo > 0) {
+                $rem = self::magSub($rem, self::magMulSmall($b, $lo));
+            }
+            $q[$i] = $lo;
+        }
+        return [$q, $rem];
+    }
+
+    public function add(BigI $y): BigI
+    {
+        if ($this->neg === $y->neg) {
+            return self::of($this->neg, self::magAdd($this->m, $y->m));
+        }
+        $c = self::magCmp($this->m, $y->m);
+        if ($c === 0) {
+            return self::int(0);
+        }
+        return $c > 0 ? self::of($this->neg, self::magSub($this->m, $y->m))
+                      : self::of($y->neg, self::magSub($y->m, $this->m));
+    }
+
+    public function sub(BigI $y): BigI { return $this->add($y->negate()); }
+    public function mul(BigI $y): BigI { return self::of($this->neg !== $y->neg, self::magMul($this->m, $y->m)); }
+
+    public function cmp(BigI $y): int
+    {
+        if ($this->neg !== $y->neg) {
+            return $this->neg ? -1 : 1;
+        }
+        $c = self::magCmp($this->m, $y->m);
+        return $this->neg ? -$c : $c;
+    }
+
+    /** Частное и остаток с усечением к нулю: знак остатка — знак делимого. */
+    public function divMod(BigI $y): array
+    {
+        [$q, $r] = self::magDivMod($this->m, $y->m);
+        return [self::of($this->neg !== $y->neg, $q), self::of($this->neg, $r)];
+    }
+
+    public static function pow10(int $k): BigI
+    {
+        $m = [1];
+        for ($i = 0; $i < $k; $i++) {
+            $m = self::magMulSmall($m, 10);
+        }
+        return self::of(false, $m);
+    }
+
+    public static function gcd(BigI $x, BigI $y): BigI
+    {
+        $a = $x->abs();
+        $b = $y->abs();
+        while (!$b->isZero()) {
+            [, $r] = $a->divMod($b);
+            [$a, $b] = [$b, $r];
+        }
+        return $a;
+    }
+}
+
+final class Dec
+{
+    public function __construct(public readonly BigI $u, public readonly int $s) {}
+}
+
+final class Money
+{
+    public function __construct(public readonly BigI $u, public readonly int $s, public readonly string $cur) {}
+}
+
+/** Календарный день §2.15 в канонической записи ISO YYYY-MM-DD: порядок записи
+ *  и есть порядок дня. Не string: у ключа атома и у сравнения свой вид. */
+final class LDate
+{
+    public function __construct(public readonly string $v) {}
+}
+
+/** Член перечисления §38 либо иная ссылка const_ref без объявления: значение —
+ *  stable qualified identity, равенство по ней (§57), порядок не определён. */
+final class Sym
+{
+    public function __construct(public readonly string $id) {}
+}
+
+final class RT
+{
+    private static string $legal = '';
+
+    public static function dec(string $lit): Dec
+    {
+        $parts = explode('.', $lit, 2);
+        $i = $parts[0];
+        $f = $parts[1] ?? '';
+        $neg = str_starts_with($i, '-');
+        $digits = ($neg ? substr($i, 1) : $i) . $f;
+        return new Dec(BigI::parse(($neg ? '-' : '') . $digits), strlen($f));
+    }
+
+    public static function money(string $lit, string $cur): Money
+    {
+        $d = self::dec($lit);
+        return new Money($d->u, $d->s, $cur);
+    }
+
+    public static function date(string $lit): LDate { return new LDate($lit); }
+    public static function sym(string $id): Sym { return new Sym($id); }
+
+    private static function isNum(mixed $v): bool { return $v instanceof Dec || $v instanceof Money; }
+
+    // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+    private static function same(mixed $a, mixed $b, string $op): void
+    {
+        if (!(self::isNum($a) && self::isNum($b) && ($a instanceof Money) === ($b instanceof Money))) {
+            throw new Refused("§58: виды операндов не совпадают: $op");
+        }
+        if ($a instanceof Money && $a->cur !== $b->cur) {
+            throw new Refused("§58: разные валюты: $op");
+        }
+    }
+
+    private static function pair(Dec|Money $a, Dec|Money $b): array
+    {
+        $s = max($a->s, $b->s);
+        return [$a->u->mul(BigI::pow10($s - $a->s)), $b->u->mul(BigI::pow10($s - $b->s)), $s];
+    }
+
+    private static function make(BigI $u, int $s, Dec|Money $like): Dec|Money
+    {
+        return $like instanceof Money ? new Money($u, $s, $like->cur) : new Dec($u, $s);
+    }
+
+    // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+    private static function integral(mixed $v): ?BigI
+    {
+        if (!($v instanceof Dec)) {
+            return null;
+        }
+        [$q, $r] = $v->u->divMod(BigI::pow10($v->s));
+        return $r->isZero() ? $q : null;
+    }
+
+    public static function add(mixed $a, mixed $b): Dec|Money
+    {
+        self::same($a, $b, 'add');
+        [$x, $y, $s] = self::pair($a, $b);
+        return self::make($x->add($y), $s, $a);
+    }
+
+    public static function sub(mixed $a, mixed $b): Dec|Money
+    {
+        self::same($a, $b, 'sub');
+        [$x, $y, $s] = self::pair($a, $b);
+        return self::make($x->sub($y), $s, $a);
+    }
+
+    // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+    // сумма масштабов. Два размерных не перемножаются.
+    public static function mul(mixed $a, mixed $b): Dec|Money
+    {
+        if (!(self::isNum($a) && self::isNum($b))) {
+            throw new Refused('§58: виды операндов не совпадают: mul');
+        }
+        if ($a instanceof Money && $b instanceof Money) {
+            throw new Refused('§58: произведение двух размерных величин не определено');
+        }
+        return self::make($a->u->mul($b->u), $a->s + $b->s, $a instanceof Money ? $a : $b);
+    }
+
+    // Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе null.
+    private static function exact(BigI $num, BigI $den): ?array
+    {
+        $g = BigI::gcd($num, $den);
+        if ($g->isZero()) {
+            $g = BigI::int(1);
+        }
+        [$num] = $num->divMod($g);
+        [$den] = $den->divMod($g);
+        if ($den->neg) {
+            $num = $num->negate();
+            $den = $den->negate();
+        }
+        $twos = $fives = 0;
+        for (;;) {
+            [$q, $r] = $den->divMod(BigI::int(2));
+            if (!$r->isZero()) {
+                break;
+            }
+            $den = $q;
+            $twos++;
+        }
+        for (;;) {
+            [$q, $r] = $den->divMod(BigI::int(5));
+            if (!$r->isZero()) {
+                break;
+            }
+            $den = $q;
+            $fives++;
+        }
+        if ($den->cmp(BigI::int(1)) !== 0) {
+            return null;
+        }
+        $k = max($twos, $fives);
+        $f = BigI::int(1);
+        for ($i = $twos; $i < $k; $i++) {
+            $f = $f->mul(BigI::int(2));
+        }
+        for ($i = $fives; $i < $k; $i++) {
+            $f = $f->mul(BigI::int(5));
+        }
+        return [$num->mul($f), $k];
+    }
+
+    // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+    // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+    public static function div(mixed $a, mixed $b): Dec|Money
+    {
+        if (!(self::isNum($a) && self::isNum($b))) {
+            throw new Refused('§58: деление вне таблицы делимых');
+        }
+        if ($b->u->isZero()) {
+            throw new Refused('деление на ноль — evaluation error (§58)');
+        }
+        $like = null;
+        if ($a instanceof Money && $b instanceof Money) {
+            if ($a->cur !== $b->cur) {
+                throw new Refused('CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте');
+            }
+        } elseif ($a instanceof Money) {
+            $like = $a;
+        } elseif ($b instanceof Money) {
+            throw new Refused('§58: деление вне таблицы делимых');
+        }
+        $q = self::exact($a->u->mul(BigI::pow10($b->s)), $b->u->mul(BigI::pow10($a->s)));
+        if ($q === null) {
+            if ($like !== null) {
+                throw new Refused('INEXACT_DIVISION: округление только явной политикой (§50/§18)');
+            }
+            throw new Refused('§58: частное не 10-гладкое — Rational вне среза');
+        }
+        return $like === null ? new Dec($q[0], $q[1]) : new Money($q[0], $q[1], $like->cur);
+    }
+
+    // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+    public static function mod(mixed $a, mixed $b): Dec
+    {
+        $x = self::integral($a);
+        $y = self::integral($b);
+        if ($x === null || $y === null) {
+            throw new Refused('§58: mod определён только для Integer');
+        }
+        if ($y->isZero()) {
+            throw new Refused('остаток от деления на ноль — evaluation error (§58)');
+        }
+        [, $r] = $x->divMod($y->abs());
+        if ($r->neg) {
+            $r = $r->add($y->abs());
+        }
+        return new Dec($r, 0);
+    }
+
+    public static function min(mixed $a, mixed $b): Dec|Money
+    {
+        self::same($a, $b, 'min');
+        [$x, $y] = self::pair($a, $b);
+        return $x->cmp($y) <= 0 ? $a : $b;
+    }
+
+    public static function max(mixed $a, mixed $b): Dec|Money
+    {
+        self::same($a, $b, 'max');
+        [$x, $y] = self::pair($a, $b);
+        return $x->cmp($y) >= 0 ? $a : $b;
+    }
+
+    public static function abs(mixed $v): Dec|Money
+    {
+        if (!self::isNum($v)) {
+            throw new Refused('§58: abs — не числовой вид');
+        }
+        return self::make($v->u->abs(), $v->s, $v);
+    }
+
+    // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+    // вычисление, диапазон — часть контракта. Умножение останавливается, как
+    // только модуль превысил 2^63: при |основание| >= 1 он дальше не убывает, а
+    // при нулевом основании не растёт, — исход тот же, что у полного вычисления.
+    public static function pow(mixed $base, mixed $exp): Dec
+    {
+        $b = self::integral($base);
+        $e = self::integral($exp);
+        if ($b === null || $e === null) {
+            throw new Refused('§58: pow определён только для Integer');
+        }
+        if ($e->neg) {
+            throw new Refused('§58: pow — показатель отрицателен');
+        }
+        if ($e->cmp(BigI::int(4096)) > 0) {
+            throw new Refused('RESOURCE_LIMIT: pow — показатель превышает 4096');
+        }
+        $min = BigI::parse('-9223372036854775808');
+        $max = BigI::parse('9223372036854775807');
+        $r = BigI::int(1);
+        for ($i = $e->small(); $i > 0; $i--) {
+            $r = $r->mul($b);
+            if (BigI::magCmp($r->m, $min->m) > 0) {
+                break;
+            }
+        }
+        if ($r->cmp($min) < 0 || $r->cmp($max) > 0) {
+            throw new Refused('RESOURCE_LIMIT: pow — результат вне 64-битного диапазона');
+        }
+        return new Dec($r, 0);
+    }
+
+    public static function round(mixed $m, mixed $digits, string $mode): Dec|Money
+    {
+        if ($mode !== 'HALF_UP') {
+            throw new Refused("§50: режим округления не реализован: $mode");
+        }
+        if (!self::isNum($m)) {
+            throw new Refused('§50: round — не числовой вид');
+        }
+        $n = is_int($digits) ? $digits : $digits->u->divMod(BigI::pow10($digits->s))[0]->small();
+        if ($m->s <= $n) {
+            return self::make($m->u->mul(BigI::pow10($n - $m->s)), $n, $m);
+        }
+        $drop = BigI::pow10($m->s - $n);
+        [$q, $r] = $m->u->abs()->divMod($drop);
+        $up = $r->add($r)->cmp($drop) >= 0 ? $q->add(BigI::int(1)) : $q; // HALF_UP — от нуля
+        return self::make($m->u->neg ? $up->negate() : $up, $n, $m);
+    }
+
+    private static function order(string $op, int $c): bool
+    {
+        return match ($op) {
+            'lt' => $c < 0,
+            'le' => $c <= 0,
+            'gt' => $c > 0,
+            'ge' => $c >= 0,
+            'eq' => $c === 0,
+            'ne' => $c !== 0,
+            default => throw new Refused("сравнение вне среза рантайма: $op"),
+        };
+    }
+
+    public static function cmp(mixed $a, string $op, mixed $b): bool
+    {
+        if ($a instanceof Sym || $b instanceof Sym) {
+            $same = $a instanceof Sym && $b instanceof Sym && $a->id === $b->id;
+            if ($op === 'eq') {
+                return $same;
+            }
+            if ($op === 'ne') {
+                return !$same;
+            }
+            throw new Refused('§57: вид enum не упорядочен');
+        }
+        if ($a instanceof LDate || $b instanceof LDate) {
+            if ($a instanceof LDate && $b instanceof LDate) {
+                return self::order($op, strcmp($a->v, $b->v));
+            }
+            if ($op === 'eq') {
+                return false;
+            }
+            if ($op === 'ne') {
+                return true;
+            }
+            throw new Refused('§57: Date сравнивается только с Date');
+        }
+        if (is_string($a) || is_string($b)) {
+            if ($op === 'eq') {
+                return $a === $b;
+            }
+            if ($op === 'ne') {
+                return $a !== $b;
+            }
+            throw new Refused("порядок на Text вне среза рантайма: $op");
+        }
+        if (($a instanceof Money) !== ($b instanceof Money)) {
+            throw new Refused('§49: сравнение денег с безразмерным');
+        }
+        if ($a instanceof Money && $a->cur !== $b->cur) {
+            throw new Refused('§49: разные валюты');
+        }
+        [$x, $y] = self::pair($a, $b);
+        return self::order($op, $x->cmp($y));
+    }
+
+    public static function eq(mixed $a, mixed $b): bool
+    {
+        if ($a instanceof Sym || $b instanceof Sym) {
+            return $a instanceof Sym && $b instanceof Sym && $a->id === $b->id;
+        }
+        if ($a instanceof LDate || $b instanceof LDate) {
+            return $a instanceof LDate && $b instanceof LDate && $a->v === $b->v;
+        }
+        if (is_string($a) || is_string($b)) {
+            return $a === $b;
+        }
+        if (($a instanceof Money) !== ($b instanceof Money)) {
+            return false;
+        }
+        if ($a instanceof Money && $a->cur !== $b->cur) {
+            return false;
+        }
+        [$x, $y] = self::pair($a, $b);
+        return $x->cmp($y) === 0;
+    }
+
+    private static function norm(Dec|Money $d): string
+    {
+        $u = $d->u;
+        $s = $d->s;
+        while ($s > 0) {
+            [$q, $r] = $u->divMod(BigI::int(10));
+            if (!$r->isZero()) {
+                break;
+            }
+            $u = $q;
+            $s--;
+        }
+        return $u->str() . 'e-' . $s;
+    }
+
+    // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+    // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+    private static function esc(string $text): string
+    {
+        return str_replace(['\\', '|'], ['\\\\', '\\|'], $text);
+    }
+
+    public static function key(array $row): string
+    {
+        $parts = [];
+        foreach ($row as $v) {
+            $parts[] = match (true) {
+                is_string($v) => 'e:' . self::esc($v),
+                $v instanceof LDate => 't:' . $v->v,
+                $v instanceof Sym => 'c:' . self::esc($v->id),
+                $v instanceof Money => 'm:' . $v->cur . ':' . self::norm($v),
+                default => 'd:' . self::norm($v),
+            };
+        }
+        return implode('|', $parts);
+    }
+
+    public static function setLegalTime(string $t): void
+    {
+        self::$legal = $t;
+    }
+
+    public static function legalTime(): string
+    {
+        if (self::$legal === '') {
+            throw new Refused('legalTime не подан делом');
+        }
+        return self::$legal;
+    }
+}