1 /** 2 * D header file for C99. 3 * 4 * $(C_HEADER_DESCRIPTION pubs.opengroup.org/onlinepubs/009695399/basedefs/_errno.h.html, _errno.h) 5 * 6 * Copyright: Copyright Sean Kelly 2005 - 2009. 7 * License: Distributed under the 8 * $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0). 9 * (See accompanying file LICENSE) 10 * Authors: Sean Kelly, Alex Rønne Petersen 11 * Source: https://github.com/dlang/dmd/blob/master/druntime/src/core/stdc/errno.d 12 * Standards: ISO/IEC 9899:1999 (E) 13 */ 14 15 module core.stdc.errno; 16 17 version (OSX) 18 version = Darwin; 19 else version (iOS) 20 version = Darwin; 21 else version (TVOS) 22 version = Darwin; 23 else version (WatchOS) 24 version = Darwin; 25 26 version (ARM) version = ARM_Any; 27 version (AArch64) version = ARM_Any; 28 version (HPPA) version = HPPA_Any; 29 version (MIPS32) version = MIPS_Any; 30 version (MIPS64) version = MIPS_Any; 31 version (PPC) version = PPC_Any; 32 version (PPC64) version = PPC_Any; 33 version (RISCV32) version = RISCV_Any; 34 version (RISCV64) version = RISCV_Any; 35 version (S390) version = IBMZ_Any; 36 version (SPARC) version = SPARC_Any; 37 version (SPARC64) version = SPARC_Any; 38 version (SystemZ) version = IBMZ_Any; 39 version (X86) version = X86_Any; 40 version (X86_64) version = X86_Any; 41 42 @trusted: // Only manipulates errno. 43 nothrow: 44 @nogc: 45 version (CRuntime_LIBWASM) 46 { 47 extern (C) 48 { 49 ref int _errno(); 50 alias errno = _errno; 51 } 52 } 53 else version (CRuntime_DigitalMars) 54 { 55 extern (C) 56 { 57 ref int _errno(); 58 alias errno = _errno; 59 } 60 } 61 else version (CRuntime_Microsoft) 62 { 63 extern (C) 64 { 65 ref int _errno(); 66 alias errno = _errno; 67 } 68 } 69 else version (CRuntime_Glibc) 70 { 71 extern (C) 72 { 73 ref int __errno_location(); 74 alias errno = __errno_location; 75 } 76 } 77 else version (CRuntime_Musl) 78 { 79 extern (C) 80 { 81 ref int __errno_location(); 82 alias errno = __errno_location; 83 } 84 } 85 else version (OpenBSD) 86 { 87 // https://github.com/openbsd/src/blob/master/include/errno.h 88 extern (C) 89 { 90 ref int __errno(); 91 alias errno = __errno; 92 } 93 } 94 else version (NetBSD) 95 { 96 // https://github.com/NetBSD/src/blob/trunk/include/errno.h 97 extern (C) 98 { 99 ref int __errno(); 100 alias errno = __errno; 101 } 102 } 103 else version (FreeBSD) 104 { 105 extern (C) 106 { 107 ref int __error(); 108 alias errno = __error; 109 } 110 } 111 else version (DragonFlyBSD) 112 { 113 extern (C) 114 { 115 pragma(mangle, "errno") int __errno; 116 ref int __error() { 117 return __errno; 118 } 119 alias errno = __error; 120 } 121 } 122 else version (CRuntime_Bionic) 123 { 124 extern (C) 125 { 126 ref int __errno(); 127 alias errno = __errno; 128 } 129 } 130 else version (CRuntime_UClibc) 131 { 132 extern (C) 133 { 134 ref int __errno_location(); 135 alias errno = __errno_location; 136 } 137 } 138 else version (Darwin) 139 { 140 extern (C) 141 { 142 ref int __error(); 143 alias errno = __error; 144 } 145 } 146 else version (Solaris) 147 { 148 extern (C) 149 { 150 ref int ___errno(); 151 alias errno = ___errno; 152 } 153 } 154 else version (Haiku) 155 { 156 // https://github.com/haiku/haiku/blob/master/headers/posix/errno.h 157 extern (C) 158 { 159 ref int _errnop(); 160 alias errno = _errnop; 161 } 162 } 163 else 164 { 165 /// 166 extern(C) pragma(mangle, "getErrno") @property int errno(); 167 /// 168 extern(C) pragma(mangle, "setErrno") @property int errno(int n); 169 } 170 171 extern (C): 172 173 174 version (Windows) 175 { 176 enum EPERM = 1; /// Operation not permitted 177 enum ENOENT = 2; /// No such file or directory 178 enum ESRCH = 3; /// No such process 179 enum EINTR = 4; /// Interrupted system call 180 enum EIO = 5; /// I/O error 181 enum ENXIO = 6; /// No such device or address 182 enum E2BIG = 7; /// Argument list too long 183 enum ENOEXEC = 8; /// Exec format error 184 enum EBADF = 9; /// Bad file number 185 enum ECHILD = 10; /// No child processes 186 enum EAGAIN = 11; /// Try again 187 enum ENOMEM = 12; /// Out of memory 188 enum EACCES = 13; /// Permission denied 189 enum EFAULT = 14; /// Bad address 190 enum EBUSY = 16; /// Device or resource busy 191 enum EEXIST = 17; /// File exists 192 enum EXDEV = 18; /// Cross-device link 193 enum ENODEV = 19; /// No such device 194 enum ENOTDIR = 20; /// Not a directory 195 enum EISDIR = 21; /// Is a directory 196 enum EINVAL = 22; /// Invalid argument 197 enum ENFILE = 23; /// File table overflow 198 enum EMFILE = 24; /// Too many open files 199 enum ENOTTY = 25; /// Not a typewriter 200 enum EFBIG = 27; /// File too large 201 enum ENOSPC = 28; /// No space left on device 202 enum ESPIPE = 29; /// Illegal seek 203 enum EROFS = 30; /// Read-only file system 204 enum EMLINK = 31; /// Too many links 205 enum EPIPE = 32; /// Broken pipe 206 enum EDOM = 33; /// Math argument out of domain of func 207 enum ERANGE = 34; /// Math result not representable 208 enum EDEADLK = 36; /// Resource deadlock would occur 209 enum ENAMETOOLONG = 38; /// File name too long 210 enum ENOLCK = 39; /// No record locks available 211 enum ENOSYS = 40; /// Function not implemented 212 enum ENOTEMPTY = 41; /// Directory not empty 213 enum EILSEQ = 42; /// Illegal byte sequence 214 enum EDEADLOCK = EDEADLK; /// Resource deadlock would occur 215 216 // POSIX compatibility 217 // See_Also: https://docs.microsoft.com/en-us/cpp/c-runtime-library/errno-constants 218 enum EADDRINUSE = 100; 219 enum EADDRNOTAVAIL = 101; 220 enum EAFNOSUPPORT = 102; 221 enum EALREADY = 103; 222 enum EBADMSG = 104; 223 enum ECANCELED = 105; 224 enum ECONNABORTED = 106; 225 enum ECONNREFUSED = 107; 226 enum ECONNRESET = 108; 227 enum EDESTADDRREQ = 109; 228 enum EHOSTUNREACH = 110; 229 enum EIDRM = 111; 230 enum EINPROGRESS = 112; 231 enum EISCONN = 113; 232 enum ELOOP = 114; 233 enum EMSGSIZE = 115; 234 enum ENETDOWN = 116; 235 enum ENETRESET = 117; 236 enum ENETUNREACH = 118; 237 enum ENOBUFS = 119; 238 enum ENODATA = 120; 239 enum ENOLINK = 121; 240 enum ENOMSG = 122; 241 enum ENOPROTOOPT = 123; 242 enum ENOSR = 124; 243 enum ENOSTR = 125; 244 enum ENOTCONN = 126; 245 enum ENOTRECOVERABLE = 127; 246 enum ENOTSOCK = 128; 247 enum ENOTSUP = 129; 248 enum EOPNOTSUPP = 130; 249 enum EOTHER = 131; 250 enum EOVERFLOW = 132; 251 enum EOWNERDEAD = 133; 252 enum EPROTO = 134; 253 enum EPROTONOSUPPORT = 135; 254 enum EPROTOTYPE = 136; 255 enum ETIME = 137; 256 enum ETIMEDOUT = 138; 257 enum ETXTBSY = 139; 258 enum EWOULDBLOCK = 140; 259 } 260 else version (linux) 261 { 262 enum EPERM = 1; /// 263 enum ENOENT = 2; /// 264 enum ESRCH = 3; /// 265 enum EINTR = 4; /// 266 enum EIO = 5; /// 267 enum ENXIO = 6; /// 268 enum E2BIG = 7; /// 269 enum ENOEXEC = 8; /// 270 enum EBADF = 9; /// 271 enum ECHILD = 10; /// 272 enum EAGAIN = 11; /// 273 enum ENOMEM = 12; /// 274 enum EACCES = 13; /// 275 enum EFAULT = 14; /// 276 enum ENOTBLK = 15; /// 277 enum EBUSY = 16; /// 278 enum EEXIST = 17; /// 279 enum EXDEV = 18; /// 280 enum ENODEV = 19; /// 281 enum ENOTDIR = 20; /// 282 enum EISDIR = 21; /// 283 enum EINVAL = 22; /// 284 enum ENFILE = 23; /// 285 enum EMFILE = 24; /// 286 enum ENOTTY = 25; /// 287 enum ETXTBSY = 26; /// 288 enum EFBIG = 27; /// 289 enum ENOSPC = 28; /// 290 enum ESPIPE = 29; /// 291 enum EROFS = 30; /// 292 enum EMLINK = 31; /// 293 enum EPIPE = 32; /// 294 enum EDOM = 33; /// 295 enum ERANGE = 34; /// 296 297 version (X86_Any) 298 { 299 enum EDEADLK = 35; /// 300 enum ENAMETOOLONG = 36; /// 301 enum ENOLCK = 37; /// 302 enum ENOSYS = 38; /// 303 enum ENOTEMPTY = 39; /// 304 enum ELOOP = 40; /// 305 enum EWOULDBLOCK = EAGAIN; /// 306 enum ENOMSG = 42; /// 307 enum EIDRM = 43; /// 308 enum ECHRNG = 44; /// 309 enum EL2NSYNC = 45; /// 310 enum EL3HLT = 46; /// 311 enum EL3RST = 47; /// 312 enum ELNRNG = 48; /// 313 enum EUNATCH = 49; /// 314 enum ENOCSI = 50; /// 315 enum EL2HLT = 51; /// 316 enum EBADE = 52; /// 317 enum EBADR = 53; /// 318 enum EXFULL = 54; /// 319 enum ENOANO = 55; /// 320 enum EBADRQC = 56; /// 321 enum EBADSLT = 57; /// 322 enum EDEADLOCK = EDEADLK; /// 323 enum EBFONT = 59; /// 324 enum ENOSTR = 60; /// 325 enum ENODATA = 61; /// 326 enum ETIME = 62; /// 327 enum ENOSR = 63; /// 328 enum ENONET = 64; /// 329 enum ENOPKG = 65; /// 330 enum EREMOTE = 66; /// 331 enum ENOLINK = 67; /// 332 enum EADV = 68; /// 333 enum ESRMNT = 69; /// 334 enum ECOMM = 70; /// 335 enum EPROTO = 71; /// 336 enum EMULTIHOP = 72; /// 337 enum EDOTDOT = 73; /// 338 enum EBADMSG = 74; /// 339 enum EOVERFLOW = 75; /// 340 enum ENOTUNIQ = 76; /// 341 enum EBADFD = 77; /// 342 enum EREMCHG = 78; /// 343 enum ELIBACC = 79; /// 344 enum ELIBBAD = 80; /// 345 enum ELIBSCN = 81; /// 346 enum ELIBMAX = 82; /// 347 enum ELIBEXEC = 83; /// 348 enum EILSEQ = 84; /// 349 enum ERESTART = 85; /// 350 enum ESTRPIPE = 86; /// 351 enum EUSERS = 87; /// 352 enum ENOTSOCK = 88; /// 353 enum EDESTADDRREQ = 89; /// 354 enum EMSGSIZE = 90; /// 355 enum EPROTOTYPE = 91; /// 356 enum ENOPROTOOPT = 92; /// 357 enum EPROTONOSUPPORT = 93; /// 358 enum ESOCKTNOSUPPORT = 94; /// 359 enum EOPNOTSUPP = 95; /// 360 enum ENOTSUP = EOPNOTSUPP; /// 361 enum EPFNOSUPPORT = 96; /// 362 enum EAFNOSUPPORT = 97; /// 363 enum EADDRINUSE = 98; /// 364 enum EADDRNOTAVAIL = 99; /// 365 enum ENETDOWN = 100; /// 366 enum ENETUNREACH = 101; /// 367 enum ENETRESET = 102; /// 368 enum ECONNABORTED = 103; /// 369 enum ECONNRESET = 104; /// 370 enum ENOBUFS = 105; /// 371 enum EISCONN = 106; /// 372 enum ENOTCONN = 107; /// 373 enum ESHUTDOWN = 108; /// 374 enum ETOOMANYREFS = 109; /// 375 enum ETIMEDOUT = 110; /// 376 enum ECONNREFUSED = 111; /// 377 enum EHOSTDOWN = 112; /// 378 enum EHOSTUNREACH = 113; /// 379 enum EALREADY = 114; /// 380 enum EINPROGRESS = 115; /// 381 enum ESTALE = 116; /// 382 enum EUCLEAN = 117; /// 383 enum ENOTNAM = 118; /// 384 enum ENAVAIL = 119; /// 385 enum EISNAM = 120; /// 386 enum EREMOTEIO = 121; /// 387 enum EDQUOT = 122; /// 388 enum ENOMEDIUM = 123; /// 389 enum EMEDIUMTYPE = 124; /// 390 enum ECANCELED = 125; /// 391 enum ENOKEY = 126; /// 392 enum EKEYEXPIRED = 127; /// 393 enum EKEYREVOKED = 128; /// 394 enum EKEYREJECTED = 129; /// 395 enum EOWNERDEAD = 130; /// 396 enum ENOTRECOVERABLE = 131; /// 397 enum ERFKILL = 132; /// 398 enum EHWPOISON = 133; /// 399 } 400 else version (ARM_Any) 401 { 402 enum EDEADLK = 35; /// 403 enum ENAMETOOLONG = 36; /// 404 enum ENOLCK = 37; /// 405 enum ENOSYS = 38; /// 406 enum ENOTEMPTY = 39; /// 407 enum ELOOP = 40; /// 408 enum EWOULDBLOCK = EAGAIN; /// 409 enum ENOMSG = 42; /// 410 enum EIDRM = 43; /// 411 enum ECHRNG = 44; /// 412 enum EL2NSYNC = 45; /// 413 enum EL3HLT = 46; /// 414 enum EL3RST = 47; /// 415 enum ELNRNG = 48; /// 416 enum EUNATCH = 49; /// 417 enum ENOCSI = 50; /// 418 enum EL2HLT = 51; /// 419 enum EBADE = 52; /// 420 enum EBADR = 53; /// 421 enum EXFULL = 54; /// 422 enum ENOANO = 55; /// 423 enum EBADRQC = 56; /// 424 enum EBADSLT = 57; /// 425 enum EDEADLOCK = EDEADLK; /// 426 enum EBFONT = 59; /// 427 enum ENOSTR = 60; /// 428 enum ENODATA = 61; /// 429 enum ETIME = 62; /// 430 enum ENOSR = 63; /// 431 enum ENONET = 64; /// 432 enum ENOPKG = 65; /// 433 enum EREMOTE = 66; /// 434 enum ENOLINK = 67; /// 435 enum EADV = 68; /// 436 enum ESRMNT = 69; /// 437 enum ECOMM = 70; /// 438 enum EPROTO = 71; /// 439 enum EMULTIHOP = 72; /// 440 enum EDOTDOT = 73; /// 441 enum EBADMSG = 74; /// 442 enum EOVERFLOW = 75; /// 443 enum ENOTUNIQ = 76; /// 444 enum EBADFD = 77; /// 445 enum EREMCHG = 78; /// 446 enum ELIBACC = 79; /// 447 enum ELIBBAD = 80; /// 448 enum ELIBSCN = 81; /// 449 enum ELIBMAX = 82; /// 450 enum ELIBEXEC = 83; /// 451 enum EILSEQ = 84; /// 452 enum ERESTART = 85; /// 453 enum ESTRPIPE = 86; /// 454 enum EUSERS = 87; /// 455 enum ENOTSOCK = 88; /// 456 enum EDESTADDRREQ = 89; /// 457 enum EMSGSIZE = 90; /// 458 enum EPROTOTYPE = 91; /// 459 enum ENOPROTOOPT = 92; /// 460 enum EPROTONOSUPPORT = 93; /// 461 enum ESOCKTNOSUPPORT = 94; /// 462 enum EOPNOTSUPP = 95; /// 463 enum ENOTSUP = EOPNOTSUPP; /// 464 enum EPFNOSUPPORT = 96; /// 465 enum EAFNOSUPPORT = 97; /// 466 enum EADDRINUSE = 98; /// 467 enum EADDRNOTAVAIL = 99; /// 468 enum ENETDOWN = 100; /// 469 enum ENETUNREACH = 101; /// 470 enum ENETRESET = 102; /// 471 enum ECONNABORTED = 103; /// 472 enum ECONNRESET = 104; /// 473 enum ENOBUFS = 105; /// 474 enum EISCONN = 106; /// 475 enum ENOTCONN = 107; /// 476 enum ESHUTDOWN = 108; /// 477 enum ETOOMANYREFS = 109; /// 478 enum ETIMEDOUT = 110; /// 479 enum ECONNREFUSED = 111; /// 480 enum EHOSTDOWN = 112; /// 481 enum EHOSTUNREACH = 113; /// 482 enum EALREADY = 114; /// 483 enum EINPROGRESS = 115; /// 484 enum ESTALE = 116; /// 485 enum EUCLEAN = 117; /// 486 enum ENOTNAM = 118; /// 487 enum ENAVAIL = 119; /// 488 enum EISNAM = 120; /// 489 enum EREMOTEIO = 121; /// 490 enum EDQUOT = 122; /// 491 enum ENOMEDIUM = 123; /// 492 enum EMEDIUMTYPE = 124; /// 493 enum ECANCELED = 125; /// 494 enum ENOKEY = 126; /// 495 enum EKEYEXPIRED = 127; /// 496 enum EKEYREVOKED = 128; /// 497 enum EKEYREJECTED = 129; /// 498 enum EOWNERDEAD = 130; /// 499 enum ENOTRECOVERABLE = 131; /// 500 enum ERFKILL = 132; /// 501 enum EHWPOISON = 133; /// 502 } 503 else version (HPPA_Any) 504 { 505 enum ENOMSG = 35; /// 506 enum EIDRM = 36; /// 507 enum ECHRNG = 37; /// 508 enum EL2NSYNC = 38; /// 509 enum EL3HLT = 39; /// 510 enum EL3RST = 40; /// 511 enum ELNRNG = 41; /// 512 enum EUNATCH = 42; /// 513 enum ENOCSI = 43; /// 514 enum EL2HLT = 44; /// 515 enum EDEADLK = 45; /// 516 enum EDEADLOCK = EDEADLK; /// 517 enum ENOLCK = 46; /// 518 enum EILSEQ = 47; /// 519 enum ENONET = 50; /// 520 enum ENODATA = 51; /// 521 enum ETIME = 52; /// 522 enum ENOSR = 53; /// 523 enum ENOSTR = 54; /// 524 enum ENOPKG = 55; /// 525 enum ENOLINK = 57; /// 526 enum EADV = 58; /// 527 enum ESRMNT = 59; /// 528 enum ECOMM = 60; /// 529 enum EPROTO = 61; /// 530 enum EMULTIHOP = 64; /// 531 enum EDOTDOT = 66; /// 532 enum EBADMSG = 67; /// 533 enum EUSERS = 68; /// 534 enum EDQUOT = 69; /// 535 enum ESTALE = 70; /// 536 enum EREMOTE = 71; /// 537 enum EOVERFLOW = 72; /// 538 enum EBADE = 160; /// 539 enum EBADR = 161; /// 540 enum EXFULL = 162; /// 541 enum ENOANO = 163; /// 542 enum EBADRQC = 164; /// 543 enum EBADSLT = 165; /// 544 enum EBFONT = 166; /// 545 enum ENOTUNIQ = 167; /// 546 enum EBADFD = 168; /// 547 enum EREMCHG = 169; /// 548 enum ELIBACC = 170; /// 549 enum ELIBBAD = 171; /// 550 enum ELIBSCN = 172; /// 551 enum ELIBMAX = 173; /// 552 enum ELIBEXEC = 174; /// 553 enum ERESTART = 175; /// 554 enum ESTRPIPE = 176; /// 555 enum EUCLEAN = 177; /// 556 enum ENOTNAM = 178; /// 557 enum ENAVAIL = 179; /// 558 enum EISNAM = 180; /// 559 enum EREMOTEIO = 181; /// 560 enum ENOMEDIUM = 182; /// 561 enum EMEDIUMTYPE = 183; /// 562 enum ENOKEY = 184; /// 563 enum EKEYEXPIRED = 185; /// 564 enum EKEYREVOKED = 186; /// 565 enum EKEYREJECTED = 187; /// 566 enum ENOSYM = 215; /// 567 enum ENOTSOCK = 216; /// 568 enum EDESTADDRREQ = 217; /// 569 enum EMSGSIZE = 218; /// 570 enum EPROTOTYPE = 219; /// 571 enum ENOPROTOOPT = 220; /// 572 enum EPROTONOSUPPORT = 221; /// 573 enum ESOCKTNOSUPPORT = 221; /// 574 enum EOPNOTSUPP = 223; /// 575 enum EPFNOSUPPORT = 224; /// 576 enum EAFNOSUPPORT = 225; /// 577 enum EADDRINUSE = 226; /// 578 enum EADDRNOTAVAIL = 227; /// 579 enum ENETDOWN = 228; /// 580 enum ENETUNREACH = 229; /// 581 enum ENETRESET = 230; /// 582 enum ECONNABORTED = 231; /// 583 enum ECONNRESET = 232; /// 584 enum ENOBUFS = 233; /// 585 enum EISCONN = 234; /// 586 enum ENOTCONN = 235; /// 587 enum ESHUTDOWN = 236; /// 588 enum ETOOMANYREFS = 237; /// 589 enum ETIMEDOUT = 238; /// 590 enum ECONNREFUSED = 239; /// 591 enum EREFUSED = ECONNREFUSED; /// 592 enum EREMOTERELEASE = 240; /// 593 enum EHOSTDOWN = 241; /// 594 enum EHOSTUNREACH = 242; /// 595 enum EALREADY = 244; /// 596 enum EINPROGRESS = 245; /// 597 enum EWOULDBLOCK = EAGAIN; /// 598 enum ENOTEMPTY = 247; /// 599 enum ENAMETOOLONG = 248; /// 600 enum ELOOP = 249; /// 601 enum ENOSYS = 251; /// 602 enum ECANCELLED = 253; /// 603 enum ECANCELED = ECANCELLED; /// 604 enum EOWNERDEAD = 254; /// 605 enum ENOTRECOVERABLE = 255; /// 606 enum ERFKILL = 256; /// 607 enum EHWPOISON = 257; /// 608 } 609 else version (MIPS_Any) 610 { 611 enum ENOMSG = 35; /// 612 enum EIDRM = 36; /// 613 enum ECHRNG = 37; /// 614 enum EL2NSYNC = 38; /// 615 enum EL3HLT = 39; /// 616 enum EL3RST = 40; /// 617 enum ELNRNG = 41; /// 618 enum EUNATCH = 42; /// 619 enum ENOCSI = 43; /// 620 enum EL2HLT = 44; /// 621 enum EDEADLK = 45; /// 622 enum ENOLCK = 46; /// 623 enum EBADE = 50; /// 624 enum EBADR = 51; /// 625 enum EXFULL = 52; /// 626 enum ENOANO = 53; /// 627 enum EBADRQC = 54; /// 628 enum EBADSLT = 55; /// 629 enum EDEADLOCK = 56; /// 630 enum EBFONT = 59; /// 631 enum ENOSTR = 60; /// 632 enum ENODATA = 61; /// 633 enum ETIME = 62; /// 634 enum ENOSR = 63; /// 635 enum ENONET = 64; /// 636 enum ENOPKG = 65; /// 637 enum EREMOTE = 66; /// 638 enum ENOLINK = 67; /// 639 enum EADV = 68; /// 640 enum ESRMNT = 69; /// 641 enum ECOMM = 70; /// 642 enum EPROTO = 71; /// 643 enum EDOTDOT = 73; /// 644 enum EMULTIHOP = 74; /// 645 enum EBADMSG = 77; /// 646 enum ENAMETOOLONG = 78; /// 647 enum EOVERFLOW = 79; /// 648 enum ENOTUNIQ = 80; /// 649 enum EBADFD = 81; /// 650 enum EREMCHG = 82; /// 651 enum ELIBACC = 83; /// 652 enum ELIBBAD = 84; /// 653 enum ELIBSCN = 85; /// 654 enum ELIBMAX = 86; /// 655 enum ELIBEXEC = 87; /// 656 enum EILSEQ = 88; /// 657 enum ENOSYS = 89; /// 658 enum ELOOP = 90; /// 659 enum ERESTART = 91; /// 660 enum ESTRPIPE = 92; /// 661 enum ENOTEMPTY = 93; /// 662 enum EUSERS = 94; /// 663 enum ENOTSOCK = 95; /// 664 enum EDESTADDRREQ = 96; /// 665 enum EMSGSIZE = 97; /// 666 enum EPROTOTYPE = 98; /// 667 enum ENOPROTOOPT = 99; /// 668 enum EPROTONOSUPPORT = 120; /// 669 enum ESOCKTNOSUPPORT = 121; /// 670 enum EOPNOTSUPP = 122; /// 671 enum ENOTSUP = EOPNOTSUPP; /// 672 enum EPFNOSUPPORT = 123; /// 673 enum EAFNOSUPPORT = 124; /// 674 enum EADDRINUSE = 125; /// 675 enum EADDRNOTAVAIL = 126; /// 676 enum ENETDOWN = 127; /// 677 enum ENETUNREACH = 128; /// 678 enum ENETRESET = 129; /// 679 enum ECONNABORTED = 130; /// 680 enum ECONNRESET = 131; /// 681 enum ENOBUFS = 132; /// 682 enum EISCONN = 133; /// 683 enum ENOTCONN = 134; /// 684 enum EUCLEAN = 135; /// 685 enum ENOTNAM = 137; /// 686 enum ENAVAIL = 138; /// 687 enum EISNAM = 139; /// 688 enum EREMOTEIO = 140; /// 689 enum EINIT = 141; /// 690 enum EREMDEV = 142; /// 691 enum ESHUTDOWN = 143; /// 692 enum ETOOMANYREFS = 144; /// 693 enum ETIMEDOUT = 145; /// 694 enum ECONNREFUSED = 146; /// 695 enum EHOSTDOWN = 147; /// 696 enum EHOSTUNREACH = 148; /// 697 enum EWOULDBLOCK = EAGAIN; /// 698 enum EALREADY = 149; /// 699 enum EINPROGRESS = 150; /// 700 enum ESTALE = 151; /// 701 enum ECANCELED = 158; /// 702 enum ENOMEDIUM = 159; /// 703 enum EMEDIUMTYPE = 160; /// 704 enum ENOKEY = 161; /// 705 enum EKEYEXPIRED = 162; /// 706 enum EKEYREVOKED = 163; /// 707 enum EKEYREJECTED = 164; /// 708 enum EOWNERDEAD = 165; /// 709 enum ENOTRECOVERABLE = 166; /// 710 enum ERFKILL = 167; /// 711 enum EHWPOISON = 168; /// 712 enum EDQUOT = 1133; /// 713 } 714 else version (PPC_Any) 715 { 716 enum EDEADLK = 35; /// 717 enum ENAMETOOLONG = 36; /// 718 enum ENOLCK = 37; /// 719 enum ENOSYS = 38; /// 720 enum ENOTEMPTY = 39; /// 721 enum ELOOP = 40; /// 722 enum EWOULDBLOCK = EAGAIN; /// 723 enum ENOMSG = 42; /// 724 enum EIDRM = 43; /// 725 enum ECHRNG = 44; /// 726 enum EL2NSYNC = 45; /// 727 enum EL3HLT = 46; /// 728 enum EL3RST = 47; /// 729 enum ELNRNG = 48; /// 730 enum EUNATCH = 49; /// 731 enum ENOCSI = 50; /// 732 enum EL2HLT = 51; /// 733 enum EBADE = 52; /// 734 enum EBADR = 53; /// 735 enum EXFULL = 54; /// 736 enum ENOANO = 55; /// 737 enum EBADRQC = 56; /// 738 enum EBADSLT = 57; /// 739 enum EDEADLOCK = 58; /// 740 enum EBFONT = 59; /// 741 enum ENOSTR = 60; /// 742 enum ENODATA = 61; /// 743 enum ETIME = 62; /// 744 enum ENOSR = 63; /// 745 enum ENONET = 64; /// 746 enum ENOPKG = 65; /// 747 enum EREMOTE = 66; /// 748 enum ENOLINK = 67; /// 749 enum EADV = 68; /// 750 enum ESRMNT = 69; /// 751 enum ECOMM = 70; /// 752 enum EPROTO = 71; /// 753 enum EMULTIHOP = 72; /// 754 enum EDOTDOT = 73; /// 755 enum EBADMSG = 74; /// 756 enum EOVERFLOW = 75; /// 757 enum ENOTUNIQ = 76; /// 758 enum EBADFD = 77; /// 759 enum EREMCHG = 78; /// 760 enum ELIBACC = 79; /// 761 enum ELIBBAD = 80; /// 762 enum ELIBSCN = 81; /// 763 enum ELIBMAX = 82; /// 764 enum ELIBEXEC = 83; /// 765 enum EILSEQ = 84; /// 766 enum ERESTART = 85; /// 767 enum ESTRPIPE = 86; /// 768 enum EUSERS = 87; /// 769 enum ENOTSOCK = 88; /// 770 enum EDESTADDRREQ = 89; /// 771 enum EMSGSIZE = 90; /// 772 enum EPROTOTYPE = 91; /// 773 enum ENOPROTOOPT = 92; /// 774 enum EPROTONOSUPPORT = 93; /// 775 enum ESOCKTNOSUPPORT = 94; /// 776 enum EOPNOTSUPP = 95; /// 777 enum ENOTSUP = EOPNOTSUPP; /// 778 enum EPFNOSUPPORT = 96; /// 779 enum EAFNOSUPPORT = 97; /// 780 enum EADDRINUSE = 98; /// 781 enum EADDRNOTAVAIL = 99; /// 782 enum ENETDOWN = 100; /// 783 enum ENETUNREACH = 101; /// 784 enum ENETRESET = 102; /// 785 enum ECONNABORTED = 103; /// 786 enum ECONNRESET = 104; /// 787 enum ENOBUFS = 105; /// 788 enum EISCONN = 106; /// 789 enum ENOTCONN = 107; /// 790 enum ESHUTDOWN = 108; /// 791 enum ETOOMANYREFS = 109; /// 792 enum ETIMEDOUT = 110; /// 793 enum ECONNREFUSED = 111; /// 794 enum EHOSTDOWN = 112; /// 795 enum EHOSTUNREACH = 113; /// 796 enum EALREADY = 114; /// 797 enum EINPROGRESS = 115; /// 798 enum ESTALE = 116; /// 799 enum EUCLEAN = 117; /// 800 enum ENOTNAM = 118; /// 801 enum ENAVAIL = 119; /// 802 enum EISNAM = 120; /// 803 enum EREMOTEIO = 121; /// 804 enum EDQUOT = 122; /// 805 enum ENOMEDIUM = 123; /// 806 enum EMEDIUMTYPE = 124; /// 807 enum ECANCELED = 125; /// 808 enum ENOKEY = 126; /// 809 enum EKEYEXPIRED = 127; /// 810 enum EKEYREVOKED = 128; /// 811 enum EKEYREJECTED = 129; /// 812 enum EOWNERDEAD = 130; /// 813 enum ENOTRECOVERABLE = 131; /// 814 enum ERFKILL = 132; /// 815 enum EHWPOISON = 133; /// 816 } 817 else version (RISCV_Any) 818 { 819 enum EDEADLK = 35; /// 820 enum ENAMETOOLONG = 36; /// 821 enum ENOLCK = 37; /// 822 enum ENOSYS = 38; /// 823 enum ENOTEMPTY = 39; /// 824 enum ELOOP = 40; /// 825 enum EWOULDBLOCK = EAGAIN; /// 826 enum ENOMSG = 42; /// 827 enum EIDRM = 43; /// 828 enum ECHRNG = 44; /// 829 enum EL2NSYNC = 45; /// 830 enum EL3HLT = 46; /// 831 enum EL3RST = 47; /// 832 enum ELNRNG = 48; /// 833 enum EUNATCH = 49; /// 834 enum ENOCSI = 50; /// 835 enum EL2HLT = 51; /// 836 enum EBADE = 52; /// 837 enum EBADR = 53; /// 838 enum EXFULL = 54; /// 839 enum ENOANO = 55; /// 840 enum EBADRQC = 56; /// 841 enum EBADSLT = 57; /// 842 enum EDEADLOCK = EDEADLK; /// 843 enum EBFONT = 59; /// 844 enum ENOSTR = 60; /// 845 enum ENODATA = 61; /// 846 enum ETIME = 62; /// 847 enum ENOSR = 63; /// 848 enum ENONET = 64; /// 849 enum ENOPKG = 65; /// 850 enum EREMOTE = 66; /// 851 enum ENOLINK = 67; /// 852 enum EADV = 68; /// 853 enum ESRMNT = 69; /// 854 enum ECOMM = 70; /// 855 enum EPROTO = 71; /// 856 enum EMULTIHOP = 72; /// 857 enum EDOTDOT = 73; /// 858 enum EBADMSG = 74; /// 859 enum EOVERFLOW = 75; /// 860 enum ENOTUNIQ = 76; /// 861 enum EBADFD = 77; /// 862 enum EREMCHG = 78; /// 863 enum ELIBACC = 79; /// 864 enum ELIBBAD = 80; /// 865 enum ELIBSCN = 81; /// 866 enum ELIBMAX = 82; /// 867 enum ELIBEXEC = 83; /// 868 enum EILSEQ = 84; /// 869 enum ERESTART = 85; /// 870 enum ESTRPIPE = 86; /// 871 enum EUSERS = 87; /// 872 enum ENOTSOCK = 88; /// 873 enum EDESTADDRREQ = 89; /// 874 enum EMSGSIZE = 90; /// 875 enum EPROTOTYPE = 91; /// 876 enum ENOPROTOOPT = 92; /// 877 enum EPROTONOSUPPORT = 93; /// 878 enum ESOCKTNOSUPPORT = 94; /// 879 enum EOPNOTSUPP = 95; /// 880 enum EPFNOSUPPORT = 96; /// 881 enum EAFNOSUPPORT = 97; /// 882 enum EADDRINUSE = 98; /// 883 enum EADDRNOTAVAIL = 99; /// 884 enum ENETDOWN = 100; /// 885 enum ENETUNREACH = 101; /// 886 enum ENETRESET = 102; /// 887 enum ECONNABORTED = 103; /// 888 enum ECONNRESET = 104; /// 889 enum ENOBUFS = 105; /// 890 enum EISCONN = 106; /// 891 enum ENOTCONN = 107; /// 892 enum ESHUTDOWN = 108; /// 893 enum ETOOMANYREFS = 109; /// 894 enum ETIMEDOUT = 110; /// 895 enum ECONNREFUSED = 111; /// 896 enum EHOSTDOWN = 112; /// 897 enum EHOSTUNREACH = 113; /// 898 enum EALREADY = 114; /// 899 enum EINPROGRESS = 115; /// 900 enum ESTALE = 116; /// 901 enum EUCLEAN = 117; /// 902 enum ENOTNAM = 118; /// 903 enum ENAVAIL = 119; /// 904 enum EISNAM = 120; /// 905 enum EREMOTEIO = 121; /// 906 enum EDQUOT = 122; /// 907 enum ENOMEDIUM = 123; /// 908 enum EMEDIUMTYPE = 124; /// 909 enum ECANCELED = 125; /// 910 enum ENOKEY = 126; /// 911 enum EKEYEXPIRED = 127; /// 912 enum EKEYREVOKED = 128; /// 913 enum EKEYREJECTED = 129; /// 914 enum EOWNERDEAD = 130; /// 915 enum ENOTRECOVERABLE = 131; /// 916 enum ERFKILL = 132; /// 917 enum EHWPOISON = 133; /// 918 } 919 else version (SPARC_Any) 920 { 921 enum EWOULDBLOCK = EAGAIN; /// 922 enum EINPROGRESS = 36; /// 923 enum EALREADY = 37; /// 924 enum ENOTSOCK = 38; /// 925 enum EDESTADDRREQ = 39; /// 926 enum EMSGSIZE = 40; /// 927 enum EPROTOTYPE = 41; /// 928 enum ENOPROTOOPT = 42; /// 929 enum EPROTONOSUPPORT = 43; /// 930 enum ESOCKTNOSUPPORT = 44; /// 931 enum EOPNOTSUPP = 45; /// 932 enum ENOTSUP = EOPNOTSUPP; /// 933 enum EPFNOSUPPORT = 46; /// 934 enum EAFNOSUPPORT = 47; /// 935 enum EADDRINUSE = 48; /// 936 enum EADDRNOTAVAIL = 49; /// 937 enum ENETDOWN = 50; /// 938 enum ENETUNREACH = 51; /// 939 enum ENETRESET = 52; /// 940 enum ECONNABORTED = 53; /// 941 enum ECONNRESET = 54; /// 942 enum ENOBUFS = 55; /// 943 enum EISCONN = 56; /// 944 enum ENOTCONN = 57; /// 945 enum ESHUTDOWN = 58; /// 946 enum ETOOMANYREFS = 59; /// 947 enum ETIMEDOUT = 60; /// 948 enum ECONNREFUSED = 61; /// 949 enum ELOOP = 62; /// 950 enum ENAMETOOLONG = 63; /// 951 enum EHOSTDOWN = 64; /// 952 enum EHOSTUNREACH = 65; /// 953 enum ENOTEMPTY = 66; /// 954 enum EPROCLIM = 67; /// 955 enum EUSERS = 68; /// 956 enum EDQUOT = 69; /// 957 enum ESTALE = 70; /// 958 enum EREMOTE = 71; /// 959 enum ENOSTR = 72; /// 960 enum ETIME = 73; /// 961 enum ENOSR = 74; /// 962 enum ENOMSG = 75; /// 963 enum EBADMSG = 76; /// 964 enum EIDRM = 77; /// 965 enum EDEADLK = 78; /// 966 enum ENOLCK = 79; /// 967 enum ENONET = 80; /// 968 enum ERREMOTE = 81; /// 969 enum ENOLINK = 82; /// 970 enum EADV = 83; /// 971 enum ESRMNT = 84; /// 972 enum ECOMM = 85; /// 973 enum EPROTO = 86; /// 974 enum EMULTIHOP = 87; /// 975 enum EDOTDOT = 88; /// 976 enum EREMCHG = 89; /// 977 enum ENOSYS = 90; /// 978 enum ESTRPIPE = 91; /// 979 enum EOVERFLOW = 92; /// 980 enum EBADFD = 93; /// 981 enum ECHRNG = 94; /// 982 enum EL2NSYNC = 95; /// 983 enum EL3HLT = 96; /// 984 enum EL3RST = 97; /// 985 enum ELNRNG = 98; /// 986 enum EUNATCH = 99; /// 987 enum ENOCSI = 100; /// 988 enum EL2HLT = 101; /// 989 enum EBADE = 102; /// 990 enum EBADR = 103; /// 991 enum EXFULL = 104; /// 992 enum ENOANO = 105; /// 993 enum EBADRQC = 106; /// 994 enum EBADSLT = 107; /// 995 enum EDEADLOCK = 108; /// 996 enum EBFONT = 109; /// 997 enum ELIBEXEC = 110; /// 998 enum ENODATA = 111; /// 999 enum ELIBBAD = 112; /// 1000 enum ENOPKG = 113; /// 1001 enum ELIBACC = 114; /// 1002 enum ENOTUNIQ = 115; /// 1003 enum ERESTART = 116; /// 1004 enum EUCLEAN = 117; /// 1005 enum ENOTNAM = 118; /// 1006 enum ENAVAIL = 119; /// 1007 enum EISNAM = 120; /// 1008 enum EREMOTEIO = 121; /// 1009 enum EILSEQ = 122; /// 1010 enum ELIBMAX = 123; /// 1011 enum ELIBSCN = 124; /// 1012 enum ENOMEDIUM = 125; /// 1013 enum EMEDIUMTYPE = 126; /// 1014 enum ECANCELED = 127; /// 1015 enum ENOKEY = 128; /// 1016 enum EKEYEXPIRED = 129; /// 1017 enum EKEYREVOKED = 130; /// 1018 enum EKEYREJECTED = 131; /// 1019 enum EOWNERDEAD = 132; /// 1020 enum ENOTRECOVERABLE = 133; /// 1021 enum ERFKILL = 134; /// 1022 enum EHWPOISON = 135; /// 1023 } 1024 else version (IBMZ_Any) 1025 { 1026 enum EDEADLK = 35; /// 1027 enum ENAMETOOLONG = 36; /// 1028 enum ENOLCK = 37; /// 1029 enum ENOSYS = 38; /// 1030 enum ENOTEMPTY = 39; /// 1031 enum ELOOP = 40; /// 1032 enum EWOULDBLOCK = EAGAIN; /// 1033 enum ENOMSG = 42; /// 1034 enum EIDRM = 43; /// 1035 enum ECHRNG = 44; /// 1036 enum EL2NSYNC = 45; /// 1037 enum EL3HLT = 46; /// 1038 enum EL3RST = 47; /// 1039 enum ELNRNG = 48; /// 1040 enum EUNATCH = 49; /// 1041 enum ENOCSI = 50; /// 1042 enum EL2HLT = 51; /// 1043 enum EBADE = 52; /// 1044 enum EBADR = 53; /// 1045 enum EXFULL = 54; /// 1046 enum ENOANO = 55; /// 1047 enum EBADRQC = 56; /// 1048 enum EBADSLT = 57; /// 1049 enum EDEADLOCK = EDEADLK; /// 1050 enum EBFONT = 59; /// 1051 enum ENOSTR = 60; /// 1052 enum ENODATA = 61; /// 1053 enum ETIME = 62; /// 1054 enum ENOSR = 63; /// 1055 enum ENONET = 64; /// 1056 enum ENOPKG = 65; /// 1057 enum EREMOTE = 66; /// 1058 enum ENOLINK = 67; /// 1059 enum EADV = 68; /// 1060 enum ESRMNT = 69; /// 1061 enum ECOMM = 70; /// 1062 enum EPROTO = 71; /// 1063 enum EMULTIHOP = 72; /// 1064 enum EDOTDOT = 73; /// 1065 enum EBADMSG = 74; /// 1066 enum EOVERFLOW = 75; /// 1067 enum ENOTUNIQ = 76; /// 1068 enum EBADFD = 77; /// 1069 enum EREMCHG = 78; /// 1070 enum ELIBACC = 79; /// 1071 enum ELIBBAD = 80; /// 1072 enum ELIBSCN = 81; /// 1073 enum ELIBMAX = 82; /// 1074 enum ELIBEXEC = 83; /// 1075 enum EILSEQ = 84; /// 1076 enum ERESTART = 85; /// 1077 enum ESTRPIPE = 86; /// 1078 enum EUSERS = 87; /// 1079 enum ENOTSOCK = 88; /// 1080 enum EDESTADDRREQ = 89; /// 1081 enum EMSGSIZE = 90; /// 1082 enum EPROTOTYPE = 91; /// 1083 enum ENOPROTOOPT = 92; /// 1084 enum EPROTONOSUPPORT = 93; /// 1085 enum ESOCKTNOSUPPORT = 94; /// 1086 enum EOPNOTSUPP = 95; /// 1087 enum ENOTSUP = EOPNOTSUPP; /// 1088 enum EPFNOSUPPORT = 96; /// 1089 enum EAFNOSUPPORT = 97; /// 1090 enum EADDRINUSE = 98; /// 1091 enum EADDRNOTAVAIL = 99; /// 1092 enum ENETDOWN = 100; /// 1093 enum ENETUNREACH = 101; /// 1094 enum ENETRESET = 102; /// 1095 enum ECONNABORTED = 103; /// 1096 enum ECONNRESET = 104; /// 1097 enum ENOBUFS = 105; /// 1098 enum EISCONN = 106; /// 1099 enum ENOTCONN = 107; /// 1100 enum ESHUTDOWN = 108; /// 1101 enum ETOOMANYREFS = 109; /// 1102 enum ETIMEDOUT = 110; /// 1103 enum ECONNREFUSED = 111; /// 1104 enum EHOSTDOWN = 112; /// 1105 enum EHOSTUNREACH = 113; /// 1106 enum EALREADY = 114; /// 1107 enum EINPROGRESS = 115; /// 1108 enum ESTALE = 116; /// 1109 enum EUCLEAN = 117; /// 1110 enum ENOTNAM = 118; /// 1111 enum ENAVAIL = 119; /// 1112 enum EISNAM = 120; /// 1113 enum EREMOTEIO = 121; /// 1114 enum EDQUOT = 122; /// 1115 enum ENOMEDIUM = 123; /// 1116 enum EMEDIUMTYPE = 124; /// 1117 enum ECANCELED = 125; /// 1118 enum ENOKEY = 126; /// 1119 enum EKEYEXPIRED = 127; /// 1120 enum EKEYREVOKED = 128; /// 1121 enum EKEYREJECTED = 129; /// 1122 enum EOWNERDEAD = 130; /// 1123 enum ENOTRECOVERABLE = 131; /// 1124 enum ERFKILL = 132; /// 1125 enum EHWPOISON = 133; /// 1126 } 1127 else version (LoongArch64) 1128 { 1129 enum EDEADLK = 35; /// 1130 enum ENAMETOOLONG = 36; /// 1131 enum ENOLCK = 37; /// 1132 enum ENOSYS = 38; /// 1133 enum ENOTEMPTY = 39; /// 1134 enum ELOOP = 40; /// 1135 enum EWOULDBLOCK = EAGAIN; /// 1136 enum ENOMSG = 42; /// 1137 enum EIDRM = 43; /// 1138 enum ECHRNG = 44; /// 1139 enum EL2NSYNC = 45; /// 1140 enum EL3HLT = 46; /// 1141 enum EL3RST = 47; /// 1142 enum ELNRNG = 48; /// 1143 enum EUNATCH = 49; /// 1144 enum ENOCSI = 50; /// 1145 enum EL2HLT = 51; /// 1146 enum EBADE = 52; /// 1147 enum EBADR = 53; /// 1148 enum EXFULL = 54; /// 1149 enum ENOANO = 55; /// 1150 enum EBADRQC = 56; /// 1151 enum EBADSLT = 57; /// 1152 enum EDEADLOCK = EDEADLK; /// 1153 enum EBFONT = 59; /// 1154 enum ENOSTR = 60; /// 1155 enum ENODATA = 61; /// 1156 enum ETIME = 62; /// 1157 enum ENOSR = 63; /// 1158 enum ENONET = 64; /// 1159 enum ENOPKG = 65; /// 1160 enum EREMOTE = 66; /// 1161 enum ENOLINK = 67; /// 1162 enum EADV = 68; /// 1163 enum ESRMNT = 69; /// 1164 enum ECOMM = 70; /// 1165 enum EPROTO = 71; /// 1166 enum EMULTIHOP = 72; /// 1167 enum EDOTDOT = 73; /// 1168 enum EBADMSG = 74; /// 1169 enum EOVERFLOW = 75; /// 1170 enum ENOTUNIQ = 76; /// 1171 enum EBADFD = 77; /// 1172 enum EREMCHG = 78; /// 1173 enum ELIBACC = 79; /// 1174 enum ELIBBAD = 80; /// 1175 enum ELIBSCN = 81; /// 1176 enum ELIBMAX = 82; /// 1177 enum ELIBEXEC = 83; /// 1178 enum EILSEQ = 84; /// 1179 enum ERESTART = 85; /// 1180 enum ESTRPIPE = 86; /// 1181 enum EUSERS = 87; /// 1182 enum ENOTSOCK = 88; /// 1183 enum EDESTADDRREQ = 89; /// 1184 enum EMSGSIZE = 90; /// 1185 enum EPROTOTYPE = 91; /// 1186 enum ENOPROTOOPT = 92; /// 1187 enum EPROTONOSUPPORT = 93; /// 1188 enum ESOCKTNOSUPPORT = 94; /// 1189 enum EOPNOTSUPP = 95; /// 1190 enum ENOTSUP = EOPNOTSUPP; /// 1191 enum EPFNOSUPPORT = 96; /// 1192 enum EAFNOSUPPORT = 97; /// 1193 enum EADDRINUSE = 98; /// 1194 enum EADDRNOTAVAIL = 99; /// 1195 enum ENETDOWN = 100; /// 1196 enum ENETUNREACH = 101; /// 1197 enum ENETRESET = 102; /// 1198 enum ECONNABORTED = 103; /// 1199 enum ECONNRESET = 104; /// 1200 enum ENOBUFS = 105; /// 1201 enum EISCONN = 106; /// 1202 enum ENOTCONN = 107; /// 1203 enum ESHUTDOWN = 108; /// 1204 enum ETOOMANYREFS = 109; /// 1205 enum ETIMEDOUT = 110; /// 1206 enum ECONNREFUSED = 111; /// 1207 enum EHOSTDOWN = 112; /// 1208 enum EHOSTUNREACH = 113; /// 1209 enum EALREADY = 114; /// 1210 enum EINPROGRESS = 115; /// 1211 enum ESTALE = 116; /// 1212 enum EUCLEAN = 117; /// 1213 enum ENOTNAM = 118; /// 1214 enum ENAVAIL = 119; /// 1215 enum EISNAM = 120; /// 1216 enum EREMOTEIO = 121; /// 1217 enum EDQUOT = 122; /// 1218 enum ENOMEDIUM = 123; /// 1219 enum EMEDIUMTYPE = 124; /// 1220 enum ECANCELED = 125; /// 1221 enum ENOKEY = 126; /// 1222 enum EKEYEXPIRED = 127; /// 1223 enum EKEYREVOKED = 128; /// 1224 enum EKEYREJECTED = 129; /// 1225 enum EOWNERDEAD = 130; /// 1226 enum ENOTRECOVERABLE = 131; /// 1227 enum ERFKILL = 132; /// 1228 enum EHWPOISON = 133; /// 1229 } 1230 else 1231 { 1232 static assert(false, "Architecture not supported."); 1233 } 1234 } 1235 else version (Darwin) 1236 { 1237 enum EPERM = 1; /// Operation not permitted 1238 enum ENOENT = 2; /// No such file or directory 1239 enum ESRCH = 3; /// No such process 1240 enum EINTR = 4; /// Interrupted system call 1241 enum EIO = 5; /// Input/output error 1242 enum ENXIO = 6; /// Device not configured 1243 enum E2BIG = 7; /// Argument list too long 1244 enum ENOEXEC = 8; /// Exec format error 1245 enum EBADF = 9; /// Bad file descriptor 1246 enum ECHILD = 10; /// No child processes 1247 enum EDEADLK = 11; /// Resource deadlock avoided 1248 enum ENOMEM = 12; /// Cannot allocate memory 1249 enum EACCES = 13; /// Permission denied 1250 enum EFAULT = 14; /// Bad address 1251 enum EBUSY = 16; /// Device busy 1252 enum EEXIST = 17; /// File exists 1253 enum EXDEV = 18; /// Cross-device link 1254 enum ENODEV = 19; /// Operation not supported by device 1255 enum ENOTDIR = 20; /// Not a directory 1256 enum EISDIR = 21; /// Is a directory 1257 enum EINVAL = 22; /// Invalid argument 1258 enum ENFILE = 23; /// Too many open files in system 1259 enum EMFILE = 24; /// Too many open files 1260 enum ENOTTY = 25; /// Inappropriate ioctl for device 1261 enum ETXTBSY = 26; /// Text file busy 1262 enum EFBIG = 27; /// File too large 1263 enum ENOSPC = 28; /// No space left on device 1264 enum ESPIPE = 29; /// Illegal seek 1265 enum EROFS = 30; /// Read-only file system 1266 enum EMLINK = 31; /// Too many links 1267 enum EPIPE = 32; /// Broken pipe 1268 enum EDOM = 33; /// Numerical argument out of domain 1269 enum ERANGE = 34; /// Result too large 1270 enum EAGAIN = 35; /// Resource temporarily unavailable 1271 enum EWOULDBLOCK = EAGAIN; /// Operation would block 1272 enum EINPROGRESS = 36; /// Operation now in progress 1273 enum EALREADY = 37; /// Operation already in progress 1274 enum ENOTSOCK = 38; /// Socket operation on non-socket 1275 enum EDESTADDRREQ = 39; /// Destination address required 1276 enum EMSGSIZE = 40; /// Message too long 1277 enum EPROTOTYPE = 41; /// Protocol wrong type for socket 1278 enum ENOPROTOOPT = 42; /// Protocol not available 1279 enum EPROTONOSUPPORT = 43; /// Protocol not supported 1280 enum ENOTSUP = 45; /// Operation not supported 1281 enum EOPNOTSUPP = ENOTSUP; /// Operation not supported on socket 1282 enum EAFNOSUPPORT = 47; /// Address family not supported by protocol family 1283 enum EADDRINUSE = 48; /// Address already in use 1284 enum EADDRNOTAVAIL = 49; /// Can't assign requested address 1285 enum ENETDOWN = 50; /// Network is down 1286 enum ENETUNREACH = 51; /// Network is unreachable 1287 enum ENETRESET = 52; /// Network dropped connection on reset 1288 enum ECONNABORTED = 53; /// Software caused connection abort 1289 enum ECONNRESET = 54; /// Connection reset by peer 1290 enum ENOBUFS = 55; /// No buffer space available 1291 enum EISCONN = 56; /// Socket is already connected 1292 enum ENOTCONN = 57; /// Socket is not connected 1293 enum ETIMEDOUT = 60; /// Operation timed out 1294 enum ECONNREFUSED = 61; /// Connection refused 1295 enum ELOOP = 62; /// Too many levels of symbolic links 1296 enum ENAMETOOLONG = 63; /// File name too long 1297 enum EHOSTUNREACH = 65; /// No route to host 1298 enum ENOTEMPTY = 66; /// Directory not empty 1299 enum EDQUOT = 69; /// Disc quota exceeded 1300 enum ESTALE = 70; /// Stale NFS file handle 1301 enum ENOLCK = 77; /// No locks available 1302 enum ENOSYS = 78; /// Function not implemented 1303 enum EOVERFLOW = 84; /// Value too large to be stored in data type 1304 enum ECANCELED = 89; /// Operation canceled 1305 enum EIDRM = 90; /// Identifier removed 1306 enum ENOMSG = 91; /// No message of desired type 1307 enum EILSEQ = 92; /// Illegal byte sequence 1308 enum EBADMSG = 94; /// Bad message 1309 enum EMULTIHOP = 95; /// Reserved 1310 enum ENODATA = 96; /// No message available on STREAM 1311 enum ENOLINK = 97; /// Reserved 1312 enum ENOSR = 98; /// No STREAM resources 1313 enum ENOSTR = 99; /// Not a STREAM 1314 enum EPROTO = 100; /// Protocol error 1315 enum ETIME = 101; /// STREAM ioctl timeout 1316 enum ELAST = 101; /// Must be equal largest errno 1317 } 1318 else version (FreeBSD) 1319 { 1320 enum EPERM = 1; /// Operation not permitted 1321 enum ENOENT = 2; /// No such file or directory 1322 enum ESRCH = 3; /// No such process 1323 enum EINTR = 4; /// Interrupted system call 1324 enum EIO = 5; /// Input/output error 1325 enum ENXIO = 6; /// Device not configured 1326 enum E2BIG = 7; /// Argument list too long 1327 enum ENOEXEC = 8; /// Exec format error 1328 enum EBADF = 9; /// Bad file descriptor 1329 enum ECHILD = 10; /// No child processes 1330 enum EDEADLK = 11; /// Resource deadlock avoided 1331 enum ENOMEM = 12; /// Cannot allocate memory 1332 enum EACCES = 13; /// Permission denied 1333 enum EFAULT = 14; /// Bad address 1334 enum ENOTBLK = 15; /// Block device required 1335 enum EBUSY = 16; /// Device busy 1336 enum EEXIST = 17; /// File exists 1337 enum EXDEV = 18; /// Cross-device link 1338 enum ENODEV = 19; /// Operation not supported by device 1339 enum ENOTDIR = 20; /// Not a directory 1340 enum EISDIR = 21; /// Is a directory 1341 enum EINVAL = 22; /// Invalid argument 1342 enum ENFILE = 23; /// Too many open files in system 1343 enum EMFILE = 24; /// Too many open files 1344 enum ENOTTY = 25; /// Inappropriate ioctl for device 1345 enum ETXTBSY = 26; /// Text file busy 1346 enum EFBIG = 27; /// File too large 1347 enum ENOSPC = 28; /// No space left on device 1348 enum ESPIPE = 29; /// Illegal seek 1349 enum EROFS = 30; /// Read-only file system 1350 enum EMLINK = 31; /// Too many links 1351 enum EPIPE = 32; /// Broken pipe 1352 enum EDOM = 33; /// Numerical argument out of domain 1353 enum ERANGE = 34; /// Result too large 1354 enum EAGAIN = 35; /// Resource temporarily unavailable 1355 enum EWOULDBLOCK = EAGAIN; /// Operation would block 1356 enum EINPROGRESS = 36; /// Operation now in progress 1357 enum EALREADY = 37; /// Operation already in progress 1358 enum ENOTSOCK = 38; /// Socket operation on non-socket 1359 enum EDESTADDRREQ = 39; /// Destination address required 1360 enum EMSGSIZE = 40; /// Message too long 1361 enum EPROTOTYPE = 41; /// Protocol wrong type for socket 1362 enum ENOPROTOOPT = 42; /// Protocol not available 1363 enum EPROTONOSUPPORT = 43; /// Protocol not supported 1364 enum ENOTSUP = 45; /// Operation not supported 1365 enum EOPNOTSUPP = ENOTSUP; /// Operation not supported on socket 1366 enum EAFNOSUPPORT = 47; /// Address family not supported by protocol family 1367 enum EADDRINUSE = 48; /// Address already in use 1368 enum EADDRNOTAVAIL = 49; /// Can't assign requested address 1369 enum ENETDOWN = 50; /// Network is down 1370 enum ENETUNREACH = 51; /// Network is unreachable 1371 enum ENETRESET = 52; /// Network dropped connection on reset 1372 enum ECONNABORTED = 53; /// Software caused connection abort 1373 enum ECONNRESET = 54; /// Connection reset by peer 1374 enum ENOBUFS = 55; /// No buffer space available 1375 enum EISCONN = 56; /// Socket is already connected 1376 enum ENOTCONN = 57; /// Socket is not connected 1377 enum ESHUTDOWN = 58; /// Can't send after socket shutdown 1378 enum ETOOMANYREFS = 59; /// Too many refrences; can't splice 1379 enum ETIMEDOUT = 60; /// Operation timed out 1380 enum ECONNREFUSED = 61; /// Connection refused 1381 enum ELOOP = 62; /// Too many levels of symbolic links 1382 enum ENAMETOOLONG = 63; /// File name too long 1383 enum EHOSTUNREACH = 65; /// No route to host 1384 enum ENOTEMPTY = 66; /// Directory not empty 1385 enum EPROCLIM = 67; /// Too many processes 1386 enum EUSERS = 68; /// Too many users 1387 enum EDQUOT = 69; /// Disc quota exceeded 1388 enum ESTALE = 70; /// Stale NFS file handle 1389 enum EREMOTE = 71; /// Too many levels of remote in path 1390 enum EBADRPC = 72; /// RPC struct is bad 1391 enum ERPCMISMATCH = 73; /// RPC version wrong 1392 enum EPROGUNAVAIL = 74; /// RPC prog. not avail 1393 enum EPROGMISMATCH = 75; /// Program version wrong 1394 enum EPROCUNAVAIL = 76; /// Bad procedure for program 1395 enum ENOLCK = 77; /// No locks available 1396 enum ENOSYS = 78; /// Function not implemented 1397 enum EFTYPE = 79; /// Inappropriate file type or format 1398 enum EAUTH = 80; /// Authentication error 1399 enum ENEEDAUTH = 81; /// Need authenticator 1400 enum EIDRM = 82; /// Itendifier removed 1401 enum ENOMSG = 83; /// No message of desired type 1402 enum EOVERFLOW = 84; /// Value too large to be stored in data type 1403 enum ECANCELED = 85; /// Operation canceled 1404 enum EILSEQ = 86; /// Illegal byte sequence 1405 enum ENOATTR = 87; /// Attribute not found 1406 enum EDOOFUS = 88; /// Programming error 1407 enum EBADMSG = 89; /// Bad message 1408 enum EMULTIHOP = 90; /// Multihop attempted 1409 enum ENOLINK = 91; /// Link has been severed 1410 enum EPROTO = 92; /// Protocol error 1411 enum ELAST = 92; /// Must be equal largest errno 1412 } 1413 else version (NetBSD) 1414 { 1415 // http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/sys/errno.h 1416 enum EPERM = 1; 1417 enum ENOENT = 2; 1418 enum ESRCH = 3; 1419 enum EINTR = 4; 1420 enum EIO = 5; 1421 enum ENXIO = 6; 1422 enum E2BIG = 7; 1423 enum ENOEXEC = 8; 1424 enum EBADF = 9; 1425 enum ECHILD = 10; 1426 enum EDEADLK = 11; 1427 /// 1428 enum ENOMEM = 12; 1429 enum EACCES = 13; 1430 enum EFAULT = 14; 1431 enum ENOTBLK = 15; 1432 enum EBUSY = 16; 1433 enum EEXIST = 17; 1434 enum EXDEV = 18; 1435 enum ENODEV = 19; 1436 enum ENOTDIR = 20; 1437 enum EISDIR = 21; 1438 enum EINVAL = 22; 1439 enum ENFILE = 23; 1440 enum EMFILE = 24; 1441 enum ENOTTY = 25; 1442 enum ETXTBSY = 26; 1443 enum EFBIG = 27; 1444 enum ENOSPC = 28; 1445 enum ESPIPE = 29; 1446 enum EROFS = 30; 1447 enum EMLINK = 31; 1448 enum EPIPE = 32; 1449 /// 1450 enum EDOM = 33; 1451 enum ERANGE = 34; 1452 1453 /// 1454 enum EAGAIN = 35; 1455 enum EWOULDBLOCK = EAGAIN; 1456 enum EINPROGRESS = 36; 1457 enum EALREADY = 37; 1458 1459 /// 1460 enum ENOTSOCK = 38; 1461 enum EDESTADDRREQ = 39; 1462 enum EMSGSIZE = 40; 1463 enum EPROTOTYPE = 41; 1464 enum ENOPROTOOPT = 42; 1465 enum EPROTONOSUPPORT = 43; 1466 enum ESOCKTNOSUPPORT = 44; 1467 enum EOPNOTSUPP = 45; 1468 enum EPFNOSUPPORT = 46; 1469 enum EAFNOSUPPORT = 47; 1470 enum EADDRINUSE = 48; 1471 enum EADDRNOTAVAIL = 49; 1472 1473 /// 1474 enum ENETDOWN = 50; 1475 enum ENETUNREACH = 51; 1476 enum ENETRESET = 52; 1477 enum ECONNABORTED = 53; 1478 enum ECONNRESET = 54; 1479 enum ENOBUFS = 55; 1480 enum EISCONN = 56; 1481 enum ENOTCONN = 57; 1482 enum ESHUTDOWN = 58; 1483 enum ETOOMANYREFS = 59; 1484 enum ETIMEDOUT = 60; 1485 enum ECONNREFUSED = 61; 1486 enum ELOOP = 62; 1487 enum ENAMETOOLONG = 63; 1488 1489 /// 1490 enum EHOSTDOWN = 64; 1491 enum EHOSTUNREACH = 65; 1492 enum ENOTEMPTY = 66; 1493 1494 /// 1495 enum EPROCLIM = 67; 1496 enum EUSERS = 68; 1497 enum EDQUOT = 69; 1498 1499 /// 1500 enum ESTALE = 70; 1501 enum EREMOTE = 71; 1502 enum EBADRPC = 72; 1503 enum ERPCMISMATCH = 73; 1504 enum EPROGUNAVAIL = 74; 1505 enum EPROGMISMATCH = 75; 1506 enum EPROCUNAVAIL = 76; 1507 1508 enum ENOLCK = 77; 1509 enum ENOSYS = 78; 1510 1511 enum EFTYPE = 79; 1512 enum EAUTH = 80; 1513 enum ENEEDAUTH = 81; 1514 1515 /// 1516 enum EIDRM = 82; 1517 enum ENOMSG = 83; 1518 enum EOVERFLOW = 84; 1519 /// 1520 enum EILSEQ = 85; 1521 1522 /// 1523 enum ENOTSUP = 86; 1524 1525 /// 1526 enum ECANCELED = 87; 1527 1528 /// 1529 enum EBADMSG = 88; 1530 1531 /// 1532 enum ENODATA = 89; 1533 enum ENOSR = 90; 1534 enum ENOSTR = 91; 1535 enum ETIME = 92; 1536 1537 /// 1538 enum ENOATTR = 93; 1539 1540 /// 1541 enum EMULTIHOP = 94; 1542 enum ENOLINK = 95; 1543 enum EPROTO = 96; 1544 } 1545 else version (OpenBSD) 1546 { 1547 enum EPERM = 1; /// Operation not permitted 1548 enum ENOENT = 2; /// No such file or directory 1549 enum ESRCH = 3; /// No such process 1550 enum EINTR = 4; /// Interrupted system call 1551 enum EIO = 5; /// Input/output error 1552 enum ENXIO = 6; /// Device not configured 1553 enum E2BIG = 7; /// Argument list too long 1554 enum ENOEXEC = 8; /// Exec format error 1555 enum EBADF = 9; /// Bad file descriptor 1556 enum ECHILD = 10; /// No child processes 1557 enum EDEADLK = 11; /// Resource deadlock avoided 1558 enum ENOMEM = 12; /// Cannot allocate memory 1559 enum EACCES = 13; /// Permission denied 1560 enum EFAULT = 14; /// Bad address 1561 enum ENOTBLK = 15; /// Block device required 1562 enum EBUSY = 16; /// Device busy 1563 enum EEXIST = 17; /// File exists 1564 enum EXDEV = 18; /// Cross-device link 1565 enum ENODEV = 19; /// Operation not supported by device 1566 enum ENOTDIR = 20; /// Not a directory 1567 enum EISDIR = 21; /// Is a directory 1568 enum EINVAL = 22; /// Invalid argument 1569 enum ENFILE = 23; /// Too many open files in system 1570 enum EMFILE = 24; /// Too many open files 1571 enum ENOTTY = 25; /// Inappropriate ioctl for device 1572 enum ETXTBSY = 26; /// Text file busy 1573 enum EFBIG = 27; /// File too large 1574 enum ENOSPC = 28; /// No space left on device 1575 enum ESPIPE = 29; /// Illegal seek 1576 enum EROFS = 30; /// Read-only file system 1577 enum EMLINK = 31; /// Too many links 1578 enum EPIPE = 32; /// Broken pipe 1579 enum EDOM = 33; /// Numerical argument out of domain 1580 enum ERANGE = 34; /// Result too large 1581 enum EAGAIN = 35; /// Resource temporarily unavailable 1582 enum EWOULDBLOCK = EAGAIN; /// Operation would block 1583 enum EINPROGRESS = 36; /// Operation now in progress 1584 enum EALREADY = 37; /// Operation already in progress 1585 enum ENOTSOCK = 38; /// Socket operation on non-socket 1586 enum EDESTADDRREQ = 39; /// Destination address required 1587 enum EMSGSIZE = 40; /// Message too long 1588 enum EPROTOTYPE = 41; /// Protocol wrong type for socket 1589 enum ENOPROTOOPT = 42; /// Protocol not available 1590 enum EPROTONOSUPPORT = 43; /// Protocol not supported 1591 enum ESOCKTNOSUPPORT = 44; /// Socket type not supported 1592 enum EOPNOTSUPP = 45; /// Operation not supported 1593 enum EPFNOSUPPORT = 46; /// Protocol family not supported 1594 enum EAFNOSUPPORT = 47; /// Address family not supported by protocol family 1595 enum EADDRINUSE = 48; /// Address already in use 1596 enum EADDRNOTAVAIL = 49; /// Can't assign requested address 1597 enum ENETDOWN = 50; /// Network is down 1598 enum ENETUNREACH = 51; /// Network is unreachable 1599 enum ENETRESET = 52; /// Network dropped connection on reset 1600 enum ECONNABORTED = 53; /// Software caused connection abort 1601 enum ECONNRESET = 54; /// Connection reset by peer 1602 enum ENOBUFS = 55; /// No buffer space available 1603 enum EISCONN = 56; /// Socket is already connected 1604 enum ENOTCONN = 57; /// Socket is not connected 1605 enum ESHUTDOWN = 58; /// Can't send after socket shutdown 1606 enum ETOOMANYREFS = 59; /// Too many references: can't splice 1607 enum ETIMEDOUT = 60; /// Operation timed out 1608 enum ECONNREFUSED = 61; /// Connection refused 1609 enum ELOOP = 62; /// Too many levels of symbolic links 1610 enum ENAMETOOLONG = 63; /// File name too long 1611 enum EHOSTDOWN = 64; /// Host is down 1612 enum EHOSTUNREACH = 65; /// No route to host 1613 enum ENOTEMPTY = 66; /// Directory not empty 1614 enum EPROCLIM = 67; /// Too many processes 1615 enum EUSERS = 68; /// Too many users 1616 enum EDQUOT = 69; /// Disk quota exceeded 1617 enum ESTALE = 70; /// Stale NFS file handle 1618 enum EREMOTE = 71; /// Too many levels of remote in path 1619 enum EBADRPC = 72; /// RPC struct is bad 1620 enum ERPCMISMATCH = 73; /// RPC version wrong 1621 enum EPROGUNAVAIL = 74; /// RPC program not available 1622 enum EPROGMISMATCH = 75; /// Program version wrong 1623 enum EPROCUNAVAIL = 76; /// Bad procedure for program 1624 enum ENOLCK = 77; /// No locks available 1625 enum ENOSYS = 78; /// Function not implemented 1626 enum EFTYPE = 79; /// Inappropriate file type or format 1627 enum EAUTH = 80; /// Authentication error 1628 enum ENEEDAUTH = 81; /// Need authenticator 1629 enum EIPSEC = 82; /// IPsec processing failure 1630 enum ENOATTR = 83; /// Attribute not found 1631 enum EILSEQ = 84; /// Illegal byte sequence 1632 enum ENOMEDIUM = 85; /// No medium found 1633 enum EMEDIUMTYPE = 86; /// Wrong medium type 1634 enum EOVERFLOW = 87; /// Value too large to be stored in data type 1635 enum ECANCELED = 88; /// Operation canceled 1636 enum EIDRM = 89; /// Identifier removed 1637 enum ENOMSG = 90; /// No message of desired type 1638 enum ENOTSUP = 91; /// Not supported 1639 enum EBADMSG = 92; /// Bad message 1640 enum ENOTRECOVERABLE = 93; /// State not recoverable 1641 enum EOWNERDEAD = 94; /// Previous owner died 1642 enum EPROTO = 95; /// Protocol error 1643 enum ELAST = 95; /// Must be equal largest errno 1644 } 1645 else version (DragonFlyBSD) 1646 { 1647 enum EPERM = 1; 1648 enum ENOENT = 2; 1649 enum ESRCH = 3; 1650 enum EINTR = 4; 1651 enum EIO = 5; 1652 enum ENXIO = 6; 1653 enum E2BIG = 7; 1654 enum ENOEXEC = 8; 1655 enum EBADF = 9; 1656 enum ECHILD = 10; 1657 enum EDEADLK = 11; 1658 enum ENOMEM = 12; 1659 enum EACCES = 13; 1660 enum EFAULT = 14; 1661 enum ENOTBLK = 15; 1662 enum EBUSY = 16; 1663 enum EEXIST = 17; 1664 enum EXDEV = 18; 1665 enum ENODEV = 19; 1666 enum ENOTDIR = 20; 1667 enum EISDIR = 21; 1668 enum EINVAL = 22; 1669 enum ENFILE = 23; 1670 enum EMFILE = 24; 1671 enum ENOTTY = 25; 1672 enum ETXTBSY = 26; 1673 enum EFBIG = 27; 1674 enum ENOSPC = 28; 1675 enum ESPIPE = 29; 1676 enum EROFS = 30; 1677 enum EMLINK = 31; 1678 enum EPIPE = 32; 1679 enum EDOM = 33; 1680 enum ERANGE = 34; 1681 enum EAGAIN = 35; 1682 enum EWOULDBLOCK = EAGAIN; 1683 enum EINPROGRESS = 36; 1684 enum EALREADY = 37; 1685 enum ENOTSOCK = 38; 1686 enum EDESTADDRREQ = 39; 1687 enum EMSGSIZE = 40; 1688 enum EPROTOTYPE = 41; 1689 enum ENOPROTOOPT = 42; 1690 enum EPROTONOSUPPORT = 43; 1691 enum ENOTSUP = 45; 1692 enum EOPNOTSUPP = ENOTSUP; 1693 enum EPFNOSUPPORT = 46; 1694 enum EAFNOSUPPORT = 47; 1695 enum EADDRINUSE = 48; 1696 enum EADDRNOTAVAIL = 49; 1697 enum ENETDOWN = 50; 1698 enum ENETUNREACH = 51; 1699 enum ENETRESET = 52; 1700 enum ECONNABORTED = 53; 1701 enum ECONNRESET = 54; 1702 enum ENOBUFS = 55; 1703 enum EISCONN = 56; 1704 enum ENOTCONN = 57; 1705 enum ESHUTDOWN = 58; 1706 enum ETOOMANYREFS = 59; 1707 enum ETIMEDOUT = 60; 1708 enum ECONNREFUSED = 61; 1709 enum ELOOP = 62; 1710 enum ENAMETOOLONG = 63; 1711 enum EHOSTUNREACH = 65; 1712 enum ENOTEMPTY = 66; 1713 enum EPROCLIM = 67; 1714 enum EUSERS = 68; 1715 enum EDQUOT = 69; 1716 enum ESTALE = 70; 1717 enum EREMOTE = 71; 1718 enum EBADRPC = 72; 1719 enum ERPCMISMATCH = 73; 1720 enum EPROGUNAVAIL = 74; 1721 enum EPROGMISMATCH = 75; 1722 enum EPROCUNAVAIL = 76; 1723 enum ENOLCK = 77; 1724 enum ENOSYS = 78; 1725 enum EFTYPE = 79; 1726 enum EAUTH = 80; 1727 enum ENEEDAUTH = 81; 1728 enum EIDRM = 82; 1729 enum ENOMSG = 83; 1730 enum EOVERFLOW = 84; 1731 enum ECANCELED = 85; 1732 enum EILSEQ = 86; 1733 enum ENOATTR = 87; 1734 enum EDOOFUS = 88; 1735 enum EBADMSG = 89; 1736 enum EMULTIHOP = 90; 1737 enum ENOLINK = 91; 1738 enum EPROTO = 92; 1739 enum ENOMEDIUM = 93; 1740 enum EUNUSED94 = 94; 1741 enum EUNUSED95 = 95; 1742 enum EUNUSED96 = 96; 1743 enum EUNUSED97 = 97; 1744 enum EUNUSED98 = 98; 1745 enum EASYNC = 99; 1746 enum ELAST = 99; 1747 } 1748 else version (Solaris) 1749 { 1750 enum EPERM = 1; /// Not super-user 1751 enum ENOENT = 2; /// No such file or directory 1752 enum ESRCH = 3; /// No such process 1753 enum EINTR = 4; /// interrupted system call 1754 enum EIO = 5; /// I/O error 1755 enum ENXIO = 6; /// No such device or address 1756 enum E2BIG = 7; /// Arg list too long 1757 enum ENOEXEC = 8; /// Exec format error 1758 enum EBADF = 9; /// Bad file number 1759 enum ECHILD = 10; /// No children 1760 enum EAGAIN = 11; /// Resource temporarily unavailable 1761 enum ENOMEM = 12; /// Not enough core 1762 enum EACCES = 13; /// Permission denied 1763 enum EFAULT = 14; /// Bad address 1764 enum ENOTBLK = 15; /// Block device required 1765 enum EBUSY = 16; /// Mount device busy 1766 enum EEXIST = 17; /// File exists 1767 enum EXDEV = 18; /// Cross-device link 1768 enum ENODEV = 19; /// No such device 1769 enum ENOTDIR = 20; /// Not a directory 1770 enum EISDIR = 21; /// Is a directory 1771 enum EINVAL = 22; /// Invalid argument 1772 enum ENFILE = 23; /// File table overflow 1773 enum EMFILE = 24; /// Too many open files 1774 enum ENOTTY = 25; /// Inappropriate ioctl for device 1775 enum ETXTBSY = 26; /// Text file busy 1776 enum EFBIG = 27; /// File too large 1777 enum ENOSPC = 28; /// No space left on device 1778 enum ESPIPE = 29; /// Illegal seek 1779 enum EROFS = 30; /// Read only file system 1780 enum EMLINK = 31; /// Too many links 1781 enum EPIPE = 32; /// Broken pipe 1782 enum EDOM = 33; /// Math arg out of domain of func 1783 enum ERANGE = 34; /// Math result not representable 1784 enum ENOMSG = 35; /// No message of desired type 1785 enum EIDRM = 36; /// Identifier removed 1786 enum ECHRNG = 37; /// Channel number out of range 1787 enum EL2NSYNC = 38; /// Level 2 not synchronized 1788 enum EL3HLT = 39; /// Level 3 halted 1789 enum EL3RST = 40; /// Level 3 reset 1790 enum ELNRNG = 41; /// Link number out of range 1791 enum EUNATCH = 42; /// Protocol driver not attached 1792 enum ENOCSI = 43; /// No CSI structure available 1793 enum EL2HLT = 44; /// Level 2 halted 1794 enum EDEADLK = 45; /// Deadlock condition. 1795 enum ENOLCK = 46; /// No record locks available. 1796 enum ECANCELED = 47; /// Operation canceled 1797 enum ENOTSUP = 48; /// Operation not supported 1798 enum EDQUOT = 49; /// Disc quota exceeded 1799 enum EBADE = 50; /// invalid exchange 1800 enum EBADR = 51; /// invalid request descriptor 1801 enum EXFULL = 52; /// exchange full 1802 enum ENOANO = 53; /// no anode 1803 enum EBADRQC = 54; /// invalid request code 1804 enum EBADSLT = 55; /// invalid slot 1805 enum EDEADLOCK = 56; /// file locking deadlock error 1806 enum EBFONT = 57; /// bad font file fmt 1807 enum EOWNERDEAD = 58; /// process died with the lock 1808 enum ENOTRECOVERABLE = 59; /// lock is not recoverable 1809 enum ENOSTR = 60; /// Device not a stream 1810 enum ENODATA = 61; /// no data (for no delay io) 1811 enum ETIME = 62; /// timer expired 1812 enum ENOSR = 63; /// out of streams resources 1813 enum ENONET = 64; /// Machine is not on the network 1814 enum ENOPKG = 65; /// Package not installed 1815 enum EREMOTE = 66; /// The object is remote 1816 enum ENOLINK = 67; /// the link has been severed 1817 enum EADV = 68; /// advertise error 1818 enum ESRMNT = 69; /// srmount error 1819 enum ECOMM = 70; /// Communication error on send 1820 enum EPROTO = 71; /// Protocol error 1821 enum ELOCKUNMAPPED = 72; /// locked lock was unmapped 1822 enum ENOTACTIVE = 73; /// Facility is not active 1823 enum EMULTIHOP = 74; /// multihop attempted 1824 enum EBADMSG = 77; /// trying to read unreadable message 1825 enum ENAMETOOLONG = 78; /// path name is too long 1826 enum EOVERFLOW = 79; /// value too large to be stored in data type 1827 enum ENOTUNIQ = 80; /// given log. name not unique 1828 enum EBADFD = 81; /// f.d. invalid for this operation 1829 enum EREMCHG = 82; /// Remote address changed 1830 enum ELIBACC = 83; /// Can't access a needed shared lib. 1831 enum ELIBBAD = 84; /// Accessing a corrupted shared lib. 1832 enum ELIBSCN = 85; /// .lib section in a.out corrupted. 1833 enum ELIBMAX = 86; /// Attempting to link in too many libs. 1834 enum ELIBEXEC = 87; /// Attempting to exec a shared library. 1835 enum EILSEQ = 88; /// Illegal byte sequence. 1836 enum ENOSYS = 89; /// Unsupported file system operation 1837 enum ELOOP = 90; /// Symbolic link loop 1838 enum ERESTART = 91; /// Restartable system call 1839 enum ESTRPIPE = 92; /// if pipe/FIFO, don't sleep in stream head 1840 enum ENOTEMPTY = 93; /// directory not empty 1841 enum EUSERS = 94; /// Too many users (for UFS) 1842 enum ENOTSOCK = 95; /// Socket operation on non-socket 1843 enum EDESTADDRREQ = 96; /// Destination address required 1844 enum EMSGSIZE = 97; /// Message too long 1845 enum EPROTOTYPE = 98; /// Protocol wrong type for socket 1846 enum ENOPROTOOPT = 99; /// Protocol not available 1847 enum EPROTONOSUPPORT = 120; /// Protocol not supported 1848 enum ESOCKTNOSUPPORT = 121; /// Socket type not supported 1849 enum EOPNOTSUPP = 122; /// Operation not supported on socket 1850 enum EPFNOSUPPORT = 123; /// Protocol family not supported 1851 enum EAFNOSUPPORT = 124; /// Address family not supported by the protocol family 1852 enum EADDRINUSE = 125; /// Address already in use 1853 enum EADDRNOTAVAIL = 126; /// Can't assign requested address 1854 enum ENETDOWN = 127; /// Network is down 1855 enum ENETUNREACH = 128; /// Network is unreachable 1856 enum ENETRESET = 129; /// Network dropped connection because of reset 1857 enum ECONNABORTED = 130; /// Software caused connection abort 1858 enum ECONNRESET = 131; /// Connection reset by peer 1859 enum ENOBUFS = 132; /// No buffer space available 1860 enum EISCONN = 133; /// Socket is already connected 1861 enum ENOTCONN = 134; /// Socket is not connected 1862 enum ESHUTDOWN = 143; /// Can't send after socket shutdown 1863 enum ETOOMANYREFS = 144; /// Too many references: can't splice 1864 enum ETIMEDOUT = 145; /// Connection timed out 1865 enum ECONNREFUSED = 146; /// Connection refused 1866 enum EHOSTDOWN = 147; /// Host is down 1867 enum EHOSTUNREACH = 148; /// No route to host 1868 enum EWOULDBLOCK = EAGAIN; /// Resource temporarily unavailable 1869 enum EALREADY = 149; /// operation already in progress 1870 enum EINPROGRESS = 150; /// operation now in progress 1871 enum ESTALE = 151; /// Stale NFS file handle 1872 } 1873 else version (Haiku) 1874 { 1875 // https://github.com/haiku/haiku/blob/master/headers/os/support/Errors.h 1876 // https://github.com/haiku/haiku/blob/master/headers/build/os/support/Errors.h 1877 import core.stdc.limits : INT_MIN; 1878 enum B_GENERAL_ERROR_BASE = INT_MIN; 1879 enum B_OS_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x1000); 1880 enum B_APP_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x2000); 1881 enum B_INTERFACE_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x3000); 1882 enum B_MEDIA_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x4000); 1883 /* - 0x41ff */ 1884 enum B_TRANSLATION_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x4800); 1885 /* - 0x48ff */ 1886 enum B_MIDI_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x5000); 1887 enum B_STORAGE_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x6000); 1888 enum B_POSIX_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x7000); 1889 enum B_MAIL_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x8000); 1890 enum B_PRINT_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0x9000); 1891 enum B_DEVICE_ERROR_BASE = (B_GENERAL_ERROR_BASE + 0xa000); 1892 1893 /* General Errors */ 1894 enum B_NO_MEMORY = (B_GENERAL_ERROR_BASE + 0); 1895 enum B_IO_ERROR = (B_GENERAL_ERROR_BASE + 1); 1896 enum B_PERMISSION_DENIED = (B_GENERAL_ERROR_BASE + 2); 1897 enum B_BAD_INDEX = (B_GENERAL_ERROR_BASE + 3); 1898 enum B_BAD_TYPE = (B_GENERAL_ERROR_BASE + 4); 1899 enum B_BAD_VALUE = (B_GENERAL_ERROR_BASE + 5); 1900 enum B_MISMATCHED_VALUES = (B_GENERAL_ERROR_BASE + 6); 1901 enum B_NAME_NOT_FOUND = (B_GENERAL_ERROR_BASE + 7); 1902 enum B_NAME_IN_USE = (B_GENERAL_ERROR_BASE + 8); 1903 enum B_TIMED_OUT = (B_GENERAL_ERROR_BASE + 9); 1904 enum B_INTERRUPTED = (B_GENERAL_ERROR_BASE + 10); 1905 enum B_WOULD_BLOCK = (B_GENERAL_ERROR_BASE + 11); 1906 enum B_CANCELED = (B_GENERAL_ERROR_BASE + 12); 1907 enum B_NO_INIT = (B_GENERAL_ERROR_BASE + 13); 1908 enum B_NOT_INITIALIZED = (B_GENERAL_ERROR_BASE + 13); 1909 enum B_BUSY = (B_GENERAL_ERROR_BASE + 14); 1910 enum B_NOT_ALLOWED = (B_GENERAL_ERROR_BASE + 15); 1911 enum B_BAD_DATA = (B_GENERAL_ERROR_BASE + 16); 1912 enum B_DONT_DO_THAT = (B_GENERAL_ERROR_BASE + 17); 1913 1914 enum B_ERROR = (-1); 1915 enum B_OK = (int(0)); 1916 enum B_NO_ERROR = (int(0)); 1917 1918 /* Kernel Kit Errors */ 1919 enum B_BAD_SEM_ID = (B_OS_ERROR_BASE + 0); 1920 enum B_NO_MORE_SEMS = (B_OS_ERROR_BASE + 1); 1921 1922 enum B_BAD_THREAD_ID = (B_OS_ERROR_BASE + 0x100); 1923 enum B_NO_MORE_THREADS = (B_OS_ERROR_BASE + 0x101); 1924 enum B_BAD_THREAD_STATE = (B_OS_ERROR_BASE + 0x102); 1925 enum B_BAD_TEAM_ID = (B_OS_ERROR_BASE + 0x103); 1926 enum B_NO_MORE_TEAMS = (B_OS_ERROR_BASE + 0x104); 1927 1928 enum B_BAD_PORT_ID = (B_OS_ERROR_BASE + 0x200); 1929 enum B_NO_MORE_PORTS = (B_OS_ERROR_BASE + 0x201); 1930 1931 enum B_BAD_IMAGE_ID = (B_OS_ERROR_BASE + 0x300); 1932 enum B_BAD_ADDRESS = (B_OS_ERROR_BASE + 0x301); 1933 enum B_NOT_AN_EXECUTABLE = (B_OS_ERROR_BASE + 0x302); 1934 enum B_MISSING_LIBRARY = (B_OS_ERROR_BASE + 0x303); 1935 enum B_MISSING_SYMBOL = (B_OS_ERROR_BASE + 0x304); 1936 enum B_UNKNOWN_EXECUTABLE = (B_OS_ERROR_BASE + 0x305); 1937 enum B_LEGACY_EXECUTABLE = (B_OS_ERROR_BASE + 0x306); 1938 1939 enum B_DEBUGGER_ALREADY_INSTALLED = (B_OS_ERROR_BASE + 0x400); 1940 1941 /* Application Kit Errors */ 1942 enum B_BAD_REPLY = (B_APP_ERROR_BASE + 0); 1943 enum B_DUPLICATE_REPLY = (B_APP_ERROR_BASE + 1); 1944 enum B_MESSAGE_TO_SELF = (B_APP_ERROR_BASE + 2); 1945 enum B_BAD_HANDLER = (B_APP_ERROR_BASE + 3); 1946 enum B_ALREADY_RUNNING = (B_APP_ERROR_BASE + 4); 1947 enum B_LAUNCH_FAILED = (B_APP_ERROR_BASE + 5); 1948 enum B_AMBIGUOUS_APP_LAUNCH = (B_APP_ERROR_BASE + 6); 1949 enum B_UNKNOWN_MIME_TYPE = (B_APP_ERROR_BASE + 7); 1950 enum B_BAD_SCRIPT_SYNTAX = (B_APP_ERROR_BASE + 8); 1951 enum B_LAUNCH_FAILED_NO_RESOLVE_LINK = (B_APP_ERROR_BASE + 9); 1952 enum B_LAUNCH_FAILED_EXECUTABLE = (B_APP_ERROR_BASE + 10); 1953 enum B_LAUNCH_FAILED_APP_NOT_FOUND = (B_APP_ERROR_BASE + 11); 1954 enum B_LAUNCH_FAILED_APP_IN_TRASH = (B_APP_ERROR_BASE + 12); 1955 enum B_LAUNCH_FAILED_NO_PREFERRED_APP = (B_APP_ERROR_BASE + 13); 1956 enum B_LAUNCH_FAILED_FILES_APP_NOT_FOUND = (B_APP_ERROR_BASE + 14); 1957 enum B_BAD_MIME_SNIFFER_RULE = (B_APP_ERROR_BASE + 15); 1958 enum B_NOT_A_MESSAGE = (B_APP_ERROR_BASE + 16); 1959 enum B_SHUTDOWN_CANCELLED = (B_APP_ERROR_BASE + 17); 1960 enum B_SHUTTING_DOWN = (B_APP_ERROR_BASE + 18); 1961 1962 /* Storage Kit/File System Errors */ 1963 enum B_FILE_ERROR = (B_STORAGE_ERROR_BASE + 0); 1964 enum B_FILE_NOT_FOUND = (B_STORAGE_ERROR_BASE + 1); 1965 /* deprecated: use B_ENTRY_NOT_FOUND instead */ 1966 enum B_FILE_EXISTS = (B_STORAGE_ERROR_BASE + 2); 1967 enum B_ENTRY_NOT_FOUND = (B_STORAGE_ERROR_BASE + 3); 1968 enum B_NAME_TOO_LONG = (B_STORAGE_ERROR_BASE + 4); 1969 enum B_NOT_A_DIRECTORY = (B_STORAGE_ERROR_BASE + 5); 1970 enum B_DIRECTORY_NOT_EMPTY = (B_STORAGE_ERROR_BASE + 6); 1971 enum B_DEVICE_FULL = (B_STORAGE_ERROR_BASE + 7); 1972 enum B_READ_ONLY_DEVICE = (B_STORAGE_ERROR_BASE + 8); 1973 enum B_IS_A_DIRECTORY = (B_STORAGE_ERROR_BASE + 9); 1974 enum B_NO_MORE_FDS = (B_STORAGE_ERROR_BASE + 10); 1975 enum B_CROSS_DEVICE_LINK = (B_STORAGE_ERROR_BASE + 11); 1976 enum B_LINK_LIMIT = (B_STORAGE_ERROR_BASE + 12); 1977 enum B_BUSTED_PIPE = (B_STORAGE_ERROR_BASE + 13); 1978 enum B_UNSUPPORTED = (B_STORAGE_ERROR_BASE + 14); 1979 enum B_PARTITION_TOO_SMALL = (B_STORAGE_ERROR_BASE + 15); 1980 enum B_PARTIAL_READ = (B_STORAGE_ERROR_BASE + 16); 1981 enum B_PARTIAL_WRITE = (B_STORAGE_ERROR_BASE + 17); 1982 1983 /* POSIX Errors */ 1984 enum B_USE_POSITIVE_POSIX_ERRORS = false; 1985 1986 static if (B_USE_POSITIVE_POSIX_ERRORS) 1987 { 1988 enum B_TO_POSIX_ERROR(int code) = -code; 1989 } 1990 else 1991 { 1992 enum B_TO_POSIX_ERROR(int code) = code; 1993 } 1994 alias B_FROM_POSIX_ERROR = B_TO_POSIX_ERROR; 1995 1996 enum B_POSIX_ENOMEM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 0); 1997 enum E2BIG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 1); 1998 enum ECHILD = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 2); 1999 enum EDEADLK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 3); 2000 enum EFBIG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 4); 2001 enum EMLINK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 5); 2002 enum ENFILE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 6); 2003 enum ENODEV = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 7); 2004 enum ENOLCK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 8); 2005 enum ENOSYS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 9); 2006 enum ENOTTY = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 10); 2007 enum ENXIO = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 11); 2008 enum ESPIPE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 12); 2009 enum ESRCH = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 13); 2010 enum EFPOS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 14); 2011 enum ESIGPARM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 15); 2012 enum EDOM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 16); 2013 enum ERANGE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 17); 2014 enum EPROTOTYPE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 18); 2015 enum EPROTONOSUPPORT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 19); 2016 enum EPFNOSUPPORT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 20); 2017 enum EAFNOSUPPORT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 21); 2018 enum EADDRINUSE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 22); 2019 enum EADDRNOTAVAIL = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 23); 2020 enum ENETDOWN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 24); 2021 enum ENETUNREACH = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 25); 2022 enum ENETRESET = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 26); 2023 enum ECONNABORTED = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 27); 2024 enum ECONNRESET = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 28); 2025 enum EISCONN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 29); 2026 enum ENOTCONN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 30); 2027 enum ESHUTDOWN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 31); 2028 enum ECONNREFUSED = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 32); 2029 enum EHOSTUNREACH = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 33); 2030 enum ENOPROTOOPT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 34); 2031 enum ENOBUFS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 35); 2032 enum EINPROGRESS = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 36); 2033 enum EALREADY = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 37); 2034 enum EILSEQ = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 38); 2035 enum ENOMSG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 39); 2036 enum ESTALE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 40); 2037 enum EOVERFLOW = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 41); 2038 enum EMSGSIZE = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 42); 2039 enum EOPNOTSUPP = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 43); 2040 enum ENOTSOCK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 44); 2041 enum EHOSTDOWN = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 45); 2042 enum EBADMSG = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 46); 2043 enum ECANCELED = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 47); 2044 enum EDESTADDRREQ = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 48); 2045 enum EDQUOT = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 49); 2046 enum EIDRM = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 50); 2047 enum EMULTIHOP = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 51); 2048 enum ENODATA = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 52); 2049 enum ENOLINK = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 53); 2050 enum ENOSR = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 54); 2051 enum ENOSTR = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 55); 2052 enum ENOTSUP = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 56); 2053 enum EPROTO = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 57); 2054 enum ETIME = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 58); 2055 enum ETXTBSY = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 59); 2056 enum ENOATTR = B_TO_POSIX_ERROR!(B_POSIX_ERROR_BASE + 60); 2057 2058 /* B_NO_MEMORY (0x80000000) can't be negated, so it needs special handling */ 2059 static if (B_USE_POSITIVE_POSIX_ERRORS) 2060 enum ENOMEM = B_POSIX_ENOMEM; 2061 else 2062 enum ENOMEM = B_NO_MEMORY; 2063 2064 /* POSIX errors that can be mapped to BeOS error codes */ 2065 enum EACCES = B_TO_POSIX_ERROR!(B_PERMISSION_DENIED); 2066 enum EINTR = B_TO_POSIX_ERROR!(B_INTERRUPTED); 2067 enum EIO = B_TO_POSIX_ERROR!(B_IO_ERROR); 2068 enum EBUSY = B_TO_POSIX_ERROR!(B_BUSY); 2069 enum EFAULT = B_TO_POSIX_ERROR!(B_BAD_ADDRESS); 2070 enum ETIMEDOUT = B_TO_POSIX_ERROR!(B_TIMED_OUT); 2071 enum EAGAIN = B_TO_POSIX_ERROR!(B_WOULD_BLOCK) /* SysV compatibility */; 2072 enum EWOULDBLOCK = B_TO_POSIX_ERROR!(B_WOULD_BLOCK) /* BSD compatibility */; 2073 enum EBADF = B_TO_POSIX_ERROR!(B_FILE_ERROR); 2074 enum EEXIST = B_TO_POSIX_ERROR!(B_FILE_EXISTS); 2075 enum EINVAL = B_TO_POSIX_ERROR!(B_BAD_VALUE); 2076 enum ENAMETOOLONG = B_TO_POSIX_ERROR!(B_NAME_TOO_LONG); 2077 enum ENOENT = B_TO_POSIX_ERROR!(B_ENTRY_NOT_FOUND); 2078 enum EPERM = B_TO_POSIX_ERROR!(B_NOT_ALLOWED); 2079 enum ENOTDIR = B_TO_POSIX_ERROR!(B_NOT_A_DIRECTORY); 2080 enum EISDIR = B_TO_POSIX_ERROR!(B_IS_A_DIRECTORY); 2081 enum ENOTEMPTY = B_TO_POSIX_ERROR!(B_DIRECTORY_NOT_EMPTY); 2082 enum ENOSPC = B_TO_POSIX_ERROR!(B_DEVICE_FULL); 2083 enum EROFS = B_TO_POSIX_ERROR!(B_READ_ONLY_DEVICE); 2084 enum EMFILE = B_TO_POSIX_ERROR!(B_NO_MORE_FDS); 2085 enum EXDEV = B_TO_POSIX_ERROR!(B_CROSS_DEVICE_LINK); 2086 enum ELOOP = B_TO_POSIX_ERROR!(B_LINK_LIMIT); 2087 enum ENOEXEC = B_TO_POSIX_ERROR!(B_NOT_AN_EXECUTABLE); 2088 enum EPIPE = B_TO_POSIX_ERROR!(B_BUSTED_PIPE); 2089 2090 /* new error codes that can be mapped to POSIX errors */ 2091 enum B_BUFFER_OVERFLOW = B_FROM_POSIX_ERROR!(EOVERFLOW); 2092 enum B_TOO_MANY_ARGS = B_FROM_POSIX_ERROR!(E2BIG); 2093 enum B_FILE_TOO_LARGE = B_FROM_POSIX_ERROR!(EFBIG); 2094 enum B_RESULT_NOT_REPRESENTABLE = B_FROM_POSIX_ERROR!(ERANGE); 2095 enum B_DEVICE_NOT_FOUND = B_FROM_POSIX_ERROR!(ENODEV); 2096 enum B_NOT_SUPPORTED = B_FROM_POSIX_ERROR!(EOPNOTSUPP); 2097 2098 /* Media Kit Errors */ 2099 enum B_STREAM_NOT_FOUND = (B_MEDIA_ERROR_BASE + 0); 2100 enum B_SERVER_NOT_FOUND = (B_MEDIA_ERROR_BASE + 1); 2101 enum B_RESOURCE_NOT_FOUND = (B_MEDIA_ERROR_BASE + 2); 2102 enum B_RESOURCE_UNAVAILABLE = (B_MEDIA_ERROR_BASE + 3); 2103 enum B_BAD_SUBSCRIBER = (B_MEDIA_ERROR_BASE + 4); 2104 enum B_SUBSCRIBER_NOT_ENTERED = (B_MEDIA_ERROR_BASE + 5); 2105 enum B_BUFFER_NOT_AVAILABLE = (B_MEDIA_ERROR_BASE + 6); 2106 enum B_LAST_BUFFER_ERROR = (B_MEDIA_ERROR_BASE + 7); 2107 2108 enum B_MEDIA_SYSTEM_FAILURE = (B_MEDIA_ERROR_BASE + 100); 2109 enum B_MEDIA_BAD_NODE = (B_MEDIA_ERROR_BASE + 101); 2110 enum B_MEDIA_NODE_BUSY = (B_MEDIA_ERROR_BASE + 102); 2111 enum B_MEDIA_BAD_FORMAT = (B_MEDIA_ERROR_BASE + 103); 2112 enum B_MEDIA_BAD_BUFFER = (B_MEDIA_ERROR_BASE + 104); 2113 enum B_MEDIA_TOO_MANY_NODES = (B_MEDIA_ERROR_BASE + 105); 2114 enum B_MEDIA_TOO_MANY_BUFFERS = (B_MEDIA_ERROR_BASE + 106); 2115 enum B_MEDIA_NODE_ALREADY_EXISTS = (B_MEDIA_ERROR_BASE + 107); 2116 enum B_MEDIA_BUFFER_ALREADY_EXISTS = (B_MEDIA_ERROR_BASE + 108); 2117 enum B_MEDIA_CANNOT_SEEK = (B_MEDIA_ERROR_BASE + 109); 2118 enum B_MEDIA_CANNOT_CHANGE_RUN_MODE = (B_MEDIA_ERROR_BASE + 110); 2119 enum B_MEDIA_APP_ALREADY_REGISTERED = (B_MEDIA_ERROR_BASE + 111); 2120 enum B_MEDIA_APP_NOT_REGISTERED = (B_MEDIA_ERROR_BASE + 112); 2121 enum B_MEDIA_CANNOT_RECLAIM_BUFFERS = (B_MEDIA_ERROR_BASE + 113); 2122 enum B_MEDIA_BUFFERS_NOT_RECLAIMED = (B_MEDIA_ERROR_BASE + 114); 2123 enum B_MEDIA_TIME_SOURCE_STOPPED = (B_MEDIA_ERROR_BASE + 115); 2124 enum B_MEDIA_TIME_SOURCE_BUSY = (B_MEDIA_ERROR_BASE + 116); 2125 enum B_MEDIA_BAD_SOURCE = (B_MEDIA_ERROR_BASE + 117); 2126 enum B_MEDIA_BAD_DESTINATION = (B_MEDIA_ERROR_BASE + 118); 2127 enum B_MEDIA_ALREADY_CONNECTED = (B_MEDIA_ERROR_BASE + 119); 2128 enum B_MEDIA_NOT_CONNECTED = (B_MEDIA_ERROR_BASE + 120); 2129 enum B_MEDIA_BAD_CLIP_FORMAT = (B_MEDIA_ERROR_BASE + 121); 2130 enum B_MEDIA_ADDON_FAILED = (B_MEDIA_ERROR_BASE + 122); 2131 enum B_MEDIA_ADDON_DISABLED = (B_MEDIA_ERROR_BASE + 123); 2132 enum B_MEDIA_CHANGE_IN_PROGRESS = (B_MEDIA_ERROR_BASE + 124); 2133 enum B_MEDIA_STALE_CHANGE_COUNT = (B_MEDIA_ERROR_BASE + 125); 2134 enum B_MEDIA_ADDON_RESTRICTED = (B_MEDIA_ERROR_BASE + 126); 2135 enum B_MEDIA_NO_HANDLER = (B_MEDIA_ERROR_BASE + 127); 2136 enum B_MEDIA_DUPLICATE_FORMAT = (B_MEDIA_ERROR_BASE + 128); 2137 enum B_MEDIA_REALTIME_DISABLED = (B_MEDIA_ERROR_BASE + 129); 2138 enum B_MEDIA_REALTIME_UNAVAILABLE = (B_MEDIA_ERROR_BASE + 130); 2139 2140 /* Mail Kit Errors */ 2141 enum B_MAIL_NO_DAEMON = (B_MAIL_ERROR_BASE + 0); 2142 enum B_MAIL_UNKNOWN_USER = (B_MAIL_ERROR_BASE + 1); 2143 enum B_MAIL_WRONG_PASSWORD = (B_MAIL_ERROR_BASE + 2); 2144 enum B_MAIL_UNKNOWN_HOST = (B_MAIL_ERROR_BASE + 3); 2145 enum B_MAIL_ACCESS_ERROR = (B_MAIL_ERROR_BASE + 4); 2146 enum B_MAIL_UNKNOWN_FIELD = (B_MAIL_ERROR_BASE + 5); 2147 enum B_MAIL_NO_RECIPIENT = (B_MAIL_ERROR_BASE + 6); 2148 enum B_MAIL_INVALID_MAIL = (B_MAIL_ERROR_BASE + 7); 2149 2150 /* Printing Errors */ 2151 enum B_NO_PRINT_SERVER = (B_PRINT_ERROR_BASE + 0); 2152 2153 /* Device Kit Errors */ 2154 enum B_DEV_INVALID_IOCTL = (B_DEVICE_ERROR_BASE + 0); 2155 enum B_DEV_NO_MEMORY = (B_DEVICE_ERROR_BASE + 1); 2156 enum B_DEV_BAD_DRIVE_NUM = (B_DEVICE_ERROR_BASE + 2); 2157 enum B_DEV_NO_MEDIA = (B_DEVICE_ERROR_BASE + 3); 2158 enum B_DEV_UNREADABLE = (B_DEVICE_ERROR_BASE + 4); 2159 enum B_DEV_FORMAT_ERROR = (B_DEVICE_ERROR_BASE + 5); 2160 enum B_DEV_TIMEOUT = (B_DEVICE_ERROR_BASE + 6); 2161 enum B_DEV_RECALIBRATE_ERROR = (B_DEVICE_ERROR_BASE + 7); 2162 enum B_DEV_SEEK_ERROR = (B_DEVICE_ERROR_BASE + 8); 2163 enum B_DEV_ID_ERROR = (B_DEVICE_ERROR_BASE + 9); 2164 enum B_DEV_READ_ERROR = (B_DEVICE_ERROR_BASE + 10); 2165 enum B_DEV_WRITE_ERROR = (B_DEVICE_ERROR_BASE + 11); 2166 enum B_DEV_NOT_READY = (B_DEVICE_ERROR_BASE + 12); 2167 enum B_DEV_MEDIA_CHANGED = (B_DEVICE_ERROR_BASE + 13); 2168 enum B_DEV_MEDIA_CHANGE_REQUESTED = (B_DEVICE_ERROR_BASE + 14); 2169 enum B_DEV_RESOURCE_CONFLICT = (B_DEVICE_ERROR_BASE + 15); 2170 enum B_DEV_CONFIGURATION_ERROR = (B_DEVICE_ERROR_BASE + 16); 2171 enum B_DEV_DISABLED_BY_USER = (B_DEVICE_ERROR_BASE + 17); 2172 enum B_DEV_DOOR_OPEN = (B_DEVICE_ERROR_BASE + 18); 2173 2174 enum B_DEV_INVALID_PIPE = (B_DEVICE_ERROR_BASE + 19); 2175 enum B_DEV_CRC_ERROR = (B_DEVICE_ERROR_BASE + 20); 2176 enum B_DEV_STALLED = (B_DEVICE_ERROR_BASE + 21); 2177 enum B_DEV_BAD_PID = (B_DEVICE_ERROR_BASE + 22); 2178 enum B_DEV_UNEXPECTED_PID = (B_DEVICE_ERROR_BASE + 23); 2179 enum B_DEV_DATA_OVERRUN = (B_DEVICE_ERROR_BASE + 24); 2180 enum B_DEV_DATA_UNDERRUN = (B_DEVICE_ERROR_BASE + 25); 2181 enum B_DEV_FIFO_OVERRUN = (B_DEVICE_ERROR_BASE + 26); 2182 enum B_DEV_FIFO_UNDERRUN = (B_DEVICE_ERROR_BASE + 27); 2183 enum B_DEV_PENDING = (B_DEVICE_ERROR_BASE + 28); 2184 enum B_DEV_MULTIPLE_ERRORS = (B_DEVICE_ERROR_BASE + 29); 2185 enum B_DEV_TOO_LATE = (B_DEVICE_ERROR_BASE + 30); 2186 2187 /* Translation Kit Errors */ 2188 enum B_TRANSLATION_BASE_ERROR = (B_TRANSLATION_ERROR_BASE + 0); 2189 enum B_NO_TRANSLATOR = (B_TRANSLATION_ERROR_BASE + 1); 2190 enum B_ILLEGAL_DATA = (B_TRANSLATION_ERROR_BASE + 2); 2191 } 2192 else version (WASI) 2193 { 2194 enum EPERM = 1; 2195 enum ENOENT = 2; 2196 enum ESRCH = 3; 2197 enum EINTR = 4; 2198 enum EIO = 5; 2199 enum ENXIO = 6; 2200 enum E2BIG = 7; 2201 enum ENOEXEC = 8; 2202 enum EBADF = 9; 2203 enum ECHILD = 10; 2204 enum EAGAIN = 11; 2205 enum ENOMEM = 12; 2206 enum EACCES = 13; 2207 enum EFAULT = 14; 2208 enum ENOTBLK = 15; 2209 enum EBUSY = 16; 2210 enum EEXIST = 17; 2211 enum EXDEV = 18; 2212 enum ENODEV = 19; 2213 enum ENOTDIR = 20; 2214 enum EISDIR = 21; 2215 enum EINVAL = 22; 2216 enum ENFILE = 23; 2217 enum EMFILE = 24; 2218 enum ENOTTY = 25; 2219 enum ETXTBSY = 26; 2220 enum EFBIG = 27; 2221 enum ENOSPC = 28; 2222 enum ESPIPE = 29; 2223 enum EROFS = 30; 2224 enum EMLINK = 31; 2225 enum EPIPE = 32; 2226 enum EDOM = 33; 2227 enum ERANGE = 34; 2228 enum EDEADLK = 35; 2229 enum ENAMETOOLONG = 36; 2230 enum ENOLCK = 37; 2231 enum ENOSYS = 38; 2232 enum ENOTEMPTY = 39; 2233 enum ELOOP = 40; 2234 enum EWOULDBLOCK = EAGAIN; 2235 enum ENOMSG = 42; 2236 enum EIDRM = 43; 2237 enum ECHRNG = 44; 2238 enum EL2NSYNC = 45; 2239 enum EL3HLT = 46; 2240 enum EL3RST = 47; 2241 enum ELNRNG = 48; 2242 enum EUNATCH = 49; 2243 enum ENOCSI = 50; 2244 enum EL2HLT = 51; 2245 enum EBADE = 52; 2246 enum EBADR = 53; 2247 enum EXFULL = 54; 2248 enum ENOANO = 55; 2249 enum EBADRQC = 56; 2250 enum EBADSLT = 57; 2251 enum EDEADLOCK = EDEADLK; 2252 enum EBFONT = 59; 2253 enum ENOSTR = 60; 2254 enum ENODATA = 61; 2255 enum ETIME = 62; 2256 enum ENOSR = 63; 2257 enum ENONET = 64; 2258 enum ENOPKG = 65; 2259 enum EREMOTE = 66; 2260 enum ENOLINK = 67; 2261 enum EADV = 68; 2262 enum ESRMNT = 69; 2263 enum ECOMM = 70; 2264 enum EPROTO = 71; 2265 enum EMULTIHOP = 72; 2266 enum EDOTDOT = 73; 2267 enum EBADMSG = 74; 2268 enum EOVERFLOW = 75; 2269 enum ENOTUNIQ = 76; 2270 enum EBADFD = 77; 2271 enum EREMCHG = 78; 2272 enum ELIBACC = 79; 2273 enum ELIBBAD = 80; 2274 enum ELIBSCN = 81; 2275 enum ELIBMAX = 82; 2276 enum ELIBEXEC = 83; 2277 enum EILSEQ = 84; 2278 enum ERESTART = 85; 2279 enum ESTRPIPE = 86; 2280 enum EUSERS = 87; 2281 enum ENOTSOCK = 88; 2282 enum EDESTADDRREQ = 89; 2283 enum EMSGSIZE = 90; 2284 enum EPROTOTYPE = 91; 2285 enum ENOPROTOOPT = 92; 2286 enum EPROTONOSUPPORT = 93; 2287 enum ESOCKTNOSUPPORT = 94; 2288 enum EOPNOTSUPP = 95; 2289 enum ENOTSUP = EOPNOTSUPP; 2290 enum EPFNOSUPPORT = 96; 2291 enum EAFNOSUPPORT = 97; 2292 enum EADDRINUSE = 98; 2293 enum EADDRNOTAVAIL = 99; 2294 enum ENETDOWN = 100; 2295 enum ENETUNREACH = 101; 2296 enum ENETRESET = 102; 2297 enum ECONNABORTED = 103; 2298 enum ECONNRESET = 104; 2299 enum ENOBUFS = 105; 2300 enum EISCONN = 106; 2301 enum ENOTCONN = 107; 2302 enum ESHUTDOWN = 108; 2303 enum ETOOMANYREFS = 109; 2304 enum ETIMEDOUT = 110; 2305 enum ECONNREFUSED = 111; 2306 enum EHOSTDOWN = 112; 2307 enum EHOSTUNREACH = 113; 2308 enum EALREADY = 114; 2309 enum EINPROGRESS = 115; 2310 enum ESTALE = 116; 2311 enum EUCLEAN = 117; 2312 enum ENOTNAM = 118; 2313 enum ENAVAIL = 119; 2314 enum EISNAM = 120; 2315 enum EREMOTEIO = 121; 2316 enum EDQUOT = 122; 2317 enum ENOMEDIUM = 123; 2318 enum EMEDIUMTYPE = 124; 2319 enum ECANCELED = 125; 2320 enum ENOKEY = 126; 2321 enum EKEYEXPIRED = 127; 2322 enum EKEYREVOKED = 128; 2323 enum EKEYREJECTED = 129; 2324 enum EOWNERDEAD = 130; 2325 enum ENOTRECOVERABLE = 131; 2326 enum ERFKILL = 132; 2327 enum EHWPOISON = 133; 2328 } 2329 else 2330 { 2331 static assert(false, "Unsupported platform"); 2332 }