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 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*: int                ## 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