@@ -1,4 +1,4 @@
-5bb8ce19fa495e5f794b3c513ae1bf7aabae93ff
+7915b6a399fbb6d9c0db351eb5a8fda7e43fe8c5
The first line of this file holds the git revision number of the last
merge done from the dlang/druntime repository.
@@ -144,6 +144,15 @@ else version (Solaris)
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
{
///
@@ -1709,6 +1718,325 @@ else version (Solaris)
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");
@@ -386,6 +386,8 @@ else version (CRuntime_Musl)
}
else version (ARM)
{
+ import core.stdc.config : c_ulong;
+
struct fenv_t
{
c_ulong __cw;
@@ -67,15 +67,21 @@ version (CRuntime_Glibc)
}
else version (CRuntime_Musl)
{
+ // off_t is always 64 bits on Musl
enum _FILE_OFFSET_BITS = 64;
+ // Not present in Musl sources
enum __REDIRECT = false;
+ // Those three are irrelevant for Musl as it always uses 64 bits off_t
enum __USE_FILE_OFFSET64 = _FILE_OFFSET_BITS == 64;
enum __USE_LARGEFILE = __USE_FILE_OFFSET64 && !__REDIRECT;
enum __USE_LARGEFILE64 = __USE_FILE_OFFSET64 && !__REDIRECT;
- enum __WORDSIZE=64;
+ version (D_LP64)
+ enum __WORDSIZE = 64;
+ else
+ enum __WORDSIZE = 32;
}
else version (CRuntime_UClibc)
{
@@ -779,7 +779,102 @@ else version (CRuntime_Bionic)
}
else version (CRuntime_Musl)
{
- enum {
+ version (X86_64)
+ {
+ enum
+ {
+ O_DIRECTORY = 0x010000, // octal 0200000
+ O_NOFOLLOW = 0x020000, // octal 0400000
+ O_DIRECT = 0x004000, // octal 040000
+ O_LARGEFILE = 0,
+ O_TMPFILE = 0x410000, // octal 020200000
+
+ F_GETLK = 5,
+ F_SETLK = 6,
+ F_SETLKW = 7,
+ }
+ }
+ // Note: Definitions for i386 are in arch/generic/bits/fcntl.h
+ else version (X86)
+ {
+ enum
+ {
+ O_DIRECTORY = 0x010000, // octal 0200000
+ O_NOFOLLOW = 0x020000, // octal 0400000
+ O_DIRECT = 0x004000, // octal 040000
+ O_LARGEFILE = 0x008000, // octal 0100000
+ O_TMPFILE = 0x410000, // octal 020200000
+
+ F_GETLK = 12,
+ F_SETLK = 13,
+ F_SETLKW = 14,
+ }
+ }
+ else version (ARM)
+ {
+ enum
+ {
+ O_DIRECTORY = 0x004000, // octal 040000
+ O_NOFOLLOW = 0x008000, // octal 0100000
+ O_DIRECT = 0x010000, // octal 0200000
+ O_LARGEFILE = 0x020000, // octal 0400000
+ O_TMPFILE = 0x404000, // octal 020040000
+
+ F_GETLK = 12,
+ F_SETLK = 13,
+ F_SETLKW = 14,
+ }
+ }
+ else version (AArch64)
+ {
+ enum
+ {
+ O_DIRECTORY = 0x004000, // octal 040000
+ O_NOFOLLOW = 0x008000, // octal 0100000
+ O_DIRECT = 0x010000, // octal 0200000
+ O_LARGEFILE = 0x020000, // octal 0400000
+ O_TMPFILE = 0x404000, // octal 020040000
+
+ F_GETLK = 5,
+ F_SETLK = 6,
+ F_SETLKW = 7,
+ }
+ }
+ else version (SystemZ)
+ {
+ enum
+ {
+ O_DIRECTORY = 0x010000, // octal 0200000
+ O_NOFOLLOW = 0x020000, // octal 0400000
+ O_DIRECT = 0x004000, // octal 040000
+ O_LARGEFILE = 0x008000, // octal 0100000
+ O_TMPFILE = 0x410000, // octal 020200000
+
+ F_GETLK = 5,
+ F_SETLK = 6,
+ F_SETLKW = 7,
+ }
+ }
+ else version (PPC64)
+ {
+ enum
+ {
+ O_DIRECTORY = 0x004000, // octal 040000
+ O_NOFOLLOW = 0x008000, // octal 0100000
+ O_DIRECT = 0x020000, // octal 0400000
+ O_LARGEFILE = 0x010000, // octal 0200000
+ O_TMPFILE = 0x410000, // octal 020200000
+
+ F_GETLK = 5,
+ F_SETLK = 6,
+ F_SETLKW = 7,
+ }
+ }
+ else
+ static assert(0, "Platform not supported");
+
+ enum
+ {
O_CREAT = 0x40, // octal 0100
O_EXCL = 0x80, // octal 0200
O_NOCTTY = 0x100, // octal 0400
@@ -790,16 +885,11 @@ else version (CRuntime_Musl)
O_DSYNC = 0x1000, // octal 010000
O_SYNC = 0x101000, // octal 04010000
O_RSYNC = O_SYNC,
- O_DIRECTORY = 0x10000,
- O_NOFOLLOW = 0x20000,
O_CLOEXEC = 0x80000,
O_ASYNC = 0x2000,
- O_DIRECT = 0x4000,
- O_LARGEFILE = 0,
O_NOATIME = 0x40000,
O_PATH = 0x200000,
- O_TMPFILE = 0x410000,
O_NDELAY = O_NONBLOCK,
O_SEARCH = O_PATH,
O_EXEC = O_PATH,
@@ -809,19 +899,19 @@ else version (CRuntime_Musl)
O_WRONLY = 01,
O_RDWR = 02,
}
- enum {
+ enum
+ {
F_DUPFD = 0,
F_GETFD = 1,
F_SETFD = 2,
F_GETFL = 3,
F_SETFL = 4,
- F_GETLK = 5,
- F_SETLK = 6,
- F_SETLKW = 7,
+ // F_GETLK, F_SETLK, F_SETLKW are arch-specific
F_SETOWN = 8,
F_GETOWN = 9,
}
- enum {
+ enum
+ {
F_RDLCK = 0,
F_WRLCK = 1,
F_UNLCK = 2,
@@ -143,8 +143,10 @@ else version (CRuntime_Bionic)
else version (CRuntime_Musl)
{
struct sem_t {
- int[4*long.sizeof/int.sizeof] __val;
+ int[4*c_long.sizeof/int.sizeof] __val;
}
+
+ enum SEM_FAILED = (sem_t*).init;
}
else version (CRuntime_UClibc)
{
@@ -1895,22 +1895,52 @@ else version (CRuntime_Musl)
enum
{
- SO_DEBUG = 1,
- SO_REUSEADDR = 2,
- SO_TYPE = 3,
- SO_ERROR = 4,
- SO_DONTROUTE = 5,
- SO_BROADCAST = 6,
- SO_SNDBUF = 7,
- SO_RCVBUF = 8,
- SO_KEEPALIVE = 9,
- SO_OOBINLINE = 10,
- SO_LINGER = 13,
- SO_RCVLOWAT = 18,
- SO_SNDLOWAT = 19,
- SO_RCVTIMEO = 20,
- SO_SNDTIMEO = 21,
- SO_ACCEPTCONN = 30
+ SO_DEBUG = 1
+ }
+
+ version (MIPS_Any)
+ {
+ enum
+ {
+ SO_REUSEADDR = 0x0004,
+ SO_TYPE = 0x1008,
+ SO_ERROR = 0x1007,
+ SO_DONTROUTE = 0x0010,
+ SO_BROADCAST = 0x0020,
+ SO_SNDBUF = 0x1001,
+ SO_RCVBUF = 0x1002,
+ SO_KEEPALIVE = 0x0008,
+ SO_OOBINLINE = 0x0100,
+ SO_LINGER = 0x0080,
+ SO_REUSEPORT = 0x0200,
+ SO_RCVLOWAT = 0x1004,
+ SO_SNDLOWAT = 0x1003,
+ SO_RCVTIMEO = 0x1006,
+ SO_SNDTIMEO = 0x1005,
+ SO_ACCEPTCONN = 0x1009
+ }
+ }
+ else
+ {
+ enum
+ {
+ SO_REUSEADDR = 2,
+ SO_TYPE = 3,
+ SO_ERROR = 4,
+ SO_DONTROUTE = 5,
+ SO_BROADCAST = 6,
+ SO_SNDBUF = 7,
+ SO_RCVBUF = 8,
+ SO_KEEPALIVE = 9,
+ SO_OOBINLINE = 10,
+ SO_LINGER = 13,
+ SO_REUSEPORT = 15,
+ SO_RCVLOWAT = 18,
+ SO_SNDLOWAT = 19,
+ SO_RCVTIMEO = 20,
+ SO_SNDTIMEO = 21,
+ SO_ACCEPTCONN = 30
+ }
}
enum : uint
@@ -1664,31 +1664,225 @@ else version (CRuntime_Musl)
S_ISGID = 0x400, // octal 02000
S_ISVTX = 0x200, // octal 01000
}
- struct stat_t {
- dev_t st_dev;
- ino_t st_ino;
- nlink_t st_nlink;
-
- mode_t st_mode;
- uid_t st_uid;
- gid_t st_gid;
- uint __pad0;
- dev_t st_rdev;
- off_t st_size;
- blksize_t st_blksize;
- blkcnt_t st_blocks;
+ version (ARM)
+ {
+ struct stat_t
+ {
+ dev_t st_dev;
+ int __st_dev_padding;
+ c_long __st_ino_truncated;
+ mode_t st_mode;
+ nlink_t st_nlink;
+
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ int __st_rdev_padding;
+ off_t st_size;
+ blksize_t st_blksize;
+ blkcnt_t st_blocks;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+ ino_t st_ino;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
+ }
+ }
+ else version (AArch64)
+ {
+ struct stat_t
+ {
+ dev_t st_dev;
+ ino_t st_ino;
+ mode_t st_mode;
+ nlink_t st_nlink;
+
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ c_ulong __pad;
+ off_t st_size;
+ blksize_t st_blksize;
+ int __pad2;
+ blkcnt_t st_blocks;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+ uint[2] __unused;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
+ }
+ }
+ else version (X86_64)
+ {
+ struct stat_t
+ {
+ dev_t st_dev;
+ ino_t st_ino;
+ nlink_t st_nlink;
+
+ mode_t st_mode;
+ uid_t st_uid;
+ gid_t st_gid;
+ uint __pad0;
+ dev_t st_rdev;
+ off_t st_size;
+ blksize_t st_blksize;
+ blkcnt_t st_blocks;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+
+ c_long[3] __unused;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
+ }
+ }
+ else version (X86)
+ {
+ struct stat_t
+ {
+ dev_t st_dev;
+ int __st_dev_padding;
+ c_long __st_ino_truncated;
+ mode_t st_mode;
+ nlink_t st_nlink;
+
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ int __st_rdev_padding;
+ off_t st_size;
+ blksize_t st_blksize;
+ blkcnt_t st_blocks;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+ ino_t st_ino;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
+ }
+ }
+ else version (MIPS64)
+ {
+ struct stat_t
+ {
+ dev_t st_dev;
+ int[3] __pad1;
+ ino_t st_ino;
+ mode_t st_mode;
+ nlink_t st_nlink;
+
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ uint[2] __pad2;
+ off_t st_size;
+ int __pad3;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+ blksize_t st_blksize;
+ uint __pad4;
+ blkcnt_t st_blocks;
+ int[14] __pad5;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
+ }
+ }
+ else version (PPC64)
+ {
+ struct stat_t
+ {
+ dev_t st_dev;
+ ino_t st_ino;
+ nlink_t st_nlink;
+ mode_t st_mode;
- timespec st_atim;
- timespec st_mtim;
- timespec st_ctim;
- extern(D) @safe @property inout pure nothrow
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ off_t st_size;
+ blksize_t st_blksize;
+ blkcnt_t st_blocks;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+ c_ulong[3] __unused;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
+ }
+ }
+ else version (SystemZ)
+ {
+ struct stat_t
{
- ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
- ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
- ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ dev_t st_dev;
+ ino_t st_ino;
+ nlink_t st_nlink;
+ mode_t st_mode;
+
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ off_t st_size;
+
+ timespec st_atim;
+ timespec st_mtim;
+ timespec st_ctim;
+
+ blksize_t st_blksize;
+ blkcnt_t st_blocks;
+ c_ulong[3] __unused;
+
+ extern(D) @safe @property inout pure nothrow
+ {
+ ref inout(time_t) st_atime() return { return st_atim.tv_sec; }
+ ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; }
+ ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; }
+ }
}
- long[3] __unused;
}
+ else
+ static assert("Unsupported platform");
+
private
{
extern (D) bool S_ISTYPE( mode_t mode, uint mask )
@@ -112,8 +112,26 @@ version (CRuntime_Glibc)
}
else version (CRuntime_Musl)
{
- alias c_long blksize_t;
- alias c_ulong nlink_t;
+ version (AArch64)
+ {
+ alias int blksize_t;
+ alias uint nlink_t;
+ }
+ else version (MIPS64)
+ {
+ alias c_long blksize_t;
+ alias uint nlink_t;
+ }
+ else version (RISCV64)
+ {
+ alias int blksize_t;
+ alias uint nlink_t;
+ }
+ else
+ {
+ alias c_long blksize_t;
+ alias c_ulong nlink_t;
+ }
alias long dev_t;
alias long blkcnt_t;
alias ulong ino_t;