Build is working again (on Zig master branch)

Re-added specifying thread count doing something
Added single-threaded performance to benchmark.sh
Added single-threaded test (currently getting stuck forever)
Various minor fixes revealed now that build is working again.

build.zig

@@ -3,6 +3,10 @@ const std = @import("std");
 pub fn build(b: *std.Build) !void {
     const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
     const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo support") orelse false;
+<<<<<<< HEAD
+=======
+    const dynamic = b.option(bool, "dynamic", "Dynamicly link C decompression libraries") orelse false;
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
     var debug = b.option(bool, "debug", "Enable options to make debugging easier.");
     const version_string_option = b.option([]const u8, "version", "Version of the library/binary");
 
@@ -28,18 +32,24 @@ pub fn build(b: *std.Build) !void {
             .target = target,
             .valgrind = debug,
             .root_source_file = b.path("src/root.zig"),
+<<<<<<< HEAD
             // .link_libc = true,
             .imports = &.{
                 .{ .name = "options", .module = zig_squashfs_options.createModule() },
                 .{ .name = "c", .module = c.createModule() },
+=======
+            .imports = &.{
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
             },
         }),
         .use_llvm = debug,
     });
 
-    const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
-    lib.root_module.linkLibrary(zstd.artifact("zstd"));
+    const deps = try dependencies(b, optimize, target, use_zig_decomp, allow_lzo, dynamic);
+    defer b.allocator.free(deps);
 
+<<<<<<< HEAD
     const zng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
     lib.root_module.linkLibrary(zng.artifact("zng"));
 
@@ -51,6 +61,23 @@ pub fn build(b: *std.Build) !void {
 
     const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
     lib.root_module.linkLibrary(lz4.artifact("lz4"));
+=======
+    for (deps) |d|
+        lib.root_module.linkLibrary(d);
+
+    if (!use_zig_decomp) {
+        const c = b.addTranslateC(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/c.h"),
+        });
+        if (allow_lzo) c.defineCMacro("ALLOW_LZO", null);
+        lib.root_module.addImport("c", c.createModule());
+
+        if (dynamic)
+            dynamicLinkLibraries(c, allow_lzo);
+    }
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
 
     var version = version_string_option orelse "0.0.0-testing";
     if (version[0] == 'v') version = version[1..];
@@ -80,17 +107,32 @@ pub fn build(b: *std.Build) !void {
 
     const mod_tests = b.addTest(.{
         .root_module = b.createModule(.{
-            .optimize = .Debug,
+            .optimize = optimize,
             .target = target,
-            .root_source_file = b.path("src/test.zig"),
+            .root_source_file = b.path("src/root.zig"),
             .imports = &.{
-                .{ .name = "c", .module = c.createModule() },
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
             },
-            .valgrind = true,
+            .valgrind = debug,
         }),
-        .use_llvm = true,
+        .use_llvm = debug,
     });
-    mod_tests.root_module.linkLibrary(zstd.artifact("zstd"));
+
+    for (deps) |d|
+        mod_tests.root_module.linkLibrary(d);
+
+    if (!use_zig_decomp) {
+        const c = b.addTranslateC(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/c.h"),
+        });
+        mod_tests.root_module.addImport("c", c.createModule());
+        if (allow_lzo) c.defineCMacro("ALLOW_LZO", null);
+
+        if (dynamic)
+            dynamicLinkLibraries(c, allow_lzo);
+    }
 
     const run_mod_tests = b.addRunArtifact(mod_tests);
     const test_step = b.step("test", "Run tests");
@@ -109,3 +151,42 @@ pub fn build(b: *std.Build) !void {
     check.dependOn(&lib_check.step);
     check.dependOn(&exe_check.step);
 }
+
+pub fn dynamicLinkLibraries(mod: *std.Build.Step.TranslateC, allow_lzo: bool) void {
+    mod.linkSystemLibrary("zstd", .{});
+    mod.linkSystemLibrary("zlib-ng", .{});
+    mod.linkSystemLibrary("lzma", .{});
+    mod.linkSystemLibrary("lz4", .{});
+    if (allow_lzo)
+        mod.linkSystemLibrary("minilzo", .{});
+}
+fn dependencies(
+    b: *std.Build,
+    optimize: std.builtin.OptimizeMode,
+    target: std.Build.ResolvedTarget,
+    use_zig_decomp: bool,
+    allow_lzo: bool,
+    dynamic: bool,
+) ![]*std.Build.Step.Compile {
+    if (use_zig_decomp or dynamic) return &.{};
+
+    var list: std.ArrayList(*std.Build.Step.Compile) = .empty;
+
+    const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, zstd.artifact("zstd"));
+
+    const zng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, zng.artifact("zng"));
+
+    const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, xz.artifact("lzma"));
+
+    const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, lz4.artifact("lz4"));
+
+    if (allow_lzo) {
+        const minilzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
+        try list.append(b.allocator, minilzo.artifact("minilzo"));
+    }
+    return list.toOwnedSlice(b.allocator);
+}