arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/cs/Cert.cs

@@ -0,0 +1,90 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+public static class Program
+{
+    static string S(JsonNode? n) => n is JsonValue v && v.TryGetValue<string>(out var s) ? s : n?.ToJsonString() ?? "";
+
+    static object Lit(JsonNode? x)
+    {
+        if (x is JsonValue v && v.TryGetValue<string>(out var s)) return s;
+        var m = (JsonObject)x!;
+        if (m.ContainsKey("dec")) return RT.dec(S(m["dec"]));
+        if (m.ContainsKey("money")) return RT.money(S(m["money"]), S(m["cur"]));
+        if (m.ContainsKey("text")) return S(m["text"]);
+        if (m.ContainsKey("date")) return RT.date(S(m["date"]));
+        if (m.ContainsKey("sym")) return RT.sym(S(m["sym"]));
+        if (m.ContainsKey("row")) return ((JsonArray)m["row"]!).Select(Lit).ToList();
+        throw new InvalidOperationException("литерал фикстуры: " + x);
+    }
+
+    // Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+    static string Digits(BigInteger u, int s)
+    {
+        bool neg = u.Sign < 0;
+        string body = BigInteger.Abs(u).ToString().PadLeft(s + 1, '0');
+        string text = s == 0 ? body : body[..^s] + "." + body[^s..];
+        return (neg ? "-" : "") + text;
+    }
+
+    static JsonNode? Render(object? v) => v switch
+    {
+        null => null,
+        bool b => JsonValue.Create(b),
+        string t => JsonValue.Create(t),
+        Money m => JsonValue.Create(Digits(m.U, m.S) + " " + m.Cur),
+        Date d => JsonValue.Create(d.V),
+        Sym y => JsonValue.Create(y.Id),
+        Dec d => JsonValue.Create(Digits(d.U, d.S)),
+        _ => throw new InvalidOperationException("отображение: " + v.GetType()),
+    };
+
+    static object? Run(JsonObject c)
+    {
+        var a = ((JsonArray)c["args"]!).Select(Lit).ToList();
+        return S(c["op"]) switch
+        {
+            "dec" => RT.dec((string)a[0]),
+            "money" => RT.money((string)a[0], (string)a[1]),
+            "date" => RT.date((string)a[0]),
+            "sym" => RT.sym((string)a[0]),
+            "add" => RT.add(a[0], a[1]),
+            "sub" => RT.sub(a[0], a[1]),
+            "mul" => RT.mul(a[0], a[1]),
+            "div" => RT.div(a[0], a[1]),
+            "mod" => RT.mod(a[0], a[1]),
+            "min" => RT.min(a[0], a[1]),
+            "max" => RT.max(a[0], a[1]),
+            "abs" => RT.abs(a[0]),
+            "pow" => RT.pow(a[0], a[1]),
+            "round" => RT.round(a[0], a[1], (string)a[2]),
+            "cmp" => RT.cmp(a[0], (string)a[1], a[2]),
+            "eq" => RT.eq(a[0], a[1]),
+            "keyEq" => RT.key((List<object>)a[0]) == RT.key((List<object>)a[1]),
+            "legalTime" => RT.legalTime(),
+            "setLegalTime" => Set((string)a[0]),
+            var op => throw new InvalidOperationException("неизвестная операция фикстуры: " + op),
+        };
+    }
+
+    static object? Set(string t) { RT.setLegalTime(t); return null; }
+
+    public static int Main(string[] argv)
+    {
+        var fixture = (JsonObject)JsonNode.Parse(File.ReadAllText(argv[0]))!;
+        var outp = new JsonArray();
+        foreach (var c in (JsonArray)fixture["cases"]!)
+        {
+            var cm = (JsonObject)c!;
+            JsonNode? got;
+            try { got = Render(Run(cm)); }
+            catch (Refused e) { got = new JsonObject { ["refused"] = e.Message }; }
+            outp.Add(new JsonObject { ["id"] = cm["id"]?.DeepClone(), ["got"] = got });
+        }
+        Console.WriteLine(outp.ToJsonString(new JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping }));
+        return 0;
+    }
+}

arxo_codegen/targets/cs/Runner.cs

@@ -0,0 +1,154 @@
+// Раннер C#-бэкенда: тот же вход и тот же ответ, что у runner.py.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3; любой другой код — крах.
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+public static class Program
+{
+    static readonly List<object> Issues = new();
+
+    static string Text(JsonNode? n) => n is JsonValue v && v.TryGetValue<string>(out var s) ? s : n?.ToJsonString() ?? "";
+
+    static object Arg(JsonObject a)
+    {
+        string kind = Text(a["kind"]);
+        if (kind == "entity_ref") return Text(a["id"]);
+        if (kind == "const_ref")
+        {
+            // §54: разыменование предшествует исполнению; член перечисления §38 либо
+            // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+            return Model.CONSTS.TryGetValue(Text(a["id"]), out var c) ? c.Item2 : RT.sym(Text(a["id"]));
+        }
+        if (kind != "value") throw new Refused("аргумент вне среза раннера: " + kind);
+        string t = Text(a["type"]?["name"]);
+        string v = Text(a["value"]);
+        return t switch
+        {
+            "urn:law:std#Money" => RT.money(v, Text(a["currency"])),
+            "urn:law:std#Decimal" or "urn:law:std#Integer" => RT.dec(v),
+            "urn:law:std#Text" => v,
+            "urn:law:std#Date" => RT.date(v),
+            _ => throw new Refused("аргумент вне среза раннера: " + t),
+        };
+    }
+
+    // Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+    // константы; entity_ref типа не несёт (как у оракула).
+    static string? ArgType(JsonObject a)
+    {
+        string kind = Text(a["kind"]);
+        if (kind == "value") return Text(a["type"]?["name"]);
+        if (kind == "const_ref") return Model.CONSTS.TryGetValue(Text(a["id"]), out var c) ? c.Item1 : null;
+        return null;
+    }
+
+    // Совпадение типа с наследованием сущностей вверх от фактического.
+    static bool Conforms(string actual, string expected)
+    {
+        var seen = new HashSet<string>();
+        string? cur = actual;
+        while (cur is not null && seen.Add(cur))
+        {
+            if (cur == expected) return true;
+            cur = Model.BASES.TryGetValue(cur, out var b) ? b : null;
+        }
+        return false;
+    }
+
+    static List<JsonObject> Args(JsonObject lit) => (lit["args"] as JsonArray ?? new JsonArray()).Select(x => (JsonObject)x!).ToList();
+
+    // Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+    static bool WellTyped(JsonObject lit)
+    {
+        if (!Model.PARAMS.TryGetValue(Text(lit["predicate"]), out var ps)) return true;
+        var args = Args(lit);
+        if (args.Count != ps.Length) { Issues.Add("TYPE_ERROR"); return false; }
+        for (int i = 0; i < ps.Length; i++)
+        {
+            var actual = ArgType(args[i]);
+            if (actual is not null && !Conforms(actual, ps[i])) { Issues.Add("TYPE_ERROR"); return false; }
+        }
+        return true;
+    }
+
+    // Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+    // атома не находит — NEITHER без issue.
+    static bool QueryTyped(JsonObject lit)
+    {
+        if (!Model.PARAMS.TryGetValue(Text(lit["predicate"]), out var ps)) return false;
+        var args = Args(lit);
+        if (args.Count != ps.Length) return false;
+        for (int i = 0; i < ps.Length; i++)
+        {
+            var actual = ArgType(args[i]);
+            if (actual is not null && !Conforms(actual, ps[i])) return false;
+        }
+        return true;
+    }
+
+    static bool KeyConflictBlocks(string predicate)
+    {
+        var tainted = Model.KeyConflictPredicates();
+        var waiting = new Stack<string>(tainted);
+        while (waiting.Count > 0)
+        {
+            var source = waiting.Pop();
+            if (!Model.KEY_READERS.TryGetValue(source, out var consumers)) continue;
+            foreach (var consumer in consumers) if (tainted.Add(consumer)) waiting.Push(consumer);
+        }
+        return tainted.Contains(predicate);
+    }
+
+    static void Run(string casePath, string queryPath)
+    {
+        var kase = (JsonObject)JsonNode.Parse(File.ReadAllText(casePath))!;
+        var query = (JsonObject)JsonNode.Parse(File.ReadAllText(queryPath))!;
+        RT.setLegalTime(Text(kase["context"]?["legalTime"]));
+        Model.PackageFacts();
+        foreach (var a in kase["assertions"] as JsonArray ?? new JsonArray())
+        {
+            var lit = (JsonObject)a!["literal"]!;
+            if (Text(lit["polarity"]) != "positive") throw new Refused("§113: отрицательный факт вне L0-среза");
+            if (!WellTyped(lit)) continue;
+            string pred = Text(lit["predicate"]);
+            if (!Model.PARAMS.ContainsKey(pred)) continue;
+            Model.Register(pred, Args(lit).Select(Arg).ToList());
+        }
+        Model.Saturate();
+        for (int n = Model.KeyConflicts(); n > 0; n--) Issues.Add("KEY_CONFLICT");
+        if (Text(query["kind"]) != "truth") throw new Refused("вид запроса вне среза раннера: " + Text(query["kind"]));
+        var qlit = (JsonObject)query["literal"]!;
+        bool hit = false;
+        if (QueryTyped(qlit))
+        {
+            var want = Args(qlit).Select(Arg).ToList();
+            var rows = Model.TABLES.TryGetValue(Text(qlit["predicate"]), out var r) ? r : new List<List<object>>();
+            hit = rows.Any(row => row.Count == want.Count && row.Select((v, i) => RT.eq(v, want[i])).All(x => x));
+        }
+        // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+        var outp = new JsonObject
+        {
+            ["queryId"] = query["queryId"]?.DeepClone(),
+            ["truthStatus"] = hit ? "TRUE_ONLY" : "NEITHER",
+            ["evaluationStatus"] = KeyConflictBlocks(Text(qlit["predicate"])) ? "NON_EXECUTABLE" : "COMPUTED",
+            ["issues"] = new JsonArray(Issues.Select(x => (JsonNode)JsonValue.Create((string)x)!).ToArray()),
+        };
+        Console.WriteLine(outp.ToJsonString(new JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping }));
+    }
+
+    public static int Main(string[] argv)
+    {
+        try
+        {
+            Run(argv[0], argv[1]);
+            return 0;
+        }
+        catch (Refused e)
+        {
+            Console.WriteLine(new JsonObject { ["refused"] = e.Message }.ToJsonString(new JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping }));
+            return 3;
+        }
+    }
+}

arxo_codegen/targets/cs/Runtime.cs

@@ -0,0 +1,243 @@
+// Рантайм L0 для C#. Тот же контракт, что у runtime.py: точная десятичная
+// арифметика §58 на BigInteger, деньги с валютой, названный режим округления,
+// календарный день, член перечисления. Отказ — исключение Refused; любое
+// другое исключение — крах.
+using System.Numerics;
+using System.Text;
+
+public sealed class Refused : Exception { public Refused(string m) : base(m) { } }
+
+public class Dec { public BigInteger U; public int S; public Dec(BigInteger u, int s) { U = u; S = s; } }
+public sealed class Money : Dec { public string Cur; public Money(BigInteger u, int s, string cur) : base(u, s) { Cur = cur; } }
+// Календарный день §2.15 в канонической записи ISO YYYY-MM-DD.
+public sealed class Date { public string V; public Date(string v) { V = v; } }
+// Член перечисления §38 либо ссылка const_ref без объявления.
+public sealed class Sym { public string Id; public Sym(string id) { Id = id; } }
+
+public static class RT
+{
+    static BigInteger P10(int n) => BigInteger.Pow(10, n);
+
+    public static Dec dec(string lit)
+    {
+        int dot = lit.IndexOf('.');
+        string i = dot < 0 ? lit : lit[..dot];
+        string f = dot < 0 ? "" : lit[(dot + 1)..];
+        bool neg = i.StartsWith("-");
+        var u = BigInteger.Parse((neg ? i[1..] : i) + f);
+        return new Dec(neg ? -u : u, f.Length);
+    }
+    public static Money money(string lit, string cur) { var d = dec(lit); return new Money(d.U, d.S, cur); }
+    public static Date date(string lit) => new Date(lit);
+    public static Sym sym(string id) => new Sym(id);
+
+    // --- виды ---------------------------------------------------------------
+    static bool IsNum(object v) => v is Dec;
+    static bool IsMoney(object v) => v is Money;
+
+    // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+    static void Same(object a, object b, string op)
+    {
+        if (!IsNum(a) || !IsNum(b) || IsMoney(a) != IsMoney(b)) throw new Refused("§58: виды операндов не совпадают: " + op);
+        if (a is Money ma && b is Money mb && ma.Cur != mb.Cur) throw new Refused("§58: разные валюты: " + op);
+    }
+    static (BigInteger, BigInteger, int) Pair(Dec a, Dec b)
+    {
+        int s = Math.Max(a.S, b.S);
+        return (a.U * P10(s - a.S), b.U * P10(s - b.S), s);
+    }
+    static Dec Mk(BigInteger u, int s, object like) => like is Money m ? new Money(u, s, m.Cur) : new Dec(u, s);
+    // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+    static BigInteger? Integral(object v)
+    {
+        if (v is not Dec d || v is Money) return null;
+        var q = BigInteger.DivRem(d.U, P10(d.S), out var r);
+        return r.IsZero ? q : null;
+    }
+
+    // --- арифметика §58 -----------------------------------------------------
+    public static Dec add(object a, object b) { Same(a, b, "add"); var (x, y, s) = Pair((Dec)a, (Dec)b); return Mk(x + y, s, a); }
+    public static Dec sub(object a, object b) { Same(a, b, "sub"); var (x, y, s) = Pair((Dec)a, (Dec)b); return Mk(x - y, s, a); }
+
+    // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+    // сумма масштабов. Два размерных не перемножаются.
+    public static Dec mul(object a, object b)
+    {
+        if (!IsNum(a) || !IsNum(b)) throw new Refused("§58: виды операндов не совпадают: mul");
+        if (IsMoney(a) && IsMoney(b)) throw new Refused("§58: произведение двух размерных величин не определено");
+        var x = (Dec)a; var y = (Dec)b;
+        return Mk(x.U * y.U, x.S + y.S, IsMoney(a) ? a : b);
+    }
+
+    // Точное десятичное частное num/den при 10-гладком знаменателе (§18).
+    static (BigInteger, int)? Exact(BigInteger num, BigInteger den)
+    {
+        var g = BigInteger.GreatestCommonDivisor(num, den);
+        if (g.IsZero) g = BigInteger.One;
+        num /= g; den /= g;
+        if (den.Sign < 0) { num = -num; den = -den; }
+        int twos = 0, fives = 0;
+        while ((den % 2).IsZero) { den /= 2; twos++; }
+        while ((den % 5).IsZero) { den /= 5; fives++; }
+        if (!den.IsOne) return null;
+        int k = Math.Max(twos, fives);
+        return (num * BigInteger.Pow(2, k - twos) * BigInteger.Pow(5, k - fives), k);
+    }
+
+    // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+    // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+    public static Dec div(object a, object b)
+    {
+        if (!IsNum(a) || !IsNum(b)) throw new Refused("§58: деление вне таблицы делимых");
+        var x = (Dec)a; var y = (Dec)b;
+        if (y.U.IsZero) throw new Refused("деление на ноль — evaluation error (§58)");
+        Money? like = null;
+        if (a is Money ma && b is Money mb)
+        {
+            if (ma.Cur != mb.Cur) throw new Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте");
+        }
+        else if (a is Money m) like = m;
+        else if (b is Money) throw new Refused("§58: деление вне таблицы делимых");
+        var q = Exact(x.U * P10(y.S), y.U * P10(x.S));
+        if (q is null)
+        {
+            if (like is not null) throw new Refused("INEXACT_DIVISION: округление только явной политикой (§50/§18)");
+            throw new Refused("§58: частное не 10-гладкое — Rational вне среза");
+        }
+        var (u, s) = q.Value;
+        return like is not null ? new Money(u, s, like.Cur) : new Dec(u, s);
+    }
+
+    // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+    public static Dec mod(object a, object b)
+    {
+        var x = Integral(a); var y = Integral(b);
+        if (x is null || y is null) throw new Refused("§58: mod определён только для Integer");
+        if (y.Value.IsZero) throw new Refused("остаток от деления на ноль — evaluation error (§58)");
+        var m = BigInteger.Abs(y.Value);
+        var r = ((x.Value % m) + m) % m;
+        return new Dec(r, 0);
+    }
+
+    public static Dec min(object a, object b) { Same(a, b, "min"); var (x, y, _) = Pair((Dec)a, (Dec)b); return x <= y ? (Dec)a : (Dec)b; }
+    public static Dec max(object a, object b) { Same(a, b, "max"); var (x, y, _) = Pair((Dec)a, (Dec)b); return x >= y ? (Dec)a : (Dec)b; }
+
+    public static Dec abs(object v)
+    {
+        if (!IsNum(v)) throw new Refused("§58: abs — не числовой вид");
+        var d = (Dec)v;
+        return Mk(BigInteger.Abs(d.U), d.S, v);
+    }
+
+    static readonly BigInteger PowMin = long.MinValue, PowMax = long.MaxValue;
+
+    // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+    // вычисление, диапазон — часть контракта.
+    public static Dec pow(object bas, object exp)
+    {
+        var x = Integral(bas); var e = Integral(exp);
+        if (x is null || e is null) throw new Refused("§58: pow определён только для Integer");
+        if (e.Value.Sign < 0) throw new Refused("§58: pow — показатель отрицателен");
+        if (e.Value > 4096) throw new Refused("RESOURCE_LIMIT: pow — показатель превышает 4096");
+        var r = BigInteger.Pow(x.Value, (int)e.Value);
+        if (r < PowMin || r > PowMax) throw new Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона");
+        return new Dec(r, 0);
+    }
+
+    public static Dec round(object m, object digits, string mode)
+    {
+        if (mode != "HALF_UP") throw new Refused("§50: режим округления не реализован: " + mode);
+        if (!IsNum(m)) throw new Refused("§50: round — не числовой вид");
+        var x = (Dec)m;
+        int n = digits is Dec d ? (int)(d.U / P10(d.S)) : 0;
+        if (x.S <= n) return Mk(x.U * P10(n - x.S), n, m);
+        var drop = P10(x.S - n);
+        bool neg = x.U.Sign < 0;
+        var q = BigInteger.DivRem(BigInteger.Abs(x.U), drop, out var r);
+        var up = r * 2 >= drop ? q + 1 : q; // HALF_UP — от нуля
+        return Mk(neg ? -up : up, n, m);
+    }
+
+    // --- сравнение и равенство -----------------------------------------------
+    static bool Ordered(string op, int c) => op switch
+    {
+        "lt" => c < 0, "le" => c <= 0, "gt" => c > 0, "ge" => c >= 0, "eq" => c == 0, "ne" => c != 0,
+        _ => throw new Refused("сравнение вне среза рантайма: " + op),
+    };
+
+    public static bool cmp(object a, string op, object b)
+    {
+        if (a is Sym || b is Sym)
+        {
+            bool same = a is Sym sa && b is Sym sb && sa.Id == sb.Id;
+            if (op == "eq") return same;
+            if (op == "ne") return !same;
+            throw new Refused("§57: вид enum не упорядочен");
+        }
+        if (a is Date || b is Date)
+        {
+            if (a is Date da && b is Date db) return Ordered(op, string.CompareOrdinal(da.V, db.V));
+            if (op == "eq") return false;
+            if (op == "ne") return true;
+            throw new Refused("§57: Date сравнивается только с Date");
+        }
+        if (a is string || b is string)
+        {
+            bool same = a is string x && b is string y && x == y;
+            if (op == "eq") return same;
+            if (op == "ne") return !same;
+            throw new Refused("порядок на Text вне среза рантайма: " + op);
+        }
+        if (IsMoney(a) != IsMoney(b)) throw new Refused("§49: сравнение денег с безразмерным");
+        if (a is Money ma && b is Money mb && ma.Cur != mb.Cur) throw new Refused("§49: разные валюты");
+        var (p, q, _) = Pair((Dec)a, (Dec)b);
+        return Ordered(op, p.CompareTo(q));
+    }
+
+    public static bool eq(object a, object b)
+    {
+        if (a is Sym || b is Sym) return a is Sym sa && b is Sym sb && sa.Id == sb.Id;
+        if (a is Date || b is Date) return a is Date da && b is Date db && da.V == db.V;
+        if (a is string || b is string) return a is string x && b is string y && x == y;
+        if (IsMoney(a) != IsMoney(b)) return false;
+        if (a is Money ma && b is Money mb && ma.Cur != mb.Cur) return false;
+        var (p, q, _) = Pair((Dec)a, (Dec)b);
+        return p == q;
+    }
+
+    static string Norm(Dec d)
+    {
+        var u = d.U; int s = d.S;
+        while (s > 0 && (u % 10).IsZero) { u /= 10; s--; }
+        return u + "e-" + s;
+    }
+    // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+    // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+    static string Esc(string t) => t.Replace("\\", "\\\\").Replace("|", "\\|");
+
+    public static string key(List<object> row)
+    {
+        var sb = new StringBuilder();
+        for (int i = 0; i < row.Count; i++)
+        {
+            if (i > 0) sb.Append('|');
+            var v = row[i];
+            if (v is string t) sb.Append("e:").Append(Esc(t));
+            else if (v is Date dt) sb.Append("t:").Append(dt.V);
+            else if (v is Sym sy) sb.Append("c:").Append(Esc(sy.Id));
+            else if (v is Money mo) sb.Append("m:").Append(mo.Cur).Append(':').Append(Norm(mo));
+            else sb.Append("d:").Append(Norm((Dec)v));
+        }
+        return sb.ToString();
+    }
+
+    static string legalTimeValue = "";
+    public static void setLegalTime(string t) => legalTimeValue = t;
+    public static string legalTime()
+    {
+        if (legalTimeValue == "") throw new Refused("legalTime не подан делом");
+        return legalTimeValue;
+    }
+
+    public static List<object> row(params object[] vs) => new List<object>(vs);
+}