/** * D header file for C99. * * $(C_HEADER_DESCRIPTION pubs.opengroup.org/onlinepubs/009695399/basedefs/_errno.h.html, _errno.h) * * Copyright: Copyright Sean Kelly 2005 - 2009. * License: Distributed under the * $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0). * (See accompanying file LICENSE) * Authors: Sean Kelly, Alex Rønne Petersen * Source: https://github.com/dlang/druntime/blob/master/src/core/stdc/errno.d * Standards: ISO/IEC 9899:1999 (E) */ module core.stdc.errno; version (OSX) version = Darwin; else version (iOS) version = Darwin; else version (TVOS) version = Darwin; else version (WatchOS) version = Darwin; version (ARM) version = ARM_Any; version (AArch64) version = ARM_Any; version (HPPA) version = HPPA_Any; version (MIPS32) version = MIPS_Any; version (MIPS64) version = MIPS_Any; version (PPC) version = PPC_Any; version (PPC64) version = PPC_Any; version (RISCV32) version = RISCV_Any; version (RISCV64) version = RISCV_Any; version (S390) version = IBMZ_Any; version (SPARC) version = SPARC_Any; version (SPARC64) version = SPARC_Any; version (SystemZ) version = IBMZ_Any; version (X86) version = X86_Any; version (X86_64) version = X86_Any; @trusted: // Only manipulates errno. nothrow: @nogc: version (CRuntime_DigitalMars) { extern (C) { ref int _errno(); alias errno = _errno; } } else version (CRuntime_Microsoft) { extern (C) { ref int _errno(); alias errno = _errno; } } else version (CRuntime_Glibc) { extern (C) { ref int __errno_location(); alias errno = __errno_location; } } else version (CRuntime_Musl) { extern (C) { ref int __errno_location(); alias errno = __errno_location; } } else version (OpenBSD) { // https://github.com/openbsd/src/blob/master/include/errno.h extern (C) { ref int __errno(); alias errno = __errno; } } else version (NetBSD) { // https://github.com/NetBSD/src/blob/trunk/include/errno.h extern (C) { ref int __errno(); alias errno = __errno; } } else version (FreeBSD) { extern (C) { ref int __error(); alias errno = __error; } } else version (DragonFlyBSD) { extern (C) { pragma(mangle, "errno") int __errno; ref int __error() { return __errno; } alias errno = __error; } } else version (CRuntime_Bionic) { extern (C) { ref int __errno(); alias errno = __errno; } } else version (CRuntime_UClibc) { extern (C) { ref int __errno_location(); alias errno = __errno_location; } } else version (Darwin) { extern (C) { ref int __error(); alias errno = __error; } } else version (Solaris) { extern (C) { ref int ___errno(); alias errno = ___errno; } } else version (Haiku) { // https://github.com/haiku/haiku/blob/master/headers/posix/errno.h extern (C) { ref int _errnop(); alias errno = _errnop; } } else { /// extern(C) pragma(mangle, "getErrno") @property int errno(); /// extern(C) pragma(mangle, "setErrno") @property int errno(int n); } extern (C): version (Windows) { enum EPERM = 1; /// Operation not permitted enum ENOENT = 2; /// No such file or directory enum ESRCH = 3; /// No such process enum EINTR = 4; /// Interrupted system call enum EIO = 5; /// I/O error enum ENXIO = 6; /// No such device or address enum E2BIG = 7; /// Argument list too long enum ENOEXEC = 8; /// Exec format error enum EBADF = 9; /// Bad file number enum ECHILD = 10; /// No child processes enum EAGAIN = 11; /// Try again enum ENOMEM = 12; /// Out of memory enum EACCES = 13; /// Permission denied enum EFAULT = 14; /// Bad address enum EBUSY = 16; /// Device or resource busy enum EEXIST = 17; /// File exists enum EXDEV = 18; /// Cross-device link enum ENODEV = 19; /// No such device enum ENOTDIR = 20; /// Not a directory enum EISDIR = 21; /// Is a directory enum EINVAL = 22; /// Invalid argument enum ENFILE = 23; /// File table overflow enum EMFILE = 24; /// Too many open files enum ENOTTY = 25; /// Not a typewriter enum EFBIG = 27; /// File too large enum ENOSPC = 28; /// No space left on device enum ESPIPE = 29; /// Illegal seek enum EROFS = 30; /// Read-only file system enum EMLINK = 31; /// Too many links enum EPIPE = 32; /// Broken pipe enum EDOM = 33; /// Math argument out of domain of func enum ERANGE = 34; /// Math result not representable enum EDEADLK = 36; /// Resource deadlock would occur enum ENAMETOOLONG = 38; /// File name too long enum ENOLCK = 39; /// No record locks available enum ENOSYS = 40; /// Function not implemented enum ENOTEMPTY = 41; /// Directory not empty enum EILSEQ = 42; /// Illegal byte sequence enum EDEADLOCK = EDEADLK; /// Resource deadlock would occur // POSIX compatibility // See_Also: https://docs.microsoft.com/en-us/cpp/c-runtime-library/errno-constants enum EADDRINUSE = 100; enum EADDRNOTAVAIL = 101; enum EAFNOSUPPORT = 102; enum EALREADY = 103; enum EBADMSG = 104; enum ECANCELED = 105; enum ECONNABORTED = 106; enum ECONNREFUSED = 107; enum ECONNRESET = 108; enum EDESTADDRREQ = 109; enum EHOSTUNREACH = 110; enum EIDRM = 111; enum EINPROGRESS = 112; enum EISCONN = 113; enum ELOOP = 114; enum EMSGSIZE = 115; enum ENETDOWN = 116; enum ENETRESET = 117; enum ENETUNREACH = 118; enum ENOBUFS = 119; enum ENODATA = 120; enum ENOLINK = 121; enum ENOMSG = 122; enum ENOPROTOOPT = 123; enum ENOSR = 124; enum ENOSTR = 125; enum ENOTCONN = 126; enum ENOTRECOVERABLE = 127; enum ENOTSOCK = 128; enum ENOTSUP = 129; enum EOPNOTSUPP = 130; enum EOTHER = 131; enum EOVERFLOW = 132; enum EOWNERDEAD = 133; enum EPROTO = 134; enum EPROTONOSUPPORT = 135; enum EPROTOTYPE = 136; enum ETIME = 137; enum ETIMEDOUT = 138; enum ETXTBSY = 139; enum EWOULDBLOCK = 140; } else version (linux) { enum EPERM = 1; /// enum ENOENT = 2; /// enum ESRCH = 3; /// enum EINTR = 4; /// enum EIO = 5; /// enum ENXIO = 6; /// enum E2BIG = 7; /// enum ENOEXEC = 8; /// enum EBADF = 9; /// enum ECHILD = 10; /// enum EAGAIN = 11; /// enum ENOMEM = 12; /// enum EACCES = 13; /// enum EFAULT = 14; /// enum ENOTBLK = 15; /// enum EBUSY = 16; /// enum EEXIST = 17; /// enum EXDEV = 18; /// enum ENODEV = 19; /// enum ENOTDIR = 20; /// enum EISDIR = 21; /// enum EINVAL = 22; /// enum ENFILE = 23; /// enum EMFILE = 24; /// enum ENOTTY = 25; /// enum ETXTBSY = 26; /// enum EFBIG = 27; /// enum ENOSPC = 28; /// enum ESPIPE = 29; /// enum EROFS = 30; /// enum EMLINK = 31; /// enum EPIPE = 32; /// enum EDOM = 33; /// enum ERANGE = 34; /// version (X86_Any) { enum EDEADLK = 35; /// enum ENAMETOOLONG = 36; /// enum ENOLCK = 37; /// enum ENOSYS = 38; /// enum ENOTEMPTY = 39; /// enum ELOOP = 40; /// enum EWOULDBLOCK = EAGAIN; /// enum ENOMSG = 42; /// enum EIDRM = 43; /// enum ECHRNG = 44; /// enum EL2NSYNC = 45; /// enum EL3HLT = 46; /// enum EL3RST = 47; /// enum ELNRNG = 48; /// enum EUNATCH = 49; /// enum ENOCSI = 50; /// enum EL2HLT = 51; /// enum EBADE = 52; /// enum EBADR = 53; /// enum EXFULL = 54; /// enum ENOANO = 55; /// enum EBADRQC = 56; /// enum EBADSLT = 57; /// enum EDEADLOCK = EDEADLK; /// enum EBFONT = 59; /// enum ENOSTR = 60; /// enum ENODATA = 61; /// enum ETIME = 62; /// enum ENOSR = 63; /// enum ENONET = 64; /// enum ENOPKG = 65; /// enum EREMOTE = 66; /// enum ENOLINK = 67; /// enum EADV = 68; /// enum ESRMNT = 69; /// enum ECOMM = 70; /// enum EPROTO = 71; /// enum EMULTIHOP = 72; /// enum EDOTDOT = 73; /// enum EBADMSG = 74; /// enum EOVERFLOW = 75; /// enum ENOTUNIQ = 76; /// enum EBADFD = 77; /// enum EREMCHG = 78; /// enum ELIBACC = 79; /// enum ELIBBAD = 80; /// enum ELIBSCN = 81; /// enum ELIBMAX = 82; /// enum ELIBEXEC = 83; /// enum EILSEQ = 84; /// enum ERESTART = 85; /// enum ESTRPIPE = 86; /// enum EUSERS = 87; /// enum ENOTSOCK = 88; /// enum EDESTADDRREQ = 89; /// enum EMSGSIZE = 90; /// enum EPROTOTYPE = 91; /// enum ENOPROTOOPT = 92; /// enum EPROTONOSUPPORT = 93; /// enum ESOCKTNOSUPPORT = 94; /// enum EOPNOTSUPP = 95; /// enum ENOTSUP = EOPNOTSUPP; /// enum EPFNOSUPPORT = 96; /// enum EAFNOSUPPORT = 97; /// enum EADDRINUSE = 98; /// enum EADDRNOTAVAIL = 99; /// enum ENETDOWN = 100; /// enum ENETUNREACH = 101; /// enum ENETRESET = 102; /// enum ECONNABORTED = 103; /// enum ECONNRESET = 104; /// enum ENOBUFS = 105; /// enum EISCONN = 106; /// enum ENOTCONN = 107; /// enum ESHUTDOWN = 108; /// enum ETOOMANYREFS = 109; /// enum ETIMEDOUT = 110; /// enum ECONNREFUSED = 111; /// enum EHOSTDOWN = 112; /// enum EHOSTUNREACH = 113; /// enum EALREADY = 114; /// enum EINPROGRESS = 115; /// enum ESTALE = 116; /// enum EUCLEAN = 117; /// enum ENOTNAM = 118; /// enum ENAVAIL = 119; /// enum EISNAM = 120; /// enum EREMOTEIO = 121; /// enum EDQUOT = 122; /// enum ENOMEDIUM = 123; /// enum EMEDIUMTYPE = 124; /// enum ECANCELED = 125; /// enum ENOKEY = 126; /// enum EKEYEXPIRED = 127; /// enum EKEYREVOKED = 128; /// enum EKEYREJECTED = 129; /// enum EOWNERDEAD = 130; /// enum ENOTRECOVERABLE = 131; /// enum ERFKILL = 132; /// enum EHWPOISON = 133; /// } else version (ARM_Any) { enum EDEADLK = 35; /// enum ENAMETOOLONG = 36; /// enum ENOLCK = 37; /// enum ENOSYS = 38; /// enum ENOTEMPTY = 39; /// enum ELOOP = 40; /// enum EWOULDBLOCK = EAGAIN; /// enum ENOMSG = 42; /// enum EIDRM = 43; /// enum ECHRNG = 44; /// enum EL2NSYNC = 45; /// enum EL3HLT = 46; /// enum EL3RST = 47; /// enum ELNRNG = 48; /// enum EUNATCH = 49; /// enum ENOCSI = 50; /// enum EL2HLT = 51; /// enum EBADE = 52; /// enum EBADR = 53; /// enum EXFULL = 54; /// enum ENOANO = 55; /// enum EBADRQC = 56; /// enum EBADSLT = 57; /// enum EDEADLOCK = EDEADLK; /// enum EBFONT = 59; /// enum ENOSTR = 60; /// enum ENODATA = 61; /// enum ETIME = 62; /// enum ENOSR = 63; /// enum ENONET = 64; /// enum ENOPKG = 65; /// enum EREMOTE = 66; /// enum ENOLINK = 67; /// enum EADV = 68; /// enum ESRMNT = 69; /// enum ECOMM = 70; /// enum EPROTO = 71; /// enum EMULTIHOP = 72; /// enum EDOTDOT = 73; /// enum EBADMSG = 74; /// enum EOVERFLOW = 75; /// enum ENOTUNIQ = 76; /// enum EBADFD = 77; /// enum EREMCHG = 78; /// enum ELIBACC = 79; /// enum ELIBBAD = 80; /// enum ELIBSCN = 81; /// enum ELIBMAX = 82; /// enum ELIBEXEC = 83; /// enum EILSEQ = 84; /// enum ERESTART = 85; /// enum ESTRPIPE = 86; /// enum EUSERS = 87; /// enum ENOTSOCK = 88; /// enum EDESTADDRREQ = 89; /// enum EMSGSIZE = 90; /// enum EPROTOTYPE = 91; /// enum ENOPROTOOPT = 92; /// enum EPROTONOSUPPORT = 93; /// enum ESOCKTNOSUPPORT = 94; /// enum EOPNOTSUPP = 95; /// enum ENOTSUP = EOPNOTSUPP; /// enum EPFNOSUPPORT = 96; /// enum EAFNOSUPPORT = 97; /// enum EADDRINUSE = 98; /// enum EADDRNOTAVAIL = 99; /// enum ENETDOWN = 100; /// enum ENETUNREACH = 101; /// enum ENETRESET = 102; /// enum ECONNABORTED = 103; /// enum ECONNRESET = 104; /// enum ENOBUFS = 105; /// enum EISCONN = 106; /// enum ENOTCONN = 107; /// enum ESHUTDOWN = 108; /// enum ETOOMANYREFS = 109; /// enum ETIMEDOUT = 110; /// enum ECONNREFUSED = 111; /// enum EHOSTDOWN = 112; /// enum EHOSTUNREACH = 113; /// enum EALREADY = 114; /// enum EINPROGRESS = 115; /// enum ESTALE = 116; /// enum EUCLEAN = 117; /// enum ENOTNAM = 118; /// enum ENAVAIL = 119; /// enum EISNAM = 120; /// enum EREMOTEIO = 121; /// enum EDQUOT = 122; /// enum ENOMEDIUM = 123; /// enum EMEDIUMTYPE = 124; /// enum ECANCELED = 125; /// enum ENOKEY = 126; /// enum EKEYEXPIRED = 127; /// enum EKEYREVOKED = 128; /// enum EKEYREJECTED = 129; /// enum EOWNERDEAD = 130; /// enum ENOTRECOVERABLE = 131; /// enum ERFKILL = 132; /// enum EHWPOISON = 133; /// } else version (HPPA_Any) { enum ENOMSG = 35; /// enum EIDRM = 36; /// enum ECHRNG = 37; /// enum EL2NSYNC = 38; /// enum EL3HLT = 39; /// enum EL3RST = 40; /// enum ELNRNG = 41; /// enum EUNATCH = 42; /// enum ENOCSI = 43; /// enum EL2HLT = 44; /// enum EDEADLK = 45; /// enum EDEADLOCK = EDEADLK; /// enum ENOLCK = 46; /// enum EILSEQ = 47; /// enum ENONET = 50; /// enum ENODATA = 51; /// enum ETIME = 52; /// enum ENOSR = 53; /// enum ENOSTR = 54; /// enum ENOPKG = 55; /// enum ENOLINK = 57; /// enum EADV = 58; /// enum ESRMNT = 59; /// enum ECOMM = 60; /// enum EPROTO = 61; /// enum EMULTIHOP = 64; /// enum EDOTDOT = 66; /// enum EBADMSG = 67; /// enum EUSERS = 68; /// enum EDQUOT = 69; /// enum ESTALE = 70; /// enum EREMOTE = 71; /// enum EOVERFLOW = 72; /// enum EBADE = 160; /// enum EBADR = 161; /// enum EXFULL = 162; /// enum ENOANO = 163; /// enum EBADRQC = 164; /// enum EBADSLT = 165; /// enum EBFONT = 166; /// enum ENOTUNIQ = 167; /// enum EBADFD = 168; /// enum EREMCHG = 169; /// enum ELIBACC = 170; /// enum ELIBBAD = 171; /// enum ELIBSCN = 172; /// enum ELIBMAX = 173; /// enum ELIBEXEC = 174; /// enum ERESTART = 175; /// enum ESTRPIPE = 176; /// enum EUCLEAN = 177; /// enum ENOTNAM = 178; /// enum ENAVAIL = 179; /// enum EISNAM = 180; /// enum EREMOTEIO = 181; /// enum ENOMEDIUM = 182; /// enum EMEDIUMTYPE = 183; /// enum ENOKEY = 184; /// enum EKEYEXPIRED = 185; /// enum EKEYREVOKED = 186; /// enum EKEYREJECTED = 187; /// enum ENOSYM = 215; /// enum ENOTSOCK = 216; /// enum EDESTADDRREQ = 217; /// enum EMSGSIZE = 218; /// enum EPROTOTYPE = 219; /// enum ENOPROTOOPT = 220; /// enum EPROTONOSUPPORT = 221; /// enum ESOCKTNOSUPPORT = 221; /// enum EOPNOTSUPP = 223; /// enum EPFNOSUPPORT = 224; /// enum EAFNOSUPPORT = 225; /// enum EADDRINUSE = 226; /// enum EADDRNOTAVAIL = 227; /// enum ENETDOWN = 228; /// enum ENETUNREACH = 229; /// enum ENETRESET = 230; /// enum ECONNABORTED = 231; /// enum ECONNRESET = 232; /// enum ENOBUFS = 233; /// enum EISCONN = 234; /// enum ENOTCONN = 235; /// enum ESHUTDOWN = 236; /// enum ETOOMANYREFS = 237; /// enum ETIMEDOUT = 238; /// enum ECONNREFUSED = 239; /// enum EREFUSED = ECONNREFUSED; /// enum EREMOTERELEASE = 240; /// enum EHOSTDOWN = 241; /// enum EHOSTUNREACH = 242; /// enum EALREADY = 244; /// enum EINPROGRESS = 245; /// enum EWOULDBLOCK = EAGAIN; /// enum ENOTEMPTY = 247; /// enum ENAMETOOLONG = 248; /// enum ELOOP = 249; /// enum ENOSYS = 251; /// enum ECANCELLED = 253; /// enum ECANCELED = ECANCELLED; /// enum EOWNERDEAD = 254; /// enum ENOTRECOVERABLE = 255; /// enum ERFKILL = 256; /// enum EHWPOISON = 257; /// } else version (MIPS_Any) { enum ENOMSG = 35; /// enum EIDRM = 36; /// enum ECHRNG = 37; /// enum EL2NSYNC = 38; /// enum EL3HLT = 39; /// enum EL3RST = 40; /// enum ELNRNG = 41; /// enum EUNATCH = 42; /// enum ENOCSI = 43; /// enum EL2HLT = 44; /// enum EDEADLK = 45; /// enum ENOLCK = 46; /// enum EBADE = 50; /// enum EBADR = 51; /// enum EXFULL = 52; /// enum ENOANO = 53; /// enum EBADRQC = 54; /// enum EBADSLT = 55; /// enum EDEADLOCK = 56; /// enum EBFONT = 59; /// enum ENOSTR = 60; /// enum ENODATA = 61; /// enum ETIME = 62; /// enum ENOSR = 63; /// enum ENONET = 64; /// enum ENOPKG = 65; /// enum EREMOTE = 66; /// enum ENOLINK = 67; /// enum EADV = 68; /// enum ESRMNT = 69; /// enum ECOMM = 70; /// enum EPROTO = 71; /// enum EDOTDOT = 73; /// enum EMULTIHOP = 74; /// enum EBADMSG = 77; /// enum ENAMETOOLONG = 78; /// enum EOVERFLOW = 79; /// enum ENOTUNIQ = 80; /// enum EBADFD = 81; /// enum EREMCHG = 82; /// enum ELIBACC = 83; /// enum ELIBBAD = 84; /// enum ELIBSCN = 85; /// enum ELIBMAX = 86; /// enum ELIBEXEC = 87; /// enum EILSEQ = 88; /// enum ENOSYS = 89; /// enum ELOOP = 90; /// enum ERESTART = 91; /// enum ESTRPIPE = 92; /// enum ENOTEMPTY = 93; /// enum EUSERS = 94; /// enum ENOTSOCK = 95; /// enum EDESTADDRREQ = 96; /// enum EMSGSIZE = 97; /// enum EPROTOTYPE = 98; /// enum ENOPROTOOPT = 99; /// enum EPROTONOSUPPORT = 120; /// enum ESOCKTNOSUPPORT = 121; /// enum EOPNOTSUPP = 122; /// enum ENOTSUP = EOPNOTSUPP; /// enum EPFNOSUPPORT = 123; /// enum EAFNOSUPPORT = 124; /// enum EADDRINUSE = 125; /// enum EADDRNOTAVAIL = 126; /// enum ENETDOWN = 127; /// enum ENETUNREACH = 128; /// enum ENETRESET = 129; /// enum ECONNABORTED = 130; /// enum ECONNRESET = 131; /// enum ENOBUFS = 132; /// enum EISCONN = 133; /// enum ENOTCONN = 134; /// enum EUCLEAN = 135; /// enum ENOTNAM = 137; /// enum ENAVAIL = 138; /// enum EISNAM = 139; /// enum EREMOTEIO = 140; /// enum EINIT = 141; /// enum EREMDEV = 142; /// enum ESHUTDOWN = 143; /// enum ETOOMANYREFS = 144; /// enum ETIMEDOUT = 145; /// enum ECONNREFUSED = 146; /// enum EHOSTDOWN = 147; /// enum EHOSTUNREACH = 148; /// enum EWOULDBLOCK = EAGAIN; /// enum EALREADY = 149; /// enum EINPROGRESS = 150; /// enum ESTALE = 151; /// enum ECANCELED = 158; /// enum ENOMEDIUM = 159; /// enum EMEDIUMTYPE = 160; /// enum ENOKEY = 161; /// enum EKEYEXPIRED = 162; /// enum EKEYREVOKED = 163; /// enum EKEYREJECTED = 164; /// enum EOWNERDEAD = 165; /// enum ENOTRECOVERABLE = 166; /// enum ERFKILL = 167; /// enum EHWPOISON = 168; /// enum EDQUOT = 1133; /// } else version (PPC_Any) { enum EDEADLK = 35; /// enum ENAMETOOLONG = 36; /// enum ENOLCK = 37; /// enum ENOSYS = 38; /// enum ENOTEMPTY = 39; /// enum ELOOP = 40; /// enum EWOULDBLOCK = EAGAIN; /// enum ENOMSG = 42; /// enum EIDRM = 43; /// enum ECHRNG = 44; /// enum EL2NSYNC = 45; /// enum EL3HLT = 46; /// enum EL3RST = 47; /// enum ELNRNG = 48; /// enum EUNATCH = 49; /// enum ENOCSI = 50; /// enum EL2HLT = 51; /// enum EBADE = 52; /// enum EBADR = 53; /// enum EXFULL = 54; /// enum ENOANO = 55; /// enum EBADRQC = 56; /// enum EBADSLT = 57; /// enum EDEADLOCK = 58; /// enum EBFONT = 59; /// enum ENOSTR = 60; /// enum ENODATA = 61; /// enum ETIME = 62; /// enum ENOSR = 63; /// enum ENONET = 64; /// enum ENOPKG = 65; /// enum EREMOTE = 66; /// enum ENOLINK = 67; /// enum EADV = 68; /// enum ESRMNT = 69; /// enum ECOMM = 70; /// enum EPROTO = 71; /// enum EMULTIHOP = 72; /// enum EDOTDOT = 73; /// enum EBADMSG = 74; /// enum EOVERFLOW = 75; /// enum ENOTUNIQ = 76; /// enum EBADFD = 77; /// enum EREMCHG = 78; /// enum ELIBACC = 79; /// enum ELIBBAD = 80; /// enum ELIBSCN = 81; /// enum ELIBMAX = 82; /// enum ELIBEXEC = 83; /// enum EILSEQ = 84; /// enum ERESTART = 85; /// enum ESTRPIPE = 86; /// enum EUSERS = 87; /// enum ENOTSOCK = 88; /// enum EDESTADDRREQ = 89; /// enum EMSGSIZE = 90; /// enum EPROTOTYPE = 91; /// enum ENOPROTOOPT = 92; /// enum EPROTONOSUPPORT = 93; /// enum ESOCKTNOSUPPORT = 94; /// enum EOPNOTSUPP = 95; /// enum ENOTSUP = EOPNOTSUPP; /// enum EPFNOSUPPORT = 96; /// enum EAFNOSUPPORT = 97; /// enum EADDRINUSE = 98; /// enum EADDRNOTAVAIL = 99; /// enum ENETDOWN = 100; /// enum ENETUNREACH = 101; /// enum ENETRESET = 102; /// enum ECONNABORTED = 103; /// enum ECONNRESET = 104; /// enum ENOBUFS = 105; /// enum EISCONN = 106; /// enum ENOTCONN = 107; /// enum ESHUTDOWN = 108; /// enum ETOOMANYREFS = 109; /// enum ETIMEDOUT = 110; /// enum ECONNREFUSED = 111; /// enum EHOSTDOWN = 112; /// enum EHOSTUNREACH = 113; /// enum EALREADY = 114; /// enum EINPROGRESS = 115; /// enum ESTALE = 116; /// enum EUCLEAN = 117; /// enum ENOTNAM = 118; /// enum ENAVAIL = 119; /// enum EISNAM = 120; /// enum EREMOTEIO = 121; /// enum EDQUOT = 122; /// enum ENOMEDIUM = 123; /// enum EMEDIUMTYPE = 124; /// enum ECANCELED = 125; /// enum ENOKEY = 126; /// enum EKEYEXPIRED = 127; /// enum EKEYREVOKED = 128; /// enum EKEYREJECTED = 129; /// enum EOWNERDEAD = 130; /// enum ENOTRECOVERABLE = 131; /// enum ERFKILL = 132; /// enum EHWPOISON = 133; /// } else version (RISCV_Any) { enum EDEADLK = 35; /// enum ENAMETOOLONG = 36; /// enum ENOLCK = 37; /// enum ENOSYS = 38; /// enum ENOTEMPTY = 39; /// enum ELOOP = 40; /// enum EWOULDBLOCK = EAGAIN; /// enum ENOMSG = 42; /// enum EIDRM = 43; /// enum ECHRNG = 44; /// enum EL2NSYNC = 45; /// enum EL3HLT = 46; /// enum EL3RST = 47; /// enum ELNRNG = 48; /// enum EUNATCH = 49; /// enum ENOCSI = 50; /// enum EL2HLT = 51; /// enum EBADE = 52; /// enum EBADR = 53; /// enum EXFULL = 54; /// enum ENOANO = 55; /// enum EBADRQC = 56; /// enum EBADSLT = 57; /// enum EDEADLOCK = EDEADLK; /// enum EBFONT = 59; /// enum ENOSTR = 60; /// enum ENODATA = 61; /// enum ETIME = 62; /// enum ENOSR = 63; /// enum ENONET = 64; /// enum ENOPKG = 65; /// enum EREMOTE = 66; /// enum ENOLINK = 67; /// enum EADV = 68; /// enum ESRMNT = 69; /// enum ECOMM = 70; /// enum EPROTO = 71; /// enum EMULTIHOP = 72; /// enum EDOTDOT = 73; /// enum EBADMSG = 74; /// enum EOVERFLOW = 75; /// enum ENOTUNIQ = 76; /// enum EBADFD = 77; /// enum EREMCHG = 78; /// enum ELIBACC = 79; /// enum ELIBBAD = 80; /// enum ELIBSCN = 81; /// enum ELIBMAX = 82; /// enum ELIBEXEC = 83; /// enum EILSEQ = 84; /// enum ERESTART = 85; /// enum ESTRPIPE = 86; /// enum EUSERS = 87; /// enum ENOTSOCK = 88; /// enum EDESTADDRREQ = 89; /// enum EMSGSIZE = 90; /// enum EPROTOTYPE = 91; /// enum ENOPROTOOPT = 92; /// enum EPROTONOSUPPORT = 93; /// enum ESOCKTNOSUPPORT = 94; /// enum EOPNOTSUPP = 95; /// enum EPFNOSUPPORT = 96; /// enum EAFNOSUPPORT = 97; /// enum EADDRINUSE = 98; /// enum EADDRNOTAVAIL = 99; /// enum ENETDOWN = 100; /// enum ENETUNREACH = 101; /// enum ENETRESET = 102; /// enum ECONNABORTED = 103; /// enum ECONNRESET = 104; /// enum ENOBUFS = 105; /// enum EISCONN = 106; /// enum ENOTCONN = 107; /// enum ESHUTDOWN = 108; /// enum ETOOMANYREFS = 109; /// enum ETIMEDOUT = 110; /// enum ECONNREFUSED = 111; /// enum EHOSTDOWN = 112; /// enum EHOSTUNREACH = 113; /// enum EALREADY = 114; /// enum EINPROGRESS = 115; /// enum ESTALE = 116; /// enum EUCLEAN = 117; /// enum ENOTNAM = 118; /// enum ENAVAIL = 119; /// enum EISNAM = 120; /// enum EREMOTEIO = 121; /// enum EDQUOT = 122; /// enum ENOMEDIUM = 123; /// enum EMEDIUMTYPE = 124; /// enum ECANCELED = 125; /// enum ENOKEY = 126; /// enum EKEYEXPIRED = 127; /// enum EKEYREVOKED = 128; /// enum EKEYREJECTED = 129; /// enum EOWNERDEAD = 130; /// enum ENOTRECOVERABLE = 131; /// enum ERFKILL = 132; /// enum EHWPOISON = 133; /// } else version (SPARC_Any) { enum EWOULDBLOCK = EAGAIN; /// enum EINPROGRESS = 36; /// enum EALREADY = 37; /// enum ENOTSOCK = 38; /// enum EDESTADDRREQ = 39; /// enum EMSGSIZE = 40; /// enum EPROTOTYPE = 41; /// enum ENOPROTOOPT = 42; /// enum EPROTONOSUPPORT = 43; /// enum ESOCKTNOSUPPORT = 44; /// enum EOPNOTSUPP = 45; /// enum ENOTSUP = EOPNOTSUPP; /// enum EPFNOSUPPORT = 46; /// enum EAFNOSUPPORT = 47; /// enum EADDRINUSE = 48; /// enum EADDRNOTAVAIL = 49; /// enum ENETDOWN = 50; /// enum ENETUNREACH = 51; /// enum ENETRESET = 52; /// enum ECONNABORTED = 53; /// enum ECONNRESET = 54; /// enum ENOBUFS = 55; /// enum EISCONN = 56; /// enum ENOTCONN = 57; /// enum ESHUTDOWN = 58; /// enum ETOOMANYREFS = 59; /// enum ETIMEDOUT = 60; /// enum ECONNREFUSED = 61; /// enum ELOOP = 62; /// enum ENAMETOOLONG = 63; /// enum EHOSTDOWN = 64; /// enum EHOSTUNREACH = 65; /// enum ENOTEMPTY = 66; /// enum EPROCLIM = 67; /// enum EUSERS = 68; /// enum EDQUOT = 69; /// enum ESTALE = 70; /// enum EREMOTE = 71; /// enum ENOSTR = 72; /// enum ETIME = 73; /// enum ENOSR = 74; /// enum ENOMSG = 75; /// enum EBADMSG = 76; /// enum EIDRM = 77; /// enum EDEADLK = 78; /// enum ENOLCK = 79; /// enum ENONET = 80; /// enum ERREMOTE = 81; /// enum ENOLINK = 82; /// enum EADV = 83; /// enum ESRMNT = 84; /// enum ECOMM = 85; /// enum EPROTO = 86; /// enum EMULTIHOP = 87; /// enum EDOTDOT = 88; /// enum EREMCHG = 89; /// enum ENOSYS = 90; /// enum ESTRPIPE = 91; /// enum EOVERFLOW = 92; /// enum EBADFD = 93; /// enum ECHRNG = 94; /// enum EL2NSYNC = 95; /// enum EL3HLT = 96; /// enum EL3RST = 97; /// enum ELNRNG = 98; /// enum EUNATCH = 99; /// enum ENOCSI = 100; /// enum EL2HLT = 101; /// enum EBADE = 102; /// enum EBADR = 103; /// enum EXFULL = 104; /// enum ENOANO = 105; /// enum EBADRQC = 106; /// enum EBADSLT = 107; /// enum EDEADLOCK = 108; /// enum EBFONT = 109; /// enum ELIBEXEC = 110; /// enum ENODATA = 111; /// enum ELIBBAD = 112; /// enum ENOPKG = 113; /// enum ELIBACC = 114; /// enum ENOTUNIQ = 115; /// enum ERESTART = 116; /// enum EUCLEAN = 117; /// enum ENOTNAM = 118; /// enum ENAVAIL = 119; /// enum EISNAM = 120; /// enum EREMOTEIO = 121; /// enum EILSEQ = 122; /// enum ELIBMAX = 123; /// enum ELIBSCN = 124; /// enum ENOMEDIUM = 125; /// enum EMEDIUMTYPE = 126; /// enum ECANCELED = 127; /// enum ENOKEY = 128; /// enum EKEYEXPIRED = 129; /// enum EKEYREVOKED = 130; /// enum EKEYREJECTED = 131; /// enum EOWNERDEAD = 132; /// enum ENOTRECOVERABLE = 133; /// enum ERFKILL = 134; /// enum EHWPOISON = 135; /// } else version (IBMZ_Any) { enum EDEADLK = 35; /// enum ENAMETOOLONG = 36; /// enum ENOLCK = 37; /// enum ENOSYS = 38; /// enum ENOTEMPTY = 39; /// enum ELOOP = 40; /// enum EWOULDBLOCK = EAGAIN; /// enum ENOMSG = 42; /// enum EIDRM = 43; /// enum ECHRNG = 44; /// enum EL2NSYNC = 45; /// enum EL3HLT = 46; /// enum EL3RST = 47; /// enum ELNRNG = 48; /// enum EUNATCH = 49; /// enum ENOCSI = 50; /// enum EL2HLT = 51; /// enum EBADE = 52; /// enum EBADR = 53; /// enum EXFULL = 54; /// enum ENOANO = 55; /// enum EBADRQC = 56; /// enum EBADSLT = 57; /// enum EDEADLOCK = EDEADLK; /// enum EBFONT = 59; /// enum ENOSTR = 60; /// enum ENODATA = 61; /// enum ETIME = 62; /// enum ENOSR = 63; /// enum ENONET = 64; /// enum ENOPKG = 65; /// enum EREMOTE = 66; /// enum ENOLINK = 67; /// enum EADV = 68; /// enum ESRMNT = 69; /// enum ECOMM = 70; /// enum EPROTO = 71; /// enum EMULTIHOP = 72; /// enum EDOTDOT = 73; /// enum EBADMSG = 74; /// enum EOVERFLOW = 75; /// enum ENOTUNIQ = 76; /// enum EBADFD = 77; /// enum EREMCHG = 78; /// enum ELIBACC = 79; /// enum ELIBBAD = 80; /// enum ELIBSCN = 81; /// enum ELIBMAX = 82; /// enum ELIBEXEC = 83; /// enum EILSEQ = 84; /// enum ERESTART = 85; /// enum ESTRPIPE = 86; /// enum EUSERS = 87; /// enum ENOTSOCK = 88; /// enum EDESTADDRREQ = 89; /// enum EMSGSIZE = 90; /// enum EPROTOTYPE = 91; /// enum ENOPROTOOPT = 92; /// enum EPROTONOSUPPORT = 93; /// enum ESOCKTNOSUPPORT = 94; /// enum EOPNOTSUPP = 95; /// enum ENOTSUP = EOPNOTSUPP; /// enum EPFNOSUPPORT = 96; /// enum EAFNOSUPPORT = 97; /// enum EADDRINUSE = 98; /// enum EADDRNOTAVAIL = 99; /// enum ENETDOWN = 100; /// enum ENETUNREACH = 101; /// enum ENETRESET = 102; /// enum ECONNABORTED = 103; /// enum ECONNRESET = 104; /// enum ENOBUFS = 105; /// enum EISCONN = 106; /// enum ENOTCONN = 107; /// enum ESHUTDOWN = 108; /// enum ETOOMANYREFS = 109; /// enum ETIMEDOUT = 110; /// enum ECONNREFUSED = 111; /// enum EHOSTDOWN = 112; /// enum EHOSTUNREACH = 113; /// enum EALREADY = 114; /// enum EINPROGRESS = 115; /// enum ESTALE = 116; /// enum EUCLEAN = 117; /// enum ENOTNAM = 118; /// enum ENAVAIL = 119; /// enum EISNAM = 120; /// enum EREMOTEIO = 121; /// enum EDQUOT = 122; /// enum ENOMEDIUM = 123; /// enum EMEDIUMTYPE = 124; /// enum ECANCELED = 125; /// enum ENOKEY = 126; /// enum EKEYEXPIRED = 127; /// enum EKEYREVOKED = 128; /// enum EKEYREJECTED = 129; /// enum EOWNERDEAD = 130; /// enum ENOTRECOVERABLE = 131; /// enum ERFKILL = 132; /// enum EHWPOISON = 133; /// } else { static assert(false, "Architecture not supported."); } } else version (Darwin) { enum EPERM = 1; /// Operation not permitted enum ENOENT = 2; /// No such file or directory enum ESRCH = 3; /// No such process enum EINTR = 4; /// Interrupted system call enum EIO = 5; /// Input/output error enum ENXIO = 6; /// Device not configured enum E2BIG = 7; /// Argument list too long enum ENOEXEC = 8; /// Exec format error enum EBADF = 9; /// Bad file descriptor enum ECHILD = 10; /// No child processes enum EDEADLK = 11; /// Resource deadlock avoided enum ENOMEM = 12; /// Cannot allocate memory enum EACCES = 13; /// Permission denied enum EFAULT = 14; /// Bad address enum EBUSY = 16; /// Device busy enum EEXIST = 17; /// File exists enum EXDEV = 18; /// Cross-device link enum ENODEV = 19; /// Operation not supported by device enum ENOTDIR = 20; /// Not a directory enum EISDIR = 21; /// Is a directory enum EINVAL = 22; /// Invalid argument enum ENFILE = 23; /// Too many open files in system enum EMFILE = 24; /// Too many open files enum ENOTTY = 25; /// Inappropriate ioctl for device enum ETXTBSY = 26; /// Text file busy enum EFBIG = 27; /// File too large enum ENOSPC = 28; /// No space left on device enum ESPIPE = 29; /// Illegal seek enum EROFS = 30; /// Read-only file system enum EMLINK = 31; /// Too many links enum EPIPE = 32; /// Broken pipe enum EDOM = 33; /// Numerical argument out of domain enum ERANGE = 34; /// Result too large enum EAGAIN = 35; /// Resource temporarily unavailable enum EWOULDBLOCK = EAGAIN; /// Operation would block enum EINPROGRESS = 36; /// Operation now in progress enum EALREADY = 37; /// Operation already in progress enum ENOTSOCK = 38; /// Socket operation on non-socket enum EDESTADDRREQ = 39; /// Destination address required enum EMSGSIZE = 40; /// Message too long enum EPROTOTYPE = 41; /// Protocol wrong type for socket enum ENOPROTOOPT = 42; /// Protocol not available enum EPROTONOSUPPORT = 43; /// Protocol not supported enum ENOTSUP = 45; /// Operation not supported enum EOPNOTSUPP = ENOTSUP; /// Operation not supported on socket enum EAFNOSUPPORT = 47; /// Address family not supported by protocol family enum EADDRINUSE = 48; /// Address already in use enum EADDRNOTAVAIL = 49; /// Can't assign requested address enum ENETDOWN = 50; /// Network is down enum ENETUNREACH = 51; /// Network is unreachable enum ENETRESET = 52; /// Network dropped connection on reset enum ECONNABORTED = 53; /// Software caused connection abort enum ECONNRESET = 54; /// Connection reset by peer enum ENOBUFS = 55; /// No buffer space available enum EISCONN = 56; /// Socket is already connected enum ENOTCONN = 57; /// Socket is not connected enum ETIMEDOUT = 60; /// Operation timed out enum ECONNREFUSED = 61; /// Connection refused enum ELOOP = 62; /// Too many levels of symbolic links enum ENAMETOOLONG = 63; /// File name too long enum EHOSTUNREACH = 65; /// No route to host enum ENOTEMPTY = 66; /// Directory not empty enum EDQUOT = 69; /// Disc quota exceeded enum ESTALE = 70; /// Stale NFS file handle enum ENOLCK = 77; /// No locks available enum ENOSYS = 78; /// Function not implemented enum EOVERFLOW = 84; /// Value too large to be stored in data type enum ECANCELED = 89; /// Operation canceled enum EIDRM = 90; /// Identifier removed enum ENOMSG = 91; /// No message of desired type enum EILSEQ = 92; /// Illegal byte sequence enum EBADMSG = 94; /// Bad message enum EMULTIHOP = 95; /// Reserved enum ENODATA = 96; /// No message available on STREAM enum ENOLINK = 97; /// Reserved enum ENOSR = 98; /// No STREAM resources enum ENOSTR = 99; /// Not a STREAM enum EPROTO = 100; /// Protocol error enum ETIME = 101; /// STREAM ioctl timeout enum ELAST = 101; /// Must be equal largest errno } else version (FreeBSD) { enum EPERM = 1; /// Operation not permitted enum ENOENT = 2; /// No such file or directory enum ESRCH = 3; /// No such process enum EINTR = 4; /// Interrupted system call enum EIO = 5; /// Input/output error enum ENXIO = 6; /// Device not configured enum E2BIG = 7; /// Argument list too long enum ENOEXEC = 8; /// Exec format error enum EBADF = 9; /// Bad file descriptor enum ECHILD = 10; /// No child processes enum EDEADLK = 11; /// Resource deadlock avoided enum ENOMEM = 12; /// Cannot allocate memory enum EACCES = 13; /// Permission denied enum EFAULT = 14; /// Bad address enum ENOTBLK = 15; /// Block device required enum EBUSY = 16; /// Device busy enum EEXIST = 17; /// File exists enum EXDEV = 18; /// Cross-device link enum ENODEV = 19; /// Operation not supported by device enum ENOTDIR = 20; /// Not a directory enum EISDIR = 21; /// Is a directory enum EINVAL = 22; /// Invalid argument enum ENFILE = 23; /// Too many open files in system enum EMFILE = 24; /// Too many open files enum ENOTTY = 25; /// Inappropriate ioctl for device enum ETXTBSY = 26; /// Text file busy enum EFBIG = 27; /// File too large enum ENOSPC = 28; /// No space left on device enum ESPIPE = 29; /// Illegal seek enum EROFS = 30; /// Read-only file system enum EMLINK = 31; /// Too many links enum EPIPE = 32; /// Broken pipe enum EDOM = 33; /// Numerical argument out of domain enum ERANGE = 34; /// Result too large enum EAGAIN = 35; /// Resource temporarily unavailable enum EWOULDBLOCK = EAGAIN; /// Operation would block enum EINPROGRESS = 36; /// Operation now in progress enum EALREADY = 37; /// Operation already in progress enum ENOTSOCK = 38; /// Socket operation on non-socket enum EDESTADDRREQ = 39; /// Destination address required enum EMSGSIZE = 40; /// Message too long enum EPROTOTYPE = 41; /// Protocol wrong type for socket enum ENOPROTOOPT = 42; /// Protocol not available enum EPROTONOSUPPORT = 43; /// Protocol not supported enum ENOTSUP = 45; /// Operation not supported enum EOPNOTSUPP = ENOTSUP; /// Operation not supported on socket enum EAFNOSUPPORT = 47; /// Address family not supported by protocol family enum EADDRINUSE = 48; /// Address already in use enum EADDRNOTAVAIL = 49; /// Can't assign requested address enum ENETDOWN = 50; /// Network is down enum ENETUNREACH = 51; /// Network is unreachable enum ENETRESET = 52; /// Network dropped connection on reset enum ECONNABORTED = 53; /// Software caused connection abort enum ECONNRESET = 54; /// Connection reset by peer enum ENOBUFS = 55; /// No buffer space available enum EISCONN = 56; /// Socket is already connected enum ENOTCONN = 57; /// Socket is not connected enum ESHUTDOWN = 58; /// Can't send after socket shutdown enum ETOOMANYREFS = 59; /// Too many refrences; can't splice enum ETIMEDOUT = 60; /// Operation timed out enum ECONNREFUSED = 61; /// Connection refused enum ELOOP = 62; /// Too many levels of symbolic links enum ENAMETOOLONG = 63; /// File name too long enum EHOSTUNREACH = 65; /// No route to host enum ENOTEMPTY = 66; /// Directory not empty enum EPROCLIM = 67; /// Too many processes enum EUSERS = 68; /// Too many users enum EDQUOT = 69; /// Disc quota exceeded enum ESTALE = 70; /// Stale NFS file handle enum EREMOTE = 71; /// Too many levels of remote in path enum EBADRPC = 72; /// RPC struct is bad enum ERPCMISMATCH = 73; /// RPC version wrong enum EPROGUNAVAIL = 74; /// RPC prog. not avail enum EPROGMISMATCH = 75; /// Program version wrong enum EPROCUNAVAIL = 76; /// Bad procedure for program enum ENOLCK = 77; /// No locks available enum ENOSYS = 78; /// Function not implemented enum EFTYPE = 79; /// Inappropriate file type or format enum EAUTH = 80; /// Authentication error enum ENEEDAUTH = 81; /// Need authenticator enum EIDRM = 82; /// Itendifier removed enum ENOMSG = 83; /// No message of desired type enum EOVERFLOW = 84; /// Value too large to be stored in data type enum ECANCELED = 85; /// Operation canceled enum EILSEQ = 86; /// Illegal byte sequence enum ENOATTR = 87; /// Attribute not found enum EDOOFUS = 88; /// Programming error enum EBADMSG = 89; /// Bad message enum EMULTIHOP = 90; /// Multihop attempted enum ENOLINK = 91; /// Link has been severed enum EPROTO = 92; /// Protocol error enum ELAST = 92; /// Must be equal largest errno } else version (NetBSD) { // http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/sys/errno.h enum EPERM = 1; enum ENOENT = 2; enum ESRCH = 3; enum EINTR = 4; enum EIO = 5; enum ENXIO = 6; enum E2BIG = 7; enum ENOEXEC = 8; enum EBADF = 9; enum ECHILD = 10; enum EDEADLK = 11; /// enum ENOMEM = 12; enum EACCES = 13; enum EFAULT = 14; enum ENOTBLK = 15; enum EBUSY = 16; enum EEXIST = 17; enum EXDEV = 18; enum ENODEV = 19; enum ENOTDIR = 20; enum EISDIR = 21; enum EINVAL = 22; enum ENFILE = 23; enum EMFILE = 24; enum ENOTTY = 25; enum ETXTBSY = 26; enum EFBIG = 27; enum ENOSPC = 28; enum ESPIPE = 29; enum EROFS = 30; enum EMLINK = 31; enum EPIPE = 32; /// enum EDOM = 33; enum ERANGE = 34; /// enum EAGAIN = 35; enum EWOULDBLOCK = EAGAIN; enum EINPROGRESS = 36; enum EALREADY = 37; /// enum ENOTSOCK = 38; enum EDESTADDRREQ = 39; enum EMSGSIZE = 40; enum EPROTOTYPE = 41; enum ENOPROTOOPT = 42; enum EPROTONOSUPPORT = 43; enum ESOCKTNOSUPPORT = 44; enum EOPNOTSUPP = 45; enum EPFNOSUPPORT = 46; enum EAFNOSUPPORT = 47; enum EADDRINUSE = 48; enum EADDRNOTAVAIL = 49; /// enum ENETDOWN = 50; enum ENETUNREACH = 51; enum ENETRESET = 52; enum ECONNABORTED = 53; enum ECONNRESET = 54; enum ENOBUFS = 55; enum EISCONN = 56; enum ENOTCONN = 57; enum ESHUTDOWN = 58; enum ETOOMANYREFS = 59; enum ETIMEDOUT = 60; enum ECONNREFUSED = 61; enum ELOOP = 62; enum ENAMETOOLONG = 63; /// enum EHOSTDOWN = 64; enum EHOSTUNREACH = 65; enum ENOTEMPTY = 66; /// enum EPROCLIM = 67; enum EUSERS = 68; enum EDQUOT = 69; /// enum ESTALE = 70; enum EREMOTE = 71; enum EBADRPC = 72; enum ERPCMISMATCH = 73; enum EPROGUNAVAIL = 74; enum EPROGMISMATCH = 75; enum EPROCUNAVAIL = 76; enum ENOLCK = 77; enum ENOSYS = 78; enum EFTYPE = 79; enum EAUTH = 80; enum ENEEDAUTH = 81; /// enum EIDRM = 82; enum ENOMSG = 83; enum EOVERFLOW = 84; /// enum EILSEQ = 85; /// enum ENOTSUP = 86; /// enum ECANCELED = 87; /// enum EBADMSG = 88; /// enum ENODATA = 89; enum ENOSR = 90; enum ENOSTR = 91; enum ETIME = 92; /// enum ENOATTR = 93; /// enum EMULTIHOP = 94; enum ENOLINK = 95; enum EPROTO = 96; } else version (OpenBSD) { enum EPERM = 1; /// Operation not permitted enum ENOENT = 2; /// No such file or directory enum ESRCH = 3; /// No such process enum EINTR = 4; /// Interrupted system call enum EIO = 5; /// Input/output error enum ENXIO = 6; /// Device not configured enum E2BIG = 7; /// Argument list too long enum ENOEXEC = 8; /// Exec format error enum EBADF = 9; /// Bad file descriptor enum ECHILD = 10; /// No child processes enum EDEADLK = 11; /// Resource deadlock avoided enum ENOMEM = 12; /// Cannot allocate memory enum EACCES = 13; /// Permission denied enum EFAULT = 14; /// Bad address enum ENOTBLK = 15; /// Block device required enum EBUSY = 16; /// Device busy enum EEXIST = 17; /// File exists enum EXDEV = 18; /// Cross-device link enum ENODEV = 19; /// Operation not supported by device enum ENOTDIR = 20; /// Not a directory enum EISDIR = 21; /// Is a directory enum EINVAL = 22; /// Invalid argument enum ENFILE = 23; /// Too many open files in system enum EMFILE = 24; /// Too many open files enum ENOTTY = 25; /// Inappropriate ioctl for device enum ETXTBSY = 26; /// Text file busy enum EFBIG = 27; /// File too large enum ENOSPC = 28; /// No space left on device enum ESPIPE = 29; /// Illegal seek enum EROFS = 30; /// Read-only file system enum EMLINK = 31; /// Too many links enum EPIPE = 32; /// Broken pipe enum EDOM = 33; /// Numerical argument out of domain enum ERANGE = 34; /// Result too large enum EAGAIN = 35; /// Resource temporarily unavailable enum EWOULDBLOCK = EAGAIN; /// Operation would block enum EINPROGRESS = 36; /// Operation now in progress enum EALREADY = 37; /// Operation already in progress enum ENOTSOCK = 38; /// Socket operation on non-socket enum EDESTADDRREQ = 39; /// Destination address required enum EMSGSIZE = 40; /// Message too long enum EPROTOTYPE = 41; /// Protocol wrong type for socket enum ENOPROTOOPT = 42; /// Protocol not available enum EPROTONOSUPPORT = 43; /// Protocol not supported enum ESOCKTNOSUPPORT = 44; /// Socket type not supported enum EOPNOTSUPP = 45; /// Operation not supported enum EPFNOSUPPORT = 46; /// Protocol family not supported enum EAFNOSUPPORT = 47; /// Address family not supported by protocol family enum EADDRINUSE = 48; /// Address already in use enum EADDRNOTAVAIL = 49; /// Can't assign requested address enum ENETDOWN = 50; /// Network is down enum ENETUNREACH = 51; /// Network is unreachable enum ENETRESET = 52; /// Network dropped connection on reset enum ECONNABORTED = 53; /// Software caused connection abort enum ECONNRESET = 54; /// Connection reset by peer enum ENOBUFS = 55; /// No buffer space available enum EISCONN = 56; /// Socket is already connected enum ENOTCONN = 57; /// Socket is not connected enum ESHUTDOWN = 58; /// Can't send after socket shutdown enum ETOOMANYREFS = 59; /// Too many references: can't splice enum ETIMEDOUT = 60; /// Operation timed out enum ECONNREFUSED = 61; /// Connection refused enum ELOOP = 62; /// Too many levels of symbolic links enum ENAMETOOLONG = 63; /// File name too long enum EHOSTDOWN = 64; /// Host is down enum EHOSTUNREACH = 65; /// No route to host enum ENOTEMPTY = 66; /// Directory not empty enum EPROCLIM = 67; /// Too many processes enum EUSERS = 68; /// Too many users enum EDQUOT = 69; /// Disk quota exceeded enum ESTALE = 70; /// Stale NFS file handle enum EREMOTE = 71; /// Too many levels of remote in path enum EBADRPC = 72; /// RPC struct is bad enum ERPCMISMATCH = 73; /// RPC version wrong enum EPROGUNAVAIL = 74; /// RPC program not available enum EPROGMISMATCH = 75; /// Program version wrong enum EPROCUNAVAIL = 76; /// Bad procedure for program enum ENOLCK = 77; /// No locks available enum ENOSYS = 78; /// Function not implemented enum EFTYPE = 79; /// Inappropriate file type or format enum EAUTH = 80; /// Authentication error enum ENEEDAUTH = 81; /// Need authenticator enum EIPSEC = 82; /// IPsec processing failure enum ENOATTR = 83; /// Attribute not found enum EILSEQ = 84; /// Illegal byte sequence enum ENOMEDIUM = 85; /// No medium found enum EMEDIUMTYPE = 86; /// Wrong medium type enum EOVERFLOW = 87; /// Value too large to be stored in data type enum ECANCELED = 88; /// Operation canceled enum EIDRM = 89; /// Identifier removed enum ENOMSG = 90; /// No message of desired type enum ENOTSUP = 91; /// Not supported enum EBADMSG = 92; /// Bad message enum ENOTRECOVERABLE = 93; /// State not recoverable enum EOWNERDEAD = 94; /// Previous owner died enum EPROTO = 95; /// Protocol error enum ELAST = 95; /// Must be equal largest errno } else version (DragonFlyBSD) { enum EPERM = 1; enum ENOENT = 2; enum ESRCH = 3; enum EINTR = 4; enum EIO = 5; enum ENXIO = 6; enum E2BIG = 7; enum ENOEXEC = 8; enum EBADF = 9; enum ECHILD = 10; enum EDEADLK = 11; enum ENOMEM = 12; enum EACCES = 13; enum EFAULT = 14; enum ENOTBLK = 15; enum EBUSY = 16; enum EEXIST = 17; enum EXDEV = 18; enum ENODEV = 19; enum ENOTDIR = 20; enum EISDIR = 21; enum EINVAL = 22; enum ENFILE = 23; enum EMFILE = 24; enum ENOTTY = 25; enum ETXTBSY = 26; enum EFBIG = 27; enum ENOSPC = 28; enum ESPIPE = 29; enum EROFS = 30; enum EMLINK = 31; enum EPIPE = 32; enum EDOM = 33; enum ERANGE = 34; enum EAGAIN = 35; enum EWOULDBLOCK = EAGAIN; enum EINPROGRESS = 36; enum EALREADY = 37; enum ENOTSOCK = 38; enum EDESTADDRREQ = 39; enum EMSGSIZE = 40; enum EPROTOTYPE = 41; enum ENOPROTOOPT = 42; enum EPROTONOSUPPORT = 43; enum ENOTSUP = 45; enum EOPNOTSUPP = ENOTSUP; enum EPFNOSUPPORT = 46; enum EAFNOSUPPORT = 47; enum EADDRINUSE = 48; enum EADDRNOTAVAIL = 49; enum ENETDOWN = 50; enum ENETUNREACH = 51; enum ENETRESET = 52; enum ECONNABORTED = 53; enum ECONNRESET = 54; enum ENOBUFS = 55; enum EISCONN = 56; enum ENOTCONN = 57; enum ESHUTDOWN = 58; enum ETOOMANYREFS = 59; enum ETIMEDOUT = 60; enum ECONNREFUSED = 61; enum ELOOP = 62; enum ENAMETOOLONG = 63; enum EHOSTUNREACH = 65; enum ENOTEMPTY = 66; enum EPROCLIM = 67; enum EUSERS = 68; enum EDQUOT = 69; enum ESTALE = 70; enum EREMOTE = 71; enum EBADRPC = 72; enum ERPCMISMATCH = 73; enum EPROGUNAVAIL = 74; enum EPROGMISMATCH = 75; enum EPROCUNAVAIL = 76; enum ENOLCK = 77; enum ENOSYS = 78; enum EFTYPE = 79; enum EAUTH = 80; enum ENEEDAUTH = 81; enum EIDRM = 82; enum ENOMSG = 83; enum EOVERFLOW = 84; enum ECANCELED = 85; enum EILSEQ = 86; enum ENOATTR = 87; enum EDOOFUS = 88; enum EBADMSG = 89; enum EMULTIHOP = 90; enum ENOLINK = 91; enum EPROTO = 92; enum ENOMEDIUM = 93; enum EUNUSED94 = 94; enum EUNUSED95 = 95; enum EUNUSED96 = 96; enum EUNUSED97 = 97; enum EUNUSED98 = 98; enum EASYNC = 99; enum ELAST = 99; } else version (Solaris) { enum EPERM = 1; /// Not super-user enum ENOENT = 2; /// No such file or directory enum ESRCH = 3; /// No such process enum EINTR = 4; /// interrupted system call enum EIO = 5; /// I/O error enum ENXIO = 6; /// No such device or address enum E2BIG = 7; /// Arg list too long enum ENOEXEC = 8; /// Exec format error enum EBADF = 9; /// Bad file number enum ECHILD = 10; /// No children enum EAGAIN = 11; /// Resource temporarily unavailable enum ENOMEM = 12; /// Not enough core enum EACCES = 13; /// Permission denied enum EFAULT = 14; /// Bad address enum ENOTBLK = 15; /// Block device required enum EBUSY = 16; /// Mount device busy enum EEXIST = 17; /// File exists enum EXDEV = 18; /// Cross-device link enum ENODEV = 19; /// No such device enum ENOTDIR = 20; /// Not a directory enum EISDIR = 21; /// Is a directory enum EINVAL = 22; /// Invalid argument enum ENFILE = 23; /// File table overflow enum EMFILE = 24; /// Too many open files enum ENOTTY = 25; /// Inappropriate ioctl for device enum ETXTBSY = 26; /// Text file busy enum EFBIG = 27; /// File too large enum ENOSPC = 28; /// No space left on device enum ESPIPE = 29; /// Illegal seek enum EROFS = 30; /// Read only file system enum EMLINK = 31; /// Too many links enum EPIPE = 32; /// Broken pipe enum EDOM = 33; /// Math arg out of domain of func enum ERANGE = 34; /// Math result not representable enum ENOMSG = 35; /// No message of desired type enum EIDRM = 36; /// Identifier removed enum ECHRNG = 37; /// Channel number out of range enum EL2NSYNC = 38; /// Level 2 not synchronized enum EL3HLT = 39; /// Level 3 halted enum EL3RST = 40; /// Level 3 reset enum ELNRNG = 41; /// Link number out of range enum EUNATCH = 42; /// Protocol driver not attached enum ENOCSI = 43; /// No CSI structure available enum EL2HLT = 44; /// Level 2 halted enum EDEADLK = 45; /// Deadlock condition. enum ENOLCK = 46; /// No record locks available. enum ECANCELED = 47; /// Operation canceled enum ENOTSUP = 48; /// Operation not supported enum EDQUOT = 49; /// Disc quota exceeded enum EBADE = 50; /// invalid exchange enum EBADR = 51; /// invalid request descriptor enum EXFULL = 52; /// exchange full enum ENOANO = 53; /// no anode enum EBADRQC = 54; /// invalid request code enum EBADSLT = 55; /// invalid slot enum EDEADLOCK = 56; /// file locking deadlock error enum EBFONT = 57; /// bad font file fmt enum EOWNERDEAD = 58; /// process died with the lock enum ENOTRECOVERABLE = 59; /// lock is not recoverable enum ENOSTR = 60; /// Device not a stream enum ENODATA = 61; /// no data (for no delay io) enum ETIME = 62; /// timer expired enum ENOSR = 63; /// out of streams resources enum ENONET = 64; /// Machine is not on the network enum ENOPKG = 65; /// Package not installed enum EREMOTE = 66; /// The object is remote enum ENOLINK = 67; /// the link has been severed enum EADV = 68; /// advertise error enum ESRMNT = 69; /// srmount error enum ECOMM = 70; /// Communication error on send enum EPROTO = 71; /// Protocol error enum ELOCKUNMAPPED = 72; /// locked lock was unmapped enum ENOTACTIVE = 73; /// Facility is not active enum EMULTIHOP = 74; /// multihop attempted enum EBADMSG = 77; /// trying to read unreadable message enum ENAMETOOLONG = 78; /// path name is too long enum EOVERFLOW = 79; /// value too large to be stored in data type enum ENOTUNIQ = 80; /// given log. name not unique enum EBADFD = 81; /// f.d. invalid for this operation enum EREMCHG = 82; /// Remote address changed enum ELIBACC = 83; /// Can't access a needed shared lib. enum ELIBBAD = 84; /// Accessing a corrupted shared lib. enum ELIBSCN = 85; /// .lib section in a.out corrupted. enum ELIBMAX = 86; /// Attempting to link in too many libs. enum ELIBEXEC = 87; /// Attempting to exec a shared library. enum EILSEQ = 88; /// Illegal byte sequence. enum ENOSYS = 89; /// Unsupported file system operation enum ELOOP = 90; /// Symbolic link loop enum ERESTART = 91; /// Restartable system call enum ESTRPIPE = 92; /// if pipe/FIFO, don't sleep in stream head enum ENOTEMPTY = 93; /// directory not empty enum EUSERS = 94; /// Too many users (for UFS) enum ENOTSOCK = 95; /// Socket operation on non-socket enum EDESTADDRREQ = 96; /// Destination address required enum EMSGSIZE = 97; /// Message too long enum EPROTOTYPE = 98; /// Protocol wrong type for socket enum ENOPROTOOPT = 99; /// Protocol not available enum EPROTONOSUPPORT = 120; /// Protocol not supported enum ESOCKTNOSUPPORT = 121; /// Socket type not supported enum EOPNOTSUPP = 122; /// Operation not supported on socket enum EPFNOSUPPORT = 123; /// Protocol family not supported enum EAFNOSUPPORT = 124; /// Address family not supported by the protocol family enum EADDRINUSE = 125; /// Address already in use enum EADDRNOTAVAIL = 126; /// Can't assign requested address enum ENETDOWN = 127; /// Network is down enum ENETUNREACH = 128; /// Network is unreachable enum ENETRESET = 129; /// Network dropped connection because of reset enum ECONNABORTED = 130; /// Software caused connection abort enum ECONNRESET = 131; /// Connection reset by peer enum ENOBUFS = 132; /// No buffer space available enum EISCONN = 133; /// Socket is already connected enum ENOTCONN = 134; /// Socket is not connected enum ESHUTDOWN = 143; /// Can't send after socket shutdown enum ETOOMANYREFS = 144; /// Too many references: can't splice enum ETIMEDOUT = 145; /// Connection timed out enum ECONNREFUSED = 146; /// Connection refused enum EHOSTDOWN = 147; /// Host is down enum EHOSTUNREACH = 148; /// No route to host enum EWOULDBLOCK = EAGAIN; /// Resource temporarily unavailable enum EALREADY = 149; /// operation already in progress enum EINPROGRESS = 150; /// operation now in progress enum ESTALE = 151; /// Stale NFS file handle } else version (Haiku) { // https://github.com/haiku/haiku/blob/master/headers/os/support/Errors.h // https://github.com/haiku/haiku/blob/master/headers/build/os/support/Errors.h import core.stdc.limits : INT_MIN; enum B_GENERAL_ERROR_BASE = INT_MIN; enum B_OS_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x1000); enum B_APP_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x2000); enum B_INTERFACE_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x3000); enum B_MEDIA_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x4000); /* - 0x41ff */ enum B_TRANSLATION_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x4800); /* - 0x48ff */ enum B_MIDI_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x5000); enum B_STORAGE_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x6000); enum B_POSIX_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x7000); enum B_MAIL_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x8000); enum B_PRINT_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x9000); enum B_DEVICE_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0xa000); /* General Errors */ enum B_NO_MEMORY = (B_GENERAL_ERROR_BASE + 0); enum B_IO_ERROR = (B_GENERAL_ERROR_BASE + 1); enum B_PERMISSION_DENIED = (B_GENERAL_ERROR_BASE + 2); enum B_BAD_INDEX = (B_GENERAL_ERROR_BASE + 3); enum B_BAD_TYPE = (B_GENERAL_ERROR_BASE + 4); enum B_BAD_VALUE = (B_GENERAL_ERROR_BASE + 5); enum B_MISMATCHED_VALUES = (B_GENERAL_ERROR_BASE + 6); enum B_NAME_NOT_FOUND = (B_GENERAL_ERROR_BASE + 7); enum B_NAME_IN_USE = (B_GENERAL_ERROR_BASE + 8); enum B_TIMED_OUT = (B_GENERAL_ERROR_BASE + 9); enum B_INTERRUPTED = (B_GENERAL_ERROR_BASE + 10); enum B_WOULD_BLOCK = (B_GENERAL_ERROR_BASE + 11); enum B_CANCELED = (B_GENERAL_ERROR_BASE + 12); enum B_NO_INIT = (B_GENERAL_ERROR_BASE + 13); enum B_NOT_INITIALIZED = (B_GENERAL_ERROR_BASE + 13); enum B_BUSY = (B_GENERAL_ERROR_BASE + 14); enum B_NOT_ALLOWED = (B_GENERAL_ERROR_BASE + 15); enum B_BAD_DATA = (B_GENERAL_ERROR_BASE + 16); enum B_DONT_DO_THAT = (B_GENERAL_ERROR_BASE + 17); enum B_ERROR = (-1); enum B_OK = (int(0)); enum B_NO_ERROR = (int(0)); /* Kernel Kit Errors */ enum B_BAD_SEM_ID = (B_OS_ERROR_BASE + 0); enum B_NO_MORE_SEMS = (B_OS_ERROR_BASE + 1); enum B_BAD_THREAD_ID = (B_OS_ERROR_BASE + 0x100); enum B_NO_MORE_THREADS = (B_OS_ERROR_BASE + 0x101); enum B_BAD_THREAD_STATE = (B_OS_ERROR_BASE + 0x102); enum B_BAD_TEAM_ID = (B_OS_ERROR_BASE + 0x103); enum B_NO_MORE_TEAMS = (B_OS_ERROR_BASE + 0x104); enum B_BAD_PORT_ID = (B_OS_ERROR_BASE + 0x200); enum B_NO_MORE_PORTS = (B_OS_ERROR_BASE + 0x201); enum B_BAD_IMAGE_ID = (B_OS_ERROR_BASE + 0x300); enum B_BAD_ADDRESS = (B_OS_ERROR_BASE + 0x301); enum B_NOT_AN_EXECUTABLE = (B_OS_ERROR_BASE + 0x302); enum B_MISSING_LIBRARY = (B_OS_ERROR_BASE + 0x303); enum B_MISSING_SYMBOL = (B_OS_ERROR_BASE + 0x304); enum B_UNKNOWN_EXECUTABLE = (B_OS_ERROR_BASE + 0x305); enum B_LEGACY_EXECUTABLE = (B_OS_ERROR_BASE + 0x306); enum B_DEBUGGER_ALREADY_INSTALLED = (B_OS_ERROR_BASE + 0x400); /* Application Kit Errors */ enum B_BAD_REPLY = (B_APP_ERROR_BASE + 0); enum B_DUPLICATE_REPLY = (B_APP_ERROR_BASE + 1); enum B_MESSAGE_TO_SELF = (B_APP_ERROR_BASE + 2); enum B_BAD_HANDLER = (B_APP_ERROR_BASE + 3); enum B_ALREADY_RUNNING = (B_APP_ERROR_BASE + 4); enum B_LAUNCH_FAILED = (B_APP_ERROR_BASE + 5); enum B_AMBIGUOUS_APP_LAUNCH = (B_APP_ERROR_BASE + 6); enum B_UNKNOWN_MIME_TYPE = (B_APP_ERROR_BASE + 7); enum B_BAD_SCRIPT_SYNTAX = (B_APP_ERROR_BASE + 8); enum B_LAUNCH_FAILED_NO_RESOLVE_LINK = (B_APP_ERROR_BASE + 9); enum B_LAUNCH_FAILED_EXECUTABLE = (B_APP_ERROR_BASE + 10); enum B_LAUNCH_FAILED_APP_NOT_FOUND = (B_APP_ERROR_BASE + 11); enum B_LAUNCH_FAILED_APP_IN_TRASH = (B_APP_ERROR_BASE + 12); enum B_LAUNCH_FAILED_NO_PREFERRED_APP = (B_APP_ERROR_BASE + 13); enum B_LAUNCH_FAILED_FILES_APP_NOT_FOUND = (B_APP_ERROR_BASE + 14); enum B_BAD_MIME_SNIFFER_RULE = (B_APP_ERROR_BASE + 15); enum B_NOT_A_MESSAGE = (B_APP_ERROR_BASE + 16); enum B_SHUTDOWN_CANCELLED = (B_APP_ERROR_BASE + 17); enum B_SHUTTING_DOWN = (B_APP_ERROR_BASE + 18); /* Storage Kit/File System Errors */ enum B_FILE_ERROR = (B_STORAGE_ERROR_BASE + 0); enum B_FILE_NOT_FOUND = (B_STORAGE_ERROR_BASE + 1); /* deprecated: use B_ENTRY_NOT_FOUND instead */ enum B_FILE_EXISTS = (B_STORAGE_ERROR_BASE + 2); enum B_ENTRY_NOT_FOUND = (B_STORAGE_ERROR_BASE + 3); enum B_NAME_TOO_LONG = (B_STORAGE_ERROR_BASE + 4); enum B_NOT_A_DIRECTORY = (B_STORAGE_ERROR_BASE + 5); enum B_DIRECTORY_NOT_EMPTY = (B_STORAGE_ERROR_BASE + 6); enum B_DEVICE_FULL = (B_STORAGE_ERROR_BASE + 7); enum B_READ_ONLY_DEVICE = (B_STORAGE_ERROR_BASE + 8); enum B_IS_A_DIRECTORY = (B_STORAGE_ERROR_BASE + 9); enum B_NO_MORE_FDS = (B_STORAGE_ERROR_BASE + 10); enum B_CROSS_DEVICE_LINK = (B_STORAGE_ERROR_BASE + 11); enum B_LINK_LIMIT = (B_STORAGE_ERROR_BASE + 12); enum B_BUSTED_PIPE = (B_STORAGE_ERROR_BASE + 13); enum B_UNSUPPORTED = (B_STORAGE_ERROR_BASE + 14); enum B_PARTITION_TOO_SMALL = (B_STORAGE_ERROR_BASE + 15); enum B_PARTIAL_READ = (B_STORAGE_ERROR_BASE + 16); enum B_PARTIAL_WRITE = (B_STORAGE_ERROR_BASE + 17); /* POSIX Errors */ enum B_USE_POSITIVE_POSIX_ERRORS = false; static if (B_USE_POSITIVE_POSIX_ERRORS) { enum B_TO_POSIX_ERROR(int code) = -code; } else { enum B_TO_POSIX_ERROR(int code) = code; } alias B_FROM_POSIX_ERROR = B_TO_POSIX_ERROR; enum B_POSIX_ENOMEM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 0); enum E2BIG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 1); enum ECHILD = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 2); enum EDEADLK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 3); enum EFBIG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 4); enum EMLINK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 5); enum ENFILE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 6); enum ENODEV = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 7); enum ENOLCK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 8); enum ENOSYS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 9); enum ENOTTY = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 10); enum ENXIO = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 11); enum ESPIPE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 12); enum ESRCH = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 13); enum EFPOS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 14); enum ESIGPARM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 15); enum EDOM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 16); enum ERANGE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 17); enum EPROTOTYPE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 18); enum EPROTONOSUPPORT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 19); enum EPFNOSUPPORT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 20); enum EAFNOSUPPORT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 21); enum EADDRINUSE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 22); enum EADDRNOTAVAIL = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 23); enum ENETDOWN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 24); enum ENETUNREACH = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 25); enum ENETRESET = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 26); enum ECONNABORTED = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 27); enum ECONNRESET = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 28); enum EISCONN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 29); enum ENOTCONN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 30); enum ESHUTDOWN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 31); enum ECONNREFUSED = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 32); enum EHOSTUNREACH = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 33); enum ENOPROTOOPT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 34); enum ENOBUFS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 35); enum EINPROGRESS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 36); enum EALREADY = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 37); enum EILSEQ = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 38); enum ENOMSG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 39); enum ESTALE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 40); enum EOVERFLOW = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 41); enum EMSGSIZE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 42); enum EOPNOTSUPP = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 43); enum ENOTSOCK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 44); enum EHOSTDOWN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 45); enum EBADMSG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 46); enum ECANCELED = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 47); enum EDESTADDRREQ = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 48); enum EDQUOT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 49); enum EIDRM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 50); enum EMULTIHOP = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 51); enum ENODATA = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 52); enum ENOLINK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 53); enum ENOSR = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 54); enum ENOSTR = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 55); enum ENOTSUP = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 56); enum EPROTO = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 57); enum ETIME = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 58); enum ETXTBSY = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 59); enum ENOATTR = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 60); /* B_NO_MEMORY (0x80000000) can't be negated, so it needs special handling */ static if (B_USE_POSITIVE_POSIX_ERRORS) enum ENOMEM = B_POSIX_ENOMEM; else enum ENOMEM = B_NO_MEMORY; /* POSIX errors that can be mapped to BeOS error codes */ enum EACCES = B_TO_POSIX_ERROR!(B_PERMISSION_DENIED); enum EINTR = B_TO_POSIX_ERROR!(B_INTERRUPTED); enum EIO = B_TO_POSIX_ERROR!(B_IO_ERROR); enum EBUSY = B_TO_POSIX_ERROR!(B_BUSY); enum EFAULT = B_TO_POSIX_ERROR!(B_BAD_ADDRESS); enum ETIMEDOUT = B_TO_POSIX_ERROR!(B_TIMED_OUT); enum EAGAIN = B_TO_POSIX_ERROR!(B_WOULD_BLOCK) /* SysV compatibility */; enum EWOULDBLOCK = B_TO_POSIX_ERROR!(B_WOULD_BLOCK) /* BSD compatibility */; enum EBADF = B_TO_POSIX_ERROR!(B_FILE_ERROR); enum EEXIST = B_TO_POSIX_ERROR!(B_FILE_EXISTS); enum EINVAL = B_TO_POSIX_ERROR!(B_BAD_VALUE); enum ENAMETOOLONG = B_TO_POSIX_ERROR!(B_NAME_TOO_LONG); enum ENOENT = B_TO_POSIX_ERROR!(B_ENTRY_NOT_FOUND); enum EPERM = B_TO_POSIX_ERROR!(B_NOT_ALLOWED); enum ENOTDIR = B_TO_POSIX_ERROR!(B_NOT_A_DIRECTORY); enum EISDIR = B_TO_POSIX_ERROR!(B_IS_A_DIRECTORY); enum ENOTEMPTY = B_TO_POSIX_ERROR!(B_DIRECTORY_NOT_EMPTY); enum ENOSPC = B_TO_POSIX_ERROR!(B_DEVICE_FULL); enum EROFS = B_TO_POSIX_ERROR!(B_READ_ONLY_DEVICE); enum EMFILE = B_TO_POSIX_ERROR!(B_NO_MORE_FDS); enum EXDEV = B_TO_POSIX_ERROR!(B_CROSS_DEVICE_LINK); enum ELOOP = B_TO_POSIX_ERROR!(B_LINK_LIMIT); enum ENOEXEC = B_TO_POSIX_ERROR!(B_NOT_AN_EXECUTABLE); enum EPIPE = B_TO_POSIX_ERROR!(B_BUSTED_PIPE); /* new error codes that can be mapped to POSIX errors */ enum B_BUFFER_OVERFLOW = B_FROM_POSIX_ERROR!(EOVERFLOW); enum B_TOO_MANY_ARGS = B_FROM_POSIX_ERROR!(E2BIG); enum B_FILE_TOO_LARGE = B_FROM_POSIX_ERROR!(EFBIG); enum B_RESULT_NOT_REPRESENTABLE = B_FROM_POSIX_ERROR!(ERANGE); enum B_DEVICE_NOT_FOUND = B_FROM_POSIX_ERROR!(ENODEV); enum B_NOT_SUPPORTED = B_FROM_POSIX_ERROR!(EOPNOTSUPP); /* Media Kit Errors */ enum B_STREAM_NOT_FOUND = (B_MEDIA_ERROR_BASE + 0); enum B_SERVER_NOT_FOUND = (B_MEDIA_ERROR_BASE + 1); enum B_RESOURCE_NOT_FOUND = (B_MEDIA_ERROR_BASE + 2); enum B_RESOURCE_UNAVAILABLE = (B_MEDIA_ERROR_BASE + 3); enum B_BAD_SUBSCRIBER = (B_MEDIA_ERROR_BASE + 4); enum B_SUBSCRIBER_NOT_ENTERED = (B_MEDIA_ERROR_BASE + 5); enum B_BUFFER_NOT_AVAILABLE = (B_MEDIA_ERROR_BASE + 6); enum B_LAST_BUFFER_ERROR = (B_MEDIA_ERROR_BASE + 7); enum B_MEDIA_SYSTEM_FAILURE = (B_MEDIA_ERROR_BASE + 100); enum B_MEDIA_BAD_NODE = (B_MEDIA_ERROR_BASE + 101); enum B_MEDIA_NODE_BUSY = (B_MEDIA_ERROR_BASE + 102); enum B_MEDIA_BAD_FORMAT = (B_MEDIA_ERROR_BASE + 103); enum B_MEDIA_BAD_BUFFER = (B_MEDIA_ERROR_BASE + 104); enum B_MEDIA_TOO_MANY_NODES = (B_MEDIA_ERROR_BASE + 105); enum B_MEDIA_TOO_MANY_BUFFERS = (B_MEDIA_ERROR_BASE + 106); enum B_MEDIA_NODE_ALREADY_EXISTS = (B_MEDIA_ERROR_BASE + 107); enum B_MEDIA_BUFFER_ALREADY_EXISTS = (B_MEDIA_ERROR_BASE + 108); enum B_MEDIA_CANNOT_SEEK = (B_MEDIA_ERROR_BASE + 109); enum B_MEDIA_CANNOT_CHANGE_RUN_MODE = (B_MEDIA_ERROR_BASE + 110); enum B_MEDIA_APP_ALREADY_REGISTERED = (B_MEDIA_ERROR_BASE + 111); enum B_MEDIA_APP_NOT_REGISTERED = (B_MEDIA_ERROR_BASE + 112); enum B_MEDIA_CANNOT_RECLAIM_BUFFERS = (B_MEDIA_ERROR_BASE + 113); enum B_MEDIA_BUFFERS_NOT_RECLAIMED = (B_MEDIA_ERROR_BASE + 114); enum B_MEDIA_TIME_SOURCE_STOPPED = (B_MEDIA_ERROR_BASE + 115); enum B_MEDIA_TIME_SOURCE_BUSY = (B_MEDIA_ERROR_BASE + 116); enum B_MEDIA_BAD_SOURCE = (B_MEDIA_ERROR_BASE + 117); enum B_MEDIA_BAD_DESTINATION = (B_MEDIA_ERROR_BASE + 118); enum B_MEDIA_ALREADY_CONNECTED = (B_MEDIA_ERROR_BASE + 119); enum B_MEDIA_NOT_CONNECTED = (B_MEDIA_ERROR_BASE + 120); enum B_MEDIA_BAD_CLIP_FORMAT = (B_MEDIA_ERROR_BASE + 121); enum B_MEDIA_ADDON_FAILED = (B_MEDIA_ERROR_BASE + 122); enum B_MEDIA_ADDON_DISABLED = (B_MEDIA_ERROR_BASE + 123); enum B_MEDIA_CHANGE_IN_PROGRESS = (B_MEDIA_ERROR_BASE + 124); enum B_MEDIA_STALE_CHANGE_COUNT = (B_MEDIA_ERROR_BASE + 125); enum B_MEDIA_ADDON_RESTRICTED = (B_MEDIA_ERROR_BASE + 126); enum B_MEDIA_NO_HANDLER = (B_MEDIA_ERROR_BASE + 127); enum B_MEDIA_DUPLICATE_FORMAT = (B_MEDIA_ERROR_BASE + 128); enum B_MEDIA_REALTIME_DISABLED = (B_MEDIA_ERROR_BASE + 129); enum B_MEDIA_REALTIME_UNAVAILABLE = (B_MEDIA_ERROR_BASE + 130); /* Mail Kit Errors */ enum B_MAIL_NO_DAEMON = (B_MAIL_ERROR_BASE + 0); enum B_MAIL_UNKNOWN_USER = (B_MAIL_ERROR_BASE + 1); enum B_MAIL_WRONG_PASSWORD = (B_MAIL_ERROR_BASE + 2); enum B_MAIL_UNKNOWN_HOST = (B_MAIL_ERROR_BASE + 3); enum B_MAIL_ACCESS_ERROR = (B_MAIL_ERROR_BASE + 4); enum B_MAIL_UNKNOWN_FIELD = (B_MAIL_ERROR_BASE + 5); enum B_MAIL_NO_RECIPIENT = (B_MAIL_ERROR_BASE + 6); enum B_MAIL_INVALID_MAIL = (B_MAIL_ERROR_BASE + 7); /* Printing Errors */ enum B_NO_PRINT_SERVER = (B_PRINT_ERROR_BASE + 0); /* Device Kit Errors */ enum B_DEV_INVALID_IOCTL = (B_DEVICE_ERROR_BASE + 0); enum B_DEV_NO_MEMORY = (B_DEVICE_ERROR_BASE + 1); enum B_DEV_BAD_DRIVE_NUM = (B_DEVICE_ERROR_BASE + 2); enum B_DEV_NO_MEDIA = (B_DEVICE_ERROR_BASE + 3); enum B_DEV_UNREADABLE = (B_DEVICE_ERROR_BASE + 4); enum B_DEV_FORMAT_ERROR = (B_DEVICE_ERROR_BASE + 5); enum B_DEV_TIMEOUT = (B_DEVICE_ERROR_BASE + 6); enum B_DEV_RECALIBRATE_ERROR = (B_DEVICE_ERROR_BASE + 7); enum B_DEV_SEEK_ERROR = (B_DEVICE_ERROR_BASE + 8); enum B_DEV_ID_ERROR = (B_DEVICE_ERROR_BASE + 9); enum B_DEV_READ_ERROR = (B_DEVICE_ERROR_BASE + 10); enum B_DEV_WRITE_ERROR = (B_DEVICE_ERROR_BASE + 11); enum B_DEV_NOT_READY = (B_DEVICE_ERROR_BASE + 12); enum B_DEV_MEDIA_CHANGED = (B_DEVICE_ERROR_BASE + 13); enum B_DEV_MEDIA_CHANGE_REQUESTED = (B_DEVICE_ERROR_BASE + 14); enum B_DEV_RESOURCE_CONFLICT = (B_DEVICE_ERROR_BASE + 15); enum B_DEV_CONFIGURATION_ERROR = (B_DEVICE_ERROR_BASE + 16); enum B_DEV_DISABLED_BY_USER = (B_DEVICE_ERROR_BASE + 17); enum B_DEV_DOOR_OPEN = (B_DEVICE_ERROR_BASE + 18); enum B_DEV_INVALID_PIPE = (B_DEVICE_ERROR_BASE + 19); enum B_DEV_CRC_ERROR = (B_DEVICE_ERROR_BASE + 20); enum B_DEV_STALLED = (B_DEVICE_ERROR_BASE + 21); enum B_DEV_BAD_PID = (B_DEVICE_ERROR_BASE + 22); enum B_DEV_UNEXPECTED_PID = (B_DEVICE_ERROR_BASE + 23); enum B_DEV_DATA_OVERRUN = (B_DEVICE_ERROR_BASE + 24); enum B_DEV_DATA_UNDERRUN = (B_DEVICE_ERROR_BASE + 25); enum B_DEV_FIFO_OVERRUN = (B_DEVICE_ERROR_BASE + 26); enum B_DEV_FIFO_UNDERRUN = (B_DEVICE_ERROR_BASE + 27); enum B_DEV_PENDING = (B_DEVICE_ERROR_BASE + 28); enum B_DEV_MULTIPLE_ERRORS = (B_DEVICE_ERROR_BASE + 29); enum B_DEV_TOO_LATE = (B_DEVICE_ERROR_BASE + 30); /* Translation Kit Errors */ enum B_TRANSLATION_BASE_ERROR = (B_TRANSLATION_ERROR_BASE + 0); enum B_NO_TRANSLATOR = (B_TRANSLATION_ERROR_BASE + 1); enum B_ILLEGAL_DATA = (B_TRANSLATION_ERROR_BASE + 2); } else { static assert(false, "Unsupported platform"); }