posix

Donate 来源:Nim 浏览 63 扫码分享 2024-07-11 21:47:52

Types
Vars
Consts
Procs
Templates

This is a raw POSIX interface module. It does not not provide any convenience: cstrings are used instead of proper Nim strings and return codes indicate errors. If you want exceptions and a proper Nim-like interface, use the OS module or write a wrapper.

For high-level wrappers specialized for Linux and BSDs see: posix_utils

Coding conventions: ALL types are named the same as in the POSIX standard except that they start with ‘T’ or ‘P’ (if they are pointers) and without the ‘_t’ suffix to be consistent with Nim conventions. If an identifier is a Nim keyword the `identifier` notation is used.

This library relies on the header files of your C compiler. The resulting C code will just #include <XYZ.h> and not define the symbols declared here.

Types

AddrInfo {.importc: "struct addrinfo", pure, final, header: "<netdb.h>".} = object
  ai_flags*: cint            ## Input flags.
  ai_family*: cint           ## Address family of socket.
  ai_socktype*: cint         ## Socket type.
  ai_protocol*: cint         ## Protocol of socket.
  ai_addrlen*: SockLen       ## Length of socket address.
  ai_addr*: ptr SockAddr     ## Socket address of socket.
  ai_canonname*: cstring     ## Canonical name of service location.
  ai_next*: ptr AddrInfo     ## Pointer to next in list.

struct addrinfo Source Edit

Blkcnt {.importc: "blkcnt_t", header: "<sys/types.h>".} = int

used for file block counts Source Edit

Blksize {.importc: "blksize_t", header: "<sys/types.h>".} = int

used for block sizes Source Edit

Clock {.importc: "clock_t", header: "<sys/types.h>".} = int

ClockId {.importc: "clockid_t", header: "<sys/types.h>".} = int

Dev {.importc: "dev_t", header: "<sys/types.h>".} = int

DIR {.importc: "DIR", header: "<dirent.h>", incompleteStruct.} = object

A type representing a directory stream. Source Edit

Dirent {.importc: "struct dirent", header: "<dirent.h>", final, pure.} = object
  when defined(haiku):
    d_dev*: Dev              ## Device (not POSIX)
    d_pdev*: Dev             ## Parent device (only for queries) (not POSIX)
  d_ino*: Ino                ## File serial number.
  when defined(dragonfly):
    d_type*: uint8
  elif defined(linux) or defined(macosx) or defined(freebsd) or defined(netbsd) or
      defined(openbsd) or
      defined(genode):
    d_reclen*: cshort        ## Length of this record. (not POSIX)
    d_type*: int8 ## Type of file; not supported by all filesystem types.
                  ## (not POSIX)
    when defined(linux) or defined(openbsd):
      d_off*: Off            ## Not an offset. Value that `telldir()` would return.
  elif defined(haiku):
    d_pino*: Ino             ## Parent inode (only for queries) (not POSIX)
    d_reclen*: cushort       ## Length of this record. (not POSIX)
  d_name*: array[0 .. 255, char] ## Name of entry.

dirent_t struct Source Edit

Fsblkcnt {.importc: "fsblkcnt_t", header: "<sys/types.h>".} = int

Fsfilcnt {.importc: "fsfilcnt_t", header: "<sys/types.h>".} = int

FTW {.importc: "struct FTW", header: "<ftw.h>", final, pure.} = object
  base*: cint
  level*: cint

Gid {.importc: "gid_t", header: "<sys/types.h>".} = int

Glob {.importc: "glob_t", header: "<glob.h>", final, pure.} = object
  gl_pathc*: int             ## Count of paths matched by pattern.
  gl_pathv*: cstringArray    ## Pointer to a list of matched pathnames.
  gl_offs*: int              ## Slots to reserve at the beginning of gl_pathv.

glob_t Source Edit

Group {.importc: "struct group", header: "<grp.h>", final, pure.} = object
  gr_name*: cstring          ## The name of the group.
  gr_gid*: Gid               ## Numerical group ID.
  gr_mem*: cstringArray      ## Pointer to a null-terminated array of character
                             ## pointers to member names.

struct group Source Edit

Hostent {.importc: "struct hostent", pure, final, header: "<netdb.h>".} = object
  h_name*: cstring           ## Official name of the host.
  h_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative host names, terminated by a
                             ## null pointer.
  h_addrtype*: cint          ## Address type.
  h_length*: cint            ## The length, in bytes, of the address.
  h_addr_list*: cstringArray ## A pointer to an array of pointers to network
                             ## addresses (in network byte order) for the
                             ## host, terminated by a null pointer.

struct hostent Source Edit

Iconv {.importc: "iconv_t", header: "<iconv.h>", final, pure.} = object

Identifies the conversion from one codeset to another. Source Edit

Id {.importc: "id_t", header: "<sys/types.h>".} = int

In6Addr {.importc: "struct in6_addr", pure, final, header: "<netinet/in.h>".} = object
  s6_addr*: array[0 .. 15, char]

struct in6_addr Source Edit

InAddr {.importc: "struct in_addr", pure, final, header: "<netinet/in.h>".} = object
  s_addr*: InAddrScalar

struct in_addr Source Edit

InAddrScalar = uint32

InAddrT {.importc: "in_addr_t", pure, final, header: "<netinet/in.h>".} = uint32

Ino {.importc: "ino_t", header: "<sys/types.h>".} = int

InPort = uint16

IOVec {.importc: "struct iovec", pure, final, header: "<sys/uio.h>".} = object
  iov_base*: pointer         ## Base address of a memory region for input or output.
  iov_len*: csize_t          ## The size of the memory pointed to by iov_base.

struct iovec Source Edit

Ipc_perm {.importc: "struct ipc_perm", header: "<sys/ipc.h>", final, pure.} = object
  uid*: Uid                  ## Owner's user ID.
  gid*: Gid                  ## Owner's group ID.
  cuid*: Uid                 ## Creator's user ID.
  cgid*: Gid                 ## Creator's group ID.
  mode*: Mode                ## Read/write permission.

struct ipc_perm Source Edit

Itimerspec {.importc: "struct itimerspec", header: "<time.h>", final, pure.} = object
  it_interval*: Timespec     ## Timer period.
  it_value*: Timespec        ## Timer expiration.

struct itimerspec Source Edit

Key {.importc: "key_t", header: "<sys/types.h>".} = int

Lconv {.importc: "struct lconv", header: "<locale.h>", final, pure.} = object
  currency_symbol*: cstring
  decimal_point*: cstring
  frac_digits*: char
  grouping*: cstring
  int_curr_symbol*: cstring
  int_frac_digits*: char
  int_n_cs_precedes*: char
  int_n_sep_by_space*: char
  int_n_sign_posn*: char
  int_p_cs_precedes*: char
  int_p_sep_by_space*: char
  int_p_sign_posn*: char
  mon_decimal_point*: cstring
  mon_grouping*: cstring
  mon_thousands_sep*: cstring
  negative_sign*: cstring
  n_cs_precedes*: char
  n_sep_by_space*: char
  n_sign_posn*: char
  positive_sign*: cstring
  p_cs_precedes*: char
  p_sep_by_space*: char
  p_sign_posn*: char
  thousands_sep*: cstring

Mcontext {.importc: "mcontext_t", header: "<ucontext.h>", final, pure.} = object

Mode {.importc: "mode_t", header: "<sys/types.h>".} = (when false or false:
  uint16
 else:
  uint32)

MqAttr {.importc: "struct mq_attr", header: "<mqueue.h>", final, pure.} = object
  mq_flags*: int             ## Message queue flags.
  mq_maxmsg*: int            ## Maximum number of messages.
  mq_msgsize*: int           ## Maximum message size.
  mq_curmsgs*: int           ## Number of messages currently queued.

message queue attribute Source Edit

Mqd {.importc: "mqd_t", header: "<mqueue.h>", final, pure.} = object

Nl_catd {.importc: "nl_catd", header: "<nl_types.h>".} = cint

Nl_item {.importc: "nl_item", header: "<nl_types.h>".} = cint

Nlink {.importc: "nlink_t", header: "<sys/types.h>".} = int

Off {.importc: "off_t", header: "<sys/types.h>".} = int64

Passwd {.importc: "struct passwd", header: "<pwd.h>", final, pure.} = object
  pw_name*: cstring          ## User's login name.
  pw_uid*: Uid               ## Numerical user ID.
  pw_gid*: Gid               ## Numerical group ID.
  pw_dir*: cstring           ## Initial working directory.
  pw_shell*: cstring         ## Program to use as shell.

struct passwd Source Edit

Pid {.importc: "pid_t", header: "<sys/types.h>".} = int32

Posix_typed_mem_info {.importc: "struct posix_typed_mem_info",
                       header: "<sys/mman.h>", final, pure.} = object
  posix_tmi_length*: int

Protoent {.importc: "struct protoent", pure, final, header: "<netdb.h>".} = object
  p_name*: cstring           ## Official name of the protocol.
  p_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative protocol names, terminated by
                             ## a null pointer.
  p_proto*: cint             ## The protocol number.

struct protoent Source Edit

Pthread {.importc: "pthread_t", header: "<sys/types.h>".} = int

Pthread_attr {.importc: "pthread_attr_t", header: "<sys/types.h>".} = int

Pthread_barrier {.importc: "pthread_barrier_t", header: "<sys/types.h>".} = int

Pthread_barrierattr {.importc: "pthread_barrierattr_t", header: "<sys/types.h>".} = int

Pthread_cond {.importc: "pthread_cond_t", header: "<sys/types.h>".} = int

Pthread_condattr {.importc: "pthread_condattr_t", header: "<sys/types.h>".} = int

Pthread_key {.importc: "pthread_key_t", header: "<sys/types.h>".} = int

Pthread_mutex {.importc: "pthread_mutex_t", header: "<sys/types.h>".} = int

Pthread_mutexattr {.importc: "pthread_mutexattr_t", header: "<sys/types.h>".} = int

Pthread_once {.importc: "pthread_once_t", header: "<sys/types.h>".} = int

Pthread_rwlock {.importc: "pthread_rwlock_t", header: "<sys/types.h>".} = int

Pthread_rwlockattr {.importc: "pthread_rwlockattr_t", header: "<sys/types.h>".} = int

Pthread_spinlock {.importc: "pthread_spinlock_t", header: "<sys/types.h>".} = int

RLimit {.importc: "struct rlimit", header: "<sys/resource.h>", pure, final.} = object
  rlim_cur*: int
  rlim_max*: int

Rusage {.importc: "struct rusage", header: "<sys/resource.h>", bycopy.} = object
  ru_utime*, ru_stime*: Timeval
  ru_maxrss*, ru_ixrss*, ru_idrss*, ru_isrss*, ru_minflt*, ru_majflt*,
  ru_nswap*, ru_inblock*, ru_oublock*, ru_msgsnd*, ru_msgrcv*, ru_nsignals*,
  ru_nvcsw*, ru_nivcsw*: clong

Sched_param {.importc: "struct sched_param", header: "<sched.h>", final, pure.} = object
  sched_priority*: cint
  sched_ss_low_priority*: cint ## Low scheduling priority for
                               ## sporadic server.
  sched_ss_repl_period*: Timespec ## Replenishment period for
                                  ## sporadic server.
  sched_ss_init_budget*: Timespec ## Initial budget for sporadic server.
  sched_ss_max_repl*: cint   ## Maximum pending replenishments for
                             ## sporadic server.

struct sched_param Source Edit

Sem {.importc: "sem_t", header: "<semaphore.h>", final, pure.} = object

Servent {.importc: "struct servent", pure, final, header: "<netdb.h>".} = object
  s_name*: cstring           ## Official name of the service.
  s_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative service names, terminated by
                             ## a null pointer.
  s_port*: cint              ## The port number at which the service
                             ## resides, in network byte order.
  s_proto*: cstring          ## The name of the protocol to use when
                             ## contacting the service.

struct servent Source Edit

Sig_atomic {.importc: "sig_atomic_t", header: "<signal.h>".} = cint

Possibly volatile-qualified integer type of an object that can be accessed as an atomic entity, even in the presence of asynchronous interrupts. Source Edit

Sigaction {.importc: "struct sigaction", header: "<signal.h>", final, pure.} = object
  sa_handler*: proc (x: cint) {.noconv.} ## Pointer to a signal-catching
                                         ## function or one of the macros
                                         ## SIG_IGN or SIG_DFL.
  sa_mask*: Sigset           ## Set of signals to be blocked during execution of
                             ## the signal handling function.
  sa_flags*: cint            ## Special flags.
  sa_sigaction*: proc (x: cint; y: ptr SigInfo; z: pointer) {.noconv.}

struct sigaction Source Edit

SigEvent {.importc: "struct sigevent", header: "<signal.h>", final, pure.} = object
  sigev_notify*: cint        ## Notification type.
  sigev_signo*: cint         ## Signal number.
  sigev_value*: SigVal       ## Signal value.
  sigev_notify_function*: proc (x: SigVal) {.noconv.} ## Notification func.
  sigev_notify_attributes*: ptr Pthread_attr ## Notification attributes.

struct sigevent Source Edit

SigInfo {.importc: "siginfo_t", header: "<signal.h>", final, pure.} = object
  si_signo*: cint            ## Signal number.
  si_code*: cint             ## Signal code.
  si_errno*: cint            ## If non-zero, an errno value associated with
                             ## this signal, as defined in <errno.h>.
  si_pid*: Pid               ## Sending process ID.
  si_uid*: Uid               ## Real user ID of sending process.
  si_addr*: pointer          ## Address of faulting instruction.
  si_status*: cint           ## Exit value or signal.
  si_band*: int              ## Band event for SIGPOLL.
  si_value*: SigVal          ## Signal value.

siginfo_t Source Edit

Sigset {.importc: "sigset_t", header: "<signal.h>", final, pure.} = object

SigStack {.importc: "struct sigstack", header: "<signal.h>", final, pure.} = object
  ss_onstack*: cint          ## Non-zero when signal stack is in use.
  ss_sp*: pointer            ## Signal stack pointer.

struct sigstack Source Edit

SigVal {.importc: "union sigval", header: "<signal.h>", final, pure.} = object
  sival_ptr*: pointer        ## pointer signal value;
                             ## integer signal value not defined!

struct sigval Source Edit

SockAddr {.importc: "struct sockaddr", header: "<sys/socket.h>", pure, final.} = object
  sa_family*: TSa_Family     ## Address family.
  sa_data*: array[0 .. 255 - 2, char] ## Socket address (variable-length data).

struct sockaddr Source Edit

Sockaddr_in {.importc: "struct sockaddr_in", pure, final,
              header: "<netinet/in.h>".} = object
  sin_family*: TSa_Family    ## AF_INET.
  sin_port*: InPort          ## Port number.
  sin_addr*: InAddr          ## IP address.

struct sockaddr_in Source Edit

Sockaddr_in6 {.importc: "struct sockaddr_in6", pure, final,
               header: "<netinet/in.h>".} = object
  sin6_family*: TSa_Family   ## AF_INET6.
  sin6_port*: InPort         ## Port number.
  sin6_flowinfo*: int32      ## IPv6 traffic class and flow information.
  sin6_addr*: In6Addr        ## IPv6 address.
  sin6_scope_id*: int32      ## Set of interfaces for a scope.

struct sockaddr_in6 Source Edit

Sockaddr_storage {.importc: "struct sockaddr_storage", header: "<sys/socket.h>",
                   pure, final.} = object
  ss_family*: TSa_Family     ## Address family.

struct sockaddr_storage Source Edit

Sockaddr_un {.importc: "struct sockaddr_un", header: "<sys/un.h>", pure, final.} = object
  sun_family*: TSa_Family    ## Address family.
  sun_path*: array[0 .. 92 - 2, char] ## Socket path

struct sockaddr_un Source Edit

SocketHandle = distinct cint

SockLen {.importc: "socklen_t", header: "<sys/socket.h>".} = cuint

Stack {.importc: "stack_t", header: "<signal.h>", final, pure.} = object
  ss_sp*: pointer            ## Stack base or pointer.
  ss_size*: int              ## Stack size.
  ss_flags*: cint            ## Flags.

stack_t Source Edit

Stat {.importc: "struct stat", header: "<sys/stat.h>", final, pure.} = object
  st_dev*: Dev               ## Device ID of device containing file.
  st_ino*: Ino               ## File serial number.
  st_mode*: Mode             ## Mode of file (see below).
  st_nlink*: Nlink           ## Number of hard links to the file.
  st_uid*: Uid               ## User ID of file.
  st_gid*: Gid               ## Group ID of file.
  st_rdev*: Dev              ## Device ID (if file is character or block special).
  st_size*: Off              ## For regular files, the file size in bytes.
                             ## For symbolic links, the length in bytes of the
                             ## pathname contained in the symbolic link.
                             ## For a shared memory object, the length in bytes.
                             ## For a typed memory object, the length in bytes.
                             ## For other file types, the use of this field is
                             ## unspecified.
  when StatHasNanoseconds:
    st_atim*: Timespec       ## Time of last access.
    st_mtim*: Timespec       ## Time of last data modification.
    st_ctim*: Timespec       ## Time of last status change.
  else:
    st_atime*: Time          ## Time of last access.
    st_mtime*: Time          ## Time of last data modification.
    st_ctime*: Time          ## Time of last status change.
  st_blksize*: Blksize       ## A file system-specific preferred I/O block size
                             ## for this object. In some file system types, this
                             ## may vary from file to file.
  st_blocks*: Blkcnt         ## Number of blocks allocated for this object.

struct stat Source Edit

Statvfs {.importc: "struct statvfs", header: "<sys/statvfs.h>", final, pure.} = object
  f_bsize*: int              ## File system block size.
  f_frsize*: int             ## Fundamental file system block size.
  f_blocks*: Fsblkcnt        ## Total number of blocks on file system
                             ## in units of f_frsize.
  f_bfree*: Fsblkcnt         ## Total number of free blocks.
  f_bavail*: Fsblkcnt        ## Number of free blocks available to
                             ## non-privileged process.
  f_files*: Fsfilcnt         ## Total number of file serial numbers.
  f_ffree*: Fsfilcnt         ## Total number of free file serial numbers.
  f_favail*: Fsfilcnt        ## Number of file serial numbers available to
                             ## non-privileged process.
  f_fsid*: int               ## File system ID.
  f_flag*: int               ## Bit mask of f_flag values.
  f_namemax*: int            ## Maximum filename length.

struct statvfs Source Edit

Suseconds {.importc: "suseconds_t", header: "<sys/types.h>".} = int

Tcmsghdr {.importc: "struct cmsghdr", pure, final, header: "<sys/socket.h>".} = object
  cmsg_len*: SockLen         ## Data byte count, including the cmsghdr.
  cmsg_level*: cint          ## Originating protocol.
  cmsg_type*: cint           ## Protocol-specific type.

struct cmsghdr Source Edit

TFdSet {.importc: "fd_set", header: "<sys/select.h>", final, pure.} = object

Tflock {.importc: "struct flock", final, pure, header: "<fcntl.h>".} = object
  l_type*: cshort            ## Type of lock; F_RDLCK, F_WRLCK, F_UNLCK.
  l_whence*: cshort          ## Flag for starting offset.
  l_start*: Off              ## Relative offset in bytes.
  l_len*: Off                ## Size; if 0 then until EOF.
  l_pid*: Pid                ## Process ID of the process holding the lock;
                             ## returned with F_GETLK.

flock type Source Edit

Tif_nameindex {.importc: "struct if_nameindex", final, pure,
                header: "<net/if.h>".} = object
  if_index*: cint            ## Numeric index of the interface.
  if_name*: cstring          ## Null-terminated name of the interface.

struct if_nameindex Source Edit

Time {.importc: "time_t", header: "<time.h>".} = distinct (when defined(
    nimUse64BitCTime):
  int64
 else:
  clong)

Timer {.importc: "timer_t", header: "<sys/types.h>".} = int

Timespec {.importc: "struct timespec", header: "<time.h>", final, pure.} = object
  tv_sec*: Time              ## Seconds.
  tv_nsec*: int              ## Nanoseconds.

struct timespec Source Edit

Timeval {.importc: "struct timeval", header: "<sys/select.h>", final, pure.} = object
  tv_sec*: Time              ## Seconds.
  tv_usec*: Suseconds        ## Microseconds.

struct timeval Source Edit

Tipv6_mreq {.importc: "struct ipv6_mreq", pure, final, header: "<netinet/in.h>".} = object
  ipv6mr_multiaddr*: In6Addr ## IPv6 multicast address.
  ipv6mr_interface*: cint    ## Interface index.

struct ipv6_mreq Source Edit

TLinger {.importc: "struct linger", pure, final, header: "<sys/socket.h>".} = object
  l_onoff*: cint             ## Indicates whether linger option is enabled.
  l_linger*: cint            ## Linger time, in seconds.

struct linger Source Edit

Tm {.importc: "struct tm", header: "<time.h>", final, pure.} = object
  tm_sec*: cint              ## Seconds [0,60].
  tm_min*: cint              ## Minutes [0,59].
  tm_hour*: cint             ## Hour [0,23].
  tm_mday*: cint             ## Day of month [1,31].
  tm_mon*: cint              ## Month of year [0,11].
  tm_year*: cint             ## Years since 1900.
  tm_wday*: cint             ## Day of week [0,6] (Sunday =0).
  tm_yday*: cint             ## Day of year [0,365].
  tm_isdst*: cint            ## Daylight Savings flag.

struct tm Source Edit

Tmsghdr {.importc: "struct msghdr", pure, final, header: "<sys/socket.h>".} = object
  msg_name*: pointer         ## Optional address.
  msg_namelen*: SockLen      ## Size of address.
  msg_iov*: ptr IOVec        ## Scatter/gather array.
  msg_iovlen*: cint          ## Members in msg_iov.
  msg_control*: pointer      ## Ancillary data; see below.
  msg_controllen*: SockLen   ## Ancillary data buffer len.
  msg_flags*: cint           ## Flags on received message.

struct msghdr Source Edit

Tnetent {.importc: "struct netent", pure, final, header: "<netdb.h>".} = object
  n_name*: cstring           ## Official, fully-qualified (including the
                             ## domain) name of the host.
  n_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative network names, terminated by a
                             ## null pointer.
  n_addrtype*: cint          ## The address type of the network.
  n_net*: int32              ## The network number, in host byte order.

struct netent Source Edit

Tnfds {.importc: "nfds_t", header: "<poll.h>".} = culong

TPollfd {.importc: "struct pollfd", pure, final, header: "<poll.h>".} = object
  fd*: cint                  ## The following descriptor being polled.
  events*: cshort            ## The input event flags (see below).
  revents*: cshort           ## The output event flags (see below).

struct pollfd Source Edit

Tposix_spawn_file_actions {.importc: "posix_spawn_file_actions_t",
                            header: "<spawn.h>", final, pure.} = object

Tposix_spawnattr {.importc: "posix_spawnattr_t", header: "<spawn.h>", final,
                   pure.} = object

Trace_attr {.importc: "trace_attr_t", header: "<sys/types.h>".} = int

Trace_event_id {.importc: "trace_event_id_t", header: "<sys/types.h>".} = int

Trace_event_set {.importc: "trace_event_set_t", header: "<sys/types.h>".} = int

Trace_id {.importc: "trace_id_t", header: "<sys/types.h>".} = int

TSa_Family {.importc: "sa_family_t", header: "<sys/socket.h>".} = cushort

Ucontext {.importc: "ucontext_t", header: "<ucontext.h>", final, pure.} = object
  uc_link*: ptr Ucontext     ## Pointer to the context that is resumed
                             ## when this context returns.
  uc_sigmask*: Sigset        ## The set of signals that are blocked when this
                             ## context is active.
  uc_stack*: Stack           ## The stack used by this context.
  uc_mcontext*: Mcontext     ## A machine-specific representation of the saved
                             ## context.

ucontext_t Source Edit

Uid {.importc: "uid_t", header: "<sys/types.h>".} = int

Useconds {.importc: "useconds_t", header: "<sys/types.h>".} = int

Utsname {.importc: "struct utsname", header: "<sys/utsname.h>", final, pure.} = object
  sysname*,                 ## Name of the hardware type on which the
                             ## system is running.
  ## Name of this implementation of the operating system.
  nodename*,                ## Name of this node within the communications
                             ## network to which this node is attached, if any.
  release*,                 ## Current release level of this implementation.
  version*,                 ## Current version level of this release.
  machine*: array[0 .. 255, char]

struct utsname Source Edit

Vars

ABDAY_1 {.importc: "ABDAY_1", header: "<langinfo.h>".}: cint

ABDAY_2 {.importc: "ABDAY_2", header: "<langinfo.h>".}: cint

ABDAY_3 {.importc: "ABDAY_3", header: "<langinfo.h>".}: cint

ABDAY_4 {.importc: "ABDAY_4", header: "<langinfo.h>".}: cint

ABDAY_5 {.importc: "ABDAY_5", header: "<langinfo.h>".}: cint

ABDAY_6 {.importc: "ABDAY_6", header: "<langinfo.h>".}: cint

ABDAY_7 {.importc: "ABDAY_7", header: "<langinfo.h>".}: cint

ABMON_1 {.importc: "ABMON_1", header: "<langinfo.h>".}: cint

ABMON_2 {.importc: "ABMON_2", header: "<langinfo.h>".}: cint

ABMON_3 {.importc: "ABMON_3", header: "<langinfo.h>".}: cint

ABMON_4 {.importc: "ABMON_4", header: "<langinfo.h>".}: cint

ABMON_5 {.importc: "ABMON_5", header: "<langinfo.h>".}: cint

ABMON_6 {.importc: "ABMON_6", header: "<langinfo.h>".}: cint

ABMON_7 {.importc: "ABMON_7", header: "<langinfo.h>".}: cint

ABMON_8 {.importc: "ABMON_8", header: "<langinfo.h>".}: cint

ABMON_9 {.importc: "ABMON_9", header: "<langinfo.h>".}: cint

ABMON_10 {.importc: "ABMON_10", header: "<langinfo.h>".}: cint

ABMON_11 {.importc: "ABMON_11", header: "<langinfo.h>".}: cint

ABMON_12 {.importc: "ABMON_12", header: "<langinfo.h>".}: cint

AF_INET {.importc: "AF_INET", header: "<sys/socket.h>".}: cint

AF_INET6 {.importc: "AF_INET6", header: "<sys/socket.h>".}: cint

AF_UNIX {.importc: "AF_UNIX", header: "<sys/socket.h>".}: cint

AF_UNSPEC {.importc: "AF_UNSPEC", header: "<sys/socket.h>".}: cint

AI_ADDRCONFIG {.importc: "AI_ADDRCONFIG", header: "<netdb.h>".}: cint

AI_ALL {.importc: "AI_ALL", header: "<netdb.h>".}: cint

AI_CANONNAME {.importc: "AI_CANONNAME", header: "<netdb.h>".}: cint

AI_NUMERICHOST {.importc: "AI_NUMERICHOST", header: "<netdb.h>".}: cint

AI_NUMERICSERV {.importc: "AI_NUMERICSERV", header: "<netdb.h>".}: cint

AI_PASSIVE {.importc: "AI_PASSIVE", header: "<netdb.h>".}: cint

AI_V4MAPPED {.importc: "AI_V4MAPPED", header: "<netdb.h>".}: cint

AIO_ALLDONE {.importc: "AIO_ALLDONE", header: "<aio.h>".}: cint

AIO_CANCELED {.importc: "AIO_CANCELED", header: "<aio.h>".}: cint

AIO_NOTCANCELED {.importc: "AIO_NOTCANCELED", header: "<aio.h>".}: cint

ALT_DIGITS {.importc: "ALT_DIGITS", header: "<langinfo.h>".}: cint

AM_STR {.importc: "AM_STR", header: "<langinfo.h>".}: cint

CLOCK_MONOTONIC {.importc: "CLOCK_MONOTONIC", header: "<time.h>".}: cint

CLOCK_PROCESS_CPUTIME_ID {.importc: "CLOCK_PROCESS_CPUTIME_ID",
                           header: "<time.h>".}: cint

CLOCK_REALTIME {.importc: "CLOCK_REALTIME", header: "<time.h>".}: cint

CLOCK_THREAD_CPUTIME_ID {.importc: "CLOCK_THREAD_CPUTIME_ID", header: "<time.h>".}: cint

CLOCKS_PER_SEC {.importc: "CLOCKS_PER_SEC", header: "<time.h>".}: clong

CODESET {.importc: "CODESET", header: "<langinfo.h>".}: cint

CRNCYSTR {.importc: "CRNCYSTR", header: "<langinfo.h>".}: cint

CS_PATH {.importc: "_CS_PATH", header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFF32_CFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFF32_CFLAGS",
                                 header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFF32_LDFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFF32_LDFLAGS",
                                  header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFF32_LIBS {.importc: "_CS_POSIX_V6_ILP32_OFF32_LIBS",
                               header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFFBIG_CFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS",
                                  header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS",
                                   header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFFBIG_LIBS {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_LIBS",
                                header: "<unistd.h>".}: cint

CS_POSIX_V6_LP64_OFF64_CFLAGS {.importc: "_CS_POSIX_V6_LP64_OFF64_CFLAGS",
                                header: "<unistd.h>".}: cint

CS_POSIX_V6_LP64_OFF64_LDFLAGS {.importc: "_CS_POSIX_V6_LP64_OFF64_LDFLAGS",
                                 header: "<unistd.h>".}: cint

CS_POSIX_V6_LP64_OFF64_LIBS {.importc: "_CS_POSIX_V6_LP64_OFF64_LIBS",
                              header: "<unistd.h>".}: cint

CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS",
                                  header: "<unistd.h>".}: cint

CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS",
                                   header: "<unistd.h>".}: cint

CS_POSIX_V6_LPBIG_OFFBIG_LIBS {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LIBS",
                                header: "<unistd.h>".}: cint

CS_POSIX_V6_WIDTH_RESTRICTED_ENVS {.importc: "_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS",
                                    header: "<unistd.h>".}: cint

D_FMT {.importc: "D_FMT", header: "<langinfo.h>".}: cint

D_T_FMT {.importc: "D_T_FMT", header: "<langinfo.h>".}: cint

DAY_1 {.importc: "DAY_1", header: "<langinfo.h>".}: cint

DAY_2 {.importc: "DAY_2", header: "<langinfo.h>".}: cint

DAY_3 {.importc: "DAY_3", header: "<langinfo.h>".}: cint

DAY_4 {.importc: "DAY_4", header: "<langinfo.h>".}: cint

DAY_5 {.importc: "DAY_5", header: "<langinfo.h>".}: cint

DAY_6 {.importc: "DAY_6", header: "<langinfo.h>".}: cint

DAY_7 {.importc: "DAY_7", header: "<langinfo.h>".}: cint

daylight {.importc, header: "<time.h>".}: cint

E2BIG {.importc: "E2BIG", header: "<errno.h>".}: cint

EACCES {.importc: "EACCES", header: "<errno.h>".}: cint

EADDRINUSE {.importc: "EADDRINUSE", header: "<errno.h>".}: cint

EADDRNOTAVAIL {.importc: "EADDRNOTAVAIL", header: "<errno.h>".}: cint

EAFNOSUPPORT {.importc: "EAFNOSUPPORT", header: "<errno.h>".}: cint

EAGAIN {.importc: "EAGAIN", header: "<errno.h>".}: cint

EAI_AGAIN {.importc: "EAI_AGAIN", header: "<netdb.h>".}: cint

EAI_BADFLAGS {.importc: "EAI_BADFLAGS", header: "<netdb.h>".}: cint

EAI_FAIL {.importc: "EAI_FAIL", header: "<netdb.h>".}: cint

EAI_FAMILY {.importc: "EAI_FAMILY", header: "<netdb.h>".}: cint

EAI_MEMORY {.importc: "EAI_MEMORY", header: "<netdb.h>".}: cint

EAI_NONAME {.importc: "EAI_NONAME", header: "<netdb.h>".}: cint

EAI_OVERFLOW {.importc: "EAI_OVERFLOW", header: "<netdb.h>".}: cint

EAI_SERVICE {.importc: "EAI_SERVICE", header: "<netdb.h>".}: cint

EAI_SOCKTYPE {.importc: "EAI_SOCKTYPE", header: "<netdb.h>".}: cint

EAI_SYSTEM {.importc: "EAI_SYSTEM", header: "<netdb.h>".}: cint

EALREADY {.importc: "EALREADY", header: "<errno.h>".}: cint

EBADF {.importc: "EBADF", header: "<errno.h>".}: cint

EBADMSG {.importc: "EBADMSG", header: "<errno.h>".}: cint

EBUSY {.importc: "EBUSY", header: "<errno.h>".}: cint

ECANCELED {.importc: "ECANCELED", header: "<errno.h>".}: cint

ECHILD {.importc: "ECHILD", header: "<errno.h>".}: cint

ECONNABORTED {.importc: "ECONNABORTED", header: "<errno.h>".}: cint

ECONNREFUSED {.importc: "ECONNREFUSED", header: "<errno.h>".}: cint

ECONNRESET {.importc: "ECONNRESET", header: "<errno.h>".}: cint

EDEADLK {.importc: "EDEADLK", header: "<errno.h>".}: cint

EDESTADDRREQ {.importc: "EDESTADDRREQ", header: "<errno.h>".}: cint

EDOM {.importc: "EDOM", header: "<errno.h>".}: cint

EDQUOT {.importc: "EDQUOT", header: "<errno.h>".}: cint

EEXIST {.importc: "EEXIST", header: "<errno.h>".}: cint

EFAULT {.importc: "EFAULT", header: "<errno.h>".}: cint

EFBIG {.importc: "EFBIG", header: "<errno.h>".}: cint

EHOSTUNREACH {.importc: "EHOSTUNREACH", header: "<errno.h>".}: cint

EIDRM {.importc: "EIDRM", header: "<errno.h>".}: cint

EILSEQ {.importc: "EILSEQ", header: "<errno.h>".}: cint

EINPROGRESS {.importc: "EINPROGRESS", header: "<errno.h>".}: cint

EINTR {.importc: "EINTR", header: "<errno.h>".}: cint

EINVAL {.importc: "EINVAL", header: "<errno.h>".}: cint

EIO {.importc: "EIO", header: "<errno.h>".}: cint

EISCONN {.importc: "EISCONN", header: "<errno.h>".}: cint

EISDIR {.importc: "EISDIR", header: "<errno.h>".}: cint

ELOOP {.importc: "ELOOP", header: "<errno.h>".}: cint

EMFILE {.importc: "EMFILE", header: "<errno.h>".}: cint

EMLINK {.importc: "EMLINK", header: "<errno.h>".}: cint

EMSGSIZE {.importc: "EMSGSIZE", header: "<errno.h>".}: cint

EMULTIHOP {.importc: "EMULTIHOP", header: "<errno.h>".}: cint

ENAMETOOLONG {.importc: "ENAMETOOLONG", header: "<errno.h>".}: cint

ENETDOWN {.importc: "ENETDOWN", header: "<errno.h>".}: cint

ENETRESET {.importc: "ENETRESET", header: "<errno.h>".}: cint

ENETUNREACH {.importc: "ENETUNREACH", header: "<errno.h>".}: cint

ENFILE {.importc: "ENFILE", header: "<errno.h>".}: cint

ENOBUFS {.importc: "ENOBUFS", header: "<errno.h>".}: cint

ENODATA {.importc: "ENODATA", header: "<errno.h>".}: cint

ENODEV {.importc: "ENODEV", header: "<errno.h>".}: cint

ENOENT {.importc: "ENOENT", header: "<errno.h>".}: cint

ENOEXEC {.importc: "ENOEXEC", header: "<errno.h>".}: cint

ENOLCK {.importc: "ENOLCK", header: "<errno.h>".}: cint

ENOLINK {.importc: "ENOLINK", header: "<errno.h>".}: cint

ENOMEM {.importc: "ENOMEM", header: "<errno.h>".}: cint

ENOMSG {.importc: "ENOMSG", header: "<errno.h>".}: cint

ENOPROTOOPT {.importc: "ENOPROTOOPT", header: "<errno.h>".}: cint

ENOSPC {.importc: "ENOSPC", header: "<errno.h>".}: cint

ENOSR {.importc: "ENOSR", header: "<errno.h>".}: cint

ENOSTR {.importc: "ENOSTR", header: "<errno.h>".}: cint

ENOSYS {.importc: "ENOSYS", header: "<errno.h>".}: cint

ENOTCONN {.importc: "ENOTCONN", header: "<errno.h>".}: cint

ENOTDIR {.importc: "ENOTDIR", header: "<errno.h>".}: cint

ENOTEMPTY {.importc: "ENOTEMPTY", header: "<errno.h>".}: cint

ENOTSOCK {.importc: "ENOTSOCK", header: "<errno.h>".}: cint

ENOTSUP {.importc: "ENOTSUP", header: "<errno.h>".}: cint

ENOTTY {.importc: "ENOTTY", header: "<errno.h>".}: cint

ENXIO {.importc: "ENXIO", header: "<errno.h>".}: cint

EOPNOTSUPP {.importc: "EOPNOTSUPP", header: "<errno.h>".}: cint

EOVERFLOW {.importc: "EOVERFLOW", header: "<errno.h>".}: cint

EPERM {.importc: "EPERM", header: "<errno.h>".}: cint

EPIPE {.importc: "EPIPE", header: "<errno.h>".}: cint

EPROTO {.importc: "EPROTO", header: "<errno.h>".}: cint

EPROTONOSUPPORT {.importc: "EPROTONOSUPPORT", header: "<errno.h>".}: cint

EPROTOTYPE {.importc: "EPROTOTYPE", header: "<errno.h>".}: cint

ERA {.importc: "ERA", header: "<langinfo.h>".}: cint

ERA_D_FMT {.importc: "ERA_D_FMT", header: "<langinfo.h>".}: cint

ERA_D_T_FMT {.importc: "ERA_D_T_FMT", header: "<langinfo.h>".}: cint

ERA_T_FMT {.importc: "ERA_T_FMT", header: "<langinfo.h>".}: cint

ERANGE {.importc: "ERANGE", header: "<errno.h>".}: cint

EROFS {.importc: "EROFS", header: "<errno.h>".}: cint

errno {.importc, header: "<errno.h>".}: cint

error variable Source Edit

ESPIPE {.importc: "ESPIPE", header: "<errno.h>".}: cint

ESRCH {.importc: "ESRCH", header: "<errno.h>".}: cint

ESTALE {.importc: "ESTALE", header: "<errno.h>".}: cint

ETIME {.importc: "ETIME", header: "<errno.h>".}: cint

ETIMEDOUT {.importc: "ETIMEDOUT", header: "<errno.h>".}: cint

ETXTBSY {.importc: "ETXTBSY", header: "<errno.h>".}: cint

EWOULDBLOCK {.importc: "EWOULDBLOCK", header: "<errno.h>".}: cint

EXDEV {.importc: "EXDEV", header: "<errno.h>".}: cint

F_DUPFD {.importc: "F_DUPFD", header: "<fcntl.h>".}: cint

F_DUPFD_CLOEXEC {.importc: "F_DUPFD", header: "<fcntl.h>".}: cint

F_GETFD {.importc: "F_GETFD", header: "<fcntl.h>".}: cint

F_GETFL {.importc: "F_GETFL", header: "<fcntl.h>".}: cint

F_GETLK {.importc: "F_GETLK", header: "<fcntl.h>".}: cint

F_GETOWN {.importc: "F_GETOWN", header: "<fcntl.h>".}: cint

F_LOCK {.importc: "F_LOCK", header: "<unistd.h>".}: cint

F_OK {.importc: "F_OK", header: "<unistd.h>".}: cint

F_RDLCK {.importc: "F_RDLCK", header: "<fcntl.h>".}: cint

F_SETFD {.importc: "F_SETFD", header: "<fcntl.h>".}: cint

F_SETFL {.importc: "F_SETFL", header: "<fcntl.h>".}: cint

F_SETLK {.importc: "F_SETLK", header: "<fcntl.h>".}: cint

F_SETLKW {.importc: "F_SETLKW", header: "<fcntl.h>".}: cint

F_SETOWN {.importc: "F_SETOWN", header: "<fcntl.h>".}: cint

F_TEST {.importc: "F_TEST", header: "<unistd.h>".}: cint

F_TLOCK {.importc: "F_TLOCK", header: "<unistd.h>".}: cint

F_ULOCK {.importc: "F_ULOCK", header: "<unistd.h>".}: cint

F_UNLCK {.importc: "F_UNLCK", header: "<fcntl.h>".}: cint

F_WRLCK {.importc: "F_WRLCK", header: "<fcntl.h>".}: cint

FD_CLOEXEC {.importc: "FD_CLOEXEC", header: "<fcntl.h>".}: cint

FD_SETSIZE {.importc: "FD_SETSIZE", header: "<sys/select.h>".}: cint

FE_ALL_EXCEPT {.importc: "FE_ALL_EXCEPT", header: "<fenv.h>".}: cint

FE_DFL_ENV {.importc: "FE_DFL_ENV", header: "<fenv.h>".}: cint

FE_DIVBYZERO {.importc: "FE_DIVBYZERO", header: "<fenv.h>".}: cint

FE_DOWNWARD {.importc: "FE_DOWNWARD", header: "<fenv.h>".}: cint

FE_INEXACT {.importc: "FE_INEXACT", header: "<fenv.h>".}: cint

FE_INVALID {.importc: "FE_INVALID", header: "<fenv.h>".}: cint

FE_OVERFLOW {.importc: "FE_OVERFLOW", header: "<fenv.h>".}: cint

FE_TONEAREST {.importc: "FE_TONEAREST", header: "<fenv.h>".}: cint

FE_TOWARDZERO {.importc: "FE_TOWARDZERO", header: "<fenv.h>".}: cint

FE_UNDERFLOW {.importc: "FE_UNDERFLOW", header: "<fenv.h>".}: cint

FE_UPWARD {.importc: "FE_UPWARD", header: "<fenv.h>".}: cint

FNM_NOESCAPE {.importc: "FNM_NOESCAPE", header: "<fnmatch.h>".}: cint

FNM_NOMATCH {.importc: "FNM_NOMATCH", header: "<fnmatch.h>".}: cint

FNM_NOSYS {.importc: "FNM_NOSYS", header: "<fnmatch.h>".}: cint

FNM_PATHNAME {.importc: "FNM_PATHNAME", header: "<fnmatch.h>".}: cint

FNM_PERIOD {.importc: "FNM_PERIOD", header: "<fnmatch.h>".}: cint

FTW_CHDIR {.importc: "FTW_CHDIR", header: "<ftw.h>".}: cint

FTW_D {.importc: "FTW_D", header: "<ftw.h>".}: cint

FTW_DEPTH {.importc: "FTW_DEPTH", header: "<ftw.h>".}: cint

FTW_DNR {.importc: "FTW_DNR", header: "<ftw.h>".}: cint

FTW_DP {.importc: "FTW_DP", header: "<ftw.h>".}: cint

FTW_F {.importc: "FTW_F", header: "<ftw.h>".}: cint

FTW_MOUNT {.importc: "FTW_MOUNT", header: "<ftw.h>".}: cint

FTW_NS {.importc: "FTW_NS", header: "<ftw.h>".}: cint

FTW_PHYS {.importc: "FTW_PHYS", header: "<ftw.h>".}: cint

FTW_SL {.importc: "FTW_SL", header: "<ftw.h>".}: cint

FTW_SLN {.importc: "FTW_SLN", header: "<ftw.h>".}: cint

GLOB_ABORTED {.importc: "GLOB_ABORTED", header: "<glob.h>".}: cint

GLOB_APPEND {.importc: "GLOB_APPEND", header: "<glob.h>".}: cint

GLOB_DOOFFS {.importc: "GLOB_DOOFFS", header: "<glob.h>".}: cint

GLOB_ERR {.importc: "GLOB_ERR", header: "<glob.h>".}: cint

GLOB_MARK {.importc: "GLOB_MARK", header: "<glob.h>".}: cint

GLOB_NOCHECK {.importc: "GLOB_NOCHECK", header: "<glob.h>".}: cint

GLOB_NOESCAPE {.importc: "GLOB_NOESCAPE", header: "<glob.h>".}: cint

GLOB_NOMATCH {.importc: "GLOB_NOMATCH", header: "<glob.h>".}: cint

GLOB_NOSORT {.importc: "GLOB_NOSORT", header: "<glob.h>".}: cint

GLOB_NOSPACE {.importc: "GLOB_NOSPACE", header: "<glob.h>".}: cint

GLOB_NOSYS {.importc: "GLOB_NOSYS", header: "<glob.h>".}: cint

h_errno {.importc, header: "<netdb.h>".}: cint

HOST_NOT_FOUND {.importc: "HOST_NOT_FOUND", header: "<netdb.h>".}: cint

IF_NAMESIZE {.importc: "IF_NAMESIZE", header: "<net/if.h>".}: cint

in6addr_any {.importc, header: "<netinet/in.h>".}: In6Addr

in6addr_loopback {.importc, header: "<netinet/in.h>".}: In6Addr

INADDR_ANY {.importc: "INADDR_ANY", header: "<netinet/in.h>".}: InAddrScalar

INADDR_BROADCAST {.importc: "INADDR_BROADCAST", header: "<netinet/in.h>".}: InAddrScalar

INADDR_LOOPBACK {.importc: "INADDR_LOOPBACK", header: "<netinet/in.h>".}: InAddrScalar

INET6_ADDRSTRLEN {.importc: "INET6_ADDRSTRLEN", header: "<netinet/in.h>".}: cint

INET_ADDRSTRLEN {.importc: "INET_ADDRSTRLEN", header: "<netinet/in.h>".}: cint

IOFBF {.importc: "_IOFBF", header: "<stdio.h>".}: cint

IONBF {.importc: "_IONBF", header: "<stdio.h>".}: cint

IPC_CREAT {.importc: "IPC_CREAT", header: "<sys/ipc.h>".}: cint

IPC_EXCL {.importc: "IPC_EXCL", header: "<sys/ipc.h>".}: cint

IPC_NOWAIT {.importc: "IPC_NOWAIT", header: "<sys/ipc.h>".}: cint

IPC_PRIVATE {.importc: "IPC_PRIVATE", header: "<sys/ipc.h>".}: cint

IPC_RMID {.importc: "IPC_RMID", header: "<sys/ipc.h>".}: cint

IPC_SET {.importc: "IPC_SET", header: "<sys/ipc.h>".}: cint

IPC_STAT {.importc: "IPC_STAT", header: "<sys/ipc.h>".}: cint

IPPORT_RESERVED {.importc: "IPPORT_RESERVED", header: "<netdb.h>".}: cint

IPPROTO_ICMP {.importc: "IPPROTO_ICMP", header: "<netinet/in.h>".}: cint

IPPROTO_ICMPV6 {.importc: "IPPROTO_ICMPV6", header: "<netinet/in.h>".}: cint

IPPROTO_IP {.importc: "IPPROTO_IP", header: "<netinet/in.h>".}: cint

IPPROTO_IPV6 {.importc: "IPPROTO_IPV6", header: "<netinet/in.h>".}: cint

IPPROTO_RAW {.importc: "IPPROTO_RAW", header: "<netinet/in.h>".}: cint

IPPROTO_TCP {.importc: "IPPROTO_TCP", header: "<netinet/in.h>".}: cint

IPPROTO_UDP {.importc: "IPPROTO_UDP", header: "<netinet/in.h>".}: cint

IPV6_JOIN_GROUP {.importc: "IPV6_JOIN_GROUP", header: "<netinet/in.h>".}: cint

IPV6_LEAVE_GROUP {.importc: "IPV6_LEAVE_GROUP", header: "<netinet/in.h>".}: cint

IPV6_MULTICAST_HOPS {.importc: "IPV6_MULTICAST_HOPS", header: "<netinet/in.h>".}: cint

IPV6_MULTICAST_IF {.importc: "IPV6_MULTICAST_IF", header: "<netinet/in.h>".}: cint

IPV6_MULTICAST_LOOP {.importc: "IPV6_MULTICAST_LOOP", header: "<netinet/in.h>".}: cint

IPV6_UNICAST_HOPS {.importc: "IPV6_UNICAST_HOPS", header: "<netinet/in.h>".}: cint

IPV6_V6ONLY {.importc: "IPV6_V6ONLY", header: "<netinet/in.h>".}: cint

LC_ALL {.importc: "LC_ALL", header: "<locale.h>".}: cint

LC_COLLATE {.importc: "LC_COLLATE", header: "<locale.h>".}: cint

LC_CTYPE {.importc: "LC_CTYPE", header: "<locale.h>".}: cint

LC_MESSAGES {.importc: "LC_MESSAGES", header: "<locale.h>".}: cint

LC_MONETARY {.importc: "LC_MONETARY", header: "<locale.h>".}: cint

LC_NUMERIC {.importc: "LC_NUMERIC", header: "<locale.h>".}: cint

LC_TIME {.importc: "LC_TIME", header: "<locale.h>".}: cint

LIO_NOP {.importc: "LIO_NOP", header: "<aio.h>".}: cint

LIO_NOWAIT {.importc: "LIO_NOWAIT", header: "<aio.h>".}: cint

LIO_READ {.importc: "LIO_READ", header: "<aio.h>".}: cint

LIO_WAIT {.importc: "LIO_WAIT", header: "<aio.h>".}: cint

LIO_WRITE {.importc: "LIO_WRITE", header: "<aio.h>".}: cint

MAP_ANONYMOUS {.importc: "MAP_ANONYMOUS", header: "<sys/mman.h>".}: cint

MAP_FAILED {.importc: "MAP_FAILED", header: "<sys/mman.h>".}: pointer

MAP_FIXED {.importc: "MAP_FIXED", header: "<sys/mman.h>".}: cint

MAP_FIXED_NOREPLACE {.importc: "MAP_FIXED_NOREPLACE", header: "<sys/mman.h>".}: cint

MAP_NORESERVE {.importc: "MAP_NORESERVE", header: "<sys/mman.h>".}: cint

MAP_POPULATE: cint = 0

MAP_PRIVATE {.importc: "MAP_PRIVATE", header: "<sys/mman.h>".}: cint

MAP_SHARED {.importc: "MAP_SHARED", header: "<sys/mman.h>".}: cint

MCL_CURRENT {.importc: "MCL_CURRENT", header: "<sys/mman.h>".}: cint

MCL_FUTURE {.importc: "MCL_FUTURE", header: "<sys/mman.h>".}: cint

MINSIGSTKSZ {.importc: "MINSIGSTKSZ", header: "<signal.h>".}: cint

MM_APPL {.importc: "MM_APPL", header: "<fmtmsg.h>".}: cint

MM_CONSOLE {.importc: "MM_CONSOLE", header: "<fmtmsg.h>".}: cint

MM_ERROR {.importc: "MM_ERROR", header: "<fmtmsg.h>".}: cint

MM_FIRM {.importc: "MM_FIRM", header: "<fmtmsg.h>".}: cint

MM_HALT {.importc: "MM_HALT", header: "<fmtmsg.h>".}: cint

MM_HARD {.importc: "MM_HARD", header: "<fmtmsg.h>".}: cint

MM_INFO {.importc: "MM_INFO", header: "<fmtmsg.h>".}: cint

MM_NOCON {.importc: "MM_NOCON", header: "<fmtmsg.h>".}: cint

MM_NOMSG {.importc: "MM_NOMSG", header: "<fmtmsg.h>".}: cint

MM_NOSEV {.importc: "MM_NOSEV", header: "<fmtmsg.h>".}: cint

MM_NOTOK {.importc: "MM_NOTOK", header: "<fmtmsg.h>".}: cint

MM_NRECOV {.importc: "MM_NRECOV", header: "<fmtmsg.h>".}: cint

MM_OK {.importc: "MM_OK", header: "<fmtmsg.h>".}: cint

MM_OPSYS {.importc: "MM_OPSYS", header: "<fmtmsg.h>".}: cint

MM_PRINT {.importc: "MM_PRINT", header: "<fmtmsg.h>".}: cint

MM_RECOVER {.importc: "MM_RECOVER", header: "<fmtmsg.h>".}: cint

MM_SOFT {.importc: "MM_SOFT", header: "<fmtmsg.h>".}: cint

MM_UTIL {.importc: "MM_UTIL", header: "<fmtmsg.h>".}: cint

MM_WARNING {.importc: "MM_WARNING", header: "<fmtmsg.h>".}: cint

MON_1 {.importc: "MON_1", header: "<langinfo.h>".}: cint

MON_2 {.importc: "MON_2", header: "<langinfo.h>".}: cint

MON_3 {.importc: "MON_3", header: "<langinfo.h>".}: cint

MON_4 {.importc: "MON_4", header: "<langinfo.h>".}: cint

MON_5 {.importc: "MON_5", header: "<langinfo.h>".}: cint

MON_6 {.importc: "MON_6", header: "<langinfo.h>".}: cint

MON_7 {.importc: "MON_7", header: "<langinfo.h>".}: cint

MON_8 {.importc: "MON_8", header: "<langinfo.h>".}: cint

MON_9 {.importc: "MON_9", header: "<langinfo.h>".}: cint

MON_10 {.importc: "MON_10", header: "<langinfo.h>".}: cint

MON_11 {.importc: "MON_11", header: "<langinfo.h>".}: cint

MON_12 {.importc: "MON_12", header: "<langinfo.h>".}: cint

MS_ASYNC {.importc: "MS_ASYNC", header: "<sys/mman.h>".}: cint

MS_INVALIDATE {.importc: "MS_INVALIDATE", header: "<sys/mman.h>".}: cint

MS_SYNC {.importc: "MS_SYNC", header: "<sys/mman.h>".}: cint

MSG_CTRUNC {.importc: "MSG_CTRUNC", header: "<sys/socket.h>".}: cint

MSG_DONTROUTE {.importc: "MSG_DONTROUTE", header: "<sys/socket.h>".}: cint

MSG_EOR {.importc: "MSG_EOR", header: "<sys/socket.h>".}: cint

MSG_NOSIGNAL {.importc, header: "<sys/socket.h>".}: cint

No SIGPIPE generated when an attempt to send is made on a stream-oriented socket that is no longer connected. Source Edit

MSG_OOB {.importc: "MSG_OOB", header: "<sys/socket.h>".}: cint

MSG_PEEK {.importc: "MSG_PEEK", header: "<sys/socket.h>".}: cint

MSG_TRUNC {.importc: "MSG_TRUNC", header: "<sys/socket.h>".}: cint

MSG_WAITALL {.importc: "MSG_WAITALL", header: "<sys/socket.h>".}: cint

NI_DGRAM {.importc: "NI_DGRAM", header: "<netdb.h>".}: cint

NI_NAMEREQD {.importc: "NI_NAMEREQD", header: "<netdb.h>".}: cint

NI_NOFQDN {.importc: "NI_NOFQDN", header: "<netdb.h>".}: cint

NI_NUMERICHOST {.importc: "NI_NUMERICHOST", header: "<netdb.h>".}: cint

NI_NUMERICSCOPE {.importc: "NI_NUMERICSCOPE", header: "<netdb.h>".}: cint

NI_NUMERICSERV {.importc: "NI_NUMERICSERV", header: "<netdb.h>".}: cint

NL_CAT_LOCALE {.importc: "NL_CAT_LOCALE", header: "<nl_types.h>".}: cint

NL_SETD {.importc: "NL_SETD", header: "<nl_types.h>".}: cint

NO_DATA {.importc: "NO_DATA", header: "<netdb.h>".}: cint

NO_RECOVERY {.importc: "NO_RECOVERY", header: "<netdb.h>".}: cint

NOEXPR {.importc: "NOEXPR", header: "<langinfo.h>".}: cint

O_ACCMODE {.importc: "O_ACCMODE", header: "<fcntl.h>".}: cint

O_APPEND {.importc: "O_APPEND", header: "<fcntl.h>".}: cint

O_CLOEXEC {.importc: "O_CLOEXEC", header: "<fcntl.h>".}: cint

O_CREAT {.importc: "O_CREAT", header: "<fcntl.h>".}: cint

O_DSYNC {.importc: "O_DSYNC", header: "<fcntl.h>".}: cint

O_EXCL {.importc: "O_EXCL", header: "<fcntl.h>".}: cint

O_NOCTTY {.importc: "O_NOCTTY", header: "<fcntl.h>".}: cint

O_NONBLOCK {.importc: "O_NONBLOCK", header: "<fcntl.h>".}: cint

O_RDONLY {.importc: "O_RDONLY", header: "<fcntl.h>".}: cint

O_RDWR {.importc: "O_RDWR", header: "<fcntl.h>".}: cint

O_RSYNC {.importc: "O_RSYNC", header: "<fcntl.h>".}: cint

O_SYNC {.importc: "O_SYNC", header: "<fcntl.h>".}: cint

O_TRUNC {.importc: "O_TRUNC", header: "<fcntl.h>".}: cint

O_WRONLY {.importc: "O_WRONLY", header: "<fcntl.h>".}: cint

P_ALL {.importc: "P_ALL", header: "<sys/wait.h>".}: cint

P_PGID {.importc: "P_PGID", header: "<sys/wait.h>".}: cint

P_PID {.importc: "P_PID", header: "<sys/wait.h>".}: cint

PC_2_SYMLINKS {.importc: "_PC_2_SYMLINKS", header: "<unistd.h>".}: cint

PC_ALLOC_SIZE_MIN {.importc: "_PC_ALLOC_SIZE_MIN", header: "<unistd.h>".}: cint

PC_ASYNC_IO {.importc: "_PC_ASYNC_IO", header: "<unistd.h>".}: cint

PC_CHOWN_RESTRICTED {.importc: "_PC_CHOWN_RESTRICTED", header: "<unistd.h>".}: cint

PC_FILESIZEBITS {.importc: "_PC_FILESIZEBITS", header: "<unistd.h>".}: cint

PC_LINK_MAX {.importc: "_PC_LINK_MAX", header: "<unistd.h>".}: cint

PC_MAX_CANON {.importc: "_PC_MAX_CANON", header: "<unistd.h>".}: cint

PC_MAX_INPUT {.importc: "_PC_MAX_INPUT", header: "<unistd.h>".}: cint

PC_NAME_MAX {.importc: "_PC_NAME_MAX", header: "<unistd.h>".}: cint

PC_NO_TRUNC {.importc: "_PC_NO_TRUNC", header: "<unistd.h>".}: cint

PC_PATH_MAX {.importc: "_PC_PATH_MAX", header: "<unistd.h>".}: cint

PC_PIPE_BUF {.importc: "_PC_PIPE_BUF", header: "<unistd.h>".}: cint

PC_PRIO_IO {.importc: "_PC_PRIO_IO", header: "<unistd.h>".}: cint

PC_REC_INCR_XFER_SIZE {.importc: "_PC_REC_INCR_XFER_SIZE", header: "<unistd.h>".}: cint

PC_REC_MIN_XFER_SIZE {.importc: "_PC_REC_MIN_XFER_SIZE", header: "<unistd.h>".}: cint

PC_REC_XFER_ALIGN {.importc: "_PC_REC_XFER_ALIGN", header: "<unistd.h>".}: cint

PC_SYMLINK_MAX {.importc: "_PC_SYMLINK_MAX", header: "<unistd.h>".}: cint

PC_SYNC_IO {.importc: "_PC_SYNC_IO", header: "<unistd.h>".}: cint

PC_VDISABLE {.importc: "_PC_VDISABLE", header: "<unistd.h>".}: cint

PM_STR {.importc: "PM_STR", header: "<langinfo.h>".}: cint

POLLERR {.importc: "POLLERR", header: "<poll.h>".}: cshort

POLLHUP {.importc: "POLLHUP", header: "<poll.h>".}: cshort

POLLIN {.importc: "POLLIN", header: "<poll.h>".}: cshort

POLLNVAL {.importc: "POLLNVAL", header: "<poll.h>".}: cshort

POLLOUT {.importc: "POLLOUT", header: "<poll.h>".}: cshort

POLLPRI {.importc: "POLLPRI", header: "<poll.h>".}: cshort

POLLRDBAND {.importc: "POLLRDBAND", header: "<poll.h>".}: cshort

POLLRDNORM {.importc: "POLLRDNORM", header: "<poll.h>".}: cshort

POLLWRBAND {.importc: "POLLWRBAND", header: "<poll.h>".}: cshort

POLLWRNORM {.importc: "POLLWRNORM", header: "<poll.h>".}: cshort

POSIX_ASYNC_IO {.importc: "_POSIX_ASYNC_IO", header: "<unistd.h>".}: cint

POSIX_FADV_DONTNEED {.importc: "POSIX_FADV_DONTNEED", header: "<fcntl.h>".}: cint

POSIX_FADV_NOREUSE {.importc: "POSIX_FADV_NOREUSE", header: "<fcntl.h>".}: cint

POSIX_FADV_NORMAL {.importc: "POSIX_FADV_NORMAL", header: "<fcntl.h>".}: cint

POSIX_FADV_RANDOM {.importc: "POSIX_FADV_RANDOM", header: "<fcntl.h>".}: cint

POSIX_FADV_SEQUENTIAL {.importc: "POSIX_FADV_SEQUENTIAL", header: "<fcntl.h>".}: cint

POSIX_FADV_WILLNEED {.importc: "POSIX_FADV_WILLNEED", header: "<fcntl.h>".}: cint

POSIX_MADV_DONTNEED {.importc: "POSIX_MADV_DONTNEED", header: "<sys/mman.h>".}: cint

POSIX_MADV_NORMAL {.importc: "POSIX_MADV_NORMAL", header: "<sys/mman.h>".}: cint

POSIX_MADV_RANDOM {.importc: "POSIX_MADV_RANDOM", header: "<sys/mman.h>".}: cint

POSIX_MADV_SEQUENTIAL {.importc: "POSIX_MADV_SEQUENTIAL", header: "<sys/mman.h>".}: cint

POSIX_MADV_WILLNEED {.importc: "POSIX_MADV_WILLNEED", header: "<sys/mman.h>".}: cint

POSIX_PRIO_IO {.importc: "_POSIX_PRIO_IO", header: "<unistd.h>".}: cint

POSIX_SPAWN_RESETIDS {.importc: "POSIX_SPAWN_RESETIDS", header: "<spawn.h>".}: cint

POSIX_SPAWN_SETPGROUP {.importc: "POSIX_SPAWN_SETPGROUP", header: "<spawn.h>".}: cint

POSIX_SPAWN_SETSCHEDPARAM {.importc: "POSIX_SPAWN_SETSCHEDPARAM",
                            header: "<spawn.h>".}: cint

POSIX_SPAWN_SETSCHEDULER {.importc: "POSIX_SPAWN_SETSCHEDULER",
                           header: "<spawn.h>".}: cint

POSIX_SPAWN_SETSIGDEF {.importc: "POSIX_SPAWN_SETSIGDEF", header: "<spawn.h>".}: cint

POSIX_SPAWN_SETSIGMASK {.importc: "POSIX_SPAWN_SETSIGMASK", header: "<spawn.h>".}: cint

POSIX_SYNC_IO {.importc: "_POSIX_SYNC_IO", header: "<unistd.h>".}: cint

POSIX_TYPED_MEM_ALLOCATE {.importc: "POSIX_TYPED_MEM_ALLOCATE",
                           header: "<sys/mman.h>".}: cint

POSIX_TYPED_MEM_ALLOCATE_CONTIG {.importc: "POSIX_TYPED_MEM_ALLOCATE_CONTIG",
                                  header: "<sys/mman.h>".}: cint

POSIX_TYPED_MEM_MAP_ALLOCATABLE {.importc: "POSIX_TYPED_MEM_MAP_ALLOCATABLE",
                                  header: "<sys/mman.h>".}: cint

PROT_EXEC {.importc: "PROT_EXEC", header: "<sys/mman.h>".}: cint

PROT_NONE {.importc: "PROT_NONE", header: "<sys/mman.h>".}: cint

PROT_READ {.importc: "PROT_READ", header: "<sys/mman.h>".}: cint

PROT_WRITE {.importc: "PROT_WRITE", header: "<sys/mman.h>".}: cint

PTHREAD_BARRIER_SERIAL_THREAD {.importc: "PTHREAD_BARRIER_SERIAL_THREAD",
                                header: "<pthread.h>".}: cint

PTHREAD_CANCEL_ASYNCHRONOUS {.importc: "PTHREAD_CANCEL_ASYNCHRONOUS",
                              header: "<pthread.h>".}: cint

PTHREAD_CANCEL_DEFERRED {.importc: "PTHREAD_CANCEL_DEFERRED",
                          header: "<pthread.h>".}: cint

PTHREAD_CANCEL_DISABLE {.importc: "PTHREAD_CANCEL_DISABLE",
                         header: "<pthread.h>".}: cint

PTHREAD_CANCEL_ENABLE {.importc: "PTHREAD_CANCEL_ENABLE", header: "<pthread.h>".}: cint

PTHREAD_CREATE_DETACHED {.importc: "PTHREAD_CREATE_DETACHED",
                          header: "<pthread.h>".}: cint

PTHREAD_CREATE_JOINABLE {.importc: "PTHREAD_CREATE_JOINABLE",
                          header: "<pthread.h>".}: cint

PTHREAD_EXPLICIT_SCHED {.importc: "PTHREAD_EXPLICIT_SCHED",
                         header: "<pthread.h>".}: cint

PTHREAD_INHERIT_SCHED {.importc: "PTHREAD_INHERIT_SCHED", header: "<pthread.h>".}: cint

PTHREAD_MUTEX_DEFAULT {.importc: "PTHREAD_MUTEX_DEFAULT", header: "<pthread.h>".}: cint

PTHREAD_MUTEX_ERRORCHECK {.importc: "PTHREAD_MUTEX_ERRORCHECK",
                           header: "<pthread.h>".}: cint

PTHREAD_MUTEX_NORMAL {.importc: "PTHREAD_MUTEX_NORMAL", header: "<pthread.h>".}: cint

PTHREAD_MUTEX_RECURSIVE {.importc: "PTHREAD_MUTEX_RECURSIVE",
                          header: "<pthread.h>".}: cint

PTHREAD_PRIO_INHERIT {.importc: "PTHREAD_PRIO_INHERIT", header: "<pthread.h>".}: cint

PTHREAD_PRIO_NONE {.importc: "PTHREAD_PRIO_NONE", header: "<pthread.h>".}: cint

PTHREAD_PRIO_PROTECT {.importc: "PTHREAD_PRIO_PROTECT", header: "<pthread.h>".}: cint

PTHREAD_PROCESS_PRIVATE {.importc: "PTHREAD_PROCESS_PRIVATE",
                          header: "<pthread.h>".}: cint

PTHREAD_PROCESS_SHARED {.importc: "PTHREAD_PROCESS_SHARED",
                         header: "<pthread.h>".}: cint

PTHREAD_SCOPE_PROCESS {.importc: "PTHREAD_SCOPE_PROCESS", header: "<pthread.h>".}: cint

PTHREAD_SCOPE_SYSTEM {.importc: "PTHREAD_SCOPE_SYSTEM", header: "<pthread.h>".}: cint

R_OK {.importc: "R_OK", header: "<unistd.h>".}: cint

RADIXCHAR {.importc: "RADIXCHAR", header: "<langinfo.h>".}: cint

RLIMIT_NOFILE {.importc: "RLIMIT_NOFILE", header: "<sys/resource.h>".}: cint

RLIMIT_STACK {.importc: "RLIMIT_STACK", header: "<sys/resource.h>".}: cint

RTLD_GLOBAL {.importc: "RTLD_GLOBAL", header: "<dlfcn.h>".}: cint

RTLD_LAZY {.importc: "RTLD_LAZY", header: "<dlfcn.h>".}: cint

RTLD_LOCAL {.importc: "RTLD_LOCAL", header: "<dlfcn.h>".}: cint

RTLD_NOW {.importc: "RTLD_NOW", header: "<dlfcn.h>".}: cint

S_IFBLK {.importc: "S_IFBLK", header: "<sys/stat.h>".}: cint

S_IFCHR {.importc: "S_IFCHR", header: "<sys/stat.h>".}: cint

S_IFDIR {.importc: "S_IFDIR", header: "<sys/stat.h>".}: cint

S_IFIFO {.importc: "S_IFIFO", header: "<sys/stat.h>".}: cint

S_IFLNK {.importc: "S_IFLNK", header: "<sys/stat.h>".}: cint

S_IFMT {.importc: "S_IFMT", header: "<sys/stat.h>".}: cint

S_IFREG {.importc: "S_IFREG", header: "<sys/stat.h>".}: cint

S_IFSOCK {.importc: "S_IFSOCK", header: "<sys/stat.h>".}: cint

S_IRGRP {.importc: "S_IRGRP", header: "<sys/stat.h>".}: cint

S_IROTH {.importc: "S_IROTH", header: "<sys/stat.h>".}: cint

S_IRUSR {.importc: "S_IRUSR", header: "<sys/stat.h>".}: cint

S_IRWXG {.importc: "S_IRWXG", header: "<sys/stat.h>".}: cint

S_IRWXO {.importc: "S_IRWXO", header: "<sys/stat.h>".}: cint

S_IRWXU {.importc: "S_IRWXU", header: "<sys/stat.h>".}: cint

S_ISGID {.importc: "S_ISGID", header: "<sys/stat.h>".}: cint

S_ISUID {.importc: "S_ISUID", header: "<sys/stat.h>".}: cint

S_ISVTX {.importc: "S_ISVTX", header: "<sys/stat.h>".}: cint

S_IWGRP {.importc: "S_IWGRP", header: "<sys/stat.h>".}: cint

S_IWOTH {.importc: "S_IWOTH", header: "<sys/stat.h>".}: cint

S_IWUSR {.importc: "S_IWUSR", header: "<sys/stat.h>".}: cint

S_IXGRP {.importc: "S_IXGRP", header: "<sys/stat.h>".}: cint

S_IXOTH {.importc: "S_IXOTH", header: "<sys/stat.h>".}: cint

S_IXUSR {.importc: "S_IXUSR", header: "<sys/stat.h>".}: cint

SA_NOCLDSTOP {.importc: "SA_NOCLDSTOP", header: "<signal.h>".}: cint

SA_NOCLDWAIT {.importc: "SA_NOCLDWAIT", header: "<signal.h>".}: cint

SA_NODEFER {.importc: "SA_NODEFER", header: "<signal.h>".}: cint

SA_ONSTACK {.importc: "SA_ONSTACK", header: "<signal.h>".}: cint

SA_RESETHAND {.importc: "SA_RESETHAND", header: "<signal.h>".}: cint

SA_RESTART {.importc: "SA_RESTART", header: "<signal.h>".}: cint

SA_SIGINFO {.importc: "SA_SIGINFO", header: "<signal.h>".}: cint

SC_2_C_BIND {.importc: "_SC_2_C_BIND", header: "<unistd.h>".}: cint

SC_2_C_DEV {.importc: "_SC_2_C_DEV", header: "<unistd.h>".}: cint

SC_2_CHAR_TERM {.importc: "_SC_2_CHAR_TERM", header: "<unistd.h>".}: cint

SC_2_FORT_DEV {.importc: "_SC_2_FORT_DEV", header: "<unistd.h>".}: cint

SC_2_FORT_RUN {.importc: "_SC_2_FORT_RUN", header: "<unistd.h>".}: cint

SC_2_LOCALEDEF {.importc: "_SC_2_LOCALEDEF", header: "<unistd.h>".}: cint

SC_2_PBS {.importc: "_SC_2_PBS", header: "<unistd.h>".}: cint

SC_2_PBS_ACCOUNTING {.importc: "_SC_2_PBS_ACCOUNTING", header: "<unistd.h>".}: cint

SC_2_PBS_CHECKPOINT {.importc: "_SC_2_PBS_CHECKPOINT", header: "<unistd.h>".}: cint

SC_2_PBS_LOCATE {.importc: "_SC_2_PBS_LOCATE", header: "<unistd.h>".}: cint

SC_2_PBS_MESSAGE {.importc: "_SC_2_PBS_MESSAGE", header: "<unistd.h>".}: cint

SC_2_PBS_TRACK {.importc: "_SC_2_PBS_TRACK", header: "<unistd.h>".}: cint

SC_2_SW_DEV {.importc: "_SC_2_SW_DEV", header: "<unistd.h>".}: cint

SC_2_UPE {.importc: "_SC_2_UPE", header: "<unistd.h>".}: cint

SC_2_VERSION {.importc: "_SC_2_VERSION", header: "<unistd.h>".}: cint

SC_ADVISORY_INFO {.importc: "_SC_ADVISORY_INFO", header: "<unistd.h>".}: cint

SC_AIO_LISTIO_MAX {.importc: "_SC_AIO_LISTIO_MAX", header: "<unistd.h>".}: cint

SC_AIO_MAX {.importc: "_SC_AIO_MAX", header: "<unistd.h>".}: cint

SC_AIO_PRIO_DELTA_MAX {.importc: "_SC_AIO_PRIO_DELTA_MAX", header: "<unistd.h>".}: cint

SC_ARG_MAX {.importc: "_SC_ARG_MAX", header: "<unistd.h>".}: cint

SC_ASYNCHRONOUS_IO {.importc: "_SC_ASYNCHRONOUS_IO", header: "<unistd.h>".}: cint

SC_ATEXIT_MAX {.importc: "_SC_ATEXIT_MAX", header: "<unistd.h>".}: cint

SC_BARRIERS {.importc: "_SC_BARRIERS", header: "<unistd.h>".}: cint

SC_BC_BASE_MAX {.importc: "_SC_BC_BASE_MAX", header: "<unistd.h>".}: cint

SC_BC_DIM_MAX {.importc: "_SC_BC_DIM_MAX", header: "<unistd.h>".}: cint

SC_BC_SCALE_MAX {.importc: "_SC_BC_SCALE_MAX", header: "<unistd.h>".}: cint

SC_BC_STRING_MAX {.importc: "_SC_BC_STRING_MAX", header: "<unistd.h>".}: cint

SC_CHILD_MAX {.importc: "_SC_CHILD_MAX", header: "<unistd.h>".}: cint

SC_CLK_TCK {.importc: "_SC_CLK_TCK", header: "<unistd.h>".}: cint

SC_CLOCK_SELECTION {.importc: "_SC_CLOCK_SELECTION", header: "<unistd.h>".}: cint

SC_COLL_WEIGHTS_MAX {.importc: "_SC_COLL_WEIGHTS_MAX", header: "<unistd.h>".}: cint

SC_CPUTIME {.importc: "_SC_CPUTIME", header: "<unistd.h>".}: cint

SC_DELAYTIMER_MAX {.importc: "_SC_DELAYTIMER_MAX", header: "<unistd.h>".}: cint

SC_EXPR_NEST_MAX {.importc: "_SC_EXPR_NEST_MAX", header: "<unistd.h>".}: cint

SC_FSYNC {.importc: "_SC_FSYNC", header: "<unistd.h>".}: cint

SC_GETGR_R_SIZE_MAX {.importc: "_SC_GETGR_R_SIZE_MAX", header: "<unistd.h>".}: cint

SC_GETPW_R_SIZE_MAX {.importc: "_SC_GETPW_R_SIZE_MAX", header: "<unistd.h>".}: cint

SC_HOST_NAME_MAX {.importc: "_SC_HOST_NAME_MAX", header: "<unistd.h>".}: cint

SC_IOV_MAX {.importc: "_SC_IOV_MAX", header: "<unistd.h>".}: cint

SC_IPV6 {.importc: "_SC_IPV6", header: "<unistd.h>".}: cint

SC_JOB_CONTROL {.importc: "_SC_JOB_CONTROL", header: "<unistd.h>".}: cint

SC_LINE_MAX {.importc: "_SC_LINE_MAX", header: "<unistd.h>".}: cint

SC_LOGIN_NAME_MAX {.importc: "_SC_LOGIN_NAME_MAX", header: "<unistd.h>".}: cint

SC_MAPPED_FILES {.importc: "_SC_MAPPED_FILES", header: "<unistd.h>".}: cint

SC_MEMLOCK {.importc: "_SC_MEMLOCK", header: "<unistd.h>".}: cint

SC_MEMLOCK_RANGE {.importc: "_SC_MEMLOCK_RANGE", header: "<unistd.h>".}: cint

SC_MEMORY_PROTECTION {.importc: "_SC_MEMORY_PROTECTION", header: "<unistd.h>".}: cint

SC_MESSAGE_PASSING {.importc: "_SC_MESSAGE_PASSING", header: "<unistd.h>".}: cint

SC_MONOTONIC_CLOCK {.importc: "_SC_MONOTONIC_CLOCK", header: "<unistd.h>".}: cint

SC_MQ_OPEN_MAX {.importc: "_SC_MQ_OPEN_MAX", header: "<unistd.h>".}: cint

SC_MQ_PRIO_MAX {.importc: "_SC_MQ_PRIO_MAX", header: "<unistd.h>".}: cint

SC_NGROUPS_MAX {.importc: "_SC_NGROUPS_MAX", header: "<unistd.h>".}: cint

SC_NPROCESSORS_ONLN {.importc: "_SC_NPROCESSORS_ONLN", header: "<unistd.h>".}: cint

SC_OPEN_MAX {.importc: "_SC_OPEN_MAX", header: "<unistd.h>".}: cint

SC_PAGESIZE {.importc: "_SC_PAGESIZE", header: "<unistd.h>".}: cint

SC_PRIORITIZED_IO {.importc: "_SC_PRIORITIZED_IO", header: "<unistd.h>".}: cint

SC_PRIORITY_SCHEDULING {.importc: "_SC_PRIORITY_SCHEDULING",
                         header: "<unistd.h>".}: cint

SC_RAW_SOCKETS {.importc: "_SC_RAW_SOCKETS", header: "<unistd.h>".}: cint

SC_RE_DUP_MAX {.importc: "_SC_RE_DUP_MAX", header: "<unistd.h>".}: cint

SC_READER_WRITER_LOCKS {.importc: "_SC_READER_WRITER_LOCKS",
                         header: "<unistd.h>".}: cint

SC_REALTIME_SIGNALS {.importc: "_SC_REALTIME_SIGNALS", header: "<unistd.h>".}: cint

SC_REGEXP {.importc: "_SC_REGEXP", header: "<unistd.h>".}: cint

SC_RTSIG_MAX {.importc: "_SC_RTSIG_MAX", header: "<unistd.h>".}: cint

SC_SAVED_IDS {.importc: "_SC_SAVED_IDS", header: "<unistd.h>".}: cint

SC_SEM_NSEMS_MAX {.importc: "_SC_SEM_NSEMS_MAX", header: "<unistd.h>".}: cint

SC_SEM_VALUE_MAX {.importc: "_SC_SEM_VALUE_MAX", header: "<unistd.h>".}: cint

SC_SEMAPHORES {.importc: "_SC_SEMAPHORES", header: "<unistd.h>".}: cint

SC_SHARED_MEMORY_OBJECTS {.importc: "_SC_SHARED_MEMORY_OBJECTS",
                           header: "<unistd.h>".}: cint

SC_SHELL {.importc: "_SC_SHELL", header: "<unistd.h>".}: cint

SC_SIGQUEUE_MAX {.importc: "_SC_SIGQUEUE_MAX", header: "<unistd.h>".}: cint

SC_SPAWN {.importc: "_SC_SPAWN", header: "<unistd.h>".}: cint

SC_SPIN_LOCKS {.importc: "_SC_SPIN_LOCKS", header: "<unistd.h>".}: cint

SC_SPORADIC_SERVER {.importc: "_SC_SPORADIC_SERVER", header: "<unistd.h>".}: cint

SC_SS_REPL_MAX {.importc: "_SC_SS_REPL_MAX", header: "<unistd.h>".}: cint

SC_STREAM_MAX {.importc: "_SC_STREAM_MAX", header: "<unistd.h>".}: cint

SC_SYMLOOP_MAX {.importc: "_SC_SYMLOOP_MAX", header: "<unistd.h>".}: cint

SC_SYNCHRONIZED_IO {.importc: "_SC_SYNCHRONIZED_IO", header: "<unistd.h>".}: cint

SC_THREAD_ATTR_STACKADDR {.importc: "_SC_THREAD_ATTR_STACKADDR",
                           header: "<unistd.h>".}: cint

SC_THREAD_ATTR_STACKSIZE {.importc: "_SC_THREAD_ATTR_STACKSIZE",
                           header: "<unistd.h>".}: cint

SC_THREAD_CPUTIME {.importc: "_SC_THREAD_CPUTIME", header: "<unistd.h>".}: cint

SC_THREAD_DESTRUCTOR_ITERATIONS {.importc: "_SC_THREAD_DESTRUCTOR_ITERATIONS",
                                  header: "<unistd.h>".}: cint

SC_THREAD_KEYS_MAX {.importc: "_SC_THREAD_KEYS_MAX", header: "<unistd.h>".}: cint

SC_THREAD_PRIO_INHERIT {.importc: "_SC_THREAD_PRIO_INHERIT",
                         header: "<unistd.h>".}: cint

SC_THREAD_PRIO_PROTECT {.importc: "_SC_THREAD_PRIO_PROTECT",
                         header: "<unistd.h>".}: cint

SC_THREAD_PRIORITY_SCHEDULING {.importc: "_SC_THREAD_PRIORITY_SCHEDULING",
                                header: "<unistd.h>".}: cint

SC_THREAD_PROCESS_SHARED {.importc: "_SC_THREAD_PROCESS_SHARED",
                           header: "<unistd.h>".}: cint

SC_THREAD_SAFE_FUNCTIONS {.importc: "_SC_THREAD_SAFE_FUNCTIONS",
                           header: "<unistd.h>".}: cint

SC_THREAD_SPORADIC_SERVER {.importc: "_SC_THREAD_SPORADIC_SERVER",
                            header: "<unistd.h>".}: cint

SC_THREAD_STACK_MIN {.importc: "_SC_THREAD_STACK_MIN", header: "<unistd.h>".}: cint

SC_THREAD_THREADS_MAX {.importc: "_SC_THREAD_THREADS_MAX", header: "<unistd.h>".}: cint

SC_THREADS {.importc: "_SC_THREADS", header: "<unistd.h>".}: cint

SC_TIMEOUTS {.importc: "_SC_TIMEOUTS", header: "<unistd.h>".}: cint

SC_TIMER_MAX {.importc: "_SC_TIMER_MAX", header: "<unistd.h>".}: cint

SC_TIMERS {.importc: "_SC_TIMERS", header: "<unistd.h>".}: cint

SC_TRACE {.importc: "_SC_TRACE", header: "<unistd.h>".}: cint

SC_TRACE_EVENT_FILTER {.importc: "_SC_TRACE_EVENT_FILTER", header: "<unistd.h>".}: cint

SC_TRACE_EVENT_NAME_MAX {.importc: "_SC_TRACE_EVENT_NAME_MAX",
                          header: "<unistd.h>".}: cint

SC_TRACE_INHERIT {.importc: "_SC_TRACE_INHERIT", header: "<unistd.h>".}: cint

SC_TRACE_LOG {.importc: "_SC_TRACE_LOG", header: "<unistd.h>".}: cint

SC_TRACE_NAME_MAX {.importc: "_SC_TRACE_NAME_MAX", header: "<unistd.h>".}: cint

SC_TRACE_SYS_MAX {.importc: "_SC_TRACE_SYS_MAX", header: "<unistd.h>".}: cint

SC_TRACE_USER_EVENT_MAX {.importc: "_SC_TRACE_USER_EVENT_MAX",
                          header: "<unistd.h>".}: cint

SC_TTY_NAME_MAX {.importc: "_SC_TTY_NAME_MAX", header: "<unistd.h>".}: cint

SC_TYPED_MEMORY_OBJECTS {.importc: "_SC_TYPED_MEMORY_OBJECTS",
                          header: "<unistd.h>".}: cint

SC_TZNAME_MAX {.importc: "_SC_TZNAME_MAX", header: "<unistd.h>".}: cint

SC_V6_ILP32_OFF32 {.importc: "_SC_V6_ILP32_OFF32", header: "<unistd.h>".}: cint

SC_V6_ILP32_OFFBIG {.importc: "_SC_V6_ILP32_OFFBIG", header: "<unistd.h>".}: cint

SC_V6_LP64_OFF64 {.importc: "_SC_V6_LP64_OFF64", header: "<unistd.h>".}: cint

SC_V6_LPBIG_OFFBIG {.importc: "_SC_V6_LPBIG_OFFBIG", header: "<unistd.h>".}: cint

SC_VERSION {.importc: "_SC_VERSION", header: "<unistd.h>".}: cint

SC_XBS5_ILP32_OFF32 {.importc: "_SC_XBS5_ILP32_OFF32", header: "<unistd.h>".}: cint

SC_XBS5_ILP32_OFFBIG {.importc: "_SC_XBS5_ILP32_OFFBIG", header: "<unistd.h>".}: cint

SC_XBS5_LP64_OFF64 {.importc: "_SC_XBS5_LP64_OFF64", header: "<unistd.h>".}: cint

SC_XBS5_LPBIG_OFFBIG {.importc: "_SC_XBS5_LPBIG_OFFBIG", header: "<unistd.h>".}: cint

SC_XOPEN_CRYPT {.importc: "_SC_XOPEN_CRYPT", header: "<unistd.h>".}: cint

SC_XOPEN_ENH_I18N {.importc: "_SC_XOPEN_ENH_I18N", header: "<unistd.h>".}: cint

SC_XOPEN_LEGACY {.importc: "_SC_XOPEN_LEGACY", header: "<unistd.h>".}: cint

SC_XOPEN_REALTIME {.importc: "_SC_XOPEN_REALTIME", header: "<unistd.h>".}: cint

SC_XOPEN_REALTIME_THREADS {.importc: "_SC_XOPEN_REALTIME_THREADS",
                            header: "<unistd.h>".}: cint

SC_XOPEN_SHM {.importc: "_SC_XOPEN_SHM", header: "<unistd.h>".}: cint

SC_XOPEN_STREAMS {.importc: "_SC_XOPEN_STREAMS", header: "<unistd.h>".}: cint

SC_XOPEN_UNIX {.importc: "_SC_XOPEN_UNIX", header: "<unistd.h>".}: cint

SC_XOPEN_VERSION {.importc: "_SC_XOPEN_VERSION", header: "<unistd.h>".}: cint

SCHED_FIFO {.importc: "SCHED_FIFO", header: "<sched.h>".}: cint

SCHED_OTHER {.importc: "SCHED_OTHER", header: "<sched.h>".}: cint

SCHED_RR {.importc: "SCHED_RR", header: "<sched.h>".}: cint

SCHED_SPORADIC {.importc: "SCHED_SPORADIC", header: "<sched.h>".}: cint

SCM_RIGHTS {.importc: "SCM_RIGHTS", header: "<sys/socket.h>".}: cint

SEEK_CUR {.importc: "SEEK_CUR", header: "<unistd.h>".}: cint

SEEK_END {.importc: "SEEK_END", header: "<unistd.h>".}: cint

SEEK_SET {.importc: "SEEK_SET", header: "<unistd.h>".}: cint

SEM_FAILED {.importc: "SEM_FAILED", header: "<semaphore.h>".}: pointer

SHUT_RD {.importc: "SHUT_RD", header: "<sys/socket.h>".}: cint

SHUT_RDWR {.importc: "SHUT_RDWR", header: "<sys/socket.h>".}: cint

SHUT_WR {.importc: "SHUT_WR", header: "<sys/socket.h>".}: cint

SIG_BLOCK {.importc: "SIG_BLOCK", header: "<signal.h>".}: cint

SIG_DFL {.importc: "SIG_DFL", header: "<signal.h>".}: Sighandler

SIG_ERR {.importc: "SIG_ERR", header: "<signal.h>".}: Sighandler

SIG_HOLD {.importc: "SIG_HOLD", header: "<signal.h>".}: Sighandler

SIG_IGN {.importc: "SIG_IGN", header: "<signal.h>".}: Sighandler

SIG_SETMASK {.importc: "SIG_SETMASK", header: "<signal.h>".}: cint

SIG_UNBLOCK {.importc: "SIG_UNBLOCK", header: "<signal.h>".}: cint

SIGABRT {.importc: "SIGABRT", header: "<signal.h>".}: cint

SIGALRM {.importc: "SIGALRM", header: "<signal.h>".}: cint

SIGBUS {.importc: "SIGBUS", header: "<signal.h>".}: cint

SIGCHLD {.importc: "SIGCHLD", header: "<signal.h>".}: cint

SIGCONT {.importc: "SIGCONT", header: "<signal.h>".}: cint

SIGEV_NONE {.importc: "SIGEV_NONE", header: "<signal.h>".}: cint

SIGEV_SIGNAL {.importc: "SIGEV_SIGNAL", header: "<signal.h>".}: cint

SIGEV_THREAD {.importc: "SIGEV_THREAD", header: "<signal.h>".}: cint

SIGFPE {.importc: "SIGFPE", header: "<signal.h>".}: cint

SIGHUP {.importc: "SIGHUP", header: "<signal.h>".}: cint

SIGILL {.importc: "SIGILL", header: "<signal.h>".}: cint

SIGINT {.importc: "SIGINT", header: "<signal.h>".}: cint

SIGKILL {.importc: "SIGKILL", header: "<signal.h>".}: cint

SIGPIPE {.importc: "SIGPIPE", header: "<signal.h>".}: cint

SIGPOLL {.importc: "SIGPOLL", header: "<signal.h>".}: cint

SIGPROF {.importc: "SIGPROF", header: "<signal.h>".}: cint

SIGQUIT {.importc: "SIGQUIT", header: "<signal.h>".}: cint

SIGSEGV {.importc: "SIGSEGV", header: "<signal.h>".}: cint

SIGSTKSZ {.importc: "SIGSTKSZ", header: "<signal.h>".}: cint

SIGSTOP {.importc: "SIGSTOP", header: "<signal.h>".}: cint

SIGSYS {.importc: "SIGSYS", header: "<signal.h>".}: cint

SIGTERM {.importc: "SIGTERM", header: "<signal.h>".}: cint

SIGTRAP {.importc: "SIGTRAP", header: "<signal.h>".}: cint

SIGTSTP {.importc: "SIGTSTP", header: "<signal.h>".}: cint

SIGTTIN {.importc: "SIGTTIN", header: "<signal.h>".}: cint

SIGTTOU {.importc: "SIGTTOU", header: "<signal.h>".}: cint

SIGURG {.importc: "SIGURG", header: "<signal.h>".}: cint

SIGUSR1 {.importc: "SIGUSR1", header: "<signal.h>".}: cint

SIGUSR2 {.importc: "SIGUSR2", header: "<signal.h>".}: cint

SIGVTALRM {.importc: "SIGVTALRM", header: "<signal.h>".}: cint

SIGXCPU {.importc: "SIGXCPU", header: "<signal.h>".}: cint

SIGXFSZ {.importc: "SIGXFSZ", header: "<signal.h>".}: cint

SO_ACCEPTCONN {.importc: "SO_ACCEPTCONN", header: "<sys/socket.h>".}: cint

SO_BINDTODEVICE {.importc: "SO_BINDTODEVICE", header: "<sys/socket.h>".}: cint

SO_BROADCAST {.importc: "SO_BROADCAST", header: "<sys/socket.h>".}: cint

SO_DEBUG {.importc: "SO_DEBUG", header: "<sys/socket.h>".}: cint

SO_DONTROUTE {.importc: "SO_DONTROUTE", header: "<sys/socket.h>".}: cint

SO_ERROR {.importc: "SO_ERROR", header: "<sys/socket.h>".}: cint

SO_KEEPALIVE {.importc: "SO_KEEPALIVE", header: "<sys/socket.h>".}: cint

SO_LINGER {.importc: "SO_LINGER", header: "<sys/socket.h>".}: cint

SO_OOBINLINE {.importc: "SO_OOBINLINE", header: "<sys/socket.h>".}: cint

SO_RCVBUF {.importc: "SO_RCVBUF", header: "<sys/socket.h>".}: cint

SO_RCVLOWAT {.importc: "SO_RCVLOWAT", header: "<sys/socket.h>".}: cint

SO_RCVTIMEO {.importc: "SO_RCVTIMEO", header: "<sys/socket.h>".}: cint

SO_REUSEADDR {.importc: "SO_REUSEADDR", header: "<sys/socket.h>".}: cint

SO_SNDBUF {.importc: "SO_SNDBUF", header: "<sys/socket.h>".}: cint

SO_SNDLOWAT {.importc: "SO_SNDLOWAT", header: "<sys/socket.h>".}: cint

SO_SNDTIMEO {.importc: "SO_SNDTIMEO", header: "<sys/socket.h>".}: cint

SO_TYPE {.importc: "SO_TYPE", header: "<sys/socket.h>".}: cint

SOCK_DGRAM {.importc: "SOCK_DGRAM", header: "<sys/socket.h>".}: cint

SOCK_RAW {.importc: "SOCK_RAW", header: "<sys/socket.h>".}: cint

SOCK_SEQPACKET {.importc: "SOCK_SEQPACKET", header: "<sys/socket.h>".}: cint

SOCK_STREAM {.importc: "SOCK_STREAM", header: "<sys/socket.h>".}: cint

SOL_SOCKET {.importc: "SOL_SOCKET", header: "<sys/socket.h>".}: cint

SOMAXCONN {.importc: "SOMAXCONN", header: "<sys/socket.h>".}: cint

SS_DISABLE {.importc: "SS_DISABLE", header: "<signal.h>".}: cint

SS_ONSTACK {.importc: "SS_ONSTACK", header: "<signal.h>".}: cint

ST_NOSUID {.importc: "ST_NOSUID", header: "<sys/statvfs.h>".}: cint

ST_RDONLY {.importc: "ST_RDONLY", header: "<sys/statvfs.h>".}: cint

T_FMT {.importc: "T_FMT", header: "<langinfo.h>".}: cint

T_FMT_AMPM {.importc: "T_FMT_AMPM", header: "<langinfo.h>".}: cint

TCP_NODELAY {.importc: "TCP_NODELAY", header: "<netinet/tcp.h>".}: cint

THOUSEP {.importc: "THOUSEP", header: "<langinfo.h>".}: cint

TIMER_ABSTIME {.importc: "TIMER_ABSTIME", header: "<time.h>".}: cint

timezone {.importc, header: "<time.h>".}: int

TRY_AGAIN {.importc: "TRY_AGAIN", header: "<netdb.h>".}: cint

W_OK {.importc: "W_OK", header: "<unistd.h>".}: cint

WCONTINUED {.importc: "WCONTINUED", header: "<sys/wait.h>".}: cint

WEXITED {.importc: "WEXITED", header: "<sys/wait.h>".}: cint

WNOHANG {.importc: "WNOHANG", header: "<sys/wait.h>".}: cint

WNOWAIT {.importc: "WNOWAIT", header: "<sys/wait.h>".}: cint

WSTOPPED {.importc: "WSTOPPED", header: "<sys/wait.h>".}: cint

WUNTRACED {.importc: "WUNTRACED", header: "<sys/wait.h>".}: cint

X_OK {.importc: "X_OK", header: "<unistd.h>".}: cint

YESEXPR {.importc: "YESEXPR", header: "<langinfo.h>".}: cint

Consts

DT_BLK = 6

Block device. Source Edit

DT_CHR = 2

Character device. Source Edit

DT_DIR = 4

Directory. Source Edit

DT_FIFO = 1

Named pipe, or FIFO. Source Edit

DT_LNK = 10

Symbolic link. Source Edit

DT_REG = 8

Regular file. Source Edit

DT_SOCK = 12

UNIX domain socket. Source Edit

DT_UNKNOWN = 0

Unknown file type. Source Edit

DT_WHT = 14

INVALID_SOCKET = -1'i32

MM_NULLACT = nil

MM_NULLLBL = nil

MM_NULLMC = 0

MM_NULLSEV = 0

MM_NULLTAG = nil

MM_NULLTXT = nil

POSIX_SPAWN_USEVFORK = 0'i32

RUSAGE_CHILDREN = -1'i32

RUSAGE_SELF = 0'i32

RUSAGE_THREAD = 1'i32

SO_REUSEPORT = 512'i32

Multiple binding: load balancing on incoming TCP connections or UDP packets. (Requires Linux kernel > 3.9) Source Edit

Sockaddr_max_length = 255

Sockaddr_un_path_length = 92

StatHasNanoseconds = false

Boolean flag that indicates if the system supports nanosecond time resolution in the fields of Stat. Note that the nanosecond based fields (Stat.st_atim, Stat.st_mtim and Stat.st_ctim) can be accessed without checking this flag, because this module defines fallback procs when they are not available. Source Edit

STDERR_FILENO = 2

File number of stderr; Source Edit

STDIN_FILENO = 0

File number of stdin; Source Edit

STDOUT_FILENO = 1

File number of stdout; Source Edit

Procs

proc `-`(a, b: Time): Time {.borrow, ...raises: [], tags: [], forbids: [].}

proc `==`(a, b: Time): bool {.borrow, ...raises: [], tags: [], forbids: [].}

proc `==`(x, y: SocketHandle): bool {.borrow, ...raises: [], tags: [], forbids: [].}

proc accept(a1: SocketHandle; a2: ptr SockAddr; a3: ptr SockLen): SocketHandle {.
    importc, header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [],
    forbids: [].}

proc access(a1: cstring; a2: cint): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc alarm(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

proc asctime(a1: var Tm): cstring {.importc, header: "<time.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc asctime_r(a1: var Tm; a2: cstring): cstring {.importc, header: "<time.h>",
    ...raises: [], tags: [], forbids: [].}

proc basename(a1: cstring): cstring {.importc, header: "<libgen.h>", ...raises: [],
                                      tags: [], forbids: [].}

proc bindSocket(a1: SocketHandle; a2: ptr SockAddr; a3: SockLen): cint {.
    importc: "bind", header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

is Posix’s bind, because bind is a reserved word Source Edit

proc bsd_signal(a1: cint; a2: proc (x: pointer) {.noconv.}) {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc catclose(a1: Nl_catd): cint {.importc, header: "<nl_types.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc catgets(a1: Nl_catd; a2, a3: cint; a4: cstring): cstring {.importc,
    header: "<nl_types.h>", ...raises: [], tags: [], forbids: [].}

proc catopen(a1: cstring; a2: cint): Nl_catd {.importc, header: "<nl_types.h>",
    ...raises: [], tags: [], forbids: [].}

proc chdir(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [], forbids: [].}

proc chmod(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc chown(a1: cstring; a2: Uid; a3: Gid): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc clock(): Clock {.importc, header: "<time.h>", sideEffect, ...raises: [],
                      tags: [], forbids: [].}

proc clock_getcpuclockid(a1: Pid; a2: var ClockId): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc clock_getres(a1: ClockId; a2: var Timespec): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc clock_gettime(a1: ClockId; a2: var Timespec): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc clock_nanosleep(a1: ClockId; a2: cint; a3: var Timespec; a4: var Timespec): cint {.
    importc, header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc clock_settime(a1: ClockId; a2: var Timespec): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc close(a1: cint | SocketHandle): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc closedir(a1: ptr DIR): cint {.importc, header: "<dirent.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc CMSG_DATA(cmsg: ptr Tcmsghdr): cstring {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [], forbids: [].}

proc CMSG_FIRSTHDR(mhdr: ptr Tmsghdr): ptr Tcmsghdr {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc CMSG_LEN(len: csize_t): csize_t {.importc, header: "<sys/socket.h>",
                                       ...raises: [], tags: [], forbids: [].}

proc CMSG_NXTHDR(mhdr: ptr Tmsghdr; cmsg: ptr Tcmsghdr): ptr Tcmsghdr {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc CMSG_SPACE(len: csize_t): csize_t {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [], forbids: [].}

proc confstr(a1: cint; a2: cstring; a3: int): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc connect(a1: SocketHandle; a2: ptr SockAddr; a3: SockLen): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc creat(a1: cstring; a2: Mode): cint {.importc, header: "<fcntl.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc crypt(a1, a2: cstring): cstring {.importc, header: "<unistd.h>",
                                       ...raises: [], tags: [], forbids: [].}

proc ctermid(a1: cstring): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc ctime(a1: var Time): cstring {.importc, header: "<time.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc ctime_r(a1: var Time; a2: cstring): cstring {.importc, header: "<time.h>",
    ...raises: [], tags: [], forbids: [].}

proc difftime(a1, a2: Time): cdouble {.importc, header: "<time.h>", ...raises: [],
                                       tags: [], forbids: [].}

proc dirname(a1: cstring): cstring {.importc, header: "<libgen.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc dlclose(a1: pointer): cint {.importc, header: "<dlfcn.h>", sideEffect,
                                  ...raises: [], tags: [], forbids: [].}

proc dlerror(): cstring {.importc, header: "<dlfcn.h>", sideEffect, ...raises: [],
                          tags: [], forbids: [].}

proc dlopen(a1: cstring; a2: cint): pointer {.importc, header: "<dlfcn.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc dlsym(a1: pointer; a2: cstring): pointer {.importc, header: "<dlfcn.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc dup(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                           forbids: [].}

proc dup2(a1, a2: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [], forbids: [].}

proc encrypt(a1: array[0 .. 63, char]; a2: cint) {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc endgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [], forbids: [].}

proc endhostent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                    forbids: [].}

proc endnetent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                   forbids: [].}

proc endprotoent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                     forbids: [].}

proc endpwent() {.importc, header: "<pwd.h>", ...raises: [], tags: [], forbids: [].}

proc endservent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                    forbids: [].}

proc execl(a1, a2: cstring): cint {.varargs, importc, header: "<unistd.h>",
                                    sideEffect, ...raises: [], tags: [],
                                    forbids: [].}

proc execle(a1, a2: cstring): cint {.varargs, importc, header: "<unistd.h>",
                                     sideEffect, ...raises: [], tags: [],
                                     forbids: [].}

proc execlp(a1, a2: cstring): cint {.varargs, importc, header: "<unistd.h>",
                                     sideEffect, ...raises: [], tags: [],
                                     forbids: [].}

proc execv(a1: cstring; a2: cstringArray): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc execve(a1: cstring; a2, a3: cstringArray): cint {.importc,
    header: "<unistd.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc execvp(a1: cstring; a2: cstringArray): cint {.importc,
    header: "<unistd.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc execvpe(a1: cstring; a2: cstringArray; a3: cstringArray): cint {.importc,
    header: "<unistd.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc exitnow(code: int) {.importc: "_exit", header: "<unistd.h>", ...raises: [],
                          tags: [], forbids: [].}

proc fchdir(a1: cint): cint {.importc, header: "<unistd.h>", sideEffect,
                              ...raises: [], tags: [], forbids: [].}

proc fchmod(a1: cint; a2: Mode): cint {.importc, header: "<sys/stat.h>",
                                        sideEffect, ...raises: [], tags: [],
                                        forbids: [].}

proc fchown(a1: cint; a2: Uid; a3: Gid): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc fcntl(a1: cint | SocketHandle; a2: cint): cint {.varargs, importc,
    header: "<fcntl.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc FD_CLR(a1: cint; a2: var TFdSet) {.importc, header: "<sys/select.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc FD_ISSET(a1: cint | SocketHandle; a2: var TFdSet): cint {.importc,
    header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

proc FD_SET(a1: cint | SocketHandle; a2: var TFdSet) {.importc: "FD_SET",
    header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

proc FD_ZERO(a1: var TFdSet) {.importc, header: "<sys/select.h>", ...raises: [],
                               tags: [], forbids: [].}

proc fdatasync(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc fmtmsg(a1: int; a2: cstring; a3: cint; a4, a5, a6: cstring): cint {.
    importc, header: "<fmtmsg.h>", ...raises: [], tags: [], forbids: [].}

proc fnmatch(a1, a2: cstring; a3: cint): cint {.importc, header: "<fnmatch.h>",
    ...raises: [], tags: [], forbids: [].}

proc fork(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                   tags: [], forbids: [].}

proc fpathconf(a1, a2: cint): int {.importc, header: "<unistd.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc freeAddrInfo(a1: ptr AddrInfo) {.importc: "freeaddrinfo",
                                      header: "<netdb.h>", ...raises: [], tags: [],
                                      forbids: [].}

proc fstat(a1: cint; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc fstatvfs(a1: cint; a2: var Statvfs): cint {.importc,
    header: "<sys/statvfs.h>", ...raises: [], tags: [], forbids: [].}

proc fsync(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

synchronize a file’s buffer cache to the storage device Source Edit

proc ftok(a1: cstring; a2: cint): Key {.importc, header: "<sys/ipc.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc ftruncate(a1: cint; a2: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc ftw(a1: cstring;
         a2: proc (x1: cstring; x2: ptr Stat; x3: cint): cint {.noconv.};
         a3: cint): cint {.importc, header: "<ftw.h>", ...raises: [], tags: [],
                           forbids: [].}

proc gai_strerror(a1: cint): cstring {.importc: "(char *)$1",
                                       header: "<netdb.h>", ...raises: [],
                                       tags: [], forbids: [].}

proc getaddrinfo(a1, a2: cstring; a3: ptr AddrInfo; a4: var ptr AddrInfo): cint {.
    importc, header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

proc getcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [], forbids: [].}

proc getcwd(a1: cstring; a2: int): cstring {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc getdate(a1: cstring): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc getegid(): Gid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                      tags: [], forbids: [].}

returns the effective group ID of the calling process Source Edit

proc geteuid(): Uid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                      tags: [], forbids: [].}

returns the effective user ID of the calling process Source Edit

proc getgid(): Gid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                     tags: [], forbids: [].}

returns the real group ID of the calling process Source Edit

proc getgrent(): ptr Group {.importc, header: "<grp.h>", ...raises: [], tags: [],
                             forbids: [].}

proc getgrgid(a1: Gid): ptr Group {.importc, header: "<grp.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc getgrgid_r(a1: Gid; a2: ptr Group; a3: cstring; a4: int; a5: ptr ptr Group): cint {.
    importc, header: "<grp.h>", ...raises: [], tags: [], forbids: [].}

proc getgrnam(a1: cstring): ptr Group {.importc, header: "<grp.h>", ...raises: [],
                                        tags: [], forbids: [].}

proc getgrnam_r(a1: cstring; a2: ptr Group; a3: cstring; a4: int;
                a5: ptr ptr Group): cint {.importc, header: "<grp.h>",
    ...raises: [], tags: [], forbids: [].}

proc getgroups(a1: cint; a2: ptr array[0 .. 255, Gid]): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc gethostbyaddr(a1: pointer; a2: SockLen; a3: cint): ptr Hostent {.importc,
    header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

proc gethostbyname(a1: cstring): ptr Hostent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [], forbids: [].}

proc gethostent(): ptr Hostent {.importc, header: "<netdb.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc gethostid(): int {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                        tags: [], forbids: [].}

proc gethostname(a1: cstring; a2: int): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc getlogin(): cstring {.importc, header: "<unistd.h>", sideEffect,
                           ...raises: [], tags: [], forbids: [].}

proc getlogin_r(a1: cstring; a2: int): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc getnameinfo(a1: ptr SockAddr; a2: SockLen; a3: cstring; a4: SockLen;
                 a5: cstring; a6: SockLen; a7: cint): cint {.importc,
    header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

proc getnetbyaddr(a1: int32; a2: cint): ptr Tnetent {.importc,
    header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

proc getnetbyname(a1: cstring): ptr Tnetent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [], forbids: [].}

proc getnetent(): ptr Tnetent {.importc, header: "<netdb.h>", ...raises: [],
                                tags: [], forbids: [].}

proc getopt(a1: cint; a2: cstringArray; a3: cstring): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc getpeername(a1: SocketHandle; a2: ptr SockAddr; a3: ptr SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc getpgid(a1: Pid): Pid {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

proc getpgrp(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                      forbids: [].}

proc getpid(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                     tags: [], forbids: [].}

returns the process ID (PID) of the calling process Source Edit

proc getppid(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                      tags: [], forbids: [].}

returns the process ID of the parent of the calling process Source Edit

proc getprotobyname(a1: cstring): ptr Protoent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [], forbids: [].}

proc getprotobynumber(a1: cint): ptr Protoent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [], forbids: [].}

proc getprotoent(): ptr Protoent {.importc, header: "<netdb.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc getpwent(): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [], tags: [],
                              forbids: [].}

proc getpwnam(a1: cstring): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
    tags: [], forbids: [].}

proc getpwnam_r(a1: cstring; a2: ptr Passwd; a3: cstring; a4: int;
                a5: ptr ptr Passwd): cint {.importc, header: "<pwd.h>",
    ...raises: [], tags: [], forbids: [].}

proc getpwuid(a1: Uid): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc getpwuid_r(a1: Uid; a2: ptr Passwd; a3: cstring; a4: int;
                a5: ptr ptr Passwd): cint {.importc, header: "<pwd.h>",
    ...raises: [], tags: [], forbids: [].}

proc getrlimit(resource: cint; rlp: var RLimit): cint {.importc: "getrlimit",
    header: "<sys/resource.h>", ...raises: [], tags: [], forbids: [].}

The getrlimit() system call gets resource limits. Source Edit

proc getrusage(who: cint; rusage: ptr Rusage): cint {.importc,
    header: "<sys/resource.h>", discardable, ...raises: [], tags: [], forbids: [].}

proc getservbyname(a1, a2: cstring): ptr Servent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [], forbids: [].}

proc getservbyport(a1: cint; a2: cstring): ptr Servent {.importc,
    header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

proc getservent(): ptr Servent {.importc, header: "<netdb.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc getsid(a1: Pid): Pid {.importc, header: "<unistd.h>", sideEffect,
                            ...raises: [], tags: [], forbids: [].}

returns the session ID of the calling process Source Edit

proc getsockname(a1: SocketHandle; a2: ptr SockAddr; a3: ptr SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc getsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: ptr SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc getuid(): Uid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                     tags: [], forbids: [].}

returns the real user ID of the calling process Source Edit

proc getwd(a1: cstring): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc glob(a1: cstring; a2: cint;
          a3: proc (x1: cstring; x2: cint): cint {.noconv.}; a4: ptr Glob): cint {.
    importc, header: "<glob.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Filename globbing. Use os.walkPattern() and similar. Source Edit

proc globfree(a1: ptr Glob) {.importc, header: "<glob.h>", ...raises: [], tags: [],
                              forbids: [].}

proc gmtime(a1: var Time): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc gmtime_r(a1: var Time; a2: var Tm): ptr Tm {.importc, header: "<time.h>",
    ...raises: [], tags: [], forbids: [].}

proc hstrerror(herrnum: cint): cstring {.importc: "(char *)$1",
    header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

proc htonl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc htons(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc iconv(a1: Iconv; a2: var cstring; a3: var int; a4: var cstring; a5: var int): int {.
    importc, header: "<iconv.h>", ...raises: [], tags: [], forbids: [].}

proc iconv_close(a1: Iconv): cint {.importc, header: "<iconv.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc iconv_open(a1, a2: cstring): Iconv {.importc, header: "<iconv.h>",
    ...raises: [], tags: [], forbids: [].}

proc if_freenameindex(a1: ptr Tif_nameindex) {.importc, header: "<net/if.h>",
    ...raises: [], tags: [], forbids: [].}

proc if_indextoname(a1: cint; a2: cstring): cstring {.importc,
    header: "<net/if.h>", ...raises: [], tags: [], forbids: [].}

proc if_nameindex(): ptr Tif_nameindex {.importc, header: "<net/if.h>",
    ...raises: [], tags: [], forbids: [].}

proc if_nametoindex(a1: cstring): cint {.importc, header: "<net/if.h>",
    ...raises: [], tags: [], forbids: [].}

proc IN6_IS_ADDR_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Unicast link-local address. Source Edit

proc IN6_IS_ADDR_LOOPBACK(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Loopback address. Source Edit

proc IN6_IS_ADDR_MC_GLOBAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Multicast global address. Source Edit

proc IN6_IS_ADDR_MC_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Multicast link-local address. Source Edit

proc IN6_IS_ADDR_MC_NODELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Multicast node-local address. Source Edit

proc IN6_IS_ADDR_MC_ORGLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Multicast organization-local address. Source Edit

proc IN6_IS_ADDR_MC_SITELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Multicast site-local address. Source Edit

proc IN6_IS_ADDR_MULTICAST(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Multicast address. Source Edit

proc IN6_IS_ADDR_SITELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Unicast site-local address. Source Edit

proc IN6_IS_ADDR_UNSPECIFIED(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Unspecified address. Source Edit

proc IN6_IS_ADDR_V4COMPAT(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

IPv4-compatible address. Source Edit

proc IN6_IS_ADDR_V4MAPPED(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

IPv4 mapped address. Source Edit

proc IN6ADDR_ANY_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                   ...raises: [], tags: [], forbids: [].}

proc IN6ADDR_LOOPBACK_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc inet_addr(a1: cstring): InAddrT {.importc, header: "<arpa/inet.h>",
                                       ...raises: [], tags: [], forbids: [].}

proc inet_ntoa(a1: InAddr): cstring {.importc, header: "<arpa/inet.h>",
                                      ...raises: [], tags: [], forbids: [].}

proc inet_ntop(a1: cint; a2: pointer | ptr InAddr | ptr In6Addr; a3: cstring;
               a4: int32): cstring {.importc: "(char *)$1",
                                     header: "<arpa/inet.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc inet_pton(a1: cint; a2: cstring; a3: pointer | ptr InAddr | ptr In6Addr): cint {.
    importc, header: "<arpa/inet.h>", ...raises: [], tags: [], forbids: [].}

proc ioctl(f: FileHandle; device: uint): int {.importc: "ioctl",
    header: "<sys/ioctl.h>", varargs, ...tags: [WriteIOEffect], raises: [],
    forbids: [].}

A system call for device-specific input/output operations and other operations which cannot be expressed by regular system calls Source Edit

proc isatty(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

proc kill(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>", sideEffect,
                                     ...raises: [], tags: [], forbids: [].}

proc killpg(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>",
                                       sideEffect, ...raises: [], tags: [],
                                       forbids: [].}

proc lchown(a1: cstring; a2: Uid; a3: Gid): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc link(a1, a2: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc listen(a1: SocketHandle; a2: cint): cint {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc localeconv(): ptr Lconv {.importc, header: "<locale.h>", ...raises: [],
                               tags: [], forbids: [].}

proc localtime(a1: var Time): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                       tags: [], forbids: [].}

proc localtime_r(a1: var Time; a2: var Tm): ptr Tm {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc lockf(a1, a2: cint; a3: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc lseek(a1: cint; a2: Off; a3: cint): Off {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc lstat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc makecontext(a1: var Ucontext; a4: proc () {.noconv.}; a3: cint) {.varargs,
    importc, header: "<ucontext.h>", ...raises: [], tags: [], forbids: [].}

proc mkdir(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

Use os.createDir() and similar. Source Edit

proc mkdtemp(tmpl: cstring): pointer {.importc, header: "<stdlib.h>",
                                       sideEffect, ...raises: [], tags: [],
                                       forbids: [].}

proc mkfifo(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    ...raises: [], tags: [], forbids: [].}

proc mknod(a1: cstring; a2: Mode; a3: Dev): cint {.importc,
    header: "<sys/stat.h>", ...raises: [], tags: [], forbids: [].}

proc mkstemp(tmpl: cstring): cint {.importc, header: "<stdlib.h>", sideEffect,
                                    ...raises: [], tags: [], forbids: [].}

Creates a unique temporary file.

Warning: The tmpl argument is written to by mkstemp and thus can’t be a string literal. If in doubt make a copy of the cstring before passing it in.

proc mkstemps(tmpl: cstring; suffixlen: int): cint {.importc,
    header: "<stdlib.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Creates a unique temporary file.

Warning: The tmpl argument is written to by mkstemps and thus can’t be a string literal. If in doubt make a copy of the cstring before passing it in.

proc mktime(a1: var Tm): Time {.importc, header: "<time.h>", ...raises: [],
                                tags: [], forbids: [].}

proc mlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

proc mlockall(a1: cint): cint {.importc, header: "<sys/mman.h>", ...raises: [],
                                tags: [], forbids: [].}

proc mmap(a1: pointer; a2: int; a3, a4, a5: cint; a6: Off): pointer {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc mprotect(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc mq_close(mqdes: Mqd): cint {.importc, header: "<mqueue.h>", ...raises: [],
                                  tags: [], forbids: [].}

proc mq_getattr(mqdes: Mqd; attribute: ptr MqAttr): cint {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

proc mq_notify(mqdes: Mqd; event: ptr SigEvent): cint {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

proc mq_open(name: cstring; flags: cint): Mqd {.varargs, importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

proc mq_receive(mqdes: Mqd; buffer: cstring; length: csize_t;
                priority: var cuint): int {.importc, header: "<mqueue.h>",
    ...raises: [], tags: [], forbids: [].}

proc mq_send(mqdes: Mqd; buffer: cstring; length: csize_t; priority: cuint): cint {.
    importc, header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

proc mq_setattr(mqdes: Mqd; newAttribute, oldAttribute: ptr MqAttr): cint {.
    importc, header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

proc mq_timedreceive(mqdes: Mqd; buffer: cstring; length: csize_t;
                     priority: cuint; timeout: ptr Timespec): int {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

proc mq_timedsend(mqdes: Mqd; buffer: cstring; length: csize_t; priority: cuint;
                  timeout: ptr Timespec): cint {.importc, header: "<mqueue.h>",
    ...raises: [], tags: [], forbids: [].}

proc mq_unlink(mqdes: cstring): cint {.importc, header: "<mqueue.h>",
                                       ...raises: [], tags: [], forbids: [].}

proc msync(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc munlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

proc munlockall(): cint {.importc, header: "<sys/mman.h>", ...raises: [], tags: [],
                          forbids: [].}

proc munmap(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

proc nanosleep(a1, a2: var Timespec): cint {.importc, header: "<time.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc nftw(a1: cstring; a2: proc (x1: cstring; x2: ptr Stat; x3: cint;
                                 x4: ptr FTW): cint {.noconv.}; a3: cint;
          a4: cint): cint {.importc, header: "<ftw.h>", ...raises: [], tags: [],
                            forbids: [].}

proc nice(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                            forbids: [].}

proc nl_langinfo(a1: Nl_item): cstring {.importc, header: "<langinfo.h>",
    ...raises: [], tags: [], forbids: [].}

proc ntohl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc ntohs(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc open(a1: cstring; a2: cint; mode: Mode | cint = 0.Mode): cint {.inline.}

proc opendir(a1: cstring): ptr DIR {.importc, header: "<dirent.h>", sideEffect,
                                     ...raises: [], tags: [], forbids: [].}

proc pathconf(a1: cstring; a2: cint): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc pause(): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                     forbids: [].}

proc pclose(a: File): cint {.importc, header: "<stdio.h>", ...raises: [], tags: [],
                             forbids: [].}

proc pipe(a: array[0 .. 1, cint]): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc poll(a1: ptr TPollfd; a2: Tnfds; a3: int): cint {.importc,
    header: "<poll.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc popen(a1, a2: cstring): File {.importc, header: "<stdio.h>", ...raises: [],
                                    tags: [], forbids: [].}

proc posix_fadvise(a1: cint; a2, a3: Off; a4: cint): cint {.importc,
    header: "<fcntl.h>", ...raises: [], tags: [], forbids: [].}

proc posix_fallocate(a1: cint; a2, a3: Off): cint {.importc,
    header: "<fcntl.h>", ...raises: [], tags: [], forbids: [].}

proc posix_madvise(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc posix_mem_offset(a1: pointer; a2: int; a3: var Off; a4: var int;
                      a5: var cint): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

proc posix_spawn(a1: var Pid; a2: cstring; a3: var Tposix_spawn_file_actions;
                 a4: var Tposix_spawnattr; a5, a6: cstringArray): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawn_file_actions_addclose(a1: var Tposix_spawn_file_actions;
                                       a2: cint): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawn_file_actions_adddup2(a1: var Tposix_spawn_file_actions;
                                      a2, a3: cint): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawn_file_actions_addopen(a1: var Tposix_spawn_file_actions;
                                      a2: cint; a3: cstring; a4: cint; a5: Mode): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawn_file_actions_destroy(a1: var Tposix_spawn_file_actions): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawn_file_actions_init(a1: var Tposix_spawn_file_actions): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_destroy(a1: var Tposix_spawnattr): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_getflags(a1: var Tposix_spawnattr; a2: var cshort): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_getpgroup(a1: var Tposix_spawnattr; a2: var Pid): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_getschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_getschedpolicy(a1: var Tposix_spawnattr; a2: var cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_getsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_getsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_init(a1: var Tposix_spawnattr): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_setflags(a1: var Tposix_spawnattr; a2: cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_setpgroup(a1: var Tposix_spawnattr; a2: Pid): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_setschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_setschedpolicy(a1: var Tposix_spawnattr; a2: cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_setsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnattr_setsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_spawnp(a1: var Pid; a2: cstring; a3: var Tposix_spawn_file_actions;
                  a4: var Tposix_spawnattr; a5, a6: cstringArray): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

proc posix_typed_mem_get_info(a1: cint; a2: var Posix_typed_mem_info): cint {.
    importc, header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc posix_typed_mem_open(a1: cstring; a2, a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc pread(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc pselect(a1: cint; a2, a3, a4: ptr TFdSet; a5: ptr Timespec; a6: var Sigset): cint {.
    importc, header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_atfork(a1, a2, a3: proc () {.noconv.}): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_destroy(a1: ptr Pthread_attr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getguardsize(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getinheritsched(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getschedpolicy(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getscope(a1: ptr Pthread_attr; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getstack(a1: ptr Pthread_attr; a2: var pointer; a3: var int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getstackaddr(a1: ptr Pthread_attr; a2: var pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_getstacksize(a1: ptr Pthread_attr; a2: var int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_init(a1: ptr Pthread_attr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setguardsize(a1: ptr Pthread_attr; a2: int): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setinheritsched(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setschedpolicy(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setscope(a1: ptr Pthread_attr; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setstack(a1: ptr Pthread_attr; a2: pointer; a3: int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setstackaddr(a1: ptr Pthread_attr; a2: pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_attr_setstacksize(a1: ptr Pthread_attr; a2: int): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_barrier_destroy(a1: ptr Pthread_barrier): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_barrier_init(a1: ptr Pthread_barrier; a2: ptr Pthread_barrierattr;
                          a3: cint): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_barrier_wait(a1: ptr Pthread_barrier): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_barrierattr_destroy(a1: ptr Pthread_barrierattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_barrierattr_getpshared(a1: ptr Pthread_barrierattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_barrierattr_init(a1: ptr Pthread_barrierattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_barrierattr_setpshared(a1: ptr Pthread_barrierattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cancel(a1: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_cleanup_pop(a1: cint) {.importc, header: "<pthread.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc pthread_cleanup_push(a1: proc (x: pointer) {.noconv.}; a2: pointer) {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cond_broadcast(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cond_destroy(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cond_init(a1: ptr Pthread_cond; a2: ptr Pthread_condattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cond_signal(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cond_timedwait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex;
                            a3: ptr Timespec): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_cond_wait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_condattr_destroy(a1: ptr Pthread_condattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_condattr_getclock(a1: ptr Pthread_condattr; a2: var ClockId): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_condattr_getpshared(a1: ptr Pthread_condattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_condattr_init(a1: ptr Pthread_condattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_condattr_setclock(a1: ptr Pthread_condattr; a2: ClockId): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_condattr_setpshared(a1: ptr Pthread_condattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_create(a1: ptr Pthread; a2: ptr Pthread_attr;
                    a3: proc (x: pointer): pointer {.noconv.}; a4: pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_detach(a1: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_equal(a1, a2: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_exit(a1: pointer) {.importc, header: "<pthread.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc pthread_getconcurrency(): cint {.importc, header: "<pthread.h>",
                                      ...raises: [], tags: [], forbids: [].}

proc pthread_getcpuclockid(a1: Pthread; a2: var ClockId): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_getschedparam(a1: Pthread; a2: var cint; a3: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_getspecific(a1: Pthread_key): pointer {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_join(a1: Pthread; a2: ptr pointer): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_key_create(a1: ptr Pthread_key; a2: proc (x: pointer) {.noconv.}): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_key_delete(a1: Pthread_key): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_kill(a1: Pthread; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_destroy(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_getprioceiling(a1: ptr Pthread_mutex; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_init(a1: ptr Pthread_mutex; a2: ptr Pthread_mutexattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_lock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_setprioceiling(a1: ptr Pthread_mutex; a2: cint; a3: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_timedlock(a1: ptr Pthread_mutex; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_trylock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutex_unlock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_destroy(a1: ptr Pthread_mutexattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_getprioceiling(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_getprotocol(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_getpshared(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_gettype(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_init(a1: ptr Pthread_mutexattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_setprioceiling(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_setprotocol(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_setpshared(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_mutexattr_settype(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_once(a1: ptr Pthread_once; a2: proc () {.noconv.}): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_destroy(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_init(a1: ptr Pthread_rwlock; a2: ptr Pthread_rwlockattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_rdlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_timedrdlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_timedwrlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_tryrdlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_trywrlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_unlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlock_wrlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlockattr_destroy(a1: ptr Pthread_rwlockattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlockattr_getpshared(a1: ptr Pthread_rwlockattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlockattr_init(a1: ptr Pthread_rwlockattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_rwlockattr_setpshared(a1: ptr Pthread_rwlockattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_self(): Pthread {.importc, header: "<pthread.h>", ...raises: [],
                               tags: [], forbids: [].}

proc pthread_setcancelstate(a1: cint; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_setcanceltype(a1: cint; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_setconcurrency(a1: cint): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

proc pthread_setschedparam(a1: Pthread; a2: cint; a3: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_setschedprio(a1: Pthread; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_setspecific(a1: Pthread_key; a2: pointer): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_sigmask(a1: cint; a2, a3: var Sigset): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_spin_destroy(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_spin_init(a1: ptr Pthread_spinlock; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_spin_lock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_spin_trylock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_spin_unlock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

proc pthread_testcancel() {.importc, header: "<pthread.h>", ...raises: [],
                            tags: [], forbids: [].}

proc pwrite(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc `raise`(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                               tags: [], forbids: [].}

proc read(a1: cint; a2: pointer; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc readdir(a1: ptr DIR): ptr Dirent {.importc, header: "<dirent.h>",
                                        sideEffect, ...raises: [], tags: [],
                                        forbids: [].}

proc readdir_r(a1: ptr DIR; a2: ptr Dirent; a3: ptr ptr Dirent): cint {.importc,
    header: "<dirent.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc readlink(a1, a2: cstring; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc readv(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
    header: "<sys/uio.h>", ...raises: [], tags: [], forbids: [].}

proc realpath(name, resolved: cstring): cstring {.importc: "realpath",
    header: "<stdlib.h>", ...raises: [], tags: [], forbids: [].}

proc recv(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc recvfrom(a1: SocketHandle; a2: pointer; a3: int; a4: cint;
              a5: ptr SockAddr; a6: ptr SockLen): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc recvmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc rewinddir(a1: ptr DIR) {.importc, header: "<dirent.h>", ...raises: [],
                              tags: [], forbids: [].}

proc rmdir(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [], forbids: [].}

proc S_ISBLK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Test for a block special file. Source Edit

proc S_ISCHR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Test for a character special file. Source Edit

proc S_ISDIR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Test for a directory. Source Edit

proc S_ISFIFO(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                               tags: [], forbids: [].}

Test for a pipe or FIFO special file. Source Edit

proc S_ISLNK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Test for a symbolic link. Source Edit

proc S_ISREG(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Test for a regular file. Source Edit

proc S_ISSOCK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                               tags: [], forbids: [].}

Test for a socket. Source Edit

proc S_TYPEISMQ(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                       ...raises: [], tags: [], forbids: [].}

Test for a message queue. Source Edit

proc S_TYPEISSEM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [], forbids: [].}

Test for a semaphore. Source Edit

proc S_TYPEISSHM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [], forbids: [].}

Test for a shared memory object. Source Edit

proc S_TYPEISTMO(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [], forbids: [].}

Test macro for a typed memory object. Source Edit

proc sched_get_priority_max(a1: cint): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [], forbids: [].}

proc sched_get_priority_min(a1: cint): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [], forbids: [].}

proc sched_getparam(a1: Pid; a2: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

proc sched_getscheduler(a1: Pid): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [], forbids: [].}

proc sched_rr_get_interval(a1: Pid; a2: var Timespec): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

proc sched_setparam(a1: Pid; a2: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

proc sched_setscheduler(a1: Pid; a2: cint; a3: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

proc sched_yield(): cint {.importc, header: "<sched.h>", ...raises: [], tags: [],
                           forbids: [].}

proc seekdir(a1: ptr DIR; a2: int) {.importc, header: "<dirent.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc select(a1: cint | SocketHandle; a2, a3, a4: ptr TFdSet; a5: ptr Timeval): cint {.
    importc, header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

proc sem_close(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                    ...raises: [], tags: [], forbids: [].}

proc sem_destroy(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                      ...raises: [], tags: [], forbids: [].}

proc sem_getvalue(a1: ptr Sem; a2: var cint): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

proc sem_init(a1: ptr Sem; a2: cint; a3: cint): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

proc sem_open(a1: cstring; a2: cint): ptr Sem {.varargs, importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

proc sem_post(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc sem_timedwait(a1: ptr Sem; a2: ptr Timespec): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

proc sem_trywait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                      ...raises: [], tags: [], forbids: [].}

proc sem_unlink(a1: cstring): cint {.importc, header: "<semaphore.h>",
                                     ...raises: [], tags: [], forbids: [].}

proc sem_wait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc send(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc sendmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc sendto(a1: SocketHandle; a2: pointer; a3: int; a4: cint; a5: ptr SockAddr;
            a6: SockLen): int {.importc, header: "<sys/socket.h>", sideEffect,
                                ...raises: [], tags: [], forbids: [].}

proc setcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [], forbids: [].}

proc setegid(a1: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

proc seteuid(a1: Uid): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

proc setgid(a1: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

proc setgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [], forbids: [].}

proc sethostent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                            forbids: [].}

proc setlocale(a1: cint; a2: cstring): cstring {.importc, header: "<locale.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

proc setnetent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                           forbids: [].}

proc setpgid(a1, a2: Pid): cint {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [], forbids: [].}

proc setpgrp(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                      forbids: [].}

proc setprotoent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                             forbids: [].}

proc setpwent() {.importc, header: "<pwd.h>", ...raises: [], tags: [], forbids: [].}

proc setregid(a1, a2: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc setreuid(a1, a2: Uid): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [], forbids: [].}

proc setrlimit(resource: cint; rlp: var RLimit): cint {.importc: "setrlimit",
    header: "<sys/resource.h>", ...raises: [], tags: [], forbids: [].}

The setrlimit() system calls sets resource limits. Source Edit

proc setservent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                            forbids: [].}

proc setsid(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                     forbids: [].}

proc setsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc setuid(a1: Uid): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

proc shm_open(a1: cstring; a2: cint; a3: Mode): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

proc shm_unlink(a1: cstring): cint {.importc, header: "<sys/mman.h>",
                                     ...raises: [], tags: [], forbids: [].}

proc shutdown(a1: SocketHandle; a2: cint): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc sigaction(a1: cint; a2, a3: var Sigaction): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigaction(a1: cint; a2: var Sigaction; a3: ptr Sigaction = nil): cint {.
    importc, header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigaddset(a1: var Sigset; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [], forbids: [].}

proc sigaltstack(a1, a2: var Stack): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [], forbids: [].}

proc sigdelset(a1: var Sigset; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [], forbids: [].}

proc sigemptyset(a1: var Sigset): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [], forbids: [].}

proc sigfillset(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc sighold(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                               tags: [], forbids: [].}

proc sigignore(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc siginterrupt(a1, a2: cint): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc sigismember(a1: var Sigset; a2: cint): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc signal(a1: cint; a2: Sighandler) {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc sigpause(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                                tags: [], forbids: [].}

proc sigpending(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc sigprocmask(a1: cint; a2, a3: var Sigset): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigqueue(a1: Pid; a2: cint; a3: SigVal): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigrelse(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                                tags: [], forbids: [].}

proc sigset(a1: int; a2: proc (x: cint) {.noconv.}) {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigsuspend(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [], forbids: [].}

proc sigtimedwait(a1: var Sigset; a2: var SigInfo; a3: var Timespec): cint {.
    importc, header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigwait(a1: var Sigset; a2: var cint): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sigwaitinfo(a1: var Sigset; a2: var SigInfo): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

proc sleep(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

proc sockatmark(a1: cint): cint {.importc, header: "<sys/socket.h>", ...raises: [],
                                  tags: [], forbids: [].}

proc socket(a1, a2, a3: cint): SocketHandle {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [], forbids: [].}

proc socketpair(a1, a2, a3: cint; a4: var array[0 .. 1, cint]): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

proc st_atim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

Nanosecond-granularity time of last access. Source Edit

proc st_ctim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

Nanosecond-granularity time of last data modification. Source Edit

proc st_mtim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

Nanosecond-granularity time of last data modification. Source Edit

proc stat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    ...raises: [], tags: [], forbids: [].}

proc statvfs(a1: cstring; a2: var Statvfs): cint {.importc,
    header: "<sys/statvfs.h>", ...raises: [], tags: [], forbids: [].}

proc strerror(errnum: cint): cstring {.importc, header: "<string.h>",
                                       ...raises: [], tags: [], forbids: [].}

proc strfmon(a1: cstring; a2: int; a3: cstring): int {.varargs, importc,
    header: "<monetary.h>", ...raises: [], tags: [], forbids: [].}

proc strftime(a1: cstring; a2: int; a3: cstring; a4: var Tm): int {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc strptime(a1, a2: cstring; a3: var Tm): cstring {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc swab(a1, a2: pointer; a3: int) {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [], forbids: [].}

proc swapcontext(a1, a2: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [], forbids: [].}

proc symlink(a1, a2: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [], forbids: [].}

proc sync() {.importc, header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc sysconf(a1: cint): int {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

proc tcgetpgrp(a1: cint): Pid {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [], forbids: [].}

proc tcsetpgrp(a1: cint; a2: Pid): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc telldir(a1: ptr DIR): int {.importc, header: "<dirent.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc time(a1: var Time): Time {.importc, header: "<time.h>", sideEffect,
                                ...raises: [], tags: [], forbids: [].}

proc timegm(a1: var Tm): Time {.importc, header: "<time.h>", ...raises: [],
                                tags: [], forbids: [].}

proc timer_create(a1: ClockId; a2: var SigEvent; a3: var Timer): cint {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc timer_delete(a1: Timer): cint {.importc, header: "<time.h>", ...raises: [],
                                     tags: [], forbids: [].}

proc timer_getoverrun(a1: Timer): cint {.importc, header: "<time.h>",
    ...raises: [], tags: [], forbids: [].}

proc timer_gettime(a1: Timer; a2: var Itimerspec): cint {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc timer_settime(a1: Timer; a2: cint; a3: var Itimerspec; a4: var Itimerspec): cint {.
    importc, header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc truncate(a1: cstring; a2: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc ttyname(a1: cint): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [], forbids: [].}

proc ttyname_r(a1: cint; a2: cstring; a3: int): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

proc tzset() {.importc, header: "<time.h>", ...raises: [], tags: [], forbids: [].}

proc ualarm(a1, a2: Useconds): Useconds {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc umask(a1: Mode): Mode {.importc, header: "<sys/stat.h>", ...raises: [],
                             tags: [], forbids: [].}

proc uname(a1: var Utsname): cint {.importc, header: "<sys/utsname.h>",
                                    ...raises: [], tags: [], forbids: [].}

proc unlink(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                 tags: [], forbids: [].}

proc usleep(a1: Useconds): cint {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [], forbids: [].}

proc utimes(path: cstring; times: ptr array[2, Timeval]): int {.
    importc: "utimes", header: "<sys/time.h>", sideEffect, ...raises: [], tags: [],
    forbids: [].}

Sets file access and modification times.

Pass the filename and an array of times to set the access and modification times respectively. If you pass nil as the array both attributes will be set to the current time.

Returns zero on success.

For more information read http://www.unix.com/man-page/posix/3/utimes/.

proc vfork(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                    forbids: [].}

proc wait(a1: ptr cint): Pid {.importc, discardable, header: "<sys/wait.h>",
                               sideEffect, ...raises: [], tags: [], forbids: [].}

proc wait4(pid: Pid; status: ptr cint; options: cint; rusage: ptr Rusage): Pid {.
    importc, header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [],
    forbids: [].}

proc waitid(a1: cint; a2: Id; a3: var SigInfo; a4: cint): cint {.importc,
    header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc waitpid(a1: Pid; a2: var cint; a3: cint): Pid {.importc,
    header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

proc WEXITSTATUS(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                                  tags: [], forbids: [].}

Exit code, if WIFEXITED(s) Source Edit

proc WIFCONTINUED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                   tags: [], forbids: [].}

True if child has been continued. Source Edit

proc WIFEXITED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                tags: [], forbids: [].}

True if child exited normally. Source Edit

proc WIFSIGNALED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                  tags: [], forbids: [].}

True if child exited due to uncaught signal. Source Edit

proc WIFSTOPPED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                 tags: [], forbids: [].}

True if child is currently stopped. Source Edit

proc write(a1: cint; a2: pointer; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

proc writev(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
    header: "<sys/uio.h>", ...raises: [], tags: [], forbids: [].}

proc WSTOPSIG(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                               tags: [], forbids: [].}

Stop signal, if WIFSTOPPED(s) Source Edit

proc WTERMSIG(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                               tags: [], forbids: [].}

Termination signal, if WIFSIGNALED(s) Source Edit

Templates

template onSignal(signals: varargs[cint]; body: untyped)

Setup code to be executed when Unix signals are received. The currently handled signal is injected as sig into the calling scope.

Example:

from std/posix import SIGINT, SIGTERM, onSignal
onSignal(SIGINT, SIGTERM):
  echo "bye from signal ", sig

当前内容版权归 Nim 或其关联方所有，如需对内容或内容相关联开源项目进行关注与资助，请访问 Nim .

本文档使用 BookStack 构建

展开/收起文章目录