@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

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);
-}

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/stropts.zig

@@ -0,0 +1,17 @@
+const builtin = @import("builtin");
+
+const std = @import("std");
+const linux = std.os.linux;
+
+const symbol = @import("../c.zig").symbol;
+const errno = @import("../c.zig").errno;
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        symbol(&isastream, "isastream");
+    }
+}
+
+fn isastream(fd: c_int) callconv(.c) c_int {
+    return if (errno(linux.fcntl(fd, linux.F.GETFD, 0)) < 0) -1 else 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/wchar.zig

@@ -5,6 +5,7 @@ const wint_t = std.c.wint_t;
 const wchar_t = std.c.wchar_t;
 
 const symbol = @import("../c.zig").symbol;
+const c = std.c;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -30,6 +31,7 @@ comptime {
         symbol(&wcspbrk, "wcspbrk");
         symbol(&wcstok, "wcstok");
         symbol(&wcsstr, "wcsstr");
+        symbol(&wcsdup, "wcsdup");
         symbol(&wcswcs, "wcswcs");
     }
 
@@ -189,3 +191,11 @@ fn wcsstr(noalias haystack: [*:0]const wchar_t, noalias needle: [*:0]const wchar
 fn wcswcs(noalias haystack: [*:0]const wchar_t, noalias needle: [*:0]const wchar_t) callconv(.c) ?[*:0]wchar_t {
     return wcsstr(haystack, needle);
 }
+
+fn wcsdup(str: [*:0]const wchar_t) callconv(.c) ?[*:0]wchar_t {
+    const len = wcslen(str);
+    const size = (len + 1) * @sizeOf(wchar_t);
+    const d_opaque = c.malloc(size) orelse return null;
+    const d: [*]wchar_t = @ptrCast(@alignCast(d_opaque));
+    return @ptrCast(wmemcpy(d, str, len + 1));
+}

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");
@@ -69,10 +68,12 @@ comptime {
         _ = @import("c/malloc.zig");
     }
     _ = @import("c/math.zig");
+    _ = @import("c/pthread.zig");
     _ = @import("c/search.zig");
     _ = @import("c/stdlib.zig");
     _ = @import("c/string.zig");
     _ = @import("c/strings.zig");
+    _ = @import("c/stropts.zig");
 
     _ = @import("c/sys/capability.zig");
     _ = @import("c/sys/file.zig");