vx-toolkit 1.16.2__py3-none-any.whl

vx_toolkit/_bin/std/mem/general.vx

@@ -0,0 +1,35 @@
+# ============================================================
+# std::mem.general —— 通用分配器（GeneralPurposeAllocator）
+#
+# Zig 风格：显式分配/释放，带泄漏检测。
+# 使用模块级全局变量（避免 StructNew 虚拟栈问题）。
+# ============================================================
+
+var gpa_alloc_count: int = 0
+var gpa_free_count: int = 0
+
+func gpa_reset():
+    gpa_alloc_count = 0
+    gpa_free_count = 0
+
+func gpa_alloc(size: int) -> int:
+    gpa_alloc_count = gpa_alloc_count + 1
+    return malloc(size)
+
+func gpa_dealloc(ptr: int):
+    if ptr == 0:
+        return
+    gpa_free_count = gpa_free_count + 1
+    c_free(ptr)
+
+func gpa_check_leaks():
+    var leaked = gpa_alloc_count - gpa_free_count
+    if leaked > 0:
+        out("LEAK DETECTED: " + leaked + " unfreed allocations")
+    else:
+        out("No leaks detected. Allocs=" + gpa_alloc_count + " Frees=" + gpa_free_count)
+
+func gpa_dump_stats():
+    out("=== GeneralPurposeAllocator Stats ===")
+    out("Total allocs: " + gpa_alloc_count)
+    out("Total frees:  " + gpa_free_count)

vx_toolkit/_bin/std/mem/mod.vx

@@ -0,0 +1,11 @@
+# ============================================================
+# std::mem —— Zig 风格内存管理模块
+#
+# 核心理念：显式、可控、无隐式开销
+# 所有堆内存操作都必须通过 Allocator 显式传参，无 hidden GC。
+# ============================================================
+
+import std.mem.allocator
+import std.mem.arena
+import std.mem.page
+import std.mem.general

vx_toolkit/_bin/std/mem/page.vx

@@ -0,0 +1,23 @@
+# ============================================================
+# std::mem.page —— 页分配器（PageAllocator）
+# ============================================================
+
+var page_size: int = 4096
+var page_count: int = 0
+
+func page_alloc(size: int) -> int:
+    var alloc_size = size
+    if alloc_size % page_size != 0:
+        alloc_size = alloc_size + (page_size - (alloc_size % page_size))
+    var ptr = malloc(alloc_size)
+    page_count = page_count + 1
+    return ptr
+
+func page_dealloc(ptr: int):
+    # 页分配器不跟踪单页释放
+
+func page_free_all():
+    page_count = 0
+
+func page_page_count() -> int:
+    return page_count

vx_toolkit/_bin/std/mod.vx

@@ -0,0 +1,5 @@
+# VX Standard Library
+# Auto-generated by VX Language Toolkit
+
+import io
+import mem

vx_toolkit/_bin/std/option.vx

@@ -0,0 +1,68 @@
+# ============================================================
+# std::option —— Option[T] 替代实现
+# 提供 some/none、map、unwrap_or 等常用操作
+# ============================================================
+
+import std.error
+
+class Option:
+    is_some: bool
+    value: var
+
+    # 创建 Some 值
+    func some(v: var) -> var:
+        var o = new Option()
+        o.is_some = true
+        o.value = v
+        return o
+
+    # 创建 None 值
+    func none() -> var:
+        var o = new Option()
+        o.is_some = false
+        o.value = nil
+        return o
+
+    # 是否有值
+    func is_some() -> bool:
+        return self.is_some
+
+    # 是否为空
+    func is_none() -> bool:
+        return self.is_some == false
+
+    # 解包，失败时返回 default
+    func unwrap_or(default: var) -> var:
+        if self.is_some:
+            return self.value
+        return default
+
+    # 强制解包（失败时返回错误对象）
+    func unwrap() -> var:
+        if self.is_some:
+            return self.value
+        return error.value_error("Option.unwrap on None")
+
+    # 映射函数
+    func map(f: var) -> var:
+        if self.is_some:
+            return Option.some(f(self.value))
+        return Option.none()
+
+    # 若 Some 则执行副作用函数
+    func if_some(f: var):
+        if self.is_some:
+            f(self.value)
+
+    # 字符串表示
+    func to_string() -> var:
+        if self.is_some:
+            return "Some(" + self.value + ")"
+        return "None"
+
+# 顶层便捷函数
+func some(v: var) -> var:
+    return Option.some(v)
+
+func none() -> var:
+    return Option.none()

vx_toolkit/_bin/std/prelude.vx

@@ -0,0 +1,13 @@
+# ============================================================
+# std::prelude —— 预导入模块
+# 编译器自动注入，提供最常用的类型和函数
+# ============================================================
+
+import std.error
+import std.collections
+import std.string
+import std.math
+import std.io
+import std.sys
+import std.macros
+import std.reflect

vx_toolkit/_bin/std/reflect/mod.vx

@@ -0,0 +1,129 @@
+# ============================================================
+# std::reflect —— 反射工具模块
+# 提供运行时类型检查和反射能力，依赖 VM 内建函数
+# ============================================================
+
+import std.error
+
+# ---- 类型名称常量 ----
+class TypeNames:
+    NIL      = "Nil"
+    INT      = "Int"
+    FLOAT    = "Float"
+    BOOL     = "Bool"
+    STRING   = "String"
+    ARRAY    = "Array"
+    MAP      = "Map"
+    INSTANCE = "Instance"
+
+# ---- Reflect 类：反射工具 ----
+class Reflect:
+    # 获取值的类型名称
+    func type_name(v: var) -> var:
+        return typeof(v)
+
+    # 检查值是否为 nil
+    func is_nil(v: var) -> bool:
+        return is_nil(v)
+
+    # 检查值是否为整数
+    func is_int(v: var) -> bool:
+        return is_int(v)
+
+    # 检查值是否为浮点数
+    func is_float(v: var) -> bool:
+        return is_float(v)
+
+    # 检查值是否为布尔值
+    func is_bool(v: var) -> bool:
+        return is_bool(v)
+
+    # 检查值是否为字符串
+    func is_string(v: var) -> bool:
+        return is_string(v)
+
+    # 检查值是否为数组
+    func is_array(v: var) -> bool:
+        return is_array(v)
+
+    # 检查值是否为映射（HashMap）
+    func is_map(v: var) -> bool:
+        return is_map(v)
+
+    # 检查值是否为实例对象
+    func is_instance(v: var) -> bool:
+        return is_instance(v)
+
+    # 检查值是否为数字类型（int 或 float）
+    func is_number(v: var) -> bool:
+        return is_int(v) or is_float(v)
+
+    # 检查值是否为基础类型（int/float/bool/string/nil）
+    func is_primitive(v: var) -> bool:
+        return is_nil(v) or is_int(v) or is_float(v) or is_bool(v) or is_string(v)
+
+    # 检查值是否为容器类型（array 或 map）
+    func is_container(v: var) -> bool:
+        return is_array(v) or is_map(v)
+
+    # 获取类型的字符串表示
+    func type_str(v: var) -> var:
+        var t = typeof(v)
+        if t == TypeNames.INSTANCE:
+            return "class instance"
+        if t == TypeNames.NIL:
+            return "nil"
+        if t == TypeNames.INT:
+            return "int"
+        if t == TypeNames.FLOAT:
+            return "float"
+        if t == TypeNames.BOOL:
+            return "bool"
+        if t == TypeNames.STRING:
+            return "string"
+        if t == TypeNames.ARRAY:
+            return "array"
+        if t == TypeNames.MAP:
+            return "map"
+        return t
+
+    # 断言类型，失败时返回错误
+    func assert_type(v: var, expected: var) -> var:
+        var actual = typeof(v)
+        if actual != expected:
+            return Result.err(error.type_error("expected " + expected + ", got " + actual))
+        return Result.ok(v)
+
+    # 断言非 nil
+    func assert_not_nil(v: var, msg: var) -> var:
+        if is_nil(v):
+            return Result.err(error.value_error(msg))
+        return Result.ok(v)
+
+# ---- 顶层便捷函数 ----
+func typeof(v: var) -> var:
+    return typeof(v)
+
+func is_nil(v: var) -> bool:
+    return is_nil(v)
+
+func is_int(v: var) -> bool:
+    return is_int(v)
+
+func is_float(v: var) -> bool:
+    return is_float(v)
+
+func is_bool(v: var) -> bool:
+    return is_bool(v)
+
+func is_string(v: var) -> bool:
+    return is_string(v)
+
+func is_array(v: var) -> bool:
+    return is_array(v)
+
+func is_map(v: var) -> bool:
+    return is_map(v)
+
+func is_instance(v: var) -> bool:
+    return is_instance(v)

vx_toolkit/_bin/std/string/codec.vx

@@ -0,0 +1,146 @@
+# ============================================================
+# std::string::codec —— 编码转换
+# 支持 hex、base64 编解码
+# ============================================================
+
+import std.error
+import std.collections.vec
+import std.string.util
+
+# ---- Codec 类：编码工具（纯静态方法）----
+class Codec:
+
+    # ========== Hex 编码 ==========
+
+    # 字节数组转十六进制字符串
+    func to_hex(bytes: var) -> var:
+        var hex_chars = "0123456789ABCDEF"
+        var result = ""
+        var i = 0
+        var n = len(bytes)
+        while i < n:
+            var byte_val = bytes[i]
+            var hi = byte_val / 16
+            var lo = byte_val % 16
+            result = result + hex_chars[hi] + hex_chars[lo]
+            i = i + 1
+        return result
+
+    # 十六进制字符串转字节数组
+    func from_hex(hex_str: var) -> var:
+        var s = StringUtil.to_upper(hex_str)
+        var s_len = len(s)
+        if s_len % 2 != 0:
+            return Result.err(error.value_error("from_hex: odd length hex string"))
+
+        var result = []
+        var i = 0
+        while i < s_len:
+            var hi = Codec._hex_digit(s[i])
+            var lo = Codec._hex_digit(s[i + 1])
+            if hi < 0:
+                return Result.err(error.value_error("from_hex: invalid hex digit '" + s[i] + "'"))
+            if lo < 0:
+                return Result.err(error.value_error("from_hex: invalid hex digit '" + s[i + 1] + "'"))
+            result = result + [(hi * 16 + lo)]
+            i = i + 2
+        return Result.ok(result)
+
+    # 十六进制数字值，-1 表示无效
+    func _hex_digit(ch: var) -> int:
+        if ch >= "0":
+            if ch <= "9":
+                return ch[0] - "0"[0]
+        if ch >= "A":
+            if ch <= "F":
+                return ch[0] - "A"[0] + 10
+        return -1
+
+    # ========== Base64 编码 ==========
+
+    # Base64 编码表
+    func _b64_table() -> var:
+        return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+    # 字节数组转 Base64 字符串
+    func to_base64(bytes: var) -> var:
+        var table = Codec._b64_table()
+        var result = ""
+        var n = len(bytes)
+        var i = 0
+        while i < n:
+            # 取出 3 个字节（或剩余）
+            var b0 = bytes[i]
+            var b1 = -1
+            var b2 = -1
+            if i + 1 < n:
+                b1 = bytes[i + 1]
+            if i + 2 < n:
+                b2 = bytes[i + 2]
+
+            # 编码为 4 个 Base64 字符
+            var c0 = (b0 / 4) % 64
+            result = result + table[c0]
+
+            if b1 >= 0:
+                var c1 = ((b0 % 4) * 16) + (b1 / 16)
+                result = result + table[c1]
+            else:
+                var c1 = (b0 % 4) * 16
+                result = result + table[c1] + "=="
+                return result
+
+            if b2 >= 0:
+                var c2 = ((b1 % 16) * 4) + (b2 / 64)
+                var c3 = b2 % 64
+                result = result + table[c2] + table[c3]
+            else:
+                var c2 = (b1 % 16) * 4
+                result = result + table[c2] + "="
+                return result
+
+            i = i + 3
+
+        return result
+
+    # Base64 字符串解码（简化版）
+    func from_base64(b64_str: var) -> var:
+        var s = b64_str
+        # 去除末尾的 =
+        var pad = 0
+        var s_len = len(s)
+        if s_len > 0:
+            if s[s_len - 1] == "=":
+                pad = pad + 1
+            if s_len > 1:
+                if s[s_len - 2] == "=":
+                    pad = pad + 1
+
+        var table = Codec._b64_table()
+        var result = []
+        var i = 0
+        var byte_count = s_len - pad
+        while i < byte_count:
+            # 取 4 个 Base64 字符
+            if i + 3 >= byte_count:
+                return Result.err(error.value_error("from_base64: invalid length"))
+            var v0 = StringUtil.find(table, s[i])
+            var v1 = StringUtil.find(table, s[i + 1])
+            var v2 = StringUtil.find(table, s[i + 2])
+            var v3 = StringUtil.find(table, s[i + 3])
+
+            if v0 < 0:
+                if v1 < 0:
+                    if v2 < 0:
+                        if v3 < 0:
+                            return Result.err(error.value_error("from_base64: invalid character"))
+
+            result = result + [(v0 * 4 + v1 / 16) % 256]
+            if s[i + 2] != "=":
+                result = result + [((v1 % 16) * 16 + v2 / 4) % 256]
+            if s[i + 3] != "=":
+                result = result + [((v2 % 4) * 64 + v3) % 256]
+
+            i = i + 4
+
+        return Result.ok(result)

vx_toolkit/_bin/std/string/core.vx

@@ -0,0 +1,28 @@
+# Core string operations via extern C functions
+
+extern strcmp(a: string, b: string) -> int
+extern strlen(s: string) -> int
+extern memcpy(dst: string, src: string, size: int) -> string
+
+func str_eq(a: string, b: string) -> int:
+    var r: int = strcmp(a, b)
+    if r == 0:
+        return 1
+    return 0
+
+func str_len(s: string) -> int:
+    return strlen(s)
+
+func str_cat(a: string, b: string) -> string:
+    var la: int = strlen(a)
+    var lb: int = strlen(b)
+    var total: int = la + lb + 1
+    var result = malloc(total)
+    var _ = memcpy(result, a, la)
+    # copy second string after first
+    var _ = memcpy(result + la, b, lb)
+    # null terminate
+    (result + la + lb)[0] = 0
+    return result
+
+extern malloc(size: int) -> string

vx_toolkit/_bin/std/string/iter.vx

@@ -0,0 +1,49 @@
+# ============================================================
+# std::string::iter —— 字符串迭代器
+# 提供基于索引的字符迭代，避免重复 split
+# ============================================================
+
+import std.error
+
+class StringIter:
+    source: var
+    pos: int
+    length: int
+
+    func new(s: var) -> var:
+        var it = new StringIter()
+        it.source = s
+        it.pos = 0
+        it.length = len(s)
+        return it
+
+    # 是否还有下一个字符
+    func has_next() -> bool:
+        return self.pos < self.length
+
+    # 返回下一个字符并前进；到达末尾返回 nil
+    func next() -> var:
+        if self.pos >= self.length:
+            return nil
+        var c = self.source[self.pos]
+        self.pos = self.pos + 1
+        return c
+
+    # 预读下一个字符但不前进；到达末尾返回 nil
+    func peek() -> var:
+        if self.pos >= self.length:
+            return nil
+        return self.source[self.pos]
+
+    # 回退一个字符
+    func back():
+        if self.pos > 0:
+            self.pos = self.pos - 1
+
+    # 当前索引
+    func index() -> int:
+        return self.pos
+
+    # 重置到起始位置
+    func reset():
+        self.pos = 0

vx_toolkit/_bin/std/string/mod.vx

@@ -0,0 +1,7 @@
+# ============================================================
+# std::string —— 模块入口
+# ============================================================
+
+import std.string.util
+import std.string.pattern
+import std.string.codec

vx_toolkit/_bin/std/string/pattern.vx

@@ -0,0 +1,84 @@
+# ============================================================
+# std::string::pattern —— 模式匹配
+# 第一版支持基本通配符 * 和 ?
+# ============================================================
+
+import std.error
+import std.collections.vec
+
+# ---- Pattern 类：通配符/正则匹配 ----
+class Pattern:
+    raw: var            # 模式字符串
+
+    func new(pattern_str: var) -> var:
+        var p = new Pattern()
+        p.raw = pattern_str
+        return p
+
+    # 测试是否匹配（通配符模式）
+    # * 匹配任意字符序列（包括空）
+    # ? 匹配单个字符
+    func test(text: var) -> bool:
+        var t_len = len(text)
+        var p_len = len(self.raw)
+        # dp[i][j] = text[0..i] 是否匹配 pattern[0..j]
+        # 简化实现：递归匹配
+        return Pattern._match(text, self.raw, 0, 0, t_len, p_len)
+
+    # 内部递归匹配
+    func _match(text: var, pat: var, ti: int, pi: int, t_len: int, p_len: int) -> bool:
+        # 到达模式末尾
+        if pi >= p_len:
+            if ti >= t_len:
+                return true
+            return false
+
+        # 处理 *
+        if pat[pi] == "*":
+            # 匹配 0 个字符
+            if Pattern._match(text, pat, ti, pi + 1, t_len, p_len):
+                return true
+            # 匹配 n 个字符
+            if ti < t_len:
+                if Pattern._match(text, pat, ti + 1, pi, t_len, p_len):
+                    return true
+            return false
+
+        if ti >= t_len:
+            return false
+
+        # 处理 ?
+        if pat[pi] == "?":
+            return Pattern._match(text, pat, ti + 1, pi + 1, t_len, p_len)
+
+        # 处理普通字符
+        if text[ti] == pat[pi]:
+            return Pattern._match(text, pat, ti + 1, pi + 1, t_len, p_len)
+
+        return false
+
+    # 匹配并返回捕获组（通配符模式下无捕获组，返回单个匹配）
+    func match(text: var) -> var:
+        if self.test(text):
+            # 返回单个匹配（完整文本）
+            return Result.ok(text)
+        return Result.err(error.value_error("Pattern.match: no match"))
+
+    # 全局搜索所有匹配（通配符模式简化：返回完整匹配位置）
+    func find_all(text: var) -> var:
+        var results = new Vec()
+        var t_len = len(text)
+        var p_len = len(self.raw)
+        var start = 0
+        while start < t_len:
+            if Pattern._match(text, self.raw, start, 0, t_len, p_len):
+                # 找到匹配，计算匹配长度
+                results.push(start)
+            start = start + 1
+        return results
+
+    # 替换匹配
+    func replace(text: var, replacement: var) -> var:
+        if self.test(text) == false:
+            return text
+        return replacement