748 lines
37 KiB
Python
748 lines
37 KiB
Python
import ast
|
|
from typing import List
|
|
from lib.includes import t
|
|
|
|
|
|
class DeclarationGenerator:
|
|
"""从 .pyi AST 生成纯 LLVM IR 声明（不使用字符串操作）"""
|
|
|
|
def __init__(self, struct_names=None, enum_names=None, module_sha1=None, target_triple=None, target_datalayout=None, struct_sha1_map=None, exception_names=None, typedef_map=None):
|
|
import llvmlite.ir as ir
|
|
self.ir = ir
|
|
self.module = None
|
|
self.builder = None
|
|
self._DefineConstants = {}
|
|
self.struct_names = struct_names or set()
|
|
self.enum_names = enum_names or set()
|
|
self.module_sha1 = module_sha1
|
|
self.struct_sha1_map = struct_sha1_map or {}
|
|
self.exception_names = exception_names or set()
|
|
self.target_triple = target_triple or "x86_64-none-elf"
|
|
self.target_datalayout = target_datalayout or "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
|
|
self.typedef_map = typedef_map or {}
|
|
t.configure_platform(self.target_triple)
|
|
|
|
def generate(self, pyi_content: str, src_path: str) -> str:
|
|
import ast
|
|
tree = ast.parse(pyi_content)
|
|
|
|
self._DefineConstants = {}
|
|
self._pyi_tree = tree
|
|
global_typedef_map = self.typedef_map
|
|
self.typedef_map = {}
|
|
if global_typedef_map:
|
|
self.typedef_map.update(global_typedef_map)
|
|
for node in ast.iter_child_nodes(tree):
|
|
if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
|
|
var_name = node.target.id
|
|
if node.value and isinstance(node.value, ast.Constant):
|
|
self._DefineConstants[var_name] = node.value.value
|
|
elif node.value and isinstance(node.value, ast.Name):
|
|
self._DefineConstants[var_name] = node.value.id
|
|
is_typedef = False
|
|
if isinstance(node.annotation, ast.Attribute) and hasattr(node.annotation, 'attr') and node.annotation.attr == 'CTypedef':
|
|
is_typedef = True
|
|
elif isinstance(node.annotation, ast.Name) and node.annotation.id == 'CTypedef':
|
|
is_typedef = True
|
|
elif isinstance(node.annotation, ast.BinOp) and isinstance(node.annotation.left, ast.Attribute) and hasattr(node.annotation.left, 'attr') and node.annotation.left.attr == 'CTypedef':
|
|
is_typedef = True
|
|
if is_typedef:
|
|
if node.value:
|
|
self.typedef_map[var_name] = node.value
|
|
elif isinstance(node.annotation, ast.BinOp) and node.annotation.right:
|
|
self.typedef_map[var_name] = node.annotation.right
|
|
|
|
lines = []
|
|
lines.append('; ModuleID = "transpyc_decl"')
|
|
lines.append(f'target triple = "{self.target_triple}"')
|
|
lines.append(f'target datalayout = "{self.target_datalayout}"')
|
|
lines.append('')
|
|
|
|
for node in ast.iter_child_nodes(tree):
|
|
if isinstance(node, ast.FunctionDef):
|
|
if hasattr(node, 'type_params') and node.type_params:
|
|
continue
|
|
decl = self._generate_func_decl(node)
|
|
if decl:
|
|
lines.append(decl)
|
|
elif isinstance(node, ast.AnnAssign):
|
|
decl = self._generate_global_decl(node)
|
|
if decl:
|
|
lines.append(decl)
|
|
elif isinstance(node, ast.Assign):
|
|
decl = self._generate_global_assign_decl(node)
|
|
if decl:
|
|
lines.append(decl)
|
|
elif isinstance(node, ast.ClassDef):
|
|
if hasattr(node, 'type_params') and node.type_params:
|
|
continue
|
|
decls = self._generate_class_decl(node)
|
|
lines.extend(decls)
|
|
|
|
return '\n'.join(lines)
|
|
|
|
def _generate_func_decl(self, node: ast.FunctionDef) -> str:
|
|
"""生成函数声明"""
|
|
func_name = node.name
|
|
is_export = self._is_export_func(node)
|
|
if self.module_sha1 and not is_export:
|
|
func_name = f"{self.module_sha1}.{func_name}"
|
|
CReturnTypes = []
|
|
if node.decorator_list:
|
|
for decorator in node.decorator_list:
|
|
if isinstance(decorator, ast.Call) and isinstance(decorator.func, ast.Attribute):
|
|
if decorator.func.attr == 'CReturn':
|
|
for arg in decorator.args:
|
|
CReturnTypes.append(arg)
|
|
if node.returns:
|
|
if isinstance(node.returns, ast.Subscript) and isinstance(node.returns.value, ast.Name) and node.returns.value.id == 'tuple':
|
|
slice_node = node.returns.slice
|
|
if isinstance(slice_node, ast.Tuple):
|
|
for elt in slice_node.elts:
|
|
CReturnTypes.append(elt)
|
|
else:
|
|
CReturnTypes.append(slice_node)
|
|
if CReturnTypes:
|
|
elem_types = [self._get_type_str(rt, embedded=True) for rt in CReturnTypes]
|
|
ret_type = '{ ' + ', '.join(elem_types) + ' }'
|
|
else:
|
|
ret_type = self._get_type_str(node.returns)
|
|
if not ret_type or ret_type == 'void':
|
|
ret_type = 'void'
|
|
elif ret_type == 'i8*':
|
|
if node.returns is None:
|
|
ret_type = 'void'
|
|
|
|
params = []
|
|
for arg in node.args.args:
|
|
if arg.annotation:
|
|
arg_type = self._get_type_str(arg.annotation)
|
|
else:
|
|
arg_type = 'i8*'
|
|
if arg_type and arg_type != 'void':
|
|
params.append(arg_type)
|
|
|
|
param_str = ', '.join(params) if params else ''
|
|
if node.args.vararg:
|
|
param_str = param_str + ', ...' if param_str else '...'
|
|
if func_name[0].isdigit():
|
|
return f'declare {ret_type} @"{func_name}"({param_str})'
|
|
return f'declare {ret_type} @{func_name}({param_str})'
|
|
|
|
def _is_export_func(self, node: ast.FunctionDef) -> bool:
|
|
"""检查函数是否标记为 CExport"""
|
|
if not node.returns:
|
|
return False
|
|
return self._check_annotation_for_export(node.returns)
|
|
|
|
def _check_annotation_for_export(self, annotation) -> bool:
|
|
"""递归检查类型注解中是否包含 CExport 或 t.State"""
|
|
if isinstance(annotation, ast.Attribute):
|
|
if hasattr(annotation, 'attr') and annotation.attr in ('CExport', 'State'):
|
|
return True
|
|
elif isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr):
|
|
return self._check_annotation_for_export(annotation.left) or self._check_annotation_for_export(annotation.right)
|
|
elif isinstance(annotation, ast.Name):
|
|
return annotation.id in ('CExport', 'State')
|
|
return False
|
|
|
|
def _generate_global_decl(self, node: ast.AnnAssign) -> str:
|
|
"""生成全局变量声明"""
|
|
if not isinstance(node.target, ast.Name):
|
|
return None
|
|
var_name = node.target.id
|
|
if isinstance(node.annotation, ast.Attribute) and hasattr(node.annotation, 'attr') and node.annotation.attr == 'CDefine':
|
|
return None
|
|
if isinstance(node.annotation, ast.Attribute) and hasattr(node.annotation, 'attr') and node.annotation.attr == 'CTypedef':
|
|
return None
|
|
if isinstance(node.annotation, ast.Name) and node.annotation.id == 'CTypedef':
|
|
return None
|
|
if isinstance(node.annotation, ast.BinOp) and isinstance(node.annotation.left, ast.Attribute) and hasattr(node.annotation.left, 'attr') and node.annotation.left.attr == 'CTypedef':
|
|
return None
|
|
if isinstance(node.annotation, ast.List):
|
|
for elt in node.annotation.elts:
|
|
if isinstance(elt, ast.Attribute) and hasattr(elt, 'attr') and elt.attr in ('CTypedef', 'Callable'):
|
|
return None
|
|
if isinstance(elt, ast.Subscript) and isinstance(elt.value, ast.Attribute) and isinstance(elt.value.value, ast.Name) and elt.value.value.id == 't' and elt.value.attr == 'Callable':
|
|
return None
|
|
VarType = self._get_type_str(node.annotation)
|
|
if VarType.startswith('[0 x ') and node.value and isinstance(node.value, ast.List):
|
|
elem_type = VarType[5:-1]
|
|
actual_count = len(node.value.elts)
|
|
if actual_count > 0:
|
|
VarType = f'[{actual_count} x {elem_type}]'
|
|
return f'@{var_name} = external global {VarType}'
|
|
|
|
def _generate_global_assign_decl(self, node: ast.Assign) -> str:
|
|
"""从无类型标注赋值推断并生成全局变量声明"""
|
|
if not node.targets or not isinstance(node.targets[0], ast.Name):
|
|
return None
|
|
var_name = node.targets[0].id
|
|
VarType = self._infer_type(node.value)
|
|
if VarType:
|
|
return f'@{var_name} = external global {VarType}'
|
|
return None
|
|
|
|
def _generate_class_decl(self, node: ast.ClassDef) -> List[str]:
|
|
"""生成结构体/类声明"""
|
|
decls = []
|
|
class_name = node.name
|
|
is_enum = False
|
|
is_exception = False
|
|
if node.bases:
|
|
for base in node.bases:
|
|
if isinstance(base, ast.Attribute) and hasattr(base, 'attr'):
|
|
if base.attr == 'CEnum' or base.attr == 'Enum':
|
|
is_enum = True
|
|
break
|
|
elif base.attr == 'Exception' or base.attr in self.exception_names:
|
|
is_exception = True
|
|
break
|
|
elif isinstance(base, ast.Name) and hasattr(base, 'id'):
|
|
if base.id == 'CEnum' or base.id == 'Enum':
|
|
is_enum = True
|
|
break
|
|
elif base.id == 'Exception' or base.id in self.exception_names:
|
|
is_exception = True
|
|
break
|
|
if is_exception:
|
|
return decls
|
|
if is_enum:
|
|
enum_values = {}
|
|
next_value = 0
|
|
for item in node.body:
|
|
if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
|
|
var_name = item.target.id
|
|
if item.value and isinstance(item.value, ast.Constant) and isinstance(item.value.value, int):
|
|
enum_values[var_name] = item.value.value
|
|
else:
|
|
enum_values[var_name] = next_value
|
|
next_value += 1
|
|
elif isinstance(item, ast.Assign) and len(item.targets) == 1 and isinstance(item.targets[0], ast.Name):
|
|
var_name = item.targets[0].id
|
|
if item.value and isinstance(item.value, ast.Constant) and isinstance(item.value.value, int):
|
|
enum_values[var_name] = item.value.value
|
|
next_value = item.value.value + 1
|
|
else:
|
|
enum_values[var_name] = next_value
|
|
next_value += 1
|
|
for var_name, value in enum_values.items():
|
|
decls.append(f'@__config_{class_name}_{var_name} = external global i32')
|
|
return decls
|
|
member_types = []
|
|
has_bitfield = False
|
|
total_bits = 0
|
|
has_methods = any(isinstance(item, ast.FunctionDef) for item in node.body)
|
|
is_cvtable = False
|
|
is_cpython_object = False
|
|
if hasattr(node, 'decorator_list') and node.decorator_list:
|
|
for decorator in node.decorator_list:
|
|
if isinstance(decorator, ast.Attribute):
|
|
if getattr(decorator.value, 'id', None) == 't':
|
|
if decorator.attr == 'CVTable':
|
|
is_cvtable = True
|
|
elif decorator.attr == 'Object':
|
|
is_cpython_object = True
|
|
elif isinstance(decorator, ast.Name):
|
|
if decorator.id == 'CVTable':
|
|
is_cvtable = True
|
|
elif decorator.id == 'Object':
|
|
is_cpython_object = True
|
|
if has_methods and not is_cpython_object:
|
|
is_cpython_object = True
|
|
has_parent_class = False
|
|
for base in node.bases:
|
|
base_name = None
|
|
if isinstance(base, ast.Attribute):
|
|
base_name = base.attr
|
|
elif isinstance(base, ast.Name):
|
|
base_name = base.id
|
|
elif isinstance(base, ast.Subscript):
|
|
if isinstance(base.value, ast.Attribute):
|
|
base_name = base.value.attr
|
|
elif isinstance(base.value, ast.Name):
|
|
base_name = base.value.id
|
|
if base_name and base_name not in ('Object', 'CVTable', 'CEnum', 'Enum', 'CStruct', 'CUnion'):
|
|
has_parent_class = True
|
|
break
|
|
if has_parent_class and not is_cvtable:
|
|
is_cvtable = True
|
|
base_has_vtable = False
|
|
for base in node.bases:
|
|
base_name = None
|
|
if isinstance(base, ast.Attribute):
|
|
base_name = base.attr
|
|
elif isinstance(base, ast.Name):
|
|
base_name = base.id
|
|
elif isinstance(base, ast.Subscript):
|
|
if isinstance(base.value, ast.Attribute):
|
|
base_name = base.value.attr
|
|
elif isinstance(base.value, ast.Name):
|
|
base_name = base.value.id
|
|
if base_name and base_name not in ('Object', 'CVTable', 'CEnum', 'Enum', 'CStruct', 'CUnion'):
|
|
for n in ast.iter_child_nodes(self._pyi_tree):
|
|
if isinstance(n, ast.ClassDef) and n.name == base_name:
|
|
if hasattr(n, 'decorator_list') and n.decorator_list:
|
|
for dec in n.decorator_list:
|
|
if isinstance(dec, ast.Attribute) and getattr(dec.value, 'id', None) == 't' and dec.attr == 'CVTable':
|
|
base_has_vtable = True
|
|
elif isinstance(dec, ast.Name) and dec.id == 'CVTable':
|
|
base_has_vtable = True
|
|
break
|
|
if base_has_vtable:
|
|
break
|
|
if has_methods and is_cvtable and not base_has_vtable:
|
|
member_types.append('i8*')
|
|
seen_member_names = set()
|
|
for base in node.bases:
|
|
base_name = None
|
|
if isinstance(base, ast.Attribute):
|
|
base_name = base.attr
|
|
elif isinstance(base, ast.Name):
|
|
base_name = base.id
|
|
elif isinstance(base, ast.Subscript):
|
|
if isinstance(base.value, ast.Attribute):
|
|
base_name = base.value.attr
|
|
elif isinstance(base.value, ast.Name):
|
|
base_name = base.value.id
|
|
if base_name and base_name not in ('Object', 'CVTable', 'CEnum', 'Enum', 'CStruct', 'CUnion'):
|
|
base_member_types, base_seen = self._get_inherited_members(base_name)
|
|
for mt in base_member_types:
|
|
member_types.append(mt)
|
|
seen_member_names.update(base_seen)
|
|
for item in node.body:
|
|
if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
|
|
seen_member_names.add(item.target.id)
|
|
init_members = []
|
|
for item in node.body:
|
|
if isinstance(item, ast.FunctionDef) and item.name == '__init__':
|
|
for stmt in item.body:
|
|
if (isinstance(stmt, ast.AnnAssign)
|
|
and isinstance(stmt.target, ast.Attribute)
|
|
and isinstance(stmt.target.value, ast.Name)
|
|
and stmt.target.value.id == 'self'):
|
|
init_members.append(stmt)
|
|
untyped_self_members = []
|
|
for m_name in [m.attr for m in init_members if isinstance(m.target, ast.Attribute)]:
|
|
seen_member_names.add(m_name)
|
|
for item in node.body:
|
|
if isinstance(item, ast.FunctionDef):
|
|
if hasattr(item, 'type_params') and item.type_params:
|
|
continue
|
|
for stmt in item.body:
|
|
if (isinstance(stmt, ast.Assign)
|
|
and len(stmt.targets) == 1
|
|
and isinstance(stmt.targets[0], ast.Attribute)
|
|
and isinstance(stmt.targets[0].value, ast.Name)
|
|
and stmt.targets[0].value.id == 'self'):
|
|
attr_name = stmt.targets[0].attr
|
|
if attr_name not in seen_member_names:
|
|
seen_member_names.add(attr_name)
|
|
untyped_self_members.append(stmt)
|
|
for item in list(node.body) + init_members + untyped_self_members:
|
|
if isinstance(item, ast.AnnAssign):
|
|
bit_width = self._get_bitfield_width(item.annotation)
|
|
if bit_width is not None:
|
|
has_bitfield = True
|
|
total_bits += bit_width
|
|
else:
|
|
VarType = self._get_type_str(item.annotation, embedded=True)
|
|
if (isinstance(item.annotation, ast.Subscript)
|
|
and isinstance(item.annotation.value, ast.Name)
|
|
and item.annotation.value.id == 'list'):
|
|
slice_node = item.annotation.slice
|
|
is_dynamic = False
|
|
if isinstance(slice_node, ast.Tuple) and len(slice_node.elts) == 2:
|
|
count_node = slice_node.elts[1]
|
|
if isinstance(count_node, ast.Constant) and count_node.value is None:
|
|
is_dynamic = True
|
|
elif not (isinstance(count_node, ast.Constant) and isinstance(count_node.value, int) and count_node.value > 0):
|
|
if not isinstance(count_node, (ast.Name, ast.BinOp)):
|
|
is_dynamic = True
|
|
elif not isinstance(slice_node, ast.Tuple):
|
|
is_dynamic = True
|
|
if is_dynamic:
|
|
elem_type = self._get_type_str(slice_node if not isinstance(slice_node, ast.Tuple) else slice_node.elts[0], embedded=True)
|
|
init_len = 0
|
|
if isinstance(item.value, ast.List):
|
|
init_len = len(item.value.elts)
|
|
elif isinstance(item.value, ast.Constant) and isinstance(item.value.value, str):
|
|
init_len = len(item.value.value) + 1
|
|
VarType = f'[{init_len} x {elem_type}]'
|
|
member_types.append(VarType)
|
|
elif isinstance(item, ast.Assign):
|
|
if (len(item.targets) == 1
|
|
and isinstance(item.targets[0], ast.Attribute)
|
|
and isinstance(item.targets[0].value, ast.Name)
|
|
and item.targets[0].value.id == 'self'):
|
|
attr_name = item.targets[0].attr
|
|
if attr_name in seen_member_names:
|
|
continue
|
|
InferredType = 'i32'
|
|
if item.value and isinstance(item.value, ast.Constant):
|
|
if isinstance(item.value.value, float):
|
|
InferredType = 'float'
|
|
elif isinstance(item.value.value, bool):
|
|
InferredType = 'i8'
|
|
elif isinstance(item.value.value, str):
|
|
InferredType = 'i8*'
|
|
member_types.append(InferredType)
|
|
else:
|
|
member_types.append('i32')
|
|
if has_bitfield:
|
|
if total_bits <= 8:
|
|
member_types.insert(0, 'i8')
|
|
elif total_bits <= 16:
|
|
member_types.insert(0, 'i16')
|
|
elif total_bits <= 32:
|
|
member_types.insert(0, 'i32')
|
|
else:
|
|
member_types.insert(0, 'i64')
|
|
struct_type_name = f'%"{self.module_sha1}.{class_name}"' if self.module_sha1 else f'%struct.{class_name}'
|
|
struct_decl = f'{struct_type_name} = type {{ {", ".join(member_types)} }}'
|
|
decls.append(struct_decl)
|
|
if is_cpython_object or is_cvtable:
|
|
new_func_name = f'{class_name}.__before_init__'
|
|
if self.module_sha1:
|
|
new_func_name = f"{self.module_sha1}.{new_func_name}"
|
|
if new_func_name[0].isdigit():
|
|
new_func_decl = f'declare void @"{new_func_name}"({struct_type_name}*)'
|
|
else:
|
|
new_func_decl = f'declare void @{new_func_name}({struct_type_name}*)'
|
|
decls.append(new_func_decl)
|
|
for item in node.body:
|
|
if isinstance(item, ast.FunctionDef):
|
|
if hasattr(item, 'type_params') and item.type_params:
|
|
continue
|
|
method_name = f'{class_name}.{item.name}'
|
|
if self.module_sha1:
|
|
method_name = f"{self.module_sha1}.{method_name}"
|
|
ret_type = self._get_type_str(item.returns) if item.returns else 'void'
|
|
if not ret_type:
|
|
ret_type = 'void'
|
|
params = []
|
|
for arg_idx, arg in enumerate(item.args.args):
|
|
if arg.annotation:
|
|
arg_type = self._get_type_str(arg.annotation)
|
|
elif arg_idx == 0 and arg.arg == 'self':
|
|
arg_type = f'{struct_type_name}*'
|
|
else:
|
|
arg_type = 'i8*'
|
|
params.append(arg_type)
|
|
param_str = ', '.join(params) if params else ''
|
|
if method_name[0].isdigit():
|
|
decls.append(f'declare {ret_type} @"{method_name}"({param_str})')
|
|
else:
|
|
decls.append(f'declare {ret_type} @{method_name}({param_str})')
|
|
return decls
|
|
|
|
def _get_inherited_members(self, base_name: str):
|
|
import ast
|
|
member_types = []
|
|
seen_names = set()
|
|
if not hasattr(self, '_pyi_tree') or self._pyi_tree is None:
|
|
return member_types, seen_names
|
|
base_node = None
|
|
for node in ast.iter_child_nodes(self._pyi_tree):
|
|
if isinstance(node, ast.ClassDef) and node.name == base_name:
|
|
base_node = node
|
|
break
|
|
if base_node is None:
|
|
return member_types, seen_names
|
|
base_decls = self._generate_class_decl(base_node)
|
|
for decl in base_decls:
|
|
if '= type {' in decl:
|
|
type_body = decl.split('= type {')[1].rstrip('}').strip()
|
|
if type_body:
|
|
for t in type_body.split(','):
|
|
t = t.strip()
|
|
if t:
|
|
member_types.append(t)
|
|
break
|
|
for item in base_node.body:
|
|
if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
|
|
seen_names.add(item.target.id)
|
|
elif isinstance(item, ast.Assign) and len(item.targets) == 1:
|
|
if isinstance(item.targets[0], ast.Attribute) and isinstance(item.targets[0].value, ast.Name) and item.targets[0].value.id == 'self':
|
|
seen_names.add(item.targets[0].attr)
|
|
for item in base_node.body:
|
|
if isinstance(item, ast.FunctionDef) and item.name == '__init__':
|
|
for stmt in item.body:
|
|
if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Attribute) and isinstance(stmt.target.value, ast.Name) and stmt.target.value.id == 'self':
|
|
seen_names.add(stmt.target.attr)
|
|
elif isinstance(stmt, ast.Assign) and len(stmt.targets) == 1 and isinstance(stmt.targets[0], ast.Attribute) and isinstance(stmt.targets[0].value, ast.Name) and stmt.targets[0].value.id == 'self':
|
|
seen_names.add(stmt.targets[0].attr)
|
|
return member_types, seen_names
|
|
|
|
@staticmethod
|
|
def _ctype_name_to_llvm(name: str) -> str:
|
|
"""根据 CType 元属性自动推导 LLVM IR 类型
|
|
|
|
通过 CTypeRegistry.NameToLLVM 查询，利用 CType 的
|
|
position/IsSigned/Size 元属性自动推导，无需手动映射表。
|
|
"""
|
|
from lib.includes.t import CTypeRegistry
|
|
result = CTypeRegistry.NameToLLVM(name)
|
|
return result
|
|
|
|
def _get_type_str(self, annotation: ast.AST, embedded: bool = False) -> str:
|
|
import ast
|
|
from lib.includes.t import CTypeRegistry
|
|
if annotation is None:
|
|
return 'i8*'
|
|
|
|
non_struct_types = {'list', 'dict', 'tuple', 'set', 'array'}
|
|
|
|
if isinstance(annotation, ast.Name):
|
|
if annotation.id == 'None':
|
|
return 'void'
|
|
if annotation.id in ('str', 'bytes'):
|
|
return 'i8*'
|
|
llvm_type = CTypeRegistry.NameToLLVM(annotation.id)
|
|
if llvm_type is not None:
|
|
return llvm_type
|
|
resolved = CTypeRegistry.ResolveName(annotation.id)
|
|
if resolved is not None:
|
|
ctype_cls, ptr_level = resolved
|
|
base = CTypeRegistry.CTypeToLLVM(ctype_cls)
|
|
if ptr_level > 0:
|
|
if base == 'void':
|
|
return 'i8*'
|
|
if '*' in base:
|
|
return base
|
|
return f'{base}*'
|
|
return base
|
|
if annotation.id in non_struct_types:
|
|
return 'i32'
|
|
if annotation.id in self.enum_names:
|
|
return 'i32'
|
|
if annotation.id in self.struct_names:
|
|
sha1 = self.struct_sha1_map.get(annotation.id, self.module_sha1)
|
|
sname = f'%"{sha1}.{annotation.id}"' if sha1 else f'%struct.{annotation.id}'
|
|
if embedded:
|
|
return sname
|
|
else:
|
|
return f'{sname}*'
|
|
if annotation.id in self.typedef_map:
|
|
resolved = self._get_type_str(self.typedef_map[annotation.id], embedded=embedded)
|
|
return resolved
|
|
sha1 = self.struct_sha1_map.get(annotation.id, self.module_sha1)
|
|
sname = f'%"{sha1}.{annotation.id}"' if sha1 else f'%struct.{annotation.id}'
|
|
return f'{sname}*'
|
|
elif isinstance(annotation, ast.Attribute):
|
|
attr_name = annotation.attr if hasattr(annotation, 'attr') else ''
|
|
module_name = ''
|
|
if hasattr(annotation, 'value'):
|
|
if isinstance(annotation.value, ast.Name):
|
|
module_name = annotation.value.id
|
|
elif isinstance(annotation.value, ast.Attribute) and hasattr(annotation.value, 'attr'):
|
|
module_name = annotation.value.attr
|
|
if (module_name == 't' and attr_name == 'State') or attr_name == 'State':
|
|
return ''
|
|
if (module_name == 't' and attr_name == 'Callable') or attr_name == 'Callable':
|
|
return 'i8*'
|
|
llvm_type = CTypeRegistry.NameToLLVM(attr_name)
|
|
if llvm_type is not None:
|
|
return llvm_type
|
|
resolved = CTypeRegistry.ResolveName(attr_name)
|
|
if resolved is not None:
|
|
ctype_cls, ptr_level = resolved
|
|
base = CTypeRegistry.CTypeToLLVM(ctype_cls)
|
|
if ptr_level > 0:
|
|
if base == 'void':
|
|
return 'i8*'
|
|
if '*' in base:
|
|
return base
|
|
return f'{base}*'
|
|
return base
|
|
if attr_name in self.typedef_map:
|
|
return self._get_type_str(self.typedef_map[attr_name], embedded=embedded)
|
|
if attr_name in self.enum_names:
|
|
return 'i32'
|
|
if attr_name in self.struct_names:
|
|
sha1 = self.struct_sha1_map.get(attr_name, self.module_sha1)
|
|
sname = f'%"{sha1}.{attr_name}"' if sha1 else f'%struct.{attr_name}'
|
|
if embedded:
|
|
return sname
|
|
else:
|
|
return f'{sname}*'
|
|
if attr_name and attr_name[0].isupper() and attr_name not in non_struct_types:
|
|
sha1 = self.struct_sha1_map.get(attr_name, self.module_sha1)
|
|
sname = f'%"{sha1}.{attr_name}"' if sha1 else f'%struct.{attr_name}'
|
|
return f'{sname}*'
|
|
if attr_name and attr_name not in non_struct_types:
|
|
sha1 = self.struct_sha1_map.get(attr_name, self.module_sha1)
|
|
sname = f'%"{sha1}.{attr_name}"' if sha1 else f'%struct.{attr_name}'
|
|
return f'{sname}*'
|
|
return 'i32'
|
|
elif isinstance(annotation, ast.BinOp):
|
|
left_type = self._get_type_str(annotation.left, embedded=embedded)
|
|
right_type = self._get_type_str(annotation.right, embedded=embedded)
|
|
if left_type in ('', 'void'):
|
|
return right_type if right_type not in ('', 'void') else (left_type or right_type)
|
|
if right_type in ('', 'void'):
|
|
return left_type
|
|
if '*' in left_type:
|
|
return left_type
|
|
if '*' in right_type:
|
|
if right_type == 'i8*':
|
|
return self._type_to_llvm_ptr(left_type)
|
|
return right_type
|
|
return left_type
|
|
elif isinstance(annotation, ast.Subscript):
|
|
base = self._get_type_str(annotation.value)
|
|
if base == 'i8*' and isinstance(annotation.slice, ast.Constant):
|
|
return f'[{self._get_const_int(annotation.slice)} x i8]'
|
|
if isinstance(annotation.slice, ast.Constant) and isinstance(annotation.slice.value, int):
|
|
return f'[{annotation.slice.value} x {base}]'
|
|
if isinstance(annotation.value, ast.Name) and annotation.value.id == 'list':
|
|
slice_node = annotation.slice
|
|
if isinstance(slice_node, ast.Tuple) and len(slice_node.elts) == 2:
|
|
elem_type = self._get_type_str(slice_node.elts[0], embedded=True)
|
|
count_node = slice_node.elts[1]
|
|
array_count = self._get_const_int(count_node)
|
|
if array_count > 0:
|
|
return f'[{array_count} x {elem_type}]'
|
|
else:
|
|
return f'[0 x {elem_type}]'
|
|
elem_type = self._get_type_str(slice_node, embedded=True)
|
|
return f'[0 x {elem_type}]'
|
|
if isinstance(annotation.value, ast.Name) and annotation.value.id == 'tuple':
|
|
slice_node = annotation.slice
|
|
if isinstance(slice_node, ast.Tuple):
|
|
elem_types = [self._get_type_str(e, embedded=True) for e in slice_node.elts]
|
|
else:
|
|
elem_types = [self._get_type_str(slice_node, embedded=True)]
|
|
return '{ ' + ', '.join(elem_types) + ' }'
|
|
return f'{base}'
|
|
elif isinstance(annotation, ast.Constant):
|
|
if annotation.value is None:
|
|
return 'void'
|
|
if isinstance(annotation.value, int):
|
|
return 'i32'
|
|
if isinstance(annotation.value, str):
|
|
type_name = annotation.value
|
|
if type_name in self.enum_names:
|
|
return 'i32'
|
|
if type_name in self.struct_names:
|
|
sha1 = self.struct_sha1_map.get(type_name, self.module_sha1)
|
|
sname = f'%"{sha1}.{type_name}"' if sha1 else f'%struct.{type_name}'
|
|
if embedded:
|
|
return sname
|
|
else:
|
|
return f'{sname}*'
|
|
llvm_type = CTypeRegistry.NameToLLVM(type_name)
|
|
if llvm_type is not None:
|
|
return llvm_type
|
|
resolved = CTypeRegistry.ResolveName(type_name)
|
|
if resolved is not None:
|
|
ctype_cls, ptr_level = resolved
|
|
base = CTypeRegistry.CTypeToLLVM(ctype_cls)
|
|
if ptr_level > 0:
|
|
if base == 'void':
|
|
return 'i8*'
|
|
if '*' in base:
|
|
return base
|
|
return f'{base}*'
|
|
return base
|
|
sha1 = self.struct_sha1_map.get(type_name, self.module_sha1)
|
|
sname = f'%"{sha1}.{type_name}"' if sha1 else f'%struct.{type_name}'
|
|
return f'{sname}*'
|
|
return 'i8*'
|
|
elif isinstance(annotation, ast.Call):
|
|
if isinstance(annotation.func, ast.Name) and annotation.func.id == 'callable':
|
|
return 'i8*'
|
|
if isinstance(annotation.func, ast.Attribute) and annotation.func.attr == 'Callable':
|
|
return 'i8*'
|
|
return 'i32'
|
|
|
|
def _type_to_llvm_ptr(self, type_str: str) -> str:
|
|
if type_str.startswith('%struct.') and not type_str.endswith('*'):
|
|
return type_str + '*'
|
|
if type_str.startswith('%') and not type_str.endswith('*'):
|
|
return type_str + '*'
|
|
if type_str.endswith('*'):
|
|
return type_str
|
|
from lib.includes.t import CTypeRegistry
|
|
resolved = CTypeRegistry.ResolveName(type_str)
|
|
if resolved is not None:
|
|
ctype_cls, ptr_level = resolved
|
|
llvm_str = CTypeRegistry.CTypeToLLVM(ctype_cls)
|
|
if llvm_str:
|
|
return f'{llvm_str}{"*" * (ptr_level + 1)}'
|
|
cnameres = CTypeRegistry.CNameToClass(type_str)
|
|
if cnameres is not None:
|
|
llvm_str = CTypeRegistry.CTypeToLLVM(cnameres)
|
|
if llvm_str:
|
|
return f'{llvm_str}*'
|
|
return f'{type_str}*'
|
|
|
|
def _infer_type(self, value: ast.AST) -> str:
|
|
"""从值推断类型"""
|
|
import ast
|
|
if isinstance(value, ast.Constant):
|
|
if isinstance(value.value, int):
|
|
return 'i32'
|
|
elif isinstance(value.value, float):
|
|
return 'double'
|
|
elif isinstance(value.value, str):
|
|
return 'i8*'
|
|
elif isinstance(value.value, bool):
|
|
return 'i8'
|
|
elif isinstance(value, ast.List):
|
|
return 'i8*'
|
|
elif isinstance(value, ast.Dict):
|
|
return 'i8*'
|
|
elif isinstance(value, ast.Name):
|
|
return 'i32'
|
|
elif isinstance(value, ast.BinOp):
|
|
return self._infer_type(value.left)
|
|
elif isinstance(value, ast.Call):
|
|
return 'i8*'
|
|
return 'i32'
|
|
|
|
def _get_bitfield_width(self, annotation: ast.AST):
|
|
import ast
|
|
if isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr):
|
|
right_width = self._get_bitfield_width(annotation.right)
|
|
if right_width is not None:
|
|
return right_width
|
|
return self._get_bitfield_width(annotation.left)
|
|
if isinstance(annotation, ast.Call):
|
|
if isinstance(annotation.func, ast.Attribute) and annotation.func.attr == 'Bit':
|
|
if annotation.args:
|
|
arg = annotation.args[0]
|
|
if isinstance(arg, ast.Constant) and isinstance(arg.value, int):
|
|
return arg.value
|
|
if isinstance(annotation, ast.Subscript):
|
|
if isinstance(annotation.value, ast.Attribute) and annotation.value.attr == 'Bit':
|
|
if isinstance(annotation.slice, ast.Constant) and isinstance(annotation.slice.value, int):
|
|
return annotation.slice.value
|
|
return None
|
|
|
|
def _get_const_int(self, node: ast.AST) -> int:
|
|
"""获取常量整数值，支持符号常量和简单表达式"""
|
|
import ast
|
|
if isinstance(node, ast.Constant) and isinstance(node.value, int):
|
|
return node.value
|
|
if isinstance(node, ast.Name):
|
|
if node.id in self._DefineConstants:
|
|
val = self._DefineConstants[node.id]
|
|
if isinstance(val, int):
|
|
return val
|
|
if isinstance(node, ast.BinOp):
|
|
left_val = self._get_const_int(node.left)
|
|
right_val = self._get_const_int(node.right)
|
|
if left_val and right_val:
|
|
if isinstance(node.op, ast.Add):
|
|
return left_val + right_val
|
|
if isinstance(node.op, ast.Sub):
|
|
return left_val - right_val
|
|
if isinstance(node.op, ast.Mult):
|
|
return left_val * right_val
|
|
if isinstance(node.op, ast.Div):
|
|
return left_val // right_val
|
|
if isinstance(node.op, ast.FloorDiv):
|
|
return left_val // right_val
|
|
return 0
|