alef 0.23.21

Opinionated polyglot binding generator for Rust libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // Resolve FFI paths. When published to a distribution (e.g., via zig fetch),
    // bundled lib/<rid>/ and include/ directories are used. For local development,
    // paths are resolved to the workspace build artifacts and FFI crate headers.
    //
    // Override with -Dffi_path=... and -Dffi_include_path=... if your layout differs.
    const ffi_path = b.option(
        []const u8,
        "ffi_path",
        "Path to directory containing lib{{ ffi_lib_name }}.{dylib,so,dll,a}"
    ) orelse blk: {
        // Published distribution: resolve bundled lib/<rid>/ subdir by compile-time target.
        // Local development: use workspace target/release (passed via -Dffi_path=...).
        const rid = ridDir(target);
        break :blk b.fmt("lib/{s}", .{rid});
    };

    const ffi_include = b.option(
        []const u8,
        "ffi_include_path",
        "Path to directory containing the FFI C header"
    ) orelse "include";

    const module = b.addModule("{{ module_name }}", .{
        .root_source_file = b.path("src/{{ module_name }}.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });
    module.addLibraryPath(b.path(ffi_path));
    module.addIncludePath(b.path(ffi_include));
    module.linkSystemLibrary("{{ ffi_lib_name }}", .{});

    const test_module = b.createModule(.{
        .root_source_file = b.path("src/{{ module_name }}.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });
    test_module.addLibraryPath(b.path(ffi_path));
    test_module.addIncludePath(b.path(ffi_include));
    test_module.linkSystemLibrary("{{ ffi_lib_name }}", .{});

    const tests = b.addTest(.{
        .root_module = test_module,
    });

    const run_tests = b.addRunArtifact(tests);
    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&run_tests.step);
}

fn ridDir(target: std.Build.ResolvedTarget) []const u8 {
    return switch (target.result.os.tag) {
        .linux => switch (target.result.cpu.arch) {
            .x86_64 => "x86_64-linux-gnu",
            .aarch64 => "aarch64-linux-gnu",
            else => @panic("unsupported linux arch for this package"),
        },
        .macos => switch (target.result.cpu.arch) {
            .aarch64 => "aarch64-darwin",
            .x86_64 => "x86_64-darwin",
            else => @panic("unsupported macos arch for this package"),
        },
        .windows => switch (target.result.cpu.arch) {
            .x86_64 => "x86_64-windows-msvc",
            else => @panic("unsupported windows arch for this package"),
        },
        else => @panic("unsupported os for this package"),
    };
}