snapshot before regression test

.gitignore

@@ -0,0 +1,73 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# 编译输出
+*.exe
+*.out
+*.o
+*.obj
+*.a
+*.lib
+*.dll
+*.so
+
+# 调试文件
+*.p2c
+debug.txt
+*.ll
+
+# 备份文件
+* copy.py
+* copy.c
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# 测试输出
+test.exe
+test_split.exe
+
+# 排除独立仓库的目录
+ViperOS/
+zlib copy/
+
+# 磁盘镜像
+*.img
+*.vmdk
+*.7z
+*.fd
+
+# 日志文件
+*.log
+
+# 字体文件
+*.ttc
+*.ttf
+
+# VMware
+Undo/vmware/
+
+# Trae AI
+.trae/

.transpyc_cache/0019c939aae7f9f1.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/0019c939aae7f9f1.pyi

@@ -0,0 +1,14 @@
+"""
+Auto-generated Python stub file from mpooltest.py
+Module: mpooltest
+"""
+
+
+import t, c
+from t import CInt, CPtr, CChar
+import viperlib
+import viperio
+import stdlib
+import memhub
+
+def mpool_main() -> CInt: pass

.transpyc_cache/001c1416e7a7dc50.doc.json

@@ -0,0 +1 @@
+{"_register_cexport_from_funcdef": "预注册 CExport/State 函数到全局表（仅注册，不生成 IR）", "translate_children": "遍历 tree.children 并翻译每个子节点\n\n    Args:\n        trans: 翻译器（含所有共享状态）\n        tree: AST 模块节点\n\n    Returns:\n        t.CInt: 新增的变量数\n    ", "handle_module_level_var": "处理模块级变量声明，创建全局变量", "create_wrapper_main": "创建包装 main 函数并翻译所有顶层语句\n\n    Args:\n        trans: 翻译器（含所有共享状态）\n        tree: AST 模块节点\n        i32_ty: i32 LLVMType\n\n    Returns:\n        t.CInt: 新增的变量数\n    "}

.transpyc_cache/001c1416e7a7dc50.pyi

@@ -0,0 +1,31 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesMain.py
+Module: lib.core.Handles.HandlesMain
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import viperlib
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesBody as HandlesBody
+import lib.core.Handles.HandlesFunctions as HandlesFunctions
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+import lib.core.Handles.HandlesAnnAssign as HandlesAnnAssign
+
+def _register_cexport_from_funcdef(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_children(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr) -> int: pass
+
+def handle_module_level_var(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def create_wrapper_main(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr, i32_ty: llvmlite.LLVMType | t.CPtr) -> int: pass

.transpyc_cache/0029db369f740dd9.doc.json

@@ -0,0 +1 @@
+{"_register_cexport_from_funcdef": "预注册 CExport/State 函数到全局表（仅注册，不生成 IR）", "translate_children": "遍历 tree.children 并翻译每个子节点\n\n    Args:\n        trans: 翻译器（含所有共享状态）\n        tree: AST 模块节点\n\n    Returns:\n        t.CInt: 新增的变量数\n    ", "handle_module_level_var": "处理模块级变量声明，创建全局变量", "create_wrapper_main": "创建包装 main 函数并翻译所有顶层语句\n\n    Args:\n        trans: 翻译器（含所有共享状态）\n        tree: AST 模块节点\n        i32_ty: i32 LLVMType\n\n    Returns:\n        t.CInt: 新增的变量数\n    "}

.transpyc_cache/0029db369f740dd9.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesMain.py
+Module: lib.core.Handles.HandlesMain
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import viperlib
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesBody as HandlesBody
+import lib.core.Handles.HandlesFunctions as HandlesFunctions
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+def _register_cexport_from_funcdef(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_children(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr) -> int: pass
+
+def handle_module_level_var(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def create_wrapper_main(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr, i32_ty: llvmlite.LLVMType | t.CPtr) -> int: pass

.transpyc_cache/0035c95a18d4f8e8.pyi

@@ -0,0 +1,81 @@
+"""
+Auto-generated Python stub file from w32.fileio.py
+Module: w32.fileio
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import w32.win32base
+import w32.win32file
+
+class MODE(t.CEnum):
+    R = 0
+    W = 1
+    A = 2
+    RP = 3
+    WP = 4
+    AP = 5
+    X = 6
+    XP = 7
+class FRESULT(t.CEnum):
+    OK = 0
+    ERR = -1
+    ERR_CLOSED = -2
+    ERR_PERM = -3
+    ERR_IO = -4
+    ERR_NOTFOUND = -5
+
+SEEK_SET: t.CDefine = 0
+SEEK_CUR: t.CDefine = 1
+SEEK_END: t.CDefine = 2
+INVALID_SET_FILE_POINTER: t.CDefine = -1
+SHARE_READ: t.CDefine = 0x00000001
+SHARE_WRITE: t.CDefine = 0x00000002
+SHARE_DELETE: t.CDefine = 0x00000004
+
+class File:
+    handle: w32.win32base.HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: File, filename: str, mode: ULONG, share: ULONG) -> t.CInt: pass
+    def __enter__(self: File) -> 'File' | t.CPtr: pass
+    def __exit__(self: File) -> t.CInt: pass
+    def read(self: File, buf: bytes, count: ULONG) -> LONG: pass
+    def write(self: File, buf: bytes, count: ULONG) -> LONG: pass
+    def write_str(self: File, s: str) -> LONG: pass
+    def seek(self: File, offset: LONG, origin: ULONG) -> LONG: pass
+    def tell(self: File) -> LONG: pass
+    def close(self: File) -> LONG: pass
+    def flush(self: File) -> LONG: pass
+    def size(self: File) -> LONGLONG: pass
+    def readline(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
+    def read_all(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
+class FileW:
+    handle: w32.win32base.HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: FileW, filename: w32.win32base.LPCWSTR, mode: ULONG, share: ULONG) -> t.CInt: pass
+    def __enter__(self: FileW) -> 'FileW' | t.CPtr: pass
+    def __exit__(self: FileW) -> t.CInt: pass
+    def read(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
+    def write(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
+    def write_str(self: FileW, s: str) -> LONG: pass
+    def seek(self: FileW, offset: LONG, origin: ULONG) -> LONG: pass
+    def tell(self: FileW) -> LONG: pass
+    def close(self: FileW) -> LONG: pass
+    def flush(self: FileW) -> LONG: pass
+    def size(self: FileW) -> LONGLONG: pass
+    def readline(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
+    def read_all(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
+
+def open(filename: str, mode: ULONG, share: ULONG) -> File | t.CPtr: pass
+
+def openw(filename: LPCWSTR, mode: ULONG, share: ULONG) -> FileW | t.CPtr: pass

.transpyc_cache/02885f6f134079c2.doc.json

@@ -0,0 +1 @@
+{"VarEntry": "变量表条目", "Scope": "作用域节点", "SymbolTable": "嵌套作用域符号表", "init_vars": "分配并清零变量表数组", "find_var": "在变量表中按名称查找", "find_var_entry": "在变量表中按名称查找，返回 VarEntry 或 None", "lookup_var_entry": "从当前作用域逐级向上查找变量，返回 VarEntry 或 None", "set_var_annot_class_name": "设置变量的原始类型注解类名，返回 0=成功 / 1=失败", "add_var": "添加变量到变量表", "get_or_create_var": "查找或创建变量 alloca", "_create_scope": "创建并初始化作用域节点", "init_symbol_table": "创建并初始化符号表，包含模块级根作用域", "enter_scope": "进入新作用域，返回新创建的作用域", "exit_scope": "退出当前作用域，恢复到父作用域", "define_var": "在当前作用域定义变量，返回 0 成功", "define_module_var": "在模块作用域定义变量，返回 0 成功", "lookup_var": "从当前作用域逐级向上查找变量，返回 alloca 或 None", "lookup_current": "仅在当前作用域查找变量", "lookup_module_var": "在模块作用域查找变量", "get_or_create_sym": "查找或创建变量 alloca（在当前作用域）"}

.transpyc_cache/02885f6f134079c2.pyi

@@ -0,0 +1,68 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesVar.py
+Module: lib.core.Handles.HandlesVar
+"""
+
+
+import t, c
+from stdint import *
+import llvmlite
+import memhub
+import string
+
+SCOPE_MODULE: t.CDefine = 0
+SCOPE_FUNCTION: t.CDefine = 1
+SCOPE_BLOCK: t.CDefine = 2
+MAX_VARS: t.CDefine = 256
+
+@t.NoVTable
+class VarEntry:
+    Name: t.CChar | t.CPtr
+    Alloca: llvmlite.Value | t.CPtr
+    Used: t.CInt
+    AnnotClassName: t.CChar | t.CPtr
+@t.NoVTable
+class Scope:
+    Parent: Scope | t.CPtr
+    Vars: VarEntry | t.CPtr
+    VarCount: t.CInt
+    Kind: t.CInt
+@t.NoVTable
+class SymbolTable:
+    Pool: memhub.MemBuddy | t.CPtr
+    Root: Scope | t.CPtr
+    Current: Scope | t.CPtr
+
+def init_vars(pool: memhub.MemBuddy | t.CPtr) -> VarEntry | t.CPtr: pass
+
+def find_var(vars_ptr: VarEntry | t.CPtr, var_count: int, name: str) -> llvmlite.Value | t.CPtr: pass
+
+def find_var_entry(vars_ptr: VarEntry | t.CPtr, var_count: int, name: str) -> VarEntry | t.CPtr: pass
+
+def lookup_var_entry(symtab: SymbolTable | t.CPtr, name: str) -> VarEntry | t.CPtr: pass
+
+def set_var_annot_class_name(symtab: SymbolTable | t.CPtr, name: str, class_name: str) -> int: pass
+
+def add_var(vars_ptr: VarEntry | t.CPtr, var_count: int, name: str, alloca: llvmlite.Value | t.CPtr) -> int: pass
+
+def get_or_create_var(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, vars_ptr: VarEntry | t.CPtr, var_count: int, name: str, ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _create_scope(pool: memhub.MemBuddy | t.CPtr, parent: Scope | t.CPtr, kind: int) -> Scope | t.CPtr: pass
+
+def init_symbol_table(pool: memhub.MemBuddy | t.CPtr) -> SymbolTable | t.CPtr: pass
+
+def enter_scope(symtab: SymbolTable | t.CPtr, kind: int) -> Scope | t.CPtr: pass
+
+def exit_scope(symtab: SymbolTable | t.CPtr) -> t.CInt: pass
+
+def define_var(symtab: SymbolTable | t.CPtr, name: str, alloca: llvmlite.Value | t.CPtr) -> int: pass
+
+def define_module_var(symtab: SymbolTable | t.CPtr, name: str, alloca: llvmlite.Value | t.CPtr) -> int: pass
+
+def lookup_var(symtab: SymbolTable | t.CPtr, name: str) -> llvmlite.Value | t.CPtr: pass
+
+def lookup_current(symtab: SymbolTable | t.CPtr, name: str) -> llvmlite.Value | t.CPtr: pass
+
+def lookup_module_var(symtab: SymbolTable | t.CPtr, name: str) -> llvmlite.Value | t.CPtr: pass
+
+def get_or_create_sym(symtab: SymbolTable | t.CPtr, pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, name: str, ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass

.transpyc_cache/02d833b3cf571c5b.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/02d833b3cf571c5b.pyi

@@ -0,0 +1,18 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+from stdint import *
+import w32.win32console
+import t, c
+from t import CInt, CExport
+import stdio
+import stdlib
+import string
+import memhub
+import hashtable
+import testcheck
+
+def main() -> CInt | CExport: pass

.transpyc_cache/03b24bc1d9327958.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/03b24bc1d9327958.pyi

@@ -0,0 +1,21 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t
+import stdio
+import string
+import __zlib.pyzlib as pyzlib
+import __zlib.zdeflate as zdeflate
+import __zlib.zinflate as zinflate
+import __zlib.zchecksum as zchecksum
+import __zlib.zdef as zdef
+import __zlib.zhuff as zhuff
+import __zlib.test_pyzlib as tpz
+import w32.win32memory
+import c
+import testcheck
+
+def main() -> t.CInt: pass

.transpyc_cache/03eeb0bea44f6637.pyi

@@ -0,0 +1,171 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprCall.py
+Module: lib.core.Handles.HandlesExprCall
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import sys
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+_g_sha1_arr: t.CExtern | bytes
+_g_mod_arr: t.CExtern | bytes
+_g_sha1_count: t.CExtern | int
+
+def set_module_sha1_map(sha1_arr: bytes, mod_arr: bytes, count: int) -> int: pass
+
+def _lookup_module_sha1(mod_name: str) -> str: pass
+
+def _lookup_module_sha1_suffix(mod_suffix: str) -> str: pass
+
+
+_g_cexport_sha1_arr: t.CExtern | bytes
+_g_cexport_func_arr: t.CExtern | bytes
+_g_cexport_count: t.CExtern | int
+_CEXPORT_MAX: t.CDefine = 256
+
+def register_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def is_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr, from_imports: str, class_name: str) -> str: pass
+
+def find_func_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _emit_llvm_memcpy_intrinsic(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, dst_val: llvmlite.Value | t.CPtr, src_val: llvmlite.Value | t.CPtr, num_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_deref(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_derefas(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_addr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_load(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+ASM_MAX_OPERANDS: t.CDefine = 16
+ASM_TEXT_BUF_SIZE: t.CDefine = 2048
+ASM_CONST_BUF_SIZE: t.CDefine = 512
+ASM_ARGS_BUF_SIZE: t.CDefine = 512
+ASM_LINE_BUF_SIZE: t.CDefine = 4096
+
+@t.NoVTable
+class AsmOperand:
+    Value: llvmlite.Value | t.CPtr
+    Constraint: str
+    IsOutput: int
+
+def _asm_append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _asm_escape_for_ir(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _resolve_register(attr_name: str) -> str: pass
+
+def _resolve_asm_descr(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _asm_get_operand(base: AsmOperand | t.CPtr, idx: int) -> AsmOperand | t.CPtr: pass
+
+def _asm_is_c_call(node: ast.Call | t.CPtr) -> str: pass
+
+def _asm_add_operand(operands: AsmOperand | t.CPtr, count: int, val: llvmlite.Value | t.CPtr, constraint: str, is_output: int) -> int: pass
+
+def translate_c_asm(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+LLVMIR_MAX_OPS: t.CDefine = 16
+LLVMIR_TEMPLATE_BUF: t.CDefine = 512
+
+def _llvmir_get_op(buf: AsmOperand | t.CPtr, i: int) -> AsmOperand | t.CPtr: pass
+
+def _llvmir_find_op_marker(s: t.CChar | t.CPtr) -> t.CPtr: pass
+
+def _llvmir_parse_op_num(marker: t.CChar | t.CPtr) -> int: pass
+
+def _llvmir_match_icmp_pred(pred: str) -> int: pass
+
+def _llvmir_match_fcmp_pred(pred: str) -> int: pass
+
+def _llvmir_extract_two_ops(template: t.CChar | t.CPtr, out_nums: int | t.CPtr) -> int: pass
+
+def _llvmir_resolve_op(op_num: int, all_kinds: int | t.CPtr, all_indices: int | t.CPtr, input_ops: AsmOperand | t.CPtr, output_targets: AsmOperand | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _llvmir_store_outputs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, result: llvmlite.Value | t.CPtr, output_targets: AsmOperand | t.CPtr, output_count: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_llvmir(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _apply_struct_defaults(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, tmp: llvmlite.Value | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _do_virtual_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, args_head: llvmlite.Value | t.CPtr, args_count: int, found_func: llvmlite.Function | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, extra_args: t.CSizeT | t.CPtr, extra_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr, method_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _translate_method_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, obj_ptr: llvmlite.Value | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _kwarg_name_matches(kw_arg: str, param_name: t.CChar | t.CPtr) -> int: pass
+
+def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_call_with_kwargs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, func_name: str, found_func: llvmlite.Function | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_t_type_cast(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _extract_type_args_from_slice(pool: memhub.MemBuddy | t.CPtr, slice_node: ast.AST | t.CPtr) -> list[str] | t.CPtr: pass
+
+def translate_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_closure_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, closure_alloca: llvmlite.Value | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT) -> llvmlite.Value | t.CPtr: pass
+
+def translate_printf_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class FuncEntry:
+    Name: str
+    Func: llvmlite.Function | t.CPtr
+
+def init_func_table(pool: memhub.MemBuddy | t.CPtr, max_count: int) -> FuncEntry | t.CPtr: pass
+
+def find_func_in_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def add_func_to_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str, func: llvmlite.Function | t.CPtr, max_count: int) -> int: pass
+
+
+GLOBAL_FUNC_MAX: t.CDefine = 8192
+_global_funcs: t.CExtern | FuncEntry | t.CPtr
+_global_func_count: t.CExtern | int
+
+def _init_global_func_table() -> int: pass
+
+def _register_global_func(name: str, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def find_func_global(name: str) -> llvmlite.Function | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprCallHandle(HandlesBase.Mixin):
+    def __init__(self: ExprCallHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleCall(self: ExprCallHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+    def HandlePrintfCall(self: ExprCallHandle, cl: ast.Call | t.CPtr) -> t.CInt: pass
+
+def NewExprCallHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprCallHandle | t.CPtr: pass

.transpyc_cache/04673ecc3aec489e.pyi

@@ -0,0 +1,171 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprCall.py
+Module: lib.core.Handles.HandlesExprCall
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import sys
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+_g_sha1_arr: t.CExtern | bytes
+_g_mod_arr: t.CExtern | bytes
+_g_sha1_count: t.CExtern | int
+
+def set_module_sha1_map(sha1_arr: bytes, mod_arr: bytes, count: int) -> int: pass
+
+def _lookup_module_sha1(mod_name: str) -> str: pass
+
+def _lookup_module_sha1_suffix(mod_suffix: str) -> str: pass
+
+
+_g_cexport_sha1_arr: t.CExtern | bytes
+_g_cexport_func_arr: t.CExtern | bytes
+_g_cexport_count: t.CExtern | int
+_CEXPORT_MAX: t.CDefine = 256
+
+def register_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def is_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr, from_imports: str, class_name: str) -> str: pass
+
+def find_func_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _emit_llvm_memcpy_intrinsic(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, dst_val: llvmlite.Value | t.CPtr, src_val: llvmlite.Value | t.CPtr, num_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_deref(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_derefas(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_addr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_load(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+ASM_MAX_OPERANDS: t.CDefine = 16
+ASM_TEXT_BUF_SIZE: t.CDefine = 2048
+ASM_CONST_BUF_SIZE: t.CDefine = 512
+ASM_ARGS_BUF_SIZE: t.CDefine = 512
+ASM_LINE_BUF_SIZE: t.CDefine = 4096
+
+@t.NoVTable
+class AsmOperand:
+    Value: llvmlite.Value | t.CPtr
+    Constraint: str
+    IsOutput: int
+
+def _asm_append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _asm_escape_for_ir(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _resolve_register(attr_name: str) -> str: pass
+
+def _resolve_asm_descr(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _asm_get_operand(base: AsmOperand | t.CPtr, idx: int) -> AsmOperand | t.CPtr: pass
+
+def _asm_is_c_call(node: ast.Call | t.CPtr) -> str: pass
+
+def _asm_add_operand(operands: AsmOperand | t.CPtr, count: int, val: llvmlite.Value | t.CPtr, constraint: str, is_output: int) -> int: pass
+
+def translate_c_asm(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+LLVMIR_MAX_OPS: t.CDefine = 16
+LLVMIR_TEMPLATE_BUF: t.CDefine = 512
+
+def _llvmir_get_op(buf: AsmOperand | t.CPtr, i: int) -> AsmOperand | t.CPtr: pass
+
+def _llvmir_find_op_marker(s: t.CChar | t.CPtr) -> t.CPtr: pass
+
+def _llvmir_parse_op_num(marker: t.CChar | t.CPtr) -> int: pass
+
+def _llvmir_match_icmp_pred(pred: str) -> int: pass
+
+def _llvmir_match_fcmp_pred(pred: str) -> int: pass
+
+def _llvmir_extract_two_ops(template: t.CChar | t.CPtr, out_nums: int | t.CPtr) -> int: pass
+
+def _llvmir_resolve_op(op_num: int, all_kinds: int | t.CPtr, all_indices: int | t.CPtr, input_ops: AsmOperand | t.CPtr, output_targets: AsmOperand | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _llvmir_store_outputs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, result: llvmlite.Value | t.CPtr, output_targets: AsmOperand | t.CPtr, output_count: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_llvmir(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _apply_struct_defaults(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, tmp: llvmlite.Value | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _do_virtual_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, args_head: llvmlite.Value | t.CPtr, args_count: int, found_func: llvmlite.Function | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, extra_args: t.CSizeT | t.CPtr, extra_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr, method_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _translate_method_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, obj_ptr: llvmlite.Value | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _kwarg_name_matches(kw_arg: str, param_name: t.CChar | t.CPtr) -> int: pass
+
+def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_call_with_kwargs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, func_name: str, found_func: llvmlite.Function | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_t_type_cast(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _extract_type_args_from_slice(pool: memhub.MemBuddy | t.CPtr, slice_node: ast.AST | t.CPtr) -> list[str] | t.CPtr: pass
+
+def translate_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_closure_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, closure_alloca: llvmlite.Value | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT) -> llvmlite.Value | t.CPtr: pass
+
+def translate_printf_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class FuncEntry:
+    Name: str
+    Func: llvmlite.Function | t.CPtr
+
+def init_func_table(pool: memhub.MemBuddy | t.CPtr, max_count: int) -> FuncEntry | t.CPtr: pass
+
+def find_func_in_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def add_func_to_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str, func: llvmlite.Function | t.CPtr, max_count: int) -> int: pass
+
+
+GLOBAL_FUNC_MAX: t.CDefine = 8192
+_global_funcs: t.CExtern | FuncEntry | t.CPtr
+_global_func_count: t.CExtern | int
+
+def _init_global_func_table() -> int: pass
+
+def _register_global_func(name: str, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def find_func_global(name: str) -> llvmlite.Function | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprCallHandle(HandlesBase.Mixin):
+    def __init__(self: ExprCallHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleCall(self: ExprCallHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+    def HandlePrintfCall(self: ExprCallHandle, cl: ast.Call | t.CPtr) -> t.CInt: pass
+
+def NewExprCallHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprCallHandle | t.CPtr: pass

.transpyc_cache/05c11f22675c60cb.pyi

@@ -0,0 +1,50 @@
+"""
+Auto-generated Python stub file from llvmlite.__values.py
+Module: llvmlite.__values
+"""
+
+
+import t, c
+from stdint import *
+import string
+import viperlib
+import memhub
+from linkedlist import GSListNode
+from .__types import LLVMType, TypePrint
+
+class Value(GSListNode[Value]):
+    Ty: LLVMType | t.CPtr
+    Name: t.CChar | t.CPtr
+    IsConst: t.CInt
+    IntVal: t.CInt64T
+    FloatVal: t.CDouble
+
+VALUE_SIZE: t.CDefine = 48
+
+def new_value(pool: memhub.MemBuddy | t.CPtr) -> Value | t.CPtr: pass
+
+def ConstInt(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr, val: t.CInt64T, name: t.CChar | t.CPtr) -> Value | t.CPtr: pass
+
+def ConstNull(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Value | t.CPtr: pass
+
+def ConstZero(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def ConstFloat(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr, val: t.CDouble) -> Value | t.CPtr: pass
+
+def SSAValue(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Value | t.CPtr: pass
+
+def ValuePrint(buf: t.CChar | t.CPtr, size: t.CSizeT, val: Value | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def value_get_ty(val: Value | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def value_get_next(val: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def value_set_ty(val: Value | t.CPtr, ty: LLVMType | t.CPtr) -> t.CInt: pass
+
+def value_set_next(val: Value | t.CPtr, nxt: Value | t.CPtr) -> t.CInt: pass
+
+def value_set_name(val: Value | t.CPtr, name: t.CChar | t.CPtr) -> t.CInt: pass
+
+def value_set_isconst(val: Value | t.CPtr, is_const: t.CInt) -> t.CInt: pass
+
+def _append_str(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass

.transpyc_cache/05db996fc87ebdaa.doc.json

@@ -0,0 +1 @@
+{"_DiagAppend": "追加诊断信息到 diag.txt（追加模式，不依赖 printf 缓冲）", "TranslateFileGetTrans": "翻译文件，返回 Translator 对象（调用者负责 dump_ir），None 失败", "ensure_dir": "递归创建目录（类似 mkdir -p），目录已存在视为成功\n\n    Args:\n        path: 目录路径（支持 / 或 \\ 分隔符）\n\n    Returns:\n        0 成功（包括目录已存在），非 0 失败\n    ", "write_ir_to_file": "将 IR 缓冲区写入 .ll 文件\n\n    Args:\n        ir_buf: IR 文本缓冲区\n        ir_len: IR 文本长度\n        output_dir: 输出目录（temp 或 output）\n        module_name: 模块名（如 \"main\"）\n\n    Returns:\n        0 成功，非 0 失败\n    ", "compile_ll_to_obj": "调用 llc 将 .ll 编译为 .obj\n\n    Args:\n        ir_path: .ll 文件路径\n        output_dir: 输出目录\n        module_name: 模块名（用于生成 .obj 文件名）\n        cc_cmd: 编译器命令（如 \"llc\"）\n        cc_flags: 编译器参数（如 \"-filetype=obj -relocation-model=pic\"）\n\n    Returns:\n        0 成功，非 0 失败\n    ", "collect_obj_files": "扫描 includes_binary_dir 目录，收集所有 .obj 文件路径到 out_buf\n\n    Args:\n        includes_binary_dir: includes.binary 目录路径\n        out_buf: 输出缓冲区（用于存放空格分隔的 .obj 文件路径）\n        out_size: 输出缓冲区大小\n\n    Returns:\n        写入的字节数（不含 null 终止符），0 表示无文件或错误\n    ", "link_obj_to_exe": "调用 clang++ 链接 .obj 为 .exe\n\n    Args:\n        output_dir: 输出目录（包含 .obj 文件）\n        module_name: 模块名\n        linker_cmd: 链接器命令（如 \"clang++\"）\n        linker_flags: 链接器参数\n        linker_output: 输出文件名（如 \"test.exe\"）\n        includes_binary_dir: includes.binary 目录路径（链接时附加预编译 .obj）\n\n    Returns:\n        0 成功，非 0 失败\n    ", "compile_module_to_obj": "编译 IR 到 .obj（不链接）\n\n    Args:\n        ir_buf: LLVM IR 文本缓冲区\n        ir_len: IR 文本长度\n        temp_dir: 临时目录\n        output_dir: 输出目录\n        module_name: 模块名（SHA1）\n        cc_cmd: 编译器命令\n        cc_flags: 编译器参数\n\n    Returns:\n        0 成功，非 0 失败\n    ", "link_objs_to_exe": "链接多个 .obj 文件为 .exe\n\n    Args:\n        obj_paths: 空格分隔的 .obj 文件完整路径字符串\n        obj_paths_len: obj_paths 长度\n        linker_cmd: 链接器命令（如 \"clang++\"）\n        linker_flags: 链接器参数\n        linker_output: 输出文件完整路径\n        includes_binary_dir: includes.binary 目录路径（链接时附加预编译 .obj）\n\n    Returns:\n        0 成功，非 0 失败\n    ", "run_pipeline": "执行完整编译管线\n\n    Args:\n        ir_buf: LLVM IR 文本缓冲区\n        ir_len: IR 文本长度\n        temp_dir: 临时目录\n        output_dir: 输出目录\n        module_name: 模块名\n        cc_cmd: 编译器命令\n        cc_flags: 编译器参数\n        linker_cmd: 链接器命令\n        linker_flags: 链接器参数\n        linker_output: 输出文件名\n        includes_binary_dir: includes.binary 目录路径（链接时附加预编译 .obj）\n\n    Returns:\n        BuildResult 对象\n    "}

.transpyc_cache/05db996fc87ebdaa.pyi

@@ -0,0 +1,52 @@
+"""
+Auto-generated Python stub file from lib.core.BuildPipeline.py
+Module: lib.core.BuildPipeline
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import string
+import stdlib
+import memhub
+import w32.fileio as fileio
+import w32.win32file
+import w32.win32base
+import subprocess
+import viperlib
+import ast
+import lib.core.Handles.HandlesTranslator as HandlesTranslator
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesType as HandlesType
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+SRC_BUF_SIZE: t.CDefine = 1048576
+
+def _DiagAppend(msg: bytes) -> t.CInt: pass
+
+def TranslateFileGetTrans(mb: memhub.MemBuddy | t.CPtr, file_path: str, sha1_val: str) -> HandlesTranslator.Translator | t.CPtr: pass
+
+
+class BuildResult:
+    Success: t.CInt
+    OutputPath: str
+    ErrorMsg: str
+    def __new__(self: BuildResult) -> t.CPtr: pass
+    def __init__(self: BuildResult) -> t.CInt: pass
+
+def ensure_dir(path: str) -> int: pass
+
+def write_ir_to_file(ir_buf: bytes, ir_len: t.CSizeT, output_dir: str, module_name: str) -> int: pass
+
+def compile_ll_to_obj(ir_path: str, output_dir: str, module_name: str, cc_cmd: str, cc_flags: str) -> int: pass
+
+def collect_obj_files(includes_binary_dir: str, out_buf: bytes, out_size: t.CSizeT) -> t.CSizeT: pass
+
+def link_obj_to_exe(output_dir: str, module_name: str, linker_cmd: str, linker_flags: str, linker_output: str, includes_binary_dir: str) -> int: pass
+
+def compile_module_to_obj(ir_buf: bytes, ir_len: t.CSizeT, temp_dir: str, output_dir: str, module_name: str, cc_cmd: str, cc_flags: str) -> int: pass
+
+def link_objs_to_exe(obj_paths: str, obj_paths_len: t.CSizeT, linker_cmd: str, linker_flags: str, linker_output: str, includes_binary_dir: str) -> int: pass
+
+def run_pipeline(ir_buf: bytes, ir_len: t.CSizeT, temp_dir: str, output_dir: str, module_name: str, cc_cmd: str, cc_flags: str, linker_cmd: str, linker_flags: str, linker_output: str, includes_binary_dir: str) -> BuildResult | t.CPtr: pass

.transpyc_cache/067c78e9f121dce3.pyi

@@ -0,0 +1,136 @@
+"""
+Auto-generated Python stub file from w32.win32process.py
+Module: w32.win32process
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+PROCESS_TERMINATE: t.CDefine = 0x0001
+PROCESS_CREATE_THREAD: t.CDefine = 0x0002
+PROCESS_VM_OPERATION: t.CDefine = 0x0008
+PROCESS_VM_READ: t.CDefine = 0x0010
+PROCESS_VM_WRITE: t.CDefine = 0x0020
+PROCESS_QUERY_INFORMATION: t.CDefine = 0x0400
+PROCESS_ALL_ACCESS: t.CDefine = 0x001FFFFF
+THREAD_TERMINATE: t.CDefine = 0x0001
+THREAD_SUSPEND_RESUME: t.CDefine = 0x0002
+THREAD_GET_CONTEXT: t.CDefine = 0x0008
+THREAD_SET_CONTEXT: t.CDefine = 0x0010
+THREAD_QUERY_INFORMATION: t.CDefine = 0x0040
+THREAD_ALL_ACCESS: t.CDefine = 0x001FFFFF
+CREATE_SUSPENDED: t.CDefine = 0x00000004
+CREATE_NEW_CONSOLE: t.CDefine = 0x00000010
+CREATE_NEW_PROCESS_GROUP: t.CDefine = 0x00000200
+CREATE_NO_WINDOW: t.CDefine = 0x08000000
+DETACHED_PROCESS: t.CDefine = 0x00000008
+STARTF_USESHOWWINDOW: t.CDefine = 0x00000001
+STARTF_USESTDHANDLES: t.CDefine = 0x00000100
+SW_HIDE: t.CDefine = 0
+SW_SHOW: t.CDefine = 5
+SW_MINIMIZE: t.CDefine = 6
+NORMAL_PRIORITY_CLASS: t.CDefine = 0x00000020
+IDLE_PRIORITY_CLASS: t.CDefine = 0x00000040
+HIGH_PRIORITY_CLASS: t.CDefine = 0x00000080
+REALTIME_PRIORITY_CLASS: t.CDefine = 0x00000100
+BELOW_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00004000
+ABOVE_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00008000
+STILL_ACTIVE: t.CDefine = 259
+
+class STARTUPINFOA:
+    cb: ULONG
+    lpReserved: CHARPTR
+    lpDesktop: CHARPTR
+    lpTitle: CHARPTR
+    dwX: ULONG
+    dwY: ULONG
+    dwXSize: ULONG
+    dwYSize: ULONG
+    dwXCountChars: ULONG
+    dwYCountChars: ULONG
+    dwFillAttribute: ULONG
+    dwFlags: ULONG
+    wShowWindow: WORD
+    cbReserved2: WORD
+    lpReserved2: VOIDPTR
+    hStdInput: HANDLE
+    hStdOutput: HANDLE
+    hStdError: HANDLE
+class STARTUPINFOW:
+    cb: ULONG
+    lpReserved: WCHARPTR
+    lpDesktop: WCHARPTR
+    lpTitle: WCHARPTR
+    dwX: ULONG
+    dwY: ULONG
+    dwXSize: ULONG
+    dwYSize: ULONG
+    dwXCountChars: ULONG
+    dwYCountChars: ULONG
+    dwFillAttribute: ULONG
+    dwFlags: ULONG
+    wShowWindow: WORD
+    cbReserved2: WORD
+    lpReserved2: VOIDPTR
+    hStdInput: HANDLE
+    hStdOutput: HANDLE
+    hStdError: HANDLE
+class PROCESS_INFORMATION:
+    hProcess: HANDLE
+    hThread: HANDLE
+    dwProcessId: ULONG
+    dwThreadId: ULONG
+
+def CreateProcessA(lpApplicationName: LPCSTR, lpCommandLine: CHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCSTR, lpStartupInfo: STARTUPINFOA | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def CreateProcessW(lpApplicationName: LPCWSTR, lpCommandLine: WCHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCWSTR, lpStartupInfo: STARTUPINFOW | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL | t.State: pass
+
+def GetExitCodeProcess(hProcess: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def GetExitCodeThread(hThread: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def OpenProcess(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwProcessId: ULONG) -> HANDLE | t.State: pass
+
+def GetCurrentProcess() -> HANDLE | t.State: pass
+
+def GetCurrentProcessId() -> ULONG | t.State: pass
+
+def CreateThread(lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwStackSize: t.CSizeT, lpStartAddress: VOIDPTR, lpParameter: VOIDPTR, dwCreationFlags: ULONG, lpThreadId: ULONG | t.CPtr) -> HANDLE | t.State: pass
+
+def OpenThread(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwThreadId: ULONG) -> HANDLE | t.State: pass
+
+def SuspendThread(hThread: HANDLE) -> ULONG | t.State: pass
+
+def ResumeThread(hThread: HANDLE) -> ULONG | t.State: pass
+
+def TerminateThread(hThread: HANDLE, dwExitCode: ULONG) -> BOOL | t.State: pass
+
+def GetCurrentThread() -> HANDLE | t.State: pass
+
+def GetCurrentThreadId() -> ULONG | t.State: pass
+
+def GetThreadId(hThread: HANDLE) -> ULONG | t.State: pass
+
+def GetProcessId(hProcess: HANDLE) -> ULONG | t.State: pass
+
+def SetThreadPriority(hThread: HANDLE, nPriority: INT) -> BOOL | t.State: pass
+
+def GetThreadPriority(hThread: HANDLE) -> INT | t.State: pass
+
+def ExitProcess(uExitCode: UINT) -> VOID | t.State: pass
+
+def ExitThread(dwExitCode: ULONG) -> VOID | t.State: pass
+
+def TlsAlloc() -> ULONG | t.State: pass
+
+def TlsFree(dwTlsIndex: ULONG) -> BOOL | t.State: pass
+
+def TlsGetValue(dwTlsIndex: ULONG) -> VOIDPTR | t.State: pass
+
+def TlsSetValue(dwTlsIndex: ULONG, lpTlsValue: VOIDPTR) -> BOOL | t.State: pass

.transpyc_cache/067f811511854c88.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/067f811511854c88.pyi

@@ -0,0 +1,48 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+import c
+
+
+import t
+import stdio
+import testcheck
+
+def add(a: t.CInt, b: t.CInt) -> t.CInt: pass
+
+def sub(a: t.CInt, b: t.CInt) -> t.CInt: pass
+
+def multi_args(a: t.CInt, b: t.CInt, c: t.CInt, d: t.CInt) -> t.CInt: pass
+
+def factorial(n: t.CInt) -> t.CInt: pass
+
+def fib(n: t.CInt) -> t.CInt: pass
+
+def add_via_ptr(p: t.CInt | t.CPtr, val: t.CInt) -> t.CInt: pass
+
+def make_u64() -> t.CUInt64T: pass
+
+def is_even(n: t.CInt) -> t.CBool: pass
+
+def test_basic_call() -> t.CInt: pass
+
+def test_multi_args() -> t.CInt: pass
+
+def test_recursion() -> t.CInt: pass
+
+def test_fibonacci() -> t.CInt: pass
+
+def test_ptr_param() -> t.CInt: pass
+
+def test_u64_return() -> t.CInt: pass
+
+def test_bool_return() -> t.CInt: pass
+
+def test_nested_call() -> t.CInt: pass
+
+
+import w32.win32memory
+
+def main() -> t.CInt: pass

.transpyc_cache/06f53cc594b4ac6c.pyi

@@ -0,0 +1,109 @@
+"""
+Auto-generated Python stub file from w32.win32sync.py
+Module: w32.win32sync
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+class CRITICAL_SECTION:
+    DebugInfo: VOIDPTR
+    LockCount: LONG
+    RecursionCount: LONG
+    OwningThread: HANDLE
+    LockSemaphore: HANDLE
+    SpinCount: QWORD
+
+def InitializeCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def EnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def LeaveCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def DeleteCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def TryEnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> BOOL | t.State: pass
+
+def SetCriticalSectionSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> ULONG | t.State: pass
+
+def InitializeCriticalSectionAndSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> BOOL | t.State: pass
+
+def CreateMutexA(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateMutexW(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenMutexA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenMutexW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def ReleaseMutex(hMutex: HANDLE) -> BOOL | t.State: pass
+
+def CreateEventA(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateEventW(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenEventA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenEventW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def SetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def ResetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def PulseEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def CreateSemaphoreA(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateSemaphoreW(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenSemaphoreA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenSemaphoreW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def ReleaseSemaphore(hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LONG | t.CPtr) -> BOOL | t.State: pass
+
+def WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: ULONG) -> ULONG | t.State: pass
+
+def WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def WaitForMultipleObjects(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG) -> ULONG | t.State: pass
+
+def WaitForMultipleObjectsEx(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def InitializeSRWLock(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def AcquireSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def AcquireSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def ReleaseSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def ReleaseSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+
+CONDITION_VARIABLE_LOCKMODE_SHARED: t.CDefine = 0x1
+
+def InitializeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
+
+def SleepConditionVariableCS(ConditionVariable: VOIDPTR, CriticalSection: CRITICAL_SECTION | t.CPtr, dwMilliseconds: ULONG) -> BOOL | t.State: pass
+
+def SleepConditionVariableSRW(ConditionVariable: VOIDPTR, SRWLock: VOIDPTR, dwMilliseconds: ULONG, Flags: ULONG) -> BOOL | t.State: pass
+
+def WakeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
+
+def WakeAllConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
+
+
+INIT_ONCE_STATIC_INIT: t.CDefine = 0x00000001
+INIT_ONCE_CHECK_ONLY:  t.CDefine = 0x00000002
+INIT_ONCE_ASYNC:       t.CDefine = 0x00000004
+INIT_ONCE_INIT_FAILED: t.CDefine = 0x00000008
+
+class INIT_ONCE:
+    Ptr: t.CPtr
+
+def InitOnceExecuteOnce(InitOnce: INIT_ONCE | t.CPtr, InitFn: VOIDPTR, Parameter: VOIDPTR, Context: VOIDPTR | t.CPtr) -> BOOL | t.State: pass

.transpyc_cache/07a8c82a8ca2be90.doc.json

@@ -0,0 +1 @@
+{"_binop_to_dunder": "将 BinOp 运算符映射到 dunder 方法名，无映射时返回 None", "_cmpop_to_dunder": "将 Compare 运算符映射到 dunder 方法名，无映射时返回 None", "try_operator_overload": "尝试运算符重载：lhs 是结构体指针时调用 dunder 方法，否则返回 None", "translate_binop": "翻译二元运算（自动类型提升）"}

.transpyc_cache/07a8c82a8ca2be90.pyi

@@ -0,0 +1,24 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprOps.py
+Module: lib.core.Handles.HandlesExprOps
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import viperlib
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesTranslator as HT
+
+def _binop_to_dunder(op: int) -> str: pass
+
+def _cmpop_to_dunder(op: int) -> str: pass
+
+def try_operator_overload(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, lhs: llvmlite.Value | t.CPtr, rhs: llvmlite.Value | t.CPtr, op: int, trans: HT.Translator | t.CPtr, is_compare: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_binop(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass

.transpyc_cache/07f7da85af876124.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/07f7da85af876124.pyi

@@ -0,0 +1,10 @@
+"""
+Auto-generated Python stub file from ptr_test.py
+Module: ptr_test
+"""
+
+
+import stdio
+import t, c
+
+def ptr_test() -> int: pass

.transpyc_cache/0853acdbdfc9b27c.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/0853acdbdfc9b27c.pyi

@@ -0,0 +1,22 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+from stdint import *
+import t, c
+from t import CInt, CExport
+from stdio import printf
+import memhub
+import stdlib
+import sys
+import string
+import ast
+import w32.win32console
+
+ARENA_SIZE: t.CDefine = 1048576
+POOL_SIZE: t.CDefine = 524288
+DUMP_SIZE: t.CDefine = 262144
+
+def main() -> CInt | CExport: pass

.transpyc_cache/08ea5281873244fd.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/08ea5281873244fd.pyi

@@ -0,0 +1,19 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import stdlib
+import string
+import memhub
+import argparse
+import testcheck
+
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
+
+@t.CExport
+def main() -> int: pass

.transpyc_cache/08f96e9e0bc0501b.doc.json

@@ -0,0 +1 @@
+{"add_imported_module": "记录已导入的模块名，返回新的 imported_modules 字符串指针", "is_module_imported": "检查模块是否已导入（词边界精确匹配，避免子串误匹配）", "add_from_import": "添加 from-import 映射 \"name:module\"，返回新的 from_imports 字符串", "lookup_from_import": "查找 from-import 名称，返回模块名或 None\n\n    支持 star import: 如果 from_imports 中有 \"*:module\" 条目，\n    且未找到精确名称匹配，且 allow_star_fallback != 0，则返回 star import 的模块名。\n    ", "ImportsHandle": "导入语句处理器：继承 Mixin 获得 Trans 回指针", "ImportsHandle.HandleImport": "处理 import 语句，返回 0", "ImportsHandle.HandleImportFromModule": "处理 from X import Y 的模块部分，更新 trans._imported_modules", "ImportsHandle.HandleImportFromNames": "处理 from X import Y 的名称部分，更新 trans._from_imports"}

.transpyc_cache/08f96e9e0bc0501b.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesImports.py
+Module: lib.core.Handles.HandlesImports
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import memhub
+import string
+import viperlib
+import stdio
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesStruct as HandlesStruct
+
+def add_imported_module(pool: memhub.MemBuddy | t.CPtr, imported_modules: str, name: str) -> str: pass
+
+def is_module_imported(imported_modules: str, name: str) -> int: pass
+
+def add_from_import(pool: memhub.MemBuddy | t.CPtr, from_imports: str, local_name: str, module_name: str) -> str: pass
+
+def lookup_from_import(from_imports: str, name: str, allow_star_fallback: int) -> str: pass
+
+
+@t.NoVTable
+class ImportsHandle(HandlesBase.Mixin):
+    def __init__(self: ImportsHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleImport(self: ImportsHandle, node: ast.AST | t.CPtr) -> int: pass
+    def HandleImportFromModule(self: ImportsHandle, node: ast.AST | t.CPtr) -> int: pass
+    def HandleImportFromNames(self: ImportsHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewImportsHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ImportsHandle | t.CPtr: pass

.transpyc_cache/0900c165e9bcb8f1.pyi

@@ -0,0 +1,173 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprCall.py
+Module: lib.core.Handles.HandlesExprCall
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import sys
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+_g_sha1_arr: t.CExtern | bytes
+_g_mod_arr: t.CExtern | bytes
+_g_sha1_count: t.CExtern | int
+
+def set_module_sha1_map(sha1_arr: bytes, mod_arr: bytes, count: int) -> int: pass
+
+def _lookup_module_sha1(mod_name: str) -> str: pass
+
+def _lookup_module_sha1_suffix(mod_suffix: str) -> str: pass
+
+
+_g_cexport_sha1_arr: t.CExtern | bytes
+_g_cexport_func_arr: t.CExtern | bytes
+_g_cexport_count: t.CExtern | int
+_CEXPORT_MAX: t.CDefine = 256
+
+def register_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def is_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr, from_imports: str, class_name: str) -> str: pass
+
+def find_func_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _get_external_func_param_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str, param_idx: int) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _emit_llvm_memcpy_intrinsic(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, dst_val: llvmlite.Value | t.CPtr, src_val: llvmlite.Value | t.CPtr, num_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_deref(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_derefas(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_addr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_load(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+ASM_MAX_OPERANDS: t.CDefine = 16
+ASM_TEXT_BUF_SIZE: t.CDefine = 2048
+ASM_CONST_BUF_SIZE: t.CDefine = 512
+ASM_ARGS_BUF_SIZE: t.CDefine = 512
+ASM_LINE_BUF_SIZE: t.CDefine = 4096
+
+@t.NoVTable
+class AsmOperand:
+    Value: llvmlite.Value | t.CPtr
+    Constraint: str
+    IsOutput: int
+
+def _asm_append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _asm_escape_for_ir(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _resolve_register(attr_name: str) -> str: pass
+
+def _resolve_asm_descr(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _asm_get_operand(base: AsmOperand | t.CPtr, idx: int) -> AsmOperand | t.CPtr: pass
+
+def _asm_is_c_call(node: ast.Call | t.CPtr) -> str: pass
+
+def _asm_add_operand(operands: AsmOperand | t.CPtr, count: int, val: llvmlite.Value | t.CPtr, constraint: str, is_output: int) -> int: pass
+
+def translate_c_asm(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+LLVMIR_MAX_OPS: t.CDefine = 16
+LLVMIR_TEMPLATE_BUF: t.CDefine = 512
+
+def _llvmir_get_op(buf: AsmOperand | t.CPtr, i: int) -> AsmOperand | t.CPtr: pass
+
+def _llvmir_find_op_marker(s: t.CChar | t.CPtr) -> t.CPtr: pass
+
+def _llvmir_parse_op_num(marker: t.CChar | t.CPtr) -> int: pass
+
+def _llvmir_match_icmp_pred(pred: str) -> int: pass
+
+def _llvmir_match_fcmp_pred(pred: str) -> int: pass
+
+def _llvmir_extract_two_ops(template: t.CChar | t.CPtr, out_nums: int | t.CPtr) -> int: pass
+
+def _llvmir_resolve_op(op_num: int, all_kinds: int | t.CPtr, all_indices: int | t.CPtr, input_ops: AsmOperand | t.CPtr, output_targets: AsmOperand | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _llvmir_store_outputs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, result: llvmlite.Value | t.CPtr, output_targets: AsmOperand | t.CPtr, output_count: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_llvmir(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _apply_struct_defaults(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, tmp: llvmlite.Value | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _do_virtual_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, args_head: llvmlite.Value | t.CPtr, args_count: int, found_func: llvmlite.Function | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, extra_args: t.CSizeT | t.CPtr, extra_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr, method_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _translate_method_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, obj_ptr: llvmlite.Value | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _kwarg_name_matches(kw_arg: str, param_name: t.CChar | t.CPtr) -> int: pass
+
+def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_call_with_kwargs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, func_name: str, found_func: llvmlite.Function | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_t_type_cast(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _extract_type_args_from_slice(pool: memhub.MemBuddy | t.CPtr, slice_node: ast.AST | t.CPtr) -> list[str] | t.CPtr: pass
+
+def translate_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_closure_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, closure_alloca: llvmlite.Value | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT) -> llvmlite.Value | t.CPtr: pass
+
+def translate_printf_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class FuncEntry:
+    Name: str
+    Func: llvmlite.Function | t.CPtr
+
+def init_func_table(pool: memhub.MemBuddy | t.CPtr, max_count: int) -> FuncEntry | t.CPtr: pass
+
+def find_func_in_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def add_func_to_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str, func: llvmlite.Function | t.CPtr, max_count: int) -> int: pass
+
+
+GLOBAL_FUNC_MAX: t.CDefine = 8192
+_global_funcs: t.CExtern | FuncEntry | t.CPtr
+_global_func_count: t.CExtern | int
+
+def _init_global_func_table() -> int: pass
+
+def _register_global_func(name: str, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def find_func_global(name: str) -> llvmlite.Function | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprCallHandle(HandlesBase.Mixin):
+    def __init__(self: ExprCallHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleCall(self: ExprCallHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+    def HandlePrintfCall(self: ExprCallHandle, cl: ast.Call | t.CPtr) -> t.CInt: pass
+
+def NewExprCallHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprCallHandle | t.CPtr: pass

.transpyc_cache/0b82fcb0aa3212c5.doc.json

@@ -0,0 +1 @@
+{"RunPhase1": "Phase1: 扫描 includes 目录，按需翻译并生成 stub"}

.transpyc_cache/0b82fcb0aa3212c5.pyi

@@ -0,0 +1,31 @@
+"""
+Auto-generated Python stub file from lib.core.Phase1.py
+Module: lib.core.Phase1
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import string
+import stdlib
+import memhub
+import viperlib
+import w32.fileio as fileio
+import w32.win32file
+import w32.win32base
+import ast
+import llvmlite
+import lib.core.VLogger as VLogger
+import lib.core.Handles.HandlesTranslator as HandlesTranslator
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.IncludesScanner as IncludesScanner
+import lib.core.StubMerger as StubMerger
+import lib.Projectrans.Config as Config
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+SRC_BUF_SIZE: t.CDefine = 1048576
+
+def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str, log: VLogger.Logger | t.CPtr) -> int: pass

.transpyc_cache/0c212981c180e7fb.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from ast.lexer.py
+Module: ast.lexer
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from .tokens import Token, TokenType, TokOp, _init_tables, _kw_lookup, _op_head, OpEntry, new_token, token_set_str, token_set_str_literal
+
+LEXER_MAX_INDENT: t.CDefine = 256
+
+class Lexer:
+    src: str
+    pos: t.CSizeT
+    len: t.CSizeT
+    lineno: t.CInt
+    col: t.CInt
+    pool: memhub.MemManager | t.CPtr
+    indent_stack: t.CInt | t.CPtr
+    indent_top: t.CInt
+    paren_depth: t.CInt
+    tokens_head: Token | t.CPtr
+    tokens_tail: Token | t.CPtr
+    at_line_start: t.CInt
+    error_count: t.CInt
+    def __new__(self: Lexer, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+def new_lexer(pool: memhub.MemManager | t.CPtr) -> Lexer | t.CPtr: pass
+
+def _lexer_init(lx: Lexer | t.CPtr, src: str, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+def _peek(lx: Lexer | t.CPtr, offset: t.CSizeT) -> t.CChar: pass
+
+def _peek_cur(lx: Lexer | t.CPtr) -> t.CChar: pass
+
+def _advance(lx: Lexer | t.CPtr) -> t.CChar: pass
+
+def _is_alpha(ch: t.CChar) -> t.CInt: pass
+
+def _is_digit(ch: t.CChar) -> t.CInt: pass
+
+def _is_alnum(ch: t.CChar) -> t.CInt: pass
+
+def _is_hex(ch: t.CChar) -> t.CInt: pass
+
+def _is_space(ch: t.CChar) -> t.CInt: pass
+
+def _emit(lx: Lexer | t.CPtr, tok: Token | t.CPtr) -> t.CInt: pass
+
+def _make_op_token(lx: Lexer | t.CPtr, op_id: t.CInt, length: t.CInt, lineno: t.CInt, col: t.CInt) -> Token | t.CPtr: pass
+
+def _handle_indent(lx: Lexer | t.CPtr) -> t.CInt: pass
+
+def _read_name(lx: Lexer | t.CPtr) -> t.CInt: pass
+
+def _read_number(lx: Lexer | t.CPtr) -> t.CInt: pass
+
+def _emit_number(lx: Lexer | t.CPtr, start: t.CSizeT, start_lineno: t.CInt, start_col: t.CInt, is_float: t.CInt, is_complex: t.CInt, is_hex: t.CInt) -> t.CInt: pass
+
+def _read_string(lx: Lexer | t.CPtr) -> t.CInt: pass
+
+def _read_operator(lx: Lexer | t.CPtr) -> t.CInt: pass
+
+def tokenize(lx: Lexer | t.CPtr) -> Token | t.CPtr: pass

.transpyc_cache/0c56128647a0b845.doc.json

@@ -0,0 +1 @@
+{"register_cdefine_constant": "注册 CDefine 编译期常量到全局表", "lookup_cdefine_constant": "查找 CDefine 编译期常量，返回值或 -1（未找到）", "clear_cdefine_constants": "清空 CDefine 常量表（模块切换时调用）", "set_generic_context": "设置泛型特化上下文（进入泛型类方法体翻译时调用）", "clear_generic_context": "清除泛型特化上下文（离开泛型类方法体翻译时调用）", "resolve_generic_type_name": "如果 name 是泛型类型参数，返回对应的具体类型名；否则返回 name 本身\n\n    用于表达式中的 T 替换（如 T.__sizeof__() → int.__sizeof__()）\n    ", "_get_type_name_from_annotation": "从类型注解节点提取类型名（支持 Name/Attribute/BinOp）", "_parse_type_string": "将类型名字符串解析为 AST 节点", "set_current_file": "设置当前编译的文件名（供报错使用）", "_read_source_line": "从源文件读取第 lineno 行内容", "fatal_error": "以 Python 风格报错并退出（带源代码行）", "fatal_type_error": "以 Python 风格报错并退出（fatal_error 的别名）", "map_t_type": "将 t.CXxx / c.CXxx 类型名映射到 LLVMType\n\n    注意: t.CChar | t.CPtr = i8* = str = bytes\n    ", "_is_t_attr": "检测节点是否是 t.attr_name 形式", "extract_class_name_from_annotation": "从类型注解 AST 中提取类名，返回 None=无法提取", "resolve_annotation_type": "解析类型注解节点为 LLVMType\n\n    Args:\n        pool: 内存分配器\n        node: 类型注解 AST 节点（Name 或 Attribute）\n        imported_modules: 已导入模块名字符串（空格分隔）\n        from_imports: from-import 映射字符串（\"name:module name:module\" 格式）\n    ", "has_decorator_marker": "检测类型注解中是否包含指定的装饰器标记", "is_pass_body": "检测函数体是否为 pass（空体或仅含 pass 语句）", "get_llvm_type_bits": "获取 LLVM 整数类型的位宽，非整数类型返回 0", "infer_expr_type": "推断表达式的 LLVM 类型\n\n    param_types 格式: \"name:bits,name:bits,...\"\n    ", "infer_return_type": "扫描函数体中的 return 语句，推断返回类型", "build_param_types_str": "构建参数类型编码字符串 \"name:bits,name:bits,...\" ", "_strappend": "将 src 追加到 dst 末尾"}

.transpyc_cache/0c56128647a0b845.pyi

@@ -0,0 +1,74 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesType.py
+Module: lib.core.Handles.HandlesType
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import sys
+import stdlib
+import viperlib
+import w32.fileio as fileio
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesStruct as HandlesStruct
+
+_g_current_file: t.CExtern | str
+_g_generic_tp_names: t.CExtern | list[str] | t.CPtr
+_g_generic_type_args: t.CExtern | list[str] | t.CPtr
+_g_cdefine_names: t.CExtern | list[str] | t.CPtr
+_g_cdefine_values: t.CExtern | list[str] | t.CPtr
+
+def register_cdefine_constant(pool: memhub.MemBuddy | t.CPtr, name: str, value: int) -> None: pass
+
+def lookup_cdefine_constant(name: str) -> int: pass
+
+def clear_cdefine_constants() -> None: pass
+
+def set_generic_context(tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> t.CInt: pass
+
+def clear_generic_context() -> t.CInt: pass
+
+def resolve_generic_type_name(name: str) -> str: pass
+
+def _get_type_name_from_annotation(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _parse_type_string(pool: memhub.MemBuddy | t.CPtr, type_str: str, ctx: t.CInt) -> ast.AST | t.CPtr: pass
+
+def set_current_file(file_path: str) -> t.CInt: pass
+
+
+_SRC_BUF_SIZE: t.CDefine = 262144
+
+def _read_source_line(file_path: str, lineno: int) -> str: pass
+
+def fatal_error(node: ast.AST | t.CPtr, msg: str) -> t.CInt: pass
+
+def fatal_type_error(node: ast.AST | t.CPtr, msg: str) -> t.CInt: pass
+
+def map_t_type(pool: memhub.MemBuddy | t.CPtr, type_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _is_t_attr(node: ast.AST | t.CPtr, attr_name: str, imported_modules: str) -> int: pass
+
+def extract_class_name_from_annotation(node: ast.AST | t.CPtr, imported_modules: str) -> str: pass
+
+def resolve_annotation_type(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, imported_modules: str, from_imports: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def has_decorator_marker(node: ast.AST | t.CPtr, marker_name: str) -> int: pass
+
+def is_pass_body(body: list[ast.AST | t.CPtr] | t.CPtr) -> int: pass
+
+def get_llvm_type_bits(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def infer_expr_type(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, param_types: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def infer_return_type(pool: memhub.MemBuddy | t.CPtr, body: list[ast.AST | t.CPtr] | t.CPtr, param_types: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def build_param_types_str(pool: memhub.MemBuddy | t.CPtr, args_node: ast.AST | t.CPtr) -> str: pass
+
+def _strappend(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass

.transpyc_cache/0df65b8ed15664b0.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from hashlib.__sha1.py
+Module: hashlib.__sha1
+"""
+
+
+import string
+import t, c
+
+SHA1_BLOCK_LEN:  t.CDefine = 64
+SHA1_DIGEST_LEN: t.CDefine = 20
+
+def sha1_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
+
+def sha1_f1(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+def sha1_f2(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+def sha1_f3(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+
+@t.Object
+class sha1:
+    state: t.CArray[t.CUInt32T, 5]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA1_BLOCK_LEN]
+    def __init__(self: sha1) -> t.CInt: pass
+    def transform(self: sha1, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha1, s: str) -> t.CInt: pass
+    def final(self: sha1, out: t.CArray[t.CUInt8T, SHA1_DIGEST_LEN]) -> t.CInt: pass

.transpyc_cache/0e1189314c937ef1.doc.json

@@ -0,0 +1 @@
+{"AnnAssignHandle": "AnnAssign 语句处理器：继承 Mixin 获得 Trans 回指针", "AnnAssignHandle._is_cdefine_annotation": "检测注解是否为 t.CDefine，返回 1 表示是，0 表示否", "AnnAssignHandle._extract_cdefine_int_value": "从值节点提取整数常量（仅支持 Constant INT）", "AnnAssignHandle.PreScan": "预扫描 AnnAssign，提前创建 alloca 到 entry block 顶部", "AnnAssignHandle.Handle": "翻译 AnnAssign(target=Name, annotation=..., value=expr)"}

.transpyc_cache/0e1189314c937ef1.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesAnnAssign.py
+Module: lib.core.Handles.HandlesAnnAssign
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesNonlocal as HandlesNonlocal
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+
+@t.NoVTable
+class AnnAssignHandle(HandlesBase.Mixin):
+    def __init__(self: AnnAssignHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def _is_cdefine_annotation(self: AnnAssignHandle, annot: ast.AST | t.CPtr) -> int: pass
+    def _extract_cdefine_int_value(self: AnnAssignHandle, val_node: ast.AST | t.CPtr) -> int: pass
+    def PreScan(self: AnnAssignHandle, node: ast.AST | t.CPtr) -> int: pass
+    def Handle(self: AnnAssignHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewAnnAssignHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> AnnAssignHandle | t.CPtr: pass

.transpyc_cache/0eccc2393466d940.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/0eccc2393466d940.pyi

@@ -0,0 +1,18 @@
+"""
+Auto-generated Python stub file from augassign_test.py
+Module: augassign_test
+"""
+
+
+import stdio
+import t, c
+
+g_count: t.CExtern | int
+
+def test_local() -> int: pass
+
+def test_global_aug() -> int: pass
+
+def test_bitops() -> int: pass
+
+def augassign_test() -> int: pass

.transpyc_cache/0f8134f67bdaba8f.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/0f8134f67bdaba8f.pyi

@@ -0,0 +1,122 @@
+"""
+Auto-generated Python stub file from __zlib.pyzlib.py
+Module: __zlib.pyzlib
+"""
+
+
+from stdint import *
+import zdeflate
+import zinflate
+import zchecksum
+import zdef
+import zhuff
+import stdlib
+import string
+import t, c
+
+Z_NO_COMPRESSION:      t.CDefine = 0
+Z_BEST_SPEED:          t.CDefine = 1
+Z_BEST_COMPRESSION:    t.CDefine = 9
+Z_DEFAULT_COMPRESSION: t.CDefine = (-1)
+DEFLATED:              t.CDefine = 8
+Z_NO_FLUSH:            t.CDefine = 0
+Z_PARTIAL_FLUSH:       t.CDefine = 1
+Z_SYNC_FLUSH:          t.CDefine = 2
+Z_FULL_FLUSH:          t.CDefine = 3
+Z_FINISH:              t.CDefine = 4
+Z_BLOCK:               t.CDefine = 5
+Z_TREES:               t.CDefine = 6
+Z_DEFAULT_STRATEGY: t.CDefine = 0
+Z_FILTERED:         t.CDefine = 1
+Z_HUFFMAN_ONLY:     t.CDefine = 2
+Z_RLE:              t.CDefine = 3
+Z_FIXED:            t.CDefine = 4
+Z_OK:            t.CDefine = 0
+Z_STREAM_END:    t.CDefine = 1
+Z_NEED_DICT:     t.CDefine = 2
+Z_ERRNO:         t.CDefine = (-1)
+Z_STREAM_ERROR:  t.CDefine = (-2)
+Z_DATA_ERROR:    t.CDefine = (-3)
+Z_MEM_ERROR:     t.CDefine = (-4)
+Z_BUF_ERROR:     t.CDefine = (-5)
+Z_VERSION_ERROR: t.CDefine = (-6)
+MAX_WBITS:       t.CDefine = 15
+DEF_BUF_SIZE:    t.CDefine = 16384
+DEF_MEM_LEVEL:   t.CDefine = 8
+ZLIB_VERSION:    t.CDefine = "1.3.2"
+pyzlib_error_msg: t.CExtern | t.CArray[t.CChar, 512]
+pyzlib_error_code_val: t.CExtern | t.CInt
+
+@t.Object
+class Compress:
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    is_finished: t.CInt
+    level: t.CInt
+    method: t.CInt
+    wbits: t.CInt
+    memLevel: t.CInt
+    strategy: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    last_pos: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    header_written: t.CInt
+    def compress(self: Compress, data: BYTEPTR, data_len: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Compress, mode: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Compress) -> Compress | t.CPtr: pass
+    def delete(self: Compress) -> t.CInt: pass
+    def __del__(self: Compress) -> t.CInt: pass
+@t.Object
+class Decompress:
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    eof: t.CInt
+    wbits: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    _unused_data: BYTEPTR
+    _unused_data_len: t.CSizeT
+    _unused_data_cap: t.CSizeT
+    _unconsumed_tail: BYTEPTR
+    _unconsumed_tail_len: t.CSizeT
+    _unconsumed_tail_cap: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    def decompress(self: Decompress, data: BYTEPTR, data_len: t.CSizeT, max_length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Decompress, length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Decompress) -> Decompress | t.CPtr: pass
+    def delete(self: Decompress) -> t.CInt: pass
+    def unused_data(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def unconsumed_tail(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def set_error(code: int, msg: str) -> t.CInt: pass
+
+def clone_bytes(src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def append_bytes(buf: BYTE | t.CPtr[t.CPtr], length: t.CSizeT | t.CPtr, cap: t.CSizeT | t.CPtr, data: BYTEPTR, data_len: t.CSizeT) -> t.CInt: pass
+
+def shrink_to_fit(buf: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def runtime_version() -> str: pass
+
+def get_error() -> str: pass
+
+def get_error_code() -> t.CInt: pass
+
+def clear_error() -> t.CInt: pass
+
+def compress(data: BYTEPTR, data_len: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def decompress(data: BYTEPTR, data_len: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def compressobj(level: t.CInt, method: t.CInt, wbits: t.CInt, memLevel: t.CInt, strategy: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Compress | t.CPtr: pass
+
+def decompressobj(wbits: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Decompress | t.CPtr: pass
+
+def zlib_adler32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass
+
+def zlib_crc32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass

.transpyc_cache/0fef3cb77da3dae3.pyi

@@ -0,0 +1,171 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprCall.py
+Module: lib.core.Handles.HandlesExprCall
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import sys
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+_g_sha1_arr: t.CExtern | bytes
+_g_mod_arr: t.CExtern | bytes
+_g_sha1_count: t.CExtern | int
+
+def set_module_sha1_map(sha1_arr: bytes, mod_arr: bytes, count: int) -> int: pass
+
+def _lookup_module_sha1(mod_name: str) -> str: pass
+
+def _lookup_module_sha1_suffix(mod_suffix: str) -> str: pass
+
+
+_g_cexport_sha1_arr: t.CExtern | bytes
+_g_cexport_func_arr: t.CExtern | bytes
+_g_cexport_count: t.CExtern | int
+_CEXPORT_MAX: t.CDefine = 256
+
+def register_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def is_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr, from_imports: str, class_name: str) -> str: pass
+
+def find_func_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _emit_llvm_memcpy_intrinsic(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, dst_val: llvmlite.Value | t.CPtr, src_val: llvmlite.Value | t.CPtr, num_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_deref(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_derefas(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_addr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_load(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+ASM_MAX_OPERANDS: t.CDefine = 16
+ASM_TEXT_BUF_SIZE: t.CDefine = 2048
+ASM_CONST_BUF_SIZE: t.CDefine = 512
+ASM_ARGS_BUF_SIZE: t.CDefine = 512
+ASM_LINE_BUF_SIZE: t.CDefine = 4096
+
+@t.NoVTable
+class AsmOperand:
+    Value: llvmlite.Value | t.CPtr
+    Constraint: str
+    IsOutput: int
+
+def _asm_append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _asm_escape_for_ir(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _resolve_register(attr_name: str) -> str: pass
+
+def _resolve_asm_descr(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _asm_get_operand(base: AsmOperand | t.CPtr, idx: int) -> AsmOperand | t.CPtr: pass
+
+def _asm_is_c_call(node: ast.Call | t.CPtr) -> str: pass
+
+def _asm_add_operand(operands: AsmOperand | t.CPtr, count: int, val: llvmlite.Value | t.CPtr, constraint: str, is_output: int) -> int: pass
+
+def translate_c_asm(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+LLVMIR_MAX_OPS: t.CDefine = 16
+LLVMIR_TEMPLATE_BUF: t.CDefine = 512
+
+def _llvmir_get_op(buf: AsmOperand | t.CPtr, i: int) -> AsmOperand | t.CPtr: pass
+
+def _llvmir_find_op_marker(s: t.CChar | t.CPtr) -> t.CPtr: pass
+
+def _llvmir_parse_op_num(marker: t.CChar | t.CPtr) -> int: pass
+
+def _llvmir_match_icmp_pred(pred: str) -> int: pass
+
+def _llvmir_match_fcmp_pred(pred: str) -> int: pass
+
+def _llvmir_extract_two_ops(template: t.CChar | t.CPtr, out_nums: int | t.CPtr) -> int: pass
+
+def _llvmir_resolve_op(op_num: int, all_kinds: int | t.CPtr, all_indices: int | t.CPtr, input_ops: AsmOperand | t.CPtr, output_targets: AsmOperand | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _llvmir_store_outputs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, result: llvmlite.Value | t.CPtr, output_targets: AsmOperand | t.CPtr, output_count: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_llvmir(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _apply_struct_defaults(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, tmp: llvmlite.Value | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _do_virtual_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, args_head: llvmlite.Value | t.CPtr, args_count: int, found_func: llvmlite.Function | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, extra_args: t.CSizeT | t.CPtr, extra_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr, method_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _translate_method_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, obj_ptr: llvmlite.Value | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _kwarg_name_matches(kw_arg: str, param_name: t.CChar | t.CPtr) -> int: pass
+
+def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_call_with_kwargs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, func_name: str, found_func: llvmlite.Function | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_t_type_cast(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _extract_type_args_from_slice(pool: memhub.MemBuddy | t.CPtr, slice_node: ast.AST | t.CPtr) -> list[str] | t.CPtr: pass
+
+def translate_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_closure_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, closure_alloca: llvmlite.Value | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT) -> llvmlite.Value | t.CPtr: pass
+
+def translate_printf_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class FuncEntry:
+    Name: str
+    Func: llvmlite.Function | t.CPtr
+
+def init_func_table(pool: memhub.MemBuddy | t.CPtr, max_count: int) -> FuncEntry | t.CPtr: pass
+
+def find_func_in_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def add_func_to_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str, func: llvmlite.Function | t.CPtr, max_count: int) -> int: pass
+
+
+GLOBAL_FUNC_MAX: t.CDefine = 8192
+_global_funcs: t.CExtern | FuncEntry | t.CPtr
+_global_func_count: t.CExtern | int
+
+def _init_global_func_table() -> int: pass
+
+def _register_global_func(name: str, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def find_func_global(name: str) -> llvmlite.Function | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprCallHandle(HandlesBase.Mixin):
+    def __init__(self: ExprCallHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleCall(self: ExprCallHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+    def HandlePrintfCall(self: ExprCallHandle, cl: ast.Call | t.CPtr) -> t.CInt: pass
+
+def NewExprCallHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprCallHandle | t.CPtr: pass

.transpyc_cache/10ac4af023af7962.doc.json

@@ -0,0 +1 @@
+{"set_generic_context": "设置泛型特化上下文（进入泛型类方法体翻译时调用）", "clear_generic_context": "清除泛型特化上下文（离开泛型类方法体翻译时调用）", "resolve_generic_type_name": "如果 name 是泛型类型参数，返回对应的具体类型名；否则返回 name 本身\n\n    用于表达式中的 T 替换（如 T.__sizeof__() → int.__sizeof__()）\n    ", "_get_type_name_from_annotation": "从类型注解节点提取类型名（支持 Name/Attribute/BinOp）", "_parse_type_string": "将类型名字符串解析为 AST 节点", "set_current_file": "设置当前编译的文件名（供报错使用）", "_read_source_line": "从源文件读取第 lineno 行内容", "fatal_error": "以 Python 风格报错并退出（带源代码行）", "fatal_type_error": "以 Python 风格报错并退出（fatal_error 的别名）", "map_t_type": "将 t.CXxx / c.CXxx 类型名映射到 LLVMType\n\n    注意: t.CChar | t.CPtr = i8* = str = bytes\n    ", "_is_t_attr": "检测节点是否是 t.attr_name 形式", "extract_class_name_from_annotation": "从类型注解 AST 中提取类名，返回 None=无法提取", "resolve_annotation_type": "解析类型注解节点为 LLVMType\n\n    Args:\n        pool: 内存分配器\n        node: 类型注解 AST 节点（Name 或 Attribute）\n        imported_modules: 已导入模块名字符串（空格分隔）\n        from_imports: from-import 映射字符串（\"name:module name:module\" 格式）\n    ", "has_decorator_marker": "检测类型注解中是否包含指定的装饰器标记", "is_pass_body": "检测函数体是否为 pass（空体或仅含 pass 语句）", "get_llvm_type_bits": "获取 LLVM 整数类型的位宽，非整数类型返回 0", "infer_expr_type": "推断表达式的 LLVM 类型\n\n    param_types 格式: \"name:bits,name:bits,...\"\n    ", "infer_return_type": "扫描函数体中的 return 语句，推断返回类型", "build_param_types_str": "构建参数类型编码字符串 \"name:bits,name:bits,...\" ", "_strappend": "将 src 追加到 dst 末尾"}

.transpyc_cache/10ac4af023af7962.pyi

@@ -0,0 +1,66 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesType.py
+Module: lib.core.Handles.HandlesType
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import sys
+import stdlib
+import viperlib
+import w32.fileio as fileio
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesStruct as HandlesStruct
+
+_g_current_file: t.CExtern | str
+_g_generic_tp_names: t.CExtern | list[str] | t.CPtr
+_g_generic_type_args: t.CExtern | list[str] | t.CPtr
+
+def set_generic_context(tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> t.CInt: pass
+
+def clear_generic_context() -> t.CInt: pass
+
+def resolve_generic_type_name(name: str) -> str: pass
+
+def _get_type_name_from_annotation(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _parse_type_string(pool: memhub.MemBuddy | t.CPtr, type_str: str, ctx: t.CInt) -> ast.AST | t.CPtr: pass
+
+def set_current_file(file_path: str) -> t.CInt: pass
+
+
+_SRC_BUF_SIZE: t.CDefine = 262144
+
+def _read_source_line(file_path: str, lineno: int) -> str: pass
+
+def fatal_error(node: ast.AST | t.CPtr, msg: str) -> t.CInt: pass
+
+def fatal_type_error(node: ast.AST | t.CPtr, msg: str) -> t.CInt: pass
+
+def map_t_type(pool: memhub.MemBuddy | t.CPtr, type_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _is_t_attr(node: ast.AST | t.CPtr, attr_name: str, imported_modules: str) -> int: pass
+
+def extract_class_name_from_annotation(node: ast.AST | t.CPtr, imported_modules: str) -> str: pass
+
+def resolve_annotation_type(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, imported_modules: str, from_imports: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def has_decorator_marker(node: ast.AST | t.CPtr, marker_name: str) -> int: pass
+
+def is_pass_body(body: list[ast.AST | t.CPtr] | t.CPtr) -> int: pass
+
+def get_llvm_type_bits(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def infer_expr_type(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, param_types: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def infer_return_type(pool: memhub.MemBuddy | t.CPtr, body: list[ast.AST | t.CPtr] | t.CPtr, param_types: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def build_param_types_str(pool: memhub.MemBuddy | t.CPtr, args_node: ast.AST | t.CPtr) -> str: pass
+
+def _strappend(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass

.transpyc_cache/117b4962d332b4c5.doc.json

@@ -0,0 +1 @@
+{"_load_includes_sha1_set": "读取 _sha1_map.txt，将 includes/ 开头的 SHA1 写入 sha1_set\n    sha1_set 大小为 MAX_INCLUDES_SHA1 * 17（每个 SHA1 16字符+null）\n    返回找到的 includes SHA1 数量，-1 表示错误", "_is_in_sha1_set": "检查 sha1 是否在集合中", "WriteIncludesSha1Map": "将 includes 扫描结果写入 _sha1_map.txt（供 StubMerger 使用）\n\n    若 filter_set 不为 None 且 filter_count > 0，只写入 filter_set 中的条目。\n    ", "_IsFuncDeclaredOrDefined": "检查 out_buf 中是否已有函数的 declare 或 define 行", "_CommentOutDeclareInBuf": "在 out_buf 中搜索 declare 行（包含 func_sig），将其注释掉", "_CommentOutGlobalInBuf": "在 out_buf 中搜索全局变量定义行（以 global_name 开头），将行首改为 ';'", "_CommentOutOpaqueTypeInBuf": "在 out_buf 中搜索 type_name_prefix 对应的 opaque 声明行，将行首改为 ';'\n\n    type_name_prefix 格式: '%\"sha1.ClassName\"'（不含 '=' 和后续内容）\n    返回 1=已注释, 0=未找到\n    ", "_HasFullTypeDefinition": "检查 out_buf 中是否已有 type_name_prefix 的完整定义", "_LoadAndAppendStub": "加载依赖 stub 并追加（跳过 header，去重）", "_LoadAndAppendTextDeclares": "从依赖 text.ll 提取 declare（define 转 declare），追加到 out_buf", "_PathToModuleName": "将文件路径转换为模块名", "_BuildIncludesSha1Map": "从 _sha1_map.txt 构建 sha1→module_name 映射，返回条目数", "_FindSha1ByModName": "从模块名查找 SHA1（精确匹配）", "_AddSha1ToSet": "将 SHA1 加入集合，返回新 count", "_BuildReachableSha1Set": "构建可达 SHA1 集合（依赖图按需翻译）", "BuildCombinedIR": "组合本地 stub + 依赖 stubs + 本地 text → out_buf（按需加载）"}

.transpyc_cache/117b4962d332b4c5.pyi

@@ -0,0 +1,60 @@
+"""
+Auto-generated Python stub file from lib.core.StubMerger.py
+Module: lib.core.StubMerger
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import stdio
+import stdlib
+import llvmlite
+import w32.win32file as win32file
+import w32.win32base as win32base
+import w32.fileio as fileio
+import viperlib
+import sys
+import ast
+import lib.core.IncludesScanner as IncludesScanner
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesTranslator as HandlesTranslator
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+MAX_INCLUDES_SHA1: t.CDefine = 256
+STUB_READ_BUF_SIZE: t.CDefine = 262144
+MAX_INCLUDES: t.CDefine = 256
+
+def _load_includes_sha1_set(pool: memhub.MemBuddy | t.CPtr, temp_dir: str, sha1_set: str) -> int: pass
+
+def _is_in_sha1_set(sha1: str, sha1_set: str, set_count: int) -> int: pass
+
+def WriteIncludesSha1Map(mb: memhub.MemBuddy | t.CPtr, temp_dir: str, scan_result: IncludesScanner.ScanResult | t.CPtr, filter_set: t.CChar | t.CPtr, filter_count: int) -> int: pass
+
+def _IsFuncDeclaredOrDefined(out_buf: bytes, func_sig: str) -> int: pass
+
+def _CommentOutDeclareInBuf(out_buf: bytes, func_sig: str) -> int: pass
+
+def _CommentOutGlobalInBuf(out_buf: bytes, global_name: str) -> int: pass
+
+def _CommentOutOpaqueTypeInBuf(out_buf: bytes, type_name_prefix: str) -> int: pass
+
+def _HasFullTypeDefinition(out_buf: bytes, type_name_prefix: str) -> int: pass
+
+def _LoadAndAppendStub(temp_dir: str, td_len: t.CSizeT, dep_sha1: str, dep_buf: bytes, out_buf: bytes, out_size: t.CSizeT, out_pos: t.CSizeT) -> t.CSizeT: pass
+
+def _LoadAndAppendTextDeclares(temp_dir: str, td_len: t.CSizeT, dep_sha1: str, dep_buf: bytes, out_buf: bytes, out_size: t.CSizeT, out_pos: t.CSizeT) -> t.CSizeT: pass
+
+def _PathToModuleName(path: str) -> str: pass
+
+def _BuildIncludesSha1Map(temp_dir: str, td_len: t.CSizeT, sha1_list: t.CChar | t.CPtr, mod_list: t.CChar | t.CPtr) -> int: pass
+
+def _FindSha1ByModName(sha1_arr: t.CChar | t.CPtr, mod_arr: t.CChar | t.CPtr, count: int, mod_name: str) -> str: pass
+
+def _AddSha1ToSet(set_buf: t.CChar | t.CPtr, count: int, sha1: str) -> int: pass
+
+def _BuildReachableSha1Set(mb: memhub.MemBuddy | t.CPtr, source_dir: str, temp_dir: str, reachable_set: t.CChar | t.CPtr) -> int: pass
+
+def BuildCombinedIR(temp_dir: str, local_sha1: str, out_buf: bytes, out_size: t.CSizeT) -> t.CSizeT: pass

.transpyc_cache/1193c9cd16698da8.doc.json

@@ -0,0 +1 @@
+{"SrcFileEntry": "源文件条目", "RunMultiFileProject": "多文件项目编译\n\n    Returns: 0 成功，非 0 失败\n    "}

.transpyc_cache/1193c9cd16698da8.pyi

@@ -0,0 +1,39 @@
+"""
+Auto-generated Python stub file from lib.core.Phase2.py
+Module: lib.core.Phase2
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import string
+import stdlib
+import memhub
+import viperlib
+import w32.fileio as fileio
+import w32.win32file
+import w32.win32base
+import sys
+import ast
+import llvmlite
+import subprocess
+import argparse
+import lib.core.VLogger as VLogger
+import lib.core.Handles.HandlesTranslator as HandlesTranslator
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.BuildPipeline as BuildPipeline
+import lib.core.StubMerger as StubMerger
+import lib.Projectrans.Utils as Utils
+import lib.Projectrans.Config as Config
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+SRC_BUF_SIZE: t.CDefine = 1048576
+MAX_SRC_FILES: t.CDefine = 32
+
+@t.NoVTable
+class SrcFileEntry:
+    Path: str
+    Sha1: str
+
+def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr, source_dir: str, temp_dir: str, output_dir: str, cc_cmd: str, cc_flags: str, linker_cmd: str, linker_flags: str, linker_output: str, includes_binary_dir: str, includes_dir: str, do_phase1: int, do_phase2: int, log: VLogger.Logger | t.CPtr, args: argparse.ParsedArgs | t.CPtr) -> int: pass

.transpyc_cache/13110effbb0bb06c.pyi

@@ -0,0 +1,35 @@
+"""
+Auto-generated Python stub file from os.path.py
+Module: os.path
+"""
+
+
+import t, c
+from stdint import *
+import string
+import memhub
+import platmacro
+
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
+
+def sep() -> t.CChar: pass
+
+def _is_sep(ch: t.CChar) -> bool: pass
+
+def _dup_str(s: str) -> str: pass
+
+def _substr(s: str, start: t.CSizeT, end: t.CSizeT) -> str: pass
+
+def isabs(path: str) -> bool: pass
+
+def join(path1: str, path2: str) -> str: pass
+
+def basename(path: str) -> str: pass
+
+def dirname(path: str) -> str: pass
+
+def splitext_name(path: str) -> str: pass
+
+def splitext_ext(path: str) -> str: pass
+
+def normpath(path: str) -> str: pass

.transpyc_cache/13d9449413372bde.pyi

@@ -0,0 +1,93 @@
+"""
+Auto-generated Python stub file from llvmlite.__function.py
+Module: llvmlite.__function
+"""
+
+
+import t, c
+from stdint import *
+import string
+import viperlib
+import memhub
+import stdio
+from linkedlist import GSListNode, GSList
+from .__types import LLVMType, ParamNode, TypePrint
+
+class Line(GSListNode[Line]):
+    Buf: t.CChar | t.CPtr
+    Len: t.CSizeT
+class BasicBlock(GSListNode[BasicBlock]):
+    Name: t.CChar | t.CPtr
+    Lines: GSList[Line] | t.CPtr
+    IsTerminated: t.CInt
+class Param(GSListNode[Param]):
+    Ty: LLVMType | t.CPtr
+    Name: t.CChar | t.CPtr
+    Attrs: t.CChar | t.CPtr
+class Function(GSListNode[Function]):
+    Name: t.CChar | t.CPtr
+    RetTy: LLVMType | t.CPtr
+    Params: GSList[Param] | t.CPtr
+    Blocks: GSList[BasicBlock] | t.CPtr
+    IsDeclared: t.CInt
+    IsVarArg: t.CInt
+    Attrs: t.CChar | t.CPtr
+
+LINE_SIZE: t.CDefine = 24
+
+def new_line(pool: memhub.MemBuddy | t.CPtr, text: t.CChar | t.CPtr) -> Line | t.CPtr: pass
+
+def _new_gslist(pool: memhub.MemBuddy | t.CPtr, list_size: t.CSizeT) -> t.CPtr: pass
+
+
+BLOCK_SIZE: t.CDefine = 32
+
+def new_basic_block(pool: memhub.MemBuddy | t.CPtr, name: t.CChar | t.CPtr) -> BasicBlock | t.CPtr: pass
+
+
+PARAM_SIZE: t.CDefine = 32
+
+def new_param(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Param | t.CPtr: pass
+
+
+FUNC_SIZE: t.CDefine = 56
+
+def new_function(pool: memhub.MemBuddy | t.CPtr, name: t.CChar | t.CPtr, ret_ty: LLVMType | t.CPtr) -> Function | t.CPtr: pass
+
+def function_add_param(func: Function | t.CPtr, param: Param | t.CPtr) -> t.CInt: pass
+
+def function_add_block(func: Function | t.CPtr, block: BasicBlock | t.CPtr) -> t.CInt: pass
+
+def function_move_block_to_end(func: Function | t.CPtr, block: BasicBlock | t.CPtr) -> t.CInt: pass
+
+def block_append_line(block: BasicBlock | t.CPtr, line: Line | t.CPtr) -> t.CInt: pass
+
+def block_append_text(pool: memhub.MemBuddy | t.CPtr, block: BasicBlock | t.CPtr, text: t.CChar | t.CPtr) -> t.CInt: pass
+
+def function_set_attrs(func: Function | t.CPtr, attrs: t.CChar | t.CPtr) -> t.CInt: pass
+
+def param_set_attrs(param: Param | t.CPtr, attrs: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _ll_name_needs_quote(name: str) -> t.CInt: pass
+
+def FunctionPrint(buf: t.CChar | t.CPtr, size: t.CSizeT, func: Function | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def _append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def function_get_name(func: Function | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def function_get_ret_ty(func: Function | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def function_get_params(func: Function | t.CPtr) -> GSList[Param] | t.CPtr: pass
+
+def function_get_param_head(func: Function | t.CPtr) -> Param | t.CPtr: pass
+
+def function_get_next(func: Function | t.CPtr) -> Function | t.CPtr: pass
+
+def function_is_declared(func: Function | t.CPtr) -> t.CInt: pass
+
+def param_get_name(param: Param | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def param_get_ty(param: Param | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def param_get_next(param: Param | t.CPtr) -> Param | t.CPtr: pass

.transpyc_cache/1446e90e8296beae.pyi

@@ -0,0 +1,171 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprCall.py
+Module: lib.core.Handles.HandlesExprCall
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import sys
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+_g_sha1_arr: t.CExtern | bytes
+_g_mod_arr: t.CExtern | bytes
+_g_sha1_count: t.CExtern | int
+
+def set_module_sha1_map(sha1_arr: bytes, mod_arr: bytes, count: int) -> int: pass
+
+def _lookup_module_sha1(mod_name: str) -> str: pass
+
+def _lookup_module_sha1_suffix(mod_suffix: str) -> str: pass
+
+
+_g_cexport_sha1_arr: t.CExtern | bytes
+_g_cexport_func_arr: t.CExtern | bytes
+_g_cexport_count: t.CExtern | int
+_CEXPORT_MAX: t.CDefine = 256
+
+def register_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def is_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr, from_imports: str, class_name: str) -> str: pass
+
+def find_func_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _emit_llvm_memcpy_intrinsic(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, dst_val: llvmlite.Value | t.CPtr, src_val: llvmlite.Value | t.CPtr, num_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_deref(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_derefas(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_addr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_load(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+ASM_MAX_OPERANDS: t.CDefine = 16
+ASM_TEXT_BUF_SIZE: t.CDefine = 2048
+ASM_CONST_BUF_SIZE: t.CDefine = 512
+ASM_ARGS_BUF_SIZE: t.CDefine = 512
+ASM_LINE_BUF_SIZE: t.CDefine = 4096
+
+@t.NoVTable
+class AsmOperand:
+    Value: llvmlite.Value | t.CPtr
+    Constraint: str
+    IsOutput: int
+
+def _asm_append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _asm_escape_for_ir(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _resolve_register(attr_name: str) -> str: pass
+
+def _resolve_asm_descr(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _asm_get_operand(base: AsmOperand | t.CPtr, idx: int) -> AsmOperand | t.CPtr: pass
+
+def _asm_is_c_call(node: ast.Call | t.CPtr) -> str: pass
+
+def _asm_add_operand(operands: AsmOperand | t.CPtr, count: int, val: llvmlite.Value | t.CPtr, constraint: str, is_output: int) -> int: pass
+
+def translate_c_asm(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+LLVMIR_MAX_OPS: t.CDefine = 16
+LLVMIR_TEMPLATE_BUF: t.CDefine = 512
+
+def _llvmir_get_op(buf: AsmOperand | t.CPtr, i: int) -> AsmOperand | t.CPtr: pass
+
+def _llvmir_find_op_marker(s: t.CChar | t.CPtr) -> t.CPtr: pass
+
+def _llvmir_parse_op_num(marker: t.CChar | t.CPtr) -> int: pass
+
+def _llvmir_match_icmp_pred(pred: str) -> int: pass
+
+def _llvmir_match_fcmp_pred(pred: str) -> int: pass
+
+def _llvmir_extract_two_ops(template: t.CChar | t.CPtr, out_nums: int | t.CPtr) -> int: pass
+
+def _llvmir_resolve_op(op_num: int, all_kinds: int | t.CPtr, all_indices: int | t.CPtr, input_ops: AsmOperand | t.CPtr, output_targets: AsmOperand | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _llvmir_store_outputs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, result: llvmlite.Value | t.CPtr, output_targets: AsmOperand | t.CPtr, output_count: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_llvmir(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _apply_struct_defaults(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, tmp: llvmlite.Value | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _do_virtual_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, args_head: llvmlite.Value | t.CPtr, args_count: int, found_func: llvmlite.Function | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, extra_args: t.CSizeT | t.CPtr, extra_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr, method_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _translate_method_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, obj_ptr: llvmlite.Value | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _kwarg_name_matches(kw_arg: str, param_name: t.CChar | t.CPtr) -> int: pass
+
+def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_call_with_kwargs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, func_name: str, found_func: llvmlite.Function | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_t_type_cast(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _extract_type_args_from_slice(pool: memhub.MemBuddy | t.CPtr, slice_node: ast.AST | t.CPtr) -> list[str] | t.CPtr: pass
+
+def translate_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_closure_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, closure_alloca: llvmlite.Value | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT) -> llvmlite.Value | t.CPtr: pass
+
+def translate_printf_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class FuncEntry:
+    Name: str
+    Func: llvmlite.Function | t.CPtr
+
+def init_func_table(pool: memhub.MemBuddy | t.CPtr, max_count: int) -> FuncEntry | t.CPtr: pass
+
+def find_func_in_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def add_func_to_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str, func: llvmlite.Function | t.CPtr, max_count: int) -> int: pass
+
+
+GLOBAL_FUNC_MAX: t.CDefine = 8192
+_global_funcs: t.CExtern | FuncEntry | t.CPtr
+_global_func_count: t.CExtern | int
+
+def _init_global_func_table() -> int: pass
+
+def _register_global_func(name: str, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def find_func_global(name: str) -> llvmlite.Function | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprCallHandle(HandlesBase.Mixin):
+    def __init__(self: ExprCallHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleCall(self: ExprCallHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+    def HandlePrintfCall(self: ExprCallHandle, cl: ast.Call | t.CPtr) -> t.CInt: pass
+
+def NewExprCallHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprCallHandle | t.CPtr: pass

.transpyc_cache/146a976893eef52b.doc.json

@@ -0,0 +1 @@
+{"_is_cenum_base": "检查 base 节点是否为 t.CEnum，返回 1=是 / 0=否", "_is_enum_class": "检查 ClassDef 是否继承自 t.CEnum，返回 1=是 / 0=否", "_is_cunion_base": "检查 base 节点是否为 t.CUnion，返回 1=是 / 0=否", "_is_union_class": "检查 ClassDef 是否继承自 t.CUnion，返回 1=是 / 0=否", "_has_decorator": "检查 decorator_list 中是否有指定装饰器名", "_is_marker_base": "检查基类名是否为标记基类，返回 1=是 / 0=否", "_get_base_name": "从 base AST 节点提取基类名，返回 None=失败", "_get_parent_class": "获取 ClassDef 的真实父类名，返回 None=无真实父类", "_has_any_func_cvtable": "检查类中是否有任何函数标记了 @t.CVTable，返回 1=有 / 0=无", "_should_method_be_virtual": "判断方法是否应该进入虚表，返回 1=包含 / 0=排除", "_detect_vtable_status": "检测类是否应该启用虚表", "_resolve_enum_member_type": "解析枚举成员的类型注解为 LLVM 整数类型", "_is_state_annotation": "检查注解节点是否为 t.State，返回 1=是 / 0=否", "_extract_int_value": "从 AST 节点提取整数值，失败返回 0", "_translate_enum_def": "翻译枚举类定义，返回 0", "_get_type_size": "计算 LLVM 类型的字节大小", "_translate_union_def": "翻译联合体定义，返回 0", "_is_generic_class": "检查 ClassDef 是否有类型参数（泛型类），返回 1=是 / 0=否", "_register_generic_template": "注册泛型类模板（类名 + ClassDef 节点）", "_find_generic_template": "查找泛型类模板，返回 ClassDef 节点或 None", "_mangle_generic_class_name": "生成特化类名: list + [int] -> list[int]\n\n    分配新缓冲区拼接，避免原地 strcat 导致缓冲区溢出\n    ", "_clone_annotation": "拷贝类型注解表达式，替换类型参数 T 为具体类型名\n\n    tp_names: 类型参数名列表 ['T']\n    type_args: 类型实参名列表 ['int']\n    ", "_clone_arguments": "拷贝 Arguments 节点，替换 arg annotation 中的 T", "_clone_classdef_for_spec": "拷贝 ClassDef 节点用于泛型特化\n\n    - 替换类名为 spec_name\n    - 清除 type_params（特化后不是泛型类）\n    - 拷贝 children 中的 AnnAssign 和 FunctionDef，替换类型注解中的 T\n    - 方法体直接引用原始节点（通过 type_map 上下文处理 T）\n    ", "_find_cached_spec": "查找已缓存的特化名，未找到返回 None", "_cache_spec": "缓存特化结果", "_specialize_generic_class": "特化泛型类，返回特化类名\n\n    1. 查找泛型模板\n    2. 生成特化名\n    3. 检查缓存\n    4. 拷贝 ClassDef 节点（替换类型注解中的 T）\n    5. 设置 type_map 上下文（用于方法体中的 T 替换）\n    6. 调用 translate_class_def 翻译特化类\n    7. 返回特化名\n    ", "translate_class_def": "翻译 class 定义，返回 0", "_vtable_strcat": "将 src 追加到 dst 末尾", "_vtable_name_needs_quote": "检查 LLVM 标识符是否需要引号（以数字开头或含 '.'）", "_format_func_type_str": "从 Function 对象生成函数类型字符串", "_generate_vtable": "生成 VTable 全局变量", "_translate_oop_methods": "扫描 class body 中的方法并翻译，生成 __before_init__", "_translate_method": "翻译单个方法，返回 0", "_generate_before_init": "生成 __before_init__ 函数，返回 0"}

.transpyc_cache/146a976893eef52b.pyi

@@ -0,0 +1,104 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesClassDef.py
+Module: lib.core.Handles.HandlesClassDef
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import viperlib
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesEnum as HandlesEnum
+
+ENUM_MEMBER_MAX_LOCAL: t.CDefine = 64
+
+def _is_cenum_base(base_node: ast.AST | t.CPtr) -> int: pass
+
+def _is_enum_class(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _is_cunion_base(base_node: ast.AST | t.CPtr) -> int: pass
+
+def _is_union_class(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+
+_MARKER_BASES: t.CDefine = 8
+
+def _has_decorator(decorator_list: list[ast.AST | t.CPtr] | t.CPtr, deco_name: str) -> int: pass
+
+def _is_marker_base(base_name: str) -> int: pass
+
+def _get_base_name(base_node: ast.AST | t.CPtr) -> str: pass
+
+def _get_parent_class(cd: ast.ClassDef | t.CPtr) -> str: pass
+
+def _has_any_func_cvtable(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _should_method_be_virtual(cd: ast.ClassDef | t.CPtr, fd: ast.FunctionDef | t.CPtr, trans: HT.Translator | t.CPtr) -> int: pass
+
+def _detect_vtable_status(cd: ast.ClassDef | t.CPtr, trans: HT.Translator | t.CPtr) -> int: pass
+
+def _resolve_enum_member_type(pool: memhub.MemBuddy | t.CPtr, ann_node: ast.AST | t.CPtr, imported_modules: str, from_imports: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _is_state_annotation(node: ast.AST | t.CPtr) -> int: pass
+
+def _extract_int_value(node: ast.AST | t.CPtr) -> t.CInt64T: pass
+
+def _translate_enum_def(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _get_type_size(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def _translate_union_def(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr) -> int: pass
+
+
+_generic_class_names: t.CExtern | list[str] | t.CPtr
+_generic_class_nodes: t.CExtern | list[ast.ClassDef | t.CPtr] | t.CPtr
+
+def _is_generic_class(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _register_generic_template(pool: memhub.MemBuddy | t.CPtr, cd: ast.ClassDef | t.CPtr) -> t.CInt: pass
+
+def _find_generic_template(class_name: str) -> ast.ClassDef | t.CPtr: pass
+
+def _mangle_generic_class_name(pool: memhub.MemBuddy | t.CPtr, class_name: str, type_args: list[str] | t.CPtr) -> str: pass
+
+def _clone_annotation(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> ast.AST | t.CPtr: pass
+
+def _clone_arguments(pool: memhub.MemBuddy | t.CPtr, args: ast.AST | t.CPtr, tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> ast.AST | t.CPtr: pass
+
+def _clone_classdef_for_spec(pool: memhub.MemBuddy | t.CPtr, cd: ast.ClassDef | t.CPtr, spec_name: str, tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> ast.ClassDef | t.CPtr: pass
+
+
+_spec_keys: t.CExtern | list[str] | t.CPtr
+_spec_names: t.CExtern | list[str] | t.CPtr
+
+def _find_cached_spec(spec_key: str) -> str: pass
+
+def _cache_spec(pool: memhub.MemBuddy | t.CPtr, spec_key: str, spec_name: str) -> t.CInt: pass
+
+def _specialize_generic_class(trans: HT.Translator | t.CPtr, class_name: str, type_args: list[str] | t.CPtr) -> str: pass
+
+def translate_class_def(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+
+VTBL_METHOD_MAX: t.CDefine = 32
+
+def _vtable_strcat(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _vtable_name_needs_quote(name: str) -> int: pass
+
+def _format_func_type_str(pool: memhub.MemBuddy | t.CPtr, buf: t.CChar | t.CPtr, buf_size: t.CSizeT, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def _generate_vtable(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr, class_name: str) -> int: pass
+
+def _translate_oop_methods(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str) -> int: pass
+
+def _translate_method(trans: HT.Translator | t.CPtr, fd: ast.FunctionDef | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str) -> int: pass
+
+def _generate_before_init(trans: HT.Translator | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str) -> int: pass

.transpyc_cache/14a9b576ab5d21c9.doc.json

@@ -0,0 +1 @@
+{"local_func": "Local function docstring.", "LocalClass": "Local class docstring.", "LocalClass.local_method": "Local method docstring.", "_check_doc_adaptive": "自适应检查 docstring：非空时验证匹配，空时视为优化剥离", "_check_doc_null": "检查 docstring 为 null（无 docstring 的符号）"}

.transpyc_cache/14a9b576ab5d21c9.pyi

@@ -0,0 +1,32 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t
+import stdio
+import string
+import c
+import testcheck
+import remote
+
+def local_func() -> t.CInt: pass
+
+def no_doc_func() -> t.CInt: pass
+
+
+@t.Object
+class LocalClass:
+    value: t.CInt
+    def local_method(self: LocalClass) -> t.CInt: pass
+
+def _check_doc_adaptive(name: str, doc: str, expected: str) -> t.CInt: pass
+
+def _check_doc_null(name: str, doc: str) -> t.CInt: pass
+
+def test_local_doc() -> t.CInt: pass
+
+def test_cross_module_doc() -> t.CInt: pass
+
+def main() -> t.CInt: pass

.transpyc_cache/16e1f65b154831e8.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/16e1f65b154831e8.pyi

@@ -0,0 +1,64 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+import c
+
+
+import t
+import stdio
+import testcheck
+
+def add[T](a: T, b: T) -> T: pass
+
+def test_generic_add() -> t.CInt: pass
+
+def combine[T1, T2](a: T1, b: T2) -> T1: pass
+
+def test_generic_combine() -> t.CInt: pass
+
+def max_val[T](a: T, b: T) -> T: pass
+
+def test_generic_max() -> t.CInt: pass
+
+
+class Box[T]:
+    value: T
+    def __init__(self: Box, v: T) -> t.CInt: pass
+    def get(self: Box) -> T: pass
+    def set(self: Box, v: T) -> t.CInt: pass
+
+def test_generic_box() -> t.CInt: pass
+
+
+class Pair[T1, T2]:
+    first: T1
+    second: T2
+    def __init__(self: Pair, a: T1, b: T2) -> t.CInt: pass
+    def sum_as_int(self: Pair) -> t.CInt: pass
+
+def test_generic_pair() -> t.CInt: pass
+
+def test_fixed_array() -> t.CInt: pass
+
+def test_char_array() -> t.CInt: pass
+
+def identity[T](x: T) -> T: pass
+
+def test_generic_identity() -> t.CInt: pass
+
+def double_val[T](x: T) -> T: pass
+
+def test_generic_nested() -> t.CInt: pass
+
+
+class Counter[T]:
+    count: T
+    def __init__(self: Counter, start: T) -> t.CInt: pass
+    def increment(self: Counter) -> t.CInt: pass
+    def get_count(self: Counter) -> T: pass
+
+def test_generic_counter() -> t.CInt: pass
+
+def main() -> t.CInt: pass

.transpyc_cache/17c0dfbcebfa3a0e.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/17c0dfbcebfa3a0e.pyi

@@ -0,0 +1,71 @@
+"""
+Auto-generated Python stub file from attr_test.py
+Module: attr_test
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import string
+
+@c.Attribute(t.attr.always_inline())
+def AlwaysInlineFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.noinline())
+def NoInlineFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.noreturn())
+def NoReturnFunc() -> t.CInt: pass
+
+def NormalFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.always_inline(), t.attr.pure())
+def MultiAttrFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.packed)
+def PackedAttrFunc(x: t.CInt) -> t.CInt: pass
+
+def test_always_inline() -> t.CInt: pass
+
+def test_noinline() -> t.CInt: pass
+
+def test_noreturn() -> t.CInt: pass
+
+def test_normal() -> t.CInt: pass
+
+def test_multi_attr() -> t.CInt: pass
+
+def test_packed_attr() -> t.CInt: pass
+
+@c.Attribute(t.attr.llvm.nounwind)
+def NoUnwindFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.llvm.noredzone)
+def NoRedZoneFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.llvm.willreturn)
+def WillReturnFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.llvm.mustprogress)
+def MustProgressFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.const())
+def ConstFunc(x: t.CInt) -> t.CInt: pass
+
+@c.Attribute(t.attr.always_inline(), t.attr.llvm.nounwind, t.attr.llvm.noredzone)
+def TripleAttrFunc(x: t.CInt) -> t.CInt: pass
+
+def test_nounwind() -> t.CInt: pass
+
+def test_noredzone() -> t.CInt: pass
+
+def test_willreturn() -> t.CInt: pass
+
+def test_mustprogress() -> t.CInt: pass
+
+def test_const_attr() -> t.CInt: pass
+
+def test_triple_attr() -> t.CInt: pass
+
+def attr_test() -> t.CInt: pass

.transpyc_cache/19b6605d568c8584.doc.json

@@ -0,0 +1 @@
+{"_load_includes_sha1_set": "读取 _sha1_map.txt，将 includes/ 开头的 SHA1 写入 sha1_set\n    sha1_set 大小为 MAX_INCLUDES_SHA1 * 17（每个 SHA1 16字符+null）\n    返回找到的 includes SHA1 数量，-1 表示错误", "_is_in_sha1_set": "检查 sha1 是否在集合中", "WriteIncludesSha1Map": "将 includes 扫描结果写入 _sha1_map.txt（供 StubMerger 使用）\n\n    若 filter_set 不为 None 且 filter_count > 0，只写入 filter_set 中的条目。\n    ", "_IsFuncDeclaredOrDefined": "检查 out_buf 中是否已有函数的 declare 或 define 行", "_CommentOutDeclareInBuf": "在 out_buf 中搜索 declare 行（包含 func_sig），将其注释掉", "_CommentOutGlobalInBuf": "在 out_buf 中搜索全局变量定义行（以 global_name 开头），将行首改为 ';'", "_CommentOutOpaqueTypeInBuf": "在 out_buf 中搜索 type_name_prefix 对应的 opaque 声明行，将行首改为 ';'\n\n    type_name_prefix 格式: '%\"sha1.ClassName\"'（不含 '=' 和后续内容）\n    返回 1=已注释, 0=未找到\n    ", "_HasFullTypeDefinition": "检查 out_buf 中是否已有 type_name_prefix 的完整定义", "_LoadAndAppendStub": "加载依赖 stub 并追加（跳过 header，去重）", "_LoadAndAppendTextDeclares": "从依赖 text.ll 提取 declare（define 转 declare），追加到 out_buf", "_PathToModuleName": "将文件路径转换为模块名", "_BuildIncludesSha1Map": "从 _sha1_map.txt 构建 sha1→module_name 映射，返回条目数", "_FindSha1ByModName": "从模块名查找 SHA1（精确匹配）", "_AddSha1ToSet": "将 SHA1 加入集合，返回新 count", "_BuildReachableSha1Set": "构建可达 SHA1 集合（依赖图按需翻译）", "BuildCombinedIR": "组合本地 stub + 依赖 stubs + 本地 text → out_buf（按需加载）"}

.transpyc_cache/19b6605d568c8584.pyi

@@ -0,0 +1,60 @@
+"""
+Auto-generated Python stub file from lib.core.StubMerger.py
+Module: lib.core.StubMerger
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import stdio
+import stdlib
+import llvmlite
+import w32.win32file as win32file
+import w32.win32base as win32base
+import w32.fileio as fileio
+import viperlib
+import sys
+import ast
+import lib.core.IncludesScanner as IncludesScanner
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesTranslator as HandlesTranslator
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+MAX_INCLUDES_SHA1: t.CDefine = 256
+STUB_READ_BUF_SIZE: t.CDefine = 262144
+MAX_INCLUDES: t.CDefine = 256
+
+def _load_includes_sha1_set(pool: memhub.MemBuddy | t.CPtr, temp_dir: str, sha1_set: str) -> int: pass
+
+def _is_in_sha1_set(sha1: str, sha1_set: str, set_count: int) -> int: pass
+
+def WriteIncludesSha1Map(mb: memhub.MemBuddy | t.CPtr, temp_dir: str, scan_result: IncludesScanner.ScanResult | t.CPtr, filter_set: t.CChar | t.CPtr, filter_count: int) -> int: pass
+
+def _IsFuncDeclaredOrDefined(out_buf: bytes, func_sig: str) -> int: pass
+
+def _CommentOutDeclareInBuf(out_buf: bytes, func_sig: str) -> int: pass
+
+def _CommentOutGlobalInBuf(out_buf: bytes, global_name: str) -> int: pass
+
+def _CommentOutOpaqueTypeInBuf(out_buf: bytes, type_name_prefix: str) -> int: pass
+
+def _HasFullTypeDefinition(out_buf: bytes, type_name_prefix: str) -> int: pass
+
+def _LoadAndAppendStub(temp_dir: str, td_len: t.CSizeT, dep_sha1: str, dep_buf: bytes, out_buf: bytes, out_size: t.CSizeT, out_pos: t.CSizeT) -> t.CSizeT: pass
+
+def _LoadAndAppendTextDeclares(temp_dir: str, td_len: t.CSizeT, dep_sha1: str, dep_buf: bytes, out_buf: bytes, out_size: t.CSizeT, out_pos: t.CSizeT) -> t.CSizeT: pass
+
+def _PathToModuleName(path: str) -> str: pass
+
+def _BuildIncludesSha1Map(temp_dir: str, td_len: t.CSizeT, sha1_list: t.CChar | t.CPtr, mod_list: t.CChar | t.CPtr) -> int: pass
+
+def _FindSha1ByModName(sha1_arr: t.CChar | t.CPtr, mod_arr: t.CChar | t.CPtr, count: int, mod_name: str) -> str: pass
+
+def _AddSha1ToSet(set_buf: t.CChar | t.CPtr, count: int, sha1: str) -> int: pass
+
+def _BuildReachableSha1Set(mb: memhub.MemBuddy | t.CPtr, source_dir: str, temp_dir: str, reachable_set: t.CChar | t.CPtr) -> int: pass
+
+def BuildCombinedIR(temp_dir: str, local_sha1: str, out_buf: bytes, out_size: t.CSizeT) -> t.CSizeT: pass

.transpyc_cache/19f8024d10c828e8.pyi

@@ -0,0 +1,35 @@
+"""
+Auto-generated Python stub file from hashlib.__md5.py
+Module: hashlib.__md5
+"""
+
+
+import string
+import t, c
+
+MD5_BLOCK_LEN:  t.CDefine = 64    # 分组块大小
+MD5_DIGEST_LEN: t.CDefine = 16    # 摘要输出长度
+
+def md5_F(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_G(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_H(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_I(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
+
+
+md5_T: t.CExtern | t.CArray[t.CUInt32T, 64]
+md5_S: t.CExtern | t.CArray[t.CInt, 64]
+
+@t.Object
+class md5:
+    state: t.CArray[t.CUInt32T, 4]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, MD5_BLOCK_LEN]
+    def __init__(self: md5) -> t.CInt: pass
+    def transform(self: md5, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: md5, s: str) -> t.CInt: pass
+    def final(self: md5, out: t.CArray[t.CUInt8T, MD5_DIGEST_LEN]) -> t.CInt: pass

.transpyc_cache/1a3af346a22d2cb6.doc.json

@@ -0,0 +1 @@
+{"translate_stmt": "翻译单条语句，返回新增的变量数", "translate_global": "翻译 global 语句：记录 global 变量名", "translate_nonlocal": "翻译 nonlocal 语句：记录 nonlocal 变量名", "translate_expr_stmt": "翻译表达式语句（printf 调用等）", "pre_scan_allocas": "预扫描语句中的 AnnAssign，提前创建 alloca\n\n    返回新增的变量数\n    ", "translate_break": "翻译 break 语句：跳转到循环 end 块", "translate_continue": "翻译 continue 语句：跳转到循环 cond/incr 块", "get_stmt_kind_name": "获取语句类型名"}

.transpyc_cache/1a3af346a22d2cb6.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesBody.py
+Module: lib.core.Handles.HandlesBody
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import viperlib
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.Handles.HandlesFunctions as HandlesFunctions
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+def translate_stmt(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_global(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_nonlocal(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_expr_stmt(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def pre_scan_allocas(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_break(trans: HT.Translator | t.CPtr) -> int: pass
+
+def translate_continue(trans: HT.Translator | t.CPtr) -> int: pass
+
+def get_stmt_kind_name(node: ast.AST | t.CPtr) -> str: pass

.transpyc_cache/1b58766d38d05de3.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/1b58766d38d05de3.pyi

@@ -0,0 +1,35 @@
+"""
+Auto-generated Python stub file from enumtest.py
+Module: enumtest
+"""
+
+
+import t, c
+from t import CInt, CPtr, CChar, CInt32T, CExport
+import viperlib
+import stdlib
+
+class Color(t.CEnum):
+    Red = 0
+    Green = 1
+    Blue = 2
+class Option(t.REnum):
+    class Some:
+        value: CInt
+    Empty = 1
+class Result(t.REnum):
+    class Ok:
+        value: CInt
+    class Err:
+        msg: t.CChar | CPtr
+class GeoShape(t.REnum):
+    class GCircle:
+        radius: CInt
+    class GRect:
+        w: CInt
+        h: CInt
+    class GPoint:
+        x: CInt
+        y: CInt
+
+def enum_main() -> CInt: pass

.transpyc_cache/1b9ab264a942c56b.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/1b9ab264a942c56b.pyi

@@ -0,0 +1,27 @@
+"""
+Auto-generated Python stub file from oop_test.py
+Module: oop_test
+"""
+
+
+import stdio
+import t, c
+
+class Point:
+    x: t.CInt
+    y: t.CInt
+    def MoveTo(self: Point, nx: t.CInt, ny: t.CInt) -> t.CInt: pass
+    def GetX(self: Point) -> t.CInt: pass
+    def GetY(self: Point) -> t.CInt: pass
+class Counter:
+    count: t.CInt = 0
+    step: t.CInt = 1
+    def Increment(self: Counter) -> t.CInt: pass
+    def Reset(self: Counter) -> t.CInt: pass
+class Rect:
+    width: t.CInt
+    height: t.CInt
+    def __init__(self: Rect, w: t.CInt, h: t.CInt) -> t.CInt: pass
+    def Area(self: Rect) -> t.CInt: pass
+
+def oop_test() -> int: pass

.transpyc_cache/1c46d554b3a3f9f3.pyi

@@ -0,0 +1,125 @@
+"""
+Auto-generated Python stub file from zlib.pyzlib.py
+Module: zlib.pyzlib
+"""
+
+
+from stdint import *
+import zlib.zdeflate as zdeflate
+import zlib.zinflate as zinflate
+import zlib.zchecksum as zchecksum
+import zlib.zdef as zdef
+import zlib.zhuff as zhuff
+import stdlib
+import string
+import memhub
+import t, c
+
+Z_NO_COMPRESSION:      t.CDefine = 0
+Z_BEST_SPEED:          t.CDefine = 1
+Z_BEST_COMPRESSION:    t.CDefine = 9
+Z_DEFAULT_COMPRESSION: t.CDefine = (-1)
+DEFLATED:              t.CDefine = 8
+Z_NO_FLUSH:            t.CDefine = 0
+Z_PARTIAL_FLUSH:       t.CDefine = 1
+Z_SYNC_FLUSH:          t.CDefine = 2
+Z_FULL_FLUSH:          t.CDefine = 3
+Z_FINISH:              t.CDefine = 4
+Z_BLOCK:               t.CDefine = 5
+Z_TREES:               t.CDefine = 6
+Z_DEFAULT_STRATEGY: t.CDefine = 0
+Z_FILTERED:         t.CDefine = 1
+Z_HUFFMAN_ONLY:     t.CDefine = 2
+Z_RLE:              t.CDefine = 3
+Z_FIXED:            t.CDefine = 4
+Z_OK:            t.CDefine = 0
+Z_STREAM_END:    t.CDefine = 1
+Z_NEED_DICT:     t.CDefine = 2
+Z_ERRNO:         t.CDefine = (-1)
+Z_STREAM_ERROR:  t.CDefine = (-2)
+Z_DATA_ERROR:    t.CDefine = (-3)
+Z_MEM_ERROR:     t.CDefine = (-4)
+Z_BUF_ERROR:     t.CDefine = (-5)
+Z_VERSION_ERROR: t.CDefine = (-6)
+MAX_WBITS:       t.CDefine = 15
+DEF_BUF_SIZE:    t.CDefine = 16384
+DEF_MEM_LEVEL:   t.CDefine = 8
+ZLIB_VERSION:    t.CDefine = "1.3.2"
+pyzlib_error_msg: t.CExtern | t.CArray[t.CChar, 512]
+pyzlib_error_code_val: t.CExtern | t.CInt
+
+@t.Object
+class Compress:
+    pool: memhub.MemManager | t.CPtr
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    is_finished: t.CInt
+    level: t.CInt
+    method: t.CInt
+    wbits: t.CInt
+    memLevel: t.CInt
+    strategy: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    last_pos: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    header_written: t.CInt
+    def compress(self: Compress, data: BYTEPTR, data_len: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Compress, mode: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Compress) -> Compress | t.CPtr: pass
+    def delete(self: Compress) -> t.CInt: pass
+    def __del__(self: Compress) -> t.CInt: pass
+@t.Object
+class Decompress:
+    pool: memhub.MemManager | t.CPtr
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    eof: t.CInt
+    wbits: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    _unused_data: BYTEPTR
+    _unused_data_len: t.CSizeT
+    _unused_data_cap: t.CSizeT
+    _unconsumed_tail: BYTEPTR
+    _unconsumed_tail_len: t.CSizeT
+    _unconsumed_tail_cap: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    def decompress(self: Decompress, data: BYTEPTR, data_len: t.CSizeT, max_length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Decompress, length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Decompress) -> Decompress | t.CPtr: pass
+    def delete(self: Decompress) -> t.CInt: pass
+    def unused_data(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def unconsumed_tail(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def set_error(code: int, msg: str) -> t.CInt: pass
+
+def clone_bytes(pool: memhub.MemManager | t.CPtr, src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def append_bytes(pool: memhub.MemManager | t.CPtr, buf: BYTE | t.CPtr[t.CPtr], length: t.CSizeT | t.CPtr, cap: t.CSizeT | t.CPtr, data: BYTEPTR, data_len: t.CSizeT) -> t.CInt: pass
+
+def shrink_to_fit(pool: memhub.MemManager | t.CPtr, buf: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def runtime_version() -> str: pass
+
+def get_error() -> str: pass
+
+def get_error_code() -> t.CInt: pass
+
+def clear_error() -> t.CInt: pass
+
+def compress(pool: memhub.MemManager | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def decompress(pool: memhub.MemManager | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def compressobj(pool: memhub.MemManager | t.CPtr, level: t.CInt, method: t.CInt, wbits: t.CInt, memLevel: t.CInt, strategy: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Compress | t.CPtr: pass
+
+def decompressobj(pool: memhub.MemManager | t.CPtr, wbits: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Decompress | t.CPtr: pass
+
+def zlib_adler32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass
+
+def zlib_crc32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass

.transpyc_cache/1c8a1eceb26a43f4.doc.json

@@ -0,0 +1 @@
+{"AnnAssignHandle": "AnnAssign 语句处理器：继承 Mixin 获得 Trans 回指针", "AnnAssignHandle.PreScan": "预扫描 AnnAssign，提前创建 alloca 到 entry block 顶部", "AnnAssignHandle.Handle": "翻译 AnnAssign(target=Name, annotation=..., value=expr)"}

.transpyc_cache/1c8a1eceb26a43f4.pyi

@@ -0,0 +1,26 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesAnnAssign.py
+Module: lib.core.Handles.HandlesAnnAssign
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesNonlocal as HandlesNonlocal
+
+@t.NoVTable
+class AnnAssignHandle(HandlesBase.Mixin):
+    def __init__(self: AnnAssignHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def PreScan(self: AnnAssignHandle, node: ast.AST | t.CPtr) -> int: pass
+    def Handle(self: AnnAssignHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewAnnAssignHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> AnnAssignHandle | t.CPtr: pass

.transpyc_cache/1df40188ee73ee05.doc.json

@@ -0,0 +1 @@
+{"ReturnHandle": "Return 语句处理器：继承 Mixin 获得 Trans 回指针", "ReturnHandle.Handle": "翻译 Return 语句"}

.transpyc_cache/1df40188ee73ee05.pyi

@@ -0,0 +1,23 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesReturn.py
+Module: lib.core.Handles.HandlesReturn
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+
+@t.NoVTable
+class ReturnHandle(HandlesBase.Mixin):
+    def __init__(self: ReturnHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def Handle(self: ReturnHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewReturnHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ReturnHandle | t.CPtr: pass

.transpyc_cache/1e19f516dc857768.doc.json

@@ -0,0 +1 @@
+{"_is_cenum_base": "检查 base 节点是否为 t.CEnum，返回 1=是 / 0=否", "_is_enum_class": "检查 ClassDef 是否继承自 t.CEnum，返回 1=是 / 0=否", "_is_cunion_base": "检查 base 节点是否为 t.CUnion，返回 1=是 / 0=否", "_is_union_class": "检查 ClassDef 是否继承自 t.CUnion，返回 1=是 / 0=否", "_has_decorator": "检查 decorator_list 中是否有指定装饰器名", "_is_marker_base": "检查基类名是否为标记基类，返回 1=是 / 0=否", "_get_base_name": "从 base AST 节点提取基类名，返回 None=失败", "_get_parent_class": "获取 ClassDef 的真实父类名，返回 None=无真实父类", "_has_any_func_cvtable": "检查类中是否有任何函数标记了 @t.CVTable，返回 1=有 / 0=无", "_should_method_be_virtual": "判断方法是否应该进入虚表，返回 1=包含 / 0=排除", "_detect_vtable_status": "检测类是否应该启用虚表", "_resolve_enum_member_type": "解析枚举成员的类型注解为 LLVM 整数类型", "_is_state_annotation": "检查注解节点是否为 t.State，返回 1=是 / 0=否", "_extract_int_value": "从 AST 节点提取整数值，失败返回 0", "_translate_enum_def": "翻译枚举类定义，返回 0", "_get_type_size": "计算 LLVM 类型的字节大小", "_translate_union_def": "翻译联合体定义，返回 0", "_is_generic_class": "检查 ClassDef 是否有类型参数（泛型类），返回 1=是 / 0=否", "_register_generic_template": "注册泛型类模板（类名 + ClassDef 节点）", "_find_generic_template": "查找泛型类模板，返回 ClassDef 节点或 None", "_mangle_generic_class_name": "生成特化类名: list + [int] -> list[int]\n\n    分配新缓冲区拼接，避免原地 strcat 导致缓冲区溢出\n    ", "_clone_annotation": "拷贝类型注解表达式，替换类型参数 T 为具体类型名\n\n    tp_names: 类型参数名列表 ['T']\n    type_args: 类型实参名列表 ['int']\n    ", "_clone_arguments": "拷贝 Arguments 节点，替换 arg annotation 中的 T", "_clone_classdef_for_spec": "拷贝 ClassDef 节点用于泛型特化\n\n    - 替换类名为 spec_name\n    - 清除 type_params（特化后不是泛型类）\n    - 拷贝 children 中的 AnnAssign 和 FunctionDef，替换类型注解中的 T\n    - 方法体直接引用原始节点（通过 type_map 上下文处理 T）\n    ", "_find_cached_spec": "查找已缓存的特化名，未找到返回 None", "_cache_spec": "缓存特化结果", "_specialize_generic_class": "特化泛型类，返回特化类名\n\n    1. 查找泛型模板\n    2. 生成特化名\n    3. 检查缓存\n    4. 拷贝 ClassDef 节点（替换类型注解中的 T）\n    5. 设置 type_map 上下文（用于方法体中的 T 替换）\n    6. 调用 translate_class_def 翻译特化类\n    7. 返回特化名\n    ", "translate_class_def": "翻译 class 定义，返回 0", "_vtable_strcat": "将 src 追加到 dst 末尾", "_vtable_name_needs_quote": "检查 LLVM 标识符是否需要引号（以数字开头或含 '.'）", "_format_func_type_str": "从 Function 对象生成函数类型字符串", "_generate_vtable": "生成 VTable 全局变量", "_translate_oop_methods": "扫描 class body 中的方法并翻译，生成 __before_init__", "_translate_method": "翻译单个方法，返回 0", "_generate_before_init": "生成 __before_init__ 函数，返回 0"}

.transpyc_cache/1e19f516dc857768.pyi

@@ -0,0 +1,104 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesClassDef.py
+Module: lib.core.Handles.HandlesClassDef
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import viperlib
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesEnum as HandlesEnum
+
+ENUM_MEMBER_MAX_LOCAL: t.CDefine = 64
+
+def _is_cenum_base(base_node: ast.AST | t.CPtr) -> int: pass
+
+def _is_enum_class(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _is_cunion_base(base_node: ast.AST | t.CPtr) -> int: pass
+
+def _is_union_class(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+
+_MARKER_BASES: t.CDefine = 8
+
+def _has_decorator(decorator_list: list[ast.AST | t.CPtr] | t.CPtr, deco_name: str) -> int: pass
+
+def _is_marker_base(base_name: str) -> int: pass
+
+def _get_base_name(base_node: ast.AST | t.CPtr) -> str: pass
+
+def _get_parent_class(cd: ast.ClassDef | t.CPtr) -> str: pass
+
+def _has_any_func_cvtable(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _should_method_be_virtual(cd: ast.ClassDef | t.CPtr, fd: ast.FunctionDef | t.CPtr, trans: HT.Translator | t.CPtr) -> int: pass
+
+def _detect_vtable_status(cd: ast.ClassDef | t.CPtr, trans: HT.Translator | t.CPtr) -> int: pass
+
+def _resolve_enum_member_type(pool: memhub.MemBuddy | t.CPtr, ann_node: ast.AST | t.CPtr, imported_modules: str, from_imports: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _is_state_annotation(node: ast.AST | t.CPtr) -> int: pass
+
+def _extract_int_value(node: ast.AST | t.CPtr) -> t.CInt64T: pass
+
+def _translate_enum_def(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _get_type_size(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def _translate_union_def(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr) -> int: pass
+
+
+_generic_class_names: t.CExtern | list[str] | t.CPtr
+_generic_class_nodes: t.CExtern | list[ast.ClassDef | t.CPtr] | t.CPtr
+
+def _is_generic_class(cd: ast.ClassDef | t.CPtr) -> int: pass
+
+def _register_generic_template(pool: memhub.MemBuddy | t.CPtr, cd: ast.ClassDef | t.CPtr) -> t.CInt: pass
+
+def _find_generic_template(class_name: str) -> ast.ClassDef | t.CPtr: pass
+
+def _mangle_generic_class_name(pool: memhub.MemBuddy | t.CPtr, class_name: str, type_args: list[str] | t.CPtr) -> str: pass
+
+def _clone_annotation(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> ast.AST | t.CPtr: pass
+
+def _clone_arguments(pool: memhub.MemBuddy | t.CPtr, args: ast.AST | t.CPtr, tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> ast.AST | t.CPtr: pass
+
+def _clone_classdef_for_spec(pool: memhub.MemBuddy | t.CPtr, cd: ast.ClassDef | t.CPtr, spec_name: str, tp_names: list[str] | t.CPtr, type_args: list[str] | t.CPtr) -> ast.ClassDef | t.CPtr: pass
+
+
+_spec_keys: t.CExtern | list[str] | t.CPtr
+_spec_names: t.CExtern | list[str] | t.CPtr
+
+def _find_cached_spec(spec_key: str) -> str: pass
+
+def _cache_spec(pool: memhub.MemBuddy | t.CPtr, spec_key: str, spec_name: str) -> t.CInt: pass
+
+def _specialize_generic_class(trans: HT.Translator | t.CPtr, class_name: str, type_args: list[str] | t.CPtr) -> str: pass
+
+def translate_class_def(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+
+VTBL_METHOD_MAX: t.CDefine = 32
+
+def _vtable_strcat(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _vtable_name_needs_quote(name: str) -> int: pass
+
+def _format_func_type_str(pool: memhub.MemBuddy | t.CPtr, buf: t.CChar | t.CPtr, buf_size: t.CSizeT, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def _generate_vtable(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr, class_name: str) -> int: pass
+
+def _translate_oop_methods(trans: HT.Translator | t.CPtr, cd: ast.ClassDef | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str) -> int: pass
+
+def _translate_method(trans: HT.Translator | t.CPtr, fd: ast.FunctionDef | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str) -> int: pass
+
+def _generate_before_init(trans: HT.Translator | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str) -> int: pass

.transpyc_cache/1eb1c9fc7e85d9f8.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/1eb1c9fc7e85d9f8.pyi

@@ -0,0 +1,10 @@
+"""
+Auto-generated Python stub file from for_test.py
+Module: for_test
+"""
+
+
+import stdio
+import t, c
+
+def for_test() -> int: pass

.transpyc_cache/1ed8ca4986cb0d65.doc.json

@@ -0,0 +1 @@
+{"get_func_name": "从函数节点提取函数名", "escape_llvm_string": "将字符串转换为 LLVM IR 字符串字面量 c\"...\\00\" ", "get_llvm_type_bits": "获取 LLVM 整数类型的位宽，非整数类型返回 0", "get_llvm_float_bits": "获取 LLVM 浮点类型的位宽，非浮点类型返回 0", "is_ptr_type": "检查 ty 是否是 Ptr 类型，返回 1=是, 0=否", "_deref_if_ptr_ptr": "如果 obj_ptr 是 Ptr(Ptr(...))，load 解引用获取内层指针", "coerce_to_type": "将 val 强制转换为 target_ty\n\n    整数: sext（扩展）/ trunc（截断）\n    浮点: fpext（扩展）/ fptrunc（截断）\n    int→float: sitofp\n    float→int: fptosi\n    ", "create_global_string": "创建全局字符串常量并返回 i8* bitcast", "translate_constant": "翻译常量（int/str/bool）", "translate_value": "翻译值表达式为 LLVM Value", "translate_compare": "翻译比较表达式，返回 i1 结果", "translate_unaryop": "翻译一元运算（-x, +x, not x, ~x）", "translate_boolop": "翻译布尔运算（and/or）的短路求值，返回 i1", "translate_name_value": "翻译变量引用（Name 节点）→ load", "ExprHandle": "表达式处理器：继承 Mixin 获得 Trans 回指针", "ExprHandle.HandleValue": "翻译值表达式，从 self.Trans 获取共享状态", "list_getitem_inline": "内联生成 list __getitem__ 逻辑，返回元素地址 (i8*)", "_list_elem_type_from_name": "从 list 类型名提取元素 LLVM 类型", "list_setitem_inline": "内联生成 list __setitem__ 逻辑，返回 0", "is_list_subscript": "检查 Subscript 节点是否是 list[T] 类型，返回 list 对象指针或 None", "translate_subscript": "翻译下标表达式，返回加载的元素值", "translate_attribute": "翻译属性访问，返回加载的字段值", "get_subscript_ptr": "获取下标表达式的元素指针（用于赋值 lhs）", "get_attribute_ptr": "获取属性访问的字段指针（用于赋值 lhs）"}

.transpyc_cache/1ed8ca4986cb0d65.pyi

@@ -0,0 +1,77 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExpr.py
+Module: lib.core.Handles.HandlesExpr
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import memhub
+import string
+import llvmlite
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExprOps as HandlesExprOps
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.Handles.HandlesNonlocal as HandlesNonlocal
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesEnum as HandlesEnum
+
+def get_func_name(func_node: ast.AST | t.CPtr) -> str: pass
+
+def escape_llvm_string(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def get_llvm_type_bits(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def get_llvm_float_bits(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def is_ptr_type(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def _deref_if_ptr_ptr(builder: llvmlite.IRBuilder | t.CPtr, obj_ptr: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def coerce_to_type(builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def create_global_string(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, str_val: str, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_constant(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_value(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_compare(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_unaryop(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_boolop(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_name_value(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprHandle(HandlesBase.Mixin):
+    def __init__(self: ExprHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleValue(self: ExprHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def NewExprHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprHandle | t.CPtr: pass
+
+def list_getitem_inline(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, lm_obj: llvmlite.Value | t.CPtr, idx_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _list_elem_type_from_name(pool: memhub.MemBuddy | t.CPtr, struct_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def list_setitem_inline(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, lm_obj: llvmlite.Value | t.CPtr, idx_val: llvmlite.Value | t.CPtr, rhs_val: llvmlite.Value | t.CPtr) -> int: pass
+
+def is_list_subscript(node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_subscript(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+import stdio
+
+def get_subscript_ptr(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def get_attribute_ptr(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass

.transpyc_cache/1ff2c5eb32359e40.doc.json

@@ -0,0 +1 @@
+{}

.transpyc_cache/1ff2c5eb32359e40.pyi

@@ -0,0 +1,16 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+from stdint import *
+import w32.win32console
+import t, c
+from t import CInt, CExport
+import stdlib
+import stdio
+import memhub
+import testcheck
+
+def main() -> CInt | CExport: pass

.transpyc_cache/2020b02f319dd87d.doc.json

@@ -0,0 +1 @@
+{"_register_cexport_from_funcdef": "预注册 CExport/State 函数到全局表（仅注册，不生成 IR）", "translate_children": "遍历 tree.children 并翻译每个子节点\n\n    Args:\n        trans: 翻译器（含所有共享状态）\n        tree: AST 模块节点\n\n    Returns:\n        t.CInt: 新增的变量数\n    ", "handle_module_level_var": "处理模块级变量声明，创建全局变量", "create_wrapper_main": "创建包装 main 函数并翻译所有顶层语句\n\n    Args:\n        trans: 翻译器（含所有共享状态）\n        tree: AST 模块节点\n        i32_ty: i32 LLVMType\n\n    Returns:\n        t.CInt: 新增的变量数\n    "}

.transpyc_cache/2020b02f319dd87d.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesMain.py
+Module: lib.core.Handles.HandlesMain
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import viperlib
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesBody as HandlesBody
+import lib.core.Handles.HandlesFunctions as HandlesFunctions
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+def _register_cexport_from_funcdef(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_children(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr) -> int: pass
+
+def handle_module_level_var(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def create_wrapper_main(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr, i32_ty: llvmlite.LLVMType | t.CPtr) -> int: pass

.transpyc_cache/20cd49775c100a38.pyi

@@ -0,0 +1,22 @@
+"""
+Auto-generated Python stub file from json.__writer.py
+Module: json.__writer
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from stdio import snprintf
+from . import JsonValue, JSON_NULL, JSON_BOOL, JSON_INT, JSON_FLOAT, JSON_STRING, JSON_ARRAY, JSON_OBJECT
+
+def _write_char(buf: t.CChar | t.CPtr, pos: t.CSizeT, ch: t.CChar) -> t.CSizeT: pass
+
+def _write_str(buf: t.CChar | t.CPtr, pos: t.CSizeT, s: t.CChar | t.CPtr) -> t.CSizeT: pass
+
+def _write_string_escaped(buf: t.CChar | t.CPtr, pos: t.CSizeT, s: t.CChar | t.CPtr) -> t.CSizeT: pass
+
+def _write_value(buf: t.CChar | t.CPtr, pos: t.CSizeT, val: JsonValue | t.CPtr, pool: memhub.MemManager | t.CPtr) -> t.CSizeT: pass
+
+def write(pool: memhub.MemManager | t.CPtr, val: JsonValue | t.CPtr, pretty: bool) -> t.CChar | t.CPtr: pass

.transpyc_cache/212fb1de4f9d6e5c.pyi

@@ -0,0 +1,171 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesExprCall.py
+Module: lib.core.Handles.HandlesExprCall
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import sys
+import viperlib
+import lib.core.Handles.HandlesBase as HandlesBase
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+
+_g_sha1_arr: t.CExtern | bytes
+_g_mod_arr: t.CExtern | bytes
+_g_sha1_count: t.CExtern | int
+
+def set_module_sha1_map(sha1_arr: bytes, mod_arr: bytes, count: int) -> int: pass
+
+def _lookup_module_sha1(mod_name: str) -> str: pass
+
+def _lookup_module_sha1_suffix(mod_suffix: str) -> str: pass
+
+
+_g_cexport_sha1_arr: t.CExtern | bytes
+_g_cexport_func_arr: t.CExtern | bytes
+_g_cexport_count: t.CExtern | int
+_CEXPORT_MAX: t.CDefine = 256
+
+def register_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def is_cexport_func(sha1: str, func_name: str) -> int: pass
+
+def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr, from_imports: str, class_name: str) -> str: pass
+
+def find_func_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr, func_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _emit_llvm_memcpy_intrinsic(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, dst_val: llvmlite.Value | t.CPtr, src_val: llvmlite.Value | t.CPtr, num_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_deref(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_derefas(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_addr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_load(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+ASM_MAX_OPERANDS: t.CDefine = 16
+ASM_TEXT_BUF_SIZE: t.CDefine = 2048
+ASM_CONST_BUF_SIZE: t.CDefine = 512
+ASM_ARGS_BUF_SIZE: t.CDefine = 512
+ASM_LINE_BUF_SIZE: t.CDefine = 4096
+
+@t.NoVTable
+class AsmOperand:
+    Value: llvmlite.Value | t.CPtr
+    Constraint: str
+    IsOutput: int
+
+def _asm_append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _asm_escape_for_ir(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _resolve_register(attr_name: str) -> str: pass
+
+def _resolve_asm_descr(pool: memhub.MemBuddy | t.CPtr, node: ast.AST | t.CPtr) -> str: pass
+
+def _asm_get_operand(base: AsmOperand | t.CPtr, idx: int) -> AsmOperand | t.CPtr: pass
+
+def _asm_is_c_call(node: ast.Call | t.CPtr) -> str: pass
+
+def _asm_add_operand(operands: AsmOperand | t.CPtr, count: int, val: llvmlite.Value | t.CPtr, constraint: str, is_output: int) -> int: pass
+
+def translate_c_asm(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+
+LLVMIR_MAX_OPS: t.CDefine = 16
+LLVMIR_TEMPLATE_BUF: t.CDefine = 512
+
+def _llvmir_get_op(buf: AsmOperand | t.CPtr, i: int) -> AsmOperand | t.CPtr: pass
+
+def _llvmir_find_op_marker(s: t.CChar | t.CPtr) -> t.CPtr: pass
+
+def _llvmir_parse_op_num(marker: t.CChar | t.CPtr) -> int: pass
+
+def _llvmir_match_icmp_pred(pred: str) -> int: pass
+
+def _llvmir_match_fcmp_pred(pred: str) -> int: pass
+
+def _llvmir_extract_two_ops(template: t.CChar | t.CPtr, out_nums: int | t.CPtr) -> int: pass
+
+def _llvmir_resolve_op(op_num: int, all_kinds: int | t.CPtr, all_indices: int | t.CPtr, input_ops: AsmOperand | t.CPtr, output_targets: AsmOperand | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _llvmir_store_outputs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, result: llvmlite.Value | t.CPtr, output_targets: AsmOperand | t.CPtr, output_count: int) -> llvmlite.Value | t.CPtr: pass
+
+def translate_c_llvmir(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _apply_struct_defaults(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, tmp: llvmlite.Value | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _do_virtual_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, args_head: llvmlite.Value | t.CPtr, args_count: int, found_func: llvmlite.Function | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, self_ptr: llvmlite.Value | t.CPtr, extra_args: t.CSizeT | t.CPtr, extra_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr, method_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def _translate_method_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, class_name: str, method_name: str, obj_ptr: llvmlite.Value | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _kwarg_name_matches(kw_arg: str, param_name: t.CChar | t.CPtr) -> int: pass
+
+def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr, class_name: str, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_call_with_kwargs(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, func_name: str, found_func: llvmlite.Function | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT, keywords: list[ast.AST | t.CPtr] | t.CPtr, kw_count: t.CSizeT, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _translate_t_type_cast(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, val: llvmlite.Value | t.CPtr, target_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _extract_type_args_from_slice(pool: memhub.MemBuddy | t.CPtr, slice_node: ast.AST | t.CPtr) -> list[str] | t.CPtr: pass
+
+def translate_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, funcs_ptr: t.CPtr, func_count: int, trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_closure_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, closure_alloca: llvmlite.Value | t.CPtr, cargs: list[ast.AST | t.CPtr] | t.CPtr, can: t.CSizeT) -> llvmlite.Value | t.CPtr: pass
+
+def translate_printf_call(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, cl: ast.Call | t.CPtr, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class FuncEntry:
+    Name: str
+    Func: llvmlite.Function | t.CPtr
+
+def init_func_table(pool: memhub.MemBuddy | t.CPtr, max_count: int) -> FuncEntry | t.CPtr: pass
+
+def find_func_in_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str) -> llvmlite.Function | t.CPtr: pass
+
+def add_func_to_table(funcs: FuncEntry | t.CPtr, func_count: int, name: str, func: llvmlite.Function | t.CPtr, max_count: int) -> int: pass
+
+
+GLOBAL_FUNC_MAX: t.CDefine = 8192
+_global_funcs: t.CExtern | FuncEntry | t.CPtr
+_global_func_count: t.CExtern | int
+
+def _init_global_func_table() -> int: pass
+
+def _register_global_func(name: str, func: llvmlite.Function | t.CPtr) -> int: pass
+
+def find_func_global(name: str) -> llvmlite.Function | t.CPtr: pass
+
+
+@t.NoVTable
+class ExprCallHandle(HandlesBase.Mixin):
+    def __init__(self: ExprCallHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def HandleCall(self: ExprCallHandle, node: ast.AST | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+    def HandlePrintfCall(self: ExprCallHandle, cl: ast.Call | t.CPtr) -> t.CInt: pass
+
+def NewExprCallHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ExprCallHandle | t.CPtr: pass

.transpyc_cache/213348433fb01cc6.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from zlib.zdef.py
+Module: zlib.zdef
+"""
+
+
+from stdint import *
+import stddef
+import string
+import stdlib
+import memhub
+import t, c
+
+ZDEFLATE_WINDOW_BITS: t.CDefine = 15
+ZDEFLATE_WINDOW_SIZE: t.CDefine =    (1 << ZDEFLATE_WINDOW_BITS)
+ZDEFLATE_WINDOW_MASK: t.CDefine =    (ZDEFLATE_WINDOW_SIZE - 1)
+ZDEFLATE_MIN_MATCH: t.CDefine =      3
+ZDEFLATE_MAX_MATCH: t.CDefine =      258
+ZDEFLATE_HASH_BITS: t.CDefine =      15
+ZDEFLATE_HASH_SIZE: t.CDefine =      (1 << ZDEFLATE_HASH_BITS)
+ZDEFLATE_HASH_MASK: t.CDefine =      (ZDEFLATE_HASH_SIZE - 1)
+ZDEFLATE_MAX_CODES:         t.CDefine =      288
+ZDEFLATE_MAX_DIST_CODES:    t.CDefine = 32
+ZDEFLATE_MAX_BITS:          t.CDefine =       15
+ZDEFLATE_MAX_CODELEN_CODES: t.CDefine = 19
+ZDEFLATE_LIT_COUNT:  t.CDefine =      286
+ZDEFLATE_DIST_COUNT: t.CDefine =     30
+ZDEFLATE_LEN_SYMBOLS_BASE: t.CDefine = 257
+ZDEFLATE_END_OF_BLOCK:     t.CDefine =     256
+zdeflate_len_extra_bits: t.CExtern | t.CArray[t.CInt, 29]
+zdeflate_len_base: t.CExtern | t.CArray[t.CInt, 29]
+zdeflate_dist_extra_bits: t.CExtern | t.CArray[t.CInt, 30]
+zdeflate_dist_base: t.CExtern | t.CArray[t.CInt, 30]
+zdeflate_codelen_order: t.CExtern | t.CArray[int, 19]
+
+@t.Object
+class zbit_writer:
+    pool: memhub.MemManager | t.CPtr
+    buf: BYTE | t.CPtr
+    cap: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def __init__(self: zbit_writer, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def ensure(self: zbit_writer, need: t.CSizeT) -> t.CInt: pass
+    def write_bits(self: zbit_writer, value: UINT, nbits: t.CInt) -> t.CInt: pass
+    def write_bits_rev(self: zbit_writer, code: UINT, nbits: t.CInt) -> t.CInt: pass
+    def stored_block(self: zbit_writer, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def write_zlib_header(self: zbit_writer, wbits: t.CInt, level: t.CInt) -> t.CInt: pass
+    def write_gzip_header(self: zbit_writer) -> t.CInt: pass
+    def align(self: zbit_writer) -> t.CInt: pass
+    def total(self: zbit_writer) -> t.CSizeT: pass
+    def free(self: zbit_writer) -> t.CInt: pass
+    def __del__(self: zbit_writer) -> t.CInt: pass
+@t.Object
+class zbit_reader:
+    buf: BYTE | t.CPtr
+    length: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def init(self: zbit_reader, buf: BYTE | t.CPtr, length: t.CSizeT) -> t.CInt: pass
+    def read_bits(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def read_bits_rev(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def align(self: zbit_reader) -> t.CInt: pass
+
+def zdef_alloc(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> VOIDPTR: pass
+
+def zdef_free(pool: memhub.MemManager | t.CPtr, p: VOIDPTR) -> t.CInt: pass

.transpyc_cache/21a7fcfc665f75ef.pyi

@@ -0,0 +1,87 @@
+"""
+Auto-generated Python stub file from llvmlite.__module.py
+Module: llvmlite.__module
+"""
+
+
+import t, c
+from stdint import *
+import string
+import stdio
+import viperlib
+import memhub
+from linkedlist import GSList, GSListNode
+from .__types import LLVMType, TypePrint, Array, PrintStructDefinition, get_struct_name, Struct
+from .__function import Function, FunctionPrint, _ll_name_needs_quote, Param
+
+@t.NoVTable
+class GlobalVariable(GSListNode[GlobalVariable]):
+    Name: t.CChar | t.CPtr
+    Ty: LLVMType | t.CPtr
+    Initializer: t.CVoid | t.CPtr
+    IsConstant: t.CInt
+    Linkage: t.CChar | t.CPtr
+    Section: t.CChar | t.CPtr
+    UnnamedAddr: t.CInt
+@t.NoVTable
+class NamedTypeNode(GSListNode[NamedTypeNode]):
+    Ty: LLVMType | t.CPtr
+@t.NoVTable
+class LLVMModule:
+    Name: t.CChar | t.CPtr
+    FuncHead: Function | t.CPtr
+    FuncTail: Function | t.CPtr
+    FuncCount: t.CSizeT
+    GlobalHead: GlobalVariable | t.CPtr
+    GlobalTail: GlobalVariable | t.CPtr
+    GlobalCount: t.CSizeT
+    TargetTriple: t.CChar | t.CPtr
+    DataLayout: t.CChar | t.CPtr
+    NamedTypeHead: NamedTypeNode | t.CPtr
+    NamedTypeTail: NamedTypeNode | t.CPtr
+    NamedTypeCount: t.CSizeT
+
+def new_module(pool: memhub.MemBuddy | t.CPtr, name: t.CChar | t.CPtr) -> LLVMModule | t.CPtr: pass
+
+
+GV_SIZE: t.CDefine = 64
+NAMED_TYPE_NODE_SIZE: t.CDefine = 16
+
+def new_global_variable(pool: memhub.MemBuddy | t.CPtr, name: t.CChar | t.CPtr, ty: LLVMType | t.CPtr) -> GlobalVariable | t.CPtr: pass
+
+def module_add_function(mod: LLVMModule | t.CPtr, func: Function | t.CPtr) -> t.CInt: pass
+
+def module_add_global(mod: LLVMModule | t.CPtr, gv: GlobalVariable | t.CPtr) -> t.CInt: pass
+
+def module_set_target(mod: LLVMModule | t.CPtr, triple: t.CChar | t.CPtr) -> t.CInt: pass
+
+def module_set_datalayout(mod: LLVMModule | t.CPtr, layout: t.CChar | t.CPtr) -> t.CInt: pass
+
+def module_add_named_type(mod: LLVMModule | t.CPtr, pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr) -> t.CInt: pass
+
+def _is_type_defined_in_module(mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr) -> int: pass
+
+def _scan_type_for_cross_module_refs(pool: memhub.MemBuddy | t.CPtr, mod: LLVMModule | t.CPtr, ty: LLVMType | t.CPtr) -> t.CInt: pass
+
+def module_ensure_opaque_for_type(mod: LLVMModule | t.CPtr, pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr) -> t.CInt: pass
+
+def global_set_constant(gv: GlobalVariable | t.CPtr, is_const: t.CInt) -> t.CInt: pass
+
+def global_set_linkage(gv: GlobalVariable | t.CPtr, linkage: t.CChar | t.CPtr) -> t.CInt: pass
+
+def global_set_unnamed_addr(gv: GlobalVariable | t.CPtr, level: t.CInt) -> t.CInt: pass
+
+def global_set_section(gv: GlobalVariable | t.CPtr, section: t.CChar | t.CPtr) -> t.CInt: pass
+
+
+OUTPUT_FULL: t.CDefine = 0   # 完整 IR（stub + text）
+OUTPUT_STUB: t.CDefine = 1   # 仅声明（header + 类型定义 + declare + external global）
+OUTPUT_TEXT: t.CDefine = 2   # 仅代码（define + global 带初值）
+
+def LLVMModulePrint(buf: t.CChar | t.CPtr, size: t.CSizeT, mod: LLVMModule | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mode: t.CInt) -> t.CInt: pass
+
+def _print_global(buf: t.CChar | t.CPtr, size: t.CSizeT, gv: GlobalVariable | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def _print_global_stub(buf: t.CChar | t.CPtr, size: t.CSizeT, gv: GlobalVariable | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def _append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass

.transpyc_cache/21fffba3315e81b4.doc.json

@@ -0,0 +1 @@
+{"Logger.banner": "输出分节标题（青色高亮）。", "Logger.compile_error": "格式化编译错误输出（红底白字标题 + 位置 + 错误信息）。", "Logger.compile_warning": "格式化编译警告输出（黄底黑字标题 + 位置 + 警告信息）。", "get_logger": "获取全局 logger 实例。若不存在则通过 _mbuddy 分配并初始化。", "set_logger": "设置全局 logger 实例。"}

.transpyc_cache/21fffba3315e81b4.pyi

@@ -0,0 +1,60 @@
+"""
+Auto-generated Python stub file from lib.core.VLogger.py
+Module: lib.core.VLogger
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import memhub
+import w32.win32console as w32cmd
+import w32.win32file as w32file
+import w32.win32base as w32base
+
+class LogLevel(t.CEnum):
+    DEBUG = 0
+    INFO = 1
+    WARNING = 2
+    ERROR = 3
+    SUCCESS = 4
+
+FOREGROUND_BLUE: t.CDefine = 0x0001
+FOREGROUND_GREEN: t.CDefine = 0x0002
+FOREGROUND_RED: t.CDefine = 0x0004
+FOREGROUND_INTENSITY: t.CDefine = 0x0008
+FOREGROUND_WHITE: t.CDefine = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
+FOREGROUND_CYAN: t.CDefine = FOREGROUND_BLUE | FOREGROUND_GREEN
+FOREGROUND_YELLOW: t.CDefine = FOREGROUND_RED | FOREGROUND_GREEN
+FOREGROUND_MAGENTA: t.CDefine = FOREGROUND_RED | FOREGROUND_BLUE
+BACKGROUND_RED: t.CDefine = 0x0040
+BACKGROUND_GREEN: t.CDefine = 0x0020
+BACKGROUND_BLUE: t.CDefine = 0x0010
+BACKGROUND_INTENSITY: t.CDefine = 0x0080
+BACKGROUND_WHITE: t.CDefine = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
+
+class Logger:
+    _level: int
+    _console_handle: w32base.HANDLE
+    _use_color: int
+    __mbuddy__: memhub.MemManager | t.CPtr
+    def __init__(self: Logger, level: int) -> t.CInt: pass
+    def _set_color(self: Logger, attr: WORD) -> int: pass
+    def _reset_color(self: Logger) -> int: pass
+    def _log(self: Logger, level: int, prefix: str, msg: str, color: WORD, category: str) -> int: pass
+    def debug(self: Logger, msg: str, category: str) -> int: pass
+    def info(self: Logger, msg: str, category: str) -> int: pass
+    def warning(self: Logger, msg: str, category: str) -> int: pass
+    def error(self: Logger, msg: str, category: str) -> int: pass
+    def success(self: Logger, msg: str, category: str) -> int: pass
+    def set_level(self: Logger, level: int) -> int: pass
+    def banner(self: Logger, msg: str) -> int: pass
+    def compile_error(self: Logger, msg: str, file: str, line: int) -> int: pass
+    def compile_warning(self: Logger, msg: str, file: str, line: int) -> int: pass
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+_g_logger: t.CExtern | Logger | t.CPtr
+
+def get_logger() -> Logger | t.CPtr: pass
+
+def set_logger(logger: Logger | t.CPtr) -> int: pass