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

Fixed some bugs and tried to maintain the bootstrap

Browse Source
This commit is contained in:
TermiNexus
2026-07-28 21:10:05 +08:00
parent 03d0bba534
commit 68481a5a7f
28 changed files with 667 additions and 1491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
App/lib/Projectrans/Config.py
View File

@@ -52,71 +52,36 @@ def Load_project_config(path: str) -> int:
global IncludesDir
if path is None:
stdio.printf("[CFG] FAIL: path is None\n")
stdio.fflush(0)
return 1
if _mbuddy is None:
stdio.printf("[CFG] FAIL: _mbuddy is None\n")
stdio.fflush(0)
return 1
# 打开文件
stdio.printf("[CFG] before File ctor path=%s\n", path)
stdio.fflush(0)
f: fileio.File | t.CPtr = fileio.File(path, fileio.MODE.R)
f_closed_flag: int = 1
if f is not None:
if f.closed:
f_closed_flag = 1
else:
f_closed_flag = 0
stdio.printf("[CFG] after File ctor f=%p closed=%d\n", f, f_closed_flag)
stdio.fflush(0)
if f is None:
stdio.printf("[CFG] FAIL: File ctor returned None\n")
stdio.fflush(0)
return 1
if f.closed:
stdio.printf("[CFG] FAIL: f.closed is True\n")
stdio.fflush(0)
return 1
# 分配读取缓冲区
CFG_BUF_SIZE: t.CSizeT = 8192
buf: bytes = _mbuddy.alloc(CFG_BUF_SIZE)
if buf is None:
stdio.printf("[CFG] FAIL: alloc buf failed\n")
stdio.fflush(0)
f.close()
return 1
stdio.printf("[CFG] before read_all\n")
stdio.fflush(0)
bytes_read: t.CInt64T = f.read_all(buf, CFG_BUF_SIZE)
f.close()
stdio.printf("[CFG] after read_all bytes_read=%d\n", bytes_read)
stdio.fflush(0)
if bytes_read <= 0:
stdio.printf("[CFG] FAIL: bytes_read <= 0\n")
stdio.fflush(0)
return 1
# 解析 JSON
stdio.printf("[CFG] before json_parse\n")
stdio.fflush(0)
root: JsonValue | t.CPtr = json_parse(_mbuddy, buf)
stdio.printf("[CFG] after json_parse root=%p\n", root)
stdio.fflush(0)
if root is None:
stdio.printf("[CFG] FAIL: json_parse returned None\n")
stdio.fflush(0)
return 1
if not root.is_object():
stdio.printf("[CFG] FAIL: root is not object\n")
stdio.fflush(0)
return 1
stdio.printf("[CFG] root is object OK\n")
stdio.fflush(0)
# 读取顶层字段（使用显式 __getitem__ 调用，兼容旧编译器二进制）
sd_val: JsonValue | t.CPtr = root.__getitem__("source_dir")

2
App/lib/Projectrans/Utils.py
View File

@@ -16,7 +16,7 @@ import w32.win32base
# ============================================================
# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# ============================================================

7
App/lib/__init__.py
View File

@@ -9,14 +9,15 @@ import lib.core.VLogger as VLogger
# ============================================================
# 全局 mbuddy 内存池指针（由 App/main.py 初始化后注入）
_mbuddy: memhub.MemManager | t.CPtr
# 注意: 使用 MemBuddy 类型而非 MemManager，避免虚函数分派不工作时调用父类 alloc 返回 None
_mbuddy: memhub.MemBuddy | t.CPtr
def InitLib(mb: memhub.MemManager | t.CPtr) -> int:
def InitLib(mb: memhub.MemBuddy | t.CPtr) -> int:
"""初始化 lib 包的全局 _mbuddy 指针，并级联注入到所有子模块。
Args:
mb: memhub.MemManager 实例指针（MemBuddy 等子类通过多态传入）
mb: memhub.MemBuddy 实例指针
Returns:
0 表示成功，非 0 表示失败

45
App/lib/core/BuildPipeline.py
View File

@@ -27,7 +27,7 @@ import lib.Projectrans.Config as Config
# ============================================================
# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# 源代码缓冲区大小（1MB）
SRC_BUF_SIZE: t.CDefine = 1048576
@@ -270,26 +270,11 @@ def compile_ll_to_obj(ir_path: str, output_dir: str, module_name: str, cc_cmd: s
return 1
viperlib.snprintf(cmd, cmd_len, "%s %s -o %s %s", cc_cmd, cc_flags, obj_path, ir_path)
result: subprocess.CompletedProcess | t.CPtr = subprocess.run(cmd, True, True)
if result is None:
# 用 stdlib.system() 直接在控制台运行，输出直接显示
# 避免 subprocess 管道捕获丢失输出
sys_ret: int = stdlib.system(cmd)
if sys_ret != 0:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "subprocess.run 返回 None: %s", module_name)
VLogger.error(fb, "LLC")
return 1
if result.returncode != 0:
# 先直接输出 llc 的具体错误信息（VLogger.error 会 sys.exit，必须先输出）
# 注意: subprocess 在 Windows 下将 stderr 合并到 stdout（si.hStdError = stdout_write）
# 因此 result.stderr 总是 None，错误信息在 result.stdout 中
# stdout 通常已含换行符，不再额外加 \n
if result.stdout is not None:
stdio.printf("%s", result.stdout)
stdio.fflush(0)
if result.stderr is not None:
stdio.printf("%s", result.stderr)
stdio.fflush(0)
# 最后输出编译失败摘要（VLogger.error 会 sys.exit）
fb = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "编译失败 (module=%s, cmd=%s)", module_name, cmd)
VLogger.error(fb, "LLC")
@@ -524,23 +509,13 @@ def link_objs_to_exe(obj_paths: str, obj_paths_len: t.CSizeT,
viperlib.snprintf(cmd, cmd_len, "%s %s -o %s %s",
linker_cmd, obj_paths, linker_output, linker_flags)
result: subprocess.CompletedProcess | t.CPtr = subprocess.run(cmd, True, True)
if result is None:
VLogger.error("subprocess.run 返回 None", "link")
return 1
if result.returncode != 0:
# 先直接输出 linker 的具体错误信息（VLogger.error 会 sys.exit，必须先输出）
# stdout/stderr 通常已含换行符，不再额外加 \n
if result.stdout is not None:
stdio.printf("%s", result.stdout)
stdio.fflush(0)
if result.stderr is not None:
stdio.printf("%s", result.stderr)
stdio.fflush(0)
# 最后输出链接失败摘要（VLogger.error 会 sys.exit）
# 用 stdlib.system() 直接在控制台运行链接，输出直接显示
# 避免 subprocess 管道捕获丢失输出（TransPyV 标准句柄可能无效）
sys_ret: int = stdlib.system(cmd)
if sys_ret != 0:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "链接失败，返回码: %d, 命令: %s", result.returncode, cmd)
viperlib.snprintf(fb, 1024, "链接失败，返回码: %d, 命令: %s", sys_ret, cmd)
VLogger.error(fb, "link")
return 1
return 0

67
App/lib/core/Handles/HandlesAnnAssign.py
View File

@@ -4,6 +4,7 @@ import ast
import llvmlite
import memhub
import string
import stdio
import lib.core.Handles.HandlesBase as HandlesBase
import lib.core.Handles.HandlesTranslator as HT
import lib.core.Handles.HandlesVar as HandlesVar
@@ -49,18 +50,72 @@ def is_cdefine_annotation(annot: ast.AST | t.CPtr) -> int:
# ============================================================
# extract_cdefine_int_value - 从 AnnAssign.value 提取整数常量（模块级函数）
#
# 仅支持 ast.Constant(INT)，其他形式返回 0
# 支持的表达式形式:
# 1. Constant(INT) — 如 0x0002, 42
# 2. BinOp(BitOr/BitAnd) — 如 FOREGROUND_RED | FOREGROUND_GREEN
# 3. Name — 引用已注册的 CDefine 常量
# 4. Call — 如 t.CUnsignedLong(-11) → 取第一个参数
# 5. UnaryOp(USub/UAdd/Invert) — 如 -11
# ============================================================
def extract_cdefine_int_value(val_node: ast.AST | t.CPtr) -> int:
"""从值节点提取整数常量（仅支持 Constant INT）"""
"""从值节点提取整数常量（支持 Constant/BinOp/Name/Call/UnaryOp）"""
if val_node is None:
return 0
if val_node.kind() != ast.ASTKind.Constant:
k: int = val_node.kind()
# Case 1: Constant(INT) — 如 0x0002
if k == ast.ASTKind.Constant:
cn: ast.Constant | t.CPtr = (ast.Constant | t.CPtr)(val_node)
if cn.const_kind != ast.CONST_INT:
return 0
return cn.int_val
# Case 2: BinOp — 如 FOREGROUND_RED | FOREGROUND_GREEN
if k == ast.ASTKind.BinOp:
bop: ast.BinOp | t.CPtr = (ast.BinOp | t.CPtr)(val_node)
left_val: int = extract_cdefine_int_value(bop.left)
right_val: int = extract_cdefine_int_value(bop.right)
if bop.op == ast.OpKind.BitOr:
return left_val | right_val
if bop.op == ast.OpKind.BitAnd:
return left_val & right_val
if bop.op == ast.OpKind.Add:
return left_val + right_val
if bop.op == ast.OpKind.Sub:
return left_val - right_val
return 0
cn: ast.Constant | t.CPtr = (ast.Constant | t.CPtr)(val_node)
if cn.const_kind != ast.CONST_INT:
# Case 3: Name — 引用已注册的 CDefine 常量
if k == ast.ASTKind.Name:
nm: ast.Name | t.CPtr = (ast.Name | t.CPtr)(val_node)
if nm.id is not None:
looked_up: int = HandlesType.lookup_cdefine_constant(nm.id)
if HandlesType.is_cdefine_found() != 0:
return looked_up
return 0
return cn.int_val
# Case 4: Call — 如 t.CUnsignedLong(-11)
if k == ast.ASTKind.Call:
cl: ast.Call | t.CPtr = (ast.Call | t.CPtr)(val_node)
if cl.args is not None and cl.args.__len__() > 0:
first_arg: ast.AST | t.CPtr = cl.args.get(0)
arg_val: int = extract_cdefine_int_value(first_arg)
return arg_val
return 0
# Case 5: UnaryOp — 如 -11
if k == ast.ASTKind.UnaryOp:
uop: ast.UnaryOp | t.CPtr = (ast.UnaryOp | t.CPtr)(val_node)
operand_val: int = extract_cdefine_int_value(uop.operand)
if uop.op == ast.OpKind.USub:
return -operand_val
if uop.op == ast.OpKind.UAdd:
return operand_val
if uop.op == ast.OpKind.Invert:
return ~operand_val
return 0
return 0
# ============================================================

13
App/lib/core/Handles/HandlesAssign.py
View File

@@ -238,8 +238,6 @@ class AssignHandle(HandlesBase.Mixin):
setitem_done = 1
if setitem_done == 0:
sub_vk: int = sub_asgn.value.kind()
stdio.printf("[ASGN-SUB] fallback failed: val_kind=%d\n", sub_vk)
stdio.fflush(0)
if setitem_done == 0:
HandlesType.fatal_error(target, "subscript ptr is None")
continue
@@ -249,25 +247,14 @@ class AssignHandle(HandlesBase.Mixin):
field_ptr: llvmlite.Value | t.CPtr = HandlesExpr.get_attribute_ptr(
builder, pool, mod, target, self.Trans)
if field_ptr is not None:
stdio.printf("[ASGN-ATTR] field_ptr ok ty_not_null=%d\n",
1 if field_ptr.Ty is not None else 0)
stdio.fflush(0)
# 获取字段类型，对 rhs_val 进行类型转换（如 i32 → i64）
store_val: llvmlite.Value | t.CPtr = rhs_val
if field_ptr.Ty is not None:
field_ty: llvmlite.LLVMType | t.CPtr = field_ptr.Ty.Pointee
if field_ty is not None:
stdio.printf("[ASGN-ATTR] coerce rhs_ty=%d field_ty=%d\n",
HandlesExpr.get_llvm_type_bits(rhs_val.Ty),
HandlesExpr.get_llvm_type_bits(field_ty))
stdio.fflush(0)
store_val = HandlesExpr.coerce_to_type(
builder, rhs_val, field_ty)
stdio.printf("[ASGN-ATTR] pre_store\n")
stdio.fflush(0)
llvmlite.build_store(builder, store_val, field_ptr)
stdio.printf("[ASGN-ATTR] post_store\n")
stdio.fflush(0)
else:
# 构造详细错误信息
attr_node: ast.Attribute | t.CPtr = (ast.Attribute | t.CPtr)(target)

6
App/lib/core/Handles/HandlesBase.py
View File

@@ -69,7 +69,7 @@ class TypeInfo:
# ============================================================
class TypeRegistry:
_ht: hashtable.HashTable | t.CPtr
__mbuddy__: memhub.MemManager | t.CPtr
__mbuddy__: memhub.MemBuddy | t.CPtr
def Register(self, ti: TypeInfo | t.CPtr) -> int:
"""注册一个 TypeInfo。ti.Name 字段必须已设置。
@@ -106,7 +106,7 @@ class TypeRegistry:
#
# 默认值：Kind=Basic, IsSigned=-1, 其余=0/None
# ============================================================
def NewTypeInfo(pool: memhub.MemManager | t.CPtr) -> TypeInfo | t.CPtr:
def NewTypeInfo(pool: memhub.MemBuddy | t.CPtr) -> TypeInfo | t.CPtr:
ptr: TypeInfo | t.CPtr = pool.alloc(TypeInfo.__sizeof__())
if ptr is None:
return None
@@ -119,7 +119,7 @@ def NewTypeInfo(pool: memhub.MemManager | t.CPtr) -> TypeInfo | t.CPtr:
# ============================================================
# NewTypeRegistry - 工厂函数：创建类型注册表
# ============================================================
def NewTypeRegistry(pool: memhub.MemManager | t.CPtr) -> TypeRegistry | t.CPtr:
def NewTypeRegistry(pool: memhub.MemBuddy | t.CPtr) -> TypeRegistry | t.CPtr:
ptr: TypeRegistry | t.CPtr = pool.alloc(TypeRegistry.__sizeof__())
if ptr is None:
return None

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

@@ -818,7 +818,7 @@ def _translate_enum_def(trans: HT.Translator | t.CPtr,
# 用于联合体确定最大字段大小
# ============================================================
def _get_type_size(ty: llvmlite.LLVMType | t.CPtr) -> int:
"""计算 LLVM 类型的字节大小"""
"""计算 LLVM 类型的字节大小（含对齐 padding）"""
if ty is None:
return 0
match ty:
@@ -831,20 +831,79 @@ def _get_type_size(ty: llvmlite.LLVMType | t.CPtr) -> int:
case llvmlite.LLVMType.Array(elem_ty, count):
return _get_type_size(elem_ty) * count
case llvmlite.LLVMType.Struct(fields, fcount, name):
# 计算结构体大小，考虑字段对齐 padding
# 规则: 每个字段的对齐 = 该字段类型的自然对齐
# 指针/i64 → 8, i32 → 4, i16 → 2, i8 → 1
# 结构体总大小需对齐到最大字段对齐的倍数
total: int = 0
max_align: int = 1
cur: llvmlite.ParamNode | t.CPtr = fields
i: int = 0
while cur is not None and i < fcount:
if cur.Ty is not None:
fty: llvmlite.LLVMType | t.CPtr = (llvmlite.LLVMType | t.CPtr)(cur.Ty)
total += _get_type_size(fty)
fsize: int = _get_type_size(fty)
falign: int = _get_type_align(fty)
# 对齐当前偏移到字段对齐边界
if falign > 0:
rem: int = total % falign
if rem != 0:
total += falign - rem
total += fsize
if falign > max_align:
max_align = falign
cur = cur.Next
i += 1
# 结构体总大小对齐到最大字段对齐的倍数
rem2: int = total % max_align
if rem2 != 0:
total += max_align - rem2
return total
case _:
return 8
def _get_type_align(ty: llvmlite.LLVMType | t.CPtr) -> int:
"""返回类型的自然对齐（字节）"""
if ty is None:
return 1
match ty:
case llvmlite.LLVMType.Int(bits):
if bits <= 8:
return 1
elif bits <= 16:
return 2
elif bits <= 32:
return 4
else:
return 8
case llvmlite.LLVMType.Float(bits):
if bits <= 32:
return 4
else:
return 8
case llvmlite.LLVMType.Ptr(pointee):
return 8
case llvmlite.LLVMType.Array(elem_ty, count):
return _get_type_align(elem_ty)
case llvmlite.LLVMType.Struct(fields, fcount, name):
# 结构体的对齐 = 最大字段对齐
max_align: int = 1
cur: llvmlite.ParamNode | t.CPtr = fields
i: int = 0
while cur is not None and i < fcount:
if cur.Ty is not None:
fty: llvmlite.LLVMType | t.CPtr = (llvmlite.LLVMType | t.CPtr)(cur.Ty)
fa: int = _get_type_align(fty)
if fa > max_align:
max_align = fa
cur = cur.Next
i += 1
return max_align
case _:
return 8
# ============================================================
# _translate_union_def — 翻译联合体定义
#
@@ -3003,6 +3062,8 @@ def _translate_method(trans: HT.Translator | t.CPtr,
return 0
# 提取默认参数信息（方法的 args[0] 是 self，不含在 param_count 中）
# 注意: 必须先把属性赋给显式类型为 list[...] | t.CPtr 的局部变量再调用 __len__()，
# 否则编译器无法识别属性返回的 list 类型，GEP base 会变成 i32 0 导致 llc 报错
md_defaults: t.CVoid | t.CPtr = None
md_default_count: int = 0
md_param_count: int = 0
@@ -3010,10 +3071,12 @@ def _translate_method(trans: HT.Translator | t.CPtr,
if md_args_node is not None:
md_ags: ast.Arguments | t.CPtr = (ast.Arguments | t.CPtr)(md_args_node)
if md_ags.args is not None:
md_param_count = md_ags.args.__len__() - 1
md_alist: list[ast.AST | t.CPtr] | t.CPtr = md_ags.args
md_param_count = md_alist.__len__() - 1
if md_ags.defaults is not None:
md_defaults = md_ags.defaults
md_default_count = md_ags.defaults.__len__()
md_dlist: list[ast.AST | t.CPtr] | t.CPtr = md_ags.defaults
md_defaults = md_dlist
md_default_count = md_dlist.__len__()
# 注册到函数表（用 ClassName.method_name 作为查找名，支持后缀匹配）
max_funcs: int = 256
@@ -3059,12 +3122,16 @@ def _translate_method(trans: HT.Translator | t.CPtr,
# 进入函数作用域
HandlesVar.enter_scope(trans.SymTab, SCOPE_FUNCTION)
# 注册 self 为 SSA 值（不创建 alloca，不 store）
# 这样 self.field 通过 lookup_var 获取 Ptr(struct_ty) 后直接 GEP
self_val: llvmlite.Value | t.CPtr = llvmlite.SSAValue(pool, self_ptr_ty, "%self")
HandlesVar.define_var(trans.SymTab, "self", self_val)
# 设置 self 的类型注解类名（属性访问 lookup_field 回退查找用）
HandlesVar.set_var_annot_class_name(trans.SymTab, "self", class_name)
# 为 self 创建 alloca 并 store（与其他参数一致）
# 修复: 之前 self 注册为 SSA 值导致 translate_name_value 错误地 load 一次
# 将 Ptr(struct_ty) 变成 struct 值，引发变参函数 ABI 不匹配崩溃
self_alloca: llvmlite.Value | t.CPtr = llvmlite.build_alloca(func_builder, self_ptr_ty)
if self_alloca is not None:
HandlesVar.define_var(trans.SymTab, "self", self_alloca)
# 设置 self 的类型注解类名（属性访问 lookup_field 回退查找用）
HandlesVar.set_var_annot_class_name(trans.SymTab, "self", class_name)
self_val: llvmlite.Value | t.CPtr = llvmlite.SSAValue(pool, self_ptr_ty, "%self")
llvmlite.build_store(func_builder, self_val, self_alloca)
# 为其他参数创建 alloca 并 store（与普通函数一致，跳过索引 0 的 self 参数）
if args_node is not None:

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

@@ -238,7 +238,10 @@ def coerce_to_type(builder: llvmlite.IRBuilder | t.CPtr,
if val_bits != 0 and is_ptr_type(target_ty) != 0:
return llvmlite.build_inttoptr(builder, val, target_ty)
# 指针 → 整数: ptrtoint（当目标明确是整数而非指针时）
if is_ptr_type(val.Ty) != 0 and target_bits != 0 and is_ptr_type(target_ty) == 0:
# 注意: target_bits == 8 时跳过 ptrtoint，走后面的 build_load 解引用首字符
# 修复: buf[idx] = '\0' 中 '\0' 是 CONST_STR → i8* 指针，
# ptrtoint 会截断地址低 8 位（非 0），应 load 解引用取首字符 0
if is_ptr_type(val.Ty) != 0 and target_bits != 0 and target_bits != 8 and is_ptr_type(target_ty) == 0:
return llvmlite.build_ptrtoint(builder, val, target_ty)
if val_bits != 0 and target_bits != 0:
if val_bits == target_bits:
@@ -284,8 +287,6 @@ def create_global_string(builder: llvmlite.IRBuilder | t.CPtr,
"""创建全局字符串常量并返回 i8* bitcast"""
escaped: t.CChar | t.CPtr = escape_llvm_string(pool, str_val)
if escaped is None:
stdio.printf("[CGS] escape_llvm_string None\n")
stdio.fflush(0)
return None
slen: t.CSizeT = string.strlen(str_val)
@@ -301,8 +302,6 @@ def create_global_string(builder: llvmlite.IRBuilder | t.CPtr,
# 字符串名加 SHA1 前缀，和函数导出规则一致，避免跨模块重名
gv_name: t.CChar | t.CPtr = pool.alloc(48)
if gv_name is None:
stdio.printf("[CGS] gv_name alloc None\n")
stdio.fflush(0)
return None
if trans.ModuleSha1 is not None:
viperlib.snprintf(gv_name, 48, ".str.%s.%d", trans.ModuleSha1, str_idx)
@@ -311,8 +310,6 @@ def create_global_string(builder: llvmlite.IRBuilder | t.CPtr,
gv: llvmlite.GlobalVariable | t.CPtr = llvmlite.new_global_variable(pool, gv_name, arr_ty)
if gv is None:
stdio.printf("[CGS] new_global_variable None name=%s\n", gv_name)
stdio.fflush(0)
return None
llvmlite.module_add_global(mod, gv)
@@ -324,8 +321,6 @@ def create_global_string(builder: llvmlite.IRBuilder | t.CPtr,
arr_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, arr_ty)
gv_ref_name: t.CChar | t.CPtr = pool.alloc(64)
if gv_ref_name is None:
stdio.printf("[CGS] gv_ref_name alloc None\n")
stdio.fflush(0)
return None
viperlib.snprintf(gv_ref_name, 64, "@%s", gv.Name)
gv_ref: llvmlite.Value | t.CPtr = llvmlite.SSAValue(pool, arr_ptr_ty, gv_ref_name)
@@ -333,9 +328,6 @@ def create_global_string(builder: llvmlite.IRBuilder | t.CPtr,
i8_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, i8_ty)
bc: llvmlite.Value | t.CPtr = llvmlite.build_bitcast(builder, gv_ref, i8_ptr_ty)
if bc is None:
stdio.printf("[CGS] build_bitcast None\n")
stdio.fflush(0)
return bc
@@ -350,12 +342,8 @@ def translate_constant(builder: llvmlite.IRBuilder | t.CPtr,
"""翻译常量（int/str/bool）"""
cn: ast.Constant | t.CPtr = (ast.Constant | t.CPtr)(node)
if cn is None:
stdio.printf("[TC] cn is None\n")
stdio.fflush(0)
return None
ck: int = cn.const_kind
stdio.printf("[TC] const_kind=%d\n", ck)
stdio.fflush(0)
if cn.const_kind == ast.CONST_INT:
# 超出 i32 范围则用 i64（避免常量创建时被截断）
iv: t.CInt64T = cn.int_val
@@ -366,18 +354,15 @@ def translate_constant(builder: llvmlite.IRBuilder | t.CPtr,
# 浮点常量默认创建为 double（64 位），赋值时由 coerce_to_type 自动 fptrunc
double_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Double(pool)
return llvmlite.ConstFloat(pool, double_ty, cn.float_val)
elif cn.const_kind == ast.CONST_CHAR:
# 单引号单字符 → i32 值（字符 ASCII 码），coerce_to_type 会 trunc 为 i8
cv: t.CInt64T = cn.int_val
return llvmlite.const_int32(pool, cv)
elif cn.const_kind == ast.CONST_STR:
sv: str = cn.str_val
if sv is None:
stdio.printf("[TC] CONST_STR but str_val is None\n")
stdio.fflush(0)
return None
stdio.printf("[TC] CONST_STR sv[0]=%d\n", sv[0])
stdio.fflush(0)
r: llvmlite.Value | t.CPtr = create_global_string(builder, pool, mod, sv, trans)
if r is None:
stdio.printf("[TC] create_global_string returned None\n")
stdio.fflush(0)
return r
elif cn.const_kind == ast.CONST_BOOL:
if cn.int_val != 0:
@@ -385,32 +370,14 @@ def translate_constant(builder: llvmlite.IRBuilder | t.CPtr,
return llvmlite.const_int32(pool, 0)
elif cn.const_kind == ast.CONST_NONE:
# None → i8* null（空指针常量），用于 `p is None` / `p is not None` 比较
stdio.printf("[TC] NONE step1 Int8\n")
stdio.fflush(0)
i8_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int8(pool)
if i8_ty is None:
stdio.printf("[TC] NONE Int8 alloc None\n")
stdio.fflush(0)
return None
stdio.printf("[TC] NONE step2 Ptr\n")
stdio.fflush(0)
i8_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, i8_ty)
if i8_ptr_ty is None:
stdio.printf("[TC] NONE Ptr alloc None\n")
stdio.fflush(0)
return None
stdio.printf("[TC] NONE step3 ConstNull\n")
stdio.fflush(0)
rv_none: llvmlite.Value | t.CPtr = llvmlite.ConstNull(pool, i8_ptr_ty, "null")
if rv_none is None:
stdio.printf("[TC] NONE ConstNull None\n")
stdio.fflush(0)
else:
stdio.printf("[TC] NONE ok\n")
stdio.fflush(0)
return rv_none
stdio.printf("[TC] unknown const_kind=%d\n", ck)
stdio.fflush(0)
return None
@@ -632,12 +599,6 @@ def translate_value(builder: llvmlite.IRBuilder | t.CPtr,
k: int = node.kind()
if k == ast.ASTKind.Constant:
rv: llvmlite.Value | t.CPtr = translate_constant(builder, pool, mod, node, trans)
if rv is None:
stdio.printf("[TV] Constant returned None\n")
stdio.fflush(0)
else:
stdio.printf("[TV] Constant ok\n")
stdio.fflush(0)
return rv
elif k == ast.ASTKind.Name:
return translate_name_value(builder, pool, node, trans)
@@ -686,24 +647,25 @@ def translate_ifexp(builder: llvmlite.IRBuilder | t.CPtr,
func: llvmlite.Function | t.CPtr = trans._cur_func
if func is None:
stdio.printf("[IFEXP] func=None\n")
stdio.fflush(0)
return None
# 1. 求值条件
cond_val: llvmlite.Value | t.CPtr = translate_value(
builder, pool, mod, ie.test, None, 0, trans)
if cond_val is None:
stdio.printf("[IFEXP] cond_val=None\n")
stdio.fflush(0)
return None
# 转换为 i1
cond_bits: int = get_llvm_type_bits(cond_val.Ty)
if cond_bits == 1:
cond_i1: llvmlite.Value | t.CPtr = cond_val
else:
zero: llvmlite.Value | t.CPtr = llvmlite.const_int32(pool, 0)
cond_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, cond_val, zero)
if is_ptr_type(cond_val.Ty) != 0:
# 指针类型：与 null 比较
null_cond: llvmlite.Value | t.CPtr = llvmlite.ConstNull(pool, cond_val.Ty, "null")
cond_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, cond_val, null_cond)
else:
zero: llvmlite.Value | t.CPtr = llvmlite.const_int32(pool, 0)
cond_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, cond_val, zero)
# 2. 创建三个基本块
cnt: int = trans._label_counter
@@ -818,14 +780,10 @@ def translate_compare(builder: llvmlite.IRBuilder | t.CPtr,
comparators: list[ast.AST | t.CPtr] | t.CPtr = cmp.comparators
if comparators is None or comparators.__len__() == 0:
stdio.printf("[CMP] comparators empty\n")
stdio.fflush(0)
return None
rhs: llvmlite.Value | t.CPtr = translate_value(
builder, pool, mod, comparators.get(0), None, 0, trans)
if rhs is None:
stdio.printf("[CMP] rhs=None\n")
stdio.fflush(0)
return None
# === 比较运算符重载路径 1: lhs 是 Name 且对应结构体变量 ===
@@ -846,8 +804,6 @@ def translate_compare(builder: llvmlite.IRBuilder | t.CPtr,
lhs: llvmlite.Value | t.CPtr = translate_value(
builder, pool, mod, cmp.left, None, 0, trans)
if lhs is None:
stdio.printf("[CMP] lhs=None\n")
stdio.fflush(0)
return None
# === 比较运算符重载路径 2: lhs 是 Ptr(Struct) ===
@@ -933,7 +889,11 @@ def translate_unaryop(builder: llvmlite.IRBuilder | t.CPtr,
# +x = x
return operand
elif uo.op == ast.OpKind.Not:
# not x = (x == 0)，返回 i1
# not x = (x == 0/null)，返回 i1
if is_ptr_type(operand.Ty) != 0:
# 指针类型：与 null 比较
null_op: llvmlite.Value | t.CPtr = llvmlite.ConstNull(pool, operand.Ty, "null")
return llvmlite.build_icmp(builder, llvmlite.ICMP_EQ, operand, null_op)
operand_bits_not: int = get_llvm_type_bits(operand.Ty)
zero = llvmlite.const_int32(pool, 0)
if operand_bits_not == 64:
@@ -1009,12 +969,17 @@ def translate_boolop(builder: llvmlite.IRBuilder | t.CPtr,
if val is None:
return None
# 转为 i1（已经是 i1 的直接用，否则与 0 比较）
# 转为 i1（已经是 i1 的直接用，否则与 0/null 比较）
val_bits: int = get_llvm_type_bits(val.Ty)
val_i1: llvmlite.Value | t.CPtr = val
if val_bits != 1:
zero: llvmlite.Value | t.CPtr = llvmlite.const_int32(pool, 0)
val_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, val, zero)
if is_ptr_type(val.Ty) != 0:
# 指针类型：与 null 比较（避免 i8* 与 i32 类型不匹配）
null_val: llvmlite.Value | t.CPtr = llvmlite.ConstNull(pool, val.Ty, "null")
val_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, val, null_val)
else:
zero: llvmlite.Value | t.CPtr = llvmlite.const_int32(pool, 0)
val_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, val, zero)
# 创建 next BB（求值下一个值）
cnt = builder.Counter
@@ -1051,8 +1016,13 @@ def translate_boolop(builder: llvmlite.IRBuilder | t.CPtr,
last_bits: int = get_llvm_type_bits(last_val.Ty)
last_i1: llvmlite.Value | t.CPtr = last_val
if last_bits != 1:
zero = llvmlite.const_int32(pool, 0)
last_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, last_val, zero)
if is_ptr_type(last_val.Ty) != 0:
# 指针类型：与 null 比较（避免 i8* 与 i32 类型不匹配）
null_val2: llvmlite.Value | t.CPtr = llvmlite.ConstNull(pool, last_val.Ty, "null")
last_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, last_val, null_val2)
else:
zero = llvmlite.const_int32(pool, 0)
last_i1 = llvmlite.build_icmp(builder, llvmlite.ICMP_NE, last_val, zero)
llvmlite.build_br(builder, merge_bb)
@@ -1147,33 +1117,27 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
name: str,
from_imports: str) -> int:
"""跨模块查找 CDefine 常量，返回值或 -1（未找到）"""
# [XMOD-CD] 诊断：记录跨模块 CDefine 查找入口
_xmod_log_buf: str = pool.alloc(512)
if _xmod_log_buf is not None:
viperlib.snprintf(_xmod_log_buf, 512, "[XMOD-CD] enter name=%s from_imports=%s\n", name, from_imports)
_xmod_lf: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf.closed:
_xmod_lf.write_str(_xmod_log_buf)
_xmod_lf.close()
if name is None or from_imports is None:
stdio.printf("[XMCD] FAIL name=%s reason=from_imports_is_none\n", name)
return -1
# 1. 从 from_imports 查找名称对应的模块名
# allow_star_fallback=1: CDefine 常量（如 INVALID_HANDLE_VALUE）通过
# from w32.win32base import * 导入，不会作为精确条目出现在 from_imports 中，
# 而是作为 *:w32.win32base 条目。必须启用 star import 回退才能找到源模块。
mod_name_raw: str = HandlesImports.lookup_from_import(from_imports, name, 1)
# 先尝试精确匹配（allow_star_fallback=0），避免 CDefine 常量被 star import 误导
mod_name_raw: str = HandlesImports.lookup_from_import(from_imports, name, 0)
if mod_name_raw is None:
if _xmod_log_buf is not None:
viperlib.snprintf(_xmod_log_buf, 512, "[XMOD-CD] FAIL step1 mod=None name=%s\n", name)
_xmod_lf2: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf2.closed:
_xmod_lf2.write_str(_xmod_log_buf)
_xmod_lf2.close()
return -1
# 精确匹配失败：尝试 star import 回退
# CDefine 常量（如 INVALID_HANDLE_VALUE）通过 from w32.win32base import * 导入，
# 不会作为精确条目出现在 from_imports 中，而是作为 *:w32.win32base 条目。
mod_name_raw = HandlesImports.lookup_from_import(from_imports, name, 1)
if mod_name_raw is None:
stdio.printf("[XMCD] FAIL name=%s reason=lookup_from_import_returned_none\n", name)
return -1
stdio.printf("[XMCD] star_fallback name=%s mod=%s\n", name, mod_name_raw)
# 打印 from_imports 用于诊断精确匹配失败原因
fi_len: t.CSizeT = string.strlen(from_imports)
stdio.printf("[XMCD] from_imports (len=%d): %s\n", fi_len, from_imports)
else:
stdio.printf("[XMCD] exact_match name=%s mod=%s\n", name, mod_name_raw)
# 2. 复制模块名到新缓冲区（lookup_from_import 返回的是内部指针）
# 截断于空格、null、或 ':'（别名格式的分隔符）
@@ -1197,29 +1161,9 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
if sha1 is None:
sha1 = HandlesExprCall._lookup_module_sha1_suffix(base_mod)
if sha1 is None:
if _xmod_log_buf is not None:
viperlib.snprintf(_xmod_log_buf, 512, "[XMOD-CD] FAIL step4 sha1=None base_mod=%s\n", base_mod)
_xmod_lf3: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf3.closed:
_xmod_lf3.write_str(_xmod_log_buf)
_xmod_lf3.close()
stdio.printf("[XMCD] FAIL name=%s base_mod=%s reason=sha1_not_found\n", name, base_mod)
return -1
# [XMOD-CD] 诊断：记录 SHA1 查找成功
if _xmod_log_buf is not None:
viperlib.snprintf(_xmod_log_buf, 512, "[XMOD-CD] ok step4 base_mod=%s sha1=%s\n", base_mod, sha1)
_xmod_lf4: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf4.closed:
_xmod_lf4.write_str(_xmod_log_buf)
_xmod_lf4.close()
# 4.5 优先查全局跨模块 CDefine 表（编译期注册，无需文件 I/O）
gcdef_val: int = HandlesType.lookup_global_cdefine(sha1, name)
if HandlesType.is_cdefine_found() != 0:
return gcdef_val
# 5. 获取 temp_dir
temp_dir: str = HandlesType.get_temp_dir()
if temp_dir is None:
@@ -1271,44 +1215,14 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
VLogger.error(err_buf, "XMOD-CD")
stdlib.free(pyi_buf)
return -1
# [XMOD-CD] 诊断：记录 src_path
_xmod_dbg_sp2: str = pool.alloc(512)
if _xmod_dbg_sp2 is not None:
viperlib.snprintf(_xmod_dbg_sp2, 512,
"[XMOD-CD] py-fallback src_path=%s sha1=%s\n", src_path, sha1)
_xmod_lf_sp2: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_sp2.closed:
_xmod_lf_sp2.write_str(_xmod_dbg_sp2)
_xmod_lf_sp2.close()
pf = fileio.File(src_path, fileio.MODE.R)
stdlib.free(src_path)
if pf.closed:
# [XMOD-CD] 诊断：文件打开失败
_xmod_dbg_fc: str = pool.alloc(512)
if _xmod_dbg_fc is not None:
viperlib.snprintf(_xmod_dbg_fc, 512,
"[XMOD-CD] FAIL file-closed sha1=%s\n", sha1)
_xmod_lf_fc: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_fc.closed:
_xmod_lf_fc.write_str(_xmod_dbg_fc)
_xmod_lf_fc.close()
stdlib.free(pyi_buf)
return -1
bytes_read = pf.read_all(pyi_buf, PYI_READ_BUF_SIZE)
pf.close()
if bytes_read <= 0:
# [XMOD-CD] 诊断：文件读取失败
_xmod_dbg_br: str = pool.alloc(512)
if _xmod_dbg_br is not None:
viperlib.snprintf(_xmod_dbg_br, 512,
"[XMOD-CD] FAIL bytes_read=%d sha1=%s\n", bytes_read, sha1)
_xmod_lf_br: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_br.closed:
_xmod_lf_br.write_str(_xmod_dbg_br)
_xmod_lf_br.close()
stdlib.free(pyi_buf)
return -1
if bytes_read < PYI_READ_BUF_SIZE:
@@ -1320,25 +1234,6 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
# 格式: NAME: t.CDefine = value
name_len: t.CSizeT = string.strlen(name)
total_len: t.CSizeT = string.strlen(pyi_buf)
# [XMOD-CD] 诊断：记录文件读取结果和 total_len
_xmod_dbg1: str = pool.alloc(512)
if _xmod_dbg1 is not None:
_dbg_first80: str = pool.alloc(81)
if _dbg_first80 is not None:
_dbg_n: int = 0
while _dbg_n < 80 and _dbg_n < total_len:
_dbg_first80[_dbg_n] = pyi_buf[_dbg_n]
_dbg_n += 1
_dbg_first80[_dbg_n] = '\0'
else:
_dbg_first80 = "<alloc-fail>"
viperlib.snprintf(_xmod_dbg1, 512, "[XMOD-CD] file-read name=%s bytes_read=%d total_len=%d first80=%.80s\n",
name, bytes_read, total_len, _dbg_first80)
_xmod_lf_d1: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_d1.closed:
_xmod_lf_d1.write_str(_xmod_dbg1)
_xmod_lf_d1.close()
pos: t.CSizeT = 0
result_val: int = 0
result_found: int = 0
@@ -1393,7 +1288,29 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ':
eq_pos += 1
# 解析整数值（支持十六进制 0x 前缀）
# 检查是否是 t.CUnsignedLong(...) / t.CLong(...) / t.CInt(...) 等类型构造函数
# 格式: t.CUnsignedLong(-11) / t.CUnsignedLong(0xFFFFFFFF)
# 如果是，跳过 "t.CXxx(" 前缀，解析括号内的值，忽略结尾 ')'
is_type_ctor: int = 0
if eq_pos + 2 < line_start + line_len:
if pyi_buf[eq_pos] == 't' and pyi_buf[eq_pos + 1] == '.':
# 找到 '(' 的位置
paren_pos: t.CSizeT = eq_pos + 2
while paren_pos < line_start + line_len and pyi_buf[paren_pos] != '(':
paren_pos += 1
if paren_pos < line_start + line_len and pyi_buf[paren_pos] == '(':
is_type_ctor = 1
eq_pos = paren_pos + 1 # 跳过 '('
# 跳过括号内可能的前导空格
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ':
eq_pos += 1
# 解析整数值（支持十六进制 0x 前缀和负号）
# 负号标记
is_neg: int = 0
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == '-':
is_neg = 1
eq_pos += 1
val_str_start: t.CSizeT = eq_pos
val_str_len: t.CSizeT = 0
is_hex: int = 0
@@ -1447,9 +1364,13 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
break
hex_result = hex_result * 16 + hd
result_val = hex_result
# 十六进制负值（如 0xFFFFFFFF）保持原样，由 32 位截断处理
result_found = 1
else:
result_val = string.atoi(val_buf)
# 应用负号（如 t.CUnsignedLong(-11) → -11）
if is_neg != 0:
result_val = -result_val
result_found = 1
break
@@ -1488,26 +1409,6 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
if rc_sub_len == 0:
continue
# [XMOD-CD] 诊断：记录找到的 from . 行和子模块名
_xmod_dbg_rc: str = pool.alloc(512)
if _xmod_dbg_rc is not None:
_rc_sub_buf_dbg: str = pool.alloc(rc_sub_len + 1)
if _rc_sub_buf_dbg is not None:
_rc_si2: t.CSizeT
for _rc_si2 in range(rc_sub_len):
_rc_sub_buf_dbg[_rc_si2] = pyi_buf[rc_sub_start + _rc_si2]
_rc_sub_buf_dbg[rc_sub_len] = '\0'
else:
_rc_sub_buf_dbg = "<alloc-fail>"
viperlib.snprintf(_xmod_dbg_rc, 512,
"[XMOD-CD] rc-from-line name=%s sub=%s rc_line_start=%d rc_line_len=%d\n",
name, _rc_sub_buf_dbg, rc_line_start, rc_line_len)
_xmod_lf_rc: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_rc.closed:
_xmod_lf_rc.write_str(_xmod_dbg_rc)
_xmod_lf_rc.close()
# 检查行是否包含 "import"
rc_has_import: int = 0
rc_ipos: t.CSizeT = rc_sub_end
@@ -1594,18 +1495,6 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
rc_name_match = 1
rc_cpos += 1
# [XMOD-CD] 诊断：记录 NAME 匹配结果
_xmod_dbg_match: str = pool.alloc(512)
if _xmod_dbg_match is not None:
viperlib.snprintf(_xmod_dbg_match, 512,
"[XMOD-CD] rc-match name=%s star=%d name_match=%d has_paren=%d rc_scan_end=%d rc_imp_start=%d\n",
name, rc_star, rc_name_match, rc_has_paren, rc_scan_end, rc_imp_start)
_xmod_lf_m: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_m.closed:
_xmod_lf_m.write_str(_xmod_dbg_match)
_xmod_lf_m.close()
if rc_star == 0 and rc_name_match == 0:
continue
@@ -1632,18 +1521,6 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
continue
viperlib.snprintf(rc_fi, rc_fi_len, "%s:%s", name, rc_full_mod)
# [XMOD-CD] 诊断：记录递归调用前的状态
_xmod_dbg_recurse: str = pool.alloc(512)
if _xmod_dbg_recurse is not None:
viperlib.snprintf(_xmod_dbg_recurse, 512,
"[XMOD-CD] rc-recurse name=%s full_mod=%s fi=%s star=%d name_match=%d has_paren=%d scan_end=%d\n",
name, rc_full_mod, rc_fi, rc_star, rc_name_match, rc_has_paren, rc_scan_end)
_xmod_lf_rec: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf_rec.closed:
_xmod_lf_rec.write_str(_xmod_dbg_recurse)
_xmod_lf_rec.close()
# 递归调用查找子模块
rc_sub_val: int = _lookup_cross_module_cdefine(pool, name, rc_fi)
if HandlesType.is_cdefine_found() != 0:
@@ -1659,21 +1536,37 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
else:
HandlesType.set_cdefine_found(0)
# [XMOD-CD] 诊断：记录查找结果
if _xmod_log_buf is not None:
if result_found != 0:
viperlib.snprintf(_xmod_log_buf, 512, "[XMOD-CD] FOUND name=%s val=%d base_mod=%s\n", name, result_val, base_mod)
else:
viperlib.snprintf(_xmod_log_buf, 512, "[XMOD-CD] NOTFOUND name=%s base_mod=%s sha1=%s\n", name, base_mod, sha1)
_xmod_lf5: fileio.File | t.CPtr = fileio.File(
"d:/Users/TermiNexus/Desktop/TransPyC/_xmod_cdefine.log", fileio.MODE.A)
if not _xmod_lf5.closed:
_xmod_lf5.write_str(_xmod_log_buf)
_xmod_lf5.close()
return result_val
# ============================================================
# _is_cdefine_name_pattern - 检查名字是否符合 CDefine 命名约定
#
# CDefine 常量（如 FOREGROUND_GREEN, STD_OUTPUT_HANDLE, SCOPE_MODULE）
# 都遵循 ALL_CAPS 约定：仅含大写字母 A-Z、数字 0-9、下划线 _，
# 且至少含一个大写字母。
#
# Python 关键字（match, if, for）和变量名（self, pool, builder）
# 都含小写字母，不会匹配，从而避免 fail-fast 误报。
#
# 返回: 1=符合 CDefine 命名约定, 0=不符合
# ============================================================
def _is_cdefine_name_pattern(name: str) -> int:
"""检查名字是否符合 CDefine 命名约定（全大写+下划线+数字）"""
if name is None:
return 0
has_upper: int = 0
i: t.CSizeT = 0
while name[i] != '\0':
c: t.CChar = name[i]
if c >= 'a' and c <= 'z':
return 0
if c >= 'A' and c <= 'Z':
has_upper = 1
i += 1
return has_upper
# ============================================================
# 翻译变量引用（Name 节点）→ load
# ============================================================
@@ -1690,27 +1583,21 @@ def translate_name_value(builder: llvmlite.IRBuilder | t.CPtr,
return None
# CDefine 编译期常量: 直接返回整数常量值（不生成运行时代码）
# NAME: t.CDefine = value 形式定义的常量在编译期已注册到全局表
# NAME: t.CDefine = value 形式定义的常量在编译期已注册到本地表
cdef_val: int = HandlesType.lookup_cdefine_constant(nm_id)
if HandlesType.is_cdefine_found() != 0:
return llvmlite.const_int32(pool, cdef_val)
# 本地 CDefine 表未找到：尝试跨模块查找
# 对于 from w32.win32base import * 导入的 INVALID_HANDLE_VALUE 等常量，
# CDefine 表在模块切换时被清空，需要从 from_imports 查找来源模块并读取 .pyi
if trans is not None:
if trans._from_imports is not None:
# 本地表未找到：尝试跨模块 .pyi 查找（保证多模块查表存表一致）
# 仅对符合 CDefine 命名约定（ALL_CAPS）的名字触发跨模块查找，
# 避免对普通变量名（mb/name/ptr/pool/self 等）误触发，造成严重性能损耗
if _is_cdefine_name_pattern(nm_id) != 0:
if trans is not None and trans._from_imports is not None:
cdef_val = _lookup_cross_module_cdefine(pool, nm_id, trans._from_imports)
if HandlesType.is_cdefine_found() != 0:
return llvmlite.const_int32(pool, cdef_val)
# 模块别名检查：如果 nm_id 是已导入模块名（如 win32file, fileio），
# 不应被当作普通变量或全局变量，返回 None 让上层处理
if trans is not None and trans._imported_modules is not None:
if HandlesImports.is_module_imported(trans._imported_modules, nm_id) != 0:
return None
# global 变量：从模块作用域查找
# global 变量：从模块作用域查找（global 声明优先级最高）
if trans is not None:
if HT.is_global_name(trans, nm_id) != 0:
mod_alloca: llvmlite.Value | t.CPtr = HandlesVar.lookup_module_var(
@@ -1727,23 +1614,40 @@ def translate_name_value(builder: llvmlite.IRBuilder | t.CPtr,
if HT.is_nonlocal_name(trans, nm_id) != 0:
return HandlesNonlocal.load_nonlocal_var(trans, nm_id)
# 局部变量查找（必须先于模块别名检查）
# 否则与模块同名的局部变量（如 `import t, c` 后的局部变量 c）会被误判为模块别名，
# 导致 SymTab 已注册的局部变量查找不到（rhs_val is None bug 根因）
alloca: llvmlite.Value | t.CPtr = HandlesVar.lookup_var(trans.SymTab, nm_id)
if alloca is None:
# 跨模块 CDefine 查找（仅当 Name 不是任何变量时才尝试）:
# 从 from_imports 解析源模块，再从该模块的 pyi 文件中解析 CDefine 常量值
# （如 FLAG_IS_ASYNC 从 base.py 导入）
if trans is not None and trans._from_imports is not None:
cross_val: int = _lookup_cross_module_cdefine(pool, nm_id, trans._from_imports)
if cross_val >= 0:
return llvmlite.const_int32(pool, cross_val)
return None
if alloca is not None:
load_ty: llvmlite.LLVMType | t.CPtr = None
if alloca.Ty is not None:
load_ty = alloca.Ty.Pointee
if load_ty is None:
load_ty = llvmlite.Int32(pool)
return llvmlite.build_load(builder, load_ty, alloca)
load_ty: llvmlite.LLVMType | t.CPtr = None
if alloca.Ty is not None:
load_ty = alloca.Ty.Pointee
if load_ty is None:
load_ty = llvmlite.Int32(pool)
return llvmlite.build_load(builder, load_ty, alloca)
# 模块别名检查：SymTab 查找失败后才检查
# 如果 nm_id 是已导入模块名（如 win32file, fileio）且未被声明为局部变量，
# 返回 None 让上层处理（用于属性访问 win32file.CreateFileA）
if trans is not None and trans._imported_modules is not None:
if HandlesImports.is_module_imported(trans._imported_modules, nm_id) != 0:
return None
# 所有查找路径均失败
# fail-fast: 仅对符合 CDefine 命名约定（ALL_CAPS）的名字报错
# 避免对 match/self/pool 等关键字和变量名误报
# 跨模块 CDefine 查找已在上方完成，此处不重复
if _is_cdefine_name_pattern(nm_id) != 0:
err_buf2: str = pool.alloc(256)
if err_buf2 is not None:
cur_sha1: str = "(unknown)"
if trans is not None and trans.ModuleSha1 is not None:
cur_sha1 = trans.ModuleSha1
viperlib.snprintf(err_buf2, 256,
"[CD] FATAL: Name '%s' NOT found (CDefine local+cross + global + nonlocal + alloca + module alias) in module sha1=%s\n",
nm_id, cur_sha1)
VLogger.error(err_buf2, "CD")
return None
# ============================================================
@@ -1989,22 +1893,11 @@ def translate_subscript(builder: llvmlite.IRBuilder | t.CPtr,
nm: ast.Name | t.CPtr = (ast.Name | t.CPtr)(sub.value)
if nm.id is not None and trans is not None:
alloca: llvmlite.Value | t.CPtr = HandlesVar.lookup_var(trans.SymTab, nm.id)
if alloca is None:
stdio.printf("[TS] alloca=None var=%s\n", nm.id)
stdio.fflush(0)
elif alloca.Ty is None:
stdio.printf("[TS] alloca.Ty=None var=%s\n", nm.id)
stdio.fflush(0)
if alloca is not None and alloca.Ty is not None:
if is_ptr_type(alloca.Ty) != 0:
pointee: llvmlite.LLVMType | t.CPtr = alloca.Ty.Pointee
if pointee is None:
stdio.printf("[TS] pointee=None var=%s\n", nm.id)
stdio.fflush(0)
if pointee is not None:
# 不调用 pointee.kind() 避免跨模块引用 LLVMType.kind 符号
stdio.printf("[TS] var=%s pointee_not_null\n", nm.id)
stdio.fflush(0)
# 单层 match（避免嵌套 match 的编译器 bug）
match pointee:
case llvmlite.LLVMType.Array(elem_ty, count):
@@ -2015,8 +1908,6 @@ def translate_subscript(builder: llvmlite.IRBuilder | t.CPtr,
return llvmlite.build_load(builder, elem_ty, elem_ptr)
return None
case llvmlite.LLVMType.Ptr(inner_ty):
stdio.printf("[TS] matched Ptr var=%s\n", nm.id)
stdio.fflush(0)
# 检查 inner_ty 是否是 list[T] 类型（泛型类不注册 struct）
# list 的 subscript 应该走 __getitem__ 内联路径，而非指针遍历
list_struct_name: str = None
@@ -2064,32 +1955,16 @@ def translate_subscript(builder: llvmlite.IRBuilder | t.CPtr,
# 自定义结构体 (如 HashTable|t.CPtr, JsonValue|t.CPtr):
# 优先转发到 __getitem__，避免 IsPtrElement 误判为指针遍历
cls_nm_rd_ptr: str = _get_custom_struct_cls_nm(pool, inner_ty)
if cls_nm_rd_ptr is None:
stdio.printf("[TS] cls_nm=None var=%s\n", nm.id)
stdio.fflush(0)
if not (cls_nm_rd_ptr is None):
stdio.printf("[TS] cls_nm=%s var=%s\n", cls_nm_rd_ptr, nm.id)
stdio.fflush(0)
stdio.printf("[TS] pre_getitem cls=%s\n", cls_nm_rd_ptr)
stdio.fflush(0)
obj_ptr_rd: llvmlite.Value | t.CPtr = llvmlite.build_load(
builder, pointee, alloca)
if obj_ptr_rd is None:
stdio.printf("[TS] __getitem__ build_load=None\n")
stdio.fflush(0)
if not (obj_ptr_rd is None):
arg_vals_rd_p: t.CSizeT | t.CPtr = pool.alloc(8)
if arg_vals_rd_p is None:
stdio.printf("[TS] __getitem__ alloc=None\n")
stdio.fflush(0)
if not (arg_vals_rd_p is None):
arg_vals_rd_p[0] = t.CSizeT(idx_val)
ret_rd_p: llvmlite.Value | t.CPtr = HandlesExprCall._call_method_on_ptr(
pool, builder, mod, cls_nm_rd_ptr, "__getitem__",
obj_ptr_rd, arg_vals_rd_p, 1, trans)
if ret_rd_p is None:
stdio.printf("[TS] __getitem__ call=None cls=%s\n", cls_nm_rd_ptr)
stdio.fflush(0)
if not (ret_rd_p is None):
return ret_rd_p
return None
@@ -2493,11 +2368,6 @@ def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr,
obj_ptr = translate_value(builder, pool, mod, at.value, None, 0, trans)
if obj_ptr is None or obj_ptr.Ty is None:
if at.value.kind() == ast.ASTKind.Name:
nm_d: ast.Name | t.CPtr = (ast.Name | t.CPtr)(at.value)
if nm_d.id is not None:
stdio.printf("[TA-DIAG] obj_ptr=None attr=%s name=%s\n",
at.attr, nm_d.id)
return None
# 如果 obj_ptr 是 Ptr(Ptr(Struct))（X|t.CPtr 变量的 alloca），
@@ -2540,29 +2410,15 @@ def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr,
var_entry: HandlesVar.VarEntry | t.CPtr = HandlesVar.lookup_var_entry(
trans.SymTab, nm_fb.id)
if var_entry is not None and var_entry.AnnotClassName is not None:
stdio.printf("[TA-DIAG] fallback annot=%s attr=%s\n",
var_entry.AnnotClassName, at.attr)
cur_sha1: str = trans.ModuleSha1
field_info = HandlesStruct.lookup_field_by_class(
var_entry.AnnotClassName, at.attr, cur_sha1)
if field_info is None:
stdio.printf("[TA-DIAG] lfbc_failed annot=%s attr=%s\n",
var_entry.AnnotClassName, at.attr)
stdio.fflush(0)
else:
stdio.printf("[TA-DIAG] lfbc_ok annot=%s attr=%s idx=%d\n",
var_entry.AnnotClassName, at.attr, field_info.Index)
stdio.fflush(0)
# 回退 1 成功：bitcast obj_ptr 到 AnnotClassName 对应的结构体类型
# 原始 struct_ty 可能是 i8（X|t.CPtr 简化为 Ptr(i8)），
# 需用实际结构体类型做 GEP，否则 GEP i8 失败
if field_info is not None:
annot_se: HandlesStruct.StructEntry | t.CPtr = \
HandlesStruct.find_struct(var_entry.AnnotClassName)
if annot_se is None:
stdio.printf("[TA-DIAG] fb1 find_struct None annot=%s\n",
var_entry.AnnotClassName)
stdio.fflush(0)
if annot_se is not None and annot_se.Ty is not None:
annot_ptr_ty: llvmlite.LLVMType | t.CPtr = \
llvmlite.Ptr(pool, annot_se.Ty)
@@ -2576,11 +2432,6 @@ def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr,
# （原始 struct_ty 可能是 i8，ensure 无效）
HandlesStruct.ensure_struct_def_in_module(
pool, mod, annot_se.Ty)
stdio.printf("[TA-DIAG] fb1 struct_ty updated\n")
stdio.fflush(0)
else:
stdio.printf("[TA-DIAG] fb1 bitcast None\n")
stdio.fflush(0)
# 回退 2: 子类搜索 — 注解类型是基类但实际值是派生类
# 如 node: AST | t.CPtr = If(...)，访问 node.orelse
if field_info is None:
@@ -2615,29 +2466,14 @@ def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr,
return None
# 普通结构体：GEP + load
field_idx: int = field_info.Index
stdio.printf("[TA-DIAG] gep_try idx=%d struct_is_ptr=%d\n",
field_idx, is_ptr_type(struct_ty))
stdio.fflush(0)
field_ptr: llvmlite.Value | t.CPtr = llvmlite.build_gep_struct(
builder, struct_ty, field_ty, obj_ptr, field_idx)
if field_ptr is None:
stdio.printf("[TA-DIAG] gep_failed idx=%d\n", field_idx)
stdio.fflush(0)
if field_ptr is not None:
stdio.printf("[TA-DIAG] gep_ok idx=%d is_array=%d\n",
field_idx, is_array_type(field_ty))
stdio.fflush(0)
# 数组类型字段不能 load 为 SSA value，直接返回字段指针
# 用于后续下标访问: self.state[0] → GEP state 字段 → GEP 数组元素
if is_array_type(field_ty) != 0:
return field_ptr
stdio.printf("[TA-DIAG] pre_load idx=%d field_ty_not_null=%d\n",
field_idx, 1 if field_ty is not None else 0)
stdio.fflush(0)
loaded_val: llvmlite.Value | t.CPtr = llvmlite.build_load(builder, field_ty, field_ptr)
stdio.printf("[TA-DIAG] post_load idx=%d loaded=%d\n",
field_idx, 1 if loaded_val is not None else 0)
stdio.fflush(0)
# 联合类型字段（如 Token | t.CPtr）被编译为 i8*，
# 若 AnnotClassName 指示了具体结构体类型，bitcast 为正确的结构体指针
if loaded_val is not None and field_info.AnnotClassName is not None:
@@ -2647,17 +2483,8 @@ def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr,
annot_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, annot_struct.Ty)
return llvmlite.build_bitcast(builder, loaded_val, annot_ptr_ty)
return loaded_val
# 诊断：所有字段查找路径失败
sn_diag: str = HandlesStruct._extract_struct_name(struct_ty)
if sn_diag is not None:
stdio.printf("[TA-DIAG] field=None attr=%s sname=%s\n",
at.attr, sn_diag)
else:
stdio.printf("[TA-DIAG] field=None attr=%s sname=(null)\n",
at.attr)
return None
case _:
stdio.printf("[TA-DIAG] type_mismatch attr=%s\n", at.attr)
return None
# ============================================================
@@ -2686,34 +2513,17 @@ def get_subscript_ptr(builder: llvmlite.IRBuilder | t.CPtr,
nm: ast.Name | t.CPtr = (ast.Name | t.CPtr)(sub.value)
if nm.id is not None and trans is not None:
alloca: llvmlite.Value | t.CPtr = HandlesVar.lookup_var(trans.SymTab, nm.id)
if alloca is None:
stdio.printf("[GSP] alloca=None var=%s\n", nm.id)
stdio.fflush(0)
elif alloca.Ty is None:
stdio.printf("[GSP] alloca.Ty=None var=%s\n", nm.id)
stdio.fflush(0)
if alloca is not None and alloca.Ty is not None:
if is_ptr_type(alloca.Ty) != 0:
pointee: llvmlite.LLVMType | t.CPtr = alloca.Ty.Pointee
if pointee is None:
stdio.printf("[GSP] pointee=None var=%s\n", nm.id)
stdio.fflush(0)
if pointee is not None:
pe_arr: int = is_array_type(pointee)
pe_ptr: int = is_ptr_type(pointee)
stdio.printf("[GSP] var=%s pe_arr=%d pe_ptr=%d\n", nm.id, pe_arr, pe_ptr)
stdio.fflush(0)
# 单层 match（避免嵌套 match 的编译器 bug）
match pointee:
case llvmlite.LLVMType.Array(elem_ty, count):
stdio.printf("[GSP] matched Array\n")
stdio.fflush(0)
# 数组遍历
return llvmlite.build_gep_array(
builder, pointee, elem_ty, alloca, idx_val)
case llvmlite.LLVMType.Ptr(inner_ty):
stdio.printf("[GSP] matched Ptr\n")
stdio.fflush(0)
# inner_ty 是 Ptr 说明 alloca.Ty 是三重指针,
# 即 X|t.CPtr 当 X 本身是指针类型 (如 T=AST|t.CPtr, T|t.CPtr=AST**)。
# 此时 [i]=val 应该是指针解引用赋值, 而非调用 __setitem__。
@@ -2731,9 +2541,6 @@ def get_subscript_ptr(builder: llvmlite.IRBuilder | t.CPtr,
if cls_nm_ptr_chk is None:
pass
if not (cls_nm_ptr_chk is None):
stdio.printf("[GSP] custom struct %s, defer to __setitem__\n",
cls_nm_ptr_chk)
stdio.fflush(0)
return None
# bytes|t.CPtr / str|t.CPtr: alloca 是 i8**，
# 直接 GEP 按 i8* 步长（8 字节），不 load
@@ -2742,39 +2549,26 @@ def get_subscript_ptr(builder: llvmlite.IRBuilder | t.CPtr,
ve_pe: HandlesVar.VarEntry | t.CPtr = \
HandlesVar.lookup_var_entry(trans.SymTab, nm.id)
if ve_pe is not None and ve_pe.IsPtrElement == 1:
stdio.printf("[GSP] IsPtrElement=1, gep direct\n")
stdio.fflush(0)
return llvmlite.build_gep(
builder, pointee, alloca, idx_val)
# 普通指针遍历: 先 load 指针值，再 GEP
ptr_val: llvmlite.Value | t.CPtr = llvmlite.build_load(
builder, pointee, alloca)
if ptr_val is None:
stdio.printf("[GSP] build_load=None\n")
stdio.fflush(0)
return None
gep_r: llvmlite.Value | t.CPtr = llvmlite.build_gep(
builder, inner_ty, ptr_val, idx_val)
if gep_r is None:
stdio.printf("[GSP] build_gep=None\n")
stdio.fflush(0)
return gep_r
case _:
# pointee 是普通标量类型 (如 i64, i32, i8):
# alloca 是 Ptr(标量), 直接 GEP 获取第 idx 个元素指针
# 支持 arg_vals[i] = val 这类参数数组下标赋值
stdio.printf("[GSP] matched scalar, gep direct\n")
stdio.fflush(0)
return llvmlite.build_gep(builder, pointee, alloca, idx_val)
# 通用路径
stdio.printf("[GSP] fallback to generic path\n")
stdio.fflush(0)
ptr_val: llvmlite.Value | t.CPtr = translate_value(
builder, pool, mod, sub.value, None, 0, trans)
if ptr_val is None or ptr_val.Ty is None:
stdio.printf("[GSP] generic: ptr_val=None\n")
stdio.fflush(0)
return None
if is_ptr_type(ptr_val.Ty) != 0:
elem_ty2: llvmlite.LLVMType | t.CPtr = ptr_val.Ty.Pointee
@@ -2792,9 +2586,6 @@ def get_subscript_ptr(builder: llvmlite.IRBuilder | t.CPtr,
if cls_nm_gen is None:
pass
if not (cls_nm_gen is None):
stdio.printf("[GSP] generic custom struct %s, defer to __setitem__\n",
cls_nm_gen)
stdio.fflush(0)
return None
# 指针类型: 单索引 GEP (getelementptr ty, ptr, idx)
return llvmlite.build_gep(builder, elem_ty2, ptr_val, idx_val)

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

@@ -362,29 +362,49 @@ def _ensure_c_lib_declare(pool: memhub.MemBuddy | t.CPtr,
# ============================================================
def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr,
func_name: str) -> llvmlite.LLVMType | t.CPtr:
"""根据函数名推断外部 includes 函数的返回类型"""
"""根据函数名推断外部 includes 函数的返回类型
支持三种函数名形式:
1. 裸名: "parse", "strlen"
2. 别名: "json_parse"（from X import parse as json_parse）
3. 带 SHA1 前缀: "240a9a4157959a9f.parse"（跨模块调用 mangled name）
"""
if pool is None or func_name is None:
return llvmlite.Int32(pool)
# 提取裸函数名：去掉 SHA1 前缀（如 "240a9a4157959a9f.parse" → "parse"）
# SHA1 前缀是 16 位十六进制 + '.'，检查是否有 '.' 分隔
bare_name: str = func_name
dot_pos: str = string.strrchr(func_name, 46) # 46 = ord('.')
if dot_pos is not None:
# '.' 后的部分是裸函数名
bare_name = dot_pos + 1
i8_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, llvmlite.Int8(pool))
# 返回 i8* 的函数（指针返回值，截断会导致错误）
if func_name == "strchr":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "strrchr":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "strstr":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "strcpy":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "strncpy":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "memset":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "memset32":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "memcpy":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "memmove":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if bare_name == "strchr" or func_name == "strchr":
return i8_ptr_ty
if bare_name == "strrchr" or func_name == "strrchr":
return i8_ptr_ty
if bare_name == "strstr" or func_name == "strstr":
return i8_ptr_ty
if bare_name == "strcpy" or func_name == "strcpy":
return i8_ptr_ty
if bare_name == "strncpy" or func_name == "strncpy":
return i8_ptr_ty
if bare_name == "memset" or func_name == "memset":
return i8_ptr_ty
if bare_name == "memset32" or func_name == "memset32":
return i8_ptr_ty
if bare_name == "memcpy" or func_name == "memcpy":
return i8_ptr_ty
if bare_name == "memmove" or func_name == "memmove":
return i8_ptr_ty
# JSON 解析函数返回 JsonValue*（指针）
# from json.__parser import parse as json_parse → 别名 json_parse 也需覆盖
if bare_name == "parse" or func_name == "parse" or func_name == "json_parse":
return i8_ptr_ty
# MemBuddy 方法（当类型信息丢失时可能走外部函数路径）
if func_name == "alloc":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
@@ -394,6 +414,14 @@ def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr,
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "alloc_buf":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
# VLogger 模块函数（跨模块调用时 stub 未注入，返回指针被截断为 i32 导致崩溃）
if func_name == "get_logger":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
if func_name == "fmt_buf":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
# Config 模块函数（跨模块调用时 stub 未注入，返回 i8* 被 inttoptr i32 截断导致路径损坏）
if func_name == "get_includes_binary_dir":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
# 返回 i64 的函数
if func_name == "strlen":
@@ -442,6 +470,17 @@ def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr,
return i8_ptr_ty
if func_name == "LoadLibraryW":
return i8_ptr_ty
# Win32 Handle 返回函数（HANDLE = void* = i8*）
if func_name == "GetStdHandle":
return i8_ptr_ty
if func_name == "CreateFileA":
return i8_ptr_ty
if func_name == "CreateFileW":
return i8_ptr_ty
if func_name == "FindFirstFileA":
return i8_ptr_ty
if func_name == "FindFirstFileW":
return i8_ptr_ty
# Win32 API 返回 i64 (SIZE_T) 的函数
if func_name == "VirtualQuery":
@@ -486,7 +525,11 @@ def _infer_external_func_ret_ty(pool: memhub.MemBuddy | t.CPtr,
func_name == "function_get_param_head" or func_name == "param_get_next":
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
# 默认 i32
# 默认 i32（整数）：与本模块函数定义的默认返回类型一致（HandlesFunctions.py line 324）
# 已知返回指针的函数在上方显式列出（返回 i8*），已知返回 i64 的函数也显式列出
# 避免使用 i64 导致 stub 声明（declare i64）与实际定义（define i32）类型不匹配
# x86-64 ABI 中 i32 返回值在 rax 低 32 位，与 define i32 完全一致
# 与 _infer_method_ret_ty 的默认策略保持一致
return llvmlite.Int32(pool)
# ============================================================
@@ -2154,6 +2197,29 @@ def _translate_struct_ctor(pool: memhub.MemBuddy | t.CPtr,
if ctor_entry is not None:
is_oop = ctor_entry.IsOOP
# 跨模块 OOP 类推断：IsOOP 可能未设置（Phase1 缓存跳过 _translate_oop_methods）
# 方案1: 检查当前模块是否有 ClassName.__init__ 的声明（stub 注入）
# 方案2: 检查全局默认参数表是否有 ClassName.__init__ 的条目（翻译时填充，更可靠）
if is_oop == 0 and class_name is not None:
init_lookup_name: t.CChar | t.CPtr = pool.alloc(128)
if init_lookup_name is not None:
viperlib.snprintf(init_lookup_name, 128, "%s.__init__", class_name)
# 方案1: 检查当前模块的函数声明
init_found_func: llvmlite.Function | t.CPtr = find_func_in_module(mod, init_lookup_name)
if init_found_func is not None:
is_oop = 1
if ctor_entry is not None:
ctor_entry.IsOOP = 1
ctor_entry.HasInit = 1
else:
# 方案2: 检查全局默认参数表（翻译时填充，不依赖 stub 注入）
init_defaults_entry: FuncDefaultsEntry | t.CPtr = find_func_defaults(init_lookup_name)
if init_defaults_entry is not None:
is_oop = 1
if ctor_entry is not None:
ctor_entry.IsOOP = 1
ctor_entry.HasInit = 1
if is_oop != 0:
# 存储指针：默认用 alloca，如果有 __new__ 则用 __new__ 返回的指针
storage_ptr: llvmlite.Value | t.CPtr = tmp
@@ -2773,7 +2839,13 @@ def _ensure_method_declare(pool: memhub.MemBuddy | t.CPtr,
ret_ty: llvmlite.LLVMType | t.CPtr,
param_head: llvmlite.ParamNode | t.CPtr,
param_count: int):
"""为跨模块方法调用创建 declare 声明"""
"""为跨模块方法调用创建 declare 声明
若模块中已存在同名 declare 且参数数量较少（例如 File.__init__ 的
stub 仅 3 个参数，而实际调用传入 4 个），则向现有 declare 追加缺失
参数，避免 llc 报 `argument invalid for parameter type` 之类的错误。
已存在的 define 不修改（其参数由定义决定）。
"""
if pool is None or mod is None or call_name is None:
return
# 检查模块中是否已有同名函数（declare 或 define）
@@ -2781,7 +2853,32 @@ def _ensure_method_declare(pool: memhub.MemBuddy | t.CPtr,
while existing is not None:
if existing.Name is not None:
if string.strcmp(existing.Name, call_name) == 0:
return # 已存在，无需重复声明
# 已存在：仅当是 declare 且参数数量不足时追加缺失参数
if existing.IsDeclared == 1:
# 遍历现有参数链表计数（避免依赖 GSList.Count 字段的类型推断）
cur_count: int = 0
cur_p: llvmlite.Param | t.CPtr = llvmlite.function_get_param_head(existing)
while cur_p is not None:
cur_count += 1
cur_p = cur_p.Next
# 只追加缺失的参数（cur_count < param_count 时）
if cur_count < param_count:
# 定位到 param_head 的第 cur_count 个节点开始追加
pnode2: llvmlite.ParamNode | t.CPtr = param_head
pi2: int = 0
# 跳过已有的 cur_count 个参数
while pnode2 is not None and pi2 < cur_count:
pnode2 = pnode2.Next
pi2 += 1
# 追加剩余参数
while pnode2 is not None and pi2 < param_count:
if pnode2.Ty is not None:
param2: llvmlite.Param | t.CPtr = llvmlite.new_param(pool, pnode2.Ty, None)
if param2 is not None:
llvmlite.function_add_param(existing, param2)
pnode2 = pnode2.Next
pi2 += 1
return
existing = existing.Next
# 创建函数声明
func: llvmlite.Function | t.CPtr = llvmlite.new_function(pool, call_name, ret_ty)
@@ -2832,18 +2929,35 @@ def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr,
return i8_ptr_ty
if string.strcmp(method_name, "__enter__") == 0:
return i8_ptr_ty
# 工厂方法：返回对象指针（截断会导致后续方法调用崩溃）
if string.strcmp(method_name, "parse_args") == 0:
return i8_ptr_ty
# 魔术方法：返回对象指针（如 JsonValue.__getitem__ 返回 JsonValue*）
if string.strcmp(method_name, "__getitem__") == 0:
return i8_ptr_ty
# 返回 i8* 的方法（返回字符串/类型名/描述）
if string.strcmp(method_name, "type_name") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "get_name") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "get_str") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "get_path") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "get_buf") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "to_string") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "as_string") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "__repr__") == 0:
return i8_ptr_ty
if string.strcmp(method_name, "__str__") == 0:
return i8_ptr_ty
# 返回 i8* 的方法（返回对象指针，如 JsonValue.get_item → JsonValue*）
if string.strcmp(method_name, "get_item") == 0:
return i8_ptr_ty
# 返回 void 的方法
if string.strcmp(method_name, "__before_init__") == 0:
@@ -2853,10 +2967,12 @@ def _infer_method_ret_ty(pool: memhub.MemBuddy | t.CPtr,
if string.strcmp(method_name, "__exit__") == 0:
return llvmlite.Void(pool)
# 默认 i64（整数）：既可安全截断为 i32（trunc），也可转换为指针（inttoptr）
# 避免使用指针类型（i8*）导致 coerce_to_type 生成 load（解引用）造成崩溃
# x86-64 ABI 中 i32 返回值在 rax 低 32 位，i64 读取后 trunc 取低 32 位是安全的
return llvmlite.Int64(pool)
# 默认 i32（整数）：与本模块函数定义的默认返回类型一致（HandlesFunctions.py line 324）
# 已知返回指针的方法在上方显式列出（返回 i8*），已知返回 void 的方法也显式列出
# 避免使用 i64 导致 stub 声明（declare i64）与实际定义（define i32）类型不匹配
# x86-64 ABI 中 i32 返回值在 rax 低 32 位，与 define i32 完全一致
# 与 _infer_external_func_ret_ty 的默认策略保持一致
return llvmlite.Int32(pool)
# ============================================================
# _translate_method_call - 翻译方法调用 obj.method(args)
@@ -2981,6 +3097,65 @@ def _translate_method_call(pool: memhub.MemBuddy | t.CPtr,
total_count: int = 1 + can
# 默认参数填充：如果调用点参数少于函数定义参数，用默认值填充缺失参数
# 查找函数的 defaults 信息
mdf_defaults: t.CVoid | t.CPtr = None
mdf_default_count: int = 0
mdf_param_count: int = 0
if trans is not None and trans._funcs is not None:
mdf_entry: FuncEntry | t.CPtr = find_func_entry_in_table(
trans._funcs, trans._func_count, lookup_name)
if mdf_entry is not None:
mdf_defaults = mdf_entry.Defaults
mdf_default_count = mdf_entry.DefaultCount
mdf_param_count = mdf_entry.ParamCount
if mdf_defaults is None:
mdf_gd: FuncDefaultsEntry | t.CPtr = find_func_defaults(lookup_name)
if mdf_gd is not None:
mdf_defaults = mdf_gd.Defaults
mdf_default_count = mdf_gd.DefaultCount
mdf_param_count = mdf_gd.ParamCount
# 计算需要填充的参数（不含 self）
# can = 已提供的非 self 参数数量
# mdf_param_count = 函数定义的非 self 参数数量
if mdf_param_count > can:
mdf_offset: int = mdf_param_count - mdf_default_count
mdf_pi: int = can
while mdf_pi < mdf_param_count:
# 优先用默认值
if mdf_defaults is not None and mdf_default_count > 0 and mdf_pi >= mdf_offset:
mdf_di: int = mdf_pi - mdf_offset
if mdf_di < mdf_default_count:
mdf_defaults_list: list[ast.AST | t.CPtr] | t.CPtr = (list[ast.AST | t.CPtr] | t.CPtr)(t.CVoid(t.CUInt64T(mdf_defaults), t.CPtr))
mdf_node: ast.AST | t.CPtr = mdf_defaults_list.get(mdf_di)
if mdf_node is not None:
mdf_val: llvmlite.Value | t.CPtr = HandlesExpr.translate_value(
builder, pool, mod, mdf_node, None, 0, trans)
if mdf_val is not None:
llvmlite.value_set_next(mdf_val, None)
llvmlite.value_set_next(tail, mdf_val)
tail = mdf_val
total_count += 1
mdf_pi += 1
continue
# 无默认值时用零值兜底（需要 found_func 获取参数类型）
if found_func is not None:
param_node_z: llvmlite.Param | t.CPtr = llvmlite.function_get_param_head(found_func)
skip_z: int = 0
while skip_z <= mdf_pi and param_node_z is not None:
param_node_z = llvmlite.param_get_next(param_node_z)
skip_z += 1
if param_node_z is not None:
zero_ty: llvmlite.LLVMType | t.CPtr = llvmlite.param_get_ty(param_node_z)
zero_val: llvmlite.Value | t.CPtr = llvmlite.ConstZero(pool, zero_ty)
if zero_val is not None:
llvmlite.value_set_next(zero_val, None)
llvmlite.value_set_next(tail, zero_val)
tail = zero_val
total_count += 1
mdf_pi += 1
# 虚方法分发：如果类有虚表且该方法在虚表中，走间接调用
# （不依赖 found_func — 继承的虚方法可能没有子类实现）
# 复用前面已获取的 mc_entry（find_struct_by_type 规避跨模块同名找错）
@@ -3061,6 +3236,30 @@ def _translate_struct_ctor_kw(pool: memhub.MemBuddy | t.CPtr,
is_oop: int = 0
if kw_entry is not None:
is_oop = kw_entry.IsOOP
# 跨模块 OOP 类推断：IsOOP 可能未设置（Phase1 缓存跳过 _translate_oop_methods）
# 方案1: 检查当前模块是否有 ClassName.__init__ 的声明（stub 注入）
# 方案2: 检查全局默认参数表是否有 ClassName.__init__ 的条目（翻译时填充，更可靠）
if is_oop == 0 and class_name is not None:
kw_init_lookup: t.CChar | t.CPtr = pool.alloc(128)
if kw_init_lookup is not None:
viperlib.snprintf(kw_init_lookup, 128, "%s.__init__", class_name)
# 方案1: 检查当前模块的函数声明
kw_init_found: llvmlite.Function | t.CPtr = find_func_in_module(mod, kw_init_lookup)
if kw_init_found is not None:
is_oop = 1
if kw_entry is not None:
kw_entry.IsOOP = 1
kw_entry.HasInit = 1
else:
# 方案2: 检查全局默认参数表（翻译时填充，不依赖 stub 注入）
kw_init_defaults: FuncDefaultsEntry | t.CPtr = find_func_defaults(kw_init_lookup)
if kw_init_defaults is not None:
is_oop = 1
if kw_entry is not None:
kw_entry.IsOOP = 1
kw_entry.HasInit = 1
if is_oop != 0:
_call_method_on_ptr(pool, builder, mod, class_name,
"__before_init__", tmp, None, 0, trans)
@@ -3693,13 +3892,27 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
# 检测 obj.__len__() — 返回 list 对象的 __count__ 字段（偏移 8，i64）
# __len__ 是 list[T] 的内置方法，list 是泛型类不注册 struct
# 注意: 必须用 translate_value 而非 translate_name_value，因为 len_at.value
# 可能是 Attribute 节点（如 md_ags.args），translate_name_value 只处理 Name 节点，
# 对 Attribute 会错误返回 i32 0，导致 GEP base 不是指针（base of getelementptr must be a pointer）
if cl.func is not None and cl.func.kind() == ast.ASTKind.Attribute:
len_at: ast.Attribute | t.CPtr = (ast.Attribute | t.CPtr)(cl.func)
if len_at.attr is not None and string.strcmp(len_at.attr, "__len__") == 0:
if len_at.value is not None and can == 0:
obj_val: llvmlite.Value | t.CPtr = HandlesExpr.translate_name_value(
builder, pool, len_at.value, trans)
if obj_val is not None:
obj_val: llvmlite.Value | t.CPtr = HandlesExpr.translate_value(
builder, pool, mod, len_at.value, funcs_ptr, func_count, trans)
if obj_val is not None and obj_val.Ty is not None:
# 防御性类型检查: obj_val 必须是指针类型才能做 GEP
# 如果 translate_value 返回 i32 (如 CDefine 常量被误解析、
# 模块属性前向引用回退为 i32)，GEP base 会是 i32 而非指针，
# 导致 llc 报错 "base of getelementptr must be a pointer"
if HandlesExpr.is_ptr_type(obj_val.Ty) == 0:
# 诊断: 输出节点类型信息帮助定位根本原因
len_node_kind: int = len_at.value.kind()
stdio.printf(
"[LEN-DIAG] __len__ on non-ptr (kind=%d), fallback to 0\n",
len_node_kind)
return llvmlite.const_int64(pool, 0)
i64_ty_len: llvmlite.LLVMType | t.CPtr = llvmlite.Int64(pool)
# 注意: 必须用 const_int64 而非 ConstInt(...,"0")
# ConstInt 的 name 参数 "0" 会被当作 IR 文本值输出 i64 0
@@ -3917,6 +4130,20 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
lm_obj: llvmlite.Value | t.CPtr = HandlesExpr.translate_value(
builder, pool, mod, lm_at.value, funcs_ptr, func_count, trans)
if lm_obj is not None:
# 防御性类型检查: lm_obj 必须是指针类型才能做 GEP
# translate_value 对某些 Attribute 节点（如 ast.Arguments 的属性）
# 可能返回 i32 0 (非指针)，直接 GEP 会导致
# "base of getelementptr must be a pointer" 错误
if lm_obj.Ty is None or HandlesExpr.is_ptr_type(lm_obj.Ty) == 0:
lm_node_kind: int = lm_at.value.kind()
fb_lm: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb_lm is not None:
viperlib.snprintf(fb_lm, 1024,
"list 方法 '%s' 的目标对象非指针 (node kind=%d)，"
"translate_value 类型推断失败",
lm_name, lm_node_kind)
VLogger.critical(fb_lm, "LIST-METHOD")
return None
i64_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int64(pool)
i8_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int8(pool)
i8_ptr_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Ptr(pool, i8_ty)
@@ -4245,6 +4472,9 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
# 旧逻辑（IsDeclared==1 时用 func_name 裸名）是错误的：stub 注入的 declare Name 已带 SHA1 前缀，
# 用裸名会导致 call @_PathToModuleName 而 define 是 @"sha1._PathToModuleName"，链接报 undefined reference
call_name: str = func_name
# 原始函数名（别名导入时记录，如 from X import parse as json_parse → orig_func_name="parse"）
# 用于在别名处理后重新推断返回类型，避免 _infer_external_func_ret_ty 用别名匹配失败
orig_func_name: str = None
if found_func is not None:
found_name: t.CChar | t.CPtr = llvmlite.function_get_name(found_func)
if found_name is not None:
@@ -4357,6 +4587,11 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
bo_buf[bo_i] = bare_orig[bo_i]
bo_buf[bo_len] = '\0'
bare_func_name = bo_buf
# 记录原始函数名，供后续重新推断返回类型
# 例如 from json.__parser import parse as json_parse
# func_name="json_parse", bare_func_name="parse"
# _infer_external_func_ret_ty 用 "parse" 能正确匹配，用 "json_parse" 则返回默认 i32
orig_func_name = bare_func_name
if is_cexport_func(bare_sha1, bare_func_name) != 0:
call_name = bare_func_name
else:
@@ -4382,6 +4617,14 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
# memcpy → @llvm.memcpy 内联函数（避免 monomorphization 跨模块 @memcpy 声明缺失）
if func_name == "memcpy" and can >= 3:
return _emit_llvm_memcpy_intrinsic(pool, builder, mod, mc_dst2, mc_src2, mc_num2)
# 别名导入重新推断返回类型：
# from X import parse as json_parse → func_name="json_parse" 时 _infer_external_func_ret_ty 返回默认 i32
# 用 orig_func_name="parse" 重新推断，能正确匹配返回 i8*（JsonValue*）
# 避免指针被截断为 i32 后 inttoptr 丢失高 32 位导致崩溃
if orig_func_name is not None and orig_func_name != func_name:
re_inferred_ty: llvmlite.LLVMType | t.CPtr = _infer_external_func_ret_ty(pool, orig_func_name)
if re_inferred_ty is not None:
call_ret_ty = re_inferred_ty
# 跨模块调用：创建 declare 声明，避免 llc 报 undefined value
_ensure_method_declare(pool, mod, call_name, call_ret_ty, head, can)
return llvmlite.build_call(builder, call_name, head, can, call_ret_ty, 0)

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

@@ -353,6 +353,8 @@ def forward_declare_functions(trans: HT.Translator | t.CPtr,
continue
# 提取默认参数信息
# 注意: 必须先把属性赋给显式类型为 list[...] | t.CPtr 的局部变量再调用 __len__()，
# 否则编译器无法识别属性返回的 list 类型，GEP base 会变成 i32 0 导致 llc 报错
fd_args_node: ast.Arguments | t.CPtr = fd.args
fd_defaults: t.CVoid | t.CPtr = None
fd_default_count: int = 0
@@ -360,10 +362,12 @@ def forward_declare_functions(trans: HT.Translator | t.CPtr,
if fd_args_node is not None:
fd_ags: ast.Arguments | t.CPtr = (ast.Arguments | t.CPtr)(fd_args_node)
if fd_ags.args is not None:
fd_param_count = fd_ags.args.__len__()
fd_alist: list[ast.AST | t.CPtr] | t.CPtr = fd_ags.args
fd_param_count = fd_alist.__len__()
if fd_ags.defaults is not None:
fd_defaults = fd_ags.defaults
fd_default_count = fd_ags.defaults.__len__()
fd_dlist: list[ast.AST | t.CPtr] | t.CPtr = fd_ags.defaults
fd_defaults = fd_dlist
fd_default_count = fd_dlist.__len__()
# 注册到函数表（用裸名 fd.name，不是 mangled_name）
max_funcs: int = 256
@@ -558,10 +562,12 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
if args_node is not None:
tfd_ags: ast.Arguments | t.CPtr = (ast.Arguments | t.CPtr)(args_node)
if tfd_ags.args is not None:
tfd_param_count = tfd_ags.args.__len__()
tfd_alist: list[ast.AST | t.CPtr] | t.CPtr = tfd_ags.args
tfd_param_count = tfd_alist.__len__()
if tfd_ags.defaults is not None:
tfd_defaults = tfd_ags.defaults
tfd_default_count = tfd_ags.defaults.__len__()
tfd_dlist: list[ast.AST | t.CPtr] | t.CPtr = tfd_ags.defaults
tfd_defaults = tfd_dlist
tfd_default_count = tfd_dlist.__len__()
# 注册到函数表
max_funcs: int = 256
@@ -668,8 +674,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
for bi2 in range(bn2):
stmt2: ast.AST | t.CPtr = body.get(bi2)
if stmt2 is not None:
stdio.printf("[DBG] TR body stmt=%d kind=%d\n", bi2, stmt2.kind())
stdio.fflush(0)
HandlesBody.translate_stmt(trans, stmt2)
# 如果函数体最后一条语句不是 Return，添加隐式 ret

15
App/lib/core/Handles/HandlesImports.py
View File

@@ -559,6 +559,21 @@ class ImportsHandle(HandlesBase.Mixin):
resolved: str = _resolve_relative_module(
self.Trans.Pool, self.Trans.CurrentPackage,
impf.level, impf.module)
# [IFD] 诊断 from-import 名称处理
mod_dbg: str = "(null)"
if impf.module is not None:
mod_dbg = impf.module
pkg_dbg: str = "(null)"
if self.Trans.CurrentPackage is not None:
pkg_dbg = self.Trans.CurrentPackage
res_dbg: str = "(null)"
if resolved is not None:
res_dbg = resolved
names_dbg: t.CSizeT = 0
if impf.names is not None:
names_dbg = impf.names.__len__()
stdio.printf("[IFD] level=%d module=%s pkg=%s resolved=%s names=%d\n",
impf.level, mod_dbg, pkg_dbg, res_dbg, names_dbg)
if resolved is not None:
names: list[ast.AST | t.CPtr] | t.CPtr = impf.names
if names is not None:

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

@@ -88,6 +88,10 @@ def translate_children(trans: HT.Translator | t.CPtr,
if child is None: continue
kd: int = child.kind()
# _declare_only == 0 时，_translate_module_level 已预处理导入语句，
# 此处跳过避免重复处理（from_imports 条目重复）
if trans._declare_only == 0 and (kd == ast.ASTKind.Import or kd == ast.ASTKind.ImportFrom):
continue
if kd == ast.ASTKind.Import:
trans.ImportsH.HandleImport(child)
elif kd == ast.ASTKind.ImportFrom:
@@ -97,10 +101,6 @@ def translate_children(trans: HT.Translator | t.CPtr,
# Phase 1a 声明模式：只注册 CExport/State 函数到全局表（解决翻译顺序依赖）
# Phase 1b 全量翻译：正常翻译函数体
if trans._declare_only == 0:
fd_dbg: ast.FunctionDef | t.CPtr = (ast.FunctionDef | t.CPtr)(child)
if fd_dbg is not None and fd_dbg.name is not None:
stdio.printf("[DBG] TR func=%s\n", fd_dbg.name)
stdio.fflush(0)
added: int = HandlesFunctions.translate_function_def(trans, child)
added_total += added
elif trans._declare_only == 1:
@@ -109,10 +109,6 @@ def translate_children(trans: HT.Translator | t.CPtr,
# ClassDef 在模块级直接处理（不需要 builder）
# _declare_only=2（import扫描模式）时跳过，只处理 import 依赖
if trans._declare_only != 2:
cd_dbg: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(child)
if cd_dbg is not None and cd_dbg.name is not None:
stdio.printf("[DBG] TR class=%s\n", cd_dbg.name)
stdio.fflush(0)
HandlesClassDef.translate_class_def(trans, child)
elif trans._declare_only == 0 and trans._cur_builder is not None:
# 有 builder → 委托 HandlesBody 分派

10
App/lib/core/Handles/HandlesStruct.py
View File

@@ -522,16 +522,8 @@ def lookup_field_by_class(class_name: str,
entry = find_struct(class_name)
if entry is None:
# 诊断：遍历打印所有已注册结构体名，确认目标类是否在注册表中
stdio.printf("[LFBC-DIAG] FAIL class=%s field=%s sha1=%s count=%d\n",
class_name, field_name,
sha1 if sha1 is not None else "(null)", _struct_count)
for diag_i in range(_struct_count):
diag_entry: StructEntry | t.CPtr = _get_struct_entry(diag_i)
if diag_entry is not None and diag_entry.Name is not None:
stdio.printf("[LFBC-DIAG] [%d] %s sha1=%s fc=%d\n",
diag_i, diag_entry.Name,
diag_entry.ModuleSha1 if diag_entry.ModuleSha1 is not None else "(null)",
diag_entry.FieldCount)
return None
for fi in range(entry.FieldCount):
fe: FieldEntry | t.CPtr = _get_field_entry(entry, fi)
@@ -539,8 +531,6 @@ def lookup_field_by_class(class_name: str,
if string.strcmp(fe.Name, field_name) == 0:
return fe
# 诊断：找到结构体但字段未找到
stdio.printf("[LFBC-DIAG] NOFIELD class=%s field=%s sname=%s fc=%d\n",
class_name, field_name, entry.Name, entry.FieldCount)
return None

78
App/lib/core/Handles/HandlesType.py
View File

@@ -68,22 +68,8 @@ _g_cdefine_names: list[str] | t.CPtr = None
_g_cdefine_values: list[str] | t.CPtr = None
# ============================================================
# 全局跨模块 CDefine 表（按模块 SHA1 索引，跨模块持久化）
#
# 本地表在模块切换时被 clear_cdefine_constants 清空，
# 导致跨模块引用（如 HandlesVar.SCOPE_FUNCTION）找不到常量。
# 全局表在模块切换时不清空，跨模块查找直接查表，无需文件 I/O。
#
# 数据布局：
# _g_gcdef_sha1s: 每条 17 字节（模块 SHA1 16字符 + null）
# _g_gcdef_names: 每条 64 字节（常量名 + null）
# _g_gcdef_values: 每条 32 字节（值字符串 + null）
# 当前模块 SHA1（Phase1 在模块开始翻译前设置，供报错使用）
# ============================================================
MAX_GLOBAL_CDEFINE: t.CDefine = 1024
_g_gcdef_sha1s: bytes = None
_g_gcdef_names: bytes = None
_g_gcdef_values: bytes = None
_g_gcdef_count: int = 0
_g_current_module_sha1: str = None
@@ -93,29 +79,14 @@ def set_current_module_sha1(sha1: str) -> None:
_g_current_module_sha1 = sha1
def _global_cdefine_init(pool: memhub.MemBuddy | t.CPtr) -> int:
"""懒初始化全局 CDefine 表"""
global _g_gcdef_sha1s, _g_gcdef_names, _g_gcdef_values
if _g_gcdef_sha1s is None:
_g_gcdef_sha1s = stdlib.malloc(MAX_GLOBAL_CDEFINE * 17)
_g_gcdef_names = stdlib.malloc(MAX_GLOBAL_CDEFINE * 64)
_g_gcdef_values = stdlib.malloc(MAX_GLOBAL_CDEFINE * 32)
if _g_gcdef_sha1s is None or _g_gcdef_names is None or _g_gcdef_values is None:
return 1
string.memset(_g_gcdef_sha1s, 0, MAX_GLOBAL_CDEFINE * 17)
string.memset(_g_gcdef_names, 0, MAX_GLOBAL_CDEFINE * 64)
string.memset(_g_gcdef_values, 0, MAX_GLOBAL_CDEFINE * 32)
return 0
def register_cdefine_constant(pool: memhub.MemBuddy | t.CPtr,
name: str, value: int) -> None:
"""注册 CDefine 编译期常量到本地表和全局表
"""注册 CDefine 编译期常量到本地表
值以十进制字符串存储。注意：value 是 32 位有符号整数，
0xFFFFFFFF 会存储为 "-1"，lookup 时用 found 标志区分"未找到"和值为 -1。
"""
global _g_cdefine_names, _g_cdefine_values, _g_gcdef_count
global _g_cdefine_names, _g_cdefine_values
if _g_cdefine_names is None:
_g_cdefine_names = list[str](pool, 64)
_g_cdefine_values = list[str](pool, 64)
@@ -126,41 +97,6 @@ def register_cdefine_constant(pool: memhub.MemBuddy | t.CPtr,
_g_cdefine_values.append(val_buf)
else:
_g_cdefine_values.append("0")
# 同时注册到全局跨模块表（用当前模块 SHA1 索引）
if _g_current_module_sha1 is not None and _g_gcdef_count < MAX_GLOBAL_CDEFINE:
if _global_cdefine_init(pool) == 0:
sidx: t.CSizeT = t.CSizeT(_g_gcdef_count) * 17
nidx: t.CSizeT = t.CSizeT(_g_gcdef_count) * 64
vidx: t.CSizeT = t.CSizeT(_g_gcdef_count) * 32
string.strcpy(_g_gcdef_sha1s + sidx, _g_current_module_sha1)
string.strcpy(_g_gcdef_names + nidx, name)
vbuf: str = _g_gcdef_values + vidx
viperlib.snprintf(vbuf, 32, "%d", value)
_g_gcdef_count += 1
def lookup_global_cdefine(module_sha1: str, name: str) -> int:
"""从全局跨模块表查找 CDefine 常量
用 module_sha1 + name 精确匹配。
找到时设置 _g_cdefine_found=1 并返回值；未找到返回 0。
"""
global _g_cdefine_found
if module_sha1 is None or name is None:
return 0
if _g_gcdef_sha1s is None or _g_gcdef_count <= 0:
return 0
i: t.CSizeT = 0
while i < _g_gcdef_count:
sidx: t.CSizeT = t.CSizeT(i) * 17
nidx: t.CSizeT = t.CSizeT(i) * 64
vidx: t.CSizeT = t.CSizeT(i) * 32
if string.strcmp(_g_gcdef_sha1s + sidx, module_sha1) == 0:
if string.strcmp(_g_gcdef_names + nidx, name) == 0:
_g_cdefine_found = 1
return string.atoi(_g_gcdef_values + vidx)
i += 1
return 0
def lookup_cdefine_constant(name: str) -> int:
@@ -645,6 +581,14 @@ def map_t_type(pool: memhub.MemBuddy | t.CPtr,
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
elif string.strcmp(type_name, "VOIDPTR") == 0:
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
# Windows API 跨模块 typedef（win32base.py 中定义）
# HANDLE = VOIDPTR = i8*，LPCSTR = const char* = i8*，LPCWSTR = const wchar_t* = i16*
elif string.strcmp(type_name, "HANDLE") == 0:
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
elif string.strcmp(type_name, "LPCSTR") == 0:
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
elif string.strcmp(type_name, "LPCWSTR") == 0:
return llvmlite.Ptr(pool, llvmlite.Int16(pool))
elif string.strcmp(type_name, "INT8PTR") == 0:
return llvmlite.Ptr(pool, llvmlite.Int8(pool))
elif string.strcmp(type_name, "INT16PTR") == 0:

2
App/lib/core/IncludesScanner.py
View File

@@ -22,7 +22,7 @@ import lib.core.VLogger as VLogger
# ============================================================
# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# 文件路径最大长度
MAX_PATH_LEN: t.CDefine = 512

9
App/lib/core/Phase1.py
View File

@@ -24,7 +24,7 @@ import lib.Projectrans.Config as Config
import lib.StubGen.Converter as StubConverter
# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# 源代码缓冲区大小（1MB）
SRC_BUF_SIZE: t.CDefine = 1048576
@@ -944,7 +944,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
src_buf[SRC_BUF_SIZE - 1] = 0
# 解析 AST
stdio.printf("[P1B-1] parse %s\n", entry.RelPath)
lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
if lx is None:
stdlib.free(src_buf)
@@ -953,7 +952,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
ast._lexer_init(lx, src_buf, mb)
tokens: ast.Token | t.CPtr = ast.tokenize(lx)
tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
stdio.printf("[P1B-1a] parse-done %s\n", entry.RelPath)
if tree is None:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
@@ -964,7 +962,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
continue
# 生成 .pyi 存根文件（直接遍历 AST，不依赖 PythonToStubConverter）
stdio.printf("[P1B-2] pyi %s\n", entry.RelPath)
pyi_buf: bytes = stdlib.malloc(PYI_BUF_SIZE)
if pyi_buf is not None:
pyi_pos: t.CSizeT = StubConverter._GeneratePyiFromAst(mb, tree, entry.RelPath, pyi_buf, PYI_BUF_SIZE)
@@ -979,7 +976,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
stdlib.free(pyi_buf)
# 翻译 AST → LLVM IR
stdio.printf("[P1B-3] translate %s\n", entry.RelPath)
tr: HandlesTranslator.Translator | t.CPtr = HandlesTranslator.Translator()
if tr is None:
stdlib.free(src_buf)
@@ -992,7 +988,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
HandlesType.clear_cdefine_constants()
HandlesStruct.reset_visible_structs(mb, 0)
ret: int = tr.translate(tree)
stdio.printf("[P1B-3a] translate-done %s ret=%d\n", entry.RelPath, ret)
if ret != 0:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
@@ -1007,7 +1002,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
continue
# dump stub IR (declarations only)
stdio.printf("[P1B-4] stub %s\n", entry.RelPath)
PHASE1_IR_SIZE: t.CSizeT = 1048576
stub_buf: bytes = stdlib.malloc(PHASE1_IR_SIZE)
if stub_buf is None:
@@ -1033,7 +1027,6 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
stdlib.free(stub_buf)
# dump text IR (definitions only)
stdio.printf("[P1B-5] text %s\n", entry.RelPath)
text_buf: bytes = stdlib.malloc(PHASE1_IR_SIZE)
if text_buf is None:
stdlib.free(src_buf)

66
App/lib/core/Phase2.py
View File

@@ -24,7 +24,7 @@ import lib.Projectrans.Utils as Utils
import lib.Projectrans.Config as Config
# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# 源代码缓冲区大小（1MB）
SRC_BUF_SIZE: t.CDefine = 1048576
@@ -32,6 +32,9 @@ SRC_BUF_SIZE: t.CDefine = 1048576
# 最大源文件数（递归扫描子目录后文件数增多，增大到 64）
MAX_SRC_FILES: t.CDefine = 64
# 全局栈金丝雀（避免局部变量改变栈布局）
_g_canary: t.CUInt32T
@t.NoVTable
class SrcFileEntry:
@@ -172,8 +175,8 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
VLogger.error("source_dir 为空", "project")
return 1
stdio.printf("[DBG] RunMultiFileProject enter src=%s\n", source_dir)
stdio.fflush(0)
# === 栈金丝雀检查（全局变量，不影响栈布局）===
_g_canary = 305419896
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
@@ -188,8 +191,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
string.memset(entries, 0, MAX_SRC_FILES * entry_size)
file_count: int = _ScanDirForPyFiles(mb, source_dir, entries, entry_size, 0, MAX_SRC_FILES)
stdio.printf("[DBG] scan done file_count=%d\n", file_count)
stdio.fflush(0)
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "共 %d 个源文件", file_count)
@@ -296,8 +297,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
# === 2. Phase A: 为每个文件生成 stub + text ===
if do_phase1 != 0:
stdio.printf("[DBG] before Phase A\n")
stdio.fflush(0)
if log is not None:
log.banner("Phase A: 生成 stub + text")
@@ -311,8 +310,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
PHASE_A_PRE_MAX_PASSES: t.CInt = 3
for pass_i in range(PHASE_A_PRE_MAX_PASSES):
struct_count_before: int = HandlesStruct.get_struct_count()
stdio.printf("[DBG] PhaseA-pre pass=%d struct_count_before=%d\n", pass_i, struct_count_before)
stdio.fflush(0)
for i in range(file_count):
ea_pre: t.CUInt64T = t.CUInt64T(entries) + i * entry_size
ent_pre: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea_pre, t.CPtr))
@@ -322,8 +319,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
if string.strlen(ent_pre.Path) > src_dir_len_pre + 1:
rel_path_pre: str = ent_pre.Path + src_dir_len_pre + 1
pkg_pre = HandlesImports.compute_package_from_relpath(mb, rel_path_pre)
stdio.printf("[DBG] PhaseA-pre pass=%d file=%s\n", pass_i, ent_pre.Path)
stdio.fflush(0)
tr_pre: HandlesTranslator.Translator | t.CPtr = BuildPipeline.TranslateFileGetTrans(mb, ent_pre.Path, ent_pre.Sha1, pkg_pre, 1)
if tr_pre is None:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
@@ -331,8 +326,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
viperlib.snprintf(fb, 1024, "预注册失败: %s", ent_pre.Path)
VLogger.warning(fb, "PhaseA")
struct_count_after: int = HandlesStruct.get_struct_count()
stdio.printf("[DBG] PhaseA-pre pass=%d done struct_count_after=%d\n", pass_i, struct_count_after)
stdio.fflush(0)
# 收敛检查：本遍没有新结构体注册 → 所有类已注册
if struct_count_after == struct_count_before:
break
@@ -341,16 +334,11 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
PHASE_A_IR_SIZE: t.CSizeT = 1048576
td_len_pa: t.CSizeT = string.strlen(temp_dir)
stdio.printf("[DBG] PhaseA full-translate start\n")
stdio.fflush(0)
for i in range(file_count):
ea: t.CUInt64T = t.CUInt64T(entries) + i * entry_size
ent: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea, t.CPtr))
if ent is None or ent.Path is None:
continue
stdio.printf("[DBG] PhaseA file=%s\n", ent.Path)
stdio.fflush(0)
# 计算源文件的包名（相对 source_dir 的目录部分）
src_dir_len_pa: t.CSizeT = string.strlen(source_dir)
pkg_pa: str = None
@@ -413,8 +401,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
# === 3. Phase B: 编译每个文件为 .obj ===
if do_phase2 != 0:
stdio.printf("[DBG] before Phase B\n")
stdio.fflush(0)
if log is not None:
log.banner("Phase B: 编译 .obj")
@@ -441,12 +427,7 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
ent: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea, t.CPtr))
if ent is None or ent.Path is None or ent.Sha1 is None:
continue
stdio.printf("[DBG] PhaseB file=%s\n", ent.Path)
stdio.fflush(0)
# 组合本地 stub + 所有依赖 stub + 本地 text → 完整 IR
stdio.printf("[DBG] PhaseB step=alloc combined_ir\n")
stdio.fflush(0)
combined_ir: bytes = stdlib.malloc(COMBINED_IR_SIZE)
if combined_ir is None:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
@@ -454,11 +435,7 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
viperlib.snprintf(fb, 1024, "combined_ir 分配失败: %s", ent.Path)
VLogger.error(fb, "PhaseB")
continue
stdio.printf("[DBG] PhaseB step=BuildCombinedIR sha1=%s\n", ent.Sha1)
stdio.fflush(0)
combined_len: t.CSizeT = StubMerger.BuildCombinedIR(temp_dir, ent.Sha1, combined_ir, COMBINED_IR_SIZE)
stdio.printf("[DBG] PhaseB step=BuildCombinedIR done len=%d\n", combined_len)
stdio.fflush(0)
if combined_len == 0:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
@@ -468,13 +445,9 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
continue
# 编译为 .obj
stdio.printf("[DBG] PhaseB step=compile_module_to_obj\n")
stdio.fflush(0)
cret: int = BuildPipeline.compile_module_to_obj(
combined_ir, combined_len, temp_dir, output_dir, ent.Sha1,
cc_cmd, cc_flags)
stdio.printf("[DBG] PhaseB step=compile_module_to_obj done cret=%d\n", cret)
stdio.fflush(0)
stdlib.free(combined_ir)
if cret != 0:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
@@ -484,9 +457,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
sys.exit(1)
compiled_count += 1
stdio.printf("[DBG] PhaseB step=obj_path construct\n")
stdio.fflush(0)
# 构造 .obj 路径，检测是否是 main 模块（test_main.py 或 main.py）
od_len: t.CSizeT = string.strlen(output_dir)
is_main_mod: int = 0
@@ -517,11 +487,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
else:
VLogger.warning(".obj 路径缓冲区不足", "PhaseB")
stdlib.free(obj_path_sliced)
stdio.printf("[DBG] PhaseB step=obj_path done\n")
stdio.fflush(0)
stdio.printf("[DBG] PhaseB loop done compiled_count=%d\n", compiled_count)
stdio.fflush(0)
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "编译完成: %d/%d", compiled_count, file_count)
@@ -538,27 +503,18 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
# 检测并编译缺失的 includes 文件到 output_dir，加入链接命令。
# 数据来源：StubMerger 全局内存存储器（不读取 _sha1_map.txt 文件）
if includes_dir is not None and includes_binary_dir is not None:
stdio.printf("[DBG] PhaseB+ start\n")
stdio.fflush(0)
inc_compiled: int = 0
td_len_mi: t.CSizeT = string.strlen(temp_dir)
# 从全局存储器获取 SHA1/模块名/rel_path 数组（直接访问器，避免 box 解引用问题）
store_count_mi: int = StubMerger.GetSha1StoreCount()
stdio.printf("[DBG] PhaseB+ store_count=%d\n", store_count_mi)
stdio.fflush(0)
if store_count_mi > 0:
store_sha1_arr_mi: bytes | t.CPtr = StubMerger.GetSha1StoreArrPtr()
store_mod_arr_mi: bytes | t.CPtr = StubMerger.GetSha1StoreModArrPtr()
store_rel_arr_mi: bytes | t.CPtr = StubMerger.GetSha1StoreRelArrPtr()
stdio.printf("[DBG] PhaseB+ arrs ok sha1=%p mod=%p rel=%p\n", store_sha1_arr_mi, store_mod_arr_mi, store_rel_arr_mi)
stdio.fflush(0)
for si_mi in range(store_count_mi):
# 获取当前条目的 SHA1 和 rel_path
inc_sha1_mi: str = store_sha1_arr_mi + t.CSizeT(si_mi) * 17
inc_rel_mi: str = store_rel_arr_mi + t.CSizeT(si_mi) * StubMerger.MAX_REL_PATH_LEN
stdio.printf("[DBG] PhaseB+ iter=%d sha1=%s rel=%s\n", si_mi, inc_sha1_mi, inc_rel_mi)
stdio.fflush(0)
# 检查 .obj 是否已存在于 includes.binary
ibd_len_mi: t.CSizeT = string.strlen(includes_binary_dir)
check_pat_mi: bytes = stdlib.malloc(ibd_len_mi + 35)
@@ -719,8 +675,6 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
VLogger.info(fb, "PhaseB+")
# === 4. Phase C: 链接所有 .obj → .exe ===
stdio.printf("[DBG] PhaseC start\n")
stdio.fflush(0)
if log is not None:
log.banner("Phase C: 链接")
@@ -754,14 +708,10 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
final_obj_paths[fop_pos] = '\0'
obj_paths_len: t.CSizeT = fop_pos
stdio.printf("[DBG] PhaseC before link_objs_to_exe len=%d\n", obj_paths_len)
stdio.fflush(0)
lret: int = BuildPipeline.link_objs_to_exe(
final_obj_paths, obj_paths_len,
linker_cmd, linker_flags, exe_path,
includes_binary_dir)
stdio.printf("[DBG] PhaseC link_objs_to_exe done lret=%d\n", lret)
stdio.fflush(0)
if lret == 0:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
@@ -772,13 +722,13 @@ def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr,
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "执行: %s", exe_path)
VLogger.info(fb, "run")
VLogger.info(fb, "run")
rp: subprocess.CompletedProcess | t.CPtr = subprocess.run(exe_path, False, False)
if rp is not None:
fb: t.CChar | t.CPtr = VLogger.fmt_buf()
if fb is not None:
viperlib.snprintf(fb, 1024, "退出码: %d", rp.returncode)
VLogger.info(fb, "run")
VLogger.info(fb, "run")
else:
VLogger.error("链接失败", "PhaseC")
stdlib.free(entries)

2
App/lib/core/StubMerger.py
View File

@@ -35,7 +35,7 @@ import lib.Projectrans.Config as Config
# ============================================================
# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# 最大 includes SHA1 数（用于过滤）
MAX_INCLUDES_SHA1: t.CDefine = 256

47
App/lib/core/VLogger.py
View File

@@ -54,11 +54,12 @@ BACKGROUND_INTENSITY: t.CDefine = 0x0080
BACKGROUND_WHITE: t.CDefine = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
@t.NoVTable
class Logger:
_level: int
_console_handle: w32base.HANDLE
_console_handle: win32base.HANDLE
_use_color: int
__mbuddy__: memhub.MemManager | t.CPtr
__mbuddy__: memhub.MemBuddy | t.CPtr
def __init__(self, level: int = 1):
self._level = level
@@ -67,8 +68,11 @@ class Logger:
self.__mbuddy__ = _mbuddy
def _set_color(self, attr: WORD) -> int:
if self._use_color:
return w32cmd.SetConsoleTextAttribute(self._console_handle, attr)
uc: int = self._use_color
if uc:
ch: win32base.HANDLE = self._console_handle
ret: int = w32cmd.SetConsoleTextAttribute(ch, attr)
return ret
return 0
def _reset_color(self) -> int:
@@ -88,23 +92,17 @@ class Logger:
def _log(self, level: int, prefix_sym: str, level_str: str, msg: str,
sym_color: WORD, level_color: WORD,
category: str = "") -> int:
if level < self._level:
return 0
# 前缀符号（如 ├）
# 前缀符号着色
self._set_color(sym_color)
stdio.printf("%s ", prefix_sym)
# LEVEL 标签（亮色）
# LEVEL 标签着色
self._set_color(level_color)
if category is not None:
if category[0] != 0:
stdio.printf("%s[%s]: ", level_str, category)
else:
stdio.printf("%s: ", level_str)
else:
stdio.printf("%s: ", level_str)
# 消息内容（默认色）
stdio.printf("%s", level_str)
self._reset_color()
stdio.printf("%s\n", msg)
# category 可选
if category is not None and category[0] != 0:
stdio.printf("[%s]", category)
stdio.printf(": %s\n", msg)
return 0
def debug(self, msg: str, category: str = "") -> int:
@@ -112,9 +110,10 @@ class Logger:
FOREGROUND_INTENSITY, FOREGROUND_INTENSITY, category)
def info(self, msg: str, category: str = "") -> int:
return self._log(LogLevel.INFO, "├", "INFO", msg,
FOREGROUND_GREEN,
FOREGROUND_GREEN | FOREGROUND_INTENSITY, category)
ret: int = self._log(LogLevel.INFO, "├", "INFO", msg,
FOREGROUND_GREEN,
FOREGROUND_GREEN | FOREGROUND_INTENSITY, category)
return ret
def warning(self, msg: str, category: str = "") -> int:
return self._log(LogLevel.WARNING, "├", "WARN", msg,
@@ -189,7 +188,7 @@ class Logger:
# 全局 mbuddy 指针（由 lib.InitLib 注入）
_mbuddy: memhub.MemManager | t.CPtr
_mbuddy: memhub.MemBuddy | t.CPtr
# 全局 logger 指针
_g_logger: Logger | t.CPtr
@@ -223,10 +222,8 @@ def get_logger() -> Logger | t.CPtr:
if raw is None:
return None
_g_logger = raw
_g_logger._level = LogLevel.INFO
_g_logger._console_handle = w32file.GetStdHandle(w32file.STD_OUTPUT_HANDLE)
_g_logger._use_color = 1
_g_logger.__mbuddy__ = _mbuddy
_g_logger.__before_init__()
_g_logger.__init__(LogLevel.INFO)
return _g_logger

105
App/main.py
View File

@@ -49,127 +49,70 @@ SRC_BUF_SIZE: t.CDefine = 1048576
def main() -> int:
w32cmd.SetConsoleOutputCP(CODE_PAGE)
w32cmd.SetConsoleCP(CODE_PAGE)
# 用 fflush(0) 刷新所有流，确保崩溃前输出可见（0=NULL 刷新所有输出流）
stdio.printf("[DBG] main enter\n")
stdio.fflush(0)
# 初始化 mbuddy 内存池
stdio.printf("[DBG] before malloc\n")
stdio.fflush(0)
arena: bytes = stdlib.malloc(POOL_SIZE)
stdio.printf("[DBG] after malloc arena=%p\n", arena)
stdio.fflush(0)
if arena is None:
stdio.printf("FAIL: malloc for arena failed\n")
return 1
stdio.printf("[DBG] before MemBuddy\n")
stdio.fflush(0)
mb: memhub.MemBuddy | t.CPtr = memhub.MemBuddy(arena, POOL_SIZE)
stdio.printf("[DBG] after MemBuddy mb=%p\n", mb)
stdio.fflush(0)
if mb is None:
stdio.printf("FAIL: MemBuddy init failed\n")
return 1
# 设置全局 mbuddy 指针（sys 和 argparse 都需要）
stdio.printf("[DBG] before _mbuddy setup\n")
stdio.fflush(0)
sys._mbuddy = mb
stdio.printf("[DBG] sys._mbuddy ok\n")
stdio.fflush(0)
argparse._mbuddy = mb
ast._mbuddy = mb
lib._mbuddy = (memhub.MemManager | t.CPtr)(mb)
Config._mbuddy = (memhub.MemManager | t.CPtr)(mb)
Utils._mbuddy = (memhub.MemManager | t.CPtr)(mb)
lib._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
Config._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
Utils._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
HandlesTranslator._mbuddy = mb
BuildPipeline._mbuddy = (memhub.MemManager | t.CPtr)(mb)
IncludesScanner._mbuddy = (memhub.MemManager | t.CPtr)(mb)
StubMerger._mbuddy = (memhub.MemManager | t.CPtr)(mb)
Phase1._mbuddy = (memhub.MemManager | t.CPtr)(mb)
Phase2._mbuddy = (memhub.MemManager | t.CPtr)(mb)
BuildPipeline._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
IncludesScanner._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
StubMerger._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
Phase1._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
Phase2._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
subprocess._mbuddy = mb
hashlib._mbuddy = (memhub.MemManager | t.CPtr)(mb)
VLogger._mbuddy = (memhub.MemManager | t.CPtr)(mb)
stdio.printf("[DBG] before InitLib\n")
stdio.fflush(0)
lib.InitLib((memhub.MemManager | t.CPtr)(mb))
stdio.printf("[DBG] after InitLib\n")
stdio.fflush(0)
hashlib._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
VLogger._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
lib.InitLib((memhub.MemBuddy | t.CPtr)(mb))
# 初始化 VLogger 并打印启动日志
log: VLogger.Logger | t.CPtr = VLogger.get_logger()
stdio.printf("[DBG] after get_logger log=%p\n", log)
stdio.fflush(0)
if log is not None:
log.info("TransPyV 启动")
stdio.printf("[DBG] after log.info\n")
stdio.fflush(0)
# 初始化命令行参数（Windows: GetCommandLineA, POSIX: /proc/self/cmdline）
stdio.printf("[DBG] before _init_argv\n")
stdio.fflush(0)
sys._init_argv()
stdio.printf("[DBG] after _init_argv\n")
stdio.fflush(0)
# 创建参数解析器
stdio.printf("[DBG] before ArgumentParser\n")
stdio.fflush(0)
parser: argparse.ArgumentParser | t.CPtr = argparse.ArgumentParser(
"TransPyV", "TransPyV 命令行参数解析", pool=mb)
stdio.printf("[DBG] after ArgumentParser parser=%p\n", parser)
stdio.fflush(0)
# 注册参数（与 Projectrans.py main() 一致）
stdio.printf("[DBG] before add_argument --project\n")
stdio.fflush(0)
parser.add_argument("--project", None, argparse.STRING, 0, None, False,
argparse.STORE, "project.json 路径（默认查找当前目录）")
stdio.printf("[DBG] after add_argument --project\n")
stdio.fflush(0)
parser.add_argument("--src", None, argparse.STRING, 0, None, False,
argparse.STORE, "源文件目录（覆盖 project.json）")
stdio.printf("[DBG] after --src\n")
stdio.fflush(0)
parser.add_argument("--temp", None, argparse.STRING, 0, None, False,
argparse.STORE, "声明接口临时目录（覆盖 project.json）")
stdio.printf("[DBG] after --temp\n")
stdio.fflush(0)
parser.add_argument("--output", None, argparse.STRING, 0, None, False,
argparse.STORE, "输出目录（覆盖 project.json）")
stdio.printf("[DBG] after --output\n")
stdio.fflush(0)
parser.add_argument("--phase", None, argparse.STRING, 0, None, False,
argparse.STORE, "阶段: 1=生成声明, 2=翻译+编译, all=全部")
stdio.printf("[DBG] after --phase\n")
stdio.fflush(0)
parser.add_argument("--cc", None, argparse.STRING, 0, None, False,
argparse.STORE, "LLVM 编译器命令（覆盖 project.json）")
stdio.printf("[DBG] after --cc\n")
stdio.fflush(0)
parser.add_argument("--clean", None, argparse.BOOL, 0, None, False,
argparse.STORE_TRUE, "清理 output 和 temp 目录")
stdio.printf("[DBG] after --clean\n")
stdio.fflush(0)
parser.add_argument("--run", None, argparse.BOOL, 0, None, False,
argparse.STORE_TRUE, "编译成功后立即执行生成的可执行文件")
stdio.printf("[DBG] after --run\n")
stdio.fflush(0)
parser.add_argument("--rebuild-includes", None, argparse.BOOL, 0, None, False,
argparse.STORE_TRUE, "删除 includes.binary 预编译缓存并重新编译所有 includes")
stdio.printf("[DBG] after --rebuild-includes\n")
stdio.fflush(0)
parser.add_argument("--clear-cache", None, argparse.BOOL, 0, None, False,
argparse.STORE_TRUE, "清除 .transpyc_cache 全局缓存")
stdio.printf("[DBG] after --clear-cache\n")
stdio.fflush(0)
# 解析命令行参数
stdio.printf("[DBG] before parse_args\n")
stdio.fflush(0)
args: argparse.ParsedArgs | t.CPtr = parser.parse_args(sys._argc, sys._argv)
stdio.printf("[DBG] after parse_args args=%p\n", args)
stdio.fflush(0)
if args is None:
if log is not None:
log.error("参数解析失败", "argparse")
@@ -244,13 +187,10 @@ def main() -> int:
proj_loaded: int = 0
proj_path: str = project
if proj_path is not None:
stdio.printf("[DBG] before Load_project_config path=%s\n", proj_path)
stdio.fflush(0)
if log is not None:
log.banner("工程配置")
if Config.Load_project_config(proj_path) == 0:
stdio.printf("[DBG] Load_project_config OK\n")
stdio.fflush(0)
cfg_ret: int = Config.Load_project_config(proj_path)
if cfg_ret == 0:
proj_loaded = 1
else:
if log is not None:
@@ -284,14 +224,8 @@ def main() -> int:
if proj_dir is not None:
string.memcpy(proj_dir, proj_path, slash_pos)
proj_dir[slash_pos] = '\0'
stdio.printf("[DBG] before resolve_paths dir=%s\n", proj_dir)
stdio.fflush(0)
Config.resolve_paths(proj_dir)
stdio.printf("[DBG] resolve_paths OK\n")
stdio.fflush(0)
Config.print_config()
stdio.printf("[DBG] print_config OK\n")
stdio.fflush(0)
# === --clean: 清理 temp 和 output 目录 ===
if _gb_clean:
@@ -321,9 +255,10 @@ def main() -> int:
phase_mode = "all"
do_phase1: int = 0
do_phase2: int = 0
if phase_mode == "1" or phase_mode == "all":
# 注意: 使用 string.strcmp 而非 ==，避免编译器 == 语义 bug
if string.strcmp(phase_mode, "1") == 0 or string.strcmp(phase_mode, "all") == 0:
do_phase1 = 1
if phase_mode == "2" or phase_mode == "all":
if string.strcmp(phase_mode, "2") == 0 or string.strcmp(phase_mode, "all") == 0:
do_phase2 = 1
if log is not None:
fb3: t.CChar | t.CPtr = VLogger.fmt_buf()
@@ -337,11 +272,7 @@ def main() -> int:
ph1_temp: str = Config.TempDir
if ph1_temp is None:
ph1_temp = "."
stdio.printf("[DBG] before Phase1.RunPhase1 inc=%s temp=%s\n", Config.IncludesDir, ph1_temp)
stdio.fflush(0)
Phase1.RunPhase1(mb, Config.IncludesDir, ph1_temp, log)
stdio.printf("[DBG] Phase1.RunPhase1 OK\n")
stdio.fflush(0)
# 如果仅 Phase1（不执行 Phase2），直接退出
if do_phase2 == 0:
if log is not None:
@@ -363,14 +294,10 @@ def main() -> int:
mf_linker_out: str = Config.LinkerOutput if Config.LinkerOutput is not None else "app.exe"
mf_includes_bin: str = Config.get_includes_binary_dir()
stdio.printf("[DBG] before Phase2.RunMultiFileProject src=%s temp=%s out=%s\n", Config.SourceDir, mf_temp, mf_output)
stdio.fflush(0)
mf_ret: int = Phase2.RunMultiFileProject(
mb, Config.SourceDir, mf_temp, mf_output,
mf_cc, mf_cc_flags, mf_linker, mf_linker_flags, mf_linker_out,
mf_includes_bin, Config.IncludesDir, do_phase1, do_phase2, log, args)
stdio.printf("[DBG] Phase2.RunMultiFileProject OK ret=%d\n", mf_ret)
stdio.fflush(0)
argparse.release(args)
if log is not None:
log.success("TransPyV 完成")

0
stderr.log
View File

0
stderr2.log
View File

0
stdout.log
View File

0
stdout2.log
View File

483
test_crash_dbg.log
View File

@@ -1,483 +0,0 @@
[DBG] main enter
├ INFO: TransPyV 启动
=== TransPyV 参数解析结果 ===
--project: TransPyV/Test/project.vpj
--src: (未指定)
--temp: (未指定)
--output: (未指定)
--phase: (未指定，默认 all)
--cc: (未指定)
--clean: True
--run: False
--rebuild-includes: False
--clear-cache: False
参数解析完成。
[DBG] before Load_project_config path=TransPyV/Test/project.vpj
=== 工程配置 ===
[DBG] Load_project_config OK
[DBG] before resolve_paths dir=TransPyV/Test
[DBG] resolve_paths OK
├ INFO[config]: project: AstTest v1.0.0
├ INFO[config]: source_dir: TransPyV/Test/App
├ INFO[config]: build_dir: TransPyV/Test/.tpv_build
├ INFO[config]: temp_dir: TransPyV/Test/.tpv_build/temp
├ INFO[config]: output_dir: TransPyV/Test/.tpv_build/output
├ INFO[config]: compiler: llc
├ INFO[config]: linker: clang++ -> app.exe
├ INFO[config]: includes: TransPyV/Test/../../includes
├ INFO[config]: sha1_slice_level: 1
[DBG] print_config OK
├ INFO[clean]: 清理临时目录...
├ INFO[clean]: TransPyV/Test/.tpv_build/temp: 删除 1 个文件
├ INFO[clean]: TransPyV/Test/.tpv_build/output: 删除 0 个文件
├ INFO[phase]: 模式: all (phase1=1 phase2=1)
[DBG] before Phase1.RunPhase1 inc=TransPyV/Test/../../includes temp=TransPyV/Test/.tpv_build/temp
=== Phase1: 扫描 includes（按需翻译） ===
├ INFO[Phase1]: 拓扑排序: 25 个类, 15 个文件按依赖顺序处理
├ INFO[Phase1]: 完成: 翻译=0 跳过=78 失败=0
[DBG] Phase1.RunPhase1 OK
[DBG] before Phase2.RunMultiFileProject src=TransPyV/Test/App temp=TransPyV/Test/.tpv_build/temp out=TransPyV/Test/.tpv_build/output
[DBG] RunMultiFileProject enter src=TransPyV/Test/App
├ INFO[project]: 多文件项目编译: TransPyV/Test/App
├ INFO[project]: asm_test.py (sha1=80241c7d6f357bd1)
├ INFO[project]: attr_test.py (sha1=17c0dfbcebfa3a0e)
├ INFO[project]: augassign_test.py (sha1=0eccc2393466d940)
├ INFO[project]: circ_a.py (sha1=ac47a9dc68e6834c)
├ INFO[project]: circ_b.py (sha1=04d33c721a603632)
├ INFO[project]: circ_test.py (sha1=5314f09055045035)
├ INFO[project]: closure_test.py (sha1=9d8e1c9631c28b1b)
├ INFO[project]: deco_test.py (sha1=b7bbe6a1c1e75ad8)
├ INFO[project]: deref_min_test.py (sha1=6f5e876273093314)
├ INFO[project]: deref_test.py (sha1=eb252050d92f8fb9)
├ INFO[project]: eq_test.py (sha1=b8cbe044a10adcca)
├ INFO[project]: float_test.py (sha1=e74870eba3e6d774)
├ INFO[project]: flow_test.py (sha1=969c589035910845)
├ INFO[project]: for_test.py (sha1=1eb1c9fc7e85d9f8)
├ INFO[project]: func_test.py (sha1=3c2fbc9e35ad3bf2)
├ INFO[project]: func_vtable_test.py (sha1=a9df037d9178888f)
├ INFO[project]: inherit_test.py (sha1=97043f0d52da437f)
├ INFO[project]: llvmir_test.py (sha1=c39f3e540adb7b4e)
├ INFO[project]: namespace_defs.py (sha1=b7eeff93aa63e70f)
├ INFO[project]: namespace_test.py (sha1=ef45adce81bf5b2d)
├ INFO[project]: new_test.py (sha1=9d798d964b9d3411)
├ INFO[project]: oop_test.py (sha1=1b9ab264a942c56b)
├ INFO[project]: opovl_test.py (sha1=a7cf0ce4066332ae)
├ INFO[project]: ptr_only_test.py (sha1=ed1c124f3cb787c9)
├ INFO[project]: ptr_test.py (sha1=07f7da85af876124)
├ INFO[project]: simple_test.py (sha1=b078e9c9c74a2a0c)
├ INFO[project]: string_min_test.py (sha1=74ca31446cac2107)
├ INFO[project]: string_test.py (sha1=e0009679269c6b63)
├ INFO[project]: struct_test.py (sha1=33a854a5c4f67d74)
├ INFO[project]: testcheck_test.py (sha1=d7662500f1c2c0ff)
├ INFO[project]: test_main.py (sha1=ff744980c190e9b0)
├ INFO[project]: type_bit_test.py (sha1=55cbbb5dec4fef2c)
├ INFO[project]: virtual_dispatch_test.py (sha1=cc3ad7f3bc880326)
├ INFO[project]: vtable_test.py (sha1=2769dee537308b00)
[DBG] scan done file_count=34
├ INFO[project]: 共 34 个源文件
├ INFO[project]: 已追加 34 个 App 文件到 _sha1_map.txt
[DBG] before Phase A
=== Phase A: 生成 stub + text ===
├ INFO[PhaseA]: 预注册 struct/enum/union...
[DBG] PhaseA-pre pass=0 struct_count_before=24
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/asm_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/attr_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/circ_a.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/circ_b.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/circ_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/closure_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/deco_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/deref_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/eq_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/float_test.py
├ INFO[UNION]: registered DataUnion with 3 fields, max_size=8
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/flow_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/for_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/func_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/new_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/oop_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/simple_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/string_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/struct_test.py
├ INFO[ENUM]: registered State with 3 members, base_bits=32
├ INFO[ENUM]: registered Color with 4 members, base_bits=32
├ INFO[ENUM]: registered MixedType with 3 members, base_bits=64
├ INFO[UNION]: registered DataUnion with 3 fields, max_size=8
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/test_main.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/vtable_test.py
[DBG] PhaseA-pre pass=0 done struct_count_after=51
[DBG] PhaseA-pre pass=1 struct_count_before=51
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/asm_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/attr_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/circ_a.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/circ_b.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/circ_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/closure_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/deco_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/deref_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/eq_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/float_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/flow_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/for_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/func_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/new_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/oop_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/simple_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/string_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/struct_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/test_main.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/vtable_test.py
[DBG] PhaseA-pre pass=1 done struct_count_after=51
├ INFO[PhaseA]: 预注册完成
[DBG] PhaseA full-translate start
[DBG] PhaseA file=TransPyV/Test/App/asm_test.py
[DBG] PhaseA file=TransPyV/Test/App/attr_test.py
[DBG] PhaseA file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseA file=TransPyV/Test/App/circ_a.py
[DBG] PhaseA file=TransPyV/Test/App/circ_b.py
[DBG] PhaseA file=TransPyV/Test/App/circ_test.py
[DBG] PhaseA file=TransPyV/Test/App/closure_test.py
[DBG] PhaseA file=TransPyV/Test/App/deco_test.py
[DBG] PhaseA file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseA file=TransPyV/Test/App/deref_test.py
[DBG] PhaseA file=TransPyV/Test/App/eq_test.py
[DBG] PhaseA file=TransPyV/Test/App/float_test.py
[DBG] PhaseA file=TransPyV/Test/App/flow_test.py
[DBG] PhaseA file=TransPyV/Test/App/for_test.py
[DBG] PhaseA file=TransPyV/Test/App/func_test.py
[DBG] PhaseA file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseA file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseA file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseA file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseA file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseA file=TransPyV/Test/App/new_test.py
[DBG] PhaseA file=TransPyV/Test/App/oop_test.py
[DBG] PhaseA file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseA file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseA file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseA file=TransPyV/Test/App/simple_test.py
[DBG] PhaseA file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseA file=TransPyV/Test/App/string_test.py
[DBG] PhaseA file=TransPyV/Test/App/struct_test.py
[DBG] PhaseA file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseA file=TransPyV/Test/App/test_main.py
[DBG] PhaseA file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseA file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseA file=TransPyV/Test/App/vtable_test.py
[DBG] before Phase B
=== Phase B: 编译 .obj ===
[DBG] PhaseB file=TransPyV/Test/App/asm_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=80241c7d6f357bd1
[DBG] PhaseB step=BuildCombinedIR done len=51574
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/attr_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=17c0dfbcebfa3a0e
[DBG] PhaseB step=BuildCombinedIR done len=72070
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=0eccc2393466d940
[DBG] PhaseB step=BuildCombinedIR done len=53827
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/circ_a.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=ac47a9dc68e6834c
[DBG] PhaseB step=BuildCombinedIR done len=51031
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/circ_b.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=04d33c721a603632
[DBG] PhaseB step=BuildCombinedIR done len=51025
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/circ_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=5314f09055045035
[DBG] PhaseB step=BuildCombinedIR done len=56407
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/closure_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=9d8e1c9631c28b1b
[DBG] PhaseB step=BuildCombinedIR done len=52838
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/deco_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=b7bbe6a1c1e75ad8
[DBG] PhaseB step=BuildCombinedIR done len=68777
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=6f5e876273093314
[DBG] PhaseB step=BuildCombinedIR done len=50111
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/deref_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=eb252050d92f8fb9
[DBG] PhaseB step=BuildCombinedIR done len=50661
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/eq_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=b8cbe044a10adcca
[DBG] PhaseB step=BuildCombinedIR done len=67044
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/float_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=e74870eba3e6d774
[DBG] PhaseB step=BuildCombinedIR done len=57074
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/flow_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=969c589035910845
[DBG] PhaseB step=BuildCombinedIR done len=51773
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/for_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=1eb1c9fc7e85d9f8
[DBG] PhaseB step=BuildCombinedIR done len=50124
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/func_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=3c2fbc9e35ad3bf2
[DBG] PhaseB step=BuildCombinedIR done len=54695
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=a9df037d9178888f
[DBG] PhaseB step=BuildCombinedIR done len=60040
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=97043f0d52da437f
[DBG] PhaseB step=BuildCombinedIR done len=63006
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=c39f3e540adb7b4e
[DBG] PhaseB step=BuildCombinedIR done len=72025
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=b7eeff93aa63e70f
[DBG] PhaseB step=BuildCombinedIR done len=52547
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=ef45adce81bf5b2d
[DBG] PhaseB step=BuildCombinedIR done len=63978
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/new_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=9d798d964b9d3411
[DBG] PhaseB step=BuildCombinedIR done len=59175
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/oop_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=1b9ab264a942c56b
[DBG] PhaseB step=BuildCombinedIR done len=62087
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=a7cf0ce4066332ae
[DBG] PhaseB step=BuildCombinedIR done len=82295
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=ed1c124f3cb787c9
[DBG] PhaseB step=BuildCombinedIR done len=52176
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=07f7da85af876124
[DBG] PhaseB step=BuildCombinedIR done len=59942
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/simple_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=b078e9c9c74a2a0c
[DBG] PhaseB step=BuildCombinedIR done len=49754
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=74ca31446cac2107
[DBG] PhaseB step=BuildCombinedIR done len=54019
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/string_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=e0009679269c6b63
[DBG] PhaseB step=BuildCombinedIR done len=65173
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/struct_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=33a854a5c4f67d74
[DBG] PhaseB step=BuildCombinedIR done len=71825
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=d7662500f1c2c0ff
[DBG] PhaseB step=BuildCombinedIR done len=58573
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/test_main.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=ff744980c190e9b0
[DBG] PhaseB step=BuildCombinedIR done len=57150
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=55cbbb5dec4fef2c
[DBG] PhaseB step=BuildCombinedIR done len=52348
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=cc3ad7f3bc880326
[DBG] PhaseB step=BuildCombinedIR done len=59792
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB file=TransPyV/Test/App/vtable_test.py
[DBG] PhaseB step=alloc combined_ir
[DBG] PhaseB step=BuildCombinedIR sha1=2769dee537308b00
[DBG] PhaseB step=BuildCombinedIR done len=56517
[DBG] PhaseB step=compile_module_to_obj
[DBG] PhaseB step=compile_module_to_obj done cret=0
[DBG] PhaseB step=obj_path construct
[DBG] PhaseB step=obj_path done
[DBG] PhaseB loop done compiled_count=34
├ SUCCESS[PhaseB]: 编译完成: 34/34
[DBG] PhaseB+ start
[DBG] PhaseB+ store_count=93

0
test_stderr.log
View File

241
test_stdout.log
View File

@@ -1,241 +0,0 @@
[DBG] main enter
├ INFO: TransPyV 启动
=== TransPyV 参数解析结果 ===
--project: TransPyV/Test/project.vpj
--src: (未指定)
--temp: (未指定)
--output: (未指定)
--phase: (未指定，默认 all)
--cc: (未指定)
--clean: True
--run: False
--rebuild-includes: False
--clear-cache: False
参数解析完成。
[DBG] before Load_project_config path=TransPyV/Test/project.vpj
=== 工程配置 ===
[DBG] Load_project_config OK
[DBG] before resolve_paths dir=TransPyV/Test
[DBG] resolve_paths OK
├ INFO[config]: project: AstTest v1.0.0
├ INFO[config]: source_dir: TransPyV/Test/App
├ INFO[config]: build_dir: TransPyV/Test/.tpv_build
├ INFO[config]: temp_dir: TransPyV/Test/.tpv_build/temp
├ INFO[config]: output_dir: TransPyV/Test/.tpv_build/output
├ INFO[config]: compiler: llc
├ INFO[config]: linker: clang++ -> app.exe
├ INFO[config]: includes: TransPyV/Test/../../includes
├ INFO[config]: sha1_slice_level: 1
[DBG] print_config OK
├ INFO[clean]: 清理临时目录...
├ INFO[clean]: TransPyV/Test/.tpv_build/temp: 删除 1 个文件
├ INFO[clean]: TransPyV/Test/.tpv_build/output: 删除 0 个文件
├ INFO[phase]: 模式: all (phase1=1 phase2=1)
[DBG] before Phase1.RunPhase1 inc=TransPyV/Test/../../includes temp=TransPyV/Test/.tpv_build/temp
=== Phase1: 扫描 includes（按需翻译） ===
├ INFO[Phase1]: 拓扑排序: 25 个类, 15 个文件按依赖顺序处理
├ INFO[Phase1]: 完成: 翻译=0 跳过=78 失败=0
[DBG] Phase1.RunPhase1 OK
[DBG] before Phase2.RunMultiFileProject src=TransPyV/Test/App temp=TransPyV/Test/.tpv_build/temp out=TransPyV/Test/.tpv_build/output
[DBG] RunMultiFileProject enter src=TransPyV/Test/App
├ INFO[project]: 多文件项目编译: TransPyV/Test/App
├ INFO[project]: asm_test.py (sha1=80241c7d6f357bd1)
├ INFO[project]: attr_test.py (sha1=17c0dfbcebfa3a0e)
├ INFO[project]: augassign_test.py (sha1=0eccc2393466d940)
├ INFO[project]: circ_a.py (sha1=ac47a9dc68e6834c)
├ INFO[project]: circ_b.py (sha1=04d33c721a603632)
├ INFO[project]: circ_test.py (sha1=5314f09055045035)
├ INFO[project]: closure_test.py (sha1=9d8e1c9631c28b1b)
├ INFO[project]: deco_test.py (sha1=b7bbe6a1c1e75ad8)
├ INFO[project]: deref_min_test.py (sha1=6f5e876273093314)
├ INFO[project]: deref_test.py (sha1=eb252050d92f8fb9)
├ INFO[project]: eq_test.py (sha1=b8cbe044a10adcca)
├ INFO[project]: float_test.py (sha1=e74870eba3e6d774)
├ INFO[project]: flow_test.py (sha1=969c589035910845)
├ INFO[project]: for_test.py (sha1=1eb1c9fc7e85d9f8)
├ INFO[project]: func_test.py (sha1=3c2fbc9e35ad3bf2)
├ INFO[project]: func_vtable_test.py (sha1=a9df037d9178888f)
├ INFO[project]: inherit_test.py (sha1=97043f0d52da437f)
├ INFO[project]: llvmir_test.py (sha1=c39f3e540adb7b4e)
├ INFO[project]: namespace_defs.py (sha1=b7eeff93aa63e70f)
├ INFO[project]: namespace_test.py (sha1=ef45adce81bf5b2d)
├ INFO[project]: new_test.py (sha1=9d798d964b9d3411)
├ INFO[project]: oop_test.py (sha1=1b9ab264a942c56b)
├ INFO[project]: opovl_test.py (sha1=a7cf0ce4066332ae)
├ INFO[project]: ptr_only_test.py (sha1=ed1c124f3cb787c9)
├ INFO[project]: ptr_test.py (sha1=07f7da85af876124)
├ INFO[project]: simple_test.py (sha1=b078e9c9c74a2a0c)
├ INFO[project]: string_min_test.py (sha1=74ca31446cac2107)
├ INFO[project]: string_test.py (sha1=e0009679269c6b63)
├ INFO[project]: struct_test.py (sha1=33a854a5c4f67d74)
├ INFO[project]: testcheck_test.py (sha1=d7662500f1c2c0ff)
├ INFO[project]: test_main.py (sha1=ff744980c190e9b0)
├ INFO[project]: type_bit_test.py (sha1=55cbbb5dec4fef2c)
├ INFO[project]: virtual_dispatch_test.py (sha1=cc3ad7f3bc880326)
├ INFO[project]: vtable_test.py (sha1=2769dee537308b00)
[DBG] scan done file_count=34
├ INFO[project]: 共 34 个源文件
├ INFO[project]: 已追加 34 个 App 文件到 _sha1_map.txt
[DBG] before Phase A
=== Phase A: 生成 stub + text ===
├ INFO[PhaseA]: 预注册 struct/enum/union...
[DBG] PhaseA-pre pass=0 struct_count_before=24
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/asm_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/attr_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/circ_a.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/circ_b.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/circ_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/closure_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/deco_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/deref_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/eq_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/float_test.py
├ INFO[UNION]: registered DataUnion with 3 fields, max_size=8
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/flow_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/for_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/func_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/new_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/oop_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/simple_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/string_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/struct_test.py
├ INFO[ENUM]: registered State with 3 members, base_bits=32
├ INFO[ENUM]: registered Color with 4 members, base_bits=32
├ INFO[ENUM]: registered MixedType with 3 members, base_bits=64
├ INFO[UNION]: registered DataUnion with 3 fields, max_size=8
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/test_main.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseA-pre pass=0 file=TransPyV/Test/App/vtable_test.py
[DBG] PhaseA-pre pass=0 done struct_count_after=51
[DBG] PhaseA-pre pass=1 struct_count_before=51
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/asm_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/attr_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/circ_a.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/circ_b.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/circ_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/closure_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/deco_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/deref_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/eq_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/float_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/flow_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/for_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/func_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/new_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/oop_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/simple_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/string_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/struct_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/test_main.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseA-pre pass=1 file=TransPyV/Test/App/vtable_test.py
[DBG] PhaseA-pre pass=1 done struct_count_after=51
├ INFO[PhaseA]: 预注册完成
[DBG] PhaseA full-translate start
[DBG] PhaseA file=TransPyV/Test/App/asm_test.py
[DBG] PhaseA file=TransPyV/Test/App/attr_test.py
[DBG] PhaseA file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseA file=TransPyV/Test/App/circ_a.py
[DBG] PhaseA file=TransPyV/Test/App/circ_b.py
[DBG] PhaseA file=TransPyV/Test/App/circ_test.py
[DBG] PhaseA file=TransPyV/Test/App/closure_test.py
[DBG] PhaseA file=TransPyV/Test/App/deco_test.py
[DBG] PhaseA file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseA file=TransPyV/Test/App/deref_test.py
[DBG] PhaseA file=TransPyV/Test/App/eq_test.py
[DBG] PhaseA file=TransPyV/Test/App/float_test.py
[DBG] PhaseA file=TransPyV/Test/App/flow_test.py
[DBG] PhaseA file=TransPyV/Test/App/for_test.py
[DBG] PhaseA file=TransPyV/Test/App/func_test.py
[DBG] PhaseA file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseA file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseA file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseA file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseA file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseA file=TransPyV/Test/App/new_test.py
[DBG] PhaseA file=TransPyV/Test/App/oop_test.py
[DBG] PhaseA file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseA file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseA file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseA file=TransPyV/Test/App/simple_test.py
[DBG] PhaseA file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseA file=TransPyV/Test/App/string_test.py
[DBG] PhaseA file=TransPyV/Test/App/struct_test.py
[DBG] PhaseA file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseA file=TransPyV/Test/App/test_main.py
[DBG] PhaseA file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseA file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseA file=TransPyV/Test/App/vtable_test.py
[DBG] before Phase B
=== Phase B: 编译 .obj ===
[DBG] PhaseB file=TransPyV/Test/App/asm_test.py
[DBG] PhaseB file=TransPyV/Test/App/attr_test.py
[DBG] PhaseB file=TransPyV/Test/App/augassign_test.py
[DBG] PhaseB file=TransPyV/Test/App/circ_a.py
[DBG] PhaseB file=TransPyV/Test/App/circ_b.py
[DBG] PhaseB file=TransPyV/Test/App/circ_test.py
[DBG] PhaseB file=TransPyV/Test/App/closure_test.py
[DBG] PhaseB file=TransPyV/Test/App/deco_test.py
[DBG] PhaseB file=TransPyV/Test/App/deref_min_test.py
[DBG] PhaseB file=TransPyV/Test/App/deref_test.py
[DBG] PhaseB file=TransPyV/Test/App/eq_test.py
[DBG] PhaseB file=TransPyV/Test/App/float_test.py
[DBG] PhaseB file=TransPyV/Test/App/flow_test.py
[DBG] PhaseB file=TransPyV/Test/App/for_test.py
[DBG] PhaseB file=TransPyV/Test/App/func_test.py
[DBG] PhaseB file=TransPyV/Test/App/func_vtable_test.py
[DBG] PhaseB file=TransPyV/Test/App/inherit_test.py
[DBG] PhaseB file=TransPyV/Test/App/llvmir_test.py
[DBG] PhaseB file=TransPyV/Test/App/namespace_defs.py
[DBG] PhaseB file=TransPyV/Test/App/namespace_test.py
[DBG] PhaseB file=TransPyV/Test/App/new_test.py
[DBG] PhaseB file=TransPyV/Test/App/oop_test.py
[DBG] PhaseB file=TransPyV/Test/App/opovl_test.py
[DBG] PhaseB file=TransPyV/Test/App/ptr_only_test.py
[DBG] PhaseB file=TransPyV/Test/App/ptr_test.py
[DBG] PhaseB file=TransPyV/Test/App/simple_test.py
[DBG] PhaseB file=TransPyV/Test/App/string_min_test.py
[DBG] PhaseB file=TransPyV/Test/App/string_test.py
[DBG] PhaseB file=TransPyV/Test/App/struct_test.py
[DBG] PhaseB file=TransPyV/Test/App/testcheck_test.py
[DBG] PhaseB file=TransPyV/Test/App/test_main.py
[DBG] PhaseB file=TransPyV/Test/App/type_bit_test.py
[DBG] PhaseB file=TransPyV/Test/App/virtual_dispatch_test.py
[DBG] PhaseB file=TransPyV/Test/App/vtable_test.py