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

Some simple information syncing

Browse Source
This commit is contained in:
TermiNexus
2026-07-28 21:08:58 +08:00
parent 1837339f69
commit 3633be1995
65 changed files with 1132 additions and 368581 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

91
TransPyV/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,17 +3062,21 @@ def _translate_method(trans: HT.Translator | t.CPtr,
return 0
# 提取默认参数信息（方法的 args[0] 是 self，不含在 param_count 中）
md_defaults: list[ast.AST | t.CPtr] | t.CPtr = None
# 注意: 必须先把属性赋给显式类型为 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
md_args_node: ast.Arguments | t.CPtr = fd.args
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
TransPyV/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
TransPyV/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)

24
TransPyV/App/lib/core/Handles/HandlesFunctions.py
View File

@@ -353,17 +353,21 @@ 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: list[ast.AST | t.CPtr] | t.CPtr = None
fd_defaults: t.CVoid | t.CPtr = None
fd_default_count: int = 0
fd_param_count: int = 0
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
@@ -552,16 +556,18 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
llvmlite.function_set_attrs(func, func_attrs)
# 提取默认参数信息
tfd_defaults: list[ast.AST | t.CPtr] | t.CPtr = None
tfd_defaults: t.CVoid | t.CPtr = None
tfd_default_count: int = 0
tfd_param_count: int = 0
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
TransPyV/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
TransPyV/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
TransPyV/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
TransPyV/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: