@zigc/lib 0.16.0-test.0 → 0.16.0

package/std/Build/Step/ConfigHeader.zig

@@ -38,7 +38,7 @@ pub const Value = union(enum) {
 };
 
 step: Step,
-values: std.StringArrayHashMap(Value),
+values: std.array_hash_map.String(Value),
 /// This directory contains the generated file under the name `include_path`.
 generated_dir: std.Build.GeneratedFile,
 
@@ -95,7 +95,7 @@ pub fn create(owner: *std.Build, options: Options) *ConfigHeader {
             .first_ret_addr = options.first_ret_addr orelse @returnAddress(),
         }),
         .style = options.style,
-        .values = .init(owner.allocator),
+        .values = .empty,
 
         .max_bytes = options.max_bytes,
         .include_path = include_path,
@@ -109,6 +109,11 @@ pub fn create(owner: *std.Build, options: Options) *ConfigHeader {
     return config_header;
 }
 
+pub fn addIdent(config_header: *ConfigHeader, name: []const u8, value: []const u8) void {
+    const arena = config_header.step.owner.allocator;
+    config_header.values.put(arena, name, .{ .ident = value }) catch @panic("OOM");
+}
+
 pub fn addValue(config_header: *ConfigHeader, name: []const u8, comptime T: type, value: T) void {
     return addValueInner(config_header, name, T, value) catch @panic("OOM");
 }
@@ -127,43 +132,44 @@ pub fn getOutputFile(ch: *ConfigHeader) std.Build.LazyPath {
 }
 
 fn addValueInner(config_header: *ConfigHeader, name: []const u8, comptime T: type, value: T) !void {
+    const arena = config_header.step.owner.allocator;
     switch (@typeInfo(T)) {
         .null => {
-            try config_header.values.put(name, .undef);
+            try config_header.values.put(arena, name, .undef);
         },
         .void => {
-            try config_header.values.put(name, .defined);
+            try config_header.values.put(arena, name, .defined);
         },
         .bool => {
-            try config_header.values.put(name, .{ .boolean = value });
+            try config_header.values.put(arena, name, .{ .boolean = value });
         },
         .int => {
-            try config_header.values.put(name, .{ .int = value });
+            try config_header.values.put(arena, name, .{ .int = value });
         },
         .comptime_int => {
-            try config_header.values.put(name, .{ .int = value });
+            try config_header.values.put(arena, name, .{ .int = value });
         },
         .@"enum", .enum_literal => {
-            try config_header.values.put(name, .{ .ident = @tagName(value) });
+            try config_header.values.put(arena, name, .{ .ident = @tagName(value) });
         },
         .optional => {
             if (value) |x| {
                 return addValueInner(config_header, name, @TypeOf(x), x);
             } else {
-                try config_header.values.put(name, .undef);
+                try config_header.values.put(arena, name, .undef);
             }
         },
         .pointer => |ptr| {
             switch (@typeInfo(ptr.child)) {
                 .array => |array| {
                     if (ptr.size == .one and array.child == u8) {
-                        try config_header.values.put(name, .{ .string = value });
+                        try config_header.values.put(arena, name, .{ .string = value });
                         return;
                     }
                 },
                 .int => {
                     if (ptr.size == .slice and ptr.child == u8) {
-                        try config_header.values.put(name, .{ .string = value });
+                        try config_header.values.put(arena, name, .{ .string = value });
                         return;
                     }
                 },
@@ -214,8 +220,8 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                 });
             };
             switch (config_header.style) {
-                .autoconf_undef => try render_autoconf_undef(step, contents, bw, config_header.values, src_path),
-                .autoconf_at => try render_autoconf_at(step, contents, &aw, config_header.values, src_path),
+                .autoconf_undef => try render_autoconf_undef(step, contents, bw, &config_header.values, src_path),
+                .autoconf_at => try render_autoconf_at(step, contents, &aw, &config_header.values, src_path),
                 else => unreachable,
             }
         },
@@ -278,7 +284,7 @@ fn render_autoconf_undef(
     step: *Step,
     contents: []const u8,
     bw: *Writer,
-    values: std.StringArrayHashMap(Value),
+    values: *const std.array_hash_map.String(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
@@ -330,7 +336,7 @@ fn render_autoconf_at(
     step: *Step,
     contents: []const u8,
     aw: *Writer.Allocating,
-    values: std.StringArrayHashMap(Value),
+    values: *const std.array_hash_map.String(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
@@ -369,7 +375,7 @@ fn render_autoconf_at(
         if (!last_line) try bw.writeByte('\n');
     }
 
-    for (values.unmanaged.entries.slice().items(.key), used) |name, u| {
+    for (values.entries.slice().items(.key), used) |name, u| {
         if (!u) {
             try step.addError("{s}: error: config header value unused: '{s}'", .{ src_path, name });
             any_errors = true;
@@ -383,14 +389,14 @@ fn render_cmake(
     step: *Step,
     contents: []const u8,
     bw: *Writer,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
     const allocator = build.allocator;
 
-    var values_copy = try values.clone();
-    defer values_copy.deinit();
+    var values_copy = try values.clone(allocator);
+    defer values_copy.deinit(allocator);
 
     var any_errors = false;
     var line_index: u32 = 0;
@@ -416,12 +422,21 @@ fn render_cmake(
         };
         defer allocator.free(line);
 
-        if (!std.mem.startsWith(u8, line, "#")) {
+        const line_start = std.mem.findNone(u8, line, " \t\r") orelse {
+            try bw.writeAll(line);
+            if (!last_line) try bw.writeByte('\n');
+            continue;
+        };
+        const whitespace_prefix = line[0..line_start];
+        const trimmed_line = line[line_start..];
+
+        if (!std.mem.startsWith(u8, trimmed_line, "#")) {
             try bw.writeAll(line);
             if (!last_line) try bw.writeByte('\n');
             continue;
         }
-        var it = std.mem.tokenizeAny(u8, line[1..], " \t\r");
+
+        var it = std.mem.tokenizeAny(u8, trimmed_line[1..], " \t\r");
         const cmakedefine = it.next().?;
         if (!std.mem.eql(u8, cmakedefine, "cmakedefine") and
             !std.mem.eql(u8, cmakedefine, "cmakedefine01"))
@@ -498,6 +513,7 @@ fn render_cmake(
             value = Value{ .ident = it.rest() };
         }
 
+        try bw.writeAll(whitespace_prefix);
         try renderValueC(bw, name, value);
     }
 
@@ -509,7 +525,7 @@ fn render_cmake(
 fn render_blank(
     gpa: std.mem.Allocator,
     bw: *Writer,
-    defines: std.StringArrayHashMap(Value),
+    defines: std.array_hash_map.String(Value),
     include_path: []const u8,
     include_guard_override: ?[]const u8,
 ) !void {
@@ -541,7 +557,7 @@ fn render_blank(
     , .{include_guard_name});
 }
 
-fn render_nasm(bw: *Writer, defines: std.StringArrayHashMap(Value)) !void {
+fn render_nasm(bw: *Writer, defines: std.array_hash_map.String(Value)) !void {
     for (defines.keys(), defines.values()) |name, value| try renderValueNasm(bw, name, value);
 }
 
@@ -572,7 +588,7 @@ fn renderValueNasm(bw: *Writer, name: []const u8, value: Value) !void {
 fn expand_variables_autoconf_at(
     bw: *Writer,
     contents: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: *const std.array_hash_map.String(Value),
     used: []bool,
 ) !void {
     const valid_varname_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
@@ -598,7 +614,7 @@ fn expand_variables_autoconf_at(
                 try bw.writeAll(key);
                 return error.MissingValue;
             };
-            const value = values.unmanaged.entries.slice().items(.value)[index];
+            const value = values.entries.slice().items(.value)[index];
             used[index] = true;
             try bw.writeAll(contents[source_offset..curr]);
             switch (value) {
@@ -619,7 +635,7 @@ fn expand_variables_autoconf_at(
 fn expand_variables_cmake(
     allocator: Allocator,
     contents: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
 ) ![]const u8 {
     var result: std.array_list.Managed(u8) = .init(allocator);
     errdefer result.deinit();
@@ -751,7 +767,7 @@ fn testReplaceVariablesAutoconfAt(
     allocator: Allocator,
     contents: []const u8,
     expected: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
 ) !void {
     var aw: Writer.Allocating = .init(allocator);
     defer aw.deinit();
@@ -770,7 +786,7 @@ fn testReplaceVariablesCMake(
     allocator: Allocator,
     contents: []const u8,
     expected: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
 ) !void {
     const actual = try expand_variables_cmake(allocator, contents, values);
     defer allocator.free(actual);
@@ -780,7 +796,7 @@ fn testReplaceVariablesCMake(
 
 test "expand_variables_autoconf_at simple cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     // empty strings are preserved
@@ -876,7 +892,7 @@ test "expand_variables_autoconf_at simple cases" {
 
 test "expand_variables_autoconf_at edge cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     // @-vars resolved only when they wrap valid characters, otherwise considered literals
@@ -892,7 +908,7 @@ test "expand_variables_autoconf_at edge cases" {
 
 test "expand_variables_cmake simple cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     try values.putNoClobber("undef", .undef);
@@ -980,7 +996,7 @@ test "expand_variables_cmake simple cases" {
 
 test "expand_variables_cmake edge cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     // special symbols
@@ -1041,7 +1057,7 @@ test "expand_variables_cmake edge cases" {
 
 test "expand_variables_cmake escaped characters" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     try values.putNoClobber("string", Value{ .string = "text" });

package/std/Build/Step/InstallArtifact.zig

@@ -17,6 +17,10 @@ emitted_implib: ?LazyPath,
 pdb_dir: ?InstallDir,
 emitted_pdb: ?LazyPath,
 
+// hack for stage2_x86_64 + coff
+compiler_rt_dyn_lib_dir: ?InstallDir,
+emitted_compiler_rt_dyn_lib: ?LazyPath,
+
 h_dir: ?InstallDir,
 emitted_h: ?LazyPath,
 
@@ -35,6 +39,7 @@ pub const Options = struct {
     /// Which installation directory to put the main output file into.
     dest_dir: Dir = .default,
     pdb_dir: Dir = .default,
+    compiler_rt_dyn_lib_dir: Dir = .default,
     h_dir: Dir = .default,
     implib_dir: Dir = .default,
 
@@ -75,6 +80,11 @@ pub fn create(owner: *std.Build, artifact: *Step.Compile, options: Options) *Ins
             .default => if (artifact.producesPdbFile()) dest_dir else null,
             .override => |o| o,
         },
+        .compiler_rt_dyn_lib_dir = switch (options.compiler_rt_dyn_lib_dir) {
+            .disabled => null,
+            .default => if (artifact.producesCompilerRtDynLib()) dest_dir else null,
+            .override => |o| o,
+        },
         .h_dir = switch (options.h_dir) {
             .disabled => null,
             .default => if (artifact.kind == .lib) .header else null,
@@ -98,6 +108,7 @@ pub fn create(owner: *std.Build, artifact: *Step.Compile, options: Options) *Ins
 
         .emitted_bin = null,
         .emitted_pdb = null,
+        .emitted_compiler_rt_dyn_lib = null,
         .emitted_h = null,
         .emitted_implib = null,
 
@@ -107,6 +118,7 @@ pub fn create(owner: *std.Build, artifact: *Step.Compile, options: Options) *Ins
     install_artifact.step.dependOn(&artifact.step);
 
     if (install_artifact.dest_dir != null) install_artifact.emitted_bin = artifact.getEmittedBin();
+    if (install_artifact.compiler_rt_dyn_lib_dir != null) install_artifact.emitted_compiler_rt_dyn_lib = artifact.getEmittedCompilerRtDynLib();
     if (install_artifact.pdb_dir != null) install_artifact.emitted_pdb = artifact.getEmittedPdb();
     // https://github.com/ziglang/zig/issues/9698
     //if (install_artifact.h_dir != null) install_artifact.emitted_h = artifact.getEmittedH();
@@ -135,6 +147,12 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         install_artifact.artifact.installed_path = full_dest_path;
     }
 
+    if (install_artifact.compiler_rt_dyn_lib_dir) |compiler_rt_dir| {
+        const full_compiler_rt_path = b.getInstallPath(compiler_rt_dir, install_artifact.emitted_compiler_rt_dyn_lib.?.basename(b, step));
+        const p = try step.installFile(install_artifact.emitted_compiler_rt_dyn_lib.?, full_compiler_rt_path);
+        all_cached = all_cached and p == .fresh;
+    }
+
     if (install_artifact.implib_dir) |implib_dir| {
         const full_implib_path = b.getInstallPath(implib_dir, install_artifact.emitted_implib.?.basename(b, step));
         const p = try step.installFile(install_artifact.emitted_implib.?, full_implib_path);