import t, c from stdint import * import stdio import string import stdlib import memhub import viperlib import w32.fileio as fileio import w32.win32file import w32.win32base import sys import ast import llvmlite import subprocess import argparse import lib.core.VLogger as VLogger import lib.core.Handles.HandlesTranslator as HandlesTranslator import lib.core.Handles.HandlesExprCall as HandlesExprCall import lib.core.Handles.HandlesImports as HandlesImports import lib.core.BuildPipeline as BuildPipeline import lib.core.StubMerger as StubMerger import lib.Projectrans.Utils as Utils import lib.Projectrans.Config as Config # 全局 mbuddy 指针 _mbuddy: memhub.MemManager | t.CPtr # 源代码缓冲区大小（1MB） SRC_BUF_SIZE: t.CDefine = 1048576 # 最大源文件数（递归扫描子目录后文件数增多，增大到 64） MAX_SRC_FILES: t.CDefine = 64 @t.NoVTable class SrcFileEntry: """源文件条目""" Path: str # 完整路径 Sha1: str # SHA1 前16字符 # ============================================================ # _ScanDirForPyFiles - 递归扫描目录，收集 .py 文件到 entries # # 替代旧的非递归 FindFirstFileA(dir/*.py) 扫描，支持子目录 # （如 App/lib/core/Handles/）。遇到目录递归扫描，遇到 .py # 文件读取内容、计算 SHA1、加入 entries。 # # Args: # mb: 内存池 # dir_path: 当前扫描目录 # entries: SrcFileEntry 数组 # entry_size: 单个条目大小（SrcFileEntry.__sizeof__()） # file_count: 当前已收集的文件数 # max_files: 最大文件数 # # Returns: # 新的 file_count # ============================================================ def _ScanDirForPyFiles(mb: memhub.MemBuddy | t.CPtr, dir_path: str, entries: SrcFileEntry | t.CPtr, entry_size: t.CSizeT, file_count: int, max_files: int) -> int: """递归扫描目录，收集 .py 文件到 entries，返回新的 file_count""" if dir_path is None or entries is None: return file_count if file_count >= max_files: return file_count dir_len: t.CSizeT = string.strlen(dir_path) pattern: bytes = stdlib.malloc(dir_len + 16) if pattern is None: return file_count viperlib.snprintf(pattern, dir_len + 16, "%s/*", dir_path) find_data_size: t.CSizeT = w32.win32file.WIN32_FIND_DATAA.__sizeof__() find_data: w32.win32file.WIN32_FIND_DATAA | t.CPtr = stdlib.malloc(find_data_size + 16) if find_data is None: stdlib.free(pattern) return file_count string.memset(find_data, 0, find_data_size + 16) handle: w32.win32base.HANDLE = w32.win32file.FindFirstFileA(pattern, find_data) if handle == w32.win32base.INVALID_HANDLE_VALUE: stdlib.free(pattern) stdlib.free(find_data) return file_count while True: fname: str = find_data.cFileName if fname is not None: fname_len: t.CSizeT = string.strlen(fname) if fname_len > 0: # 跳过 . 和 .. is_dot: int = 0 if fname_len == 1 and fname[0] == '.': is_dot = 1 elif fname_len == 2 and fname[0] == '.' and fname[1] == '.': is_dot = 1 if is_dot == 0: # 检查是否是目录 attrs: ULONG = find_data.dwFileAttributes is_dir: int = 0 if (attrs & w32.win32file.FILE_ATTRIBUTE_DIRECTORY) != 0: is_dir = 1 if is_dir != 0: # 递归扫描子目录 sub_dir: bytes = stdlib.malloc(dir_len + fname_len + 2) if sub_dir is not None: viperlib.snprintf(sub_dir, dir_len + fname_len + 2, "%s/%s", dir_path, fname) file_count = _ScanDirForPyFiles(mb, sub_dir, entries, entry_size, file_count, max_files) stdlib.free(sub_dir) else: # 检查是否是 .py 文件 if fname_len > 3: if fname[fname_len - 3] == '.' and fname[fname_len - 2] == 'p' and fname[fname_len - 1] == 'y': if file_count < max_files: 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", dir_path, fname) sf: fileio.File | t.CPtr = fileio.File(full_path, fileio.MODE.R) if not sf.closed: sbuf: bytes = stdlib.malloc(SRC_BUF_SIZE) if sbuf is not None: br: LONG = sf.read_all(sbuf, SRC_BUF_SIZE) sf.close() if br > 0: if br < SRC_BUF_SIZE: sbuf[br] = 0 else: sbuf[SRC_BUF_SIZE - 1] = 0 sha1_val: str = Utils.compute_sha1(mb, sbuf) if sha1_val is not None: ea: t.CUInt64T = t.CUInt64T(entries) + file_count * entry_size ent: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea, t.CPtr)) if ent is not None: ent.Path = full_path ent.Sha1 = sha1_val file_count += 1 stdio.printf("[project] %s (sha1=%s)\n", fname, sha1_val) stdlib.free(sbuf) # full_path 不释放：ent.Path 引用它 if w32.win32file.FindNextFileA(handle, find_data) == 0: break w32.win32file.FindClose(handle) stdlib.free(pattern) stdlib.free(find_data) return file_count def RunMultiFileProject(mb: memhub.MemBuddy | t.CPtr, source_dir: str, temp_dir: str, output_dir: str, cc_cmd: str, cc_flags: str, linker_cmd: str, linker_flags: str, linker_output: str, includes_binary_dir: str, includes_dir: str, do_phase1: int, do_phase2: int, log: VLogger.Logger | t.CPtr, args: argparse.ParsedArgs | t.CPtr) -> int: """多文件项目编译 Returns: 0 成功，非 0 失败 """ if source_dir is None: stdio.printf("[project] source_dir 为空\n") return 1 stdio.printf("[project] 多文件项目编译: %s\n", source_dir) # === 1. 递归扫描 source_dir 下的 .py 文件（包括子目录）=== entry_size: t.CSizeT = SrcFileEntry.__sizeof__() entries: SrcFileEntry | t.CPtr = stdlib.malloc(MAX_SRC_FILES * entry_size) if entries is None: return 1 string.memset(entries, 0, MAX_SRC_FILES * entry_size) file_count: int = _ScanDirForPyFiles(mb, source_dir, entries, entry_size, 0, MAX_SRC_FILES) stdio.printf("[project] 共 %d 个源文件\n", file_count) if file_count == 0: stdlib.free(entries) return 1 # 初始化 AST 表 ast._init_tables(mb) # 确保 temp/output 目录存在 BuildPipeline.ensure_dir(temp_dir) BuildPipeline.ensure_dir(output_dir) # 追加 App 源文件 SHA1 到 _sha1_map.txt（供日志转存和符号查找使用） # 格式: {sha1}:App/{filename}\n （与 includes 条目格式对应） td_len_am: t.CSizeT = string.strlen(temp_dir) map_path_am: bytes = stdlib.malloc(td_len_am + 32) if map_path_am is not None: viperlib.snprintf(map_path_am, td_len_am + 32, "%s/_sha1_map.txt", temp_dir) mf: fileio.File | t.CPtr = fileio.File(map_path_am, fileio.MODE.A) if not mf.closed: line_am: bytes = stdlib.malloc(512) if line_am is not None: for i in range(file_count): ea_am: t.CUInt64T = t.CUInt64T(entries) + i * entry_size ent_am: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea_am, t.CPtr)) if ent_am is None or ent_am.Path is None or ent_am.Sha1 is None: continue # 从路径提取文件名（最后一个 / 或 \\ 之后的部分） p_str: str = ent_am.Path p_len: t.CSizeT = string.strlen(p_str) f_start: t.CSizeT = 0 for j in range(p_len): if p_str[j] == '/' or p_str[j] == '\\': f_start = j + 1 viperlib.snprintf(line_am, 512, "%s:App/%s\n", ent_am.Sha1, p_str + f_start) ll_am: t.CSizeT = string.strlen(line_am) mf.write(line_am, ll_am) stdlib.free(line_am) mf.close() stdio.printf("[project] 已追加 %d 个 App 文件到 _sha1_map.txt\n", file_count) stdlib.free(map_path_am) # 构建模块 SHA1 映射（供跨模块函数调用名混淆使用） td_len_pb: t.CSizeT = string.strlen(temp_dir) pb_sha1_arr: bytes = stdlib.malloc(StubMerger.MAX_INCLUDES * 17) pb_mod_arr: bytes = stdlib.malloc(StubMerger.MAX_INCLUDES * 64) pb_inc_count: int = 0 if pb_sha1_arr is not None and pb_mod_arr is not None: pb_inc_count = StubMerger._BuildIncludesSha1Map(temp_dir, td_len_pb, pb_sha1_arr, pb_mod_arr) # 追加用户源文件的 (模块名, SHA1) 到全局映射 # 使跨模块方法调用能通过 from_imports + _lookup_module_sha1 找到正确的 SHA1 if pb_sha1_arr is not None and pb_mod_arr is not None: for i in range(file_count): ea_us: t.CUInt64T = t.CUInt64T(entries) + i * entry_size ent_us: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea_us, t.CPtr)) if ent_us is None or ent_us.Path is None or ent_us.Sha1 is None: continue if pb_inc_count >= StubMerger.MAX_INCLUDES: break # 从路径提取模块名（文件名去掉 .py 后缀） path_str: str = ent_us.Path path_len: t.CSizeT = string.strlen(path_str) fname_start: t.CSizeT = 0 for j in range(path_len): if path_str[j] == '/' or path_str[j] == '\\': fname_start = j + 1 mod_len: t.CSizeT = path_len - fname_start if mod_len < 4: continue mod_len -= 3 if mod_len >= 64: mod_len = 63 # 写入模块名 mod_idx: t.CSizeT = t.CSizeT(pb_inc_count) * 64 for k in range(mod_len): pb_mod_arr[mod_idx + k] = path_str[fname_start + k] pb_mod_arr[mod_idx + mod_len] = '\0' # 写入 SHA1 sha1_idx: t.CSizeT = t.CSizeT(pb_inc_count) * 17 string.strcpy(pb_sha1_arr + sha1_idx, ent_us.Sha1) pb_inc_count += 1 HandlesExprCall.set_module_sha1_map(pb_sha1_arr, pb_mod_arr, pb_inc_count) # === 2. Phase A: 为每个文件生成 stub + text === if do_phase1 != 0: if log is not None: log.banner("Phase A: 生成 stub + text") PHASE_A_IR_SIZE: t.CSizeT = 262144 td_len_pa: t.CSizeT = string.strlen(temp_dir) for i in range(file_count): ea: t.CUInt64T = t.CUInt64T(entries) + i * entry_size ent: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea, t.CPtr)) if ent is None or ent.Path is None: continue # 计算源文件的包名（相对 source_dir 的目录部分） src_dir_len_pa: t.CSizeT = string.strlen(source_dir) pkg_pa: str = None if string.strlen(ent.Path) > src_dir_len_pa + 1: rel_path_pa: str = ent.Path + src_dir_len_pa + 1 pkg_pa = HandlesImports.compute_package_from_relpath(mb, rel_path_pa) tr_a: HandlesTranslator.Translator | t.CPtr = BuildPipeline.TranslateFileGetTrans(mb, ent.Path, ent.Sha1, pkg_pa) if tr_a is None: continue # dump stub IR (declarations only) stub_buf_a: bytes = stdlib.malloc(PHASE_A_IR_SIZE) if stub_buf_a is None: continue tr_a.dump_ir(stub_buf_a, PHASE_A_IR_SIZE, llvmlite.OUTPUT_STUB) stub_len_a: t.CSizeT = string.strlen(stub_buf_a) # save stub.ll stub_path_a: bytes = stdlib.malloc(td_len_pa + 32) if stub_path_a is not None: viperlib.snprintf(stub_path_a, td_len_pa + 32, "%s/%s.stub.ll", temp_dir, ent.Sha1) sf_a: fileio.File | t.CPtr = fileio.File(stub_path_a, fileio.MODE.W) if not sf_a.closed: sf_a.write(stub_buf_a, stub_len_a) sf_a.close() stdlib.free(stub_path_a) stdlib.free(stub_buf_a) # dump text IR (definitions only) text_buf_a: bytes = stdlib.malloc(PHASE_A_IR_SIZE) if text_buf_a is None: continue tr_a.dump_ir(text_buf_a, PHASE_A_IR_SIZE, llvmlite.OUTPUT_TEXT) text_len_a: t.CSizeT = string.strlen(text_buf_a) # save text.ll text_path_a: bytes = stdlib.malloc(td_len_pa + 32) if text_path_a is not None: viperlib.snprintf(text_path_a, td_len_pa + 32, "%s/%s.text.ll", temp_dir, ent.Sha1) tf_a: fileio.File | t.CPtr = fileio.File(text_path_a, fileio.MODE.W) if not tf_a.closed: tf_a.write(text_buf_a, text_len_a) tf_a.close() stdlib.free(text_path_a) stdlib.free(text_buf_a) # save dependencies (_imported_modules) for Phase B deps_path_a: bytes = stdlib.malloc(td_len_pa + 32) if deps_path_a is not None: viperlib.snprintf(deps_path_a, td_len_pa + 32, "%s/%s.deps.txt", temp_dir, ent.Sha1) df_a: fileio.File | t.CPtr = fileio.File(deps_path_a, fileio.MODE.W) if not df_a.closed: if tr_a._imported_modules is not None: dl_a: t.CSizeT = string.strlen(tr_a._imported_modules) df_a.write(tr_a._imported_modules, dl_a) df_a.close() stdlib.free(deps_path_a) if do_phase2 == 0: stdio.printf("[project] Phase A 完成（仅 stub 生成）\n") stdlib.free(entries) return 0 # === 3. Phase B: 编译每个文件为 .obj === if do_phase2 != 0: if log is not None: log.banner("Phase B: 编译 .obj") # 收集 .obj 路径 OBJ_PATHS_SIZE: t.CSizeT = 8192 obj_paths: bytes = stdlib.malloc(OBJ_PATHS_SIZE) if obj_paths is None: return 1 obj_paths[0] = '\0' obj_pos: t.CSizeT = 0 # main_obj_path: 存放定义了用户 main 的 .obj 路径（链接时放在最前面， # 避免 --allow-multiple-definition 选择了其他模块的 wrapper main） main_obj_path: bytes = stdlib.malloc(512) if main_obj_path is None: return 1 main_obj_path[0] = '\0' compiled_count: int = 0 # 组合 IR 缓冲区大小（4MB，足够容纳本地 stub + 所有依赖 stub + 本地 text） COMBINED_IR_SIZE: t.CSizeT = 4194304 for i in range(file_count): ea: t.CUInt64T = t.CUInt64T(entries) + i * entry_size ent: SrcFileEntry | t.CPtr = (SrcFileEntry | t.CPtr)(t.CVoid(ea, t.CPtr)) if ent is None or ent.Path is None or ent.Sha1 is None: continue stdio.printf("[Phase B] %s\n", ent.Path) # 组合本地 stub + 所有依赖 stub + 本地 text → 完整 IR stdio.printf("[Phase B] malloc %d bytes...\n", COMBINED_IR_SIZE) combined_ir: bytes = stdlib.malloc(COMBINED_IR_SIZE) if combined_ir is None: stdio.printf("[Phase B] combined_ir 分配失败: %s\n", ent.Path) continue stdio.printf("[Phase B] malloc OK, calling BuildCombinedIR...\n") combined_len: t.CSizeT = StubMerger.BuildCombinedIR(temp_dir, ent.Sha1, combined_ir, COMBINED_IR_SIZE) if combined_len == 0: stdio.printf("[Phase B] BuildCombinedIR 失败: %s\n", ent.Path) stdlib.free(combined_ir) continue # 编译为 .obj cret: int = BuildPipeline.compile_module_to_obj( combined_ir, combined_len, temp_dir, output_dir, ent.Sha1, cc_cmd, cc_flags) stdlib.free(combined_ir) if cret != 0: stdio.printf("[FATAL][Phase B] llc 编译失败，终止编译: %s\n", ent.Path) sys.exit(1) compiled_count += 1 # 构造 .obj 路径，检测是否是 main 模块（test_main.py 或 main.py） od_len: t.CSizeT = string.strlen(output_dir) sha1_len: t.CSizeT = string.strlen(ent.Sha1) need: t.CSizeT = od_len + 1 + sha1_len + 6 is_main_mod: int = 0 if string.strstr(ent.Path, "test_main.py") is not None: is_main_mod = 1 elif string.strstr(ent.Path, "main.py") is not None: is_main_mod = 1 if is_main_mod != 0: viperlib.snprintf(main_obj_path, 512, "%s/%s.obj", output_dir, ent.Sha1) else: if obj_pos + need < OBJ_PATHS_SIZE: if obj_pos > 0: obj_paths[obj_pos] = ' ' obj_pos += 1 viperlib.snprintf(obj_paths + obj_pos, need, "%s/%s.obj", output_dir, ent.Sha1) obj_pos += od_len + 1 + sha1_len + 4 obj_paths[obj_pos] = '\0' else: stdio.printf("[Phase B] 警告: .obj 路径缓冲区不足\n") stdio.printf("[Phase B] 编译完成: %d/%d\n", compiled_count, file_count) if compiled_count == 0: stdio.printf("[Phase B] 无成功编译的文件\n") stdlib.free(entries) return 1 # === 3.5 编译缺失的 includes 文件 === # includes.binary 可能缺少某些 includes .obj（如 testcheck.py）， # 这些文件被用户项目导入但未被 TransPyV 自身依赖，Projectrans.py 未编译它们。 # 检测并编译缺失的 includes 文件到 output_dir，加入链接命令。 if includes_dir is not None and includes_binary_dir is not None: inc_compiled: int = 0 td_len_mi: t.CSizeT = string.strlen(temp_dir) map_path_mi: bytes = stdlib.malloc(td_len_mi + 32) if map_path_mi is not None: viperlib.snprintf(map_path_mi, td_len_mi + 32, "%s/_sha1_map.txt", temp_dir) mapf_mi: fileio.File | t.CPtr = fileio.File(map_path_mi, fileio.MODE.R) if not mapf_mi.closed: map_buf_mi: bytes = stdlib.malloc(65536) if map_buf_mi is not None: map_br_mi: t.CInt64T = mapf_mi.read_all(map_buf_mi, 65536) mapf_mi.close() if map_br_mi > 0: if map_br_mi < 65536: map_buf_mi[map_br_mi] = '\0' else: map_buf_mi[65535] = '\0' map_len_mi: t.CSizeT = map_br_mi mpos_mi: t.CSizeT = 0 while mpos_mi < map_len_mi: ml_start_mi: t.CSizeT = mpos_mi while mpos_mi < map_len_mi: if map_buf_mi[mpos_mi] == '\n': break mpos_mi += 1 ml_len_mi: t.CSizeT = mpos_mi - ml_start_mi mpos_mi += 1 # 最小长度: 16(sha1)+1(:)+9(includes/)+1+1+1 = 29 if ml_len_mi < 26: continue if map_buf_mi[ml_start_mi + 16] != ':': continue rp_start_mi: t.CSizeT = ml_start_mi + 17 if string.strncmp(map_buf_mi + rp_start_mi, "includes/", 9) != 0: continue # 提取 SHA1 inc_sha1_mi: str = stdlib.malloc(17) if inc_sha1_mi is None: continue string.strncpy(inc_sha1_mi, map_buf_mi + ml_start_mi, 16) inc_sha1_mi[16] = '\0' # 检查 .obj 是否已存在于 includes.binary ibd_len_mi: t.CSizeT = string.strlen(includes_binary_dir) check_pat_mi: bytes = stdlib.malloc(ibd_len_mi + 35) if check_pat_mi is None: continue viperlib.snprintf(check_pat_mi, ibd_len_mi + 35, "%s/%s*.obj", includes_binary_dir, inc_sha1_mi) check_fd_mi: w32.win32file.WIN32_FIND_DATAA | t.CPtr = stdlib.malloc(w32.win32file.WIN32_FIND_DATAA.__sizeof__()) obj_exists_mi: int = 0 if check_fd_mi is not None: string.memset(check_fd_mi, 0, w32.win32file.WIN32_FIND_DATAA.__sizeof__()) check_h_mi: w32.win32base.HANDLE = w32.win32file.FindFirstFileA(check_pat_mi, check_fd_mi) if check_h_mi != w32.win32base.INVALID_HANDLE_VALUE: w32.win32file.FindClose(check_h_mi) obj_exists_mi = 1 if obj_exists_mi != 0: continue # .obj 不存在，需要编译 # 构造源文件路径: {includes_dir}/{rel_path_without_includes_prefix} rel_path_len_mi: t.CSizeT = ml_len_mi - 26 inc_dir_len_mi: t.CSizeT = string.strlen(includes_dir) src_fp_mi: bytes = stdlib.malloc(inc_dir_len_mi + 1 + rel_path_len_mi + 1) if src_fp_mi is None: continue viperlib.snprintf(src_fp_mi, inc_dir_len_mi + 1 + rel_path_len_mi + 1, "%s/%s", includes_dir, map_buf_mi + rp_start_mi + 9) # 检查是否为声明文件（只有 declare 没有实质 define） # 判断方法: text.ll 中若有混淆函数 define（含 @\"）则为实现文件 is_decl_mi: int = -1 tpath_mi: bytes = stdlib.malloc(td_len_mi + 32) if tpath_mi is not None: viperlib.snprintf(tpath_mi, td_len_mi + 32, "%s/%s.text.ll", temp_dir, inc_sha1_mi) tf_mi: fileio.File | t.CPtr = fileio.File(tpath_mi, fileio.MODE.R) if not tf_mi.closed: is_decl_mi = 1 tbuf_mi: bytes = stdlib.malloc(StubMerger.STUB_READ_BUF_SIZE) if tbuf_mi is not None: tbr_mi: t.CInt64T = tf_mi.read_all(tbuf_mi, StubMerger.STUB_READ_BUF_SIZE) if tbr_mi > 0: if tbr_mi < StubMerger.STUB_READ_BUF_SIZE: tbuf_mi[tbr_mi] = '\0' else: tbuf_mi[StubMerger.STUB_READ_BUF_SIZE - 1] = '\0' # 逐行扫描: 找 define 行中含 @\" 的（混淆函数名） tpos_mi: t.CSizeT = 0 while tpos_mi < tbr_mi: tls_mi: t.CSizeT = tpos_mi while tpos_mi < tbr_mi: if tbuf_mi[tpos_mi] == '\n': break tpos_mi += 1 tll_mi: t.CSizeT = tpos_mi - tls_mi if tpos_mi < tbr_mi: tpos_mi += 1 if tll_mi >= 7 and string.strncmp(tbuf_mi + tls_mi, "define ", 7) == 0: # 临时在行尾加 \0 供 strstr 使用 saved_mi: t.CChar = tbuf_mi[tls_mi + tll_mi] tbuf_mi[tls_mi + tll_mi] = '\0' if string.strstr(tbuf_mi + tls_mi, "@\"") is not None: tbuf_mi[tls_mi + tll_mi] = saved_mi is_decl_mi = 0 break tbuf_mi[tls_mi + tll_mi] = saved_mi stdlib.free(tbuf_mi) tf_mi.close() stdlib.free(tpath_mi) if is_decl_mi == 1: stdio.printf("[Phase B+] 跳过(声明文件): %s (sha1=%s)\n", src_fp_mi, inc_sha1_mi) continue stdio.printf("[Phase B+] 编译缺失 includes: %s (sha1=%s)\n", src_fp_mi, inc_sha1_mi) # 尝试 BuildCombinedIR（stub/text 应已由 Phase1 生成） inc_combined_mi: bytes = stdlib.malloc(COMBINED_IR_SIZE) inc_combined_len_mi: t.CSizeT = 0 if inc_combined_mi is not None: inc_combined_len_mi = StubMerger.BuildCombinedIR(temp_dir, inc_sha1_mi, inc_combined_mi, COMBINED_IR_SIZE) # 如果 stub/text 不存在，翻译源文件并保存 stub + text，然后重试 if inc_combined_len_mi == 0 and inc_combined_mi is not None: stdio.printf("[Phase B+] stub/text 不存在，翻译: %s\n", src_fp_mi) # 计算 includes 文件的包名（相对 includes_dir 的目录部分） inc_pkg_mi: str = None if string.strlen(src_fp_mi) > inc_dir_len_mi + 1: inc_rel_mi: str = src_fp_mi + inc_dir_len_mi + 1 inc_pkg_mi = HandlesImports.compute_package_from_relpath(mb, inc_rel_mi) tr_mi: HandlesTranslator.Translator | t.CPtr = BuildPipeline.TranslateFileGetTrans(mb, src_fp_mi, inc_sha1_mi, inc_pkg_mi) if tr_mi is not None: PBP_IR_SIZE: t.CSizeT = 262144 # 保存 stub.ll inc_stub_buf: bytes = stdlib.malloc(PBP_IR_SIZE) if inc_stub_buf is not None: tr_mi.dump_ir(inc_stub_buf, PBP_IR_SIZE, llvmlite.OUTPUT_STUB) inc_stub_len: t.CSizeT = string.strlen(inc_stub_buf) inc_stub_path: bytes = stdlib.malloc(td_len_mi + 32) if inc_stub_path is not None: viperlib.snprintf(inc_stub_path, td_len_mi + 32, "%s/%s.stub.ll", temp_dir, inc_sha1_mi) isf: fileio.File | t.CPtr = fileio.File(inc_stub_path, fileio.MODE.W) if not isf.closed: isf.write(inc_stub_buf, inc_stub_len) isf.close() stdlib.free(inc_stub_path) stdlib.free(inc_stub_buf) # 保存 text.ll inc_text_buf: bytes = stdlib.malloc(PBP_IR_SIZE) if inc_text_buf is not None: tr_mi.dump_ir(inc_text_buf, PBP_IR_SIZE, llvmlite.OUTPUT_TEXT) inc_text_len: t.CSizeT = string.strlen(inc_text_buf) inc_text_path: bytes = stdlib.malloc(td_len_mi + 32) if inc_text_path is not None: viperlib.snprintf(inc_text_path, td_len_mi + 32, "%s/%s.text.ll", temp_dir, inc_sha1_mi) itf: fileio.File | t.CPtr = fileio.File(inc_text_path, fileio.MODE.W) if not itf.closed: itf.write(inc_text_buf, inc_text_len) itf.close() stdlib.free(inc_text_path) stdlib.free(inc_text_buf) # 重试 BuildCombinedIR inc_combined_len_mi = StubMerger.BuildCombinedIR(temp_dir, inc_sha1_mi, inc_combined_mi, COMBINED_IR_SIZE) if inc_combined_len_mi == 0: stdio.printf("[Phase B+] BuildCombinedIR 失败: %s\n", src_fp_mi) if inc_combined_mi is not None: stdlib.free(inc_combined_mi) continue # 编译为 .obj inc_cret_mi: int = BuildPipeline.compile_module_to_obj( inc_combined_mi, inc_combined_len_mi, temp_dir, output_dir, inc_sha1_mi, cc_cmd, cc_flags) stdlib.free(inc_combined_mi) if inc_cret_mi != 0: stdio.printf("[FATAL][Phase B+] llc 编译失败，终止编译: %s\n", src_fp_mi) sys.exit(1) inc_compiled += 1 # 添加到 obj_paths od_len_mi: t.CSizeT = string.strlen(output_dir) sha1_len_mi: t.CSizeT = 16 need_mi: t.CSizeT = od_len_mi + 1 + sha1_len_mi + 6 if obj_pos + need_mi < OBJ_PATHS_SIZE: if obj_pos > 0: obj_paths[obj_pos] = ' ' obj_pos += 1 viperlib.snprintf(obj_paths + obj_pos, need_mi, "%s/%s.obj", output_dir, inc_sha1_mi) obj_pos += od_len_mi + 1 + sha1_len_mi + 4 obj_paths[obj_pos] = '\0' stdio.printf("[Phase B+] 编译缺失 includes: %d 个\n", inc_compiled) # === 4. Phase C: 链接所有 .obj → .exe === if log is not None: log.banner("Phase C: 链接") od_len2: t.CSizeT = string.strlen(output_dir) lo_len: t.CSizeT = string.strlen(linker_output) exe_path: bytes = stdlib.malloc(od_len2 + lo_len + 2) if exe_path is not None: viperlib.snprintf(exe_path, od_len2 + lo_len + 2, "%s/%s", output_dir, linker_output) else: exe_path = linker_output # 构造最终 .obj 路径列表：main_obj_path 在前，其他 .obj 在后 final_obj_paths: bytes = stdlib.malloc(OBJ_PATHS_SIZE + 512) if final_obj_paths is None: stdlib.free(entries) return 1 final_obj_paths[0] = '\0' fop_pos: t.CSizeT = 0 # main_obj_path 放在最前面（确保 --allow-multiple-definition 选择用户 main） if main_obj_path[0] != '\0': mlen: t.CSizeT = string.strlen(main_obj_path) string.strcpy(final_obj_paths, main_obj_path) fop_pos = mlen if obj_paths[0] != '\0': final_obj_paths[fop_pos] = ' ' fop_pos += 1 # 追加其他 .obj if obj_paths[0] != '\0': string.strcpy(final_obj_paths + fop_pos, obj_paths) fop_pos += string.strlen(obj_paths) final_obj_paths[fop_pos] = '\0' obj_paths_len: t.CSizeT = fop_pos lret: int = BuildPipeline.link_objs_to_exe( final_obj_paths, obj_paths_len, linker_cmd, linker_flags, exe_path, includes_binary_dir) if lret == 0: stdio.printf("输出: %s\n", exe_path) if args.get_bool("run"): stdio.printf("[run] 执行: %s\n", exe_path) rp: subprocess.CompletedProcess | t.CPtr = subprocess.run(exe_path, False, False) if rp is not None: stdio.printf("[run] 退出码: %d\n", rp.returncode) else: stdio.printf("[Phase C] 链接失败\n") stdlib.free(entries) return 1 stdlib.free(entries) return 0