std/posix

    Dark Mode
Search:
  Source   Edit

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
  Source   Edit
ClockId {.importc: "clockid_t", header: "<sys/types.h>".} = int
  Source   Edit
Dev {.importc: "dev_t", header: "<sys/types.h>".} = int
  Source   Edit
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 false or false:
      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
  Source   Edit
Fsfilcnt {.importc: "fsfilcnt_t", header: "<sys/types.h>".} = int
  Source   Edit
FTW {.importc: "struct FTW", header: "<ftw.h>", final, pure.} = object
  base*: cint
  level*: cint
  Source   Edit
Gid {.importc: "gid_t", header: "<sys/types.h>".} = int
  Source   Edit
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
  Source   Edit
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
InAddrT {.importc: "in_addr_t", pure, final, header: "<netinet/in.h>".} = uint32
  Source   Edit
Ino {.importc: "ino_t", header: "<sys/types.h>".} = int
  Source   Edit
InPort = uint16
  Source   Edit
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
  Source   Edit
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
  Source   Edit
Mcontext {.importc: "mcontext_t", header: "<ucontext.h>", final, pure.} = object
  Source   Edit
Mode {.importc: "mode_t", header: "<sys/types.h>".} = (when false or false:
  uint16
 else:
  uint32)
  Source   Edit
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
  Source   Edit
Nl_catd {.importc: "nl_catd", header: "<nl_types.h>".} = cint
  Source   Edit
Nl_item {.importc: "nl_item", header: "<nl_types.h>".} = cint
  Source   Edit
Off {.importc: "off_t", header: "<sys/types.h>".} = int64
  Source   Edit
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
  Source   Edit
Posix_typed_mem_info {.importc: "struct posix_typed_mem_info",
                       header: "<sys/mman.h>", final, pure.} = object
  posix_tmi_length*: int
  Source   Edit
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
  Source   Edit
Pthread_attr {.importc: "pthread_attr_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_barrier {.importc: "pthread_barrier_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_barrierattr {.importc: "pthread_barrierattr_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_cond {.importc: "pthread_cond_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_condattr {.importc: "pthread_condattr_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_key {.importc: "pthread_key_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_mutex {.importc: "pthread_mutex_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_mutexattr {.importc: "pthread_mutexattr_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_once {.importc: "pthread_once_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_rwlock {.importc: "pthread_rwlock_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_rwlockattr {.importc: "pthread_rwlockattr_t", header: "<sys/types.h>".} = int
  Source   Edit
Pthread_spinlock {.importc: "pthread_spinlock_t", header: "<sys/types.h>".} = int
  Source   Edit
RLimit {.importc: "struct rlimit", header: "<sys/resource.h>", pure, final.} = object
  rlim_cur*: int
  rlim_max*: int
  Source   Edit
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
  Source   Edit
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
  Source   Edit
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
  Source   Edit
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
  Source   Edit
SockLen {.importc: "socklen_t", header: "<sys/socket.h>".} = cuint
  Source   Edit
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
  Source   Edit
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
  Source   Edit
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)
  Source   Edit
Timer {.importc: "timer_t", header: "<sys/types.h>".} = int
  Source   Edit
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>".} = cint
  Source   Edit
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
  Source   Edit
Tposix_spawnattr {.importc: "posix_spawnattr_t", header: "<spawn.h>", final,
                   pure.} = object
  Source   Edit
Trace_attr {.importc: "trace_attr_t", header: "<sys/types.h>".} = int
  Source   Edit
Trace_event_id {.importc: "trace_event_id_t", header: "<sys/types.h>".} = int
  Source   Edit
Trace_event_set {.importc: "trace_event_set_t", header: "<sys/types.h>".} = int
  Source   Edit
Trace_id {.importc: "trace_id_t", header: "<sys/types.h>".} = int
  Source   Edit
TSa_Family {.importc: "sa_family_t", header: "<sys/socket.h>".} = cushort
  Source   Edit
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
  Source   Edit
Useconds {.importc: "useconds_t", header: "<sys/types.h>".} = int
  Source   Edit
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: cint
  Source   Edit
ABDAY_2: cint
  Source   Edit
ABDAY_3: cint
  Source   Edit
ABDAY_4: cint
  Source   Edit
ABDAY_5: cint
  Source   Edit
ABDAY_6: cint
  Source   Edit
ABDAY_7: cint
  Source   Edit
ABMON_1: cint
  Source   Edit
ABMON_2: cint
  Source   Edit
ABMON_3: cint
  Source   Edit
ABMON_4: cint
  Source   Edit
ABMON_5: cint
  Source   Edit
ABMON_6: cint
  Source   Edit
ABMON_7: cint
  Source   Edit
ABMON_8: cint
  Source   Edit
ABMON_9: cint
  Source   Edit
AF_INET: cint
  Source   Edit
AF_UNIX: cint
  Source   Edit
AI_ALL: cint
  Source   Edit
AM_STR: cint
  Source   Edit
CODESET: cint
  Source   Edit
CS_PATH: cint
  Source   Edit
D_FMT: cint
  Source   Edit
D_T_FMT: cint
  Source   Edit
DAY_1: cint
  Source   Edit
DAY_2: cint
  Source   Edit
DAY_3: cint
  Source   Edit
DAY_4: cint
  Source   Edit
DAY_5: cint
  Source   Edit
DAY_6: cint
  Source   Edit
DAY_7: cint
  Source   Edit
E2BIG: cint
  Source   Edit
EACCES: cint
  Source   Edit
EAGAIN: cint
  Source   Edit
EBADF: cint
  Source   Edit
EBADMSG: cint
  Source   Edit
EBUSY: cint
  Source   Edit
ECHILD: cint
  Source   Edit
EDEADLK: cint
  Source   Edit
EDOM: cint
  Source   Edit
EDQUOT: cint
  Source   Edit
EEXIST: cint
  Source   Edit
EFAULT: cint
  Source   Edit
EFBIG: cint
  Source   Edit
EIDRM: cint
  Source   Edit
EILSEQ: cint
  Source   Edit
EINTR: cint
  Source   Edit
EINVAL: cint
  Source   Edit
EIO: cint
  Source   Edit
EISCONN: cint
  Source   Edit
EISDIR: cint
  Source   Edit
ELOOP: cint
  Source   Edit
EMFILE: cint
  Source   Edit
ENFILE: cint
  Source   Edit
ENOBUFS: cint
  Source   Edit
ENODATA: cint
  Source   Edit
ENODEV: cint
  Source   Edit
ENOENT: cint
  Source   Edit
ENOEXEC: cint
  Source   Edit
ENOLCK: cint
  Source   Edit
ENOMEM: cint
  Source   Edit
ENOMSG: cint
  Source   Edit
ENOSPC: cint
  Source   Edit
ENOSR: cint
  Source   Edit
ENOSTR: cint
  Source   Edit
ENOSYS: cint
  Source   Edit
ENOTDIR: cint
  Source   Edit
ENOTSUP: cint
  Source   Edit
ENOTTY: cint
  Source   Edit
ENXIO: cint
  Source   Edit
EPERM: cint
  Source   Edit
EPIPE: cint
  Source   Edit
EPROTO: cint
  Source   Edit
ERA: cint
  Source   Edit
ERANGE: cint
  Source   Edit
EROFS: cint
  Source   Edit
errno: cint
error variable   Source   Edit
ESPIPE: cint
  Source   Edit
ESRCH: cint
  Source   Edit
ESTALE: cint
  Source   Edit
ETIME: cint
  Source   Edit
ETXTBSY: cint
  Source   Edit
EXDEV: cint
  Source   Edit
F_DUPFD: cint
  Source   Edit
F_GETFD: cint
  Source   Edit
F_GETFL: cint
  Source   Edit
F_GETLK: cint
  Source   Edit
F_LOCK: cint
  Source   Edit
F_OK: cint
  Source   Edit
F_RDLCK: cint
  Source   Edit
F_SETFD: cint
  Source   Edit
F_SETFL: cint
  Source   Edit
F_SETLK: cint
  Source   Edit
F_TEST: cint
  Source   Edit
F_TLOCK: cint
  Source   Edit
F_ULOCK: cint
  Source   Edit
F_UNLCK: cint
  Source   Edit
F_WRLCK: cint
  Source   Edit
FTW_D: cint
  Source   Edit
FTW_DNR: cint
  Source   Edit
FTW_DP: cint
  Source   Edit
FTW_F: cint
  Source   Edit
FTW_NS: cint
  Source   Edit
FTW_SL: cint
  Source   Edit
FTW_SLN: cint
  Source   Edit
h_errno: cint
  Source   Edit
IOFBF: cint
  Source   Edit
IONBF: cint
  Source   Edit
IPC_SET: cint
  Source   Edit
LC_ALL: cint
  Source   Edit
LC_TIME: cint
  Source   Edit
LIO_NOP: cint
  Source   Edit
MAP_POPULATE: cint = 0
  Source   Edit
MM_APPL: cint
  Source   Edit
MM_FIRM: cint
  Source   Edit
MM_HALT: cint
  Source   Edit
MM_HARD: cint
  Source   Edit
MM_INFO: cint
  Source   Edit
MM_OK: cint
  Source   Edit
MM_SOFT: cint
  Source   Edit
MM_UTIL: cint
  Source   Edit
MON_1: cint
  Source   Edit
MON_2: cint
  Source   Edit
MON_3: cint
  Source   Edit
MON_4: cint
  Source   Edit
MON_5: cint
  Source   Edit
MON_6: cint
  Source   Edit
MON_7: cint
  Source   Edit
MON_8: cint
  Source   Edit
MON_9: cint
  Source   Edit
MON_10: cint
  Source   Edit
MON_11: cint
  Source   Edit
MON_12: cint
  Source   Edit
MS_SYNC: cint
  Source   Edit
MSG_EOR: cint
  Source   Edit
MSG_NOSIGNAL: 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: cint
  Source   Edit
NL_SETD: cint
  Source   Edit
NO_DATA: cint
  Source   Edit
NOEXPR: cint
  Source   Edit
O_CREAT: cint
  Source   Edit
O_DSYNC: cint
  Source   Edit
O_EXCL: cint
  Source   Edit
O_RDWR: cint
  Source   Edit
O_RSYNC: cint
  Source   Edit
O_SYNC: cint
  Source   Edit
O_TRUNC: cint
  Source   Edit
P_ALL: cint
  Source   Edit
P_PGID: cint
  Source   Edit
P_PID: cint
  Source   Edit
PM_STR: cint
  Source   Edit
R_OK: cint
  Source   Edit
S_IFBLK: cint
  Source   Edit
S_IFCHR: cint
  Source   Edit
S_IFDIR: cint
  Source   Edit
S_IFIFO: cint
  Source   Edit
S_IFLNK: cint
  Source   Edit
S_IFMT: cint
  Source   Edit
S_IFREG: cint
  Source   Edit
S_IRGRP: cint
  Source   Edit
S_IROTH: cint
  Source   Edit
S_IRUSR: cint
  Source   Edit
S_IRWXG: cint
  Source   Edit
S_IRWXO: cint
  Source   Edit
S_IRWXU: cint
  Source   Edit
S_ISGID: cint
  Source   Edit
S_ISUID: cint
  Source   Edit
S_ISVTX: cint
  Source   Edit
S_IWGRP: cint
  Source   Edit
S_IWOTH: cint
  Source   Edit
S_IWUSR: cint
  Source   Edit
S_IXGRP: cint
  Source   Edit
S_IXOTH: cint
  Source   Edit
S_IXUSR: cint
  Source   Edit
SC_IPV6: cint
  Source   Edit
SHUT_RD: cint
  Source   Edit
SHUT_WR: cint
  Source   Edit
SIG_DFL: Sighandler
  Source   Edit
SIG_ERR: Sighandler
  Source   Edit
SIG_HOLD: Sighandler
  Source   Edit
SIG_IGN: Sighandler
  Source   Edit
SIGABRT: cint
  Source   Edit
SIGALRM: cint
  Source   Edit
SIGBUS: cint
  Source   Edit
SIGCHLD: cint
  Source   Edit
SIGCONT: cint
  Source   Edit
SIGFPE: cint
  Source   Edit
SIGHUP: cint
  Source   Edit
SIGILL: cint
  Source   Edit
SIGINT: cint
  Source   Edit
SIGKILL: cint
  Source   Edit
SIGPIPE: cint
  Source   Edit
SIGPOLL: cint
  Source   Edit
SIGPROF: cint
  Source   Edit
SIGQUIT: cint
  Source   Edit
SIGSEGV: cint
  Source   Edit
SIGSTOP: cint
  Source   Edit
SIGSYS: cint
  Source   Edit
SIGTERM: cint
  Source   Edit
SIGTRAP: cint
  Source   Edit
SIGTSTP: cint
  Source   Edit
SIGTTIN: cint
  Source   Edit
SIGTTOU: cint
  Source   Edit
SIGURG: cint
  Source   Edit
SIGUSR1: cint
  Source   Edit
SIGUSR2: cint
  Source   Edit
SIGXCPU: cint
  Source   Edit
SIGXFSZ: cint
  Source   Edit
SO_TYPE: cint
  Source   Edit
T_FMT: cint
  Source   Edit
THOUSEP: cint
  Source   Edit
timezone: int
  Source   Edit
W_OK: cint
  Source   Edit
WEXITED: cint
  Source   Edit
WNOHANG: cint
  Source   Edit
WNOWAIT: cint
  Source   Edit
X_OK: cint
  Source   Edit
YESEXPR: cint
  Source   Edit

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
  Source   Edit
INVALID_SOCKET = -1'i32
  Source   Edit
MM_NULLACT = nil
  Source   Edit
MM_NULLLBL = nil
  Source   Edit
MM_NULLMC = 0
  Source   Edit
MM_NULLSEV = 0
  Source   Edit
MM_NULLTAG = nil
  Source   Edit
MM_NULLTXT = nil
  Source   Edit
POSIX_SPAWN_USEVFORK = 0'i32
  Source   Edit
RUSAGE_CHILDREN = -1'i32
  Source   Edit
RUSAGE_SELF = 0'i32
  Source   Edit
RUSAGE_THREAD = 1'i32
  Source   Edit
SO_REUSEPORT = 512'i32
Multiple binding: load balancing on incoming TCP connections or UDP packets. (Requires Linux kernel > 3.9)   Source   Edit
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: [].}
  Source   Edit
proc `==`(a, b: Time): bool {.borrow, ...raises: [], tags: [].}
  Source   Edit
proc `==`(x, y: SocketHandle): bool {.borrow, ...raises: [], tags: [].}
  Source   Edit
proc `raise`(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                               tags: [].}
  Source   Edit
proc accept(a1: SocketHandle; a2: ptr SockAddr; a3: ptr SockLen): SocketHandle {.
    importc, header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc access(a1: cstring; a2: cint): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc alarm(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc asctime(a1: var Tm): cstring {.importc, header: "<time.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc asctime_r(a1: var Tm; a2: cstring): cstring {.importc, header: "<time.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc basename(a1: cstring): cstring {.importc, header: "<libgen.h>", ...raises: [],
                                      tags: [].}
  Source   Edit
proc bindSocket(a1: SocketHandle; a2: ptr SockAddr; a3: SockLen): cint {.
    importc: "bind", header: "<sys/socket.h>", ...raises: [], tags: [].}
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: [].}
  Source   Edit
proc catclose(a1: Nl_catd): cint {.importc, header: "<nl_types.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc catgets(a1: Nl_catd; a2, a3: cint; a4: cstring): cstring {.importc,
    header: "<nl_types.h>", ...raises: [], tags: [].}
  Source   Edit
proc catopen(a1: cstring; a2: cint): Nl_catd {.importc, header: "<nl_types.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc chdir(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc chmod(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc chown(a1: cstring; a2: Uid; a3: Gid): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc clock(): Clock {.importc, header: "<time.h>", sideEffect, ...raises: [],
                      tags: [].}
  Source   Edit
proc clock_getcpuclockid(a1: Pid; a2: var ClockId): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc clock_getres(a1: ClockId; a2: var Timespec): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc clock_gettime(a1: ClockId; a2: var Timespec): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc clock_nanosleep(a1: ClockId; a2: cint; a3: var Timespec; a4: var Timespec): cint {.
    importc, header: "<time.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc clock_settime(a1: ClockId; a2: var Timespec): cint {.importc,
    header: "<time.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc close(a1: cint | SocketHandle): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc closedir(a1: ptr DIR): cint {.importc, header: "<dirent.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc CMSG_DATA(cmsg: ptr Tcmsghdr): cstring {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc CMSG_FIRSTHDR(mhdr: ptr Tmsghdr): ptr Tcmsghdr {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc CMSG_LEN(len: csize): csize {.importc, header: "<sys/socket.h>", ...deprecated: "argument `len` should be of type `csize_t`",
                                   raises: [], tags: [].}
Deprecated: argument `len` should be of type `csize_t`
  Source   Edit
proc CMSG_LEN(len: csize_t): csize_t {.importc, header: "<sys/socket.h>",
                                       ...raises: [], tags: [].}
  Source   Edit
proc CMSG_NXTHDR(mhdr: ptr Tmsghdr; cmsg: ptr Tcmsghdr): ptr Tcmsghdr {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc CMSG_SPACE(len: csize): csize {.importc, header: "<sys/socket.h>", ...deprecated: "argument `len` should be of type `csize_t`",
                                     raises: [], tags: [].}
Deprecated: argument `len` should be of type `csize_t`
  Source   Edit
proc CMSG_SPACE(len: csize_t): csize_t {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc confstr(a1: cint; a2: cstring; a3: int): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc connect(a1: SocketHandle; a2: ptr SockAddr; a3: SockLen): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc creat(a1: cstring; a2: Mode): cint {.importc, header: "<fcntl.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc crypt(a1, a2: cstring): cstring {.importc, header: "<unistd.h>",
                                       ...raises: [], tags: [].}
  Source   Edit
proc ctermid(a1: cstring): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                     tags: [].}
  Source   Edit
proc ctime(a1: var Time): cstring {.importc, header: "<time.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc ctime_r(a1: var Time; a2: cstring): cstring {.importc, header: "<time.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc difftime(a1, a2: Time): cdouble {.importc, header: "<time.h>", ...raises: [],
                                       tags: [].}
  Source   Edit
proc dirname(a1: cstring): cstring {.importc, header: "<libgen.h>", ...raises: [],
                                     tags: [].}
  Source   Edit
proc dlclose(a1: pointer): cint {.importc, header: "<dlfcn.h>", sideEffect,
                                  ...raises: [], tags: [].}
  Source   Edit
proc dlerror(): cstring {.importc, header: "<dlfcn.h>", sideEffect, ...raises: [],
                          tags: [].}
  Source   Edit
proc dlopen(a1: cstring; a2: cint): pointer {.importc, header: "<dlfcn.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc dlsym(a1: pointer; a2: cstring): pointer {.importc, header: "<dlfcn.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc dup(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc dup2(a1, a2: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc encrypt(a1: array[0 .. 63, char]; a2: cint) {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc endgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [].}
  Source   Edit
proc endhostent() {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc endnetent() {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc endprotoent() {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc endpwent() {.importc, header: "<pwd.h>", ...raises: [], tags: [].}
  Source   Edit
proc endservent() {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc execl(a1, a2: cstring): cint {.varargs, importc, header: "<unistd.h>",
                                    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc execle(a1, a2: cstring): cint {.varargs, importc, header: "<unistd.h>",
                                     sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc execlp(a1, a2: cstring): cint {.varargs, importc, header: "<unistd.h>",
                                     sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc execv(a1: cstring; a2: cstringArray): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc execve(a1: cstring; a2, a3: cstringArray): cint {.importc,
    header: "<unistd.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc execvp(a1: cstring; a2: cstringArray): cint {.importc,
    header: "<unistd.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc execvpe(a1: cstring; a2: cstringArray; a3: cstringArray): cint {.importc,
    header: "<unistd.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc exitnow(code: int) {.importc: "_exit", header: "<unistd.h>", ...raises: [],
                          tags: [].}
  Source   Edit
proc fchdir(a1: cint): cint {.importc, header: "<unistd.h>", sideEffect,
                              ...raises: [], tags: [].}
  Source   Edit
proc fchmod(a1: cint; a2: Mode): cint {.importc, header: "<sys/stat.h>",
                                        sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc fchown(a1: cint; a2: Uid; a3: Gid): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc fcntl(a1: cint | SocketHandle; a2: cint): cint {.varargs, importc,
    header: "<fcntl.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc FD_CLR(a1: cint; a2: var TFdSet) {.importc, header: "<sys/select.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc FD_ISSET(a1: cint | SocketHandle; a2: var TFdSet): cint {.importc,
    header: "<sys/select.h>", ...raises: [], tags: [].}
  Source   Edit
proc FD_SET(a1: cint | SocketHandle; a2: var TFdSet) {.importc: "FD_SET",
    header: "<sys/select.h>", ...raises: [], tags: [].}
  Source   Edit
proc FD_ZERO(a1: var TFdSet) {.importc, header: "<sys/select.h>", ...raises: [],
                               tags: [].}
  Source   Edit
proc fdatasync(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc fmtmsg(a1: int; a2: cstring; a3: cint; a4, a5, a6: cstring): cint {.
    importc, header: "<fmtmsg.h>", ...raises: [], tags: [].}
  Source   Edit
proc fnmatch(a1, a2: cstring; a3: cint): cint {.importc, header: "<fnmatch.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc fork(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                   tags: [].}
  Source   Edit
proc fpathconf(a1, a2: cint): int {.importc, header: "<unistd.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc freeaddrinfo(a1: ptr AddrInfo) {.importc, header: "<netdb.h>", ...raises: [],
                                      tags: [].}
  Source   Edit
proc fstat(a1: cint; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc fstatvfs(a1: cint; a2: var Statvfs): cint {.importc,
    header: "<sys/statvfs.h>", ...raises: [], tags: [].}
  Source   Edit
proc fsync(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
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: [].}
  Source   Edit
proc ftruncate(a1: cint; a2: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc ftw(a1: cstring;
         a2: proc (x1: cstring; x2: ptr Stat; x3: cint): cint {.noconv.};
         a3: cint): cint {.importc, header: "<ftw.h>", ...raises: [], tags: [].}
  Source   Edit
proc gai_strerror(a1: cint): cstring {.importc: "(char *)$1",
                                       header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc getaddrinfo(a1, a2: cstring; a3: ptr AddrInfo; a4: var ptr AddrInfo): cint {.
    importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc getcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getcwd(a1: cstring; a2: int): cstring {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc getdate(a1: cstring): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc getegid(): Gid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                      tags: [].}
returns the effective group ID of the calling process   Source   Edit
proc geteuid(): Uid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                      tags: [].}
returns the effective user ID of the calling process   Source   Edit
proc getgid(): Gid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                     tags: [].}
returns the real group ID of the calling process   Source   Edit
proc getgrent(): ptr Group {.importc, header: "<grp.h>", ...raises: [], tags: [].}
  Source   Edit
proc getgrgid(a1: Gid): ptr Group {.importc, header: "<grp.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc getgrgid_r(a1: Gid; a2: ptr Group; a3: cstring; a4: int; a5: ptr ptr Group): cint {.
    importc, header: "<grp.h>", ...raises: [], tags: [].}
  Source   Edit
proc getgrnam(a1: cstring): ptr Group {.importc, header: "<grp.h>", ...raises: [],
                                        tags: [].}
  Source   Edit
proc getgrnam_r(a1: cstring; a2: ptr Group; a3: cstring; a4: int;
                a5: ptr ptr Group): cint {.importc, header: "<grp.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getgroups(a1: cint; a2: ptr array[0 .. 255, Gid]): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc gethostbyaddr(a1: pointer; a2: SockLen; a3: cint): ptr Hostent {.importc,
    header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc gethostbyname(a1: cstring): ptr Hostent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc gethostent(): ptr Hostent {.importc, header: "<netdb.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc gethostid(): int {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                        tags: [].}
  Source   Edit
proc gethostname(a1: cstring; a2: int): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc getlogin(): cstring {.importc, header: "<unistd.h>", sideEffect,
                           ...raises: [], tags: [].}
  Source   Edit
proc getlogin_r(a1: cstring; a2: int): cint {.importc, header: "<unistd.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc getnameinfo(a1: ptr SockAddr; a2: SockLen; a3: cstring; a4: SockLen;
                 a5: cstring; a6: SockLen; a7: cint): cint {.importc,
    header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc getnetbyaddr(a1: int32; a2: cint): ptr Tnetent {.importc,
    header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc getnetbyname(a1: cstring): ptr Tnetent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getnetent(): ptr Tnetent {.importc, header: "<netdb.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc getopt(a1: cint; a2: cstringArray; a3: cstring): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc getpeername(a1: SocketHandle; a2: ptr SockAddr; a3: ptr SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc getpgid(a1: Pid): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc getpgrp(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc getpid(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                     tags: [].}
returns the process ID (PID) of the calling process   Source   Edit
proc getppid(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                      tags: [].}
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: [].}
  Source   Edit
proc getprotobynumber(a1: cint): ptr Protoent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getprotoent(): ptr Protoent {.importc, header: "<netdb.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc getpwent(): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [], tags: [].}
  Source   Edit
proc getpwnam(a1: cstring): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
    tags: [].}
  Source   Edit
proc getpwnam_r(a1: cstring; a2: ptr Passwd; a3: cstring; a4: int;
                a5: ptr ptr Passwd): cint {.importc, header: "<pwd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getpwuid(a1: Uid): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
                                     tags: [].}
  Source   Edit
proc getpwuid_r(a1: Uid; a2: ptr Passwd; a3: cstring; a4: int;
                a5: ptr ptr Passwd): cint {.importc, header: "<pwd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getrlimit(resource: cint; rlp: var RLimit): cint {.importc: "getrlimit",
    header: "<sys/resource.h>", ...raises: [], tags: [].}
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: [].}
  Source   Edit
proc getservbyname(a1, a2: cstring): ptr Servent {.importc, header: "<netdb.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc getservbyport(a1: cint; a2: cstring): ptr Servent {.importc,
    header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc getservent(): ptr Servent {.importc, header: "<netdb.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc getsid(a1: Pid): Pid {.importc, header: "<unistd.h>", sideEffect,
                            ...raises: [], tags: [].}
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: [].}
  Source   Edit
proc getsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: ptr SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc getuid(): Uid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                     tags: [].}
returns the real user ID of the calling process   Source   Edit
proc getwd(a1: cstring): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
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: [].}
Filename globbing. Use os.walkPattern() and similar.   Source   Edit
proc globfree(a1: ptr Glob) {.importc, header: "<glob.h>", ...raises: [], tags: [].}
  Source   Edit
proc gmtime(a1: var Time): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc gmtime_r(a1: var Time; a2: var Tm): ptr Tm {.importc, header: "<time.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc hstrerror(herrnum: cint): cstring {.importc: "(char *)$1",
    header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc htonl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc htons(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc iconv(a1: Iconv; a2: var cstring; a3: var int; a4: var cstring; a5: var int): int {.
    importc, header: "<iconv.h>", ...raises: [], tags: [].}
  Source   Edit
proc iconv_close(a1: Iconv): cint {.importc, header: "<iconv.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc iconv_open(a1, a2: cstring): Iconv {.importc, header: "<iconv.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc if_freenameindex(a1: ptr Tif_nameindex) {.importc, header: "<net/if.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc if_indextoname(a1: cint; a2: cstring): cstring {.importc,
    header: "<net/if.h>", ...raises: [], tags: [].}
  Source   Edit
proc if_nameindex(): ptr Tif_nameindex {.importc, header: "<net/if.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc if_nametoindex(a1: cstring): cint {.importc, header: "<net/if.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc IN6_IS_ADDR_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Unicast link-local address.   Source   Edit
proc IN6_IS_ADDR_LOOPBACK(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Loopback address.   Source   Edit
proc IN6_IS_ADDR_MC_GLOBAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Multicast global address.   Source   Edit
proc IN6_IS_ADDR_MC_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Multicast link-local address.   Source   Edit
proc IN6_IS_ADDR_MC_NODELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Multicast node-local address.   Source   Edit
proc IN6_IS_ADDR_MC_ORGLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Multicast organization-local address.   Source   Edit
proc IN6_IS_ADDR_MC_SITELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Multicast site-local address.   Source   Edit
proc IN6_IS_ADDR_MULTICAST(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Multicast address.   Source   Edit
proc IN6_IS_ADDR_SITELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Unicast site-local address.   Source   Edit
proc IN6_IS_ADDR_UNSPECIFIED(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
Unspecified address.   Source   Edit
proc IN6_IS_ADDR_V4COMPAT(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
IPv4-compatible address.   Source   Edit
proc IN6_IS_ADDR_V4MAPPED(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [].}
IPv4 mapped address.   Source   Edit
proc IN6ADDR_ANY_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                   ...raises: [], tags: [].}
  Source   Edit
proc IN6ADDR_LOOPBACK_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc inet_addr(a1: cstring): InAddrT {.importc, header: "<arpa/inet.h>",
                                       ...raises: [], tags: [].}
  Source   Edit
proc inet_ntoa(a1: InAddr): cstring {.importc, header: "<arpa/inet.h>",
                                      ...raises: [], tags: [].}
  Source   Edit
proc inet_ntop(a1: cint; a2: pointer; a3: cstring; a4: int32): cstring {.
    importc: "(char *)$1", header: "<arpa/inet.h>", ...raises: [], tags: [].}
  Source   Edit
proc inet_pton(a1: cint; a2: cstring; a3: pointer): cint {.importc,
    header: "<arpa/inet.h>", ...raises: [], tags: [].}
  Source   Edit
proc ioctl(f: FileHandle; device: uint): int {.importc: "ioctl",
    header: "<sys/ioctl.h>", varargs, ...tags: [WriteIOEffect], raises: [].}
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: [].}
  Source   Edit
proc kill(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>", sideEffect,
                                     ...raises: [], tags: [].}
  Source   Edit
proc killpg(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>",
                                       sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc lchown(a1: cstring; a2: Uid; a3: Gid): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc link(a1, a2: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc listen(a1: SocketHandle; a2: cint): cint {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc localeconv(): ptr Lconv {.importc, header: "<locale.h>", ...raises: [],
                               tags: [].}
  Source   Edit
proc localtime(a1: var Time): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                       tags: [].}
  Source   Edit
proc localtime_r(a1: var Time; a2: var Tm): ptr Tm {.importc,
    header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc lockf(a1, a2: cint; a3: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc lseek(a1: cint; a2: Off; a3: cint): Off {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc lstat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc makecontext(a1: var Ucontext; a4: proc () {.noconv.}; a3: cint) {.varargs,
    importc, header: "<ucontext.h>", ...raises: [], tags: [].}
  Source   Edit
proc mkdir(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [].}
Use os.createDir() and similar.   Source   Edit
proc mkdtemp(tmpl: cstring): pointer {.importc, header: "<stdlib.h>",
                                       sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc mkfifo(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc mknod(a1: cstring; a2: Mode; a3: Dev): cint {.importc,
    header: "<sys/stat.h>", ...raises: [], tags: [].}
  Source   Edit
proc mkstemp(tmpl: cstring): cint {.importc, header: "<stdlib.h>", sideEffect,
                                    ...raises: [], tags: [].}
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.
  Source   Edit
proc mkstemps(tmpl: cstring; suffixlen: int): cint {.importc,
    header: "<stdlib.h>", sideEffect, ...raises: [], tags: [].}
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.
  Source   Edit
proc mktime(a1: var Tm): Time {.importc, header: "<time.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc mlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc mlockall(a1: cint): cint {.importc, header: "<sys/mman.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc mmap(a1: pointer; a2: int; a3, a4, a5: cint; a6: Off): pointer {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc mprotect(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_close(a1: Mqd): cint {.importc, header: "<mqueue.h>", ...raises: [],
                               tags: [].}
  Source   Edit
proc mq_getattr(a1: Mqd; a2: ptr MqAttr): cint {.importc, header: "<mqueue.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc mq_notify(a1: Mqd; a2: ptr SigEvent): cint {.importc, header: "<mqueue.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc mq_open(a1: cstring; a2: cint): Mqd {.varargs, importc,
    header: "<mqueue.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_receive(a1: Mqd; a2: cstring; a3: int; a4: var int): int {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_send(a1: Mqd; a2: cstring; a3: int; a4: int): cint {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_setattr(a1: Mqd; a2, a3: ptr MqAttr): cint {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_timedreceive(a1: Mqd; a2: cstring; a3: int; a4: int; a5: ptr Timespec): int {.
    importc, header: "<mqueue.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_timedsend(a1: Mqd; a2: cstring; a3: int; a4: int; a5: ptr Timespec): cint {.
    importc, header: "<mqueue.h>", ...raises: [], tags: [].}
  Source   Edit
proc mq_unlink(a1: cstring): cint {.importc, header: "<mqueue.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc msync(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc munlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc munlockall(): cint {.importc, header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc munmap(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc nanosleep(a1, a2: var Timespec): cint {.importc, header: "<time.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
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: [].}
  Source   Edit
proc nice(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc nl_langinfo(a1: Nl_item): cstring {.importc, header: "<langinfo.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc ntohl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc ntohs(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc open(a1: cstring; a2: cint; mode: Mode | cint = 0.Mode): cint {.inline.}
  Source   Edit
proc opendir(a1: cstring): ptr DIR {.importc, header: "<dirent.h>", sideEffect,
                                     ...raises: [], tags: [].}
  Source   Edit
proc pathconf(a1: cstring; a2: cint): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pause(): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc pclose(a: File): cint {.importc, header: "<stdio.h>", ...raises: [], tags: [].}
  Source   Edit
proc pipe(a: array[0 .. 1, cint]): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc poll(a1: ptr TPollfd; a2: Tnfds; a3: int): cint {.importc,
    header: "<poll.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc popen(a1, a2: cstring): File {.importc, header: "<stdio.h>", ...raises: [],
                                    tags: [].}
  Source   Edit
proc posix_fadvise(a1: cint; a2, a3: Off; a4: cint): cint {.importc,
    header: "<fcntl.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_fallocate(a1: cint; a2, a3: Off): cint {.importc,
    header: "<fcntl.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_madvise(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
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: [].}
  Source   Edit
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: [].}
  Source   Edit
proc posix_spawn_file_actions_addclose(a1: var Tposix_spawn_file_actions;
                                       a2: cint): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawn_file_actions_adddup2(a1: var Tposix_spawn_file_actions;
                                      a2, a3: cint): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
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: [].}
  Source   Edit
proc posix_spawn_file_actions_destroy(a1: var Tposix_spawn_file_actions): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawn_file_actions_init(a1: var Tposix_spawn_file_actions): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_destroy(a1: var Tposix_spawnattr): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_getflags(a1: var Tposix_spawnattr; a2: var cshort): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_getpgroup(a1: var Tposix_spawnattr; a2: var Pid): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_getschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_getschedpolicy(a1: var Tposix_spawnattr; a2: var cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_getsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_getsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_init(a1: var Tposix_spawnattr): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_setflags(a1: var Tposix_spawnattr; a2: cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_setpgroup(a1: var Tposix_spawnattr; a2: Pid): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_setschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_setschedpolicy(a1: var Tposix_spawnattr; a2: cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_setsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_spawnattr_setsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [].}
  Source   Edit
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: [].}
  Source   Edit
proc posix_typed_mem_get_info(a1: cint; a2: var Posix_typed_mem_info): cint {.
    importc, header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc posix_typed_mem_open(a1: cstring; a2, a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc pread(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc pselect(a1: cint; a2, a3, a4: ptr TFdSet; a5: ptr Timespec; a6: var Sigset): cint {.
    importc, header: "<sys/select.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_atfork(a1, a2, a3: proc () {.noconv.}): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_destroy(a1: ptr Pthread_attr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getguardsize(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getinheritsched(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getschedpolicy(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getscope(a1: ptr Pthread_attr; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getstack(a1: ptr Pthread_attr; a2: var pointer; a3: var int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getstackaddr(a1: ptr Pthread_attr; a2: var pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_getstacksize(a1: ptr Pthread_attr; a2: var int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_init(a1: ptr Pthread_attr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setguardsize(a1: ptr Pthread_attr; a2: int): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setinheritsched(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setschedpolicy(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setscope(a1: ptr Pthread_attr; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setstack(a1: ptr Pthread_attr; a2: pointer; a3: int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setstackaddr(a1: ptr Pthread_attr; a2: pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_attr_setstacksize(a1: ptr Pthread_attr; a2: int): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrier_destroy(a1: ptr Pthread_barrier): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrier_init(a1: ptr Pthread_barrier; a2: ptr Pthread_barrierattr;
                          a3: cint): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrier_wait(a1: ptr Pthread_barrier): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrierattr_destroy(a1: ptr Pthread_barrierattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrierattr_getpshared(a1: ptr Pthread_barrierattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrierattr_init(a1: ptr Pthread_barrierattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_barrierattr_setpshared(a1: ptr Pthread_barrierattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cancel(a1: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_cleanup_pop(a1: cint) {.importc, header: "<pthread.h>", ...raises: [],
                                     tags: [].}
  Source   Edit
proc pthread_cleanup_push(a1: proc (x: pointer) {.noconv.}; a2: pointer) {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cond_broadcast(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cond_destroy(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cond_init(a1: ptr Pthread_cond; a2: ptr Pthread_condattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cond_signal(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cond_timedwait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex;
                            a3: ptr Timespec): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_cond_wait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_condattr_destroy(a1: ptr Pthread_condattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_condattr_getclock(a1: ptr Pthread_condattr; a2: var ClockId): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_condattr_getpshared(a1: ptr Pthread_condattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_condattr_init(a1: ptr Pthread_condattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_condattr_setclock(a1: ptr Pthread_condattr; a2: ClockId): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_condattr_setpshared(a1: ptr Pthread_condattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
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: [].}
  Source   Edit
proc pthread_detach(a1: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_equal(a1, a2: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_exit(a1: pointer) {.importc, header: "<pthread.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc pthread_getconcurrency(): cint {.importc, header: "<pthread.h>",
                                      ...raises: [], tags: [].}
  Source   Edit
proc pthread_getcpuclockid(a1: Pthread; a2: var ClockId): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_getschedparam(a1: Pthread; a2: var cint; a3: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_getspecific(a1: Pthread_key): pointer {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_join(a1: Pthread; a2: ptr pointer): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_key_create(a1: ptr Pthread_key; a2: proc (x: pointer) {.noconv.}): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_key_delete(a1: Pthread_key): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_kill(a1: Pthread; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_destroy(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_getprioceiling(a1: ptr Pthread_mutex; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_init(a1: ptr Pthread_mutex; a2: ptr Pthread_mutexattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_lock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_setprioceiling(a1: ptr Pthread_mutex; a2: cint; a3: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_timedlock(a1: ptr Pthread_mutex; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_trylock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutex_unlock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_destroy(a1: ptr Pthread_mutexattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_getprioceiling(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_getprotocol(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_getpshared(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_gettype(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_init(a1: ptr Pthread_mutexattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_setprioceiling(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_setprotocol(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_setpshared(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_mutexattr_settype(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_once(a1: ptr Pthread_once; a2: proc () {.noconv.}): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_destroy(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_init(a1: ptr Pthread_rwlock; a2: ptr Pthread_rwlockattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_rdlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_timedrdlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_timedwrlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_tryrdlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_trywrlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_unlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlock_wrlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlockattr_destroy(a1: ptr Pthread_rwlockattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlockattr_getpshared(a1: ptr Pthread_rwlockattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlockattr_init(a1: ptr Pthread_rwlockattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_rwlockattr_setpshared(a1: ptr Pthread_rwlockattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_self(): Pthread {.importc, header: "<pthread.h>", ...raises: [],
                               tags: [].}
  Source   Edit
proc pthread_setcancelstate(a1: cint; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_setcanceltype(a1: cint; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_setconcurrency(a1: cint): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc pthread_setschedparam(a1: Pthread; a2: cint; a3: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_setschedprio(a1: Pthread; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_setspecific(a1: Pthread_key; a2: pointer): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_sigmask(a1: cint; a2, a3: var Sigset): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_spin_destroy(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_spin_init(a1: ptr Pthread_spinlock; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_spin_lock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_spin_trylock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_spin_unlock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pthread_testcancel() {.importc, header: "<pthread.h>", ...raises: [], tags: [].}
  Source   Edit
proc pwrite(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc read(a1: cint; a2: pointer; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc readdir(a1: ptr DIR): ptr Dirent {.importc, header: "<dirent.h>",
                                        sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc readdir_r(a1: ptr DIR; a2: ptr Dirent; a3: ptr ptr Dirent): cint {.importc,
    header: "<dirent.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc readlink(a1, a2: cstring; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc readv(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
    header: "<sys/uio.h>", ...raises: [], tags: [].}
  Source   Edit
proc realpath(name, resolved: cstring): cstring {.importc: "realpath",
    header: "<stdlib.h>", ...raises: [], tags: [].}
  Source   Edit
proc recv(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
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: [].}
  Source   Edit
proc recvmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc rewinddir(a1: ptr DIR) {.importc, header: "<dirent.h>", ...raises: [],
                              tags: [].}
  Source   Edit
proc rmdir(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc S_ISBLK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [].}
Test for a block special file.   Source   Edit
proc S_ISCHR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [].}
Test for a character special file.   Source   Edit
proc S_ISDIR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [].}
Test for a directory.   Source   Edit
proc S_ISFIFO(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                               tags: [].}
Test for a pipe or FIFO special file.   Source   Edit
proc S_ISLNK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [].}
Test for a symbolic link.   Source   Edit
proc S_ISREG(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [].}
Test for a regular file.   Source   Edit
proc S_ISSOCK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                               tags: [].}
Test for a socket.   Source   Edit
proc S_TYPEISMQ(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                       ...raises: [], tags: [].}
Test for a message queue.   Source   Edit
proc S_TYPEISSEM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [].}
Test for a semaphore.   Source   Edit
proc S_TYPEISSHM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [].}
Test for a shared memory object.   Source   Edit
proc S_TYPEISTMO(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [].}
Test macro for a typed memory object.   Source   Edit
proc sched_get_priority_max(a1: cint): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sched_get_priority_min(a1: cint): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sched_getparam(a1: Pid; a2: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [].}
  Source   Edit
proc sched_getscheduler(a1: Pid): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sched_rr_get_interval(a1: Pid; a2: var Timespec): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [].}
  Source   Edit
proc sched_setparam(a1: Pid; a2: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [].}
  Source   Edit
proc sched_setscheduler(a1: Pid; a2: cint; a3: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [].}
  Source   Edit
proc sched_yield(): cint {.importc, header: "<sched.h>", ...raises: [], tags: [].}
  Source   Edit
proc seekdir(a1: ptr DIR; a2: int) {.importc, header: "<dirent.h>", ...raises: [],
                                     tags: [].}
  Source   Edit
proc select(a1: cint | SocketHandle; a2, a3, a4: ptr TFdSet; a5: ptr Timeval): cint {.
    importc, header: "<sys/select.h>", ...raises: [], tags: [].}
  Source   Edit
proc sem_close(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                    ...raises: [], tags: [].}
  Source   Edit
proc sem_destroy(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                      ...raises: [], tags: [].}
  Source   Edit
proc sem_getvalue(a1: ptr Sem; a2: var cint): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [].}
  Source   Edit
proc sem_init(a1: ptr Sem; a2: cint; a3: cint): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [].}
  Source   Edit
proc sem_open(a1: cstring; a2: cint): ptr Sem {.varargs, importc,
    header: "<semaphore.h>", ...raises: [], tags: [].}
  Source   Edit
proc sem_post(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc sem_timedwait(a1: ptr Sem; a2: ptr Timespec): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [].}
  Source   Edit
proc sem_trywait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                      ...raises: [], tags: [].}
  Source   Edit
proc sem_unlink(a1: cstring): cint {.importc, header: "<semaphore.h>",
                                     ...raises: [], tags: [].}
  Source   Edit
proc sem_wait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc send(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc sendmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc sendto(a1: SocketHandle; a2: pointer; a3: int; a4: cint; a5: ptr SockAddr;
            a6: SockLen): int {.importc, header: "<sys/socket.h>", sideEffect,
                                ...raises: [], tags: [].}
  Source   Edit
proc setcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc setegid(a1: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [].}
  Source   Edit
proc seteuid(a1: Uid): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [].}
  Source   Edit
proc setgid(a1: Gid): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc setgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [].}
  Source   Edit
proc sethostent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc setlocale(a1: cint; a2: cstring): cstring {.importc, header: "<locale.h>",
    sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc setnetent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc setpgid(a1, a2: Pid): cint {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [].}
  Source   Edit
proc setpgrp(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc setprotoent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc setpwent() {.importc, header: "<pwd.h>", ...raises: [], tags: [].}
  Source   Edit
proc setregid(a1, a2: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc setreuid(a1, a2: Uid): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [].}
  Source   Edit
proc setrlimit(resource: cint; rlp: var RLimit): cint {.importc: "setrlimit",
    header: "<sys/resource.h>", ...raises: [], tags: [].}
The setrlimit() system calls sets resource limits.   Source   Edit
proc setservent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [].}
  Source   Edit
proc setsid(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc setsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: SockLen): cint {.
    importc, header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc setuid(a1: Uid): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc shm_open(a1: cstring; a2: cint; a3: Mode): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [].}
  Source   Edit
proc shm_unlink(a1: cstring): cint {.importc, header: "<sys/mman.h>",
                                     ...raises: [], tags: [].}
  Source   Edit
proc shutdown(a1: SocketHandle; a2: cint): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigaction(a1: cint; a2, a3: var Sigaction): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigaction(a1: cint; a2: var Sigaction; a3: ptr Sigaction = nil): cint {.
    importc, header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigaddset(a1: var Sigset; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sigaltstack(a1, a2: var Stack): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sigdelset(a1: var Sigset; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sigemptyset(a1: var Sigset): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc sigfillset(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc sighold(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                               tags: [].}
  Source   Edit
proc sigignore(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc siginterrupt(a1, a2: cint): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc sigismember(a1: var Sigset; a2: cint): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc signal(a1: cint; a2: Sighandler) {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc sigpause(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc sigpending(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc sigprocmask(a1: cint; a2, a3: var Sigset): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigqueue(a1: Pid; a2: cint; a3: SigVal): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigrelse(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc sigset(a1: int; a2: proc (x: cint) {.noconv.}) {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigsuspend(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                        ...raises: [], tags: [].}
  Source   Edit
proc sigtimedwait(a1: var Sigset; a2: var SigInfo; a3: var Timespec): cint {.
    importc, header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigwait(a1: var Sigset; a2: var cint): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sigwaitinfo(a1: var Sigset; a2: var SigInfo): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [].}
  Source   Edit
proc sleep(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc sockatmark(a1: cint): cint {.importc, header: "<sys/socket.h>", ...raises: [],
                                  tags: [].}
  Source   Edit
proc socket(a1, a2, a3: cint): SocketHandle {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc socketpair(a1, a2, a3: cint; a4: var array[0 .. 1, cint]): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [].}
  Source   Edit
proc st_atim(s: Stat): Timespec {.inline, ...raises: [], tags: [].}
Nanosecond-granularity time of last access.   Source   Edit
proc st_ctim(s: Stat): Timespec {.inline, ...raises: [], tags: [].}
Nanosecond-granularity time of last data modification.   Source   Edit
proc st_mtim(s: Stat): Timespec {.inline, ...raises: [], tags: [].}
Nanosecond-granularity time of last data modification.   Source   Edit
proc stat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc statvfs(a1: cstring; a2: var Statvfs): cint {.importc,
    header: "<sys/statvfs.h>", ...raises: [], tags: [].}
  Source   Edit
proc strerror(errnum: cint): cstring {.importc, header: "<string.h>",
                                       ...raises: [], tags: [].}
  Source   Edit
proc strfmon(a1: cstring; a2: int; a3: cstring): int {.varargs, importc,
    header: "<monetary.h>", ...raises: [], tags: [].}
  Source   Edit
proc strftime(a1: cstring; a2: int; a3: cstring; a4: var Tm): int {.importc,
    header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc strptime(a1, a2: cstring; a3: var Tm): cstring {.importc,
    header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc swab(a1, a2: pointer; a3: int) {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [].}
  Source   Edit
proc swapcontext(a1, a2: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc symlink(a1, a2: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [].}
  Source   Edit
proc sync() {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc sysconf(a1: cint): int {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [].}
  Source   Edit
proc tcgetpgrp(a1: cint): Pid {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc tcsetpgrp(a1: cint; a2: Pid): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc telldir(a1: ptr DIR): int {.importc, header: "<dirent.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc time(a1: var Time): Time {.importc, header: "<time.h>", sideEffect,
                                ...raises: [], tags: [].}
  Source   Edit
proc timegm(a1: var Tm): Time {.importc, header: "<time.h>", ...raises: [],
                                tags: [].}
  Source   Edit
proc timer_create(a1: ClockId; a2: var SigEvent; a3: var Timer): cint {.importc,
    header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc timer_delete(a1: Timer): cint {.importc, header: "<time.h>", ...raises: [],
                                     tags: [].}
  Source   Edit
proc timer_getoverrun(a1: Timer): cint {.importc, header: "<time.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc timer_gettime(a1: Timer; a2: var Itimerspec): cint {.importc,
    header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc timer_settime(a1: Timer; a2: cint; a3: var Itimerspec; a4: var Itimerspec): cint {.
    importc, header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc truncate(a1: cstring; a2: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc ttyname(a1: cint): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [].}
  Source   Edit
proc ttyname_r(a1: cint; a2: cstring; a3: int): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc tzset() {.importc, header: "<time.h>", ...raises: [], tags: [].}
  Source   Edit
proc ualarm(a1, a2: Useconds): Useconds {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc umask(a1: Mode): Mode {.importc, header: "<sys/stat.h>", ...raises: [],
                             tags: [].}
  Source   Edit
proc uname(a1: var Utsname): cint {.importc, header: "<sys/utsname.h>",
                                    ...raises: [], tags: [].}
  Source   Edit
proc unlink(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                 tags: [].}
  Source   Edit
proc usleep(a1: Useconds): cint {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [].}
  Source   Edit
proc utimes(path: cstring; times: ptr array[2, Timeval]): int {.
    importc: "utimes", header: "<sys/time.h>", sideEffect, ...raises: [], tags: [].}

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

  Source   Edit
proc vfork(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [].}
  Source   Edit
proc wait(a1: ptr cint): Pid {.importc, discardable, header: "<sys/wait.h>",
                               sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc wait4(pid: Pid; status: ptr cint; options: cint; rusage: ptr Rusage): Pid {.
    importc, header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc waitid(a1: cint; a2: Id; a3: var SigInfo; a4: cint): cint {.importc,
    header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc waitpid(a1: Pid; a2: var cint; a3: cint): Pid {.importc,
    header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [].}
  Source   Edit
proc WEXITSTATUS(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                                  tags: [].}
Exit code, if WIFEXITED(s)   Source   Edit
proc WIFCONTINUED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                   tags: [].}
True if child has been continued.   Source   Edit
proc WIFEXITED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                tags: [].}
True if child exited normally.   Source   Edit
proc WIFSIGNALED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                  tags: [].}
True if child exited due to uncaught signal.   Source   Edit
proc WIFSTOPPED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                 tags: [].}
True if child is currently stopped.   Source   Edit
proc write(a1: cint; a2: pointer; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [].}
  Source   Edit
proc writev(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
    header: "<sys/uio.h>", ...raises: [], tags: [].}
  Source   Edit
proc WSTOPSIG(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                               tags: [].}
Stop signal, if WIFSTOPPED(s)   Source   Edit
proc WTERMSIG(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                               tags: [].}
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
  Source   Edit