@zigc/lib 0.17.0-dev.657 → 0.17.0-dev.667

package/compiler/Maker.zig

@@ -194,7 +194,7 @@ pub fn main(init: process.Init.Minimal) !void {
     var max_rss: u64 = 0;
     var skip_oom_steps = false;
     var test_timeout_ns: ?u64 = null;
-    var color: Color = .auto;
+    var color: Color = .settingFromEnvironment(&graph.environ_map);
     var watch = false;
     var fuzz: ?Fuzz.Mode = null;
     var debounce_interval_ms: u16 = 50;
@@ -533,7 +533,7 @@ pub fn main(init: process.Init.Minimal) !void {
     }
 
     const main_progress_node = std.Progress.start(io, .{
-        .disable_printing = (color == .off),
+        .disable_printing = (graph.stderr_mode.? == .no_color),
     });
     defer main_progress_node.end();
 

package/libc/include/powerpc-linux-gnu/bits/struct_mutex.h

@@ -32,7 +32,7 @@ struct __pthread_mutex_s
   int __kind;
 #if __WORDSIZE == 64
   short __spins;
-  short __unused;
+  short __glibc_reserved;
   __pthread_list_t __list;
 # define __PTHREAD_MUTEX_HAVE_PREV      1
 #else
@@ -59,4 +59,4 @@ struct __pthread_mutex_s
   0, 0, 0, __kind, 0, { { 0, 0 } }
 #endif
 
-#endif
+#endif

package/libc/include/s390x-linux-gnu/bits/fenv.h

@@ -76,7 +76,7 @@ typedef unsigned int fexcept_t; /* size of fpc */
 typedef struct
 {
   fexcept_t __fpc;
-  void *__unused;
+  void *__glibc_reserved;
   /* The field __unused (formerly __ieee_instruction_pointer) is a relict from
      commit "Remove PTRACE_PEEKUSER" (87b9b50f0d4b92248905e95a06a13c513dc45e59)
      and isn't used anymore.  */
@@ -96,4 +96,4 @@ typedef unsigned int femode_t;
 
 /* Default floating-point control modes.  */
 # define FE_DFL_MODE	((const femode_t *) -1L)
-#endif
+#endif

package/libc/include/s390x-linux-gnu/bits/struct_mutex.h

@@ -32,7 +32,7 @@ struct __pthread_mutex_s
   int __kind;
 #if __WORDSIZE == 64
   short __spins;
-  short __unused;
+  short __glibc_reserved;
   __pthread_list_t __list;
 # define __PTHREAD_MUTEX_HAVE_PREV      1
 #else
@@ -59,4 +59,4 @@ struct __pthread_mutex_s
   0, 0, 0, __kind, 0, { { 0, 0 } }
 #endif
 
-#endif
+#endif

package/libc/include/x86-linux-gnu/bits/struct_mutex.h

@@ -32,7 +32,7 @@ struct __pthread_mutex_s
   int __kind;
 #ifdef __x86_64__
   short __spins;
-  short __unused;
+  short __glibc_reserved;
   __pthread_list_t __list;
 # define __PTHREAD_MUTEX_HAVE_PREV      1
 #else
@@ -59,4 +59,4 @@ struct __pthread_mutex_s
   0, 0, 0, __kind, 0, { { 0, 0 } }
 #endif
 
-#endif
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.657",
+  "version": "0.17.0-dev.667",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/crypto/aes/aesni.zig

@@ -312,7 +312,7 @@ pub fn BlockVec(comptime blocks_count: comptime_int) type {
         }
 
         /// Apply the bitwise OR operation to the content of two block vectors.
-        pub fn orBlocks(block_vec1: Self, block_vec2: Block) Self {
+        pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self {
             var out: Self = undefined;
             inline for (0..native_words) |i| {
                 out.repr[i] = block_vec1.repr[i] | block_vec2.repr[i];

package/std/crypto/aes/armcrypto.zig

@@ -216,10 +216,10 @@ pub fn BlockVec(comptime blocks_count: comptime_int) type {
         }
 
         /// XOR the block vector with a byte sequence.
-        pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [32]u8 {
-            var out: Self = undefined;
+        pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [blocks_count * 16]u8 {
+            var out: [blocks_count * 16]u8 = undefined;
             inline for (0..native_words) |i| {
-                out.repr[i] = block_vec.repr[i].xorBytes(bytes[i * native_word_size ..][0..native_word_size]);
+                out[i * native_word_size ..][0..native_word_size].* = block_vec.repr[i].xorBytes(bytes[i * native_word_size ..][0..native_word_size]);
             }
             return out;
         }
@@ -279,7 +279,7 @@ pub fn BlockVec(comptime blocks_count: comptime_int) type {
         }
 
         /// Apply the bitwise OR operation to the content of two block vectors.
-        pub fn orBlocks(block_vec1: Self, block_vec2: Block) Self {
+        pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self {
             var out: Self = undefined;
             inline for (0..native_words) |i| {
                 out.repr[i] = block_vec1.repr[i].orBlocks(block_vec2.repr[i]);

package/std/crypto/aes/soft.zig

@@ -391,10 +391,10 @@ pub fn BlockVec(comptime blocks_count: comptime_int) type {
         }
 
         /// XOR the block vector with a byte sequence.
-        pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [32]u8 {
-            var out: Self = undefined;
+        pub fn xorBytes(block_vec: Self, bytes: *const [blocks_count * 16]u8) [blocks_count * 16]u8 {
+            var out: [blocks_count * 16]u8 = undefined;
             for (0..native_words) |i| {
-                out.repr[i] = block_vec.repr[i].xorBytes(bytes[i * native_word_size ..][0..native_word_size]);
+                out[i * native_word_size ..][0..native_word_size].* = block_vec.repr[i].xorBytes(bytes[i * native_word_size ..][0..native_word_size]);
             }
             return out;
         }
@@ -454,7 +454,7 @@ pub fn BlockVec(comptime blocks_count: comptime_int) type {
         }
 
         /// Apply the bitwise OR operation to the content of two block vectors.
-        pub fn orBlocks(block_vec1: Self, block_vec2: Block) Self {
+        pub fn orBlocks(block_vec1: Self, block_vec2: Self) Self {
             var out: Self = undefined;
             for (0..native_words) |i| {
                 out.repr[i] = block_vec1.repr[i].orBlocks(block_vec2.repr[i]);

package/std/crypto/aes.zig

@@ -137,6 +137,18 @@ test "BlockVec invMixColumns" {
     }
 }
 
+test "BlockVec bitwise operations" {
+    const a_bytes: [32]u8 = @splat(0xaa);
+    const b_bytes: [32]u8 = @splat(0xbb);
+    const a = BlockVec(2).fromBytes(&a_bytes);
+    const b = BlockVec(2).fromBytes(&b_bytes);
+
+    try testing.expectEqual(@as([32]u8, @splat(0x11)), a.xorBytes(&b_bytes));
+    try testing.expectEqual(@as([32]u8, @splat(0x11)), a.xorBlocks(b).toBytes());
+    try testing.expectEqual(@as([32]u8, @splat(0xbb)), a.orBlocks(b).toBytes());
+    try testing.expectEqual(@as([32]u8, @splat(0xaa)), a.andBlocks(b).toBytes());
+}
+
 test "expand 256-bit key" {
     const key = [_]u8{
         0x60, 0x3d, 0xeb, 0x10,

package/std/debug/SelfInfo/MachO.zig

@@ -93,12 +93,28 @@ pub fn getSymbols(
 pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
     _ = si;
     _ = io;
-    // This function is marked as deprecated; however, it is significantly more
-    // performant than `dladdr` (since the latter also does a very slow symbol
-    // lookup), so let's use it since it's still available.
-    return std.mem.span(std.c.dyld_image_path_containing_address(
-        @ptrFromInt(address),
-    ) orelse return error.MissingDebugInfo);
+    return getModuleNameInner(address) orelse return error.MissingDebugInfo;
+}
+fn getModuleNameInner(address: usize) ?[]const u8 {
+    switch (builtin.target.os.tag) {
+        .macos => {
+            // This function is marked as deprecated; however, it is significantly more performant
+            // than `dladdr` (since the latter also does a very slow symbol lookup), so let's just
+            // use it for the better performance since it's still available.
+            return std.mem.span(std.c.dyld_image_path_containing_address(
+                @ptrFromInt(address),
+            ) orelse return null);
+        },
+        else => {
+            // On other Darwin systems, the function used above is entirely unavailable, so we have
+            // no choice but to use the slow `dladdr`.
+            var info: std.c.dl_info = undefined;
+            if (std.c.dladdr(@ptrFromInt(address), &info) == 0) {
+                return null;
+            }
+            return std.mem.span(info.fname);
+        },
+    }
 }
 pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
     const gpa = std.debug.getDebugInfoAllocator();
@@ -446,12 +462,25 @@ fn unwindFrameInner(si: *SelfInfo, io: Io, context: *UnwindContext) !usize {
 
 /// Acquires the mutex on success.
 fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!*Module {
-    // This function is marked as deprecated; however, it is significantly more
-    // performant than `dladdr` (since the latter also does a very slow symbol
-    // lookup), so let's use it since it's still available.
-    const text_base = std.c._dyld_get_image_header_containing_address(
-        @ptrFromInt(address),
-    ) orelse return error.MissingDebugInfo;
+    const text_base: *anyopaque = switch (builtin.target.os.tag) {
+        .macos => base: {
+            // This function is marked as deprecated; however, it is significantly more performant
+            // than `dladdr` (since the latter also does a very slow symbol lookup), so let's just
+            // use it for the better performance since it's still available.
+            break :base std.c._dyld_get_image_header_containing_address(
+                @ptrFromInt(address),
+            ) orelse return error.MissingDebugInfo;
+        },
+        else => base: {
+            // On other Darwin systems, the function used above is entirely unavailable, so we have
+            // no choice but to use the slow `dladdr`.
+            var info: std.c.dl_info = undefined;
+            if (std.c.dladdr(@ptrFromInt(address), &info) == 0) {
+                return error.MissingDebugInfo;
+            }
+            break :base info.fbase;
+        },
+    };
     try si.mutex.lock(io);
     errdefer si.mutex.unlock(io);
     const gop = try si.modules.getOrPutAdapted(gpa, @intFromPtr(text_base), Module.Adapter{});
@@ -563,9 +592,7 @@ const Module = struct {
 
     fn getFile(module: *Module, gpa: Allocator, io: Io) Error!*MachOFile {
         if (module.file == null) {
-            const path = std.mem.span(
-                std.c.dyld_image_path_containing_address(@ptrFromInt(module.text_base)).?,
-            );
+            const path = getModuleNameInner(module.text_base).?;
             module.file = MachOFile.load(gpa, io, path, builtin.cpu.arch) catch |err| switch (err) {
                 error.InvalidMachO, error.InvalidDwarf => error.InvalidDebugInfo,
                 error.MissingDebugInfo, error.OutOfMemory, error.UnsupportedDebugInfo, error.ReadFailed => |e| e,

package/std/sort/pdq.zig

@@ -47,10 +47,10 @@ pub fn pdqContext(a: usize, b: usize, context: anytype) void {
     const max_limit = std.math.floorPowerOfTwo(usize, b - a) + 1;
 
     // set upper bound on stack memory usage.
-    const Range = struct { a: usize, b: usize, limit: usize };
+    const Range = struct { a: usize, b: usize, limit: usize, leftmost: bool };
     const stack_size = math.log2(math.maxInt(usize) + 1);
     var stack: [stack_size]Range = undefined;
-    var range = Range{ .a = a, .b = b, .limit = max_limit };
+    var range = Range{ .a = a, .b = b, .limit = max_limit, .leftmost = true };
     var top: usize = 0;
 
     while (true) {
@@ -62,7 +62,11 @@ pub fn pdqContext(a: usize, b: usize, context: anytype) void {
 
             // very short slices get sorted using insertion sort.
             if (len <= max_insertion) {
-                break sort.insertionContext(range.a, range.b, context);
+                if (range.leftmost) {
+                    break sort.insertionContext(range.a, range.b, context);
+                } else {
+                    break unguardedInsertionContext(range.a, range.b, context);
+                }
             }
 
             // if too many bad pivot choices were made, simply fall back to heapsort in order to
@@ -115,12 +119,13 @@ pub fn pdqContext(a: usize, b: usize, context: anytype) void {
             const balanced_threshold = len / 8;
             if (left_len < right_len) {
                 was_balanced = left_len >= balanced_threshold;
-                stack[top] = .{ .a = range.a, .b = mid, .limit = range.limit };
+                stack[top] = .{ .a = range.a, .b = mid, .limit = range.limit, .leftmost = range.leftmost };
                 top += 1;
                 range.a = mid + 1;
+                range.leftmost = false;
             } else {
                 was_balanced = right_len >= balanced_threshold;
-                stack[top] = .{ .a = mid + 1, .b = range.b, .limit = range.limit };
+                stack[top] = .{ .a = mid + 1, .b = range.b, .limit = range.limit, .leftmost = false };
                 top += 1;
                 range.b = mid;
             }
@@ -131,6 +136,18 @@ pub fn pdqContext(a: usize, b: usize, context: anytype) void {
     }
 }
 
+/// Insertion sort that assumes `items[a-1]` exists and is <= all elements in `[a, b)`,
+/// allowing the inner loop to skip the bounds check.
+fn unguardedInsertionContext(a: usize, b: usize, context: anytype) void {
+    var i = a + 1;
+    while (i < b) : (i += 1) {
+        var j = i;
+        while (context.lessThan(j, j - 1)) : (j -= 1) {
+            context.swap(j, j - 1);
+        }
+    }
+}
+
 /// partitions `items[a..b]` into elements smaller than `items[pivot]`,
 /// followed by elements greater than or equal to `items[pivot]`.
 ///

package/std/zon/parse.zig

@@ -1094,6 +1094,7 @@ const Parser = struct {
         name: []const u8,
     ) error{ OutOfMemory, ParseZon } {
         @branchHint(.cold);
+        if (self.diag == null) return error.ParseZon;
         const gpa = self.gpa;
         const token = if (field) |f| b: {
             var buf: [2]Ast.Node.Index = undefined;
@@ -1150,6 +1151,7 @@ const Parser = struct {
         field: usize,
     ) error{ OutOfMemory, ParseZon } {
         @branchHint(.cold);
+        if (self.diag == null) return error.ParseZon;
         const ast_node = node.getAstNode(self.zoir);
         var buf: [2]Ast.Node.Index = undefined;
         const token = if (self.ast.fullStructInit(&buf, ast_node)) |struct_init| b: {
@@ -3540,3 +3542,26 @@ test "std.zon no alloc" {
         try fromZoirNode(Nested, ast, zoir, .root, null, .{}),
     );
 }
+
+test "std.zon errors without diagnostics" {
+    const gpa = std.testing.allocator;
+
+    const Enum = enum {
+        foo,
+        bar,
+        baz,
+    };
+    try std.testing.expectError(error.ParseZon, fromSliceAlloc(Enum, gpa, ".nothing", null, .{}));
+
+    const Struct = struct {
+        name: []const u8,
+    };
+    try std.testing.expectError(error.ParseZon, fromSliceAlloc(Struct, gpa, ".{ .name = \"Alice\", .age = 25 }", null, .{}));
+
+    const Union = union(enum) {
+        x,
+        y: u32,
+    };
+    try std.testing.expectError(error.ParseZon, fromSliceAlloc(Union, gpa, ".a", null, .{}));
+    try std.testing.expectError(error.ParseZon, fromSliceAlloc(Union, gpa, ".{ .b = 8 }", null, .{}));
+}