codecin 5.8.0__tar.gz → 5.8.2__tar.gz

{codecin-5.8.0 → codecin-5.8.2}/CHANGELOG.md

@@ -5,6 +5,70 @@
 
 ---
 
+## [5.8.2] - 2026-10-04
+
+一次以「真实压测程序暴露的错误信息与栈安全」为主线的修复发布。核心结论：
+5.5.3 的浮点下标修复在三条执行路径均有效（`a[(n * p) / 100]` 一类变量参与
+的浮点表达式同样覆盖）；用户在 Termux 上报告的 `address ffffffffffffc6f8
+out of bounds` 实为**局部大数组把栈推成负地址**——`int lat[10000]` 需要
+80 KB 局部空间，超过默认 64 KB 内存后 SP 绕回，越界检查检查的是绕回后的
+地址。为此新增带防护的帧分配系统调用（SYS 137），并全面改进运行时/编译期
+错误信息、补齐 CLI 直传参数与高精度计时。
+
+### 修复 (Fixed)
+
+#### 局部大数组撑爆栈（静默生成负地址）
+- **函数序言的帧分配改为带防护的系统调用**。此前 prologue 用裸 `ADDI sp, sp,
+  -frame_bytes` 递减栈指针，局部数组总大小超过可用内存时 SP 绕回为巨大无符号
+  值（如 0xFFFFFFFFFFFFC6F8），后续所有访问都指向"负地址"，报错只看到一句
+  out of bounds，看不出真因。现在两侧编译器（`cin.py` / `codegen.go`）改为
+  `SYS ALLOCFRAME`：VM 侧用**有符号比较**在分配前检查栈余量（含 4 KB 警戒
+  线），不足时直接报
+  `Stack overflow: frame needs N bytes, stack headroom only M bytes (...)
+  Try --mem-size (default 65536) or smaller local arrays`，
+  不再让绕回地址流入访存路径。Python 解释器、JIT、Go 原生三条路径语义一致。
+- **负地址越界提示兜底**：地址 >= 2^63 的越界报错（Python `memory.py` 与
+  Go `checkAddr`）追加
+  `(negative address: stack overflow or bad pointer?)`，把"看起来像随机大数"
+  的地址翻译成可排查的方向。
+
+#### 错误信息补全（问题 2/4/5）
+- **Heap exhausted 附用量与建议**：三处堆耗尽点（malloc / 字符串拼接 / 字符串
+  操作）在 Python 与 Go 两侧逐字一致地报
+  `Heap exhausted: need N bytes, free M bytes (heap 0x...0x...).
+  Try --mem-size (default 65536) or reduce allocations`。
+- **非常量数组长度的编译期报错附 hint**：
+  `array lengths must be compile-time constants; declare it as
+  \`const int NAME = ...\`; variable-length arrays are not supported —
+  use a fixed-size array plus a count variable`。
+- **`float(x)` / `int(x)` 报错附替代写法**：提示使用 `to_float(x)` / `to_int(x)`
+  或依赖混合表达式的隐式提升。
+
+#### 兼容层与文档
+- `gostd.cin` 头注释明确列出当前覆盖的包（strings / strconv / math / slices /
+  os.Args）与**未覆盖项**（time、os 文件读写、net/http、sync），并指向对应
+  内建（`time_ms/time_us/time_ns`、`file_*` 函数族），避免"Go 标准库兼容层"
+  的命名让人误以为常用包会逐步全覆盖。
+
+### 新增 (Added)
+
+#### CLI 程序名后直传参数
+- `codecin 压测.cin https://example.com 24` 现在可用：程序文件之后的裸参数
+  原样传给 CIN 程序（`arg_count()` / `arg(i)`），已知 CLI 选项放在程序之前或
+  之后均可识别；形如选项的直传参数给出 stderr 提示并用 `--` 显式分隔。
+  `--` 分隔符行为不变且优先级最高，`--help` 新增 Program arguments 说明段。
+
+#### 高精度计时 `time_us()` / `time_ns()`（SYS 138/139）
+- 微秒 / 纳秒级单调计时，补齐 `time_ms()` 只能测毫秒的短板（压测与微基准
+  基础设施）。两侧编译器同步登记，解释器 / JIT / 原生三条路径均可用；
+  与 ALLOCFRAME 同属核心 VM 机制，不触发沙箱门禁与原生路径限定。
+
+#### 显式类型转换 `to_int()` / `to_float()`
+- 数值类型（int/float/bool）间的显式转换，语义与隐式转换一致（float→int 向零
+  截断）。非数值参数在编译期报错并说明。
+
+---
+
 ## [5.8.0] - 2026-10-04
 
 一次「图形、媒体与跨平台兼容」发布：新增 **GUI 窗口**（Windows Win32 /

{codecin-5.8.0/codecin.egg-info → codecin-5.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecin
-Version: 5.8.0
+Version: 5.8.2
 Summary: Code CIN - 高级语言与运行时 (CIN/PL/ASM 工具链 + Go 原生 VM + ARM64/RISC-V/FP/Vector 指令集)
 Author: ByUsi Studio, 北啊呢
 License-Expression: MIT

{codecin-5.8.0 → codecin-5.8.2}/codecin/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "5.8.0"
+__version__ = "5.8.2"
 __author__ = "ByUsi Studio"
 
 from .config import Config

{codecin-5.8.0 → codecin-5.8.2}/codecin/cin.py

@@ -210,6 +210,8 @@ HOST_BUILTINS = {
     'chdir': (Syscall.CHDIR, 1, 'int'),
     # 时间与系统信息
     'time_ms': (Syscall.TIMEMS, 0, 'int'),
+    'time_us': (Syscall.TIMEUS, 0, 'int'),
+    'time_ns': (Syscall.TIMENS, 0, 'int'),
     'sleep_ms': (Syscall.SLEEPMS, 1, 'int'),
     'cpu_count': (Syscall.CPUCOUNT, 0, 'int'),
     'arch_name': (Syscall.ARCHNAME, 0, 'string'),
@@ -953,7 +955,11 @@ class Parser:
                 return ('int', self.enums[node[1]])
             raise CompilerError(
                 f"Constant expression uses non-constant name '{node[1]}' "
-                f"at {self._loc()}")
+                f"at {self._loc()} "
+                "(hint: array lengths must be compile-time constants; "
+                f"declare it as `const int {node[1]} = ...`; "
+                "variable-length arrays are not supported — use a fixed-size "
+                "array plus a count variable)")
         if kind == 'neg':
             ctype, value = self._const_value_ast(node[1])
             if ctype == 'string':
@@ -1996,12 +2002,15 @@ class CodeGen:
             self.locals[pname] = (ptype, poff, False)
 
         self.label(f.name)
-        # prologue: 保存调用方 FP, 建立帧指针, 分配局部空间
+        # prologue: 保存调用方 FP, 建立帧指针, 分配局部空间。
+        # 帧分配走 SYS ALLOCFRAME (带栈溢出防护): 此前直接 ADDI SP 减帧长,
+        # 局部大数组会把 SP 推到负地址 —— 轻则报晦涩的越界地址
+        # (如 address ffff...c6f8), 重则静默覆盖全局/堆内存。
         self.emit('PUSH', self.reg(29))
         self.emit('MOV', self.reg(29), self.reg(32))   # FP = SP
         if self.frame_bytes:
-            self.emit('ADDI', self.reg(0), self.reg(32), self.imm(-self.frame_bytes))
-            self.emit('MOV', self.reg(32), self.reg(0))
+            self.emit('MOV', self.reg(0), self.imm(self.frame_bytes))
+            self.emit('SYS', self.imm(Syscall.ALLOCFRAME))
 
         # struct 局部变量: 堆分配对象 (槽里存对象指针, 与全局 struct 同一模型)
         for _name, (t, loff, _is_block) in list(self.locals.items()):
@@ -3543,6 +3552,18 @@ class CodeGen:
                       'rtrim': Syscall.RTRIM}[name]
             self.emit('SYS', self.imm(sys_id))
             return 'string'
+        if name in ('to_int', 'to_float'):
+            # 显式类型转换: to_int(x) 向零截断 (与 int x = 1.9 一致),
+            # to_float(x) 整数提升为浮点。参数类型静态已知, 非数值报编译错。
+            t = self.gen_value(args[0])
+            target = 'int' if name == 'to_int' else 'float'
+            if t not in ('int', 'float', 'bool'):
+                raise CompilerError(
+                    f"{name}() expects a numeric argument, got {t} "
+                    f"at {self._loc()}"
+                    + (f" (hint: use atoi() to parse a string)" if t == 'string' else ""))
+            self._convert(t, target)
+            return target
         if name == 'atoi':
             self.gen_value(args[0])
             self.emit('SYS', self.imm(Syscall.ATOI))
@@ -3562,6 +3583,12 @@ class CodeGen:
             return 'int'
 
         # 用户函数 (已在 _gen_call 开头优先分派; 走到这里说明名字未知)
+        if name in ('int', 'float'):
+            # 常见迁移习惯: C/Python 风格的显式转换函数。给出可操作的替代写法。
+            raise CompilerError(
+                f"Unknown function: {name} (hint: use "
+                f"to_{name}(x) for explicit conversion, or rely on implicit "
+                "promotion in mixed int/float expressions)")
         raise CompilerError(f"Unknown function: {name}")
 
     @staticmethod

{codecin-5.8.0 → codecin-5.8.2}/codecin/cli.py

@@ -17,7 +17,11 @@ from .console import Colors, Console, Panel
 HELP_INTRO = f"""{Colors.colorize(f'Code CIN v{__version__}', Colors.CYAN, True)}
 
 {Colors.colorize('Usage:', Colors.YELLOW)}
-  codecin <program.[cin|pl|asm|bin]> [options]
+  codecin [options] <program.[cin|pl|asm|bin]> [args...]
+
+{Colors.colorize('Program arguments:', Colors.YELLOW)}
+  program 之后的裸参数原样传给 CIN 程序 (arg_count()/arg(i) 读取);
+  CLI 选项放在 program 之前或之后均可识别, 形如选项的参数请用 `--` 显式分隔。
 
 {Colors.colorize('Supported formats:', Colors.YELLOW)}
   .cin   CIN 高级语言 (函数/struct/数组/浮点/字符串)
@@ -219,6 +223,43 @@ def _run_aot_build(ns: argparse.Namespace, console, program_file: str,
     return 0
 
 
+def _extract_program_args(args: List[str], parser: argparse.ArgumentParser):
+    """把程序文件之后的裸参数透传给 CIN 程序 (arg_count()/arg(i))。
+
+    规则 (向后兼容): 第一个非选项 token 是程序文件; 此后遇到已知 CLI 选项
+    (及其取值) 仍归 CLI 解析, 其余裸 token 归程序参数。`--` 分隔的参数已在
+    main 里摘出, 优先级更高。返回 (cli_args, program_args)。
+    """
+    takes_value = {}
+    for act in parser._actions:  # noqa: SLF001 - argparse 无公开枚举接口
+        for s in getattr(act, 'option_strings', []):
+            takes_value[s] = getattr(act, 'nargs', None) != 0
+    cli_args: List[str] = []
+    prog_args: List[str] = []
+    seen_prog = False
+    i, n = 0, len(args)
+    while i < n:
+        tok = args[i]
+        # --opt=value 形式按其选项名识别
+        optname = tok.split('=', 1)[0] if tok.startswith('--') else tok
+        if optname in takes_value:
+            cli_args.append(tok)
+            if takes_value[optname] and '=' not in tok:
+                i += 1
+                if i < n:
+                    cli_args.append(args[i])
+            i += 1
+            continue
+        if not seen_prog:
+            cli_args.append(tok)
+            seen_prog = True
+            i += 1
+            continue
+        prog_args.append(tok)
+        i += 1
+    return cli_args, prog_args
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     args = list(sys.argv[1:] if argv is None else argv)
 
@@ -246,8 +287,20 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     console = Console()
     parser = build_parser()
+
+    # 程序文件之后的裸参数透传给 CIN 程序 (问题反馈 #3): 已知 CLI 选项
+    # (含取值) 仍归 argparse, 其余 token 归 arg_count()/arg(i)。
+    cli_args, direct_args = _extract_program_args(args, parser)
+    if direct_args:
+        for tok in direct_args:
+            if tok.startswith('-') and tok not in ('-',) \
+                    and not tok.lstrip('-').split('=')[0].isdigit():
+                sys.stderr.write(
+                    f"note: {tok!r} 不是 CLI 选项, 已作为程序参数传递 "
+                    f"(arg_count/arg); 如需强制传参请用 `-- {tok}`\n")
+
     try:
-        ns = parser.parse_args(args)
+        ns = parser.parse_args(cli_args)
     except SystemExit as e:
         # argparse 错误 (未知选项/非法数值): 已打印 usage, 返回其退出码
         return int(e.code) if e.code is not None else 2
@@ -278,7 +331,8 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     config = Config()
     _apply_namespace(config, ns)
-    config.program_args = program_args
+    # 直传参数与 `--` 后参数合并 (直传在前, 位置顺序与命令行一致)
+    config.program_args = direct_args + program_args
     config.validate()
 
     program_file = ns.program

{codecin-5.8.0 → codecin-5.8.2}/codecin/cpu.py

@@ -23,6 +23,12 @@ Instruction = Tuple[str, List[Operand]]
 MASK64 = 0xFFFFFFFFFFFFFFFF
 MASK32 = 0xFFFFFFFF
 
+# 核心 VM 机制系统调用: 不触碰宿主状态, 沙箱模式同样放行 (与 SYS < AUDIOPLAY
+# 的数学/字符串类内建同级)。文本语义必须与 Go 引擎 vm.go 保持一致。
+_CORE_SYS_CALLS = frozenset({
+    Syscall.ALLOCFRAME, Syscall.TIMEUS, Syscall.TIMENS,
+})
+
 
 def _f_to_bits(f: float) -> int:
     return struct.unpack('<Q', struct.pack('<d', f))[0]
@@ -85,7 +91,8 @@ class CPU:
         self.pstate: Dict[str, bool] = {'N': False, 'Z': False, 'C': False, 'V': False}
         self.pc = 0
         self.sp = (config.mem_size - Constants.STACK_SLOT) & ~0x7
-        self.heap_ptr = config.mem_size // 2
+        self.heap_base = config.mem_size // 2
+        self.heap_ptr = self.heap_base
 
         self.logger.dump("CPU 初始化", {
             'memory': f"0x{config.mem_size:x} bytes",
@@ -1153,7 +1160,11 @@ class CPU:
         ptr = self.heap_ptr
         self.heap_ptr += size
         if self.heap_ptr > self.sp:
-            raise ExecutionError("Heap exhausted (string operation)")
+            free = max(self.sp - ptr, 0)
+            raise ExecutionError(
+                f"Heap exhausted (string operation): need {size} bytes,"
+                f" free {free} bytes (heap 0x{self.heap_base:x}..0x{self.sp:x})."
+                " Try --mem-size (default 65536) or reduce allocations")
         self.memory.write_block(ptr, data)
         return ptr
 
@@ -1170,7 +1181,9 @@ class CPU:
         call_id = args[0][1]
         # 沙箱模式: 拦截全部宿主能力 (音频/画布/文件/进程/环境/网络/Termux),
         # 只放行数学/字符串/内存/输出类内建。原生路径在 _try_native_run 已强制回退。
-        if self.config.sandbox_mode and call_id >= Syscall.AUDIOPLAY:
+        # 核心机制系统调用 (_CORE_SYS_CALLS) 不触碰宿主状态, 沙箱内照常放行。
+        if (self.config.sandbox_mode and call_id >= Syscall.AUDIOPLAY
+                and call_id not in _CORE_SYS_CALLS):
             raise ExecutionError(
                 "Host capability disabled in sandbox mode (SYS "
                 f"{call_id}: {Syscall(call_id).name if call_id in Syscall._value2member_map_ else 'UNKNOWN'})")
@@ -1183,7 +1196,30 @@ class CPU:
             self.logger.trace(f"  SYS #{call_id} ({name}) "
                               f"x0=0x{x0:x} x1=0x{x1:x} x2=0x{x2:x}")
 
-        if call_id == Syscall.ABS:
+        if call_id == Syscall.ALLOCFRAME:
+            # 函数序言的帧分配 (核心机制, 沙箱放行): 带溢出防护的 SP 递减。
+            # 此前 prologue 直接 ADDI SP, SP, -frame_bytes, 局部大数组会把 SP
+            # 推到负地址 —— 轻则报晦涩的 "address ffff... out of bounds",
+            # 重则静默覆盖全局/堆内存。消息文本必须与 Go 引擎 vm.go 一致。
+            fb = x0
+            guard = self.heap_ptr + 4096
+            # 按有符号比较: SP 绕回 (负地址) 必须判定为溢出, 不能先按
+            # 2^64 取模再比大小 (绕回值会显得巨大而漏判)。
+            new_sp = self.sp - fb
+            if new_sp < guard:
+                avail = max(self.sp - guard, 0)
+                raise ExecutionError(
+                    f"Stack overflow: frame needs {fb} bytes, stack headroom "
+                    f"only {avail} bytes (SP 0x{self.sp:x}, guard "
+                    f"0x{guard:x}, memory {self.config.mem_size} bytes). "
+                    "Try --mem-size (default 65536) or smaller local arrays")
+            self.sp = new_sp & MASK64
+            self._set_reg(0, self.sp)
+        elif call_id in (Syscall.TIMEUS, Syscall.TIMENS):
+            # 高精度计时: Unix 纪元微秒/纳秒 (与 Go time.Now() 同基, 非单调钟)
+            ns = time.time_ns()
+            self._set_reg(0, ns // 1000 if call_id == Syscall.TIMEUS else ns)
+        elif call_id == Syscall.ABS:
             self._set_reg(0, abs(x0 if x0 < (1 << 63) else x0 - (1 << 64)))
         elif call_id in (Syscall.SQRT,):
             # 负数定义域: 与 Go 路径一致返回 NaN (不抛 CPython 内部异常)
@@ -1258,7 +1294,11 @@ class CPU:
             ptr = self.heap_ptr
             self.heap_ptr += size
             if self.heap_ptr > self.sp:
-                raise ExecutionError("Heap exhausted")
+                free = max(self.sp - ptr, 0)
+                raise ExecutionError(
+                    f"Heap exhausted: need {size} bytes, free {free} bytes"
+                    f" (heap 0x{self.heap_base:x}..0x{self.sp:x})."
+                    " Try --mem-size (default 65536) or reduce allocations")
             self._set_reg(0, ptr)
         elif call_id == Syscall.PRINT_FLOAT:
             self._emit_text(_format_float(_bits_to_f(x0)))
@@ -1282,7 +1322,11 @@ class CPU:
             ptr = self.heap_ptr
             self.heap_ptr += size
             if self.heap_ptr > self.sp:
-                raise ExecutionError("Heap exhausted (string concat)")
+                free = max(self.sp - ptr, 0)
+                raise ExecutionError(
+                    f"Heap exhausted (string concat): need {size} bytes,"
+                    f" free {free} bytes (heap 0x{self.heap_base:x}..0x{self.sp:x})."
+                    " Try --mem-size (default 65536) or reduce allocations")
             self.memory.write_block(ptr, data)
             self._set_reg(0, ptr)
         elif call_id == Syscall.BOOL_STR:

{codecin-5.8.0 → codecin-5.8.2}/codecin/isa.py

@@ -275,6 +275,10 @@ class Syscall(IntEnum):
     AUDIOPAUSE = 134  # audio_pause() -> 0 成功 / -1 (无播放或已暂停)
     AUDIORESUME = 135 # audio_resume() -> 0 成功 / -1 (无暂停可恢复)
     AUDIOLEVEL = 136  # audio_level() -> 当前音量 0..100 (audio_volume 设置值)
+    # ---- 核心 VM 机制 (非宿主能力: 解释器/沙箱/原生三路径都可用) ----
+    ALLOCFRAME = 137  # alloc_frame(x0=字节数): SP -= x0; 低于堆警戒线则中止
+    TIMEUS = 138    # time_us() -> 单调微秒计时 (高精度基准测试用)
+    TIMENS = 139    # time_ns() -> 单调纳秒计时 (time_us 的高分辨率版本)
 
 
 class Cond:

{codecin-5.8.0 → codecin-5.8.2}/codecin/lib/gostd.cin

@@ -1,9 +1,18 @@
 // Code CIN 官方标准库: Go 标准库兼容层 (gostd)
 // 用法: import "gostd.cin"
 //
-// 以 pkg.Func 命名习惯提供 strings / strconv / math / slices / os 的
-// 常用函数 (go_strings_contains 对应 strings.Contains)。命名里的包段
-// 与 Go 文档一一对应, 便于从 Go 移植或查阅语义。
+// 覆盖范围 (纯 CIN 实现, 与 Go 标准库命名的对应关系):
+//   strings  —— Contains/Index/重复/大小写/裁剪/前后缀/替换等常用函数
+//   strconv  —— Itoa/Atoi/ParseBool/FormatFloat(经 ftoa) 等转换
+//   math     —— Sqrt/Abs/Floor/Ceil/Round/Pow 等包装
+//   slices   —— Contains/Index/Sort(经排序内建)/Reverse 等常用操作
+//   os       —— 仅 os.Args (go_os_args_len / go_os_args_get)
+// 未覆盖 (避免误解): time、os 文件读写、net/http、sync 等包暂无兼容层 ——
+// 计时请用内建 time_ms/time_us/time_ns, 文件读写用内建 file_* 函数族。
+//
+// 以 pkg.Func 命名习惯提供上述包的常用函数 (go_strings_contains 对应
+// strings.Contains)。命名里的包段与 Go 文档一一对应, 便于从 Go 移植或
+// 查阅语义。
 // 注意: go_os_args_len / go_os_args_get 依赖命令行参数内建 (arg_count /
 // arg, SYS 129..130), 需要原生路径 (CLI `--` 传参或 AOT 产物 os.Args)。
 

{codecin-5.8.0 → codecin-5.8.2}/codecin/memory.py

@@ -179,9 +179,14 @@ class FastMemory:
 
     def _check_bounds(self, addr: int, size: int = 1) -> None:
         if not 0 <= addr <= self._size - size:
+            hint = ""
+            if addr >= (1 << 63):
+                # 按位模 2^64 后为负数: 典型成因是栈溢出 (SP 被推到负地址)
+                # 或野指针。可读性提示, 与 Go 引擎 vm.go 的文案保持一致。
+                hint = " (negative address: stack overflow or bad pointer?)"
             raise MemoryAccessError(
                 f"Address 0x{addr:x} out of bounds (memory size 0x{self._size:x}, "
-                f"access width {size})")
+                f"access width {size}){hint}")
 
     def _check_protection(self, addr: int, access: str) -> None:
         if not self.check_access(addr, access):

{codecin-5.8.0 → codecin-5.8.2}/codecin/native/compiler/codegen.go

@@ -79,6 +79,8 @@ var hostBuiltins = map[string]hostBuiltin{
 	"chdir":         {SysCHDIR, 1, kInt},
 	// 时间与系统信息
 	"time_ms":    {SysTIMEMS, 0, kInt},
+	"time_us":    {SysTIMEUS, 0, kInt},
+	"time_ns":    {SysTIMENS, 0, kInt},
 	"sleep_ms":   {SysSLEEPMS, 1, kInt},
 	"cpu_count":  {SysCPUCOUNT, 0, kInt},
 	"arch_name":  {SysARCHNAME, 0, kString},
@@ -342,9 +344,11 @@ func (c *compiler) genFunctionBody(f *FuncDef) {
 	c.label(f.name)
 	c.emit("PUSH", c.reg(29))
 	c.emit("MOV", c.reg(29), c.reg(32))
+	// 帧分配走 SYS ALLOCFRAME (带栈溢出防护), 与 Python 编译器逐字节一致:
+	// 此前直接 ADDI SP 减帧长, 局部大数组会把 SP 推到负地址 (越界/静默破坏内存)。
 	if c.frameBytes != 0 {
-		c.emit("ADDI", c.reg(0), c.reg(32), c.imm(int64(-c.frameBytes)))
-		c.emit("MOV", c.reg(32), c.reg(0))
+		c.emit("MOV", c.reg(0), c.imm(int64(c.frameBytes)))
+		c.emit("SYS", c.imm(SysALLOCFRAME))
 	}
 
 	// struct 局部变量: 堆分配对象
@@ -1923,6 +1927,25 @@ func (c *compiler) genCall(name string, args []*Node) *Type {
 		c.emit("SYS", c.imm(SysATOI))
 		return scalarT(kInt)
 	}
+	if name == "to_int" || name == "to_float" {
+		// 显式类型转换: to_int 向零截断 (与 int x = 1.9 一致), to_float 提升。
+		// 与 Python 编译器 (cin.py) 的同名内建语义逐一致。
+		argT := c.genValue(args[0])
+		target := scalarT(kInt)
+		if name == "to_float" {
+			target = scalarT(kFloat)
+		}
+		if argT == nil || (argT.Kind != kInt && argT.Kind != kFloat && argT.Kind != kBool) {
+			got := "void"
+			if argT != nil {
+				got = typeName(argT)
+			}
+			c.failf("%s() expects a numeric argument, got %s", name, got)
+			return nil
+		}
+		c.convert(argT, target)
+		return target
+	}
 
 	// 宿主能力 (表驱动): 音频 / 画布 / 系统交互 / Termux API
 	if hb, ok := hostBuiltins[name]; ok {
@@ -1946,6 +1969,12 @@ func (c *compiler) genCall(name string, args []*Node) *Type {
 	// 用户函数
 	fdef := c.functions[name]
 	if fdef == nil {
+		if name == "int" || name == "float" {
+			c.failf("Unknown function: %s (hint: use to_%s(x) for explicit "+
+				"conversion, or rely on implicit promotion in mixed "+
+				"int/float expressions)", name, name)
+			return nil
+		}
 		c.failf("Unknown function: %s", name)
 		return nil
 	}

{codecin-5.8.0 → codecin-5.8.2}/codecin/native/compiler/syscalls.go

@@ -141,3 +141,6 @@ const SysAUDIOPLAYING = 133
 const SysAUDIOPAUSE = 134
 const SysAUDIORESUME = 135
 const SysAUDIOLEVEL = 136
+const SysALLOCFRAME = 137
+const SysTIMEUS = 138
+const SysTIMENS = 139

{codecin-5.8.0 → codecin-5.8.2}/codecin/native/engine/isa_gen.go

@@ -500,3 +500,6 @@ const sysAUDIOPLAYING = 133
 const sysAUDIOPAUSE = 134
 const sysAUDIORESUME = 135
 const sysAUDIOLEVEL = 136
+const sysALLOCFRAME = 137
+const sysTIMEUS = 138
+const sysTIMENS = 139

{codecin-5.8.0 → codecin-5.8.2}/codecin/native/engine/version_gen.go

@@ -4,4 +4,4 @@
 package engine
 
 // BuildVersion 是 Code CIN 的版本号 (被 codecin_version() 与日志使用)。
-const BuildVersion = "5.8.0"
+const BuildVersion = "5.8.2"

{codecin-5.8.0 → codecin-5.8.2}/codecin/native/engine/vm.go

@@ -50,6 +50,7 @@ type vmState struct {
 	sp        uint64
 	pc        int
 	heapPtr   uint64
+	heapBase  uint64 // 堆起始 (heapPtr 初值; 报错信息用)
 	steps     uint64
 	flags     struct{ N, Z, C, V bool }
 	out       strings.Builder
@@ -199,15 +200,16 @@ func Run(bc []byte, mem []byte, entry, sp, heapBase int64, inData []byte,
 		ent = int(entry)
 	}
 	vm := &vmState{
-		prog:    prog,
-		entry:   ent,
-		mem:     mem,
-		sp:      uint64(sp),
-		pc:      ent,
-		heapPtr: uint64(heapBase),
-		rng:     rand.New(rand.NewSource(time.Now().UnixNano())),
-		inData:  inData,
-		args:    currentProgramArgs(),
+		prog:     prog,
+		entry:    ent,
+		mem:      mem,
+		sp:       uint64(sp),
+		pc:       ent,
+		heapPtr:  uint64(heapBase),
+		heapBase: uint64(heapBase),
+		rng:      rand.New(rand.NewSource(time.Now().UnixNano())),
+		inData:   inData,
+		args:     currentProgramArgs(),
 	}
 
 	// 键盘监听可能切换终端 raw mode, 任何出口都必须恢复 (幂等)
@@ -280,7 +282,7 @@ func opcodeSupported(op uint8) bool {
 }
 
 func syscallSupported(id uint64) bool {
-	return id <= sysAUDIOLEVEL
+	return id <= sysTIMENS
 }
 
 func (vm *vmState) reg(n int) uint64 {
@@ -342,7 +344,13 @@ func (vm *vmState) val(op operand) (uint64, bool) {
 
 func (vm *vmState) checkAddr(addr uint64, width int) string {
 	if uint64(len(vm.mem)) < uint64(width) || addr > uint64(len(vm.mem))-uint64(width) {
-		return "address " + strconv.FormatUint(addr, 16) + " out of bounds"
+		hint := ""
+		if addr >= 1<<63 {
+			// 按位模 2^64 后为负数: 典型成因是栈溢出 (SP 被推到负地址)
+			// 或野指针。可读性提示, 与 Python 侧 memory.py 文案一致。
+			hint = " (negative address: stack overflow or bad pointer?)"
+		}
+		return "Address 0x" + strconv.FormatUint(addr, 16) + " out of bounds" + hint
 	}
 	return ""
 }
@@ -976,7 +984,14 @@ func (vm *vmState) doSyscall(id uint64) string {
 		ptr := vm.heapPtr
 		vm.heapPtr += size
 		if vm.heapPtr > vm.sp {
-			return "Heap exhausted"
+			free := uint64(0)
+			if vm.sp > ptr {
+				free = vm.sp - ptr
+			}
+			// 文本与 Python 解释器 (cpu.py) 保持一致
+			return fmt.Sprintf("Heap exhausted: need %d bytes, free %d bytes "+
+				"(heap 0x%x..0x%x). Try --mem-size (default 65536) or "+
+				"reduce allocations", size, free, vm.heapBase, vm.sp)
 		}
 		vm.setReg(0, ptr)
 	case sysPRINTFLO:
@@ -1005,7 +1020,14 @@ func (vm *vmState) doSyscall(id uint64) string {
 		ptr := vm.heapPtr
 		vm.heapPtr += size
 		if vm.heapPtr > vm.sp {
-			return "Heap exhausted (string concat)"
+			free := uint64(0)
+			if vm.sp > ptr {
+				free = vm.sp - ptr
+			}
+			return fmt.Sprintf("Heap exhausted (string concat): need %d bytes, "+
+				"free %d bytes (heap 0x%x..0x%x). Try --mem-size "+
+				"(default 65536) or reduce allocations",
+				size, free, vm.heapBase, vm.sp)
 		}
 		if e := vm.checkAddr(ptr, len(data)); e != "" {
 			return e
@@ -1313,6 +1335,28 @@ func (vm *vmState) doSyscall(id uint64) string {
 		vm.setReg(0, vm.argAt(x0))
 	case sysREADLINE:
 		vm.setReg(0, vm.readLineStr())
+	// 核心 VM 机制 (非宿主能力, 与 Python 解释器 cpu.py 语义逐一致)
+	case sysALLOCFRAME:
+		fb := x0
+		guard := vm.heapPtr + 4096
+		// 有符号比较: SP 绕回 (负地址) 必须判溢出, 不能先取模再比大小
+		newSP := int64(vm.sp) - int64(fb)
+		if newSP < int64(guard) {
+			avail := int64(vm.sp) - int64(guard)
+			if avail < 0 {
+				avail = 0
+			}
+			return fmt.Sprintf("Stack overflow: frame needs %d bytes, stack "+
+				"headroom only %d bytes (SP 0x%x, guard 0x%x, memory %d "+
+				"bytes). Try --mem-size (default 65536) or smaller local "+
+				"arrays", fb, avail, vm.sp, guard, len(vm.mem))
+		}
+		vm.sp = uint64(newSP)
+		vm.setReg(0, vm.sp)
+	case sysTIMEUS:
+		vm.setReg(0, uint64(time.Now().UnixNano()/1000))
+	case sysTIMENS:
+		vm.setReg(0, uint64(time.Now().UnixNano()))
 	default:
 		return "Unknown SYS call id"
 	}
@@ -1326,7 +1370,14 @@ func (vm *vmState) heapDupString(s string) (uint64, string) {
 	ptr := vm.heapPtr
 	vm.heapPtr += size
 	if vm.heapPtr > vm.sp {
-		return 0, "Heap exhausted (string operation)"
+		free := uint64(0)
+		if vm.sp > ptr {
+			free = vm.sp - ptr
+		}
+		return 0, fmt.Sprintf("Heap exhausted (string operation): need %d "+
+			"bytes, free %d bytes (heap 0x%x..0x%x). Try --mem-size "+
+			"(default 65536) or reduce allocations",
+			size, free, vm.heapBase, vm.sp)
 	}
 	if e := vm.checkAddr(ptr, len(data)); e != "" {
 		return 0, e

{codecin-5.8.0 → codecin-5.8.2/codecin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecin
-Version: 5.8.0
+Version: 5.8.2
 Summary: Code CIN - 高级语言与运行时 (CIN/PL/ASM 工具链 + Go 原生 VM + ARM64/RISC-V/FP/Vector 指令集)
 Author: ByUsi Studio, 北啊呢
 License-Expression: MIT

{codecin-5.8.0 → codecin-5.8.2}/codecin.egg-info/SOURCES.txt

@@ -175,6 +175,7 @@ tests/test_gui.py
 tests/test_index_subscript_type.py
 tests/test_isa_dispatch.py
 tests/test_isa_single_source.py
+tests/test_issue_regress.py
 tests/test_keyboard.py
 tests/test_lib_bigint.py
 tests/test_lib_bitset.py

{codecin-5.8.0 → codecin-5.8.2}/examples/args_demo.cin

@@ -1,8 +1,8 @@
 // Code CIN 命令行参数与行输入演示 (SYS 129..131, 跨平台一致)
-// 运行: codecin examples/args_demo.cin -- alice 42
-//       codecin examples/args_demo.cin -- alice 42
-// 参数在 `--` 之后传给 CIN 程序; AOT 产物直接取进程 os.Args[1:]。
-// 另见 stdlib: gostd.cin 的 go_os_args_len() / go_os_args_get(i)。
+// 运行: codecin examples/args_demo.cin alice 42        (程序名后直传)
+//       codecin examples/args_demo.cin -- alice 42     (`--` 显式分隔, 兼容旧法)
+// 两种方式等价; 含 `--` 前缀形如选项的参数必须走 `--`。AOT 产物直接取进程
+// os.Args[1:]。另见 stdlib: gostd.cin 的 go_os_args_len() / go_os_args_get(i)。
 
 function main() -> int {
     int n = arg_count()