# std/posix

Theme:

- Manual
- Standard library
- Index
- Compiler docs
- Fusion docs
- devel, stable

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 defined(linux) or defined(macosx) or defined(freebsd) or defined(netbsd) or
          defined(openbsd) or
          defined(genode):
        d_reclen*: cshort        ## Length of this record. (not POSIX)
        d_type*: int8 ## Type of file; not supported by all filesystem types.
                      ## (not POSIX)
        when defined(linux) or defined(openbsd):
          d_off*: Off            ## Not an offset. Value that `telldir()` would return.
      elif defined(haiku):
        d_pino*: Ino             ## Parent inode (only for queries) (not POSIX)
        d_reclen*: cushort       ## Length of this record. (not POSIX)
      d_name*: array[0 .. 255, char] ## Name of entry.

  dirent_t struct Source Edit

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

  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

    InAddrScalar = uint32

  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

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

  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>".} = cuint

  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 {.importc: "ABDAY_1", header: "<langinfo.h>".}: cint

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  error variable Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    MAP_POPULATE: cint = 0

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

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

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    YESEXPR {.importc: "YESEXPR", header: "<langinfo.h>".}: 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

    Sockaddr_max_length = 255

  Source Edit

    Sockaddr_un_path_length = 92

  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: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  is Posix's `bind`, because `bind` is a reserved word Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc chmod(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc clock(): Clock {.importc, header: "<time.h>", sideEffect, ...raises: [],
                          tags: [], forbids: [].}

  Source Edit

    proc clock_getcpuclockid(a1: Pid; a2: var ClockId): cint {.importc,
        header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc clock_getres(a1: ClockId; a2: var Timespec): cint {.importc,
        header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc clock_gettime(a1: ClockId; a2: var Timespec): cint {.importc,
        header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc clock_nanosleep(a1: ClockId; a2: cint; a3: var Timespec; a4: var Timespec): cint {.
        importc, header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc clock_settime(a1: ClockId; a2: var Timespec): cint {.importc,
        header: "<time.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc closedir(a1: ptr DIR): cint {.importc, header: "<dirent.h>", ...raises: [],
                                       tags: [], forbids: [].}

  Source Edit

    proc CMSG_DATA(cmsg: ptr Tcmsghdr): cstring {.importc, header: "<sys/socket.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc CMSG_FIRSTHDR(mhdr: ptr Tmsghdr): ptr Tcmsghdr {.importc,
        header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc CMSG_LEN(len: csize_t): csize_t {.importc, header: "<sys/socket.h>",
                                           ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc CMSG_NXTHDR(mhdr: ptr Tmsghdr; cmsg: ptr Tcmsghdr): ptr Tcmsghdr {.importc,
        header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc CMSG_SPACE(len: csize_t): csize_t {.importc, header: "<sys/socket.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc difftime(a1, a2: Time): cdouble {.importc, header: "<time.h>", ...raises: [],
                                           tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc dlclose(a1: pointer): cint {.importc, header: "<dlfcn.h>", sideEffect,
                                      ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc dlerror(): cstring {.importc, header: "<dlfcn.h>", sideEffect, ...raises: [],
                              tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc dlsym(a1: pointer; a2: cstring): pointer {.importc, header: "<dlfcn.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc encrypt(a1: array[0 .. 63, char]; a2: cint) {.importc,
        header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc endgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc endhostent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                        forbids: [].}

  Source Edit

    proc endnetent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                       forbids: [].}

  Source Edit

    proc endprotoent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                         forbids: [].}

  Source Edit

    proc endpwent() {.importc, header: "<pwd.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc endservent() {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                        forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc exitnow(code: cint) {.importc: "_exit", header: "<unistd.h>", noreturn,
                               ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc fchmod(a1: cint; a2: Mode): cint {.importc, header: "<sys/stat.h>",
                                            sideEffect, ...raises: [], tags: [],
                                            forbids: [].}

  Source Edit

    proc fchown(a1: cint; a2: Uid; a3: Gid): cint {.importc, header: "<unistd.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc fcntl(a1: cint | SocketHandle; a2: cint): cint {.varargs, importc,
        header: "<fcntl.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc FD_CLR(a1: cint; a2: var TFdSet) {.importc, header: "<sys/select.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc FD_ISSET(a1: cint | SocketHandle; a2: var TFdSet): cint {.importc,
        header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc FD_SET(a1: cint | SocketHandle; a2: var TFdSet) {.importc: "FD_SET",
        header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc FD_ZERO(a1: var TFdSet) {.importc, header: "<sys/select.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc fmtmsg(a1: int; a2: cstring; a3: cint; a4, a5, a6: cstring): cint {.
        importc, header: "<fmtmsg.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc fork(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                       tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc freeAddrInfo(a1: ptr AddrInfo) {.importc: "freeaddrinfo",
                                          header: "<netdb.h>", ...raises: [], tags: [],
                                          forbids: [].}

  Source Edit

    proc fstat(a1: cint; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc fstatvfs(a1: cint; a2: var Statvfs): cint {.importc,
        header: "<sys/statvfs.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  synchronize a file's buffer cache to the storage device Source Edit

    proc ftok(a1: cstring; a2: cint): Key {.importc, header: "<sys/ipc.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  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: [],
                               forbids: [].}

  Source Edit

    proc gai_strerror(a1: cint): cstring {.importc: "(char *)$1",
                                           header: "<netdb.h>", ...raises: [],
                                           tags: [], forbids: [].}

  Source Edit

    proc getaddrinfo(a1, a2: cstring; a3: ptr AddrInfo; a4: var ptr AddrInfo): cint {.
        importc, header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc getcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc getegid(): Gid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                          tags: [], forbids: [].}

  returns the effective group ID of the calling process Source Edit

    proc geteuid(): Uid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                          tags: [], forbids: [].}

  returns the effective user ID of the calling process Source Edit

    proc getgid(): Gid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                         tags: [], forbids: [].}

  returns the real group ID of the calling process Source Edit

    proc getgrent(): ptr Group {.importc, header: "<grp.h>", ...raises: [], tags: [],
                                 forbids: [].}

  Source Edit

    proc getgrgid(a1: Gid): ptr Group {.importc, header: "<grp.h>", ...raises: [],
                                        tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc getgrnam(a1: cstring): ptr Group {.importc, header: "<grp.h>", ...raises: [],
                                            tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc getgroups(a1: cint; a2: ptr array[0 .. 255, Gid]): cint {.importc,
        header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc gethostbyaddr(a1: pointer; a2: SockLen; a3: cint): ptr Hostent {.importc,
        header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc gethostbyname(a1: cstring): ptr Hostent {.importc, header: "<netdb.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc gethostent(): ptr Hostent {.importc, header: "<netdb.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

    proc gethostid(): int {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                            tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc getlogin(): cstring {.importc, header: "<unistd.h>", sideEffect,
                               ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  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: [], forbids: [].}

  Source Edit

    proc getnetbyaddr(a1: int32; a2: cint): ptr Tnetent {.importc,
        header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc getnetbyname(a1: cstring): ptr Tnetent {.importc, header: "<netdb.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc getnetent(): ptr Tnetent {.importc, header: "<netdb.h>", ...raises: [],
                                    tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc getpid(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                         tags: [], forbids: [].}

  returns the process ID (PID) of the calling process Source Edit

    proc getppid(): Pid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                          tags: [], forbids: [].}

  returns the process ID of the parent of the calling process Source Edit

    proc getprotobyname(a1: cstring): ptr Protoent {.importc, header: "<netdb.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc getprotobynumber(a1: cint): ptr Protoent {.importc, header: "<netdb.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc getprotoent(): ptr Protoent {.importc, header: "<netdb.h>", ...raises: [],
                                       tags: [], forbids: [].}

  Source Edit

    proc getpwent(): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [], tags: [],
                                  forbids: [].}

  Source Edit

    proc getpwnam(a1: cstring): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
        tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc getpwuid(a1: Uid): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
                                         tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc getrlimit(resource: cint; rlp: var RLimit): cint {.importc: "getrlimit",
        header: "<sys/resource.h>", ...raises: [], tags: [], forbids: [].}

  The getrlimit() system call gets resource limits. Source Edit

    proc getrusage(who: cint; rusage: ptr Rusage): cint {.importc,
        header: "<sys/resource.h>", discardable, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc getservbyname(a1, a2: cstring): ptr Servent {.importc, header: "<netdb.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc getservent(): ptr Servent {.importc, header: "<netdb.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

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

  returns the session ID of the calling process Source Edit

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

  Source Edit

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

  Source Edit

    proc getuid(): Uid {.importc, header: "<unistd.h>", sideEffect, ...raises: [],
                         tags: [], forbids: [].}

  returns the real user ID of the calling process Source Edit

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

  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: [], forbids: [].}

  Filename globbing. Use os.walkPattern() and similar. Source Edit

    proc globfree(a1: ptr Glob) {.importc, header: "<glob.h>", ...raises: [], tags: [],
                                  forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc hstrerror(herrnum: cint): cstring {.importc: "(char *)$1",
        header: "<netdb.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc htonl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

    proc htons(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                     tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc iconv_open(a1, a2: cstring): Iconv {.importc, header: "<iconv.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc if_freenameindex(a1: ptr Tif_nameindex) {.importc, header: "<net/if.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc if_nameindex(): ptr Tif_nameindex {.importc, header: "<net/if.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc if_nametoindex(a1: cstring): cint {.importc, header: "<net/if.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc IN6_IS_ADDR_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Unicast link-local address. Source Edit

    proc IN6_IS_ADDR_LOOPBACK(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Loopback address. Source Edit

    proc IN6_IS_ADDR_MC_GLOBAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Multicast global address. Source Edit

    proc IN6_IS_ADDR_MC_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Multicast link-local address. Source Edit

    proc IN6_IS_ADDR_MC_NODELOCAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Multicast node-local address. Source Edit

    proc IN6_IS_ADDR_MC_ORGLOCAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Multicast organization-local address. Source Edit

    proc IN6_IS_ADDR_MC_SITELOCAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Multicast site-local address. Source Edit

    proc IN6_IS_ADDR_MULTICAST(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Multicast address. Source Edit

    proc IN6_IS_ADDR_SITELOCAL(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Unicast site-local address. Source Edit

    proc IN6_IS_ADDR_UNSPECIFIED(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  Unspecified address. Source Edit

    proc IN6_IS_ADDR_V4COMPAT(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  IPv4-compatible address. Source Edit

    proc IN6_IS_ADDR_V4MAPPED(a1: ptr In6Addr): cint {.importc,
        header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

  IPv4 mapped address. Source Edit

    proc IN6ADDR_ANY_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                       ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc IN6ADDR_LOOPBACK_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc inet_addr(a1: cstring): InAddrT {.importc, header: "<arpa/inet.h>",
                                           ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc inet_ntoa(a1: InAddr): cstring {.importc, header: "<arpa/inet.h>",
                                          ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc inet_ntop(a1: cint; a2: pointer | ptr InAddr | ptr In6Addr; a3: cstring;
                   a4: int32): cstring {.importc: "(char *)$1",
                                         header: "<arpa/inet.h>", ...raises: [],
                                         tags: [], forbids: [].}

  Source Edit

    proc inet_pton(a1: cint; a2: cstring; a3: pointer | ptr InAddr | ptr In6Addr): cint {.
        importc, header: "<arpa/inet.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc ioctl(f: FileHandle; device: uint): int {.importc: "ioctl",
        header: "<sys/ioctl.h>", varargs, ...tags: [WriteIOEffect], raises: [],
        forbids: [].}

  A system call for device-specific input/output operations and other operations which cannot be expressed by regular system calls Source Edit

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

  Source Edit

    proc kill(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>", sideEffect,
                                         ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc killpg(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>",
                                           sideEffect, ...raises: [], tags: [],
                                           forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc listen(a1: SocketHandle; a2: cint): cint {.importc,
        header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc localeconv(): ptr Lconv {.importc, header: "<locale.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc lstat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc makecontext(a1: var Ucontext; a4: proc () {.noconv.}; a3: cint) {.varargs,
        importc, header: "<ucontext.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mkdir(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  Use os.createDir() and similar. Source Edit

    proc mkdtemp(tmpl: cstring): pointer {.importc, header: "<stdlib.h>",
                                           sideEffect, ...raises: [], tags: [],
                                           forbids: [].}

  Source Edit

    proc mkfifo(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mknod(a1: cstring; a2: Mode; a3: Dev): cint {.importc,
        header: "<sys/stat.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mkstemp(tmpl: cstring): cint {.importc, header: "<stdlib.h>", sideEffect,
                                        ...raises: [], tags: [], forbids: [].}

  Creates a unique temporary file.
  Warning: The `tmpl` argument is written to by `mkstemp` and thus can't be a string literal. If in doubt make a copy of the cstring before passing it in.
  Source Edit

    proc mkstemps(tmpl: cstring; suffixlen: int): cint {.importc,
        header: "<stdlib.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Creates a unique temporary file.
  Warning: The `tmpl` argument is written to by `mkstemps` and thus can't be a string literal. If in doubt make a copy of the cstring before passing it in.
  Source Edit

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

  Source Edit

    proc mlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mlockall(a1: cint): cint {.importc, header: "<sys/mman.h>", ...raises: [],
                                    tags: [], forbids: [].}

  Source Edit

    proc mmap(a1: pointer; a2: int; a3, a4, a5: cint; a6: Off): pointer {.importc,
        header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mprotect(a1: pointer; a2: int; a3: cint): cint {.importc,
        header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_close(mqdes: Mqd): cint {.importc, header: "<mqueue.h>", ...raises: [],
                                      tags: [], forbids: [].}

  Source Edit

    proc mq_getattr(mqdes: Mqd; attribute: ptr MqAttr): cint {.importc,
        header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_notify(mqdes: Mqd; event: ptr SigEvent): cint {.importc,
        header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_open(name: cstring; flags: cint): Mqd {.varargs, importc,
        header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_receive(mqdes: Mqd; buffer: cstring; length: csize_t;
                    priority: var cuint): int {.importc, header: "<mqueue.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_send(mqdes: Mqd; buffer: cstring; length: csize_t; priority: cuint): cint {.
        importc, header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_setattr(mqdes: Mqd; newAttribute, oldAttribute: ptr MqAttr): cint {.
        importc, header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_timedreceive(mqdes: Mqd; buffer: cstring; length: csize_t;
                         priority: cuint; timeout: ptr Timespec): int {.importc,
        header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_timedsend(mqdes: Mqd; buffer: cstring; length: csize_t; priority: cuint;
                      timeout: ptr Timespec): cint {.importc, header: "<mqueue.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc mq_unlink(mqdes: cstring): cint {.importc, header: "<mqueue.h>",
                                           ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc msync(a1: pointer; a2: int; a3: cint): cint {.importc,
        header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc munlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc munlockall(): cint {.importc, header: "<sys/mman.h>", ...raises: [], tags: [],
                              forbids: [].}

  Source Edit

    proc munmap(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc nanosleep(a1, a2: var Timespec): cint {.importc, header: "<time.h>",
        sideEffect, ...raises: [], tags: [], forbids: [].}

  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: [],
                                forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc ntohl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

    proc ntohs(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                     tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc pclose(a: File): cint {.importc, header: "<stdio.h>", ...raises: [], tags: [],
                                 forbids: [].}

  Source Edit

    proc pipe(a: array[0 .. 1, cint]): cint {.importc, header: "<unistd.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc poll(a1: ptr TPollfd; a2: Tnfds; a3: cint): cint {.importc,
        header: "<poll.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc popen(a1, a2: cstring): File {.importc, header: "<stdio.h>", ...raises: [],
                                        tags: [], forbids: [].}

  Source Edit

    proc posix_fadvise(a1: cint; a2, a3: Off; a4: cint): cint {.importc,
        header: "<fcntl.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_fallocate(a1: cint; a2, a3: Off): cint {.importc,
        header: "<fcntl.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_madvise(a1: pointer; a2: int; a3: cint): cint {.importc,
        header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  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: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc posix_spawn_file_actions_addclose(a1: var Tposix_spawn_file_actions;
                                           a2: cint): cint {.importc,
        header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawn_file_actions_adddup2(a1: var Tposix_spawn_file_actions;
                                          a2, a3: cint): cint {.importc,
        header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc posix_spawn_file_actions_destroy(a1: var Tposix_spawn_file_actions): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawn_file_actions_init(a1: var Tposix_spawn_file_actions): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_destroy(a1: var Tposix_spawnattr): cint {.importc,
        header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_getflags(a1: var Tposix_spawnattr; a2: var cshort): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_getpgroup(a1: var Tposix_spawnattr; a2: var Pid): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_getschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_getschedpolicy(a1: var Tposix_spawnattr; a2: var cint): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_getsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_getsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_init(a1: var Tposix_spawnattr): cint {.importc,
        header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_setflags(a1: var Tposix_spawnattr; a2: cint): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_setpgroup(a1: var Tposix_spawnattr; a2: Pid): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_setschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_setschedpolicy(a1: var Tposix_spawnattr; a2: cint): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_setsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_spawnattr_setsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
        importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc posix_typed_mem_get_info(a1: cint; a2: var Posix_typed_mem_info): cint {.
        importc, header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc posix_typed_mem_open(a1: cstring; a2, a3: cint): cint {.importc,
        header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pread(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
        header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

    proc pthread_atfork(a1, a2, a3: proc () {.noconv.}): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_destroy(a1: ptr Pthread_attr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getguardsize(a1: ptr Pthread_attr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getinheritsched(a1: ptr Pthread_attr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getschedpolicy(a1: ptr Pthread_attr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getscope(a1: ptr Pthread_attr; a2: var cint): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getstack(a1: ptr Pthread_attr; a2: var pointer; a3: var int): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getstackaddr(a1: ptr Pthread_attr; a2: var pointer): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_getstacksize(a1: ptr Pthread_attr; a2: var int): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_init(a1: ptr Pthread_attr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setguardsize(a1: ptr Pthread_attr; a2: int): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setinheritsched(a1: ptr Pthread_attr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setschedpolicy(a1: ptr Pthread_attr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setscope(a1: ptr Pthread_attr; a2: cint): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setstack(a1: ptr Pthread_attr; a2: pointer; a3: int): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setstackaddr(a1: ptr Pthread_attr; a2: pointer): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_attr_setstacksize(a1: ptr Pthread_attr; a2: int): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrier_destroy(a1: ptr Pthread_barrier): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrier_init(a1: ptr Pthread_barrier; a2: ptr Pthread_barrierattr;
                              a3: cint): cint {.importc, header: "<pthread.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrier_wait(a1: ptr Pthread_barrier): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrierattr_destroy(a1: ptr Pthread_barrierattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrierattr_getpshared(a1: ptr Pthread_barrierattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrierattr_init(a1: ptr Pthread_barrierattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_barrierattr_setpshared(a1: ptr Pthread_barrierattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc pthread_cond_broadcast(a1: ptr Pthread_cond): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_cond_destroy(a1: ptr Pthread_cond): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_cond_init(a1: ptr Pthread_cond; a2: ptr Pthread_condattr): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_cond_signal(a1: ptr Pthread_cond): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_cond_timedwait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex;
                                a3: ptr Timespec): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_cond_wait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_condattr_destroy(a1: ptr Pthread_condattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_condattr_getclock(a1: ptr Pthread_condattr; a2: var ClockId): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_condattr_getpshared(a1: ptr Pthread_condattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_condattr_init(a1: ptr Pthread_condattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_condattr_setclock(a1: ptr Pthread_condattr; a2: ClockId): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_condattr_setpshared(a1: ptr Pthread_condattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc pthread_equal(a1, a2: Pthread): cint {.importc, header: "<pthread.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_exit(a1: pointer) {.importc, header: "<pthread.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc pthread_getcpuclockid(a1: Pthread; a2: var ClockId): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_getschedparam(a1: Pthread; a2: var cint; a3: ptr Sched_param): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_getspecific(a1: Pthread_key): pointer {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_join(a1: Pthread; a2: ptr pointer): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc pthread_mutex_destroy(a1: ptr Pthread_mutex): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_getprioceiling(a1: ptr Pthread_mutex; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_init(a1: ptr Pthread_mutex; a2: ptr Pthread_mutexattr): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_lock(a1: ptr Pthread_mutex): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_setprioceiling(a1: ptr Pthread_mutex; a2: cint; a3: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_timedlock(a1: ptr Pthread_mutex; a2: ptr Timespec): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_trylock(a1: ptr Pthread_mutex): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutex_unlock(a1: ptr Pthread_mutex): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_destroy(a1: ptr Pthread_mutexattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_getprioceiling(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_getprotocol(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_getpshared(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_gettype(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_init(a1: ptr Pthread_mutexattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_setprioceiling(a1: ptr Pthread_mutexattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_setprotocol(a1: ptr Pthread_mutexattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_setpshared(a1: ptr Pthread_mutexattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_mutexattr_settype(a1: ptr Pthread_mutexattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_once(a1: ptr Pthread_once; a2: proc () {.noconv.}): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_destroy(a1: ptr Pthread_rwlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_init(a1: ptr Pthread_rwlock; a2: ptr Pthread_rwlockattr): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_rdlock(a1: ptr Pthread_rwlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_timedrdlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_timedwrlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_tryrdlock(a1: ptr Pthread_rwlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_trywrlock(a1: ptr Pthread_rwlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_unlock(a1: ptr Pthread_rwlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlock_wrlock(a1: ptr Pthread_rwlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlockattr_destroy(a1: ptr Pthread_rwlockattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlockattr_getpshared(a1: ptr Pthread_rwlockattr; a2: var cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlockattr_init(a1: ptr Pthread_rwlockattr): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_rwlockattr_setpshared(a1: ptr Pthread_rwlockattr; a2: cint): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_self(): Pthread {.importc, header: "<pthread.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Source Edit

    proc pthread_setcancelstate(a1: cint; a2: var cint): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_setcanceltype(a1: cint; a2: var cint): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc pthread_setschedparam(a1: Pthread; a2: cint; a3: ptr Sched_param): cint {.
        importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_setschedprio(a1: Pthread; a2: cint): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_setspecific(a1: Pthread_key; a2: pointer): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_sigmask(a1: cint; a2, a3: var Sigset): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_spin_destroy(a1: ptr Pthread_spinlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_spin_init(a1: ptr Pthread_spinlock; a2: cint): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_spin_lock(a1: ptr Pthread_spinlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_spin_trylock(a1: ptr Pthread_spinlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_spin_unlock(a1: ptr Pthread_spinlock): cint {.importc,
        header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc pthread_testcancel() {.importc, header: "<pthread.h>", ...raises: [],
                                tags: [], forbids: [].}

  Source Edit

    proc pwrite(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
        header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc readdir(a1: ptr DIR): ptr Dirent {.importc, header: "<dirent.h>",
                                            sideEffect, ...raises: [], tags: [],
                                            forbids: [].}

  Source Edit

    proc readdir_r(a1: ptr DIR; a2: ptr Dirent; a3: ptr ptr Dirent): cint {.importc,
        header: "<dirent.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc readv(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
        header: "<sys/uio.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc realpath(name, resolved: cstring): cstring {.importc: "realpath",
        header: "<stdlib.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc recv(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
        header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  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: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc rewinddir(a1: ptr DIR) {.importc, header: "<dirent.h>", ...raises: [],
                                  tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc S_ISBLK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                  tags: [], forbids: [].}

  Test for a block special file. Source Edit

    proc S_ISCHR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                  tags: [], forbids: [].}

  Test for a character special file. Source Edit

    proc S_ISDIR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                  tags: [], forbids: [].}

  Test for a directory. Source Edit

    proc S_ISFIFO(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Test for a pipe or FIFO special file. Source Edit

    proc S_ISLNK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                  tags: [], forbids: [].}

  Test for a symbolic link. Source Edit

    proc S_ISREG(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                  tags: [], forbids: [].}

  Test for a regular file. Source Edit

    proc S_ISSOCK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Test for a socket. Source Edit

    proc S_TYPEISMQ(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                           ...raises: [], tags: [], forbids: [].}

  Test for a message queue. Source Edit

    proc S_TYPEISSEM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Test for a semaphore. Source Edit

    proc S_TYPEISSHM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Test for a shared memory object. Source Edit

    proc S_TYPEISTMO(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Test macro for a typed memory object. Source Edit

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

  Source Edit

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

  Source Edit

    proc sched_getparam(a1: Pid; a2: var Sched_param): cint {.importc,
        header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc sched_rr_get_interval(a1: Pid; a2: var Timespec): cint {.importc,
        header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sched_setparam(a1: Pid; a2: var Sched_param): cint {.importc,
        header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sched_setscheduler(a1: Pid; a2: cint; a3: var Sched_param): cint {.importc,
        header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc seekdir(a1: ptr DIR; a2: int) {.importc, header: "<dirent.h>", ...raises: [],
                                         tags: [], forbids: [].}

  Source Edit

    proc select(a1: cint | SocketHandle; a2, a3, a4: ptr TFdSet; a5: ptr Timeval): cint {.
        importc, header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_close(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_destroy(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                          ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_getvalue(a1: ptr Sem; a2: var cint): cint {.importc,
        header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_init(a1: ptr Sem; a2: cint; a3: cint): cint {.importc,
        header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_open(a1: cstring; a2: cint): ptr Sem {.varargs, importc,
        header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_post(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                       tags: [], forbids: [].}

  Source Edit

    proc sem_timedwait(a1: ptr Sem; a2: ptr Timespec): cint {.importc,
        header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sem_trywait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                          ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc sem_wait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                       tags: [], forbids: [].}

  Source Edit

    proc send(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
        header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  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: [], forbids: [].}

  Source Edit

    proc setcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc setgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc setpwent() {.importc, header: "<pwd.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc setrlimit(resource: cint; rlp: var RLimit): cint {.importc: "setrlimit",
        header: "<sys/resource.h>", ...raises: [], tags: [], forbids: [].}

  The setrlimit() system calls sets resource limits. Source Edit

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

  Source Edit

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

  Source Edit

    proc setsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: SockLen): cint {.
        importc, header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc shm_open(a1: cstring; a2: cint; a3: Mode): cint {.importc,
        header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc shm_unlink(a1: cstring): cint {.importc, header: "<sys/mman.h>",
                                         ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc shutdown(a1: SocketHandle; a2: cint): cint {.importc,
        header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigaction(a1: cint; a2, a3: var Sigaction): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigaction(a1: cint; a2: var Sigaction; a3: ptr Sigaction = nil): cint {.
        importc, header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigaddset(a1: var Sigset; a2: cint): cint {.importc, header: "<signal.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigaltstack(a1, a2: var Stack): cint {.importc, header: "<signal.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigdelset(a1: var Sigset; a2: cint): cint {.importc, header: "<signal.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigemptyset(a1: var Sigset): cint {.importc, header: "<signal.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigfillset(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc sigismember(a1: var Sigset; a2: cint): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc sigpending(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigprocmask(a1: cint; a2, a3: var Sigset): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigqueue(a1: Pid; a2: cint; a3: SigVal): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc sigsuspend(a1: var Sigset): cint {.importc, header: "<signal.h>",
                                            ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigtimedwait(a1: var Sigset; a2: var SigInfo; a3: var Timespec): cint {.
        importc, header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigwait(a1: var Sigset; a2: var cint): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc sigwaitinfo(a1: var Sigset; a2: var SigInfo): cint {.importc,
        header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc sockatmark(a1: cint): cint {.importc, header: "<sys/socket.h>", ...raises: [],
                                      tags: [], forbids: [].}

  Source Edit

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

  Source Edit

    proc socketpair(a1, a2, a3: cint; a4: var array[0 .. 1, cint]): cint {.importc,
        header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc st_atim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

  Nanosecond-granularity time of last access. Source Edit

    proc st_ctim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

  Nanosecond-granularity time of last data modification. Source Edit

    proc st_mtim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

  Nanosecond-granularity time of last data modification. Source Edit

    proc stat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc statvfs(a1: cstring; a2: var Statvfs): cint {.importc,
        header: "<sys/statvfs.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc strerror(errnum: cint): cstring {.importc, header: "<string.h>",
                                           ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc strfmon(a1: cstring; a2: int; a3: cstring): int {.varargs, importc,
        header: "<monetary.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc swab(a1, a2: pointer; a3: int) {.importc, header: "<unistd.h>", ...raises: [],
                                          tags: [], forbids: [].}

  Source Edit

    proc swapcontext(a1, a2: var Ucontext): cint {.importc, header: "<ucontext.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

    proc telldir(a1: ptr DIR): int {.importc, header: "<dirent.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc timer_create(a1: ClockId; a2: var SigEvent; a3: var Timer): cint {.importc,
        header: "<time.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

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

  Source Edit

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

  Source Edit

    proc timer_gettime(a1: Timer; a2: var Itimerspec): cint {.importc,
        header: "<time.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc timer_settime(a1: Timer; a2: cint; a3: var Itimerspec; a4: var Itimerspec): cint {.
        importc, header: "<time.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc truncate(a1: cstring; a2: Off): cint {.importc, header: "<unistd.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc ttyname(a1: cint): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [], forbids: [].}

  Source Edit

    proc ttyname_r(a1: cint; a2: cstring; a3: int): cint {.importc,
        header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc tzset() {.importc, header: "<time.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc ualarm(a1, a2: Useconds): Useconds {.importc, header: "<unistd.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc umask(a1: Mode): Mode {.importc, header: "<sys/stat.h>", ...raises: [],
                                 tags: [], forbids: [].}

  Source Edit

    proc uname(a1: var Utsname): cint {.importc, header: "<sys/utsname.h>",
                                        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc unlink(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                     tags: [], forbids: [].}

  Source Edit

    proc usleep(a1: Useconds): cint {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [], forbids: [].}

  Source Edit

    proc utimes(path: cstring; times: ptr array[2, Timeval]): int {.
        importc: "utimes", header: "<sys/time.h>", sideEffect, ...raises: [], tags: [],
        forbids: [].}

  Sets file access and modification times.

  Pass the filename and an array of times to set the access and modification times respectively. If you pass nil as the array both attributes will be set to the current time.

  Returns zero on success.

  For more information read https://www.unix.com/man-page/posix/3/utimes/.

  Source Edit

    proc vfork(): Pid {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                        forbids: [].}

  Source Edit

    proc wait(a1: ptr cint): Pid {.importc, discardable, header: "<sys/wait.h>",
                                   sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc wait4(pid: Pid; status: ptr cint; options: cint; rusage: ptr Rusage): Pid {.
        importc, header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [],
        forbids: [].}

  Source Edit

    proc waitid(a1: cint; a2: Id; a3: var SigInfo; a4: cint): cint {.importc,
        header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc waitpid(a1: Pid; a2: var cint; a3: cint): Pid {.importc,
        header: "<sys/wait.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc WEXITSTATUS(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                                      tags: [], forbids: [].}

  Exit code, if WIFEXITED(s) Source Edit

    proc WIFCONTINUED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                       tags: [], forbids: [].}

  True if child has been continued. Source Edit

    proc WIFEXITED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                    tags: [], forbids: [].}

  True if child exited normally. Source Edit

    proc WIFSIGNALED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                      tags: [], forbids: [].}

  True if child exited due to uncaught signal. Source Edit

    proc WIFSTOPPED(s: cint): bool {.importc, header: "<sys/wait.h>", ...raises: [],
                                     tags: [], forbids: [].}

  True if child is currently stopped. Source Edit

    proc write(a1: cint; a2: pointer; a3: int): int {.importc, header: "<unistd.h>",
        ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc writev(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
        header: "<sys/uio.h>", ...raises: [], tags: [], forbids: [].}

  Source Edit

    proc WSTOPSIG(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Stop signal, if WIFSTOPPED(s) Source Edit

    proc WTERMSIG(s: cint): cint {.importc, header: "<sys/wait.h>", ...raises: [],
                                   tags: [], forbids: [].}

  Termination signal, if WIFSIGNALED(s) Source Edit

# Templates

    template onSignal(signals: varargs[cint]; body: untyped)

  Setup code to be executed when Unix signals are received. The currently handled signal is injected as `sig` into the calling scope.

  Example:

      from std/posix import SIGINT, SIGTERM, onSignal
      onSignal(SIGINT, SIGTERM):
        echo "bye from signal ", sig

  Source Edit