feat: initial code

Author: RossComputerGuy

Step/Autoconf.zig

@@ -0,0 +1,50 @@
+const std = @import("std");
+const Autoconf = @This();
+const evalChildProcess = @import("build").evalChildProcessInDirectory;
+
+pub const Options = struct {
+    source: std.Build.LazyPath,
+};
+
+step: std.Build.Step,
+source: std.Build.LazyPath,
+output_file: std.Build.GeneratedFile,
+
+pub fn create(b: *std.Build, options: Options) Autoconf {
+    const arena = b.allocator;
+    const self = arena.create(Autoconf) catch @panic("OOM");
+    self.* = .{
+        .step = std.Build.Step.init(.{
+            .id = .custom,
+            .name = b.fmt("Autoconf {}", .{options.source.getDisplayName()}),
+            .owner = b,
+            .makeFn = make,
+        }),
+        .source = options.source,
+        .output_file = .{ .step = &self.step },
+    };
+
+    self.source.addStepDependencies(&self.step);
+    return self;
+}
+
+fn make(step: *std.Build.Step, _: *std.Progress.Node) anyerror!void {
+    const b = step.owner;
+    const self = @fieldParentPtr(Autoconf, "step", step);
+
+    var man = b.graph.cache.obtain();
+    defer man.deinit();
+
+    try man.addFile(b.pathJoin(&.{ self.source.getPath2(b, step), "configure.ac" }), null);
+
+    self.output_file.path = b.pathJoin(&.{ self.source.getPath2(b, step), "configure.ac" });
+
+    if (try step.cacheHit(&man)) return;
+
+    const cmd = b.findProgram(&.{"autoconf"}, &.{}) catch return step.fail("Cannot locate autoconf", .{});
+
+    try evalChildProcess(step, &.{
+        cmd,
+    }, self.source.getPath2(b, step));
+    try step.writeManifest(&man);
+}

Step/Configure.zig

@@ -0,0 +1,129 @@
+const std = @import("std");
+const Configure = @This();
+const evalChildProcess = @import("build").evalChildProcessInDirectory;
+
+pub const Options = struct {
+    source: std.Build.LazyPath,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode = .Debug,
+    linkage: std.Build.Step.Compile.Linkage = .Static,
+    flags: ?[]const []const u8 = null,
+};
+
+step: std.Build.Step,
+source: std.Build.LazyPath,
+target: std.Build.ResolvedTarget,
+optimize: std.builtin.OptimizeMode,
+linkage: std.Build.Step.Compile.Linkage,
+flags: std.ArrayListUnmanaged([]const u8),
+
+pub fn create(b: *std.Build, options: Options) Configure {
+    const arena = b.allocator;
+    const self = arena.create(Configure) catch @panic("OOM");
+    self.* = .{
+        .step = std.Build.Step.init(.{
+            .id = .custom,
+            .name = b.fmt("Configure {}", .{options.source.getDisplayName()}),
+            .owner = b,
+            .makeFn = make,
+        }),
+        .source = options.source,
+        .target = options.target,
+        .optimize = options.optimize,
+        .linkage = options.linkage,
+        .flags = .{},
+    };
+
+    self.source.addStepDependencies(&self.step);
+
+    if (options.flags) |flags| {
+        self.flags.ensureTotalCapacity(arena, flags.len) catch @panic("OOM");
+
+        for (flags) |flag| {
+            self.flags.appendAssumeCapacity(arena.dupe(u8, flag) catch @panic("OOM"));
+        }
+    }
+    return self;
+}
+
+fn make(step: *std.Build.Step, _: *std.Progress.Node) anyerror!void {
+    const b = step.owner;
+    const arena = b.allocator;
+    const self = @fieldParentPtr(Configure, "step", step);
+
+    var man = b.graph.cache.obtain();
+    defer man.deinit();
+
+    try man.addFile(b.pathJoin(&.{ self.source.getPath2(b, step), "configure" }), null);
+
+    if (try step.cacheHit(&man)) return;
+
+    const cmd = b.findProgram(&.{ "bash", "sh" }, &.{}) catch return step.fail("Cannot locate a shell", .{});
+
+    var args = std.ArrayList([]const u8).init(arena);
+    defer args.deinit();
+
+    try args.appendSlice(&.{
+        cmd,
+        b.pathJoin(&.{ self.source.getPath2(b, step), "configure" }),
+        b.fmt("--build={s}", .{try self.target.query.zigTriple(arena)}),
+        "--prefix=/usr",
+        b.fmt("--includedir={s}", .{b.cache_root.join(b.allocator, &.{ "expidus-dev", "include" })}),
+        b.fmt("--enable-{s}", .{@as([]const u8, switch (self.linkage) {
+            .dynamic => "shared",
+            else => @tagName(self.linkage),
+        })}),
+    });
+
+    try args.appendSlice(self.flags.items);
+
+    try step.handleChildProcUnsupported(null, args.items);
+    try std.Build.Step.handleVerbose(b, null, args.items);
+
+    var env_map = std.process.EnvMap.init(arena);
+    defer env_map.deinit();
+
+    {
+        var iter = b.graph.env_map.iterator();
+        while (iter.next()) |entry| {
+            try env_map.put(entry.key_ptr.*, entry.value_ptr.*);
+        }
+    }
+
+    try env_map.put("CC", b.fmt("{s} cc", .{
+        b.graph.zig_exe,
+    }));
+
+    try env_map.put("CXX", b.fmt("{s} c++", .{
+        b.graph.zig_exe,
+    }));
+
+    try env_map.put("CFLAGS", b.fmt("-target={s} -mcpu={s} -O{s}", .{
+        try self.target.query.zigTriple(arena),
+        try self.target.query.serializeCpuAlloc(arena),
+        @as([]const u8, switch (self.optimize) {
+            .ReleaseSmall => "s",
+            .ReleaseSafe => "3",
+            .ReleaseFast => "fast",
+            .Debug => "g",
+        }),
+    }));
+
+    if (b.findProgram(&.{"pkg-config"}, &.{}) catch null) |pkgconfig| {
+        try env_map.put("PKG_CONFIG", pkgconfig);
+    }
+
+    const result = std.ChildProcess.run(.{
+        .allocator = arena,
+        .argv = args.items,
+        .cwd = self.source.getPath2(b, step),
+        .env_map = env_map,
+    }) catch |err| return step.fail("unable to spawn {s}: {s}", .{ cmd, @errorName(err) });
+
+    if (result.stderr.len > 0) {
+        try step.result_error_msgs.append(arena, result.stderr);
+    }
+
+    try step.handleChildProcessTerm(result.term, null, args.items);
+    try step.writeManifest(&man);
+}

Step/Make.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+const Make = @This();
+const evalChildProcess = @import("build").evalChildProcessInDirectory;
+
+pub const Options = struct {
+    source: std.Build.LazyPath,
+};
+
+step: std.Build.Step,
+source: std.Build.LazyPath,
+output_file: std.Build.GeneratedFile,
+
+pub fn create(b: *std.Build, options: Options) Make {
+    const arena = b.allocator;
+    const self = arena.create(Make) catch @panic("OOM");
+    self.* = .{
+        .step = std.Build.Step.init(.{
+            .id = .custom,
+            .name = b.fmt("Make {}", .{options.source.getDisplayName()}),
+            .owner = b,
+            .makeFn = make,
+        }),
+        .source = options.source,
+        .output_file = .{ .step = &self.step },
+    };
+
+    self.source.addStepDependencies(&self.step);
+    return self;
+}
+
+fn make(step: *std.Build.Step, _: *std.Progress.Node) anyerror!void {
+    const b = step.owner;
+    const self = @fieldParentPtr(Make, "step", step);
+
+    var man = b.graph.cache.obtain();
+    defer man.deinit();
+
+    try man.addFile(b.pathJoin(&.{ self.source.getPath2(b, step), "Makefile" }), null);
+
+    if (try step.cacheHit(&man)) return;
+
+    const cmd = b.findProgram(&.{"make"}, &.{}) catch return step.fail("Cannot locate GNU Make", .{});
+
+    try evalChildProcess(step, &.{
+        cmd,
+    }, self.source.getPath2(b, step));
+    try step.writeManifest(&man);
+}

build.zig

@@ -0,0 +1,9 @@
+const std = @import("std");
+
+pub const Step = struct {
+    pub const Autoconf = @import("Step/Autoconf.zig");
+    pub const Configure = @import("Step/Configure.zig");
+    pub const Make = @import("Step/Make.zig");
+};
+
+pub fn build(_: *std.Build) void {}

build.zig.zon

@@ -0,0 +1,11 @@
+.{
+    .name = "pkgbuild",
+    .version = "0.0.0",
+    .paths = .{""},
+    .dependencies = .{
+        .build = .{
+            .url = "https://github.com/ExpidusOS/build/archive/aab78d6bd30004e002361dc5e66c090719bb88a7.tar.gz",
+            .hash = "1220fe80f8f80b02213a1aa25d000f65fc889e8f8e39d0a0344a35caaef9c1b35bb7",
+        },
+    },
+}