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.

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

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

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

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

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

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

Dirent {.importc: "struct dirent", header: "<dirent.h>", final, pure.} = object
  d_ino*: Ino
  d_off*: Off
  d_reclen*: cushort
  d_type*: int8
  d_name*: array[256, cchar]

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

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

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

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

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

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.

Iconv {.importc: "iconv_t", header: "<iconv.h>".} = pointer

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

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

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

InAddrScalar = uint32

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

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

InPort = uint16

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

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*: cshort              ## Read/write permission.

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

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

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

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

Mode {.importc: "mode_t", header: "<sys/types.h>".} = uint32

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

Mqd {.importc: "mqd_t", header: "<mqueue.h>".} = cint

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sched_param {.importc: "struct sched_param", header: "<sched.h>", final, pure.} = object
  sched_priority*: cint

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

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

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

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.
  ## not intended for application use.

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

SigInfo {.importc: "siginfo_t", header: "<signal.h>", final, pure.} = object
  si_signo*: cint            ## Signal number.
  si_errno*: cint            ## If non-zero, an errno value associated with
                             ## this signal, as defined in <errno.h>.
  si_code*: cint             ## Signal code.
  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.

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

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

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

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

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.

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*: uint32     ## IPv6 traffic class and flow information.
  sin6_addr*: In6Addr        ## IPv6 address.
  sin6_scope_id*: uint32     ## Set of interfaces for a scope.

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

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

SocketHandle = distinct cint

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

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

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_nlink*: Nlink           ## Number of hard links to the file.
  st_mode*: Mode             ## Mode of file (see below).
  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.
  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.
  st_atim*: Timespec         ## Time of last access.
  st_mtim*: Timespec         ## Time of last data modification.
  st_ctim*: Timespec         ## Time of last status change.

Statvfs {.importc: "struct statvfs", header: "<sys/statvfs.h>", final, pure.} = object
  f_bsize*: culong           ## File system block size.
  f_frsize*: culong          ## 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*: culong            ## File system ID.
  f_flag*: culong            ## Bit mask of f_flag values.
  f_namemax*: culong         ## Maximum filename length.

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

Taiocb {.importc: "struct aiocb", header: "<aio.h>", final, pure.} = object
  aio_fildes*: cint          ## File descriptor.
  aio_lio_opcode*: cint      ## Operation to be performed.
  aio_reqprio*: cint         ## Request priority offset.
  aio_buf*: pointer          ## Location of buffer.
  aio_nbytes*: csize_t       ## Length of transfer.
  aio_sigevent*: SigEvent    ## Signal number and value.
  aio_offset*: Off           ## File offset.

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

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

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

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

Time {.importc: "time_t", header: "<time.h>".} = distinct clong

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

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

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

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

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.

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.
  tm_gmtoff*: clong
  tm_zone*: cstring

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*: csize_t       ## Members in msg_iov.
  msg_control*: pointer      ## Ancillary data; see below.
  msg_controllen*: csize_t   ## Ancillary data buffer len.
  msg_flags*: cint           ## Flags on received message.

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*: uint32             ## The network number, in host byte order.

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

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

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

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

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

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

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

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

Utsname {.importc: "struct utsname", header: "<sys/utsname.h>", final, pure.} = object
  sysname*,                 ## 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*,                 ## Name of the hardware type on which the
                             ## system is running.
  domainname*: array[65, char]

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

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

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

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

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

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

ABDAY_1 = 131072'i32

ABDAY_2 = 131073'i32

ABDAY_3 = 131074'i32

ABDAY_4 = 131075'i32

ABDAY_5 = 131076'i32

ABDAY_6 = 131077'i32

ABDAY_7 = 131078'i32

ABMON_1 = 131086'i32

ABMON_2 = 131087'i32

ABMON_3 = 131088'i32

ABMON_4 = 131089'i32

ABMON_5 = 131090'i32

ABMON_6 = 131091'i32

ABMON_7 = 131092'i32

ABMON_8 = 131093'i32

ABMON_9 = 131094'i32

ABMON_10 = 131095'i32

ABMON_11 = 131096'i32

ABMON_12 = 131097'i32

AF_INET = 2'i32

AF_INET6 = 10'i32

AF_UNIX = 1'i32

AF_UNSPEC = 0'i32

AI_ADDRCONFIG = 32'i32

AI_ALL = 16'i32

AI_CANONNAME = 2'i32

AI_NUMERICHOST = 4'i32

AI_NUMERICSERV = 1024'i32

AI_PASSIVE = 1'i32

AI_V4MAPPED = 8'i32

AIO_ALLDONE = 2'i32

AIO_CANCELED = 0'i32

AIO_NOTCANCELED = 1'i32

ALT_DIGITS = 131119'i32

AM_STR = 131110'i32

CLOCK_MONOTONIC = 1'i32

CLOCK_PROCESS_CPUTIME_ID = 2'i32

CLOCK_REALTIME = 0'i32

CLOCK_THREAD_CPUTIME_ID = 3'i32

CLOCKS_PER_SEC = 1000000

CODESET = 14'i32

CRNCYSTR = 262159'i32

CS_PATH = 0'i32

CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116'i32

CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117'i32

CS_POSIX_V6_ILP32_OFF32_LIBS = 1118'i32

CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120'i32

CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121'i32

CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122'i32

CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124'i32

CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125'i32

CS_POSIX_V6_LP64_OFF64_LIBS = 1126'i32

CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128'i32

CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129'i32

CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130'i32

CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 1'i32

D_FMT = 131113'i32

D_T_FMT = 131112'i32

DAY_1 = 131079'i32

DAY_2 = 131080'i32

DAY_3 = 131081'i32

DAY_4 = 131082'i32

DAY_5 = 131083'i32

DAY_6 = 131084'i32

DAY_7 = 131085'i32

DT_BLK = 6

DT_CHR = 2

DT_DIR = 4

DT_FIFO = 1

DT_LNK = 10

DT_REG = 8

DT_SOCK = 12

DT_UNKNOWN = 0

DT_WHT = 14

E2BIG = 7'i32

EACCES = 13'i32

EADDRINUSE = 98'i32

EADDRNOTAVAIL = 99'i32

EAFNOSUPPORT = 97'i32

EAGAIN = 11'i32

EAI_AGAIN = -3'i32

EAI_BADFLAGS = -1'i32

EAI_FAIL = -4'i32

EAI_FAMILY = -6'i32

EAI_MEMORY = -10'i32

EAI_NONAME = -2'i32

EAI_OVERFLOW = -12'i32

EAI_SERVICE = -8'i32

EAI_SOCKTYPE = -7'i32

EAI_SYSTEM = -11'i32

EALREADY = 114'i32

EBADF = 9'i32

EBADMSG = 74'i32

EBUSY = 16'i32

ECANCELED = 125'i32

ECHILD = 10'i32

ECONNABORTED = 103'i32

ECONNREFUSED = 111'i32

ECONNRESET = 104'i32

EDEADLK = 35'i32

EDESTADDRREQ = 89'i32

EDOM = 33'i32

EDQUOT = 122'i32

EEXIST = 17'i32

EFAULT = 14'i32

EFBIG = 27'i32

EHOSTUNREACH = 113'i32

EIDRM = 43'i32

EILSEQ = 84'i32

EINPROGRESS = 115'i32

EINTR = 4'i32

EINVAL = 22'i32

EIO = 5'i32

EISCONN = 106'i32

EISDIR = 21'i32

ELOOP = 40'i32

EMFILE = 24'i32

EMLINK = 31'i32

EMSGSIZE = 90'i32

EMULTIHOP = 72'i32

ENAMETOOLONG = 36'i32

ENETDOWN = 100'i32

ENETRESET = 102'i32

ENETUNREACH = 101'i32

ENFILE = 23'i32

ENOBUFS = 105'i32

ENODATA = 61'i32

ENODEV = 19'i32

ENOENT = 2'i32

ENOEXEC = 8'i32

ENOLCK = 37'i32

ENOLINK = 67'i32

ENOMEM = 12'i32

ENOMSG = 42'i32

ENOPROTOOPT = 92'i32

ENOSPC = 28'i32

ENOSR = 63'i32

ENOSTR = 60'i32

ENOSYS = 38'i32

ENOTCONN = 107'i32

ENOTDIR = 20'i32

ENOTEMPTY = 39'i32

ENOTSOCK = 88'i32

ENOTSUP = 95'i32

ENOTTY = 25'i32

ENXIO = 6'i32

EOPNOTSUPP = 95'i32

EOVERFLOW = 75'i32

EPERM = 1'i32

EPIPE = 32'i32

EPROTO = 71'i32