zig/lib/std / c.zig

const std = @import("std");
const builtin = @import("builtin");
const c = @This();
const maxInt = std.math.maxInt;
const assert = std.debug.assert;
const page_size = std.heap.page_size_min;
const native_abi = builtin.abi;
const native_arch = builtin.cpu.arch;
const native_os = builtin.os.tag;
const linux = std.os.linux;
const emscripten = std.os.emscripten;
const wasi = std.os.wasi;
const windows = std.os.windows;
const ws2_32 = std.os.windows.ws2_32;
const darwin = @import("c/darwin.zig");
const freebsd = @import("c/freebsd.zig");
const solaris = @import("c/solaris.zig");
const netbsd = @import("c/netbsd.zig");
const dragonfly = @import("c/dragonfly.zig");
const haiku = @import("c/haiku.zig");
const openbsd = @import("c/openbsd.zig");

// These constants are shared among all operating systems even when not linking
// libc.

pub const iovec = std.posix.iovec;
pub const iovec_const = std.posix.iovec_const;

pub const LOCK = std.posix.LOCK;

pub const winsize = std.posix.winsize;

/// The value of the link editor defined symbol _MH_EXECUTE_SYM is the address
/// of the mach header in a Mach-O executable file type.  It does not appear in
/// any file type other than a MH_EXECUTE file type.  The type of the symbol is
/// absolute as the header is not part of any section.
/// This symbol is populated when linking the system's libc, which is guaranteed
/// on this operating system. However when building object files or libraries,
/// the system libc won't be linked until the final executable. So we
/// export a weak symbol here, to be overridden by the real one.
pub extern var _mh_execute_header: mach_hdr;
var dummy_execute_header: mach_hdr = undefined;
comptime {
    if (native_os.isDarwin()) {
        @export(&dummy_execute_header, .{ .name = "_mh_execute_header", .linkage = .weak });
    }

}

/// * If not linking libc, returns `false`.
/// * If linking musl libc, returns `true`.
/// * If linking GNU libc (glibc), returns `true` if the target version is greater than or equal to
///   `version`.
/// * If linking Android libc (bionic), returns `true` if the target API level is greater than or
///   equal to `version.major`, ignoring other components.
/// * If linking a libc other than these, returns `false`.
pub inline fn versionCheck(comptime version: std.SemanticVersion) bool {
    return comptime blk: {
        if (!builtin.link_libc) break :blk false;
        if (native_abi.isMusl()) break :blk true;
        if (builtin.target.isGnuLibC()) {
            const ver = builtin.os.versionRange().gnuLibCVersion().?;
            break :blk switch (ver.order(version)) {
                .gt, .eq => true,
                .lt => false,
            };
        } else if (builtin.abi.isAndroid()) {
            break :blk builtin.os.version_range.linux.android >= version.major;
        } else {
            break :blk false;
        }
    };

}

pub const ino_t = switch (native_os) {
    .linux => linux.ino_t,
    .emscripten => emscripten.ino_t,
    .wasi => wasi.inode_t,
    .windows => windows.LARGE_INTEGER,
    .haiku => i64,
    else => u64,

};

pub const off_t = switch (native_os) {
    .linux => linux.off_t,
    .emscripten => emscripten.off_t,
    else => i64,

};

pub const timespec = switch (native_os) {
    .linux => linux.timespec,
    .emscripten => emscripten.timespec,
    .wasi => extern struct {
        sec: time_t,
        nsec: isize,

        pub fn fromTimestamp(tm: wasi.timestamp_t) timespec {
            const sec: wasi.timestamp_t = tm / 1_000_000_000;
            const nsec = tm - sec * 1_000_000_000;
            return .{
                .sec = @as(time_t, @intCast(sec)),
                .nsec = @as(isize, @intCast(nsec)),
            };
        }

        pub fn toTimestamp(ts: timespec) wasi.timestamp_t {
            return @as(wasi.timestamp_t, @intCast(ts.sec * 1_000_000_000)) +
                @as(wasi.timestamp_t, @intCast(ts.nsec));
        }
    },
    .windows => extern struct {
        sec: time_t,
        nsec: c_long,
    },
    .dragonfly, .freebsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
        sec: isize,
        nsec: isize,
    },
    .netbsd, .solaris, .illumos => extern struct {
        sec: i64,
        nsec: isize,
    },
    .openbsd, .haiku => extern struct {
        sec: time_t,
        nsec: isize,
    },
    else => void,

};

pub const dev_t = switch (native_os) {
    .linux => linux.dev_t,
    .emscripten => emscripten.dev_t,
    .wasi => wasi.device_t,
    .openbsd, .haiku, .solaris, .illumos, .macos, .ios, .tvos, .watchos, .visionos => i32,
    .netbsd, .freebsd => u64,
    else => void,

};

pub const mode_t = switch (native_os) {
    .linux => linux.mode_t,
    .emscripten => emscripten.mode_t,
    .openbsd, .haiku, .netbsd, .solaris, .illumos, .wasi, .windows => u32,
    .freebsd, .macos, .ios, .tvos, .watchos, .visionos, .dragonfly => u16,
    else => u0,

};

pub const nlink_t = switch (native_os) {
    .linux => linux.nlink_t,
    .emscripten => emscripten.nlink_t,
    .wasi => c_ulonglong,
    .freebsd => u64,
    .openbsd, .netbsd, .solaris, .illumos => u32,
    .haiku => i32,
    else => void,

};

pub const uid_t = switch (native_os) {
    .linux => linux.uid_t,
    .emscripten => emscripten.uid_t,
    else => u32,

};

pub const gid_t = switch (native_os) {
    .linux => linux.gid_t,
    .emscripten => emscripten.gid_t,
    else => u32,

};

pub const blksize_t = switch (native_os) {
    .linux => linux.blksize_t,
    .emscripten => emscripten.blksize_t,
    .wasi => c_long,
    else => i32,

};

pub const passwd = switch (native_os) {
    .linux => extern struct {
        name: ?[*:0]const u8, // username
        passwd: ?[*:0]const u8, // user password
        uid: uid_t, // user ID
        gid: gid_t, // group ID
        gecos: ?[*:0]const u8, // user information
        dir: ?[*:0]const u8, // home directory
        shell: ?[*:0]const u8, // shell program
    },
    .netbsd, .openbsd, .macos => extern struct {
        name: ?[*:0]const u8, // user name
        passwd: ?[*:0]const u8, // encrypted password
        uid: uid_t, // user uid
        gid: gid_t, // user gid
        change: time_t, // password change time
        class: ?[*:0]const u8, // user access class
        gecos: ?[*:0]const u8, // Honeywell login info
        dir: ?[*:0]const u8, // home directory
        shell: ?[*:0]const u8, // default shell
        expire: time_t, // account expiration
    },
    else => void,

};

pub const blkcnt_t = switch (native_os) {
    .linux => linux.blkcnt_t,
    .emscripten => emscripten.blkcnt_t,
    .wasi => c_longlong,
    else => i64,

};

pub const fd_t = switch (native_os) {
    .linux => linux.fd_t,
    .wasi => wasi.fd_t,
    .windows => windows.HANDLE,
    else => i32,

};

pub const ARCH = switch (native_os) {
    .linux => linux.ARCH,
    else => void,

};

// For use with posix.timerfd_create()
// Actually, the parameter for the timerfd_create() function is an integer,
// which means that the developer has to figure out which value is appropriate.
// To make this easier and, above all, safer, because an incorrect value leads
// to a panic, an enum is introduced which only allows the values
// that actually work.
pub const TIMERFD_CLOCK = timerfd_clockid_t;
pub const timerfd_clockid_t = switch (native_os) {
    .freebsd => enum(u32) {
        REALTIME = 0,
        MONOTONIC = 4,
        _,
    },
    .linux => linux.timerfd_clockid_t,
    else => clockid_t,

};

pub const CLOCK = clockid_t;
pub const clockid_t = switch (native_os) {
    .linux, .emscripten => linux.clockid_t,
    .wasi => wasi.clockid_t,
    .macos, .ios, .tvos, .watchos, .visionos => enum(u32) {
        REALTIME = 0,
        MONOTONIC = 6,
        MONOTONIC_RAW = 4,
        MONOTONIC_RAW_APPROX = 5,
        UPTIME_RAW = 8,
        UPTIME_RAW_APPROX = 9,
        PROCESS_CPUTIME_ID = 12,
        THREAD_CPUTIME_ID = 16,
        _,
    },
    .haiku => enum(i32) {
        /// system-wide monotonic clock (aka system time)
        MONOTONIC = 0,
        /// system-wide real time clock
        REALTIME = -1,
        /// clock measuring the used CPU time of the current process
        PROCESS_CPUTIME_ID = -2,
        /// clock measuring the used CPU time of the current thread
        THREAD_CPUTIME_ID = -3,
    },
    .freebsd => enum(u32) {
        REALTIME = 0,
        VIRTUAL = 1,
        PROF = 2,
        MONOTONIC = 4,
        UPTIME = 5,
        UPTIME_PRECISE = 7,
        UPTIME_FAST = 8,
        REALTIME_PRECISE = 9,
        REALTIME_FAST = 10,
        MONOTONIC_PRECISE = 11,
        MONOTONIC_FAST = 12,
        SECOND = 13,
        THREAD_CPUTIME_ID = 14,
        PROCESS_CPUTIME_ID = 15,
    },
    .solaris, .illumos => enum(u32) {
        VIRTUAL = 1,
        THREAD_CPUTIME_ID = 2,
        REALTIME = 3,
        MONOTONIC = 4,
        PROCESS_CPUTIME_ID = 5,
    },
    .netbsd => enum(u32) {
        REALTIME = 0,
        VIRTUAL = 1,
        PROF = 2,
        MONOTONIC = 3,
        THREAD_CPUTIME_ID = 0x20000000,
        PROCESS_CPUTIME_ID = 0x40000000,
    },
    .dragonfly => enum(u32) {
        REALTIME = 0,
        VIRTUAL = 1,
        PROF = 2,
        MONOTONIC = 4,
        UPTIME = 5,
        UPTIME_PRECISE = 7,
        UPTIME_FAST = 8,
        REALTIME_PRECISE = 9,
        REALTIME_FAST = 10,
        MONOTONIC_PRECISE = 11,
        MONOTONIC_FAST = 12,
        SECOND = 13,
        THREAD_CPUTIME_ID = 14,
        PROCESS_CPUTIME_ID = 15,
    },
    .openbsd => enum(u32) {
        REALTIME = 0,
        PROCESS_CPUTIME_ID = 2,
        MONOTONIC = 3,
        THREAD_CPUTIME_ID = 4,
    },
    else => void,

};
pub const CPU_COUNT = switch (native_os) {
    .linux => linux.CPU_COUNT,
    .emscripten => emscripten.CPU_COUNT,
    else => void,

};
pub const E = switch (native_os) {
    .linux => linux.E,
    .emscripten => emscripten.E,
    .wasi => wasi.errno_t,
    .windows => enum(u16) {
        /// No error occurred.
        SUCCESS = 0,
        PERM = 1,
        NOENT = 2,
        SRCH = 3,
        INTR = 4,
        IO = 5,
        NXIO = 6,
        @"2BIG" = 7,
        NOEXEC = 8,
        BADF = 9,
        CHILD = 10,
        AGAIN = 11,
        NOMEM = 12,
        ACCES = 13,
        FAULT = 14,
        BUSY = 16,
        EXIST = 17,
        XDEV = 18,
        NODEV = 19,
        NOTDIR = 20,
        ISDIR = 21,
        NFILE = 23,
        MFILE = 24,
        NOTTY = 25,
        FBIG = 27,
        NOSPC = 28,
        SPIPE = 29,
        ROFS = 30,
        MLINK = 31,
        PIPE = 32,
        DOM = 33,
        /// Also means `DEADLOCK`.
        DEADLK = 36,
        NAMETOOLONG = 38,
        NOLCK = 39,
        NOSYS = 40,
        NOTEMPTY = 41,

        INVAL = 22,
        RANGE = 34,
        ILSEQ = 42,

        // POSIX Supplement
        ADDRINUSE = 100,
        ADDRNOTAVAIL = 101,
        AFNOSUPPORT = 102,
        ALREADY = 103,
        BADMSG = 104,
        CANCELED = 105,
        CONNABORTED = 106,
        CONNREFUSED = 107,
        CONNRESET = 108,
        DESTADDRREQ = 109,
        HOSTUNREACH = 110,
        IDRM = 111,
        INPROGRESS = 112,
        ISCONN = 113,
        LOOP = 114,
        MSGSIZE = 115,
        NETDOWN = 116,
        NETRESET = 117,
        NETUNREACH = 118,
        NOBUFS = 119,
        NODATA = 120,
        NOLINK = 121,
        NOMSG = 122,
        NOPROTOOPT = 123,
        NOSR = 124,
        NOSTR = 125,
        NOTCONN = 126,
        NOTRECOVERABLE = 127,
        NOTSOCK = 128,
        NOTSUP = 129,
        OPNOTSUPP = 130,
        OTHER = 131,
        OVERFLOW = 132,
        OWNERDEAD = 133,
        PROTO = 134,
        PROTONOSUPPORT = 135,
        PROTOTYPE = 136,
        TIME = 137,
        TIMEDOUT = 138,
        TXTBSY = 139,
        WOULDBLOCK = 140,
        DQUOT = 10069,
        _,
    },
    .macos, .ios, .tvos, .watchos, .visionos => darwin.E,
    .freebsd => freebsd.E,
    .solaris, .illumos => enum(u16) {
        /// No error occurred.
        SUCCESS = 0,
        /// Not super-user
        PERM = 1,
        /// No such file or directory
        NOENT = 2,
        /// No such process
        SRCH = 3,
        /// interrupted system call
        INTR = 4,
        /// I/O error
        IO = 5,
        /// No such device or address
        NXIO = 6,
        /// Arg list too long
        @"2BIG" = 7,
        /// Exec format error
        NOEXEC = 8,
        /// Bad file number
        BADF = 9,
        /// No children
        CHILD = 10,
        /// Resource temporarily unavailable.
        /// also: WOULDBLOCK: Operation would block.
        AGAIN = 11,
        /// Not enough core
        NOMEM = 12,
        /// Permission denied
        ACCES = 13,
        /// Bad address
        FAULT = 14,
        /// Block device required
        NOTBLK = 15,
        /// Mount device busy
        BUSY = 16,
        /// File exists
        EXIST = 17,
        /// Cross-device link
        XDEV = 18,
        /// No such device
        NODEV = 19,
        /// Not a directory
        NOTDIR = 20,
        /// Is a directory
        ISDIR = 21,
        /// Invalid argument
        INVAL = 22,
        /// File table overflow
        NFILE = 23,
        /// Too many open files
        MFILE = 24,
        /// Inappropriate ioctl for device
        NOTTY = 25,
        /// Text file busy
        TXTBSY = 26,
        /// File too large
        FBIG = 27,
        /// No space left on device
        NOSPC = 28,
        /// Illegal seek
        SPIPE = 29,
        /// Read only file system
        ROFS = 30,
        /// Too many links
        MLINK = 31,
        /// Broken pipe
        PIPE = 32,
        /// Math arg out of domain of func
        DOM = 33,
        /// Math result not representable
        RANGE = 34,
        /// No message of desired type
        NOMSG = 35,
        /// Identifier removed
        IDRM = 36,
        /// Channel number out of range
        CHRNG = 37,
        /// Level 2 not synchronized
        L2NSYNC = 38,
        /// Level 3 halted
        L3HLT = 39,
        /// Level 3 reset
        L3RST = 40,
        /// Link number out of range
        LNRNG = 41,
        /// Protocol driver not attached
        UNATCH = 42,
        /// No CSI structure available
        NOCSI = 43,
        /// Level 2 halted
        L2HLT = 44,
        /// Deadlock condition.
        DEADLK = 45,
        /// No record locks available.
        NOLCK = 46,
        /// Operation canceled
        CANCELED = 47,
        /// Operation not supported
        NOTSUP = 48,

        // Filesystem Quotas
        /// Disc quota exceeded
        DQUOT = 49,

        // Convergent Error Returns
        /// invalid exchange
        BADE = 50,
        /// invalid request descriptor
        BADR = 51,
        /// exchange full
        XFULL = 52,
        /// no anode
        NOANO = 53,
        /// invalid request code
        BADRQC = 54,
        /// invalid slot
        BADSLT = 55,
        /// file locking deadlock error
        DEADLOCK = 56,
        /// bad font file fmt
        BFONT = 57,

        // Interprocess Robust Locks
        /// process died with the lock
        OWNERDEAD = 58,
        /// lock is not recoverable
        NOTRECOVERABLE = 59,
        /// locked lock was unmapped
        LOCKUNMAPPED = 72,
        /// Facility is not active
        NOTACTIVE = 73,
        /// multihop attempted
        MULTIHOP = 74,
        /// trying to read unreadable message
        BADMSG = 77,
        /// path name is too long
        NAMETOOLONG = 78,
        /// value too large to be stored in data type
        OVERFLOW = 79,
        /// given log. name not unique
        NOTUNIQ = 80,
        /// f.d. invalid for this operation
        BADFD = 81,
        /// Remote address changed
        REMCHG = 82,

        // Stream Problems
        /// Device not a stream
        NOSTR = 60,
        /// no data (for no delay io)
        NODATA = 61,
        /// timer expired
        TIME = 62,
        /// out of streams resources
        NOSR = 63,
        /// Machine is not on the network
        NONET = 64,
        /// Package not installed
        NOPKG = 65,
        /// The object is remote
        REMOTE = 66,
        /// the link has been severed
        NOLINK = 67,
        /// advertise error
        ADV = 68,
        /// srmount error
        SRMNT = 69,
        /// Communication error on send
        COMM = 70,
        /// Protocol error
        PROTO = 71,

        // Shared Library Problems
        /// Can't access a needed shared lib.
        LIBACC = 83,
        /// Accessing a corrupted shared lib.
        LIBBAD = 84,
        /// .lib section in a.out corrupted.
        LIBSCN = 85,
        /// Attempting to link in too many libs.
        LIBMAX = 86,
        /// Attempting to exec a shared library.
        LIBEXEC = 87,
        /// Illegal byte sequence.
        ILSEQ = 88,
        /// Unsupported file system operation
        NOSYS = 89,
        /// Symbolic link loop
        LOOP = 90,
        /// Restartable system call
        RESTART = 91,
        /// if pipe/FIFO, don't sleep in stream head
        STRPIPE = 92,
        /// directory not empty
        NOTEMPTY = 93,
        /// Too many users (for UFS)
        USERS = 94,

        // BSD Networking Software
        // Argument Errors
        /// Socket operation on non-socket
        NOTSOCK = 95,
        /// Destination address required
        DESTADDRREQ = 96,
        /// Message too long
        MSGSIZE = 97,
        /// Protocol wrong type for socket
        PROTOTYPE = 98,
        /// Protocol not available
        NOPROTOOPT = 99,
        /// Protocol not supported
        PROTONOSUPPORT = 120,
        /// Socket type not supported
        SOCKTNOSUPPORT = 121,
        /// Operation not supported on socket
        OPNOTSUPP = 122,
        /// Protocol family not supported
        PFNOSUPPORT = 123,
        /// Address family not supported by
        AFNOSUPPORT = 124,
        /// Address already in use
        ADDRINUSE = 125,
        /// Can't assign requested address
        ADDRNOTAVAIL = 126,

        // Operational Errors
        /// Network is down
        NETDOWN = 127,
        /// Network is unreachable
        NETUNREACH = 128,
        /// Network dropped connection because
        NETRESET = 129,
        /// Software caused connection abort
        CONNABORTED = 130,
        /// Connection reset by peer
        CONNRESET = 131,
        /// No buffer space available
        NOBUFS = 132,
        /// Socket is already connected
        ISCONN = 133,
        /// Socket is not connected
        NOTCONN = 134,
        /// Can't send after socket shutdown
        SHUTDOWN = 143,
        /// Too many references: can't splice
        TOOMANYREFS = 144,
        /// Connection timed out
        TIMEDOUT = 145,
        /// Connection refused
        CONNREFUSED = 146,
        /// Host is down
        HOSTDOWN = 147,
        /// No route to host
        HOSTUNREACH = 148,
        /// operation already in progress
        ALREADY = 149,
        /// operation now in progress
        INPROGRESS = 150,

        // SUN Network File System
        /// Stale NFS file handle
        STALE = 151,

        _,
    },
    .netbsd => netbsd.E,
    .dragonfly => dragonfly.E,
    .haiku => haiku.E,
    .openbsd => openbsd.E,
    else => void,

};
pub const Elf_Symndx = switch (native_os) {
    .linux => linux.Elf_Symndx,
    else => void,

};
/// Command flags for fcntl(2).
pub const F = switch (native_os) {
    .linux => linux.F,
    .emscripten => emscripten.F,
    .wasi => struct {
        // Match `F_*` constants from lib/libc/include/wasm-wasi-musl/__header_fcntl.h

        pub const GETFD = 1;

        pub const SETFD = 2;

        pub const GETFL = 3;

        pub const SETFL = 4;
    },
    .macos, .ios, .tvos, .watchos, .visionos => struct {
        /// duplicate file descriptor

        pub const DUPFD = 0;
        /// get file descriptor flags

        pub const GETFD = 1;
        /// set file descriptor flags

        pub const SETFD = 2;
        /// get file status flags

        pub const GETFL = 3;
        /// set file status flags

        pub const SETFL = 4;
        /// get SIGIO/SIGURG proc/pgrp

        pub const GETOWN = 5;
        /// set SIGIO/SIGURG proc/pgrp

        pub const SETOWN = 6;
        /// get record locking information

        pub const GETLK = 7;
        /// set record locking information

        pub const SETLK = 8;
        /// F.SETLK; wait if blocked

        pub const SETLKW = 9;
        /// F.SETLK; wait if blocked, return on timeout
        pub const SETLKWTIMEOUT = 10;
        pub const FLUSH_DATA = 40;
        /// Used for regression test
        pub const CHKCLEAN = 41;
        /// Preallocate storage
        pub const PREALLOCATE = 42;
        /// Truncate a file without zeroing space
        pub const SETSIZE = 43;
        /// Issue an advisory read async with no copy to user
        pub const RDADVISE = 44;
        /// turn read ahead off/on for this fd
        pub const RDAHEAD = 45;
        /// turn data caching off/on for this fd
        pub const NOCACHE = 48;
        /// file offset to device offset
        pub const LOG2PHYS = 49;
        /// return the full path of the fd
        pub const GETPATH = 50;
        /// fsync + ask the drive to flush to the media
        pub const FULLFSYNC = 51;
        /// find which component (if any) is a package
        pub const PATHPKG_CHECK = 52;
        /// "freeze" all fs operations
        pub const FREEZE_FS = 53;
        /// "thaw" all fs operations
        pub const THAW_FS = 54;
        /// turn data caching off/on (globally) for this file
        pub const GLOBAL_NOCACHE = 55;
        /// add detached signatures
        pub const ADDSIGS = 59;
        /// add signature from same file (used by dyld for shared libs)
        pub const ADDFILESIGS = 61;
        /// used in conjunction with F.NOCACHE to indicate that DIRECT, synchronous writes
        /// should not be used (i.e. its ok to temporarily create cached pages)
        pub const NODIRECT = 62;
        /// Get the protection class of a file from the EA, returns int
        pub const GETPROTECTIONCLASS = 63;
        /// Set the protection class of a file for the EA, requires int
        pub const SETPROTECTIONCLASS = 64;
        /// file offset to device offset, extended
        pub const LOG2PHYS_EXT = 65;
        /// get record locking information, per-process
        pub const GETLKPID = 66;
        /// Mark the file as being the backing store for another filesystem
        pub const SETBACKINGSTORE = 70;
        /// return the full path of the FD, but error in specific mtmd circumstances
        pub const GETPATH_MTMINFO = 71;
        /// Returns the code directory, with associated hashes, to the caller
        pub const GETCODEDIR = 72;
        /// No SIGPIPE generated on EPIPE
        pub const SETNOSIGPIPE = 73;
        /// Status of SIGPIPE for this fd

        pub const GETNOSIGPIPE = 74;
        /// For some cases, we need to rewrap the key for AKS/MKB

        pub const TRANSCODEKEY = 75;
        /// file being written to a by single writer... if throttling enabled, writes
        /// may be broken into smaller chunks with throttling in between

        pub const SINGLE_WRITER = 76;
        /// Get the protection version number for this filesystem

        pub const GETPROTECTIONLEVEL = 77;
        /// Add detached code signatures (used by dyld for shared libs)

        pub const FINDSIGS = 78;
        /// Add signature from same file, only if it is signed by Apple (used by dyld for simulator)

        pub const ADDFILESIGS_FOR_DYLD_SIM = 83;
        /// fsync + issue barrier to drive

        pub const BARRIERFSYNC = 85;
        /// Add signature from same file, return end offset in structure on success

        pub const ADDFILESIGS_RETURN = 97;
        /// Check if Library Validation allows this Mach-O file to be mapped into the calling process

        pub const CHECK_LV = 98;
        /// Deallocate a range of the file

        pub const PUNCHHOLE = 99;
        /// Trim an active file

        pub const TRIM_ACTIVE_FILE = 100;
        /// mark the dup with FD_CLOEXEC

        pub const DUPFD_CLOEXEC = 67;
        /// shared or read lock

        pub const RDLCK = 1;
        /// unlock

        pub const UNLCK = 2;
        /// exclusive or write lock

        pub const WRLCK = 3;
    },
    .freebsd => struct {
        /// Duplicate file descriptor.

        pub const DUPFD = 0;
        /// Get file descriptor flags.

        pub const GETFD = 1;
        /// Set file descriptor flags.

        pub const SETFD = 2;
        /// Get file status flags.

        pub const GETFL = 3;
        /// Set file status flags.

        pub const SETFL = 4;

        /// Get SIGIO/SIGURG proc/pgrrp.

        pub const GETOWN = 5;
        /// Set SIGIO/SIGURG proc/pgrrp.

        pub const SETOWN = 6;

        /// Get record locking information.
        pub const GETLK = 11;
        /// Set record locking information.
        pub const SETLK = 12;
        /// Set record locking information and wait if blocked.

        pub const SETLKW = 13;

        /// Debugging support for remote locks.
        pub const SETLK_REMOTE = 14;
        /// Read ahead.

        pub const READAHEAD = 15;

        /// DUPFD with FD_CLOEXEC set.

        pub const DUPFD_CLOEXEC = 17;
        /// DUP2FD with FD_CLOEXEC set.

        pub const DUP2FD_CLOEXEC = 18;

        pub const ADD_SEALS = 19;
        pub const GET_SEALS = 20;
        /// Return `kinfo_file` for a file descriptor.

        pub const KINFO = 22;

        // Seals (ADD_SEALS, GET_SEALS)
        /// Prevent adding sealings.
        pub const SEAL_SEAL = 0x0001;
        /// May not shrink

        pub const SEAL_SHRINK = 0x0002;
        /// May not grow.

        pub const SEAL_GROW = 0x0004;
        /// May not write.

        pub const SEAL_WRITE = 0x0008;

        // Record locking flags (GETLK, SETLK, SETLKW).
        /// Shared or read lock.

        pub const RDLCK = 1;
        /// Unlock.

        pub const UNLCK = 2;
        /// Exclusive or write lock.

        pub const WRLCK = 3;
        /// Purge locks for a given system ID.
        pub const UNLCKSYS = 4;
        /// Cancel an async lock request.

        pub const CANCEL = 5;

        pub const SETOWN_EX = 15;

        pub const GETOWN_EX = 16;

        pub const GETOWNER_UIDS = 17;
    },
    .solaris, .illumos => struct {
        /// Unlock a previously locked region

        pub const ULOCK = 0;
        /// Lock a region for exclusive use

        pub const LOCK = 1;
        /// Test and lock a region for exclusive use

        pub const TLOCK = 2;
        /// Test a region for other processes locks

        pub const TEST = 3;

        /// Duplicate fildes

        pub const DUPFD = 0;
        /// Get fildes flags

        pub const GETFD = 1;
        /// Set fildes flags

        pub const SETFD = 2;
        /// Get file flags

        pub const GETFL = 3;
        /// Get file flags including open-only flags
        pub const GETXFL = 45;
        /// Set file flags

        pub const SETFL = 4;

        /// Unused
        pub const CHKFL = 8;
        /// Duplicate fildes at third arg

        pub const DUP2FD = 9;
        /// Like DUP2FD with O_CLOEXEC set EINVAL is fildes matches arg1

        pub const DUP2FD_CLOEXEC = 36;
        /// Like DUPFD with O_CLOEXEC set

        pub const DUPFD_CLOEXEC = 37;

        /// Is the file desc. a stream ?
        pub const ISSTREAM = 13;
        /// Turn on private access to file

        pub const PRIV = 15;
        /// Turn off private access to file

        pub const NPRIV = 16;
        /// UFS quota call

        pub const QUOTACTL = 17;
        /// Get number of BLKSIZE blocks allocated

        pub const BLOCKS = 18;
        /// Get optimal I/O block size

        pub const BLKSIZE = 19;
        /// Get owner (socket emulation)

        pub const GETOWN = 23;
        /// Set owner (socket emulation)

        pub const SETOWN = 24;
        /// Object reuse revoke access to file desc.

        pub const REVOKE = 25;
        /// Does vp have NFS locks private to lock manager

        pub const HASREMOTELOCKS = 26;

        /// Set file lock
        pub const SETLK = 6;
        /// Set file lock and wait

        pub const SETLKW = 7;
        /// Allocate file space

        pub const ALLOCSP = 10;
        /// Free file space

        pub const FREESP = 11;
        /// Get file lock

        pub const GETLK = 14;
        /// Get file lock owned by file

        pub const OFD_GETLK = 47;
        /// Set file lock owned by file

        pub const OFD_SETLK = 48;
        /// Set file lock owned by file and wait

        pub const OFD_SETLKW = 49;
        /// Set a file share reservation

        pub const SHARE = 40;
        /// Remove a file share reservation

        pub const UNSHARE = 41;
        /// Create Poison FD

        pub const BADFD = 46;

        /// Read lock

        pub const RDLCK = 1;
        /// Write lock
        pub const WRLCK = 2;
        /// Remove lock(s)

        pub const UNLCK = 3;
        /// remove remote locks for a given system

        pub const UNLKSYS = 4;

        // f_access values
        /// Read-only share access
        pub const RDACC = 0x1;
        /// Write-only share access

        pub const WRACC = 0x2;
        /// Read-Write share access

        pub const RWACC = 0x3;

        // f_deny values
        /// Don't deny others access
        pub const NODNY = 0x0;
        /// Deny others read share access

        pub const RDDNY = 0x1;
        /// Deny others write share access

        pub const WRDNY = 0x2;
        /// Deny others read or write share access

        pub const RWDNY = 0x3;
        /// private flag: Deny delete share access

        pub const RMDNY = 0x4;
    },
    .netbsd => struct {

        pub const DUPFD = 0;

        pub const GETFD = 1;

        pub const SETFD = 2;

        pub const GETFL = 3;

        pub const SETFL = 4;

        pub const GETOWN = 5;

        pub const SETOWN = 6;

        pub const GETLK = 7;

        pub const SETLK = 8;

        pub const SETLKW = 9;

        pub const CLOSEM = 10;

        pub const MAXFD = 11;

        pub const DUPFD_CLOEXEC = 12;

        pub const GETNOSIGPIPE = 13;

        pub const SETNOSIGPIPE = 14;

        pub const GETPATH = 15;

        pub const RDLCK = 1;

        pub const WRLCK = 3;

        pub const UNLCK = 2;
    },
    .dragonfly => struct {
        pub const ULOCK = 0;

        pub const LOCK = 1;

        pub const TLOCK = 2;

        pub const TEST = 3;

        pub const DUPFD = 0;

        pub const GETFD = 1;

        pub const RDLCK = 1;

        pub const SETFD = 2;

        pub const UNLCK = 2;

        pub const WRLCK = 3;

        pub const GETFL = 3;

        pub const SETFL = 4;

        pub const GETOWN = 5;

        pub const SETOWN = 6;

        pub const GETLK = 7;

        pub const SETLK = 8;

        pub const SETLKW = 9;
        pub const DUP2FD = 10;

        pub const DUPFD_CLOEXEC = 17;

        pub const DUP2FD_CLOEXEC = 18;

        pub const GETPATH = 19;
    },
    .haiku => struct {

        pub const DUPFD = 0x0001;

        pub const GETFD = 0x0002;

        pub const SETFD = 0x0004;

        pub const GETFL = 0x0008;

        pub const SETFL = 0x0010;

        pub const GETLK = 0x0020;

        pub const SETLK = 0x0080;

        pub const SETLKW = 0x0100;

        pub const DUPFD_CLOEXEC = 0x0200;

        pub const RDLCK = 0x0040;

        pub const UNLCK = 0x0200;

        pub const WRLCK = 0x0400;
    },
    .openbsd => struct {

        pub const DUPFD = 0;

        pub const GETFD = 1;

        pub const SETFD = 2;

        pub const GETFL = 3;

        pub const SETFL = 4;

        pub const GETOWN = 5;

        pub const SETOWN = 6;

        pub const GETLK = 7;

        pub const SETLK = 8;

        pub const SETLKW = 9;

        pub const RDLCK = 1;

        pub const UNLCK = 2;

        pub const WRLCK = 3;
    },
    else => void,

};
pub const FD_CLOEXEC = switch (native_os) {
    .linux => linux.FD_CLOEXEC,
    .emscripten => emscripten.FD_CLOEXEC,
    else => 1,

};

/// Test for existence of file.
pub const F_OK = switch (native_os) {
    .linux => linux.F_OK,
    .emscripten => emscripten.F_OK,
    else => 0,

};
/// Test for execute or search permission.
pub const X_OK = switch (native_os) {
    .linux => linux.X_OK,
    .emscripten => emscripten.X_OK,
    else => 1,

};
/// Test for write permission.
pub const W_OK = switch (native_os) {
    .linux => linux.W_OK,
    .emscripten => emscripten.W_OK,
    else => 2,

};
/// Test for read permission.
pub const R_OK = switch (native_os) {
    .linux => linux.R_OK,
    .emscripten => emscripten.R_OK,
    else => 4,

};

pub const Flock = switch (native_os) {
    .linux => linux.Flock,
    .emscripten => emscripten.Flock,
    .openbsd, .dragonfly, .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
        start: off_t,
        len: off_t,
        pid: pid_t,
        type: i16,
        whence: i16,
    },
    .freebsd => extern struct {
        /// Starting offset.
        start: off_t,
        /// Number of consecutive bytes to be locked.
        /// A value of 0 means to the end of the file.
        len: off_t,
        /// Lock owner.
        pid: pid_t,
        /// Lock type.
        type: i16,
        /// Type of the start member.
        whence: i16,
        /// Remote system id or zero for local.
        sysid: i32,
    },
    .solaris, .illumos => extern struct {
        type: c_short,
        whence: c_short,
        start: off_t,
        // len == 0 means until end of file.
        len: off_t,
        sysid: c_int,
        pid: pid_t,
        __pad: [4]c_long,
    },
    .haiku => extern struct {
        type: i16,
        whence: i16,
        start: off_t,
        len: off_t,
        pid: pid_t,
    },
    else => void,

};
pub const HOST_NAME_MAX = switch (native_os) {
    .linux => linux.HOST_NAME_MAX,
    .macos, .ios, .tvos, .watchos, .visionos => 72,
    .openbsd, .haiku, .dragonfly, .netbsd, .solaris, .illumos, .freebsd => 255,
    else => {},

};
pub const IOV_MAX = switch (native_os) {
    .linux => linux.IOV_MAX,
    .emscripten => emscripten.IOV_MAX,
    .openbsd, .haiku, .solaris, .illumos, .wasi => 1024,
    .macos, .ios, .tvos, .watchos, .visionos => 16,
    .dragonfly, .netbsd, .freebsd => KERN.IOV_MAX,
    else => {},

};
pub const CTL = switch (native_os) {
    .freebsd => struct {

        pub const KERN = 1;

        pub const DEBUG = 5;
    },
    .netbsd => struct {

        pub const KERN = 1;

        pub const DEBUG = 5;
    },
    .dragonfly => struct {

        pub const UNSPEC = 0;

        pub const KERN = 1;

        pub const VM = 2;
        pub const VFS = 3;

        pub const NET = 4;

        pub const DEBUG = 5;

        pub const HW = 6;

        pub const MACHDEP = 7;
        pub const USER = 8;

        pub const LWKT = 10;

        pub const MAXID = 11;

        pub const MAXNAME = 12;
    },
    .openbsd => struct {

        pub const UNSPEC = 0;

        pub const KERN = 1;

        pub const VM = 2;

        pub const FS = 3;

        pub const NET = 4;

        pub const DEBUG = 5;

        pub const HW = 6;

        pub const MACHDEP = 7;

        pub const DDB = 9;

        pub const VFS = 10;
    },
    else => void,

};
pub const KERN = switch (native_os) {
    .freebsd => struct {
        /// struct: process entries

        pub const PROC = 14;
        /// path to executable

        pub const PROC_PATHNAME = 12;
        /// file descriptors for process

        pub const PROC_FILEDESC = 33;

        pub const IOV_MAX = 35;
    },
    .netbsd => struct {
        /// struct: process argv/env

        pub const PROC_ARGS = 48;
        /// path to executable

        pub const PROC_PATHNAME = 5;

        pub const IOV_MAX = 38;
    },
    .dragonfly => struct {

        pub const PROC_ALL = 0;

        pub const OSTYPE = 1;

        pub const PROC_PID = 1;

        pub const OSRELEASE = 2;

        pub const PROC_PGRP = 2;

        pub const OSREV = 3;

        pub const PROC_SESSION = 3;

        pub const VERSION = 4;

        pub const PROC_TTY = 4;

        pub const MAXVNODES = 5;

        pub const PROC_UID = 5;

        pub const MAXPROC = 6;

        pub const PROC_RUID = 6;

        pub const MAXFILES = 7;

        pub const PROC_ARGS = 7;

        pub const ARGMAX = 8;

        pub const PROC_CWD = 8;

        pub const PROC_PATHNAME = 9;

        pub const SECURELVL = 9;

        pub const PROC_SIGTRAMP = 10;

        pub const HOSTNAME = 10;

        pub const HOSTID = 11;

        pub const CLOCKRATE = 12;

        pub const VNODE = 13;

        pub const PROC = 14;

        pub const FILE = 15;

        pub const PROC_FLAGMASK = 16;

        pub const PROF = 16;

        pub const PROC_FLAG_LWP = 16;

        pub const POSIX1 = 17;

        pub const NGROUPS = 18;

        pub const JOB_CONTROL = 19;

        pub const SAVED_IDS = 20;

        pub const BOOTTIME = 21;

        pub const NISDOMAINNAME = 22;

        pub const UPDATEINTERVAL = 23;

        pub const OSRELDATE = 24;

        pub const NTP_PLL = 25;

        pub const BOOTFILE = 26;

        pub const MAXFILESPERPROC = 27;

        pub const MAXPROCPERUID = 28;

        pub const DUMPDEV = 29;

        pub const IPC = 30;

        pub const DUMMY = 31;

        pub const PS_STRINGS = 32;

        pub const USRSTACK = 33;

        pub const LOGSIGEXIT = 34;

        pub const IOV_MAX = 35;

        pub const MAXPOSIXLOCKSPERUID = 36;

        pub const MAXID = 37;
    },
    .openbsd => struct {

        pub const OSTYPE = 1;

        pub const OSRELEASE = 2;

        pub const OSREV = 3;

        pub const VERSION = 4;

        pub const MAXVNODES = 5;

        pub const MAXPROC = 6;

        pub const MAXFILES = 7;

        pub const ARGMAX = 8;

        pub const SECURELVL = 9;

        pub const HOSTNAME = 10;

        pub const HOSTID = 11;

        pub const CLOCKRATE = 12;

        pub const PROF = 16;

        pub const POSIX1 = 17;

        pub const NGROUPS = 18;

        pub const JOB_CONTROL = 19;

        pub const SAVED_IDS = 20;

        pub const BOOTTIME = 21;

        pub const DOMAINNAME = 22;

        pub const MAXPARTITIONS = 23;

        pub const RAWPARTITION = 24;

        pub const MAXTHREAD = 25;

        pub const NTHREADS = 26;

        pub const OSVERSION = 27;

        pub const SOMAXCONN = 28;

        pub const SOMINCONN = 29;

        pub const NOSUIDCOREDUMP = 32;

        pub const FSYNC = 33;

        pub const SYSVMSG = 34;

        pub const SYSVSEM = 35;

        pub const SYSVSHM = 36;

        pub const MSGBUFSIZE = 38;

        pub const MALLOCSTATS = 39;

        pub const CPTIME = 40;

        pub const NCHSTATS = 41;

        pub const FORKSTAT = 42;

        pub const NSELCOLL = 43;

        pub const TTY = 44;

        pub const CCPU = 45;

        pub const FSCALE = 46;

        pub const NPROCS = 47;

        pub const MSGBUF = 48;

        pub const POOL = 49;

        pub const STACKGAPRANDOM = 50;

        pub const SYSVIPC_INFO = 51;

        pub const ALLOWKMEM = 52;

        pub const WITNESSWATCH = 53;

        pub const SPLASSERT = 54;

        pub const PROC_ARGS = 55;

        pub const NFILES = 56;

        pub const TTYCOUNT = 57;

        pub const NUMVNODES = 58;

        pub const MBSTAT = 59;

        pub const WITNESS = 60;

        pub const SEMINFO = 61;

        pub const SHMINFO = 62;

        pub const INTRCNT = 63;

        pub const WATCHDOG = 64;

        pub const ALLOWDT = 65;

        pub const PROC = 66;

        pub const MAXCLUSTERS = 67;

        pub const EVCOUNT = 68;

        pub const TIMECOUNTER = 69;

        pub const MAXLOCKSPERUID = 70;

        pub const CPTIME2 = 71;

        pub const CACHEPCT = 72;

        pub const FILE = 73;

        pub const WXABORT = 74;

        pub const CONSDEV = 75;

        pub const NETLIVELOCKS = 76;

        pub const POOL_DEBUG = 77;

        pub const PROC_CWD = 78;

        pub const PROC_NOBROADCASTKILL = 79;

        pub const PROC_VMMAP = 80;

        pub const GLOBAL_PTRACE = 81;

        pub const CONSBUFSIZE = 82;

        pub const CONSBUF = 83;

        pub const AUDIO = 84;

        pub const CPUSTATS = 85;

        pub const PFSTATUS = 86;

        pub const TIMEOUT_STATS = 87;

        pub const UTC_OFFSET = 88;

        pub const VIDEO = 89;

        pub const PROC_ALL = 0;

        pub const PROC_PID = 1;

        pub const PROC_PGRP = 2;

        pub const PROC_SESSION = 3;

        pub const PROC_TTY = 4;

        pub const PROC_UID = 5;

        pub const PROC_RUID = 6;

        pub const PROC_KTHREAD = 7;

        pub const PROC_SHOW_THREADS = 0x40000000;

        pub const PROC_ARGV = 1;

        pub const PROC_NARGV = 2;

        pub const PROC_ENV = 3;

        pub const PROC_NENV = 4;
    },
    else => void,

};
pub const MADV = switch (native_os) {
    .linux => linux.MADV,
    .emscripten => emscripten.MADV,
    .macos, .ios, .tvos, .watchos, .visionos => struct {

        pub const NORMAL = 0;

        pub const RANDOM = 1;

        pub const SEQUENTIAL = 2;

        pub const WILLNEED = 3;

        pub const DONTNEED = 4;

        pub const FREE = 5;

        pub const ZERO_WIRED_PAGES = 6;

        pub const FREE_REUSABLE = 7;

        pub const FREE_REUSE = 8;

        pub const CAN_REUSE = 9;

        pub const PAGEOUT = 10;

        pub const ZERO = 11;
    },
    .freebsd => struct {

        pub const NORMAL = 0;

        pub const RANDOM = 1;

        pub const SEQUENTIAL = 2;

        pub const WILLNEED = 3;

        pub const DONTNEED = 4;

        pub const FREE = 5;

        pub const NOSYNC = 6;

        pub const AUTOSYNC = 7;

        pub const NOCORE = 8;

        pub const CORE = 9;

        pub const PROTECT = 10;
    },
    .solaris, .illumos => struct {
        /// no further special treatment

        pub const NORMAL = 0;
        /// expect random page references

        pub const RANDOM = 1;
        /// expect sequential page references

        pub const SEQUENTIAL = 2;
        /// will need these pages

        pub const WILLNEED = 3;
        /// don't need these pages

        pub const DONTNEED = 4;
        /// contents can be freed

        pub const FREE = 5;
        /// default access

        pub const ACCESS_DEFAULT = 6;
        /// next LWP to access heavily

        pub const ACCESS_LWP = 7;
        /// many processes to access heavily

        pub const ACCESS_MANY = 8;
        /// contents will be purged

        pub const PURGE = 9;
    },
    .dragonfly => struct {

        pub const SEQUENTIAL = 2;

        pub const CONTROL_END = SETMAP;

        pub const DONTNEED = 4;

        pub const RANDOM = 1;

        pub const WILLNEED = 3;

        pub const NORMAL = 0;

        pub const CONTROL_START = INVAL;

        pub const FREE = 5;

        pub const NOSYNC = 6;

        pub const AUTOSYNC = 7;

        pub const NOCORE = 8;

        pub const CORE = 9;

        pub const INVAL = 10;

        pub const SETMAP = 11;
    },
    else => void,

};
pub const MSF = switch (native_os) {
    .linux => linux.MSF,
    .emscripten => emscripten.MSF,
    .macos, .ios, .tvos, .watchos, .visionos => struct {

        pub const ASYNC = 0x1;

        pub const INVALIDATE = 0x2;
        /// invalidate, leave mapped

        pub const KILLPAGES = 0x4;
        /// deactivate, leave mapped

        pub const DEACTIVATE = 0x8;

        pub const SYNC = 0x10;
    },
    .openbsd, .haiku, .dragonfly, .netbsd, .solaris, .illumos, .freebsd => struct {

        pub const ASYNC = 1;

        pub const INVALIDATE = 2;

        pub const SYNC = 4;
    },
    else => void,

};
pub const MMAP2_UNIT = switch (native_os) {
    .linux => linux.MMAP2_UNIT,
    else => void,

};
pub const NAME_MAX = switch (native_os) {
    .linux => linux.NAME_MAX,
    .emscripten => emscripten.NAME_MAX,
    // Haiku's headers make this 256, to contain room for the terminating null
    // character, but POSIX definition says that NAME_MAX does not include the
    // terminating null.
    .haiku, .openbsd, .dragonfly, .netbsd, .solaris, .illumos, .freebsd, .macos, .ios, .tvos, .watchos, .visionos => 255,
    else => {},

};
pub const PATH_MAX = switch (native_os) {
    .linux => linux.PATH_MAX,
    .emscripten => emscripten.PATH_MAX,
    .wasi => 4096,
    .windows => 260,
    .openbsd, .haiku, .dragonfly, .netbsd, .solaris, .illumos, .freebsd, .macos, .ios, .tvos, .watchos, .visionos => 1024,
    else => {},

};

pub const POLL = switch (native_os) {
    .linux => linux.POLL,
    .emscripten => emscripten.POLL,
    .wasi => struct {
        pub const RDNORM = 0x1;

        pub const WRNORM = 0x2;

        pub const IN = RDNORM;

        pub const OUT = WRNORM;

        pub const ERR = 0x1000;

        pub const HUP = 0x2000;

        pub const NVAL = 0x4000;
    },
    .windows => ws2_32.POLL,
    .macos, .ios, .tvos, .watchos, .visionos => struct {

        pub const IN = 0x001;

        pub const PRI = 0x002;

        pub const OUT = 0x004;

        pub const RDNORM = 0x040;

        pub const WRNORM = OUT;

        pub const RDBAND = 0x080;

        pub const WRBAND = 0x100;

        pub const EXTEND = 0x0200;

        pub const ATTRIB = 0x0400;

        pub const NLINK = 0x0800;

        pub const WRITE = 0x1000;

        pub const ERR = 0x008;

        pub const HUP = 0x010;

        pub const NVAL = 0x020;

        pub const STANDARD = IN | PRI | OUT | RDNORM | RDBAND | WRBAND | ERR | HUP | NVAL;
    },
    .freebsd => struct {
        /// any readable data available.

        pub const IN = 0x0001;
        /// OOB/Urgent readable data.

        pub const PRI = 0x0002;
        /// file descriptor is writeable.

        pub const OUT = 0x0004;
        /// non-OOB/URG data available.

        pub const RDNORM = 0x0040;
        /// no write type differentiation.

        pub const WRNORM = OUT;
        /// OOB/Urgent readable data.

        pub const RDBAND = 0x0080;
        /// OOB/Urgent data can be written.

        pub const WRBAND = 0x0100;
        /// like IN, except ignore EOF.
        pub const INIGNEOF = 0x2000;
        /// some poll error occurred.

        pub const ERR = 0x0008;
        /// file descriptor was "hung up".

        pub const HUP = 0x0010;
        /// requested events "invalid".

        pub const NVAL = 0x0020;

        pub const STANDARD = IN | PRI | OUT | RDNORM | RDBAND | WRBAND | ERR | HUP | NVAL;
    },
    .solaris, .illumos => struct {

        pub const IN = 0x0001;

        pub const PRI = 0x0002;

        pub const OUT = 0x0004;

        pub const RDNORM = 0x0040;

        pub const WRNORM = .OUT;

        pub const RDBAND = 0x0080;

        pub const WRBAND = 0x0100;
        /// Read-side hangup.

        pub const RDHUP = 0x4000;

        /// Non-testable events (may not be specified in events).

        pub const ERR = 0x0008;

        pub const HUP = 0x0010;

        pub const NVAL = 0x0020;

        /// Events to control `/dev/poll` (not specified in revents)
        pub const REMOVE = 0x0800;
        pub const ONESHOT = 0x1000;

        pub const ET = 0x2000;
    },
    .dragonfly, .netbsd => struct {
        /// Testable events (may be specified in events field).

        pub const IN = 0x0001;

        pub const PRI = 0x0002;

        pub const OUT = 0x0004;

        pub const RDNORM = 0x0040;

        pub const WRNORM = OUT;

        pub const RDBAND = 0x0080;

        pub const WRBAND = 0x0100;

        /// Non-testable events (may not be specified in events field).

        pub const ERR = 0x0008;

        pub const HUP = 0x0010;

        pub const NVAL = 0x0020;
    },
    .haiku => struct {
        /// any readable data available

        pub const IN = 0x0001;
        /// file descriptor is writeable
        pub const OUT = 0x0002;

        pub const RDNORM = IN;

        pub const WRNORM = OUT;
        /// priority readable data

        pub const RDBAND = 0x0008;
        /// priority data can be written

        pub const WRBAND = 0x0010;
        /// high priority readable data

        pub const PRI = 0x0020;

        /// errors pending
        pub const ERR = 0x0004;
        /// disconnected

        pub const HUP = 0x0080;
        /// invalid file descriptor

        pub const NVAL = 0x1000;
    },
    .openbsd => struct {

        pub const IN = 0x0001;

        pub const PRI = 0x0002;

        pub const OUT = 0x0004;

        pub const ERR = 0x0008;

        pub const HUP = 0x0010;

        pub const NVAL = 0x0020;

        pub const RDNORM = 0x0040;

        pub const NORM = RDNORM;

        pub const WRNORM = OUT;

        pub const RDBAND = 0x0080;

        pub const WRBAND = 0x0100;
    },
    else => void,

};

/// Basic memory protection flags
pub const PROT = switch (native_os) {
    .linux => linux.PROT,
    .emscripten => emscripten.PROT,
    .openbsd, .haiku, .dragonfly, .netbsd, .solaris, .illumos, .freebsd, .windows => struct {
        /// page can not be accessed
        pub const NONE = 0x0;
        /// page can be read

        pub const READ = 0x1;
        /// page can be written

        pub const WRITE = 0x2;
        /// page can be executed

        pub const EXEC = 0x4;
    },
    .macos, .ios, .tvos, .watchos, .visionos => struct {
        /// [MC2] no permissions

        pub const NONE: vm_prot_t = 0x00;
        /// [MC2] pages can be read

        pub const READ: vm_prot_t = 0x01;
        /// [MC2] pages can be written

        pub const WRITE: vm_prot_t = 0x02;
        /// [MC2] pages can be executed

        pub const EXEC: vm_prot_t = 0x04;
        /// When a caller finds that they cannot obtain write permission on a
        /// mapped entry, the following flag can be used. The entry will be
        /// made "needs copy" effectively copying the object (using COW),
        /// and write permission will be added to the maximum protections for
        /// the associated entry.

        pub const COPY: vm_prot_t = 0x10;
    },
    else => void,

};

pub const REG = switch (native_os) {
    .linux => linux.REG,
    .emscripten => emscripten.REG,
    .freebsd => switch (builtin.cpu.arch) {
        .aarch64 => struct {

            pub const FP = 29;

            pub const SP = 31;

            pub const PC = 32;
        },
        .arm => struct {

            pub const FP = 11;

            pub const SP = 13;

            pub const PC = 15;
        },
        .x86_64 => struct {

            pub const RBP = 12;

            pub const RIP = 21;

            pub const RSP = 24;
        },
        else => struct {},
    },
    .solaris, .illumos => struct {
        pub const R15 = 0;

        pub const R14 = 1;

        pub const R13 = 2;

        pub const R12 = 3;

        pub const R11 = 4;

        pub const R10 = 5;

        pub const R9 = 6;

        pub const R8 = 7;

        pub const RDI = 8;

        pub const RSI = 9;

        pub const RBP = 10;

        pub const RBX = 11;

        pub const RDX = 12;

        pub const RCX = 13;

        pub const RAX = 14;

        pub const RIP = 17;

        pub const RSP = 20;
    },
    .netbsd => switch (builtin.cpu.arch) {
        .aarch64 => struct {

            pub const FP = 29;

            pub const SP = 31;

            pub const PC = 32;
        },
        .arm => struct {

            pub const FP = 11;

            pub const SP = 13;

            pub const PC = 15;
        },
        .x86_64 => struct {

            pub const RDI = 0;

            pub const RSI = 1;

            pub const RDX = 2;

            pub const RCX = 3;

            pub const R8 = 4;

            pub const R9 = 5;

            pub const R10 = 6;

            pub const R11 = 7;

            pub const R12 = 8;

            pub const R13 = 9;

            pub const R14 = 10;

            pub const R15 = 11;

            pub const RBP = 12;

            pub const RBX = 13;

            pub const RAX = 14;

            pub const GS = 15;

            pub const FS = 16;

            pub const ES = 17;

            pub const DS = 18;

            pub const TRAPNO = 19;

            pub const ERR = 20;

            pub const RIP = 21;

            pub const CS = 22;

            pub const RFLAGS = 23;

            pub const RSP = 24;

            pub const SS = 25;
        },
        else => struct {},
    },
    else => struct {},

};
pub const RLIM = switch (native_os) {
    .linux => linux.RLIM,
    .emscripten => emscripten.RLIM,
    .openbsd, .haiku, .dragonfly, .netbsd, .freebsd, .macos, .ios, .tvos, .watchos, .visionos => struct {
        /// No limit

        pub const INFINITY: rlim_t = (1 << 63) - 1;

        pub const SAVED_MAX = INFINITY;

        pub const SAVED_CUR = INFINITY;
    },
    .solaris, .illumos => struct {
        /// No limit

        pub const INFINITY: rlim_t = (1 << 63) - 3;

        pub const SAVED_MAX: rlim_t = (1 << 63) - 2;

        pub const SAVED_CUR: rlim_t = (1 << 63) - 1;
    },
    else => void,

};
pub const S = switch (native_os) {
    .linux => linux.S,
    .emscripten => emscripten.S,
    .wasi => struct {
        // Match `S_*` constants from lib/libc/include/wasm-wasi-musl/__mode_t.h

        pub const IFBLK = 0x6000;

        pub const IFCHR = 0x2000;

        pub const IFDIR = 0x4000;

        pub const IFIFO = 0x1000;

        pub const IFLNK = 0xa000;

        pub const IFMT = IFBLK | IFCHR | IFDIR | IFIFO | IFLNK | IFREG | IFSOCK;

        pub const IFREG = 0x8000;

        pub const IFSOCK = 0xc000;

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }
    },
    .macos, .ios, .tvos, .watchos, .visionos => struct {

        pub const IFMT = 0o170000;

        pub const IFIFO = 0o010000;

        pub const IFCHR = 0o020000;

        pub const IFDIR = 0o040000;

        pub const IFBLK = 0o060000;

        pub const IFREG = 0o100000;

        pub const IFLNK = 0o120000;

        pub const IFSOCK = 0o140000;

        pub const IFWHT = 0o160000;

        pub const ISUID = 0o4000;

        pub const ISGID = 0o2000;

        pub const ISVTX = 0o1000;

        pub const IRWXU = 0o700;

        pub const IRUSR = 0o400;

        pub const IWUSR = 0o200;

        pub const IXUSR = 0o100;

        pub const IRWXG = 0o070;

        pub const IRGRP = 0o040;

        pub const IWGRP = 0o020;

        pub const IXGRP = 0o010;

        pub const IRWXO = 0o007;

        pub const IROTH = 0o004;

        pub const IWOTH = 0o002;

        pub const IXOTH = 0o001;

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }

        pub fn IWHT(m: u32) bool {
            return m & IFMT == IFWHT;
        }
    },
    .freebsd => struct {

        pub const IFMT = 0o170000;

        pub const IFIFO = 0o010000;

        pub const IFCHR = 0o020000;

        pub const IFDIR = 0o040000;

        pub const IFBLK = 0o060000;

        pub const IFREG = 0o100000;

        pub const IFLNK = 0o120000;

        pub const IFSOCK = 0o140000;

        pub const IFWHT = 0o160000;

        pub const ISUID = 0o4000;

        pub const ISGID = 0o2000;

        pub const ISVTX = 0o1000;

        pub const IRWXU = 0o700;

        pub const IRUSR = 0o400;

        pub const IWUSR = 0o200;

        pub const IXUSR = 0o100;

        pub const IRWXG = 0o070;

        pub const IRGRP = 0o040;

        pub const IWGRP = 0o020;

        pub const IXGRP = 0o010;

        pub const IRWXO = 0o007;

        pub const IROTH = 0o004;

        pub const IWOTH = 0o002;

        pub const IXOTH = 0o001;

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }

        pub fn IWHT(m: u32) bool {
            return m & IFMT == IFWHT;
        }
    },
    .solaris, .illumos => struct {

        pub const IFMT = 0o170000;

        pub const IFIFO = 0o010000;

        pub const IFCHR = 0o020000;

        pub const IFDIR = 0o040000;

        pub const IFBLK = 0o060000;

        pub const IFREG = 0o100000;

        pub const IFLNK = 0o120000;

        pub const IFSOCK = 0o140000;
        /// SunOS 2.6 Door
        pub const IFDOOR = 0o150000;
        /// Solaris 10 Event Port
        pub const IFPORT = 0o160000;

        pub const ISUID = 0o4000;

        pub const ISGID = 0o2000;

        pub const ISVTX = 0o1000;

        pub const IRWXU = 0o700;

        pub const IRUSR = 0o400;

        pub const IWUSR = 0o200;

        pub const IXUSR = 0o100;

        pub const IRWXG = 0o070;

        pub const IRGRP = 0o040;

        pub const IWGRP = 0o020;

        pub const IXGRP = 0o010;

        pub const IRWXO = 0o007;

        pub const IROTH = 0o004;

        pub const IWOTH = 0o002;

        pub const IXOTH = 0o001;

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }

        pub fn ISDOOR(m: u32) bool {
            return m & IFMT == IFDOOR;
        }

        pub fn ISPORT(m: u32) bool {
            return m & IFMT == IFPORT;
        }
    },
    .netbsd => struct {

        pub const IFMT = 0o170000;

        pub const IFIFO = 0o010000;

        pub const IFCHR = 0o020000;

        pub const IFDIR = 0o040000;

        pub const IFBLK = 0o060000;

        pub const IFREG = 0o100000;

        pub const IFLNK = 0o120000;

        pub const IFSOCK = 0o140000;
        pub const IFWHT = 0o160000;

        pub const ISUID = 0o4000;

        pub const ISGID = 0o2000;

        pub const ISVTX = 0o1000;

        pub const IRWXU = 0o700;

        pub const IRUSR = 0o400;

        pub const IWUSR = 0o200;

        pub const IXUSR = 0o100;

        pub const IRWXG = 0o070;

        pub const IRGRP = 0o040;

        pub const IWGRP = 0o020;

        pub const IXGRP = 0o010;

        pub const IRWXO = 0o007;

        pub const IROTH = 0o004;

        pub const IWOTH = 0o002;

        pub const IXOTH = 0o001;

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }

        pub fn IWHT(m: u32) bool {
            return m & IFMT == IFWHT;
        }
    },
    .dragonfly => struct {
        pub const IREAD = IRUSR;
        pub const IEXEC = IXUSR;
        pub const IWRITE = IWUSR;
        pub const IXOTH = 1;
        pub const IWOTH = 2;
        pub const IROTH = 4;
        pub const IRWXO = 7;
        pub const IXGRP = 8;
        pub const IWGRP = 16;
        pub const IRGRP = 32;
        pub const IRWXG = 56;
        pub const IXUSR = 64;
        pub const IWUSR = 128;
        pub const IRUSR = 256;
        pub const IRWXU = 448;
        pub const ISTXT = 512;
        pub const BLKSIZE = 512;
        pub const ISVTX = 512;
        pub const ISGID = 1024;
        pub const ISUID = 2048;
        pub const IFIFO = 4096;
        pub const IFCHR = 8192;
        pub const IFDIR = 16384;
        pub const IFBLK = 24576;
        pub const IFREG = 32768;
        pub const IFDB = 36864;
        pub const IFLNK = 40960;
        pub const IFSOCK = 49152;
        pub const IFWHT = 57344;
        pub const IFMT = 61440;

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }
    },
    .haiku => struct {

        pub const IFMT = 0o170000;

        pub const IFSOCK = 0o140000;

        pub const IFLNK = 0o120000;

        pub const IFREG = 0o100000;

        pub const IFBLK = 0o060000;

        pub const IFDIR = 0o040000;

        pub const IFCHR = 0o020000;

        pub const IFIFO = 0o010000;
        pub const INDEX_DIR = 0o4000000000;

        pub const IUMSK = 0o7777;

        pub const ISUID = 0o4000;

        pub const ISGID = 0o2000;

        pub const ISVTX = 0o1000;

        pub const IRWXU = 0o700;

        pub const IRUSR = 0o400;

        pub const IWUSR = 0o200;

        pub const IXUSR = 0o100;

        pub const IRWXG = 0o070;

        pub const IRGRP = 0o040;

        pub const IWGRP = 0o020;

        pub const IXGRP = 0o010;

        pub const IRWXO = 0o007;

        pub const IROTH = 0o004;

        pub const IWOTH = 0o002;

        pub const IXOTH = 0o001;

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }

        pub fn ISINDEX(m: u32) bool {
            return m & INDEX_DIR == INDEX_DIR;
        }
    },
    .openbsd => struct {
        pub const IFMT = 0o170000;

        pub const IFIFO = 0o010000;
        pub const IFCHR = 0o020000;
        pub const IFDIR = 0o040000;
        pub const IFBLK = 0o060000;
        pub const IFREG = 0o100000;
        pub const IFLNK = 0o120000;
        pub const IFSOCK = 0o140000;

        pub const ISUID = 0o4000;
        pub const ISGID = 0o2000;
        pub const ISVTX = 0o1000;
        pub const IRWXU = 0o700;
        pub const IRUSR = 0o400;
        pub const IWUSR = 0o200;
        pub const IXUSR = 0o100;
        pub const IRWXG = 0o070;
        pub const IRGRP = 0o040;
        pub const IWGRP = 0o020;
        pub const IXGRP = 0o010;
        pub const IRWXO = 0o007;
        pub const IROTH = 0o004;

        pub const IWOTH = 0o002;

        pub const IXOTH = 0o001;

        pub fn ISFIFO(m: u32) bool {
            return m & IFMT == IFIFO;
        }

        pub fn ISCHR(m: u32) bool {
            return m & IFMT == IFCHR;
        }

        pub fn ISDIR(m: u32) bool {
            return m & IFMT == IFDIR;
        }

        pub fn ISBLK(m: u32) bool {
            return m & IFMT == IFBLK;
        }

        pub fn ISREG(m: u32) bool {
            return m & IFMT == IFREG;
        }

        pub fn ISLNK(m: u32) bool {
            return m & IFMT == IFLNK;
        }

        pub fn ISSOCK(m: u32) bool {
            return m & IFMT == IFSOCK;
        }
    },
    else => void,

};
pub const SA = switch (native_os) {
    .linux => linux.SA,
    .emscripten => emscripten.SA,
    .macos, .ios, .tvos, .watchos, .visionos => struct {
        /// take signal on signal stack

        pub const ONSTACK = 0x0001;
        /// restart system on signal return

        pub const RESTART = 0x0002;
        /// reset to SIG.DFL when taking signal

        pub const RESETHAND = 0x0004;
        /// do not generate SIG.CHLD on child stop

        pub const NOCLDSTOP = 0x0008;
        /// don't mask the signal we're delivering

        pub const NODEFER = 0x0010;
        /// don't keep zombies around

        pub const NOCLDWAIT = 0x0020;
        /// signal handler with SIGINFO args

        pub const SIGINFO = 0x0040;
        /// do not bounce off kernel's sigtramp

        pub const USERTRAMP = 0x0100;
        /// signal handler with SIGINFO args with 64bit regs information

        pub const @"64REGSET" = 0x0200;
    },
    .freebsd => struct {

        pub const ONSTACK = 0x0001;

        pub const RESTART = 0x0002;

        pub const RESETHAND = 0x0004;

        pub const NOCLDSTOP = 0x0008;

        pub const NODEFER = 0x0010;

        pub const NOCLDWAIT = 0x0020;

        pub const SIGINFO = 0x0040;
    },
    .solaris, .illumos => struct {

        pub const ONSTACK = 0x00000001;

        pub const RESETHAND = 0x00000002;

        pub const RESTART = 0x00000004;

        pub const SIGINFO = 0x00000008;

        pub const NODEFER = 0x00000010;

        pub const NOCLDWAIT = 0x00010000;
    },
    .netbsd => struct {

        pub const ONSTACK = 0x0001;

        pub const RESTART = 0x0002;

        pub const RESETHAND = 0x0004;

        pub const NOCLDSTOP = 0x0008;

        pub const NODEFER = 0x0010;

        pub const NOCLDWAIT = 0x0020;

        pub const SIGINFO = 0x0040;
    },
    .dragonfly => struct {

        pub const ONSTACK = 0x0001;

        pub const RESTART = 0x0002;

        pub const RESETHAND = 0x0004;

        pub const NODEFER = 0x0010;

        pub const NOCLDWAIT = 0x0020;

        pub const SIGINFO = 0x0040;
    },
    .haiku => struct {

        pub const NOCLDSTOP = 0x01;

        pub const NOCLDWAIT = 0x02;

        pub const RESETHAND = 0x04;

        pub const NODEFER = 0x08;

        pub const RESTART = 0x10;

        pub const ONSTACK = 0x20;

        pub const SIGINFO = 0x40;

        pub const NOMASK = NODEFER;

        pub const STACK = ONSTACK;

        pub const ONESHOT = RESETHAND;
    },
    .openbsd => struct {

        pub const ONSTACK = 0x0001;

        pub const RESTART = 0x0002;

        pub const RESETHAND = 0x0004;

        pub const NOCLDSTOP = 0x0008;

        pub const NODEFER = 0x0010;

        pub const NOCLDWAIT = 0x0020;

        pub const SIGINFO = 0x0040;
    },
    else => void,

};
pub const sigval_t = switch (native_os) {
    .netbsd, .solaris, .illumos => extern union {
        int: i32,
        ptr: ?*anyopaque,
    },
    else => void,

};

pub const SC = switch (native_os) {
    .linux => linux.SC,
    else => void,

};

pub const _SC = if (builtin.abi.isAndroid()) enum(c_int) {
    PAGESIZE = 39,
    NPROCESSORS_ONLN = 97,
} else switch (native_os) {
    .driverkit, .ios, .macos, .tvos, .visionos, .watchos => enum(c_int) {
        PAGESIZE = 29,
    },
    .dragonfly => enum(c_int) {
        PAGESIZE = 47,
    },
    .freebsd => enum(c_int) {
        PAGESIZE = 47,
    },
    .fuchsia => enum(c_int) {
        PAGESIZE = 30,
    },
    .haiku => enum(c_int) {
        PAGESIZE = 27,
    },
    .linux => enum(c_int) {
        PAGESIZE = 30,
    },
    .netbsd => enum(c_int) {
        PAGESIZE = 28,
    },
    .openbsd => enum(c_int) {
        PAGESIZE = 28,
    },
    .solaris, .illumos => enum(c_int) {
        PAGESIZE = 11,
        NPROCESSORS_ONLN = 15,
    },
    else => void,

};

pub const SEEK = switch (native_os) {
    .linux => linux.SEEK,
    .emscripten => emscripten.SEEK,
    .wasi => struct {
        pub const SET: wasi.whence_t = .SET;
        pub const CUR: wasi.whence_t = .CUR;
        pub const END: wasi.whence_t = .END;
    },
    .openbsd, .haiku, .netbsd, .freebsd, .macos, .ios, .tvos, .watchos, .visionos, .windows => struct {

        pub const SET = 0;

        pub const CUR = 1;

        pub const END = 2;
    },
    .dragonfly, .solaris, .illumos => struct {

        pub const SET = 0;

        pub const CUR = 1;

        pub const END = 2;

        pub const DATA = 3;

        pub const HOLE = 4;
    },
    else => void,

};
pub const SHUT = switch (native_os) {
    .linux => linux.SHUT,
    .emscripten => emscripten.SHUT,
    else => struct {

        pub const RD = 0;

        pub const WR = 1;

        pub const RDWR = 2;
    },

};

/// Signal types
pub const SIG = switch (native_os) {
    .linux => linux.SIG,
    .emscripten => emscripten.SIG,
    .windows => struct {
        /// interrupt

        pub const INT = 2;
        /// illegal instruction - invalid function image

        pub const ILL = 4;
        /// floating point exception

        pub const FPE = 8;
        /// segment violation

        pub const SEGV = 11;
        /// Software termination signal from kill

        pub const TERM = 15;
        /// Ctrl-Break sequence
        pub const BREAK = 21;
        /// abnormal termination triggered by abort call

        pub const ABRT = 22;
        /// SIGABRT compatible with other platforms, same as SIGABRT

        pub const ABRT_COMPAT = 6;

        // Signal action codes
        /// default signal action
        pub const DFL = 0;
        /// ignore signal

        pub const IGN = 1;
        /// return current value

        pub const GET = 2;
        /// signal gets error

        pub const SGE = 3;
        /// acknowledge

        pub const ACK = 4;
        /// Signal error value (returned by signal call on error)

        pub const ERR = -1;
    },
    .macos, .ios, .tvos, .watchos, .visionos => struct {

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);

        pub const HOLD: ?Sigaction.handler_fn = @ptrFromInt(5);

        /// block specified signal set

        pub const BLOCK = 1;
        /// unblock specified signal set

        pub const UNBLOCK = 2;
        /// set specified signal set

        pub const SETMASK = 3;
        /// hangup

        pub const HUP = 1;
        /// interrupt

        pub const INT = 2;
        /// quit

        pub const QUIT = 3;
        /// illegal instruction (not reset when caught)

        pub const ILL = 4;
        /// trace trap (not reset when caught)

        pub const TRAP = 5;
        /// abort()

        pub const ABRT = 6;
        /// pollable event ([XSR] generated, not supported)
        pub const POLL = 7;
        /// compatibility

        pub const IOT = ABRT;
        /// EMT instruction

        pub const EMT = 7;
        /// floating point exception

        pub const FPE = 8;
        /// kill (cannot be caught or ignored)

        pub const KILL = 9;
        /// bus error

        pub const BUS = 10;
        /// segmentation violation

        pub const SEGV = 11;
        /// bad argument to system call

        pub const SYS = 12;
        /// write on a pipe with no one to read it

        pub const PIPE = 13;
        /// alarm clock

        pub const ALRM = 14;
        /// software termination signal from kill

        pub const TERM = 15;
        /// urgent condition on IO channel

        pub const URG = 16;
        /// sendable stop signal not from tty

        pub const STOP = 17;
        /// stop signal from tty

        pub const TSTP = 18;
        /// continue a stopped process

        pub const CONT = 19;
        /// to parent on child stop or exit

        pub const CHLD = 20;
        /// to readers pgrp upon background tty read

        pub const TTIN = 21;
        /// like TTIN for output if (tp->t_local&LTOSTOP)

        pub const TTOU = 22;
        /// input/output possible signal

        pub const IO = 23;
        /// exceeded CPU time limit

        pub const XCPU = 24;
        /// exceeded file size limit

        pub const XFSZ = 25;
        /// virtual time alarm

        pub const VTALRM = 26;
        /// profiling time alarm

        pub const PROF = 27;
        /// window size changes

        pub const WINCH = 28;
        /// information request

        pub const INFO = 29;
        /// user defined signal 1

        pub const USR1 = 30;
        /// user defined signal 2

        pub const USR2 = 31;
    },
    .freebsd => struct {

        pub const HUP = 1;

        pub const INT = 2;

        pub const QUIT = 3;

        pub const ILL = 4;

        pub const TRAP = 5;

        pub const ABRT = 6;

        pub const IOT = ABRT;

        pub const EMT = 7;

        pub const FPE = 8;

        pub const KILL = 9;

        pub const BUS = 10;

        pub const SEGV = 11;

        pub const SYS = 12;

        pub const PIPE = 13;

        pub const ALRM = 14;

        pub const TERM = 15;

        pub const URG = 16;

        pub const STOP = 17;

        pub const TSTP = 18;

        pub const CONT = 19;

        pub const CHLD = 20;

        pub const TTIN = 21;

        pub const TTOU = 22;

        pub const IO = 23;

        pub const XCPU = 24;

        pub const XFSZ = 25;

        pub const VTALRM = 26;

        pub const PROF = 27;

        pub const WINCH = 28;

        pub const INFO = 29;

        pub const USR1 = 30;

        pub const USR2 = 31;

        pub const THR = 32;

        pub const LWP = THR;

        pub const LIBRT = 33;

        pub const RTMIN = 65;

        pub const RTMAX = 126;

        pub const BLOCK = 1;

        pub const UNBLOCK = 2;

        pub const SETMASK = 3;

        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const WORDS = 4;

        pub const MAXSIG = 128;

        pub inline fn IDX(sig: usize) usize {
            return sig - 1;
        }

        pub inline fn WORD(sig: usize) usize {
            return IDX(sig) >> 5;
        }

        pub inline fn BIT(sig: usize) usize {
            return 1 << (IDX(sig) & 31);
        }

        pub inline fn VALID(sig: usize) usize {
            return sig <= MAXSIG and sig > 0;
        }
    },
    .solaris, .illumos => struct {

        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);
        pub const HOLD: ?Sigaction.handler_fn = @ptrFromInt(2);

        pub const WORDS = 4;
        pub const MAXSIG = 75;

        pub const SIG_BLOCK = 1;
        pub const SIG_UNBLOCK = 2;
        pub const SIG_SETMASK = 3;

        pub const HUP = 1;

        pub const INT = 2;

        pub const QUIT = 3;

        pub const ILL = 4;

        pub const TRAP = 5;
        pub const IOT = 6;

        pub const ABRT = 6;

        pub const EMT = 7;

        pub const FPE = 8;

        pub const KILL = 9;

        pub const BUS = 10;

        pub const SEGV = 11;

        pub const SYS = 12;

        pub const PIPE = 13;

        pub const ALRM = 14;

        pub const TERM = 15;
        pub const USR1 = 16;

        pub const USR2 = 17;

        pub const CLD = 18;

        pub const CHLD = 18;

        pub const PWR = 19;

        pub const WINCH = 20;

        pub const URG = 21;

        pub const POLL = 22;

        pub const IO = .POLL;

        pub const STOP = 23;

        pub const TSTP = 24;

        pub const CONT = 25;

        pub const TTIN = 26;

        pub const TTOU = 27;

        pub const VTALRM = 28;

        pub const PROF = 29;

        pub const XCPU = 30;

        pub const XFSZ = 31;

        pub const WAITING = 32;

        pub const LWP = 33;

        pub const FREEZE = 34;

        pub const THAW = 35;

        pub const CANCEL = 36;

        pub const LOST = 37;

        pub const XRES = 38;

        pub const JVM1 = 39;

        pub const JVM2 = 40;

        pub const INFO = 41;

        pub const RTMIN = 42;

        pub const RTMAX = 74;

        pub inline fn IDX(sig: usize) usize {
            return sig - 1;
        }

        pub inline fn WORD(sig: usize) usize {
            return IDX(sig) >> 5;
        }

        pub inline fn BIT(sig: usize) usize {
            return 1 << (IDX(sig) & 31);
        }

        pub inline fn VALID(sig: usize) usize {
            return sig <= MAXSIG and sig > 0;
        }
    },
    .netbsd => struct {

        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const WORDS = 4;
        pub const MAXSIG = 128;

        pub const BLOCK = 1;

        pub const UNBLOCK = 2;

        pub const SETMASK = 3;

        pub const HUP = 1;

        pub const INT = 2;

        pub const QUIT = 3;

        pub const ILL = 4;

        pub const TRAP = 5;

        pub const ABRT = 6;

        pub const IOT = ABRT;

        pub const EMT = 7;

        pub const FPE = 8;

        pub const KILL = 9;

        pub const BUS = 10;

        pub const SEGV = 11;

        pub const SYS = 12;

        pub const PIPE = 13;

        pub const ALRM = 14;

        pub const TERM = 15;

        pub const URG = 16;

        pub const STOP = 17;

        pub const TSTP = 18;

        pub const CONT = 19;

        pub const CHLD = 20;

        pub const TTIN = 21;

        pub const TTOU = 22;

        pub const IO = 23;

        pub const XCPU = 24;

        pub const XFSZ = 25;

        pub const VTALRM = 26;

        pub const PROF = 27;

        pub const WINCH = 28;

        pub const INFO = 29;

        pub const USR1 = 30;

        pub const USR2 = 31;

        pub const PWR = 32;

        pub const RTMIN = 33;
        pub const RTMAX = 63;

        pub inline fn IDX(sig: usize) usize {
            return sig - 1;
        }
        pub inline fn WORD(sig: usize) usize {
            return IDX(sig) >> 5;
        }
        pub inline fn BIT(sig: usize) usize {
            return 1 << (IDX(sig) & 31);
        }

        pub inline fn VALID(sig: usize) usize {
            return sig <= MAXSIG and sig > 0;
        }
    },
    .dragonfly => struct {

        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const BLOCK = 1;

        pub const UNBLOCK = 2;

        pub const SETMASK = 3;

        pub const IOT = ABRT;

        pub const HUP = 1;

        pub const INT = 2;

        pub const QUIT = 3;

        pub const ILL = 4;

        pub const TRAP = 5;

        pub const ABRT = 6;

        pub const EMT = 7;

        pub const FPE = 8;

        pub const KILL = 9;

        pub const BUS = 10;

        pub const SEGV = 11;

        pub const SYS = 12;

        pub const PIPE = 13;

        pub const ALRM = 14;

        pub const TERM = 15;

        pub const URG = 16;

        pub const STOP = 17;

        pub const TSTP = 18;

        pub const CONT = 19;

        pub const CHLD = 20;

        pub const TTIN = 21;

        pub const TTOU = 22;

        pub const IO = 23;

        pub const XCPU = 24;

        pub const XFSZ = 25;

        pub const VTALRM = 26;

        pub const PROF = 27;

        pub const WINCH = 28;

        pub const INFO = 29;

        pub const USR1 = 30;

        pub const USR2 = 31;
        pub const THR = 32;
        pub const CKPT = 33;

        pub const CKPTEXIT = 34;

        pub const WORDS = 4;
    },
    .haiku => struct {

        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const HOLD: ?Sigaction.handler_fn = @ptrFromInt(3);

        pub const HUP = 1;

        pub const INT = 2;

        pub const QUIT = 3;

        pub const ILL = 4;
        pub const CHLD = 5;

        pub const ABRT = 6;

        pub const IOT = ABRT;
        pub const PIPE = 7;

        pub const FPE = 8;

        pub const KILL = 9;

        pub const STOP = 10;

        pub const SEGV = 11;

        pub const CONT = 12;

        pub const TSTP = 13;

        pub const ALRM = 14;

        pub const TERM = 15;

        pub const TTIN = 16;

        pub const TTOU = 17;

        pub const USR1 = 18;

        pub const USR2 = 19;

        pub const WINCH = 20;

        pub const KILLTHR = 21;

        pub const TRAP = 22;

        pub const POLL = 23;

        pub const PROF = 24;

        pub const SYS = 25;

        pub const URG = 26;

        pub const VTALRM = 27;

        pub const XCPU = 28;

        pub const XFSZ = 29;

        pub const BUS = 30;

        pub const RESERVED1 = 31;

        pub const RESERVED2 = 32;

        pub const BLOCK = 1;

        pub const UNBLOCK = 2;

        pub const SETMASK = 3;
    },
    .openbsd => struct {
        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);

        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);

        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));

        pub const CATCH: ?Sigaction.handler_fn = @ptrFromInt(2);

        pub const HOLD: ?Sigaction.handler_fn = @ptrFromInt(3);

        pub const HUP = 1;

        pub const INT = 2;

        pub const QUIT = 3;

        pub const ILL = 4;

        pub const TRAP = 5;

        pub const ABRT = 6;

        pub const IOT = ABRT;

        pub const EMT = 7;

        pub const FPE = 8;

        pub const KILL = 9;

        pub const BUS = 10;

        pub const SEGV = 11;

        pub const SYS = 12;

        pub const PIPE = 13;

        pub const ALRM = 14;

        pub const TERM = 15;

        pub const URG = 16;

        pub const STOP = 17;

        pub const TSTP = 18;

        pub const CONT = 19;

        pub const CHLD = 20;

        pub const TTIN = 21;

        pub const TTOU = 22;

        pub const IO = 23;

        pub const XCPU = 24;

        pub const XFSZ = 25;

        pub const VTALRM = 26;

        pub const PROF = 27;

        pub const WINCH = 28;

        pub const INFO = 29;

        pub const USR1 = 30;

        pub const USR2 = 31;

        pub const PWR = 32;

        pub const BLOCK = 1;

        pub const UNBLOCK = 2;

        pub const SETMASK = 3;
    },
    else => void,

};

pub const SIOCGIFINDEX = switch (native_os) {
    .linux => linux.SIOCGIFINDEX,
    .emscripten => emscripten.SIOCGIFINDEX,
    .solaris, .illumos => solaris.SIOCGLIFINDEX,
    else => void,

};

pub const STDIN_FILENO = switch (native_os) {
    .linux => linux.STDIN_FILENO,
    .emscripten => emscripten.STDIN_FILENO,
    else => 0,

};
pub const STDOUT_FILENO = switch (native_os) {
    .linux => linux.STDOUT_FILENO,
    .emscripten => emscripten.STDOUT_FILENO,
    else => 1,

};
pub const STDERR_FILENO = switch (native_os) {
    .linux => linux.STDERR_FILENO,
    .emscripten => emscripten.STDERR_FILENO,
    else => 2,

};

pub const SYS = switch (native_os) {
    .linux => linux.SYS,
    else => void,

};
/// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
pub const Sigaction = switch (native_os) {
    .linux => switch (native_arch) {
        .mips,
        .mipsel,
        .mips64,
        .mips64el,
        => if (builtin.target.abi.isMusl())
            linux.Sigaction
        else if (builtin.target.ptrBitWidth() == 64) extern struct {

            pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;

            pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

            flags: c_uint,
            handler: extern union {
                handler: ?handler_fn,
                sigaction: ?sigaction_fn,
            },
            mask: sigset_t,
            restorer: ?*const fn () callconv(.c) void = null,
        } else extern struct {
            pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;
            pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

            flags: c_uint,
            handler: extern union {
                handler: ?handler_fn,
                sigaction: ?sigaction_fn,
            },
            mask: sigset_t,
            restorer: ?*const fn () callconv(.c) void = null,
            __resv: [1]c_int = .{0},
        },
        .s390x => if (builtin.abi == .gnu) extern struct {
            pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;
            pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

            handler: extern union {
                handler: ?handler_fn,
                sigaction: ?sigaction_fn,
            },
            __glibc_reserved0: c_int = 0,
            flags: c_uint,
            restorer: ?*const fn () callconv(.c) void = null,
            mask: sigset_t,
        } else linux.Sigaction,
        else => linux.Sigaction,
    },
    .emscripten => emscripten.Sigaction,
    .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {

        pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;

        pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

        handler: extern union {
            handler: ?handler_fn,
            sigaction: ?sigaction_fn,
        },
        mask: sigset_t,
        flags: c_uint,
    },
    .dragonfly, .freebsd => extern struct {

        pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;

        pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

        /// signal handler
        handler: extern union {
            handler: ?handler_fn,
            sigaction: ?sigaction_fn,
        },
        /// see signal options
        flags: c_uint,
        /// signal mask to apply
        mask: sigset_t,
    },
    .solaris, .illumos => extern struct {

        pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;

        pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

        /// signal options
        flags: c_uint,
        /// signal handler
        handler: extern union {
            handler: ?handler_fn,
            sigaction: ?sigaction_fn,
        },
        /// signal mask to apply
        mask: sigset_t,
    },
    .haiku => extern struct {
        pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;
        pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

        /// signal handler
        handler: extern union {
            handler: handler_fn,
            sigaction: sigaction_fn,
        },

        /// signal mask to apply
        mask: sigset_t,

        /// see signal options
        flags: i32,

        /// will be passed to the signal handler, BeOS extension
        userdata: *allowzero anyopaque = undefined,
    },
    .openbsd => extern struct {
        pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;
        pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;

        /// signal handler
        handler: extern union {
            handler: ?handler_fn,
            sigaction: ?sigaction_fn,
        },
        /// signal mask to apply
        mask: sigset_t,
        /// signal options
        flags: c_uint,
    },
    else => void,

};
pub const T = switch (native_os) {
    .linux => linux.T,
    .macos, .ios, .tvos, .watchos, .visionos => struct {
        pub const IOCGWINSZ = ior(0x40000000, 't', 104, @sizeOf(winsize));

        fn ior(inout: u32, group: usize, num: usize, len: usize) usize {
            return (inout | ((len & IOCPARM_MASK) << 16) | ((group) << 8) | (num));
        }
    },
    .freebsd => struct {

        pub const IOCEXCL = 0x2000740d;

        pub const IOCNXCL = 0x2000740e;

        pub const IOCSCTTY = 0x20007461;

        pub const IOCGPGRP = 0x40047477;

        pub const IOCSPGRP = 0x80047476;

        pub const IOCOUTQ = 0x40047473;

        pub const IOCSTI = 0x80017472;

        pub const IOCGWINSZ = 0x40087468;

        pub const IOCSWINSZ = 0x80087467;

        pub const IOCMGET = 0x4004746a;

        pub const IOCMBIS = 0x8004746c;

        pub const IOCMBIC = 0x8004746b;

        pub const IOCMSET = 0x8004746d;
        pub const FIONREAD = 0x4004667f;

        pub const IOCCONS = 0x80047462;

        pub const IOCPKT = 0x80047470;
        pub const FIONBIO = 0x8004667e;

        pub const IOCNOTTY = 0x20007471;

        pub const IOCSETD = 0x8004741b;

        pub const IOCGETD = 0x4004741a;

        pub const IOCSBRK = 0x2000747b;

        pub const IOCCBRK = 0x2000747a;

        pub const IOCGSID = 0x40047463;
        pub const IOCGPTN = 0x4004740f;
        pub const IOCSIG = 0x2004745f;
    },
    .solaris, .illumos => struct {
        pub const CGETA = tioc('T', 1);
        pub const CSETA = tioc('T', 2);

        pub const CSETAW = tioc('T', 3);

        pub const CSETAF = tioc('T', 4);

        pub const CSBRK = tioc('T', 5);

        pub const CXONC = tioc('T', 6);

        pub const CFLSH = tioc('T', 7);

        pub const IOCGWINSZ = tioc('T', 104);

        pub const IOCSWINSZ = tioc('T', 103);
        // Softcarrier ioctls

        pub const IOCGSOFTCAR = tioc('T', 105);

        pub const IOCSSOFTCAR = tioc('T', 106);
        // termios ioctls

        pub const CGETS = tioc('T', 13);

        pub const CSETS = tioc('T', 14);

        pub const CSANOW = tioc('T', 14);

        pub const CSETSW = tioc('T', 15);

        pub const CSADRAIN = tioc('T', 15);

        pub const CSETSF = tioc('T', 16);

        pub const IOCSETLD = tioc('T', 123);

        pub const IOCGETLD = tioc('T', 124);
        // NTP PPS ioctls

        pub const IOCGPPS = tioc('T', 125);

        pub const IOCSPPS = tioc('T', 126);

        pub const IOCGPPSEV = tioc('T', 127);

        pub const IOCGETD = tioc('t', 0);

        pub const IOCSETD = tioc('t', 1);

        pub const IOCHPCL = tioc('t', 2);

        pub const IOCGETP = tioc('t', 8);

        pub const IOCSETP = tioc('t', 9);

        pub const IOCSETN = tioc('t', 10);

        pub const IOCEXCL = tioc('t', 13);

        pub const IOCNXCL = tioc('t', 14);

        pub const IOCFLUSH = tioc('t', 16);

        pub const IOCSETC = tioc('t', 17);

        pub const IOCGETC = tioc('t', 18);
        /// bis local mode bits

        pub const IOCLBIS = tioc('t', 127);
        /// bic local mode bits

        pub const IOCLBIC = tioc('t', 126);
        /// set entire local mode word

        pub const IOCLSET = tioc('t', 125);
        /// get local modes

        pub const IOCLGET = tioc('t', 124);
        /// set break bit

        pub const IOCSBRK = tioc('t', 123);
        /// clear break bit

        pub const IOCCBRK = tioc('t', 122);
        /// set data terminal ready

        pub const IOCSDTR = tioc('t', 121);
        /// clear data terminal ready

        pub const IOCCDTR = tioc('t', 120);
        /// set local special chars

        pub const IOCSLTC = tioc('t', 117);
        /// get local special chars

        pub const IOCGLTC = tioc('t', 116);
        /// driver output queue size

        pub const IOCOUTQ = tioc('t', 115);
        /// void tty association

        pub const IOCNOTTY = tioc('t', 113);
        /// get a ctty

        pub const IOCSCTTY = tioc('t', 132);
        /// stop output, like ^S

        pub const IOCSTOP = tioc('t', 111);
        /// start output, like ^Q

        pub const IOCSTART = tioc('t', 110);
        /// get pgrp of tty

        pub const IOCGPGRP = tioc('t', 20);
        /// set pgrp of tty

        pub const IOCSPGRP = tioc('t', 21);
        /// get session id on ctty

        pub const IOCGSID = tioc('t', 22);
        /// simulate terminal input

        pub const IOCSTI = tioc('t', 23);
        /// set all modem bits

        pub const IOCMSET = tioc('t', 26);
        /// bis modem bits

        pub const IOCMBIS = tioc('t', 27);
        /// bic modem bits

        pub const IOCMBIC = tioc('t', 28);
        /// get all modem bits

        pub const IOCMGET = tioc('t', 29);

        fn tioc(t: u16, num: u8) u16 {
            return (t << 8) | num;
        }
    },
    .netbsd => struct {

        pub const IOCCBRK = 0x2000747a;

        pub const IOCCDTR = 0x20007478;

        pub const IOCCONS = 0x80047462;

        pub const IOCDCDTIMESTAMP = 0x40107458;

        pub const IOCDRAIN = 0x2000745e;

        pub const IOCEXCL = 0x2000740d;

        pub const IOCEXT = 0x80047460;

        pub const IOCFLAG_CDTRCTS = 0x10;

        pub const IOCFLAG_CLOCAL = 0x2;

        pub const IOCFLAG_CRTSCTS = 0x4;

        pub const IOCFLAG_MDMBUF = 0x8;

        pub const IOCFLAG_SOFTCAR = 0x1;

        pub const IOCFLUSH = 0x80047410;

        pub const IOCGETA = 0x402c7413;

        pub const IOCGETD = 0x4004741a;

        pub const IOCGFLAGS = 0x4004745d;

        pub const IOCGLINED = 0x40207442;

        pub const IOCGPGRP = 0x40047477;

        pub const IOCGQSIZE = 0x40047481;

        pub const IOCGRANTPT = 0x20007447;

        pub const IOCGSID = 0x40047463;