Odin Documentation

core/sys/posix

posix

Types

122

AF

AF :: enum c.int { // Unspecified. UNSPEC = AF_UNSPEC, // Internet domain sockets for use with IPv4 addresses. INET = AF_INET, // Internet domain sockets for use with IPv6 addresses. INET6 = AF_INET6, // UNIX domain sockets. UNIX = AF_UNIX, }Source

AT_Flag_Bits

AT_Flag_Bits :: enum c.int { EACCESS = log2(AT_EACCESS), SYMLINK_NOFOLLOW = log2(AT_SYMLINK_NOFOLLOW), SYMLINK_FOLLOW = log2(AT_SYMLINK_FOLLOW), REMOVEDIR = log2(AT_REMOVEDIR), }Source

Addrinfo_Flag_Bits

Addrinfo_Flag_Bits :: enum c.int { // Socket address is intended for bind(). PASSIVE = log2(AI_PASSIVE), // Request for canonical name. CANONNAME = log2(AI_CANONNAME), // Return numeric host address as name. NUMERICHOST = log2(AI_NUMERICHOST), // Inhibit service name resolution. NUMERICSERV = log2(AI_NUMERICSERV), // If no IPv6 addresses are found, query for IPv4 addresses and return them to the // caller as IPv4-mapped IPv6 addresses. V4MAPPED = log2(AI_V4MAPPED), // Query for both IPv4 and IPv6 addresses. ALL = log2(AI_ALL), // Query for IPv4 addresses only when an IPv4 address is configured; query for IPv6 addresses // only when an IPv6 address is configured. ADDRCONFIG = log2(AI_ADDRCONFIG), }Source

Any_Code

Any_Code :: enum c.int { // Signal sent by kill(). USER = SI_USER, // Signal sent by sigqueue(). QUEUE = SI_QUEUE, // Signal generated by expiration of a timer set by timer_settime(). TIMER = SI_TIMER, // Signal generated by completion of an asynchronous I/O request. ASYNCIO = SI_ASYNCIO, // Signal generated by arrival of a message on an empty message queue. MESGQ = SI_MESGQ, }Source

BUS_Code

BUS_Code :: enum c.int { // Invalid address alignment. ADRALN = BUS_ADRALN, // Nonexistent physical address. ADRERR = BUS_ADRERR, // Object-specific hardware error. OBJERR = BUS_OBJERR, }Source

CControl_Flag_Bits

CControl_Flag_Bits :: enum tcflag_t { // CS5 = log2(CS5), /* 5 bits (pseudo) (default) */ CS6 = log2(CS6), // 6 bits CS7 = log2(CS7), // 7 bits CS8 = log2(CS8), // 8 bits CSTOPB = log2(CSTOPB), // send 2 stop bits CREAD = log2(CREAD), // enable receiver PARENB = log2(PARENB), // parity enable PARODD = log2(PARODD), // odd parity, else even HUPCL = log2(HUPCL), // hang up on last close CLOCAL = log2(CLOCAL), // ignore modem status lines }Source

CInput_Flag_Bits

CInput_Flag_Bits :: enum tcflag_t { IGNBRK = log2(IGNBRK), // ignore BREAK condition BRKINT = log2(BRKINT), // map BREAK to SIGINTR IGNPAR = log2(IGNPAR), // ignore (discard) parity errors PARMRK = log2(PARMRK), // mark parity and framing errors INPCK = log2(INPCK), // enable checking of parity errors ISTRIP = log2(ISTRIP), // strip 8th bit off chars INLCR = log2(INLCR), // map NL into CR IGNCR = log2(IGNCR), // ignore CR ICRNL = log2(ICRNL), // map CR to NL (ala CRMOD) IXON = log2(IXON), // enable output flow control IXOFF = log2(IXOFF), // enable input flow control IXANY = log2(IXANY), // any char will restart after stop }Source

CLD_Code

CLD_Code :: enum c.int { // Child has exited.. EXITED = CLD_EXITED, // Child has terminated abnormally and did not create a core file. KILLED = CLD_KILLED, // Child has terminated abnormally and created a core file. DUMPED = CLD_DUMPED, // Traced child trapped. TRAPPED = CLD_TRAPPED, // Child has stopped. STOPPED = CLD_STOPPED, // Stopped child has continued. CONTINUED = CLD_CONTINUED, }Source

CLocal_Flag_Bits

CLocal_Flag_Bits :: enum tcflag_t { ECHO = log2(ECHO), // visual erase for line kill ECHOE = log2(ECHOE), // visually erase chars ECHOK = log2(ECHOK), // echo NL after line kill ECHONL = log2(ECHONL), // echo NL even if ECHO is off ICANON = log2(ICANON), // canonicalize input lines IEXTEN = log2(IEXTEN), // enable DISCARD and LNEXT ISIG = log2(ISIG), // enable signals INTR, QUIT, [D]SUSP NOFLSH = log2(NOFLSH), // don't flush after interrupt TOSTOP = log2(TOSTOP), // stop background jobs from output }Source

COutput_Flag_Bits

COutput_Flag_Bits :: enum tcflag_t { OPOST = log2(OPOST), // enable following output processing ONLCR = log2(ONLCR), // map NL to CR-NL (ala CRMOD) OCRNL = log2(OCRNL), // map CR to NL on output ONOCR = log2(ONOCR), // no CR output at column 0 ONLRET = log2(ONLRET), // NL performs CR function OFDEL = log2(OFDEL), // fill is DEL, else NUL OFILL = log2(OFILL), // use fill characters for delay // NL0 = log2(NL0), /* \n delay 0 (default) */ NL1 = log2(NL1), // \n delay 1 // CR0 = log2(CR0), /* \r delay 0 (default) */ CR1 = log2(CR1), // \r delay 1 CR2 = log2(CR2), // \r delay 2 CR3 = log2(CR3), // \r delay 3 // TAB0 = log2(TAB0),/* horizontal tab delay 0 (default) */ TAB1 = log2(TAB1), // horizontal tab delay 1 TAB3 = log2(TAB3), // horizontal tab delay 3 // BS0 = log2(BS0), /* \b delay 0 (default) */ BS1 = log2(BS1), // \b delay 1 // VT0 = log2(VT0), /* vertical tab delay 0 (default) */ VT1 = log2(VT1), // vertical tab delay 1 // FF0 = log2(FF0), /* form feed delay 0 (default) */ FF1 = log2(FF1), // form feed delay 1 }Source

CS

CS :: enum c.int { _PATH = _CS_PATH, _POSIX_V6_ILP32_OFF32_CFLAGS = _CS_POSIX_V6_ILP32_OFF32_CFLAGS, _POSIX_V6_ILP32_OFF32_LDFLAGS = _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, _POSIX_V6_ILP32_OFF32_LIBS = _CS_POSIX_V6_ILP32_OFF32_LIBS, _POSIX_V6_ILP32_OFFBIG_CFLAGS = _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS, _POSIX_V6_ILP32_OFFBIG_LDFLAGS = _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, _POSIX_V6_ILP32_OFFBIG_LIBS = _CS_POSIX_V6_ILP32_OFFBIG_LIBS, _POSIX_V6_LP64_OFF64_CFLAGS = _CS_POSIX_V6_LP64_OFF64_CFLAGS, _POSIX_V6_LP64_OFF64_LDFLAGS = _CS_POSIX_V6_LP64_OFF64_LDFLAGS, _POSIX_V6_LP64_OFF64_LIBS = _CS_POSIX_V6_LP64_OFF64_LIBS, _POSIX_V6_LPBIG_OFFBIG_CFLAGS = _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, _POSIX_V6_LPBIG_OFFBIG_LDFLAGS = _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, _POSIX_V6_LPBIG_OFFBIG_LIBS = _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, _POSIX_V6_WIDTH_RESTRICTED_ENVS = _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS, }Source

Cancel_State

Cancel_State :: enum c.int { // Cancel takes place at next cancellation point. ENABLE = PTHREAD_CANCEL_ENABLE, // Cancel postponed. DISABLE = PTHREAD_CANCEL_DISABLE, }Source

Cancel_Type

Cancel_Type :: enum c.int { // Cancel waits until cancellation point. DEFERRED = PTHREAD_CANCEL_DEFERRED, // Cancel occurs immediately. ASYNCHRONOUS = PTHREAD_CANCEL_ASYNCHRONOUS, }Source

Clock

Clock :: enum clockid_t { // system-wide monotonic clock, defined as clock measuring real time, // can be set with clock_settime() and cannot have negative clock jumps. MONOTONIC = CLOCK_MONOTONIC, // CPU-time clock associated with the process making a clock() function call. PROCESS_CPUTIME_ID = CLOCK_PROCESS_CPUTIME_ID, // system-wide clock measuring real time. REALTIME = CLOCK_REALTIME, // CPU-time clock associated with the thread making a clock() function call. THREAD_CPUTIME_ID = CLOCK_THREAD_CPUTIME_ID, }Source

Control_Char

Control_Char :: enum c.int { VEOF = VEOF, VEOL = VEOL, VERASE = VERASE, VINTR = VINTR, VKILL = VKILL, VMIN = VMIN, VQUIT = VQUIT, VSTART = VSTART, VSTOP = VSTOP, VSUSP = VSUSP, VTIME = VTIME, NCCS = NCCS-1, }Source

D_Type

D_Type :: enum c.uint8_t { UNKNOWN = 0, FIFO = 1, CHR = 2, DIR = 4, BLK = 6, REG = 8, LNK = 10, SOCK = 12, WHT = 14, }Source

NOTE: d_type is not a POSIX standard field, but all targets we support add it.

Detach_State

Detach_State :: enum c.int { // Causes all threads to be in the joinable state. CREATE_JOINABLE = PTHREAD_CREATE_JOINABLE, // Causes all threads to be in the detached state. CREATE_DETACHED = PTHREAD_CREATE_DETACHED, }Source

Errno

Errno :: enum c.int { NONE = 0, EDOM = EDOM, EILSEQ = EILSEQ, ERANGE = ERANGE, E2BIG = E2BIG, EACCES = EACCES, EADDRINUSE = EADDRINUSE, EADDRNOTAVAIL = EADDRNOTAVAIL, EAFNOSUPPORT = EAFNOSUPPORT, EAGAIN = EAGAIN, EALREADY = EALREADY, EBADF = EBADF, EBADMSG = EBADMSG, EBUSY = EBUSY, ECANCELED = ECANCELED, ECHILD = ECHILD, ECONNABORTED = ECONNABORTED, ECONNREFUSED = ECONNREFUSED, ECONNRESET = ECONNRESET, EDEADLK = EDEADLK, EDESTADDRREQ = EDESTADDRREQ, EDQUOT = EDQUOT, EEXIST = EEXIST, EFAULT = EFAULT, EFBIG = EFBIG, EHOSTUNREACH = EHOSTUNREACH, EIDRM = EIDRM, EINPROGRESS = EINPROGRESS, EINTR = EINTR, EINVAL = EINVAL, EIO = EIO, EISCONN = EISCONN, EISDIR = EISDIR, ELOOP = ELOOP, EMFILE = EMFILE, EMLINK = EMLINK, EMSGSIZE = EMSGSIZE, EMULTIHOP = EMULTIHOP, ENAMETOOLONG = ENAMETOOLONG, ENETDOWN = ENETDOWN, ENETRESET = ENETRESET, ENETUNREACH = ENETUNREACH, ENFILE = ENFILE, ENOBUFS = ENOBUFS, ENODATA = ENODATA, ENODEV = ENODEV, ENOENT = ENOENT, ENOEXEC = ENOEXEC, ENOLCK = ENOLCK, ENOLINK = ENOLINK, ENOMEM = ENOMEM, ENOMSG = ENOMSG, ENOPROTOOPT = ENOPROTOOPT, ENOSPC = ENOSPC, ENOSR = ENOSR, ENOSTR = ENOSTR, ENOSYS = ENOSYS, ENOTCONN = ENOTCONN, ENOTDIR = ENOTDIR, ENOTEMPTY = ENOTEMPTY, ENOTRECOVERABLE = ENOTRECOVERABLE, ENOTSOCK = ENOTSOCK, ENOTSUP = ENOTSUP, ENOTTY = ENOTTY, ENXIO = ENXIO, EOPNOTSUPP = EOPNOTSUPP, EOVERFLOW = EOVERFLOW, EOWNERDEAD = EOWNERDEAD, EPERM = EPERM, EPIPE = EPIPE, EPROTO = EPROTO, EPROTONOSUPPORT = EPROTONOSUPPORT, EPROTOTYPE = EPROTOTYPE, EROFS = EROFS, ESPIPE = ESPIPE, ESRCH = ESRCH, ESTALE = ESTALE, ETIME = ETIME, ETIMEDOUT = ETIMEDOUT, ETXTBSY = ETXTBSY, EWOULDBLOCK = EWOULDBLOCK, EXDEV = EXDEV, }Source

FCNTL_Cmd

FCNTL_Cmd :: enum c.int { DUPFD = F_DUPFD, DUPFD_CLOEXEC = F_DUPFD_CLOEXEC, GETFD = F_GETFD, SETFD = F_SETFD, GETFL = F_GETFL, SETFL = F_SETFL, GETLK = F_GETLK, SETLK = F_SETLK, SETLKW = F_SETLKW, GETOWN = F_GETOWN, SETOWN = F_SETOWN, }Source

FNM_Flag_Bits

FNM_Flag_Bits :: enum c.int { // A <slash> character ( '/' ) in string shall be explicitly matched by a <slash> in pattern; // it shall not be matched by either the <asterisk> or <question-mark> special characters, // nor by a bracket expression. PATHNAME = log2(FNM_PATHNAME), // A leading <period> ( '.' ) in string shall match a <period> in pattern; // as described by rule 2 in XCU [[ Patterns Used for Filename Expansion; https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13_03 ]] // where the location of "leading" is indicated by the value of PATHNAME: // 1. If PATHNAME is set, a <period> is "leading" if it is the first character in string or if it immediately follows a <slash>. // 2. If PATHNAME is not set, a <period> is "leading" only if it is the first character of string. PERIOD = log2(FNM_PERIOD), // A <backslash> character shall be treated as an ordinary character. NOESCAPE = log2(FNM_NOESCAPE), }Source

FPE_Code

FPE_Code :: enum c.int { // Integer divide by zero. INTDIV = FPE_INTDIV, // Integer overflow. INTOVF = FPE_INTOVF, // Floating-point divide by zero. FLTDIV = FPE_FLTDIV, // Floating-point overflow. FLTOVF = FPE_FLTOVF, // Floating-point underflow. FLTUND = FPE_FLTUND, // Floating-point inexact result. FLTRES = FPE_FLTRES, // Invalid floating-point operation. FLTINV = FPE_FLTINV, // Subscript out of range. FLTSUB = FPE_FLTSUB, }Source

Glob_Flag_Bits

Glob_Flag_Bits :: enum c.int { // Append pathnames generated to the ones from a previous call to glob(). APPEND = log2(GLOB_APPEND), // Make use of pglob->gl_offs. If this flag is set, pglob->gl_offs is used to specify how many null pointers to add to the beginning of pglob->gl_pathv. // In other words, pglob->gl_pathv shall point to pglob->gl_offs null pointers, followed by pglob->gl_pathc pathname pointers, followed by a null pointer. DOOFFS = log2(GLOB_DOOFFS), // Cause glob() to return when it encounters a directory that it cannot open or read. Ordinarily, // glob() continues to find matches. ERR = log2(GLOB_ERR), // Each pathname that is a directory that matches pattern shall have a <slash> appended. MARK = log2(GLOB_MARK), // Supports rule 3 in [[ XCU Patterns Used for Filename Expansion; https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13_03 ]]. // If pattern does not match any pathname, then glob() shall return a list consisting of only pattern, // and the number of matched pathnames is 1. NOCHECK = log2(GLOB_NOCHECK), // Disable backslash escaping. NOESCAPE = log2(GLOB_NOESCAPE), // Ordinarily, glob() sorts the matching pathnames according to the current setting of the // LC_COLLATE category; see XBD LC_COLLATE. When this flag is used, // the order of pathnames returned is unspecified. NOSORT = log2(GLOB_NOSORT), }Source

ILL_Code

ILL_Code :: enum c.int { // Illegal opcode. ILLOPC = ILL_ILLOPC, // Illegal operand. ILLOPN = ILL_ILLOPN, // Illegal addressing mode. ILLADR = ILL_ILLADR, // Illegal trap. ILLTRP = ILL_ILLTRP, // Priviledged opcode. PRVOPC = ILL_PRVOPC, // Priviledged register. PRVREG = ILL_PRVREG, // Coprocessor error. COPROC = ILL_COPROC, // Internal stack error. BADSTK = ILL_BADSTK, }Source

ITimer

ITimer :: enum c.int { // Decrements in real time. REAL = ITIMER_REAL, // Decrements in process virtual time, only when the process is executing. VIRTUAL = ITIMER_VIRTUAL, // Decrements both in process virtual time and when the system is running on // behalf of the process. PROF = ITIMER_PROF, }Source

Info_Errno

Info_Errno :: enum c.int { NONE = 0, // The name could not be resolved at this time. Future attempts may succeed. AGAIN = EAI_AGAIN, // The flags had an invalid value. BADFLAGS = EAI_BADFLAGS, // A non-recoverable error ocurred. FAIL = EAI_FAIL, // The address family was not recognized or the address length was invald for the specified family. FAMILY = EAI_FAMILY, // There was a memory allocation failure. MEMORY = EAI_MEMORY, // The name does not resolve for the supplied parameters. NONAME = EAI_NONAME, // The service passed was not recognized for the specified socket. SERVICE = EAI_SERVICE, // The intended socket type was not recognized. SOCKTYPE = EAI_SOCKTYPE, // A system error occurred. The error code can be found in errno. SYSTEM = EAI_SYSTEM, // An argument buffer overflowed. OVERFLOW = EAI_OVERFLOW, }Source

Inherit_Sched

Inherit_Sched :: enum c.int { // Threads inherit from the creating thread. INHERIT_SCHED = PTHREAD_INHERIT_SCHED, // Threads scheduling shall be set to the corresponding values from the attributes object. EXPLICIT_SCHED = PTHREAD_EXPLICIT_SCHED, }Source

Lock_Flag_Bits

Lock_Flag_Bits :: enum c.int { // Lock all pages currently mapped into the address space of the process. CURRENT = log2(MCL_CURRENT), // Lock all pages that become mapped into the address space of the process in the future, // when those mappings are established. FUTURE = log2(MCL_FUTURE), }Source

Lock_Function

Lock_Function :: enum c.int { // Lock a section for exclusive use. LOCK = F_LOCK, // Test a section for locks by other processes. TEST = F_TEST, // Test and lock a section for exclusive use. TLOCK = F_TLOCK, // Unlock locked sections. ULOCK = F_ULOCK, }Source

MAdvice

MAdvice :: enum c.int { DONTNEED = POSIX_MADV_DONTNEED, NORMAL = POSIX_MADV_NORMAL, RANDOM = POSIX_MADV_RANDOM, SEQUENTIAL = POSIX_MADV_SEQUENTIAL, WILLNEED = POSIX_MADV_WILLNEED, }Source

Map_Flag_Bits

Map_Flag_Bits :: enum c.int { // Map anonymous memory. ANONYMOUS = log2(MAP_ANONYMOUS), // Interpret addr exactly. FIXED = log2(MAP_FIXED), // Changes are private. PRIVATE = log2(MAP_PRIVATE), // Changes are shared. SHARED = log2(MAP_SHARED), }Source

Mode_Bits

Mode_Bits :: enum c.int { // File type: IFCHR = log2(_S_IFCHR), // Character special IFIFO = log2(_S_IFIFO), // FIFO special IFREG = log2(_S_IFREG), // Regular IFDIR = log2(_S_IFDIR), // Directory // Permissions: IRUSR = log2(_S_IRUSR), // R for owner IWUSR = log2(_S_IWUSR), // W for owner IXUSR = log2(_S_IXUSR), // X for owner IRGRP = log2(_S_IRGRP), // R for group IWGRP = log2(_S_IWGRP), // W for group IXGRP = log2(_S_IXGRP), // X for group IROTH = log2(_S_IROTH), // R for other IWOTH = log2(_S_IWOTH), // W for other IXOTH = log2(_S_IXOTH), // X for other ISUID = log2(_S_ISUID), // Set user ID on execution ISGID = log2(_S_ISGID), // Set group ID on execution ISVXT = log2(_S_ISVTX), // On directories, restricted deletion flag }Source

Msg_Flag_Bits

Msg_Flag_Bits :: enum c.int { // Control data truncated. CTRUNC = log2(MSG_CTRUNC), // Send without using routing table. DONTROUTE = log2(MSG_DONTROUTE), // Terminates a record (if supported by protocol). EOR = log2(MSG_EOR), // Out-of-band data. OOB = log2(MSG_OOB), // No SIGPIPE is generated when an attempt to send is made on a stream-oriented socket that is // no longer connected. NOSIGNAL = log2(MSG_NOSIGNAL), // Leave received data in queue. PEEK = log2(MSG_PEEK), // Normal data truncated. TRUNC = log2(MSG_TRUNC), // Attempt to fill the read buffer. WAITALL = log2(MSG_WAITALL), }Source

Nameinfo_Flag_Bits

Nameinfo_Flag_Bits :: enum c.int { // Only the nodename portion of the FQDN is returned for local hosts. NOFQDN = log2(NI_NOFQDN), // The numeric form of the node's address is returned instead of its name. NUMERICHOST = log2(NI_NUMERICHOST), // Return an error if the node's name cannot be located in the database. NAMEREQD = log2(NI_NAMEREQD), // The numeric form of the service address is returned instead of its name. NUMERICSERV = log2(NI_NUMERICSERV), // For IPv6 addresses, the numeric form of the scope identifier is returned instead of its name. NUMERICSCOPE = log2(NI_NUMERICSCOPE), // Indicates that the service is a datagram service (SOCK_DGRAM). DGRAM = log2(NI_DGRAM), }Source

O_Flag_Bits

O_Flag_Bits :: enum c.int { // Sets FD_CLOEXEC on the file descriptor. CLOEXEC = log2(O_CLOEXEC), // If not exists, combined with DIRECTORY will cause creation of a directory, otherwise a regular file. CREAT = log2(O_CREAT), // Fails if the opened descriptor would not be a directory. DIRECTORY = log2(O_DIRECTORY), // If combined with CREAT, causes a failure if the file already exists. EXCL = log2(O_EXCL), // If terminal device, do not make it the controlling terminal for the process. NOCTTY = log2(O_NOCTTY), // Don't follow symbolic links, fail with errno ELOOP. NOFOLLOW = log2(O_NOFOLLOW), // If exists and regular, truncate the length to 0. TRUNC = log2(O_TRUNC), // NOTE: use with `posix.O_TTY_INIT + { .OTHER_FLAG, .OTHER_FLAG }`, unfortunately can't be in // this bit set enum because it is 0 on some platforms and a value on others. // TTY_INIT = O_TTY_INIT, // Set file offset to end of file prior to each write. APPEND = log2(O_APPEND), // Write I/O shall complete as defined by synchronized I/O data integrity completion. DSYNC = log2(O_DSYNC), // Causes nonblocking behaviour in various situations. NONBLOCK = log2(O_NONBLOCK), // Write I/O shall complete as defined by synchronized I/O file integrity completion. SYNC = log2(O_SYNC), // NOTE: use with `posix.O_RSYNC + { .OTHER_FLAG, .OTHER_FLAG }`, unfortunately can't be in // this bit set enum because it is 0 on some platforms and a value on others. // RSYNC = O_RSYNC, // Execute only. EXEC = log2(O_EXEC), // Reading and writing. RDWR = log2(O_RDWR), // Writing only. WRONLY = log2(O_WRONLY), }Source

PC

PC :: enum c.int { _2_SYMLINKS = _PC_2_SYMLINKS, _ALLOC_SIZE_MIN = _PC_ALLOC_SIZE_MIN, _ASYNC_IO = _PC_ASYNC_IO, _CHOWN_RESTRICTED = _PC_CHOWN_RESTRICTED, _FILESIZEBITS = _PC_FILESIZEBITS, _LINK_MAX = _PC_LINK_MAX, _MAX_CANON = _PC_MAX_CANON, _MAX_INPUT = _PC_MAX_INPUT, _NAME_MAX = _PC_NAME_MAX, _NO_TRUNC = _PC_NO_TRUNC, _PATH_MAX = _PC_PATH_MAX, _PIPE_BUF = _PC_PIPE_BUF, _PRIO_IO = _PC_PRIO_IO, _REC_INCR_XFER_SIZE = _PC_REC_INCR_XFER_SIZE, _REC_MAX_XFER_SIZE = _PC_REC_MAX_XFER_SIZE, _REC_MIN_XFER_SIZE = _PC_REC_MIN_XFER_SIZE, _REC_XFER_ALIGN = _PC_REC_XFER_ALIGN, _SYMLINK_MAX = _PC_SYMLINK_MAX, _SYNC_IO = _PC_SYNC_IO, _VDISABLE = _PC_VDISABLE, }Source

POLL_Code

POLL_Code :: enum c.int { // Data input is available. IN = POLL_IN, // Output buffers available. OUT = POLL_OUT, // Input message available. MSG = POLL_MSG, // I/O error. ERR = POLL_ERR, // High priority input available. PRI = POLL_PRI, // Device disconnected. HUP = POLL_HUP, }Source

Poll_Event_Bits

Poll_Event_Bits :: enum c.short { // Data other than high-priority data may be read without blocking. IN = log2(POLLIN), // Normal data may be read without blocking. RDNORM = log2(POLLRDNORM), // Priority data may be read without blocking. RDBAND = log2(POLLRDBAND), // High priority data may be read without blocking. PRI = log2(POLLPRI), // Normal data may be written without blocking. OUT = log2(POLLOUT), // Equivalent to POLLOUT. WRNORM = log2(POLLWRNORM), // Priority data may be written. WRBAND = log2(POLLWRBAND), // An error has occurred (revents only). ERR = log2(POLLERR), // Device hsa been disconnected (revents only). HUP = log2(POLLHUP), // Invalid fd member (revents only). NVAL = log2(POLLNVAL), }Source

Prot_Flag_Bits

Prot_Flag_Bits :: enum c.int { // Data can be executed. EXEC = log2(PROT_EXEC), // Data can be read. READ = log2(PROT_READ), // Data can be written. WRITE = log2(PROT_WRITE), }Source

Protocol

Protocol :: enum c.int { IP = IPPROTO_IP, ICMP = IPPROTO_ICMP, IPV6 = IPPROTO_IPV6, RAW = IPPROTO_RAW, TCP = IPPROTO_TCP, UDP = IPPROTO_UDP, }Source

RTLD_Flag_Bits

RTLD_Flag_Bits :: enum c.int { LAZY = log2(RTLD_LAZY), NOW = log2(RTLD_NOW), GLOBAL = log2(RTLD_GLOBAL), // NOTE: use with `posix.RTLD_LOCAL + { .OTHER_FLAG, .OTHER_FLAG }`, unfortunately can't be in // this bit set enum because it is 0 on some platforms and a value on others. // LOCAL = RTLD_LOCAL _MAX = 31, }Source

Resource

Resource :: enum c.int { // Maximum byte size of a core file that may be created by a process. CORE = RLIMIT_CORE, // Maximum amount of CPU time, in seconds, used by a process. CPU = RLIMIT_CPU, // Maximum size of data segment of the process, in bytes. DATA = RLIMIT_DATA, // Maximum size of a file, in bytes, that may be created by a process. FSIZE = RLIMIT_FSIZE, // A number one greater than the maximum value that the system may assign to a newly-created descriptor. NOFILE = RLIMIT_NOFILE, // The maximum size of the initial thread's stack, in bytes. STACK = RLIMIT_STACK, // Maximum size of total available memory of the process, in bytes. AS = RLIMIT_AS, }Source

SA_Flags_Bits

SA_Flags_Bits :: enum c.int { // Do not generate SIGCHLD when children stop or stopped children continue. NOCLDSTOP = log2(SA_NOCLDSTOP), // Cause signal delivery to occur on an alternate stack. ONSTACK = log2(SA_ONSTACK), // Cause signal disposition to be set to SIG_DFL on entry to signal handlers. RESETHAND = log2(SA_RESETHAND), // Cause certain functions to become restartable. RESTART = log2(SA_RESTART), // Cause extra information to be passed to signal handlers at the time of receipt of a signal. SIGINFO = log2(SA_SIGINFO), // Cause implementation not to create zombie processes or status information on child termination. NOCLDWAIT = log2(SA_NOCLDWAIT), // Cause signal not to be automatically blocked on entry to signal handler. SA_NODEFER = log2(SA_NODEFER), }Source

SC

SC :: enum c.int { _2_C_BIND = _SC_2_C_BIND, _2_C_DEV = _SC_2_C_DEV, _2_CHAR_TERM = _SC_2_CHAR_TERM, _2_FORT_DEV = _SC_2_FORT_DEV, _2_FORT_RUN = _SC_2_FORT_RUN, _2_LOCALEDEF = _SC_2_LOCALEDEF, _2_PBS = _SC_2_PBS, _2_PBS_ACCOUNTING = _SC_2_PBS_ACCOUNTING, _2_PBS_CHECKPOINT = _SC_2_PBS_CHECKPOINT, _2_PBS_LOCATE = _SC_2_PBS_LOCATE, _2_PBS_MESSAGE = _SC_2_PBS_MESSAGE, _2_PBS_TRACK = _SC_2_PBS_TRACK, _2_SW_DEV = _SC_2_SW_DEV, _2_UPE = _SC_2_UPE, _2_VERSION = _SC_2_VERSION, _ADVISORY_INFO = _SC_ADVISORY_INFO, _AIO_LISTIO_MAX = _SC_AIO_LISTIO_MAX, _AIO_MAX = _SC_AIO_MAX, _AIO_PRIO_DELTA_MAX = _SC_AIO_PRIO_DELTA_MAX, _ARG_MAX = _SC_ARG_MAX, _ASYNCHRONOUS_IO = _SC_ASYNCHRONOUS_IO, _ATEXIT_MAX = _SC_ATEXIT_MAX, _BARRIERS = _SC_BARRIERS, _BC_BASE_MAX = _SC_BC_BASE_MAX, _BC_DIM_MAX = _SC_BC_DIM_MAX, _BC_SCALE_MAX = _SC_BC_SCALE_MAX, _BC_STRING_MAX = _SC_BC_STRING_MAX, _CHILD_MAX = _SC_CHILD_MAX, _CLK_TCK = _SC_CLK_TCK, _CLOCK_SELECTION = _SC_CLOCK_SELECTION, _COLL_WEIGHTS_MAX = _SC_COLL_WEIGHTS_MAX, _CPUTIME = _SC_CPUTIME, _DELAYTIMER_MAX = _SC_DELAYTIMER_MAX, _EXPR_NEST_MAX = _SC_EXPR_NEST_MAX, _FSYNC = _SC_FSYNC, _GETGR_R_SIZE_MAX = _SC_GETGR_R_SIZE_MAX, _GETPW_R_SIZE_MAX = _SC_GETPW_R_SIZE_MAX, _HOST_NAME_MAX = _SC_HOST_NAME_MAX, _IOV_MAX = _SC_IOV_MAX, _IPV6 = _SC_IPV6, _JOB_CONTROL = _SC_JOB_CONTROL, _LINE_MAX = _SC_LINE_MAX, _LOGIN_NAME_MAX = _SC_LOGIN_NAME_MAX, _MAPPED_FILES = _SC_MAPPED_FILES, _MEMLOCK = _SC_MEMLOCK, _MEMLOCK_RANGE = _SC_MEMLOCK_RANGE, _MEMORY_PROTECTION = _SC_MEMORY_PROTECTION, _MESSAGE_PASSING = _SC_MESSAGE_PASSING, _MONOTONIC_CLOCK = _SC_MONOTONIC_CLOCK, _MQ_OPEN_MAX = _SC_MQ_OPEN_MAX, _MQ_PRIO_MAX = _SC_MQ_PRIO_MAX, _NGROUPS_MAX = _SC_NGROUPS_MAX, _OPEN_MAX = _SC_OPEN_MAX, _PAGE_SIZE = _SC_PAGE_SIZE, _PAGESIZE = _SC_PAGESIZE, _PRIORITIZED_IO = _SC_PRIORITIZED_IO, _PRIORITY_SCHEDULING = _SC_PRIORITY_SCHEDULING, _RAW_SOCKETS = _SC_RAW_SOCKETS, _RE_DUP_MAX = _SC_RE_DUP_MAX, _READER_WRITER_LOCKS = _SC_READER_WRITER_LOCKS, _REALTIME_SIGNALS = _SC_REALTIME_SIGNALS, _REGEXP = _SC_REGEXP, _RTSIG_MAX = _SC_RTSIG_MAX, _SAVED_IDS = _SC_SAVED_IDS, _SEM_NSEMS_MAX = _SC_SEM_NSEMS_MAX, _SEM_VALUE_MAX = _SC_SEM_VALUE_MAX, _SEMAPHORES = _SC_SEMAPHORES, _SHARED_MEMORY_OBJECTS = _SC_SHARED_MEMORY_OBJECTS, _SHELL = _SC_SHELL, _SIGQUEUE_MAX = _SC_SIGQUEUE_MAX, _SPAWN = _SC_SPAWN, _SPIN_LOCKS = _SC_SPIN_LOCKS, _SPORADIC_SERVER = _SC_SPORADIC_SERVER, _SS_REPL_MAX = _SC_SS_REPL_MAX, _STREAM_MAX = _SC_STREAM_MAX, _SYMLOOP_MAX = _SC_SYMLOOP_MAX, _SYNCHRONIZED_IO = _SC_SYNCHRONIZED_IO, _THREAD_ATTR_STACKADDR = _SC_THREAD_ATTR_STACKADDR, _THREAD_ATTR_STACKSIZE = _SC_THREAD_ATTR_STACKSIZE, _THREAD_CPUTIME = _SC_THREAD_CPUTIME, _THREAD_DESTRUCTOR_ITERATIONS = _SC_THREAD_DESTRUCTOR_ITERATIONS, _THREAD_KEYS_MAX = _SC_THREAD_KEYS_MAX, _THREAD_PRIO_INHERIT = _SC_THREAD_PRIO_INHERIT, _THREAD_PRIO_PROTECT = _SC_THREAD_PRIO_PROTECT, _THREAD_PRIORITY_SCHEDULING = _SC_THREAD_PRIORITY_SCHEDULING, _THREAD_PROCESS_SHARED = _SC_THREAD_PROCESS_SHARED, _THREAD_SAFE_FUNCTIONS = _SC_THREAD_SAFE_FUNCTIONS, _THREAD_SPORADIC_SERVER = _SC_THREAD_SPORADIC_SERVER, _THREAD_STACK_MIN = _SC_THREAD_STACK_MIN, _THREAD_THREADS_MAX = _SC_THREAD_THREADS_MAX, _THREADS = _SC_THREADS, _TIMEOUTS = _SC_TIMEOUTS, _TIMER_MAX = _SC_TIMER_MAX, _TIMERS = _SC_TIMERS, _TRACE = _SC_TRACE, _TRACE_EVENT_FILTER = _SC_TRACE_EVENT_FILTER, _TRACE_EVENT_NAME_MAX = _SC_TRACE_EVENT_NAME_MAX, _TRACE_INHERIT = _SC_TRACE_INHERIT, _TRACE_LOG = _SC_TRACE_LOG, _TRACE_NAME_MAX = _SC_TRACE_NAME_MAX, _TRACE_SYS_MAX = _SC_TRACE_SYS_MAX, _TRACE_USER_EVENT_MAX = _SC_TRACE_USER_EVENT_MAX, _TTY_NAME_MAX = _SC_TTY_NAME_MAX, _TYPED_MEMORY_OBJECTS = _SC_TYPED_MEMORY_OBJECTS, _TZNAME_MAX = _SC_TZNAME_MAX, _V6_ILP32_OFF32 = _SC_V6_ILP32_OFF32, _V6_ILP32_OFFBIG = _SC_V6_ILP32_OFFBIG, _V6_LP64_OFF64 = _SC_V6_LP64_OFF64, _V6_LPBIG_OFFBIG = _SC_V6_LPBIG_OFFBIG, _VERSION = _SC_VERSION, _XOPEN_CRYPT = _SC_XOPEN_CRYPT, _XOPEN_ENH_I18N = _SC_XOPEN_ENH_I18N, _XOPEN_REALTIME = _SC_XOPEN_REALTIME, _XOPEN_REALTIME_THREADS = _SC_XOPEN_REALTIME_THREADS, _XOPEN_SHM = _SC_XOPEN_SHM, _XOPEN_STREAMS = _SC_XOPEN_STREAMS, _XOPEN_UNIX = _SC_XOPEN_UNIX, _XOPEN_VERSION = _SC_XOPEN_VERSION, }Source

SEGV_Code

SEGV_Code :: enum c.int { // Address not mapped to object. MAPERR = SEGV_MAPERR, // Invalid permissions for mapped object. ACCERR = SEGV_ACCERR, }Source

SS_Flag_Bits

SS_Flag_Bits :: enum c.int { // Process is executing on an alternate signal stack. ONSTACK = log2(SS_ONSTACK), // Alternate signal stack is disabled. DISABLE = log2(SS_DISABLE), }Source

Sched_Policy

Sched_Policy :: enum c.int { // Error condition of sched_getscheduler. ERROR = -1, // First in-first out (FIFO) scheduling policy. FIFO = SCHED_FIFO, // Round robin scheduling policy. RR = SCHED_RR, // Another scheduling policy. OTHER = SCHED_OTHER, }Source

Sem_Cmd

Sem_Cmd :: enum c.int { RMID = IPC_RMID, SET = IPC_SET, STAT = IPC_STAT, // Returns the value of semncnt. GETNCNT = GETNCNT, // Returns the value of sempid. GETPID = GETPID, // Return the value of semval. GETVAL = GETVAL, // Returns the value of semval for each semaphore in the semaphore set. GETALL = GETALL, // Returns the value of semzcnt. GETZCNT = GETZCNT, // Sets the value of semval to arg.val. SETVAL = SETVAL, // Sets the value of semval for each semaphore in the set. SETALL = SETALL, }Source

Shut

Shut :: enum c.int { // Disables further receive operations. RD = SHUT_RD, // Disables further send and receive operations. RDWR = SHUT_RDWR, // Disables further send operations. WR = SHUT_WR, }Source

Sig

Sig :: enum c.int { // Resulting set is the union of the current set and the signal set and the complement of // the signal set pointed to by the argument. BLOCK = SIG_BLOCK, // Resulting set is the intersection of the current set and the complement of the signal set // pointed to by the argument. UNBLOCK = SIG_UNBLOCK, // Resulting set is the signal set pointed to by the argument. SETMASK = SIG_SETMASK, }Source

Signal

Signal :: enum c.int { NONE = 0, // LIBC: // Process abort signal. SIGABRT = SIGABRT, // Erronous arithemtic operation. SIGFPE = SIGFPE, // Illegal instruction. SIGILL = SIGILL, // Terminal interrupt signal. SIGINT = SIGINT, // Invalid memory reference. SIGSEGV = SIGSEGV, // Termination signal. SIGTERM = SIGTERM, // POSIX: // Process abort signal. SIGALRM = SIGALRM, // Access to an undefined portion of a memory object. SIGBUS = SIGBUS, // Child process terminated, stopped, or continued. SIGCHLD = SIGCHLD, // Continue execution, if stopped. SIGCONT = SIGCONT, // Hangup. SIGHUP = SIGHUP, // Kill (cannot be caught or ignored). SIGKILL = SIGKILL, // Write on a pipe with no one to read it. SIGPIPE = SIGPIPE, // Terminal quit signal. SIGQUIT = SIGQUIT, // Stop executing (cannot be caught or ignored). SIGSTOP = SIGSTOP, // Terminal stop process. SIGTSTP = SIGTSTP, // Background process attempting read. SIGTTIN = SIGTTIN, // Background process attempting write. SIGTTOU = SIGTTOU, // User-defined signal 1. SIGUSR1 = SIGUSR1, // User-defined signal 2. SIGUSR2 = SIGUSR2, // Pollable event. SIGPOLL = SIGPOLL, // Profiling timer expired. SIGPROF = SIGPROF, // Bad system call. SIGSYS = SIGSYS, // Trace/breakpoint trap. SIGTRAP = SIGTRAP, // High bandwidth data is available at a socket. SIGURG = SIGURG, // Virtual timer expired. SIGVTALRM = SIGVTALRM, // CPU time limit exceeded. SIGXCPU = SIGXCPU, // File size limit exceeded. SIGXFSZ = SIGXFSZ, }Source

Sock

Sock :: enum c.int { // Datagram socket. DGRAM = SOCK_DGRAM, // Raw Protocol Interface. RAW = SOCK_RAW, // Sequenced-packet socket. SEQPACKET = SOCK_SEQPACKET, // Byte-stream socket. STREAM = SOCK_STREAM, }Source

Sock_Option

Sock_Option :: enum c.int { // Transmission of broadcast message is supported. BROADCAST = SO_BROADCAST, // Debugging information is being recorded. DEBUG = SO_DEBUG, // Bypass normal routing. DONTROUTE = SO_DONTROUTE, // Socket error status. ERROR = SO_ERROR, // Connections are kept alive with periodic messages. KEEPALIVE = SO_KEEPALIVE, // Socket lingers on close. LINGER = SO_LINGER, // Out-of-band data is transmitted in line. OOBINLINE = SO_OOBINLINE, // Receive buffer size. RCVBUF = SO_RCVBUF, // Receive low water mark. RCVLOWAT = SO_RCVLOWAT, // Receive timeout. RCVTIMEO = SO_RCVTIMEO, // Reuse of local addresses is supported. REUSEADDR = SO_REUSEADDR, // Send buffer size. SNDBUF = SO_SNDBUF, // Send low water mark. SNDLOWAT = SO_SNDLOWAT, // Send timeout. SNDTIMEO = SO_SNDTIMEO, // Socket type. TYPE = SO_TYPE, }Source

Sync_Flags_Bits

Sync_Flags_Bits :: enum c.int { // Perform asynchronous writes. ASYNC = log2(MS_ASYNC), // Invalidate cached data. INVALIDATE = log2(MS_INVALIDATE), // Perform synchronous writes. // NOTE: use with `posix.MS_SYNC + { .OTHER_FLAG, .OTHER_FLAG }`, unfortunately can't be in // this bit set enum because it is 0 on some platforms and a value on others. // LOCAL = RTLD_LOCAL // SYNC = MS_SYNC, _MAX = 31, }Source

Thread_Scope

Thread_Scope :: enum c.int { // System scheduling contention scope. SYSTEM = PTHREAD_SCOPE_SYSTEM, // Process scheduling contention scope. PROCESS = PTHREAD_SCOPE_PROCESS, }Source

Ulimit_Cmd

Ulimit_Cmd :: enum c.int { // Returns the file size limit of the process in units of 512-byte blocks inherited by children. GETFSIZE = UL_GETFSIZE, // Set the file size limit for output operations, taken as a long, multiplied by 512. SETFSIZE = UL_SETFSIZE, }Source

VFS_Flag_Bits

VFS_Flag_Bits :: enum c.ulong { // Read-only file system. RDONLY = log2(ST_RDONLY), // Does not support the semantics of the ST_ISUID and ST_ISGID file mode bits. NOSUID = log2(ST_NOSUID), }Source

WRDE_Errno

WRDE_Errno :: enum c.int { OK = 0, // One of the unquoted characters- <newline>, '|', '&', ';', '<', '>', '(', ')', '{', '}' - // appears in words in an inappropriate context. BADCHAR = WRDE_BADCHAR, // Reference to undefined shell variable when WRDE_UNDEF is set in flags. BADVAL = WRDE_BADVAL, // Command substitution requested when WRDE_NOCMD was set in flags. CMDSUB = WRDE_CMDSUB, // Attempt to allocate memory failed. NOSPACE = WRDE_NOSPACE, // Shell syntax error, such as unbalanced parentheses or an unterminated string. SYNTAX = WRDE_SYNTAX, }Source

WRDE_Flag_Bits

WRDE_Flag_Bits :: enum c.int { // Appends words to those previously generated. APPEND = log2(WRDE_APPEND), // Number of null pointers to prepend to we_wordv. DOOFFS = log2(WRDE_DOOFFS), // Fail if command substitution is requested. NOCMD = log2(WRDE_NOCMD), // The pwordexp argument was passed to a previous successful call to wordexp(), // and has not been passed to wordfree(). REUSE = log2(WRDE_REUSE), // Do not redirect stderr to /dev/null. SHOWERR = log2(WRDE_SHOWERR), // Report error on attempt to expand an undefined shell variable. UNDEF = log2(WRDE_UNDEF), }Source

Wait_Flag_Bits

Wait_Flag_Bits :: enum c.int { // Report the status of any continued child process specified by pid whose status has not been // reported since it continued from a job control stop. CONTINUED = log2(WCONTINUED), // Don't suspend execution of the calling thread if status is not immediately available for one // of the child processes specified by pid. NOHANG = log2(WNOHANG), // The status of any child process specified by pid that are stopped, and whose status has not // yet been reported since they stopped, shall also be reported to the requesting process. UNTRACED = log2(WUNTRACED), // Following are only available on `waitid`, not `waitpid`. // Wait for processes that have exited. EXITED = log2(WEXITED), // Keep the process whose status is returned in a waitable state, so it may be waited on again. NOWAIT = log2(WNOWAIT), // Children that have stopped upon receipt of a signal, and whose status either hasn't been reported // or has been reported but that report was called with NOWAIT. STOPPED = log2(WSTOPPED), }Source

idtype_t

idtype_t :: enum c.int { // Wait for any children and `id` is ignored. P_ALL = _P_ALL, // Wait for any child wiith a process group ID equal to `id`. P_PID = _P_PID, // Wait for any child with a process group ID equal to `id`. P_PGID = _P_PGID, }Source

nl_item

nl_item :: enum nl_item_t { CODESET = CODESET, D_T_FMT = D_T_FMT, D_FMT = D_FMT, T_FMT = T_FMT, T_FMT_AMPM = T_FMT_AMPM, AM_STR = AM_STR, PM_STR = PM_STR, DAY_1 = DAY_1, DAY_2 = DAY_2, DAY_3 = DAY_3, DAY_4 = DAY_4, DAY_5 = DAY_5, DAY_6 = DAY_6, DAY_7 = DAY_7, ABDAY_1 = ABDAY_1, ABDAY_2 = ABDAY_2, ABDAY_3 = ABDAY_3, ABDAY_4 = ABDAY_4, ABDAY_5 = ABDAY_5, ABDAY_6 = ABDAY_6, ABDAY_7 = ABDAY_7, MON_1 = MON_1, MON_2 = MON_2, MON_3 = MON_3, MON_4 = MON_4, MON_5 = MON_5, MON_6 = MON_6, MON_7 = MON_7, MON_8 = MON_8, MON_9 = MON_9, MON_10 = MON_10, MON_11 = MON_11, MON_12 = MON_12, ABMON_1 = ABMON_1, ABMON_2 = ABMON_2, ABMON_3 = ABMON_3, ABMON_4 = ABMON_4, ABMON_5 = ABMON_5, ABMON_6 = ABMON_6, ABMON_7 = ABMON_7, ABMON_8 = ABMON_8, ABMON_9 = ABMON_9, ABMON_10 = ABMON_10, ABMON_11 = ABMON_11, ABMON_12 = ABMON_12, ERA = ERA, ERA_D_FMT = ERA_D_FMT, ERA_D_T_FMT = ERA_D_T_FMT, ERA_T_FMT = ERA_T_FMT, ALT_DIGITS = ALT_DIGITS, RADIXCHAR = RADIXCHAR, THOUSEP = THOUSEP, YESEXPR = YESEXPR, NOEXPR = NOEXPR, CRNCYSTR = CRNCYSTR, }Source

result

result :: enum c.int { // Use `errno` and `strerror` for more information. FAIL = -1, // Operation succeeded. OK = 0, }Source

sa_family_t

sa_family_t :: enum _sa_family_t { // Unspecified. UNSPEC = AF_UNSPEC, // Internet domain sockets for use with IPv4 addresses. INET = AF_INET, // Internet domain sockets for use with IPv6 addresses. INET6 = AF_INET6, // UNIX domain sockets. UNIX = AF_UNIX, }Source

speed_t

speed_t :: enum _speed_t { B0 = B0, B50 = B50, B75 = B75, B110 = B110, B134 = B134, B150 = B150, B200 = B200, B300 = B300, B600 = B600, B1200 = B1200, B1800 = B1800, B2400 = B2400, B4800 = B4800, B9600 = B9600, B19200 = B19200, B38400 = B38400, }Source

Constants

225

_POSIX_AIO_LISTIO_MAX

_POSIX_AIO_LISTIO_MAX :: 2Source

The <limits.h> header shall define the following symbolic constants with the values shown. These are the most restrictive values for certain features on an implementation conforming to this volume of POSIX.1-2017. Related symbolic constants are defined elsewhere in this volume of POSIX.1-2017 which reflect the actual implementation and which need not be as restrictive. For each of these limits, a conforming implementation shall provide a value at least this large or shall have no limit. A strictly conforming application must not require a larger value for correct operation.

_POSIX_CLOCKRES_MIN

_POSIX_CLOCKRES_MIN :: 20000000Source

limits.h - implementation-defined constants NOTE: numerical limits are left out because Odin provides min(T) and max(T). The <limits.h> header shall define the following symbolic constants with the values shown. These are the most restrictive values for certain features on an implementation. A conforming implementation shall provide values no larger than these values. A conforming application must not require a smaller value for correct operation.

Variables

3

Procedures

19

Procedure Groups

1

Reference search

Find anything

Documentation preferences

Settings

System theme variants

Used only while Theme is set to System.