vx-toolkit 1.16.2__py3-none-any.whl

vx_toolkit/_bin/std/string/util.vx

@@ -0,0 +1,369 @@
+# ============================================================
+# std::string —— 字符串处理模块
+# 扩展内建字符串操作
+# ============================================================
+
+import std.error
+import std.collections.vec
+
+# ---- String 工具类（静态方法集合）----
+# 所有方法都是静态的，接收 string 作为首个参数
+class StringUtil:
+
+    # ========== 基本信息 ==========
+
+    # 字符串长度
+    func size(s: var) -> int:
+        return len(s)
+
+    # 是否为空
+    func is_empty(s: var) -> bool:
+        if len(s) == 0:
+            return true
+        return false
+
+    # ========== 拼接 & 截取 ==========
+
+    # 字符串拼接（等于使用 + 运算符）
+    func concat(a: var, b: var) -> var:
+        return a + b
+
+    # 重复字符串 n 次
+    func repeat(s: var, n: int) -> var:
+        var result = ""
+        var i = 0
+        while i < n:
+            result = result + s
+            i = i + 1
+        return result
+
+    # 截取子串 [start, end)
+    func slice(s: var, start: int, end: int) -> var:
+        var s_len = len(s)
+        if start < 0:
+            start = 0
+        if end > s_len:
+            end = s_len
+        if start >= end:
+            return ""
+
+        var result = ""
+        var i = start
+        while i < end:
+            result = result + s[i]
+            i = i + 1
+        return result
+
+    # 从 start 到末尾
+    func slice_from(s: var, start: int) -> var:
+        return StringUtil.slice(s, start, len(s))
+
+    # 从头到 end
+    func slice_to(s: var, end: int) -> var:
+        return StringUtil.slice(s, 0, end)
+
+    # ========== 查找 & 匹配 ==========
+
+    # 查找子串首次出现位置，-1 表示未找到
+    func find(s: var, pattern: var) -> int:
+        var s_len = len(s)
+        var p_len = len(pattern)
+        if p_len == 0:
+            return 0
+        if p_len > s_len:
+            return -1
+
+        var i = 0
+        while i <= s_len - p_len:
+            var match = true
+            var j = 0
+            while j < p_len:
+                if s[i + j] != pattern[j]:
+                    match = false
+                    j = p_len
+                j = j + 1
+            if match:
+                return i
+            i = i + 1
+        return -1
+
+    # 从右侧查找
+    func rfind(s: var, pattern: var) -> int:
+        var s_len = len(s)
+        var p_len = len(pattern)
+        if p_len == 0:
+            return s_len
+        if p_len > s_len:
+            return -1
+
+        var i = s_len - p_len
+        while i >= 0:
+            var match = true
+            var j = 0
+            while j < p_len:
+                if s[i + j] != pattern[j]:
+                    match = false
+                    j = p_len
+                j = j + 1
+            if match:
+                return i
+            i = i - 1
+        return -1
+
+    # 是否包含子串
+    func contains(s: var, pattern: var) -> bool:
+        if StringUtil.find(s, pattern) >= 0:
+            return true
+        return false
+
+    # 是否以 prefix 开头
+    func starts_with(s: var, prefix: var) -> bool:
+        var p_len = len(prefix)
+        if p_len > len(s):
+            return false
+        var i = 0
+        while i < p_len:
+            if s[i] != prefix[i]:
+                return false
+            i = i + 1
+        return true
+
+    # 是否以 suffix 结尾
+    func ends_with(s: var, suffix: var) -> bool:
+        var s_len = len(s)
+        var sf_len = len(suffix)
+        if sf_len > s_len:
+            return false
+        var i = 0
+        while i < sf_len:
+            if s[s_len - sf_len + i] != suffix[i]:
+                return false
+            i = i + 1
+        return true
+
+    # 子串出现次数
+    func count(s: var, pattern: var) -> int:
+        var c = 0
+        var pos = StringUtil.find(s, pattern)
+        while pos >= 0:
+            c = c + 1
+            s = StringUtil.slice_from(s, pos + len(pattern))
+            pos = StringUtil.find(s, pattern)
+        return c
+
+    # ========== 变换 ==========
+
+    # 替换首次出现的子串
+    func replace(s: var, from: var, to: var) -> var:
+        var pos = StringUtil.find(s, from)
+        if pos < 0:
+            return s
+        var before = StringUtil.slice_to(s, pos)
+        var after = StringUtil.slice_from(s, pos + len(from))
+        return before + to + after
+
+    # 替换所有出现的子串
+    func replace_all(s: var, from: var, to: var) -> var:
+        var result = ""
+        var current = s
+        var pos = StringUtil.find(current, from)
+        while pos >= 0:
+            result = result + StringUtil.slice_to(current, pos) + to
+            current = StringUtil.slice_from(current, pos + len(from))
+            pos = StringUtil.find(current, from)
+        result = result + current
+        return result
+
+    # 去除首尾空白（空格、tab、换行）
+    func trim(s: var) -> var:
+        return StringUtil.trim_end(StringUtil.trim_start(s))
+
+    # 去除首部空白
+    func trim_start(s: var) -> var:
+        var i = 0
+        var s_len = len(s)
+        while i < s_len:
+            var ch = s[i]
+            if ch != " ":
+                if ch != "\t":
+                    if ch != "\n":
+                        if ch != "\r":
+                            i = s_len
+            if i < s_len:
+                if ch != " ":
+                    if ch != "\t":
+                        if ch != "\n":
+                            if ch != "\r":
+                                i = s_len
+                else:
+                    i = i + 1
+        return StringUtil.slice_from(s, i)
+
+    # 去除尾部空白
+    func trim_end(s: var) -> var:
+        var i = len(s) - 1
+        while i >= 0:
+            var ch = s[i]
+            if ch != " ":
+                if ch != "\t":
+                    if ch != "\n":
+                        if ch != "\r":
+                            i = -1
+            if i >= 0:
+                if ch != " ":
+                    if ch != "\t":
+                        if ch != "\n":
+                            if ch != "\r":
+                                i = -1
+                else:
+                    i = i - 1
+        return StringUtil.slice_to(s, i + 1)
+
+    # 转换为小写（ASCII）
+    func to_lower(s: var) -> var:
+        var result = ""
+        var i = 0
+        var s_len = len(s)
+        while i < s_len:
+            var ch = s[i]
+            # ASCII 'A'~'Z' = 65~90, 'a'~'z' = 97~122
+            var code = ch[0]
+            if code >= "A"[0]:
+                if code <= "Z"[0]:
+                    # 转为小写：ch + 32
+                    var lower_code = code - "A"[0] + "a"[0]
+                    result = result + lower_code
+                    i = i + 1
+                    continue
+            result = result + ch
+            i = i + 1
+        return result
+
+    # 转换为大写（ASCII）
+    func to_upper(s: var) -> var:
+        var result = ""
+        var i = 0
+        var s_len = len(s)
+        while i < s_len:
+            var ch = s[i]
+            var code = ch[0]
+            if code >= "a"[0]:
+                if code <= "z"[0]:
+                    var upper_code = code - "a"[0] + "A"[0]
+                    result = result + upper_code
+                    i = i + 1
+                    continue
+            result = result + ch
+            i = i + 1
+        return result
+
+    # 首字母大写
+    func capitalize(s: var) -> var:
+        if len(s) == 0:
+            return ""
+        var first = StringUtil.to_upper(StringUtil.slice_to(s, 1))
+        var rest = StringUtil.to_lower(StringUtil.slice_from(s, 1))
+        return first + rest
+
+    # ========== 分割 & 连接 ==========
+
+    # 按分隔符分割
+    func split(s: var, delim: var) -> var:
+        var result = new Vec()
+        var current = s
+        var delim_len = len(delim)
+        if delim_len == 0:
+            # 拆分为单字符
+            var i = 0
+            while i < len(s):
+                result.push(StringUtil.slice(s, i, i + 1))
+                i = i + 1
+            return result
+
+        var pos = StringUtil.find(current, delim)
+        while pos >= 0:
+            var part = StringUtil.slice_to(current, pos)
+            result.push(part)
+            current = StringUtil.slice_from(current, pos + delim_len)
+            pos = StringUtil.find(current, delim)
+        result.push(current)
+        return result
+
+    # 按空白分割
+    func split_whitespace(s: var) -> var:
+        var result = new Vec()
+        var current = ""
+        var i = 0
+        var s_len = len(s)
+        while i < s_len:
+            var ch = s[i]
+            if ch == " ":
+                if current != "":
+                    result.push(current)
+                    current = ""
+            elif ch == "\t":
+                if current != "":
+                    result.push(current)
+                    current = ""
+            elif ch == "\n":
+                if current != "":
+                    result.push(current)
+                    current = ""
+            else:
+                current = current + ch
+            i = i + 1
+        if current != "":
+            result.push(current)
+        return result
+
+    # 按行分割
+    func lines(s: var) -> var:
+        var result = new Vec()
+        var current = ""
+        var i = 0
+        var s_len = len(s)
+        while i < s_len:
+            var ch = s[i]
+            if ch == "\n":
+                result.push(current)
+                current = ""
+            elif ch == "\r":
+                # 跳过 \r
+                if i + 1 < s_len:
+                    if s[i + 1] == "\n":
+                        i = i + 1
+                result.push(current)
+                current = ""
+            else:
+                current = current + ch
+            i = i + 1
+        # 最后一行（既使是空行）
+        result.push(current)
+        return result
+
+    # 用分隔符连接字符串数组
+    func join(strings: var, sep: var) -> var:
+        var result = ""
+        var i = 0
+        var n = len(strings)
+        while i < n:
+            if i > 0:
+                result = result + sep
+            result = result + strings[i]
+            i = i + 1
+        return result
+
+    # ========== 字符访问 ==========
+
+    # 安全字符访问（返回单字符字符串）
+    func char_at(s: var, idx: int) -> var:
+        var s_len = len(s)
+        if idx < 0:
+            return Result.err(error.value_error("char_at: index " + idx + " < 0"))
+        if idx >= s_len:
+            return Result.err(error.value_error("char_at: index " + idx + " out of bounds"))
+        return Result.ok(StringUtil.slice(s, idx, idx + 1))
+
+    # 获取所有字符列表
+    func chars(s: var) -> var:
+        return StringUtil.split(s, "")

vx_toolkit/_bin/std/sys/coroutine.vx

@@ -0,0 +1,46 @@
+# ============================================================
+# std::sys::coroutine —— 协程（用户态轻量级并发）
+# 第一版：占位定义，等待 VM 层支持
+# ============================================================
+
+import std.error
+
+# ---- CoroutineState 枚举 ----
+enum CoroutineState:
+    Ready     = 0
+    Running   = 1
+    Suspended = 2
+    Done      = 3
+
+# ---- Coroutine 类：协程句柄 ----
+class Coroutine:
+    id: int
+    state: int
+
+    # 创建协程
+    func spawn(func: var) -> var:
+        # TODO: 需要 VM 层 CallFrame 保存/恢复机制
+        var co = new Coroutine()
+        co.id = 0
+        co.state = CoroutineState.Ready
+        return co
+
+    # 恢复执行
+    func resume() -> var:
+        # TODO: 需要 VM 支持
+        return Result.err(error.runtime_error("Coroutine.resume: not implemented"))
+
+    # 让出执行权
+    func yield_co():
+        # TODO: 需要 VM 支持
+        pass
+
+    # 是否完成
+    func is_done() -> bool:
+        if self.state == CoroutineState.Done:
+            return true
+        return false
+
+    # 获取协程 ID
+    func get_id() -> int:
+        return self.id

vx_toolkit/_bin/std/sys/datetime.vx

@@ -0,0 +1,160 @@
+# ============================================================
+# std::sys::datetime —— 日期时间
+# ============================================================
+
+import std.error
+import std.math
+import std.collections.vec
+
+# ---- DateTime 类：日期时间表示 ----
+class DateTime:
+    year: int
+    month: int
+    day: int
+    hour: int
+    minute: int
+    second: int
+    nanos: int
+    weekday: int        # 0=Sunday ... 6=Saturday
+
+    # 请求当前日期时间（需要 VM 支持的系统时钟）
+    func now() -> var:
+        # TODO: 需要 VM 内建 system_time 指令
+        var dt = new DateTime()
+        dt.year = 1970
+        dt.month = 1
+        dt.day = 1
+        dt.hour = 0
+        dt.minute = 0
+        dt.second = 0
+        dt.nanos = 0
+        dt.weekday = 4  # 1970-01-01 是周四
+        return dt
+
+    # 从 Unix 时间戳创建
+    func from_timestamp(ts: int) -> var:
+        # 使用公历算法将 Unix 时间戳转为日期
+        var dt = new DateTime()
+
+        # 先转为从 1970-01-01 的天数
+        var days = ts / 86400
+        var secs_remain = ts % 86400
+        if secs_remain < 0:
+            secs_remain = secs_remain + 86400
+            days = days - 1
+
+        # 计算时分秒
+        dt.hour = secs_remain / 3600
+        secs_remain = secs_remain % 3600
+        dt.minute = secs_remain / 60
+        dt.second = secs_remain % 60
+        dt.nanos = 0
+
+        # 从 Epoch 1970-01-01 计算年月日
+        # 使用偏移算法：向前走到目标天数
+        var remaining_days = days
+        dt.year = 1970
+        dt.month = 1
+
+        # 按年推进
+        while remaining_days >= 365:
+            var days_in_this_year = 365
+            if DateTime._is_leap(dt.year):
+                days_in_this_year = 366
+            if remaining_days >= days_in_this_year:
+                remaining_days = remaining_days - days_in_this_year
+                dt.year = dt.year + 1
+            else:
+                break
+
+        # 按月推进
+        var days_in_months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        if DateTime._is_leap(dt.year):
+            days_in_months[1] = 29
+
+        var m = 0
+        while m < 12:
+            if remaining_days < days_in_months[m]:
+                dt.month = m + 1
+                dt.day = remaining_days + 1
+                break
+            remaining_days = remaining_days - days_in_months[m]
+            m = m + 1
+
+        # 计算星期几（Zeller 算法简化）
+        dt.weekday = DateTime._calc_weekday(dt.year, dt.month, dt.day)
+
+        return dt
+
+    # 转换回 Unix 时间戳
+    func to_timestamp() -> int:
+        var days = 0
+        # 从 1970 到当前年的天数
+        var y = 1970
+        while y < self.year:
+            days = days + 365
+            if DateTime._is_leap(y):
+                days = days + 1
+            y = y + 1
+
+        # 当年已过月份的天数
+        var days_in_months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        if DateTime._is_leap(self.year):
+            days_in_months[1] = 29
+
+        var m = 0
+        while m < self.month - 1:
+            days = days + days_in_months[m]
+            m = m + 1
+
+        days = days + (self.day - 1)
+
+        var total_secs = days * 86400
+        total_secs = total_secs + self.hour * 3600
+        total_secs = total_secs + self.minute * 60
+        total_secs = total_secs + self.second
+
+        return total_secs
+
+    # 格式化输出（ISO 8601 简化版）
+    func to_string() -> var:
+        return self.to_iso8601()
+
+    # ISO 8601 格式
+    func to_iso8601() -> var:
+        var s = ""
+        s = s + self.year
+        s = s + "-" + DateTime._pad2(self.month)
+        s = s + "-" + DateTime._pad2(self.day)
+        s = s + "T" + DateTime._pad2(self.hour)
+        s = s + ":" + DateTime._pad2(self.minute)
+        s = s + ":" + DateTime._pad2(self.second)
+        return s
+
+    # 填充两位数
+    func _pad2(n: int) -> var:
+        if n < 10:
+            return "0" + n
+        return n
+
+    # 判断闰年
+    func _is_leap(year: int) -> bool:
+        if year % 400 == 0:
+            return true
+        if year % 100 == 0:
+            return false
+        if year % 4 == 0:
+            return true
+        return false
+
+    # 计算星期几（Zeller 公式，返回 0=Sunday）
+    func _calc_weekday(year: int, month: int, day: int) -> int:
+        if month < 3:
+            month = month + 12
+            year = year - 1
+        var k = year % 100
+        var j = year / 100
+        var h = (day + (13 * (month + 1)) / 5 + k + k / 4 + j / 4 - 2 * j) % 7
+        if h < 0:
+            h = h + 7
+        return h

vx_toolkit/_bin/std/sys/duration.vx

@@ -0,0 +1,53 @@
+# ============================================================
+# std::sys::duration —— 时间间隔
+# ============================================================
+
+# ---- Duration 类：时间段 ----
+class Duration:
+    secs: int
+    nanos: int
+
+    # 从秒创建
+    func from_secs(s: float) -> var:
+        var dur = new Duration()
+        dur.secs = s
+        var frac = s - dur.secs
+        dur.nanos = frac * 1000000000.0
+        return dur
+
+    # 从毫秒创建
+    func from_millis(ms: int) -> var:
+        var dur = new Duration()
+        dur.secs = ms / 1000
+        dur.nanos = (ms % 1000) * 1000000
+        return dur
+
+    # 从微秒创建
+    func from_micros(us: int) -> var:
+        var dur = new Duration()
+        dur.secs = us / 1000000
+        dur.nanos = (us % 1000000) * 1000
+        return dur
+
+    # 从纳秒创建
+    func from_nanos(ns: int) -> var:
+        var dur = new Duration()
+        dur.secs = ns / 1000000000
+        dur.nanos = ns % 1000000000
+        return dur
+
+    # 转为秒（浮点）
+    func as_secs() -> float:
+        return self.secs + self.nanos / 1000000000.0
+
+    # 转为毫秒
+    func as_millis() -> int:
+        return self.secs * 1000 + self.nanos / 1000000
+
+    # 转为微秒
+    func as_micros() -> int:
+        return self.secs * 1000000 + self.nanos / 1000
+
+    # 转为纳秒
+    func as_nanos() -> int:
+        return self.secs * 1000000000 + self.nanos

vx_toolkit/_bin/std/sys/env.vx

@@ -0,0 +1,43 @@
+# ============================================================
+# std::sys::env —— 环境变量与进程控制
+# ============================================================
+
+import std.error
+import std.collections.vec
+
+# ---- Env 类：环境和进程工具（静态方法）----
+class Env:
+    # 获取命令行参数（封装 VM 内建 sys_argv）
+    func args() -> var:
+        var raw = sys_argv()
+        if raw == nil:
+            return []
+        return raw
+
+    # 获取环境变量（占位）
+    func get(key: var) -> var:
+        # TODO: 需要 VM 内建 get_env 指令
+        return nil
+
+    # 设置环境变量（占位）
+    func set(key: var, val: var):
+        # TODO: 需要 VM 内建 set_env 指令
+        pass
+
+    # 删除环境变量（占位）
+    func remove(key: var):
+        # TODO: 需要 VM 内建 unset_env 指令
+        pass
+
+    # 退出进程
+    func exit(code: int):
+        # TODO: 需要 VM 内建 exit 指令
+        out("[EXIT] code=" + code)
+
+    # 获取当前工作目录（占位）
+    func current_dir() -> var:
+        return Result.err(error.system_error("Env.current_dir: not implemented"))
+
+    # 获取临时目录（占位）
+    func temp_dir() -> var:
+        return "/tmp"

vx_toolkit/_bin/std/sys/mod.vx

@@ -0,0 +1,10 @@
+# ============================================================
+# std::sys —— 模块入口
+# ============================================================
+
+import std.sys.time
+import std.sys.duration
+import std.sys.datetime
+import std.sys.coroutine
+import std.sys.sync
+import std.sys.env