Types

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

A type representing a directory stream.   Source Edit

SocketHandle = distinct cint

  Source Edit

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

  Source Edit

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

struct timespec   Source Edit

Dirent {...}{.importc: "struct dirent", header: "<dirent.h>", final, pure.} = object
  when defined(haiku):
      d_dev*: Dev            ## Device (not POSIX)
      d_pdev*: Dev           ## Parent device (only for queries) (not POSIX)
    
  d_ino*: Ino                ## File serial number.
  when defined(dragonfly):
      d_type*: uint8

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

dirent_t struct   Source Edit

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

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

  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

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

Identifies the conversion from one codeset to another.   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

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

  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

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

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

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  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

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

  Source Edit

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

  Source Edit

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

  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

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

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

  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

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

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

  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

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

struct itimerspec   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

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

  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

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

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

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

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

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

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

  Source Edit

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

  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

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

struct timeval   Source Edit

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

  Source Edit

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

  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

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

  Source Edit

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

struct sockaddr   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 - 1, char] ## Socket path
  

struct sockaddr_un   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

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

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

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

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

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

InPort = uint16

  Source Edit

InAddrScalar = uint32

  Source Edit

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

  Source Edit

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

struct in_addr   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

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

struct in6_addr   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

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

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

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

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

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

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

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

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

  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

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

  Source Edit