@zigc/lib 0.17.0-dev.44 → 0.17.0-dev.607

package/c/fcntl.zig

@@ -12,6 +12,7 @@ comptime {
         symbol(&fallocateLinux, "fallocate");
         symbol(&posix_fadviseLinux, "posix_fadvise");
         symbol(&posix_fallocateLinux, "posix_fallocate");
+        symbol(&teeLinux, "tee");
     }
 }
 
@@ -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,7 @@ 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 ld = math.long_double;
 
 const symbol = @import("../c.zig").symbol;
 
@@ -39,7 +36,9 @@ comptime {
         symbol(&frexpl, "frexpl");
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
+        symbol(&lrintl, "lrintl");
         symbol(&modfl, "modfl");
+        symbol(&rintl, "rintl");
     }
 
     if ((builtin.target.isMinGW() and @sizeOf(f64) != @sizeOf(c_longdouble)) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -116,13 +115,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),
     };
 }
 
@@ -143,7 +138,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 {
@@ -183,15 +181,18 @@ fn fdimf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn fdiml(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return fdimGeneric(c_longdouble, x, y);
+    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 {
@@ -222,7 +223,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 {
@@ -234,27 +238,34 @@ 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 {
-    return @intFromFloat(rint(x));
+    return @trunc(rint(x));
 }
 
 fn lrintf(x: f32) callconv(.c) c_long {
-    return @intFromFloat(rintf(x));
+    return @trunc(rintf(x));
+}
+
+fn lrintl(x: c_longdouble) callconv(.c) c_long {
+    return @trunc(rintl(x));
 }
 
 fn modfGeneric(comptime T: type, x: T, iptr: *T) T {
@@ -290,60 +301,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 {
@@ -410,47 +371,26 @@ 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));
+fn rintl(x: c_longdouble) callconv(.c) c_longdouble {
+    if (@typeInfo(c_longdouble).float.bits == 64)
+        return rint(x);
 
-    // Small positive numbers round to zero
-    const pos_result = f(0.3);
-    try expect(math.isPositiveZero(pos_result));
+    const toint: c_longdouble = 1 << math.floatFractionalBits(c_longdouble);
+    const se = ld.signExponent(x);
 
-    // Small negative numbers round to negative zero
-    const neg_result = f(-0.3);
-    try expect(math.isNegativeZero(neg_result));
+    if (se & 0x7fff >= 0x3fff + math.floatFractionalBits(c_longdouble))
+        return x;
 
-    // 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));
-}
+    var y: c_longdouble = undefined;
+    if ((se >> 15) == 1) {
+        y = x - toint + toint;
+    } else {
+        y = x + toint - toint;
+    }
 
-test "rint" {
-    try testRint(f32);
-    try testRint(f64);
+    if (y == 0)
+        return 0 * x;
+    return y;
 }
 
 fn tanh(x: f64) callconv(.c) f64 {

package/c/pthread.zig

@@ -0,0 +1,57 @@
+const builtin = @import("builtin");
+
+const std = @import("std");
+const c = std.c;
+
+const symbol = @import("../c.zig").symbol;
+
+comptime {
+    if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC() or builtin.target.isMinGW()) {
+        symbol(&pthread_spin_init, "pthread_spin_init");
+        symbol(&pthread_spin_destroy, "pthread_spin_destroy");
+        symbol(&pthread_spin_trylock, "pthread_spin_trylock");
+        symbol(&pthread_spin_lock, "pthread_spin_lock");
+        symbol(&pthread_spin_unlock, "pthread_spin_unlock");
+    }
+}
+
+const SpinLock = enum(c.pthread_spinlock_t) {
+    unlocked = if (builtin.target.isMinGW()) -1 else 0,
+    locked = if (builtin.target.isMinGW()) 0 else @intFromEnum(c.E.BUSY),
+};
+
+fn pthread_spin_init(s: *c.pthread_spinlock_t, pshared: c_int) callconv(.c) c_int {
+    _ = pshared;
+    const spin: *SpinLock = @ptrCast(s);
+    spin.* = .unlocked;
+    return 0;
+}
+
+fn pthread_spin_destroy(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+    spin.* = undefined;
+    return 0;
+}
+
+fn pthread_spin_trylock(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+    return if (@cmpxchgStrong(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| @intFromEnum(c.E.BUSY) else 0;
+}
+
+fn pthread_spin_lock(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+    if (builtin.single_threaded and @atomicLoad(SpinLock, spin, .monotonic) == .locked) return @intFromEnum(c.E.DEADLK);
+
+    while (@cmpxchgWeak(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| {
+        std.atomic.spinLoopHint();
+    }
+    return 0;
+}
+
+fn pthread_spin_unlock(s: *c.pthread_spinlock_t) callconv(.c) c_int {
+    const spin: *SpinLock = @ptrCast(s);
+
+    // "The results are undefined if the lock is not held by the calling thread"
+    std.debug.assert(@atomicRmw(SpinLock, spin, .Xchg, .unlocked, .release) == .locked);
+    return 0;
+}

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

@@ -158,29 +158,40 @@ fn stringToInteger(comptime T: type, noalias buf: [*:0]const u8, noalias maybe_e
     };
 
     // The prefix is allowed iff base == 0 or base == base of the prefix
-    const real_base: u6 = if (current[0] == '0') blk: {
-        current += 1;
-
-        if ((base == 0 or base == 16) and std.ascii.toLower(current[0]) == 'x' and std.ascii.isHex(current[1])) {
-            current += 1;
-            break :blk 16;
-        }
+    const real_base: u6, const digits = blk: {
+        if (current[0] == '0') {
+            if ((base == 0 or base == 16) and std.ascii.toLower(current[1]) == 'x' and std.ascii.isHex(current[2])) {
+                break :blk .{ 16, current[2..] };
+            } else if (base == 0) {
+                break :blk .{ 8, current };
+            } else {
+                break :blk .{
+                    switch (base) {
+                        0 => 10,
+                        else => @intCast(base),
+                    },
+                    current,
+                };
+            }
+        } else {
+            const real_base: u6 = switch (base) {
+                0 => 10,
+                else => @intCast(base),
+            };
 
-        if ((base == 0 or base == 8) and std.ascii.isDigit(current[0])) {
-            break :blk 8;
+            _ = std.fmt.charToDigit(current[0], real_base) catch {
+                // No digits to parse. Setting errno to .INVAL is optional in this case.
+                if (maybe_end) |end| {
+                    end.* = buf;
+                }
+                return 0;
+            };
+            break :blk .{ real_base, current };
         }
-
-        break :blk switch (base) {
-            0 => 10,
-            else => @intCast(base),
-        };
-    } else switch (base) {
-        0 => 10,
-        else => @intCast(base),
     };
 
     if (@typeInfo(T).int.signedness == .unsigned) {
-        const result = parseDigitsWithSignGenericCharacter(T, u8, current, maybe_end, real_base, .pos) catch {
+        const result = parseDigitsWithSignGenericCharacter(T, u8, digits, maybe_end, real_base, .pos) catch {
             std.c._errno().* = @intFromEnum(std.c.E.RANGE);
             return std.math.maxInt(T);
         };
@@ -188,12 +199,12 @@ fn stringToInteger(comptime T: type, noalias buf: [*:0]const u8, noalias maybe_e
         return if (negative) -%result else result;
     }
 
-    if (negative) return parseDigitsWithSignGenericCharacter(T, u8, current, maybe_end, real_base, .neg) catch blk: {
+    if (negative) return parseDigitsWithSignGenericCharacter(T, u8, digits, maybe_end, real_base, .neg) catch blk: {
         std.c._errno().* = @intFromEnum(std.c.E.RANGE);
         break :blk std.math.minInt(T);
     };
 
-    return parseDigitsWithSignGenericCharacter(T, u8, current, maybe_end, real_base, .pos) catch blk: {
+    return parseDigitsWithSignGenericCharacter(T, u8, digits, maybe_end, real_base, .pos) catch blk: {
         std.c._errno().* = @intFromEnum(std.c.E.RANGE);
         break :blk std.math.maxInt(T);
     };
@@ -222,7 +233,6 @@ fn parseDigitsWithSignGenericCharacter(
     var value: T = 0;
     while (true) {
         const c: u8 = std.math.cast(u8, current[0]) orelse break;
-        if (!std.ascii.isAlphanumeric(c)) break;
 
         const digit: u6 = @intCast(std.fmt.charToDigit(c, base) catch break);
         defer current += 1;
@@ -294,103 +304,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

@@ -1,6 +1,7 @@
 const builtin = @import("builtin");
 const std = @import("std");
 const symbol = @import("../c.zig").symbol;
+const c = std.c;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -24,6 +25,8 @@ comptime {
         symbol(&strpbrk, "strpbrk");
         symbol(&strstr, "strstr");
         symbol(&strtok, "strtok");
+        symbol(&strdup, "strdup");
+        symbol(&strndup, "strndup");
         // strlen is in compiler_rt
 
         symbol(&strtok_r, "strtok_r");
@@ -164,6 +167,23 @@ fn strtok(noalias maybe_str: ?[*:0]c_char, noalias values: [*:0]const c_char) ca
     return strtok_r(maybe_str, values, &state.str);
 }
 
+fn strdup(str: [*:0]const c_char) callconv(.c) ?[*:0]c_char {
+    const len = std.mem.len(str);
+    const d_opaque = c.malloc(len + 1) orelse return null;
+    const d: [*]c_char = @ptrCast(d_opaque);
+    @memcpy(d[0 .. len + 1], str[0 .. len + 1]);
+    return @ptrCast(d);
+}
+
+fn strndup(str: [*:0]const c_char, n: usize) callconv(.c) ?[*:0]c_char {
+    const len = strnlen(str, n);
+    const d_opaque = c.malloc(len + 1) orelse return null;
+    const d: [*]c_char = @ptrCast(d_opaque);
+    @memcpy(d[0..len], str[0..len]);
+    d[len] = 0;
+    return @ptrCast(d);
+}
+
 // strlen is in compiler_rt
 
 fn strtok_r(noalias maybe_str: ?[*:0]c_char, noalias values: [*:0]const c_char, noalias state: *?[*:0]c_char) callconv(.c) ?[*:0]c_char {
@@ -290,10 +310,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);
-}