TermiNexus
24ae2dc966
- 新建 Gen/Translator.vp：Translator 类 + Mixin + 常量 + _mbuddy 自 HandlesTranslator 迁入（删 7 个委托壳与 _g_gen） - GenApi 下沉 7 个 global/nonlocal 管理委托（add/is_global_name、add/is_nonlocal_name、get_nonlocal_type/index、clear_scope_names）+ update_global_func_typestr - CallGenLeafKit 并入 ExprCallHandle 类，NewExprCallHandle 改本地引用 - 删除 Handles/HandlesExpr/ExprCallTable/HandlesBase（60+ 委托零消费者/纯委托壳）与 Handles 目录整体 - 全 App 56 文件 import 改指 lib.core.Gen.*，清理死 import，委托调用改 GenApi，main/BuildPipeline _g_gen 注入删除
523 lines
26 KiB
Plaintext
523 lines
26 KiB
Plaintext
import t, c
|
||
from stdint import *
|
||
import memhub
|
||
import string
|
||
import stdlib
|
||
import llvmlite
|
||
import w32.win32file as win32file
|
||
import w32.win32base as win32base
|
||
import w32.fileio as fileio
|
||
import viperlib
|
||
import sys
|
||
import ast
|
||
import lib.core.VLogger as VLogger
|
||
import lib.core.IncludesScanner as IncludesScanner
|
||
import lib.core.Gen.Translator as HandlesTranslator
|
||
import lib.Phase.BuildPipeline as BuildPipeline
|
||
import lib.Stub.StubGen.VpiReader as VpiReader
|
||
import lib.Projectrans.Utils as Utils
|
||
import lib.Projectrans.Config as Config
|
||
|
||
import lib.Stub.StubMerger.StubMergerCollect as StubMergerCollect
|
||
import lib.Stub.StubMerger.StubMergerTopo as StubMergerTopo
|
||
import lib.Stub.StubMerger.StubMergerIR as StubMergerIR
|
||
import lib.Stub.StubMerger.StubMergerBuild as StubMergerBuild
|
||
import lib.Stub.StubMerger as StubMerger
|
||
|
||
|
||
# ============================================================
|
||
# StubMergerStore - StubMerger 拆分（阶段 E）：StubMergerStore
|
||
# ============================================================
|
||
|
||
# ============================================================
|
||
# PopulateSha1MapStore - 从扫描结果填充全局 SHA1 映射存储器
|
||
#
|
||
# 遍历 ScanResult.Entries，为每个条目构建 sha1→module_name 映射。
|
||
# 模块名通过 _PathToModuleName(includes/rel_path) 计算。
|
||
# 内存用 stdlib.malloc 分配（全局存储器，不随 mbuddy 释放）。
|
||
#
|
||
# Args:
|
||
# scan_result: IncludesScanner 扫描结果
|
||
#
|
||
# Returns:
|
||
# 填充的条目数，-1 表示失败
|
||
# ============================================================
|
||
def PopulateSha1MapStore(scan_result: IncludesScanner.ScanResult | t.CPtr) -> int:
|
||
"""从扫描结果填充全局 SHA1 映射存储器
|
||
|
||
遍历 ScanResult.Entries，为每个条目构建 sha1→module_name 映射。
|
||
模块名通过 _PathToModuleName(includes/rel_path) 计算。
|
||
内存用 stdlib.malloc 分配（全局存储器，不随 mbuddy 释放）。
|
||
"""
|
||
if scan_result is None:
|
||
return -1
|
||
# 释放旧存储器
|
||
if StubMerger._sha1_store_arr is not None:
|
||
stdlib.free(StubMerger._sha1_store_arr)
|
||
if StubMerger._sha1_store_mod is not None:
|
||
stdlib.free(StubMerger._sha1_store_mod)
|
||
if StubMerger._sha1_store_rel is not None:
|
||
stdlib.free(StubMerger._sha1_store_rel)
|
||
if StubMerger._sha1_store_incdir is not None:
|
||
stdlib.free(StubMerger._sha1_store_incdir)
|
||
StubMerger._sha1_store_arr = stdlib.malloc(StubMerger.MAX_INCLUDES * 17)
|
||
StubMerger._sha1_store_mod = stdlib.malloc(StubMerger.MAX_INCLUDES * 64)
|
||
StubMerger._sha1_store_rel = stdlib.malloc(StubMerger.MAX_INCLUDES * StubMerger.MAX_REL_PATH_LEN)
|
||
StubMerger._sha1_store_incdir = stdlib.malloc(StubMerger.MAX_INCLUDES * StubMerger.MAX_INC_DIR_LEN)
|
||
if StubMerger._sha1_store_arr is None or StubMerger._sha1_store_mod is None or StubMerger._sha1_store_rel is None or StubMerger._sha1_store_incdir is None:
|
||
return -1
|
||
string.memset(StubMerger._sha1_store_arr, 0, StubMerger.MAX_INCLUDES * 17)
|
||
string.memset(StubMerger._sha1_store_mod, 0, StubMerger.MAX_INCLUDES * 64)
|
||
string.memset(StubMerger._sha1_store_rel, 0, StubMerger.MAX_INCLUDES * StubMerger.MAX_REL_PATH_LEN)
|
||
string.memset(StubMerger._sha1_store_incdir, 0, StubMerger.MAX_INCLUDES * StubMerger.MAX_INC_DIR_LEN)
|
||
StubMerger._sha1_store_count = 0
|
||
p_bad: int = 0
|
||
entry_size_p: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()
|
||
for i in range(scan_result.Count):
|
||
if StubMerger._sha1_store_count >= StubMerger.MAX_INCLUDES:
|
||
VLogger.error("includes SHA1 存储超上限，终止", "StubMerger")
|
||
ea: t.CUInt64T = t.CUInt64T(scan_result.Entries) + i * entry_size_p
|
||
ent: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(ea, t.CPtr))
|
||
if ent is None or ent.Sha1 is None or ent.RelPath is None:
|
||
p_bad += 1
|
||
continue
|
||
# 构建完整路径 includes/{RelPath}（_PathToModuleName 需要）
|
||
rp_len: t.CSizeT = string.strlen(ent.RelPath)
|
||
full_path_buf: bytes = stdlib.malloc(rp_len + 10)
|
||
if full_path_buf is None:
|
||
p_bad += 1
|
||
continue
|
||
viperlib.snprintf(full_path_buf, rp_len + 10, "includes/%s", ent.RelPath)
|
||
mod_name: str = Utils.PathToModuleName(full_path_buf, 1)
|
||
stdlib.free(full_path_buf)
|
||
if mod_name is not None:
|
||
idx: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * 17
|
||
string.strcpy(StubMerger._sha1_store_arr + idx, ent.Sha1)
|
||
idx2: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * 64
|
||
mn_len: t.CSizeT = string.strlen(mod_name)
|
||
if mn_len < 64:
|
||
string.strcpy(StubMerger._sha1_store_mod + idx2, mod_name)
|
||
else:
|
||
string.strncpy(StubMerger._sha1_store_mod + idx2, mod_name, 63)
|
||
StubMerger._sha1_store_mod[idx2 + 63] = '\0'
|
||
stdlib.free(mod_name)
|
||
# 保存 rel_path（供 Phase2 3.5 编译缺失 includes 使用）
|
||
idx3: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * StubMerger.MAX_REL_PATH_LEN
|
||
if rp_len < StubMerger.MAX_REL_PATH_LEN:
|
||
string.strcpy(StubMerger._sha1_store_rel + idx3, ent.RelPath)
|
||
else:
|
||
string.strncpy(StubMerger._sha1_store_rel + idx3, ent.RelPath, StubMerger.MAX_REL_PATH_LEN - 1)
|
||
StubMerger._sha1_store_rel[idx3 + StubMerger.MAX_REL_PATH_LEN - 1] = '\0'
|
||
# 保存所属 includes 根目录（Phase2 预注册/按需编译拼路径用）
|
||
idx_inc: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * StubMerger.MAX_INC_DIR_LEN
|
||
if ent.IncDir is not None:
|
||
icd_len: t.CSizeT = string.strlen(ent.IncDir)
|
||
if icd_len < StubMerger.MAX_INC_DIR_LEN:
|
||
string.strcpy(StubMerger._sha1_store_incdir + idx_inc, ent.IncDir)
|
||
else:
|
||
string.strncpy(StubMerger._sha1_store_incdir + idx_inc, ent.IncDir, StubMerger.MAX_INC_DIR_LEN - 1)
|
||
StubMerger._sha1_store_incdir[idx_inc + StubMerger.MAX_INC_DIR_LEN - 1] = '\0'
|
||
StubMerger._sha1_store_count += 1
|
||
if p_bad > 0:
|
||
VLogger.error(f"includes SHA1 存储有 {p_bad} 个条目失败", "StubMerger")
|
||
return StubMerger._sha1_store_count
|
||
# ============================================================
|
||
# AppendToSha1MapStore - 追加条目到全局 SHA1 映射存储器
|
||
#
|
||
# Phase1 调用 PopulateSha1MapStore 填充 includes 文件，
|
||
# Phase2 扫描 App 源文件后调用此函数追加 App 模块条目，
|
||
# 确保编译 App 自身时跨模块 CDefine 查找能命中 App 模块
|
||
# （如 StubMerger.StubMerger.MAX_INCLUDES 在编译 Phase2 时通过
|
||
# _build_source_path_from_sha1 查找 StubMerger 的源路径）。
|
||
#
|
||
# 若存储器未初始化（PopulateSha1MapStore 未调用），自动初始化。
|
||
# 若 SHA1 已存在（去重），跳过。
|
||
#
|
||
# Args:
|
||
# sha1: SHA1 字符串（16 字符 + null）
|
||
# rel_path: 相对路径（如 "lib/core/StubMerger.vp"，
|
||
# 不含 includes/ 前缀，与 _sha1_map.txt 格式一致）
|
||
#
|
||
# Returns:
|
||
# 0 成功（含去重跳过），1 失败
|
||
# ============================================================
|
||
def AppendToSha1MapStore(sha1: str, rel_path: str) -> int:
|
||
"""追加条目到全局 SHA1 映射存储器（Phase2 用）"""
|
||
if sha1 is None or rel_path is None:
|
||
return 1
|
||
# 存储器未初始化：自动初始化（Phase2 可能先于 Phase1 调用）
|
||
if StubMerger._sha1_store_arr is None:
|
||
StubMerger._sha1_store_arr = stdlib.malloc(StubMerger.MAX_INCLUDES * 17)
|
||
StubMerger._sha1_store_mod = stdlib.malloc(StubMerger.MAX_INCLUDES * 64)
|
||
StubMerger._sha1_store_rel = stdlib.malloc(StubMerger.MAX_INCLUDES * StubMerger.MAX_REL_PATH_LEN)
|
||
StubMerger._sha1_store_incdir = stdlib.malloc(StubMerger.MAX_INCLUDES * StubMerger.MAX_INC_DIR_LEN)
|
||
if StubMerger._sha1_store_arr is None or StubMerger._sha1_store_mod is None or StubMerger._sha1_store_rel is None or StubMerger._sha1_store_incdir is None:
|
||
return 1
|
||
string.memset(StubMerger._sha1_store_arr, 0, StubMerger.MAX_INCLUDES * 17)
|
||
string.memset(StubMerger._sha1_store_mod, 0, StubMerger.MAX_INCLUDES * 64)
|
||
string.memset(StubMerger._sha1_store_rel, 0, StubMerger.MAX_INCLUDES * StubMerger.MAX_REL_PATH_LEN)
|
||
string.memset(StubMerger._sha1_store_incdir, 0, StubMerger.MAX_INCLUDES * StubMerger.MAX_INC_DIR_LEN)
|
||
StubMerger._sha1_store_count = 0
|
||
if StubMerger._sha1_store_count >= StubMerger.MAX_INCLUDES:
|
||
return 1
|
||
# 模块名：rel_path "lib/core/StubMerger.vp" → "lib.core.StubMerger"
|
||
full_path_buf: bytes = stdlib.malloc(string.strlen(rel_path) + 10)
|
||
if full_path_buf is None:
|
||
return 1
|
||
viperlib.snprintf(full_path_buf, string.strlen(rel_path) + 10, "includes/%s", rel_path)
|
||
mod_name: str = Utils.PathToModuleName(full_path_buf, 1)
|
||
stdlib.free(full_path_buf)
|
||
if mod_name is None:
|
||
return 1
|
||
# 去重：SHA1 与模块名都相同才跳过。同一 SHA1 可能被 includes 扫描先以
|
||
# 全路径模块名注册（如 App 源文件在 includes 目录下 → "Apps.Scene3D.gfx"），
|
||
# App 追加的短模块名（"gfx"）必须保留——否则 import gfx 的精确查找
|
||
# LookupSha1ByModName("gfx") 失败 → 后缀匹配劫持到 VKernel 同名 gfx
|
||
# （VKernel/Kernel/drivers/video/vesafb/gfx.vp，类 Scene3D 归属错乱根因）。
|
||
for i in range(StubMerger._sha1_store_count):
|
||
sidx_d: t.CSizeT = t.CSizeT(i) * 17
|
||
if string.strcmp(StubMerger._sha1_store_arr + sidx_d, sha1) == 0:
|
||
midx_d: t.CSizeT = t.CSizeT(i) * 64
|
||
if string.strcmp(StubMerger._sha1_store_mod + midx_d, mod_name) == 0:
|
||
stdlib.free(mod_name)
|
||
return 0
|
||
# 写入 SHA1
|
||
idx_a: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * 17
|
||
string.strcpy(StubMerger._sha1_store_arr + idx_a, sha1)
|
||
# 写入模块名
|
||
idx_m: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * 64
|
||
mn_len: t.CSizeT = string.strlen(mod_name)
|
||
if mn_len < 64:
|
||
string.strcpy(StubMerger._sha1_store_mod + idx_m, mod_name)
|
||
else:
|
||
string.strncpy(StubMerger._sha1_store_mod + idx_m, mod_name, 63)
|
||
StubMerger._sha1_store_mod[idx_m + 63] = '\0'
|
||
stdlib.free(mod_name)
|
||
# 写入相对路径
|
||
idx_r: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * StubMerger.MAX_REL_PATH_LEN
|
||
rp_len: t.CSizeT = string.strlen(rel_path)
|
||
if rp_len < StubMerger.MAX_REL_PATH_LEN:
|
||
string.strcpy(StubMerger._sha1_store_rel + idx_r, rel_path)
|
||
else:
|
||
string.strncpy(StubMerger._sha1_store_rel + idx_r, rel_path, StubMerger.MAX_REL_PATH_LEN - 1)
|
||
StubMerger._sha1_store_rel[idx_r + StubMerger.MAX_REL_PATH_LEN - 1] = '\0'
|
||
# App 源文件不属于任何 includes 目录：IncDir 留空（Phase2 回退 includes_dir 参数）
|
||
idx_inc_a: t.CSizeT = t.CSizeT(StubMerger._sha1_store_count) * StubMerger.MAX_INC_DIR_LEN
|
||
StubMerger._sha1_store_incdir[idx_inc_a] = '\0'
|
||
StubMerger._sha1_store_count += 1
|
||
return 0
|
||
# ============================================================
|
||
# GetSha1StoreCount - 获取全局存储器条目数
|
||
# ============================================================
|
||
def GetSha1StoreCount() -> int:
|
||
"""返回全局 SHA1 存储器的条目数"""
|
||
return StubMerger._sha1_store_count
|
||
# ============================================================
|
||
# LookupSha1ByModName - 从模块名查找 SHA1（直接查全局存储器）
|
||
#
|
||
# 精确匹配失败时，尝试 "{mod_name}.__init__" 回退，
|
||
# 支持 import ast（包）→ ast.__init__ 的 SHA1 查找。
|
||
#
|
||
# Returns:
|
||
# SHA1 字符串指针（指向全局存储器内部，无需释放），None 未找到
|
||
# ============================================================
|
||
def LookupSha1ByModName(mod_name: str) -> str:
|
||
"""从模块名查找 SHA1（精确匹配 + 包名回退），委托通用实现 _FindSha1ByModName"""
|
||
return StubMergerIR._FindSha1ByModName(StubMerger._sha1_store_arr, StubMerger._sha1_store_mod, StubMerger._sha1_store_count, mod_name)
|
||
# ============================================================
|
||
# LookupSha1ByModNameSuffix - 后缀匹配查找模块 SHA1
|
||
#
|
||
# 用于 from .X import Y 的相对导入：impf.module 是 ".X"（带前导点），
|
||
# 去掉前导点后为 "X"，SHA1 映射表中键是 "pkg.X"，需要后缀匹配。
|
||
# 包含三种匹配方式：精确、后缀、反向后缀。
|
||
#
|
||
# Returns:
|
||
# SHA1 字符串指针（指向全局存储器内部，无需释放），None 未找到
|
||
# ============================================================
|
||
def LookupSha1ByModNameSuffix(mod_suffix: str) -> str:
|
||
"""后缀匹配查找模块 SHA1"""
|
||
if mod_suffix is None:
|
||
return None
|
||
if StubMerger._sha1_store_arr is None or StubMerger._sha1_store_mod is None:
|
||
return None
|
||
if StubMerger._sha1_store_count <= 0:
|
||
return None
|
||
suffix_len_sf: t.CSizeT = string.strlen(mod_suffix)
|
||
if suffix_len_sf == 0:
|
||
return None
|
||
i_sf: int
|
||
for i_sf in range(StubMerger._sha1_store_count):
|
||
idx_sf: t.CSizeT = t.CSizeT(i_sf) * 64
|
||
mod_name_sf: str = StubMerger._sha1_store_mod + idx_sf
|
||
mod_len_sf: t.CSizeT = string.strlen(mod_name_sf)
|
||
if mod_len_sf == 0:
|
||
continue
|
||
# 精确匹配
|
||
if mod_len_sf == suffix_len_sf:
|
||
if string.strcmp(mod_name_sf, mod_suffix) == 0:
|
||
sidx_sf: t.CSizeT = t.CSizeT(i_sf) * 17
|
||
return StubMerger._sha1_store_arr + sidx_sf
|
||
# 后缀匹配：mod_name 以 "." + mod_suffix 结尾
|
||
if mod_len_sf > suffix_len_sf:
|
||
if mod_name_sf[mod_len_sf - suffix_len_sf - 1] == '.':
|
||
cmp_start_sf: str = mod_name_sf + mod_len_sf - suffix_len_sf
|
||
if string.strcmp(cmp_start_sf, mod_suffix) == 0:
|
||
sidx2_sf: t.CSizeT = t.CSizeT(i_sf) * 17
|
||
return StubMerger._sha1_store_arr + sidx2_sf
|
||
# 反向后缀匹配：mod_suffix 以 "." + mod_name 结尾
|
||
if suffix_len_sf > mod_len_sf:
|
||
if mod_suffix[suffix_len_sf - mod_len_sf - 1] == '.':
|
||
cmp_start_rev_sf: str = mod_suffix + suffix_len_sf - mod_len_sf
|
||
if string.strcmp(cmp_start_rev_sf, mod_name_sf) == 0:
|
||
sidx_rev_sf: t.CSizeT = t.CSizeT(i_sf) * 17
|
||
return StubMerger._sha1_store_arr + sidx_rev_sf
|
||
return None
|
||
# ============================================================
|
||
# LookupSha1ByAlias - 从 from_imports 别名映射解析模块 SHA1
|
||
#
|
||
# from_imports 条目格式: "local:module" 或 "local:module:orig"（空格分隔），
|
||
# 由 ImportsGenMixin.add_from_import 写入（import X as Y → "Y:X"）。
|
||
# 命中 local==alias 时，对 module 执行 LookupSha1ByModName 返回 SHA1。
|
||
#
|
||
# Returns:
|
||
# SHA1 字符串指针（指向全局存储器内部），None 未找到
|
||
# ============================================================
|
||
def LookupSha1ByAlias(from_imports: str, alias: str) -> str:
|
||
"""从 from_imports 别名映射解析模块 SHA1（改名别名 import X as Y 场景）"""
|
||
if from_imports is None or alias is None:
|
||
return None
|
||
alias_len: t.CSizeT = string.strlen(alias)
|
||
if alias_len == 0:
|
||
return None
|
||
total_len: t.CSizeT = string.strlen(from_imports)
|
||
ci: t.CSizeT = 0
|
||
while ci < total_len:
|
||
# 跳过前导空格
|
||
while ci < total_len and from_imports[ci] == ' ':
|
||
ci += 1
|
||
if ci >= total_len:
|
||
break
|
||
# 条目起点 ci，找 ':'（local_name 结束）
|
||
colon: t.CSizeT = ci
|
||
while colon < total_len and from_imports[colon] != ':' and from_imports[colon] != ' ':
|
||
colon += 1
|
||
local_len: t.CSizeT = colon - ci
|
||
if colon < total_len and from_imports[colon] == ':' and local_len == alias_len:
|
||
# 比较 local_name == alias
|
||
match: int = 1
|
||
li: t.CSizeT = 0
|
||
while li < alias_len:
|
||
if from_imports[ci + li] != alias[li]:
|
||
match = 0
|
||
break
|
||
li += 1
|
||
if match == 1:
|
||
# 提取 module（colon+1 到下一个 ':' 或空格）
|
||
m_start: t.CSizeT = colon + 1
|
||
m_end: t.CSizeT = m_start
|
||
while m_end < total_len and from_imports[m_end] != ':' and from_imports[m_end] != ' ':
|
||
m_end += 1
|
||
if m_end > m_start:
|
||
mbuf: str = stdlib.malloc(m_end - m_start + 1)
|
||
if mbuf is not None:
|
||
string.strncpy(mbuf, from_imports + m_start, m_end - m_start)
|
||
mbuf[m_end - m_start] = '\0'
|
||
res: str = LookupSha1ByModName(mbuf)
|
||
stdlib.free(mbuf)
|
||
return res
|
||
return None
|
||
# 跳到下一条目
|
||
while ci < total_len and from_imports[ci] != ' ':
|
||
ci += 1
|
||
return None
|
||
# ============================================================
|
||
# LookupModNameByAlias - 从 from_imports 别名映射解析模块真名
|
||
#
|
||
# import X as Y 时 ImportsGenMixin.add_from_import 写入 "Y:X"（Y=别名，
|
||
# X=模块真名）。本函数返回别名 Y 对应的模块真名 X（供限定名解析
|
||
# "Y.Class" → 按 X 模块归属匹配，如 "types.fileinfo" → "fat32_types"）。
|
||
#
|
||
# Returns:
|
||
# 模块名字符串（stdlib 分配，调用方负责 free），None 未找到
|
||
# ============================================================
|
||
def LookupModNameByAlias(from_imports: str, alias: str) -> str:
|
||
"""从 from_imports 别名映射解析模块真名（import X as Y → Y:X）"""
|
||
if from_imports is None or alias is None:
|
||
return None
|
||
alias_len: t.CSizeT = string.strlen(alias)
|
||
if alias_len == 0:
|
||
return None
|
||
total_len: t.CSizeT = string.strlen(from_imports)
|
||
ci: t.CSizeT = 0
|
||
while ci < total_len:
|
||
# 跳过前导空格
|
||
while ci < total_len and from_imports[ci] == ' ':
|
||
ci += 1
|
||
if ci >= total_len:
|
||
break
|
||
# 条目起点 ci，找 ':'（local_name 结束）
|
||
colon: t.CSizeT = ci
|
||
while colon < total_len and from_imports[colon] != ':' and from_imports[colon] != ' ':
|
||
colon += 1
|
||
local_len: t.CSizeT = colon - ci
|
||
if colon < total_len and from_imports[colon] == ':' and local_len == alias_len:
|
||
# 比较 local_name == alias
|
||
match: int = 1
|
||
li: t.CSizeT = 0
|
||
while li < alias_len:
|
||
if from_imports[ci + li] != alias[li]:
|
||
match = 0
|
||
break
|
||
li += 1
|
||
if match == 1:
|
||
# 提取 module（colon+1 到下一个 ':' 或空格）
|
||
m_start: t.CSizeT = colon + 1
|
||
m_end: t.CSizeT = m_start
|
||
while m_end < total_len and from_imports[m_end] != ':' and from_imports[m_end] != ' ':
|
||
m_end += 1
|
||
if m_end > m_start:
|
||
mbuf: str = stdlib.malloc(m_end - m_start + 1)
|
||
if mbuf is not None:
|
||
string.strncpy(mbuf, from_imports + m_start, m_end - m_start)
|
||
mbuf[m_end - m_start] = '\0'
|
||
return mbuf
|
||
return None
|
||
# 跳到下一条目
|
||
while ci < total_len and from_imports[ci] != ' ':
|
||
ci += 1
|
||
return None
|
||
# ============================================================
|
||
# PopulateIncludesDeps - 将 includes 文件的依赖存入内存
|
||
#
|
||
# Phase B+ 前用 declare_only 翻译 includes 文件，提取 _imported_modules
|
||
# 后调用此函数存入内存。_BuildReachableSha1Set 从内存读取，不读 deps.txt。
|
||
#
|
||
# Args:
|
||
# sha1: includes 文件的 SHA1（16字符）
|
||
# deps_str: 依赖模块名字符串（空格分隔，如 "t c stdint string"）
|
||
#
|
||
# Returns:
|
||
# 0 成功，非 0 失败
|
||
# ============================================================
|
||
def PopulateIncludesDeps(sha1: str, deps_str: str) -> int:
|
||
"""将 includes 文件的依赖存入内存"""
|
||
if sha1 is None:
|
||
return 1
|
||
# 延迟初始化
|
||
if StubMerger._includes_deps_sha1 is None:
|
||
StubMerger._includes_deps_sha1 = stdlib.malloc(StubMerger.MAX_INCLUDES * 17)
|
||
StubMerger._includes_deps_str = stdlib.malloc(StubMerger.MAX_INCLUDES * StubMerger.MAX_DEPS_STR_LEN)
|
||
if StubMerger._includes_deps_sha1 is None or StubMerger._includes_deps_str is None:
|
||
return 1
|
||
string.memset(StubMerger._includes_deps_sha1, 0, StubMerger.MAX_INCLUDES * 17)
|
||
string.memset(StubMerger._includes_deps_str, 0, StubMerger.MAX_INCLUDES * StubMerger.MAX_DEPS_STR_LEN)
|
||
StubMerger._includes_deps_count = 0
|
||
if StubMerger._includes_deps_count >= StubMerger.MAX_INCLUDES:
|
||
return 1
|
||
# 去重：若 SHA1 已存在则跳过
|
||
for i in range(StubMerger._includes_deps_count):
|
||
sidx: t.CSizeT = t.CSizeT(i) * 17
|
||
if string.strcmp(StubMerger._includes_deps_sha1 + sidx, sha1) == 0:
|
||
return 0
|
||
# 写入 SHA1
|
||
idx: t.CSizeT = t.CSizeT(StubMerger._includes_deps_count) * 17
|
||
string.strcpy(StubMerger._includes_deps_sha1 + idx, sha1)
|
||
# 写入依赖字符串
|
||
idx2: t.CSizeT = t.CSizeT(StubMerger._includes_deps_count) * StubMerger.MAX_DEPS_STR_LEN
|
||
if deps_str is not None:
|
||
dl: t.CSizeT = string.strlen(deps_str)
|
||
if dl < StubMerger.MAX_DEPS_STR_LEN:
|
||
string.strcpy(StubMerger._includes_deps_str + idx2, deps_str)
|
||
else:
|
||
string.strncpy(StubMerger._includes_deps_str + idx2, deps_str, StubMerger.MAX_DEPS_STR_LEN - 1)
|
||
else:
|
||
StubMerger._includes_deps_str[idx2] = '\0'
|
||
StubMerger._includes_deps_count = StubMerger._includes_deps_count + 1
|
||
return 0
|
||
# ============================================================
|
||
# LookupIncludesDeps - 从内存查找 includes 文件的依赖
|
||
#
|
||
# Args:
|
||
# sha1: includes 文件的 SHA1（16字符）
|
||
#
|
||
# Returns:
|
||
# 依赖模块名字符串指针（空格分隔），None 表示未找到
|
||
# ============================================================
|
||
def LookupIncludesDeps(sha1: str) -> str:
|
||
"""从内存查找 includes 文件的依赖"""
|
||
if sha1 is None or StubMerger._includes_deps_sha1 is None:
|
||
return None
|
||
if StubMerger._includes_deps_count <= 0:
|
||
return None
|
||
for i in range(StubMerger._includes_deps_count):
|
||
sidx: t.CSizeT = t.CSizeT(i) * 17
|
||
if string.strcmp(StubMerger._includes_deps_sha1 + sidx, sha1) == 0:
|
||
idx2: t.CSizeT = t.CSizeT(i) * StubMerger.MAX_DEPS_STR_LEN
|
||
return StubMerger._includes_deps_str + idx2
|
||
return None
|
||
def GetSha1StoreArrPtr() -> bytes:
|
||
"""返回 SHA1 数组指针（每个条目 17 字节）"""
|
||
return StubMerger._sha1_store_arr
|
||
def GetSha1StoreModArrPtr() -> bytes:
|
||
"""返回模块名数组指针（每个条目 64 字节）"""
|
||
return StubMerger._sha1_store_mod
|
||
def GetSha1StoreRelArrPtr() -> bytes:
|
||
"""返回相对路径数组指针（每个条目 StubMerger.MAX_REL_PATH_LEN 字节）"""
|
||
return StubMerger._sha1_store_rel
|
||
def GetSha1StoreIncdirArrPtr() -> bytes:
|
||
"""返回所属 includes 根目录数组指针（每个条目 StubMerger.MAX_INC_DIR_LEN 字节，空串表示不属于任何 includes 目录）"""
|
||
return StubMerger._sha1_store_incdir
|
||
# ============================================================
|
||
# GetSha1StoreArr - 获取全局存储器数组指针（直接遍历用）
|
||
#
|
||
# 返回 sha1_arr、mod_arr、rel_arr 三个数组的指针和条目数。
|
||
# 调用者直接遍历数组：sha1_arr[i*17]、mod_arr[i*64]、rel_arr[i*StubMerger.MAX_REL_PATH_LEN]
|
||
# 内存归全局存储器所有，调用者不要 free
|
||
# ============================================================
|
||
def GetSha1StoreArr(out_sha1_arr: t.CPtr, out_mod_arr: t.CPtr, out_rel_arr: t.CPtr) -> int:
|
||
"""获取全局存储器数组指针
|
||
|
||
out_sha1_arr/out_mod_arr/out_rel_arr 是调用者提供的 t.CPtr 指针，
|
||
函数将存储器数组指针写入这些位置。
|
||
返回条目数，-1 失败
|
||
"""
|
||
if out_sha1_arr is None or out_mod_arr is None or out_rel_arr is None:
|
||
return -1
|
||
if StubMerger._sha1_store_arr is None or StubMerger._sha1_store_mod is None or StubMerger._sha1_store_rel is None:
|
||
return -1
|
||
sp: t.CPtr = (t.CPtr | t.CPtr)(t.CVoid(out_sha1_arr, t.CPtr)) # 存疑
|
||
if sp is not None:
|
||
sp[0] = StubMerger._sha1_store_arr
|
||
mp: t.CPtr = (t.CPtr | t.CPtr)(t.CVoid(out_mod_arr, t.CPtr))
|
||
if mp is not None:
|
||
mp[0] = StubMerger._sha1_store_mod
|
||
rp: t.CPtr = (t.CPtr | t.CPtr)(t.CVoid(out_rel_arr, t.CPtr))
|
||
if rp is not None:
|
||
rp[0] = StubMerger._sha1_store_rel
|
||
return StubMerger._sha1_store_count
|
||
|
||
# ============================================================
|
||
# LookupSha1RelPath - 通过 SHA1 查找相对路径
|
||
#
|
||
# 遍历全局存储器，返回 sha1 对应的相对路径指针（只读，不要 free）。
|
||
# 用于错误提示：将 sha1 转换为人类可读的文件路径。
|
||
#
|
||
# Args:
|
||
# sha1: SHA1 字符串（16 字符）
|
||
#
|
||
# Returns:
|
||
# 相对路径字符串指针（只读），None=未找到
|
||
# ============================================================
|
||
def LookupSha1RelPath(sha1: str) -> str:
|
||
"""通过 SHA1 查找相对路径，返回只读指针，None=未找到"""
|
||
if sha1 is None:
|
||
return None
|
||
if StubMerger._sha1_store_arr is None or StubMerger._sha1_store_rel is None:
|
||
return None
|
||
for i in range(StubMerger._sha1_store_count):
|
||
sidx: t.CSizeT = t.CSizeT(i) * 17
|
||
if string.strcmp(StubMerger._sha1_store_arr + sidx, sha1) == 0:
|
||
ridx: t.CSizeT = t.CSizeT(i) * StubMerger.MAX_REL_PATH_LEN
|
||
return StubMerger._sha1_store_rel + ridx
|
||
return None
|