arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/swift/runtime.swift

@@ -0,0 +1,528 @@
+// Рантайм L0 для Swift. Тот же контракт, что у runtime.rb: точная десятичная
+// арифметика §58, деньги с валютой, названный режим округления, календарный
+// день, член перечисления. Целых произвольной длины в стандартной библиотеке
+// нет — свои: модуль по основанию 10^7 и знак. Foundation не подключается:
+// её `Decimal` ограничен 38 цифрами, а сборка с ней втрое дольше.
+
+/// Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+/// печатает его как JSON с кодом выхода 3; любая другая ошибка — крах.
+struct Refused: Error {
+    let message: String
+    init(_ message: String) { self.message = message }
+}
+
+// --- целые произвольной длины ---------------------------------------------------
+
+struct BigI {
+    static let base = 10_000_000
+    let neg: Bool
+    let m: [Int] // младшая конечность первой; ноль — пустой массив
+
+    init(neg: Bool, m: [Int]) {
+        var mm = m
+        while let last = mm.last, last == 0 { mm.removeLast() }
+        self.m = mm
+        self.neg = mm.isEmpty ? false : neg
+    }
+
+    init(_ n: Int) {
+        var x = n.magnitude
+        var mm: [Int] = []
+        while x > 0 {
+            mm.append(Int(x % UInt(BigI.base)))
+            x /= UInt(BigI.base)
+        }
+        self.init(neg: n < 0, m: mm)
+    }
+
+    /// Десятичная запись со знаком; иная запись — крах, а не отказ.
+    init(parsing s: String) {
+        var bytes = Array(s.utf8)
+        var neg = false
+        if bytes.first == UInt8(ascii: "-") {
+            neg = true
+            bytes.removeFirst()
+        }
+        precondition(!bytes.isEmpty && bytes.allSatisfy { $0 >= 48 && $0 <= 57 }, "целое: не десятичная запись: \(s)")
+        var mm: [Int] = []
+        var end = bytes.count
+        while end > 0 {
+            let start = Swift.max(0, end - 7)
+            var limb = 0
+            for k in start..<end { limb = limb * 10 + Int(bytes[k] - 48) }
+            mm.append(limb)
+            end = start
+        }
+        self.init(neg: neg, m: mm)
+    }
+
+    var isZero: Bool { m.isEmpty }
+    var magnitude: BigI { BigI(neg: false, m: m) }
+    var negated: BigI { BigI(neg: !neg, m: m) }
+
+    var description: String {
+        guard let top = m.last else { return "0" }
+        var s = neg ? "-" : ""
+        s += String(top)
+        for limb in m.dropLast().reversed() {
+            let d = String(limb)
+            s += String(repeating: "0", count: 7 - d.count) + d
+        }
+        return s
+    }
+
+    /// Малое целое: вызывающий обязан сперва проверить диапазон.
+    var small: Int {
+        var n = 0
+        for limb in m.reversed() { n = n * BigI.base + limb }
+        return neg ? -n : n
+    }
+
+    static func magCmp(_ a: [Int], _ b: [Int]) -> Int {
+        if a.count != b.count { return a.count < b.count ? -1 : 1 }
+        var i = a.count - 1
+        while i >= 0 {
+            if a[i] != b[i] { return a[i] < b[i] ? -1 : 1 }
+            i -= 1
+        }
+        return 0
+    }
+
+    static func magAdd(_ a: [Int], _ b: [Int]) -> [Int] {
+        var r: [Int] = []
+        var carry = 0
+        for i in 0..<Swift.max(a.count, b.count) {
+            let t = (i < a.count ? a[i] : 0) + (i < b.count ? b[i] : 0) + carry
+            r.append(t % base)
+            carry = t / base
+        }
+        if carry > 0 { r.append(carry) }
+        return r
+    }
+
+    /// |a| >= |b|.
+    static func magSub(_ a: [Int], _ b: [Int]) -> [Int] {
+        var r: [Int] = []
+        var borrow = 0
+        for i in 0..<a.count {
+            var t = a[i] - (i < b.count ? b[i] : 0) - borrow
+            if t < 0 {
+                t += base
+                borrow = 1
+            } else {
+                borrow = 0
+            }
+            r.append(t)
+        }
+        while let last = r.last, last == 0 { r.removeLast() }
+        return r
+    }
+
+    static func magMul(_ a: [Int], _ b: [Int]) -> [Int] {
+        if a.isEmpty || b.isEmpty { return [] }
+        var r = [Int](repeating: 0, count: a.count + b.count + 1)
+        for i in 0..<a.count {
+            var carry = 0
+            for j in 0..<b.count {
+                let t = r[i + j] + a[i] * b[j] + carry
+                r[i + j] = t % base
+                carry = t / base
+            }
+            var k = i + b.count
+            while carry > 0 {
+                let t = r[k] + carry
+                r[k] = t % base
+                carry = t / base
+                k += 1
+            }
+        }
+        while let last = r.last, last == 0 { r.removeLast() }
+        return r
+    }
+
+    static func magMulSmall(_ a: [Int], _ s: Int) -> [Int] {
+        var r: [Int] = []
+        var carry = 0
+        for limb in a {
+            let t = limb * s + carry
+            r.append(t % base)
+            carry = t / base
+        }
+        while carry > 0 {
+            r.append(carry % base)
+            carry /= base
+        }
+        while let last = r.last, last == 0 { r.removeLast() }
+        return r
+    }
+
+    /// Деление модулей в столбик: цифра частного по основанию 10^7 подбирается
+    /// двоичным поиском. Делитель ненулевой.
+    static func magDivMod(_ a: [Int], _ b: [Int]) -> ([Int], [Int]) {
+        if magCmp(a, b) < 0 { return ([], a) }
+        var q = [Int](repeating: 0, count: a.count)
+        var rem: [Int] = []
+        var i = a.count - 1
+        while i >= 0 {
+            rem.insert(a[i], at: 0)
+            while let last = rem.last, last == 0 { rem.removeLast() }
+            var lo = 0, hi = base - 1
+            while lo < hi {
+                let mid = (lo + hi + 1) / 2
+                if magCmp(magMulSmall(b, mid), rem) <= 0 { lo = mid } else { hi = mid - 1 }
+            }
+            if lo > 0 { rem = magSub(rem, magMulSmall(b, lo)) }
+            q[i] = lo
+            i -= 1
+        }
+        return (q, rem)
+    }
+
+    static func + (x: BigI, y: BigI) -> BigI {
+        if x.neg == y.neg { return BigI(neg: x.neg, m: magAdd(x.m, y.m)) }
+        let c = magCmp(x.m, y.m)
+        if c == 0 { return BigI(0) }
+        return c > 0 ? BigI(neg: x.neg, m: magSub(x.m, y.m)) : BigI(neg: y.neg, m: magSub(y.m, x.m))
+    }
+
+    static func - (x: BigI, y: BigI) -> BigI { x + y.negated }
+    static func * (x: BigI, y: BigI) -> BigI { BigI(neg: x.neg != y.neg, m: magMul(x.m, y.m)) }
+
+    static func cmp(_ x: BigI, _ y: BigI) -> Int {
+        if x.neg != y.neg { return x.neg ? -1 : 1 }
+        let c = magCmp(x.m, y.m)
+        return x.neg ? -c : c
+    }
+
+    /// Частное и остаток с усечением к нулю: знак остатка — знак делимого.
+    func divMod(_ y: BigI) -> (BigI, BigI) {
+        let (q, r) = BigI.magDivMod(m, y.m)
+        return (BigI(neg: neg != y.neg, m: q), BigI(neg: neg, m: r))
+    }
+
+    static func pow10(_ k: Int) -> BigI {
+        var r = BigI(1)
+        for _ in 0..<Swift.max(0, k) { r = BigI(neg: false, m: magMulSmall(r.m, 10)) }
+        return r
+    }
+
+    static func gcd(_ x: BigI, _ y: BigI) -> BigI {
+        var a = x.magnitude, b = y.magnitude
+        while !b.isZero { (a, b) = (b, a.divMod(b).1) }
+        return a
+    }
+}
+
+// --- значения --------------------------------------------------------------------
+
+/// Значение ячейки: Text и сущность — `text`; календарный день §2.15 в
+/// канонической записи ISO — `date` (порядок записи и есть порядок дня); член
+/// перечисления §38 или ссылка без объявления — `sym` (равенство по
+/// идентичности, порядок не определён, §57).
+enum V {
+    case text(String)
+    case dec(BigI, Int)
+    case money(BigI, Int, String)
+    case date(String)
+    case sym(String)
+}
+
+enum RT {
+    static func dec(_ lit: String) -> V {
+        let parts = lit.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
+        let i = String(parts[0])
+        let f = parts.count > 1 ? String(parts[1]) : ""
+        let neg = i.hasPrefix("-")
+        let digits = (neg ? String(i.dropFirst()) : i) + f
+        return .dec(BigI(parsing: (neg ? "-" : "") + digits), f.count)
+    }
+
+    static func money(_ lit: String, _ cur: String) -> V {
+        guard case let .dec(u, s) = dec(lit) else { fatalError() }
+        return .money(u, s, cur)
+    }
+
+    static func date(_ lit: String) -> V { .date(lit) }
+    static func sym(_ id: String) -> V { .sym(id) }
+
+    /// Модуль, масштаб и валюта числа; nil — не число.
+    static func num(_ v: V) -> (u: BigI, s: Int, cur: String?)? {
+        switch v {
+        case let .dec(u, s): return (u, s, nil)
+        case let .money(u, s, cur): return (u, s, cur)
+        default: return nil
+        }
+    }
+
+    static func make(_ u: BigI, _ s: Int, _ cur: String?) -> V {
+        if let cur = cur { return .money(u, s, cur) }
+        return .dec(u, s)
+    }
+
+    // §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+    static func same(_ a: V, _ b: V, _ op: String) throws -> ((u: BigI, s: Int, cur: String?), (u: BigI, s: Int, cur: String?)) {
+        guard let x = num(a), let y = num(b), (x.cur == nil) == (y.cur == nil) else {
+            throw Refused("§58: виды операндов не совпадают: \(op)")
+        }
+        if x.cur != nil && x.cur != y.cur { throw Refused("§58: разные валюты: \(op)") }
+        return (x, y)
+    }
+
+    static func pair(_ a: (u: BigI, s: Int, cur: String?), _ b: (u: BigI, s: Int, cur: String?)) -> (BigI, BigI, Int) {
+        let s = Swift.max(a.s, b.s)
+        return (a.u * BigI.pow10(s - a.s), b.u * BigI.pow10(s - b.s), s)
+    }
+
+    // Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+    static func integral(_ v: V) -> BigI? {
+        guard case let .dec(u, s) = v else { return nil }
+        let (q, r) = u.divMod(BigI.pow10(s))
+        return r.isZero ? q : nil
+    }
+
+    static func add(_ a: V, _ b: V) throws -> V {
+        let (x, y) = try same(a, b, "add")
+        let (p, q, s) = pair(x, y)
+        return make(p + q, s, x.cur)
+    }
+
+    static func sub(_ a: V, _ b: V) throws -> V {
+        let (x, y) = try same(a, b, "sub")
+        let (p, q, s) = pair(x, y)
+        return make(p - q, s, x.cur)
+    }
+
+    // Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+    // сумма масштабов. Два размерных не перемножаются.
+    static func mul(_ a: V, _ b: V) throws -> V {
+        guard let x = num(a), let y = num(b) else { throw Refused("§58: виды операндов не совпадают: mul") }
+        if x.cur != nil && y.cur != nil { throw Refused("§58: произведение двух размерных величин не определено") }
+        return make(x.u * y.u, x.s + y.s, x.cur ?? y.cur)
+    }
+
+    // Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе nil.
+    static func exact(_ num0: BigI, _ den0: BigI) -> (BigI, Int)? {
+        var g = BigI.gcd(num0, den0)
+        if g.isZero { g = BigI(1) }
+        var num = num0.divMod(g).0
+        var den = den0.divMod(g).0
+        if den.neg {
+            num = num.negated
+            den = den.negated
+        }
+        var twos = 0, fives = 0
+        while true {
+            let (q, r) = den.divMod(BigI(2))
+            if !r.isZero { break }
+            den = q
+            twos += 1
+        }
+        while true {
+            let (q, r) = den.divMod(BigI(5))
+            if !r.isZero { break }
+            den = q
+            fives += 1
+        }
+        if BigI.cmp(den, BigI(1)) != 0 { return nil }
+        let k = Swift.max(twos, fives)
+        var f = BigI(1)
+        for _ in 0..<(k - twos) { f = f * BigI(2) }
+        for _ in 0..<(k - fives) { f = f * BigI(5) }
+        return (num * f, k)
+    }
+
+    // Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+    // валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+    static func div(_ a: V, _ b: V) throws -> V {
+        guard let x = num(a), let y = num(b) else { throw Refused("§58: деление вне таблицы делимых") }
+        if y.u.isZero { throw Refused("деление на ноль — evaluation error (§58)") }
+        var like: String? = nil
+        if x.cur != nil && y.cur != nil {
+            if x.cur != y.cur {
+                throw Refused("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+            }
+        } else if x.cur != nil {
+            like = x.cur
+        } else if y.cur != nil {
+            throw Refused("§58: деление вне таблицы делимых")
+        }
+        guard let q = exact(x.u * BigI.pow10(y.s), y.u * BigI.pow10(x.s)) else {
+            if like != nil { throw Refused("INEXACT_DIVISION: округление только явной политикой (§50/§18)") }
+            throw Refused("§58: частное не 10-гладкое — Rational вне среза")
+        }
+        return make(q.0, q.1, like)
+    }
+
+    // Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+    static func mod(_ a: V, _ b: V) throws -> V {
+        guard let x = integral(a), let y = integral(b) else { throw Refused("§58: mod определён только для Integer") }
+        if y.isZero { throw Refused("остаток от деления на ноль — evaluation error (§58)") }
+        var r = x.divMod(y.magnitude).1
+        if r.neg { r = r + y.magnitude }
+        return .dec(r, 0)
+    }
+
+    static func min(_ a: V, _ b: V) throws -> V {
+        let (x, y) = try same(a, b, "min")
+        let (p, q, _) = pair(x, y)
+        return BigI.cmp(p, q) <= 0 ? a : b
+    }
+
+    static func max(_ a: V, _ b: V) throws -> V {
+        let (x, y) = try same(a, b, "max")
+        let (p, q, _) = pair(x, y)
+        return BigI.cmp(p, q) >= 0 ? a : b
+    }
+
+    static func abs(_ v: V) throws -> V {
+        guard let x = num(v) else { throw Refused("§58: abs — не числовой вид") }
+        return make(x.u.magnitude, x.s, x.cur)
+    }
+
+    static let powMin = BigI(parsing: "-9223372036854775808")
+    static let powMax = BigI(parsing: "9223372036854775807")
+
+    // §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+    // вычисление, диапазон — часть контракта. Умножение останавливается, как
+    // только модуль превысил 2^63: при |основание| >= 1 он дальше не убывает, а
+    // при нулевом основании не растёт, — исход тот же, что у полного вычисления.
+    static func pow(_ base: V, _ exp: V) throws -> V {
+        guard let b = integral(base), let e = integral(exp) else { throw Refused("§58: pow определён только для Integer") }
+        if e.neg { throw Refused("§58: pow — показатель отрицателен") }
+        if BigI.cmp(e, BigI(4096)) > 0 { throw Refused("RESOURCE_LIMIT: pow — показатель превышает 4096") }
+        var r = BigI(1)
+        for _ in 0..<e.small {
+            r = r * b
+            if BigI.magCmp(r.m, powMin.m) > 0 { break }
+        }
+        if BigI.cmp(r, powMin) < 0 || BigI.cmp(r, powMax) > 0 {
+            throw Refused("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+        }
+        return .dec(r, 0)
+    }
+
+    static func round(_ m: V, _ digits: V, _ mode: String) throws -> V {
+        if mode != "HALF_UP" { throw Refused("§50: режим округления не реализован: \(mode)") }
+        guard let x = num(m) else { throw Refused("§50: round — не числовой вид") }
+        guard case let .dec(du, ds) = digits else { throw Refused("§50: round — не числовой вид") }
+        let n = du.divMod(BigI.pow10(ds)).0.small
+        if x.s <= n { return make(x.u * BigI.pow10(n - x.s), n, x.cur) }
+        let drop = BigI.pow10(x.s - n)
+        let (q, r) = x.u.magnitude.divMod(drop)
+        let up = BigI.cmp(r + r, drop) >= 0 ? q + BigI(1) : q // HALF_UP — от нуля
+        return make(x.u.neg ? up.negated : up, n, x.cur)
+    }
+
+    static func order(_ op: String, _ c: Int) throws -> Bool {
+        switch op {
+        case "lt": return c < 0
+        case "le": return c <= 0
+        case "gt": return c > 0
+        case "ge": return c >= 0
+        case "eq": return c == 0
+        case "ne": return c != 0
+        default: throw Refused("сравнение вне среза рантайма: \(op)")
+        }
+    }
+
+    static func strOrder(_ a: String, _ b: String) -> Int {
+        // Порядок по байтам UTF-8: у записи ISO он и есть порядок дня.
+        let x = Array(a.utf8), y = Array(b.utf8)
+        for i in 0..<Swift.min(x.count, y.count) where x[i] != y[i] { return x[i] < y[i] ? -1 : 1 }
+        return x.count == y.count ? 0 : (x.count < y.count ? -1 : 1)
+    }
+
+    static func cmp(_ a: V, _ op: String, _ b: V) throws -> Bool {
+        if case .sym = a {} else if case .sym = b {} else {
+            return try cmpNoSym(a, op, b)
+        }
+        var same = false
+        if case let .sym(x) = a, case let .sym(y) = b { same = x == y }
+        if op == "eq" { return same }
+        if op == "ne" { return !same }
+        throw Refused("§57: вид enum не упорядочен")
+    }
+
+    static func cmpNoSym(_ a: V, _ op: String, _ b: V) throws -> Bool {
+        switch (a, b) {
+        case let (.date(x), .date(y)): return try order(op, strOrder(x, y))
+        case (.date, _), (_, .date):
+            if op == "eq" { return false }
+            if op == "ne" { return true }
+            throw Refused("§57: Date сравнивается только с Date")
+        default: break
+        }
+        switch (a, b) {
+        case (.text, _), (_, .text):
+            var same = false
+            if case let .text(x) = a, case let .text(y) = b { same = x == y }
+            if op == "eq" { return same }
+            if op == "ne" { return !same }
+            throw Refused("порядок на Text вне среза рантайма: \(op)")
+        default: break
+        }
+        let x = num(a)!, y = num(b)!
+        if (x.cur == nil) != (y.cur == nil) { throw Refused("§49: сравнение денег с безразмерным") }
+        if x.cur != y.cur { throw Refused("§49: разные валюты") }
+        let (p, q, _) = pair(x, y)
+        return try order(op, BigI.cmp(p, q))
+    }
+
+    static func eq(_ a: V, _ b: V) -> Bool {
+        switch (a, b) {
+        case let (.sym(x), .sym(y)): return x == y
+        case (.sym, _), (_, .sym): return false
+        case let (.date(x), .date(y)): return x == y
+        case (.date, _), (_, .date): return false
+        case let (.text(x), .text(y)): return x == y
+        case (.text, _), (_, .text): return false
+        default: break
+        }
+        let x = num(a)!, y = num(b)!
+        if (x.cur == nil) != (y.cur == nil) || x.cur != y.cur { return false }
+        let (p, q, _) = pair(x, y)
+        return BigI.cmp(p, q) == 0
+    }
+
+    static func norm(_ u0: BigI, _ s0: Int) -> String {
+        var u = u0, s = s0
+        while s > 0 {
+            let (q, r) = u.divMod(BigI(10))
+            if !r.isZero { break }
+            u = q
+            s -= 1
+        }
+        return "\(u.description)e-\(s)"
+    }
+
+    // Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+    // ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+    static func esc(_ text: String) -> String {
+        var out = ""
+        for ch in text.unicodeScalars {
+            if ch == "\\" { out += "\\\\" } else if ch == "|" { out += "\\|" } else { out.unicodeScalars.append(ch) }
+        }
+        return out
+    }
+
+    static func key(_ row: [V]) -> String {
+        row.map { v -> String in
+            switch v {
+            case let .text(t): return "e:" + esc(t)
+            case let .date(d): return "t:" + d
+            case let .sym(id): return "c:" + esc(id)
+            case let .money(u, s, cur): return "m:" + cur + ":" + norm(u, s)
+            case let .dec(u, s): return "d:" + norm(u, s)
+            }
+        }.joined(separator: "|")
+    }
+
+    static var legal = ""
+
+    static func setLegalTime(_ t: String) { legal = t }
+
+    static func legalTime() throws -> String {
+        if legal.isEmpty { throw Refused("legalTime не подан делом") }
+        return legal
+    }
+}