1067 lines
57 KiB
Python
1067 lines
57 KiB
Python
from __future__ import annotations
|
||
from typing import TYPE_CHECKING
|
||
if TYPE_CHECKING:
|
||
from lib.core.translator import Translator
|
||
from lib.core.Translator.LlvmGenerator import LlvmGeneratorMixin
|
||
import ast
|
||
import copy
|
||
import llvmlite.ir as ir
|
||
from lib.core.Exportable import EnumMember as ExportEnumMember
|
||
from lib.core.Handles.HandlesBase import BaseHandle, CTypeInfo, FuncMeta
|
||
from lib.core.SymbolUtils import IsTModule, FindStructNameInAnnotation
|
||
from lib.core.VLogger import get_logger as _vlog
|
||
from lib.constants.config import mode as _config_mode
|
||
from lib.includes import t
|
||
from lib.includes.t import CTypeRegistry
|
||
|
||
|
||
class ClassHandle(BaseHandle):
|
||
def _is_exception_class(self, Node: ast.ClassDef) -> bool:
|
||
if not Node.bases:
|
||
return False
|
||
for base in Node.bases:
|
||
if hasattr(base, 'id'):
|
||
if base.id == 'Exception':
|
||
return True
|
||
if base.id in self.Trans.exception_registry:
|
||
return True
|
||
elif hasattr(base, 'attr'):
|
||
if base.attr == 'Exception':
|
||
return True
|
||
if base.attr in self.Trans.exception_registry:
|
||
return True
|
||
return False
|
||
|
||
def _get_exception_parent(self, Node: ast.ClassDef) -> str | None:
|
||
if not Node.bases:
|
||
return None
|
||
for base in Node.bases:
|
||
if hasattr(base, 'id'):
|
||
if base.id != 'Exception' and base.id in self.Trans.exception_registry:
|
||
return base.id
|
||
elif hasattr(base, 'attr'):
|
||
if base.attr != 'Exception' and base.attr in self.Trans.exception_registry:
|
||
return base.attr
|
||
return None
|
||
|
||
def _RegisterExceptionClass(self, Node: ast.ClassDef) -> None:
|
||
ClassName: str = Node.name
|
||
if ClassName in self.Trans.exception_registry:
|
||
return
|
||
code: int = self.Trans._next_exception_code
|
||
self.Trans._next_exception_code += 1
|
||
self.Trans.exception_registry[ClassName] = code
|
||
parent: str | None = self._get_exception_parent(Node)
|
||
if parent:
|
||
self.Trans.exception_parents[ClassName] = parent
|
||
ExcTypeInfo: CTypeInfo = CTypeInfo()
|
||
ExcTypeInfo.Name = ClassName
|
||
ExcTypeInfo.IsExceptionClass = True
|
||
ExcTypeInfo.value = code
|
||
self.Trans.SymbolTable.insert(ClassName, ExcTypeInfo)
|
||
|
||
def _is_generic_class(self, Node: ast.ClassDef) -> bool:
|
||
if hasattr(Node, 'type_params') and Node.type_params:
|
||
return True
|
||
return False
|
||
|
||
def _mangle_generic_class_name(self, class_name: str, type_args: list[str]) -> str:
|
||
mangled_args: list[str] = []
|
||
for ta in type_args:
|
||
llvm_str: str | None = CTypeRegistry.NameToLLVM(ta)
|
||
if llvm_str:
|
||
if llvm_str in ('float', 'double', 'half', 'fp128'):
|
||
mangled: str = 'f' + str(CTypeRegistry.GetClassByName(ta)().Size)
|
||
else:
|
||
mangled = llvm_str
|
||
else:
|
||
mangled = ta
|
||
mangled_args.append(mangled)
|
||
return class_name + '[' + ']['.join(mangled_args) + ']'
|
||
|
||
def _specialize_generic_class(self, ClassName: str, type_args: list[str], Gen: LlvmGeneratorMixin, type_names: list[str] | None = None, declare_only: bool = False) -> str | None:
|
||
if not hasattr(self, '_generic_class_templates') or ClassName not in self._generic_class_templates:
|
||
return None
|
||
template: dict = self._generic_class_templates[ClassName]
|
||
Node: ast.ClassDef = template['node']
|
||
type_param_names: list[str] = template['type_params']
|
||
if len(type_args) != len(type_param_names):
|
||
return None
|
||
spec_key: str = ClassName + '<' + ','.join(type_args) + '>'
|
||
if not hasattr(self, '_generic_class_specializations'):
|
||
self._generic_class_specializations = {}
|
||
if spec_key in self._generic_class_specializations:
|
||
return self._generic_class_specializations[spec_key]
|
||
spec_name: str = self._mangle_generic_class_name(ClassName, type_args)
|
||
type_map: dict[str, str] = {}
|
||
for i, tp_name in enumerate(type_param_names):
|
||
if type_names and i < len(type_names):
|
||
type_map[tp_name] = type_names[i]
|
||
else:
|
||
type_map[tp_name] = type_args[i]
|
||
if type_names:
|
||
if not hasattr(self.Trans, '_t_c_imported_names'):
|
||
self.Trans._t_c_imported_names = {}
|
||
for tn in type_names:
|
||
if tn not in self.Trans._t_c_imported_names:
|
||
self.Trans._t_c_imported_names[tn] = ('t', tn)
|
||
SpecNode: ast.ClassDef = copy.deepcopy(Node)
|
||
SpecNode.type_params = []
|
||
SpecNode.name = spec_name
|
||
for item in SpecNode.body:
|
||
if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
|
||
if item.annotation:
|
||
item.annotation = self.Trans.FunctionHandler._replace_type_in_annotation(item.annotation, type_map)
|
||
elif isinstance(item, ast.FunctionDef):
|
||
for arg in item.args.args:
|
||
if arg.annotation:
|
||
arg.annotation = self.Trans.FunctionHandler._replace_type_in_annotation(arg.annotation, type_map)
|
||
if item.returns:
|
||
item.returns = self.Trans.FunctionHandler._replace_type_in_annotation(item.returns, type_map)
|
||
self.Trans.FunctionHandler._apply_type_map_to_body(item.body, type_map)
|
||
saved_builder: ir.IRBuilder = Gen.builder
|
||
saved_func: ir.Function = Gen.func
|
||
saved_variables: dict = dict(Gen.variables) if Gen.variables else {}
|
||
saved_direct_values: dict = dict(Gen._direct_values) if Gen._direct_values else {}
|
||
saved_var_type_info: dict = dict(Gen.var_type_info) if Gen.var_type_info else {}
|
||
saved_var_signedness: dict = dict(Gen.var_signedness) if Gen.var_signedness else {}
|
||
saved_global_vars: set = set(Gen.global_vars) if Gen.global_vars else set()
|
||
saved_var_scopes: list = [dict(s) for s in self.Trans.VarScopes] if self.Trans.VarScopes else []
|
||
saved_block: ir.Block | None = None
|
||
if Gen.builder and Gen.builder.block and not Gen.builder.block.is_terminated:
|
||
saved_block = Gen.builder.block
|
||
self._EmitClassLlvm(SpecNode, Gen, declare_only=declare_only)
|
||
Gen.builder = saved_builder
|
||
if saved_block is not None and Gen.builder is not None:
|
||
Gen.builder.position_at_end(saved_block)
|
||
Gen.func = saved_func
|
||
Gen.variables = saved_variables
|
||
Gen._direct_values = saved_direct_values
|
||
Gen.var_type_info = saved_var_type_info
|
||
Gen.var_signedness = saved_var_signedness
|
||
Gen.global_vars = saved_global_vars
|
||
self.Trans.VarScopes = saved_var_scopes
|
||
self._generic_class_specializations[spec_key] = spec_name
|
||
if not hasattr(self.Trans, '_generic_class_specializations'):
|
||
self.Trans._generic_class_specializations = {}
|
||
self.Trans._generic_class_specializations[spec_key] = spec_name
|
||
if hasattr(self.Trans, '_module_sha1') and self.Trans._module_sha1:
|
||
Gen._struct_sha1_map[spec_name] = self.Trans._module_sha1
|
||
return spec_name
|
||
|
||
def _resolve_base_kind(self, base_name: str, Gen: LlvmGeneratorMixin) -> str | None:
|
||
"""解析基类名称的类型种类
|
||
|
||
查询顺序：
|
||
1. _t_type_symbols（from t import CEnum as en）
|
||
2. t 模块属性（t.CEnum / t.CUnion / t.CStruct / t.REnum）
|
||
3. 返回 None 表示不是已知标记基类
|
||
|
||
Returns:
|
||
'enum' | 'union' | 'renum' | 'struct' | None
|
||
"""
|
||
# 1) 查 _t_type_symbols（别名导入）
|
||
symtab: object = self.Trans.SymbolTable
|
||
cls: type | None = symtab._t_type_symbols.get(base_name)
|
||
if cls is not None:
|
||
if issubclass(cls, (t.CEnum, t.REnum)):
|
||
return 'renum' if issubclass(cls, t.REnum) else 'enum'
|
||
if issubclass(cls, t.CUnion):
|
||
return 'union'
|
||
if issubclass(cls, t.CStruct):
|
||
return 'struct'
|
||
|
||
# 2) 查 t 模块属性（直接引用 t.CEnum 等）
|
||
t_cls: type | None = getattr(t, base_name, None)
|
||
if isinstance(t_cls, type) and issubclass(t_cls, t.CType):
|
||
if issubclass(t_cls, (t.CEnum, t.REnum)):
|
||
return 'renum' if issubclass(t_cls, t.REnum) else 'enum'
|
||
if issubclass(t_cls, t.CUnion):
|
||
return 'union'
|
||
if issubclass(t_cls, t.CStruct):
|
||
return 'struct'
|
||
|
||
return None
|
||
|
||
def _resolve_decorator_kind(self, Node: ast.ClassDef, Gen: LlvmGeneratorMixin) -> str | None:
|
||
"""从装饰器列表中解析结构体类型种类
|
||
|
||
支持 @t.CStruct, @t.CUnion, @t.CEnum, @t.REnum
|
||
也支持 from t import CStruct 等别名形式
|
||
|
||
Returns:
|
||
'enum' | 'union' | 'renum' | 'struct' | None
|
||
"""
|
||
if not hasattr(Node, 'decorator_list') or not Node.decorator_list:
|
||
return None
|
||
symtab: object = self.Trans.SymbolTable
|
||
for decorator in Node.decorator_list:
|
||
attr_name: str | None = None
|
||
# @t.CStruct 形式
|
||
if isinstance(decorator, ast.Attribute) and isinstance(decorator.value, ast.Name):
|
||
if IsTModule(decorator.value.id, symtab):
|
||
attr_name = decorator.attr
|
||
# @CStruct 形式 (from t import CStruct)
|
||
elif isinstance(decorator, ast.Name):
|
||
cls: type | None = getattr(t, decorator.id, None)
|
||
if cls is None and hasattr(symtab, '_t_type_symbols'):
|
||
cls = symtab._t_type_symbols.get(decorator.id)
|
||
if cls is not None and isinstance(cls, type) and issubclass(cls, t.CType):
|
||
attr_name = cls.__name__
|
||
if attr_name:
|
||
# 查 _t_type_symbols 和 t 模块属性以确定种类
|
||
resolved_cls: type | None = None
|
||
if hasattr(symtab, '_t_type_symbols'):
|
||
resolved_cls = symtab._t_type_symbols.get(attr_name)
|
||
if resolved_cls is None:
|
||
resolved_cls = getattr(t, attr_name, None)
|
||
if resolved_cls is not None and isinstance(resolved_cls, type):
|
||
if issubclass(resolved_cls, t.REnum):
|
||
return 'renum'
|
||
if issubclass(resolved_cls, t.CEnum):
|
||
return 'enum'
|
||
if issubclass(resolved_cls, t.CUnion):
|
||
return 'union'
|
||
if issubclass(resolved_cls, t.CStruct):
|
||
return 'struct'
|
||
return None
|
||
|
||
def _resolve_class_flags(self, Node: ast.ClassDef, Gen: LlvmGeneratorMixin) -> tuple[bool, bool, str | None]:
|
||
"""解析类的 Object/CVTable 标志和父类信息
|
||
|
||
Returns:
|
||
tuple: (IsCpythonObject, IsCVTable, ParentClassName)
|
||
"""
|
||
ClassName: str = Node.name
|
||
IsCpythonObject: bool = False
|
||
IsCVTable: bool = False
|
||
if hasattr(Node, 'decorator_list') and Node.decorator_list:
|
||
for decorator in Node.decorator_list:
|
||
if isinstance(decorator, ast.Attribute):
|
||
if hasattr(decorator.value, 'id') and IsTModule(decorator.value.id, self.Trans.SymbolTable):
|
||
if decorator.attr == 'Object':
|
||
IsCpythonObject = True
|
||
elif decorator.attr == 'CVTable':
|
||
IsCVTable = True
|
||
elif isinstance(decorator, ast.Name):
|
||
if decorator.id == 'Object':
|
||
IsCpythonObject = True
|
||
elif decorator.id == 'CVTable':
|
||
IsCVTable = True
|
||
elif isinstance(decorator, ast.Call):
|
||
# 检测 @c.Attribute(t.attr.packed)
|
||
if isinstance(decorator.func, ast.Attribute):
|
||
if getattr(decorator.func.value, 'id', None) == 'c' and decorator.func.attr == 'Attribute':
|
||
for arg in decorator.args:
|
||
if isinstance(arg, ast.Attribute):
|
||
if isinstance(arg.value, ast.Attribute):
|
||
if IsTModule(getattr(arg.value.value, 'id', ''), self.Trans.SymbolTable) and arg.value.attr == 'attr' and arg.attr == 'packed':
|
||
Gen.class_packed.add(ClassName)
|
||
class_graph: dict = getattr(Gen, '_class_graph', {})
|
||
if class_graph.get(ClassName, {}).get('has_methods', False):
|
||
if not IsCpythonObject:
|
||
IsCpythonObject = True
|
||
# 仅当该类作为其他类的基类时，才启用 CVTable
|
||
# 检查 _class_graph 中是否有任何类将此类作为基类
|
||
is_base_of_any: bool = False
|
||
for other_cls, info in class_graph.items():
|
||
if ClassName in info.get('bases', []):
|
||
is_base_of_any = True
|
||
break
|
||
if is_base_of_any:
|
||
IsCVTable = True
|
||
HasParentClass: bool = False
|
||
ParentClassName: str | None = None
|
||
if Node.bases:
|
||
for base in Node.bases:
|
||
base_name: str | None = None
|
||
if hasattr(base, 'id'):
|
||
base_name = base.id
|
||
elif hasattr(base, 'attr'):
|
||
base_name = base.attr
|
||
if base_name:
|
||
kind: str | None = self._resolve_base_kind(base_name, Gen)
|
||
if kind is not None or base_name in t._MARKER_BASES:
|
||
continue # 标记基类，跳过
|
||
if base_name in class_graph or base_name in Gen.class_members or base_name in Gen.structs:
|
||
HasParentClass = True
|
||
ParentClassName = base_name
|
||
break
|
||
if HasParentClass and not IsCVTable:
|
||
IsCVTable = True
|
||
if IsCVTable:
|
||
Gen.class_vtable.add(ClassName)
|
||
# 沿继承链向上传播，将所有祖先类加入 vtable
|
||
visited: set[str] = {ClassName}
|
||
ancestor: str | None = ParentClassName
|
||
while ancestor and ancestor not in visited:
|
||
visited.add(ancestor)
|
||
Gen.class_vtable.add(ancestor)
|
||
# 查询祖先类的父类
|
||
ancestor_info: dict | None = class_graph.get(ancestor)
|
||
if ancestor_info:
|
||
ancestor_bases: list = ancestor_info.get('bases', [])
|
||
next_ancestor: str | None = None
|
||
for ab in ancestor_bases:
|
||
if ab not in t._MARKER_BASES and ab not in visited:
|
||
next_ancestor = ab
|
||
break
|
||
ancestor = next_ancestor
|
||
else:
|
||
# 类图中没有，尝试从 class_parent 查询
|
||
ancestor = Gen.class_parent.get(ancestor)
|
||
return IsCpythonObject, IsCVTable, ParentClassName
|
||
|
||
def _EmitClassLlvm(self, Node: ast.ClassDef, Gen: LlvmGeneratorMixin, declare_only: bool = False) -> None:
|
||
ClassName: str = Node.name
|
||
if self._is_generic_class(Node):
|
||
if not hasattr(self, '_generic_class_templates'):
|
||
self._generic_class_templates = {}
|
||
type_params: list[str] = [tp.name for tp in Node.type_params]
|
||
self._generic_class_templates[ClassName] = {
|
||
'node': Node,
|
||
'type_params': type_params,
|
||
}
|
||
return
|
||
if self._is_exception_class(Node):
|
||
self._RegisterExceptionClass(Node)
|
||
return
|
||
IsCenum: bool = False
|
||
IsCunion: bool = False
|
||
IsRenum: bool = False
|
||
# 先检查装饰器形式（@t.CStruct / @t.CEnum / @t.CUnion / @t.REnum）
|
||
deco_kind: str | None = self._resolve_decorator_kind(Node, Gen)
|
||
if deco_kind == 'enum':
|
||
IsCenum = True
|
||
elif deco_kind == 'union':
|
||
IsCunion = True
|
||
elif deco_kind == 'renum':
|
||
IsRenum = True
|
||
# 再检查基类继承形式（class X(t.CStruct):），与装饰器合并
|
||
if not IsCenum and not IsCunion and not IsRenum and Node.bases:
|
||
for base in Node.bases:
|
||
base_name: str | None = None
|
||
if hasattr(base, 'attr'):
|
||
base_name = base.attr
|
||
elif hasattr(base, 'id'):
|
||
base_name = base.id
|
||
if base_name:
|
||
kind: str | None = self._resolve_base_kind(base_name, Gen)
|
||
if kind == 'enum':
|
||
IsCenum = True
|
||
break
|
||
elif kind == 'union':
|
||
IsCunion = True
|
||
elif kind == 'renum':
|
||
IsRenum = True
|
||
if IsCenum:
|
||
self._RegisterEnumMembers(Node)
|
||
return
|
||
if IsCunion:
|
||
self._EmitUnionLlvm(Node, Gen)
|
||
return
|
||
if IsRenum:
|
||
self._EmitREnumLlvm(Node, Gen)
|
||
return
|
||
IsCpythonObject: bool
|
||
IsCVTable: bool
|
||
ParentClassName: str | None
|
||
IsCpythonObject, IsCVTable, ParentClassName = self._resolve_class_flags(Node, Gen)
|
||
if ClassName not in Gen.class_methods:
|
||
Gen.class_methods[ClassName] = []
|
||
# 当前文件定义的类是权威定义，覆盖之前导入阶段可能添加的外部声明
|
||
Gen.class_members[ClassName] = []
|
||
Gen.class_member_defaults[ClassName] = {}
|
||
Gen.class_member_signeds[ClassName] = {}
|
||
Gen.class_member_bitfields[ClassName] = {}
|
||
Gen.class_member_byteorders[ClassName] = {}
|
||
Gen.class_member_bitoffsets[ClassName] = {}
|
||
ParentClass: str | None = None
|
||
if Node.bases:
|
||
class_graph: dict = getattr(Gen, '_class_graph', {})
|
||
for base in Node.bases:
|
||
if hasattr(base, 'id'):
|
||
base_name = base.id
|
||
elif hasattr(base, 'attr'):
|
||
base_name = base.attr
|
||
else:
|
||
continue
|
||
if base_name == ClassName:
|
||
continue
|
||
if base_name in class_graph or base_name in Gen.class_members:
|
||
ParentClass = base_name
|
||
break
|
||
if ParentClass:
|
||
Gen.class_parent[ClassName] = ParentClass
|
||
if ParentClass:
|
||
parent_members: list = list(Gen.class_members[ParentClass])
|
||
parent_defaults: dict = dict(Gen.class_member_defaults.get(ParentClass, {}))
|
||
existing_names: set = {m[0] for m in Gen.class_members[ClassName]}
|
||
inherited: list[tuple] = []
|
||
for pm_name, pm_type in parent_members:
|
||
if pm_name not in existing_names:
|
||
inherited.append((pm_name, pm_type))
|
||
if pm_name in parent_defaults:
|
||
Gen.class_member_defaults[ClassName][pm_name] = parent_defaults[pm_name]
|
||
Gen.class_members[ClassName] = inherited + Gen.class_members[ClassName]
|
||
if ParentClass in Gen.class_methods:
|
||
parent_methods: list = list(Gen.class_methods[ParentClass])
|
||
for pm in parent_methods:
|
||
method_name: str = pm.split('.')[-1] if '.' in pm else pm
|
||
child_method: str = f"{ClassName}.{method_name}"
|
||
if child_method not in Gen.class_methods[ClassName]:
|
||
Gen.class_methods[ClassName].append(child_method)
|
||
Gen.register_method(ClassName, child_method)
|
||
# 解析 __provides__/__requires__/__require_must__ 编译期元数据
|
||
for item in Node.body:
|
||
if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
|
||
field_name: str = item.target.id
|
||
if field_name in ('__provides__', '__requires__', '__require_must__') and item.value:
|
||
values: list[str] = []
|
||
if isinstance(item.value, ast.List):
|
||
for elt in item.value.elts:
|
||
if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
|
||
values.append(elt.value)
|
||
if field_name == '__provides__':
|
||
Gen.class_provides[ClassName] = values
|
||
elif field_name == '__requires__':
|
||
Gen.class_requires[ClassName] = values
|
||
elif field_name == '__require_must__':
|
||
Gen.class_require_must[ClassName] = values
|
||
for item in Node.body:
|
||
# 跳过编译期元数据字段（__provides__/__requires__/__require_must__）
|
||
if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
|
||
if item.target.id in ('__provides__', '__requires__', '__require_must__'):
|
||
continue
|
||
parsed = self.CollectAnnAssignMember(item, Gen)
|
||
if parsed:
|
||
VarName, MemberType, TypeInfo = parsed
|
||
Gen.class_members[ClassName].append((VarName, MemberType))
|
||
if TypeInfo:
|
||
if isinstance(MemberType, ir.PointerType) and isinstance(MemberType.pointee, ir.IntType) and MemberType.pointee.width == 8:
|
||
if isinstance(item.annotation, ast.BinOp) and isinstance(item.annotation.op, ast.BitOr):
|
||
element_class: str | None = FindStructNameInAnnotation(item.annotation, Gen.structs)
|
||
if element_class:
|
||
if ClassName not in Gen.class_member_element_class:
|
||
Gen.class_member_element_class[ClassName] = {}
|
||
Gen.class_member_element_class[ClassName][VarName] = element_class
|
||
if hasattr(TypeInfo.BaseType, 'IsSigned'):
|
||
Gen.class_member_signeds[ClassName][VarName] = TypeInfo.BaseType.IsSigned
|
||
else:
|
||
Gen.class_member_signeds[ClassName][VarName] = None
|
||
if TypeInfo.IsBitField:
|
||
Gen.class_member_bitfields[ClassName][VarName] = TypeInfo.BitWidth
|
||
else:
|
||
Gen.class_member_bitfields[ClassName][VarName] = 0
|
||
if TypeInfo.ByteOrder:
|
||
Gen.class_member_byteorders[ClassName][VarName] = TypeInfo.ByteOrder
|
||
else:
|
||
Gen.class_member_byteorders[ClassName][VarName] = ""
|
||
if item.value:
|
||
const: ir.Constant | None = self._BuildScalarConstant(item.value, MemberType, Gen)
|
||
if const:
|
||
Gen.class_member_defaults[ClassName][VarName] = const
|
||
else:
|
||
Gen.class_member_signeds[ClassName][VarName] = None
|
||
Gen.class_member_bitfields[ClassName][VarName] = 0
|
||
existing_members: set[str] = {m[0] for m in Gen.class_members[ClassName]}
|
||
for item in Node.body:
|
||
if isinstance(item, ast.FunctionDef):
|
||
self._current_method_args = {}
|
||
for arg in item.args.args:
|
||
if arg.arg != 'self' and arg.annotation:
|
||
self._current_method_args[arg.arg] = arg.annotation
|
||
self._scan_method_body_for_self_members(item.body, ClassName, existing_members, Gen)
|
||
self._current_method_args = {}
|
||
for item in Node.body:
|
||
if isinstance(item, ast.FunctionDef):
|
||
MethodName: str = item.name
|
||
FullMethodName: str = f"{ClassName}.{MethodName}"
|
||
# property setter/deleter 使用不同的函数名后缀
|
||
item_meta: FuncMeta = self.Trans.FunctionHandler._ExtractFuncMeta(item.decorator_list)
|
||
if FuncMeta.PROPERTY_SETTER in item_meta:
|
||
FullMethodName = FullMethodName + '$set'
|
||
elif FuncMeta.PROPERTY_DELETER in item_meta:
|
||
FullMethodName = FullMethodName + '$del'
|
||
if FullMethodName not in Gen.class_methods[ClassName]:
|
||
Gen.class_methods[ClassName].append(FullMethodName)
|
||
Gen.register_method(ClassName, FullMethodName)
|
||
if IsCVTable:
|
||
Gen.class_vtable.add(ClassName)
|
||
Gen._generate_structs()
|
||
Gen._create_Vtable_globals()
|
||
if (IsCpythonObject or IsCVTable) and ClassName in Gen.structs:
|
||
self._EmitNewFunctionLlvm(ClassName, Gen, IsCVTable=IsCVTable, IsCpythonObject=IsCpythonObject)
|
||
for item in Node.body:
|
||
if isinstance(item, ast.FunctionDef):
|
||
self.Trans.FunctionHandler._EmitFunctionForwardDeclLlvm(item, Gen, ClassName=ClassName)
|
||
if not declare_only:
|
||
for item in Node.body:
|
||
if isinstance(item, ast.FunctionDef):
|
||
self.Trans.FunctionHandler._EmitFunctionLlvm(item, Gen, ClassName=ClassName)
|
||
if IsCVTable and ClassName in Gen.Vtables:
|
||
self._fill_vtable_with_methods(ClassName, Gen)
|
||
# Generate wrapper functions for inherited methods that are not overridden
|
||
if ParentClass:
|
||
self._generate_inherited_method_wrappers(ClassName, Gen)
|
||
|
||
def _generate_inherited_method_wrappers(self, ClassName: str, Gen: LlvmGeneratorMixin) -> None:
|
||
"""为子类继承但未覆写的方法生成包装函数，使跨模块调用能正确链接。
|
||
|
||
例如 Label 继承 Widget.place，生成 Label.place 函数，
|
||
内部将 self 从 Label* bitcast 为 Widget*，然后调用 Widget.place。
|
||
"""
|
||
methods: list = Gen.class_methods.get(ClassName, [])
|
||
if not methods:
|
||
return
|
||
if ClassName not in Gen.structs:
|
||
return
|
||
|
||
for method_name in methods:
|
||
method_short: str = method_name.split('.')[-1] if '.' in method_name else method_name
|
||
child_full: str = f"{ClassName}.{method_short}"
|
||
|
||
# 如果子类已经有该方法的实现，跳过
|
||
if Gen._find_function(child_full):
|
||
continue
|
||
|
||
# 沿继承链查找父类实现
|
||
parent_func: ir.Function | None = None
|
||
parent_class: str | None = None
|
||
p: str | None = Gen.class_parent.get(ClassName)
|
||
while p:
|
||
parent_full: str = f"{p}.{method_short}"
|
||
parent_func = Gen._find_function(parent_full)
|
||
if parent_func:
|
||
parent_class = p
|
||
break
|
||
p = Gen.class_parent.get(p)
|
||
|
||
if not parent_func or not parent_class:
|
||
continue
|
||
|
||
# 父类和子类都需要有 struct 定义
|
||
if parent_class not in Gen.structs:
|
||
continue
|
||
|
||
# 构造子类包装函数签名：与父类函数相同，但 self 参数类型为子类指针
|
||
parent_ftype: ir.FunctionType = parent_func.function_type
|
||
parent_ret_type: ir.Type = parent_ftype.return_type
|
||
parent_param_types: list[ir.Type] = list(parent_ftype.args)
|
||
is_vararg: bool = parent_ftype.var_arg
|
||
|
||
# 判断父类方法是否是静态方法：
|
||
# 如果第一个参数类型是父类指针，说明是实例方法；否则是静态方法
|
||
parent_struct_ptr_type: ir.PointerType | None = ir.PointerType(Gen.structs[parent_class]) if parent_class in Gen.structs else None
|
||
is_static: bool = True
|
||
if parent_param_types and parent_struct_ptr_type:
|
||
first_param: ir.Type = parent_param_types[0]
|
||
# 检查第一个参数是否是父类指针（或可以 bitcast 为父类指针的指针类型）
|
||
if isinstance(first_param, ir.PointerType):
|
||
if isinstance(first_param.pointee, ir.IdentifiedStructType):
|
||
if first_param.pointee.name == Gen.structs[parent_class].name:
|
||
is_static = False
|
||
elif first_param == ir.IntType(8):
|
||
# i8* 可能是前向声明时的 self 类型，视为实例方法
|
||
is_static = False
|
||
|
||
if is_static:
|
||
# 静态方法：签名与父类完全一致，不需要 self 参数
|
||
child_param_types: list[ir.Type] = list(parent_param_types)
|
||
child_struct_ptr: ir.PointerType | None = None
|
||
else:
|
||
# 实例方法：替换第一个参数（self）的类型为子类指针
|
||
child_struct_ptr = ir.PointerType(Gen.structs[ClassName])
|
||
if parent_param_types:
|
||
child_param_types = [child_struct_ptr] + parent_param_types[1:]
|
||
else:
|
||
child_param_types = [child_struct_ptr]
|
||
|
||
child_func_type: ir.FunctionType = ir.FunctionType(parent_ret_type, child_param_types, var_arg=is_vararg)
|
||
child_mangled: str = Gen._mangle_func_name(child_full)
|
||
child_func: ir.Function = Gen._get_or_declare_function(child_mangled, child_func_type)
|
||
Gen.functions[child_full] = child_func
|
||
|
||
# 生成函数体
|
||
entry_block: ir.Block = child_func.append_basic_block(name="entry")
|
||
saved_builder: ir.IRBuilder = Gen.builder
|
||
saved_func: ir.Function = Gen.func
|
||
Gen.builder = ir.IRBuilder(entry_block)
|
||
Gen.func = child_func
|
||
|
||
# 准备参数
|
||
call_args: list[ir.Value] = []
|
||
if is_static:
|
||
# 静态方法：参数直接传递，不做 bitcast
|
||
for arg in child_func.args:
|
||
call_args.append(arg)
|
||
else:
|
||
# 实例方法：bitcast self，其余参数直接传递
|
||
for i, arg in enumerate(child_func.args):
|
||
if i == 0 and parent_param_types:
|
||
actual_self_type: ir.Type = parent_param_types[0]
|
||
casted_self: ir.Value = Gen.builder.bitcast(arg, actual_self_type, name="self_cast")
|
||
call_args.append(casted_self)
|
||
else:
|
||
call_args.append(arg)
|
||
|
||
result: ir.Value = Gen.builder.call(parent_func, call_args, name="inherited_call")
|
||
|
||
if isinstance(parent_ret_type, ir.VoidType):
|
||
Gen.builder.ret_void()
|
||
else:
|
||
Gen.builder.ret(result)
|
||
|
||
Gen.builder = saved_builder
|
||
Gen.func = saved_func
|
||
|
||
def _fill_vtable_with_methods(self, ClassName: str, Gen: LlvmGeneratorMixin) -> None:
|
||
methods: list = Gen.class_methods.get(ClassName, [])
|
||
if not methods or ClassName not in Gen.Vtables:
|
||
return
|
||
Vtable: ir.GlobalVariable = Gen.Vtables[ClassName]
|
||
VtableType: ir.Type = Vtable.type.pointee
|
||
null_i8ptr: ir.Constant = ir.Constant(ir.PointerType(ir.IntType(8)), None)
|
||
initializers: list[ir.Constant] = []
|
||
for mi, method_name in enumerate(methods):
|
||
method_short: str = method_name.split('.')[-1] if '.' in method_name else method_name
|
||
func: ir.Function | None = Gen._find_function(f"{ClassName}.{method_short}")
|
||
if not func:
|
||
func = Gen._find_function(f"{ClassName}.{method_short}__")
|
||
if not func:
|
||
p: str | None = Gen.class_parent.get(ClassName)
|
||
while p:
|
||
func = Gen._find_function(f"{p}.{method_short}")
|
||
if not func:
|
||
func = Gen._find_function(f"{p}.{method_short}__")
|
||
if func:
|
||
break
|
||
p = Gen.class_parent.get(p)
|
||
if func:
|
||
initializers.append(func.bitcast(ir.PointerType(ir.IntType(8))))
|
||
else:
|
||
initializers.append(null_i8ptr)
|
||
if initializers:
|
||
Vtable.initializer = ir.Constant(VtableType, initializers)
|
||
|
||
def _scan_method_body_for_self_members(self, body: list[ast.AST], ClassName: str, existing_members: set[str], Gen: LlvmGeneratorMixin) -> None:
|
||
for stmt in body:
|
||
self._scan_node_for_self_assign(stmt, ClassName, existing_members, Gen)
|
||
|
||
def _scan_node_for_self_assign(self, node: ast.AST, ClassName: str, existing_members: set[str], Gen: LlvmGeneratorMixin) -> None:
|
||
if isinstance(node, ast.AnnAssign):
|
||
if (isinstance(node.target, ast.Attribute)
|
||
and isinstance(node.target.value, ast.Name)
|
||
and node.target.value.id == 'self'):
|
||
VarName: str = node.target.attr
|
||
if VarName not in existing_members:
|
||
try:
|
||
TypeInfo: CTypeInfo | None = CTypeInfo.FromNode(node.annotation, self.Trans.SymbolTable)
|
||
if TypeInfo is None:
|
||
TypeInfo = CTypeInfo()
|
||
TypeInfo.BaseType = t.CInt()
|
||
MemberType: ir.Type = Gen._ctype_to_llvm(TypeInfo)
|
||
if isinstance(MemberType, ir.VoidType):
|
||
MemberType = ir.IntType(32)
|
||
except Exception as e: # 回退：成员类型解析失败时使用默认 i32
|
||
_vlog().warning(f"HandlesClassDef: 忽略异常 {e}", exc_info=e)
|
||
MemberType = ir.IntType(32)
|
||
Gen.class_members[ClassName].append((VarName, MemberType))
|
||
Gen.class_member_signeds[ClassName][VarName] = None
|
||
Gen.class_member_bitfields[ClassName][VarName] = 0
|
||
Gen.class_member_byteorders[ClassName][VarName] = ""
|
||
Gen.class_member_bitoffsets[ClassName][VarName] = 0
|
||
existing_members.add(VarName)
|
||
len_name = f'{VarName}__len'
|
||
if isinstance(MemberType, ir.PointerType) and node.value and isinstance(node.value, ast.List):
|
||
if len_name not in existing_members:
|
||
Gen.class_members[ClassName].append((len_name, ir.IntType(64)))
|
||
Gen.class_member_signeds[ClassName][len_name] = None
|
||
Gen.class_member_bitfields[ClassName][len_name] = 0
|
||
Gen.class_member_byteorders[ClassName][len_name] = ""
|
||
Gen.class_member_bitoffsets[ClassName][len_name] = 0
|
||
Gen.class_member_defaults[ClassName][len_name] = ir.Constant(ir.IntType(64), len(node.value.elts))
|
||
existing_members.add(len_name)
|
||
elif isinstance(node, ast.Assign):
|
||
for target in node.targets:
|
||
if (isinstance(target, ast.Attribute)
|
||
and isinstance(target.value, ast.Name)
|
||
and target.value.id == 'self'):
|
||
VarName = target.attr
|
||
if VarName not in existing_members:
|
||
MemberType = ir.IntType(32)
|
||
if node.value:
|
||
try:
|
||
if isinstance(node.value, ast.Constant):
|
||
if isinstance(node.value.value, int):
|
||
MemberType = ir.IntType(32)
|
||
elif isinstance(node.value.value, float):
|
||
MemberType = ir.DoubleType()
|
||
elif isinstance(node.value.value, str):
|
||
MemberType = ir.PointerType(ir.IntType(8))
|
||
elif isinstance(node.value, ast.Name):
|
||
if hasattr(self, '_current_method_args'):
|
||
arg_info = self._current_method_args.get(node.value.id)
|
||
if arg_info:
|
||
TypeInfo = CTypeInfo.FromNode(arg_info, self.Trans.SymbolTable)
|
||
if TypeInfo:
|
||
InferredType = Gen._ctype_to_llvm(TypeInfo)
|
||
if not isinstance(InferredType, ir.VoidType):
|
||
MemberType = InferredType
|
||
elif isinstance(node.value, ast.Call):
|
||
if isinstance(node.value.func, ast.Name):
|
||
if node.value.func.id in ('float', 'double'):
|
||
MemberType = ir.DoubleType()
|
||
elif node.value.func.id in ('int', 'long', 'short', 'char'):
|
||
MemberType = ir.IntType(32)
|
||
elif isinstance(node.value.func, ast.Attribute):
|
||
if node.value.func.attr == 'len':
|
||
MemberType = ir.IntType(32)
|
||
except Exception as _e:
|
||
if _config_mode == "strict":
|
||
self.Trans.LogWarning(f"异常被忽略: {_e}")
|
||
Gen.class_members[ClassName].append((VarName, MemberType))
|
||
Gen.class_member_signeds[ClassName][VarName] = None
|
||
Gen.class_member_bitfields[ClassName][VarName] = 0
|
||
Gen.class_member_byteorders[ClassName][VarName] = ""
|
||
Gen.class_member_bitoffsets[ClassName][VarName] = 0
|
||
existing_members.add(VarName)
|
||
for child in ast.iter_child_nodes(node):
|
||
if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
|
||
continue
|
||
self._scan_node_for_self_assign(child, ClassName, existing_members, Gen)
|
||
|
||
def _EmitUnionLlvm(self, Node: ast.ClassDef, Gen: LlvmGeneratorMixin) -> None:
|
||
ClassName: str = Node.name
|
||
union_member_types: list[ir.Type] = []
|
||
for item in Node.body:
|
||
if isinstance(item, ast.ClassDef):
|
||
nested_class_name: str = item.name
|
||
nested_member_types: list[ir.Type] = []
|
||
for nested_item in item.body:
|
||
parsed = self.CollectAnnAssignMember(nested_item, Gen)
|
||
if parsed:
|
||
nested_member_types.append(parsed[1])
|
||
if nested_member_types:
|
||
nested_struct_type: ir.IdentifiedStructType = ir.IdentifiedStructType(Gen.module, f"{ClassName}_{nested_class_name}")
|
||
nested_struct_type.set_body(*nested_member_types)
|
||
Gen.structs[f"{ClassName}_{nested_class_name}"] = nested_struct_type
|
||
union_member_types.append(nested_struct_type)
|
||
nested_class_full_name: str = f"{ClassName}_{nested_class_name}"
|
||
if nested_class_full_name not in Gen.class_members:
|
||
Gen.class_members[nested_class_full_name] = []
|
||
if nested_class_full_name not in Gen.class_member_signeds:
|
||
Gen.class_member_signeds[nested_class_full_name] = {}
|
||
for nested_item in item.body:
|
||
parsed = self.CollectAnnAssignMember(nested_item, Gen)
|
||
if parsed:
|
||
VarName, MemberType, TypeInfo = parsed
|
||
Gen.class_members[nested_class_full_name].append((VarName, MemberType))
|
||
if TypeInfo and hasattr(TypeInfo.BaseType, 'IsSigned'):
|
||
Gen.class_member_signeds[nested_class_full_name][VarName] = TypeInfo.BaseType.IsSigned
|
||
else:
|
||
Gen.class_member_signeds[nested_class_full_name][VarName] = None
|
||
if union_member_types:
|
||
max_size: int = 0
|
||
for member_type in union_member_types:
|
||
try:
|
||
size: int = member_type.get_abi_size(ir.DataLayout(Gen.module.data_layout))
|
||
except Exception as e: # 回退：获取类型大小失败时使用默认值 8
|
||
_vlog().warning(f"HandlesClassDef: 忽略异常 {e}", exc_info=e)
|
||
size = 8
|
||
max_size = max(max_size, size)
|
||
union_type: ir.IdentifiedStructType = ir.IdentifiedStructType(Gen.module, ClassName)
|
||
union_type.set_body(ir.ArrayType(ir.IntType(8), max_size))
|
||
Gen.structs[ClassName] = union_type
|
||
UnionNode: CTypeInfo = CTypeInfo()
|
||
UnionNode.Name = ClassName
|
||
UnionNode.IsUnion = True
|
||
self.Trans.SymbolTable.insert(ClassName, UnionNode)
|
||
|
||
def _EmitREnumLlvm(self, Node: ast.ClassDef, Gen: LlvmGeneratorMixin) -> None:
|
||
ClassName: str = Node.name
|
||
variant_info: list[tuple] = []
|
||
variant_names: list[str] = []
|
||
|
||
# 第一遍：收集显式赋值的 tag 值，确定起始索引
|
||
explicit_values: dict[str, int] = {}
|
||
for item in Node.body:
|
||
if isinstance(item, ast.Assign):
|
||
for target in item.targets:
|
||
if isinstance(target, ast.Name):
|
||
if item.value and isinstance(item.value, ast.Constant):
|
||
explicit_values[target.id] = item.value.value
|
||
# 类变体从 max(explicit_values, default=-1) + 1 开始
|
||
next_class_tag: int = max(explicit_values.values()) + 1 if explicit_values else 0
|
||
variant_index: int = 0
|
||
|
||
for item in Node.body:
|
||
if isinstance(item, ast.ClassDef):
|
||
VariantName: str = item.name
|
||
variant_names.append(VariantName)
|
||
member_types: list[ir.Type] = []
|
||
member_names: list[str] = []
|
||
member_annotations: list[ast.AST | None] = []
|
||
for nested_item in item.body:
|
||
parsed = self.CollectAnnAssignMember(nested_item, Gen)
|
||
if parsed:
|
||
VarName, MemberType, TypeInfo = parsed
|
||
member_types.append(MemberType)
|
||
member_names.append(VarName)
|
||
member_annotations.append(nested_item.annotation if TypeInfo else None)
|
||
# 类变体使用专用计数器，避免与显式值冲突
|
||
tag: int = next_class_tag
|
||
next_class_tag += 1
|
||
variant_info.append((VariantName, member_types, member_names, member_annotations, item.lineno, tag))
|
||
elif isinstance(item, ast.Assign):
|
||
for target in item.targets:
|
||
if isinstance(target, ast.Name):
|
||
VarName = target.id
|
||
variant_names.append(VarName)
|
||
value: int | None = None
|
||
if item.value and isinstance(item.value, ast.Constant):
|
||
value = item.value.value
|
||
else:
|
||
value = variant_index
|
||
variant_index += 1
|
||
variant_info.append((VarName, [], [], [], item.lineno, value))
|
||
max_variant_struct: list[ir.Type] | None = None
|
||
max_variant_size: int = 0
|
||
for _, member_types, _, _, _, _ in variant_info:
|
||
if member_types:
|
||
full_types: list[ir.Type] = [ir.IntType(32)] + member_types
|
||
size: int = 4
|
||
for mt in full_types:
|
||
if isinstance(mt, ir.IntType):
|
||
size += mt.width // 8
|
||
elif isinstance(mt, ir.PointerType):
|
||
size += 8
|
||
elif isinstance(mt, ir.FloatType):
|
||
size += 4
|
||
elif isinstance(mt, ir.DoubleType):
|
||
size += 8
|
||
elif isinstance(mt, ir.ArrayType):
|
||
if isinstance(mt.element, ir.IntType):
|
||
size += mt.element.width // 8 * mt.count
|
||
else:
|
||
size += 8 * mt.count
|
||
else:
|
||
size += 8
|
||
if size > max_variant_size:
|
||
max_variant_size = size
|
||
max_variant_struct = full_types
|
||
if max_variant_struct is None:
|
||
max_variant_struct = [ir.IntType(32), ir.IntType(32)]
|
||
renum_type: ir.IdentifiedStructType = ir.IdentifiedStructType(Gen.module, ClassName)
|
||
renum_type.set_body(*max_variant_struct)
|
||
Gen.structs[ClassName] = renum_type
|
||
for VariantName, member_types, member_names, member_annotations, lineno, tag_value in variant_info:
|
||
NestedStructName: str = f"{ClassName}_{VariantName}"
|
||
if member_types:
|
||
padded_member_types: list[ir.Type] = list(max_variant_struct)
|
||
nested_struct_type: ir.IdentifiedStructType = ir.IdentifiedStructType(Gen.module, NestedStructName)
|
||
nested_struct_type.set_body(*padded_member_types)
|
||
Gen.structs[NestedStructName] = nested_struct_type
|
||
if NestedStructName not in Gen.class_members:
|
||
Gen.class_members[NestedStructName] = []
|
||
if NestedStructName not in Gen.class_member_signeds:
|
||
Gen.class_member_signeds[NestedStructName] = {}
|
||
Gen.class_members[NestedStructName].append(('__tag', ir.IntType(32)))
|
||
Gen.class_member_signeds[NestedStructName]['__tag'] = None
|
||
for i, (mname, mtype) in enumerate(zip(member_names, member_types)):
|
||
Gen.class_members[NestedStructName].append((mname, mtype))
|
||
try:
|
||
ti: CTypeInfo | None = CTypeInfo.FromNode(member_annotations[i], self.Trans.SymbolTable)
|
||
if ti and hasattr(ti.BaseType, 'IsSigned'):
|
||
Gen.class_member_signeds[NestedStructName][mname] = ti.BaseType.IsSigned
|
||
else:
|
||
Gen.class_member_signeds[NestedStructName][mname] = None
|
||
except Exception as e: # 回退：签名信息解析失败时设为 None
|
||
_vlog().warning(f"HandlesClassDef: 忽略异常 {e}", exc_info=e)
|
||
Gen.class_member_signeds[NestedStructName][mname] = None
|
||
MemberNode: CTypeInfo = CTypeInfo()
|
||
MemberNode.Name = VariantName
|
||
MemberNode.BaseType = t.CEnum(ClassName)
|
||
MemberNode.value = tag_value
|
||
MemberNode.EnumName = ClassName
|
||
MemberNode.Lineno = lineno
|
||
MemberNode.IsEnumMember = True
|
||
self.Trans.SymbolTable.insert(VariantName, MemberNode)
|
||
RenumTypeInfo: CTypeInfo = CTypeInfo()
|
||
RenumTypeInfo.Name = ClassName
|
||
RenumTypeInfo.BaseType = t.REnum(ClassName)
|
||
RenumTypeInfo.IsRenum = True
|
||
RenumTypeInfo.IsEnum = True
|
||
RenumTypeInfo.RenumVariants = variant_names
|
||
self.Trans.SymbolTable.insert(ClassName, RenumTypeInfo)
|
||
|
||
def _RegisterEnumMembers(self, Node: ast.ClassDef) -> None:
|
||
ClassName: str = Node.name
|
||
EnumTypeInfo: CTypeInfo = CTypeInfo()
|
||
EnumTypeInfo.Name = ClassName
|
||
EnumTypeInfo.BaseType = t.CEnum(ClassName)
|
||
EnumTypeInfo.IsEnum = True
|
||
self.Trans.SymbolTable.insert(ClassName, EnumTypeInfo)
|
||
enum_export = self.Trans.Exportable.add_enum(
|
||
name=ClassName,
|
||
lineno=Node.lineno,
|
||
is_public=True
|
||
)
|
||
next_enum_value: int = 0
|
||
for item in Node.body:
|
||
if isinstance(item, ast.Assign):
|
||
for target in item.targets:
|
||
if isinstance(target, ast.Name):
|
||
VarName: str = target.id
|
||
value: int | str | None = None
|
||
if item.value:
|
||
if isinstance(item.value, ast.Constant):
|
||
value = item.value.value
|
||
next_enum_value = value + 1
|
||
elif isinstance(item.value, ast.UnaryOp) and isinstance(item.value.op, ast.USub):
|
||
if isinstance(item.value.operand, ast.Constant):
|
||
value = -item.value.operand.value
|
||
next_enum_value = value + 1
|
||
elif isinstance(item.value, ast.Name):
|
||
value = item.value.id
|
||
ref_info: CTypeInfo | None = self.Trans.SymbolTable.lookup(value)
|
||
if ref_info:
|
||
if ref_info.value is not None and isinstance(ref_info.value, int):
|
||
next_enum_value = ref_info.value + 1
|
||
else:
|
||
value = next_enum_value
|
||
next_enum_value += 1
|
||
MemberNode: CTypeInfo = CTypeInfo()
|
||
MemberNode.Name = VarName
|
||
MemberNode.BaseType = t.CEnum(ClassName)
|
||
MemberNode.value = value
|
||
MemberNode.EnumName = ClassName
|
||
MemberNode.Lineno = item.lineno
|
||
MemberNode.IsEnumMember = True
|
||
self.Trans.SymbolTable.insert(VarName, MemberNode)
|
||
enum_export.members.append(ExportEnumMember(
|
||
name=VarName,
|
||
value=value,
|
||
lineno=item.lineno
|
||
))
|
||
elif isinstance(item, ast.AnnAssign):
|
||
if isinstance(item.target, ast.Name):
|
||
VarName = item.target.id
|
||
value = None
|
||
if item.value:
|
||
if isinstance(item.value, ast.Constant):
|
||
value = item.value.value
|
||
next_enum_value = value + 1
|
||
elif isinstance(item.value, ast.UnaryOp) and isinstance(item.value.op, ast.USub):
|
||
if isinstance(item.value.operand, ast.Constant):
|
||
value = -item.value.operand.value
|
||
next_enum_value = value + 1
|
||
elif isinstance(item.value, ast.Name):
|
||
value = item.value.id
|
||
ref_info: CTypeInfo | None = self.Trans.SymbolTable.lookup(value)
|
||
if ref_info:
|
||
if ref_info.value is not None and isinstance(ref_info.value, int):
|
||
next_enum_value = ref_info.value + 1
|
||
else:
|
||
value = next_enum_value
|
||
next_enum_value += 1
|
||
MemberNode: CTypeInfo = CTypeInfo()
|
||
MemberNode.Name = VarName
|
||
MemberNode.BaseType = t.CEnum(ClassName)
|
||
MemberNode.value = value
|
||
MemberNode.EnumName = ClassName
|
||
MemberNode.Lineno = item.lineno
|
||
MemberNode.IsEnumMember = True
|
||
self.Trans.SymbolTable.insert(VarName, MemberNode)
|
||
enum_export.members.append(ExportEnumMember(
|
||
name=VarName,
|
||
value=value,
|
||
lineno=item.lineno
|
||
))
|
||
|
||
def _EmitNewFunctionLlvm(self, ClassName: str, Gen: LlvmGeneratorMixin, IsCVTable: bool = False, IsCpythonObject: bool = False) -> None:
|
||
NewFuncName: str = f'{ClassName}.__before_init__'
|
||
existing_func: ir.Function | None = Gen.functions.get(NewFuncName)
|
||
if existing_func and len(existing_func.blocks) > 0:
|
||
return
|
||
MangledName: str = Gen._mangle_name(NewFuncName)
|
||
StructType: ir.Type = Gen.structs[ClassName]
|
||
if isinstance(StructType, ir.IdentifiedStructType) and (StructType.elements is None or len(StructType.elements) == 0):
|
||
self.Trans.ImportHandler._TryLoadStructFromStub(ClassName, Gen)
|
||
StructType = Gen.structs.get(ClassName, StructType)
|
||
StructPtrType: ir.PointerType = ir.PointerType(StructType)
|
||
FuncType: ir.FunctionType = ir.FunctionType(ir.VoidType(), [StructPtrType])
|
||
if existing_func:
|
||
func: ir.Function = existing_func
|
||
else:
|
||
func = Gen._get_or_declare_function(MangledName, FuncType)
|
||
Gen.functions[NewFuncName] = func
|
||
EntryBlock: ir.Block = func.append_basic_block(name="entry")
|
||
saved_builder: ir.IRBuilder = Gen.builder
|
||
saved_func: ir.Function = Gen.func
|
||
Gen.builder = ir.IRBuilder(EntryBlock)
|
||
Gen.func = func
|
||
StructPtr: ir.Argument = func.args[0]
|
||
if IsCVTable:
|
||
base: int = 1
|
||
if ClassName in Gen.Vtables:
|
||
VtablePtr: ir.Value = Gen.builder.gep(StructPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name="vtable_slot")
|
||
VtableAddr: ir.Value = Gen.builder.bitcast(Gen.Vtables[ClassName], ir.PointerType(ir.IntType(8)), name="vtable_addr")
|
||
Gen.builder.store(VtableAddr, VtablePtr)
|
||
members: list[tuple] = Gen.class_members.get(ClassName, [])
|
||
defaults: dict = Gen.class_member_defaults.get(ClassName, {})
|
||
for i, (member_name, member_type) in enumerate(members):
|
||
ElemPtr: ir.Value = Gen.builder.gep(StructPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), base + i)], name=f"{ClassName}_{member_name}")
|
||
if member_name in defaults:
|
||
try:
|
||
val: ir.Constant = defaults[member_name]
|
||
if not isinstance(val, ir.Constant):
|
||
val = ir.Constant(ElemPtr.type.pointee, val)
|
||
Gen.builder.store(val, ElemPtr)
|
||
except Exception as _e:
|
||
if _config_mode == "strict":
|
||
self.Trans.LogWarning(f"异常被忽略: {_e}")
|
||
Gen.builder.ret_void()
|
||
Gen.builder = saved_builder
|
||
Gen.func = saved_func
|
||
|
||
def _BuildScalarConstant(self, node: ast.AST, llvm_type: ir.Type, Gen: LlvmGeneratorMixin | None = None) -> ir.Constant | None:
|
||
"""构建标量常量，委托给统一的 _BuildScalarConstantUnified 方法。"""
|
||
if Gen is None:
|
||
Gen = self.Trans.LlvmGen
|
||
return self.Trans._BuildScalarConstantUnified(node, llvm_type, Gen)
|
||
|
||
def _BuildStructConstant(self, call_node: ast.Call, StructName: str, Gen: LlvmGeneratorMixin) -> ir.Constant | None:
|
||
struct_type: ir.Type = Gen.structs[StructName]
|
||
members: list[tuple] = Gen.class_members.get(StructName, [])
|
||
defaults: dict = Gen.class_member_defaults.get(StructName, {})
|
||
member_values: list[ir.Constant] = []
|
||
for member_name, member_type in members:
|
||
if member_name in defaults:
|
||
val: ir.Constant = defaults[member_name]
|
||
if not isinstance(val, ir.Constant):
|
||
try:
|
||
val = ir.Constant(member_type, val)
|
||
except Exception: # 回退：常量转换失败时使用零值
|
||
val = ir.Constant(member_type, 0)
|
||
member_values.append(val)
|
||
else:
|
||
try:
|
||
if isinstance(member_type, (ir.IdentifiedStructType, ir.LiteralStructType, ir.PointerType, ir.ArrayType)):
|
||
member_values.append(ir.Constant(member_type, None))
|
||
else:
|
||
member_values.append(ir.Constant(member_type, ir.Undefined))
|
||
except Exception: # 回退：常量创建失败时使用零值
|
||
member_values.append(ir.Constant(member_type, 0))
|
||
if call_node.args:
|
||
for i, arg in enumerate(call_node.args):
|
||
if i < len(members):
|
||
_, member_type = members[i]
|
||
const: ir.Constant | None = self._BuildScalarConstant(arg, member_type, Gen)
|
||
if const is not None:
|
||
member_values[i] = const
|
||
try:
|
||
return ir.Constant(struct_type, member_values)
|
||
except Exception: # 回退：结构体常量创建失败
|
||
return None
|