@zigc/lib 0.17.0-dev.9 → 0.17.0-dev.93

package/c/fcntl.zig

@@ -12,11 +12,12 @@ comptime {
         symbol(&fallocateLinux, "fallocate");
         symbol(&posix_fadviseLinux, "posix_fadvise");
         symbol(&posix_fallocateLinux, "posix_fallocate");
+        symbol(&teeLinux, "tee");
     }
 }
 
 fn fallocateLinux(fd: c_int, mode: c_int, offset: off_t, len: off_t) callconv(.c) c_int {
-    return errno(linux.fallocate(fd, mode, offset, len));
+    return errno(linux.fallocate(fd, @bitCast(mode), offset, len));
 }
 
 fn posix_fadviseLinux(fd: c_int, offset: off_t, len: off_t, advice: c_int) callconv(.c) c_int {
@@ -26,3 +27,7 @@ fn posix_fadviseLinux(fd: c_int, offset: off_t, len: off_t, advice: c_int) callc
 fn posix_fallocateLinux(fd: c_int, offset: off_t, len: off_t) callconv(.c) c_int {
     return errno(linux.fallocate(fd, 0, offset, len));
 }
+
+fn teeLinux(src: c_int, dest: c_int, len: usize, flags: c_uint) callconv(.c) isize {
+    return errno(linux.tee(src, dest, len, flags));
+}

package/c/inttypes.zig

@@ -24,13 +24,3 @@ fn imaxdiv(a: intmax_t, b: intmax_t) callconv(.c) imaxdiv_t {
         .rem = @rem(a, b),
     };
 }
-
-test imaxabs {
-    const val: intmax_t = -10;
-    try std.testing.expectEqual(10, imaxabs(val));
-}
-
-test imaxdiv {
-    const expected: imaxdiv_t = .{ .quot = 9, .rem = 0 };
-    try std.testing.expectEqual(expected, imaxdiv(9, 1));
-}

package/c/math.zig

@@ -2,10 +2,6 @@ const builtin = @import("builtin");
 
 const std = @import("std");
 const math = std.math;
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-const expectApproxEqAbs = std.testing.expectApproxEqAbs;
-const expectApproxEqRel = std.testing.expectApproxEqRel;
 
 const symbol = @import("../c.zig").symbol;
 
@@ -45,6 +41,7 @@ comptime {
     if ((builtin.target.isMinGW() and @sizeOf(f64) != @sizeOf(c_longdouble)) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&atanl, "atanl");
         symbol(&copysignl, "copysignl");
+        symbol(&fdiml, "fdiml");
         symbol(&nanl, "nanl");
     }
 
@@ -67,6 +64,7 @@ comptime {
         symbol(&exp10, "exp10");
         symbol(&exp10f, "exp10f");
         symbol(&fdim, "fdim");
+        symbol(&fdimf, "fdimf");
         symbol(&finite, "finite");
         symbol(&finitef, "finitef");
         symbol(&frexp, "frexp");
@@ -114,13 +112,9 @@ fn atanf(x: f32) callconv(.c) f32 {
 }
 
 fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
-    return switch (@typeInfo(@TypeOf(x)).float.bits) {
-        16 => math.atan(@as(f16, @floatCast(x))),
-        32 => math.atan(@as(f32, @floatCast(x))),
-        64 => math.atan(@as(f64, @floatCast(x))),
-        80 => math.atan(@as(f80, @floatCast(x))),
-        128 => math.atan(@as(f128, @floatCast(x))),
-        else => unreachable,
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.atan(x),
+        else => math.atan(x),
     };
 }
 
@@ -141,7 +135,10 @@ fn copysignf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return math.copysign(x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.copysign(x, y),
+        else => math.copysign(x, y),
+    };
 }
 
 fn cosh(x: f64) callconv(.c) f64 {
@@ -160,25 +157,39 @@ fn exp10f(x: f32) callconv(.c) f32 {
     return math.pow(f32, 10.0, x);
 }
 
-fn fdim(x: f64, y: f64) callconv(.c) f64 {
-    if (math.isNan(x)) {
+fn fdimGeneric(comptime T: type, x: T, y: T) T {
+    if (math.isNan(x))
         return x;
-    }
-    if (math.isNan(y)) {
+
+    if (math.isNan(y))
         return y;
-    }
-    if (x > y) {
+
+    if (x > y)
         return x - y;
-    }
     return 0;
 }
 
+fn fdim(x: f64, y: f64) callconv(.c) f64 {
+    return fdimGeneric(f64, x, y);
+}
+
+fn fdimf(x: f32, y: f32) callconv(.c) f32 {
+    return fdimGeneric(f32, x, y);
+}
+
+fn fdiml(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.fdim(x, y),
+        else => fdimGeneric(c_longdouble, x, y),
+    };
+}
+
 fn finite(x: f64) callconv(.c) c_int {
-    return if (math.isFinite(x)) 1 else 0;
+    return @intFromBool(math.isFinite(x));
 }
 
 fn finitef(x: f32) callconv(.c) c_int {
-    return if (math.isFinite(x)) 1 else 0;
+    return @intFromBool(math.isFinite(x));
 }
 
 fn frexpGeneric(comptime T: type, x: T, e: *c_int) T {
@@ -209,7 +220,10 @@ fn frexpf(x: f32, e: *c_int) callconv(.c) f32 {
 }
 
 fn frexpl(x: c_longdouble, e: *c_int) callconv(.c) c_longdouble {
-    return frexpGeneric(c_longdouble, x, e);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.frexp(x, e),
+        else => frexpGeneric(c_longdouble, x, e),
+    };
 }
 
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
@@ -221,19 +235,22 @@ fn hypotf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn hypotl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return math.hypot(x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.hypot(x, y),
+        else => math.hypot(x, y),
+    };
 }
 
 fn isnan(x: f64) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn isnanf(x: f32) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn isnanl(x: c_longdouble) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn lrint(x: f64) callconv(.c) c_long {
@@ -277,60 +294,10 @@ fn modff(x: f32, iptr: *f32) callconv(.c) f32 {
 }
 
 fn modfl(x: c_longdouble, iptr: *c_longdouble) callconv(.c) c_longdouble {
-    return modfGeneric(c_longdouble, x, iptr);
-}
-
-fn testModf(comptime T: type) !void {
-    // Choose the appropriate `modf` impl to test based on type
-    const f = switch (T) {
-        f32 => modff,
-        f64 => modf,
-        c_longdouble => modfl,
-        else => @compileError("modf not implemented for " ++ @typeName(T)),
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.modf(x, iptr),
+        else => modfGeneric(c_longdouble, x, iptr),
     };
-
-    var int: T = undefined;
-    const iptr = ∫
-    const eps_val: comptime_float = @max(1e-6, math.floatEps(T));
-
-    const normal_frac = f(@as(T, 1234.567), iptr);
-    // Account for precision error
-    const expected = 1234.567 - @as(T, 1234);
-    try expectApproxEqAbs(expected, normal_frac, eps_val);
-    try expectApproxEqRel(@as(T, 1234.0), iptr.*, eps_val);
-
-    // When `x` is a NaN, NaN is returned and `*iptr` is set to NaN
-    const nan_frac = f(math.nan(T), iptr);
-    try expect(math.isNan(nan_frac));
-    try expect(math.isNan(iptr.*));
-
-    // When `x` is positive infinity, +0 is returned and `*iptr` is set to
-    // positive infinity
-    const pos_zero_frac = f(math.inf(T), iptr);
-    try expect(math.isPositiveZero(pos_zero_frac));
-    try expect(math.isPositiveInf(iptr.*));
-
-    // When `x` is negative infinity, -0 is returned and `*iptr` is set to
-    // negative infinity
-    const neg_zero_frac = f(-math.inf(T), iptr);
-    try expect(math.isNegativeZero(neg_zero_frac));
-    try expect(math.isNegativeInf(iptr.*));
-
-    // Return -0 when `x` is a negative integer
-    const nz_frac = f(@as(T, -1000.0), iptr);
-    try expect(math.isNegativeZero(nz_frac));
-    try expectEqual(@as(T, -1000.0), iptr.*);
-
-    // Return +0 when `x` is a positive integer
-    const pz_frac = f(@as(T, 1000.0), iptr);
-    try expect(math.isPositiveZero(pz_frac));
-    try expectEqual(@as(T, 1000.0), iptr.*);
-}
-
-test "modf" {
-    try testModf(f32);
-    try testModf(f64);
-    try testModf(c_longdouble);
 }
 
 fn nan(_: [*:0]const c_char) callconv(.c) f64 {
@@ -397,49 +364,6 @@ fn rintf(x: f32) callconv(.c) f32 {
     return y;
 }
 
-fn testRint(comptime T: type) !void {
-    const f = switch (T) {
-        f32 => rintf,
-        f64 => rint,
-        else => @compileError("rint not implemented for" ++ @typeName(T)),
-    };
-
-    // Positive numbers round correctly
-    try expectEqual(@as(T, 42.0), f(42.2));
-    try expectEqual(@as(T, 42.0), f(41.8));
-
-    // Negative numbers round correctly
-    try expectEqual(@as(T, -6.0), f(-5.9));
-    try expectEqual(@as(T, -6.0), f(-6.1));
-
-    // No rounding needed test
-    try expectEqual(@as(T, 5.0), f(5.0));
-    try expectEqual(@as(T, -10.0), f(-10.0));
-    try expectEqual(@as(T, 0.0), f(0.0));
-
-    // Very large numbers return unchanged
-    const large: T = 9007199254740992.0; // 2^53
-    try expectEqual(large, f(large));
-    try expectEqual(-large, f(-large));
-
-    // Small positive numbers round to zero
-    const pos_result = f(0.3);
-    try expect(math.isPositiveZero(pos_result));
-
-    // Small negative numbers round to negative zero
-    const neg_result = f(-0.3);
-    try expect(math.isNegativeZero(neg_result));
-
-    // Exact half rounds to nearest even (banker's rounding)
-    try expectEqual(@as(T, 2.0), f(2.5));
-    try expectEqual(@as(T, 4.0), f(3.5));
-}
-
-test "rint" {
-    try testRint(f32);
-    try testRint(f64);
-}
-
 fn tanh(x: f64) callconv(.c) f64 {
     return math.tanh(x);
 }

package/c/search.zig

@@ -9,6 +9,7 @@ comptime {
     }
 }
 
+/// Not defined in `std.c` because C headers don't either.
 const Node = extern struct {
     next: ?*Node,
     prev: ?*Node,
@@ -38,30 +39,3 @@ fn remque(element: *anyopaque) callconv(.c) void {
     if (e.next) |next| next.prev = e.prev;
     if (e.prev) |prev| prev.next = e.next;
 }
-
-test "insque and remque" {
-    var first = Node{ .next = null, .prev = null };
-    var second = Node{ .next = null, .prev = null };
-    var third = Node{ .next = null, .prev = null };
-
-    insque(&first, null);
-    try std.testing.expectEqual(@as(?*Node, null), first.next);
-    try std.testing.expectEqual(@as(?*Node, null), first.prev);
-
-    insque(&second, &first);
-    try std.testing.expectEqual(@as(?*Node, &second), first.next);
-    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
-
-    insque(&third, &first);
-    try std.testing.expectEqual(@as(?*Node, &third), first.next);
-    try std.testing.expectEqual(@as(?*Node, &second), third.next);
-    try std.testing.expectEqual(@as(?*Node, &first), third.prev);
-    try std.testing.expectEqual(@as(?*Node, &third), second.prev);
-
-    remque(&third);
-    try std.testing.expectEqual(@as(?*Node, &second), first.next);
-    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
-
-    remque(&second);
-    try std.testing.expectEqual(@as(?*Node, null), first.next);
-}

package/c/stdlib/drand48.zig

@@ -90,60 +90,3 @@ fn srand48(seedval: c_long) callconv(.c) void {
     const xi = (@as(u32, @truncate(@as(c_ulong, @bitCast(seedval)))) << 16) | 0x330E;
     lcg = .init(xi, default_multiplier, default_addend);
 }
-
-test erand48 {
-    var xsubi: [3]c_ushort = .{ 37174, 64810, 11603 };
-
-    try std.testing.expectApproxEqAbs(0.8965, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 22537, 47966, 58735 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.3375, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 37344, 32911, 22119 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.6475, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 23659, 29872, 42445 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.5005, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 31642, 7875, 32802 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.5065, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 64669, 14399, 33170 }, &xsubi);
-}
-
-test jrand48 {
-    var xsubi: [3]c_ushort = .{ 25175, 11052, 45015 };
-
-    try std.testing.expectEqual(1699503220, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 2326, 23668, 25932 }, &xsubi);
-
-    try std.testing.expectEqual(-992276007, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 41577, 4569, 50395 }, &xsubi);
-
-    try std.testing.expectEqual(-19535776, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 31936, 59488, 65237 }, &xsubi);
-
-    try std.testing.expectEqual(79438377, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 40395, 8745, 1212 }, &xsubi);
-
-    try std.testing.expectEqual(-1258917728, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 37242, 28832, 46326 }, &xsubi);
-}
-
-test nrand48 {
-    var xsubi: [3]c_ushort = .{ 546, 33817, 23389 };
-
-    try std.testing.expectEqual(914920692, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 29829, 10728, 27921 }, &xsubi);
-
-    try std.testing.expectEqual(754104482, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 6828, 28997, 23013 }, &xsubi);
-
-    try std.testing.expectEqual(609453945, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 58183, 3826, 18599 }, &xsubi);
-
-    try std.testing.expectEqual(1878644360, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 36678, 44304, 57331 }, &xsubi);
-
-    try std.testing.expectEqual(2114923686, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 58585, 22861, 64542 }, &xsubi);
-}

package/c/stdlib.zig

@@ -294,103 +294,3 @@ fn bsearch(key: *const anyopaque, base: *const anyopaque, n: usize, size: usize,
     }
     return null;
 }
-
-test abs {
-    const val: c_int = -10;
-    try std.testing.expectEqual(10, abs(val));
-}
-
-test labs {
-    const val: c_long = -10;
-    try std.testing.expectEqual(10, labs(val));
-}
-
-test llabs {
-    const val: c_longlong = -10;
-    try std.testing.expectEqual(10, llabs(val));
-}
-
-test div {
-    const expected: div_t = .{ .quot = 5, .rem = 5 };
-    try std.testing.expectEqual(expected, div(55, 10));
-}
-
-test ldiv {
-    const expected: ldiv_t = .{ .quot = -6, .rem = 2 };
-    try std.testing.expectEqual(expected, ldiv(38, -6));
-}
-
-test lldiv {
-    const expected: lldiv_t = .{ .quot = 1, .rem = 2 };
-    try std.testing.expectEqual(expected, lldiv(5, 3));
-}
-
-test atoi {
-    try std.testing.expectEqual(0, atoi(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atoi(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atoi(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atoi(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atoi(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atoi(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atoi(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atoi(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atoi(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atoi(@ptrCast("+32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_int), atoi(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_int)}))));
-    try std.testing.expectEqual(std.math.minInt(c_int), atoi(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_int)}))));
-}
-
-test atol {
-    try std.testing.expectEqual(0, atol(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atol(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atol(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atol(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atol(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atol(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atol(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atol(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atol(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atol(@ptrCast("+32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_long), atol(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_long)}))));
-    try std.testing.expectEqual(std.math.minInt(c_long), atol(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_long)}))));
-}
-
-test atoll {
-    try std.testing.expectEqual(0, atoll(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atoll(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atoll(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atoll(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atoll(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atoll(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atoll(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atoll(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atoll(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atoll(@ptrCast("   +32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_longlong), atoll(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_longlong)}))));
-    try std.testing.expectEqual(std.math.minInt(c_longlong), atoll(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_longlong)}))));
-}
-
-// FIXME: We cannot test strtol, strtoll, strtoul, etc.. here as it must modify errno and libc is not linked in tests
-
-test bsearch {
-    const Comparison = struct {
-        pub fn compare(a: *const anyopaque, b: *const anyopaque) callconv(.c) c_int {
-            const a_u16: *const u16 = @ptrCast(@alignCast(a));
-            const b_u16: *const u16 = @ptrCast(@alignCast(b));
-
-            return switch (std.math.order(a_u16.*, b_u16.*)) {
-                .gt => 1,
-                .eq => 0,
-                .lt => -1,
-            };
-        }
-    };
-
-    const items: []const u16 = &.{ 0, 5, 7, 9, 10, 200, 512, 768 };
-
-    try std.testing.expectEqual(@as(?*anyopaque, null), bsearch(&@as(u16, 2000), items.ptr, items.len, @sizeOf(u16), Comparison.compare));
-
-    for (items) |*value| {
-        try std.testing.expectEqual(@as(*const anyopaque, value), bsearch(value, items.ptr, items.len, @sizeOf(u16), Comparison.compare));
-    }
-}

package/c/string.zig

@@ -290,10 +290,3 @@ fn mempcpy(noalias dst: *anyopaque, noalias src: *const anyopaque, len: usize) c
     @memcpy(dst_bytes[0..len], src_bytes[0..len]);
     return dst_bytes + len;
 }
-
-test strncmp {
-    try std.testing.expect(strncmp(@ptrCast("a"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncmp(@ptrCast("a"), @ptrCast("c"), 1) < 0);
-    try std.testing.expect(strncmp(@ptrCast("b"), @ptrCast("a"), 1) > 0);
-    try std.testing.expect(strncmp(@ptrCast("\xff"), @ptrCast("\x02"), 1) > 0);
-}

package/c/strings.zig

@@ -81,41 +81,3 @@ fn __strncasecmp_l(a: [*:0]const c_char, b: [*:0]const c_char, n: usize, locale:
     _ = locale;
     return strncasecmp(a, b, n);
 }
-
-test bzero {
-    var array: [10]u8 = [_]u8{ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
-    var a = std.mem.zeroes([array.len]u8);
-    a[9] = '0';
-    bzero(&array[0], 9);
-    try std.testing.expect(std.mem.eql(u8, &array, &a));
-}
-
-test firstBitSet {
-    try std.testing.expectEqual(0, firstBitSet(usize, 0));
-
-    for (0..@bitSizeOf(usize)) |i| {
-        const bit = @as(usize, 1) << @intCast(i);
-
-        try std.testing.expectEqual(i + 1, firstBitSet(usize, bit));
-    }
-}
-
-test strcasecmp {
-    try std.testing.expect(strcasecmp(@ptrCast("a"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("a")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("A")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("A")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("B"), @ptrCast("b")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("bb"), @ptrCast("AA")) > 0);
-}
-
-test strncasecmp {
-    try std.testing.expect(strncasecmp(@ptrCast("a"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("a"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("A"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("A"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("B"), @ptrCast("b"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("bb"), @ptrCast("AA"), 2) > 0);
-}

package/c/unistd.zig

@@ -21,6 +21,8 @@ comptime {
         symbol(&chrootLinux, "chroot");
         symbol(&ctermidLinux, "ctermid");
         symbol(&dupLinux, "dup");
+        symbol(&dup2Linux, "dup2");
+        symbol(&dup3Linux, "dup3");
 
         symbol(&getegidLinux, "getegid");
         symbol(&geteuidLinux, "geteuid");
@@ -101,6 +103,31 @@ fn dupLinux(fd: c_int) callconv(.c) c_int {
     return errno(linux.dup(fd));
 }
 
+fn dup2Linux(old: c_int, new: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+    while (res == busy) res = linux.dup2(old, new);
+    return errno(res);
+}
+
+fn dup3Linux(old: c_int, new: c_int, flags: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+
+    if (@hasField(linux.SYS, "dup3")) {
+        while (res == busy) res = linux.dup3(old, new, @intCast(flags));
+    } else if (@hasField(linux.SYS, "dup2")) {
+        const cloexec: c_int = @bitCast(linux.O{ .CLOEXEC = true });
+        const inval: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.INVAL)));
+        if (old == new or (flags & ~cloexec != 0)) return errno(inval);
+        while (res == busy) res = linux.dup2(old, new);
+        _ = if (res >= 0 and (flags & cloexec == cloexec)) linux.fcntl(new, linux.F.SETFD, linux.FD_CLOEXEC);
+    } else {
+        return errno(@bitCast(-@as(isize, @intFromEnum(linux.E.NOSYS))));
+    }
+    return errno(res);
+}
+
 fn getegidLinux() callconv(.c) linux.gid_t {
     return linux.getegid();
 }
@@ -206,32 +233,6 @@ fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isiz
     }
 }
 
-test swab {
-    var a: [4]u8 = undefined;
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 4);
-    try std.testing.expectEqualSlices(u8, "badc", &a);
-
-    // Partial copy
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 2);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-
-    // n < 1
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 0);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, -1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-
-    // Odd n
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, 3);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-}
-
 fn close(fd: std.c.fd_t) callconv(.c) c_int {
     const signed: isize = @bitCast(linux.close(fd));
     if (signed < 0) {

package/c.zig

@@ -2,8 +2,7 @@
 //! bundled libcs.
 //!
 //! mingw-w64 libc is not fully statically linked, so some symbols don't need
-//! to be exported. However, a future enhancement could be eliminating Zig's
-//! dependency on msvcrt dll even when linking libc and targeting Windows.
+//! to be exported.
 
 const builtin = @import("builtin");
 const std = @import("std");

package/compiler/aro/aro/CodeGen.zig

@@ -54,8 +54,9 @@ return_label: Ir.Ref = undefined,
 compound_assign_dummy: ?Ir.Ref = null,
 
 fn fail(c: *CodeGen, comptime fmt: []const u8, args: anytype) error{ FatalError, OutOfMemory } {
-    var sf = std.heap.stackFallback(1024, c.comp.gpa);
-    const allocator = sf.get();
+    var bfa_buf: [u8]1024 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, c.comp.gpa);
+    const allocator = bfa.allocator();
     var buf: std.ArrayList(u8) = .empty;
     defer buf.deinit(allocator);