hidapi/build.zig at master · allyourcodebase/hidapi · GitHub

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
const std = @import("std");

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

    const upstream = b.dependency("upstream", .{});

    const use_libussb = b.option(
        bool,
        "libusb",
        "Use libusb backend (default: false)",
    ) orelse false;

    const iconv = b.option(
        bool,
        "iconv",
        "Use iconv for string conversion (default: true)",
    ) orelse true;

    const iconv_flags: []const []const u8 = if (iconv) &.{} else &.{"-DNO_ICONV"};

    const mod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });
    mod.addIncludePath(upstream.path("hidapi"));

    const root_file_path = if (use_libussb) "libusb" else switch (target.result.os.tag) {
        .linux, .netbsd, .windows => |t| @tagName(t),
        else => |t| if (t.isDarwin()) "mac" else {
            if (!use_libussb) std.debug.panic("target {t} needs libusb", .{t});
            unreachable;
        },
    };

    const lib = b.addLibrary(.{ .name = "hidapi", .root_module = mod });
    mod.addCSourceFiles(.{
        .root = upstream.path(root_file_path),
        .files = &.{"hid.c"},
        .flags = iconv_flags,
    });

    switch (target.result.os.tag) {
        .windows => {
            mod.addAfterIncludePath(upstream.path("windows"));
            lib.installHeader(upstream.path("windows/hidapi_winapi.h"), "hidapi_winapi.h");
        },
        .macos => {
            lib.root_module.linkFramework("IOKit", .{});
        },
        else => {},
    }

    if (use_libussb) {
        const libusb_dep = b.lazyDependency("libusb", .{
            .target = target,
            .optimize = optimize,
            .linkage = .static,
            .@"system-libudev" = false,
        }) orelse return;
        mod.linkLibrary(libusb_dep.artifact("usb"));

        lib.installHeader(upstream.path("libusb/hidapi_libusb.h"), "hidapi_libusb.h");
    } else if (target.result.os.tag == .linux) {
        const libudev_zero_dep = b.lazyDependency("libudev_zero", .{
            .target = target,
            .optimize = optimize,
        }) orelse return;
        mod.linkLibrary(libudev_zero_dep.artifact("udev"));
    }

    lib.installHeader(upstream.path("hidapi/hidapi.h"), "hidapi.h");
    b.installArtifact(lib);

    const hidtest = b.addExecutable(.{
        .name = "hidtest",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    hidtest.root_module.addCSourceFile(.{
        .file = upstream.path("hidtest/test.c"),
    });
    hidtest.root_module.linkLibrary(lib);
    b.installArtifact(hidtest);

    const hidtest_run = b.addRunArtifact(hidtest);
    const hidtest_step = b.step("hidtest", "Run hidtest");
    hidtest_step.dependOn(&hidtest_run.step);
}