import t, c
from stdint import *
import memhub
import string
import stdio
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.IncludesScanner as IncludesScanner
import lib.core.Handles.HandlesStruct as HandlesStruct
import lib.core.Handles.HandlesImports as HandlesImports
import lib.core.Handles.HandlesTranslator as HandlesTranslator
import lib.core.BuildPipeline as BuildPipeline
import lib.Projectrans.Config as Config


# ============================================================
# StubMerger - stub 声明合并模块
#
# 从 temp 目录加载所有 .stub.ll 文件，将声明内容合并到主 IR。
# 这是 Phase2 的核心功能：翻译主文件时，将所有依赖的 stub
# 声明合并到主 IR 前面，使链接器能解析跨模块符号引用。
#
# 合并策略：
#   1. 扫描 temp 目录，收集所有 {sha1}.stub.ll 文件
#   2. 读取每个 stub 文件内容
#   3. 过滤去重（避免重复声明）
#   4. 将声明插入到主 IR 的 target triple 之后
# ============================================================

# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr

# 最大 includes SHA1 数（用于过滤）
MAX_INCLUDES_SHA1: t.CDefine = 256
# stub 读取缓冲区大小
STUB_READ_BUF_SIZE: t.CDefine = 262144
# 最大 includes 条目数
MAX_INCLUDES: t.CDefine = 256


# ============================================================
# _sliced_path - 构建切片路径（stdlib.malloc 分配，调用者负责 free）
#
# 根据 Config.Sha1SliceLevel 将文件分散到 SHA1 前缀子目录:
#   level=0 → {temp_dir}/{sha1}.{ext}
#   level=1 → {temp_dir}/b7/{sha1}.{ext}
#   level=2 → {temp_dir}/b7/90/{sha1}.{ext}
#
# 自动调用 BuildPipeline.ensure_dir 创建子目录（level>0 时）。
#
# Args:
#   temp_dir: 基础目录
#   td_len: temp_dir 长度（避免重复 strlen）
#   sha1: SHA1 字符串
#   ext: 文件扩展名（如 "stub.ll"）
#
# Returns:
#   完整路径（stdlib.malloc 分配，需 stdlib.free），None 失败
# ============================================================
def _sliced_path(temp_dir: str, td_len: t.CSizeT, sha1: str, ext: str) -> str:
    """构建切片路径（stdlib.malloc 分配，调用者负责 free）

    level>0 时自动调用 ensure_dir 创建子目录。
    """
    if temp_dir is None or sha1 is None or ext is None:
        return None
    sha1_len: t.CSizeT = string.strlen(sha1)
    ext_len: t.CSizeT = string.strlen(ext)

    # 子目录前缀缓冲区（最多 3 层 = 8 字节 + null = 16 足够）
    SUBDIR_BUF_SIZE: t.CSizeT = 16
    subdir_buf: bytes = stdlib.malloc(SUBDIR_BUF_SIZE)
    if subdir_buf is None:
        return None
    subdir_buf[0] = '\0'
    sub_len: t.CSizeT = 0
    level: int = Config.Sha1SliceLevel
    if level > 0:
        li: int = 0
        while li < level:
            if li > 0:
                subdir_buf[sub_len] = '/'
                sub_len += 1
            idx: int = li * 2
            subdir_buf[sub_len] = sha1[idx]
            subdir_buf[sub_len + 1] = sha1[idx + 1]
            sub_len += 2
            li += 1
        subdir_buf[sub_len] = '\0'

        # 确保子目录存在: {temp_dir}/{subdir}
        # 不创建目录会导致 fileio.File(MODE.W) 静默失败（file.closed==True），
        # 进而 BuildCombinedIR 读不到文件返回 0（"BuildCombinedIR 失败"）。
        dir_path_len: t.CSizeT = td_len + sub_len + 2
        dir_path: bytes = stdlib.malloc(dir_path_len)
        if dir_path is not None:
            viperlib.snprintf(dir_path, dir_path_len, "%s/%s", temp_dir, subdir_buf)
            BuildPipeline.ensure_dir(dir_path)
            stdlib.free(dir_path)

    # 构建完整路径
    path: str = None
    path_len: t.CSizeT = 0
    if sub_len > 0:
        path_len = td_len + sub_len + sha1_len + ext_len + 4
        path = stdlib.malloc(path_len)
        if path is not None:
            viperlib.snprintf(path, path_len, "%s/%s/%s.%s", temp_dir, subdir_buf, sha1, ext)
    else:
        path_len = td_len + sha1_len + ext_len + 3
        path = stdlib.malloc(path_len)
        if path is not None:
            viperlib.snprintf(path, path_len, "%s/%s.%s", temp_dir, sha1, ext)

    stdlib.free(subdir_buf)
    return path


# ============================================================
# _collect_stub_sha1s - 递归扫描子目录，收集 .stub.ll 文件的 SHA1
#
# 根据 level 递归扫描子目录:
#   level=0 → 扫描 {base_dir}/*.stub.ll，从文件名提取 SHA1
#   level>0 → 扫描 {base_dir}/* 的子目录，对每个子目录递归调用
#
# Args:
#   base_dir: 当前扫描目录
#   bd_len: base_dir 长度
#   level: 剩余递归层数
#   out_arr: 输出数组（每个 SHA1 17 字节 = 16字符 + null）
#   out_count: 当前已收集数量
#   max_count: 最大数量
#
# Returns:
#   收集后的总数量
# ============================================================
def _collect_stub_sha1s(base_dir: str, bd_len: t.CSizeT, level: int,
                        out_arr: str, out_count: int, max_count: int) -> int:
    """递归扫描子目录，收集 .stub.ll 文件的 SHA1"""
    if base_dir is None or out_arr is None:
        return out_count
    if out_count >= max_count:
        return out_count

    find_data: win32file.WIN32_FIND_DATAA | t.CPtr = stdlib.malloc(win32file.WIN32_FIND_DATAA.__sizeof__())
    if find_data is None:
        return out_count
    string.memset(find_data, 0, win32file.WIN32_FIND_DATAA.__sizeof__())

    if level <= 0:
        # 扫描 {base_dir}/*.stub.ll
        pattern: bytes = stdlib.malloc(bd_len + 16)
        if pattern is None:
            stdlib.free(find_data)
            return out_count
        viperlib.snprintf(pattern, bd_len + 16, "%s/*.stub.ll", base_dir)
        handle: win32base.HANDLE = win32file.FindFirstFileA(pattern, find_data)
        stdlib.free(pattern)
        if handle != win32base.INVALID_HANDLE_VALUE:
            while 1:
                if out_count >= max_count:
                    break
                fname: str = find_data.cFileName
                if fname is not None:
                    if fname[0] != '\0':
                        # 从文件名提取 SHA1（前 16 字符）
                        string.strncpy(out_arr + out_count * 17, fname, 16)
                        out_arr[out_count * 17 + 16] = '\0'
                        out_count += 1
                if win32file.FindNextFileA(handle, find_data) == 0:
                    break
            win32file.FindClose(handle)
    else:
        # 扫描 {base_dir}/* 的子目录
        pattern = stdlib.malloc(bd_len + 4)
        if pattern is None:
            stdlib.free(find_data)
            return out_count
        viperlib.snprintf(pattern, bd_len + 4, "%s/*", base_dir)
        handle = win32file.FindFirstFileA(pattern, find_data)
        stdlib.free(pattern)
        if handle != win32base.INVALID_HANDLE_VALUE:
            while 1:
                # 检查是否是目录（FILE_ATTRIBUTE_DIRECTORY = 0x10 = 16）
                attrs: t.CUInt32T = find_data.dwFileAttributes
                if (attrs & 16) != 0:
                    fname = find_data.cFileName
                    if fname is not None:
                        # 跳过 "." 和 ".."
                        is_dot: int = 0
                        if fname[0] == '.':
                            if fname[1] == '\0':
                                is_dot = 1
                            elif fname[1] == '.' and fname[2] == '\0':
                                is_dot = 1
                        if is_dot == 0:
                            # 构建子目录路径并递归扫描
                            fname_len: t.CSizeT = string.strlen(fname)
                            sub_dir: str = stdlib.malloc(bd_len + fname_len + 2)
                            if sub_dir is not None:
                                viperlib.snprintf(sub_dir, bd_len + fname_len + 2, "%s/%s", base_dir, fname)
                                sub_dir_len: t.CSizeT = string.strlen(sub_dir)
                                out_count = _collect_stub_sha1s(sub_dir, sub_dir_len, level - 1, out_arr, out_count, max_count)
                                stdlib.free(sub_dir)
                if win32file.FindNextFileA(handle, find_data) == 0:
                    break
            win32file.FindClose(handle)

    stdlib.free(find_data)
    return out_count


# ============================================================
# _load_includes_sha1_set - 读取 _sha1_map.txt，收集 includes/ 开头的 SHA1
#
# _sha1_map.txt 格式：{sha16}:{rel_path}
# 仅收集 rel_path 以 "includes/" 开头的 SHA1，用于过滤 stub 文件，
# 避免加载 TransPyV 自身源文件（lib/*）的 stub 导致链接失败。
# ============================================================
def _load_includes_sha1_set(pool: memhub.MemBuddy | t.CPtr,
                            temp_dir: str,
                            sha1_set: str) -> int:
    """读取 _sha1_map.txt，将 includes/ 开头的 SHA1 写入 sha1_set
    sha1_set 大小为 MAX_INCLUDES_SHA1 * 17（每个 SHA1 16字符+null）
    返回找到的 includes SHA1 数量，-1 表示错误"""
    if pool is None or temp_dir is None or sha1_set is None:
        return -1

    # 构造路径 temp_dir/_sha1_map.txt（使用 stdlib.malloc 避免 mbuddy 池耗尽）
    dir_len: t.CSizeT = string.strlen(temp_dir)
    map_path: bytes = stdlib.malloc(dir_len + 32)
    if map_path is None:
        return -1
    viperlib.snprintf(map_path, dir_len + 32, "%s/_sha1_map.txt", temp_dir)

    # 打开文件
    f: fileio.File | t.CPtr = fileio.File(map_path, fileio.MODE.R)
    if f.closed:
        return -1

    # 读取内容（使用 stdlib.malloc 避免 mbuddy 池耗尽）
    MAP_BUF_SIZE: t.CSizeT = 65536
    content: str = stdlib.malloc(MAP_BUF_SIZE)
    if content is None:
        f.close()
        return -1
    bytes_read: t.CInt64T = f.read_all(content, MAP_BUF_SIZE)
    f.close()
    if bytes_read <= 0:
        return -1
    if bytes_read < MAP_BUF_SIZE:
        content[bytes_read] = '\0'
    else:
        content[MAP_BUF_SIZE - 1] = '\0'

    # 解析行: {sha1}:{rel_path}
    count: int = 0
    pos: t.CSizeT = 0
    content_len: t.CSizeT = bytes_read
    while pos < content_len:
        # 找行尾
        line_start: t.CSizeT = pos
        while pos < content_len:
            if content[pos] == '\n':
                break
            pos += 1
        line_len: t.CSizeT = pos - line_start
        pos += 1  # skip \n

        # 最小长度: 16(sha1) + 1(:) + 9(includes/) = 26
        if line_len < 26:
            continue
        # 检查第17个字符是 ':'
        if content[line_start + 16] != ':':
            continue

        # 检查 rel_path 是否以 "includes/" 开头
        rel_start: t.CSizeT = line_start + 17
        if string.strncmp(content + rel_start, "includes/", 9) == 0:
            if count < MAX_INCLUDES_SHA1:
                string.strncpy(sha1_set + count * 17, content + line_start, 16)
                sha1_set[count * 17 + 16] = '\0'
                count += 1

    return count


# ============================================================
# _is_in_sha1_set - 检查 SHA1 是否在集合中
# ============================================================
def _is_in_sha1_set(sha1: str, sha1_set: str, set_count: int) -> int:
    """检查 sha1 是否在集合中"""
    if sha1 is None or sha1_set is None:
        return 0
    for i in range(set_count):
        if string.strcmp(sha1_set + i * 17, sha1) == 0:
            return 1
    return 0


# ============================================================
# WriteIncludesSha1Map - 将 includes 扫描结果写入 _sha1_map.txt
#
# TransPyV.exe 自己生成 _sha1_map.txt（不再依赖 Projectrans.py 预生成），
# 确保所有 includes 文件的 SHA1 都被记录，供 StubMerger 加载 stub 时过滤。
#
# Args:
#   mb: 内存池
#   temp_dir: 临时目录（_sha1_map.txt 写入位置）
#   scan_result: IncludesScanner 扫描结果
#
# Returns:
#   0 成功，非 0 失败
# ============================================================
def WriteIncludesSha1Map(mb: memhub.MemBuddy | t.CPtr, temp_dir: str,
                         scan_result: IncludesScanner.ScanResult | t.CPtr,
                         filter_set: t.CChar | t.CPtr,
                         filter_count: int) -> int:
    """将 includes 扫描结果写入 _sha1_map.txt（供 StubMerger 使用）

    若 filter_set 不为 None 且 filter_count > 0，只写入 filter_set 中的条目。
    """
    if temp_dir is None or scan_result is None:
        return 1

    # 构造路径 temp_dir/_sha1_map.txt
    dir_len: t.CSizeT = string.strlen(temp_dir)
    map_path: bytes = stdlib.malloc(dir_len + 32)
    if map_path is None:
        return 1
    viperlib.snprintf(map_path, dir_len + 32, "%s/_sha1_map.txt", temp_dir)

    # 打开文件写入（CREATE_ALWAYS）
    f: fileio.File | t.CPtr = fileio.File(map_path, fileio.MODE.W)
    if f.closed:
        return 1

    # 写入每个 include 条目: {sha1}:includes/{rel_path}\n
    entry_size_w: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()
    line_buf: bytes = stdlib.malloc(512)
    if line_buf is None:
        f.close()
        return 1

    written_count: int = 0
    for i in range(scan_result.Count):
        ea_w: t.CUInt64T = t.CUInt64T(scan_result.Entries) + i * entry_size_w
        ent_w: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(ea_w, t.CPtr))
        if ent_w is None or ent_w.Sha1 is None or ent_w.RelPath is None:
            continue
        # 若提供过滤集合，只写入集合中的条目
        if filter_set is not None and filter_count > 0:
            if _is_in_sha1_set(ent_w.Sha1, filter_set, filter_count) == 0:
                continue
        viperlib.snprintf(line_buf, 512, "%s:includes/%s\n", ent_w.Sha1, ent_w.RelPath)
        line_len_w: t.CSizeT = string.strlen(line_buf)
        f.write(line_buf, line_len_w)
        written_count += 1

    f.close()
    return 0


# ============================================================
# _IsFuncDeclaredOrDefined - 检查 out_buf 中是否已有函数的 declare/define
#
# 逐字节strncmp搜索 func_sig（如 @"sha1.func"(/ @printf( ），每次
# 找到匹配后检查行首是否以 "declare " 或 "define " 开头，跳过 call 语句。
# 避免 strstr 子串匹配误匹配 call ... @"func"(...) 中的 @"func"( 子串。
#
# Args:
#   out_buf: 已有的 IR 文本缓冲区
#   func_sig: 函数签名片段，如 @"sha1.func"(/ @printf(
#
# Returns:
#   1=已存在 declare/define, 0=不存在
# ============================================================
def _IsFuncDeclaredOrDefined(out_buf: bytes, func_sig: str) -> int:
    """检查 out_buf 中是否已有函数的 declare 或 define 行"""
    if out_buf is None or func_sig is None:
        return 0
    sig_len: t.CSizeT = string.strlen(func_sig)
    out_len: t.CSizeT = string.strlen(out_buf)
    if sig_len == 0 or out_len == 0 or sig_len > out_len:
        return 0
    pos: t.CSizeT = 0
    while pos + sig_len <= out_len:
        if string.strncmp(out_buf + pos, func_sig, sig_len) == 0:
            ls: t.CSizeT = pos
            while ls > 0 and out_buf[ls - 1] != '\n':
                ls -= 1
            if string.strncmp(out_buf + ls, "declare ", 8) == 0:
                return 1
            if string.strncmp(out_buf + ls, "define ", 7) == 0:
                return 1
        pos += 1
    return 0


# ============================================================
# _CommentOutDeclareInBuf - 将 out_buf 中匹配 func_sig 的 declare 行注释掉
#
# 用于解决 declare/define 冲突：当本地 text.ll 包含 define 而依赖
# text.ll 已生成了同函数的 declare 时，将 declare 行首字符改为 ';'
# 使其成为注释，然后追加 define 行。
# ============================================================
def _CommentOutDeclareInBuf(out_buf: bytes, func_sig: str) -> int:
    """在 out_buf 中搜索 declare 行（包含 func_sig），将其注释掉"""
    if out_buf is None or func_sig is None:
        return 0
    sig_len: t.CSizeT = string.strlen(func_sig)
    out_len: t.CSizeT = string.strlen(out_buf)
    if sig_len == 0 or out_len == 0 or sig_len > out_len:
        return 0
    pos: t.CSizeT = 0
    while pos + sig_len <= out_len:
        if string.strncmp(out_buf + pos, func_sig, sig_len) == 0:
            ls: t.CSizeT = pos
            while ls > 0 and out_buf[ls - 1] != '\n':
                ls -= 1
            if string.strncmp(out_buf + ls, "declare ", 8) == 0:
                out_buf[ls] = ';'
                return 1
        pos += 1
    return 0


# ============================================================
# _CommentOutGlobalInBuf - 将 out_buf 中匹配全局变量名的行注释掉
#
# 解决 stub/text 全局变量重复定义问题：stub 中可能是 external 声明
# 或完整定义，以 text 中的定义为准，将 stub 中的同名行注释掉。
# ============================================================
def _CommentOutGlobalInBuf(out_buf: bytes, global_name: str) -> int:
    """在 out_buf 中搜索全局变量定义行（以 global_name 开头），将行首改为 ';'"""
    if out_buf is None or global_name is None:
        return 0
    name_len: t.CSizeT = string.strlen(global_name)
    out_len: t.CSizeT = string.strlen(out_buf)
    if name_len == 0 or out_len == 0 or name_len > out_len:
        return 0
    pos: t.CSizeT = 0
    while pos + name_len <= out_len:
        if string.strncmp(out_buf + pos, global_name, name_len) == 0:
            # 确认是行首（前一个是换行或 pos==0）
            if pos == 0 or out_buf[pos - 1] == '\n':
                out_buf[pos] = ';'
                return 1
        pos += 1
    return 0


# ============================================================
# _CommentOutOpaqueTypeInBuf - 将 out_buf 中匹配类型名的 opaque 声明行注释掉
#
# 解决跨模块类型定义冲突：本地 stub 可能包含自动生成的 opaque 声明
#（如 %"sha1.Widget" = type opaque），而依赖 stub 包含完整定义
#（如 %"sha1.Widget" = type { i8*, i32 }）。去重时需要将 opaque 声明
# 注释掉，让完整定义被追加，否则 LLC 报错 "Cannot allocate unsized type"。
# ============================================================
def _CommentOutOpaqueTypeInBuf(out_buf: bytes, type_name_prefix: str) -> int:
    """在 out_buf 中搜索 type_name_prefix 对应的 opaque 声明行，将行首改为 ';'

    type_name_prefix 格式: '%"sha1.ClassName"'（不含 '=' 和后续内容）
    返回 1=已注释, 0=未找到
    """
    if out_buf is None or type_name_prefix is None:
        return 0
    prefix_len: t.CSizeT = string.strlen(type_name_prefix)
    out_len: t.CSizeT = string.strlen(out_buf)
    if prefix_len == 0 or out_len == 0 or prefix_len > out_len:
        return 0
    pos: t.CSizeT = 0
    while pos + prefix_len <= out_len:
        if string.strncmp(out_buf + pos, type_name_prefix, prefix_len) == 0:
            # 确认是行首（前一个是换行或 pos==0）
            if pos == 0 or out_buf[pos - 1] == '\n':
                # 检查后面是否是 " = type opaque"
                p: t.CSizeT = pos + prefix_len
                # 跳过空格
                while p < out_len and out_buf[p] == ' ':
                    p += 1
                if p < out_len and out_buf[p] == '=':
                    p += 1
                    while p < out_len and out_buf[p] == ' ':
                        p += 1
                    if p + 11 <= out_len:
                        if string.strncmp(out_buf + p, "type opaque", 11) == 0:
                            # 找到 opaque 声明，将行首改为 ';'
                            out_buf[pos] = ';'
                            return 1
        pos += 1
    return 0


# ============================================================
# _HasFullTypeDefinition - 检查 out_buf 中是否已有完整类型定义（非 opaque）
#
# type_name_prefix 格式: '%"sha1.ClassName"'（不含 '='）
# 完整定义: %"name" = type { ... } 或 %"name" = type < { ... } >
# 返回 1=已有完整定义, 0=无完整定义
# ============================================================
def _HasFullTypeDefinition(out_buf: bytes, type_name_prefix: str) -> int:
    """检查 out_buf 中是否已有 type_name_prefix 的完整定义"""
    if out_buf is None or type_name_prefix is None:
        return 0
    prefix_len: t.CSizeT = string.strlen(type_name_prefix)
    out_len: t.CSizeT = string.strlen(out_buf)
    if prefix_len == 0 or out_len == 0 or prefix_len > out_len:
        return 0
    pos: t.CSizeT = 0
    while pos + prefix_len <= out_len:
        if string.strncmp(out_buf + pos, type_name_prefix, prefix_len) == 0:
            # 确认是行首（前一个是换行或 pos==0），且未被注释（行首不是 ';'）
            is_line_start: int = 0
            if pos == 0:
                is_line_start = 1
            elif out_buf[pos - 1] == '\n':
                is_line_start = 1
            if is_line_start == 1:
                # 检查后面是否是 " = type {" 或 " = type <"
                p: t.CSizeT = pos + prefix_len
                while p < out_len and out_buf[p] == ' ':
                    p += 1
                if p < out_len and out_buf[p] == '=':
                    p += 1
                    while p < out_len and out_buf[p] == ' ':
                        p += 1
                    if p + 5 < out_len:
                        if string.strncmp(out_buf + p, "type ", 5) == 0:
                            p += 5
                            if p < out_len:
                                if out_buf[p] == '{' or out_buf[p] == '<':
                                    return 1
        pos += 1
    return 0


# ============================================================
# _LoadAndAppendStub - 加载依赖 stub 并追加到 out_buf
#
# 读取 {temp_dir}/{sha1}.stub.ll，跳过 header（;, target, source_filename），
# 去重 declare/global，追加到 out_buf。返回新 out_pos。
# ============================================================
def _LoadAndAppendStub(temp_dir: str, td_len: t.CSizeT, dep_sha1: str,
                       dep_buf: bytes, out_buf: bytes, out_size: t.CSizeT,
                       out_pos: t.CSizeT) -> t.CSizeT:
    """加载依赖 stub 并追加（跳过 header，去重）"""
    if temp_dir is None or dep_sha1 is None or dep_buf is None or out_buf is None:
        return out_pos

    dep_path: str = _sliced_path(temp_dir, td_len, dep_sha1, "stub.ll")
    if dep_path is None:
        return out_pos
    df_ls: fileio.File | t.CPtr = fileio.File(dep_path, fileio.MODE.R)
    if df_ls.closed:
        stdlib.free(dep_path)
        return out_pos
    dep_br_ls: t.CInt64T = df_ls.read_all(dep_buf, STUB_READ_BUF_SIZE)
    df_ls.close()
    stdlib.free(dep_path)
    if dep_br_ls <= 0:
        return out_pos
    if dep_br_ls < STUB_READ_BUF_SIZE:
        dep_buf[dep_br_ls] = '\0'
    else:
        dep_buf[STUB_READ_BUF_SIZE - 1] = '\0'

    # 注释掉依赖 stub 中的字符串常量行（模块内部的，不需要）
    # 简单方案：搜索 "= external unnamed_addr constant" 并将行首的 @ 改为 ;@
    cfs_pos: t.CSizeT = 0
    while cfs_pos + 30 < t.CSizeT(dep_br_ls):
        ext_p: t.CPtr = string.strstr(dep_buf + cfs_pos, "= external unnamed_addr constant")
        if ext_p is None:
            break
        ext_off2: t.CSizeT = t.CSizeT(t.CUInt64T(ext_p) - t.CUInt64T(dep_buf))
        # 向前查找行首的 @
        ls: t.CSizeT = ext_off2
        while ls > 0:
            if dep_buf[ls] == '\n':
                ls += 1
                break
            ls -= 1
        if ls < ext_off2 and dep_buf[ls] == '@':
            dep_buf[ls] = ';'
        cfs_pos = ext_off2 + 30

    # 跳过 header，追加内容（去重 declare/global）
    dep_pos: t.CSizeT = 0
    skipping: int = 1
    while dep_pos < dep_br_ls:
        line_start: t.CSizeT = dep_pos
        while dep_pos < dep_br_ls:
            if dep_buf[dep_pos] == '\n':
                break
            dep_pos += 1
        line_len: t.CSizeT = dep_pos - line_start
        if dep_pos < dep_br_ls:
            dep_pos += 1
        if skipping != 0:
            if line_len == 0:
                continue
            ch0: int = dep_buf[line_start]
            if ch0 == ';':
                continue
            if ch0 == 't' and line_len >= 6:
                if string.strncmp(dep_buf + line_start, "target", 6) == 0:
                    continue
            if ch0 == 's' and line_len >= 15:
                if string.strncmp(dep_buf + line_start, "source_filename", 15) == 0:
                    continue
            skipping = 0
        # 去重：declare（用 _IsFuncDeclaredOrDefined 避免误匹配 call 语句）
        if line_len >= 8 and string.strncmp(dep_buf + line_start, "declare ", 8) == 0:
            at: t.CSizeT = line_start + 8
            while at < line_start + line_len:
                if dep_buf[at] == '@':
                    break
                at += 1
            if at < line_start + line_len:
                lp: t.CSizeT = at + 1
                while lp < line_start + line_len:
                    if dep_buf[lp] == '(':
                        break
                    lp += 1
                if lp < line_start + line_len:
                    saved: t.CChar = dep_buf[lp + 1]
                    dep_buf[lp + 1] = '\0'
                    if _IsFuncDeclaredOrDefined(out_buf, dep_buf + at) != 0:
                        dep_buf[lp + 1] = saved
                        continue
                    dep_buf[lp + 1] = saved
        # 去重：external global
        if line_len > 0 and dep_buf[line_start] == '@':
            eq: t.CSizeT = line_start + 1
            while eq < line_start + line_len:
                if dep_buf[eq] == '=':
                    break
                eq += 1
            if eq < line_start + line_len:
                saved: t.CChar = dep_buf[eq + 1]
                dep_buf[eq + 1] = '\0'
                if string.strstr(out_buf, dep_buf + line_start) is not None:
                    dep_buf[eq + 1] = saved
                    continue
                dep_buf[eq + 1] = saved
        # 去重：type 定义（如 %"sha1.Point" = type {i32, i32}）
        # 区分完整定义（= type { ... } / = type < ... >）和 opaque 声明（= type opaque）
        # 当本地 stub 有 opaque 声明而依赖 stub 有完整定义时，注释掉 opaque 行，
        # 让完整定义被追加，避免 LLC "Cannot allocate unsized type" 错误。
        if line_len > 0 and dep_buf[line_start] == '%':
            eq2: t.CSizeT = line_start + 1
            while eq2 < line_start + line_len:
                if dep_buf[eq2] == '=':
                    break
                eq2 += 1
            if eq2 < line_start + line_len:
                saved2: t.CChar = dep_buf[eq2 + 1]
                dep_buf[eq2 + 1] = '\0'
                # 检查依赖行是否为完整定义（= type { 或 = type <）
                dep_is_full_def: int = 0
                if eq2 + 8 <= line_start + line_len:
                    if dep_buf[eq2 + 2] == 't' and dep_buf[eq2 + 3] == 'y' and dep_buf[eq2 + 4] == 'p' and dep_buf[eq2 + 5] == 'e' and dep_buf[eq2 + 6] == ' ':
                        if dep_buf[eq2 + 7] == '{' or dep_buf[eq2 + 7] == '<':
                            dep_is_full_def = 1
                if dep_is_full_def == 1:
                    # 依赖行是完整定义
                    # 临时截断到 '=' 之前（不含 '='），辅助函数期望纯类型名前缀
                    saved_eq: t.CChar = dep_buf[eq2]
                    dep_buf[eq2] = '\0'
                    # 1. 注释掉 out_buf 中的 opaque 声明（如果有）
                    commented: int = _CommentOutOpaqueTypeInBuf(out_buf, dep_buf + line_start)
                    # 2. 检查 out_buf 中是否已有完整定义（避免重复）
                    has_full: int = _HasFullTypeDefinition(out_buf, dep_buf + line_start)
                    dep_buf[eq2] = saved_eq
                    if has_full == 1:
                        dep_buf[eq2 + 1] = saved2
                        continue
                    # 3. 追加完整定义
                else:
                    # 依赖行是 opaque 声明，用原有子串匹配去重
                    found_opaque: t.CPtr = string.strstr(out_buf, dep_buf + line_start)
                    if found_opaque is not None:
                        dep_buf[eq2 + 1] = saved2
                        continue
                dep_buf[eq2 + 1] = saved2
        # 追加
        if out_pos + line_len + 2 < out_size:
            string.strncpy(out_buf + out_pos, dep_buf + line_start, line_len)
            out_pos += line_len
            out_buf[out_pos] = '\n'
            out_pos += 1
            out_buf[out_pos] = '\0'
    return out_pos


# ============================================================
# _LoadAndAppendTextDeclares - 从依赖 text.ll 提取 declare 追加到 out_buf
#
# 读取 {temp_dir}/{sha1}.text.ll，将 define 行转为 declare（提取函数签名），
# 跳过函数体，去重后追加到 out_buf。返回新 out_pos。
# ============================================================
def _LoadAndAppendTextDeclares(temp_dir: str, td_len: t.CSizeT, dep_sha1: str,
                                dep_buf: bytes, out_buf: bytes, out_size: t.CSizeT,
                                out_pos: t.CSizeT) -> t.CSizeT:
    """从依赖 text.ll 提取 declare（define 转 declare），追加到 out_buf"""
    if temp_dir is None or dep_sha1 is None or dep_buf is None or out_buf is None:
        return out_pos

    text_path: str = _sliced_path(temp_dir, td_len, dep_sha1, "text.ll")
    if text_path is None:
        return out_pos
    tf_lt: fileio.File | t.CPtr = fileio.File(text_path, fileio.MODE.R)
    if tf_lt.closed:
        stdlib.free(text_path)
        return out_pos
    text_br: t.CInt64T = tf_lt.read_all(dep_buf, STUB_READ_BUF_SIZE)
    tf_lt.close()
    stdlib.free(text_path)
    if text_br <= 0:
        return out_pos
    if text_br < STUB_READ_BUF_SIZE:
        dep_buf[text_br] = '\0'
    else:
        dep_buf[STUB_READ_BUF_SIZE - 1] = '\0'

    dep_pos_lt: t.CSizeT = 0
    in_body: int = 0
    while dep_pos_lt < text_br:
        ls: t.CSizeT = dep_pos_lt
        while dep_pos_lt < text_br:
            if dep_buf[dep_pos_lt] == '\n':
                break
            dep_pos_lt += 1
        ll: t.CSizeT = dep_pos_lt - ls
        if dep_pos_lt < text_br:
            dep_pos_lt += 1

        # 函数体跳过：直到单独的 } 行
        if in_body != 0:
            if ll == 1 and dep_buf[ls] == '}':
                in_body = 0
            continue

        # 跳过空行和 header
        if ll == 0:
            continue
        c0: int = dep_buf[ls]
        if c0 == ';':
            continue
        if c0 == 't' and ll >= 6 and string.strncmp(dep_buf + ls, "target", 6) == 0:
            continue
        if c0 == 's' and ll >= 15 and string.strncmp(dep_buf + ls, "source_filename", 15) == 0:
            continue

        # 处理 define 行：转为 declare
        if ll >= 7 and string.strncmp(dep_buf + ls, "define ", 7) == 0:
            # 提取 @funcname( 用于去重
            at_lt: t.CSizeT = ls + 7
            while at_lt < ls + ll:
                if dep_buf[at_lt] == '@':
                    break
                at_lt += 1
            if at_lt >= ls + ll:
                in_body = 1
                continue
            lp_lt: t.CSizeT = at_lt + 1
            while lp_lt < ls + ll:
                if dep_buf[lp_lt] == '(':
                    break
                lp_lt += 1
            if lp_lt >= ls + ll:
                in_body = 1
                continue
            # 去重检查：用 _IsFuncDeclaredOrDefined 避免误匹配 call 语句
            saved_lt: t.CChar = dep_buf[lp_lt + 1]
            dep_buf[lp_lt + 1] = '\0'
            if _IsFuncDeclaredOrDefined(out_buf, dep_buf + at_lt) != 0:
                dep_buf[lp_lt + 1] = saved_lt
                in_body = 1
                continue
            dep_buf[lp_lt + 1] = saved_lt

            # 找行尾的 ' {' 并截断
            decl_end: t.CSizeT = ls + ll
            if decl_end > ls + 1:
                if dep_buf[decl_end - 1] == '{' and dep_buf[decl_end - 2] == ' ':
                    decl_end -= 2

            # 输出: declare + content (skip "define " 7 chars, up to decl_end)
            copy_len_lt: t.CSizeT = decl_end - (ls + 7)
            if out_pos + 8 + copy_len_lt + 2 < out_size:
                string.strncpy(out_buf + out_pos, "declare ", 8)
                out_pos += 8
                string.strncpy(out_buf + out_pos, dep_buf + ls + 7, copy_len_lt)
                out_pos += copy_len_lt
                out_buf[out_pos] = '\n'
                out_pos += 1
                out_buf[out_pos] = '\0'
            in_body = 1
            continue

        # 跳过其他行（global 带初值定义、type 定义等，stub 已有 external 声明）
    return out_pos


# ============================================================
# _PathToModuleName - 将文件路径转换为模块名
#
# 输入: "includes/stdio.py" 或 "includes/lib/core/Handles/HandlesType.py"
# 输出: "stdio" 或 "lib.core.Handles.HandlesType"
# 去除 includes/ 前缀和 .py 后缀，/ 替换为 .
# 返回 stdlib.malloc 分配的字符串，调用者负责释放
# ============================================================
def _PathToModuleName(path: str) -> str:
    """将文件路径转换为模块名

    特殊处理 __init__.py：includes/ast/__init__.py → ast（而非 ast.__init__）
    """
    if path is None:
        return None
    plen: t.CSizeT = string.strlen(path)
    # 跳过 includes/ 前缀
    prefix: str = "includes/"
    prefix_len: t.CSizeT = 9
    path_start: t.CSizeT = 0
    if plen > prefix_len and string.strncmp(path, prefix, prefix_len) == 0:
        path_start = prefix_len
        plen = plen - prefix_len
    # 去掉 .py 后缀
    if plen > 3 and path[path_start + plen - 3] == '.' and path[path_start + plen - 2] == 'p' and path[path_start + plen - 1] == 'y':
        plen -= 3
    if plen == 0:
        return None
    # 检查是否以 /__init__ 或 \__init__ 结尾（包的 __init__.py）
    # /__init__ 是 9 个字符：/  _  _  i  n  i  t  _  _
    # 如果是，去掉分隔符+__init__ 后缀，模块名就是包名（如 ast/__init__ → ast）
    # 注意：顶级 __init__.py（plen=8）不会进入此分支，因为 plen > 9 才检查
    # 同时支持 / 和 \ 两种分隔符（TPC 写入的路径可能混合使用）
    if plen > 9:
        tail_off: t.CSizeT = path_start + plen - 9
        sep_char: t.CChar = path[tail_off]
        if (sep_char == '/' or sep_char == '\\') \
           and path[tail_off + 1] == '_' and path[tail_off + 2] == '_' \
           and path[tail_off + 3] == 'i' and path[tail_off + 4] == 'n' and path[tail_off + 5] == 'i' \
           and path[tail_off + 6] == 't' and path[tail_off + 7] == '_' and path[tail_off + 8] == '_':
            # 去掉 分隔符+__init__ 后缀，plen 就是包名部分长度
            plen = tail_off - path_start
    if plen == 0:
        return None
    # 复制并替换 / 为 .
    result: str = stdlib.malloc(plen + 1)
    if result is None:
        return None
    for ri in range(plen):
        ch: t.CChar = path[path_start + ri]
        if ch == '/' or ch == '\\':
            result[ri] = '.'
        else:
            result[ri] = ch
    result[plen] = '\0'
    return result


# ============================================================
# _BuildIncludesSha1Map - 从 _sha1_map.txt 构建 sha1 → module_name 映射
#
# _sha1_map.txt 格式: {sha1}:includes/{rel_path}\n
# 返回两个数组（sha1_list 和 mod_list），长度存储在 count 中。
# 所有内存由 stdlib.malloc 分配，调用者负责释放。
# ============================================================
def _BuildIncludesSha1Map(temp_dir: str, td_len: t.CSizeT,
                          sha1_list: t.CChar | t.CPtr,
                          mod_list: t.CChar | t.CPtr) -> int:
    """从 _sha1_map.txt 构建 sha1→module_name 映射，返回条目数"""
    if temp_dir is None or sha1_list is None or mod_list is None:
        return 0

    map_path: bytes = stdlib.malloc(td_len + 32)
    if map_path is None:
        return 0
    viperlib.snprintf(map_path, td_len + 32, "%s/_sha1_map.txt", temp_dir)
    mf: fileio.File | t.CPtr = fileio.File(map_path, fileio.MODE.R)
    if mf.closed:
        stdlib.free(map_path)
        return 0
    map_buf: bytes = stdlib.malloc(STUB_READ_BUF_SIZE)
    if map_buf is None:
        mf.close()
        stdlib.free(map_path)
        return 0
    map_br: t.CInt64T = mf.read_all(map_buf, STUB_READ_BUF_SIZE)
    mf.close()
    stdlib.free(map_path)
    if map_br <= 0:
        stdlib.free(map_buf)
        return 0
    if map_br < STUB_READ_BUF_SIZE:
        map_buf[map_br] = '\0'
    else:
        map_buf[STUB_READ_BUF_SIZE - 1] = '\0'

    count: int = 0
    pos: t.CSizeT = 0
    # 在循环外分配 sha1 缓冲区，避免反复 malloc/free 导致堆碎片化
    sha1: t.CChar | t.CPtr = stdlib.malloc(17)
    if sha1 is None:
        stdlib.free(map_buf)
        return 0
    while pos < map_br and count < MAX_INCLUDES:
        # 提取 SHA1（16 hex）
        string.strncpy(sha1, map_buf + pos, 16)
        sha1[16] = '\0'
        pos += 16
        # 跳过 ':'
        if pos < map_br and map_buf[pos] == ':':
            pos += 1
        # 提取路径（到 \r、\n 或 \0）
        # 注意: Windows CRLF 换行符是 \r\n，必须同时检查 \r 避免路径包含 \r
        path_start: t.CSizeT = pos
        while pos < map_br and map_buf[pos] != '\n' and map_buf[pos] != '\r' and map_buf[pos] != '\0':
            pos += 1
        path_len: t.CSizeT = pos - path_start
        # 跳过 \r\n 或 \n
        if pos < map_br and map_buf[pos] == '\r':
            pos += 1
        if pos < map_br and map_buf[pos] == '\n':
            pos += 1
        if path_len > 0:
            # 仅收集 includes/ 前缀的条目（用户文件如 App/ 不应进入 includes 映射）
            # 否则用户文件会被误判为 includes，导致 is_module_imported 模块名不匹配而跳过加载
            if path_len >= 9 and string.strncmp(map_buf + path_start, "includes/", 9) == 0:
                path_buf: t.CChar | t.CPtr = stdlib.malloc(path_len + 1)
                if path_buf is not None:
                    string.strncpy(path_buf, map_buf + path_start, path_len)
                    path_buf[path_len] = '\0'
                    mod_name: str = _PathToModuleName(path_buf)
                    stdlib.free(path_buf)
                    if mod_name is not None:
                        # 存储 sha1 和 mod_name 到数组中
                        idx: t.CSizeT = t.CSizeT(count) * 17
                        string.strcpy(sha1_list + idx, sha1)
                        idx2: t.CSizeT = t.CSizeT(count) * 64
                        mn_len: t.CSizeT = string.strlen(mod_name)
                        if mn_len < 64:
                            string.strcpy(mod_list + idx2, mod_name)
                        else:
                            string.strncpy(mod_list + idx2, mod_name, 63)
                            mod_list[idx2 + 63] = '\0'
                        stdlib.free(mod_name)
                        count += 1
    stdlib.free(sha1)
    stdlib.free(map_buf)
    return count


# ============================================================
# _FindSha1ByModName - 从模块名查找 SHA1（精确匹配）
#
# 在 sha1_arr/mod_arr 映射中查找模块名对应的 SHA1。
# 用于依赖图分析：模块名 → SHA1。
#
# Args:
#   sha1_arr: SHA1 数组（每个 17 字节）
#   mod_arr: 模块名数组（每个 64 字节）
#   count: 映射条目数
#   mod_name: 要查找的模块名
#
# Returns:
#   SHA1 字符串指针（指向 sha1_arr 内部，无需释放），未找到返回 None
# ============================================================
def _FindSha1ByModName(sha1_arr: t.CChar | t.CPtr, mod_arr: t.CChar | t.CPtr,
                       count: int, mod_name: str) -> str:
    """从模块名查找 SHA1（精确匹配）"""
    if sha1_arr is None or mod_arr is None or mod_name is None:
        return None
    if count <= 0:
        return None
    for i in range(count):
        idx: t.CSizeT = t.CSizeT(i) * 64
        if string.strcmp(mod_arr + idx, mod_name) == 0:
            sidx: t.CSizeT = t.CSizeT(i) * 17
            return sha1_arr + sidx
    return None


# ============================================================
# _AddSha1ToSet - 将 SHA1 加入集合（去重）
#
# 检查 SHA1 是否已在集合中，若不在则加入。返回新的 count。
#
# Args:
#   set_buf: SHA1 集合缓冲区（每个 17 字节）
#   count: 当前集合中的 SHA1 数量
#   sha1: 要加入的 SHA1
#
# Returns:
#   新的 count（如果已存在则不变）
# ============================================================
def _AddSha1ToSet(set_buf: t.CChar | t.CPtr, count: int, sha1: str) -> int:
    """将 SHA1 加入集合，返回新 count"""
    if set_buf is None or sha1 is None:
        return count
    for i in range(count):
        idx: t.CSizeT = t.CSizeT(i) * 17
        if string.strcmp(set_buf + idx, sha1) == 0:
            return count
    if count < MAX_INCLUDES_SHA1:
        idx: t.CSizeT = t.CSizeT(count) * 17
        string.strcpy(set_buf + idx, sha1)
        return count + 1
    return count


# ============================================================
# _BuildReachableSha1Set - 构建可达 SHA1 集合（依赖图按需翻译）
#
# 从 source_dir 的源文件开始，解析 import 语句，递归收集可达的
# includes 文件 SHA1。Phase 1b 只翻译可达集合中的文件，避免
# 翻译不需要的 includes（如 Test 不依赖 llvmlite，则不翻译）。
#
# 算法（工作列表）：
# 1. 扫描 source_dir 下的 .py 文件，解析 AST 获取 _imported_modules
# 2. 构建 SHA1→module_name 映射（从 _sha1_map.txt）
# 3. 工作列表递归：模块名 → 查 SHA1 → 加入 reachable_set → 读 .deps.txt → 追加新模块名
#
# Args:
#   mb: 内存池
#   source_dir: 源文件目录（Config.SourceDir）
#   temp_dir: 临时目录（_sha1_map.txt 和 .deps.txt 所在位置）
#   reachable_set: 输出参数，可达 SHA1 集合缓冲区（MAX_INCLUDES_SHA1 * 17 字节）
#
# Returns:
#   可达 SHA1 数量（>0 成功，<=0 失败）
# ============================================================
def _BuildReachableSha1Set(mb: memhub.MemBuddy | t.CPtr, source_dir: str,
                           temp_dir: str,
                           reachable_set: t.CChar | t.CPtr) -> int:
    """构建可达 SHA1 集合（依赖图按需翻译）"""
    if source_dir is None or temp_dir is None or reachable_set is None:
        return -1

    SRC_BUF_SIZE_R: t.CSizeT = 1048576

    # 1. 构建 SHA1→module_name 映射
    td_len_r: t.CSizeT = string.strlen(temp_dir)
    sha1_arr: bytes = stdlib.malloc(MAX_INCLUDES * 17)
    mod_arr: bytes = stdlib.malloc(MAX_INCLUDES * 64)
    if sha1_arr is None or mod_arr is None:
        if sha1_arr is not None:
            stdlib.free(sha1_arr)
        if mod_arr is not None:
            stdlib.free(mod_arr)
        return -1
    map_count: int = _BuildIncludesSha1Map(temp_dir, td_len_r, sha1_arr, mod_arr)
    if map_count <= 0:
        stdio.printf("[Reachable] 无法构建 SHA1 映射\n")
        stdlib.free(sha1_arr)
        stdlib.free(mod_arr)
        return -1
    stdio.printf("[Reachable] SHA1 映射: %d 个\n", map_count)

    # 2. 扫描 source_dir 下的 .py 文件，收集直接依赖
    dir_len: t.CSizeT = string.strlen(source_dir)
    pattern: bytes = stdlib.malloc(dir_len + 8)
    if pattern is None:
        stdlib.free(sha1_arr)
        stdlib.free(mod_arr)
        return -1
    viperlib.snprintf(pattern, dir_len + 8, "%s/*.py", source_dir)

    find_data_size: t.CSizeT = win32file.WIN32_FIND_DATAA.__sizeof__()
    find_data: win32file.WIN32_FIND_DATAA | t.CPtr = stdlib.malloc(find_data_size + 16)
    if find_data is None:
        stdlib.free(pattern)
        stdlib.free(sha1_arr)
        stdlib.free(mod_arr)
        return -1
    string.memset(find_data, 0, find_data_size + 16)

    # 工作列表（空格分隔的模块名）
    worklist: bytes = stdlib.malloc(8192)
    if worklist is None:
        stdlib.free(pattern)
        stdlib.free(find_data)
        stdlib.free(sha1_arr)
        stdlib.free(mod_arr)
        return -1
    worklist[0] = '\0'
    wl_len: t.CSizeT = 0

    reachable_count: int = 0

    handle: win32base.HANDLE = win32file.FindFirstFileA(pattern, find_data)
    if handle == win32base.INVALID_HANDLE_VALUE:
        stdio.printf("[Reachable] 未找到 .py 文件: %s\n", pattern)
        stdlib.free(pattern)
        stdlib.free(find_data)
        stdlib.free(sha1_arr)
        stdlib.free(mod_arr)
        stdlib.free(worklist)
        return -1

    while True:
        fname: str = find_data.cFileName
        if fname is not None:
            fname_len: t.CSizeT = string.strlen(fname)
            if fname_len > 3:
                is_py: int = 0
                if fname[fname_len - 3] == '.' and fname[fname_len - 2] == 'p' and fname[fname_len - 1] == 'y':
                    is_py = 1
                if is_py != 0:
                    full_path: bytes = stdlib.malloc(dir_len + fname_len + 2)
                    if full_path is not None:
                        viperlib.snprintf(full_path, dir_len + fname_len + 2, "%s/%s", source_dir, fname)
                        sf: fileio.File | t.CPtr = fileio.File(full_path, fileio.MODE.R)
                        if not sf.closed:
                            sbuf: bytes = stdlib.malloc(SRC_BUF_SIZE_R)
                            if sbuf is not None:
                                br: LONG = sf.read_all(sbuf, SRC_BUF_SIZE_R)
                                sf.close()
                                if br > 0:
                                    if br < SRC_BUF_SIZE_R:
                                        sbuf[br] = 0
                                    else:
                                        sbuf[SRC_BUF_SIZE_R - 1] = 0
                                    # 解析 AST 获取 _imported_modules
                                    lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
                                    if lx is not None:
                                        ast._lexer_init(lx, sbuf, mb)
                                        tokens: ast.Token | t.CPtr = ast.tokenize(lx)
                                        tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
                                        if tree is not None:
                                            tr: HandlesTranslator.Translator | t.CPtr = HandlesTranslator.Translator()
                                            if tr is not None:
                                                tr._declare_only = 2
                                                # 源文件包名：fname 是顶级文件名（无目录分隔符），包为 None
                                                tr.CurrentPackage = HandlesImports.compute_package_from_relpath(mb, fname)
                                                HandlesStruct.reset_visible_structs(mb, 0)
                                                tr.translate(tree)
                                                # 获取 _imported_modules
                                                if tr._imported_modules is not None:
                                                    im_len: t.CSizeT = string.strlen(tr._imported_modules)
                                                    if im_len > 0 and wl_len + im_len + 1 < 8192:
                                                        string.strcpy(worklist + wl_len, tr._imported_modules)
                                                        wl_len += im_len
                                                        worklist[wl_len] = ' '
                                                        wl_len += 1
                                                        worklist[wl_len] = '\0'
                                                # 释放 Translator 资源
                                                if tr._global_names is not None:
                                                    stdlib.free(tr._global_names)
                                                if tr._nonlocal_names is not None:
                                                    stdlib.free(tr._nonlocal_names)
                                    stdlib.free(sbuf)
                                else:
                                    stdlib.free(sbuf)
                            else:
                                sf.close()
                        stdlib.free(full_path)

        if win32file.FindNextFileA(handle, find_data) == 0:
            break
    win32base.FindClose(handle)
    stdlib.free(pattern)
    stdlib.free(find_data)

    # 去掉末尾多余空格
    if wl_len > 0 and worklist[wl_len - 1] == ' ':
        worklist[wl_len - 1] = '\0'
        wl_len -= 1

    stdio.printf("[Reachable] 源文件直接依赖: '%s'\n", worklist)

    # 2.5. 全局预加入基础容器模块（_list/_dict/json）
    #
    # 这些模块定义了 list/dict 等内建容器的泛型模板。
    # 使用 list[...]/dict[...] 语法时需要这些模块被翻译并注册模板。
    # 即使源文件和 includes 文件没有显式 import _list，也预加入以确保可达。
    # 这对应 TPC 的 _inject_auto_imports 机制（TPC 在翻译前自动注入 import _list）。
    # _list
    if HandlesImports.is_module_imported(worklist, "_list") == 0:
        bsha1_l: str = _FindSha1ByModName(sha1_arr, mod_arr, map_count, "_list")
        if bsha1_l is not None:
            if wl_len + 7 < 8192:
                if wl_len > 0:
                    worklist[wl_len] = ' '
                    wl_len += 1
                string.strcpy(worklist + wl_len, "_list")
                wl_len += 5
                worklist[wl_len] = ' '
                wl_len += 1
                worklist[wl_len] = '\0'
    # _dict
    if HandlesImports.is_module_imported(worklist, "_dict") == 0:
        bsha1_d: str = _FindSha1ByModName(sha1_arr, mod_arr, map_count, "_dict")
        if bsha1_d is not None:
            if wl_len + 7 < 8192:
                if wl_len > 0:
                    worklist[wl_len] = ' '
                    wl_len += 1
                string.strcpy(worklist + wl_len, "_dict")
                wl_len += 5
                worklist[wl_len] = ' '
                wl_len += 1
                worklist[wl_len] = '\0'
    # json
    if HandlesImports.is_module_imported(worklist, "json") == 0:
        bsha1_j: str = _FindSha1ByModName(sha1_arr, mod_arr, map_count, "json")
        if bsha1_j is not None:
            if wl_len + 6 < 8192:
                if wl_len > 0:
                    worklist[wl_len] = ' '
                    wl_len += 1
                string.strcpy(worklist + wl_len, "json")
                wl_len += 4
                worklist[wl_len] = ' '
                wl_len += 1
                worklist[wl_len] = '\0'
    stdio.printf("[Reachable] 预加入容器模块后: '%s'\n", worklist)

    # 3. 工作列表算法：递归收集可达 SHA1
    processed: bytes = stdlib.malloc(8192)
    if processed is None:
        stdlib.free(sha1_arr)
        stdlib.free(mod_arr)
        stdlib.free(worklist)
        return -1
    processed[0] = '\0'
    proc_len: t.CSizeT = 0

    wl_pos: t.CSizeT = 0
    wl_iter: int = 0
    while wl_pos < wl_len:
        wl_iter += 1
        # 提取一个模块名（到空格或末尾）
        name_start: t.CSizeT = wl_pos
        while wl_pos < wl_len and worklist[wl_pos] != ' ':
            wl_pos += 1
        name_len: t.CSizeT = wl_pos - name_start
        if wl_pos < wl_len:
            wl_pos += 1
        if name_len == 0:
            continue

        # 复制模块名
        mod_buf: bytes = stdlib.malloc(name_len + 1)
        if mod_buf is None:
            continue
        string.strncpy(mod_buf, worklist + name_start, name_len)
        mod_buf[name_len] = '\0'

        # 检查是否已处理
        already: int = 0
        if HandlesImports.is_module_imported(processed, mod_buf) != 0:
            already = 1
        if already == 0:
            # 加入 processed
            if proc_len + name_len + 1 < 8192:
                string.strcpy(processed + proc_len, mod_buf)
                proc_len += name_len
                processed[proc_len] = ' '
                proc_len += 1
                processed[proc_len] = '\0'

            # 查找 SHA1
            found_sha1: str = _FindSha1ByModName(sha1_arr, mod_arr, map_count, mod_buf)
            if found_sha1 is not None:
                # 加入 reachable_set
                reachable_count = _AddSha1ToSet(reachable_set, reachable_count, found_sha1)

                # 读取 .deps.txt 追加到 worklist
                deps_path: str = _sliced_path(temp_dir, td_len_r, found_sha1, "deps.txt")
                if deps_path is not None:
                    df: fileio.File | t.CPtr = fileio.File(deps_path, fileio.MODE.R)
                    if not df.closed:
                        deps_buf: bytes = stdlib.malloc(2048)
                        if deps_buf is not None:
                            dbr: t.CInt64T = df.read_all(deps_buf, 2048)
                            df.close()
                            if dbr > 0:
                                if dbr < 2048:
                                    deps_buf[dbr] = '\0'
                                else:
                                    deps_buf[2047] = '\0'
                                # 追加到 worklist（确保前面有空格分隔符，避免模块名合并）
                                dl: t.CSizeT = string.strlen(deps_buf)
                                if dl > 0 and wl_len + dl + 2 < 8192:
                                    if wl_len > 0 and worklist[wl_len - 1] != ' ':
                                        worklist[wl_len] = ' '
                                        wl_len += 1
                                    string.strcpy(worklist + wl_len, deps_buf)
                                    wl_len += dl
                                    worklist[wl_len] = ' '
                                    wl_len += 1
                                    worklist[wl_len] = '\0'
                            stdlib.free(deps_buf)
                        else:
                            df.close()
                    stdlib.free(deps_path)
        stdlib.free(mod_buf)
    stdlib.free(sha1_arr)
    stdlib.free(mod_arr)
    stdlib.free(worklist)
    stdlib.free(processed)

    stdio.printf("[Reachable] 可达 SHA1: %d 个\n", reachable_count)
    return reachable_count


# ============================================================
# BuildCombinedIR - 组合本地 stub + 依赖 stubs + 本地 text → 完整 IR
#
# 按需加载：读取 deps.txt 获取导入模块名，通过 _sha1_map.txt 查找 SHA1，
# 仅加载实际使用的依赖 stub（而非全部扫描）。
# ============================================================
def BuildCombinedIR(temp_dir: str, local_sha1: str,
                    out_buf: bytes, out_size: t.CSizeT) -> t.CSizeT:
    """组合本地 stub + 依赖 stubs + 本地 text → out_buf（按需加载）"""
    if temp_dir is None or local_sha1 is None or out_buf is None or out_size == 0:
        return 0

    td_len: t.CSizeT = string.strlen(temp_dir)
    out_buf[0] = '\0'
    out_pos: t.CSizeT = 0

    # 1. 读取并追加本地 stub.ll（含 header）
    stub_path: str = _sliced_path(temp_dir, td_len, local_sha1, "stub.ll")
    if stub_path is None:
        return 0
    sf: fileio.File | t.CPtr = fileio.File(stub_path, fileio.MODE.R)
    if sf.closed:
        stdlib.free(stub_path)
        return 0
    stub_content: bytes = stdlib.malloc(STUB_READ_BUF_SIZE)
    if stub_content is None:
        sf.close()
        stdlib.free(stub_path)
        return 0
    stub_br: t.CInt64T = sf.read_all(stub_content, STUB_READ_BUF_SIZE)
    sf.close()
    stdlib.free(stub_path)
    if stub_br <= 0:
        stdlib.free(stub_content)
        return 0
    if stub_br < STUB_READ_BUF_SIZE:
        stub_content[stub_br] = '\0'
    else:
        stub_content[STUB_READ_BUF_SIZE - 1] = '\0'
    slen: t.CSizeT = stub_br
    # 修复本地 stub.ll 中字符串常量的非法 IR：
    # llvmlite OUTPUT_STUB 模式输出 "= external unnamed_addr constant" 的非法形式。
    # 简单方案：搜索 "= external unnamed_addr constant" 并将 external 替换为 8 个空格。
    fix_pos: t.CSizeT = 0
    while fix_pos + 30 < slen:
        ext_ptr: t.CPtr = string.strstr(stub_content + fix_pos, "= external unnamed_addr constant")
        if ext_ptr is None:
            break
        # ext_ptr 指向 "= external ..." 中的 '='
        # 'external' 开始于 ext_ptr + 2
        ext_off: t.CSizeT = t.CSizeT(t.CUInt64T(ext_ptr) - t.CUInt64T(stub_content)) + 2
        if ext_off + 8 <= slen:
            stub_content[ext_off] = ' '
            stub_content[ext_off + 1] = ' '
            stub_content[ext_off + 2] = ' '
            stub_content[ext_off + 3] = ' '
            stub_content[ext_off + 4] = ' '
            stub_content[ext_off + 5] = ' '
            stub_content[ext_off + 6] = ' '
            stub_content[ext_off + 7] = ' '
        fix_pos = ext_off + 8
    # 直接复制修复后的 stub 内容
    if out_pos + slen + 2 < out_size:
        string.strcpy(out_buf + out_pos, stub_content)
        out_pos += slen
        if out_buf[out_pos - 1] != '\n':
            out_buf[out_pos] = '\n'
            out_pos += 1
        out_buf[out_pos] = '\0'
    stdlib.free(stub_content)

    # 2. 按需加载依赖 stubs（根据 deps.txt 过滤，而非扫描全部）
    #    先加载依赖 stub（含 type 定义），确保 type 定义在本地 text.ll 的 define 块之前
    # 2a. 构建 includes SHA1 → module_name 映射（从 _sha1_map.txt）
    sha1_arr: bytes = stdlib.malloc(MAX_INCLUDES * 17)
    mod_arr: bytes = stdlib.malloc(MAX_INCLUDES * 64)
    inc_count: int = 0
    if sha1_arr is not None and mod_arr is not None:
        inc_count = _BuildIncludesSha1Map(temp_dir, td_len, sha1_arr, mod_arr)

    # 2b. 读取 deps.txt 获取导入模块名集合
    deps_buf: str = None
    deps_loaded: int = 0
    deps_path: str = _sliced_path(temp_dir, td_len, local_sha1, "deps.txt")
    if deps_path is not None:
        df_deps: fileio.File | t.CPtr = fileio.File(deps_path, fileio.MODE.R)
        if not df_deps.closed:
            deps_buf = stdlib.malloc(4096)
            if deps_buf is not None:
                deps_br: t.CInt64T = df_deps.read_all(deps_buf, 4096)
                if deps_br > 0:
                    if deps_br < 4096:
                        deps_buf[deps_br] = '\0'
                    else:
                        deps_buf[4095] = '\0'
                    deps_loaded = 1
            df_deps.close()
        stdlib.free(deps_path)

    # 2c. 递归扫描 temp_dir 中所有 .stub.ll，按需加载
    all_sha1_arr: str = stdlib.malloc(MAX_INCLUDES_SHA1 * 17)
    all_count: int = 0
    if all_sha1_arr is not None:
        string.memset(all_sha1_arr, 0, MAX_INCLUDES_SHA1 * 17)
        all_count = _collect_stub_sha1s(temp_dir, td_len, Config.Sha1SliceLevel, all_sha1_arr, 0, MAX_INCLUDES_SHA1)
        if all_count > 0:
            dep_buf: bytes = stdlib.malloc(STUB_READ_BUF_SIZE)
            if dep_buf is not None:
                si: int = 0
                while si < all_count:
                    dep_sha1: str = all_sha1_arr + t.CSizeT(si) * 17
                    if string.strcmp(dep_sha1, local_sha1) != 0:
                        should_load: int = 0
                        # 检查是否在 includes 映射中
                        is_include: int = 0
                        if inc_count > 0:
                            for ii in range(inc_count):
                                idx_ii: t.CSizeT = t.CSizeT(ii) * 17
                                if string.strcmp(sha1_arr + idx_ii, dep_sha1) == 0:
                                    is_include = 1
                                    if deps_loaded != 0:
                                        idx_mi: t.CSizeT = t.CSizeT(ii) * 64
                                        if HandlesImports.is_module_imported(deps_buf, mod_arr + idx_mi) != 0:
                                            should_load = 1
                                    break
                        if is_include == 0:
                            # 非 includes stub（用户文件），总是加载
                            should_load = 1
                        if should_load != 0:
                            out_pos = _LoadAndAppendStub(temp_dir, td_len, dep_sha1, dep_buf, out_buf, out_size, out_pos)
                            out_pos = _LoadAndAppendTextDeclares(temp_dir, td_len, dep_sha1, dep_buf, out_buf, out_size, out_pos)
                    si += 1
                stdlib.free(dep_buf)
        stdlib.free(all_sha1_arr)

    # 2d. 验证 deps.txt 中所有依赖模块的 stub 文件都存在（fail-fast）
    #     避免到 llc 才报 undefined value 错误。
    #     仅验证在 includes 映射中找到的模块（t/c 等内部库无 SHA1 映射，自动跳过）。
    if deps_loaded != 0 and inc_count > 0:
        dep_total: t.CSizeT = string.strlen(deps_buf)
        dp: t.CSizeT = 0
        while dp < dep_total:
            # 跳过前导空格
            while dp < dep_total:
                if deps_buf[dp] != ' ':
                    break
                dp += 1
            if dp >= dep_total:
                break
            # 提取模块名（到下一个空格或末尾）
            ms: t.CSizeT = dp
            while dp < dep_total:
                if deps_buf[dp] == ' ':
                    break
                dp += 1
            ml: t.CSizeT = dp - ms
            if ml == 0:
                continue
            # 复制模块名到临时缓冲区并 null 终止
            mod_nm: str = stdlib.malloc(ml + 1)
            if mod_nm is None:
                continue
            string.strncpy(mod_nm, deps_buf + ms, ml)
            mod_nm[ml] = '\0'
            # 在 includes 映射中查找模块对应的 SHA1
            found_s: str = None
            for mi2 in range(inc_count):
                idx_m2: t.CSizeT = t.CSizeT(mi2) * 64
                if string.strcmp(mod_arr + idx_m2, mod_nm) == 0:
                    idx_s2: t.CSizeT = t.CSizeT(mi2) * 17
                    found_s = sha1_arr + idx_s2
                    break
            if found_s is not None:
                # 检查 stub 文件是否存在
                chk_path: str = _sliced_path(temp_dir, td_len, found_s, "stub.ll")
                if chk_path is not None:
                    chk_f: fileio.File | t.CPtr = fileio.File(chk_path, fileio.MODE.R)
                    if chk_f.closed:
                        stdio.printf("[FATAL][BuildCombinedIR] 依赖模块 '%s' (sha1=%s) 的 stub 文件不存在: %s，立即终止编译\n", mod_nm, found_s, chk_path)
                        sys.exit(1)
                    chk_f.close()
                    stdlib.free(chk_path)
            stdlib.free(mod_nm)

    # 3. 读取并追加本地 text.ll（行级去重，跳过 stub.ll 中已存在的定义）
    text_path: str = _sliced_path(temp_dir, td_len, local_sha1, "text.ll")
    if text_path is None:
        return out_pos
    tf: fileio.File | t.CPtr = fileio.File(text_path, fileio.MODE.R)
    if tf.closed:
        stdlib.free(text_path)
        # text.ll 不存在的情况，继续
    else:
        text_content: bytes = stdlib.malloc(STUB_READ_BUF_SIZE)
        if text_content is None:
            tf.close()
            stdlib.free(text_path)
        else:
            text_br: t.CInt64T = tf.read_all(text_content, STUB_READ_BUF_SIZE)
            tf.close()
            stdlib.free(text_path)
            if text_br > 0:
                if text_br < STUB_READ_BUF_SIZE:
                    text_content[text_br] = '\0'
                else:
                    text_content[STUB_READ_BUF_SIZE - 1] = '\0'
                # 行级去重追加（与 _LoadAndAppendStub 相同逻辑）
                tx_pos: t.CSizeT = 0
                tx_skip: int = 1
                while tx_pos < text_br:
                    tx_ls: t.CSizeT = tx_pos
                    while tx_pos < text_br:
                        if text_content[tx_pos] == '\n':
                            break
                        tx_pos += 1
                    tx_ll: t.CSizeT = tx_pos - tx_ls
                    if tx_pos < text_br:
                        tx_pos += 1
                    if tx_skip != 0:
                        if tx_ll == 0:
                            continue
                        tx_c0: int = text_content[tx_ls]
                        if tx_c0 == ';':
                            continue
                        if tx_c0 == 't' and tx_ll >= 6:
                            if string.strncmp(text_content + tx_ls, "target", 6) == 0:
                                continue
                        if tx_c0 == 's' and tx_ll >= 15:
                            if string.strncmp(text_content + tx_ls, "source_filename", 15) == 0:
                                continue
                        tx_skip = 0
                    # 去重：declare（用 _IsFuncDeclaredOrDefined 避免误匹配 call 语句）
                    if tx_ll >= 8 and string.strncmp(text_content + tx_ls, "declare ", 8) == 0:
                        tx_at: t.CSizeT = tx_ls + 8
                        while tx_at < tx_ls + tx_ll:
                            if text_content[tx_at] == '@':
                                break
                            tx_at += 1
                        if tx_at < tx_ls + tx_ll:
                            tx_lp: t.CSizeT = tx_at + 1
                            while tx_lp < tx_ls + tx_ll:
                                if text_content[tx_lp] == '(':
                                    break
                                tx_lp += 1
                            if tx_lp < tx_ls + tx_ll:
                                tx_sv: t.CChar = text_content[tx_lp + 1]
                                text_content[tx_lp + 1] = '\0'
                                if _IsFuncDeclaredOrDefined(out_buf, text_content + tx_at) != 0:
                                    text_content[tx_lp + 1] = tx_sv
                                    continue
                                text_content[tx_lp + 1] = tx_sv
                    # 去重：define（注释掉 out_buf 中已有的 declare，避免 declare/define 冲突）
                    if tx_ll >= 7 and string.strncmp(text_content + tx_ls, "define ", 7) == 0:
                        tx_at_d: t.CSizeT = tx_ls + 7
                        while tx_at_d < tx_ls + tx_ll:
                            if text_content[tx_at_d] == '@':
                                break
                            tx_at_d += 1
                        if tx_at_d < tx_ls + tx_ll:
                            tx_lp_d: t.CSizeT = tx_at_d + 1
                            while tx_lp_d < tx_ls + tx_ll:
                                if text_content[tx_lp_d] == '(':
                                    break
                                tx_lp_d += 1
                            if tx_lp_d < tx_ls + tx_ll:
                                tx_sv_d: t.CChar = text_content[tx_lp_d + 1]
                                text_content[tx_lp_d + 1] = '\0'
                                _CommentOutDeclareInBuf(out_buf, text_content + tx_at_d)
                                text_content[tx_lp_d + 1] = tx_sv_d
                    # 处理：@global = ...
                    # stub 中可能是 external 声明或完整定义，以 text 中的定义为准
                    # 找到 stub 中同名全局变量行并注释掉，然后追加 text 中的
                    if tx_ll > 0 and text_content[tx_ls] == '@':
                        tx_eq: t.CSizeT = tx_ls + 1
                        while tx_eq < tx_ls + tx_ll:
                            if text_content[tx_eq] == '=':
                                break
                            tx_eq += 1
                        if tx_eq < tx_ls + tx_ll:
                            tx_sv2: t.CChar = text_content[tx_eq + 1]
                            text_content[tx_eq + 1] = '\0'
                            _CommentOutGlobalInBuf(out_buf, text_content + tx_ls)
                            text_content[tx_eq + 1] = tx_sv2
                    # 去重：%type = ...
                    if tx_ll > 0 and text_content[tx_ls] == '%':
                        tx_eq2: t.CSizeT = tx_ls + 1
                        while tx_eq2 < tx_ls + tx_ll:
                            if text_content[tx_eq2] == '=':
                                break
                            tx_eq2 += 1
                        if tx_eq2 < tx_ls + tx_ll:
                            tx_sv3: t.CChar = text_content[tx_eq2 + 1]
                            text_content[tx_eq2 + 1] = '\0'
                            if string.strstr(out_buf, text_content + tx_ls) is not None:
                                text_content[tx_eq2 + 1] = tx_sv3
                                continue
                            text_content[tx_eq2 + 1] = tx_sv3
                    # 追加
                    if out_pos + tx_ll + 2 < out_size:
                        string.strncpy(out_buf + out_pos, text_content + tx_ls, tx_ll)
                        out_pos += tx_ll
                        out_buf[out_pos] = '\n'
                        out_pos += 1
                        out_buf[out_pos] = '\0'
            stdlib.free(text_content)

    if deps_buf is not None:
        stdlib.free(deps_buf)
    if sha1_arr is not None:
        stdlib.free(sha1_arr)
    if mod_arr is not None:
        stdlib.free(mod_arr)

    return out_pos