GVSDS/TransPyV
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

实现了 TPV 的 pyi 生成逻辑（部分），删除了直接拷贝自 CPython（TPC） 版本的死代码

Browse Source
This commit is contained in:
TermiNexus
2026-07-22 19:47:23 +08:00
parent a99d2a5ad9
commit 751dc72d61
19 changed files with 641 additions and 1436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
App/lib/core/Handles/HandlesClassDef.py
View File

@@ -1626,11 +1626,9 @@ def translate_class_def(trans: HT.Translator | t.CPtr,
if fname is not None and fty2 is not None:
HandlesStruct.add_field(pool, entry, fname, fty2, fdef, fannot)
stdio.printf("[CLASS] registered %s with %d fields (vtable=%d)\n",
class_name, field_count, has_vtable)
# Phase 1a 声明模式：只注册 struct，不翻译方法体
# Phase 1a 声明模式：只注册 struct + 设置 OOP 标志，不翻译方法体
if trans._declare_only == 1:
_translate_oop_methods(trans, cd, struct_ty, class_name, 1)
return 0
# ============================================================
@@ -1997,8 +1995,6 @@ def _generate_vtable(trans: HT.Translator | t.CPtr,
vt_self_entry.VTableMethods = method_names_buf
vt_self_entry.VTableMethodCount = method_count
stdio.printf("[VTABLE] generated vtable for %s with %d methods\n",
class_name, method_count)
return 0
@@ -2023,8 +2019,12 @@ def _generate_vtable(trans: HT.Translator | t.CPtr,
def _translate_oop_methods(trans: HT.Translator | t.CPtr,
cd: ast.ClassDef | t.CPtr,
struct_ty: llvmlite.LLVMType | t.CPtr,
class_name: str) -> int:
"""扫描 class body 中的方法并翻译，生成 __before_init__"""
class_name: str,
mark_only: int = 0) -> int:
"""扫描 class body 中的方法并翻译，生成 __before_init__
mark_only: 0=全量翻译（默认），1=只设置 IsOOP/HasNew/HasInit 标志（不翻译方法体）
"""
if trans is None or cd is None or struct_ty is None or class_name is None:
return 0
@@ -2075,6 +2075,10 @@ def _translate_oop_methods(trans: HT.Translator | t.CPtr,
if has_new != 0:
oop_entry.HasNew = 1
# mark_only 模式：只设置标志，不翻译方法体
if mark_only != 0:
return 0
# 第二遍：翻译每个方法
for ci in range(cn):
stmt: ast.AST | t.CPtr = children.get(ci)

4
App/lib/core/Handles/HandlesExpr.py
View File

@@ -207,6 +207,10 @@ def coerce_to_type(builder: llvmlite.IRBuilder | t.CPtr,
# float → int
if val_fbits != 0 and target_bits != 0:
return llvmlite.build_fp2si(builder, val, target_ty)
# 整数 → 指针: inttoptr
# 适用于: 跨模块方法返回 i64（默认推断），目标变量是指针类型
if val_bits != 0 and is_ptr_type(target_ty) != 0:
return llvmlite.build_inttoptr(builder, val, target_ty)
# 指针 → 非指针值: build_load 解引用
# 适用于: 指针 → 整数 (如 i8* → i8), 指针 → 结构体值
# 当构造器返回 Ptr(Struct) 但目标变量是 Struct 值类型时，需要 load

24
App/lib/core/Handles/HandlesExprCall.py
View File

@@ -905,12 +905,6 @@ def _asm_add_operand(operands: AsmOperand | t.CPtr,
op.Value = val
op.Constraint = constraint
op.IsOutput = is_output
if val is not None:
stdio.printf("[A] count=%d op=%lld val=%lld val.Ty=%lld val.Name=%lld is_out=%d\n",
count, t.CInt64T(op), t.CInt64T(val), t.CInt64T(val.Ty), t.CInt64T(val.Name), is_output)
else:
stdio.printf("[A] count=%d op=%lld val=None is_out=%d\n", count, t.CInt64T(op), is_output)
stdio.fflush(0)
return count + 1
# ============================================================
@@ -1177,9 +1171,6 @@ def translate_c_asm(pool: memhub.MemBuddy | t.CPtr,
ret_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Void(pool)
if output_count > 0 and first_output_idx >= 0:
out_op: AsmOperand | t.CPtr = _asm_get_operand(operands, first_output_idx)
stdio.printf("[R] out_idx=%d out_op=%lld Val=%lld\n",
first_output_idx, t.CInt64T(out_op), t.CInt64T(out_op.Value))
stdio.fflush(0)
if out_op.Value is not None and out_op.Value.Ty is not None:
# alloca 的类型是指针，Pointee 是目标类型
if out_op.Value.Ty.Pointee is not None:
@@ -2352,6 +2343,11 @@ def _call_method_on_ptr(pool: memhub.MemBuddy | t.CPtr,
frt: llvmlite.LLVMType | t.CPtr = llvmlite.function_get_ret_ty(found_func)
if frt is not None:
call_ret_ty = frt
else:
# found_func 为 None（跨模块调用 stub 未注入）：根据方法名推断返回类型
# __new__ 返回 Ptr(struct_ty)，其他方法默认 void
if string.strcmp(method_name, "__new__") == 0 and cmop_struct_ty is not None:
call_ret_ty = llvmlite.Ptr(pool, cmop_struct_ty)
# 构建参数链表: self_ptr → extra_args...
llvmlite.value_set_next(self_ptr, None)
@@ -2449,9 +2445,15 @@ def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr,
# 返回 void 的方法
if string.strcmp(method_name, "__before_init__") == 0:
return llvmlite.Void(pool)
if string.strcmp(method_name, "__init__") == 0:
return llvmlite.Void(pool)
if string.strcmp(method_name, "__exit__") == 0:
return llvmlite.Void(pool)
# 默认 i32（free, reset, __init__, __exit__, _fl_push 等）
return llvmlite.Int32(pool)
# 默认 i64（整数）：既可安全截断为 i32（trunc），也可转换为指针（inttoptr）
# 避免使用指针类型（i8*）导致 coerce_to_type 生成 load（解引用）造成崩溃
# x86-64 ABI 中 i32 返回值在 rax 低 32 位，i64 读取后 trunc 取低 32 位是安全的
return llvmlite.Int64(pool)
# ============================================================
# _translate_method_call - 翻译方法调用 obj.method(args)

55
App/lib/core/Handles/HandlesFunctions.py
View File

@@ -399,9 +399,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
if fd is None or fd.name is None:
return 0
stdio.printf("[FD] enter name=%s\n", fd.name)
stdio.fflush(0)
pool: memhub.MemBuddy | t.CPtr = trans.Pool
mod: llvmlite.LLVMModule | t.CPtr = trans.Module
imported_modules: str = trans._imported_modules
@@ -412,8 +409,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
i32_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int32(pool)
# 推断返回类型：优先使用返回类型注解
stdio.printf("[FD] %s 推断返回类型前\n", fd.name)
stdio.fflush(0)
ret_ty: llvmlite.LLVMType | t.CPtr = None
if fd.returns is not None:
ret_ty = HandlesType.resolve_annotation_type(
@@ -430,9 +425,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
param_types_str: str = HandlesType.build_param_types_str(pool, fd.args)
ret_ty = HandlesType.infer_return_type(
pool, fd.children, param_types_str)
stdio.printf("[FD] %s 推断返回类型后=%d\n", fd.name, ret_ty)
stdio.fflush(0)
# 检测是否为外部声明函数（t.CExtern 或 t.State）
# 语义：t.CExtern 忽略 body 体，仅生成 declare（由链接器解析符号）
# t.State = t.CExtern + t.CExport（既是声明又是导出）
@@ -449,9 +441,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
# t.CExtern/t.State 忽略 body 体，仅声明（无论 body 是否为 pass）
if has_extern != 0 or has_state != 0:
is_extern_decl = 1
stdio.printf("[FD] %s extern=%d state=%d export=%d is_extern_decl=%d\n",
fd.name, has_extern, has_state, has_export, is_extern_decl)
stdio.fflush(0)
# SHA1 命名空间：t.CExtern/t.State/t.CExport 不加前缀，直接用裸名
# （裸名映射到 C 标准库符号，带 sha1 前缀会导致 undefined reference）
@@ -460,8 +449,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
mangled_name: str = fd.name
else:
mangled_name: str = _mangle_func_name(trans, fd.name, 0)
stdio.printf("[FD] %s mangled_name=%s\n", fd.name, mangled_name)
stdio.fflush(0)
# 注册 CExport 函数到全局表（供跨模块调用查表）
# t.CExport 函数定义用裸名（@strlen），跨模块调用需查表确认用裸名而非 @{sha1}.func
@@ -479,7 +466,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
func: llvmlite.Function | t.CPtr = llvmlite.create_declare(
pool, mod, mangled_name, ret_ty)
if func is None:
stdio.printf("[FUNC] create_declare %s failed\n", fd.name)
return 0
# 注册到函数表
@@ -523,11 +509,7 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
args_node: ast.Arguments | t.CPtr = fd.args
# 检查是否已有前向声明（由 forward_declare_functions 创建）
stdio.printf("[FD] %s find_func_in_module 前\n", fd.name)
stdio.fflush(0)
func: llvmlite.Function | t.CPtr = HandlesExprCall.find_func_in_module(mod, mangled_name)
stdio.printf("[FD] %s find_func_in_module 后=%d\n", fd.name, func)
stdio.fflush(0)
if func is not None and llvmlite.function_is_declared(func) != 0:
# 复用前向声明：清除 IsDeclared 标记，转为 define
func.IsDeclared = 0
@@ -535,15 +517,9 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
func_attrs_reuse: t.CChar | t.CPtr = extract_func_attrs(pool, fd.decorator_list, imported_modules)
if func_attrs_reuse is not None:
llvmlite.function_set_attrs(func, func_attrs_reuse)
stdio.printf("[FD] %s 复用前向声明\n", fd.name)
stdio.fflush(0)
else:
# 创建新的 LLVM 函数（使用 SHA1 混淆名）
stdio.printf("[FD] %s create_function 前\n", fd.name)
stdio.fflush(0)
func = llvmlite.create_function(pool, mod, mangled_name, ret_ty)
stdio.printf("[FD] %s create_function 后=%d\n", fd.name, func)
stdio.fflush(0)
if func is None:
stdio.printf("[FUNC] create_function %s failed\n", fd.name)
return 0
@@ -581,38 +557,21 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
if pname is not None:
viperlib.snprintf(pname, 32, "%%%s", arg.arg)
llvmlite.add_param(pool, func, param_ty, pname)
stdio.printf("[FD] %s 新函数创建完成\n", fd.name)
stdio.fflush(0)
# 创建 entry 块
stdio.printf("[FD] %s create_block 前\n", fd.name)
stdio.fflush(0)
entry_blk: llvmlite.BasicBlock | t.CPtr = llvmlite.create_block(pool, func, "entry")
stdio.printf("[FD] %s create_block 后=%d\n", fd.name, entry_blk)
stdio.fflush(0)
if entry_blk is None:
return 0
# 创建函数专属 builder
stdio.printf("[FD] %s new_builder 前\n", fd.name)
stdio.fflush(0)
func_builder: llvmlite.IRBuilder | t.CPtr = llvmlite.new_builder(pool, func)
stdio.printf("[FD] %s new_builder 后=%d\n", fd.name, func_builder)
stdio.fflush(0)
if func_builder is None:
return 0
llvmlite.position_at_end(func_builder, entry_blk)
# 进入函数作用域（嵌套符号表）
stdio.printf("[FD] %s enter_scope 前\n", fd.name)
stdio.fflush(0)
HandlesVar.enter_scope(trans.SymTab, HandlesVar.SCOPE_FUNCTION)
stdio.printf("[FD] %s enter_scope 后\n", fd.name)
stdio.fflush(0)
# 为参数创建 alloca
stdio.printf("[FD] %s 参数 alloca 前\n", fd.name)
stdio.fflush(0)
if args_node is not None:
ags2: ast.Arguments | t.CPtr = (ast.Arguments | t.CPtr)(args_node)
if ags2.args is not None:
@@ -647,9 +606,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
param_val: llvmlite.Value | t.CPtr = llvmlite.SSAValue(
pool, param_ty2, pname2)
llvmlite.build_store(func_builder, param_val, alloca)
stdio.printf("[FD] %s 参数 alloca 后\n", fd.name)
stdio.fflush(0)
# 保存模块级作用域状态（仅非变量表相关）
old_func: llvmlite.Function | t.CPtr = trans._cur_func
old_builder: llvmlite.IRBuilder | t.CPtr = trans._cur_builder
@@ -663,8 +619,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
HT.clear_scope_names(trans)
# 预扫描函数体：为局部变量提前创建 alloca
stdio.printf("[FD] %s pre_scan_allocas 前\n", fd.name)
stdio.fflush(0)
body: list[ast.AST | t.CPtr] | t.CPtr = fd.children
if body is not None:
bn: t.CSizeT = body.__len__()
@@ -672,23 +626,14 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
stmt: ast.AST | t.CPtr = body.get(bi)
if stmt is not None:
HandlesBody.pre_scan_allocas(trans, stmt)
stdio.printf("[FD] %s pre_scan_allocas 后\n", fd.name)
stdio.fflush(0)
# 翻译函数体
stdio.printf("[FD] %s translate_stmt 前 body_len=%d\n", fd.name,
body.__len__() if body is not None else 0)
stdio.fflush(0)
if body is not None:
bn2: t.CSizeT = body.__len__()
for bi2 in range(bn2):
stmt2: ast.AST | t.CPtr = body.get(bi2)
if stmt2 is not None:
stdio.printf("[FD] %s translate_stmt bi2=%d kd=%d 前\n", fd.name, bi2, stmt2.kind())
stdio.fflush(0)
HandlesBody.translate_stmt(trans, stmt2)
stdio.printf("[FD] %s translate_stmt bi2=%d 后\n", fd.name, bi2)
stdio.fflush(0)
# 如果函数体最后一条语句不是 Return，添加隐式 ret
last_is_return: int = 0

36
App/lib/core/Handles/HandlesMain.py
View File

@@ -81,81 +81,45 @@ def translate_children(trans: HT.Translator | t.CPtr,
cn_count: t.CSizeT = ch.__len__()
added_total: int = 0
stdio.printf("[TC] cn_count=%d\n", cn_count)
stdio.fflush(0)
for ci in range(cn_count):
child: ast.AST | t.CPtr = ch.get(ci)
if child is None: continue
kd: int = child.kind()
stdio.printf("[TC] ci=%d kd=%d\n", ci, kd)
stdio.fflush(0)
if kd == ast.ASTKind.Import:
stdio.printf("[TC] ci=%d 处理 Import\n", ci)
stdio.fflush(0)
trans.ImportsH.HandleImport(child)
stdio.printf("[TC] ci=%d Import 后\n", ci)
stdio.fflush(0)
elif kd == ast.ASTKind.ImportFrom:
stdio.printf("[TC] ci=%d 处理 ImportFrom\n", ci)
stdio.fflush(0)
trans.ImportsH.HandleImportFromModule(child)
trans.ImportsH.HandleImportFromNames(child)
stdio.printf("[TC] ci=%d ImportFrom 后\n", ci)
stdio.fflush(0)
elif kd == ast.ASTKind.FunctionDef:
# Phase 1a 声明模式：只注册 CExport/State 函数到全局表（解决翻译顺序依赖）
# Phase 1b 全量翻译：正常翻译函数体
fd_dbg: ast.FunctionDef | t.CPtr = (ast.FunctionDef | t.CPtr)(child)
fd_name_dbg: str = "?" if fd_dbg is None or fd_dbg.name is None else fd_dbg.name
stdio.printf("[TC] ci=%d FunctionDef name=%s _declare_only=%d 前\n", ci, fd_name_dbg, trans._declare_only)
stdio.fflush(0)
if trans._declare_only == 0:
added: int = HandlesFunctions.translate_function_def(trans, child)
added_total += added
elif trans._declare_only == 1:
_register_cexport_from_funcdef(trans, child)
stdio.printf("[TC] ci=%d FunctionDef 后\n", ci)
stdio.fflush(0)
elif kd == ast.ASTKind.ClassDef:
# ClassDef 在模块级直接处理（不需要 builder）
# _declare_only=2（import扫描模式）时跳过，只处理 import 依赖
cd_node: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(child)
cd_name: str = "?" if cd_node is None or cd_node.name is None else cd_node.name
stdio.printf("[TC] ci=%d ClassDef name=%s 前\n", ci, cd_name)
stdio.fflush(0)
if trans._declare_only != 2:
HandlesClassDef.translate_class_def(trans, child)
stdio.printf("[TC] ci=%d ClassDef 后\n", ci)
stdio.fflush(0)
elif trans._declare_only == 0 and trans._cur_builder is not None:
# 有 builder → 委托 HandlesBody 分派
stdio.printf("[TC] ci=%d translate_stmt 前\n", ci)
stdio.fflush(0)
added = HandlesBody.translate_stmt(trans, child)
added_total += added
stdio.printf("[TC] ci=%d translate_stmt 后\n", ci)
stdio.fflush(0)
elif kd == ast.ASTKind.AnnAssign and trans._declare_only != 2:
# 模块级 AnnAssign
# _declare_only=2（import扫描模式）时跳过
# _declare_only=1（struct注册模式）时只处理 CDefine（在 handle_module_level_var 内部判断）
# _declare_only=0（全量翻译）时处理所有模块级 AnnAssign
stdio.printf("[TC] ci=%d AnnAssign 前\n", ci)
stdio.fflush(0)
added = handle_module_level_var(trans, child)
added_total += added
stdio.printf("[TC] ci=%d AnnAssign 后\n", ci)
stdio.fflush(0)
elif trans._declare_only == 0 and kd == ast.ASTKind.Assign:
# 无 builder 的模块级 Assign → 创建全局变量（仅全量翻译模式）
stdio.printf("[TC] ci=%d Assign 前\n", ci)
stdio.fflush(0)
added = handle_module_level_var(trans, child)
added_total += added
stdio.printf("[TC] ci=%d Assign 后\n", ci)
stdio.fflush(0)
return added_total

40
App/lib/core/Handles/HandlesTranslator.py
View File

@@ -206,19 +206,11 @@ class Translator:
pool: memhub.MemBuddy | t.CPtr = _mbuddy
stdio.printf("[TR] step1 _init_state 前\n")
stdio.fflush(0)
# 初始化状态
self._init_state(pool)
stdio.printf("[TR] step1 _init_state 后\n")
stdio.fflush(0)
# 创建 LLVM 模块
stdio.printf("[TR] step2 new_module 前\n")
stdio.fflush(0)
mod: llvmlite.LLVMModule | t.CPtr = llvmlite.new_module(pool, "main")
stdio.printf("[TR] step2 new_module 后=%d\n", mod)
stdio.fflush(0)
if mod is None:
stdio.printf("[TR] NewModule returned NULL\n")
return 1
@@ -228,11 +220,7 @@ class Translator:
triple: str = Config.TargetTriple
if triple is None:
triple = "x86_64-pc-windows-msvc"
stdio.printf("[TR] step3 module_set_target 前\n")
stdio.fflush(0)
llvmlite.module_set_target(mod, triple)
stdio.printf("[TR] step3 module_set_target 后\n")
stdio.fflush(0)
# 类型
i32_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int32(pool)
@@ -240,12 +228,8 @@ class Translator:
i8_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, i8_ty)
# 声明 printf
stdio.printf("[TR] step4 create_declare printf 前\n")
stdio.fflush(0)
printf_func: llvmlite.Function | t.CPtr = llvmlite.create_declare(
pool, mod, "printf", i32_ty)
stdio.printf("[TR] step4 create_declare printf 后=%d\n", printf_func)
stdio.fflush(0)
if printf_func is None:
stdio.printf("[TR] CreateDeclare printf returned NULL\n")
return 1
@@ -253,19 +237,13 @@ class Translator:
printf_func.IsVarArg = 1
# 声明 malloc（闭包分配用）
stdio.printf("[TR] step5 create_declare malloc 前\n")
stdio.fflush(0)
malloc_func: llvmlite.Function | t.CPtr = llvmlite.create_declare(
pool, mod, "malloc", i8_ptr_ty)
stdio.printf("[TR] step5 create_declare malloc 后\n")
stdio.fflush(0)
if malloc_func is not None:
i64_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int64(pool)
llvmlite.add_param(pool, malloc_func, i64_ty, "size")
# 检查用户是否定义了 main 函数
stdio.printf("[TR] step6 检查 user main 前\n")
stdio.fflush(0)
has_user_main: int = 0
ch: list[ast.AST | t.CPtr] | t.CPtr = tree.children
if ch is not None:
@@ -278,11 +256,7 @@ class Translator:
if string.strcmp(fd.name, "main") == 0:
has_user_main = 1
break
stdio.printf("[TR] step6 检查 user main 后=%d\n", has_user_main)
stdio.fflush(0)
stdio.printf("[TR] step7 _translate_module_level 前\n")
stdio.fflush(0)
if self._declare_only != 0:
# Phase 1a-pre(2=import扫描) / Phase 1a(1=struct注册): 只处理模块级，不创建 main 函数和 builder
self._translate_module_level(pool, mod, tree)
@@ -294,8 +268,6 @@ class Translator:
else:
# 用户已定义 main → 委托 HandlesMain 翻译模块级
self._translate_module_level(pool, mod, tree)
stdio.printf("[TR] step7 _translate_module_level 后\n")
stdio.fflush(0)
return 0
@@ -318,8 +290,6 @@ class Translator:
"""委托 HandlesMain.translate_children() 翻译模块级语句（trans 单参）"""
# 全量翻译模式下，先处理导入语句，再创建前向声明，解决前向引用问题
if self._declare_only == 0:
stdio.printf("[TR._translate_module_level] _declare_only==0, 预处理 imports\n")
stdio.fflush(0)
# 预处理导入语句，确保 _imported_modules 和 _from_imports 已填充
# （前向声明需要解析类型注解，如 t.CArray[str] 依赖 t 模块已导入）
ch: list[ast.AST | t.CPtr] | t.CPtr = tree.children
@@ -335,19 +305,9 @@ class Translator:
elif kd == ast.ASTKind.ImportFrom:
self.ImportsH.HandleImportFromModule(child)
self.ImportsH.HandleImportFromNames(child)
stdio.printf("[TR._translate_module_level] 预处理 imports 完成\n")
stdio.fflush(0)
# 创建前向声明
stdio.printf("[TR._translate_module_level] forward_declare_functions 前\n")
stdio.fflush(0)
HandlesFunctions.forward_declare_functions(self, tree)
stdio.printf("[TR._translate_module_level] forward_declare_functions 后\n")
stdio.fflush(0)
stdio.printf("[TR._translate_module_level] translate_children 前\n")
stdio.fflush(0)
added: int = HandlesMain.translate_children(self, tree)
stdio.printf("[TR._translate_module_level] translate_children 后=%d\n", added)
stdio.fflush(0)
# ============================================================
# IR 输出