build.zig

const std = @import("std");

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

    const versionString = @import("./build.zig.zon").version;
    const version = std.SemanticVersion.parse(versionString) catch @panic("OOM");

    const build_tools = b.option(bool, "tools", "Build the gifsicle tools") orelse true;
    const linkage = b.option(std.builtin.LinkMode, "linkage", "Link mode for the library") orelse .static;
    const terminalAvailable = b.option(bool, "terminal", "Output gif to terminal") orelse true;

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

    const lib_mod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .pic = true,
    });
    const lib = b.addLibrary(.{
        .name = "gifsicle",
        .root_module = lib_mod,
        .version = version,
        .linkage = linkage,
    });

    lib_mod.addIncludePath(gifsicle_upstream.path("include"));

    const t = lib.rootModuleTarget();

    const is32Bit = t.ptrBitWidth() == 32;
    const isWindows = t.os.tag == .windows;

    const haveX11 = !isWindows;

    // std.Target.x86.featureSetHas(t.getCpuFeatures(), .simd);
    const config_h = b.addConfigHeader(.{ .style = .{ .cmake = b.path("winconf.h.in") }, .include_path = "config.h" }, .{
        .GIF_ALLOCATOR_DEFINED = 1,
        .HAVE_INT64_T = 1,
        .X_DISPLAY_MISSING = @intFromBool(!haveX11),
        .HAVE_MKSTEMP = @intFromBool(!isWindows),
        .HAVE_POW = 1,
        .HAVE_STRERROR = 1,
        .HAVE_STRTOUL = 1,
        .HAVE_UINT64_T = 1, // search for unused types
        .HAVE_UINTPTR_T = 1,
        .OUTPUT_GIF_TO_TERMINAL = if (terminalAvailable) null else @as(?u1, 1),
        .ENABLE_THREADS = @intFromBool(!isWindows), // pthread.h not on windows
        .HAVE_SIMD = 1, // TODO: check target and enable as needed
        .HAVE_VECTOR_SIZE_VECTOR_TYPES = 1,
        //HAVE___BUILTIN_SHUFFLEVECTOR
        //HAVE___SYNC_ADD_AND_FETCH

        .HAVE_STDINT_H = 1,
        .HAVE_INTTYPES_H = 1,
        .HAVE_SYS_STAT_H = 1,
        .HAVE_SYS_TYPES_H = 1,
        .HAVE_UNISTD_H = @intFromBool(terminalAvailable),

        .SIZEOF_FLOAT = 4,
        .SIZEOF_UNSIGNED_INT = 4,
        .SIZEOF_VOID_P = @as(u8, if (is32Bit) 4 else 8),
        .SIZEOF_UNSIGNED_LONG = @as(u8, if (is32Bit or isWindows) 4 else 8),

        .PATHNAME_SEPARATOR = if (isWindows) "\\\\" else "/",
        .RANDOM = "rand",
        .GIF_FREE = "free",
        .IS_WINDOWS = @intFromBool(isWindows),

        .VERSION = versionString, // b.fmt("{f}", .{version}),
    });

    lib_mod.addCMacro("HAVE_CONFIG_H", "1");

    lib.installHeader(gifsicle_upstream.path("src/gifsicle.h"), "gifsicle.h");
    lib.installHeadersDirectory(gifsicle_upstream.path("include"), ".", .{});

    lib_mod.addConfigHeader(config_h);
    // lib.installConfigHeader(config_h);
    lib_mod.addCSourceFiles(.{ .root = gifsicle_upstream.path("."), .files = &gifsicle_sources, .flags = gifsicle_cflags });
    b.installArtifact(lib);

    ////

    const gifsicle = b.addExecutable(.{
        .name = "gifsicle-cli",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    gifsicle.root_module.linkLibrary(lib);
    gifsicle.root_module.addConfigHeader(config_h);
    gifsicle.root_module.addCSourceFile(.{ .file = gifsicle_upstream.path("src/gifsicle.c"), .flags = &.{} });

    const gifview = b.addExecutable(.{
        .name = "gifview-cli",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    gifview.root_module.linkLibrary(lib);
    gifview.root_module.addConfigHeader(config_h);
    gifview.root_module.addCSourceFiles(.{ .root = gifsicle_upstream.path("."), .files = &gifview_sources });
    gifview.root_module.linkSystemLibrary("X11", .{});
    gifview.root_module.addCMacro("HAVE_CONFIG_H", "1");

    const gifdiff = b.addExecutable(.{
        .name = "gifdiff-cli",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    gifdiff.root_module.linkLibrary(lib);
    gifdiff.root_module.addConfigHeader(config_h);
    gifdiff.root_module.addCSourceFile(.{ .file = gifsicle_upstream.path("src/gifdiff.c"), .flags = &.{} });

    if (build_tools) {
        b.installArtifact(gifsicle);

        if (linkage == .static) {
            if (haveX11) b.installArtifact(gifview);
            b.installArtifact(gifdiff);
        }
    }
}

const gifsicle_sources = [_][]const u8{
    "src/clp.c",
    "src/fmalloc.c",
    "src/giffunc.c",
    "src/gifread.c",
    "src/gifunopt.c",
    "src/gifwrite.c",
    "src/merge.c",
    "src/optimize.c",
    "src/quantize.c",
    "src/support.c",
    "src/xform.c",
    "src/kcolor.c",
};

const gifview_sources = [_][]const u8{
    "src/gifview.c",
    "src/gifx.c",
};

const gifsicle_cflags: []const []const u8 = &.{
    // "-std=c89",
    // "-W", "-Wall"
};