diff options
Diffstat (limited to 'src/windows_c.zig')
| -rw-r--r-- | src/windows_c.zig | 1032 |
1 files changed, 1032 insertions, 0 deletions
diff --git a/src/windows_c.zig b/src/windows_c.zig new file mode 100644 index 000000000..299614579 --- /dev/null +++ b/src/windows_c.zig @@ -0,0 +1,1032 @@ +const std = @import("std"); +const bun = @import("root").bun; +const builtin = @import("builtin"); +const win32 = std.os.windows; +const os = std.os; +const mem = std.mem; +const Stat = std.fs.File.Stat; +const Kind = std.fs.File.Kind; +const StatError = std.fs.File.StatError; + +pub fn getTotalMemory() usize { + return 0; +} +pub fn getSystemMemory() usize { + return 0; +} + +pub fn getFreeMemory() usize { + return 0; +} + +pub fn getSystemUptime() usize { + return 0; +} + +pub fn getSystemLoadavg() [3]f32 { + return .{ 0, 0, 0 }; +} + +pub const Mode = i32; +const Win32Error = bun.windows.Win32Error; + +// The way we do errors in Bun needs to get cleaned up. +// This is way too complicated. +// The problem is because we use libc in some cases and we use zig's std lib in other places and other times we go direct. +// So we end up with a lot of redundant code. +pub const SystemErrno = enum(u8) { + SUCCESS = 0, + EPERM = 1, + ENOENT = 2, + ESRCH = 3, + EINTR = 4, + EIO = 5, + ENXIO = 6, + E2BIG = 7, + ENOEXEC = 8, + EBADF = 9, + ECHILD = 10, + EAGAIN = 11, + ENOMEM = 12, + EACCES = 13, + EFAULT = 14, + ENOTBLK = 15, + EBUSY = 16, + EEXIST = 17, + EXDEV = 18, + ENODEV = 19, + ENOTDIR = 20, + EISDIR = 21, + EINVAL = 22, + ENFILE = 23, + EMFILE = 24, + ENOTTY = 25, + ETXTBSY = 26, + EFBIG = 27, + ENOSPC = 28, + ESPIPE = 29, + EROFS = 30, + EMLINK = 31, + EPIPE = 32, + EDOM = 33, + ERANGE = 34, + EDEADLK = 35, + ENAMETOOLONG = 36, + ENOLCK = 37, + ENOSYS = 38, + ENOTEMPTY = 39, + ELOOP = 40, + EWOULDBLOCK = 41, + ENOMSG = 42, + EIDRM = 43, + ECHRNG = 44, + EL2NSYNC = 45, + EL3HLT = 46, + EL3RST = 47, + ELNRNG = 48, + EUNATCH = 49, + ENOCSI = 50, + EL2HLT = 51, + EBADE = 52, + EBADR = 53, + EXFULL = 54, + ENOANO = 55, + EBADRQC = 56, + EBADSLT = 57, + EDEADLOCK = 58, + EBFONT = 59, + ENOSTR = 60, + ENODATA = 61, + ETIME = 62, + ENOSR = 63, + ENONET = 64, + ENOPKG = 65, + EREMOTE = 66, + ENOLINK = 67, + EADV = 68, + ESRMNT = 69, + ECOMM = 70, + EPROTO = 71, + EMULTIHOP = 72, + EDOTDOT = 73, + EBADMSG = 74, + EOVERFLOW = 75, + ENOTUNIQ = 76, + EBADFD = 77, + EREMCHG = 78, + ELIBACC = 79, + ELIBBAD = 80, + ELIBSCN = 81, + ELIBMAX = 82, + ELIBEXEC = 83, + EILSEQ = 84, + ERESTART = 85, + ESTRPIPE = 86, + EUSERS = 87, + ENOTSOCK = 88, + EDESTADDRREQ = 89, + EMSGSIZE = 90, + EPROTOTYPE = 91, + ENOPROTOOPT = 92, + EPROTONOSUPPORT = 93, + ESOCKTNOSUPPORT = 94, + /// For Linux, EOPNOTSUPP is the real value + /// but it's ~the same and is incompatible across operating systems + /// https://lists.gnu.org/archive/html/bug-glibc/2002-08/msg00017.html + ENOTSUP = 95, + EPFNOSUPPORT = 96, + EAFNOSUPPORT = 97, + EADDRINUSE = 98, + EADDRNOTAVAIL = 99, + ENETDOWN = 100, + ENETUNREACH = 101, + ENETRESET = 102, + ECONNABORTED = 103, + ECONNRESET = 104, + ENOBUFS = 105, + EISCONN = 106, + ENOTCONN = 107, + ESHUTDOWN = 108, + ETOOMANYREFS = 109, + ETIMEDOUT = 110, + ECONNREFUSED = 111, + EHOSTDOWN = 112, + EHOSTUNREACH = 113, + EALREADY = 114, + EINPROGRESS = 115, + ESTALE = 116, + EUCLEAN = 117, + ENOTNAM = 118, + ENAVAIL = 119, + EISNAM = 120, + EREMOTEIO = 121, + EDQUOT = 122, + ENOMEDIUM = 123, + EMEDIUMTYPE = 124, + ECANCELED = 125, + ENOKEY = 126, + EKEYEXPIRED = 127, + EKEYREVOKED = 128, + EKEYREJECTED = 129, + EOWNERDEAD = 130, + ENOTRECOVERABLE = 131, + ERFKILL = 132, + EHWPOISON = 133, + // made up erropr + EUNKNOWN = 134, + ECHARSET = 135, + EOF = 136, + + pub const max = 137; + + pub const Error = error{ + PERM, + NOENT, + SRCH, + INTR, + IO, + NXIO, + @"2BIG", + NOEXEC, + BADF, + CHILD, + AGAIN, + NOMEM, + ACCES, + FAULT, + NOTBLK, + BUSY, + EXIST, + XDEV, + NODEV, + NOTDIR, + ISDIR, + INVAL, + NFILE, + MFILE, + NOTTY, + TXTBSY, + FBIG, + NOSPC, + SPIPE, + ROFS, + MLINK, + PIPE, + DOM, + RANGE, + DEADLK, + NAMETOOLONG, + NOLCK, + NOSYS, + NOTEMPTY, + LOOP, + WOULDBLOCK, + NOMSG, + IDRM, + CHRNG, + L2NSYNC, + L3HLT, + L3RST, + LNRNG, + UNATCH, + NOCSI, + L2HLT, + BADE, + BADR, + XFULL, + NOANO, + BADRQC, + BADSLT, + DEADLOCK, + BFONT, + NOSTR, + NODATA, + TIME, + NOSR, + NONET, + NOPKG, + REMOTE, + NOLINK, + ADV, + SRMNT, + COMM, + PROTO, + MULTIHOP, + DOTDOT, + BADMSG, + OVERFLOW, + NOTUNIQ, + BADFD, + REMCHG, + LIBACC, + LIBBAD, + LIBSCN, + LIBMAX, + LIBEXEC, + ILSEQ, + RESTART, + STRPIPE, + USERS, + NOTSOCK, + DESTADDRREQ, + MSGSIZE, + PROTOTYPE, + NOPROTOOPT, + PROTONOSUPPORT, + SOCKTNOSUPPORT, + NOTSUP, + PFNOSUPPORT, + AFNOSUPPORT, + ADDRINUSE, + ADDRNOTAVAIL, + NETDOWN, + NETUNREACH, + NETRESET, + CONNABORTED, + CONNRESET, + NOBUFS, + ISCONN, + NOTCONN, + SHUTDOWN, + TOOMANYREFS, + TIMEDOUT, + CONNREFUSED, + HOSTDOWN, + HOSTUNREACH, + ALREADY, + INPROGRESS, + STALE, + UCLEAN, + NOTNAM, + NAVAIL, + ISNAM, + REMOTEIO, + DQUOT, + NOMEDIUM, + MEDIUMTYPE, + CANCELED, + NOKEY, + KEYEXPIRED, + KEYREVOKED, + KEYREJECTED, + OWNERDEAD, + NOTRECOVERABLE, + RFKILL, + HWPOISON, + UNKNOWN, + CHARSET, + OF, + Unexpected, + }; + + pub inline fn toE(this: SystemErrno) E { + return @enumFromInt(@intFromEnum(this)); + } + + const error_map: [SystemErrno.max]Error = brk: { + var errors: [SystemErrno.max]Error = undefined; + errors[@intFromEnum(SystemErrno.EPERM)] = error.PERM; + errors[@intFromEnum(SystemErrno.ENOENT)] = error.NOENT; + errors[@intFromEnum(SystemErrno.ESRCH)] = error.SRCH; + errors[@intFromEnum(SystemErrno.EINTR)] = error.INTR; + errors[@intFromEnum(SystemErrno.EIO)] = error.IO; + errors[@intFromEnum(SystemErrno.ENXIO)] = error.NXIO; + errors[@intFromEnum(SystemErrno.E2BIG)] = error.@"2BIG"; + errors[@intFromEnum(SystemErrno.ENOEXEC)] = error.NOEXEC; + errors[@intFromEnum(SystemErrno.EBADF)] = error.BADF; + errors[@intFromEnum(SystemErrno.ECHILD)] = error.CHILD; + errors[@intFromEnum(SystemErrno.EAGAIN)] = error.AGAIN; + errors[@intFromEnum(SystemErrno.ENOMEM)] = error.NOMEM; + errors[@intFromEnum(SystemErrno.EACCES)] = error.ACCES; + errors[@intFromEnum(SystemErrno.EFAULT)] = error.FAULT; + errors[@intFromEnum(SystemErrno.ENOTBLK)] = error.NOTBLK; + errors[@intFromEnum(SystemErrno.EBUSY)] = error.BUSY; + errors[@intFromEnum(SystemErrno.EEXIST)] = error.EXIST; + errors[@intFromEnum(SystemErrno.EXDEV)] = error.XDEV; + errors[@intFromEnum(SystemErrno.ENODEV)] = error.NODEV; + errors[@intFromEnum(SystemErrno.ENOTDIR)] = error.NOTDIR; + errors[@intFromEnum(SystemErrno.EISDIR)] = error.ISDIR; + errors[@intFromEnum(SystemErrno.EINVAL)] = error.INVAL; + errors[@intFromEnum(SystemErrno.ENFILE)] = error.NFILE; + errors[@intFromEnum(SystemErrno.EMFILE)] = error.MFILE; + errors[@intFromEnum(SystemErrno.ENOTTY)] = error.NOTTY; + errors[@intFromEnum(SystemErrno.ETXTBSY)] = error.TXTBSY; + errors[@intFromEnum(SystemErrno.EFBIG)] = error.FBIG; + errors[@intFromEnum(SystemErrno.ENOSPC)] = error.NOSPC; + errors[@intFromEnum(SystemErrno.ESPIPE)] = error.SPIPE; + errors[@intFromEnum(SystemErrno.EROFS)] = error.ROFS; + errors[@intFromEnum(SystemErrno.EMLINK)] = error.MLINK; + errors[@intFromEnum(SystemErrno.EPIPE)] = error.PIPE; + errors[@intFromEnum(SystemErrno.EDOM)] = error.DOM; + errors[@intFromEnum(SystemErrno.ERANGE)] = error.RANGE; + errors[@intFromEnum(SystemErrno.EDEADLK)] = error.DEADLK; + errors[@intFromEnum(SystemErrno.ENAMETOOLONG)] = error.NAMETOOLONG; + errors[@intFromEnum(SystemErrno.ENOLCK)] = error.NOLCK; + errors[@intFromEnum(SystemErrno.ENOSYS)] = error.NOSYS; + errors[@intFromEnum(SystemErrno.ENOTEMPTY)] = error.NOTEMPTY; + errors[@intFromEnum(SystemErrno.ELOOP)] = error.LOOP; + errors[@intFromEnum(SystemErrno.EWOULDBLOCK)] = error.WOULDBLOCK; + errors[@intFromEnum(SystemErrno.ENOMSG)] = error.NOMSG; + errors[@intFromEnum(SystemErrno.EIDRM)] = error.IDRM; + errors[@intFromEnum(SystemErrno.ECHRNG)] = error.CHRNG; + errors[@intFromEnum(SystemErrno.EL2NSYNC)] = error.L2NSYNC; + errors[@intFromEnum(SystemErrno.EL3HLT)] = error.L3HLT; + errors[@intFromEnum(SystemErrno.EL3RST)] = error.L3RST; + errors[@intFromEnum(SystemErrno.ELNRNG)] = error.LNRNG; + errors[@intFromEnum(SystemErrno.EUNATCH)] = error.UNATCH; + errors[@intFromEnum(SystemErrno.ENOCSI)] = error.NOCSI; + errors[@intFromEnum(SystemErrno.EL2HLT)] = error.L2HLT; + errors[@intFromEnum(SystemErrno.EBADE)] = error.BADE; + errors[@intFromEnum(SystemErrno.EBADR)] = error.BADR; + errors[@intFromEnum(SystemErrno.EXFULL)] = error.XFULL; + errors[@intFromEnum(SystemErrno.ENOANO)] = error.NOANO; + errors[@intFromEnum(SystemErrno.EBADRQC)] = error.BADRQC; + errors[@intFromEnum(SystemErrno.EBADSLT)] = error.BADSLT; + errors[@intFromEnum(SystemErrno.EDEADLOCK)] = error.DEADLOCK; + errors[@intFromEnum(SystemErrno.EBFONT)] = error.BFONT; + errors[@intFromEnum(SystemErrno.ENOSTR)] = error.NOSTR; + errors[@intFromEnum(SystemErrno.ENODATA)] = error.NODATA; + errors[@intFromEnum(SystemErrno.ETIME)] = error.TIME; + errors[@intFromEnum(SystemErrno.ENOSR)] = error.NOSR; + errors[@intFromEnum(SystemErrno.ENONET)] = error.NONET; + errors[@intFromEnum(SystemErrno.ENOPKG)] = error.NOPKG; + errors[@intFromEnum(SystemErrno.EREMOTE)] = error.REMOTE; + errors[@intFromEnum(SystemErrno.ENOLINK)] = error.NOLINK; + errors[@intFromEnum(SystemErrno.EADV)] = error.ADV; + errors[@intFromEnum(SystemErrno.ESRMNT)] = error.SRMNT; + errors[@intFromEnum(SystemErrno.ECOMM)] = error.COMM; + errors[@intFromEnum(SystemErrno.EPROTO)] = error.PROTO; + errors[@intFromEnum(SystemErrno.EMULTIHOP)] = error.MULTIHOP; + errors[@intFromEnum(SystemErrno.EDOTDOT)] = error.DOTDOT; + errors[@intFromEnum(SystemErrno.EBADMSG)] = error.BADMSG; + errors[@intFromEnum(SystemErrno.EOVERFLOW)] = error.OVERFLOW; + errors[@intFromEnum(SystemErrno.ENOTUNIQ)] = error.NOTUNIQ; + errors[@intFromEnum(SystemErrno.EBADFD)] = error.BADFD; + errors[@intFromEnum(SystemErrno.EREMCHG)] = error.REMCHG; + errors[@intFromEnum(SystemErrno.ELIBACC)] = error.LIBACC; + errors[@intFromEnum(SystemErrno.ELIBBAD)] = error.LIBBAD; + errors[@intFromEnum(SystemErrno.ELIBSCN)] = error.LIBSCN; + errors[@intFromEnum(SystemErrno.ELIBMAX)] = error.LIBMAX; + errors[@intFromEnum(SystemErrno.ELIBEXEC)] = error.LIBEXEC; + errors[@intFromEnum(SystemErrno.EILSEQ)] = error.ILSEQ; + errors[@intFromEnum(SystemErrno.ERESTART)] = error.RESTART; + errors[@intFromEnum(SystemErrno.ESTRPIPE)] = error.STRPIPE; + errors[@intFromEnum(SystemErrno.EUSERS)] = error.USERS; + errors[@intFromEnum(SystemErrno.ENOTSOCK)] = error.NOTSOCK; + errors[@intFromEnum(SystemErrno.EDESTADDRREQ)] = error.DESTADDRREQ; + errors[@intFromEnum(SystemErrno.EMSGSIZE)] = error.MSGSIZE; + errors[@intFromEnum(SystemErrno.EPROTOTYPE)] = error.PROTOTYPE; + errors[@intFromEnum(SystemErrno.ENOPROTOOPT)] = error.NOPROTOOPT; + errors[@intFromEnum(SystemErrno.EPROTONOSUPPORT)] = error.PROTONOSUPPORT; + errors[@intFromEnum(SystemErrno.ESOCKTNOSUPPORT)] = error.SOCKTNOSUPPORT; + errors[@intFromEnum(SystemErrno.ENOTSUP)] = error.NOTSUP; + errors[@intFromEnum(SystemErrno.EPFNOSUPPORT)] = error.PFNOSUPPORT; + errors[@intFromEnum(SystemErrno.EAFNOSUPPORT)] = error.AFNOSUPPORT; + errors[@intFromEnum(SystemErrno.EADDRINUSE)] = error.ADDRINUSE; + errors[@intFromEnum(SystemErrno.EADDRNOTAVAIL)] = error.ADDRNOTAVAIL; + errors[@intFromEnum(SystemErrno.ENETDOWN)] = error.NETDOWN; + errors[@intFromEnum(SystemErrno.ENETUNREACH)] = error.NETUNREACH; + errors[@intFromEnum(SystemErrno.ENETRESET)] = error.NETRESET; + errors[@intFromEnum(SystemErrno.ECONNABORTED)] = error.CONNABORTED; + errors[@intFromEnum(SystemErrno.ECONNRESET)] = error.CONNRESET; + errors[@intFromEnum(SystemErrno.ENOBUFS)] = error.NOBUFS; + errors[@intFromEnum(SystemErrno.EISCONN)] = error.ISCONN; + errors[@intFromEnum(SystemErrno.ENOTCONN)] = error.NOTCONN; + errors[@intFromEnum(SystemErrno.ESHUTDOWN)] = error.SHUTDOWN; + errors[@intFromEnum(SystemErrno.ETOOMANYREFS)] = error.TOOMANYREFS; + errors[@intFromEnum(SystemErrno.ETIMEDOUT)] = error.TIMEDOUT; + errors[@intFromEnum(SystemErrno.ECONNREFUSED)] = error.CONNREFUSED; + errors[@intFromEnum(SystemErrno.EHOSTDOWN)] = error.HOSTDOWN; + errors[@intFromEnum(SystemErrno.EHOSTUNREACH)] = error.HOSTUNREACH; + errors[@intFromEnum(SystemErrno.EALREADY)] = error.ALREADY; + errors[@intFromEnum(SystemErrno.EINPROGRESS)] = error.INPROGRESS; + errors[@intFromEnum(SystemErrno.ESTALE)] = error.STALE; + errors[@intFromEnum(SystemErrno.EUCLEAN)] = error.UCLEAN; + errors[@intFromEnum(SystemErrno.ENOTNAM)] = error.NOTNAM; + errors[@intFromEnum(SystemErrno.ENAVAIL)] = error.NAVAIL; + errors[@intFromEnum(SystemErrno.EISNAM)] = error.ISNAM; + errors[@intFromEnum(SystemErrno.EREMOTEIO)] = error.REMOTEIO; + errors[@intFromEnum(SystemErrno.EDQUOT)] = error.DQUOT; + errors[@intFromEnum(SystemErrno.ENOMEDIUM)] = error.NOMEDIUM; + errors[@intFromEnum(SystemErrno.EMEDIUMTYPE)] = error.MEDIUMTYPE; + errors[@intFromEnum(SystemErrno.ECANCELED)] = error.CANCELED; + errors[@intFromEnum(SystemErrno.ENOKEY)] = error.NOKEY; + errors[@intFromEnum(SystemErrno.EKEYEXPIRED)] = error.KEYEXPIRED; + errors[@intFromEnum(SystemErrno.EKEYREVOKED)] = error.KEYREVOKED; + errors[@intFromEnum(SystemErrno.EKEYREJECTED)] = error.KEYREJECTED; + errors[@intFromEnum(SystemErrno.EOWNERDEAD)] = error.OWNERDEAD; + errors[@intFromEnum(SystemErrno.ENOTRECOVERABLE)] = error.NOTRECOVERABLE; + errors[@intFromEnum(SystemErrno.ERFKILL)] = error.RFKILL; + errors[@intFromEnum(SystemErrno.EHWPOISON)] = error.HWPOISON; + errors[@intFromEnum(SystemErrno.EUNKNOWN)] = error.UNKNOWN; + errors[@intFromEnum(SystemErrno.ECHARSET)] = error.CHARSET; + errors[@intFromEnum(SystemErrno.EOF)] = error.OF; + break :brk errors; + }; + + pub fn fromError(err: anyerror) ?SystemErrno { + return switch (err) { + error.PERM => SystemErrno.EPERM, + error.NOENT => SystemErrno.ENOENT, + error.SRCH => SystemErrno.ESRCH, + error.INTR => SystemErrno.EINTR, + error.IO => SystemErrno.EIO, + error.NXIO => SystemErrno.ENXIO, + error.@"2BIG" => SystemErrno.E2BIG, + error.NOEXEC => SystemErrno.ENOEXEC, + error.BADF => SystemErrno.EBADF, + error.CHILD => SystemErrno.ECHILD, + error.AGAIN => SystemErrno.EAGAIN, + error.NOMEM => SystemErrno.ENOMEM, + error.ACCES => SystemErrno.EACCES, + error.FAULT => SystemErrno.EFAULT, + error.NOTBLK => SystemErrno.ENOTBLK, + error.BUSY => SystemErrno.EBUSY, + error.EXIST => SystemErrno.EEXIST, + error.XDEV => SystemErrno.EXDEV, + error.NODEV => SystemErrno.ENODEV, + error.NOTDIR => SystemErrno.ENOTDIR, + error.ISDIR => SystemErrno.EISDIR, + error.INVAL => SystemErrno.EINVAL, + error.NFILE => SystemErrno.ENFILE, + error.MFILE => SystemErrno.EMFILE, + error.NOTTY => SystemErrno.ENOTTY, + error.TXTBSY => SystemErrno.ETXTBSY, + error.FBIG => SystemErrno.EFBIG, + error.NOSPC => SystemErrno.ENOSPC, + error.SPIPE => SystemErrno.ESPIPE, + error.ROFS => SystemErrno.EROFS, + error.MLINK => SystemErrno.EMLINK, + error.PIPE => SystemErrno.EPIPE, + error.DOM => SystemErrno.EDOM, + error.RANGE => SystemErrno.ERANGE, + error.DEADLK => SystemErrno.EDEADLK, + error.NAMETOOLONG => SystemErrno.ENAMETOOLONG, + error.NOLCK => SystemErrno.ENOLCK, + error.NOSYS => SystemErrno.ENOSYS, + error.NOTEMPTY => SystemErrno.ENOTEMPTY, + error.LOOP => SystemErrno.ELOOP, + error.WOULDBLOCK => SystemErrno.EWOULDBLOCK, + error.NOMSG => SystemErrno.ENOMSG, + error.IDRM => SystemErrno.EIDRM, + error.CHRNG => SystemErrno.ECHRNG, + error.L2NSYNC => SystemErrno.EL2NSYNC, + error.L3HLT => SystemErrno.EL3HLT, + error.L3RST => SystemErrno.EL3RST, + error.LNRNG => SystemErrno.ELNRNG, + error.UNATCH => SystemErrno.EUNATCH, + error.NOCSI => SystemErrno.ENOCSI, + error.L2HLT => SystemErrno.EL2HLT, + error.BADE => SystemErrno.EBADE, + error.BADR => SystemErrno.EBADR, + error.XFULL => SystemErrno.EXFULL, + error.NOANO => SystemErrno.ENOANO, + error.BADRQC => SystemErrno.EBADRQC, + error.BADSLT => SystemErrno.EBADSLT, + error.DEADLOCK => SystemErrno.EDEADLOCK, + error.BFONT => SystemErrno.EBFONT, + error.NOSTR => SystemErrno.ENOSTR, + error.NODATA => SystemErrno.ENODATA, + error.TIME => SystemErrno.ETIME, + error.NOSR => SystemErrno.ENOSR, + error.NONET => SystemErrno.ENONET, + error.NOPKG => SystemErrno.ENOPKG, + error.REMOTE => SystemErrno.EREMOTE, + error.NOLINK => SystemErrno.ENOLINK, + error.ADV => SystemErrno.EADV, + error.SRMNT => SystemErrno.ESRMNT, + error.COMM => SystemErrno.ECOMM, + error.PROTO => SystemErrno.EPROTO, + error.MULTIHOP => SystemErrno.EMULTIHOP, + error.DOTDOT => SystemErrno.EDOTDOT, + error.BADMSG => SystemErrno.EBADMSG, + error.OVERFLOW => SystemErrno.EOVERFLOW, + error.NOTUNIQ => SystemErrno.ENOTUNIQ, + error.BADFD => SystemErrno.EBADFD, + error.REMCHG => SystemErrno.EREMCHG, + error.LIBACC => SystemErrno.ELIBACC, + error.LIBBAD => SystemErrno.ELIBBAD, + error.LIBSCN => SystemErrno.ELIBSCN, + error.LIBMAX => SystemErrno.ELIBMAX, + error.LIBEXEC => SystemErrno.ELIBEXEC, + error.ILSEQ => SystemErrno.EILSEQ, + error.RESTART => SystemErrno.ERESTART, + error.STRPIPE => SystemErrno.ESTRPIPE, + error.USERS => SystemErrno.EUSERS, + error.NOTSOCK => SystemErrno.ENOTSOCK, + error.DESTADDRREQ => SystemErrno.EDESTADDRREQ, + error.MSGSIZE => SystemErrno.EMSGSIZE, + error.PROTOTYPE => SystemErrno.EPROTOTYPE, + error.NOPROTOOPT => SystemErrno.ENOPROTOOPT, + error.PROTONOSUPPORT => SystemErrno.EPROTONOSUPPORT, + error.SOCKTNOSUPPORT => SystemErrno.ESOCKTNOSUPPORT, + error.NOTSUP => SystemErrno.ENOTSUP, + error.PFNOSUPPORT => SystemErrno.EPFNOSUPPORT, + error.AFNOSUPPORT => SystemErrno.EAFNOSUPPORT, + error.ADDRINUSE => SystemErrno.EADDRINUSE, + error.ADDRNOTAVAIL => SystemErrno.EADDRNOTAVAIL, + error.NETDOWN => SystemErrno.ENETDOWN, + error.NETUNREACH => SystemErrno.ENETUNREACH, + error.NETRESET => SystemErrno.ENETRESET, + error.CONNABORTED => SystemErrno.ECONNABORTED, + error.CONNRESET => SystemErrno.ECONNRESET, + error.NOBUFS => SystemErrno.ENOBUFS, + error.ISCONN => SystemErrno.EISCONN, + error.NOTCONN => SystemErrno.ENOTCONN, + error.SHUTDOWN => SystemErrno.ESHUTDOWN, + error.TOOMANYREFS => SystemErrno.ETOOMANYREFS, + error.TIMEDOUT => SystemErrno.ETIMEDOUT, + error.CONNREFUSED => SystemErrno.ECONNREFUSED, + error.HOSTDOWN => SystemErrno.EHOSTDOWN, + error.HOSTUNREACH => SystemErrno.EHOSTUNREACH, + error.ALREADY => SystemErrno.EALREADY, + error.INPROGRESS => SystemErrno.EINPROGRESS, + error.STALE => SystemErrno.ESTALE, + error.UCLEAN => SystemErrno.EUCLEAN, + error.NOTNAM => SystemErrno.ENOTNAM, + error.NAVAIL => SystemErrno.ENAVAIL, + error.ISNAM => SystemErrno.EISNAM, + error.REMOTEIO => SystemErrno.EREMOTEIO, + error.DQUOT => SystemErrno.EDQUOT, + error.NOMEDIUM => SystemErrno.ENOMEDIUM, + error.MEDIUMTYPE => SystemErrno.EMEDIUMTYPE, + error.CANCELED => SystemErrno.ECANCELED, + error.NOKEY => SystemErrno.ENOKEY, + error.KEYEXPIRED => SystemErrno.EKEYEXPIRED, + error.KEYREVOKED => SystemErrno.EKEYREVOKED, + error.KEYREJECTED => SystemErrno.EKEYREJECTED, + error.OWNERDEAD => SystemErrno.EOWNERDEAD, + error.NOTRECOVERABLE => SystemErrno.ENOTRECOVERABLE, + error.RFKILL => SystemErrno.ERFKILL, + error.HWPOISON => SystemErrno.EHWPOISON, + error.UNKNOWN => SystemErrno.EUNKNOWN, + error.CHARSET => SystemErrno.ECHARSET, + error.OF => SystemErrno.EOF, + else => return null, + }; + } + pub fn toError(this: SystemErrno) Error { + return error_map[@intFromEnum(this)]; + } + + pub fn init(code: anytype) ?SystemErrno { + if (comptime @TypeOf(code) == u16) { + if (code <= 3950) { + return init(@as(Win32Error, @enumFromInt(code))); + } else { + if (comptime bun.Environment.allow_assert) + bun.Output.debug("Unknown error code: {}\n", .{code}); + + return null; + } + } + + if (comptime @TypeOf(code) == Win32Error) { + return switch (code) { + Win32Error.NOACCESS => SystemErrno.EACCES, + @as(Win32Error, @enumFromInt(10013)) => SystemErrno.EACCES, + Win32Error.ELEVATION_REQUIRED => SystemErrno.EACCES, + Win32Error.CANT_ACCESS_FILE => SystemErrno.EACCES, + Win32Error.ADDRESS_ALREADY_ASSOCIATED => SystemErrno.EADDRINUSE, + Win32Error.WSAEADDRINUSE => SystemErrno.EADDRINUSE, + Win32Error.WSAEADDRNOTAVAIL => SystemErrno.EADDRNOTAVAIL, + Win32Error.WSAEAFNOSUPPORT => SystemErrno.EAFNOSUPPORT, + Win32Error.WSAEWOULDBLOCK => SystemErrno.EAGAIN, + Win32Error.WSAEALREADY => SystemErrno.EALREADY, + Win32Error.INVALID_FLAGS => SystemErrno.EBADF, + Win32Error.INVALID_HANDLE => SystemErrno.EBADF, + Win32Error.LOCK_VIOLATION => SystemErrno.EBUSY, + Win32Error.PIPE_BUSY => SystemErrno.EBUSY, + Win32Error.SHARING_VIOLATION => SystemErrno.EBUSY, + Win32Error.OPERATION_ABORTED => SystemErrno.ECANCELED, + Win32Error.WSAEINTR => SystemErrno.ECANCELED, + Win32Error.NO_UNICODE_TRANSLATION => SystemErrno.ECHARSET, + Win32Error.CONNECTION_ABORTED => SystemErrno.ECONNABORTED, + Win32Error.WSAECONNABORTED => SystemErrno.ECONNABORTED, + Win32Error.CONNECTION_REFUSED => SystemErrno.ECONNREFUSED, + Win32Error.WSAECONNREFUSED => SystemErrno.ECONNREFUSED, + Win32Error.NETNAME_DELETED => SystemErrno.ECONNRESET, + Win32Error.WSAECONNRESET => SystemErrno.ECONNRESET, + Win32Error.ALREADY_EXISTS => SystemErrno.EEXIST, + Win32Error.FILE_EXISTS => SystemErrno.EEXIST, + Win32Error.BUFFER_OVERFLOW => SystemErrno.EFAULT, + Win32Error.WSAEFAULT => SystemErrno.EFAULT, + Win32Error.HOST_UNREACHABLE => SystemErrno.EHOSTUNREACH, + Win32Error.WSAEHOSTUNREACH => SystemErrno.EHOSTUNREACH, + Win32Error.INSUFFICIENT_BUFFER => SystemErrno.EINVAL, + Win32Error.INVALID_DATA => SystemErrno.EINVAL, + Win32Error.INVALID_PARAMETER => SystemErrno.EINVAL, + Win32Error.SYMLINK_NOT_SUPPORTED => SystemErrno.EINVAL, + Win32Error.WSAEINVAL => SystemErrno.EINVAL, + Win32Error.WSAEPFNOSUPPORT => SystemErrno.EINVAL, + Win32Error.BEGINNING_OF_MEDIA => SystemErrno.EIO, + Win32Error.BUS_RESET => SystemErrno.EIO, + Win32Error.CRC => SystemErrno.EIO, + Win32Error.DEVICE_DOOR_OPEN => SystemErrno.EIO, + Win32Error.DEVICE_REQUIRES_CLEANING => SystemErrno.EIO, + Win32Error.DISK_CORRUPT => SystemErrno.EIO, + Win32Error.EOM_OVERFLOW => SystemErrno.EIO, + Win32Error.FILEMARK_DETECTED => SystemErrno.EIO, + Win32Error.GEN_FAILURE => SystemErrno.EIO, + Win32Error.INVALID_BLOCK_LENGTH => SystemErrno.EIO, + Win32Error.IO_DEVICE => SystemErrno.EIO, + Win32Error.NO_DATA_DETECTED => SystemErrno.EIO, + Win32Error.NO_SIGNAL_SENT => SystemErrno.EIO, + Win32Error.OPEN_FAILED => SystemErrno.EIO, + Win32Error.SETMARK_DETECTED => SystemErrno.EIO, + Win32Error.SIGNAL_REFUSED => SystemErrno.EIO, + Win32Error.WSAEISCONN => SystemErrno.EISCONN, + Win32Error.CANT_RESOLVE_FILENAME => SystemErrno.ELOOP, + Win32Error.TOO_MANY_OPEN_FILES => SystemErrno.EMFILE, + Win32Error.WSAEMFILE => SystemErrno.EMFILE, + Win32Error.WSAEMSGSIZE => SystemErrno.EMSGSIZE, + Win32Error.FILENAME_EXCED_RANGE => SystemErrno.ENAMETOOLONG, + Win32Error.NETWORK_UNREACHABLE => SystemErrno.ENETUNREACH, + Win32Error.WSAENETUNREACH => SystemErrno.ENETUNREACH, + Win32Error.WSAENOBUFS => SystemErrno.ENOBUFS, + Win32Error.BAD_PATHNAME => SystemErrno.ENOENT, + Win32Error.DIRECTORY => SystemErrno.ENOENT, + Win32Error.ENVVAR_NOT_FOUND => SystemErrno.ENOENT, + Win32Error.FILE_NOT_FOUND => SystemErrno.ENOENT, + Win32Error.INVALID_NAME => SystemErrno.ENOENT, + Win32Error.INVALID_DRIVE => SystemErrno.ENOENT, + Win32Error.INVALID_REPARSE_DATA => SystemErrno.ENOENT, + Win32Error.MOD_NOT_FOUND => SystemErrno.ENOENT, + Win32Error.PATH_NOT_FOUND => SystemErrno.ENOENT, + Win32Error.WSAHOST_NOT_FOUND => SystemErrno.ENOENT, + Win32Error.WSANO_DATA => SystemErrno.ENOENT, + Win32Error.NOT_ENOUGH_MEMORY => SystemErrno.ENOMEM, + Win32Error.OUTOFMEMORY => SystemErrno.ENOMEM, + Win32Error.CANNOT_MAKE => SystemErrno.ENOSPC, + Win32Error.DISK_FULL => SystemErrno.ENOSPC, + Win32Error.EA_TABLE_FULL => SystemErrno.ENOSPC, + Win32Error.END_OF_MEDIA => SystemErrno.ENOSPC, + Win32Error.HANDLE_DISK_FULL => SystemErrno.ENOSPC, + Win32Error.NOT_CONNECTED => SystemErrno.ENOTCONN, + Win32Error.WSAENOTCONN => SystemErrno.ENOTCONN, + Win32Error.DIR_NOT_EMPTY => SystemErrno.ENOTEMPTY, + Win32Error.WSAENOTSOCK => SystemErrno.ENOTSOCK, + Win32Error.NOT_SUPPORTED => SystemErrno.ENOTSUP, + Win32Error.BROKEN_PIPE => SystemErrno.EOF, + Win32Error.ACCESS_DENIED => SystemErrno.EPERM, + Win32Error.PRIVILEGE_NOT_HELD => SystemErrno.EPERM, + Win32Error.BAD_PIPE => SystemErrno.EPIPE, + Win32Error.NO_DATA => SystemErrno.EPIPE, + Win32Error.PIPE_NOT_CONNECTED => SystemErrno.EPIPE, + Win32Error.WSAESHUTDOWN => SystemErrno.EPIPE, + Win32Error.WSAEPROTONOSUPPORT => SystemErrno.EPROTONOSUPPORT, + Win32Error.WRITE_PROTECT => SystemErrno.EROFS, + Win32Error.SEM_TIMEOUT => SystemErrno.ETIMEDOUT, + Win32Error.WSAETIMEDOUT => SystemErrno.ETIMEDOUT, + Win32Error.NOT_SAME_DEVICE => SystemErrno.EXDEV, + Win32Error.INVALID_FUNCTION => SystemErrno.EISDIR, + Win32Error.META_EXPANSION_TOO_LONG => SystemErrno.E2BIG, + Win32Error.WSAESOCKTNOSUPPORT => SystemErrno.ESOCKTNOSUPPORT, + Win32Error.DELETE_PENDING => SystemErrno.EBUSY, + else => return null, + }; + } + + if (comptime std.meta.trait.isSignedInt(@TypeOf(code))) { + if (code < 0) + return init(-code); + } + + if (code >= max) return null; + return @as(SystemErrno, @enumFromInt(code)); + } + + pub fn label(this: SystemErrno) ?[]const u8 { + return labels.get(this) orelse null; + } + + const LabelMap = std.EnumMap(SystemErrno, []const u8); + pub const labels: LabelMap = brk: { + var map: LabelMap = LabelMap.initFull(""); + + map.put(.EPERM, "Operation not permitted"); + map.put(.ENOENT, "No such file or directory"); + map.put(.ESRCH, "No such process"); + map.put(.EINTR, "Interrupted system call"); + map.put(.EIO, "I/O error"); + map.put(.ENXIO, "No such device or address"); + map.put(.E2BIG, "Argument list too long"); + map.put(.ENOEXEC, "Exec format error"); + map.put(.EBADF, "Bad file number"); + map.put(.ECHILD, "No child processes"); + map.put(.EAGAIN, "Try again"); + map.put(.EOF, "End of file"); + map.put(.ENOMEM, "Out of memory"); + map.put(.EACCES, "Permission denied"); + map.put(.EFAULT, "Bad address"); + map.put(.ENOTBLK, "Block device required"); + map.put(.EBUSY, "Device or resource busy"); + map.put(.EEXIST, "File or folder exists"); + map.put(.EXDEV, "Cross-device link"); + map.put(.ENODEV, "No such device"); + map.put(.ENOTDIR, "Not a directory"); + map.put(.EISDIR, "Is a directory"); + map.put(.EINVAL, "Invalid argument"); + map.put(.ENFILE, "File table overflow"); + map.put(.EMFILE, "Too many open files"); + map.put(.ECHARSET, "Invalid or incomplete multibyte or wide character"); + map.put(.ENOTTY, "Not a typewriter"); + map.put(.ETXTBSY, "Text file busy"); + map.put(.EFBIG, "File too large"); + map.put(.ENOSPC, "No space left on device"); + map.put(.ESPIPE, "Illegal seek"); + map.put(.EROFS, "Read-only file system"); + map.put(.EMLINK, "Too many links"); + map.put(.EPIPE, "Broken pipe"); + map.put(.EDOM, "Math argument out of domain of func"); + map.put(.ERANGE, "Math result not representable"); + map.put(.EDEADLK, "Resource deadlock would occur"); + map.put(.ENAMETOOLONG, "File name too long"); + map.put(.ENOLCK, "No record locks available"); + map.put(.EUNKNOWN, "An unknown error occurred"); + map.put(.ENOSYS, "Function not implemented"); + map.put(.ENOTEMPTY, "Directory not empty"); + map.put(.ELOOP, "Too many symbolic links encountered"); + map.put(.ENOMSG, "No message of desired type"); + map.put(.EIDRM, "Identifier removed"); + map.put(.ECHRNG, "Channel number out of range"); + map.put(.EL2NSYNC, "Level 2 not synchronized"); + map.put(.EL3HLT, "Level 3 halted"); + map.put(.EL3RST, "Level 3 reset"); + map.put(.ELNRNG, "Link number out of range"); + map.put(.EUNATCH, "Protocol driver not attached"); + map.put(.ENOCSI, "No CSI structure available"); + map.put(.EL2HLT, "Level 2 halted"); + map.put(.EBADE, "Invalid exchange"); + map.put(.EBADR, "Invalid request descriptor"); + map.put(.EXFULL, "Exchange full"); + map.put(.ENOANO, "No anode"); + map.put(.EBADRQC, "Invalid request code"); + map.put(.EBADSLT, "Invalid slot"); + map.put(.EBFONT, "Bad font file format"); + map.put(.ENOSTR, "Device not a stream"); + map.put(.ENODATA, "No data available"); + map.put(.ETIME, "Timer expired"); + map.put(.ENOSR, "Out of streams resources"); + map.put(.ENONET, "Machine is not on the network"); + map.put(.ENOPKG, "Package not installed"); + map.put(.EREMOTE, "Object is remote"); + map.put(.ENOLINK, "Link has been severed"); + map.put(.EADV, "Advertise error"); + map.put(.ESRMNT, "Srmount error"); + map.put(.ECOMM, "Communication error on send"); + map.put(.EPROTO, "Protocol error"); + map.put(.EMULTIHOP, "Multihop attempted"); + map.put(.EDOTDOT, "RFS specific error"); + map.put(.EBADMSG, "Not a data message"); + map.put(.EOVERFLOW, "Value too large for defined data type"); + map.put(.ENOTUNIQ, "Name not unique on network"); + map.put(.EBADFD, "File descriptor in bad state"); + map.put(.EREMCHG, "Remote address changed"); + map.put(.ELIBACC, "Can not access a needed shared library"); + map.put(.ELIBBAD, "Accessing a corrupted shared library"); + map.put(.ELIBSCN, "lib section in a.out corrupted"); + map.put(.ELIBMAX, "Attempting to link in too many shared libraries"); + map.put(.ELIBEXEC, "Cannot exec a shared library directly"); + map.put(.EILSEQ, "Illegal byte sequence"); + map.put(.ERESTART, "Interrupted system call should be restarted"); + map.put(.ESTRPIPE, "Streams pipe error"); + map.put(.EUSERS, "Too many users"); + map.put(.ENOTSOCK, "Socket operation on non-socket"); + map.put(.EDESTADDRREQ, "Destination address required"); + map.put(.EMSGSIZE, "Message too long"); + map.put(.EPROTOTYPE, "Protocol wrong type for socket"); + map.put(.ENOPROTOOPT, "Protocol not available"); + map.put(.EPROTONOSUPPORT, "Protocol not supported"); + map.put(.ESOCKTNOSUPPORT, "Socket type not supported"); + map.put(.ENOTSUP, "Operation not supported on transport endpoint"); + map.put(.EPFNOSUPPORT, "Protocol family not supported"); + map.put(.EAFNOSUPPORT, "Address family not supported by protocol"); + map.put(.EADDRINUSE, "Address already in use"); + map.put(.EADDRNOTAVAIL, "Cannot assign requested address"); + map.put(.ENETDOWN, "Network is down"); + map.put(.ENETUNREACH, "Network is unreachable"); + map.put(.ENETRESET, "Network dropped connection because of reset"); + map.put(.ECONNABORTED, "Software caused connection abort"); + map.put(.ECONNRESET, "Connection reset by peer"); + map.put(.ENOBUFS, "No buffer space available"); + map.put(.EISCONN, "Transport endpoint is already connected"); + map.put(.ENOTCONN, "Transport endpoint is not connected"); + map.put(.ESHUTDOWN, "Cannot send after transport endpoint shutdown"); + map.put(.ETOOMANYREFS, "Too many references: cannot splice"); + map.put(.ETIMEDOUT, "Connection timed out"); + map.put(.ECONNREFUSED, "Connection refused"); + map.put(.EHOSTDOWN, "Host is down"); + map.put(.EHOSTUNREACH, "No route to host"); + map.put(.EALREADY, "Operation already in progress"); + map.put(.EINPROGRESS, "Operation now in progress"); + map.put(.ESTALE, "Stale NFS file handle"); + map.put(.EUCLEAN, "Structure needs cleaning"); + map.put(.ENOTNAM, "Not a XENIX named type file"); + map.put(.ENAVAIL, "No XENIX semaphores available"); + map.put(.EISNAM, "Is a named type file"); + map.put(.EREMOTEIO, "Remote I/O error"); + map.put(.EDQUOT, "Quota exceeded"); + map.put(.ENOMEDIUM, "No medium found"); + map.put(.EMEDIUMTYPE, "Wrong medium type"); + map.put(.ECANCELED, "Operation Canceled"); + map.put(.ENOKEY, "Required key not available"); + map.put(.EKEYEXPIRED, "Key has expired"); + map.put(.EKEYREVOKED, "Key has been revoked"); + map.put(.EKEYREJECTED, "Key was rejected by service"); + map.put(.EOWNERDEAD, "Owner died"); + map.put(.ENOTRECOVERABLE, "State not recoverable"); + break :brk map; + }; +}; + +pub const off_t = i64; +pub fn preallocate_file(_: os.fd_t, _: off_t, _: off_t) !void {} + +pub const E = enum(u8) { + 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, + NOTBLK = 15, + BUSY = 16, + EXIST = 17, + XDEV = 18, + NODEV = 19, + NOTDIR = 20, + ISDIR = 21, + INVAL = 22, + NFILE = 23, + MFILE = 24, + NOTTY = 25, + TXTBSY = 26, + FBIG = 27, + NOSPC = 28, + SPIPE = 29, + ROFS = 30, + MLINK = 31, + PIPE = 32, + DOM = 33, + RANGE = 34, + DEADLK = 35, + NAMETOOLONG = 36, + NOLCK = 37, + NOSYS = 38, + NOTEMPTY = 39, + LOOP = 40, + WOULDBLOCK = 41, + NOMSG = 42, + IDRM = 43, + CHRNG = 44, + L2NSYNC = 45, + L3HLT = 46, + L3RST = 47, + LNRNG = 48, + UNATCH = 49, + NOCSI = 50, + L2HLT = 51, + BADE = 52, + BADR = 53, + XFULL = 54, + NOANO = 55, + BADRQC = 56, + BADSLT = 57, + DEADLOCK = 58, + BFONT = 59, + NOSTR = 60, + NODATA = 61, + TIME = 62, + NOSR = 63, + NONET = 64, + NOPKG = 65, + REMOTE = 66, + NOLINK = 67, + ADV = 68, + SRMNT = 69, + COMM = 70, + PROTO = 71, + MULTIHOP = 72, + DOTDOT = 73, + BADMSG = 74, + OVERFLOW = 75, + NOTUNIQ = 76, + BADFD = 77, + REMCHG = 78, + LIBACC = 79, + LIBBAD = 80, + LIBSCN = 81, + LIBMAX = 82, + LIBEXEC = 83, + ILSEQ = 84, + RESTART = 85, + STRPIPE = 86, + USERS = 87, + NOTSOCK = 88, + DESTADDRREQ = 89, + MSGSIZE = 90, + PROTOTYPE = 91, + NOPROTOOPT = 92, + PROTONOSUPPORT = 93, + SOCKTNOSUPPORT = 94, + NOTSUP = 95, + PFNOSUPPORT = 96, + AFNOSUPPORT = 97, + ADDRINUSE = 98, + ADDRNOTAVAIL = 99, + NETDOWN = 100, + NETUNREACH = 101, + NETRESET = 102, + CONNABORTED = 103, + CONNRESET = 104, + NOBUFS = 105, + ISCONN = 106, + NOTCONN = 107, + SHUTDOWN = 108, + TOOMANYREFS = 109, + TIMEDOUT = 110, + CONNREFUSED = 111, + HOSTDOWN = 112, + HOSTUNREACH = 113, + ALREADY = 114, + INPROGRESS = 115, + STALE = 116, + UCLEAN = 117, + NOTNAM = 118, + NAVAIL = 119, + ISNAM = 120, + REMOTEIO = 121, + DQUOT = 122, + NOMEDIUM = 123, + MEDIUMTYPE = 124, + CANCELED = 125, + NOKEY = 126, + KEYEXPIRED = 127, + KEYREVOKED = 128, + KEYREJECTED = 129, + OWNERDEAD = 130, + NOTRECOVERABLE = 131, + RFKILL = 132, + HWPOISON = 133, + UNKNOWN = 134, + CHARSET = 135, + OF = 136, +}; + +pub fn getErrno(_: anytype) E { + if (Win32Error.get().toSystemErrno()) |sys| { + return sys.toE(); + } + + return .SUCCESS; +} |