| /** |
| * 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"); |
| } |
