简化了一些表达，最后仍使用 fb 缓冲区的版本（新版本使用 栈f-string）
This commit is contained in:
TermiNexus committed
1 parent
c542442987
commit
54462320d2
24 files changed
+175
-341
No files matched your search
@@ -5,7 +5,6 @@ import stdlib
|
||||
import memhub
|
||||
import viperlib
|
||||
import w32.fileio as fileio
|
||||
import w32.win32file
|
||||
import w32.win32base
|
||||
import ast
|
||||
import llvmlite
|
||||
@@ -79,9 +78,7 @@ def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
|
||||
result: IncludesScanner.ScanResult | t.CPtr = IncludesScanner.scan_includes(mb, includes_dir)
|
||||
t_scan1: t.CUInt64T = w32.win32base.GetTickCount64()
|
||||
fb: str = VLogger.fmtbuffer
|
||||
viperlib.snprintf(fb, 1024,
|
||||
"扫描 includes 总耗时: %llu ms (%d 文件, 含 SHA1 计算)",
|
||||
t_scan1 - t_scan0, result.Count if result is not None else 0)
|
||||
viperlib.snprintf(fb, 1024, "扫描 includes 总耗时: %llu ms (%d 文件, 含 SHA1 计算)", t_scan1 - t_scan0, result.Count if result is not None else 0)
|
||||
VLogger.info(fb, "Phase1")
|
||||
if result is None:
|
||||
VLogger.error("扫描失败", "Phase1")
|
||||
|
||||
@@ -278,7 +278,7 @@ def _PreRegisterAllGenericTemplates(mb: memhub.MemBuddy | t.CPtr,
|
||||
"""预注册全部 includes 文件的泛型类模板，返回处理到的泛型类数量"""
|
||||
if result is None or mb is None:
|
||||
return 0
|
||||
perm: memhub.MemBuddy | t.CPtr = CompilerFactory.get_perm_pool()
|
||||
perm: memhub.MemBuddy | t.CPtr = CompilerFactory.factory.PermPool
|
||||
if perm is None:
|
||||
return 0
|
||||
p1e_size: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()
|
||||
|
||||
@@ -1,28 +1,6 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
import string
|
||||
import stdlib
|
||||
import memhub
|
||||
import viperlib
|
||||
import w32.fileio as fileio
|
||||
import w32.win32file
|
||||
import w32.win32base
|
||||
import ast
|
||||
import llvmlite
|
||||
import lib.core.VLogger as VLogger
|
||||
import lib.core.Handles.HandlesTranslator as HandlesTranslator
|
||||
import lib.core.Handles.HandlesExprCall as HandlesExprCall
|
||||
import lib.core.IncludesScanner as IncludesScanner
|
||||
import lib.Stub.StubMerger as StubMerger
|
||||
import lib.core.Gen.Generator as GenGenerator
|
||||
import lib.core.CompilerFactory as CompilerFactory
|
||||
import lib.Phase.BuildPipeline as BuildPipeline
|
||||
import lib.Projectrans.Config as Config
|
||||
import lib.Stub.StubGen.Converter as StubConverter
|
||||
import lib.Stub.StubMerger.StubMergerBuild as StubMergerBuild
|
||||
import lib.Stub.StubMerger.StubMergerCollect as StubMergerCollect
|
||||
import lib.Stub.StubMerger.StubMergerIR as StubMergerIR
|
||||
import lib.Stub.StubMerger.StubMergerStore as StubMergerStore
|
||||
|
||||
# 全局 mbuddy 指针
|
||||
_mbuddy: memhub.MemBuddy | t.CPtr
|
||||
|
||||
@@ -38,7 +38,7 @@ SRC_BUF_SIZE: t.CDefine = 1048576
|
||||
|
||||
# 最大源文件数（递归扫描子目录后文件数增多：App 现有 65 个 .vp，
|
||||
# 2026-08-14 CompilerFactory.vp 加入后超出 64 被截断 → 链接 undefined symbol
|
||||
# CompilerFactory.get_perm_pool。增大到 128 留余量）
|
||||
# CompilerFactory.factory.PermPool。增大到 128 留余量）
|
||||
MAX_SRC_FILES: t.CDefine = 128
|
||||
|
||||
@t.NoVTable
|
||||
@@ -308,7 +308,7 @@ def _PreRegisterAppGenericTemplates(mb: memhub.MemBuddy | t.CPtr,
|
||||
else:
|
||||
src_buf_pa[SRC_BUF_SIZE - 1] = 0
|
||||
# 解析 AST（只解析，不完整翻译；用永久池使模板节点跨 mark2 reset 存活）
|
||||
perm_pa: memhub.MemBuddy | t.CPtr = CompilerFactory.get_perm_pool()
|
||||
perm_pa: memhub.MemBuddy | t.CPtr = CompilerFactory.factory.PermPool
|
||||
if perm_pa is None:
|
||||
perm_pa = mb
|
||||
lx_pa: ast.Lexer | t.CPtr = ast.new_lexer(perm_pa)
|
||||
|
||||
@@ -1597,7 +1597,7 @@ def _inject_class_struct_declare(pool: memhub.MemBuddy | t.CPtr,
|
||||
# （对齐 ClassGenDef.translate_class_def L489-494）
|
||||
if GenApi.get_stdlib_alloc() != 0:
|
||||
st_copy_c: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), struct_ty_c)
|
||||
CompilerFactory.factory.PermPool, struct_ty_c)
|
||||
if st_copy_c is not None:
|
||||
struct_ty_c = st_copy_c
|
||||
# 6. 注册到当前模块（输出类型定义行）+ 全局 StructTable + 可见性
|
||||
|
||||
@@ -13,7 +13,7 @@ import memhub
|
||||
# - Pool ：主内存池（MemBuddy，瞬时数据，受 mark/reset_to 回收）
|
||||
# - PermPool ：永久内存池（MemBuddy，跨 mark 持久数据专用，从不 reset）
|
||||
#
|
||||
# 各模块经模块级委托 CompilerFactory.get_perm_pool() 获取永久池，
|
||||
# 各模块经模块级委托 CompilerFactory.PermPool 获取永久池，
|
||||
# 避免把编译器专属单例塞进通用内存库 memhub（memhub 保持通用）。
|
||||
# includes 层（llvmlite/__types.vp 的 DeepCopyType）不依赖本工厂：
|
||||
# 深拷贝的分配源由调用方以 pool 参数传入（传 PermPool 即持久）。
|
||||
@@ -40,29 +40,4 @@ class CompilerFactory:
|
||||
# ============================================================
|
||||
# 全局工厂单例
|
||||
# ============================================================
|
||||
_g_factory: CompilerFactory | t.CPtr = None
|
||||
|
||||
|
||||
def set_factory(factory: CompilerFactory | t.CPtr) -> None:
|
||||
"""注册全局工厂单例（main 创建后注册）"""
|
||||
global _g_factory
|
||||
_g_factory = factory
|
||||
|
||||
|
||||
def get_factory() -> CompilerFactory | t.CPtr:
|
||||
"""获取全局工厂单例（未注册返回 None）"""
|
||||
return _g_factory
|
||||
|
||||
|
||||
def get_pool() -> memhub.MemBuddy | t.CPtr:
|
||||
"""获取主内存池（瞬时数据分配源）"""
|
||||
if _g_factory is not None:
|
||||
return _g_factory.Pool
|
||||
return None
|
||||
|
||||
|
||||
def get_perm_pool() -> memhub.MemBuddy | t.CPtr:
|
||||
"""获取永久内存池（跨 mark 持久数据分配源）"""
|
||||
if _g_factory is not None:
|
||||
return _g_factory.PermPool
|
||||
return None
|
||||
factory: CompilerFactory | t.CPtr = None
|
||||
@@ -12,31 +12,13 @@ import lib.core.VLogger as VLogger
|
||||
import lib.core.Handles.HandlesTranslator as HT
|
||||
import lib.core.Handles.HandlesExpr as HandlesExpr
|
||||
import lib.Stub.StubMerger.StubMergerStore as StubMergerStore
|
||||
|
||||
import lib.core.Gen.GenTypes as GenTypes
|
||||
import lib.core.Gen.Generator as Generator
|
||||
import lib.core.Gen.TypeGenCType as TypeGenCType
|
||||
import lib.core.Gen.ExprGenAttr as ExprGenAttr
|
||||
import lib.core.Gen.CallGenBase as CallGenBase
|
||||
import lib.core.Gen.CallGenFd as CallGenFd
|
||||
import lib.core.Gen.CallGenVt as CallGenVt
|
||||
|
||||
import lib.Stub.StubGen.VpiReader as VpiReader
|
||||
|
||||
# ============================================================
|
||||
# AssignGenMixin - 赋值翻译 Mixin（P6 方法化）
|
||||
#
|
||||
# 从 HandlesAssign/HandlesAnnAssign/HandlesAugAssign 迁移：
|
||||
# 模块级无状态函数（trans/pool 首参）→ 类方法；全局状态
|
||||
# （HandlesAnnAssign._g_recover_found）→ 本类字段 RecoverFound。
|
||||
#
|
||||
# 迁移原则（与 P1-P5 一致，行为零变化）：
|
||||
# 1. 方法保留原函数签名（含 trans/pool 首参），仅函数体内的
|
||||
# 本模块函数调用改为 self.xxx(...)
|
||||
# 2. 外部模块调用（HandlesType.xxx/HandlesExpr.xxx 等）保留模块前缀
|
||||
# 3. 原 Handles 模块函数保留为"委托"：本地模块级单例 _g_gen
|
||||
# （BuildPipeline/main 注入）cast 成 Generator 类型
|
||||
#
|
||||
# @t.NoVTable：静态绑定（方法沿 MRO 直接调用 + this 调整）。
|
||||
# ============================================================
|
||||
|
||||
@@ -46,11 +28,10 @@ class AssignGenMixin:
|
||||
Gen: Generator.Generator | t.CPtr
|
||||
"""赋值翻译 Mixin（P6 方法化）"""
|
||||
|
||||
# --- 原 HandlesAnnAssign._g_recover_found 模块级全局（迁移为实例字段） ---
|
||||
RecoverFound: int
|
||||
|
||||
# ============================================================
|
||||
# is_cdefine_annotation - 检测注解是否为 t.CDefine（模块级函数）
|
||||
# 检测注解是否为 t.CDefine（模块级函数）
|
||||
#
|
||||
# 支持两种形式:
|
||||
# 1. Attribute(Name('t'), 'CDefine')
|
||||
@@ -58,8 +39,7 @@ class AssignGenMixin:
|
||||
# ============================================================
|
||||
def is_cdefine_annotation(self, annot: ast.AST | t.CPtr) -> int:
|
||||
"""检测注解是否为 t.CDefine，返回 1 表示是，0 表示否"""
|
||||
if annot is None:
|
||||
return 0
|
||||
if annot is None: return 0
|
||||
k: int = annot.kind()
|
||||
if k == ast.ASTKind.Attribute:
|
||||
at: ast.Attribute | t.CPtr = (ast.Attribute | t.CPtr)(annot)
|
||||
@@ -68,7 +48,7 @@ class AssignGenMixin:
|
||||
return 0
|
||||
if k == ast.ASTKind.BinOp:
|
||||
bop: ast.BinOp | t.CPtr = (ast.BinOp | t.CPtr)(annot)
|
||||
if self.is_cdefine_annotation(bop.left) != 0:
|
||||
if self.is_cdefine_annotation(bop.left) != 0:
|
||||
return 1
|
||||
if self.is_cdefine_annotation(bop.right) != 0:
|
||||
return 1
|
||||
@@ -109,31 +89,19 @@ class AssignGenMixin:
|
||||
# Case 2: BinOp — 如 FOREGROUND_RED | FOREGROUND_GREEN、(1 << ZDEFLATE_WINDOW_BITS)
|
||||
if k == ast.ASTKind.BinOp:
|
||||
bop: ast.BinOp | t.CPtr = (ast.BinOp | t.CPtr)(val_node)
|
||||
left_val: t.CInt64T = self.extract_cdefine_int_value(bop.left)
|
||||
left_val: t.CInt64T = self.extract_cdefine_int_value(bop.left)
|
||||
right_val: t.CInt64T = self.extract_cdefine_int_value(bop.right)
|
||||
if bop.op == ast.OpKind.BitOr:
|
||||
return left_val | right_val
|
||||
if bop.op == ast.OpKind.BitAnd:
|
||||
return left_val & right_val
|
||||
if bop.op == ast.OpKind.BitXor:
|
||||
return left_val ^ right_val
|
||||
if bop.op == ast.OpKind.LShift:
|
||||
return left_val << right_val
|
||||
if bop.op == ast.OpKind.RShift:
|
||||
return left_val >> right_val
|
||||
if bop.op == ast.OpKind.Add:
|
||||
return left_val + right_val
|
||||
if bop.op == ast.OpKind.Sub:
|
||||
return left_val - right_val
|
||||
if bop.op == ast.OpKind.Mult:
|
||||
return left_val * right_val
|
||||
if bop.op == ast.OpKind.Div:
|
||||
# 整数常量除法：与 FloorDiv 一致（对齐 TPC ConstEvaluator L354-355）
|
||||
return left_val // right_val
|
||||
if bop.op == ast.OpKind.FloorDiv:
|
||||
return left_val // right_val
|
||||
if bop.op == ast.OpKind.Mod:
|
||||
return left_val % right_val
|
||||
if bop.op == ast.OpKind.BitOr: return left_val | right_val
|
||||
if bop.op == ast.OpKind.BitAnd: return left_val & right_val
|
||||
if bop.op == ast.OpKind.BitXor: return left_val ^ right_val
|
||||
if bop.op == ast.OpKind.LShift: return left_val << right_val
|
||||
if bop.op == ast.OpKind.RShift: return left_val >> right_val
|
||||
if bop.op == ast.OpKind.Add: return left_val + right_val
|
||||
if bop.op == ast.OpKind.Sub: return left_val - right_val
|
||||
if bop.op == ast.OpKind.Mult: return left_val * right_val
|
||||
if bop.op == ast.OpKind.Div: return left_val // right_val
|
||||
if bop.op == ast.OpKind.FloorDiv: return left_val // right_val
|
||||
if bop.op == ast.OpKind.Mod: return left_val % right_val
|
||||
# 未知 BinOp 运算符：直接报错终止（fail-fast）
|
||||
self.Gen.TypeGenErr.fatal_error(val_node, "CDefine 值提取失败：无法从表达式解析编译期常量", "TypeError")
|
||||
|
||||
@@ -141,7 +109,7 @@ class AssignGenMixin:
|
||||
if k == ast.ASTKind.Name:
|
||||
nm: ast.Name | t.CPtr = (ast.Name | t.CPtr)(val_node)
|
||||
if nm.id is not None:
|
||||
# True/False 布尔字面量 → 1/0（对齐 TPC：bool 在 CDefine 语境按整数处理）
|
||||
# True/False 布尔字面量 → 1/0（bool 在 CDefine 语境按整数处理）
|
||||
if string.strcmp(nm.id, "True") == 0:
|
||||
return 1
|
||||
if string.strcmp(nm.id, "False") == 0:
|
||||
@@ -169,12 +137,9 @@ class AssignGenMixin:
|
||||
if k == ast.ASTKind.UnaryOp:
|
||||
uop: ast.UnaryOp | t.CPtr = (ast.UnaryOp | t.CPtr)(val_node)
|
||||
operand_val: t.CInt64T = self.extract_cdefine_int_value(uop.operand)
|
||||
if uop.op == ast.OpKind.USub:
|
||||
return -operand_val
|
||||
if uop.op == ast.OpKind.UAdd:
|
||||
return operand_val
|
||||
if uop.op == ast.OpKind.Invert:
|
||||
return ~operand_val
|
||||
if uop.op == ast.OpKind.USub: return -operand_val
|
||||
if uop.op == ast.OpKind.UAdd: return operand_val
|
||||
if uop.op == ast.OpKind.Invert: return ~operand_val
|
||||
# 未知 UnaryOp 运算符：直接报错终止（fail-fast）
|
||||
self.Gen.TypeGenErr.fatal_error(val_node, "CDefine 值提取失败：无法从表达式解析编译期常量", "TypeError")
|
||||
|
||||
@@ -649,16 +614,11 @@ class AssignGenMixin:
|
||||
# 将两个操作数转换为目标浮点类型（int→float via si2fp, float→float via fpext/fptrunc）
|
||||
lhs = self.Gen.ExprGenBase.coerce_to_type(builder, lhs, target_float_ty, node)
|
||||
rhs = self.Gen.ExprGenBase.coerce_to_type(builder, rhs, target_float_ty, node)
|
||||
if op == ast.OpKind.Add:
|
||||
return llvmlite.build_fadd(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Sub:
|
||||
return llvmlite.build_fsub(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Mult:
|
||||
return llvmlite.build_fmul(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Div:
|
||||
return llvmlite.build_fdiv(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Mod:
|
||||
return llvmlite.build_frem(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Add: return llvmlite.build_fadd(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Sub: return llvmlite.build_fsub(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Mult: return llvmlite.build_fmul(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Div: return llvmlite.build_fdiv(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Mod: return llvmlite.build_frem(builder, lhs, rhs)
|
||||
return None
|
||||
|
||||
# 指针算术: ptr += int / ptr -= int → getelementptr（按元素大小缩放）
|
||||
@@ -674,26 +634,16 @@ class AssignGenMixin:
|
||||
elif rhs_bits > lhs_bits and lhs_bits > 0:
|
||||
lhs = self.Gen.ExprGenBase.coerce_to_type(builder, lhs, rhs.Ty, node)
|
||||
|
||||
if op == ast.OpKind.Add:
|
||||
return llvmlite.build_add(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Sub:
|
||||
return llvmlite.build_sub(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Mult:
|
||||
return llvmlite.build_mul(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Div:
|
||||
return llvmlite.build_sdiv(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.FloorDiv:
|
||||
return llvmlite.build_sdiv(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Mod:
|
||||
return llvmlite.build_srem(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.BitAnd:
|
||||
return llvmlite.build_and(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.BitOr:
|
||||
return llvmlite.build_or(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.BitXor:
|
||||
return llvmlite.build_xor(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.LShift:
|
||||
return llvmlite.build_shl(builder, lhs, rhs)
|
||||
if op == ast.OpKind.Add: return llvmlite.build_add(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Sub: return llvmlite.build_sub(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Mult: return llvmlite.build_mul(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Div: return llvmlite.build_sdiv(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.FloorDiv: return llvmlite.build_sdiv(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.Mod: return llvmlite.build_srem(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.BitAnd: return llvmlite.build_and(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.BitOr: return llvmlite.build_or(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.BitXor: return llvmlite.build_xor(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.LShift: return llvmlite.build_shl(builder, lhs, rhs)
|
||||
elif op == ast.OpKind.RShift:
|
||||
# 无符号 >> → lshr（逻辑右移），有符号 >> → ashr（算术右移）
|
||||
# 对齐 TPC ExprGen.emit_binary_op：i8/i16 默认无符号；其余查操作数无符号性
|
||||
@@ -1867,7 +1817,7 @@ class AssignGenMixin:
|
||||
continue
|
||||
attr_node: ast.Attribute | t.CPtr = (ast.Attribute | t.CPtr)(target)
|
||||
attr_name: str = "(unknown)"
|
||||
obj_name: str = "(unknown)"
|
||||
obj_name: str = "(unknown)"
|
||||
if attr_node is not None:
|
||||
attr_name = attr_node.attr
|
||||
if attr_node.value is not None and attr_node.value.kind() == ast.ASTKind.Name:
|
||||
@@ -2173,21 +2123,21 @@ class AssignGenMixin:
|
||||
# ============================================================
|
||||
def _op_to_dunder(self, op: int) -> str:
|
||||
"""BinOp/UnaryOp 运算符 → dunder 方法名，无映射返回 None"""
|
||||
if op == ast.OpKind.Add: return "__add__"
|
||||
if op == ast.OpKind.Sub: return "__sub__"
|
||||
if op == ast.OpKind.Mult: return "__mul__"
|
||||
if op == ast.OpKind.Div: return "__truediv__"
|
||||
if op == ast.OpKind.Add: return "__add__"
|
||||
if op == ast.OpKind.Sub: return "__sub__"
|
||||
if op == ast.OpKind.Mult: return "__mul__"
|
||||
if op == ast.OpKind.Div: return "__truediv__"
|
||||
if op == ast.OpKind.FloorDiv: return "__floordiv__"
|
||||
if op == ast.OpKind.Mod: return "__mod__"
|
||||
if op == ast.OpKind.Pow: return "__pow__"
|
||||
if op == ast.OpKind.BitAnd: return "__and__"
|
||||
if op == ast.OpKind.BitOr: return "__or__"
|
||||
if op == ast.OpKind.BitXor: return "__xor__"
|
||||
if op == ast.OpKind.LShift: return "__lshift__"
|
||||
if op == ast.OpKind.RShift: return "__rshift__"
|
||||
if op == ast.OpKind.USub: return "__neg__"
|
||||
if op == ast.OpKind.UAdd: return "__pos__"
|
||||
if op == ast.OpKind.Invert: return "__invert__"
|
||||
if op == ast.OpKind.Mod: return "__mod__"
|
||||
if op == ast.OpKind.Pow: return "__pow__"
|
||||
if op == ast.OpKind.BitAnd: return "__and__"
|
||||
if op == ast.OpKind.BitOr: return "__or__"
|
||||
if op == ast.OpKind.BitXor: return "__xor__"
|
||||
if op == ast.OpKind.LShift: return "__lshift__"
|
||||
if op == ast.OpKind.RShift: return "__rshift__"
|
||||
if op == ast.OpKind.USub: return "__neg__"
|
||||
if op == ast.OpKind.UAdd: return "__pos__"
|
||||
if op == ast.OpKind.Invert: return "__invert__"
|
||||
return None
|
||||
|
||||
# ============================================================
|
||||
|
||||
@@ -9,15 +9,6 @@ import lib.core.Handles.HandlesExprCall as HandlesExprCall
|
||||
|
||||
# ============================================================
|
||||
# BaseGenMixin - 生成器基座（状态容器）
|
||||
#
|
||||
# 对象化重构 P1（方案见 wiki/14-oo-refactor.md）：
|
||||
# 将 Translator/Handles 的共享状态集中于此。后续 Mixin
|
||||
# （TypeGen/StructGen/ExprGen/CallGen/FuncGen/ClassGen/StmtGen/
|
||||
# ImportsGen）单继承本类，逐步把 Handles* 模块的函数迁移为
|
||||
# Generator 的方法，消除 (pool, builder, mod, node, ...) 六参连传。
|
||||
#
|
||||
# 注意：@t.NoVTable（静态绑定，骨架无多态需求；若未来需要
|
||||
# 运行时多态再改 @t.CVTable，字段布局由编译器统一管理）。
|
||||
# ============================================================
|
||||
@t.NoVTable
|
||||
class BaseGenMixin:
|
||||
|
||||
@@ -26,12 +26,6 @@ import lib.Stub.StubGen.VpiReader as VpiReader
|
||||
# ============================================================
|
||||
# CallGenBase - CallGenMixin 拆分 1/9（最底层父类）：模块符号查找 +
|
||||
# 返回类型解析基础设施
|
||||
#
|
||||
# 按功能域从 CallGenMixin.vp 拆出（500~1500 行/文件架构重构）：
|
||||
# 字段（15 个）+ InitCallGen + 模块符号查找（sha1/cexport/vpi/reexport/find_func_in_module）
|
||||
# + 返回类型解析链（_ensure_method_declare/_LookupMethodRetTyFromTextLL/_dep_text_ll_exists 等）
|
||||
#
|
||||
# @t.NoVTable：静态绑定（方法沿 MRO 直接调用 + this 调整）。
|
||||
# ============================================================
|
||||
|
||||
|
||||
@@ -310,8 +304,8 @@ class CallGenBase:
|
||||
if self.Gen is None or sha1 is None or func_name is None:
|
||||
return 0
|
||||
if self.Gen.CallGenBase.CexportSha1Arr is None:
|
||||
self.Gen.CallGenBase.CexportSha1Arr = CompilerFactory.get_perm_pool().alloc(_CEXPORT_MAX * 17)
|
||||
self.Gen.CallGenBase.CexportFuncArr = CompilerFactory.get_perm_pool().alloc(_CEXPORT_MAX * 64)
|
||||
self.Gen.CallGenBase.CexportSha1Arr = CompilerFactory.factory.PermPool.alloc(_CEXPORT_MAX * 17)
|
||||
self.Gen.CallGenBase.CexportFuncArr = CompilerFactory.factory.PermPool.alloc(_CEXPORT_MAX * 64)
|
||||
if self.Gen.CallGenBase.CexportSha1Arr is None or self.Gen.CallGenBase.CexportFuncArr is None:
|
||||
return 0
|
||||
string.memset(self.Gen.CallGenBase.CexportSha1Arr, 0, _CEXPORT_MAX * 17)
|
||||
|
||||
@@ -930,29 +930,12 @@ class CallGenDispatch(CallGenBase.CallGenBase):
|
||||
if st_at.value.kind() == ast.ASTKind.Name:
|
||||
st_nm: ast.Name | t.CPtr = (ast.Name | t.CPtr)(st_at.value)
|
||||
if st_nm.id is not None:
|
||||
# 仅当该名称不是普通变量且是已注册结构体类名时尝试静态/类方法
|
||||
# 追加"非导入模块"条件：st_nm.id 是模块名（import X as Y 把别名
|
||||
# Y 加入 _imported_modules，HandlesImports L344-347）时，X.Y(...)
|
||||
# 是模块限定调用（Module.Class 构造 / Module.func 函数），不是
|
||||
# ClassName.method(obj,args)。模块名与类名同名时（CompilerFactory.
|
||||
# CompilerFactory(...) 构造 / .set_factory(...) 函数，main.vp
|
||||
# 追加84/84b 根因）get_struct_type(st_nm.id) 会误判为类名 →
|
||||
# 把首实参当 self 传 _call_method_on_ptr → 返回类型查 "X.Y" 永远
|
||||
# 落空 → fail-fast。模块限定调用由尾部 ctor 检测（L7441 模块限定
|
||||
# 构造）与跨模块函数路径正确路由。
|
||||
st_var: llvmlite.Value | t.CPtr = self.Gen.VarGen.lookup_var(
|
||||
trans.SymTab, st_nm.id)
|
||||
if st_var is None and self.Gen.StructGen.get_struct_type(st_nm.id) is not None \
|
||||
and self.Gen.ImportsGen.is_module_imported(
|
||||
trans._imported_modules, st_nm.id) == 0:
|
||||
# REnum 变体构造优先于静态/类方法调用：
|
||||
# ClassName.VariantName(args)（如 Option.Some(42)）若被当
|
||||
# "实例方法经类名调用"处理，会把首实参 42 当 self 传
|
||||
# _call_method_on_ptr → 查 "Option.Some" 方法返回类型 →
|
||||
# 跨模块 stub 未命中 → fail-fast（EnumTest "方法
|
||||
# 'Option.Some' 返回类型无法确定" 根因）。REnum 变体
|
||||
# 构造检测原在 translate_call 尾部（L7493），被本分支
|
||||
# 拦截先执行不到，此处提前检测。
|
||||
if self.Gen.ClassGenEnum._is_renum_class_name(st_nm.id) != 0:
|
||||
rc_tag_sc: int = self.Gen.ClassGenEnum._lookup_renum_variant_in_class(
|
||||
st_nm.id, func_name)
|
||||
|
||||
@@ -591,7 +591,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
"""确保闭包名表已分配，0 失败"""
|
||||
if self.ClosureNames is not None:
|
||||
return 1
|
||||
self.ClosureNames = CompilerFactory.get_perm_pool().alloc(64 * MAX_CLOSURE_NAMES)
|
||||
self.ClosureNames = CompilerFactory.factory.PermPool.alloc(64 * MAX_CLOSURE_NAMES)
|
||||
if self.ClosureNames is None:
|
||||
return 0
|
||||
string.memset(self.ClosureNames, 0, 64 * MAX_CLOSURE_NAMES)
|
||||
@@ -627,8 +627,8 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
"""确保函数指针签名表已分配（stdlib.malloc，懒初始化）"""
|
||||
if self.FuncptrNames is not None:
|
||||
return 1
|
||||
self.FuncptrNames = CompilerFactory.get_perm_pool().alloc(64 * MAX_FUNC_PTR_SIGS)
|
||||
self.FuncptrRets = CompilerFactory.get_perm_pool().alloc(8 * MAX_FUNC_PTR_SIGS)
|
||||
self.FuncptrNames = CompilerFactory.factory.PermPool.alloc(64 * MAX_FUNC_PTR_SIGS)
|
||||
self.FuncptrRets = CompilerFactory.factory.PermPool.alloc(8 * MAX_FUNC_PTR_SIGS)
|
||||
if self.FuncptrNames is None or self.FuncptrRets is None:
|
||||
return 0
|
||||
string.memset(self.FuncptrNames, 0, 64 * MAX_FUNC_PTR_SIGS)
|
||||
@@ -650,7 +650,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
# ret_ty 是调用方 pool 分配的裸 LLVMType，1a 每文件 reset 后悬空；
|
||||
# 深拷贝到 perm_pool（lookup_func_ptr_ret 跨文件读取）
|
||||
ret_copy_fp: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), ret_ty)
|
||||
CompilerFactory.factory.PermPool, ret_ty)
|
||||
if ret_copy_fp is not None:
|
||||
self.FuncptrRets[self.FuncptrCount] = t.CUInt64T(ret_copy_fp)
|
||||
else:
|
||||
@@ -1011,7 +1011,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
if self.GlobalFuncs is not None:
|
||||
return 1
|
||||
size: t.CSizeT = GLOBAL_FUNC_MAX * GenTypes.FuncEntry.__sizeof__()
|
||||
self.GlobalFuncs = CompilerFactory.get_perm_pool().alloc(size)
|
||||
self.GlobalFuncs = CompilerFactory.factory.PermPool.alloc(size)
|
||||
if self.GlobalFuncs is None:
|
||||
return 0
|
||||
string.memset(self.GlobalFuncs, 0, size)
|
||||
@@ -1058,7 +1058,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
|
||||
# 深拷贝到 stdlib 区（TypeStr 跨文件永久存活）
|
||||
ts_len: t.CSizeT = string.strlen(ty_buf)
|
||||
ts_copy: str = CompilerFactory.get_perm_pool().alloc(ts_len + 1)
|
||||
ts_copy: str = CompilerFactory.factory.PermPool.alloc(ts_len + 1)
|
||||
if ts_copy is None:
|
||||
return None
|
||||
string.strcpy(ts_copy, ty_buf)
|
||||
@@ -1088,7 +1088,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
# Name 深拷贝到 stdlib 区：全局表跨文件永久存活，pool 内名字会被 1b 每文件
|
||||
# reset_to(mark1) 回收导致悬空（vtable 生成 find_func_global 后 strcmp 崩溃）
|
||||
name_len: t.CSizeT = string.strlen(name)
|
||||
name_copy: str = CompilerFactory.get_perm_pool().alloc(name_len + 1)
|
||||
name_copy: str = CompilerFactory.factory.PermPool.alloc(name_len + 1)
|
||||
if name_copy is None:
|
||||
return 1
|
||||
string.strcpy(name_copy, name)
|
||||
@@ -1144,7 +1144,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
if self.GlobalDefaults is not None:
|
||||
return 1
|
||||
size: t.CSizeT = GLOBAL_DEFAULTS_MAX * GenTypes.FuncDefaultsEntry.__sizeof__()
|
||||
self.GlobalDefaults = CompilerFactory.get_perm_pool().alloc(size)
|
||||
self.GlobalDefaults = CompilerFactory.factory.PermPool.alloc(size)
|
||||
if self.GlobalDefaults is None:
|
||||
return 0
|
||||
string.memset(self.GlobalDefaults, 0, size)
|
||||
@@ -1175,7 +1175,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
entry: GenTypes.FuncDefaultsEntry | t.CPtr = (GenTypes.FuncDefaultsEntry | t.CPtr)(t.CVoid(entry_addr, t.CPtr))
|
||||
# Name 深拷贝到 stdlib（全局表跨文件永久存活）
|
||||
nm_len: t.CSizeT = string.strlen(name)
|
||||
nm_copy: str = CompilerFactory.get_perm_pool().alloc(nm_len + 1)
|
||||
nm_copy: str = CompilerFactory.factory.PermPool.alloc(nm_len + 1)
|
||||
if nm_copy is None:
|
||||
return 1
|
||||
string.strcpy(nm_copy, name)
|
||||
@@ -1192,9 +1192,9 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
return 0
|
||||
# 提取常量快照到 stdlib
|
||||
if default_count > 0:
|
||||
kinds: t.CInt | t.CPtr = CompilerFactory.get_perm_pool().alloc(default_count * 4)
|
||||
ints: t.CInt64T | t.CPtr = CompilerFactory.get_perm_pool().alloc(default_count * 8)
|
||||
strs: t.CSizeT | t.CPtr = CompilerFactory.get_perm_pool().alloc(default_count * 8)
|
||||
kinds: t.CInt | t.CPtr = CompilerFactory.factory.PermPool.alloc(default_count * 4)
|
||||
ints: t.CInt64T | t.CPtr = CompilerFactory.factory.PermPool.alloc(default_count * 8)
|
||||
strs: t.CSizeT | t.CPtr = CompilerFactory.factory.PermPool.alloc(default_count * 8)
|
||||
if kinds is not None and ints is not None and strs is not None:
|
||||
string.memset(kinds, 0, default_count * 4)
|
||||
string.memset(ints, 0, default_count * 8)
|
||||
@@ -1209,7 +1209,7 @@ class CallGenLeafKit(CallGenCBuiltin.CallGenCBuiltin):
|
||||
ints[di] = dcn.int_val
|
||||
if dcn.const_kind == ast.CONST_STR and dcn.str_val is not None:
|
||||
slen: t.CSizeT = string.strlen(dcn.str_val)
|
||||
scopy: str = CompilerFactory.get_perm_pool().alloc(slen + 1)
|
||||
scopy: str = CompilerFactory.factory.PermPool.alloc(slen + 1)
|
||||
if scopy is not None:
|
||||
string.strcpy(scopy, dcn.str_val)
|
||||
strs[di] = t.CSizeT(scopy)
|
||||
|
||||
@@ -397,9 +397,9 @@ class ClassGenBase:
|
||||
if pool is None or cls is None or field is None:
|
||||
return -1
|
||||
if self.ClassMetaKinds is None:
|
||||
self.ClassMetaKinds = CompilerFactory.get_perm_pool().alloc(CLASS_META_MAX * 4)
|
||||
self.ClassMetaClss = CompilerFactory.get_perm_pool().alloc(CLASS_META_MAX * 64)
|
||||
self.ClassMetaFields = CompilerFactory.get_perm_pool().alloc(CLASS_META_MAX * 64)
|
||||
self.ClassMetaKinds = CompilerFactory.factory.PermPool.alloc(CLASS_META_MAX * 4)
|
||||
self.ClassMetaClss = CompilerFactory.factory.PermPool.alloc(CLASS_META_MAX * 64)
|
||||
self.ClassMetaFields = CompilerFactory.factory.PermPool.alloc(CLASS_META_MAX * 64)
|
||||
if self.ClassMetaKinds is None or self.ClassMetaClss is None or self.ClassMetaFields is None:
|
||||
return -1
|
||||
string.memset(self.ClassMetaKinds, 0, CLASS_META_MAX * 4)
|
||||
@@ -455,11 +455,11 @@ class ClassGenBase:
|
||||
if pool is None or func_name is None or wrapper_name is None:
|
||||
return -1
|
||||
if self.DecoratorFuncNames is None:
|
||||
self.DecoratorFuncNames = CompilerFactory.get_perm_pool().alloc(
|
||||
self.DecoratorFuncNames = CompilerFactory.factory.PermPool.alloc(
|
||||
DECOR_FUNC_MAX * DECOR_NAME_LEN)
|
||||
self.DecoratorWrapNames = CompilerFactory.get_perm_pool().alloc(
|
||||
self.DecoratorWrapNames = CompilerFactory.factory.PermPool.alloc(
|
||||
DECOR_FUNC_MAX * DECOR_NAME_LEN)
|
||||
self.DecoratorArgs = CompilerFactory.get_perm_pool().alloc(
|
||||
self.DecoratorArgs = CompilerFactory.factory.PermPool.alloc(
|
||||
DECOR_FUNC_MAX * 8)
|
||||
if self.DecoratorFuncNames is None or self.DecoratorWrapNames is None \
|
||||
or self.DecoratorArgs is None:
|
||||
@@ -505,7 +505,7 @@ class ClassGenBase:
|
||||
"""懒初始化异常表（perm_pool），返回 0 成功"""
|
||||
if self.ExceptionNames is not None:
|
||||
return 0
|
||||
pp_e: memhub.MemBuddy | t.CPtr = CompilerFactory.get_perm_pool()
|
||||
pp_e: memhub.MemBuddy | t.CPtr = CompilerFactory.factory.PermPool
|
||||
if pp_e is None:
|
||||
return -1
|
||||
self.ExceptionNames = pp_e.alloc(EXCEPTION_MAX * EXCEPTION_NAME_LEN)
|
||||
@@ -710,8 +710,8 @@ class ClassGenBase:
|
||||
return
|
||||
# 懒初始化
|
||||
if self.MethodMetaKeys is None:
|
||||
self.MethodMetaKeys = CompilerFactory.get_perm_pool().alloc(META_MAX * META_KEY_LEN)
|
||||
self.MethodMetaFlags = CompilerFactory.get_perm_pool().alloc(META_MAX * 4)
|
||||
self.MethodMetaKeys = CompilerFactory.factory.PermPool.alloc(META_MAX * META_KEY_LEN)
|
||||
self.MethodMetaFlags = CompilerFactory.factory.PermPool.alloc(META_MAX * 4)
|
||||
if self.MethodMetaKeys is None or self.MethodMetaFlags is None:
|
||||
return
|
||||
string.memset(self.MethodMetaKeys, 0, META_MAX * META_KEY_LEN)
|
||||
@@ -902,7 +902,7 @@ class ClassGenBase:
|
||||
while orig[og_len] != ' ' and orig[og_len] != '\0':
|
||||
og_len += 1
|
||||
if og_len > 0:
|
||||
og_buf: str = CompilerFactory.get_perm_pool().alloc(og_len + 1)
|
||||
og_buf: str = CompilerFactory.factory.PermPool.alloc(og_len + 1)
|
||||
if og_buf is not None:
|
||||
string.strncpy(og_buf, orig, og_len)
|
||||
og_buf[og_len] = '\0'
|
||||
|
||||
@@ -105,13 +105,13 @@ class ClassGenDef(ClassGenBase.ClassGenBase):
|
||||
# 读悬空挂起（G3 LinkedNode.prepend 挂起根因）。DeepCopyType
|
||||
# 递归深拷贝字段链表/子类型/Name 到 stdlib（深度上限+链守卫）。
|
||||
ty_deep: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), existing.Ty)
|
||||
CompilerFactory.factory.PermPool, existing.Ty)
|
||||
if ty_deep is not None:
|
||||
existing.Ty = ty_deep
|
||||
old_name: str = llvmlite.get_struct_name(existing.Ty)
|
||||
if old_name is not None:
|
||||
on_len: t.CSizeT = string.strlen(old_name)
|
||||
on_copy: str = CompilerFactory.get_perm_pool().alloc(on_len + 1)
|
||||
on_copy: str = CompilerFactory.factory.PermPool.alloc(on_len + 1)
|
||||
if on_copy is not None:
|
||||
string.strcpy(on_copy, old_name)
|
||||
c.DerefAs(existing.Ty, llvmlite.LLVMType.Struct(
|
||||
@@ -461,7 +461,7 @@ class ClassGenDef(ClassGenBase.ClassGenBase):
|
||||
type_name = name_buf
|
||||
if trans._declare_only == 0 and type_name is not None:
|
||||
tn_len: t.CSizeT = string.strlen(type_name)
|
||||
tn_copy: str = CompilerFactory.get_perm_pool().alloc(tn_len + 1)
|
||||
tn_copy: str = CompilerFactory.factory.PermPool.alloc(tn_len + 1)
|
||||
if tn_copy is not None:
|
||||
string.strcpy(tn_copy, type_name)
|
||||
type_name = tn_copy
|
||||
@@ -484,7 +484,7 @@ class ClassGenDef(ClassGenBase.ClassGenBase):
|
||||
# 崩溃（LoopTest _scan_type_for_cross_module_refs 0xFFFF 根因）。
|
||||
if trans._declare_only == 0 or self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||||
st_copy: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), struct_ty)
|
||||
CompilerFactory.factory.PermPool, struct_ty)
|
||||
if st_copy is not None:
|
||||
struct_ty = st_copy
|
||||
type_name = llvmlite.get_struct_name(struct_ty)
|
||||
@@ -522,7 +522,7 @@ class ClassGenDef(ClassGenBase.ClassGenBase):
|
||||
# find_struct(ParentName) strcmp 解引用 → 用 stdlib 拷贝保证跨文件存活
|
||||
if self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||||
pn_len: t.CSizeT = string.strlen(parent_name)
|
||||
pn_buf: str = CompilerFactory.get_perm_pool().alloc(pn_len + 1)
|
||||
pn_buf: str = CompilerFactory.factory.PermPool.alloc(pn_len + 1)
|
||||
if pn_buf is not None:
|
||||
string.strcpy(pn_buf, parent_name)
|
||||
entry.ParentName = pn_buf
|
||||
|
||||
@@ -508,7 +508,7 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
# （LoopTest _scan_type_for_cross_module_refs 0xFFFF 根因）。
|
||||
if trans._declare_only == 0 or self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||||
union_copy: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), union_ty)
|
||||
CompilerFactory.factory.PermPool, union_ty)
|
||||
if union_copy is not None:
|
||||
union_ty = union_copy
|
||||
|
||||
@@ -779,7 +779,7 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
# StdlibAlloc=1（Phase2 mark2 后）也必须深拷贝：同 union 的悬空根因。
|
||||
if trans._declare_only == 0 or self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||||
renum_copy: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), renum_ty)
|
||||
CompilerFactory.factory.PermPool, renum_ty)
|
||||
if renum_copy is not None:
|
||||
renum_ty = renum_copy
|
||||
|
||||
@@ -844,10 +844,10 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
# 若用 pool 会被 reset_to(mark1) 回收导致悬空（LLVMType 的 match 在
|
||||
# parser.vp 等后续文件翻译时访问已回收的表 → 崩溃）。
|
||||
if self.RenumClassNames is None:
|
||||
self.RenumClassNames = CompilerFactory.get_perm_pool().alloc(8 * RENUM_CLASS_MAX)
|
||||
self.RenumClassVariantCounts = CompilerFactory.get_perm_pool().alloc(8 * RENUM_CLASS_MAX)
|
||||
self.RenumVariantNames = CompilerFactory.get_perm_pool().alloc(8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||||
self.RenumVariantTags = CompilerFactory.get_perm_pool().alloc(8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||||
self.RenumClassNames = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX)
|
||||
self.RenumClassVariantCounts = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX)
|
||||
self.RenumVariantNames = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||||
self.RenumVariantTags = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||||
if (self.RenumClassNames is None or self.RenumClassVariantCounts is None
|
||||
or self.RenumVariantNames is None or self.RenumVariantTags is None):
|
||||
self.RenumClassNames = None
|
||||
@@ -893,7 +893,7 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
# _lookup_renum_variant/_is_renum_class_name 的 strcmp 会读毒化内存）
|
||||
idx: int = self.RenumClassCount
|
||||
cn_len_rv: t.CSizeT = string.strlen(class_name)
|
||||
cn_buf_rv: str = CompilerFactory.get_perm_pool().alloc(cn_len_rv + 1)
|
||||
cn_buf_rv: str = CompilerFactory.factory.PermPool.alloc(cn_len_rv + 1)
|
||||
if cn_buf_rv is None:
|
||||
return
|
||||
string.strcpy(cn_buf_rv, class_name)
|
||||
@@ -923,7 +923,7 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
name_offset: t.CSizeT = idx * RENUM_VARIANT_PER_CLASS + tag
|
||||
# 变体名同样 strcpy 到 perm_pool（1a 每文件 reset 后 vcd.name 悬空）
|
||||
vn_len_rv: t.CSizeT = string.strlen(vcd.name)
|
||||
vn_buf_rv: str = CompilerFactory.get_perm_pool().alloc(vn_len_rv + 1)
|
||||
vn_buf_rv: str = CompilerFactory.factory.PermPool.alloc(vn_len_rv + 1)
|
||||
if vn_buf_rv is None:
|
||||
break
|
||||
string.strcpy(vn_buf_rv, vcd.name)
|
||||
@@ -993,7 +993,7 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
|
||||
# 懒初始化表（perm_pool：1a 每文件 reset 后表本体不被回收）
|
||||
if self.RenumAliasClass is None:
|
||||
alias_pool_rfa: memhub.MemBuddy | t.CPtr = CompilerFactory.get_perm_pool()
|
||||
alias_pool_rfa: memhub.MemBuddy | t.CPtr = CompilerFactory.factory.PermPool
|
||||
self.RenumAliasClass = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||||
self.RenumAliasField = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||||
self.RenumAliasIndex = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||||
@@ -1032,7 +1032,7 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
# class_name 槽位保持原指针：_update_renum_alias_class_ptr 会统一为
|
||||
# entry.Name（perm_pool 拷贝），指针值比较契约不变。
|
||||
fn_len_rfa: t.CSizeT = string.strlen(field_name)
|
||||
fn_buf_rfa: str = CompilerFactory.get_perm_pool().alloc(fn_len_rfa + 1)
|
||||
fn_buf_rfa: str = CompilerFactory.factory.PermPool.alloc(fn_len_rfa + 1)
|
||||
if fn_buf_rfa is None:
|
||||
return
|
||||
string.strcpy(fn_buf_rfa, field_name)
|
||||
@@ -1043,14 +1043,14 @@ class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||||
self.RenumAliasTy[idx] = 0
|
||||
if field_ty is not None:
|
||||
ty_copy_rfa: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), field_ty)
|
||||
CompilerFactory.factory.PermPool, field_ty)
|
||||
if ty_copy_rfa is not None:
|
||||
self.RenumAliasTy[idx] = t.CSizeT(ty_copy_rfa)
|
||||
# 变体名同样 strcpy 到 perm_pool（1a reset 后 variant_cd.name 悬空）
|
||||
self.RenumAliasVariant[idx] = 0
|
||||
if variant_name is not None:
|
||||
vn_len_rfa: t.CSizeT = string.strlen(variant_name)
|
||||
vn_buf_rfa: str = CompilerFactory.get_perm_pool().alloc(vn_len_rfa + 1)
|
||||
vn_buf_rfa: str = CompilerFactory.factory.PermPool.alloc(vn_len_rfa + 1)
|
||||
if vn_buf_rfa is not None:
|
||||
string.strcpy(vn_buf_rfa, variant_name)
|
||||
self.RenumAliasVariant[idx] = t.CSizeT(vn_buf_rfa)
|
||||
|
||||
@@ -67,7 +67,7 @@ class ClassGenGeneric(ClassGenBase.ClassGenBase):
|
||||
self.GenericClassSha1s = list[str](pool, 8)
|
||||
self.GenericClassFiles = list[str](pool, 8)
|
||||
if self.GenericClassTpParams is None:
|
||||
self.GenericClassTpParams = CompilerFactory.get_perm_pool().alloc(GENERIC_TEMPLATE_MAX * 8)
|
||||
self.GenericClassTpParams = CompilerFactory.factory.PermPool.alloc(GENERIC_TEMPLATE_MAX * 8)
|
||||
if self.GenericClassTpParams is None:
|
||||
return
|
||||
string.memset(self.GenericClassTpParams, 0, GENERIC_TEMPLATE_MAX * 8)
|
||||
@@ -108,7 +108,7 @@ class ClassGenGeneric(ClassGenBase.ClassGenBase):
|
||||
tp_name: str = tp.get(ti)
|
||||
if tp_name is not None:
|
||||
total += string.strlen(tp_name) + 1
|
||||
buf: str = CompilerFactory.get_perm_pool().alloc(total)
|
||||
buf: str = CompilerFactory.factory.PermPool.alloc(total)
|
||||
if buf is None:
|
||||
return None
|
||||
buf[0] = '\0'
|
||||
@@ -426,8 +426,8 @@ class ClassGenGeneric(ClassGenBase.ClassGenBase):
|
||||
if spec_key is None or spec_name is None:
|
||||
return
|
||||
if self.SpecKeys is None:
|
||||
self.SpecKeys = CompilerFactory.get_perm_pool().alloc(SPEC_CACHE_MAX * 8)
|
||||
self.SpecNames = CompilerFactory.get_perm_pool().alloc(SPEC_CACHE_MAX * 8)
|
||||
self.SpecKeys = CompilerFactory.factory.PermPool.alloc(SPEC_CACHE_MAX * 8)
|
||||
self.SpecNames = CompilerFactory.factory.PermPool.alloc(SPEC_CACHE_MAX * 8)
|
||||
if self.SpecKeys is None or self.SpecNames is None:
|
||||
return
|
||||
string.memset(self.SpecKeys, 0, SPEC_CACHE_MAX * 8)
|
||||
@@ -438,8 +438,8 @@ class ClassGenGeneric(ClassGenBase.ClassGenBase):
|
||||
# 深拷贝字符串到 stdlib 区
|
||||
key_len: t.CSizeT = string.strlen(spec_key)
|
||||
name_len: t.CSizeT = string.strlen(spec_name)
|
||||
key_copy: str = CompilerFactory.get_perm_pool().alloc(key_len + 1)
|
||||
name_copy: str = CompilerFactory.get_perm_pool().alloc(name_len + 1)
|
||||
key_copy: str = CompilerFactory.factory.PermPool.alloc(key_len + 1)
|
||||
name_copy: str = CompilerFactory.factory.PermPool.alloc(name_len + 1)
|
||||
if key_copy is None or name_copy is None:
|
||||
return
|
||||
string.strcpy(key_copy, spec_key)
|
||||
@@ -485,7 +485,7 @@ class ClassGenGeneric(ClassGenBase.ClassGenBase):
|
||||
if string.strcmp(entry_rt.Name, spec_name) != 0:
|
||||
return 0
|
||||
ts_len_r: t.CSizeT = string.strlen(trigger_sha1)
|
||||
ts_buf_r: str = CompilerFactory.get_perm_pool().alloc(ts_len_r + 1)
|
||||
ts_buf_r: str = CompilerFactory.factory.PermPool.alloc(ts_len_r + 1)
|
||||
if ts_buf_r is None:
|
||||
return 0
|
||||
string.strcpy(ts_buf_r, trigger_sha1)
|
||||
@@ -512,7 +512,7 @@ class ClassGenGeneric(ClassGenBase.ClassGenBase):
|
||||
# 特化触发文件 sha1：进入函数时 trans.ModuleSha1 是触发方文件，
|
||||
# 翻译特化类时会被切换为模板 sha1（见下方），作废重译时按此重置
|
||||
# 特化类 MethodsEmitted（见 _record_spec_trigger / reset_module_methods_emitted）
|
||||
spec_trigger_sha1: str = trans.ModuleSha1
|
||||
spec_trigger_sha1: str = trans.ModuleSha1
|
||||
if self.GenericSpecDepth > GENERIC_SPEC_MAX_DEPTH:
|
||||
err_spec: str = trans.Pool.alloc(256)
|
||||
if err_spec is not None:
|
||||
|
||||
@@ -139,10 +139,10 @@ class ClassGenVTable(ClassGenBase.ClassGenBase):
|
||||
# 1. 收集虚方法信息
|
||||
# stdlib 分配：method_names_buf 存到 StructEntry.VTableMethods（跨文件永久存活），
|
||||
# 必须迁出 mb 池 reset 区间，否则 1b 每文件 reset_to(mark1) 会回收导致悬空。
|
||||
full_names_buf: t.CSizeT | t.CPtr = CompilerFactory.get_perm_pool().alloc(8 * VTBL_METHOD_MAX)
|
||||
method_names_buf: t.CSizeT | t.CPtr = CompilerFactory.get_perm_pool().alloc(8 * VTBL_METHOD_MAX)
|
||||
full_names_buf: t.CSizeT | t.CPtr = CompilerFactory.factory.PermPool.alloc(8 * VTBL_METHOD_MAX)
|
||||
method_names_buf: t.CSizeT | t.CPtr = CompilerFactory.factory.PermPool.alloc(8 * VTBL_METHOD_MAX)
|
||||
# 记录每个方法的父类 SHA1（非 0=继承方法用父模块 SHA1 mangling，0=当前类方法）
|
||||
method_parent_sha1s: t.CSizeT | t.CPtr = CompilerFactory.get_perm_pool().alloc(8 * VTBL_METHOD_MAX)
|
||||
method_parent_sha1s: t.CSizeT | t.CPtr = CompilerFactory.factory.PermPool.alloc(8 * VTBL_METHOD_MAX)
|
||||
if full_names_buf is None or method_names_buf is None or method_parent_sha1s is None:
|
||||
return 0
|
||||
string.memset(full_names_buf, 0, 8 * VTBL_METHOD_MAX)
|
||||
@@ -232,13 +232,13 @@ class ClassGenVTable(ClassGenBase.ClassGenBase):
|
||||
def_class = anc
|
||||
break
|
||||
mro_i += 1
|
||||
pfname_buf: str = CompilerFactory.get_perm_pool().alloc(128)
|
||||
pfname_buf: str = CompilerFactory.factory.PermPool.alloc(128)
|
||||
if pfname_buf is not None:
|
||||
viperlib.snprintf(pfname_buf, 128, "%s.%s", def_class, pmethod_name)
|
||||
full_names_buf[method_count] = t.CSizeT(pfname_buf)
|
||||
# 复制方法名（短名）
|
||||
pmname_len: t.CSizeT = string.strlen(pmethod_name)
|
||||
pmname_buf: str = CompilerFactory.get_perm_pool().alloc(pmname_len + 1)
|
||||
pmname_buf: str = CompilerFactory.factory.PermPool.alloc(pmname_len + 1)
|
||||
if pmname_buf is not None:
|
||||
string.strcpy(pmname_buf, pmethod_name)
|
||||
method_names_buf[method_count] = t.CSizeT(pmname_buf)
|
||||
@@ -294,14 +294,14 @@ class ClassGenVTable(ClassGenBase.ClassGenBase):
|
||||
# 构造 full_name = "ClassName.method_name"
|
||||
# 内容必须落在 perm_pool：1a（mark_only=1）收集的 VTableMethods 被
|
||||
# Phase 1b 依赖模块翻译跨文件读取，1a 每文件 reset 后 pool 裸字符串悬空
|
||||
fname_buf: str = CompilerFactory.get_perm_pool().alloc(128)
|
||||
fname_buf: str = CompilerFactory.factory.PermPool.alloc(128)
|
||||
if fname_buf is not None:
|
||||
viperlib.snprintf(fname_buf, 128, "%s.%s", class_name, mname)
|
||||
full_names_buf[method_count] = t.CSizeT(fname_buf)
|
||||
|
||||
# 复制方法名
|
||||
mname_len: t.CSizeT = string.strlen(mname)
|
||||
mname_buf: str = CompilerFactory.get_perm_pool().alloc(mname_len + 1)
|
||||
mname_buf: str = CompilerFactory.factory.PermPool.alloc(mname_len + 1)
|
||||
if mname_buf is not None:
|
||||
string.strcpy(mname_buf, mname)
|
||||
method_names_buf[method_count] = t.CSizeT(mname_buf)
|
||||
|
||||
@@ -78,8 +78,8 @@ class ExprGenCls(ExprGenBase.ExprGenBase):
|
||||
if string.strlen(doc) == 0:
|
||||
return
|
||||
if self.DocKeys is None:
|
||||
self.DocKeys = CompilerFactory.get_perm_pool().alloc(DOC_MAX * DOC_KEY_SZ)
|
||||
self.DocValues = CompilerFactory.get_perm_pool().alloc(DOC_MAX * DOC_VAL_SZ)
|
||||
self.DocKeys = CompilerFactory.factory.PermPool.alloc(DOC_MAX * DOC_KEY_SZ)
|
||||
self.DocValues = CompilerFactory.factory.PermPool.alloc(DOC_MAX * DOC_VAL_SZ)
|
||||
if self.DocKeys is None or self.DocValues is None:
|
||||
return
|
||||
string.memset(self.DocKeys, 0, DOC_MAX * DOC_KEY_SZ)
|
||||
@@ -337,10 +337,6 @@ class ExprGenCls(ExprGenBase.ExprGenBase):
|
||||
if ca is None or ca.attr is None or ca.value is None:
|
||||
return None
|
||||
# 模块级函数调用（Module.func()）：接收者是已导入模块名而非类对象
|
||||
# （CompilerFactory.get_perm_pool()）。返回注解可能是联合类型
|
||||
# （memhub.MemBuddy | t.CPtr），查 vpi 模块函数返回注解（cls=None）
|
||||
# 提取返回类，解决链式方法调用 .alloc() 推断失败退化裸名 @alloc
|
||||
# （链接 undefined symbol: alloc 根因）。
|
||||
if ca.value.kind() == ast.ASTKind.Name:
|
||||
mod_nm2: str = ((ast.Name | t.CPtr)(ca.value)).id
|
||||
if mod_nm2 is not None and trans._from_imports is not None:
|
||||
|
||||
@@ -120,329 +120,329 @@ class Generator:
|
||||
if self is None:
|
||||
return
|
||||
# ---- alloc 46 个子对象 + 回指（永久池，fail-fast） ----
|
||||
SubBaseGen: BaseGenMixin.BaseGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(BaseGenMixin.BaseGenMixin.__sizeof__())
|
||||
SubBaseGen: BaseGenMixin.BaseGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(BaseGenMixin.BaseGenMixin.__sizeof__())
|
||||
if SubBaseGen is None:
|
||||
stdio.printf("FAIL: BaseGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubBaseGen, 0, BaseGenMixin.BaseGenMixin.__sizeof__())
|
||||
SubBaseGen.Gen = self
|
||||
self.BaseGen = SubBaseGen
|
||||
SubTypeGenBase: TypeGenBase.TypeGenBase | t.CPtr = CompilerFactory.get_perm_pool().alloc(TypeGenBase.TypeGenBase.__sizeof__())
|
||||
SubTypeGenBase: TypeGenBase.TypeGenBase | t.CPtr = CompilerFactory.factory.PermPool.alloc(TypeGenBase.TypeGenBase.__sizeof__())
|
||||
if SubTypeGenBase is None:
|
||||
stdio.printf("FAIL: TypeGenBase alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTypeGenBase, 0, TypeGenBase.TypeGenBase.__sizeof__())
|
||||
SubTypeGenBase.Gen = self
|
||||
self.TypeGenBase = SubTypeGenBase
|
||||
SubTypeGen: TypeGenMixin.TypeGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(TypeGenMixin.TypeGenMixin.__sizeof__())
|
||||
SubTypeGen: TypeGenMixin.TypeGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(TypeGenMixin.TypeGenMixin.__sizeof__())
|
||||
if SubTypeGen is None:
|
||||
stdio.printf("FAIL: TypeGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTypeGen, 0, TypeGenMixin.TypeGenMixin.__sizeof__())
|
||||
SubTypeGen.Gen = self
|
||||
self.TypeGen = SubTypeGen
|
||||
SubTypeGenCDef: TypeGenCDef.TypeGenCDef | t.CPtr = CompilerFactory.get_perm_pool().alloc(TypeGenCDef.TypeGenCDef.__sizeof__())
|
||||
SubTypeGenCDef: TypeGenCDef.TypeGenCDef | t.CPtr = CompilerFactory.factory.PermPool.alloc(TypeGenCDef.TypeGenCDef.__sizeof__())
|
||||
if SubTypeGenCDef is None:
|
||||
stdio.printf("FAIL: TypeGenCDef alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTypeGenCDef, 0, TypeGenCDef.TypeGenCDef.__sizeof__())
|
||||
SubTypeGenCDef.Gen = self
|
||||
self.TypeGenCDef = SubTypeGenCDef
|
||||
SubTypeGenCType: TypeGenCType.TypeGenCType | t.CPtr = CompilerFactory.get_perm_pool().alloc(TypeGenCType.TypeGenCType.__sizeof__())
|
||||
SubTypeGenCType: TypeGenCType.TypeGenCType | t.CPtr = CompilerFactory.factory.PermPool.alloc(TypeGenCType.TypeGenCType.__sizeof__())
|
||||
if SubTypeGenCType is None:
|
||||
stdio.printf("FAIL: TypeGenCType alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTypeGenCType, 0, TypeGenCType.TypeGenCType.__sizeof__())
|
||||
SubTypeGenCType.Gen = self
|
||||
self.TypeGenCType = SubTypeGenCType
|
||||
SubTypeGenResolve: TypeGenResolve.TypeGenResolve | t.CPtr = CompilerFactory.get_perm_pool().alloc(TypeGenResolve.TypeGenResolve.__sizeof__())
|
||||
SubTypeGenResolve: TypeGenResolve.TypeGenResolve | t.CPtr = CompilerFactory.factory.PermPool.alloc(TypeGenResolve.TypeGenResolve.__sizeof__())
|
||||
if SubTypeGenResolve is None:
|
||||
stdio.printf("FAIL: TypeGenResolve alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTypeGenResolve, 0, TypeGenResolve.TypeGenResolve.__sizeof__())
|
||||
SubTypeGenResolve.Gen = self
|
||||
self.TypeGenResolve = SubTypeGenResolve
|
||||
SubTypeGenErr: TypeGenErr.TypeGenErr | t.CPtr = CompilerFactory.get_perm_pool().alloc(TypeGenErr.TypeGenErr.__sizeof__())
|
||||
SubTypeGenErr: TypeGenErr.TypeGenErr | t.CPtr = CompilerFactory.factory.PermPool.alloc(TypeGenErr.TypeGenErr.__sizeof__())
|
||||
if SubTypeGenErr is None:
|
||||
stdio.printf("FAIL: TypeGenErr alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTypeGenErr, 0, TypeGenErr.TypeGenErr.__sizeof__())
|
||||
SubTypeGenErr.Gen = self
|
||||
self.TypeGenErr = SubTypeGenErr
|
||||
SubStructGen: StructGenMixin.StructGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(StructGenMixin.StructGenMixin.__sizeof__())
|
||||
SubStructGen: StructGenMixin.StructGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(StructGenMixin.StructGenMixin.__sizeof__())
|
||||
if SubStructGen is None:
|
||||
stdio.printf("FAIL: StructGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubStructGen, 0, StructGenMixin.StructGenMixin.__sizeof__())
|
||||
SubStructGen.Gen = self
|
||||
self.StructGen = SubStructGen
|
||||
SubExprGenBase: ExprGenBase.ExprGenBase | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenBase.ExprGenBase.__sizeof__())
|
||||
SubExprGenBase: ExprGenBase.ExprGenBase | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenBase.ExprGenBase.__sizeof__())
|
||||
if SubExprGenBase is None:
|
||||
stdio.printf("FAIL: ExprGenBase alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenBase, 0, ExprGenBase.ExprGenBase.__sizeof__())
|
||||
SubExprGenBase.Gen = self
|
||||
self.ExprGenBase = SubExprGenBase
|
||||
SubExprGen: ExprGenMixin.ExprGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenMixin.ExprGenMixin.__sizeof__())
|
||||
SubExprGen: ExprGenMixin.ExprGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenMixin.ExprGenMixin.__sizeof__())
|
||||
if SubExprGen is None:
|
||||
stdio.printf("FAIL: ExprGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGen, 0, ExprGenMixin.ExprGenMixin.__sizeof__())
|
||||
SubExprGen.Gen = self
|
||||
self.ExprGen = SubExprGen
|
||||
SubExprGenConst: ExprGenConst.ExprGenConst | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenConst.ExprGenConst.__sizeof__())
|
||||
SubExprGenConst: ExprGenConst.ExprGenConst | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenConst.ExprGenConst.__sizeof__())
|
||||
if SubExprGenConst is None:
|
||||
stdio.printf("FAIL: ExprGenConst alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenConst, 0, ExprGenConst.ExprGenConst.__sizeof__())
|
||||
SubExprGenConst.Gen = self
|
||||
self.ExprGenConst = SubExprGenConst
|
||||
SubExprGenFstr: ExprGenFstr.ExprGenFstr | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenFstr.ExprGenFstr.__sizeof__())
|
||||
SubExprGenFstr: ExprGenFstr.ExprGenFstr | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenFstr.ExprGenFstr.__sizeof__())
|
||||
if SubExprGenFstr is None:
|
||||
stdio.printf("FAIL: ExprGenFstr alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenFstr, 0, ExprGenFstr.ExprGenFstr.__sizeof__())
|
||||
SubExprGenFstr.Gen = self
|
||||
self.ExprGenFstr = SubExprGenFstr
|
||||
SubExprGenOps: ExprGenOps.ExprGenOps | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenOps.ExprGenOps.__sizeof__())
|
||||
SubExprGenOps: ExprGenOps.ExprGenOps | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenOps.ExprGenOps.__sizeof__())
|
||||
if SubExprGenOps is None:
|
||||
stdio.printf("FAIL: ExprGenOps alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenOps, 0, ExprGenOps.ExprGenOps.__sizeof__())
|
||||
SubExprGenOps.Gen = self
|
||||
self.ExprGenOps = SubExprGenOps
|
||||
SubExprGenCdef: ExprGenCdef.ExprGenCdef | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenCdef.ExprGenCdef.__sizeof__())
|
||||
SubExprGenCdef: ExprGenCdef.ExprGenCdef | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenCdef.ExprGenCdef.__sizeof__())
|
||||
if SubExprGenCdef is None:
|
||||
stdio.printf("FAIL: ExprGenCdef alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenCdef, 0, ExprGenCdef.ExprGenCdef.__sizeof__())
|
||||
SubExprGenCdef.Gen = self
|
||||
self.ExprGenCdef = SubExprGenCdef
|
||||
SubExprGenName: ExprGenName.ExprGenName | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenName.ExprGenName.__sizeof__())
|
||||
SubExprGenName: ExprGenName.ExprGenName | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenName.ExprGenName.__sizeof__())
|
||||
if SubExprGenName is None:
|
||||
stdio.printf("FAIL: ExprGenName alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenName, 0, ExprGenName.ExprGenName.__sizeof__())
|
||||
SubExprGenName.Gen = self
|
||||
self.ExprGenName = SubExprGenName
|
||||
SubExprGenAttr: ExprGenAttr.ExprGenAttr | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenAttr.ExprGenAttr.__sizeof__())
|
||||
SubExprGenAttr: ExprGenAttr.ExprGenAttr | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenAttr.ExprGenAttr.__sizeof__())
|
||||
if SubExprGenAttr is None:
|
||||
stdio.printf("FAIL: ExprGenAttr alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenAttr, 0, ExprGenAttr.ExprGenAttr.__sizeof__())
|
||||
SubExprGenAttr.Gen = self
|
||||
self.ExprGenAttr = SubExprGenAttr
|
||||
SubExprGenCls: ExprGenCls.ExprGenCls | t.CPtr = CompilerFactory.get_perm_pool().alloc(ExprGenCls.ExprGenCls.__sizeof__())
|
||||
SubExprGenCls: ExprGenCls.ExprGenCls | t.CPtr = CompilerFactory.factory.PermPool.alloc(ExprGenCls.ExprGenCls.__sizeof__())
|
||||
if SubExprGenCls is None:
|
||||
stdio.printf("FAIL: ExprGenCls alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubExprGenCls, 0, ExprGenCls.ExprGenCls.__sizeof__())
|
||||
SubExprGenCls.Gen = self
|
||||
self.ExprGenCls = SubExprGenCls
|
||||
SubCallGenBase: CallGenBase.CallGenBase | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenBase.CallGenBase.__sizeof__())
|
||||
SubCallGenBase: CallGenBase.CallGenBase | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenBase.CallGenBase.__sizeof__())
|
||||
if SubCallGenBase is None:
|
||||
stdio.printf("FAIL: CallGenBase alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenBase, 0, CallGenBase.CallGenBase.__sizeof__())
|
||||
SubCallGenBase.Gen = self
|
||||
self.CallGenBase = SubCallGenBase
|
||||
SubCallGenCBuiltin: CallGenCBuiltin.CallGenCBuiltin | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenCBuiltin.CallGenCBuiltin.__sizeof__())
|
||||
SubCallGenCBuiltin: CallGenCBuiltin.CallGenCBuiltin | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenCBuiltin.CallGenCBuiltin.__sizeof__())
|
||||
if SubCallGenCBuiltin is None:
|
||||
stdio.printf("FAIL: CallGenCBuiltin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenCBuiltin, 0, CallGenCBuiltin.CallGenCBuiltin.__sizeof__())
|
||||
SubCallGenCBuiltin.Gen = self
|
||||
self.CallGenCBuiltin = SubCallGenCBuiltin
|
||||
SubCallGenLeafKit: CallGenLeafKit.CallGenLeafKit | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenLeafKit.CallGenLeafKit.__sizeof__())
|
||||
SubCallGenLeafKit: CallGenLeafKit.CallGenLeafKit | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenLeafKit.CallGenLeafKit.__sizeof__())
|
||||
if SubCallGenLeafKit is None:
|
||||
stdio.printf("FAIL: CallGenLeafKit alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenLeafKit, 0, CallGenLeafKit.CallGenLeafKit.__sizeof__())
|
||||
SubCallGenLeafKit.Gen = self
|
||||
self.CallGenLeafKit = SubCallGenLeafKit
|
||||
SubCallGenCtor: CallGenCtor.CallGenCtor | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenCtor.CallGenCtor.__sizeof__())
|
||||
SubCallGenCtor: CallGenCtor.CallGenCtor | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenCtor.CallGenCtor.__sizeof__())
|
||||
if SubCallGenCtor is None:
|
||||
stdio.printf("FAIL: CallGenCtor alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenCtor, 0, CallGenCtor.CallGenCtor.__sizeof__())
|
||||
SubCallGenCtor.Gen = self
|
||||
self.CallGenCtor = SubCallGenCtor
|
||||
SubCallGenCall: CallGenCall.CallGenCall | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenCall.CallGenCall.__sizeof__())
|
||||
SubCallGenCall: CallGenCall.CallGenCall | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenCall.CallGenCall.__sizeof__())
|
||||
if SubCallGenCall is None:
|
||||
stdio.printf("FAIL: CallGenCall alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenCall, 0, CallGenCall.CallGenCall.__sizeof__())
|
||||
SubCallGenCall.Gen = self
|
||||
self.CallGenCall = SubCallGenCall
|
||||
SubCallGen: CallGenMixin.CallGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenMixin.CallGenMixin.__sizeof__())
|
||||
SubCallGen: CallGenMixin.CallGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenMixin.CallGenMixin.__sizeof__())
|
||||
if SubCallGen is None:
|
||||
stdio.printf("FAIL: CallGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGen, 0, CallGenMixin.CallGenMixin.__sizeof__())
|
||||
SubCallGen.Gen = self
|
||||
self.CallGen = SubCallGen
|
||||
SubCallGenDispatch: CallGenDispatch.CallGenDispatch | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenDispatch.CallGenDispatch.__sizeof__())
|
||||
SubCallGenDispatch: CallGenDispatch.CallGenDispatch | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenDispatch.CallGenDispatch.__sizeof__())
|
||||
if SubCallGenDispatch is None:
|
||||
stdio.printf("FAIL: CallGenDispatch alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenDispatch, 0, CallGenDispatch.CallGenDispatch.__sizeof__())
|
||||
SubCallGenDispatch.Gen = self
|
||||
self.CallGenDispatch = SubCallGenDispatch
|
||||
SubCallGenLib: CallGenLib.CallGenLib | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenLib.CallGenLib.__sizeof__())
|
||||
SubCallGenLib: CallGenLib.CallGenLib | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenLib.CallGenLib.__sizeof__())
|
||||
if SubCallGenLib is None:
|
||||
stdio.printf("FAIL: CallGenLib alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenLib, 0, CallGenLib.CallGenLib.__sizeof__())
|
||||
SubCallGenLib.Gen = self
|
||||
self.CallGenLib = SubCallGenLib
|
||||
SubCallGenVt: CallGenVt.CallGenVt | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenVt.CallGenVt.__sizeof__())
|
||||
SubCallGenVt: CallGenVt.CallGenVt | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenVt.CallGenVt.__sizeof__())
|
||||
if SubCallGenVt is None:
|
||||
stdio.printf("FAIL: CallGenVt alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenVt, 0, CallGenVt.CallGenVt.__sizeof__())
|
||||
SubCallGenVt.Gen = self
|
||||
self.CallGenVt = SubCallGenVt
|
||||
SubCallGenVa: CallGenVa.CallGenVa | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenVa.CallGenVa.__sizeof__())
|
||||
SubCallGenVa: CallGenVa.CallGenVa | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenVa.CallGenVa.__sizeof__())
|
||||
if SubCallGenVa is None:
|
||||
stdio.printf("FAIL: CallGenVa alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenVa, 0, CallGenVa.CallGenVa.__sizeof__())
|
||||
SubCallGenVa.Gen = self
|
||||
self.CallGenVa = SubCallGenVa
|
||||
SubCallGenProp: CallGenProp.CallGenProp | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenProp.CallGenProp.__sizeof__())
|
||||
SubCallGenProp: CallGenProp.CallGenProp | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenProp.CallGenProp.__sizeof__())
|
||||
if SubCallGenProp is None:
|
||||
stdio.printf("FAIL: CallGenProp alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenProp, 0, CallGenProp.CallGenProp.__sizeof__())
|
||||
SubCallGenProp.Gen = self
|
||||
self.CallGenProp = SubCallGenProp
|
||||
SubCallGenFd: CallGenFd.CallGenFd | t.CPtr = CompilerFactory.get_perm_pool().alloc(CallGenFd.CallGenFd.__sizeof__())
|
||||
SubCallGenFd: CallGenFd.CallGenFd | t.CPtr = CompilerFactory.factory.PermPool.alloc(CallGenFd.CallGenFd.__sizeof__())
|
||||
if SubCallGenFd is None:
|
||||
stdio.printf("FAIL: CallGenFd alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubCallGenFd, 0, CallGenFd.CallGenFd.__sizeof__())
|
||||
SubCallGenFd.Gen = self
|
||||
self.CallGenFd = SubCallGenFd
|
||||
SubFuncGenBase: FuncGenBase.FuncGenBase | t.CPtr = CompilerFactory.get_perm_pool().alloc(FuncGenBase.FuncGenBase.__sizeof__())
|
||||
SubFuncGenBase: FuncGenBase.FuncGenBase | t.CPtr = CompilerFactory.factory.PermPool.alloc(FuncGenBase.FuncGenBase.__sizeof__())
|
||||
if SubFuncGenBase is None:
|
||||
stdio.printf("FAIL: FuncGenBase alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubFuncGenBase, 0, FuncGenBase.FuncGenBase.__sizeof__())
|
||||
SubFuncGenBase.Gen = self
|
||||
self.FuncGenBase = SubFuncGenBase
|
||||
SubFuncGenDef: FuncGenDef.FuncGenDef | t.CPtr = CompilerFactory.get_perm_pool().alloc(FuncGenDef.FuncGenDef.__sizeof__())
|
||||
SubFuncGenDef: FuncGenDef.FuncGenDef | t.CPtr = CompilerFactory.factory.PermPool.alloc(FuncGenDef.FuncGenDef.__sizeof__())
|
||||
if SubFuncGenDef is None:
|
||||
stdio.printf("FAIL: FuncGenDef alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubFuncGenDef, 0, FuncGenDef.FuncGenDef.__sizeof__())
|
||||
SubFuncGenDef.Gen = self
|
||||
self.FuncGenDef = SubFuncGenDef
|
||||
SubFuncGen: FuncGenMixin.FuncGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(FuncGenMixin.FuncGenMixin.__sizeof__())
|
||||
SubFuncGen: FuncGenMixin.FuncGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(FuncGenMixin.FuncGenMixin.__sizeof__())
|
||||
if SubFuncGen is None:
|
||||
stdio.printf("FAIL: FuncGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubFuncGen, 0, FuncGenMixin.FuncGenMixin.__sizeof__())
|
||||
SubFuncGen.Gen = self
|
||||
self.FuncGen = SubFuncGen
|
||||
SubClassGenBase: ClassGenBase.ClassGenBase | t.CPtr = CompilerFactory.get_perm_pool().alloc(ClassGenBase.ClassGenBase.__sizeof__())
|
||||
SubClassGenBase: ClassGenBase.ClassGenBase | t.CPtr = CompilerFactory.factory.PermPool.alloc(ClassGenBase.ClassGenBase.__sizeof__())
|
||||
if SubClassGenBase is None:
|
||||
stdio.printf("FAIL: ClassGenBase alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubClassGenBase, 0, ClassGenBase.ClassGenBase.__sizeof__())
|
||||
SubClassGenBase.Gen = self
|
||||
self.ClassGenBase = SubClassGenBase
|
||||
SubClassGen: ClassGenMixin.ClassGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(ClassGenMixin.ClassGenMixin.__sizeof__())
|
||||
SubClassGen: ClassGenMixin.ClassGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(ClassGenMixin.ClassGenMixin.__sizeof__())
|
||||
if SubClassGen is None:
|
||||
stdio.printf("FAIL: ClassGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubClassGen, 0, ClassGenMixin.ClassGenMixin.__sizeof__())
|
||||
SubClassGen.Gen = self
|
||||
self.ClassGen = SubClassGen
|
||||
SubClassGenEnum: ClassGenEnum.ClassGenEnum | t.CPtr = CompilerFactory.get_perm_pool().alloc(ClassGenEnum.ClassGenEnum.__sizeof__())
|
||||
SubClassGenEnum: ClassGenEnum.ClassGenEnum | t.CPtr = CompilerFactory.factory.PermPool.alloc(ClassGenEnum.ClassGenEnum.__sizeof__())
|
||||
if SubClassGenEnum is None:
|
||||
stdio.printf("FAIL: ClassGenEnum alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubClassGenEnum, 0, ClassGenEnum.ClassGenEnum.__sizeof__())
|
||||
SubClassGenEnum.Gen = self
|
||||
self.ClassGenEnum = SubClassGenEnum
|
||||
SubClassGenGeneric: ClassGenGeneric.ClassGenGeneric | t.CPtr = CompilerFactory.get_perm_pool().alloc(ClassGenGeneric.ClassGenGeneric.__sizeof__())
|
||||
SubClassGenGeneric: ClassGenGeneric.ClassGenGeneric | t.CPtr = CompilerFactory.factory.PermPool.alloc(ClassGenGeneric.ClassGenGeneric.__sizeof__())
|
||||
if SubClassGenGeneric is None:
|
||||
stdio.printf("FAIL: ClassGenGeneric alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubClassGenGeneric, 0, ClassGenGeneric.ClassGenGeneric.__sizeof__())
|
||||
SubClassGenGeneric.Gen = self
|
||||
self.ClassGenGeneric = SubClassGenGeneric
|
||||
SubClassGenVTable: ClassGenVTable.ClassGenVTable | t.CPtr = CompilerFactory.get_perm_pool().alloc(ClassGenVTable.ClassGenVTable.__sizeof__())
|
||||
SubClassGenVTable: ClassGenVTable.ClassGenVTable | t.CPtr = CompilerFactory.factory.PermPool.alloc(ClassGenVTable.ClassGenVTable.__sizeof__())
|
||||
if SubClassGenVTable is None:
|
||||
stdio.printf("FAIL: ClassGenVTable alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubClassGenVTable, 0, ClassGenVTable.ClassGenVTable.__sizeof__())
|
||||
SubClassGenVTable.Gen = self
|
||||
self.ClassGenVTable = SubClassGenVTable
|
||||
SubClassGenDef: ClassGenDef.ClassGenDef | t.CPtr = CompilerFactory.get_perm_pool().alloc(ClassGenDef.ClassGenDef.__sizeof__())
|
||||
SubClassGenDef: ClassGenDef.ClassGenDef | t.CPtr = CompilerFactory.factory.PermPool.alloc(ClassGenDef.ClassGenDef.__sizeof__())
|
||||
if SubClassGenDef is None:
|
||||
stdio.printf("FAIL: ClassGenDef alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubClassGenDef, 0, ClassGenDef.ClassGenDef.__sizeof__())
|
||||
SubClassGenDef.Gen = self
|
||||
self.ClassGenDef = SubClassGenDef
|
||||
SubImportsGen: ImportsGenMixin.ImportsGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(ImportsGenMixin.ImportsGenMixin.__sizeof__())
|
||||
SubImportsGen: ImportsGenMixin.ImportsGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(ImportsGenMixin.ImportsGenMixin.__sizeof__())
|
||||
if SubImportsGen is None:
|
||||
stdio.printf("FAIL: ImportsGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubImportsGen, 0, ImportsGenMixin.ImportsGenMixin.__sizeof__())
|
||||
SubImportsGen.Gen = self
|
||||
self.ImportsGen = SubImportsGen
|
||||
SubStmtGenCif: StmtGenCifMixin.StmtGenCifMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(StmtGenCifMixin.StmtGenCifMixin.__sizeof__())
|
||||
SubStmtGenCif: StmtGenCifMixin.StmtGenCifMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(StmtGenCifMixin.StmtGenCifMixin.__sizeof__())
|
||||
if SubStmtGenCif is None:
|
||||
stdio.printf("FAIL: StmtGenCifMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubStmtGenCif, 0, StmtGenCifMixin.StmtGenCifMixin.__sizeof__())
|
||||
SubStmtGenCif.Gen = self
|
||||
self.StmtGenCif = SubStmtGenCif
|
||||
SubStmtGenDecl: StmtGenDeclMixin.StmtGenDeclMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(StmtGenDeclMixin.StmtGenDeclMixin.__sizeof__())
|
||||
SubStmtGenDecl: StmtGenDeclMixin.StmtGenDeclMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(StmtGenDeclMixin.StmtGenDeclMixin.__sizeof__())
|
||||
if SubStmtGenDecl is None:
|
||||
stdio.printf("FAIL: StmtGenDeclMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubStmtGenDecl, 0, StmtGenDeclMixin.StmtGenDeclMixin.__sizeof__())
|
||||
SubStmtGenDecl.Gen = self
|
||||
self.StmtGenDecl = SubStmtGenDecl
|
||||
SubStmtGen: StmtGenMixin.StmtGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(StmtGenMixin.StmtGenMixin.__sizeof__())
|
||||
SubStmtGen: StmtGenMixin.StmtGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(StmtGenMixin.StmtGenMixin.__sizeof__())
|
||||
if SubStmtGen is None:
|
||||
stdio.printf("FAIL: StmtGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubStmtGen, 0, StmtGenMixin.StmtGenMixin.__sizeof__())
|
||||
SubStmtGen.Gen = self
|
||||
self.StmtGen = SubStmtGen
|
||||
SubMatchGen: MatchGenMixin.MatchGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(MatchGenMixin.MatchGenMixin.__sizeof__())
|
||||
SubMatchGen: MatchGenMixin.MatchGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(MatchGenMixin.MatchGenMixin.__sizeof__())
|
||||
if SubMatchGen is None:
|
||||
stdio.printf("FAIL: MatchGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubMatchGen, 0, MatchGenMixin.MatchGenMixin.__sizeof__())
|
||||
SubMatchGen.Gen = self
|
||||
self.MatchGen = SubMatchGen
|
||||
SubAssignGen: AssignGenMixin.AssignGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(AssignGenMixin.AssignGenMixin.__sizeof__())
|
||||
SubAssignGen: AssignGenMixin.AssignGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(AssignGenMixin.AssignGenMixin.__sizeof__())
|
||||
if SubAssignGen is None:
|
||||
stdio.printf("FAIL: AssignGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubAssignGen, 0, AssignGenMixin.AssignGenMixin.__sizeof__())
|
||||
SubAssignGen.Gen = self
|
||||
self.AssignGen = SubAssignGen
|
||||
SubVarGen: VarGenMixin.VarGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(VarGenMixin.VarGenMixin.__sizeof__())
|
||||
SubVarGen: VarGenMixin.VarGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(VarGenMixin.VarGenMixin.__sizeof__())
|
||||
if SubVarGen is None:
|
||||
stdio.printf("FAIL: VarGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubVarGen, 0, VarGenMixin.VarGenMixin.__sizeof__())
|
||||
SubVarGen.Gen = self
|
||||
self.VarGen = SubVarGen
|
||||
SubTranslatorGen: TranslatorGenMixin.TranslatorGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(TranslatorGenMixin.TranslatorGenMixin.__sizeof__())
|
||||
SubTranslatorGen: TranslatorGenMixin.TranslatorGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(TranslatorGenMixin.TranslatorGenMixin.__sizeof__())
|
||||
if SubTranslatorGen is None:
|
||||
stdio.printf("FAIL: TranslatorGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
string.memset(SubTranslatorGen, 0, TranslatorGenMixin.TranslatorGenMixin.__sizeof__())
|
||||
SubTranslatorGen.Gen = self
|
||||
self.TranslatorGen = SubTranslatorGen
|
||||
SubAsyncGen: AsyncGenMixin.AsyncGenMixin | t.CPtr = CompilerFactory.get_perm_pool().alloc(AsyncGenMixin.AsyncGenMixin.__sizeof__())
|
||||
SubAsyncGen: AsyncGenMixin.AsyncGenMixin | t.CPtr = CompilerFactory.factory.PermPool.alloc(AsyncGenMixin.AsyncGenMixin.__sizeof__())
|
||||
if SubAsyncGen is None:
|
||||
stdio.printf("FAIL: AsyncGenMixin alloc failed\n")
|
||||
stdlib.exit(1)
|
||||
|
||||
@@ -424,7 +424,7 @@ class StmtGenDeclMixin(StmtGenCifMixin.StmtGenCifMixin):
|
||||
return 1
|
||||
|
||||
entry_size: t.CSizeT = GenTypes.EnumEntry.__sizeof__()
|
||||
self.EnumTable = CompilerFactory.get_perm_pool().alloc(entry_size * ENUM_MAX)
|
||||
self.EnumTable = CompilerFactory.factory.PermPool.alloc(entry_size * ENUM_MAX)
|
||||
if self.EnumTable is None:
|
||||
return 0
|
||||
string.memset(self.EnumTable, 0, entry_size * ENUM_MAX)
|
||||
@@ -471,14 +471,14 @@ class StmtGenDeclMixin(StmtGenCifMixin.StmtGenCifMixin):
|
||||
|
||||
# 分配成员数组（永久池：跨 mark/reset 存活，对齐 EnumTable 永久池化）
|
||||
member_size: t.CSizeT = GenTypes.EnumMember.__sizeof__()
|
||||
entry.Members = CompilerFactory.get_perm_pool().alloc(member_size * ENUM_MEMBER_MAX)
|
||||
entry.Members = CompilerFactory.factory.PermPool.alloc(member_size * ENUM_MEMBER_MAX)
|
||||
if entry.Members is None:
|
||||
return None
|
||||
string.memset(entry.Members, 0, member_size * ENUM_MEMBER_MAX)
|
||||
|
||||
# 复制类名（永久池深拷贝）
|
||||
name_len: t.CSizeT = string.strlen(name)
|
||||
name_buf: str = CompilerFactory.get_perm_pool().alloc(name_len + 1)
|
||||
name_buf: str = CompilerFactory.factory.PermPool.alloc(name_len + 1)
|
||||
if name_buf is not None:
|
||||
string.strcpy(name_buf, name)
|
||||
entry.Name = name_buf
|
||||
@@ -491,7 +491,7 @@ class StmtGenDeclMixin(StmtGenCifMixin.StmtGenCifMixin):
|
||||
# self.StdlibAlloc（NoVTable 按本 Mixin 字段布局编译），走模块级委托。
|
||||
if self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||||
base_ty_copy: llvmlite.LLVMType | t.CPtr = llvmlite.DeepCopyType(
|
||||
CompilerFactory.get_perm_pool(), base_ty)
|
||||
CompilerFactory.factory.PermPool, base_ty)
|
||||
if base_ty_copy is not None:
|
||||
entry.BaseTy = base_ty_copy
|
||||
else:
|
||||
@@ -533,7 +533,7 @@ class StmtGenDeclMixin(StmtGenCifMixin.StmtGenCifMixin):
|
||||
|
||||
# 复制成员名（永久池深拷贝：成员表跨 mark/reset 存活）
|
||||
name_len: t.CSizeT = string.strlen(member_name)
|
||||
name_buf: str = CompilerFactory.get_perm_pool().alloc(name_len + 1)
|
||||
name_buf: str = CompilerFactory.factory.PermPool.alloc(name_len + 1)
|
||||
if name_buf is not None:
|
||||
string.strcpy(name_buf, member_name)
|
||||
me.Name = name_buf
|
||||
|
||||
@@ -832,36 +832,7 @@ class StructGenMixin:
|
||||
self.Gen.TypeGenErr.fatal_error(node, fb, "AttributeError")
|
||||
stdlib.free(mod_buf_q)
|
||||
return None
|
||||
# 模块可解析但类未注册：先看裸名同名类是否唯一——
|
||||
# 模块归属错位场景（如 "ast.Attribute"：模块 'ast' 经包名
|
||||
# 回退解析到 ast/__init__.vp 的 sha1，但 Attribute 类实际
|
||||
# 注册在子模块 ast/exprs.vp，ModuleSha1 不匹配 → 查不到）。
|
||||
# 裸名唯一时回退（Attribute 短名无跨模块同名，安全）；
|
||||
# 多同名时保持 fail-fast（防 sched.Thread 被顶掉的同类问题）。
|
||||
same_cnt_q: int = 0
|
||||
same_entry_q: GenTypes.StructEntry | t.CPtr = None
|
||||
for i_sq in range(self.StructCount):
|
||||
e_sq: GenTypes.StructEntry | t.CPtr = self._get_struct_entry(i_sq)
|
||||
if e_sq is not None and e_sq.Name is not None:
|
||||
if string.strcmp(e_sq.Name, bare_q) == 0:
|
||||
same_cnt_q += 1
|
||||
same_entry_q = e_sq
|
||||
if same_cnt_q == 1 and same_entry_q is not None:
|
||||
for fi_q2 in range(same_entry_q.FieldCount):
|
||||
fe_q2: GenTypes.FieldEntry | t.CPtr = \
|
||||
self._get_field_entry(same_entry_q, fi_q2)
|
||||
if fe_q2 is not None and fe_q2.Name is not None:
|
||||
if string.strcmp(fe_q2.Name, field_name) == 0:
|
||||
stdlib.free(mod_buf_q)
|
||||
return fe_q2
|
||||
# 裸名类命中但字段未找到：返回 None（不 fatal_error）——
|
||||
# 字段可能是 REnum 变体别名（如 LLVMType.Pointee → _p2
|
||||
# 槽位）或继承字段，调用方（ExprGenAttr L853-864）有
|
||||
# REnum 别名回退等后续机会；对齐主 SHA1 匹配分支
|
||||
# （L797-798 字段未找到 return None）的语义。
|
||||
stdlib.free(mod_buf_q)
|
||||
return None
|
||||
# 裸名也不唯一/不存在：fail-fast（暴露 vpi 注入/注册缺陷，
|
||||
# 模块可解析但类未注册：fail-fast（暴露 vpi 注入/注册缺陷，
|
||||
# 不再裸名跨库抓其他模块同名类）
|
||||
viperlib.snprintf(fb, 1024,
|
||||
"lookup_field_by_class: 类 '%s' 未找到（模块 '%s' 可解析"
|
||||
|
||||
@@ -115,7 +115,7 @@ class TypeGenBase:
|
||||
if self.TraceFrames is not None:
|
||||
return 1
|
||||
entry_size: t.CSizeT = GenTypes.TraceFrame.__sizeof__()
|
||||
self.TraceFrames = CompilerFactory.get_perm_pool().alloc(entry_size * TypeGenMixin.TRACE_MAX)
|
||||
self.TraceFrames = CompilerFactory.factory.PermPool.alloc(entry_size * TypeGenMixin.TRACE_MAX)
|
||||
if self.TraceFrames is None:
|
||||
return 0
|
||||
string.memset(self.TraceFrames, 0, entry_size * TypeGenMixin.TRACE_MAX)
|
||||
|
||||
@@ -143,7 +143,7 @@ class TypeGenCDef(TypeGenBase.TypeGenBase):
|
||||
x_nm: str = self.XmodCdefNames.get(x_i)
|
||||
if x_nm is not None and string.strcmp(x_nm, name) == 0:
|
||||
return
|
||||
perm: memhub.MemBuddy | t.CPtr = CompilerFactory.get_perm_pool()
|
||||
perm: memhub.MemBuddy | t.CPtr = CompilerFactory.factory.PermPool
|
||||
if self.XmodCdefNames is None:
|
||||
self.XmodCdefNames = list[str](perm, 64)
|
||||
self.XmodCdefValues = list[str](perm, 64)
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
# ============================================================
|
||||
# Gen - 对象化生成器（P1 骨架 + P2 TypeGenMixin）
|
||||
# Generator: 翻译状态容器 + Mixin 组合（BaseGen 状态 + TypeGen 类型映射，
|
||||
# Generator: 翻译状态容器
|
||||
# ============================================================
|
||||
+4
-5
@@ -88,7 +88,7 @@ def main() -> int:
|
||||
stdio.printf("FAIL: perm_pool init failed\n")
|
||||
return 1
|
||||
|
||||
CompilerFactory.set_factory(CompilerFactory.CompilerFactory(mb, perm_pool))
|
||||
CompilerFactory.factory = CompilerFactory.CompilerFactory(mb, perm_pool)
|
||||
|
||||
# 设置全局 mbuddy 指针（sys 和 argparse 都需要）
|
||||
sys._mbuddy = mb
|
||||
@@ -133,6 +133,7 @@ def main() -> int:
|
||||
if log is None:
|
||||
log.error("TransPyV Failed to parse parameters")
|
||||
fmtbuf: str = VLogger.fmtbuffer
|
||||
fb: str = VLogger.fmtbuffer
|
||||
|
||||
# 初始化命令行参数（Windows: GetCommandLineA, POSIX: /proc/self/cmdline）
|
||||
sys._init_argv()
|
||||
@@ -233,10 +234,8 @@ Target: %s
|
||||
mf_inc_bin_asan: str = Config.get_includes_binary_dir()
|
||||
if mf_inc_bin_asan is not None:
|
||||
n_asan: int = Utils.CleanDir(mf_inc_bin_asan)
|
||||
fb_asan: str = VLogger.fmtbuffer
|
||||
if fb_asan is not None:
|
||||
viperlib.snprintf(fb_asan, 1024, "ASan 模式清理 includes 缓存: %d 个文件（将重建 asan obj）", n_asan)
|
||||
log.info(fb_asan, "asan")
|
||||
viperlib.snprintf(fb, 1024, "ASan 模式清理 includes 缓存: %d 个文件（将重建 asan obj）", n_asan)
|
||||
log.info(f"ASan 模式清理 includes 缓存: {n_asan} 个文件（将重建 asan obj）", "asan")
|
||||
else:
|
||||
BuildPipeline._asan_mode = False
|
||||
Config._inc_bin_suffix = ".binary"
|
||||
|
||||
Reference in new issue
Block a user