OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

libphobos: Merge upstream druntime 7915b6a3 

Includes port fixes for Musl on ARM, AArch64, and SystemZ targets.

Reviewed-on: https://github.com/dlang/druntime/pull/2751
             https://github.com/dlang/druntime/pull/2843
             https://github.com/dlang/druntime/pull/2844
             https://github.com/dlang/druntime/pull/2898
This commit is contained in:
Iain Buclaw 2020-03-14 19:30:24 +01:00
parent 9a6408bd18
commit 6e5084b440
9 changed files with 724 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libphobos/libdruntime/MERGE
View File

@ -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.

328
libphobos/libdruntime/core/stdc/errno.d
View File

@ -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");

2
libphobos/libdruntime/core/stdc/fenv.d
View File

@ -386,6 +386,8 @@ else version (CRuntime_Musl)
}
else version (ARM)
{
import core.stdc.config : c_ulong;
struct fenv_t
{
c_ulong __cw;

8
libphobos/libdruntime/core/sys/posix/config.d
View File

@ -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)
{

112
libphobos/libdruntime/core/sys/posix/fcntl.d
View File

@ -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,

4
libphobos/libdruntime/core/sys/posix/semaphore.d
View File

@ -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)
{

62
libphobos/libdruntime/core/sys/posix/sys/socket.d
View File

@ -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

238
libphobos/libdruntime/core/sys/posix/sys/stat.d
View File

@ -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;
timespec st_atim;
timespec st_mtim;
timespec st_ctim;
extern(D) @safe @property inout pure nothrow
version (ARM)
{
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;
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; }
}
}
long[3] __unused;
}
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;
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
{
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; }
}
}
}
else
static assert("Unsupported platform");
private
{
extern (D) bool S_ISTYPE( mode_t mode, uint mask )

22
libphobos/libdruntime/core/sys/posix/sys/types.d
View File

@ -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;