跳转到内容

std.zig.LibCDirs

标准库Zig 0.17.1官方原文
源码std/zig/LibCDirs.zig

第 1 行

字段

libc_include_dir_list: []const []const u8
libc_installation: ?*const LibCInstallation
libc_framework_dir_list: []const []const u8
sysroot: ?[]const u8

std.zig.LibCDirs.Allocator

别名

第 7 行

别名目标 std.mem.Allocator

std.zig.LibCDirs.builtin

常量

第 2 行

std.zig.LibCDirs.detect

函数

第 15 行

pub fn detect( arena: Allocator, io: Io, zig_lib_dir: Path, target: *const std.Target, is_native_abi: bool, link_libc: bool, libc_installation: ?*const LibCInstallation, environ_map: *const std.process.Environ.Map, ) LibCInstallation.FindError!LibCDirs

参数

arena: Allocator
io: Io
zig_lib_dir: Path
target: *const std.Target
is_native_abi: bool
link_libc: bool
libc_installation: ?*const LibCInstallation
environ_map: *const std.process.Environ.Map

错误

CCompilerCannotFindHeaders
CCompilerCrashed
CCompilerExitCode
DarwinSdkNotFound
FileSystem
LibCKernel32LibNotFound
LibCRuntimeNotFound
LibCStdLibHeaderNotFound
OutOfMemory
UnableToSpawnCCompiler
UnsupportedArchitecture
WindowsSdkNotFound
ZigIsTheCCompiler

std.zig.LibCDirs.detectFromBuilding

函数

第 152 行

pub fn detectFromBuilding(arena: Allocator, zig_lib_dir: Path, target: *const std.Target) !LibCDirs

参数

arena: Allocator
zig_lib_dir: Path
target: *const std.Target

std.zig.LibCDirs.detectFromInstallation

函数

第 98 行

fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *const LibCInstallation) !LibCDirs

参数

arena: Allocator
target: *const std.Target
lci: *const LibCInstallation

std.zig.LibCDirs.Io

别名

第 5 行

别名目标 std.Io

std.zig.LibCDirs.LibCDirs

别名

第 1 行

别名目标 std.zig.LibCDirs

std.zig.LibCDirs.libCGenericName

函数

第 217 行

fn libCGenericName(target: *const std.Target) [:0]const u8

参数

target: *const std.Target

std.zig.LibCDirs.LibCInstallation

别名

第 6 行

别名目标 std.zig.LibCInstallation

std.zig.LibCDirs.Path

别名

第 8 行

别名目标 std.Build.Cache.Path

std.zig.LibCDirs.std

别名

第 4 行

别名目标 std

源码

std/zig/LibCDirs.zig

const LibCDirs = @This();
const builtin = @import("builtin");

const std = @import("../std.zig");
const Io = std.Io;
const LibCInstallation = std.zig.LibCInstallation;
const Allocator = std.mem.Allocator;
const Path = std.Build.Cache.Path;

libc_include_dir_list: []const []const u8,
libc_installation: ?*const LibCInstallation,
libc_framework_dir_list: []const []const u8,
sysroot: ?[]const u8,

pub fn detect(
    arena: Allocator,
    io: Io,
    zig_lib_dir: Path,
    target: *const std.Target,
    is_native_abi: bool,
    link_libc: bool,
    libc_installation: ?*const LibCInstallation,
    environ_map: *const std.process.Environ.Map,
) LibCInstallation.FindError!LibCDirs {
    if (!link_libc) {
        return .{
            .libc_include_dir_list = &[0][]u8{},
            .libc_installation = null,
            .libc_framework_dir_list = &.{},
            .sysroot = null,
        };
    }

    if (libc_installation) |lci| {
        return detectFromInstallation(arena, target, lci);
    }

    // 如果链接系统库且目标为本机 ABI,
    // 则默认使用系统安装的 libc。
    if (is_native_abi and !target.isMinGW()) {
        const libc = try arena.create(LibCInstallation);
        libc.* = LibCInstallation.findNative(arena, io, .{
            .target = target,
            .environ_map = environ_map,
        }) catch |err| switch (err) {
            error.CCompilerExitCode,
            error.CCompilerCrashed,
            error.CCompilerCannotFindHeaders,
            error.UnableToSpawnCCompiler,
            error.DarwinSdkNotFound,
            => |e| {
                // 已尝试与原生系统 C 编译器集成,
                // 但它未安装,因此必须依赖随附的
                // libc 文件。
                if (std.zig.target.canBuildLibC(target)) {
                    return detectFromBuilding(arena, zig_lib_dir, target);
                }
                return e;
            },
            else => |e| return e,
        };
        return detectFromInstallation(arena, target, libc);
    }

    // 如果不链接系统库,且条件允许,
    // 则默认构建并提供我们自己的 libc。
    if (std.zig.target.canBuildLibC(target)) {
        return detectFromBuilding(arena, zig_lib_dir, target);
    }

    // 如果 Zig 无法为目标构建 libc,且目标为
    // 本机 ABI,则回退到系统安装的 libc。
    // Windows 上,回退时应检查 MSVC ABI,
    // 而不是本机的 mingw ABI。
    const use_system_abi = if (builtin.os.tag == .windows)
        target.abi == .msvc or target.abi == .itanium
    else
        is_native_abi;

    if (use_system_abi) {
        const libc = try arena.create(LibCInstallation);
        libc.* = try LibCInstallation.findNative(arena, io, .{
            .verbose = true,
            .target = target,
            .environ_map = environ_map,
        });
        return detectFromInstallation(arena, target, libc);
    }

    return .{
        .libc_include_dir_list = &.{},
        .libc_installation = null,
        .libc_framework_dir_list = &.{},
        .sysroot = null,
    };
}

fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *const LibCInstallation) !LibCDirs {
    var list = try std.array_list.Managed([]const u8).initCapacity(arena, 5);

    list.appendAssumeCapacity(lci.include_dir.?);

    const is_redundant = std.mem.eql(u8, lci.sys_include_dir.?, lci.include_dir.?);
    if (!is_redundant) list.appendAssumeCapacity(lci.sys_include_dir.?);

    if (target.os.tag == .windows) {
        if (std.fs.path.dirname(lci.sys_include_dir.?)) |sys_include_dir_parent| {
            // 仅安装可选的“使用 C++ 的桌面开发”组件后,此包含路径才存在。
            // 它包含头文件、.rc 文件及资源,
            // 处理 Windows 资源时尤其必需。
            const atlmfc_dir = try std.fs.path.join(arena, &[_][]const u8{ sys_include_dir_parent, "atlmfc", "include" });
            list.appendAssumeCapacity(atlmfc_dir);
        }
        if (std.fs.path.dirname(lci.include_dir.?)) |include_dir_parent| {
            const um_dir = try std.fs.path.join(arena, &[_][]const u8{ include_dir_parent, "um" });
            list.appendAssumeCapacity(um_dir);

            const shared_dir = try std.fs.path.join(arena, &[_][]const u8{ include_dir_parent, "shared" });
            list.appendAssumeCapacity(shared_dir);
        }
    }
    if (target.os.tag == .haiku) {
        const include_dir_path = lci.include_dir.?;

        const subdirs = &[_][]const u8{
            "os",                   "os/app",                  "os/device",               "os/drivers",
            "os/game",              "os/interface",            "os/kernel",               "os/locale",
            "os/mail",              "os/media",                "os/midi",                 "os/midi2",
            "os/net",               "os/opengl",               "os/storage",              "os/support",
            "os/translation",       "os/add-ons/graphics",     "os/add-ons/input_server", "os/add-ons/mail_daemon",
            "os/add-ons/registrar", "os/add-ons/screen_saver", "os/add-ons/tracker",      "os/be_apps/NetPositive",
            "os/be_apps/Tracker",   "bsd",                     "glibc",                   "gnu",
        };
        for (subdirs) |subdir| {
            const path = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, subdir });
            try list.append(path);
        }
    }

    const frameworks: []const []const u8 = if (target.os.tag.isDarwin()) try arena.dupe([]const u8, &.{
        try std.fs.path.join(arena, &.{ lci.darwin_sdk_dir.?, "System", "Library", "Frameworks" }),
    }) else &.{};

    return .{
        .libc_include_dir_list = list.items,
        .libc_installation = lci,
        .libc_framework_dir_list = frameworks,
        .sysroot = if (target.os.tag.isDarwin()) lci.darwin_sdk_dir.? else null,
    };
}

pub fn detectFromBuilding(arena: Allocator, zig_lib_dir: Path, target: *const std.Target) !LibCDirs {
    const s = std.fs.path.sep_str;

    if (target.os.tag.isDarwin()) {
        const list = try arena.alloc([]const u8, 1);
        list[0] = try arena.print("{f}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "any-darwin-any", .{zig_lib_dir});
        return .{
            .libc_include_dir_list = list,
            .libc_installation = null,
            .libc_framework_dir_list = &.{},
            .sysroot = null,
        };
    }

    const generic_name = libCGenericName(target);
    // 某些架构系列由同一组头文件处理。
    const arch_name = if (target.isMuslLibC() or target.isWasiLibC())
        std.zig.target.muslArchNameHeaders(target.cpu.arch)
    else if (target.isGnuLibC())
        std.zig.target.glibcArchNameHeaders(target.cpu.arch)
    else if (target.isFreeBSDLibC())
        std.zig.target.freebsdArchNameHeaders(target.cpu.arch)
    else if (target.isNetBSDLibC())
        std.zig.target.netbsdArchNameHeaders(target.cpu.arch)
    else if (target.isOpenBSDLibC())
        std.zig.target.openbsdArchNameHeaders(target.cpu.arch)
    else
        @tagName(target.cpu.arch);
    const os_name = @tagName(target.os.tag);
    const abi_name = if (target.isMuslLibC())
        std.zig.target.muslAbiNameHeaders(target.abi)
    else if (target.isGnuLibC())
        std.zig.target.glibcAbiNameHeaders(target.abi)
    else if (target.isNetBSDLibC())
        std.zig.target.netbsdAbiNameHeaders(target.abi)
    else
        @tagName(target.abi);
    const arch_include_dir = try arena.print("{f}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "{s}-{s}-{s}", .{
        zig_lib_dir, arch_name, os_name, abi_name,
    });
    const generic_include_dir = try arena.print("{f}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "generic-{s}", .{
        zig_lib_dir, generic_name,
    });
    const generic_arch_name = std.zig.target.osArchName(target);
    const arch_os_include_dir = try arena.print("{f}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "{s}-{s}-any", .{
        zig_lib_dir, generic_arch_name, os_name,
    });
    const generic_os_include_dir = try arena.print("{f}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "any-{s}-any", .{
        zig_lib_dir, os_name,
    });

    const list = try arena.alloc([]const u8, 4);
    list[0] = arch_include_dir;
    list[1] = generic_include_dir;
    list[2] = arch_os_include_dir;
    list[3] = generic_os_include_dir;

    return .{
        .libc_include_dir_list = list,
        .libc_installation = null,
        .libc_framework_dir_list = &.{},
        .sysroot = null,
    };
}

fn libCGenericName(target: *const std.Target) [:0]const u8 {
    switch (target.os.tag) {
        .windows => return "mingw",
        .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => return "darwin",
        .freebsd => return "freebsd",
        .netbsd => return "netbsd",
        .openbsd => return "openbsd",
        else => {},
    }
    switch (target.abi) {
        .gnu,
        .gnuabin32,
        .gnuabi64,
        .gnueabi,
        .gnueabihf,
        .gnuf32,
        .gnusf,
        .gnux32,
        => return "glibc",
        .musl,
        .muslabin32,
        .muslabi64,
        .musleabi,
        .musleabihf,
        .muslf32,
        .muslsf,
        .muslx32,
        .none,
        .ohos,
        .ohoseabi,
        => return "musl",
        .eabi,
        .eabihf,
        .abin32,
        .x32,
        .ilp32,
        .android,
        .androideabi,
        .msvc,
        .itanium,
        .simulator,
        .call0,
        => unreachable,
    }
}