from __future__ import annotations from typing import TYPE_CHECKING if TYPE_CHECKING: from lib.core.translator import Translator from lib.core.SymbolNode import SymbolNode from lib.core.Handles.HandlesBase import CTypeInfo, CTypeHelper from lib.includes import t from typing import Any, Dict, Iterator import ast import re def _IsTModuleType(TypeName: str) -> bool: """检测类型名称是否是 t 模块中的类型（CType 或其他特殊类型）""" if TypeName in ('t', 'State', 'Bit', 'Anonymous', 'Postdefinition'): return True TypeClass = getattr(t, TypeName, None) if TypeClass and isinstance(TypeClass, type): if issubclass(TypeClass, t.CType): return True FallbackClass = getattr(t, f'_{TypeName}', None) if FallbackClass and isinstance(FallbackClass, type): if issubclass(FallbackClass, t.CType): return True return False def _AnnotationContainsTType(node, TypeName: str) -> bool: """检测 AST 节点中是否包含指定名称的 t 模块类型""" if isinstance(node, ast.Attribute): if (hasattr(node.value, 'id') and node.value.id == 't' and node.attr == TypeName): return True elif isinstance(node, ast.BinOp): return _AnnotationContainsTType(node.left, TypeName) or _AnnotationContainsTType(node.right, TypeName) elif isinstance(node, ast.Call): if _AnnotationContainsTType(node.func, TypeName): return True for arg in node.args: if _AnnotationContainsTType(arg, TypeName): return True elif isinstance(node, ast.Subscript): if _AnnotationContainsTType(node.value, TypeName): return True if _AnnotationContainsTType(node.slice, TypeName): return True return False class SymbolTable: def __init__(self, translator: "Translator"): self.translator = translator self._root = SymbolNode(name='root', NodeType='root') def clear(self): self._root = SymbolNode(name='root', NodeType='root') def get(self, name: str, default=None) -> CTypeInfo: node = self._FindNode(name) if node: return node.attributes return default def set(self, name: str, value: Any): self._InsertNode(name, value) self._cached_len = -1 def update(self, symbols: Dict[str, Any]): for name, value in symbols.items(): self.set(name, value) def keys(self) -> Iterator[str]: return self._CollectKeys(self._root) def values(self) -> Iterator[CTypeInfo]: for node in self._CollectNodes(self._root): yield node.attributes def items(self) -> Iterator[tuple[str, CTypeInfo]]: for node in self._CollectNodes(self._root): yield node.name, node.attributes def pop(self, name: str, *args) -> CTypeInfo: node = self._FindNode(name) if node and node.parent: node.parent.RemoveChild(node.name) return node.attributes if args: return args[0] raise KeyError(name) def __getitem__(self, name: str) -> CTypeInfo: node = self._FindNode(name) if node: return node.attributes raise KeyError(name) def __setitem__(self, name: str, value: Any): self.set(name, value) def __delitem__(self, name: str): node = self._FindNode(name) if node and node.parent: node.parent.RemoveChild(node.name) self._cached_len = -1 else: raise KeyError(name) def __contains__(self, name: str) -> bool: return self._FindNode(name) is not None def __len__(self) -> int: if not hasattr(self, '_cached_len') or self._cached_len < 0: self._cached_len = sum(1 for _ in self._CollectNodes(self._root)) return self._cached_len def __iter__(self) -> Iterator[str]: return self.keys() def ToDict(self) -> Dict[str, Any]: return self._root.ToDict() def FromDict(self, symbols: Dict[str, Any]): self._root = SymbolNode.FromDict('root', symbols) def LoadModuleSymbols(self, FullModulePath: str, asname: str, lineno: int = 0) -> list[str]: return self._LoadSymbolsFromFile(FullModulePath, asname, lineno) def _LoadSymbolsFromFile(self, FilePath: str, namespace_prefix: str | list[str], lineno: int = 0) -> list[str]: from lib.core.Handles.HandlesTypeMerge import HandlesTypeMerge import ast LoadedSymbols = [] try: with open(FilePath, 'r', encoding='utf-8') as f: ModuleCode = f.read() ModuleTree = ast.parse(ModuleCode) ClassMembers = {} AnonymousTypes = {} for node in ModuleTree.body: if isinstance(node, ast.ClassDef): ClassName = node.name MembersInfo = {} def CollectMembers(ClassNode, prefix=''): for item in ClassNode.body: if isinstance(item, ast.AnnAssign): if isinstance(item.target, ast.Name): MemberName = item.target.id FullName = f'{prefix}{MemberName}' if prefix else MemberName MemberTypeInfo = CTypeInfo.FromNode(item.annotation, self.translator.SymbolTable) if MemberTypeInfo is None: MemberTypeInfo = CTypeInfo() MemberTypeInfo.BaseType = t.CInt() IsPtr = MemberTypeInfo.IsPtr if isinstance(item.annotation, ast.BinOp): AnnotationStr = ast.dump(item.annotation) if 'CPtr' in AnnotationStr: IsPtr = True MembersInfo[FullName] = MemberTypeInfo.Copy() elif isinstance(item, ast.ClassDef): IsAnonymous = any( any(_AnnotationContainsTType(base, 'Anonymous') for base in item.bases) ) if item.bases else False if IsAnonymous: IsUnion = any( any(_AnnotationContainsTType(base, 'CUnion') for base in item.bases) ) NestedMemberName = f'{prefix}{item.name}' if prefix else item.name MembersInfo[NestedMemberName] = CTypeInfo() MembersInfo[NestedMemberName].BaseType = f'union {item.name}' if IsUnion else f'struct {item.name}' MembersInfo[NestedMemberName].PtrCount = 0 MembersInfo[NestedMemberName].ArrayDims = [] NewPrefix = f'{prefix}{item.name}.' if prefix else f'{item.name}.' CollectMembers(item, NewPrefix) AnonymousMembers = {} for FullName, MemberInfo in MembersInfo.items(): if FullName.startswith(f"{NestedMemberName}."): MemberName = FullName[len(NestedMemberName) + 1:] AnonymousMembers[MemberName] = MemberInfo if item.name not in AnonymousTypes: AnonymousTypes[item.name] = { 'IsUnion': IsUnion, 'members': AnonymousMembers, 'lineno': item.lineno } CollectMembers(node) ClassMembers[ClassName] = MembersInfo LoadedSymbols = [] prefixes = [namespace_prefix] if isinstance(namespace_prefix, str) else namespace_prefix for prefix in prefixes: for node in ModuleTree.body: if isinstance(node, ast.ClassDef): ClassName = node.name MembersInfo = ClassMembers.get(ClassName, {}) TypeKind = 'struct' IsCpythonObject = False IsPacked = 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 decorator.value.id == 't' and decorator.attr == 'Object'): IsCpythonObject = True break elif isinstance(decorator, ast.Call): if isinstance(decorator.func, ast.Attribute): if hasattr(decorator.func.value, 'id') and decorator.func.value.id == 'c' and decorator.func.attr == 'Attribute': for arg in decorator.args: if isinstance(arg, ast.Attribute): if isinstance(arg.value, ast.Attribute): if hasattr(arg.value.value, 'id') and arg.value.value.id == 't' and arg.value.attr == 'attr' and arg.attr == 'packed': IsPacked = True for base in node.bases: if _AnnotationContainsTType(base, 'CUnion'): TypeKind = 'union' break elif _AnnotationContainsTType(base, 'CEnum'): TypeKind = 'enum' break elif _AnnotationContainsTType(base, 'CStruct'): TypeKind = 'struct' break elif _AnnotationContainsTType(base, 'Object'): IsCpythonObject = True TypeKind = 'struct' break elif isinstance(base, ast.Name) and base.id == 'Exception': TypeKind = 'exception' break elif isinstance(base, ast.Name): base_entry = self.get(base.id) if base_entry and hasattr(base_entry, 'IsExceptionClass') and base_entry.IsExceptionClass: TypeKind = 'exception' break if prefix == prefixes[0]: self._InsertClassSymbol(ClassName, TypeKind, node.lineno, FilePath, MembersInfo, IsCpythonObject, IsPacked) LoadedSymbols.append(ClassName) FullName = f"{prefix}.{ClassName}" self._InsertClassSymbol(FullName, TypeKind, node.lineno, FilePath, MembersInfo, IsCpythonObject, IsPacked) LoadedSymbols.append(FullName) if TypeKind == 'enum': next_enum_value = 0 for item in node.body: if isinstance(item, ast.Assign): if len(item.targets) == 1 and isinstance(item.targets[0], ast.Name): MemberName = item.targets[0].id if isinstance(item.value, ast.Constant) and isinstance(item.value.value, int): next_enum_value = item.value.value + 1 else: next_enum_value += 1 if prefix == prefixes[0]: self._InsertEnumMemberSymbol(MemberName, ClassName, item.lineno, FilePath) LoadedSymbols.append(MemberName) ClassMemberName = f"{ClassName}.{MemberName}" self._InsertEnumMemberSymbol(ClassMemberName, ClassName, item.lineno, FilePath) LoadedSymbols.append(ClassMemberName) FullMemberName = f"{prefix}.{MemberName}" self._InsertEnumMemberSymbol(FullMemberName, ClassName, item.lineno, FilePath) LoadedSymbols.append(FullMemberName) elif isinstance(item, ast.AnnAssign): if isinstance(item.target, ast.Name): MemberName = item.target.id if item.value: if isinstance(item.value, ast.Constant) and isinstance(item.value.value, int): next_enum_value = item.value.value + 1 else: next_enum_value += 1 else: next_enum_value += 1 if prefix == prefixes[0]: self._InsertEnumMemberSymbol(MemberName, ClassName, item.lineno, FilePath) LoadedSymbols.append(MemberName) ClassMemberName = f"{ClassName}.{MemberName}" self._InsertEnumMemberSymbol(ClassMemberName, ClassName, item.lineno, FilePath) LoadedSymbols.append(ClassMemberName) FullMemberName = f"{prefix}.{MemberName}" self._InsertEnumMemberSymbol(FullMemberName, ClassName, item.lineno, FilePath) LoadedSymbols.append(FullMemberName) elif isinstance(node, ast.AnnAssign): if isinstance(node.target, ast.Name): VarName = node.target.id HasCDefine = _AnnotationContainsTType(node.annotation, 'CDefine') if node.annotation else False HasPostdef = _AnnotationContainsTType(node.annotation, 'Postdefinition') if node.annotation else False HasCtypedef = _AnnotationContainsTType(node.annotation, 'CTypedef') if node.annotation else False IsPostdefWithTypedef = HasPostdef and HasCtypedef if HasCDefine: DefineValue = None if node.value: DefineValue = self._eval_const_expr(node.value) if prefix == prefixes[0]: self._InsertDefineSymbol(VarName, DefineValue, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertDefineSymbol(FullName, DefineValue, node.lineno, FilePath) LoadedSymbols.append(FullName) continue def FindBaseType(n): if isinstance(n, ast.Attribute): if hasattr(n.value, 'id') and n.value.id == 't': if n.attr == 'CPtr': return 'ptr' return n.attr elif isinstance(n, ast.Subscript): if isinstance(n.value, ast.Attribute) and isinstance(n.value.value, ast.Name) and n.value.value.id == 't' and n.value.attr == 'Callable': return 'Callable' elif isinstance(n, ast.BinOp) and isinstance(n.op, ast.BitOr): LeftResult = FindBaseType(n.left) if LeftResult == 'ptr': RightResult = FindBaseType(n.right) return (RightResult if RightResult and RightResult != 'ptr' else 'void') + ' *' if LeftResult == 'Callable': return 'Callable' RightResult = FindBaseType(n.right) if RightResult == 'ptr': return (LeftResult if LeftResult and LeftResult != 'ptr' else 'void') + ' *' if RightResult == 'Callable': return 'Callable' if LeftResult: return LeftResult if RightResult: return RightResult return None if IsPostdefWithTypedef: def FindPostdefArg(n): if isinstance(n, ast.Call): if isinstance(n.func, ast.Attribute): if hasattr(n.func.value, 'id') and n.func.value.id == 't' and n.func.attr == 'Postdefinition': if n.args and isinstance(n.args[0], ast.Name): return n.args[0].id elif isinstance(n, ast.BinOp) and isinstance(n.op, ast.BitOr): LeftResult = FindPostdefArg(n.left) if LeftResult: return LeftResult RightResult = FindPostdefArg(n.right) if RightResult: return RightResult return None OriginalClass = FindPostdefArg(node.annotation) if OriginalClass and OriginalClass in ClassMembers: MembersInfo = ClassMembers[OriginalClass] OriginalType_kind = 'struct' if OriginalClass in self: OrigTypeInfo = self[OriginalClass] if OrigTypeInfo.TypeCls in (t.CStruct, t.CEnum, t.CUnion): if OrigTypeInfo.TypeCls is t.CStruct: OriginalType_kind = 'struct' elif OrigTypeInfo.TypeCls is t.CEnum: OriginalType_kind = 'enum' elif OrigTypeInfo.TypeCls is t.CUnion: OriginalType_kind = 'union' if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, OriginalType_kind, OriginalClass, node.lineno, FilePath, MembersInfo) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, OriginalType_kind, OriginalClass, node.lineno, FilePath, MembersInfo) LoadedSymbols.append(FullName) else: if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, None, None, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, None, None, node.lineno, FilePath) LoadedSymbols.append(FullName) elif HasCtypedef: BaseTypeName = FindBaseType(node.annotation) _TYPE_QUALIFIERS = {'CTypedef', 'CConst', 'CVolatile', 'CInline', 'CStatic', 'CExtern', 'CDefine', 'CPostdefinition'} if BaseTypeName == 'Callable': OriginalType = CTypeInfo() OriginalType.IsFuncPtr = True OriginalType.FuncPtrReturn = CTypeInfo.VoidTypeInfo() OriginalType.FuncPtrParams = [] if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(FullName) continue elif BaseTypeName and BaseTypeName not in _TYPE_QUALIFIERS: CName = CTypeHelper.GetCName(BaseTypeName) if CName and CName != BaseTypeName: OriginalType = CName else: OriginalType = BaseTypeName[1:] if BaseTypeName.startswith('C') else BaseTypeName if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(FullName) else: if node.value: ValueBaseType = FindBaseType(node.value) _PTR_MODIFIERS = {'CPtr', 'CArrayPtr', 'CConst', 'CVolatile', 'CInline', 'CStatic', 'CExtern'} if ValueBaseType and ValueBaseType not in _PTR_MODIFIERS: CName = CTypeHelper.GetCName(ValueBaseType) if CName and CName != ValueBaseType: OriginalType = CName else: OriginalType = ValueBaseType[1:] if ValueBaseType.startswith('C') else ValueBaseType if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(FullName) continue if isinstance(node.value, ast.BinOp) and isinstance(node.value.op, ast.BitOr): LeftType = self._ResolveTypedefValueType(node.value.left) RightType = self._ResolveTypedefValueType(node.value.right) IsPtrType = RightType == 'ptr' or LeftType == 'ptr' if IsPtrType: BaseName = LeftType if LeftType != 'ptr' else (RightType if RightType != 'ptr' else '') if BaseName: OriginalType = BaseName + ' *' else: OriginalType = 'void *' elif LeftType: OriginalType = LeftType elif RightType: OriginalType = RightType if OriginalType: if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, 'typedef', OriginalType, node.lineno, FilePath) LoadedSymbols.append(FullName) continue if isinstance(node.value, ast.Name): RefName = node.value.id if RefName in self: RefInfo = self[RefName] if RefInfo and RefInfo.IsTypedef and RefInfo.OriginalType: if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, 'typedef', RefInfo.OriginalType, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, 'typedef', RefInfo.OriginalType, node.lineno, FilePath) LoadedSymbols.append(FullName) continue if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, None, None, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, None, None, node.lineno, FilePath) LoadedSymbols.append(FullName) else: if prefix == prefixes[0]: self._InsertTypedefSymbol(VarName, None, None, node.lineno, FilePath) LoadedSymbols.append(VarName) FullName = f"{prefix}.{VarName}" self._InsertTypedefSymbol(FullName, None, None, node.lineno, FilePath) LoadedSymbols.append(FullName) elif isinstance(node, ast.FunctionDef): FuncName = node.name RetType = self._GetFuncRetTypeStr(node.returns) ParamTypes = [] for arg in node.args.args: if arg.annotation: ParamTypes.append(self._GetFuncParamTypeStr(arg.annotation)) else: ParamTypes.append('i8*') FuncIsVariadic = node.args.vararg is not None FuncIsInline = self._CheckAnnotationHasCInline(node.returns) if prefix == prefixes[0]: self._InsertFuncSymbol(FuncName, RetType, ParamTypes, node.lineno, FilePath, FuncIsVariadic, FuncIsInline) LoadedSymbols.append(FuncName) FullName = f"{prefix}.{FuncName}" self._InsertFuncSymbol(FullName, RetType, ParamTypes, node.lineno, FilePath, FuncIsVariadic, FuncIsInline) LoadedSymbols.append(FullName) self._InsertModuleSymbol(prefix, lineno, FilePath) for AnonymousTypeName, AnonymousTypeData in AnonymousTypes.items(): if prefix == prefixes[0]: self._InsertAnonymousSymbol(AnonymousTypeName, AnonymousTypeData['IsUnion'], AnonymousTypeData['members'], AnonymousTypeData['lineno'], FilePath) FullTypeName = f"{prefix}.{AnonymousTypeName}" self._InsertAnonymousSymbol(FullTypeName, AnonymousTypeData['IsUnion'], AnonymousTypeData['members'], AnonymousTypeData['lineno'], FilePath) if LoadedSymbols: pass return LoadedSymbols except Exception as e: import traceback print(traceback.format_exc()) print(f"[SymbolTable Error] Failed to load module: {FilePath} - {e}") return [] def _GetLLVMTypeStr(self, node): if node is None: return 'i32' if isinstance(node, ast.Name): if node.id == 'str': return 'i8*' elif node.id == 'int': return 'i32' elif node.id == 'bool': return 'i8' elif node.id == 'float': return 'double' elif node.id == 'None': return 'void' elif node.id in ('UINT8PTR', 'INT8PTR', 'BYTEPTR'): return 'i8*' elif node.id in ('UINT16PTR', 'INT16PTR'): return 'i16*' elif node.id in ('UINT32PTR', 'INT32PTR'): return 'i32*' elif node.id in ('UINT64PTR', 'INT64PTR'): return 'i64*' else: if node.id in self: entry = self[node.id] if entry and hasattr(entry, 'IsTypedef') and entry.IsTypedef and hasattr(entry, 'OriginalType') and entry.OriginalType: if isinstance(entry.OriginalType, CTypeInfo) and entry.OriginalType.IsFuncPtr: return 'i8*' elif isinstance(entry.OriginalType, CTypeInfo) and entry.OriginalType.BaseType: return entry.OriginalType.ToString() elif isinstance(entry.OriginalType, str): return entry.OriginalType return 'i32' elif isinstance(node, ast.Attribute): attr_name = node.attr if hasattr(node, 'attr') else '' from lib.includes.t import CTypeRegistry llvm_str = CTypeRegistry.NameToLLVM(attr_name) if llvm_str is not None: return llvm_str if attr_name in ('CState', 'CDefine', 'CTypedef', 'CExtern', 'CStatic', 'CConst', 'State'): return '' if attr_name in ('CCharPtr', 'CIntPtr', 'CVoidPtr', 'CArrayPtr'): return 'i8*' if attr_name == 'CVoidPtr': return 'i8*' if attr_name and attr_name[0].isupper() and attr_name not in CTypeRegistry._name_to_class: return f'%struct.{attr_name}*' if attr_name and attr_name not in CTypeRegistry._name_to_class: return f'%struct.{attr_name}*' return 'i32' elif isinstance(node, ast.Subscript): if isinstance(node.value, ast.Name) and node.value.id == 'tuple': slice_node = node.slice elem_types = [] if isinstance(slice_node, ast.Tuple): for elt in slice_node.elts: elem_types.append(self._GetLLVMTypeStr(elt)) else: elem_types.append(self._GetLLVMTypeStr(slice_node)) if elem_types: return '{ ' + ', '.join(elem_types) + ' }' if isinstance(node.value, ast.Name) and node.value.id == 'list': slice_node = node.slice if isinstance(slice_node, ast.Tuple) and len(slice_node.elts) >= 1: elem_type = self._GetLLVMTypeStr(slice_node.elts[0]) else: elem_type = self._GetLLVMTypeStr(slice_node) return elem_type + '*' return 'i32' elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr): left = self._GetLLVMTypeStr(node.left) right = self._GetLLVMTypeStr(node.right) if right and right.endswith('*'): return right if left and left.endswith('*'): return left if left and left not in ('i32', 'void', 'i64'): return left if right and right not in ('i32', 'void', 'i64'): return right return left if left else right elif isinstance(node, ast.Constant): if isinstance(node.value, bool): return 'i8' return 'i32' elif isinstance(node, ast.Call): if isinstance(node.func, ast.Attribute): if hasattr(node.func.value, 'id') and node.func.value.id == 't': return self._GetLLVMTypeStr(ast.Attribute(value=ast.Name(id='t'), attr=node.func.attr)) return 'i32' return 'i32' def _GetFuncRetTypeStr(self, returns_node): if returns_node is None: return 'i32' actual = returns_node if isinstance(returns_node, ast.BinOp) and isinstance(returns_node.op, ast.BitOr): left_str = self._GetLLVMTypeStr(returns_node.left) right_str = self._GetLLVMTypeStr(returns_node.right) if right_str and right_str.endswith('*'): return right_str if left_str and left_str.endswith('*'): return left_str if left_str and left_str not in ('i32', 'void', 'i64'): return left_str if right_str and right_str not in ('i32', 'void', 'i64'): return right_str return left_str result = self._GetLLVMTypeStr(actual) return result if result else 'i32' @staticmethod def _CheckAnnotationHasCInline(annotation_node) -> bool: if annotation_node is None: return False if isinstance(annotation_node, ast.Attribute): if hasattr(annotation_node.value, 'id') and annotation_node.value.id == 't' and annotation_node.attr == 'CInline': return True if isinstance(annotation_node, ast.Name): if annotation_node.id == 'CInline': return True if isinstance(annotation_node, ast.BinOp) and isinstance(annotation_node.op, ast.BitOr): return SymbolTable._CheckAnnotationHasCInline(annotation_node.left) or SymbolTable._CheckAnnotationHasCInline(annotation_node.right) return False def _GetFuncParamTypeStr(self, annotation_node): if annotation_node is None: return 'i8*' actual = annotation_node if isinstance(annotation_node, ast.BinOp) and isinstance(annotation_node.op, ast.BitOr): left_str = self._GetLLVMTypeStr(annotation_node.left) right_str = self._GetLLVMTypeStr(annotation_node.right) if right_str and right_str.endswith('*'): return right_str if left_str and left_str.endswith('*'): return left_str if right_str and right_str not in ('i32', 'void', 'i64'): return right_str if left_str and left_str not in ('i32', 'void', 'i64'): return left_str if left_str and left_str.endswith('*'): return left_str return right_str if right_str else left_str result = self._GetLLVMTypeStr(actual) return result if result else 'i8*' def _ResolveTypedefValueType(self, node): if node is None: return '' if isinstance(node, ast.Name): if node.id in self: Entry = self[node.id] if hasattr(Entry, 'IsTypedef') and Entry.IsTypedef and Entry.OriginalType: return Entry.OriginalType return '' if isinstance(node, ast.Attribute): if isinstance(node.value, ast.Name) and node.value.id == 't': CName = CTypeHelper.GetCName(node.attr) if CName and CName == '*': return 'ptr' if CName: return CName return '' if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr): left_str = self._ResolveTypedefValueType(node.left) right_str = self._ResolveTypedefValueType(node.right) if right_str == 'ptr' or (right_str and right_str.endswith('*')): base = left_str if left_str and left_str != 'ptr' else '' return base + ' *' if base else 'void *' if left_str == 'ptr' or (left_str and left_str.endswith('*')): base = right_str if right_str and right_str != 'ptr' else '' return base + ' *' if base else 'void *' if right_str and right_str not in ('ptr', 'void', 'i32', 'i64'): return right_str if left_str and left_str not in ('ptr', 'void', 'i32', 'i64'): return left_str return left_str if left_str else right_str return '' def _InsertClassSymbol(self, FullName: str, TypeKind: str, lineno: int, FilePath: str, members: dict, IsCpythonObject: bool, IsPacked: bool = False): parts = FullName.split('.') current = self._root for i, part in enumerate(parts[:-1]): if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] node = SymbolNode.CreateClass( name=LastPart, TypeKind=TypeKind, members=members, lineno=lineno, file=FilePath, IsCpythonObject=IsCpythonObject, IsPacked=IsPacked ) current.AddChild(node) def _InsertEnumMemberSymbol(self, FullName: str, EnumName: str, lineno: int, FilePath: str): from lib.core.Handles.HandlesBase import CTypeInfo parts = FullName.split('.') current = self._root for i, part in enumerate(parts[:-1]): if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] info = CTypeInfo() info.IsEnumMember = True info.EnumName = EnumName info.Lineno = lineno info.file = FilePath node = SymbolNode(name=LastPart, NodeType='enum_member') node.attributes = info current.AddChild(node) def _InsertTypedefSymbol(self, FullName: str, OriginalType_kind: str | None, OriginalClass, lineno: int, FilePath: str, members: dict | None = None): parts = FullName.split('.') current = self._root for i, part in enumerate(parts[:-1]): if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] if isinstance(OriginalClass, CTypeInfo): OriginalType = OriginalClass elif OriginalType_kind == 'typedef' and OriginalClass and isinstance(OriginalClass, str) and ('*' in OriginalClass): OriginalType = OriginalClass if OriginalType == 'CVoid *': OriginalType = 'void *' elif OriginalType_kind == 'typedef' and OriginalClass == 'void': OriginalType = 'void *' elif OriginalType_kind == 'typedef' and OriginalClass: OriginalType = OriginalClass elif OriginalType_kind and OriginalClass and isinstance(OriginalClass, str): OriginalType = f'{OriginalType_kind} {OriginalClass}' else: OriginalType = OriginalClass node = SymbolNode.CreateTypedef( name=LastPart, OriginalType=OriginalType, members=members, lineno=lineno, file=FilePath ) current.AddChild(node) def _InsertModuleSymbol(self, name: str, lineno: int, FilePath: str): node = SymbolNode.CreateModule( name=name, lineno=lineno, file=FilePath ) self._root.AddChild(node) def _InsertFuncSymbol(self, FullName: str, RetType, ParamTypes: list, lineno: int, FilePath: str, IsVariadic: bool = False, IsInline: bool = False): parts = FullName.split('.') current = self._root for i, part in enumerate(parts[:-1]): if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] from lib.core.Handles.HandlesBase import CTypeInfo info = CTypeInfo() info.IsFunction = True if isinstance(RetType, str): info.FuncPtrReturn = CTypeInfo.FromTypeName(RetType) if RetType else CTypeInfo.VoidTypeInfo() elif isinstance(RetType, CTypeInfo): info.FuncPtrReturn = RetType else: info.FuncPtrReturn = CTypeInfo.VoidTypeInfo() info.FuncPtrParams = [(f'arg{i}', pt) for i, pt in enumerate(ParamTypes)] info.IsVariadic = IsVariadic info.IsInline = IsInline if IsInline: info.Storage = t.CInline() info.Lineno = lineno info.file = FilePath node = SymbolNode(name=LastPart, NodeType='function') node.attributes = info current.AddChild(node) def _InsertDefineSymbol(self, FullName: str, DefineValue, lineno: int, FilePath: str): parts = FullName.split('.') current = self._root for i, part in enumerate(parts[:-1]): if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] from lib.core.Handles.HandlesBase import CTypeInfo info = CTypeInfo() info.IsDefine = True info.DefineValue = DefineValue info.Lineno = lineno info.file = FilePath node = SymbolNode(name=LastPart, NodeType='define') node.attributes = info current.AddChild(node) def _eval_const_expr(self, node): """计算常量表达式的值""" import ast if isinstance(node, ast.Constant): return node.value elif isinstance(node, ast.BinOp): left = self._eval_const_expr(node.left) right = self._eval_const_expr(node.right) if left is None or right is None: return None if isinstance(node.op, ast.Add): return left + right elif isinstance(node.op, ast.Sub): return left - right elif isinstance(node.op, ast.Mult): return left * right elif isinstance(node.op, ast.Div): return left // right if isinstance(left, int) and isinstance(right, int) else left / right elif isinstance(node.op, ast.FloorDiv): return left // right elif isinstance(node.op, ast.Mod): return left % right elif isinstance(node.op, ast.Pow): return left ** right elif isinstance(node.op, ast.LShift): return left << right elif isinstance(node.op, ast.RShift): return left >> right elif isinstance(node.op, ast.BitOr): return left | right elif isinstance(node.op, ast.BitXor): return left ^ right elif isinstance(node.op, ast.BitAnd): return left & right elif isinstance(node, ast.UnaryOp): operand = self._eval_const_expr(node.operand) if operand is None: return None if isinstance(node.op, ast.USub): return -operand elif isinstance(node.op, ast.UAdd): return +operand elif isinstance(node.op, ast.Invert): return ~operand elif isinstance(node, ast.Name): # 引用其他常量 if node.id in self: info = self[node.id] if hasattr(info, 'IsDefine') and info.IsDefine and hasattr(info, 'DefineValue') and info.DefineValue is not None: return info.DefineValue return None def _InsertAnonymousSymbol(self, FullName: str, IsUnion: bool, members: dict, lineno: int, FilePath: str): parts = FullName.split('.') current = self._root for i, part in enumerate(parts[:-1]): if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] node = SymbolNode.CreateAnonymous( name=LastPart, IsUnion=IsUnion, members=members, lineno=lineno, file=FilePath ) current.AddChild(node) def _FindNode(self, name: str) -> SymbolNode | None: if '.' not in name: return self._root.GetChild(name) parts = name.split('.') current = self._root for part in parts: if current.HasChild(part): current = current.GetChild(part) else: return None return current def _InsertNode(self, name: str, attributes: dict | "CTypeInfo"): from lib.core.Handles.HandlesBase import CTypeInfo parts = name.split('.') current = self._root for part in parts[:-1]: if not current.HasChild(part): node = SymbolNode(name=part, NodeType='namespace') current.AddChild(node) current = current.GetChild(part) LastPart = parts[-1] if isinstance(attributes, CTypeInfo): node = SymbolNode(name=LastPart, NodeType='type', lineno=attributes.Lineno or 0) node.attributes = attributes current.AddChild(node) return NodeType = attributes.get('type', 'unknown') # 根据节点类型使用相应的工厂函数 if NodeType == 'member': node = SymbolNode.CreateMember( name=LastPart, TypeName=attributes.get('type', ''), IsPtr=attributes.get('IsPtr', False), dims=attributes.get('dims', []), lineno=attributes.get('lineno', 0), file=attributes.get('file', '') ) elif NodeType == 'typedef': node = SymbolNode.CreateTypedef( name=LastPart, OriginalType=attributes.get('OriginalType', ''), members=attributes.get('members', None), lineno=attributes.get('lineno', 0), file=attributes.get('file', '') ) elif NodeType == 'module': node = SymbolNode.CreateModule( name=LastPart, lineno=attributes.get('lineno', 0), file=attributes.get('file', '') ) elif attributes.get('IsAnonymous'): node = SymbolNode.CreateAnonymous( name=LastPart, IsUnion=NodeType == 'union', members=attributes.get('members', {}), lineno=attributes.get('lineno', 0), file=attributes.get('file', '') ) else: # 其他类型（struct, union, enum, function, variable 等） node = SymbolNode.CreateClass( name=LastPart, TypeKind=NodeType, members=attributes.get('members', None), lineno=attributes.get('lineno', 0), file=attributes.get('file', ''), IsCpythonObject=attributes.get('IsCpythonObject', False) ) # 设置其他属性 for key, value in attributes.items(): if key not in ('type', 'lineno', 'file', 'members', 'IsCpythonObject', 'IsAnonymous'): node.set(key, value) current.AddChild(node) def _CollectKeys(self, node: SymbolNode) -> Iterator[str]: for name, child in node.children.items(): yield child.name yield from self._CollectKeys(child) def _CollectNodes(self, node: SymbolNode) -> Iterator[SymbolNode]: for child in node.children.values(): yield child yield from self._CollectNodes(child)