arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/lua/emit.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""Эмиттер Lua. Тот же план и тот же контракт рантайма; строки таблиц — массивы
+Lua с индексом от единицы, правила — функции в массиве (у функции Lua не больше
+200 локальных имён, пакет с сотней правил в локалы бы не влез)."""
+import json
+import shutil
+import subprocess
+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 lua_str(s: str) -> str:
+    """Строковый литерал Lua: символы UTF-8 как есть, кавычка, экран и
+    управляющие символы — десятичным экраном `\\ddd`. Экраны JSON вида
+    `\\uXXXX` Lua не знает, поэтому `json.dumps` здесь не годится."""
+    return '"' + "".join(f"\\{ord(c):03d}" if c in '"\\' or ord(c) < 0x20 or ord(c) == 0x7F else c
+                         for c in s) + '"'
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}[{t["col"] + 1}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT.money({lua_str(t["v"])}, {lua_str(t["cur"])})'
+        if t["t"] == "dec":
+            return f'RT.dec({lua_str(t["v"])})'
+        if t["t"] == "date":
+            return f'RT.date({lua_str(t["v"])})'
+        if t["t"] == "enum":
+            return f'RT.sym({lua_str(t["v"])})'
+        return lua_str(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 emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ['local RT = require("runtime")', "", "local M = {}", "M.TABLES = {"]
+    for t in plan["tables"]:
+        L.append(f'  [{lua_str(t["pred"])}] = {{}},')
+    L.append("}")
+    L.append("-- Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("M.PARAMS = {")
+    for t in plan["tables"]:
+        L.append(f'  [{lua_str(t["pred"])}] = {{' + ", ".join(lua_str(p) for p in t["params"]) + "},")
+    L.append("}")
+    L.append("-- Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("M.CONSTS = {")
+    for cid, c in plan["consts"].items():
+        L.append(f'  [{lua_str(cid)}] = {{{lua_str(c["type"])}, {term(c["term"])}}},')
+    L.append("}")
+    L.append("-- Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("M.BASES = {")
+    for sub, base in plan["bases"].items():
+        L.append(f"  [{lua_str(sub)}] = {lua_str(base)},")
+    L.append("}")
+    L.append("-- Ключи отношений §45.1: позиции столбцов каждого ключа (от единицы).")
+    L.append("M.KEYS = {")
+    for t in plan["tables"]:
+        if t["keys"]:
+            keys = ", ".join("{" + ", ".join(str(i + 1) for i in k) + "}" for k in t["keys"])
+            L.append(f'  {{{lua_str(t["pred"])}, {{{keys}}}}},')
+    L.append("}")
+    L.append("local seen = {}")
+    L.append("")
+    L.append("local function add_row(urn, row)")
+    L.append("  local s = seen[urn]")
+    L.append("  if s == nil then")
+    L.append("    s = {}")
+    L.append("    seen[urn] = s")
+    L.append("  end")
+    L.append("  local k = RT.key(row)")
+    L.append("  if s[k] then return false end")
+    L.append("  s[k] = true")
+    L.append("  local t = M.TABLES[urn]")
+    L.append("  t[#t + 1] = row")
+    L.append("  return true")
+    L.append("end")
+    L.append("")
+    L.append("local RULES = {}")
+    for r in plan["rules"]:
+        L.append(f'-- {r["id"]}')
+        L.append(f'RULES[#RULES + 1] = function() -- {r["name"]}')
+        L.append("  local grew = false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'  if RT.legalTime() < {lua_str(r["window"]["start"])} then return false end')
+            if r["window"].get("end"):
+                L.append(f'  if RT.legalTime() >= {lua_str(r["window"]["end"])} then return false end')
+        ind = "  "
+        for i, a in enumerate(r["atoms"]):
+            # Длина берётся один раз на входе в цикл: строки, добавленные этим
+            # же проходом, не перебираются — как у копии таблицы в других целях.
+            L.append(f'{ind}local t{i} = M.TABLES[{lua_str(a["pred"])}]')
+            L.append(f"{ind}for i{i} = 1, #t{i} do")
+            ind += "  "
+            L.append(f"{ind}local r{i} = t{i}[i{i}]")
+        conds = []
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            conds.append(f'RT.cmp(r{ai}[{aj + 1}], "eq", r{bi}[{bj + 1}])')
+        for f in r["filters"]:
+            conds.append(f'RT.eq(r{f["row"]}[{f["col"] + 1}], {term(f["term"])})')
+        for g in r["guards"]:
+            conds.append(f'RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        add = f'if add_row({lua_str(r["head"]["pred"])}, {{{args}}}) then grew = true end'
+        if conds:
+            # `and` вычисляется по порядку и обрывается на первом ложном — тот же
+            # порядок отсева и тех же отказов, что у `next unless` в Ruby.
+            L.append(f"{ind}if " + " and ".join(conds) + " then")
+            L.append(f"{ind}  {add}")
+            L.append(f"{ind}end")
+        else:
+            L.append(f"{ind}{add}")
+        for _ in r["atoms"]:
+            ind = ind[:-2]
+            L.append(ind + "end")
+        L.append("  return grew")
+        L.append("end")
+        L.append("")
+    L.append("function M.saturate()")
+    L.append("  local grew = true")
+    L.append("  while grew do")
+    L.append("    grew = false")
+    L.append("    for i = 1, #RULES do")
+    L.append("      if RULES[i]() then grew = true end")
+    L.append("    end")
+    L.append("  end")
+    L.append("end")
+    L.append("")
+    L.append("function M.register(urn, row)")
+    L.append("  return add_row(urn, row)")
+    L.append("end")
+    L.append("")
+    L.append("-- KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("function M.key_conflicts()")
+    L.append("  local n = 0")
+    L.append("  for _, entry in ipairs(M.KEYS) do")
+    L.append("    local rows = M.TABLES[entry[1]]")
+    L.append("    for _, key in ipairs(entry[2]) do")
+    L.append("      local groups = {}")
+    L.append("      for _, row in ipairs(rows) do")
+    L.append("        local proj = {}")
+    L.append("        for j, i in ipairs(key) do proj[j] = row[i] end")
+    L.append("        local g = RT.key(proj)")
+    L.append("        groups[g] = (groups[g] or 0) + 1")
+    L.append("      end")
+    L.append("      for _, c in pairs(groups) do")
+    L.append("        if c > 1 then n = n + 1 end")
+    L.append("      end")
+    L.append("    end")
+    L.append("  end")
+    L.append("  return n")
+    L.append("end")
+    L.append("")
+    readers = {}
+    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("M.KEY_READERS = {" + ", ".join(
+        f"[{lua_str(key)}] = {{" + ", ".join(lua_str(head) for head in sorted(value)) + "}"
+        for key, value in sorted(readers.items())) + "}")
+    L.append("function M.key_conflict_predicates()")
+    L.append("  local out = {}")
+    L.append("  for _, entry in ipairs(M.KEYS) do")
+    L.append("    local rows = M.TABLES[entry[1]]")
+    L.append("    for _, key in ipairs(entry[2]) do")
+    L.append("      local groups = {}; for _, row in ipairs(rows) do local p = {}; for j, i in ipairs(key) do p[j] = row[i] end; local g = RT.key(p); groups[g] = (groups[g] or 0) + 1 end")
+    L.append("      for _, c in pairs(groups) do if c > 1 then out[entry[1]] = true end end")
+    L.append("    end")
+    L.append("  end")
+    L.append("  return out")
+    L.append("end")
+    L.append("")
+    for f in plan["facts"]:
+        L.append(f'add_row({lua_str(f["pred"])}, {{' + ", ".join(term(a) for a in f["args"]) + "})")
+    L.append("")
+    L.append("return M")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "lua"
+MODEL = "model.lua"
+MAINS = {"runner": "runner.lua", "cert": "cert.lua"}
+
+
+def _lua():
+    """Интерпретатор Lua 5.3+ (целые 64 бита, `//`, `utf8`); LuaJIT называет
+    себя 5.1 и не подходит: без целых точной арифметики на конечностях нет."""
+    for name in ("lua", "lua5.5", "lua5.4", "lua5.3"):
+        path = shutil.which(name)
+        if not path:
+            continue
+        try:
+            res = subprocess.run([path, "-e", "print(math.type and _VERSION or '')"],
+                                 capture_output=True, text=True, timeout=30)
+        except (OSError, subprocess.TimeoutExpired):
+            continue
+        if res.returncode == 0 and res.stdout.strip() >= "Lua 5.3":
+            return path
+    return None
+
+
+def available():
+    lua = _lua()
+    return (True, lua) if lua else (False, "нет lua 5.3+ в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("runtime.lua", "json.lua", 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 [_lua() or "lua", 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/lua/json.lua

@@ -0,0 +1,133 @@
+-- Разбор и печать JSON для Lua: в стандартной библиотеке их нет. Число
+-- остаётся ТЕКСТОМ ({num = запись}) — двоичная плавающая точка не видит ни
+-- одной записи дела; null — отдельное значение JSON.null, а не nil.
+local J = {}
+J.null = setmetatable({}, {__tostring = function() return "null" end})
+
+local function fail(s, i, what)
+  error("JSON: " .. what .. " в позиции " .. i .. ": " .. s:sub(i, i + 20))
+end
+
+local function skip(s, i)
+  local _, e = s:find("^[ \t\r\n]*", i)
+  return e + 1
+end
+
+local parse_value
+
+local function parse_string(s, i)
+  -- s:sub(i, i) == '"'
+  local out = {}
+  i = i + 1
+  while true do
+    local c = s:sub(i, i)
+    if c == "" then fail(s, i, "строка не закрыта") end
+    if c == '"' then return table.concat(out), i + 1 end
+    if c == "\\" then
+      local e = s:sub(i + 1, i + 1)
+      local simple = {['"'] = '"', ["\\"] = "\\", ["/"] = "/", b = "\b", f = "\f", n = "\n", r = "\r", t = "\t"}
+      if simple[e] then
+        out[#out + 1] = simple[e]
+        i = i + 2
+      elseif e == "u" then
+        local cp = tonumber(s:sub(i + 2, i + 5), 16)
+        if cp == nil then fail(s, i, "плохой \\u") end
+        i = i + 6
+        if cp >= 0xD800 and cp <= 0xDBFF and s:sub(i, i + 1) == "\\u" then
+          local lo = tonumber(s:sub(i + 2, i + 5), 16)
+          if lo and lo >= 0xDC00 and lo <= 0xDFFF then
+            cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00)
+            i = i + 6
+          end
+        end
+        out[#out + 1] = utf8.char(cp)
+      else
+        fail(s, i, "плохой экран")
+      end
+    else
+      local j = s:find('["\\]', i)
+      if j == nil then fail(s, i, "строка не закрыта") end
+      out[#out + 1] = s:sub(i, j - 1)
+      i = j
+    end
+  end
+end
+
+function parse_value(s, i)
+  i = skip(s, i)
+  local c = s:sub(i, i)
+  if c == "{" then
+    local obj = {}
+    i = skip(s, i + 1)
+    if s:sub(i, i) == "}" then return obj, i + 1 end
+    while true do
+      i = skip(s, i)
+      if s:sub(i, i) ~= '"' then fail(s, i, "ожидался ключ") end
+      local k
+      k, i = parse_string(s, i)
+      i = skip(s, i)
+      if s:sub(i, i) ~= ":" then fail(s, i, "ожидалось ':'") end
+      obj[k], i = parse_value(s, i + 1)
+      i = skip(s, i)
+      local d = s:sub(i, i)
+      if d == "}" then return obj, i + 1 end
+      if d ~= "," then fail(s, i, "ожидалось ',' или '}'") end
+      i = i + 1
+    end
+  elseif c == "[" then
+    local arr = {}
+    i = skip(s, i + 1)
+    if s:sub(i, i) == "]" then return arr, i + 1 end
+    while true do
+      arr[#arr + 1], i = parse_value(s, i)
+      i = skip(s, i)
+      local d = s:sub(i, i)
+      if d == "]" then return arr, i + 1 end
+      if d ~= "," then fail(s, i, "ожидалось ',' или ']'") end
+      i = i + 1
+    end
+  elseif c == '"' then
+    return parse_string(s, i)
+  elseif s:sub(i, i + 3) == "true" then
+    return true, i + 4
+  elseif s:sub(i, i + 4) == "false" then
+    return false, i + 5
+  elseif s:sub(i, i + 3) == "null" then
+    return J.null, i + 4
+  end
+  local _, e = s:find("^-?%d+%.?%d*[eE]?[-+]?%d*", i)
+  if e == nil then fail(s, i, "неизвестное значение") end
+  return {num = s:sub(i, e)}, e + 1
+end
+
+function J.decode(s)
+  local v, i = parse_value(s, 1)
+  if skip(s, i) <= #s then fail(s, i, "лишнее после значения") end
+  return v
+end
+
+-- Текст значения JSON: строка как есть, число — его запись.
+function J.text(v)
+  if type(v) == "table" and v.num then return v.num end
+  if v == nil or v == J.null then return "" end
+  return tostring(v)
+end
+
+function J.read(path)
+  local f = assert(io.open(path, "rb"))
+  local s = f:read("a")
+  f:close()
+  return J.decode(s)
+end
+
+local ESC = {['"'] = '\\"', ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t"}
+
+-- Строка печатается байтами UTF-8 как есть, экранируются кавычка, экран и
+-- управляющие символы.
+function J.str(s)
+  return '"' .. s:gsub('[%c"\\]', function(c)
+    return ESC[c] or string.format("\\u%04x", c:byte())
+  end) .. '"'
+end
+
+return J

arxo_codegen/targets/lua/runner.lua

@@ -0,0 +1,167 @@
+-- Раннер Lua-бэкенда: тот же вход и тот же ответ, что у runner.rb.
+--
+-- Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+-- среза — JSON {"refused": текст} и код 3, текст побайтово одинаков между
+-- целями; любая другая ошибка — крах с кодом 1, который ворота валят.
+local dir = arg[0]:match("^(.*)/") or "."
+package.path = dir .. "/?.lua;" .. package.path
+local RT = require("runtime")
+local J = require("json")
+local M = require("model")
+
+local ISSUES = {}
+
+local function field(t, k)
+  if type(t) ~= "table" or t == J.null then return nil end
+  local v = t[k]
+  if v == J.null then return nil end
+  return v
+end
+
+local function arg_value(a)
+  local kind = field(a, "kind")
+  if kind == "entity_ref" then return field(a, "id") end
+  if kind == "const_ref" then
+    -- §54: разыменование предшествует исполнению; член перечисления §38 либо
+    -- имя без объявления остаётся идентичностью, как в ключе атома оракула.
+    local c = M.CONSTS[field(a, "id")]
+    if c == nil then return RT.sym(J.text(field(a, "id"))) end
+    return c[2]
+  end
+  if kind ~= "value" then RT.refuse("аргумент вне среза раннера: " .. J.text(kind)) end
+  local t = field(field(a, "type"), "name")
+  local v = J.text(field(a, "value"))
+  if t == "urn:law:std#Money" then return RT.money(v, field(a, "currency")) end
+  if t == "urn:law:std#Decimal" or t == "urn:law:std#Integer" then return RT.dec(v) end
+  if t == "urn:law:std#Text" then return v end
+  if t == "urn:law:std#Date" then return RT.date(v) end
+  RT.refuse("аргумент вне среза раннера: " .. J.text(t))
+end
+
+-- Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+-- константы; entity_ref типа не несёт (как у оракула).
+local function arg_type(a)
+  if field(a, "kind") == "value" then return field(field(a, "type"), "name") end
+  if field(a, "kind") == "const_ref" then
+    local c = M.CONSTS[field(a, "id")]
+    return c and c[1]
+  end
+  return nil
+end
+
+-- Совпадение типа с наследованием сущностей вверх от фактического.
+local function conforms(actual, expected)
+  local seen = {}
+  local cur = actual
+  while cur ~= nil and not seen[cur] do
+    if cur == expected then return true end
+    seen[cur] = true
+    cur = M.BASES[cur]
+  end
+  return false
+end
+
+-- Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+local function well_typed(lit)
+  local params = M.PARAMS[lit.predicate]
+  if params == nil then return true end
+  local args = field(lit, "args") or {}
+  if #args ~= #params then
+    ISSUES[#ISSUES + 1] = "TYPE_ERROR"
+    return false
+  end
+  for i, expected in ipairs(params) do
+    local actual = arg_type(args[i])
+    if actual ~= nil and not conforms(actual, expected) then
+      ISSUES[#ISSUES + 1] = "TYPE_ERROR"
+      return false
+    end
+  end
+  return true
+end
+
+-- Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+-- атома не находит — NEITHER без issue.
+local function query_typed(lit)
+  local params = M.PARAMS[lit.predicate]
+  if params == nil then return false end
+  local args = field(lit, "args") or {}
+  if #args ~= #params then return false end
+  for i, expected in ipairs(params) do
+    local actual = arg_type(args[i])
+    if actual ~= nil and not conforms(actual, expected) then return false end
+  end
+  return true
+end
+
+local function key_conflict_blocks(predicate)
+  local tainted, waiting = M.key_conflict_predicates(), {}
+  for pred, _ in pairs(tainted) do waiting[#waiting + 1] = pred end
+  local at = 1
+  while at <= #waiting do
+    local source = waiting[at]; at = at + 1
+    for _, consumer in ipairs(M.KEY_READERS[source] or {}) do
+      if not tainted[consumer] then tainted[consumer] = true; waiting[#waiting + 1] = consumer end
+    end
+  end
+  return tainted[predicate] == true
+end
+
+local function main()
+  local case = J.read(arg[1])
+  local query = J.read(arg[2])
+  RT.setLegalTime(J.text(field(field(case, "context"), "legalTime")))
+  for _, a in ipairs(case.assertions) do
+    local lit = a.literal
+    if field(lit, "polarity") ~= "positive" then RT.refuse("§113: отрицательный факт вне L0-среза") end
+    if well_typed(lit) and M.PARAMS[lit.predicate] ~= nil then
+      local row = {}
+      for i, x in ipairs(lit.args) do row[i] = arg_value(x) end
+      M.register(lit.predicate, row)
+    end
+  end
+  M.saturate()
+  for _ = 1, M.key_conflicts() do ISSUES[#ISSUES + 1] = "KEY_CONFLICT" end
+  if field(query, "kind") ~= "truth" then
+    RT.refuse("вид запроса вне среза раннера: " .. J.text(field(query, "kind")))
+  end
+  local hit = false
+  if query_typed(query.literal) then
+    local want = {}
+    for i, x in ipairs(query.literal.args) do want[i] = arg_value(x) end
+    for _, r in ipairs(M.TABLES[query.literal.predicate] or {}) do
+      if #r == #want then
+        local all = true
+        for i = 1, #r do
+          if not RT.eq(r[i], want[i]) then
+            all = false
+            break
+          end
+        end
+        if all then
+          hit = true
+          break
+        end
+      end
+    end
+  end
+  local issues = {}
+  for i, c in ipairs(ISSUES) do issues[i] = J.str(c) end
+  -- Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+  print('{"queryId":' .. J.str(J.text(field(query, "queryId"))) ..
+        ',"truthStatus":' .. J.str(hit and "TRUE_ONLY" or "NEITHER") ..
+        ',"evaluationStatus":' .. J.str(key_conflict_blocks(query.literal.predicate) and "NON_EXECUTABLE" or "COMPUTED") .. ',"issues":[' .. table.concat(issues, ",") .. "]}")
+end
+
+local ok, err = xpcall(main, function(e)
+  if RT.is_refused(e) then return e end
+  return debug.traceback(tostring(e), 2)
+end)
+if not ok then
+  if RT.is_refused(err) then
+    print('{"refused":' .. J.str(err.msg) .. "}")
+    os.exit(3)
+  end
+  io.stderr:write("error: " .. tostring(err) .. "\n")
+  os.exit(1)
+end