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
parent
9a6408bd18
commit
6e5084b440
|
|
@ -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;
|
||||
|
||||
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,7 +1895,35 @@ else version (CRuntime_Musl)
|
|||
|
||||
enum
|
||||
{
|
||||
SO_DEBUG = 1,
|
||||
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,
|
||||
|
|
@ -1906,12 +1934,14 @@ else version (CRuntime_Musl)
|
|||
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,7 +1664,72 @@ else version (CRuntime_Musl)
|
|||
S_ISGID = 0x400, // octal 02000
|
||||
S_ISVTX = 0x200, // octal 01000
|
||||
}
|
||||
struct stat_t {
|
||||
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;
|
||||
|
|
@ -1681,14 +1746,143 @@ else version (CRuntime_Musl)
|
|||
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; }
|
||||
}
|
||||
long[3] __unused;
|
||||
}
|
||||
}
|
||||
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 )
|
||||
|
|
|
|||
|
|
@ -111,9 +111,27 @@ version (CRuntime_Glibc)
|
|||
alias uint uid_t;
|
||||
}
|
||||
else version (CRuntime_Musl)
|
||||
{
|
||||
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;
|
||||
|
|
|
|||
Loading…
Reference in New Issue