跳转到内容

std.zig.PkgConfig

标准库Zig 0.17.0官方原文
源码std/zig/PkgConfig.zig

第 1 行

构建系统中 pkg-config 集成逻辑的可复用部分。

字段

all: []const Pkg

std.zig.PkgConfig.Allocator

别名

第 6 行

别名目标 std.mem.Allocator

std.zig.PkgConfig.assert

别名

第 7 行

别名目标 std.debug.assert

std.zig.PkgConfig.Diagnostic

容器

第 18 行

字段

invalid_line_index: usize
invalid_line: []const u8

std.zig.PkgConfig.exe

函数

第 90 行

pub fn exe(environ_map: *const std.process.Environ.Map) []const u8

参数

environ_map: *const std.process.Environ.Map

std.zig.PkgConfig.find

函数

第 52 行

pub fn find(pc: *const PkgConfig, lib_name: []const u8) ?usize

参数

pc: *const PkgConfig
lib_name: []const u8

std.zig.PkgConfig.init

函数

第 24 行

解析 pkg-config --list-all 的输出。

pub fn init(arena: Allocator, stdout: []const u8, diagnostic: ?*Diagnostic) InitError!PkgConfig

参数

arena: Allocator
stdout: []const u8
diagnostic: ?*Diagnostic

错误

InvalidPkgConfigOutput
OutOfMemory Error

std.zig.PkgConfig.InitError

错误集合

第 16 行

错误

InvalidPkgConfigOutput
OutOfMemory Error

std.zig.PkgConfig.mem

别名

第 5 行

别名目标 std.mem

std.zig.PkgConfig.parse

函数

第 104 行

解析 pkg-config [name] --cflags --libs 的输出。

pub fn parse(arena: Allocator, stdout: []const u8) ParseError!Parsed

参数

arena: Allocator
stdout: []const u8

错误

InvalidPkgConfigOutput
OutOfMemory Error

std.zig.PkgConfig.Parsed

容器

第 94 行

字段

cflags: []const []const u8
libs: []const []const u8
unknown_flags: []const []const u8
pthread: bool

std.zig.PkgConfig.ParseError

错误集合

第 101 行

错误

InvalidPkgConfigOutput
OutOfMemory Error

std.zig.PkgConfig.Pkg

容器

第 11 行

字段

name: []const u8
desc: []const u8

std.zig.PkgConfig.PkgConfig

别名

第 2 行

别名目标 std.zig.PkgConfig

std.zig.PkgConfig.std

别名

第 4 行

别名目标 std

源码

std/zig/PkgConfig.zig

//! 构建系统中 pkg-config 集成逻辑的可复用部分。
const PkgConfig = @This();

const std = @import("../std.zig");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;

all: []const Pkg,

pub const Pkg = struct {
    name: []const u8,
    desc: []const u8,
};

pub const InitError = Allocator.Error || error{InvalidPkgConfigOutput};

pub const Diagnostic = struct {
    invalid_line_index: usize,
    invalid_line: []const u8,
};

/// 解析 `pkg-config --list-all` 的输出。
pub fn init(arena: Allocator, stdout: []const u8, diagnostic: ?*Diagnostic) InitError!PkgConfig {
    var list: std.ArrayList(Pkg) = .empty;
    var line_it = mem.tokenizeAny(u8, stdout, "\r\n");
    var line_index: usize = 0;
    while (line_it.next()) |line| : (line_index += 1) {
        if (mem.trim(u8, line, " \t").len == 0) continue;
        var tok_it = mem.tokenizeAny(u8, line, " \t");
        try list.append(arena, .{
            .name = tok_it.next() orelse {
                if (diagnostic) |d| d.* = .{
                    .invalid_line_index = line_index,
                    .invalid_line = line,
                };
                return error.InvalidPkgConfigOutput;
            },
            .desc = tok_it.rest(),
        });
    }
    try list.shrinkToLen(arena);
    return .{ .all = list.toOwnedSliceAssert() };
}

// 将库名映射为 pkg-config 名称。遗憾的是,某些
// 映射并不直接对应,例如:
// * -lSDL2 -> pkg-config sdl2
// * -lgdk-3 -> pkg-config gdk-3.0
// * -latk-1.0 -> pkg-config atk
// * -lpulse -> pkg-config libpulse
pub fn find(pc: *const PkgConfig, lib_name: []const u8) ?usize {
    const all = pc.all;

    // 精确匹配意味着立即胜出。
    for (all, 0..) |pkg, i| {
        if (mem.eql(u8, pkg.name, lib_name))
            return i;
    }

    // 接下来尝试忽略大小写。
    for (all, 0..) |pkg, i| {
        if (std.ascii.eqlIgnoreCase(pkg.name, lib_name))
            return i;
    }

    // 带前缀 "lib" 或后缀 ".0"。
    for (all, 0..) |pkg, i| {
        if (std.ascii.findIgnoreCase(pkg.name, lib_name)) |pos| {
            const prefix = pkg.name[0..pos];
            const suffix = pkg.name[pos + lib_name.len ..];
            if (prefix.len > 0 and !mem.eql(u8, prefix, "lib")) continue;
            if (suffix.len > 0 and !mem.eql(u8, suffix, ".0")) continue;
            return i;
        }
    }

    // 裁剪 "-1.0"。
    if (mem.cutSuffix(u8, lib_name, "-1.0")) |trimmed| {
        for (all, 0..) |pkg, i| {
            if (std.ascii.eqlIgnoreCase(pkg.name, trimmed)) {
                return i;
            }
        }
    }

    return null;
}

pub fn exe(environ_map: *const std.process.Environ.Map) []const u8 {
    return std.zig.EnvVar.PKG_CONFIG.get(environ_map) orelse "pkg-config";
}

pub const Parsed = struct {
    cflags: []const []const u8,
    libs: []const []const u8,
    unknown_flags: []const []const u8,
    pthread: bool,
};

pub const ParseError = Allocator.Error || error{InvalidPkgConfigOutput};

/// 解析 `pkg-config [name] --cflags --libs` 的输出。
pub fn parse(arena: Allocator, stdout: []const u8) ParseError!Parsed {
    var zig_cflags: std.ArrayList([]const u8) = .empty;
    var zig_libs: std.ArrayList([]const u8) = .empty;
    var unknown_flags: std.ArrayList([]const u8) = .empty;
    var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");
    var pthread = false;

    while (arg_it.next()) |arg| {
        if (mem.eql(u8, arg, "-I")) {
            const dir = arg_it.next() orelse return error.InvalidPkgConfigOutput;
            try zig_cflags.appendSlice(arena, &.{ "-I", dir });
        } else if (mem.startsWith(u8, arg, "-I")) {
            try zig_cflags.append(arena, arg);
        } else if (mem.eql(u8, arg, "-L")) {
            const dir = arg_it.next() orelse return error.InvalidPkgConfigOutput;
            try zig_libs.appendSlice(arena, &.{ "-L", dir });
        } else if (mem.startsWith(u8, arg, "-L")) {
            try zig_libs.append(arena, arg);
        } else if (mem.eql(u8, arg, "-l")) {
            const lib = arg_it.next() orelse return error.InvalidPkgConfigOutput;
            try zig_libs.appendSlice(arena, &.{ "-l", lib });
        } else if (mem.startsWith(u8, arg, "-l")) {
            try zig_libs.append(arena, arg);
        } else if (mem.eql(u8, arg, "-D")) {
            const macro = arg_it.next() orelse return error.InvalidPkgConfigOutput;
            try zig_cflags.appendSlice(arena, &.{ "-D", macro });
        } else if (mem.startsWith(u8, arg, "-D")) {
            try zig_cflags.append(arena, arg);
        } else if (mem.cutPrefix(u8, arg, "-Wl,-rpath,")) |rest| {
            try zig_cflags.appendSlice(arena, &.{ "-rpath", rest });
        } else if (mem.eql(u8, arg, "-pthread")) {
            pthread = true;
        } else {
            try unknown_flags.append(arena, arg);
        }
    }

    try zig_cflags.shrinkToLen(arena);
    try zig_libs.shrinkToLen(arena);
    try unknown_flags.shrinkToLen(arena);

    return .{
        .cflags = zig_cflags.toOwnedSliceAssert(),
        .libs = zig_libs.toOwnedSliceAssert(),
        .unknown_flags = unknown_flags.toOwnedSliceAssert(),
        .pthread = pthread,
    };
}