arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/lua/runtime.lua

@@ -0,0 +1,541 @@
+-- Рантайм L0 для Lua 5.3+. Тот же контракт, что у runtime.rb: точная
+-- десятичная арифметика §58, деньги с валютой, названный режим округления,
+-- календарный день, член перечисления. Целых произвольной длины в Lua нет —
+-- свои: модуль числа по основанию 10^7 и знак; двоичной плавающей точки нет
+-- ни в одном пути.
+local RT = {}
+
+-- Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+-- печатает его как JSON с кодом выхода 3; любая другая ошибка — крах.
+local Refused = {}
+Refused.__index = Refused
+RT.Refused = Refused
+
+local function refuse(msg)
+  error(setmetatable({msg = msg}, Refused), 0)
+end
+RT.refuse = refuse
+
+function RT.is_refused(e)
+  return getmetatable(e) == Refused
+end
+
+-- --- целые произвольной длины ------------------------------------------------
+-- {neg = bool, m = {младшая конечность, ...}}; ноль — пустой m и neg = false.
+local BASE = 10000000
+local WIDTH = 7
+
+local function trim(m)
+  local n = #m
+  while n > 0 and m[n] == 0 do
+    m[n] = nil
+    n = n - 1
+  end
+  return m
+end
+
+local function big(neg, m)
+  trim(m)
+  if #m == 0 then neg = false end
+  return {neg = neg, m = m}
+end
+
+local function parse_int(s)
+  local neg = false
+  if s:sub(1, 1) == "-" then
+    neg = true
+    s = s:sub(2)
+  end
+  if not s:match("^%d+$") then error("целое: не десятичная запись: " .. s) end
+  local m = {}
+  local i = #s
+  while i >= 1 do
+    local j = i - WIDTH + 1
+    if j < 1 then j = 1 end
+    m[#m + 1] = math.tointeger(tonumber(s:sub(j, i)))
+    i = j - 1
+  end
+  return big(neg, m)
+end
+
+local function from_int(n)
+  local neg = n < 0
+  if neg then n = -n end
+  local m = {}
+  while n > 0 do
+    m[#m + 1] = n % BASE
+    n = n // BASE
+  end
+  return big(neg, m)
+end
+
+local function mag_str(m)
+  if #m == 0 then return "0" end
+  local parts = {tostring(m[#m])}
+  for i = #m - 1, 1, -1 do
+    parts[#parts + 1] = string.format("%07d", m[i])
+  end
+  return table.concat(parts)
+end
+
+local function int_str(x)
+  return (x.neg and "-" or "") .. mag_str(x.m)
+end
+
+local function mag_cmp(a, b)
+  if #a ~= #b then return #a < #b and -1 or 1 end
+  for i = #a, 1, -1 do
+    if a[i] ~= b[i] then return a[i] < b[i] and -1 or 1 end
+  end
+  return 0
+end
+
+local function mag_add(a, b)
+  local r, carry = {}, 0
+  local n = #a > #b and #a or #b
+  for i = 1, n do
+    local t = (a[i] or 0) + (b[i] or 0) + carry
+    r[i] = t % BASE
+    carry = t // BASE
+  end
+  if carry > 0 then r[n + 1] = carry end
+  return r
+end
+
+-- a >= b по модулю.
+local function mag_sub(a, b)
+  local r, borrow = {}, 0
+  for i = 1, #a do
+    local t = a[i] - (b[i] or 0) - borrow
+    if t < 0 then
+      t = t + BASE
+      borrow = 1
+    else
+      borrow = 0
+    end
+    r[i] = t
+  end
+  return trim(r)
+end
+
+local function mag_mul(a, b)
+  if #a == 0 or #b == 0 then return {} end
+  local r = {}
+  for i = 1, #a + #b do r[i] = 0 end
+  for i = 1, #a do
+    local carry = 0
+    local ai = a[i]
+    for j = 1, #b do
+      local t = r[i + j - 1] + ai * b[j] + carry
+      r[i + j - 1] = t % BASE
+      carry = t // BASE
+    end
+    local k = i + #b
+    while carry > 0 do
+      local t = r[k] + carry
+      r[k] = t % BASE
+      carry = t // BASE
+      k = k + 1
+    end
+  end
+  return trim(r)
+end
+
+local function mag_mul_small(a, s)
+  local r, carry = {}, 0
+  for i = 1, #a do
+    local t = a[i] * s + carry
+    r[i] = t % BASE
+    carry = t // BASE
+  end
+  local k = #a + 1
+  while carry > 0 do
+    r[k] = carry % BASE
+    carry = carry // BASE
+    k = k + 1
+  end
+  return trim(r)
+end
+
+-- Деление модулей в столбик: цифра частного по основанию 10^7 подбирается
+-- двоичным поиском. Делитель ненулевой.
+local function mag_divmod(a, b)
+  if mag_cmp(a, b) < 0 then
+    local r = {}
+    for i = 1, #a do r[i] = a[i] end
+    return {}, r
+  end
+  local q, rem = {}, {}
+  for i = #a, 1, -1 do
+    table.insert(rem, 1, a[i])
+    trim(rem)
+    local lo, hi = 0, BASE - 1
+    while lo < hi do
+      local mid = (lo + hi + 1) // 2
+      if mag_cmp(mag_mul_small(b, mid), rem) <= 0 then lo = mid else hi = mid - 1 end
+    end
+    if lo > 0 then rem = mag_sub(rem, mag_mul_small(b, lo)) end
+    q[i] = lo
+  end
+  return trim(q), rem
+end
+
+local I = {}
+function I.add(x, y)
+  if x.neg == y.neg then return big(x.neg, mag_add(x.m, y.m)) end
+  local c = mag_cmp(x.m, y.m)
+  if c == 0 then return big(false, {}) end
+  if c > 0 then return big(x.neg, mag_sub(x.m, y.m)) end
+  return big(y.neg, mag_sub(y.m, x.m))
+end
+function I.neg(x) return big(not x.neg, x.m) end
+function I.sub(x, y) return I.add(x, big(not y.neg, y.m)) end
+function I.mul(x, y) return big(x.neg ~= y.neg, mag_mul(x.m, y.m)) end
+function I.zero(x) return #x.m == 0 end
+function I.cmp(x, y)
+  if x.neg ~= y.neg then return x.neg and -1 or 1 end
+  local c = mag_cmp(x.m, y.m)
+  return x.neg and -c or c
+end
+function I.absv(x) return big(false, x.m) end
+-- Частное и остаток с усечением к нулю: знак остатка — знак делимого.
+function I.divmod(x, y)
+  local q, r = mag_divmod(x.m, y.m)
+  return big(x.neg ~= y.neg, q), big(x.neg, r)
+end
+function I.pow10(k)
+  local r = from_int(1)
+  local ten = from_int(10)
+  for _ = 1, k do r = I.mul(r, ten) end
+  return r
+end
+function I.gcd(x, y)
+  local a, b = I.absv(x), I.absv(y)
+  while not I.zero(b) do
+    local _, r = I.divmod(a, b)
+    a, b = b, r
+  end
+  return a
+end
+-- Малое целое: вызывающий обязан сперва проверить диапазон.
+function I.to_small(x)
+  local n = 0
+  for i = #x.m, 1, -1 do n = n * BASE + x.m[i] end
+  return x.neg and -n or n
+end
+I.parse = parse_int
+I.from = from_int
+I.str = int_str
+RT.I = I
+
+-- --- значения ----------------------------------------------------------------
+-- Dec {kind="dec", u, s}, Money {kind="money", u, s, cur}; календарный день
+-- §2.15 в канонической записи ISO — {kind="date", v}: порядок записи и есть
+-- порядок дня; член перечисления §38 или ссылка без объявления — {kind="sym",
+-- id}. Text и сущность — строки Lua.
+local function dec_of(u, s) return {kind = "dec", u = u, s = s} end
+local function money_of(u, s, cur) return {kind = "money", u = u, s = s, cur = cur} end
+
+function RT.dec(lit)
+  lit = tostring(lit)
+  local ip, fp = lit:match("^([^.]*)%.(.*)$")
+  if ip == nil then
+    ip, fp = lit, ""
+  end
+  local neg = ip:sub(1, 1) == "-"
+  local digits = (neg and ip:sub(2) or ip) .. fp
+  return dec_of(parse_int((neg and "-" or "") .. digits), #fp)
+end
+
+function RT.money(lit, cur)
+  local d = RT.dec(lit)
+  return money_of(d.u, d.s, cur)
+end
+
+function RT.date(lit) return {kind = "date", v = tostring(lit)} end
+function RT.sym(id) return {kind = "sym", id = tostring(id)} end
+
+local function kind(v)
+  if type(v) == "table" then return v.kind end
+  return type(v)
+end
+local function is_num(v) local k = kind(v) return k == "dec" or k == "money" end
+local function is_money(v) return kind(v) == "money" end
+
+-- §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+local function same(a, b, op)
+  if not (is_num(a) and is_num(b) and is_money(a) == is_money(b)) then
+    refuse("§58: виды операндов не совпадают: " .. op)
+  end
+  if is_money(a) and a.cur ~= b.cur then refuse("§58: разные валюты: " .. op) end
+end
+
+local function imax(x, y) if x > y then return x end return y end
+
+local function pair(a, b)
+  local s = imax(a.s, b.s)
+  return I.mul(a.u, I.pow10(s - a.s)), I.mul(b.u, I.pow10(s - b.s)), s
+end
+
+local function make(u, s, like)
+  if is_money(like) then return money_of(u, s, like.cur) end
+  return dec_of(u, s)
+end
+
+-- Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+local function integral(v)
+  if kind(v) ~= "dec" then return false end
+  local _, r = I.divmod(v.u, I.pow10(v.s))
+  return I.zero(r)
+end
+local function to_int(v)
+  local q = I.divmod(v.u, I.pow10(v.s))
+  return q
+end
+
+function RT.add(a, b)
+  same(a, b, "add")
+  local x, y, s = pair(a, b)
+  return make(I.add(x, y), s, a)
+end
+
+function RT.sub(a, b)
+  same(a, b, "sub")
+  local x, y, s = pair(a, b)
+  return make(I.sub(x, y), s, a)
+end
+
+-- Правило скаляра §49: безразмерное масштабирует размерное; масштаб
+-- результата — сумма масштабов. Два размерных не перемножаются.
+function RT.mul(a, b)
+  if not (is_num(a) and is_num(b)) then refuse("§58: виды операндов не совпадают: mul") end
+  if is_money(a) and is_money(b) then refuse("§58: произведение двух размерных величин не определено") end
+  return make(I.mul(a.u, b.u), a.s + b.s, is_money(a) and a or b)
+end
+
+local TWO, FIVE = from_int(2), from_int(5)
+
+-- Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе nil.
+local function exact(num, den)
+  local g = I.gcd(num, den)
+  if I.zero(g) then g = from_int(1) end
+  num = I.divmod(num, g)
+  den = I.divmod(den, g)
+  if den.neg then
+    num = I.neg(num)
+    den = I.neg(den)
+  end
+  local twos, fives = 0, 0
+  while true do
+    local q, r = I.divmod(den, TWO)
+    if not I.zero(r) then break end
+    den = q
+    twos = twos + 1
+  end
+  while true do
+    local q, r = I.divmod(den, FIVE)
+    if not I.zero(r) then break end
+    den = q
+    fives = fives + 1
+  end
+  if I.cmp(den, from_int(1)) ~= 0 then return nil end
+  local k = imax(twos, fives)
+  local f = from_int(1)
+  for _ = 1, k - twos do f = I.mul(f, TWO) end
+  for _ = 1, k - fives do f = I.mul(f, FIVE) end
+  return I.mul(num, f), k
+end
+
+-- Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money
+-- одной валюты. Integer/Integer даёт Rational — вне среза, отвергается планом.
+function RT.div(a, b)
+  if not (is_num(a) and is_num(b)) then refuse("§58: деление вне таблицы делимых") end
+  if I.zero(b.u) then refuse("деление на ноль — evaluation error (§58)") end
+  local like = nil
+  if is_money(a) and is_money(b) then
+    if a.cur ~= b.cur then
+      refuse("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+    end
+  elseif is_money(a) then
+    like = a
+  elseif is_money(b) then
+    refuse("§58: деление вне таблицы делимых")
+  end
+  local qu, qs = exact(I.mul(a.u, I.pow10(b.s)), I.mul(b.u, I.pow10(a.s)))
+  if qu == nil then
+    if like ~= nil then refuse("INEXACT_DIVISION: округление только явной политикой (§50/§18)") end
+    refuse("§58: частное не 10-гладкое — Rational вне среза")
+  end
+  if like == nil then return dec_of(qu, qs) end
+  return money_of(qu, qs, like.cur)
+end
+
+-- Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+function RT.mod(a, b)
+  if not (integral(a) and integral(b)) then refuse("§58: mod определён только для Integer") end
+  local y = to_int(b)
+  if I.zero(y) then refuse("остаток от деления на ноль — evaluation error (§58)") end
+  local ya = I.absv(y)
+  local _, r = I.divmod(to_int(a), ya)
+  if r.neg then r = I.add(r, ya) end
+  return dec_of(r, 0)
+end
+
+function RT.min(a, b)
+  same(a, b, "min")
+  local x, y = pair(a, b)
+  if I.cmp(x, y) <= 0 then return a end
+  return b
+end
+
+function RT.max(a, b)
+  same(a, b, "max")
+  local x, y = pair(a, b)
+  if I.cmp(x, y) >= 0 then return a end
+  return b
+end
+
+function RT.abs(v)
+  if not is_num(v) then refuse("§58: abs — не числовой вид") end
+  return make(I.absv(v.u), v.s, v)
+end
+
+local POW_MIN = parse_int("-9223372036854775808")
+local POW_MAX = parse_int("9223372036854775807")
+
+-- §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+-- вычисление, диапазон — часть контракта. Умножение останавливается, как
+-- только модуль превысил 2^63: при |основание| >= 1 он дальше не убывает, а
+-- при нулевом основании не растёт, — исход тот же, что у полного вычисления.
+function RT.pow(base, exp)
+  if not (integral(base) and integral(exp)) then refuse("§58: pow определён только для Integer") end
+  local e = to_int(exp)
+  if e.neg then refuse("§58: pow — показатель отрицателен") end
+  if I.cmp(e, from_int(4096)) > 0 then refuse("RESOURCE_LIMIT: pow — показатель превышает 4096") end
+  local b = to_int(base)
+  local r = from_int(1)
+  local bound = I.absv(POW_MIN)
+  for _ = 1, I.to_small(e) do
+    r = I.mul(r, b)
+    if I.cmp(I.absv(r), bound) > 0 then break end
+  end
+  if I.cmp(r, POW_MIN) < 0 or I.cmp(r, POW_MAX) > 0 then
+    refuse("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+  end
+  return dec_of(r, 0)
+end
+
+function RT.round(m, digits, mode)
+  if mode ~= "HALF_UP" then refuse("§50: режим округления не реализован: " .. tostring(mode)) end
+  if not is_num(m) then refuse("§50: round — не числовой вид") end
+  local n
+  if math.type(digits) == "integer" then n = digits else n = I.to_small(to_int(digits)) end
+  if m.s <= n then return make(I.mul(m.u, I.pow10(n - m.s)), n, m) end
+  local drop = I.pow10(m.s - n)
+  local q, r = I.divmod(I.absv(m.u), drop)
+  local up = q
+  if I.cmp(I.add(r, r), drop) >= 0 then up = I.add(q, from_int(1)) end -- HALF_UP — от нуля
+  if m.u.neg then up = I.neg(up) end
+  return make(up, n, m)
+end
+
+local ORDER = {
+  lt = function(c) return c < 0 end, le = function(c) return c <= 0 end,
+  gt = function(c) return c > 0 end, ge = function(c) return c >= 0 end,
+  eq = function(c) return c == 0 end, ne = function(c) return c ~= 0 end,
+}
+
+local function str_order(x, y)
+  if x < y then return -1 elseif x > y then return 1 end
+  return 0
+end
+
+function RT.cmp(a, op, b)
+  if kind(a) == "sym" or kind(b) == "sym" then
+    local same_sym = kind(a) == "sym" and kind(b) == "sym" and a.id == b.id
+    if op == "eq" then return same_sym end
+    if op == "ne" then return not same_sym end
+    refuse("§57: вид enum не упорядочен")
+  end
+  if kind(a) == "date" or kind(b) == "date" then
+    if kind(a) == "date" and kind(b) == "date" then
+      local f = ORDER[op]
+      if f == nil then refuse("сравнение вне среза рантайма: " .. tostring(op)) end
+      return f(str_order(a.v, b.v))
+    end
+    if op == "eq" then return false end
+    if op == "ne" then return true end
+    refuse("§57: Date сравнивается только с Date")
+  end
+  if type(a) == "string" or type(b) == "string" then
+    if op == "eq" then return a == b end
+    if op == "ne" then return a ~= b end
+    refuse("порядок на Text вне среза рантайма: " .. tostring(op))
+  end
+  if is_money(a) ~= is_money(b) then refuse("§49: сравнение денег с безразмерным") end
+  if is_money(a) and a.cur ~= b.cur then refuse("§49: разные валюты") end
+  local x, y = pair(a, b)
+  local f = ORDER[op]
+  if f == nil then refuse("сравнение вне среза рантайма: " .. tostring(op)) end
+  return f(I.cmp(x, y))
+end
+
+function RT.eq(a, b)
+  if kind(a) == "sym" or kind(b) == "sym" then
+    return kind(a) == "sym" and kind(b) == "sym" and a.id == b.id
+  end
+  if kind(a) == "date" or kind(b) == "date" then
+    return kind(a) == "date" and kind(b) == "date" and a.v == b.v
+  end
+  if type(a) == "string" or type(b) == "string" then return a == b end
+  if is_money(a) ~= is_money(b) then return false end
+  if is_money(a) and a.cur ~= b.cur then return false end
+  local x, y = pair(a, b)
+  return I.cmp(x, y) == 0
+end
+
+local function norm(d)
+  local u, s = d.u, d.s
+  local ten = from_int(10)
+  while s > 0 do
+    local q, r = I.divmod(u, ten)
+    if not I.zero(r) then break end
+    u = q
+    s = s - 1
+  end
+  return int_str(u) .. "e-" .. s
+end
+
+-- Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+-- ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+local function esc(text)
+  return (text:gsub("\\", "\\\\"):gsub("|", "\\|"))
+end
+
+function RT.key(row)
+  local parts = {}
+  for i = 1, #row do
+    local v = row[i]
+    local k = kind(v)
+    if k == "string" then parts[i] = "e:" .. esc(v)
+    elseif k == "date" then parts[i] = "t:" .. v.v
+    elseif k == "sym" then parts[i] = "c:" .. esc(v.id)
+    elseif k == "money" then parts[i] = "m:" .. v.cur .. ":" .. norm(v)
+    else parts[i] = "d:" .. norm(v)
+    end
+  end
+  return table.concat(parts, "|")
+end
+
+local legal_time = ""
+
+function RT.setLegalTime(t)
+  legal_time = tostring(t)
+end
+
+function RT.legalTime()
+  if legal_time == "" then refuse("legalTime не подан делом") end
+  return legal_time
+end
+
+return RT

arxo_codegen/targets/php/cert.php

@@ -0,0 +1,84 @@
+<?php
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+declare(strict_types=1);
+
+require __DIR__ . '/runtime.php';
+require __DIR__ . '/json.php';
+
+function lit(mixed $x): mixed
+{
+    if (is_string($x)) {
+        return $x;
+    }
+    return match (true) {
+        array_key_exists('dec', $x) => RT::dec($x['dec']),
+        array_key_exists('money', $x) => RT::money($x['money'], $x['cur']),
+        array_key_exists('text', $x) => $x['text'],
+        array_key_exists('date', $x) => RT::date($x['date']),
+        array_key_exists('sym', $x) => RT::sym($x['sym']),
+        array_key_exists('row', $x) => array_map('lit', $x['row']),
+        default => throw new RuntimeException('литерал фикстуры'),
+    };
+}
+
+// Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+function digits(BigI $u, int $s): string
+{
+    $body = str_pad($u->abs()->str(), $s + 1, '0', STR_PAD_LEFT);
+    $text = $s === 0 ? $body : substr($body, 0, -$s) . '.' . substr($body, -$s);
+    return ($u->neg ? '-' : '') . $text;
+}
+
+function render(mixed $v): string
+{
+    return match (true) {
+        $v === null => 'null',
+        is_bool($v) => $v ? 'true' : 'false',
+        is_string($v) => JsonText::str($v),
+        $v instanceof Money => JsonText::str(digits($v->u, $v->s) . ' ' . $v->cur),
+        $v instanceof LDate => JsonText::str($v->v),
+        $v instanceof Sym => JsonText::str($v->id),
+        default => JsonText::str(digits($v->u, $v->s)),
+    };
+}
+
+function run_case(string $op, array $a): mixed
+{
+    switch ($op) {
+        case 'dec': return RT::dec($a[0]);
+        case 'money': return RT::money($a[0], $a[1]);
+        case 'date': return RT::date($a[0]);
+        case 'sym': return RT::sym($a[0]);
+        case 'mul': return RT::mul($a[0], $a[1]);
+        case 'add': return RT::add($a[0], $a[1]);
+        case 'sub': return RT::sub($a[0], $a[1]);
+        case 'div': return RT::div($a[0], $a[1]);
+        case 'mod': return RT::mod($a[0], $a[1]);
+        case 'min': return RT::min($a[0], $a[1]);
+        case 'max': return RT::max($a[0], $a[1]);
+        case 'abs': return RT::abs($a[0]);
+        case 'pow': return RT::pow($a[0], $a[1]);
+        case 'round': return RT::round($a[0], $a[1], $a[2]);
+        case 'cmp': return RT::cmp($a[0], $a[1], $a[2]);
+        case 'eq': return RT::eq($a[0], $a[1]);
+        case 'keyEq': return RT::key($a[0]) === RT::key($a[1]);
+        case 'legalTime': return RT::legalTime();
+        case 'setLegalTime':
+            RT::setLegalTime($a[0]);
+            return null;
+    }
+    throw new RuntimeException("неизвестная операция фикстуры: $op");
+}
+
+$fixture = JsonText::read($argv[1]);
+$out = [];
+foreach ($fixture['cases'] as $c) {
+    try {
+        $got = render(run_case($c['op'], array_map('lit', $c['args'])));
+    } catch (Refused $e) {
+        $got = '{"refused":' . JsonText::str($e->getMessage()) . '}';
+    }
+    $out[] = '{"id":' . JsonText::str($c['id']) . ',"got":' . $got . '}';
+}
+echo '[' . implode(',', $out) . "]\n";