std/posix

Это модуль низкоуровневого интерфейса POSIX. Он не предоставляет никаких удобств: вместо обычных Nim-строк используются C-строки, а коды возврата указывают на ошибки. Если вам нужны исключения и правильный интерфейс в стиле Nim, используйте модуль OS или напишите обёртку.

Для высокоуровневых обёртки, специализированных для Linux и BSD, см.: posix_utils

Конвенции кодирования: все типы имеют те же имена, что и в стандарте POSIX, за исключением того, что они начинаются с 'T' или 'P' (если это указатели) и без суффикса '_t', чтобы соответствовать соглашениям Nim. Если идентификатор является ключевым словом Nim, используется запись `identifier`.

Эта библиотека полагается на заголовочные файлы вашего компилятора C. Полученный C-код просто #include <XYZ.h> и не определяет символы, объявленные здесь.

Типы

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

используется для подсчета блоков файлов Source Edit

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

используется для размеров блоков 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

Тип, представляющий поток каталога. 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 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

Определяет преобразование из одной кодовой страницы в другую. 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.

атрибут очереди сообщений 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 Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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
  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 Источник Изменить

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.

struct servent Источник Изменить

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

Возможно, квалифицированный как volatile целочисленный тип объекта, к которому можно получить доступ как к атомарной сущности, даже при наличии асинхронных прерываний. Источник Изменить

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 Источник Изменить

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 Источник Изменить

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 Источник Изменить

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.

struct sigstack Источник Изменить

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

struct sigval Источник Изменить

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 Источник Изменить

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 Источник Изменить

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 Источник Изменить

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

struct sockaddr_storage Источник Изменить

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 Источник Изменить

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.

stack_t Источник Изменить

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 Источник Изменить

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 Источник Изменить

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

Источник Изменить

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 Источник Изменить

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.

тип flock Исходный код Редактировать

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.

структура if_nameindex Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

структура timespec Исходный код Редактировать

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

структура timeval Исходный код Редактировать

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

структура ipv6_mreq Исходный код Редактировать

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.

структура linger Исходный код Редактировать

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 Исходный код Редактировать

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.

структура msghdr Исходный код Редактировать

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.

структура netent Исходный код Редактировать

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

Исходный код Редактировать

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

структура pollfd Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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_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 Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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]

структура utsname Исходный код Редактировать

Переменные

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

переменная ошибки Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

MAP_POPULATE: cint = 0

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Нет SIGPIPE при попытке отправки на сокет ориентированного на поток, который больше не подключен. Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Исходный код Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

Consts

DT_BLK = 6

Блочное устройство. Исходный код Редактировать

DT_CHR = 2

Символьное устройство. Исходный код Редактировать

DT_DIR = 4

Каталог. Исходный код Редактировать

DT_FIFO = 1

Именованная труба, или FIFO. Исходный код Редактировать

DT_LNK = 10

Символическая ссылка. Исходный код Редактировать

DT_REG = 8

Регулярный файл. Исходный код Редактировать

DT_SOCK = 12

UNIX-сокет. Исходный код Редактировать

DT_UNKNOWN = 0

Неизвестный тип файла. Исходный код Редактировать

DT_WHT = 14

Исходный код Редактировать

INVALID_SOCKET = -1'i32

Исходный код Редактировать

MM_NULLACT = nil

Исходный код Редактировать

MM_NULLLBL = nil

Исходный код Редактировать

MM_NULLMC = 0

Исходный код Редактировать

MM_NULLSEV = 0

Исходный код Редактировать

MM_NULLTAG = nil

Исходный код Редактировать

MM_NULLTXT = nil

Исходный код Редактировать

POSIX_SPAWN_USEVFORK = 0'i32

Исходный код Редактировать

RUSAGE_CHILDREN = -1'i32

Исходный код Редактировать

RUSAGE_SELF = 0'i32

Исходный код Редактировать

RUSAGE_THREAD = 1'i32

Исходный код Редактировать

SO_REUSEPORT = 512'i32

Множественная привязка: балансировка нагрузки на входящие TCP-соединения или UDP-пакеты. (Требуется ядро Linux > 3.9) Исходный код Редактировать

Sockaddr_max_length = 255

Исходный код Редактировать

Sockaddr_un_path_length = 92

Исходный код Редактировать

StatHasNanoseconds = false

Логический флаг, указывающий, поддерживает ли система наносекундное разрешение времени в полях Stat. Обратите внимание, что к наносекундным полям (Stat.st_atim, Stat.st_mtim и Stat.st_ctim) можно получить доступ без проверки этого флага, поскольку этот модуль определяет резервные процедуры, когда они недоступны. Исходный код Редактировать

STDERR_FILENO = 2

Номер файла stderr; Исходный код Редактировать

STDIN_FILENO = 0

Номер файла stdin; Исходный код Редактировать

STDOUT_FILENO = 1

Номер файла stdout; Исходный код Редактировать

Procs

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

это функция Posix's bind, потому что bind — зарезервированное слово Исходный код Редактировать

proc bsd_signal(a1: cint; a2: proc (x: pointer) {.noconv.}) {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

синхронизировать кэш буфера файла со съёмным устройством хранения Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

возвращает эффективный идентификатор группы вызывающего процесса Источник Изменить

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

возвращает эффективный идентификатор пользователя вызывающего процесса Источник Изменить

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

возвращает реальный идентификатор группы вызывающего процесса Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Источник Изменить

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

возвращает идентификатор процесса (PID) вызывающего процесса Исходный код Редактировать

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

возвращает идентификатор процесса родителя вызывающего процесса Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

proc getpwnam(a1: cstring): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
    tags: [], forbids: [].}

Исходный код Редактировать

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

Исходный код Редактировать

proc getpwuid(a1: Uid): ptr Passwd {.importc, header: "<pwd.h>", ...raises: [],
                                     tags: [], forbids: [].}

Исходный код Редактировать

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

Исходный код Редактировать

proc getrlimit(resource: cint; rlp: var RLimit): cint {.importc: "getrlimit",
    header: "<sys/resource.h>", ...raises: [], tags: [], forbids: [].}

Системный вызов getrlimit() получает ограничения ресурсов. Исходный код Редактировать

proc getrusage(who: cint; rusage: ptr Rusage): cint {.importc,
    header: "<sys/resource.h>", discardable, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

возвращает идентификатор сессии вызывающего процесса Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

возвращает действительный идентификатор пользователя вызывающего процесса Исходный код Редактировать

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

Исходный код Редактировать

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

Сопоставление имен файлов. Используйте os.walkPattern() и аналогичные функции. Исходный код Редактировать

proc globfree(a1: ptr Glob) {.importc, header: "<glob.h>", ...raises: [], tags: [],
                              forbids: [].}

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

proc htonl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

Исходный код Редактировать

proc htons(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Редактировать

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

Исходный код Изменить

proc if_freenameindex(a1: ptr Tif_nameindex) {.importc, header: "<net/if.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc if_indextoname(a1: cint; a2: cstring): cstring {.importc,
    header: "<net/if.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc if_nameindex(): ptr Tif_nameindex {.importc, header: "<net/if.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc if_nametoindex(a1: cstring): cint {.importc, header: "<net/if.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc IN6_IS_ADDR_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Адрес одноадресной связи локальной сети. Исходный код Изменить

proc IN6_IS_ADDR_LOOPBACK(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Адрес обратной связи. Исходный код Изменить

proc IN6_IS_ADDR_MC_GLOBAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Мультип адрес глобальной сети. Исходный код Изменить

proc IN6_IS_ADDR_MC_LINKLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Мультип адрес локальной сети. Исходный код Изменить

proc IN6_IS_ADDR_MC_NODELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Мультип адрес локального узла. Исходный код Изменить

proc IN6_IS_ADDR_MC_ORGLOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Мультип адрес локальной организации. Исходный код Изменить

proc IN6_IS_ADDR_MC_SITELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Мультип адрес локального сайта. Исходный код Изменить

proc IN6_IS_ADDR_MULTICAST(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Мультип адрес. Исходный код Изменить

proc IN6_IS_ADDR_SITELOCAL(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Адрес одноадресной связи локального сайта. Исходный код Изменить

proc IN6_IS_ADDR_UNSPECIFIED(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Неопределенный адрес. Исходный код Изменить

proc IN6_IS_ADDR_V4COMPAT(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Адрес совместимый с IPv4. Исходный код Изменить

proc IN6_IS_ADDR_V4MAPPED(a1: ptr In6Addr): cint {.importc,
    header: "<netinet/in.h>", ...raises: [], tags: [], forbids: [].}

Адрес отображённый на IPv4. Исходный код Изменить

proc IN6ADDR_ANY_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                   ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc IN6ADDR_LOOPBACK_INIT(): In6Addr {.importc, header: "<netinet/in.h>",
                                        ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc inet_addr(a1: cstring): InAddrT {.importc, header: "<arpa/inet.h>",
                                       ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc inet_ntoa(a1: InAddr): cstring {.importc, header: "<arpa/inet.h>",
                                      ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

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: [].}

Исходный код Изменить

proc inet_pton(a1: cint; a2: cstring; a3: pointer | ptr InAddr | ptr In6Addr): cint {.
    importc, header: "<arpa/inet.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc ioctl(f: FileHandle; device: uint): int {.importc: "ioctl",
    header: "<sys/ioctl.h>", varargs, ...tags: [WriteIOEffect], raises: [],
    forbids: [].}

Системный вызов для операций ввода/вывода, специфичных для устройства, и других операций, которые нельзя выразить с помощью обычных системных вызовов. Исходный код Изменить

proc isatty(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

Исходный код Изменить

proc kill(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>", sideEffect,
                                     ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc killpg(a1: Pid; a2: cint): cint {.importc, header: "<signal.h>",
                                       sideEffect, ...raises: [], tags: [],
                                       forbids: [].}

Исходный код Изменить

proc lchown(a1: cstring; a2: Uid; a3: Gid): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc link(a1, a2: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                   tags: [], forbids: [].}

Исходный код Изменить

proc listen(a1: SocketHandle; a2: cint): cint {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc localeconv(): ptr Lconv {.importc, header: "<locale.h>", ...raises: [],
                               tags: [], forbids: [].}

Исходный код Изменить

proc localtime(a1: var Time): ptr Tm {.importc, header: "<time.h>", ...raises: [],
                                       tags: [], forbids: [].}

Исходный код Изменить

proc localtime_r(a1: var Time; a2: var Tm): ptr Tm {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc lockf(a1, a2: cint; a3: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc lseek(a1: cint; a2: Off; a3: cint): Off {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc lstat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc makecontext(a1: var Ucontext; a4: proc () {.noconv.}; a3: cint) {.varargs,
    importc, header: "<ucontext.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mkdir(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

Используйте os.createDir() и аналогичные функции. Исходный код Редактировать

proc mkdtemp(tmpl: cstring): pointer {.importc, header: "<stdlib.h>",
                                       sideEffect, ...raises: [], tags: [],
                                       forbids: [].}

Исходный код Редактировать

proc mkfifo(a1: cstring; a2: Mode): cint {.importc, header: "<sys/stat.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mknod(a1: cstring; a2: Mode; a3: Dev): cint {.importc,
    header: "<sys/stat.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mkstemp(tmpl: cstring): cint {.importc, header: "<stdlib.h>", sideEffect,
                                    ...raises: [], tags: [], forbids: [].}

Создает уникальный временный файл.

Предупреждение: Аргумент tmpl перезаписывается mkstemp и, следовательно, не может быть строковой константой. В случае сомнений создайте копию cstring перед передачей.

Исходный код Редактировать

proc mkstemps(tmpl: cstring; suffixlen: int): cint {.importc,
    header: "<stdlib.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Создает уникальный временный файл.

Предупреждение: Аргумент tmpl перезаписывается mkstemps и, следовательно, не может быть строковой константой. В случае сомнений создайте копию cstring перед передачей.

Исходный код Редактировать

proc mktime(a1: var Tm): Time {.importc, header: "<time.h>", ...raises: [],
                                tags: [], forbids: [].}

Исходный код Редактировать

proc mlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mlockall(a1: cint): cint {.importc, header: "<sys/mman.h>", ...raises: [],
                                tags: [], forbids: [].}

Исходный код Редактировать

proc mmap(a1: pointer; a2: int; a3, a4, a5: cint; a6: Off): pointer {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mprotect(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_close(mqdes: Mqd): cint {.importc, header: "<mqueue.h>", ...raises: [],
                                  tags: [], forbids: [].}

Исходный код Редактировать

proc mq_getattr(mqdes: Mqd; attribute: ptr MqAttr): cint {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_notify(mqdes: Mqd; event: ptr SigEvent): cint {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_open(name: cstring; flags: cint): Mqd {.varargs, importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_receive(mqdes: Mqd; buffer: cstring; length: csize_t;
                priority: var cuint): int {.importc, header: "<mqueue.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_send(mqdes: Mqd; buffer: cstring; length: csize_t; priority: cuint): cint {.
    importc, header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_setattr(mqdes: Mqd; newAttribute, oldAttribute: ptr MqAttr): cint {.
    importc, header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_timedreceive(mqdes: Mqd; buffer: cstring; length: csize_t;
                     priority: cuint; timeout: ptr Timespec): int {.importc,
    header: "<mqueue.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_timedsend(mqdes: Mqd; buffer: cstring; length: csize_t; priority: cuint;
                  timeout: ptr Timespec): cint {.importc, header: "<mqueue.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc mq_unlink(mqdes: cstring): cint {.importc, header: "<mqueue.h>",
                                       ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc msync(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc munlock(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc munlockall(): cint {.importc, header: "<sys/mman.h>", ...raises: [], tags: [],
                          forbids: [].}

Исходный код Редактировать

proc munmap(a1: pointer; a2: int): cint {.importc, header: "<sys/mman.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc nanosleep(a1, a2: var Timespec): cint {.importc, header: "<time.h>",
    sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc nice(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                            forbids: [].}

Исходный код Редактировать

proc nl_langinfo(a1: Nl_item): cstring {.importc, header: "<langinfo.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc ntohl(a1: uint32): uint32 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

Исходный код Редактировать

proc ntohs(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>", ...raises: [],
                                 tags: [], forbids: [].}

Исходный код Редактировать

proc open(a1: cstring; a2: cint; mode: Mode | cint = 0.Mode): cint {.inline.}

Исходный код Редактировать

proc opendir(a1: cstring): ptr DIR {.importc, header: "<dirent.h>", sideEffect,
                                     ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pathconf(a1: cstring; a2: cint): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pause(): cint {.importc, header: "<unistd.h>", ...raises: [], tags: [],
                     forbids: [].}

Исходный код Редактировать

proc pclose(a: File): cint {.importc, header: "<stdio.h>", ...raises: [], tags: [],
                             forbids: [].}

Исходный код Редактировать

proc pipe(a: array[0 .. 1, cint]): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc poll(a1: ptr TPollfd; a2: Tnfds; a3: int): cint {.importc,
    header: "<poll.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc popen(a1, a2: cstring): File {.importc, header: "<stdio.h>", ...raises: [],
                                    tags: [], forbids: [].}

Исходный код Редактировать

proc posix_fadvise(a1: cint; a2, a3: Off; a4: cint): cint {.importc,
    header: "<fcntl.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_fallocate(a1: cint; a2, a3: Off): cint {.importc,
    header: "<fcntl.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_madvise(a1: pointer; a2: int; a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc posix_spawn_file_actions_addclose(a1: var Tposix_spawn_file_actions;
                                       a2: cint): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawn_file_actions_adddup2(a1: var Tposix_spawn_file_actions;
                                      a2, a3: cint): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc posix_spawn_file_actions_destroy(a1: var Tposix_spawn_file_actions): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawn_file_actions_init(a1: var Tposix_spawn_file_actions): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_destroy(a1: var Tposix_spawnattr): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_getflags(a1: var Tposix_spawnattr; a2: var cshort): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_getpgroup(a1: var Tposix_spawnattr; a2: var Pid): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_getschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_getschedpolicy(a1: var Tposix_spawnattr; a2: var cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_getsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_getsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_init(a1: var Tposix_spawnattr): cint {.importc,
    header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_setflags(a1: var Tposix_spawnattr; a2: cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_setpgroup(a1: var Tposix_spawnattr; a2: Pid): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_setschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_setschedpolicy(a1: var Tposix_spawnattr; a2: cint): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_setsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_spawnattr_setsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint {.
    importc, header: "<spawn.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc posix_typed_mem_get_info(a1: cint; a2: var Posix_typed_mem_info): cint {.
    importc, header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc posix_typed_mem_open(a1: cstring; a2, a3: cint): cint {.importc,
    header: "<sys/mman.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pread(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pselect(a1: cint; a2, a3, a4: ptr TFdSet; a5: ptr Timespec; a6: var Sigset): cint {.
    importc, header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_atfork(a1, a2, a3: proc () {.noconv.}): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_destroy(a1: ptr Pthread_attr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getguardsize(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getinheritsched(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getschedpolicy(a1: ptr Pthread_attr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getscope(a1: ptr Pthread_attr; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getstack(a1: ptr Pthread_attr; a2: var pointer; a3: var int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getstackaddr(a1: ptr Pthread_attr; a2: var pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_getstacksize(a1: ptr Pthread_attr; a2: var int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_init(a1: ptr Pthread_attr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setdetachstate(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setguardsize(a1: ptr Pthread_attr; a2: int): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setinheritsched(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setschedpolicy(a1: ptr Pthread_attr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setscope(a1: ptr Pthread_attr; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setstack(a1: ptr Pthread_attr; a2: pointer; a3: int): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setstackaddr(a1: ptr Pthread_attr; a2: pointer): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_attr_setstacksize(a1: ptr Pthread_attr; a2: int): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrier_destroy(a1: ptr Pthread_barrier): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrier_init(a1: ptr Pthread_barrier; a2: ptr Pthread_barrierattr;
                          a3: cint): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrier_wait(a1: ptr Pthread_barrier): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrierattr_destroy(a1: ptr Pthread_barrierattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrierattr_getpshared(a1: ptr Pthread_barrierattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrierattr_init(a1: ptr Pthread_barrierattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_barrierattr_setpshared(a1: ptr Pthread_barrierattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cancel(a1: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cleanup_pop(a1: cint) {.importc, header: "<pthread.h>", ...raises: [],
                                     tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cleanup_push(a1: proc (x: pointer) {.noconv.}; a2: pointer) {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cond_broadcast(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cond_destroy(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cond_init(a1: ptr Pthread_cond; a2: ptr Pthread_condattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cond_signal(a1: ptr Pthread_cond): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cond_timedwait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex;
                            a3: ptr Timespec): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_cond_wait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_condattr_destroy(a1: ptr Pthread_condattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_condattr_getclock(a1: ptr Pthread_condattr; a2: var ClockId): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_condattr_getpshared(a1: ptr Pthread_condattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_condattr_init(a1: ptr Pthread_condattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_condattr_setclock(a1: ptr Pthread_condattr; a2: ClockId): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_condattr_setpshared(a1: ptr Pthread_condattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc pthread_detach(a1: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_equal(a1, a2: Pthread): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_exit(a1: pointer) {.importc, header: "<pthread.h>", ...raises: [],
                                 tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_getconcurrency(): cint {.importc, header: "<pthread.h>",
                                      ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_getcpuclockid(a1: Pthread; a2: var ClockId): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_getschedparam(a1: Pthread; a2: var cint; a3: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_getspecific(a1: Pthread_key): pointer {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_join(a1: Pthread; a2: ptr pointer): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_key_create(a1: ptr Pthread_key; a2: proc (x: pointer) {.noconv.}): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_key_delete(a1: Pthread_key): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_kill(a1: Pthread; a2: cint): cint {.importc, header: "<signal.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_destroy(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_getprioceiling(a1: ptr Pthread_mutex; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_init(a1: ptr Pthread_mutex; a2: ptr Pthread_mutexattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_lock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_setprioceiling(a1: ptr Pthread_mutex; a2: cint; a3: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_timedlock(a1: ptr Pthread_mutex; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_trylock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutex_unlock(a1: ptr Pthread_mutex): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_destroy(a1: ptr Pthread_mutexattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_getprioceiling(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_getprotocol(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_getpshared(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_gettype(a1: ptr Pthread_mutexattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_init(a1: ptr Pthread_mutexattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_setprioceiling(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_setprotocol(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_setpshared(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_mutexattr_settype(a1: ptr Pthread_mutexattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_once(a1: ptr Pthread_once; a2: proc () {.noconv.}): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_destroy(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_init(a1: ptr Pthread_rwlock; a2: ptr Pthread_rwlockattr): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_rdlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_timedrdlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_timedwrlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_tryrdlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_trywrlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_unlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlock_wrlock(a1: ptr Pthread_rwlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlockattr_destroy(a1: ptr Pthread_rwlockattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlockattr_getpshared(a1: ptr Pthread_rwlockattr; a2: var cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlockattr_init(a1: ptr Pthread_rwlockattr): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_rwlockattr_setpshared(a1: ptr Pthread_rwlockattr; a2: cint): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_self(): Pthread {.importc, header: "<pthread.h>", ...raises: [],
                               tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_setcancelstate(a1: cint; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_setcanceltype(a1: cint; a2: var cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_setconcurrency(a1: cint): cint {.importc, header: "<pthread.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_setschedparam(a1: Pthread; a2: cint; a3: ptr Sched_param): cint {.
    importc, header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_setschedprio(a1: Pthread; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_setspecific(a1: Pthread_key; a2: pointer): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_sigmask(a1: cint; a2, a3: var Sigset): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_spin_destroy(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_spin_init(a1: ptr Pthread_spinlock; a2: cint): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_spin_lock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_spin_trylock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_spin_unlock(a1: ptr Pthread_spinlock): cint {.importc,
    header: "<pthread.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc pthread_testcancel() {.importc, header: "<pthread.h>", ...raises: [],
                            tags: [], forbids: [].}

Исходный код Редактировать

proc pwrite(a1: cint; a2: pointer; a3: int; a4: Off): int {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `raise`(a1: cint): cint {.importc, header: "<signal.h>", ...raises: [],
                               tags: [], forbids: [].}

Исходный код Редактировать

proc read(a1: cint; a2: pointer; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc readdir(a1: ptr DIR): ptr Dirent {.importc, header: "<dirent.h>",
                                        sideEffect, ...raises: [], tags: [],
                                        forbids: [].}

Исходный код Редактировать

proc readdir_r(a1: ptr DIR; a2: ptr Dirent; a3: ptr ptr Dirent): cint {.importc,
    header: "<dirent.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc readlink(a1, a2: cstring; a3: int): int {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc readv(a1: cint; a2: ptr IOVec; a3: cint): int {.importc,
    header: "<sys/uio.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc realpath(name, resolved: cstring): cstring {.importc: "realpath",
    header: "<stdlib.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc recv(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc recvmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc rewinddir(a1: ptr DIR) {.importc, header: "<dirent.h>", ...raises: [],
                              tags: [], forbids: [].}

Исходный код Редактировать

proc rmdir(a1: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [], forbids: [].}

Исходный код Редактировать

proc S_ISBLK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Проверка на наличие специального блока файла. Исходный код Редактировать

proc S_ISCHR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Проверка на наличие специального символьного файла. Исходный код Редактировать

proc S_ISDIR(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Проверка на наличие каталога. Исходный код Редактировать

proc S_ISFIFO(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                               tags: [], forbids: [].}

Проверка на наличие файла типа труба или FIFO. Исходный код Редактировать

proc S_ISLNK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Проверка на наличие символической ссылки. Исходный код Редактировать

proc S_ISREG(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                              tags: [], forbids: [].}

Проверка на наличие обычного файла. Исходный код Редактировать

proc S_ISSOCK(m: Mode): bool {.importc, header: "<sys/stat.h>", ...raises: [],
                               tags: [], forbids: [].}

Проверка на сокет. Исходный код Редактировать

proc S_TYPEISMQ(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                       ...raises: [], tags: [], forbids: [].}

Проверка на очередь сообщений. Исходный код Редактировать

proc S_TYPEISSEM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [], forbids: [].}

Проверка на семафор. Исходный код Редактировать

proc S_TYPEISSHM(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [], forbids: [].}

Проверка на объект общей памяти. Исходный код Редактировать

proc S_TYPEISTMO(buf: var Stat): bool {.importc, header: "<sys/stat.h>",
                                        ...raises: [], tags: [], forbids: [].}

Макрос проверки на типизированный объект памяти. Исходный код Редактировать

proc sched_get_priority_max(a1: cint): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_get_priority_min(a1: cint): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_getparam(a1: Pid; a2: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_getscheduler(a1: Pid): cint {.importc, header: "<sched.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_rr_get_interval(a1: Pid; a2: var Timespec): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_setparam(a1: Pid; a2: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_setscheduler(a1: Pid; a2: cint; a3: var Sched_param): cint {.importc,
    header: "<sched.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sched_yield(): cint {.importc, header: "<sched.h>", ...raises: [], tags: [],
                           forbids: [].}

Исходный код Редактировать

proc seekdir(a1: ptr DIR; a2: int) {.importc, header: "<dirent.h>", ...raises: [],
                                     tags: [], forbids: [].}

Исходный код Редактировать

proc select(a1: cint | SocketHandle; a2, a3, a4: ptr TFdSet; a5: ptr Timeval): cint {.
    importc, header: "<sys/select.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_close(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_destroy(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                      ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_getvalue(a1: ptr Sem; a2: var cint): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_init(a1: ptr Sem; a2: cint; a3: cint): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_open(a1: cstring; a2: cint): ptr Sem {.varargs, importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_post(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                   tags: [], forbids: [].}

Исходный код Редактировать

proc sem_timedwait(a1: ptr Sem; a2: ptr Timespec): cint {.importc,
    header: "<semaphore.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_trywait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>",
                                      ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_unlink(a1: cstring): cint {.importc, header: "<semaphore.h>",
                                     ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sem_wait(a1: ptr Sem): cint {.importc, header: "<semaphore.h>", ...raises: [],
                                   tags: [], forbids: [].}

Исходный код Редактировать

proc send(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sendmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int {.importc,
    header: "<sys/socket.h>", sideEffect, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

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: [].}

Исходный код Редактировать

proc setcontext(a1: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc setegid(a1: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

Исходный код Редактировать

proc seteuid(a1: Uid): cint {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

Исходный код Редактировать

proc setgid(a1: Gid): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

Исходный код Редактировать

proc setgrent() {.importc, header: "<grp.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sethostent(a1: cint) {.importc, header: "<netdb.h>", ...raises: [], tags: [],
                            forbids: [].}

Исходный код Редактировать

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: [].}

Системный вызов setrlimit() устанавливает лимиты ресурсов. 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) {.importc, 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: [].}

Исходный код Редактировать

proc sigwait(a1: var Sigset; a2: var cint): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sigwaitinfo(a1: var Sigset; a2: var SigInfo): cint {.importc,
    header: "<signal.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sleep(a1: cint): cint {.importc, header: "<unistd.h>", ...raises: [],
                             tags: [], forbids: [].}

Исходный код Редактировать

proc sockatmark(a1: cint): cint {.importc, header: "<sys/socket.h>", ...raises: [],
                                  tags: [], forbids: [].}

Исходный код Редактировать

proc socket(a1, a2, a3: cint): SocketHandle {.importc, header: "<sys/socket.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc socketpair(a1, a2, a3: cint; a4: var array[0 .. 1, cint]): cint {.importc,
    header: "<sys/socket.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc st_atim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

Время последнего доступа с точностью до наносекунды. Исходный код Редактировать

proc st_ctim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

Время последнего изменения данных с точностью до наносекунды. Исходный код Редактировать

proc st_mtim(s: Stat): Timespec {.inline, ...raises: [], tags: [], forbids: [].}

Время последнего изменения данных с точностью до наносекунды. Исходный код Редактировать

proc stat(a1: cstring; a2: var Stat): cint {.importc, header: "<sys/stat.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc statvfs(a1: cstring; a2: var Statvfs): cint {.importc,
    header: "<sys/statvfs.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc strerror(errnum: cint): cstring {.importc, header: "<string.h>",
                                       ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc strfmon(a1: cstring; a2: int; a3: cstring): int {.varargs, importc,
    header: "<monetary.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc strftime(a1: cstring; a2: int; a3: cstring; a4: var Tm): int {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc strptime(a1, a2: cstring; a3: var Tm): cstring {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc swab(a1, a2: pointer; a3: int) {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [], forbids: [].}

Исходный код Редактировать

proc swapcontext(a1, a2: var Ucontext): cint {.importc, header: "<ucontext.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc symlink(a1, a2: cstring): cint {.importc, header: "<unistd.h>", ...raises: [],
                                      tags: [], forbids: [].}

Исходный код Редактировать

proc sync() {.importc, header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc sysconf(a1: cint): int {.importc, header: "<unistd.h>", ...raises: [],
                              tags: [], forbids: [].}

Исходный код Редактировать

proc tcgetpgrp(a1: cint): Pid {.importc, header: "<unistd.h>", ...raises: [],
                                tags: [], forbids: [].}

Исходный код Редактировать

proc tcsetpgrp(a1: cint; a2: Pid): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc telldir(a1: ptr DIR): int {.importc, header: "<dirent.h>", ...raises: [],
                                 tags: [], forbids: [].}

Исходный код Редактировать

proc time(a1: var Time): Time {.importc, header: "<time.h>", sideEffect,
                                ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc timegm(a1: var Tm): Time {.importc, header: "<time.h>", ...raises: [],
                                tags: [], forbids: [].}

Исходный код Редактировать

proc timer_create(a1: ClockId; a2: var SigEvent; a3: var Timer): cint {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc timer_delete(a1: Timer): cint {.importc, header: "<time.h>", ...raises: [],
                                     tags: [], forbids: [].}

Исходный код Редактировать

proc timer_getoverrun(a1: Timer): cint {.importc, header: "<time.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc timer_gettime(a1: Timer; a2: var Itimerspec): cint {.importc,
    header: "<time.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc timer_settime(a1: Timer; a2: cint; a3: var Itimerspec; a4: var Itimerspec): cint {.
    importc, header: "<time.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc truncate(a1: cstring; a2: Off): cint {.importc, header: "<unistd.h>",
    ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc ttyname(a1: cint): cstring {.importc, header: "<unistd.h>", ...raises: [],
                                  tags: [], forbids: [].}

Исходный код Редактировать

proc ttyname_r(a1: cint; a2: cstring; a3: int): cint {.importc,
    header: "<unistd.h>", ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать