snapshot before regression test

TransPyV/temp/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    "}

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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（在当前作用域）"}

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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": "翻译二元运算（自动类型提升）"}

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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 末尾"}

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/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

TransPyV/temp/21fffba3315e81b4.doc.json

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

TransPyV/temp/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

TransPyV/temp/240a9a4157959a9f.pyi

@@ -0,0 +1,38 @@
+"""
+Auto-generated Python stub file from json.__parser.py
+Module: json.__parser
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from . import JsonValue, JSON_NULL, JSON_BOOL, JSON_INT, JSON_FLOAT, JSON_STRING, JSON_ARRAY, JSON_OBJECT, null, bool_val, int_val, float_val, string_val, array, object
+
+class ParseState:
+    src: t.CChar | t.CPtr
+    pos: t.CSizeT
+    len: t.CSizeT
+    pool: memhub.MemManager | t.CPtr
+    def __init__(self: ParseState, src: t.CChar | t.CPtr, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+def _peek(s: ParseState | t.CPtr) -> t.CChar: pass
+
+def _advance(s: ParseState | t.CPtr) -> t.CChar: pass
+
+def _skip_whitespace(s: ParseState | t.CPtr) -> t.CInt: pass
+
+def _expect(s: ParseState | t.CPtr, ch: t.CChar) -> bool: pass
+
+def _parse_string(s: ParseState | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _parse_number(s: ParseState | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def _parse_value(s: ParseState | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def _parse_array(s: ParseState | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def _parse_object(s: ParseState | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def parse(pool: memhub.MemManager | t.CPtr, src: t.CChar | t.CPtr) -> JsonValue | t.CPtr: pass

TransPyV/temp/271ea3decb810db2.pyi

@@ -0,0 +1,26 @@
+"""
+Auto-generated Python stub file from atom.py
+Module: atom
+"""
+
+
+import t, c
+
+ATOMIC_RELAXED: t.CDefine = 0
+ATOMIC_CONSUME: t.CDefine = 1
+ATOMIC_ACQUIRE: t.CDefine = 2
+ATOMIC_RELEASE: t.CDefine = 3
+ATOMIC_ACQ_REL: t.CDefine = 4
+ATOMIC_SEQ_CST: t.CDefine = 5
+
+def __atomic_test_and_set(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CBool: pass
+
+def __atomic_clear(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CVoid: pass
+
+def __atomic_thread_fence(order: t.CInt) -> t.CVoid: pass
+
+def __atomic_signal_fence(order: t.CInt) -> t.CVoid: pass
+
+def __atomic_always_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass
+
+def __atomic_is_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass

TransPyV/temp/2998b8f78d7022bf.doc.json

@@ -0,0 +1 @@
+{"Translator": "翻译器：管理编译状态，委托 Handles 模块执行翻译", "Translator._init_state": "初始化变量表、函数表和子 Handle", "Translator.translate": "将 AST 翻译为 LLVM IR", "Translator._translate_wrapper_main": "委托 HandlesMain.create_wrapper_main() 创建包装 main（trans 单参）", "Translator._translate_module_level": "委托 HandlesMain.translate_children() 翻译模块级语句（trans 单参）", "Translator.dump_ir": "将 LLVM IR 输出到缓冲区\n\n        mode: 0=完整, 1=stub(仅声明), 2=text(仅代码)\n        ", "add_global_name": "添加一个 global 变量名", "is_global_name": "检查 name 是否在当前函数的 global 集合中", "add_nonlocal_name": "添加一个 nonlocal 变量名", "is_nonlocal_name": "检查 name 是否在当前函数的 nonlocal 集合中", "get_nonlocal_index": "获取 nonlocal 变量在 env 中的索引（0-based），找不到返回 -1", "clear_scope_names": "清空当前函数的 global/nonlocal 名称集合（进入新函数时调用）"}

TransPyV/temp/2998b8f78d7022bf.pyi

@@ -0,0 +1,90 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesTranslator.py
+Module: lib.core.Handles.HandlesTranslator
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import stdlib
+import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.Handles.HandlesMain as HandlesMain
+import lib.core.Handles.HandlesAssign as HandlesAssign
+import lib.core.Handles.HandlesReturn as HandlesReturn
+import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Handles.HandlesAnnAssign as HandlesAnnAssign
+import lib.core.Handles.HandlesAugAssign as HandlesAugAssign
+import lib.core.Handles.HandlesIf as HandlesIf
+import lib.core.Handles.HandlesWhile as HandlesWhile
+import lib.core.Handles.HandlesFor as HandlesFor
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesFunctions as HandlesFunctions
+import lib.Projectrans.Config as Config
+
+MAX_VARS: t.CDefine = 256
+MAX_FUNCS: t.CDefine = 256
+MAX_GLOBAL_NAMES: t.CDefine = 32
+
+@t.NoVTable
+class Translator:
+    Module: llvmlite.LLVMModule | t.CPtr
+    Pool: memhub.MemBuddy | t.CPtr
+    _funcs: HandlesExprCall.FuncEntry | t.CPtr
+    _func_count: t.CInt
+    _imported_modules: str
+    _from_imports: str
+    _cur_func: llvmlite.Function | t.CPtr
+    _cur_builder: llvmlite.IRBuilder | t.CPtr
+    _break_bb: llvmlite.BasicBlock | t.CPtr
+    _continue_bb: llvmlite.BasicBlock | t.CPtr
+    _label_counter: t.CInt
+    _global_names: str
+    _global_name_count: t.CInt
+    _nonlocal_names: str
+    _nonlocal_name_count: t.CInt
+    _cur_func_name: str
+    ModuleSha1: str
+    CurrentPackage: str
+    _closure_env_offsets: t.CInt
+    _closure_env_count: t.CInt
+    GenericTypeParamNames: list[str] | t.CPtr
+    GenericTypeArgs: list[str] | t.CPtr
+    _declare_only: t.CInt
+    AssignH: HandlesAssign.AssignHandle | t.CPtr
+    ReturnH: HandlesReturn.ReturnHandle | t.CPtr
+    ImportsH: HandlesImports.ImportsHandle | t.CPtr
+    AnnAssignH: HandlesAnnAssign.AnnAssignHandle | t.CPtr
+    AugAssignH: HandlesAugAssign.AugAssignHandle | t.CPtr
+    IfH: HandlesIf.IfHandle | t.CPtr
+    WhileH: HandlesWhile.WhileHandle | t.CPtr
+    ForH: HandlesFor.ForHandle | t.CPtr
+    ExprH: HandlesExpr.ExprHandle | t.CPtr
+    ExprCallH: HandlesExprCall.ExprCallHandle | t.CPtr
+    SymTab: HandlesVar.SymbolTable | t.CPtr
+    def __init__(self: Translator) -> t.CInt: pass
+    def _init_state(self: Translator, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+    def translate(self: Translator, tree: ast.AST | t.CPtr) -> int: pass
+    def _translate_wrapper_main(self: Translator, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, tree: ast.AST | t.CPtr, i32_ty: llvmlite.LLVMType | t.CPtr) -> t.CInt: pass
+    def _translate_module_level(self: Translator, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, tree: ast.AST | t.CPtr) -> t.CInt: pass
+    def dump_ir(self: Translator, buf: bytes, size: t.CSizeT, mode: int) -> t.CInt: pass
+
+def add_global_name(trans: HT.Translator | t.CPtr, name: str) -> t.CInt: pass
+
+def is_global_name(trans: HT.Translator | t.CPtr, name: str) -> int: pass
+
+def add_nonlocal_name(trans: HT.Translator | t.CPtr, name: str) -> t.CInt: pass
+
+def is_nonlocal_name(trans: HT.Translator | t.CPtr, name: str) -> int: pass
+
+def get_nonlocal_index(trans: HT.Translator | t.CPtr, name: str) -> int: pass
+
+def clear_scope_names(trans: HT.Translator | t.CPtr) -> t.CInt: pass
+
+
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr

TransPyV/temp/2d39c6c7d3557b3e.pyi

@@ -0,0 +1,63 @@
+"""
+Auto-generated Python stub file from linkedlist.py
+Module: linkedlist
+"""
+
+
+import t, c
+from stdint import *
+
+@t.NoVTable
+class LinkedNode:
+    next: 'LinkedNode' | t.CPtr
+    prev: 'LinkedNode' | t.CPtr
+    child: 'LinkedNode' | t.CPtr
+    last_child: 'LinkedNode' | t.CPtr
+    parent: 'LinkedNode' | t.CPtr
+    child_count: t.CSizeT
+    def append(self: LinkedNode, node: 'LinkedNode' | t.CPtr) -> t.CInt: pass
+    def prepend(self: LinkedNode, node: 'LinkedNode' | t.CPtr) -> t.CInt: pass
+    def insert_before(self: LinkedNode, node: 'LinkedNode' | t.CPtr, new_node: 'LinkedNode' | t.CPtr) -> t.CInt: pass
+    def insert_after(self: LinkedNode, node: 'LinkedNode' | t.CPtr, new_node: 'LinkedNode' | t.CPtr) -> t.CInt: pass
+    def remove_child(self: LinkedNode, node: 'LinkedNode' | t.CPtr) -> t.CInt: pass
+    def detach(self: LinkedNode) -> t.CInt: pass
+    def unlink(self: LinkedNode) -> t.CInt: pass
+    def has_children(self: LinkedNode) -> t.CInt: pass
+    def child_at(self: LinkedNode, index: t.CSizeT) -> 'LinkedNode' | t.CPtr: pass
+    def count_children(self: LinkedNode) -> t.CSizeT: pass
+    def first_sibling(self: LinkedNode) -> 'LinkedNode' | t.CPtr: pass
+    def last_sibling(self: LinkedNode) -> 'LinkedNode' | t.CPtr: pass
+@t.NoVTable
+class SListNode:
+    Next: 'SListNode' | t.CPtr
+    def append(self: SListNode, node: 'SListNode' | t.CPtr) -> 'SListNode' | t.CPtr: pass
+    def append_after(self: SListNode, node: 'SListNode' | t.CPtr) -> 'SListNode' | t.CPtr: pass
+    def count(self: SListNode) -> t.CSizeT: pass
+    def at(self: SListNode, index: t.CSizeT) -> 'SListNode' | t.CPtr: pass
+    def remove(self: SListNode, node: 'SListNode' | t.CPtr) -> 'SListNode' | t.CPtr: pass
+@t.NoVTable
+class GSListNode[T]:
+    Next: T | t.CPtr
+@t.NoVTable
+class GSList[T]:
+    Head: T | t.CPtr
+    Tail: T | t.CPtr
+    Count: t.CSizeT
+    def __init__(self: GSList) -> t.CInt: pass
+    def append(self: GSList, node: T) -> t.CInt: pass
+    def count(self: GSList) -> t.CSizeT: pass
+    def at(self: GSList, index: t.CSizeT) -> T | t.CPtr: pass
+@t.NoVTable
+class GTreeNode[T]:
+    Next: T | t.CPtr
+    Prev: T | t.CPtr
+    Child: T | t.CPtr
+    LastChild: T | t.CPtr
+    Parent: T | t.CPtr
+    Count: t.CSizeT
+    def append(self: GTreeNode, node: T | t.CPtr) -> t.CInt: pass
+    def prepend(self: GTreeNode, node: T | t.CPtr) -> t.CInt: pass
+    def detach(self: GTreeNode) -> t.CInt: pass
+    def has_children(self: GTreeNode) -> t.CInt: pass
+    def child_at(self: GTreeNode, index: t.CSizeT) -> T | t.CPtr: pass
+    def count_children(self: GTreeNode) -> t.CSizeT: pass

TransPyV/temp/2da636c61863c815.pyi

@@ -0,0 +1,33 @@
+"""
+Auto-generated Python stub file from subprocess.py
+Module: subprocess
+"""
+
+
+import t, c
+from stdint import *
+import platmacro
+import memhub
+import string
+import w32.win32base
+import w32.win32file
+import w32.win32process
+import w32.win32sync
+import posix
+
+OUTPUT_BUF_SIZE: t.CDefine = 65536
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
+
+class CompletedProcess:
+    args: str
+    returncode: int
+    stdout: str
+    stderr: str
+    def __new__(self: CompletedProcess, args: str, returncode: int, stdout: str, stderr: str) -> t.CPtr: pass
+    def __init__(self: CompletedProcess, args: str, returncode: int, stdout: str, stderr: str) -> t.CInt: pass
+
+def run(args: str, capture_output: bool, text: bool) -> CompletedProcess | t.CPtr: pass
+
+def _run_win32(args: str, capture_output: bool, text: bool) -> CompletedProcess | t.CPtr: pass
+
+def _run_posix(args: str, capture_output: bool, text: bool) -> CompletedProcess | t.CPtr: pass

TransPyV/temp/2ed380190e9df89e.doc.json

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

TransPyV/temp/2ed380190e9df89e.pyi

@@ -0,0 +1,33 @@
+"""
+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
+
+def is_cdefine_annotation(annot: ast.AST | t.CPtr) -> int: pass
+
+def extract_cdefine_int_value(val_node: ast.AST | t.CPtr) -> int: pass
+
+
+@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

TransPyV/temp/34548789d646f432.pyi

@@ -0,0 +1,26 @@
+"""
+Auto-generated Python stub file from ast.__init__.py
+Module: ast.__init__
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from .tokens import Token, TokenType, Keyword, TokOp, _init_tables
+from .base import AST, ASTKind, ASTCtx, OpKind, ASTFlag, CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE, FLAG_IS_ASYNC, FLAG_SIMPLE, FLAG_HAS_STAR, _init_ast, _copy_str, _set_pos, _inherit_pos, _set_parent_list, _binop_from_op, _augop_from_op, _cmpop_from_op, _emit, _emit_str, _emit_int, _dump_list, dump
+from .stmts import Module, Expression, Interactive, FunctionType, FunctionDef, ClassDef, Return, Delete, Assign, AugAssign, AnnAssign, For, While, If, With, Raise, Try, Assert, Global, Nonlocal, Pass, Break, Continue, Expr, Import, ImportFrom, Match
+from .exprs import BoolOp, BinOp, UnaryOp, Lambda, IfExp, Dict, Set, ListComp, SetComp, DictComp, GeneratorExp, Await, Yield, YieldFrom, FormattedValue, JoinedStr, Constant, NamedExpr, Attribute, Subscript, Starred, Name, List, Tuple, Slice, Call, Compare, OpNode
+from .astaux import ExceptHandler, Arguments, Arg, Keyword, Alias, WithItem, Comprehension
+from .match import MatchCase, MatchValue, MatchSingleton, MatchSequence, MatchMapping, MatchClass, MatchStar, MatchAs, MatchOr
+from .visitor import ASTVisitor
+from .lexer import Lexer, _lexer_init, tokenize, new_lexer
+from .parser import Parser, _parser_init, parse_tokens, new_parser
+from .parser import _parse_test
+
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
+
+def parse(src: str, pool: memhub.MemManager | t.CPtr) -> AST | t.CPtr: pass
+
+def parse_expression(src: str, pool: memhub.MemManager | t.CPtr) -> AST | t.CPtr: pass

TransPyV/temp/3d3edda4a4e6c08b.doc.json

@@ -0,0 +1 @@
+{"AssignHandle": "Assign 语句处理器：继承 Mixin 获得 Trans 回指针 + 共享方法"}

TransPyV/temp/3d3edda4a4e6c08b.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesAssign.py
+Module: lib.core.Handles.HandlesAssign
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+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.HandlesExpr as HandlesExpr
+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
+
+@t.NoVTable
+class AssignHandle(HandlesBase.Mixin):
+    _CurrentClass: str
+    def __init__(self: AssignHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def Handle(self: AssignHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewAssignHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> AssignHandle | t.CPtr: pass

TransPyV/temp/4020cac9bab5e9f1.doc.json

@@ -0,0 +1 @@
+{"extract_func_attrs": "从 decorator_list 提取 c.Attribute 属性，返回 LLVM IR 属性字符串", "_get_attr_name_from_node": "从 AST 节点提取属性名\n\n    支持:\n    - Call(func=Attribute(...)): t.attr.always_inline() -> \"always_inline\"\n    - Attribute: t.attr.packed -> \"packed\"\n    - Attribute(t.attr.llvm.xxx): t.attr.llvm.nounwind -> \"nounwind\"\n    ", "_append_llvm_attr": "将属性名映射到 LLVM 属性名并追加到缓冲区\n\n    返回 1 表示已追加，0 表示不支持该属性\n    ", "_append_str": "将字符串追加到 buf 末尾（用 strlen+strcpy 模拟 strcat）", "_mangle_name": "为任意名称添加 SHA1 前缀（不做 main/export 检查）", "_mangle_name_with_sha1": "用指定 SHA1 为名称添加前缀（不做 main/export 检查）", "_mangle_func_name": "为函数名添加 SHA1 前缀（检查 main/export）", "forward_declare_functions": "预扫描所有顶层 FunctionDef，创建前向声明", "translate_function_def": "翻译函数定义，返回新增的变量数（通常为 0，函数定义不增加当前作用域变量）", "translate_nested_function_def": "翻译嵌套函数定义：提升为顶层函数 + 创建闭包", "create_function": "创建 LLVM 函数并添加参数"}

TransPyV/temp/4020cac9bab5e9f1.pyi

@@ -0,0 +1,45 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesFunctions.py
+Module: lib.core.Handles.HandlesFunctions
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import viperlib
+import stdio
+import stdlib
+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.HandlesType as HandlesType
+import lib.core.Handles.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesBody as HandlesBody
+import lib.core.Handles.HandlesNonlocal as HandlesNonlocal
+import lib.core.Handles.HandlesImports as HandlesImports
+
+def extract_func_attrs(pool: memhub.MemBuddy | t.CPtr, decorator_list: list[ast.AST | t.CPtr] | t.CPtr, imported_modules: str) -> t.CChar | t.CPtr: pass
+
+def _get_attr_name_from_node(node: ast.AST | t.CPtr) -> str: pass
+
+def _append_llvm_attr(attrs_buf: t.CChar | t.CPtr, attr_name: str) -> int: pass
+
+def _append_str(buf: t.CChar | t.CPtr, s: str) -> None: pass
+
+def _mangle_name(trans: HT.Translator | t.CPtr, name: str) -> str: pass
+
+def _mangle_name_with_sha1(sha1: str, name: str) -> str: pass
+
+def _mangle_func_name(trans: HT.Translator | t.CPtr, name: str, has_export: int) -> str: pass
+
+def forward_declare_functions(trans: HT.Translator | t.CPtr, tree: ast.AST | t.CPtr) -> int: pass
+
+def translate_function_def(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def translate_nested_function_def(trans: HT.Translator | t.CPtr, node: ast.AST | t.CPtr) -> int: pass
+
+def create_function(pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, name: str, args_node: ast.AST | t.CPtr, ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Function | t.CPtr: pass

TransPyV/temp/4337fb260448bbe2.pyi

@@ -0,0 +1,73 @@
+"""
+Auto-generated Python stub file from ast.astaux.py
+Module: ast.astaux
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from .base import AST, ASTKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list
+
+class ExceptHandler(AST):
+    type: AST | t.CPtr
+    name: str
+    def __new__(self: ExceptHandler, pool: memhub.MemManager | t.CPtr, type: AST | t.CPtr, name: str) -> t.CInt: pass
+    def __init__(self: ExceptHandler, pool: memhub.MemManager | t.CPtr, type: AST | t.CPtr, name: str) -> t.CInt: pass
+    def kind(self: ExceptHandler) -> t.CInt: pass
+    def type_name(self: ExceptHandler) -> str: pass
+    def dump(self: ExceptHandler, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Arguments(AST):
+    args: list[AST | t.CPtr] | t.CPtr
+    vararg: AST | t.CPtr
+    kwarg: AST | t.CPtr
+    defaults: list[AST | t.CPtr] | t.CPtr
+    kw_defaults: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Arguments, pool: memhub.MemManager | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, vararg: AST | t.CPtr, kwarg: AST | t.CPtr, defaults: list[AST | t.CPtr] | t.CPtr, kw_defaults: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Arguments, pool: memhub.MemManager | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, vararg: AST | t.CPtr, kwarg: AST | t.CPtr, defaults: list[AST | t.CPtr] | t.CPtr, kw_defaults: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Arguments) -> t.CInt: pass
+    def type_name(self: Arguments) -> str: pass
+    def dump(self: Arguments, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Arg(AST):
+    arg: str
+    annotation: AST | t.CPtr
+    def __new__(self: Arg, pool: memhub.MemManager | t.CPtr, arg: str, annotation: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Arg, pool: memhub.MemManager | t.CPtr, arg: str, annotation: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Arg) -> t.CInt: pass
+    def type_name(self: Arg) -> str: pass
+    def dump(self: Arg, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Keyword(AST):
+    arg: str
+    value: AST | t.CPtr
+    def __new__(self: Keyword, pool: memhub.MemManager | t.CPtr, arg: str, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Keyword, pool: memhub.MemManager | t.CPtr, arg: str, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Keyword) -> t.CInt: pass
+    def type_name(self: Keyword) -> str: pass
+    def dump(self: Keyword, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Alias(AST):
+    name: str
+    asname: str
+    def __new__(self: Alias, pool: memhub.MemManager | t.CPtr, name: str, asname: str) -> t.CInt: pass
+    def __init__(self: Alias, pool: memhub.MemManager | t.CPtr, name: str, asname: str) -> t.CInt: pass
+    def kind(self: Alias) -> t.CInt: pass
+    def type_name(self: Alias) -> str: pass
+    def dump(self: Alias, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class WithItem(AST):
+    context_expr: AST | t.CPtr
+    optional_vars: AST | t.CPtr
+    def __new__(self: WithItem, pool: memhub.MemManager | t.CPtr, context_expr: AST | t.CPtr, optional_vars: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: WithItem, pool: memhub.MemManager | t.CPtr, context_expr: AST | t.CPtr, optional_vars: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: WithItem) -> t.CInt: pass
+    def type_name(self: WithItem) -> str: pass
+    def dump(self: WithItem, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Comprehension(AST):
+    target: AST | t.CPtr
+    iter: AST | t.CPtr
+    ifs: list[AST | t.CPtr] | t.CPtr
+    is_async: t.CInt
+    def __new__(self: Comprehension, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, ifs: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def __init__(self: Comprehension, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, ifs: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def kind(self: Comprehension) -> t.CInt: pass
+    def type_name(self: Comprehension) -> str: pass
+    def dump(self: Comprehension, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

TransPyV/temp/455ff4e74c3dbfb0.pyi

@@ -0,0 +1,120 @@
+"""
+Auto-generated Python stub file from llvmlite.__types.py
+Module: llvmlite.__types
+"""
+
+
+import t, c
+from stdint import *
+import viperlib
+import string
+import memhub
+from linkedlist import GSListNode
+
+class ParamNode(GSListNode[ParamNode]):
+    Ty: t.CVoid | t.CPtr
+class LLVMType(t.REnum):
+    class Int:
+        Bits: t.CInt
+    class Ptr:
+        Pointee: LLVMType | t.CPtr
+    class Func:
+        Ret: LLVMType | t.CPtr
+        Params: ParamNode | t.CPtr
+        PCount: t.CInt
+    class Array:
+        ElemTy: LLVMType | t.CPtr
+        Count: t.CInt
+    class Struct:
+        Fields: ParamNode | t.CPtr
+        FCount: t.CInt
+        Name: t.CChar | t.CPtr
+    class Float:
+        Bits: t.CInt
+    class Void:
+        pass
+    class Label:
+        pass
+    class Metadata:
+        pass
+
+def _new_type(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Int1(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Int8(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Int16(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Int32(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Int64(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Ptr(pool: memhub.MemBuddy | t.CPtr, pointee: LLVMType | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Func(pool: memhub.MemBuddy | t.CPtr, ret: LLVMType | t.CPtr, params: ParamNode | t.CPtr, count: t.CInt) -> LLVMType | t.CPtr: pass
+
+def Void(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Array(pool: memhub.MemBuddy | t.CPtr, elem_ty: LLVMType | t.CPtr, count: t.CInt) -> LLVMType | t.CPtr: pass
+
+def Struct(pool: memhub.MemBuddy | t.CPtr, fields: ParamNode | t.CPtr, fcount: t.CInt, name: t.CChar | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Half(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Float(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Double(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def FP128(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def Label(pool: memhub.MemBuddy | t.CPtr) -> LLVMType | t.CPtr: pass
+
+
+PNODE_SIZE: t.CDefine = 16
+
+def new_param_node(pool: memhub.MemBuddy | t.CPtr, ty: LLVMType | t.CPtr) -> ParamNode | t.CPtr: pass
+
+def param_list_append(head: ParamNode | t.CPtr, tail: ParamNode | t.CPtr, node: ParamNode | t.CPtr) -> ParamNode | t.CPtr: pass
+
+def paramnode_get_ty(node: ParamNode | t.CPtr) -> LLVMType | t.CPtr: pass
+
+def paramnode_get_next(node: ParamNode | t.CPtr) -> ParamNode | t.CPtr: pass
+
+def paramnode_set_ty(node: ParamNode | t.CPtr, ty: LLVMType | t.CPtr) -> t.CInt: pass
+
+def paramnode_set_next(node: ParamNode | t.CPtr, nxt: ParamNode | t.CPtr) -> t.CInt: pass
+
+
+@t.NoVTable
+class LLVMTypeCore:
+    Pool: memhub.MemBuddy | t.CPtr
+    def __init__(self: LLVMTypeCore, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+    def Int1(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Int8(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Int16(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Int32(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Int64(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Ptr(self: LLVMTypeCore, pointee: LLVMType | t.CPtr) -> LLVMType | t.CPtr: pass
+    def Func(self: LLVMTypeCore, ret: LLVMType | t.CPtr, params: ParamNode | t.CPtr, count: t.CInt) -> LLVMType | t.CPtr: pass
+    def Array(self: LLVMTypeCore, elem_ty: LLVMType | t.CPtr, count: t.CInt) -> LLVMType | t.CPtr: pass
+    def Struct(self: LLVMTypeCore, fields: ParamNode | t.CPtr, fcount: t.CInt, name: t.CChar | t.CPtr) -> LLVMType | t.CPtr: pass
+    def Void(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Half(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Float(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Double(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def FP128(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def Label(self: LLVMTypeCore) -> LLVMType | t.CPtr: pass
+    def NewParamNode(self: LLVMTypeCore, ty: LLVMType | t.CPtr) -> ParamNode | t.CPtr: pass
+    def ParamListAppend(self: LLVMTypeCore, head: ParamNode | t.CPtr, tail: ParamNode | t.CPtr, node: ParamNode | t.CPtr) -> ParamNode | t.CPtr: pass
+    def PrintType(self: LLVMTypeCore, buf: t.CChar | t.CPtr, size: t.CSizeT, ty: LLVMType | t.CPtr) -> t.CInt: pass
+
+def TypePrint(buf: t.CChar | t.CPtr, size: t.CSizeT, ty: LLVMType | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def _strappend(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _print_struct_body(buf: t.CChar | t.CPtr, size: t.CSizeT, fields: ParamNode | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def PrintStructDefinition(buf: t.CChar | t.CPtr, size: t.CSizeT, ty: LLVMType | t.CPtr, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+
+def get_struct_name(ty: LLVMType | t.CPtr) -> t.CChar | t.CPtr: pass

TransPyV/temp/46ea362b72c10a9e.pyi

@@ -0,0 +1,219 @@
+"""
+Auto-generated Python stub file from llvmlite.__builder.py
+Module: llvmlite.__builder
+"""
+
+
+import t, c
+from stdint import *
+import string
+import viperlib
+import memhub
+from linkedlist import GSListNode, GSList
+from .__types import LLVMType, TypePrint
+from .__values import Value, new_value, SSAValue
+from .__function import Function, BasicBlock, block_append_text, function_move_block_to_end, _ll_name_needs_quote
+
+class IRBuilder:
+    Pool: memhub.MemBuddy | t.CPtr
+    Func: Function | t.CPtr
+    CurBlock: BasicBlock | t.CPtr
+    Counter: t.CInt
+
+BUILDER_SIZE: t.CDefine = 32
+
+def new_builder(pool: memhub.MemBuddy | t.CPtr, func: Function | t.CPtr) -> IRBuilder | t.CPtr: pass
+
+def position_at_end(builder: IRBuilder | t.CPtr, block: BasicBlock | t.CPtr) -> t.CInt: pass
+
+def _alloc_ssa_name(builder: IRBuilder | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _type_str(builder: IRBuilder | t.CPtr, ty: LLVMType | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def _emit(builder: IRBuilder | t.CPtr, text: t.CChar | t.CPtr) -> t.CInt: pass
+
+def _mark_terminated(builder: IRBuilder | t.CPtr) -> t.CInt: pass
+
+def builder_cur_block_is_terminated(builder: IRBuilder | t.CPtr) -> t.CInt: pass
+
+def build_alloca(builder: IRBuilder | t.CPtr, ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_load(builder: IRBuilder | t.CPtr, ty: LLVMType | t.CPtr, ptr: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_store(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, ptr: Value | t.CPtr) -> t.CInt: pass
+
+def build_add(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_sub(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_mul(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_sdiv(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_udiv(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_srem(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_urem(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_and(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_or(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_xor(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_shl(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_lshr(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_ashr(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fadd(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fsub(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fmul(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fdiv(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_frem(builder: IRBuilder | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fneg(builder: IRBuilder | t.CPtr, val: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def _build_binop(builder: IRBuilder | t.CPtr, op: t.CChar | t.CPtr, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+
+ICMP_EQ:  t.CDefine = 0
+ICMP_NE:  t.CDefine = 1
+ICMP_SGT: t.CDefine = 2
+ICMP_SGE: t.CDefine = 3
+ICMP_SLT: t.CDefine = 4
+ICMP_SLE: t.CDefine = 5
+ICMP_UGT: t.CDefine = 6
+ICMP_UGE: t.CDefine = 7
+ICMP_ULT: t.CDefine = 8
+ICMP_ULE: t.CDefine = 9
+FCMP_FALSE: t.CDefine = 0
+FCMP_OEQ:   t.CDefine = 1
+FCMP_OGT:   t.CDefine = 2
+FCMP_OGE:   t.CDefine = 3
+FCMP_OLT:   t.CDefine = 4
+FCMP_OLE:   t.CDefine = 5
+FCMP_ONE:   t.CDefine = 6
+FCMP_ORD:   t.CDefine = 7
+FCMP_UNO:   t.CDefine = 8
+FCMP_UEQ:   t.CDefine = 9
+FCMP_UGT:   t.CDefine = 10
+FCMP_UGE:   t.CDefine = 11
+FCMP_ULT:   t.CDefine = 12
+FCMP_ULE:   t.CDefine = 13
+FCMP_UNE:   t.CDefine = 14
+FCMP_TRUE:  t.CDefine = 15
+
+def _icmp_pred_str(pred: t.CInt) -> t.CChar | t.CPtr: pass
+
+def _fcmp_pred_str(pred: t.CInt) -> t.CChar | t.CPtr: pass
+
+def build_icmp(builder: IRBuilder | t.CPtr, pred: t.CInt, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fcmp(builder: IRBuilder | t.CPtr, pred: t.CInt, lhs: Value | t.CPtr, rhs: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_br(builder: IRBuilder | t.CPtr, target: BasicBlock | t.CPtr) -> t.CInt: pass
+
+def build_cond_br(builder: IRBuilder | t.CPtr, cond: Value | t.CPtr, then_blk: BasicBlock | t.CPtr, else_blk: BasicBlock | t.CPtr) -> t.CInt: pass
+
+def build_ret(builder: IRBuilder | t.CPtr, val: Value | t.CPtr) -> t.CInt: pass
+
+def build_ret_void(builder: IRBuilder | t.CPtr) -> t.CInt: pass
+
+def build_call(builder: IRBuilder | t.CPtr, callee: t.CChar | t.CPtr, args: Value | t.CPtr, arg_count: t.CInt, ret_ty: LLVMType | t.CPtr, is_variadic: t.CInt) -> Value | t.CPtr: pass
+
+def build_call_indirect(builder: IRBuilder | t.CPtr, callee_val: Value | t.CPtr, args: Value | t.CPtr, arg_count: t.CInt, ret_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_bitcast(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_sext(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_trunc(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_zext(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_ptrtoint(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_inttoptr(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fpext(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fptrunc(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fp2si(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_si2fp(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_fp2ui(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_ui2fp(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, to_ty: LLVMType | t.CPtr) -> Value | t.CPtr: pass
+
+def build_gep(builder: IRBuilder | t.CPtr, elem_ty: LLVMType | t.CPtr, ptr: Value | t.CPtr, idx: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_gep_array(builder: IRBuilder | t.CPtr, array_ty: LLVMType | t.CPtr, elem_ty: LLVMType | t.CPtr, ptr: Value | t.CPtr, idx: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_gep_struct(builder: IRBuilder | t.CPtr, struct_ty: LLVMType | t.CPtr, field_ty: LLVMType | t.CPtr, ptr: Value | t.CPtr, field_idx: t.CInt) -> Value | t.CPtr: pass
+
+
+class PhiIncoming(GSListNode[PhiIncoming]):
+    Val: Value | t.CPtr
+    Block: BasicBlock | t.CPtr
+
+PHIINC_SIZE: t.CDefine = 24
+
+def new_phi_incoming(pool: memhub.MemBuddy | t.CPtr, val: Value | t.CPtr, block: BasicBlock | t.CPtr) -> PhiIncoming | t.CPtr: pass
+
+def build_phi(builder: IRBuilder | t.CPtr, ty: LLVMType | t.CPtr, incoming_head: PhiIncoming | t.CPtr, count: t.CInt) -> Value | t.CPtr: pass
+
+
+class SwitchCase(GSListNode[SwitchCase]):
+    CaseVal: Value | t.CPtr
+    Block: BasicBlock | t.CPtr
+
+SWCASE_SIZE: t.CDefine = 24
+
+def new_switch_case(pool: memhub.MemBuddy | t.CPtr, case_val: Value | t.CPtr, block: BasicBlock | t.CPtr) -> SwitchCase | t.CPtr: pass
+
+def build_switch(builder: IRBuilder | t.CPtr, val: Value | t.CPtr, default_blk: BasicBlock | t.CPtr, cases_head: SwitchCase | t.CPtr, case_count: t.CInt) -> t.CInt: pass
+
+def build_select(builder: IRBuilder | t.CPtr, cond: Value | t.CPtr, true_val: Value | t.CPtr, false_val: Value | t.CPtr) -> Value | t.CPtr: pass
+
+def build_unreachable(builder: IRBuilder | t.CPtr) -> t.CInt: pass
+
+
+ATOMIC_XCHG:  t.CDefine = 0
+ATOMIC_ADD:   t.CDefine = 1
+ATOMIC_SUB:   t.CDefine = 2
+ATOMIC_AND:   t.CDefine = 3
+ATOMIC_NAND:  t.CDefine = 4
+ATOMIC_OR:    t.CDefine = 5
+ATOMIC_XOR:   t.CDefine = 6
+ATOMIC_MAX:   t.CDefine = 7
+ATOMIC_MIN:   t.CDefine = 8
+ATOMIC_UMAX:  t.CDefine = 9
+ATOMIC_UMIN:  t.CDefine = 10
+ATOMIC_ORDER_NOTATOMIC:  t.CDefine = 0
+ATOMIC_ORDER_UNORDERED:  t.CDefine = 1
+ATOMIC_ORDER_MONOTONIC:  t.CDefine = 2
+ATOMIC_ORDER_ACQUIRE:    t.CDefine = 3
+ATOMIC_ORDER_RELEASE:    t.CDefine = 4
+ATOMIC_ORDER_ACQ_REL:    t.CDefine = 5
+ATOMIC_ORDER_SEQ_CST:    t.CDefine = 6
+
+def _atomic_op_str(op: t.CInt) -> t.CChar | t.CPtr: pass
+
+def _atomic_order_str(ord: t.CInt) -> t.CChar | t.CPtr: pass
+
+def build_atomicrmw(builder: IRBuilder | t.CPtr, op: t.CInt, ptr: Value | t.CPtr, val: Value | t.CPtr, order: t.CInt) -> Value | t.CPtr: pass
+
+def build_cmpxchg(builder: IRBuilder | t.CPtr, ptr: Value | t.CPtr, cmp_val: Value | t.CPtr, new_val: Value | t.CPtr, succ_order: t.CInt, fail_order: t.CInt) -> Value | t.CPtr: pass
+
+def build_inline_asm(builder: IRBuilder | t.CPtr, ret_ty: LLVMType | t.CPtr, asm_text: t.CChar | t.CPtr, constraints: t.CChar | t.CPtr, has_side_effects: t.CInt) -> Value | t.CPtr: pass
+
+def _append_cstr(dst: t.CChar | t.CPtr, dst_size: t.CSizeT, src: t.CChar | t.CPtr) -> t.CInt: pass

TransPyV/temp/47767b5026a8ee15.pyi

@@ -0,0 +1,241 @@
+"""
+Auto-generated Python stub file from ast.exprs.py
+Module: ast.exprs
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from .base import AST, ASTKind, ASTCtx, OpKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list, _dump_op_list, _op_name, CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE
+
+class Name(AST):
+    id: str
+    ctx: t.CInt
+    def __new__(self: Name, pool: memhub.MemManager | t.CPtr, id: str, ctx: t.CInt) -> t.CInt: pass
+    def __init__(self: Name, pool: memhub.MemManager | t.CPtr, id: str, ctx: t.CInt) -> t.CInt: pass
+    def kind(self: Name) -> t.CInt: pass
+    def type_name(self: Name) -> str: pass
+    def dump(self: Name, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Constant(AST):
+    int_val: t.CInt64T
+    float_val: t.CDouble
+    str_val: str
+    const_kind: t.CInt
+    def __new__(self: Constant, pool: memhub.MemManager | t.CPtr, const_kind: t.CInt, int_val: t.CInt64T, float_val: t.CDouble, str_val: str, lineno: t.CInt, col: t.CInt) -> t.CInt: pass
+    def __init__(self: Constant, pool: memhub.MemManager | t.CPtr, const_kind: t.CInt, int_val: t.CInt64T, float_val: t.CDouble, str_val: str, lineno: t.CInt, col: t.CInt) -> t.CInt: pass
+    def kind(self: Constant) -> t.CInt: pass
+    def type_name(self: Constant) -> str: pass
+    def dump(self: Constant, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class BinOp(AST):
+    left: AST | t.CPtr
+    op: t.CInt
+    right: AST | t.CPtr
+    def __new__(self: BinOp, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, op: t.CInt, right: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: BinOp, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, op: t.CInt, right: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: BinOp) -> t.CInt: pass
+    def type_name(self: BinOp) -> str: pass
+    def dump(self: BinOp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class UnaryOp(AST):
+    op: t.CInt
+    operand: AST | t.CPtr
+    def __new__(self: UnaryOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, operand: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: UnaryOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, operand: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: UnaryOp) -> t.CInt: pass
+    def type_name(self: UnaryOp) -> str: pass
+    def dump(self: UnaryOp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Compare(AST):
+    left: AST | t.CPtr
+    ops: t.CPtr
+    comparators: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Compare, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, ops: t.CPtr, comparators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Compare, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, ops: t.CPtr, comparators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Compare) -> t.CInt: pass
+    def type_name(self: Compare) -> str: pass
+    def dump(self: Compare, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Call(AST):
+    func: AST | t.CPtr
+    args: list[AST | t.CPtr] | t.CPtr
+    keywords: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Call, pool: memhub.MemManager | t.CPtr, func: AST | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Call, pool: memhub.MemManager | t.CPtr, func: AST | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Call) -> t.CInt: pass
+    def type_name(self: Call) -> str: pass
+    def dump(self: Call, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class BoolOp(AST):
+    op: t.CInt
+    values: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: BoolOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: BoolOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: BoolOp) -> t.CInt: pass
+    def type_name(self: BoolOp) -> str: pass
+    def dump(self: BoolOp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Lambda(AST):
+    args: AST | t.CPtr
+    body: AST | t.CPtr
+    def __new__(self: Lambda, pool: memhub.MemManager | t.CPtr, args: AST | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Lambda, pool: memhub.MemManager | t.CPtr, args: AST | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Lambda) -> t.CInt: pass
+    def type_name(self: Lambda) -> str: pass
+    def dump(self: Lambda, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class IfExp(AST):
+    test: AST | t.CPtr
+    body: AST | t.CPtr
+    orelse: AST | t.CPtr
+    def __new__(self: IfExp, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, body: AST | t.CPtr, orelse: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: IfExp, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, body: AST | t.CPtr, orelse: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: IfExp) -> t.CInt: pass
+    def type_name(self: IfExp) -> str: pass
+    def dump(self: IfExp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Dict(AST):
+    keys: list[AST | t.CPtr] | t.CPtr
+    values: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Dict, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Dict, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Dict) -> t.CInt: pass
+    def type_name(self: Dict) -> str: pass
+    def dump(self: Dict, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Set(AST):
+    elts: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Set, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Set, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Set) -> t.CInt: pass
+    def type_name(self: Set) -> str: pass
+    def dump(self: Set, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class ListComp(AST):
+    elt: AST | t.CPtr
+    generators: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: ListComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: ListComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: ListComp) -> t.CInt: pass
+    def type_name(self: ListComp) -> str: pass
+    def dump(self: ListComp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class SetComp(AST):
+    elt: AST | t.CPtr
+    generators: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: SetComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: SetComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: SetComp) -> t.CInt: pass
+    def type_name(self: SetComp) -> str: pass
+    def dump(self: SetComp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class DictComp(AST):
+    key: AST | t.CPtr
+    value: AST | t.CPtr
+    generators: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: DictComp, pool: memhub.MemManager | t.CPtr, key: AST | t.CPtr, value: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: DictComp, pool: memhub.MemManager | t.CPtr, key: AST | t.CPtr, value: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: DictComp) -> t.CInt: pass
+    def type_name(self: DictComp) -> str: pass
+    def dump(self: DictComp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class GeneratorExp(AST):
+    elt: AST | t.CPtr
+    generators: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: GeneratorExp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: GeneratorExp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: GeneratorExp) -> t.CInt: pass
+    def type_name(self: GeneratorExp) -> str: pass
+    def dump(self: GeneratorExp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Await(AST):
+    value: AST | t.CPtr
+    def __new__(self: Await, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Await, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Await) -> t.CInt: pass
+    def type_name(self: Await) -> str: pass
+    def dump(self: Await, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Yield(AST):
+    value: AST | t.CPtr
+    def __new__(self: Yield, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Yield, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Yield) -> t.CInt: pass
+    def type_name(self: Yield) -> str: pass
+    def dump(self: Yield, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class YieldFrom(AST):
+    value: AST | t.CPtr
+    def __new__(self: YieldFrom, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: YieldFrom, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: YieldFrom) -> t.CInt: pass
+    def type_name(self: YieldFrom) -> str: pass
+    def dump(self: YieldFrom, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class FormattedValue(AST):
+    value: AST | t.CPtr
+    conversion: t.CInt
+    format_spec: AST | t.CPtr
+    def __new__(self: FormattedValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, conversion: t.CInt, format_spec: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: FormattedValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, conversion: t.CInt, format_spec: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: FormattedValue) -> t.CInt: pass
+    def type_name(self: FormattedValue) -> str: pass
+    def dump(self: FormattedValue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class JoinedStr(AST):
+    values: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: JoinedStr, pool: memhub.MemManager | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: JoinedStr, pool: memhub.MemManager | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: JoinedStr) -> t.CInt: pass
+    def type_name(self: JoinedStr) -> str: pass
+    def dump(self: JoinedStr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Attribute(AST):
+    value: AST | t.CPtr
+    attr: str
+    ctx: t.CInt
+    def __new__(self: Attribute, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, attr: str, ctx: t.CInt) -> t.CInt: pass
+    def __init__(self: Attribute, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, attr: str, ctx: t.CInt) -> t.CInt: pass
+    def kind(self: Attribute) -> t.CInt: pass
+    def type_name(self: Attribute) -> str: pass
+    def dump(self: Attribute, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Subscript(AST):
+    value: AST | t.CPtr
+    slice: AST | t.CPtr
+    ctx: t.CInt
+    def __new__(self: Subscript, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, slice: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def __init__(self: Subscript, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, slice: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def kind(self: Subscript) -> t.CInt: pass
+    def type_name(self: Subscript) -> str: pass
+    def dump(self: Subscript, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Starred(AST):
+    value: AST | t.CPtr
+    ctx: t.CInt
+    def __new__(self: Starred, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def __init__(self: Starred, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def kind(self: Starred) -> t.CInt: pass
+    def type_name(self: Starred) -> str: pass
+    def dump(self: Starred, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class List(AST):
+    elts: list[AST | t.CPtr] | t.CPtr
+    ctx: t.CInt
+    def __new__(self: List, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def __init__(self: List, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def kind(self: List) -> t.CInt: pass
+    def type_name(self: List) -> str: pass
+    def dump(self: List, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Tuple(AST):
+    elts: list[AST | t.CPtr] | t.CPtr
+    ctx: t.CInt
+    def __new__(self: Tuple, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def __init__(self: Tuple, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
+    def kind(self: Tuple) -> t.CInt: pass
+    def type_name(self: Tuple) -> str: pass
+    def dump(self: Tuple, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Slice(AST):
+    lower: AST | t.CPtr
+    upper: AST | t.CPtr
+    step: AST | t.CPtr
+    def __new__(self: Slice, pool: memhub.MemManager | t.CPtr, lower: AST | t.CPtr, upper: AST | t.CPtr, step: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Slice, pool: memhub.MemManager | t.CPtr, lower: AST | t.CPtr, upper: AST | t.CPtr, step: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Slice) -> t.CInt: pass
+    def type_name(self: Slice) -> str: pass
+    def dump(self: Slice, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class NamedExpr(AST):
+    target: AST | t.CPtr
+    value: AST | t.CPtr
+    def __new__(self: NamedExpr, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: NamedExpr, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: NamedExpr) -> t.CInt: pass
+    def type_name(self: NamedExpr) -> str: pass
+    def dump(self: NamedExpr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class OpNode(AST):
+    op: t.CInt
+    def __new__(self: OpNode, pool: memhub.MemManager | t.CPtr, op: t.CInt) -> t.CInt: pass
+    def __init__(self: OpNode, pool: memhub.MemManager | t.CPtr, op: t.CInt) -> t.CInt: pass
+    def kind(self: OpNode) -> t.CInt: pass
+    def type_name(self: OpNode) -> str: pass
+    def dump(self: OpNode, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

TransPyV/temp/48fa8cc758d3826b.doc.json

@@ -0,0 +1 @@
+{"ForHandle": "for 循环语句处理器：继承 Mixin 获得 Trans 回指针", "ForHandle.Handle": "翻译 for i in range(...) 循环语句", "ForHandle._handle_ptr_iter": "指针迭代: for x in ptr: 直到解引用为空"}

TransPyV/temp/48fa8cc758d3826b.pyi

@@ -0,0 +1,28 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesFor.py
+Module: lib.core.Handles.HandlesFor
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+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.HandlesExpr as HandlesExpr
+import lib.core.Handles.HandlesBody as HandlesBody
+import lib.core.Handles.HandlesType as HandlesType
+
+@t.NoVTable
+class ForHandle(HandlesBase.Mixin):
+    def __init__(self: ForHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def Handle(self: ForHandle, node: ast.AST | t.CPtr) -> int: pass
+    def _handle_ptr_iter(self: ForHandle, for_node: ast.For | t.CPtr, var_name: str) -> int: pass
+
+def NewForHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> ForHandle | t.CPtr: pass

TransPyV/temp/49cf633017627a4a.doc.json

@@ -0,0 +1 @@
+{"Load_project_config": "加载工程配置文件（project.vpj）\n\n    Args:\n        path: 配置文件路径\n\n    Returns:\n        0 表示成功，非 0 表示失败\n    ", "_join_flags_array": "将 JSON 字符串数组拼接成空格分隔的字符串\n\n    用于 linker.flags 和 compiler.flags 数组。\n    用 while + 索引遍历，避免 list 迭代器 bug。\n\n    Args:\n        flags_val: JsonValue，应为字符串数组\n\n    Returns:\n        空格分隔的字符串，或 None 如果 flags_val 为 None 或非数组或空数组\n    ", "_join_path": "将相对路径与 project_dir 拼接为绝对路径\n\n    - ./App + Test → Test/App\n    - ./temp + Test → Test/temp\n    - ../includes + Test → Test/../includes（OS 解析为 includes）\n    - 绝对路径保持不变\n    - None 返回 None\n    ", "resolve_paths": "解析并规范化工程路径（src/temp/output/includes）\n\n    将 project.vpj 中的相对路径（以 ./ 开头）转换为基于 project_dir 的路径。\n\n    Args:\n        project_dir: 工程根目录（project.vpj 所在目录）\n\n    Returns:\n        0 表示成功，非 0 表示失败\n    ", "get_includes_binary_dir": "获取 includes.binary 目录路径（includes 目录 + .binary 后缀）\n\n    includes 目录如 ../includes，则 includes.binary 为 ../includes.binary\n    ", "print_config": "打印当前配置（调试用）"}

TransPyV/temp/49cf633017627a4a.pyi

@@ -0,0 +1,44 @@
+"""
+Auto-generated Python stub file from lib.Projectrans.Config.py
+Module: lib.Projectrans.Config
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import stdio
+import viperlib
+from json.__parser import parse as json_parse
+from json import JsonValue, JSON_OBJECT, JSON_INT
+import w32.fileio as fileio
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+SourceDir: t.CExtern | str
+TempDir: t.CExtern | str
+OutputDir: t.CExtern | str
+ProjectName: t.CExtern | str
+ProjectVersion: t.CExtern | str
+CompilerCmd: t.CExtern | str
+CompilerFlags: t.CExtern | str
+LinkerCmd: t.CExtern | str
+LinkerFlags: t.CExtern | str
+LinkerOutput: t.CExtern | str
+TargetTriple: t.CExtern | str
+TargetDataLayout: t.CExtern | str
+SliceLevel: t.CExtern | t.CInt
+StrictMode: t.CExtern | t.CInt
+IncludesDir: t.CExtern | str
+
+def Load_project_config(path: str) -> int: pass
+
+def _join_flags_array(flags_val: JsonValue | t.CPtr) -> str: pass
+
+def _join_path(rel: str, project_dir: str) -> str: pass
+
+def resolve_paths(project_dir: str) -> int: pass
+
+def get_includes_binary_dir() -> str: pass
+
+def print_config() -> t.CInt: pass

TransPyV/temp/4dd6b3f1427d1cc5.pyi

@@ -0,0 +1,82 @@
+"""
+Auto-generated Python stub file from ast.match.py
+Module: ast.match
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from .base import AST, ASTKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list
+
+class MatchCase(AST):
+    pattern: AST | t.CPtr
+    guard: AST | t.CPtr
+    def __new__(self: MatchCase, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, guard: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: MatchCase, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, guard: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: MatchCase) -> t.CInt: pass
+    def type_name(self: MatchCase) -> str: pass
+    def dump(self: MatchCase, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchValue(AST):
+    value: AST | t.CPtr
+    def __new__(self: MatchValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: MatchValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: MatchValue) -> t.CInt: pass
+    def type_name(self: MatchValue) -> str: pass
+    def dump(self: MatchValue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchSingleton(AST):
+    value: AST | t.CPtr
+    def __new__(self: MatchSingleton, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: MatchSingleton, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: MatchSingleton) -> t.CInt: pass
+    def type_name(self: MatchSingleton) -> str: pass
+    def dump(self: MatchSingleton, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchSequence(AST):
+    patterns: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: MatchSequence, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: MatchSequence, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: MatchSequence) -> t.CInt: pass
+    def type_name(self: MatchSequence) -> str: pass
+    def dump(self: MatchSequence, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchMapping(AST):
+    keys: list[AST | t.CPtr] | t.CPtr
+    patterns: list[AST | t.CPtr] | t.CPtr
+    rest: str
+    def __new__(self: MatchMapping, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, rest: str) -> t.CInt: pass
+    def __init__(self: MatchMapping, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, rest: str) -> t.CInt: pass
+    def kind(self: MatchMapping) -> t.CInt: pass
+    def type_name(self: MatchMapping) -> str: pass
+    def dump(self: MatchMapping, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchClass(AST):
+    cls: AST | t.CPtr
+    patterns: list[AST | t.CPtr] | t.CPtr
+    kwd_attrs: list[AST | t.CPtr] | t.CPtr
+    kwd_patterns: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: MatchClass, pool: memhub.MemManager | t.CPtr, cls: AST | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, kwd_attrs: list[AST | t.CPtr] | t.CPtr, kwd_patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: MatchClass, pool: memhub.MemManager | t.CPtr, cls: AST | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, kwd_attrs: list[AST | t.CPtr] | t.CPtr, kwd_patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: MatchClass) -> t.CInt: pass
+    def type_name(self: MatchClass) -> str: pass
+    def dump(self: MatchClass, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchStar(AST):
+    name: str
+    def __new__(self: MatchStar, pool: memhub.MemManager | t.CPtr, name: str) -> t.CInt: pass
+    def __init__(self: MatchStar, pool: memhub.MemManager | t.CPtr, name: str) -> t.CInt: pass
+    def kind(self: MatchStar) -> t.CInt: pass
+    def type_name(self: MatchStar) -> str: pass
+    def dump(self: MatchStar, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchAs(AST):
+    pattern: AST | t.CPtr
+    name: str
+    def __new__(self: MatchAs, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, name: str) -> t.CInt: pass
+    def __init__(self: MatchAs, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, name: str) -> t.CInt: pass
+    def kind(self: MatchAs) -> t.CInt: pass
+    def type_name(self: MatchAs) -> str: pass
+    def dump(self: MatchAs, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class MatchOr(AST):
+    patterns: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: MatchOr, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: MatchOr, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: MatchOr) -> t.CInt: pass
+    def type_name(self: MatchOr) -> str: pass
+    def dump(self: MatchOr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

TransPyV/temp/51f0144d6e8188d9.doc.json

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

TransPyV/temp/51f0144d6e8188d9.pyi

@@ -0,0 +1,25 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesWhile.py
+Module: lib.core.Handles.HandlesWhile
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+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.HandlesBody as HandlesBody
+
+@t.NoVTable
+class WhileHandle(HandlesBase.Mixin):
+    def __init__(self: WhileHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def Handle(self: WhileHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewWhileHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> WhileHandle | t.CPtr: pass

TransPyV/temp/54014f6c53e9640b.pyi

@@ -0,0 +1,139 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesStruct.py
+Module: lib.core.Handles.HandlesStruct
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import llvmlite
+import stdio
+import ast
+import hashtable
+
+STRUCT_MAX: t.CDefine = 512
+FIELD_MAX: t.CDefine = 32
+FIELD_NAME_MAX: t.CDefine = 64
+
+@t.NoVTable
+class FieldEntry:
+    Name: t.CChar | t.CPtr
+    Index: int
+    Ty: llvmlite.LLVMType | t.CPtr
+    DefaultVal: ast.AST | t.CPtr
+    AnnotClassName: t.CChar | t.CPtr
+@t.NoVTable
+class StructEntry:
+    Name: t.CChar | t.CPtr
+    Ty: llvmlite.LLVMType | t.CPtr
+    FieldCount: int
+    Fields: FieldEntry | t.CPtr
+    IsUnion: int
+    IsOOP: int
+    HasInit: int
+    HasNew: int
+    HasVTable: int
+    IsNoVTable: int
+    ParentName: t.CChar | t.CPtr
+    VTableMethodCount: int
+    VTableMethods: t.CChar | t.CPtr
+    ModuleSha1: t.CChar | t.CPtr
+
+_struct_table: t.CExtern | StructEntry | t.CPtr
+_struct_count: t.CExtern | int
+_visible_structs: t.CExtern | hashtable.HashTable | t.CPtr
+_strict_visibility: t.CExtern | int
+
+def reset_visible_structs(pool: memhub.MemBuddy | t.CPtr, strict: int) -> t.CInt: pass
+
+def add_visible_struct(pool: memhub.MemBuddy | t.CPtr, name: str) -> t.CInt: pass
+
+def is_struct_visible(name: str) -> int: pass
+
+def init_struct_table(pool: memhub.MemBuddy | t.CPtr) -> int: pass
+
+def _get_struct_entry(i: int) -> StructEntry | t.CPtr: pass
+
+def _get_field_entry(struct_entry: StructEntry | t.CPtr, i: int) -> FieldEntry | t.CPtr: pass
+
+def register_struct(pool: memhub.MemBuddy | t.CPtr, name: str, struct_ty: llvmlite.LLVMType | t.CPtr, sha1: str) -> StructEntry | t.CPtr: pass
+
+def set_struct_sha1(pool: memhub.MemBuddy | t.CPtr, class_name: str, sha1: str) -> int: pass
+
+def get_struct_sha1(class_name: str) -> str: pass
+
+def add_field(pool: memhub.MemBuddy | t.CPtr, struct_entry: StructEntry | t.CPtr, field_name: str, field_ty: llvmlite.LLVMType | t.CPtr, default_val: ast.AST | t.CPtr, annot_class_name: t.CChar | t.CPtr) -> int: pass
+
+def find_struct(name: str) -> StructEntry | t.CPtr: pass
+
+def find_struct_by_module(name: str, sha1: str) -> StructEntry | t.CPtr: pass
+
+def find_struct_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> StructEntry | t.CPtr: pass
+
+def lookup_field(struct_ty: llvmlite.LLVMType | t.CPtr, field_name: str) -> FieldEntry | t.CPtr: pass
+
+def lookup_field_by_class(class_name: str, field_name: str, sha1: str) -> FieldEntry | t.CPtr: pass
+
+def get_struct_type(class_name: str) -> llvmlite.LLVMType | t.CPtr: pass
+
+def get_field_by_index(class_name: str, idx: int) -> FieldEntry | t.CPtr: pass
+
+def struct_has_defaults(class_name: str) -> int: pass
+
+def _is_struct_type(ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def get_struct_type_from_value(val: llvmlite.Value | t.CPtr) -> llvmlite.LLVMType | t.CPtr: pass
+
+def mark_as_union(name: str) -> int: pass
+
+def is_union_by_name(name: str) -> int: pass
+
+def is_union_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> int: pass
+
+def mark_as_oop(name: str) -> int: pass
+
+def is_oop_by_name(name: str) -> int: pass
+
+def mark_has_init(name: str) -> int: pass
+
+def has_init_by_name(name: str) -> int: pass
+
+def mark_has_new(name: str) -> int: pass
+
+def has_new_by_name(name: str) -> int: pass
+
+def get_class_name_by_type(pool: memhub.MemBuddy | t.CPtr, struct_ty: llvmlite.LLVMType | t.CPtr) -> str: pass
+
+def _extract_struct_name(ty: llvmlite.LLVMType | t.CPtr) -> str: pass
+
+def mark_has_vtable(name: str) -> int: pass
+
+def has_vtable_by_name(name: str) -> int: pass
+
+def mark_novtable(name: str) -> int: pass
+
+def is_novtable_by_name(name: str) -> int: pass
+
+def set_parent_name(name: str, parent_name: str) -> int: pass
+
+def get_parent_name(name: str) -> str: pass
+
+def set_vtable_methods(name: str, methods: t.CChar | t.CPtr, count: int) -> int: pass
+
+def get_vtable_method_index(name: str, method_name: str) -> int: pass
+
+def get_vtable_method_count(name: str) -> int: pass
+
+def get_vtable_method_name(name: str, idx: int) -> str: pass
+
+def get_field_count(name: str) -> int: pass
+
+def get_field_name_ptr(fe: FieldEntry | t.CPtr) -> str: pass
+
+def get_field_type_ptr(fe: FieldEntry | t.CPtr) -> llvmlite.LLVMType | t.CPtr: pass
+
+def get_field_default_ptr(fe: FieldEntry | t.CPtr) -> ast.AST | t.CPtr: pass
+
+def get_field_annot_class_name(fe: FieldEntry | t.CPtr) -> str: pass

TransPyV/temp/541a090dde0cc1ba.doc.json

@@ -0,0 +1 @@
+{"AugAssignHandle": "增强赋值处理器 (+=, -=, *=, etc.)：继承 Mixin 获得 Trans 回指针", "AugAssignHandle.Handle": "翻译增强赋值语句 (x += 1, y -= 2, etc.)", "_apply_aug_op": "应用增强赋值的二元运算（指针算术 + 整数运算）"}

TransPyV/temp/541a090dde0cc1ba.pyi

@@ -0,0 +1,27 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesAugAssign.py
+Module: lib.core.Handles.HandlesAugAssign
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import stdio
+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.HandlesNonlocal as HandlesNonlocal
+
+@t.NoVTable
+class AugAssignHandle(HandlesBase.Mixin):
+    def __init__(self: AugAssignHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def Handle(self: AugAssignHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def _apply_aug_op(pool: memhub.MemBuddy | t.CPtr, builder: llvmlite.IRBuilder | t.CPtr, op: int, lhs: llvmlite.Value | t.CPtr, rhs: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def NewAugAssignHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> AugAssignHandle | t.CPtr: pass

TransPyV/temp/57288496f7c2d1ad.pyi

@@ -0,0 +1,71 @@
+"""
+Auto-generated Python stub file from json.__init__.py
+Module: json.__init__
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import viperio
+
+JSON_NULL:   t.CDefine = 0
+JSON_BOOL:   t.CDefine = 1
+JSON_INT:    t.CDefine = 2
+JSON_FLOAT:  t.CDefine = 3
+JSON_STRING: t.CDefine = 4
+JSON_ARRAY:  t.CDefine = 5
+JSON_OBJECT: t.CDefine = 6
+
+class JsonValue:
+    vtype: t.CInt
+    bool_val: t.CInt
+    int_val: t.CInt64T
+    float_val: t.CDouble
+    str_val: t.CChar | t.CPtr
+    next: 'JsonValue' | t.CPtr
+    key: t.CChar | t.CPtr
+    child: 'JsonValue' | t.CPtr
+    child_count: t.CSizeT
+    def __new__(self: JsonValue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def type(self: JsonValue) -> t.CInt: pass
+    def is_null(self: JsonValue) -> bool: pass
+    def is_bool(self: JsonValue) -> bool: pass
+    def is_int(self: JsonValue) -> bool: pass
+    def is_float(self: JsonValue) -> bool: pass
+    def is_string(self: JsonValue) -> bool: pass
+    def is_array(self: JsonValue) -> bool: pass
+    def is_object(self: JsonValue) -> bool: pass
+    def as_bool(self: JsonValue) -> bool: pass
+    def as_int(self: JsonValue) -> t.CInt64T: pass
+    def as_float(self: JsonValue) -> t.CDouble: pass
+    def as_string(self: JsonValue) -> t.CChar | t.CPtr: pass
+    def __len__(self: JsonValue) -> t.CSizeT: pass
+    def __getitem__(self: JsonValue, key: t.CChar | t.CPtr) -> 'JsonValue' | t.CPtr: pass
+    def __setitem__(self: JsonValue, key: t.CChar | t.CPtr, val: 'JsonValue' | t.CPtr) -> t.CInt: pass
+    def get_item(self: JsonValue, index: t.CSizeT) -> 'JsonValue' | t.CPtr: pass
+    def _pool_alloc(self: JsonValue, size: t.CSizeT) -> t.CChar | t.CPtr: pass
+    def _append_child(self: JsonValue, child: 'JsonValue' | t.CPtr) -> t.CInt: pass
+
+def null(pool: memhub.MemManager | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def bool_val(pool: memhub.MemManager | t.CPtr, val: bool) -> JsonValue | t.CPtr: pass
+
+def int_val(pool: memhub.MemManager | t.CPtr, val: t.CInt64T) -> JsonValue | t.CPtr: pass
+
+def float_val(pool: memhub.MemManager | t.CPtr, val: t.CDouble) -> JsonValue | t.CPtr: pass
+
+def string_val(pool: memhub.MemManager | t.CPtr, val: t.CChar | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def array(pool: memhub.MemManager | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def object(pool: memhub.MemManager | t.CPtr) -> JsonValue | t.CPtr: pass
+
+def array_append(pool: memhub.MemManager | t.CPtr, arr: JsonValue | t.CPtr, item: JsonValue | t.CPtr) -> t.CInt: pass
+
+def object_set(pool: memhub.MemManager | t.CPtr, obj: JsonValue | t.CPtr, key: t.CChar | t.CPtr, val: JsonValue | t.CPtr) -> t.CInt: pass
+
+
+from .__parser import parse
+from .__writer import write

TransPyV/temp/5dab8cb390496d22.pyi

@@ -0,0 +1,182 @@
+"""
+Auto-generated Python stub file from ast.base.py
+Module: ast.base
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import viperlib
+from .tokens import TokOp
+
+class ASTKind(t.CEnum):
+    Module: t.State
+    FunctionDef: t.State
+    ClassDef: t.State
+    Assign: t.State
+    If: t.State
+    For: t.State
+    While: t.State
+    Return: t.State
+    Expr: t.State
+    Name: t.State
+    Constant: t.State
+    BinOp: t.State
+    UnaryOp: t.State
+    Call: t.State
+    Compare: t.State
+    Expression: t.State
+    Interactive: t.State
+    FunctionType: t.State
+    Delete: t.State
+    AugAssign: t.State
+    AnnAssign: t.State
+    With: t.State
+    Raise: t.State
+    Try: t.State
+    Assert: t.State
+    Global: t.State
+    Nonlocal: t.State
+    Pass: t.State
+    Break: t.State
+    Continue: t.State
+    Import: t.State
+    ImportFrom: t.State
+    Match: t.State
+    BoolOp: t.State
+    Lambda: t.State
+    IfExp: t.State
+    Dict: t.State
+    Set: t.State
+    ListComp: t.State
+    SetComp: t.State
+    DictComp: t.State
+    GeneratorExp: t.State
+    Await: t.State
+    Yield: t.State
+    YieldFrom: t.State
+    FormattedValue: t.State
+    JoinedStr: t.State
+    Attribute: t.State
+    Subscript: t.State
+    Starred: t.State
+    List: t.State
+    Tuple: t.State
+    Slice: t.State
+    NamedExpr: t.State
+    ExceptHandler: t.State
+    Arguments: t.State
+    Arg: t.State
+    Keyword: t.State
+    Alias: t.State
+    WithItem: t.State
+    Comprehension: t.State
+    OpNode: t.State
+    MatchCase: t.State
+    MatchValue: t.State
+    MatchSingleton: t.State
+    MatchSequence: t.State
+    MatchMapping: t.State
+    MatchClass: t.State
+    MatchStar: t.State
+    MatchAs: t.State
+    MatchOr: t.State
+class ASTCtx(t.CEnum):
+    Load: t.State
+    Store: t.State
+    Del: t.State
+class OpKind(t.CEnum):
+    Add: t.State
+    Sub: t.State
+    Mult: t.State
+    MatMult: t.State
+    Div: t.State
+    Mod: t.State
+    Pow: t.State
+    LShift: t.State
+    RShift: t.State
+    BitOr: t.State
+    BitXor: t.State
+    BitAnd: t.State
+    FloorDiv: t.State
+    And: t.State
+    Or: t.State
+    Eq: t.State
+    Ne: t.State
+    Lt: t.State
+    Le: t.State
+    Gt: t.State
+    Ge: t.State
+    Is: t.State
+    IsNot: t.State
+    In: t.State
+    NotIn: t.State
+    Not: t.State
+    UAdd: t.State
+    USub: t.State
+    Invert: t.State
+    NoneOp: t.State
+
+CONST_INT: t.CDefine = 1
+CONST_FLOAT: t.CDefine = 2
+CONST_STR: t.CDefine = 3
+CONST_BOOL: t.CDefine = 4
+CONST_NONE: t.CDefine = 5
+FLAG_IS_ASYNC: t.CDefine = 1
+FLAG_SIMPLE: t.CDefine = 2
+FLAG_HAS_STAR: t.CDefine = 4
+
+class ASTFlag(t.CEnum):
+    IsAsync: t.State
+    Simple: t.State
+    HasStar: t.State
+
+def _copy_str(pool: memhub.MemManager | t.CPtr, src: str) -> str: pass
+
+def _set_pos(node: AST | t.CPtr, lineno: t.CInt, col_offset: t.CInt, end_lineno: t.CInt, end_col_offset: t.CInt) -> t.CInt: pass
+
+def _inherit_pos(node: AST | t.CPtr, ref: AST | t.CPtr) -> t.CInt: pass
+
+def _init_ast(node: AST | t.CPtr, pool: memhub.MemManager | t.CPtr, lineno: t.CInt, col: t.CInt) -> t.CInt: pass
+
+def _set_parent_list(lst: list[AST | t.CPtr] | t.CPtr, parent: AST | t.CPtr) -> t.CInt: pass
+
+def _append_child(lst: list[AST | t.CPtr] | t.CPtr, node: AST | t.CPtr, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+def _binop_from_op(op_id: t.CInt) -> t.CInt: pass
+
+def _augop_from_op(op_id: t.CInt) -> t.CInt: pass
+
+def _cmpop_from_op(op_id: t.CInt) -> t.CInt: pass
+
+def _emit(buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT, text: str) -> t.CSizeT: pass
+
+def _emit_str(buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT, text: str) -> t.CSizeT: pass
+
+def _emit_int(buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT, val: t.CInt64T) -> t.CSizeT: pass
+
+def _op_name(op: t.CInt) -> str: pass
+
+def _dump_list(lst: list[AST | t.CPtr] | t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+def _dump_op_list(lst: t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+
+@t.CVTable
+class AST:
+    parent: AST | t.CPtr
+    pool: memhub.MemManager | t.CPtr
+    lineno: t.CInt
+    col_offset: t.CInt
+    end_lineno: t.CInt
+    end_col_offset: t.CInt
+    children: list[AST | t.CPtr] | t.CPtr
+    def kind(self: AST) -> t.CInt: pass
+    def type_name(self: AST) -> str: pass
+    def dump(self: AST, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+    def accept(self: AST, visitor: t.CPtr) -> t.CInt: pass
+    def append(self: AST, node: AST | t.CPtr) -> t.CInt: pass
+
+def dump(node: AST | t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT) -> t.CInt: pass

TransPyV/temp/6446627d4f07a1b5.pyi

@@ -0,0 +1,86 @@
+"""
+Auto-generated Python stub file from w32.winsock2.py
+Module: w32.winsock2
+"""
+
+
+import t, c
+from stdint import *
+from w32.win32base import *
+
+WINSOCK_VERSION: t.CDefine = 0x0202  # 2.2
+AF_INET: t.CDefine = 2
+AF_INET6: t.CDefine = 23
+SOCK_STREAM: t.CDefine = 1     # TCP
+SOCK_DGRAM: t.CDefine = 2      # UDP
+SOCK_RAW: t.CDefine = 3        # 原始套接字
+IPPROTO_TCP: t.CDefine = 6
+IPPROTO_UDP: t.CDefine = 17
+SOL_SOCKET: t.CDefine = 0xFFFF      # WinSock2 值
+SO_RCVTIMEO: t.CDefine = 0x1006     # WinSock2 值
+SO_SNDTIMEO: t.CDefine = 0x1005     # WinSock2 值
+SO_REUSEADDR: t.CDefine = 0x0004    # WinSock2 值
+INADDR_ANY: t.CDefine = 0
+SOCKET_ERROR: t.CDefine = -1
+INVALID_SOCKET: t.CDefine = 0xFFFFFFFF  # WinSock2: ~0
+MSG_NOSIGNAL: t.CDefine = 0  # Windows 不支持，设为 0
+SD_SEND: t.CDefine = 1
+SD_RECV: t.CDefine = 0
+SD_BOTH: t.CDefine = 2
+
+class WSASocketAddr:
+    family: u16
+    port: u16
+    addr: u32
+    zero: u64
+class WSAData:
+    wVersion: WORD
+    wHighVersion: WORD
+    szDescription: BYTE
+    szSystemStatus: BYTE
+    iMaxSockets: u16
+    iMaxUdpDg: u16
+    lpVendorInfo: CHARPTR
+class WSAHostEnt:
+    h_name: CHARPTR
+    h_aliases: CHARPTR
+    h_addrtype: SHORT
+    h_length: SHORT
+    h_addr_list: CHARPTR
+class WinTimeVal:
+    tv_sec: LONG
+    tv_usec: LONG
+
+def WSAStartup(wVersionRequested: WORD, lpWSAData: WSAData | t.CPtr) -> INT | t.State: pass
+
+def WSACleanup() -> INT | t.State: pass
+
+def WSAGetLastError() -> INT | t.State: pass
+
+def socket(family: INT, type: INT, protocol: INT) -> u64 | t.State: pass
+
+def closesocket(s: u64) -> INT | t.State: pass
+
+def connect(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
+
+def send(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
+
+def recv(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
+
+def bind(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
+
+def listen(s: u64, backlog: INT) -> INT | t.State: pass
+
+def accept(s: u64, addr: WSASocketAddr | t.CPtr, addrlen: INT | t.CPtr) -> u64 | t.State: pass
+
+def setsockopt(s: u64, level: INT, optname: INT, optval: t.CVoid | t.CPtr, optlen: INT) -> INT | t.State: pass
+
+def shutdown(s: u64, how: INT) -> INT | t.State: pass
+
+def gethostbyname(name: t.CChar | t.CConst | t.CPtr) -> WSAHostEnt | t.CPtr | t.State: pass
+
+def ntohs(netshort: u16) -> u16 | t.State: pass
+
+def htons(hostshort: u16) -> u16 | t.State: pass
+
+def inet_addr(cp: t.CChar | t.CConst | t.CPtr) -> u32 | t.State: pass

TransPyV/temp/6503c97dde0c79c4.pyi

@@ -0,0 +1,189 @@
+"""
+Auto-generated Python stub file from posix.py
+Module: posix
+"""
+
+
+import t, c
+from stdint import *
+
+DIR: t.CTypedef = t.CVoid | t.CPtr
+mode_t: t.CTypedef = t.CUInt32T
+pid_t: t.CTypedef = t.CInt32T
+off_t: t.CTypedef = t.CInt64T
+dev_t: t.CTypedef = t.CUInt64T
+ino_t: t.CTypedef = t.CUInt64T
+nlink_t: t.CTypedef = t.CUInt64T
+uid_t: t.CTypedef = t.CUInt32T
+gid_t: t.CTypedef = t.CUInt32T
+blksize_t: t.CTypedef = t.CInt64T
+blkcnt_t: t.CTypedef = t.CInt64T
+time_t: t.CTypedef = t.CInt64T
+O_RDONLY:   t.CDefine = 0
+O_WRONLY:   t.CDefine = 1
+O_RDWR:     t.CDefine = 2
+O_CREAT:    t.CDefine = 0o100
+O_EXCL:     t.CDefine = 0o200
+O_TRUNC:    t.CDefine = 0o1000
+O_APPEND:   t.CDefine = 0o2000
+O_NONBLOCK: t.CDefine = 0o4000
+O_CLOEXEC:  t.CDefine = 0o2000000
+F_OK: t.CDefine = 0    # 文件存在
+R_OK: t.CDefine = 4    # 可读
+W_OK: t.CDefine = 2    # 可写
+X_OK: t.CDefine = 1    # 可执行
+S_IFMT:   t.CDefine = 0o170000   # 类型掩码
+S_IFSOCK: t.CDefine = 0o140000   # 套接字
+S_IFLNK:  t.CDefine = 0o120000   # 符号链接
+S_IFREG:  t.CDefine = 0o100000   # 普通文件
+S_IFBLK:  t.CDefine = 0o060000   # 块设备
+S_IFDIR:  t.CDefine = 0o040000   # 目录
+S_IFCHR:  t.CDefine = 0o020000   # 字符设备
+S_IFIFO:  t.CDefine = 0o010000   # FIFO/管道
+S_ISUID: t.CDefine = 0o4000    # set-user-ID
+S_ISGID: t.CDefine = 0o2000    # set-group-ID
+S_ISVTX: t.CDefine = 0o1000    # sticky 位
+S_IRWXU: t.CDefine = 0o700     # 用户读写执行
+S_IRUSR: t.CDefine = 0o400     # 用户读
+S_IWUSR: t.CDefine = 0o200     # 用户写
+S_IXUSR: t.CDefine = 0o100     # 用户执行
+S_IRWXG: t.CDefine = 0o070     # 组读写执行
+S_IRGRP: t.CDefine = 0o040     # 组读
+S_IWGRP: t.CDefine = 0o020     # 组写
+S_IXGRP: t.CDefine = 0o010     # 组执行
+S_IRWXO: t.CDefine = 0o007     # 其他读写执行
+S_IROTH: t.CDefine = 0o004     # 其他读
+S_IWOTH: t.CDefine = 0o002     # 其他写
+S_IXOTH: t.CDefine = 0o001     # 其他执行
+SEEK_SET: t.CDefine = 0
+SEEK_CUR: t.CDefine = 1
+SEEK_END: t.CDefine = 2
+PATH_MAX: t.CDefine = 4096
+NAME_MAX: t.CDefine = 255
+_SC_NPROCESSORS_ONLN: t.CDefine = 84
+_SC_PAGESIZE:         t.CDefine = 30
+_SC_CLK_TCK:          t.CDefine = 2
+DT_UNKNOWN: t.CDefine = 0
+DT_FIFO:    t.CDefine = 1
+DT_CHR:     t.CDefine = 2
+DT_DIR:     t.CDefine = 4
+DT_BLK:     t.CDefine = 6
+DT_REG:     t.CDefine = 8
+DT_LNK:     t.CDefine = 10
+DT_SOCK:    t.CDefine = 12
+DT_WHT:     t.CDefine = 14
+WNOHANG:    t.CDefine = 1
+WUNTRACED:  t.CDefine = 2
+WCONTINUED: t.CDefine = 8
+
+class Stat:
+    st_dev: dev_t
+    st_ino: ino_t
+    st_nlink: nlink_t
+    st_mode: mode_t
+    st_uid: uid_t
+    st_gid: gid_t
+    __pad0: INT
+    st_rdev: dev_t
+    st_size: off_t
+    st_blksize: blksize_t
+    st_blocks: blkcnt_t
+    st_atim_sec: time_t
+    st_atim_nsec: LONGLONG
+    st_mtim_sec: time_t
+    st_mtim_nsec: LONGLONG
+    st_ctim_sec: time_t
+    st_ctim_nsec: LONGLONG
+    __unused0: LONGLONG
+    __unused1: LONGLONG
+    __unused2: LONGLONG
+class Dirent:
+    d_ino: ino_t
+    d_off: off_t
+    d_reclen: USHORT
+    d_type: BYTE
+    d_name: CHARPTR
+
+def open(path: t.CConst | str, oflag: INT, *args) -> INT | t.State: pass
+
+def close(fd: INT) -> INT | t.State: pass
+
+def read(fd: INT, buf: bytes, count: t.CSizeT) -> ssize_t | t.State: pass
+
+def write(fd: INT, buf: t.CConst | bytes, count: t.CSizeT) -> ssize_t | t.State: pass
+
+def lseek(fd: INT, offset: off_t, whence: INT) -> off_t | t.State: pass
+
+def unlink(path: t.CConst | str) -> INT | t.State: pass
+
+def access(path: t.CConst | str, amode: INT) -> INT | t.State: pass
+
+def realpath(path: t.CConst | str, resolved: CHARPTR) -> CHARPTR | t.State: pass
+
+def rename(oldpath: t.CConst | str, newpath: t.CConst | str) -> INT | t.State: pass
+
+def chmod(path: t.CConst | str, mode: mode_t) -> INT | t.State: pass
+
+def stat(path: t.CConst | str, buf: Stat | t.CPtr) -> INT | t.State: pass
+
+def fstat(fd: INT, buf: Stat | t.CPtr) -> INT | t.State: pass
+
+def opendir(name: t.CConst | str) -> DIR | t.CPtr | t.State: pass
+
+def readdir(dirp: DIR | t.CPtr) -> Dirent | t.CPtr | t.State: pass
+
+def closedir(dirp: DIR | t.CPtr) -> INT | t.State: pass
+
+def mkdir(path: t.CConst | str, mode: mode_t) -> INT | t.State: pass
+
+def rmdir(path: t.CConst | str) -> INT | t.State: pass
+
+def getcwd(buf: CHARPTR, size: t.CSizeT) -> CHARPTR | t.State: pass
+
+def chdir(path: t.CConst | str) -> INT | t.State: pass
+
+def fork() -> pid_t | t.State: pass
+
+def execvp(file: t.CConst | str, argv: CHARPTR | t.CPtr) -> INT | t.State: pass
+
+def execv(path: t.CConst | str, argv: CHARPTR | t.CPtr) -> INT | t.State: pass
+
+def waitpid(pid: pid_t, status: INT | t.CPtr, options: INT) -> pid_t | t.State: pass
+
+def pipe(fds: INT | t.CPtr) -> INT | t.State: pass
+
+def dup2(oldfd: INT, newfd: INT) -> INT | t.State: pass
+
+def _exit(status: INT) -> t.CVoid | t.State: pass
+
+def getpid() -> pid_t | t.State: pass
+
+def getenv(name: t.CConst | str) -> CHARPTR | t.State: pass
+
+def setenv(name: t.CConst | str, value: t.CConst | str, overwrite: INT) -> INT | t.State: pass
+
+def sysconf(name: INT) -> LONG | t.State: pass
+
+def isatty(fd: INT) -> INT | t.State: pass
+
+def S_ISREG(mode: mode_t) -> bool: pass
+
+def S_ISDIR(mode: mode_t) -> bool: pass
+
+def S_ISLNK(mode: mode_t) -> bool: pass
+
+def S_ISCHR(mode: mode_t) -> bool: pass
+
+def S_ISBLK(mode: mode_t) -> bool: pass
+
+def S_ISFIFO(mode: mode_t) -> bool: pass
+
+def S_ISSOCK(mode: mode_t) -> bool: pass
+
+def WIFEXITED(status: INT) -> bool: pass
+
+def WEXITSTATUS(status: INT) -> INT: pass
+
+def WIFSIGNALED(status: INT) -> bool: pass
+
+def WTERMSIG(status: INT) -> INT: pass

TransPyV/temp/657e182b27c2a022.pyi

@@ -0,0 +1,226 @@
+"""
+Auto-generated Python stub file from ast.stmts.py
+Module: ast.stmts
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+from .base import AST, ASTKind, ASTCtx, OpKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list, FLAG_IS_ASYNC
+
+@t.CVTable
+class Module(AST):
+    def __new__(self: Module, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def __init__(self: Module, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def kind(self: Module) -> t.CInt: pass
+    def type_name(self: Module) -> str: pass
+    def dump(self: Module, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Assign(AST):
+    targets: list[AST | t.CPtr] | t.CPtr
+    value: AST | t.CPtr
+    def __new__(self: Assign, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Assign, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Assign) -> t.CInt: pass
+    def type_name(self: Assign) -> str: pass
+    def dump(self: Assign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class If(AST):
+    test: AST | t.CPtr
+    orelse: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: If, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: If, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: If) -> t.CInt: pass
+    def type_name(self: If) -> str: pass
+    def dump(self: If, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class For(AST):
+    target: AST | t.CPtr
+    iter: AST | t.CPtr
+    orelse: list[AST | t.CPtr] | t.CPtr
+    flags: t.CInt
+    def __new__(self: For, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def __init__(self: For, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def kind(self: For) -> t.CInt: pass
+    def type_name(self: For) -> str: pass
+    def dump(self: For, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class While(AST):
+    test: AST | t.CPtr
+    orelse: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: While, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: While, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: While) -> t.CInt: pass
+    def type_name(self: While) -> str: pass
+    def dump(self: While, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Return(AST):
+    value: AST | t.CPtr
+    def __new__(self: Return, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Return, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Return) -> t.CInt: pass
+    def type_name(self: Return) -> str: pass
+    def dump(self: Return, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Expr(AST):
+    value: AST | t.CPtr
+    def __new__(self: Expr, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Expr, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Expr) -> t.CInt: pass
+    def type_name(self: Expr) -> str: pass
+    def dump(self: Expr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class FunctionDef(AST):
+    name: str
+    args: AST | t.CPtr
+    decorator_list: list[AST | t.CPtr] | t.CPtr
+    returns: AST | t.CPtr
+    flags: t.CInt
+    def __new__(self: FunctionDef, pool: memhub.MemManager | t.CPtr, name: str, args: AST | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def __init__(self: FunctionDef, pool: memhub.MemManager | t.CPtr, name: str, args: AST | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def kind(self: FunctionDef) -> t.CInt: pass
+    def type_name(self: FunctionDef) -> str: pass
+    def dump(self: FunctionDef, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Expression(AST):
+    body: AST | t.CPtr
+    def __new__(self: Expression, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Expression, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Expression) -> t.CInt: pass
+    def type_name(self: Expression) -> str: pass
+    def dump(self: Expression, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Interactive(AST):
+    body: AST | t.CPtr
+    def __new__(self: Interactive, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Interactive, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Interactive) -> t.CInt: pass
+    def type_name(self: Interactive) -> str: pass
+    def dump(self: Interactive, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class FunctionType(AST):
+    argtypes: list[AST | t.CPtr] | t.CPtr
+    returns: AST | t.CPtr
+    def __new__(self: FunctionType, pool: memhub.MemManager | t.CPtr, argtypes: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: FunctionType, pool: memhub.MemManager | t.CPtr, argtypes: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: FunctionType) -> t.CInt: pass
+    def type_name(self: FunctionType) -> str: pass
+    def dump(self: FunctionType, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class ClassDef(AST):
+    name: str
+    bases: list[AST | t.CPtr] | t.CPtr
+    keywords: list[AST | t.CPtr] | t.CPtr
+    decorator_list: list[AST | t.CPtr] | t.CPtr
+    type_params: list[str] | t.CPtr
+    def __new__(self: ClassDef, pool: memhub.MemManager | t.CPtr, name: str, bases: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, type_params: list[str] | t.CPtr) -> t.CInt: pass
+    def __init__(self: ClassDef, pool: memhub.MemManager | t.CPtr, name: str, bases: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, type_params: list[str] | t.CPtr) -> t.CInt: pass
+    def kind(self: ClassDef) -> t.CInt: pass
+    def type_name(self: ClassDef) -> str: pass
+    def dump(self: ClassDef, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Delete(AST):
+    targets: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Delete, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Delete, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Delete) -> t.CInt: pass
+    def type_name(self: Delete) -> str: pass
+    def dump(self: Delete, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class AugAssign(AST):
+    target: AST | t.CPtr
+    op: t.CInt
+    value: AST | t.CPtr
+    def __new__(self: AugAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: AugAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: AugAssign) -> t.CInt: pass
+    def type_name(self: AugAssign) -> str: pass
+    def dump(self: AugAssign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class AnnAssign(AST):
+    target: AST | t.CPtr
+    annotation: AST | t.CPtr
+    value: AST | t.CPtr
+    simple: t.CInt
+    def __new__(self: AnnAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, annotation: AST | t.CPtr, value: AST | t.CPtr, simple: t.CInt) -> t.CInt: pass
+    def __init__(self: AnnAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, annotation: AST | t.CPtr, value: AST | t.CPtr, simple: t.CInt) -> t.CInt: pass
+    def kind(self: AnnAssign) -> t.CInt: pass
+    def type_name(self: AnnAssign) -> str: pass
+    def dump(self: AnnAssign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class With(AST):
+    items: list[AST | t.CPtr] | t.CPtr
+    flags: t.CInt
+    def __new__(self: With, pool: memhub.MemManager | t.CPtr, items: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def __init__(self: With, pool: memhub.MemManager | t.CPtr, items: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
+    def kind(self: With) -> t.CInt: pass
+    def type_name(self: With) -> str: pass
+    def dump(self: With, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Raise(AST):
+    exc: AST | t.CPtr
+    cause: AST | t.CPtr
+    def __new__(self: Raise, pool: memhub.MemManager | t.CPtr, exc: AST | t.CPtr, cause: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Raise, pool: memhub.MemManager | t.CPtr, exc: AST | t.CPtr, cause: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Raise) -> t.CInt: pass
+    def type_name(self: Raise) -> str: pass
+    def dump(self: Raise, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Try(AST):
+    handlers: list[AST | t.CPtr] | t.CPtr
+    orelse: list[AST | t.CPtr] | t.CPtr
+    finalbody: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Try, pool: memhub.MemManager | t.CPtr, handlers: list[AST | t.CPtr] | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, finalbody: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Try, pool: memhub.MemManager | t.CPtr, handlers: list[AST | t.CPtr] | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, finalbody: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Try) -> t.CInt: pass
+    def type_name(self: Try) -> str: pass
+    def dump(self: Try, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Assert(AST):
+    test: AST | t.CPtr
+    msg: AST | t.CPtr
+    def __new__(self: Assert, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, msg: AST | t.CPtr) -> t.CInt: pass
+    def __init__(self: Assert, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, msg: AST | t.CPtr) -> t.CInt: pass
+    def kind(self: Assert) -> t.CInt: pass
+    def type_name(self: Assert) -> str: pass
+    def dump(self: Assert, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Global(AST):
+    names: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Global, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Global, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Global) -> t.CInt: pass
+    def type_name(self: Global) -> str: pass
+    def dump(self: Global, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Nonlocal(AST):
+    names: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Nonlocal, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Nonlocal, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Nonlocal) -> t.CInt: pass
+    def type_name(self: Nonlocal) -> str: pass
+    def dump(self: Nonlocal, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Pass(AST):
+    def __new__(self: Pass, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def __init__(self: Pass, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def kind(self: Pass) -> t.CInt: pass
+    def type_name(self: Pass) -> str: pass
+    def dump(self: Pass, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Break(AST):
+    def __new__(self: Break, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def __init__(self: Break, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def kind(self: Break) -> t.CInt: pass
+    def type_name(self: Break) -> str: pass
+    def dump(self: Break, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Continue(AST):
+    def __new__(self: Continue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def __init__(self: Continue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def kind(self: Continue) -> t.CInt: pass
+    def type_name(self: Continue) -> str: pass
+    def dump(self: Continue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Import(AST):
+    names: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Import, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Import, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Import) -> t.CInt: pass
+    def type_name(self: Import) -> str: pass
+    def dump(self: Import, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class ImportFrom(AST):
+    module: str
+    names: list[AST | t.CPtr] | t.CPtr
+    level: t.CInt
+    def __new__(self: ImportFrom, pool: memhub.MemManager | t.CPtr, module: str, names: list[AST | t.CPtr] | t.CPtr, level: t.CInt) -> t.CInt: pass
+    def __init__(self: ImportFrom, pool: memhub.MemManager | t.CPtr, module: str, names: list[AST | t.CPtr] | t.CPtr, level: t.CInt) -> t.CInt: pass
+    def kind(self: ImportFrom) -> t.CInt: pass
+    def type_name(self: ImportFrom) -> str: pass
+    def dump(self: ImportFrom, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+class Match(AST):
+    subject: AST | t.CPtr
+    cases: list[AST | t.CPtr] | t.CPtr
+    def __new__(self: Match, pool: memhub.MemManager | t.CPtr, subject: AST | t.CPtr, cases: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def __init__(self: Match, pool: memhub.MemManager | t.CPtr, subject: AST | t.CPtr, cases: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
+    def kind(self: Match) -> t.CInt: pass
+    def type_name(self: Match) -> str: pass
+    def dump(self: Match, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

TransPyV/temp/66de93aaeebc0601.doc.json

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

TransPyV/temp/66de93aaeebc0601.pyi

@@ -0,0 +1,25 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesIf.py
+Module: lib.core.Handles.HandlesIf
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+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.HandlesBody as HandlesBody
+
+@t.NoVTable
+class IfHandle(HandlesBase.Mixin):
+    def __init__(self: IfHandle, trans: HT.Translator | t.CPtr) -> t.CInt: pass
+    def Handle(self: IfHandle, node: ast.AST | t.CPtr) -> int: pass
+
+def NewIfHandle(pool: memhub.MemBuddy | t.CPtr, trans: HT.Translator | t.CPtr) -> IfHandle | t.CPtr: pass

TransPyV/temp/6f62fe05c5ea1ceb.pyi

@@ -0,0 +1,28 @@
+"""
+Auto-generated Python stub file from stdio.py
+Module: stdio
+"""
+
+
+import t, c
+
+def printf(fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def snprintf(buf: bytes, size: t.CSizeT, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def puts(s: t.CConst | str) -> t.CInt | t.State: pass
+
+def fputs(s: t.CConst | str, stream: bytes) -> t.CInt | t.State: pass
+
+def fgets(buf: bytes, size: t.CInt, stream: bytes) -> bytes | t.State: pass
+
+def fflush(stream: bytes) -> t.CInt | t.State: pass
+
+
+stdin: t.CExtern | bytes
+stdout: t.CExtern | bytes
+stderr: t.CExtern | bytes

TransPyV/temp/6ff26590374ae6fc.pyi

@@ -0,0 +1,39 @@
+"""
+Auto-generated Python stub file from hashlib.__sha512.py
+Module: hashlib.__sha512
+"""
+
+
+import t, c
+
+SHA512_BLOCK_LEN:  t.CDefine = 128
+SHA512_DIGEST_LEN: t.CDefine =  64
+
+def sha512_ror(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
+
+def sha512_shr(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
+
+def sha512_Ch(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Maj(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_BigSigma0(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_BigSigma1(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Sigma0(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Sigma1(x: t.CUInt64T) -> t.CUInt64T: pass
+
+
+sha512_K: t.CExtern | t.CArray[t.CUInt64T, 80]
+
+@t.Object
+class sha512:
+    state: t.CArray[t.CUInt64T, 8]
+    count: t.CArray[t.CUInt64T, 2]
+    buf: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]
+    def __init__(self: sha512) -> t.CInt: pass
+    def transform(self: sha512, block: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]) -> t.CInt: pass
+    def update(self: sha512, s: str) -> t.CInt: pass
+    def final(self: sha512, out: t.CArray[t.CUInt8T, SHA512_DIGEST_LEN]) -> t.CInt: pass

TransPyV/temp/71e0a3ffcb3ebfad.pyi

@@ -0,0 +1,20 @@
+"""
+Auto-generated Python stub file from stdarg.py
+Module: stdarg
+"""
+
+import c
+
+
+import t
+
+def va_start(args: t.CPtr, last_arg: t.CPtr) -> t.State: pass
+
+def va_arg(args: t.CPtr, type: t.CPtr) -> t.CPtr | t.State: pass
+
+def va_end(args: t.CPtr) -> t.State | t.State: pass
+
+
+va_list: t.CTypedef = t.CUnsignedChar | t.CPtr
+
+def arg(type: t.CType) -> t.State: pass

TransPyV/temp/72e2d5ccb7cedcf1.pyi

@@ -0,0 +1,91 @@
+"""
+Auto-generated Python stub file from w32.win32memory.py
+Module: w32.win32memory
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+MEM_COMMIT: t.CDefine = 0x00001000
+MEM_RESERVE: t.CDefine = 0x00002000
+MEM_DECOMMIT: t.CDefine = 0x00004000
+MEM_RELEASE: t.CDefine = 0x00008000
+MEM_FREE: t.CDefine = 0x00010000
+MEM_RESET: t.CDefine = 0x00080000
+MEM_TOP_DOWN: t.CDefine = 0x00100000
+MEM_WRITE_WATCH: t.CDefine = 0x00200000
+MEM_PHYSICAL: t.CDefine = 0x00400000
+MEM_LARGE_PAGES: t.CDefine = 0x20000000
+PAGE_NOACCESS: t.CDefine = 0x01
+PAGE_READONLY: t.CDefine = 0x02
+PAGE_READWRITE: t.CDefine = 0x04
+PAGE_WRITECOPY: t.CDefine = 0x08
+PAGE_EXECUTE: t.CDefine = 0x10
+PAGE_EXECUTE_READ: t.CDefine = 0x20
+PAGE_EXECUTE_READWRITE: t.CDefine = 0x40
+PAGE_EXECUTE_WRITECOPY: t.CDefine = 0x80
+PAGE_GUARD: t.CDefine = 0x100
+PAGE_NOCACHE: t.CDefine = 0x200
+PAGE_WRITECOMBINE: t.CDefine = 0x400
+HEAP_NO_SERIALIZE: t.CDefine = 0x00000001
+HEAP_GROWABLE: t.CDefine = 0x00000002
+HEAP_GENERATE_EXCEPTIONS: t.CDefine = 0x00000004
+HEAP_ZERO_MEMORY: t.CDefine = 0x00000008
+HEAP_REALLOC_IN_PLACE_ONLY: t.CDefine = 0x00000010
+
+class MEMORY_BASIC_INFORMATION:
+    BaseAddress: VOIDPTR
+    AllocationBase: VOIDPTR
+    AllocationProtect: ULONG
+    RegionSize: t.CSizeT
+    State: ULONG
+    Protect: ULONG
+    Type: ULONG
+
+def VirtualAlloc(lpAddress: VOIDPTR, dwSize: t.CSizeT, flAllocationType: ULONG, flProtect: ULONG) -> VOIDPTR | t.State: pass
+
+def VirtualFree(lpAddress: VOIDPTR, dwSize: t.CSizeT, dwFreeType: ULONG) -> BOOL | t.State: pass
+
+def VirtualProtect(lpAddress: VOIDPTR, dwSize: t.CSizeT, flNewProtect: ULONG, lpflOldProtect: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def VirtualQuery(lpAddress: t.CConst | VOIDPTR, lpBuffer: MEMORY_BASIC_INFORMATION | t.CPtr, dwLength: t.CSizeT) -> t.CSizeT | t.State: pass
+
+def VirtualLock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
+
+def VirtualUnlock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
+
+def GetProcessHeap() -> HANDLE | t.State: pass
+
+def HeapCreate(flOptions: ULONG, dwInitialSize: t.CSizeT, dwMaximumSize: t.CSizeT) -> HANDLE | t.State: pass
+
+def HeapDestroy(hHeap: HANDLE) -> BOOL | t.State: pass
+
+def HeapAlloc(hHeap: HANDLE, dwFlags: ULONG, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def HeapReAlloc(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def HeapFree(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR) -> BOOL | t.State: pass
+
+def HeapSize(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> t.CSizeT | t.State: pass
+
+def HeapValidate(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> BOOL | t.State: pass
+
+def HeapCompact(hHeap: HANDLE, dwFlags: ULONG) -> t.CSizeT | t.State: pass
+
+def GlobalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def GlobalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
+
+def GlobalLock(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
+
+def GlobalUnlock(hMem: VOIDPTR) -> BOOL | t.State: pass
+
+def GlobalSize(hMem: VOIDPTR) -> t.CSizeT | t.State: pass
+
+def LocalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def LocalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass

TransPyV/temp/78bbe886bbe5ca8f.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    ", "_resolve_relative_module": "解析相对导入为完整模块名", "compute_package_from_relpath": "从相对路径计算包名（目录部分，分隔符替换为 .）", "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"}

TransPyV/temp/78bbe886bbe5ca8f.pyi

@@ -0,0 +1,38 @@
+"""
+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
+
+def _resolve_relative_module(pool: memhub.MemBuddy | t.CPtr, current_package: str, level: t.CInt, module: str) -> str: pass
+
+def compute_package_from_relpath(pool: memhub.MemBuddy | t.CPtr, rel_path: str) -> 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

TransPyV/temp/7e260c14d2712119.doc.json

@@ -0,0 +1 @@
+{"SrcFileEntry": "源文件条目", "_ScanDirForPyFiles": "递归扫描目录，收集 .py 文件到 entries，返回新的 file_count", "RunMultiFileProject": "多文件项目编译\n\n    Returns: 0 成功，非 0 失败\n    "}

TransPyV/temp/7e260c14d2712119.pyi

@@ -0,0 +1,42 @@
+"""
+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.Handles.HandlesImports as HandlesImports
+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 = 64
+
+@t.NoVTable
+class SrcFileEntry:
+    Path: str
+    Sha1: str
+
+def _ScanDirForPyFiles(mb: memhub.MemBuddy | t.CPtr, dir_path: str, entries: SrcFileEntry | t.CPtr, entry_size: t.CSizeT, file_count: int, max_files: int) -> int: pass
+
+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

TransPyV/temp/7e529fe7a078cfef.pyi

@@ -0,0 +1,100 @@
+"""
+Auto-generated Python stub file from w32.win32base.py
+Module: w32.win32base
+"""
+
+import c
+
+
+import t
+from stdint import *
+
+HANDLE: t.CTypedef = VOIDPTR
+LPCSTR: t.CTypedef = t.CConst | t.CChar | t.CPtr
+LPCWSTR: t.CTypedef = t.CConst | t.CUnsignedShort | t.CPtr
+INVALID_HANDLE_VALUE: t.CDefine = t.CVoid(-1)
+NULL: t.CDefine = 0
+TRUE: t.CDefine = 1
+FALSE: t.CDefine = 0
+INFINITE: t.CDefine = 0xFFFFFFFF
+WAIT_FAILED: t.CDefine = 0xFFFFFFFF
+WAIT_OBJECT_0: t.CDefine = 0
+WAIT_TIMEOUT: t.CDefine = 258
+WAIT_ABANDONED: t.CDefine = 0x80
+MAX_PATH: t.CDefine = 260
+ERROR_SUCCESS: t.CDefine = 0
+ERROR_FILE_NOT_FOUND: t.CDefine = 2
+ERROR_ACCESS_DENIED: t.CDefine = 5
+ERROR_INSUFFICIENT_BUFFER: t.CDefine = 122
+
+class SECURITY_ATTRIBUTES:
+    nLength: ULONG
+    lpSecurityDescriptor: VOIDPTR
+    bInheritHandle: BOOL
+class OVERLAPPED:
+    Internal: ULONGLONG
+    InternalHigh: ULONGLONG
+    Offset: ULONG
+    OffsetHigh: ULONG
+    hEvent: HANDLE
+class FILETIME:
+    dwLowDateTime: DWORD
+    dwHighDateTime: DWORD
+class SYSTEMTIME:
+    wYear: WORD
+    wMonth: WORD
+    wDayOfWeek: WORD
+    wDay: WORD
+    wHour: WORD
+    wMinute: WORD
+    wSecond: WORD
+    wMilliseconds: WORD
+class GUID:
+    Data1: DWORD
+    Data2: WORD
+    Data3: WORD
+    Data4: BYTEPTR
+class LARGE_INTEGER:
+    QuadPart: LONGLONG
+class ULARGE_INTEGER:
+    QuadPart: ULONGLONG
+
+def GetLastError() -> ULONG | t.State: pass
+
+def SetLastError(dwErrCode: ULONG) -> t.State: pass
+
+def CloseHandle(hObject: HANDLE) -> BOOL | t.State: pass
+
+def GetProcAddress(hModule: HANDLE, lpProcName: LPCSTR) -> VOIDPTR | t.State: pass
+
+def GetModuleHandleA(lpModuleName: LPCSTR) -> HANDLE | t.State: pass
+
+def GetModuleHandleW(lpModuleName: LPCWSTR) -> HANDLE | t.State: pass
+
+def LoadLibraryA(lpLibFileName: LPCSTR) -> HANDLE | t.State: pass
+
+def LoadLibraryW(lpLibFileName: LPCWSTR) -> HANDLE | t.State: pass
+
+def FreeLibrary(hLibModule: HANDLE) -> BOOL | t.State: pass
+
+def GetSystemTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
+
+def GetLocalTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
+
+def FileTimeToSystemTime(lpFileTime: FILETIME | t.CPtr, lpSystemTime: SYSTEMTIME | t.CPtr) -> BOOL | t.State: pass
+
+def SystemTimeToFileTime(lpSystemTime: SYSTEMTIME | t.CPtr, lpFileTime: FILETIME | t.CPtr) -> BOOL | t.State: pass
+
+def QueryPerformanceCounter(lpPerformanceCount: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def QueryPerformanceFrequency(lpFrequency: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def Sleep(dwMilliseconds: ULONG) -> t.State: pass
+
+def SleepEx(dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def GetTickCount() -> ULONG | t.State: pass
+
+def GetTickCount64() -> ULONGLONG | t.State: pass
+
+def GetCommandLineA() -> CHARPTR | t.State: pass

TransPyV/temp/81eb28ba912467a6.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": "获取语句类型名"}

TransPyV/temp/81eb28ba912467a6.pyi

@@ -0,0 +1,35 @@
+"""
+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 stdio
+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

TransPyV/temp/83ba314b4637eec9.doc.json

@@ -0,0 +1 @@
+{"TypeRegistry.Register": "注册一个 TypeInfo。ti.Name 字段必须已设置。\n\n        Returns:\n            1 表示成功，0 表示失败（ti 为 None 或 Name 为 None）\n        ", "TypeRegistry.Lookup": "按名称查找 TypeInfo。\n\n        Returns:\n            找到返回 TypeInfo*，找不到返回 None\n        ", "TypeRegistry.Has": "检查类型是否已注册。", "Mixin": "所有 Handle 的非多态基类：持有 Translator 回指针 + 共享委托方法", "Mixin.InitMixin": "初始化 Mixin 字段（子类 __init__ 中调用）"}

TransPyV/temp/83ba314b4637eec9.pyi

@@ -0,0 +1,54 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesBase.py
+Module: lib.core.Handles.HandlesBase
+"""
+
+
+import t, c
+from stdint import *
+import string
+import viperlib
+import memhub
+import hashtable
+import lib.core.Handles.HandlesTranslator as HT
+
+class TypeKind(t.CEnum):
+    Basic: t.State
+    Pointer: t.State
+    Struct: t.State
+    Union: t.State
+    Enum: t.State
+    Typedef: t.State
+    Function: t.State
+    Array: t.State
+    Void: t.State
+@t.NoVTable
+class TypeInfo:
+    Kind: int
+    Name: str
+    Size: int
+    Align: int
+    IsSigned: int
+    PtrCount: int
+    IsConst: int
+    IsVolatile: int
+class TypeRegistry:
+    _ht: hashtable.HashTable | t.CPtr
+    __mbuddy__: memhub.MemManager | t.CPtr
+    def Register(self: TypeRegistry, ti: TypeInfo | t.CPtr) -> int: pass
+    def Lookup(self: TypeRegistry, name: str) -> TypeInfo | t.CPtr: pass
+    def Has(self: TypeRegistry, name: str) -> int: pass
+
+def NewTypeInfo(pool: memhub.MemManager | t.CPtr) -> TypeInfo | t.CPtr: pass
+
+def NewTypeRegistry(pool: memhub.MemManager | t.CPtr) -> TypeRegistry | t.CPtr: pass
+
+def TypeToLLVM(buf: t.CChar | t.CPtr, buf_size: t.CSizeT, ti: TypeInfo | t.CPtr) -> int: pass
+
+
+@t.NoVTable
+class Mixin:
+    Trans: HT.Translator | t.CPtr
+    def InitMixin(self: Mixin, trans: HT.Translator | t.CPtr) -> int: pass
+
+_mbuddy: t.CExtern | t.CVoid | t.CPtr

TransPyV/temp/888ea5bd6ab516ae.doc.json

@@ -0,0 +1 @@
+{"compute_sha1": "计算字符串的 SHA1，返回前 16 个十六进制字符（用于文件命名）", "CleanDir": "删除目录中所有文件（非递归），返回删除的文件数，-1 表示错误"}

TransPyV/temp/888ea5bd6ab516ae.pyi

@@ -0,0 +1,21 @@
+"""
+Auto-generated Python stub file from lib.Projectrans.Utils.py
+Module: lib.Projectrans.Utils
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import stdlib
+import viperlib
+import hashlib
+import w32.win32file
+import w32.win32base
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+
+def compute_sha1(pool: memhub.MemBuddy | t.CPtr, content: str) -> str: pass
+
+def CleanDir(dir_path: str) -> int: pass

TransPyV/temp/8f12094c840be06a.doc.json

@@ -0,0 +1 @@
+{"InitLib": "初始化 lib 包的全局 _mbuddy 指针，并级联注入到所有子模块。\n\n    Args:\n        mb: memhub.MemManager 实例指针（MemBuddy 等子类通过多态传入）\n\n    Returns:\n        0 表示成功，非 0 表示失败\n    "}

TransPyV/temp/8f12094c840be06a.pyi

@@ -0,0 +1,14 @@
+"""
+Auto-generated Python stub file from lib.__init__.py
+Module: lib.__init__
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import lib.core.VLogger as VLogger
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+
+def InitLib(mb: memhub.MemManager | t.CPtr) -> int: pass

TransPyV/temp/90c53dd6db8d41cf.pyi

@@ -0,0 +1,20 @@
+"""
+Auto-generated Python stub file from stdlib.py
+Module: stdlib
+"""
+
+import c
+
+
+from stdint import *
+import t
+
+def malloc(size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def realloc(p: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def free(p: t.CVoid | t.CPtr) -> t.State: pass
+
+def system(cmd: t.CConst | t.CChar | t.CPtr) -> INT | t.State: pass

TransPyV/temp/93c1d18e35d188d6.pyi

@@ -0,0 +1,53 @@
+"""
+Auto-generated Python stub file from platmacro.py
+Module: platmacro
+"""
+
+
+import t, c
+
+IS_WINDOWS: t.CDefine = 1
+IS_WIN64: t.CDefine = 1
+IS_X86_64: t.CDefine = 1
+IS_LP64: t.CDefine = 1
+IS_LITTLE_ENDIAN: t.CDefine = 1
+IS_LINUX: t.CDefine = 0
+IS_MACOS: t.CDefine = 0
+IS_ARM64: t.CDefine = 0
+IS_BIG_ENDIAN: t.CDefine = 0
+IS_ILP32: t.CDefine = 0
+PTR_SIZE: t.CDefine = t.CSizeT().Size
+INT_SIZE: t.CDefine = 4
+LONG_SIZE: t.CDefine = t.CLong().Size
+WORD_SIZE: t.CDefine = t.CSizeT().Size
+CACHE_LINE_SIZE: t.CDefine = 64
+PAGE_SIZE: t.CDefine = 4096
+STACK_ALIGN: t.CDefine = 16
+MAX_PATH_LEN: t.CDefine = 260
+PLATFORM_NAME: t.CDefine = 1
+ARCH_NAME: t.CDefine = 1
+WINVER: t.CDefine = 0x0A00
+_WIN32_WINNT: t.CDefine = 0x0A00
+NTDDI_VERSION: t.CDefine = 0x0A000006
+HAS_SSE2: t.CDefine = 1
+HAS_AVX: t.CDefine = 1
+HAS_AVX2: t.CDefine = 1
+HAS_FMA: t.CDefine = 1
+HAS_NEON: t.CDefine = 0
+ALIGNOF_INT: t.CDefine = 4
+ALIGNOF_LONG: t.CDefine = t.CLong().Size // 8
+ALIGNOF_PTR: t.CDefine = t.CSizeT().Size // 8
+ALIGNOF_DOUBLE: t.CDefine = 8
+ALIGNOF_LONG_DOUBLE: t.CDefine = 16
+SIZEOF_SHORT: t.CDefine = 2
+SIZEOF_INT: t.CDefine = 4
+SIZEOF_LONG: t.CDefine = t.CLong().Size // 8
+SIZEOF_LONG_LONG: t.CDefine = 8
+SIZEOF_FLOAT: t.CDefine = 4
+SIZEOF_DOUBLE: t.CDefine = 8
+SIZEOF_LONG_DOUBLE: t.CDefine = 16
+SIZEOF_POINTER: t.CDefine = t.CSizeT().Size // 8
+SIZEOF_SIZE_T: t.CDefine = t.CSizeT().Size // 8
+SIZEOF_PTRDIFF_T: t.CDefine = t.CPtrDiffT().Size // 8
+BYTE_ORDER_LE: t.CDefine = 1
+BYTE_ORDER_BE: t.CDefine = 0

TransPyV/temp/950028de389b7a7b.doc.json

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

TransPyV/temp/950028de389b7a7b.pyi

@@ -0,0 +1,41 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import string
+import stdlib
+import memhub
+import argparse
+import w32.win32console as w32cmd
+import w32.fileio as fileio
+import w32.win32file
+import w32.win32base
+import sys
+import ast
+import lib
+import lib.core.VLogger as VLogger
+import lib.core.Handles.HandlesTranslator as HandlesTranslator
+import lib.core.Handles.HandlesStruct as HandlesStruct
+import lib.core.Handles.HandlesExprCall as HandlesExprCall
+import lib.core.BuildPipeline as BuildPipeline
+import lib.core.IncludesScanner as IncludesScanner
+import lib.core.StubMerger as StubMerger
+import lib.core.Phase1 as Phase1
+import lib.core.Phase2 as Phase2
+import lib.Projectrans.Config as Config
+import lib.Projectrans.Utils as Utils
+import llvmlite
+import subprocess
+import viperlib
+import hashlib
+
+POOL_SIZE: t.CDefine = 1073741824
+CODE_PAGE: t.CDefine = 65001
+SRC_BUF_SIZE: t.CDefine = 1048576
+
+def main() -> int: pass

TransPyV/temp/95394ca8da0f655a.pyi

@@ -0,0 +1,70 @@
+"""
+Auto-generated Python stub file from llvmlite.__init__.py
+Module: llvmlite.__init__
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import viperlib
+from .__types import LLVMType, ParamNode, LLVMTypeCore, Int1, Int8, Int16, Int32, Int64, Ptr, Func, Void, Array, Struct, Half, Float, Double, FP128, Label, new_param_node, param_list_append, paramnode_get_ty, paramnode_get_next, paramnode_set_ty, paramnode_set_next, TypePrint, PrintStructDefinition, get_struct_name
+from .__values import Value, new_value, ConstInt, ConstNull, ConstZero, ConstFloat, SSAValue, ValuePrint, value_get_ty, value_get_next, value_set_ty, value_set_next, value_set_name, value_set_isconst
+from .__function import Line, BasicBlock, Param, Function, new_line, new_basic_block, new_param, new_function, function_add_param, function_add_block, block_append_line, block_append_text, function_set_attrs, param_set_attrs, function_get_name, function_get_ret_ty, function_get_params, function_get_param_head, function_get_next, function_is_declared, param_get_name, param_get_ty, param_get_next, FunctionPrint
+from .__module import LLVMModule, GlobalVariable, NamedTypeNode, new_module, new_global_variable, module_add_function, module_add_global, module_add_named_type, module_set_target, module_set_datalayout, global_set_constant, global_set_linkage, global_set_unnamed_addr, global_set_section, LLVMModulePrint, OUTPUT_FULL, OUTPUT_STUB, OUTPUT_TEXT, module_ensure_opaque_for_type
+from .__builder import IRBuilder, new_builder, position_at_end, build_alloca, build_load, build_store, build_add, build_sub, build_mul, build_sdiv, build_udiv, build_srem, build_urem, build_and, build_or, build_xor, build_shl, build_lshr, build_ashr, build_fadd, build_fsub, build_fmul, build_fdiv, build_frem, build_fneg, build_icmp, build_fcmp, build_br, build_cond_br, build_ret, build_ret_void, build_call, build_call_indirect, build_bitcast, build_sext, build_trunc, build_zext, build_ptrtoint, build_inttoptr, build_fpext, build_fptrunc, build_fp2si, build_si2fp, build_fp2ui, build_ui2fp, build_gep, build_gep_array, build_gep_struct, build_phi, build_switch, build_select, build_unreachable, build_atomicrmw, build_cmpxchg, build_inline_asm, PhiIncoming, new_phi_incoming, SwitchCase, new_switch_case, ICMP_EQ, ICMP_NE, ICMP_SGT, ICMP_SGE, ICMP_SLT, ICMP_SLE, ICMP_UGT, ICMP_UGE, ICMP_ULT, ICMP_ULE, FCMP_FALSE, FCMP_OEQ, FCMP_OGT, FCMP_OGE, FCMP_OLT, FCMP_OLE, FCMP_ONE, FCMP_ORD, FCMP_UNO, FCMP_UEQ, FCMP_UGT, FCMP_UGE, FCMP_ULT, FCMP_ULE, FCMP_UNE, FCMP_TRUE, ATOMIC_XCHG, ATOMIC_ADD, ATOMIC_SUB, ATOMIC_AND, ATOMIC_NAND, ATOMIC_OR, ATOMIC_XOR, ATOMIC_MAX, ATOMIC_MIN, ATOMIC_UMAX, ATOMIC_UMIN, ATOMIC_ORDER_NOTATOMIC, ATOMIC_ORDER_UNORDERED, ATOMIC_ORDER_MONOTONIC, ATOMIC_ORDER_ACQUIRE, ATOMIC_ORDER_RELEASE, ATOMIC_ORDER_ACQ_REL, ATOMIC_ORDER_SEQ_CST
+from .__verify import VerifyResult, NameEntry, verify_function, verify_module, VERIFY_OK, VERIFY_ERR_NO_TERMINATOR, VERIFY_ERR_DUPLICATE_DEF, VERIFY_ERR_UNDEFINED_USE, VERIFY_ERR_PHI_NOT_FIRST, _new_verify_result
+
+def _str_dup(pool: memhub.MemBuddy | t.CPtr, src: t.CChar | t.CPtr) -> t.CChar | t.CPtr: pass
+
+def create_block(pool: memhub.MemBuddy | t.CPtr, func: Function | t.CPtr, name: t.CChar | t.CPtr) -> BasicBlock | t.CPtr: pass
+
+def const_int(pool: memhub.MemBuddy | t.CPtr, bits: t.CInt, val: t.CInt64T) -> Value | t.CPtr: pass
+
+def const_int32(pool: memhub.MemBuddy | t.CPtr, val: t.CInt64T) -> Value | t.CPtr: pass
+
+def const_int64(pool: memhub.MemBuddy | t.CPtr, val: t.CInt64T) -> Value | t.CPtr: pass
+
+def create_function(pool: memhub.MemBuddy | t.CPtr, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, ret_ty: LLVMType | t.CPtr) -> Function | t.CPtr: pass
+
+def add_param(pool: memhub.MemBuddy | t.CPtr, func: Function | t.CPtr, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Param | t.CPtr: pass
+
+def create_declare(pool: memhub.MemBuddy | t.CPtr, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, ret_ty: LLVMType | t.CPtr) -> Function | t.CPtr: pass
+
+def create_global_string(pool: memhub.MemBuddy | t.CPtr, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, text: t.CChar | t.CPtr) -> GlobalVariable | t.CPtr: pass
+
+def create_global_int(pool: memhub.MemBuddy | t.CPtr, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, bits: t.CInt, val: t.CInt64T) -> GlobalVariable | t.CPtr: pass
+
+
+@t.NoVTable
+class LLVMModuleCore:
+    Pool: memhub.MemBuddy | t.CPtr
+    def __init__(self: LLVMModuleCore, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+    def NewModule(self: LLVMModuleCore, name: t.CChar | t.CPtr) -> LLVMModule | t.CPtr: pass
+    def CreateFunction(self: LLVMModuleCore, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, ret_ty: LLVMType | t.CPtr) -> Function | t.CPtr: pass
+    def CreateDeclare(self: LLVMModuleCore, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, ret_ty: LLVMType | t.CPtr) -> Function | t.CPtr: pass
+    def AddParam(self: LLVMModuleCore, func: Function | t.CPtr, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Param | t.CPtr: pass
+    def FunctionSetAttrs(self: LLVMModuleCore, func: Function | t.CPtr, attrs: t.CChar | t.CPtr) -> t.CInt: pass
+    def ParamSetAttrs(self: LLVMModuleCore, param: Param | t.CPtr, attrs: t.CChar | t.CPtr) -> t.CInt: pass
+    def CreateBlock(self: LLVMModuleCore, func: Function | t.CPtr, name: t.CChar | t.CPtr) -> BasicBlock | t.CPtr: pass
+    def NewBuilder(self: LLVMModuleCore, func: Function | t.CPtr) -> IRBuilder | t.CPtr: pass
+    def NewGlobal(self: LLVMModuleCore, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, ty: LLVMType | t.CPtr) -> GlobalVariable | t.CPtr: pass
+    def CreateGlobalString(self: LLVMModuleCore, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, text: t.CChar | t.CPtr) -> GlobalVariable | t.CPtr: pass
+    def CreateGlobalInt(self: LLVMModuleCore, mod: LLVMModule | t.CPtr, name: t.CChar | t.CPtr, bits: t.CInt, val: t.CInt64T) -> GlobalVariable | t.CPtr: pass
+    def GlobalSetConstant(self: LLVMModuleCore, gv: GlobalVariable | t.CPtr, is_const: t.CInt) -> t.CInt: pass
+    def GlobalSetLinkage(self: LLVMModuleCore, gv: GlobalVariable | t.CPtr, linkage: t.CChar | t.CPtr) -> t.CInt: pass
+    def GlobalSetUnnamedAddr(self: LLVMModuleCore, gv: GlobalVariable | t.CPtr, level: t.CInt) -> t.CInt: pass
+    def GlobalSetSection(self: LLVMModuleCore, gv: GlobalVariable | t.CPtr, section: t.CChar | t.CPtr) -> t.CInt: pass
+    def ConstInt(self: LLVMModuleCore, bits: t.CInt, val: t.CInt64T) -> Value | t.CPtr: pass
+    def ConstInt32(self: LLVMModuleCore, val: t.CInt64T) -> Value | t.CPtr: pass
+    def ConstInt64(self: LLVMModuleCore, val: t.CInt64T) -> Value | t.CPtr: pass
+    def ConstFloat(self: LLVMModuleCore, ty: LLVMType | t.CPtr, val: t.CDouble) -> Value | t.CPtr: pass
+    def SSAValue(self: LLVMModuleCore, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Value | t.CPtr: pass
+    def ConstNull(self: LLVMModuleCore, ty: LLVMType | t.CPtr, name: t.CChar | t.CPtr) -> Value | t.CPtr: pass
+    def PrintValue(self: LLVMModuleCore, buf: t.CChar | t.CPtr, size: t.CSizeT, val: Value | t.CPtr) -> t.CInt: pass
+    def PrintFunction(self: LLVMModuleCore, buf: t.CChar | t.CPtr, size: t.CSizeT, func: Function | t.CPtr) -> t.CInt: pass
+    def PrintModule(self: LLVMModuleCore, buf: t.CChar | t.CPtr, size: t.CSizeT, mod: LLVMModule | t.CPtr) -> t.CInt: pass
+    def NewVerifyResult(self: LLVMModuleCore, buf_size: t.CSizeT) -> VerifyResult | t.CPtr: pass
+    def VerifyFunction(self: LLVMModuleCore, func: Function | t.CPtr, result: VerifyResult | t.CPtr) -> t.CInt: pass
+    def VerifyModule(self: LLVMModuleCore, mod: LLVMModule | t.CPtr, result: VerifyResult | t.CPtr) -> t.CInt: pass

TransPyV/temp/96837bcc64032444.pyi

@@ -0,0 +1,13 @@
+"""
+Auto-generated Python stub file from hashlib.__init__.py
+Module: hashlib.__init__
+"""
+
+import t
+import c
+
+
+from .__md5 import md5, MD5_DIGEST_LEN
+from .__sha1 import sha1, SHA1_DIGEST_LEN
+from .__sha256 import sha256, SHA256_DIGEST_LEN
+from .__sha512 import sha512, SHA512_DIGEST_LEN

TransPyV/temp/_sha1_map.txt

@@ -0,0 +1,79 @@
+001c1416e7a7dc50:lib\core\Handles\HandlesMain.py
+0035c95a18d4f8e8:includes/w32\fileio.py
+02885f6f134079c2:lib\core\Handles\HandlesVar.py
+05c11f22675c60cb:includes/llvmlite\__values.py
+067c78e9f121dce3:includes/w32\win32process.py
+06f53cc594b4ac6c:includes/w32\win32sync.py
+07a8c82a8ca2be90:lib\core\Handles\HandlesExprOps.py
+0c212981c180e7fb:includes/ast\lexer.py
+0c56128647a0b845:lib\core\Handles\HandlesType.py
+0df65b8ed15664b0:includes/hashlib\__sha1.py
+19f8024d10c828e8:includes/hashlib\__md5.py
+20cd49775c100a38:includes/json\__writer.py
+21a7fcfc665f75ef:includes/llvmlite\__module.py
+21fffba3315e81b4:lib\core\VLogger.py
+240a9a4157959a9f:includes/json\__parser.py
+271ea3decb810db2:includes/atom.py
+2998b8f78d7022bf:lib\core\Handles\HandlesTranslator.py
+2d39c6c7d3557b3e:includes/linkedlist.py
+2da636c61863c815:includes/subprocess.py
+2ed380190e9df89e:lib\core\Handles\HandlesAnnAssign.py
+34548789d646f432:includes/ast\__init__.py
+3d3edda4a4e6c08b:lib\core\Handles\HandlesAssign.py
+4020cac9bab5e9f1:lib\core\Handles\HandlesFunctions.py
+4337fb260448bbe2:includes/ast\astaux.py
+455ff4e74c3dbfb0:includes/llvmlite\__types.py
+46ea362b72c10a9e:includes/llvmlite\__builder.py
+47767b5026a8ee15:includes/ast\exprs.py
+48fa8cc758d3826b:lib\core\Handles\HandlesFor.py
+49cf633017627a4a:lib\Projectrans\Config.py
+4dd6b3f1427d1cc5:includes/ast\match.py
+51f0144d6e8188d9:lib\core\Handles\HandlesWhile.py
+54014f6c53e9640b:lib\core\Handles\HandlesStruct.py
+541a090dde0cc1ba:lib\core\Handles\HandlesAugAssign.py
+57288496f7c2d1ad:includes/json\__init__.py
+5dab8cb390496d22:includes/ast\base.py
+6503c97dde0c79c4:includes/posix.py
+657e182b27c2a022:includes/ast\stmts.py
+66de93aaeebc0601:lib\core\Handles\HandlesIf.py
+6f62fe05c5ea1ceb:includes/stdio.py
+6ff26590374ae6fc:includes/hashlib\__sha512.py
+71e0a3ffcb3ebfad:includes/stdarg.py
+78bbe886bbe5ca8f:lib\core\Handles\HandlesImports.py
+7e260c14d2712119:lib\core\Phase2.py
+7e529fe7a078cfef:includes/w32\win32base.py
+81eb28ba912467a6:lib\core\Handles\HandlesBody.py
+83ba314b4637eec9:lib\core\Handles\HandlesBase.py
+888ea5bd6ab516ae:lib\Projectrans\Utils.py
+8f12094c840be06a:lib\__init__.py
+90c53dd6db8d41cf:includes/stdlib.py
+93c1d18e35d188d6:includes/platmacro.py
+950028de389b7a7b:main.py
+95394ca8da0f655a:includes/llvmlite\__init__.py
+96837bcc64032444:includes/hashlib\__init__.py
+ab6e54ba9a669f76:includes/string.py
+aba439b7882ad9d6:includes/argparse.py
+ae0cc890f657076d:lib\core\Handles\HandlesExpr.py
+af9484a65085bf4b:lib\core\Handles\HandlesNonlocal.py
+b29b80b6106e4be7:lib\core\Handles\HandlesExprCall.py
+b547ac4f380bddb6:includes/ast\tokens.py
+b5a965302cded36b:includes/sys.py
+b5d05dbd7fee36ef:lib\core\StubMerger.py
+b8c66c8ff44eb874:includes/hashtable.py
+bbdf3bbd4c3bc28c:includes/w32\win32console.py
+bd82e3ca81546c76:lib\core\IncludesScanner.py
+c3b259b4059f8668:includes/viperlib.py
+c4f2d483ec0f4db5:lib\core\Handles\HandlesClassDef.py
+c9d54a4158f7f5a8:includes/hashlib\__sha256.py
+c9f4be41ca1cc2b4:includes/viperio.py
+d1599ecbac5b6586:lib\core\BuildPipeline.py
+d4117f5e00a6c3b5:includes/llvmlite\__verify.py
+d9322f0db660edd8:lib\core\Handles\HandlesReturn.py
+db7c4a8f09d02a17:lib\core\Phase1.py
+e0b84369e50c937c:includes/llvmlite\__function.py
+e5be27ae4fe7ce04:lib\core\Handles\HandlesEnum.py
+ee084e9fc6ee413a:includes/memhub.py
+ee52c08239684346:includes/ast\parser.py
+f2ecbf8ced20575c:includes/_list.py
+f5522571bcce7bcb:includes/stdint.py
+f6b51804a0ba8ff0:includes/w32\win32file.py

TransPyV/temp/ab6e54ba9a669f76.pyi

@@ -0,0 +1,48 @@
+"""
+Auto-generated Python stub file from string.py
+Module: string
+"""
+
+
+from stdint import *
+import t, c
+
+def strcpy(dest: str, src: str) -> str: pass
+
+def strcat(dest: str, src: str) -> str: pass
+
+def strncpy(dest: str, src: str, n: t.CSizeT) -> str: pass
+
+def strlen(src: str) -> t.CSizeT | t.CExport: pass
+
+def strcmp(str1: str, str2: str) -> t.CInt: pass
+
+def samestr(str1: str, str2: str) -> bool: pass
+
+def strncmp(str1: str, str2: str, n: t.CSizeT) -> t.CInt: pass
+
+def memcmp(ptr1: t.CVoid | t.CPtr, ptr2: t.CVoid | t.CPtr, n: t.CSizeT) -> t.CInt: pass
+
+def strchr(s: str, cr: t.CInt) -> str: pass
+
+def strrchr(s: str, cr: t.CInt) -> str: pass
+
+def strstr(s: str, needle: str) -> str: pass
+
+def strspn(s: str, skip: str) -> int: pass
+
+def memset(ptr: t.CVoid | t.CPtr, value: t.CInt, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memset32(ptr: t.CVoid | t.CPtr, value: t.CUInt32T, count: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def memcpy(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memmove(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def atoi(src: str) -> t.CInt: pass
+
+def atoll(src: str) -> t.CInt64T: pass
+
+def atof(src: str) -> t.CDouble: pass
+
+def split(s: str, delim: str, result: t.CArray[str]) -> int: pass

TransPyV/temp/aba439b7882ad9d6.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from argparse.py
+Module: argparse
+"""
+
+
+import t, c
+from stdint import *
+import string
+import memhub
+import stdio
+import hashtable
+
+STRING: t.CDefine = 0
+INT: t.CDefine = 1
+BOOL: t.CDefine = 2
+STORE: t.CDefine = 0
+STORE_TRUE: t.CDefine = 1
+STORE_FALSE: t.CDefine = 2
+COUNT: t.CDefine = 3
+MAX_ARGS: t.CDefine = 32
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
+
+class Argument:
+    name: str
+    short_name: str
+    help_text: str
+    arg_type: INT
+    action: INT
+    default_int: INT
+    default_str: str
+    required: bool
+    is_positional: bool
+    dest: str
+class ParsedArgs:
+    _ht: hashtable.HashTable | t.CPtr
+    __mbuddy__: memhub.MemBuddy | t.CPtr
+    def __new__(self: ParsedArgs, mb: memhub.MemBuddy | t.CPtr) -> t.CPtr: pass
+    def __init__(self: ParsedArgs, mb: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+    def get_str(self: ParsedArgs, name: str) -> str: pass
+    def get_int(self: ParsedArgs, name: str) -> INT: pass
+    def get_bool(self: ParsedArgs, name: str) -> INT: pass
+    def has(self: ParsedArgs, name: str) -> bool: pass
+    def _set_str(self: ParsedArgs, name: str, val: str) -> t.CInt: pass
+    def _set_int(self: ParsedArgs, name: str, val: INT) -> t.CInt: pass
+    def _set_bool(self: ParsedArgs, name: str, val: bool) -> t.CInt: pass
+class ArgumentParser:
+    _prog: str
+    _description: str
+    _args: Argument | t.CPtr
+    _arg_count: INT
+    __mbuddy__: memhub.MemBuddy | t.CPtr
+    def __new__(self: ArgumentParser, prog: str, description: str, pool: memhub.MemBuddy | t.CPtr) -> t.CPtr: pass
+    def __init__(self: ArgumentParser, prog: str, description: str, pool: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+    def add_argument(self: ArgumentParser, name: str, short: str, arg_type: INT, default: INT, default_str: str, required: bool, action: INT, help: str) -> t.CInt: pass
+    def _get_arg(self: ArgumentParser, idx: INT) -> Argument | t.CPtr: pass
+    def _find_long(self: ArgumentParser, token: str) -> INT: pass
+    def _find_long_prefix(self: ArgumentParser, token: str) -> INT: pass
+    def _find_short(self: ArgumentParser, token: str) -> INT: pass
+    def _find_positional(self: ArgumentParser, pos_idx: INT) -> INT: pass
+    def _store_value(self: ArgumentParser, args: ParsedArgs | t.CPtr, arg: Argument | t.CPtr, value: str) -> t.CInt: pass
+    def _apply_action(self: ArgumentParser, args: ParsedArgs | t.CPtr, arg: Argument | t.CPtr) -> t.CInt: pass
+    def parse_args(self: ArgumentParser, argc: INT, argv: str | t.CPtr) -> ParsedArgs | t.CPtr: pass
+    def print_help(self: ArgumentParser) -> t.CInt: pass
+    def print_usage(self: ArgumentParser) -> t.CInt: pass
+
+def release(args: ParsedArgs | t.CPtr) -> t.CInt: pass

TransPyV/temp/ae0cc890f657076d.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）", "_infer_elem_type_from_value": "从 LLVM Value 的类型推断 list 元素类型名", "_find_pool_var": "查找上下文中的 pool 变量，返回 alloca 或 None", "translate_list_literal": "翻译 list 字面量 [a, b, c] → list[T](pool) + append 序列", "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": "翻译下标表达式，返回加载的元素值", "find_global_in_module": "在模块全局变量链表中按名称查找全局变量", "make_global_ref": "创建全局变量引用 (类型为 ty*，名称为 @name)", "_resolve_module_attribute_global": "解析模块属性访问，返回全局变量引用 (用于跨模块 global 访问)", "translate_attribute": "翻译属性访问，返回加载的字段值", "get_subscript_ptr": "获取下标表达式的元素指针（用于赋值 lhs）", "get_attribute_ptr": "获取属性访问的字段指针（用于赋值 lhs）"}

TransPyV/temp/ae0cc890f657076d.pyi

@@ -0,0 +1,88 @@
+"""
+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
+import lib.core.Handles.HandlesClassDef as HandlesClassDef
+import lib.core.Handles.HandlesImports as HandlesImports
+
+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 _infer_elem_type_from_value(pool: memhub.MemBuddy | t.CPtr, value: llvmlite.Value | t.CPtr) -> str: pass
+
+def _find_pool_var(trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def translate_list_literal(builder: llvmlite.IRBuilder | t.CPtr, pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, node: ast.AST | t.CPtr, elem_type_name: str, 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 find_global_in_module(mod: llvmlite.LLVMModule | t.CPtr, name: str) -> llvmlite.GlobalVariable | t.CPtr: pass
+
+def make_global_ref(pool: memhub.MemBuddy | t.CPtr, name: str, ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def _resolve_module_attribute_global(pool: memhub.MemBuddy | t.CPtr, mod: llvmlite.LLVMModule | t.CPtr, trans: HT.Translator | t.CPtr, at: ast.Attribute | t.CPtr, ty_hint: llvmlite.LLVMType | 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
+
+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

TransPyV/temp/af9484a65085bf4b.doc.json

@@ -0,0 +1 @@
+{"get_env_ptr_var": "获取或创建 _env_ptr 变量（存储闭包 env 指针）", "load_nonlocal_var": "从闭包 env 加载 nonlocal 变量值（env 直接存储 i32 值）", "get_nonlocal_var_ptr": "获取 nonlocal 变量在 env 中的地址（i32*），用于 store 操作"}

TransPyV/temp/af9484a65085bf4b.pyi

@@ -0,0 +1,21 @@
+"""
+Auto-generated Python stub file from lib.core.Handles.HandlesNonlocal.py
+Module: lib.core.Handles.HandlesNonlocal
+"""
+
+
+import t, c
+from stdint import *
+import ast
+import llvmlite
+import memhub
+import string
+import stdio
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Handles.HandlesVar as HandlesVar
+
+def get_env_ptr_var(trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr: pass
+
+def load_nonlocal_var(trans: HT.Translator | t.CPtr, name: str) -> llvmlite.Value | t.CPtr: pass
+
+def get_nonlocal_var_ptr(trans: HT.Translator | t.CPtr, name: str) -> llvmlite.Value | t.CPtr: pass

TransPyV/temp/b29b80b6106e4be7.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, allow_star_fallback: int) -> 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

TransPyV/temp/b547ac4f380bddb6.pyi

@@ -0,0 +1,166 @@
+"""
+Auto-generated Python stub file from ast.tokens.py
+Module: ast.tokens
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+
+class TokenType(t.CEnum):
+    EndMarker: t.State
+    NewLine: t.State
+    Indent: t.State
+    Dedent: t.State
+    Name: t.State
+    Number: t.State
+    String: t.State
+    FStringStart: t.State
+    FStringMiddle: t.State
+    FStringEnd: t.State
+    Op: t.State
+    Nl: t.State
+    Comment: t.State
+    Encoding: t.State
+class Keyword(t.CEnum):
+    NotKeyword: t.State
+    False_: t.State
+    None_: t.State
+    True_: t.State
+    And: t.State
+    As: t.State
+    Assert: t.State
+    Async: t.State
+    Await: t.State
+    Break: t.State
+    Class: t.State
+    Continue: t.State
+    Def: t.State
+    Del: t.State
+    Elif: t.State
+    Else: t.State
+    Except: t.State
+    Finally: t.State
+    For: t.State
+    From: t.State
+    Global: t.State
+    If: t.State
+    Import: t.State
+    In: t.State
+    Is: t.State
+    Lambda: t.State
+    Nonlocal: t.State
+    Not: t.State
+    Or: t.State
+    Pass: t.State
+    Raise: t.State
+    Return: t.State
+    Try: t.State
+    While: t.State
+    With: t.State
+    Yield: t.State
+    Match: t.State
+    Case: t.State
+    Type: t.State
+class TokOp(t.CEnum):
+    LPar: t.State
+    RPar: t.State
+    Lsqb: t.State
+    Rsqb: t.State
+    LBrace: t.State
+    RBrace: t.State
+    Comma: t.State
+    Colon: t.State
+    Dot: t.State
+    Semi: t.State
+    At: t.State
+    Equal: t.State
+    RArrow: t.State
+    PlusEq: t.State
+    MinusEq: t.State
+    StarEq: t.State
+    SlashEq: t.State
+    DSlashEq: t.State
+    PercentEq: t.State
+    AtEq: t.State
+    AmpEq: t.State
+    VBarEq: t.State
+    CaretEq: t.State
+    GtGtEq: t.State
+    LtLtEq: t.State
+    StarEqEq: t.State
+    DSlash: t.State
+    StarStar: t.State
+    LtLt: t.State
+    GtGt: t.State
+    LessEq: t.State
+    GreaterEq: t.State
+    EqEq: t.State
+    ExclaimEq: t.State
+    Less: t.State
+    Greater: t.State
+    Plus: t.State
+    Minus: t.State
+    Star: t.State
+    Slash: t.State
+    Percent: t.State
+    Amp: t.State
+    VBar: t.State
+    Caret: t.State
+    Tilde: t.State
+    ColonEq: t.State
+    Ellipsis: t.State
+    Bang: t.State
+class Token:
+    type: t.CInt
+    op_subtype: t.CInt
+    kw_subtype: t.CInt
+    str_val: str
+    int_val: t.CInt64T
+    float_val: t.CDouble
+    is_float: t.CInt
+    is_complex: t.CInt
+    lineno: t.CInt
+    col_offset: t.CInt
+    end_lineno: t.CInt
+    end_col_offset: t.CInt
+    next: Token | t.CPtr
+    def __new__(self: Token, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+class KwEntry:
+    name: str
+    kw_id: t.CInt
+    next: KwEntry | t.CPtr
+    def __new__(self: KwEntry, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+_kw_head: t.CExtern | KwEntry | t.CPtr
+_kw_pool: t.CExtern | memhub.MemManager | t.CPtr
+
+def _kw_intern(pool: memhub.MemManager | t.CPtr, name: str, kw_id: t.CInt) -> t.CInt: pass
+
+def _kw_lookup(name: str) -> t.CInt: pass
+
+def _init_keywords(pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+
+class OpEntry:
+    name: str
+    op_id: t.CInt
+    length: t.CInt
+    next: OpEntry | t.CPtr
+    def __new__(self: OpEntry, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+_op_head: t.CExtern | OpEntry | t.CPtr
+
+def _op_intern(pool: memhub.MemManager | t.CPtr, name: str, op_id: t.CInt) -> t.CInt: pass
+
+def _init_operators(pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+def _init_tables(pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+
+def new_token(pool: memhub.MemManager | t.CPtr, ttype: t.CInt, lineno: t.CInt, col_offset: t.CInt) -> Token | t.CPtr: pass
+
+def token_set_str(pool: memhub.MemManager | t.CPtr, tok: Token | t.CPtr, src: str, start: t.CSizeT, length: t.CSizeT) -> t.CInt: pass
+
+def token_set_str_literal(pool: memhub.MemManager | t.CPtr, tok: Token | t.CPtr, text: str) -> t.CInt: pass

TransPyV/temp/b5a965302cded36b.pyi

@@ -0,0 +1,44 @@
+"""
+Auto-generated Python stub file from sys.py
+Module: sys
+"""
+
+
+import t, c
+from stdint import *
+import platmacro
+import memhub
+import string
+import stdio
+import w32.win32base
+import w32.win32process
+import posix
+
+_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
+
+def fgets(buf: t.CChar | t.CPtr, size: t.CInt, stream: t.CVoid | t.CPtr) -> t.CChar | t.CPtr | t.CExtern | t.CExport: pass
+
+def fflush(stream: t.CVoid | t.CPtr) -> t.CInt | t.CExtern | t.CExport: pass
+
+def exit(status: INT) -> VOID | t.CExtern | t.CExport: pass
+
+
+maxsize: t.CDefine = 9223372036854775807
+
+def platform() -> str: pass
+
+def get_pid() -> int: pass
+
+
+_argc: t.CExtern | INT
+_argv: t.CExtern | str | t.CPtr
+
+def _init_argv() -> t.CInt: pass
+
+def _init_argv_win32() -> t.CInt: pass
+
+def _init_argv_posix() -> t.CInt: pass
+
+def argc() -> int: pass
+
+def argv(index: int) -> str: pass

TransPyV/temp/b5d05dbd7fee36ef.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": "将文件路径转换为模块名\n\n    特殊处理 __init__.py：includes/ast/__init__.py → ast（而非 ast.__init__）\n    ", "_BuildIncludesSha1Map": "从 _sha1_map.txt 构建 sha1→module_name 映射，返回条目数", "_FindSha1ByModName": "从模块名查找 SHA1（精确匹配）", "_AddSha1ToSet": "将 SHA1 加入集合，返回新 count", "_BuildReachableSha1Set": "构建可达 SHA1 集合（依赖图按需翻译）", "BuildCombinedIR": "组合本地 stub + 依赖 stubs + 本地 text → out_buf（按需加载）"}

TransPyV/temp/b5d05dbd7fee36ef.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

TransPyV/temp/b8c66c8ff44eb874.pyi

@@ -0,0 +1,46 @@
+"""
+Auto-generated Python stub file from hashtable.py
+Module: hashtable
+"""
+
+
+import t, c
+import string
+import memhub
+from stdint import *
+
+_HT_EMPTY: t.CDefine = 0
+_HT_TOMBSTONE: t.CDefine = 1
+_HT_INIT_CAP: t.CDefine = 16
+_HT_SLOT_SIZE: t.CDefine = 24
+_FNV_OFFSET: t.CExtern | t.CUInt64T
+_FNV_PRIME: t.CExtern | t.CUInt64T
+
+def _fnv1a_hash(key: str) -> t.CUInt64T: pass
+
+
+class HashTable:
+    __slots__: t.CVoid | t.CPtr
+    __count__: t.CSizeT = 0
+    __capacity__: t.CSizeT = 16
+    __tombstones__: t.CSizeT = 0
+    __mbuddy__: memhub.MemBuddy | t.CPtr
+    __iter_index__: t.CSizeT = 0
+    def __new__(self: HashTable, mb: memhub.MemBuddy | t.CPtr) -> t.CPtr: pass
+    def __init__(self: HashTable, mb: memhub.MemBuddy | t.CPtr) -> t.CInt: pass
+    def _slot_hash(self: HashTable, idx: t.CSizeT) -> t.CUInt64T: pass
+    def _slot_key(self: HashTable, idx: t.CSizeT) -> str: pass
+    def _slot_value(self: HashTable, idx: t.CSizeT) -> t.CPtr: pass
+    def _set_slot(self: HashTable, idx: t.CSizeT, h: t.CUInt64T, key: str, val: t.CPtr) -> t.CInt: pass
+    def _find_slot(self: HashTable, key: str, h: t.CUInt64T) -> t.CSizeT: pass
+    def _resize(self: HashTable, new_cap: t.CSizeT) -> t.CInt: pass
+    def __setitem__(self: HashTable, key: str, val: t.CNeedPtr) -> t.CInt: pass
+    def __getitem__(self: HashTable, key: str) -> t.CPtr: pass
+    def __contains__(self: HashTable, key: str) -> t.CInt: pass
+    def __delitem__(self: HashTable, key: str) -> t.CInt: pass
+    def __len__(self: HashTable) -> t.CSizeT: pass
+    def __iter__(self: HashTable) -> HashTable | t.CPtr: pass
+    def __next__(self: HashTable) -> str: pass
+    def get(self: HashTable, key: str, default: t.CPtr) -> t.CPtr: pass
+    def set_int(self: HashTable, key: str, val: int) -> t.CInt: pass
+    def set_str(self: HashTable, key: str, val: str) -> t.CInt: pass

TransPyV/temp/bbdf3bbd4c3bc28c.pyi

@@ -0,0 +1,138 @@
+"""
+Auto-generated Python stub file from w32.win32console.py
+Module: w32.win32console
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+ENABLE_PROCESSED_INPUT: t.CDefine = 0x0001
+ENABLE_LINE_INPUT: t.CDefine = 0x0002
+ENABLE_ECHO_INPUT: t.CDefine = 0x0004
+ENABLE_WINDOW_INPUT: t.CDefine = 0x0008
+ENABLE_MOUSE_INPUT: t.CDefine = 0x0010
+ENABLE_INSERT_MODE: t.CDefine = 0x0020
+ENABLE_QUICK_EDIT_MODE: t.CDefine = 0x0040
+ENABLE_EXTENDED_FLAGS: t.CDefine = 0x0080
+ENABLE_PROCESSED_OUTPUT: t.CDefine = 0x0001
+ENABLE_WRAP_AT_EOL_OUTPUT: t.CDefine = 0x0002
+ENABLE_VIRTUAL_TERMINAL_PROCESSING: t.CDefine = 0x0004
+DISABLE_NEWLINE_AUTO_RETURN: t.CDefine = 0x0008
+ENABLE_LVB_GRID_WORLDWIDE: t.CDefine = 0x0010
+FOREGROUND_BLUE: t.CDefine = 0x0001
+FOREGROUND_GREEN: t.CDefine = 0x0002
+FOREGROUND_RED: t.CDefine = 0x0004
+FOREGROUND_INTENSITY: t.CDefine = 0x0008
+BACKGROUND_BLUE: t.CDefine = 0x0010
+BACKGROUND_GREEN: t.CDefine = 0x0020
+BACKGROUND_RED: t.CDefine = 0x0040
+BACKGROUND_INTENSITY: t.CDefine = 0x0080
+KEY_EVENT: t.CDefine = 0x0001
+MOUSE_EVENT: t.CDefine = 0x0002
+WINDOW_BUFFER_SIZE_EVENT: t.CDefine = 0x0004
+MENU_EVENT: t.CDefine = 0x0008
+FOCUS_EVENT: t.CDefine = 0x0010
+
+class COORD:
+    X: SHORT
+    Y: SHORT
+class SMALL_RECT:
+    Left: SHORT
+    Top: SHORT
+    Right: SHORT
+    Bottom: SHORT
+class CONSOLE_SCREEN_BUFFER_INFO:
+    dwSize: COORD
+    dwCursorPosition: COORD
+    wAttributes: WORD
+    srWindow: SMALL_RECT
+    dwMaximumWindowSize: COORD
+class CONSOLE_CURSOR_INFO:
+    dwSize: ULONG
+    bVisible: BOOL
+class CHAR_INFO:
+    UnicodeChar: WCHAR
+    Attributes: WORD
+class KEY_EVENT_RECORD:
+    bKeyDown: BOOL
+    wRepeatCount: WORD
+    wVirtualKeyCode: WORD
+    wVirtualScanCode: WORD
+    uChar: WCHAR
+    dwControlKeyState: ULONG
+class MOUSE_EVENT_RECORD:
+    dwMousePosition: COORD
+    dwButtonState: ULONG
+    dwControlKeyState: ULONG
+    dwEventFlags: ULONG
+class WINDOW_BUFFER_SIZE_RECORD:
+    dwSize: COORD
+class INPUT_RECORD:
+    EventType: WORD
+    Event: KEY_EVENT_RECORD
+
+def SetConsoleOutputCP(codepage: UINT) -> BOOL | t.State: pass
+
+def SetConsoleCP(codepage: UINT) -> BOOL | t.State: pass
+
+def GetConsoleCP() -> UINT | t.State: pass
+
+def GetConsoleOutputCP() -> UINT | t.State: pass
+
+def GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleScreenBufferSize(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL | t.State: pass
+
+def SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) -> BOOL | t.State: pass
+
+def GetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL | t.State: pass
+
+def FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: t.CChar, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FillConsoleOutputCharacterW(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfAttrsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def WriteConsoleA(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
+
+def WriteConsoleW(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
+
+def ReadConsoleA(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
+
+def ReadConsoleW(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
+
+def GetConsoleMode(hConsoleHandle: HANDLE, lpMode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleMode(hConsoleHandle: HANDLE, dwMode: ULONG) -> BOOL | t.State: pass
+
+def ReadConsoleInputA(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def ReadConsoleInputW(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE, lpNumberOfEvents: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FlushConsoleInputBuffer(hConsoleInput: HANDLE) -> BOOL | t.State: pass
+
+def SetConsoleTitleA(lpConsoleTitle: LPCSTR) -> BOOL | t.State: pass
+
+def SetConsoleTitleW(lpConsoleTitle: LPCWSTR) -> BOOL | t.State: pass
+
+def GetConsoleTitleA(lpConsoleTitle: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def GetConsoleTitleW(lpConsoleTitle: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def AllocConsole() -> BOOL | t.State: pass
+
+def FreeConsole() -> BOOL | t.State: pass
+
+def SetConsoleWindowInfo(hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: SMALL_RECT | t.CPtr) -> BOOL | t.State: pass
+
+def ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE, lpScrollRectangle: SMALL_RECT | t.CPtr, lpClipRectangle: SMALL_RECT | t.CPtr, dwDestinationOrigin: COORD, lpFill: CHAR_INFO | t.CPtr) -> BOOL | t.State: pass

TransPyV/temp/bd82e3ca81546c76.doc.json

@@ -0,0 +1 @@
+{"FileEntry": "扫描到的文件条目", "ScanResult": "扫描结果集合", "create_scan_result": "创建扫描结果容器，预分配 MAX_FILES 个槽位", "add_file_entry": "添加文件条目到扫描结果，返回 0 成功", "compute_file_sha1": "读取文件内容并计算 SHA1 前16字符（CRLF→LF 后计算，与 Projectrans.py 一致）", "scan_directory_recursive": "递归扫描目录，收集 .py 文件", "scan_includes": "扫描 includes 目录，返回所有 .py 文件的扫描结果", "find_entry_by_module": "按模块名查找文件条目"}

TransPyV/temp/bd82e3ca81546c76.pyi

@@ -0,0 +1,45 @@
+"""
+Auto-generated Python stub file from lib.core.IncludesScanner.py
+Module: lib.core.IncludesScanner
+"""
+
+
+import t, c
+from stdint import *
+import memhub
+import string
+import stdio
+import stdlib
+import w32.win32file as win32file
+import w32.win32base as win32base
+import w32.fileio as fileio
+import hashlib
+import viperlib
+
+_mbuddy: t.CExtern | memhub.MemManager | t.CPtr
+MAX_PATH_LEN: t.CDefine = 512
+MAX_FILES: t.CDefine = 256
+
+@t.NoVTable
+class FileEntry:
+    Path: str
+    Sha1: str
+    RelPath: str
+    ModuleName: str
+@t.NoVTable
+class ScanResult:
+    Entries: FileEntry | t.CPtr
+    Count: t.CInt
+    Capacity: t.CInt
+
+def create_scan_result(pool: memhub.MemBuddy | t.CPtr) -> ScanResult | t.CPtr: pass
+
+def add_file_entry(result: ScanResult | t.CPtr, pool: memhub.MemBuddy | t.CPtr, abs_path: str, rel_path: str, sha1: str) -> int: pass
+
+def compute_file_sha1(pool: memhub.MemBuddy | t.CPtr, file_path: str) -> str: pass
+
+def scan_directory_recursive(pool: memhub.MemBuddy | t.CPtr, root_dir: str, rel_prefix: str, result: ScanResult | t.CPtr) -> int: pass
+
+def scan_includes(pool: memhub.MemBuddy | t.CPtr, includes_dir: str) -> ScanResult | t.CPtr: pass
+
+def find_entry_by_module(result: ScanResult | t.CPtr, module_name: str) -> FileEntry | t.CPtr: pass

TransPyV/temp/c3b259b4059f8668.pyi

@@ -0,0 +1,23 @@
+"""
+Auto-generated Python stub file from viperlib.py
+Module: viperlib
+"""
+
+
+import t, c
+import viperio
+from stdarg import arg, va_arg
+
+TEMP_BUF_SIZE: t.CDefine = 68
+
+def get_digit_count(num: t.CUnsignedInt, base: t.CInt) -> t.CStatic | t.CInt: pass
+
+def sprintf(buf: t.CChar | t.CPtr, rule: str, *args) -> t.CVoid | t.CExport: pass
+
+def vsprintf(buf: t.CChar | t.CPtr, rule: str, *args) -> t.CInt: pass
+
+def snprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, *args) -> t.CInt | t.CExport: pass
+
+def _check_special_float(fv: t.CDouble) -> t.CInt: pass
+
+def vsnprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, ap: t.CChar | t.CPtr) -> t.CInt | t.CExport: pass

TransPyV/temp/c4f2d483ec0f4db5.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"}

TransPyV/temp/c4f2d483ec0f4db5.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

TransPyV/temp/c9d54a4158f7f5a8.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from hashlib.__sha256.py
+Module: hashlib.__sha256
+"""
+
+
+import t, c
+
+SHA256_BLOCK_LEN:  t.CDefine = 64
+SHA256_DIGEST_LEN: t.CDefine = 32
+sha256_K: t.CExtern | t.CArray[t.CUInt32T, 64]
+
+def s0(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def s1(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def S0(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def S1(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def Ch(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def Maj(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+
+@t.Object
+class sha256:
+    state: t.CArray[t.CUInt32T, 8]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA256_BLOCK_LEN]
+    def __init__(self: sha256) -> t.CInt: pass
+    def transform(self: sha256, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha256, s: str) -> t.CInt: pass
+    def final(self: sha256, out: t.CArray[t.CUInt8T, SHA256_DIGEST_LEN]) -> t.CInt: pass