jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

case consistency for linux

Browse source
This commit is contained in:
Araq 2013-12-29 03:32:46 +01:00
commit 286f166304
6 changed files with 322 additions and 322 deletions
Download patch file Download diff file Expand all files Collapse all files

468
lib/posix/posix.nim
View file

@ -85,15 +85,15 @@ type
Tdirent* {.importc: "struct dirent",
header: "<dirent.h>", final, pure.} = object ## dirent_t struct
d_ino*: TIno ## File serial number.
d_ino*: Tino ## File serial number.
d_name*: array [0..255, char] ## Name of entry.
Tflock* {.importc: "flock", final, pure,
header: "<fcntl.h>".} = object ## flock type
l_type*: cshort ## Type of lock; F_RDLCK, F_WRLCK, F_UNLCK.
l_whence*: cshort ## Flag for starting offset.
l_start*: Toff ## Relative offset in bytes.
l_len*: Toff ## Size; if 0 then until EOF.
l_start*: TOff ## Relative offset in bytes.
l_len*: TOff ## Size; if 0 then until EOF.
l_pid*: TPid ## Process ID of the process holding the lock;
## returned with F_GETLK.
@ -172,7 +172,7 @@ type
TPasswd* {.importc: "struct passwd", header: "<pwd.h>",
final, pure.} = object ## struct passwd
pw_name*: cstring ## User's login name.
pw_uid*: TUid ## Numerical user ID.
pw_uid*: Tuid ## Numerical user ID.
pw_gid*: TGid ## Numerical group ID.
pw_dir*: cstring ## Initial working directory.
pw_shell*: cstring ## Program to use as shell.
@ -240,20 +240,20 @@ type
TSem* {.importc: "sem_t", header: "<semaphore.h>", final, pure.} = object
Tipc_perm* {.importc: "struct ipc_perm",
header: "<sys/ipc.h>", final, pure.} = object ## struct ipc_perm
uid*: tuid ## Owner's user ID.
gid*: tgid ## Owner's group ID.
uid*: Tuid ## Owner's user ID.
gid*: TGid ## Owner's group ID.
cuid*: Tuid ## Creator's user ID.
cgid*: Tgid ## Creator's group ID.
cgid*: TGid ## Creator's group ID.
mode*: TMode ## Read/write permission.
TStat* {.importc: "struct stat",
header: "<sys/stat.h>", final, pure.} = object ## struct stat
st_dev*: TDev ## Device ID of device containing file.
st_ino*: TIno ## File serial number.
st_ino*: Tino ## File serial number.
st_mode*: TMode ## Mode of file (see below).
st_nlink*: tnlink ## Number of hard links to the file.
st_uid*: tuid ## User ID of file.
st_gid*: Tgid ## Group ID of file.
st_nlink*: TNlink ## Number of hard links to the file.
st_uid*: Tuid ## User ID of file.
st_gid*: TGid ## Group ID of file.
st_rdev*: TDev ## Device ID (if file is character or block special).
st_size*: TOff ## For regular files, the file size in bytes.
## For symbolic links, the length in bytes of the
@ -262,9 +262,9 @@ type
## For a typed memory object, the length in bytes.
## For other file types, the use of this field is
## unspecified.
st_atime*: ttime ## Time of last access.
st_mtime*: ttime ## Time of last data modification.
st_ctime*: ttime ## Time of last status change.
st_atime*: TTime ## Time of last access.
st_mtime*: TTime ## Time of last data modification.
st_ctime*: TTime ## Time of last status change.
st_blksize*: Tblksize ## A file system-specific preferred I/O block size
## for this object. In some file system types, this
## may vary from file to file.
@ -305,12 +305,12 @@ type
tm_isdst*: cint ## Daylight Savings flag.
Ttimespec* {.importc: "struct timespec",
header: "<time.h>", final, pure.} = object ## struct timespec
tv_sec*: Ttime ## Seconds.
tv_sec*: TTime ## Seconds.
tv_nsec*: int ## Nanoseconds.
titimerspec* {.importc: "struct itimerspec", header: "<time.h>",
final, pure.} = object ## struct itimerspec
it_interval*: ttimespec ## Timer period.
it_value*: ttimespec ## Timer expiration.
it_interval*: Ttimespec ## Timer period.
it_value*: Ttimespec ## Timer expiration.
Tsig_atomic* {.importc: "sig_atomic_t", header: "<signal.h>".} = cint
## Possibly volatile-qualified integer type of an object that can be
@ -322,9 +322,9 @@ type
header: "<signal.h>", final, pure.} = object ## struct sigevent
sigev_notify*: cint ## Notification type.
sigev_signo*: cint ## Signal number.
sigev_value*: Tsigval ## Signal value.
sigev_notify_function*: proc (x: TSigval) {.noconv.} ## Notification func.
sigev_notify_attributes*: ptr Tpthreadattr ## Notification attributes.
sigev_value*: TsigVal ## Signal value.
sigev_notify_function*: proc (x: TsigVal) {.noconv.} ## Notification func.
sigev_notify_attributes*: ptr Tpthread_attr ## Notification attributes.
TsigVal* {.importc: "union sigval",
header: "<signal.h>", final, pure.} = object ## struct sigval
@ -335,10 +335,10 @@ type
sa_handler*: proc (x: cint) {.noconv.} ## Pointer to a signal-catching
## function or one of the macros
## SIG_IGN or SIG_DFL.
sa_mask*: TsigSet ## Set of signals to be blocked during execution of
sa_mask*: Tsigset ## Set of signals to be blocked during execution of
## the signal handling function.
sa_flags*: cint ## Special flags.
sa_sigaction*: proc (x: cint, y: var TSigInfo, z: pointer) {.noconv.}
sa_sigaction*: proc (x: cint, y: var TsigInfo, z: pointer) {.noconv.}
TStack* {.importc: "stack_t",
header: "<signal.h>", final, pure.} = object ## stack_t
@ -357,12 +357,12 @@ type
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*: tpid ## Sending process ID.
si_uid*: tuid ## Real user ID of sending process.
si_pid*: TPid ## Sending process ID.
si_uid*: Tuid ## 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*: TSigval ## Signal value.
si_value*: TsigVal ## Signal value.
Tnl_item* {.importc: "nl_item", header: "<nl_types.h>".} = cint
Tnl_catd* {.importc: "nl_catd", header: "<nl_types.h>".} = cint
@ -373,9 +373,9 @@ type
sched_priority*: cint
sched_ss_low_priority*: cint ## Low scheduling priority for
## sporadic server.
sched_ss_repl_period*: ttimespec ## Replenishment period for
sched_ss_repl_period*: Ttimespec ## Replenishment period for
## sporadic server.
sched_ss_init_budget*: ttimespec ## Initial budget for sporadic server.
sched_ss_init_budget*: Ttimespec ## Initial budget for sporadic server.
sched_ss_max_repl*: cint ## Maximum pending replenishments for
## sporadic server.
@ -383,8 +383,8 @@ type
final, pure.} = object ## struct timeval
tv_sec*: int ## Seconds.
tv_usec*: int ## Microseconds.
Tfd_set* {.importc: "fd_set", header: "<sys/select.h>",
final, pure.} = object
TFdSet* {.importc: "fd_set", header: "<sys/select.h>",
final, pure.} = object
Tmcontext* {.importc: "mcontext_t", header: "<ucontext.h>",
final, pure.} = object
Tucontext* {.importc: "ucontext_t", header: "<ucontext.h>",
@ -406,7 +406,7 @@ when hasAioH:
aio_buf*: pointer ## Location of buffer.
aio_nbytes*: int ## Length of transfer.
aio_reqprio*: cint ## Request priority offset.
aio_sigevent*: TSigEvent ## Signal number and value.
aio_sigevent*: TsigEvent ## Signal number and value.
aio_lio_opcode: cint ## Operation to be performed.
when hasSpawnH:
@ -422,13 +422,13 @@ type
TSockAddr* {.importc: "struct sockaddr", header: "<sys/socket.h>",
pure, final.} = object ## struct sockaddr
sa_family*: Tsa_family ## Address family.
sa_family*: TSa_Family ## Address family.
sa_data*: array [0..255, char] ## Socket address (variable-length data).
Tsockaddr_storage* {.importc: "struct sockaddr_storage",
header: "<sys/socket.h>",
pure, final.} = object ## struct sockaddr_storage
ss_family*: Tsa_family ## Address family.
ss_family*: TSa_Family ## Address family.
Tif_nameindex* {.importc: "struct if_nameindex", final,
pure, header: "<net/if.h>".} = object ## struct if_nameindex
@ -444,17 +444,17 @@ type
Tmsghdr* {.importc: "struct msghdr", pure, final,
header: "<sys/socket.h>".} = object ## struct msghdr
msg_name*: pointer ## Optional address.
msg_namelen*: TSockLen ## Size of address.
msg_namelen*: TSocklen ## Size of address.
msg_iov*: ptr TIOVec ## Scatter/gather array.
msg_iovlen*: cint ## Members in msg_iov.
msg_control*: pointer ## Ancillary data; see below.
msg_controllen*: TSockLen ## Ancillary data buffer len.
msg_controllen*: TSocklen ## Ancillary data buffer len.
msg_flags*: cint ## Flags on received message.
Tcmsghdr* {.importc: "struct cmsghdr", pure, final,
header: "<sys/socket.h>".} = object ## struct cmsghdr
cmsg_len*: TSockLen ## Data byte count, including the cmsghdr.
cmsg_len*: TSocklen ## Data byte count, including the cmsghdr.
cmsg_level*: cint ## Originating protocol.
cmsg_type*: cint ## Protocol-specific type.
@ -475,7 +475,7 @@ type
Tsockaddr_in* {.importc: "struct sockaddr_in", pure, final,
header: "<netinet/in.h>".} = object ## struct sockaddr_in
sin_family*: TSa_family ## AF_INET.
sin_family*: TSa_Family ## AF_INET.
sin_port*: TInPort ## Port number.
sin_addr*: TInAddr ## IP address.
@ -485,10 +485,10 @@ type
Tsockaddr_in6* {.importc: "struct sockaddr_in6", pure, final,
header: "<netinet/in.h>".} = object ## struct sockaddr_in6
sin6_family*: TSa_family ## AF_INET6.
sin6_family*: TSa_Family ## AF_INET6.
sin6_port*: TInPort ## Port number.
sin6_flowinfo*: int32 ## IPv6 traffic class and flow information.
sin6_addr*: Tin6Addr ## IPv6 address.
sin6_addr*: TIn6Addr ## IPv6 address.
sin6_scope_id*: int32 ## Set of interfaces for a scope.
Tipv6_mreq* {.importc: "struct ipv6_mreq", pure, final,
@ -543,10 +543,10 @@ type
ai_family*: cint ## Address family of socket.
ai_socktype*: cint ## Socket type.
ai_protocol*: cint ## Protocol of socket.
ai_addrlen*: TSockLen ## Length of socket address.
ai_addrlen*: TSocklen ## Length of socket address.
ai_addr*: ptr TSockAddr ## Socket address of socket.
ai_canonname*: cstring ## Canonical name of service location.
ai_next*: ptr TAddrInfo ## Pointer to next in list.
ai_next*: ptr Taddrinfo ## Pointer to next in list.
TPollfd* {.importc: "struct pollfd", pure, final,
header: "<poll.h>".} = object ## struct pollfd
@ -1616,9 +1616,9 @@ var
IPPROTO_UDP* {.importc, header: "<netinet/in.h>".}: cint
## User datagram protocol.
INADDR_ANY* {.importc, header: "<netinet/in.h>".}: TinAddrScalar
INADDR_ANY* {.importc, header: "<netinet/in.h>".}: TInAddrScalar
## IPv4 local host address.
INADDR_BROADCAST* {.importc, header: "<netinet/in.h>".}: TinAddrScalar
INADDR_BROADCAST* {.importc, header: "<netinet/in.h>".}: TInAddrScalar
## IPv4 broadcast address.
INET_ADDRSTRLEN* {.importc, header: "<netinet/in.h>".}: cint
@ -1726,7 +1726,7 @@ var
## Invalid fd member (revents only).
when hasSpawnh:
when hasSpawnH:
var
POSIX_SPAWN_RESETIDS* {.importc, header: "<spawn.h>".}: cint
POSIX_SPAWN_SETPGROUP* {.importc, header: "<spawn.h>".}: cint
@ -1750,11 +1750,11 @@ when hasAioH:
proc aio_fsync*(a1: cint, a2: ptr Taiocb): cint {.importc, header: "<aio.h>".}
proc aio_read*(a1: ptr Taiocb): cint {.importc, header: "<aio.h>".}
proc aio_return*(a1: ptr Taiocb): int {.importc, header: "<aio.h>".}
proc aio_suspend*(a1: ptr ptr Taiocb, a2: cint, a3: ptr ttimespec): cint {.
proc aio_suspend*(a1: ptr ptr Taiocb, a2: cint, a3: ptr Ttimespec): cint {.
importc, header: "<aio.h>".}
proc aio_write*(a1: ptr Taiocb): cint {.importc, header: "<aio.h>".}
proc lio_listio*(a1: cint, a2: ptr ptr Taiocb, a3: cint,
a4: ptr Tsigevent): cint {.importc, header: "<aio.h>".}
a4: ptr TsigEvent): cint {.importc, header: "<aio.h>".}
# arpa/inet.h
proc htonl*(a1: int32): int32 {.importc, header: "<arpa/inet.h>".}
@ -1778,9 +1778,9 @@ proc IN6ADDR_LOOPBACK_INIT* (): TIn6Addr {.importc, header: "<netinet/in.h>".}
# dirent.h
proc closedir*(a1: ptr TDIR): cint {.importc, header: "<dirent.h>".}
proc opendir*(a1: cstring): ptr TDir {.importc, header: "<dirent.h>".}
proc readdir*(a1: ptr TDIR): ptr TDirent {.importc, header: "<dirent.h>".}
proc readdir_r*(a1: ptr TDIR, a2: ptr Tdirent, a3: ptr ptr TDirent): cint {.
proc opendir*(a1: cstring): ptr TDIR {.importc, header: "<dirent.h>".}
proc readdir*(a1: ptr TDIR): ptr Tdirent {.importc, header: "<dirent.h>".}
proc readdir_r*(a1: ptr TDIR, a2: ptr Tdirent, a3: ptr ptr Tdirent): cint {.
importc, header: "<dirent.h>".}
proc rewinddir*(a1: ptr TDIR) {.importc, header: "<dirent.h>".}
proc seekdir*(a1: ptr TDIR, a2: int) {.importc, header: "<dirent.h>".}
@ -1792,12 +1792,12 @@ proc dlerror*(): cstring {.importc, header: "<dlfcn.h>".}
proc dlopen*(a1: cstring, a2: cint): pointer {.importc, header: "<dlfcn.h>".}
proc dlsym*(a1: pointer, a2: cstring): pointer {.importc, header: "<dlfcn.h>".}
proc creat*(a1: cstring, a2: Tmode): cint {.importc, header: "<fcntl.h>".}
proc creat*(a1: cstring, a2: TMode): cint {.importc, header: "<fcntl.h>".}
proc fcntl*(a1: cint | TSocketHandle, a2: cint): cint {.varargs, importc, header: "<fcntl.h>".}
proc open*(a1: cstring, a2: cint): cint {.varargs, importc, header: "<fcntl.h>".}
proc posix_fadvise*(a1: cint, a2, a3: Toff, a4: cint): cint {.
proc posix_fadvise*(a1: cint, a2, a3: TOff, a4: cint): cint {.
importc, header: "<fcntl.h>".}
proc posix_fallocate*(a1: cint, a2, a3: Toff): cint {.
proc posix_fallocate*(a1: cint, a2, a3: TOff): cint {.
importc, header: "<fcntl.h>".}
proc feclearexcept*(a1: cint): cint {.importc, header: "<fenv.h>".}
@ -1812,7 +1812,7 @@ proc fesetround*(a1: cint): cint {.importc, header: "<fenv.h>".}
proc fegetenv*(a1: ptr Tfenv): cint {.importc, header: "<fenv.h>".}
proc feholdexcept*(a1: ptr Tfenv): cint {.importc, header: "<fenv.h>".}
proc fesetenv*(a1: ptr Tfenv): cint {.importc, header: "<fenv.h>".}
proc feupdateenv*(a1: ptr TFenv): cint {.importc, header: "<fenv.h>".}
proc feupdateenv*(a1: ptr Tfenv): cint {.importc, header: "<fenv.h>".}
when not defined(haiku):
proc fmtmsg*(a1: int, a2: cstring, a3: cint,
@ -1830,12 +1830,12 @@ proc nftw*(a1: cstring,
proc glob*(a1: cstring, a2: cint,
a3: proc (x1: cstring, x2: cint): cint {.noconv.},
a4: ptr Tglob): cint {.importc, header: "<glob.h>".}
a4: ptr TGlob): cint {.importc, header: "<glob.h>".}
proc globfree*(a1: ptr TGlob) {.importc, header: "<glob.h>".}
proc getgrgid*(a1: TGid): ptr TGroup {.importc, header: "<grp.h>".}
proc getgrnam*(a1: cstring): ptr TGroup {.importc, header: "<grp.h>".}
proc getgrgid_r*(a1: Tgid, a2: ptr TGroup, a3: cstring, a4: int,
proc getgrgid_r*(a1: TGid, a2: ptr TGroup, a3: cstring, a4: int,
a5: ptr ptr TGroup): cint {.importc, header: "<grp.h>".}
proc getgrnam_r*(a1: cstring, a2: ptr TGroup, a3: cstring,
a4: int, a5: ptr ptr TGroup): cint {.
@ -1845,7 +1845,7 @@ proc endgrent*() {.importc, header: "<grp.h>".}
proc setgrent*() {.importc, header: "<grp.h>".}
proc iconv_open*(a1, a2: cstring): TIconv {.importc, header: "<iconv.h>".}
proc iconv_open*(a1, a2: cstring): Ticonv {.importc, header: "<iconv.h>".}
proc iconv*(a1: Ticonv, a2: var cstring, a3: var int, a4: var cstring,
a5: var int): int {.importc, header: "<iconv.h>".}
proc iconv_close*(a1: Ticonv): cint {.importc, header: "<iconv.h>".}
@ -1862,33 +1862,33 @@ proc setlocale*(a1: cint, a2: cstring): cstring {.
proc strfmon*(a1: cstring, a2: int, a3: cstring): int {.varargs,
importc, header: "<monetary.h>".}
proc mq_close*(a1: Tmqd): cint {.importc, header: "<mqueue.h>".}
proc mq_getattr*(a1: Tmqd, a2: ptr Tmq_attr): cint {.
proc mq_close*(a1: TMqd): cint {.importc, header: "<mqueue.h>".}
proc mq_getattr*(a1: TMqd, a2: ptr TMqAttr): cint {.
importc, header: "<mqueue.h>".}
proc mq_notify*(a1: Tmqd, a2: ptr Tsigevent): cint {.
proc mq_notify*(a1: TMqd, a2: ptr TsigEvent): cint {.
importc, header: "<mqueue.h>".}
proc mq_open*(a1: cstring, a2: cint): TMqd {.
varargs, importc, header: "<mqueue.h>".}
proc mq_receive*(a1: Tmqd, a2: cstring, a3: int, a4: var int): int {.
proc mq_receive*(a1: TMqd, a2: cstring, a3: int, a4: var int): int {.
importc, header: "<mqueue.h>".}
proc mq_send*(a1: Tmqd, a2: cstring, a3: int, a4: int): cint {.
proc mq_send*(a1: TMqd, a2: cstring, a3: int, a4: int): cint {.
importc, header: "<mqueue.h>".}
proc mq_setattr*(a1: Tmqd, a2, a3: ptr Tmq_attr): cint {.
proc mq_setattr*(a1: TMqd, a2, a3: ptr TMqAttr): cint {.
importc, header: "<mqueue.h>".}
proc mq_timedreceive*(a1: Tmqd, a2: cstring, a3: int, a4: int,
a5: ptr TTimespec): int {.importc, header: "<mqueue.h>".}
proc mq_timedsend*(a1: Tmqd, a2: cstring, a3: int, a4: int,
a5: ptr TTimeSpec): cint {.importc, header: "<mqueue.h>".}
proc mq_timedreceive*(a1: TMqd, a2: cstring, a3: int, a4: int,
a5: ptr Ttimespec): int {.importc, header: "<mqueue.h>".}
proc mq_timedsend*(a1: TMqd, a2: cstring, a3: int, a4: int,
a5: ptr Ttimespec): cint {.importc, header: "<mqueue.h>".}
proc mq_unlink*(a1: cstring): cint {.importc, header: "<mqueue.h>".}
proc getpwnam*(a1: cstring): ptr TPasswd {.importc, header: "<pwd.h>".}
proc getpwuid*(a1: Tuid): ptr TPasswd {.importc, header: "<pwd.h>".}
proc getpwnam_r*(a1: cstring, a2: ptr Tpasswd, a3: cstring, a4: int,
a5: ptr ptr Tpasswd): cint {.importc, header: "<pwd.h>".}
proc getpwuid_r*(a1: Tuid, a2: ptr Tpasswd, a3: cstring,
a4: int, a5: ptr ptr Tpasswd): cint {.importc, header: "<pwd.h>".}
proc getpwnam_r*(a1: cstring, a2: ptr TPasswd, a3: cstring, a4: int,
a5: ptr ptr TPasswd): cint {.importc, header: "<pwd.h>".}
proc getpwuid_r*(a1: Tuid, a2: ptr TPasswd, a3: cstring,
a4: int, a5: ptr ptr TPasswd): cint {.importc, header: "<pwd.h>".}
proc endpwent*() {.importc, header: "<pwd.h>".}
proc getpwent*(): ptr TPasswd {.importc, header: "<pwd.h>".}
proc setpwent*() {.importc, header: "<pwd.h>".}
@ -1933,9 +1933,9 @@ proc pthread_attr_setscope*(a1: ptr Tpthread_attr, a2: cint): cint {.importc,
header: "<pthread.h>".}
proc pthread_attr_setstack*(a1: ptr Tpthread_attr, a2: pointer, a3: int): cint {.
importc, header: "<pthread.h>".}
proc pthread_attr_setstackaddr*(a1: ptr TPthread_attr, a2: pointer): cint {.
proc pthread_attr_setstackaddr*(a1: ptr Tpthread_attr, a2: pointer): cint {.
importc, header: "<pthread.h>".}
proc pthread_attr_setstacksize*(a1: ptr TPthread_attr, a2: int): cint {.
proc pthread_attr_setstacksize*(a1: ptr Tpthread_attr, a2: int): cint {.
importc, header: "<pthread.h>".}
proc pthread_barrier_destroy*(a1: ptr Tpthread_barrier): cint {.
importc, header: "<pthread.h>".}
@ -1949,9 +1949,9 @@ proc pthread_barrierattr_destroy*(a1: ptr Tpthread_barrierattr): cint {.
proc pthread_barrierattr_getpshared*(
a1: ptr Tpthread_barrierattr, a2: var cint): cint {.
importc, header: "<pthread.h>".}
proc pthread_barrierattr_init*(a1: ptr TPthread_barrierattr): cint {.
proc pthread_barrierattr_init*(a1: ptr Tpthread_barrierattr): cint {.
importc, header: "<pthread.h>".}
proc pthread_barrierattr_setpshared*(a1: ptr TPthread_barrierattr,
proc pthread_barrierattr_setpshared*(a1: ptr Tpthread_barrierattr,
a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_cancel*(a1: Tpthread): cint {.importc, header: "<pthread.h>".}
proc pthread_cleanup_push*(a1: proc (x: pointer) {.noconv.}, a2: pointer) {.
@ -1970,13 +1970,13 @@ proc pthread_cond_wait*(a1: ptr Tpthread_cond,
a2: ptr Tpthread_mutex): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_destroy*(a1: ptr Tpthread_condattr): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_getclock*(a1: ptr Tpthread_condattr,
a2: var Tclockid): cint {.importc, header: "<pthread.h>".}
a2: var TClockId): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_getpshared*(a1: ptr Tpthread_condattr,
a2: var cint): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_init*(a1: ptr TPthread_condattr): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_setclock*(a1: ptr TPthread_condattr,a2: Tclockid): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_setpshared*(a1: ptr TPthread_condattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_init*(a1: ptr Tpthread_condattr): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_setclock*(a1: ptr Tpthread_condattr,a2: TClockId): cint {.importc, header: "<pthread.h>".}
proc pthread_condattr_setpshared*(a1: ptr Tpthread_condattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_create*(a1: ptr Tpthread, a2: ptr Tpthread_attr,
a3: proc (x: pointer): pointer {.noconv.}, a4: pointer): cint {.importc, header: "<pthread.h>".}
@ -1984,7 +1984,7 @@ proc pthread_detach*(a1: Tpthread): cint {.importc, header: "<pthread.h>".}
proc pthread_equal*(a1, a2: Tpthread): cint {.importc, header: "<pthread.h>".}
proc pthread_exit*(a1: pointer) {.importc, header: "<pthread.h>".}
proc pthread_getconcurrency*(): cint {.importc, header: "<pthread.h>".}
proc pthread_getcpuclockid*(a1: Tpthread, a2: var Tclockid): cint {.importc, header: "<pthread.h>".}
proc pthread_getcpuclockid*(a1: Tpthread, a2: var TClockId): cint {.importc, header: "<pthread.h>".}
proc pthread_getschedparam*(a1: Tpthread, a2: var cint,
a3: ptr Tsched_param): cint {.importc, header: "<pthread.h>".}
proc pthread_getspecific*(a1: Tpthread_key): pointer {.importc, header: "<pthread.h>".}
@ -2016,7 +2016,7 @@ proc pthread_mutexattr_gettype*(a1: ptr Tpthread_mutexattr,
a2: var cint): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_init*(a1: ptr Tpthread_mutexattr): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_setprioceiling*(a1: ptr tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_setprioceiling*(a1: ptr Tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_setprotocol*(a1: ptr Tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_setpshared*(a1: ptr Tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_settype*(a1: ptr Tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
@ -2069,7 +2069,7 @@ proc pthread_testcancel*() {.importc, header: "<pthread.h>".}
proc access*(a1: cstring, a2: cint): cint {.importc, header: "<unistd.h>".}
proc alarm*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc chdir*(a1: cstring): cint {.importc, header: "<unistd.h>".}
proc chown*(a1: cstring, a2: Tuid, a3: Tgid): cint {.importc, header: "<unistd.h>".}
proc chown*(a1: cstring, a2: Tuid, a3: TGid): cint {.importc, header: "<unistd.h>".}
proc close*(a1: cint | TSocketHandle): cint {.importc, header: "<unistd.h>".}
proc confstr*(a1: cint, a2: cstring, a3: int): int {.importc, header: "<unistd.h>".}
proc crypt*(a1, a2: cstring): cstring {.importc, header: "<unistd.h>".}
@ -2085,19 +2085,19 @@ proc execv*(a1: cstring, a2: cstringArray): cint {.importc, header: "<unistd.h>"
proc execve*(a1: cstring, a2, a3: cstringArray): cint {.
importc, header: "<unistd.h>".}
proc execvp*(a1: cstring, a2: cstringArray): cint {.importc, header: "<unistd.h>".}
proc fchown*(a1: cint, a2: Tuid, a3: Tgid): cint {.importc, header: "<unistd.h>".}
proc fchown*(a1: cint, a2: Tuid, a3: TGid): cint {.importc, header: "<unistd.h>".}
proc fchdir*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc fdatasync*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc fork*(): Tpid {.importc, header: "<unistd.h>".}
proc fork*(): TPid {.importc, header: "<unistd.h>".}
proc fpathconf*(a1, a2: cint): int {.importc, header: "<unistd.h>".}
proc fsync*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc ftruncate*(a1: cint, a2: Toff): cint {.importc, header: "<unistd.h>".}
proc ftruncate*(a1: cint, a2: TOff): cint {.importc, header: "<unistd.h>".}
proc getcwd*(a1: cstring, a2: int): cstring {.importc, header: "<unistd.h>".}
proc getegid*(): TGid {.importc, header: "<unistd.h>".}
proc geteuid*(): TUid {.importc, header: "<unistd.h>".}
proc geteuid*(): Tuid {.importc, header: "<unistd.h>".}
proc getgid*(): TGid {.importc, header: "<unistd.h>".}
proc getgroups*(a1: cint, a2: ptr array[0..255, Tgid]): cint {.
proc getgroups*(a1: cint, a2: ptr array[0..255, TGid]): cint {.
importc, header: "<unistd.h>".}
proc gethostid*(): int {.importc, header: "<unistd.h>".}
proc gethostname*(a1: cstring, a2: int): cint {.importc, header: "<unistd.h>".}
@ -2106,105 +2106,105 @@ proc getlogin_r*(a1: cstring, a2: int): cint {.importc, header: "<unistd.h>".}
proc getopt*(a1: cint, a2: cstringArray, a3: cstring): cint {.
importc, header: "<unistd.h>".}
proc getpgid*(a1: Tpid): Tpid {.importc, header: "<unistd.h>".}
proc getpgrp*(): Tpid {.importc, header: "<unistd.h>".}
proc getpid*(): Tpid {.importc, header: "<unistd.h>".}
proc getppid*(): Tpid {.importc, header: "<unistd.h>".}
proc getsid*(a1: Tpid): Tpid {.importc, header: "<unistd.h>".}
proc getpgid*(a1: TPid): TPid {.importc, header: "<unistd.h>".}
proc getpgrp*(): TPid {.importc, header: "<unistd.h>".}
proc getpid*(): TPid {.importc, header: "<unistd.h>".}
proc getppid*(): TPid {.importc, header: "<unistd.h>".}
proc getsid*(a1: TPid): TPid {.importc, header: "<unistd.h>".}
proc getuid*(): Tuid {.importc, header: "<unistd.h>".}
proc getwd*(a1: cstring): cstring {.importc, header: "<unistd.h>".}
proc isatty*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc lchown*(a1: cstring, a2: Tuid, a3: Tgid): cint {.importc, header: "<unistd.h>".}
proc lchown*(a1: cstring, a2: Tuid, a3: TGid): cint {.importc, header: "<unistd.h>".}
proc link*(a1, a2: cstring): cint {.importc, header: "<unistd.h>".}
proc lockf*(a1, a2: cint, a3: Toff): cint {.importc, header: "<unistd.h>".}
proc lseek*(a1: cint, a2: Toff, a3: cint): Toff {.importc, header: "<unistd.h>".}
proc lockf*(a1, a2: cint, a3: TOff): cint {.importc, header: "<unistd.h>".}
proc lseek*(a1: cint, a2: TOff, a3: cint): TOff {.importc, header: "<unistd.h>".}
proc nice*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc pathconf*(a1: cstring, a2: cint): int {.importc, header: "<unistd.h>".}
proc pause*(): cint {.importc, header: "<unistd.h>".}
proc pipe*(a: array[0..1, cint]): cint {.importc, header: "<unistd.h>".}
proc pread*(a1: cint, a2: pointer, a3: int, a4: Toff): int {.
proc pread*(a1: cint, a2: pointer, a3: int, a4: TOff): int {.
importc, header: "<unistd.h>".}
proc pwrite*(a1: cint, a2: pointer, a3: int, a4: Toff): int {.
proc pwrite*(a1: cint, a2: pointer, a3: int, a4: TOff): int {.
importc, header: "<unistd.h>".}
proc read*(a1: cint, a2: pointer, a3: int): int {.importc, header: "<unistd.h>".}
proc readlink*(a1, a2: cstring, a3: int): int {.importc, header: "<unistd.h>".}
proc rmdir*(a1: cstring): cint {.importc, header: "<unistd.h>".}
proc setegid*(a1: Tgid): cint {.importc, header: "<unistd.h>".}
proc setegid*(a1: TGid): cint {.importc, header: "<unistd.h>".}
proc seteuid*(a1: Tuid): cint {.importc, header: "<unistd.h>".}
proc setgid*(a1: Tgid): cint {.importc, header: "<unistd.h>".}
proc setgid*(a1: TGid): cint {.importc, header: "<unistd.h>".}
proc setpgid*(a1, a2: Tpid): cint {.importc, header: "<unistd.h>".}
proc setpgrp*(): Tpid {.importc, header: "<unistd.h>".}
proc setregid*(a1, a2: Tgid): cint {.importc, header: "<unistd.h>".}
proc setpgid*(a1, a2: TPid): cint {.importc, header: "<unistd.h>".}
proc setpgrp*(): TPid {.importc, header: "<unistd.h>".}
proc setregid*(a1, a2: TGid): cint {.importc, header: "<unistd.h>".}
proc setreuid*(a1, a2: Tuid): cint {.importc, header: "<unistd.h>".}
proc setsid*(): Tpid {.importc, header: "<unistd.h>".}
proc setsid*(): TPid {.importc, header: "<unistd.h>".}
proc setuid*(a1: Tuid): cint {.importc, header: "<unistd.h>".}
proc sleep*(a1: cint): cint {.importc, header: "<unistd.h>".}
proc swab*(a1, a2: pointer, a3: int) {.importc, header: "<unistd.h>".}
proc symlink*(a1, a2: cstring): cint {.importc, header: "<unistd.h>".}
proc sync*() {.importc, header: "<unistd.h>".}
proc sysconf*(a1: cint): int {.importc, header: "<unistd.h>".}
proc tcgetpgrp*(a1: cint): tpid {.importc, header: "<unistd.h>".}
proc tcsetpgrp*(a1: cint, a2: Tpid): cint {.importc, header: "<unistd.h>".}
proc truncate*(a1: cstring, a2: Toff): cint {.importc, header: "<unistd.h>".}
proc tcgetpgrp*(a1: cint): TPid {.importc, header: "<unistd.h>".}
proc tcsetpgrp*(a1: cint, a2: TPid): cint {.importc, header: "<unistd.h>".}
proc truncate*(a1: cstring, a2: TOff): cint {.importc, header: "<unistd.h>".}
proc ttyname*(a1: cint): cstring {.importc, header: "<unistd.h>".}
proc ttyname_r*(a1: cint, a2: cstring, a3: int): cint {.
importc, header: "<unistd.h>".}
proc ualarm*(a1, a2: Tuseconds): Tuseconds {.importc, header: "<unistd.h>".}
proc unlink*(a1: cstring): cint {.importc, header: "<unistd.h>".}
proc usleep*(a1: Tuseconds): cint {.importc, header: "<unistd.h>".}
proc vfork*(): tpid {.importc, header: "<unistd.h>".}
proc vfork*(): TPid {.importc, header: "<unistd.h>".}
proc write*(a1: cint, a2: pointer, a3: int): int {.importc, header: "<unistd.h>".}
proc sem_close*(a1: ptr Tsem): cint {.importc, header: "<semaphore.h>".}
proc sem_destroy*(a1: ptr Tsem): cint {.importc, header: "<semaphore.h>".}
proc sem_getvalue*(a1: ptr Tsem, a2: var cint): cint {.
proc sem_close*(a1: ptr TSem): cint {.importc, header: "<semaphore.h>".}
proc sem_destroy*(a1: ptr TSem): cint {.importc, header: "<semaphore.h>".}
proc sem_getvalue*(a1: ptr TSem, a2: var cint): cint {.
importc, header: "<semaphore.h>".}
proc sem_init*(a1: ptr Tsem, a2: cint, a3: cint): cint {.
proc sem_init*(a1: ptr TSem, a2: cint, a3: cint): cint {.
importc, header: "<semaphore.h>".}
proc sem_open*(a1: cstring, a2: cint): ptr TSem {.
varargs, importc, header: "<semaphore.h>".}
proc sem_post*(a1: ptr Tsem): cint {.importc, header: "<semaphore.h>".}
proc sem_timedwait*(a1: ptr Tsem, a2: ptr Ttimespec): cint {.
proc sem_post*(a1: ptr TSem): cint {.importc, header: "<semaphore.h>".}
proc sem_timedwait*(a1: ptr TSem, a2: ptr Ttimespec): cint {.
importc, header: "<semaphore.h>".}
proc sem_trywait*(a1: ptr Tsem): cint {.importc, header: "<semaphore.h>".}
proc sem_trywait*(a1: ptr TSem): cint {.importc, header: "<semaphore.h>".}
proc sem_unlink*(a1: cstring): cint {.importc, header: "<semaphore.h>".}
proc sem_wait*(a1: ptr Tsem): cint {.importc, header: "<semaphore.h>".}
proc sem_wait*(a1: ptr TSem): cint {.importc, header: "<semaphore.h>".}
proc ftok*(a1: cstring, a2: cint): Tkey {.importc, header: "<sys/ipc.h>".}
proc ftok*(a1: cstring, a2: cint): TKey {.importc, header: "<sys/ipc.h>".}
proc statvfs*(a1: cstring, a2: var Tstatvfs): cint {.
proc statvfs*(a1: cstring, a2: var TStatvfs): cint {.
importc, header: "<sys/statvfs.h>".}
proc fstatvfs*(a1: cint, a2: var Tstatvfs): cint {.
proc fstatvfs*(a1: cint, a2: var TStatvfs): cint {.
importc, header: "<sys/statvfs.h>".}
proc chmod*(a1: cstring, a2: TMode): cint {.importc, header: "<sys/stat.h>".}
proc fchmod*(a1: cint, a2: TMode): cint {.importc, header: "<sys/stat.h>".}
proc fstat*(a1: cint, a2: var Tstat): cint {.importc, header: "<sys/stat.h>".}
proc lstat*(a1: cstring, a2: var Tstat): cint {.importc, header: "<sys/stat.h>".}
proc fstat*(a1: cint, a2: var TStat): cint {.importc, header: "<sys/stat.h>".}
proc lstat*(a1: cstring, a2: var TStat): cint {.importc, header: "<sys/stat.h>".}
proc mkdir*(a1: cstring, a2: TMode): cint {.importc, header: "<sys/stat.h>".}
proc mkfifo*(a1: cstring, a2: TMode): cint {.importc, header: "<sys/stat.h>".}
proc mknod*(a1: cstring, a2: TMode, a3: Tdev): cint {.
proc mknod*(a1: cstring, a2: TMode, a3: TDev): cint {.
importc, header: "<sys/stat.h>".}
proc stat*(a1: cstring, a2: var Tstat): cint {.importc, header: "<sys/stat.h>".}
proc umask*(a1: Tmode): TMode {.importc, header: "<sys/stat.h>".}
proc stat*(a1: cstring, a2: var TStat): cint {.importc, header: "<sys/stat.h>".}
proc umask*(a1: TMode): TMode {.importc, header: "<sys/stat.h>".}
proc S_ISBLK*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISBLK*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a block special file.
proc S_ISCHR*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISCHR*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a character special file.
proc S_ISDIR*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISDIR*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a directory.
proc S_ISFIFO*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISFIFO*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a pipe or FIFO special file.
proc S_ISREG*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISREG*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a regular file.
proc S_ISLNK*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISLNK*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a symbolic link.
proc S_ISSOCK*(m: Tmode): bool {.importc, header: "<sys/stat.h>".}
proc S_ISSOCK*(m: TMode): bool {.importc, header: "<sys/stat.h>".}
## Test for a socket.
proc S_TYPEISMQ*(buf: var TStat): bool {.importc, header: "<sys/stat.h>".}
@ -2219,7 +2219,7 @@ proc S_TYPEISTMO*(buf: var TStat): bool {.importc, header: "<sys/stat.h>".}
proc mlock*(a1: pointer, a2: int): cint {.importc, header: "<sys/mman.h>".}
proc mlockall*(a1: cint): cint {.importc, header: "<sys/mman.h>".}
proc mmap*(a1: pointer, a2: int, a3, a4, a5: cint, a6: Toff): pointer {.
proc mmap*(a1: pointer, a2: int, a3, a4, a5: cint, a6: TOff): pointer {.
importc, header: "<sys/mman.h>".}
proc mprotect*(a1: pointer, a2: int, a3: cint): cint {.
importc, header: "<sys/mman.h>".}
@ -2229,75 +2229,75 @@ proc munlockall*(): cint {.importc, header: "<sys/mman.h>".}
proc munmap*(a1: pointer, a2: int): cint {.importc, header: "<sys/mman.h>".}
proc posix_madvise*(a1: pointer, a2: int, a3: cint): cint {.
importc, header: "<sys/mman.h>".}
proc posix_mem_offset*(a1: pointer, a2: int, a3: var Toff,
proc posix_mem_offset*(a1: pointer, a2: int, a3: var TOff,
a4: var int, a5: var cint): cint {.importc, header: "<sys/mman.h>".}
proc posix_typed_mem_get_info*(a1: cint,
a2: var Tposix_typed_mem_info): cint {.importc, header: "<sys/mman.h>".}
proc posix_typed_mem_open*(a1: cstring, a2, a3: cint): cint {.
importc, header: "<sys/mman.h>".}
proc shm_open*(a1: cstring, a2: cint, a3: Tmode): cint {.
proc shm_open*(a1: cstring, a2: cint, a3: TMode): cint {.
importc, header: "<sys/mman.h>".}
proc shm_unlink*(a1: cstring): cint {.importc, header: "<sys/mman.h>".}
proc asctime*(a1: var ttm): cstring{.importc, header: "<time.h>".}
proc asctime*(a1: var Ttm): cstring{.importc, header: "<time.h>".}
proc asctime_r*(a1: var ttm, a2: cstring): cstring {.importc, header: "<time.h>".}
proc clock*(): Tclock {.importc, header: "<time.h>".}
proc clock_getcpuclockid*(a1: tpid, a2: var Tclockid): cint {.
proc asctime_r*(a1: var Ttm, a2: cstring): cstring {.importc, header: "<time.h>".}
proc clock*(): TClock {.importc, header: "<time.h>".}
proc clock_getcpuclockid*(a1: TPid, a2: var TClockId): cint {.
importc, header: "<time.h>".}
proc clock_getres*(a1: Tclockid, a2: var Ttimespec): cint {.
proc clock_getres*(a1: TClockId, a2: var Ttimespec): cint {.
importc, header: "<time.h>".}
proc clock_gettime*(a1: Tclockid, a2: var Ttimespec): cint {.
proc clock_gettime*(a1: TClockId, a2: var Ttimespec): cint {.
importc, header: "<time.h>".}
proc clock_nanosleep*(a1: Tclockid, a2: cint, a3: var Ttimespec,
proc clock_nanosleep*(a1: TClockId, a2: cint, a3: var Ttimespec,
a4: var Ttimespec): cint {.importc, header: "<time.h>".}
proc clock_settime*(a1: Tclockid, a2: var Ttimespec): cint {.
proc clock_settime*(a1: TClockId, a2: var Ttimespec): cint {.
importc, header: "<time.h>".}
proc ctime*(a1: var Ttime): cstring {.importc, header: "<time.h>".}
proc ctime_r*(a1: var Ttime, a2: cstring): cstring {.importc, header: "<time.h>".}
proc difftime*(a1, a2: Ttime): cdouble {.importc, header: "<time.h>".}
proc getdate*(a1: cstring): ptr ttm {.importc, header: "<time.h>".}
proc ctime*(a1: var TTime): cstring {.importc, header: "<time.h>".}
proc ctime_r*(a1: var TTime, a2: cstring): cstring {.importc, header: "<time.h>".}
proc difftime*(a1, a2: TTime): cdouble {.importc, header: "<time.h>".}
proc getdate*(a1: cstring): ptr Ttm {.importc, header: "<time.h>".}
proc gmtime*(a1: var ttime): ptr ttm {.importc, header: "<time.h>".}
proc gmtime_r*(a1: var ttime, a2: var ttm): ptr ttm {.importc, header: "<time.h>".}
proc localtime*(a1: var ttime): ptr ttm {.importc, header: "<time.h>".}
proc localtime_r*(a1: var ttime, a2: var ttm): ptr ttm {.importc, header: "<time.h>".}
proc mktime*(a1: var ttm): ttime {.importc, header: "<time.h>".}
proc gmtime*(a1: var TTime): ptr Ttm {.importc, header: "<time.h>".}
proc gmtime_r*(a1: var TTime, a2: var Ttm): ptr Ttm {.importc, header: "<time.h>".}
proc localtime*(a1: var TTime): ptr Ttm {.importc, header: "<time.h>".}
proc localtime_r*(a1: var TTime, a2: var Ttm): ptr Ttm {.importc, header: "<time.h>".}
proc mktime*(a1: var Ttm): TTime {.importc, header: "<time.h>".}
proc nanosleep*(a1, a2: var Ttimespec): cint {.importc, header: "<time.h>".}
proc strftime*(a1: cstring, a2: int, a3: cstring,
a4: var ttm): int {.importc, header: "<time.h>".}
proc strptime*(a1, a2: cstring, a3: var ttm): cstring {.importc, header: "<time.h>".}
proc time*(a1: var Ttime): ttime {.importc, header: "<time.h>".}
proc timer_create*(a1: var Tclockid, a2: var Tsigevent,
a4: var Ttm): int {.importc, header: "<time.h>".}
proc strptime*(a1, a2: cstring, a3: var Ttm): cstring {.importc, header: "<time.h>".}
proc time*(a1: var TTime): TTime {.importc, header: "<time.h>".}
proc timer_create*(a1: var TClockId, a2: var TsigEvent,
a3: var Ttimer): cint {.importc, header: "<time.h>".}
proc timer_delete*(a1: var Ttimer): cint {.importc, header: "<time.h>".}
proc timer_gettime*(a1: Ttimer, a2: var Titimerspec): cint {.
proc timer_gettime*(a1: Ttimer, a2: var titimerspec): cint {.
importc, header: "<time.h>".}
proc timer_getoverrun*(a1: Ttimer): cint {.importc, header: "<time.h>".}
proc timer_settime*(a1: Ttimer, a2: cint, a3: var Titimerspec,
proc timer_settime*(a1: Ttimer, a2: cint, a3: var titimerspec,
a4: var titimerspec): cint {.importc, header: "<time.h>".}
proc tzset*() {.importc, header: "<time.h>".}
proc wait*(a1: var cint): tpid {.importc, header: "<sys/wait.h>".}
proc waitid*(a1: cint, a2: tid, a3: var Tsiginfo, a4: cint): cint {.
proc wait*(a1: var cint): TPid {.importc, header: "<sys/wait.h>".}
proc waitid*(a1: cint, a2: Tid, a3: var TsigInfo, a4: cint): cint {.
importc, header: "<sys/wait.h>".}
proc waitpid*(a1: tpid, a2: var cint, a3: cint): tpid {.
proc waitpid*(a1: TPid, a2: var cint, a3: cint): TPid {.
importc, header: "<sys/wait.h>".}
proc bsd_signal*(a1: cint, a2: proc (x: pointer) {.noconv.}) {.
importc, header: "<signal.h>".}
proc kill*(a1: Tpid, a2: cint): cint {.importc, header: "<signal.h>".}
proc killpg*(a1: Tpid, a2: cint): cint {.importc, header: "<signal.h>".}
proc pthread_kill*(a1: tpthread, a2: cint): cint {.importc, header: "<signal.h>".}
proc kill*(a1: TPid, a2: cint): cint {.importc, header: "<signal.h>".}
proc killpg*(a1: TPid, a2: cint): cint {.importc, header: "<signal.h>".}
proc pthread_kill*(a1: Tpthread, a2: cint): cint {.importc, header: "<signal.h>".}
proc pthread_sigmask*(a1: cint, a2, a3: var Tsigset): cint {.
importc, header: "<signal.h>".}
proc `raise`*(a1: cint): cint {.importc, header: "<signal.h>".}
proc sigaction*(a1: cint, a2, a3: var Tsigaction): cint {.
proc sigaction*(a1: cint, a2, a3: var TSigaction): cint {.
importc, header: "<signal.h>".}
proc sigaddset*(a1: var Tsigset, a2: cint): cint {.importc, header: "<signal.h>".}
proc sigaltstack*(a1, a2: var Tstack): cint {.importc, header: "<signal.h>".}
proc sigaltstack*(a1, a2: var TStack): cint {.importc, header: "<signal.h>".}
proc sigdelset*(a1: var Tsigset, a2: cint): cint {.importc, header: "<signal.h>".}
proc sigemptyset*(a1: var Tsigset): cint {.importc, header: "<signal.h>".}
proc sigfillset*(a1: var Tsigset): cint {.importc, header: "<signal.h>".}
@ -2308,20 +2308,20 @@ proc sigismember*(a1: var Tsigset, a2: cint): cint {.importc, header: "<signal.h
proc signal*(a1: cint, a2: proc (x: cint) {.noconv.}) {.
importc, header: "<signal.h>".}
proc sigpause*(a1: cint): cint {.importc, header: "<signal.h>".}
proc sigpending*(a1: var tsigset): cint {.importc, header: "<signal.h>".}
proc sigprocmask*(a1: cint, a2, a3: var tsigset): cint {.
proc sigpending*(a1: var Tsigset): cint {.importc, header: "<signal.h>".}
proc sigprocmask*(a1: cint, a2, a3: var Tsigset): cint {.
importc, header: "<signal.h>".}
proc sigqueue*(a1: tpid, a2: cint, a3: Tsigval): cint {.
proc sigqueue*(a1: TPid, a2: cint, a3: TsigVal): cint {.
importc, header: "<signal.h>".}
proc sigrelse*(a1: cint): cint {.importc, header: "<signal.h>".}
proc sigset*(a1: int, a2: proc (x: cint) {.noconv.}) {.
importc, header: "<signal.h>".}
proc sigsuspend*(a1: var Tsigset): cint {.importc, header: "<signal.h>".}
proc sigtimedwait*(a1: var Tsigset, a2: var tsiginfo,
a3: var ttimespec): cint {.importc, header: "<signal.h>".}
proc sigtimedwait*(a1: var Tsigset, a2: var TsigInfo,
a3: var Ttimespec): cint {.importc, header: "<signal.h>".}
proc sigwait*(a1: var Tsigset, a2: var cint): cint {.
importc, header: "<signal.h>".}
proc sigwaitinfo*(a1: var Tsigset, a2: var tsiginfo): cint {.
proc sigwaitinfo*(a1: var Tsigset, a2: var TsigInfo): cint {.
importc, header: "<signal.h>".}
@ -2333,81 +2333,81 @@ proc catopen*(a1: cstring, a2: cint): Tnl_catd {.
proc sched_get_priority_max*(a1: cint): cint {.importc, header: "<sched.h>".}
proc sched_get_priority_min*(a1: cint): cint {.importc, header: "<sched.h>".}
proc sched_getparam*(a1: tpid, a2: var Tsched_param): cint {.
proc sched_getparam*(a1: TPid, a2: var Tsched_param): cint {.
importc, header: "<sched.h>".}
proc sched_getscheduler*(a1: tpid): cint {.importc, header: "<sched.h>".}
proc sched_rr_get_interval*(a1: tpid, a2: var Ttimespec): cint {.
proc sched_getscheduler*(a1: TPid): cint {.importc, header: "<sched.h>".}
proc sched_rr_get_interval*(a1: TPid, a2: var Ttimespec): cint {.
importc, header: "<sched.h>".}
proc sched_setparam*(a1: tpid, a2: var Tsched_param): cint {.
proc sched_setparam*(a1: TPid, a2: var Tsched_param): cint {.
importc, header: "<sched.h>".}
proc sched_setscheduler*(a1: tpid, a2: cint, a3: var tsched_param): cint {.
proc sched_setscheduler*(a1: TPid, a2: cint, a3: var Tsched_param): cint {.
importc, header: "<sched.h>".}
proc sched_yield*(): cint {.importc, header: "<sched.h>".}
proc strerror*(errnum: cint): cstring {.importc, header: "<string.h>".}
proc hstrerror*(herrnum: cint): cstring {.importc, header: "<netdb.h>".}
proc FD_CLR*(a1: cint, a2: var Tfd_set) {.importc, header: "<sys/select.h>".}
proc FD_ISSET*(a1: cint | TSocketHandle, a2: var Tfd_set): cint {.
proc FD_CLR*(a1: cint, a2: var TFdSet) {.importc, header: "<sys/select.h>".}
proc FD_ISSET*(a1: cint | TSocketHandle, a2: var TFdSet): cint {.
importc, header: "<sys/select.h>".}
proc FD_SET*(a1: cint | TSocketHandle, a2: var Tfd_set) {.importc, header: "<sys/select.h>".}
proc FD_ZERO*(a1: var Tfd_set) {.importc, header: "<sys/select.h>".}
proc FD_SET*(a1: cint | TSocketHandle, a2: var TFdSet) {.importc, header: "<sys/select.h>".}
proc FD_ZERO*(a1: var TFdSet) {.importc, header: "<sys/select.h>".}
proc pselect*(a1: cint, a2, a3, a4: ptr Tfd_set, a5: ptr ttimespec,
proc pselect*(a1: cint, a2, a3, a4: ptr TFdSet, a5: ptr Ttimespec,
a6: var Tsigset): cint {.importc, header: "<sys/select.h>".}
proc select*(a1: cint, a2, a3, a4: ptr Tfd_set, a5: ptr ttimeval): cint {.
proc select*(a1: cint, a2, a3, a4: ptr TFdSet, a5: ptr Ttimeval): cint {.
importc, header: "<sys/select.h>".}
when hasSpawnH:
proc posix_spawn*(a1: var tpid, a2: cstring,
proc posix_spawn*(a1: var TPid, a2: cstring,
a3: var Tposix_spawn_file_actions,
a4: var Tposix_spawnattr,
a5, a6: cstringArray): cint {.importc, header: "<spawn.h>".}
proc posix_spawn_file_actions_addclose*(a1: var tposix_spawn_file_actions,
proc posix_spawn_file_actions_addclose*(a1: var Tposix_spawn_file_actions,
a2: cint): cint {.importc, header: "<spawn.h>".}
proc posix_spawn_file_actions_adddup2*(a1: var tposix_spawn_file_actions,
proc posix_spawn_file_actions_adddup2*(a1: var Tposix_spawn_file_actions,
a2, a3: cint): cint {.importc, header: "<spawn.h>".}
proc posix_spawn_file_actions_addopen*(a1: var tposix_spawn_file_actions,
a2: cint, a3: cstring, a4: cint, a5: tmode): cint {.
proc posix_spawn_file_actions_addopen*(a1: var Tposix_spawn_file_actions,
a2: cint, a3: cstring, a4: cint, a5: TMode): cint {.
importc, header: "<spawn.h>".}
proc posix_spawn_file_actions_destroy*(
a1: var tposix_spawn_file_actions): cint {.importc, header: "<spawn.h>".}
a1: var Tposix_spawn_file_actions): cint {.importc, header: "<spawn.h>".}
proc posix_spawn_file_actions_init*(
a1: var tposix_spawn_file_actions): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_destroy*(a1: var tposix_spawnattr): cint {.
a1: var Tposix_spawn_file_actions): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_destroy*(a1: var Tposix_spawnattr): cint {.
importc, header: "<spawn.h>".}
proc posix_spawnattr_getsigdefault*(a1: var tposix_spawnattr,
proc posix_spawnattr_getsigdefault*(a1: var Tposix_spawnattr,
a2: var Tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getflags*(a1: var tposix_spawnattr,
proc posix_spawnattr_getflags*(a1: var Tposix_spawnattr,
a2: var cshort): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getpgroup*(a1: var tposix_spawnattr,
a2: var tpid): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getschedparam*(a1: var tposix_spawnattr,
a2: var tsched_param): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getschedpolicy*(a1: var tposix_spawnattr,
proc posix_spawnattr_getpgroup*(a1: var Tposix_spawnattr,
a2: var TPid): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getschedparam*(a1: var Tposix_spawnattr,
a2: var Tsched_param): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getschedpolicy*(a1: var Tposix_spawnattr,
a2: var cint): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getsigmask*(a1: var tposix_spawnattr,
a2: var tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_getsigmask*(a1: var Tposix_spawnattr,
a2: var Tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_init*(a1: var tposix_spawnattr): cint {.
proc posix_spawnattr_init*(a1: var Tposix_spawnattr): cint {.
importc, header: "<spawn.h>".}
proc posix_spawnattr_setsigdefault*(a1: var tposix_spawnattr,
a2: var tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_setflags*(a1: var tposix_spawnattr, a2: cint): cint {.
proc posix_spawnattr_setsigdefault*(a1: var Tposix_spawnattr,
a2: var Tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_setflags*(a1: var Tposix_spawnattr, a2: cint): cint {.
importc, header: "<spawn.h>".}
proc posix_spawnattr_setpgroup*(a1: var tposix_spawnattr, a2: tpid): cint {.
proc posix_spawnattr_setpgroup*(a1: var Tposix_spawnattr, a2: TPid): cint {.
importc, header: "<spawn.h>".}
proc posix_spawnattr_setschedparam*(a1: var tposix_spawnattr,
a2: var tsched_param): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_setschedpolicy*(a1: var tposix_spawnattr,
proc posix_spawnattr_setschedparam*(a1: var Tposix_spawnattr,
a2: var Tsched_param): cint {.importc, header: "<spawn.h>".}
proc posix_spawnattr_setschedpolicy*(a1: var Tposix_spawnattr,
a2: cint): cint {.
importc, header: "<spawn.h>".}
proc posix_spawnattr_setsigmask*(a1: var tposix_spawnattr,
a2: var tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnp*(a1: var tpid, a2: cstring,
a3: var tposix_spawn_file_actions,
a4: var tposix_spawnattr,
proc posix_spawnattr_setsigmask*(a1: var Tposix_spawnattr,
a2: var Tsigset): cint {.importc, header: "<spawn.h>".}
proc posix_spawnp*(a1: var TPid, a2: cstring,
a3: var Tposix_spawn_file_actions,
a4: var Tposix_spawnattr,
a5, a6: cstringArray): cint {.importc, header: "<spawn.h>".}
proc getcontext*(a1: var Tucontext): cint {.importc, header: "<ucontext.h>".}
@ -2424,10 +2424,10 @@ proc writev*(a1: cint, a2: ptr TIOVec, a3: cint): int {.
proc CMSG_DATA*(cmsg: ptr Tcmsghdr): cstring {.
importc, header: "<sys/socket.h>".}
proc CMSG_NXTHDR*(mhdr: ptr TMsgHdr, cmsg: ptr TCMsgHdr): ptr TCmsgHdr {.
proc CMSG_NXTHDR*(mhdr: ptr Tmsghdr, cmsg: ptr Tcmsghdr): ptr Tcmsghdr {.
importc, header: "<sys/socket.h>".}
proc CMSG_FIRSTHDR*(mhdr: ptr TMsgHdr): ptr TCMsgHdr {.
proc CMSG_FIRSTHDR*(mhdr: ptr Tmsghdr): ptr Tcmsghdr {.
importc, header: "<sys/socket.h>".}
const
@ -2435,21 +2435,21 @@ const
proc `==`*(x, y: TSocketHandle): bool {.borrow.}
proc accept*(a1: TSocketHandle, a2: ptr Tsockaddr, a3: ptr Tsocklen): TSocketHandle {.
proc accept*(a1: TSocketHandle, a2: ptr TSockAddr, a3: ptr TSocklen): TSocketHandle {.
importc, header: "<sys/socket.h>".}
proc bindSocket*(a1: TSocketHandle, a2: ptr Tsockaddr, a3: Tsocklen): cint {.
proc bindSocket*(a1: TSocketHandle, a2: ptr TSockAddr, a3: TSocklen): cint {.
importc: "bind", header: "<sys/socket.h>".}
## is Posix's ``bind``, because ``bind`` is a reserved word
proc connect*(a1: TSocketHandle, a2: ptr Tsockaddr, a3: Tsocklen): cint {.
proc connect*(a1: TSocketHandle, a2: ptr TSockAddr, a3: TSocklen): cint {.
importc, header: "<sys/socket.h>".}
proc getpeername*(a1: TSocketHandle, a2: ptr Tsockaddr, a3: ptr Tsocklen): cint {.
proc getpeername*(a1: TSocketHandle, a2: ptr TSockAddr, a3: ptr TSocklen): cint {.
importc, header: "<sys/socket.h>".}
proc getsockname*(a1: TSocketHandle, a2: ptr Tsockaddr, a3: ptr Tsocklen): cint {.
proc getsockname*(a1: TSocketHandle, a2: ptr TSockAddr, a3: ptr TSocklen): cint {.
importc, header: "<sys/socket.h>".}
proc getsockopt*(a1: TSocketHandle, a2, a3: cint, a4: pointer, a5: ptr Tsocklen): cint {.
proc getsockopt*(a1: TSocketHandle, a2, a3: cint, a4: pointer, a5: ptr TSocklen): cint {.
importc, header: "<sys/socket.h>".}
proc listen*(a1: TSocketHandle, a2: cint): cint {.
@ -2457,7 +2457,7 @@ proc listen*(a1: TSocketHandle, a2: cint): cint {.
proc recv*(a1: TSocketHandle, a2: pointer, a3: int, a4: cint): int {.
importc, header: "<sys/socket.h>".}
proc recvfrom*(a1: TSocketHandle, a2: pointer, a3: int, a4: cint,
a5: ptr Tsockaddr, a6: ptr Tsocklen): int {.
a5: ptr TSockAddr, a6: ptr TSocklen): int {.
importc, header: "<sys/socket.h>".}
proc recvmsg*(a1: TSocketHandle, a2: ptr Tmsghdr, a3: cint): int {.
importc, header: "<sys/socket.h>".}
@ -2465,10 +2465,10 @@ proc send*(a1: TSocketHandle, a2: pointer, a3: int, a4: cint): int {.
importc, header: "<sys/socket.h>".}
proc sendmsg*(a1: TSocketHandle, a2: ptr Tmsghdr, a3: cint): int {.
importc, header: "<sys/socket.h>".}
proc sendto*(a1: TSocketHandle, a2: pointer, a3: int, a4: cint, a5: ptr Tsockaddr,
a6: Tsocklen): int {.
proc sendto*(a1: TSocketHandle, a2: pointer, a3: int, a4: cint, a5: ptr TSockAddr,
a6: TSocklen): int {.
importc, header: "<sys/socket.h>".}
proc setsockopt*(a1: TSocketHandle, a2, a3: cint, a4: pointer, a5: Tsocklen): cint {.
proc setsockopt*(a1: TSocketHandle, a2, a3: cint, a4: pointer, a5: TSocklen): cint {.
importc, header: "<sys/socket.h>".}
proc shutdown*(a1: TSocketHandle, a2: cint): cint {.
importc, header: "<sys/socket.h>".}
@ -2530,21 +2530,21 @@ proc freeaddrinfo*(a1: ptr Taddrinfo) {.importc, header: "<netdb.h>".}
proc gai_strerror*(a1: cint): cstring {.importc, header: "<netdb.h>".}
proc getaddrinfo*(a1, a2: cstring, a3: ptr TAddrInfo,
a4: var ptr TAddrInfo): cint {.importc, header: "<netdb.h>".}
proc getaddrinfo*(a1, a2: cstring, a3: ptr Taddrinfo,
a4: var ptr Taddrinfo): cint {.importc, header: "<netdb.h>".}
proc gethostbyaddr*(a1: pointer, a2: Tsocklen, a3: cint): ptr THostent {.
proc gethostbyaddr*(a1: pointer, a2: TSocklen, a3: cint): ptr Thostent {.
importc, header: "<netdb.h>".}
proc gethostbyname*(a1: cstring): ptr THostent {.importc, header: "<netdb.h>".}
proc gethostent*(): ptr THostent {.importc, header: "<netdb.h>".}
proc gethostbyname*(a1: cstring): ptr Thostent {.importc, header: "<netdb.h>".}
proc gethostent*(): ptr Thostent {.importc, header: "<netdb.h>".}
proc getnameinfo*(a1: ptr Tsockaddr, a2: Tsocklen,
a3: cstring, a4: Tsocklen, a5: cstring,
a6: Tsocklen, a7: cint): cint {.importc, header: "<netdb.h>".}
proc getnameinfo*(a1: ptr TSockAddr, a2: TSocklen,
a3: cstring, a4: TSocklen, a5: cstring,
a6: TSocklen, a7: cint): cint {.importc, header: "<netdb.h>".}
proc getnetbyaddr*(a1: int32, a2: cint): ptr TNetent {.importc, header: "<netdb.h>".}
proc getnetbyname*(a1: cstring): ptr TNetent {.importc, header: "<netdb.h>".}
proc getnetent*(): ptr TNetent {.importc, header: "<netdb.h>".}
proc getnetbyaddr*(a1: int32, a2: cint): ptr Tnetent {.importc, header: "<netdb.h>".}
proc getnetbyname*(a1: cstring): ptr Tnetent {.importc, header: "<netdb.h>".}
proc getnetent*(): ptr Tnetent {.importc, header: "<netdb.h>".}
proc getprotobyname*(a1: cstring): ptr TProtoent {.importc, header: "<netdb.h>".}
proc getprotobynumber*(a1: cint): ptr TProtoent {.importc, header: "<netdb.h>".}
@ -2560,10 +2560,10 @@ proc setnetent*(a1: cint) {.importc, header: "<netdb.h>".}
proc setprotoent*(a1: cint) {.importc, header: "<netdb.h>".}
proc setservent*(a1: cint) {.importc, header: "<netdb.h>".}
proc poll*(a1: ptr Tpollfd, a2: Tnfds, a3: int): cint {.
proc poll*(a1: ptr TPollfd, a2: Tnfds, a3: int): cint {.
importc, header: "<poll.h>".}
proc realpath*(name, resolved: CString): CString {.
proc realpath*(name, resolved: cstring): cstring {.
importc: "realpath", header: "<stdlib.h>".}

14
lib/pure/memfiles.nim
View file

@ -122,7 +122,7 @@ proc open*(filename: string, mode: TFileMode = fmRead,
template fail(errCode: TOSErrorCode, msg: expr) =
rollback()
if result.handle != 0: discard close(result.handle)
OSError(errCode)
osError(errCode)
var flags = if readonly: O_RDONLY else: O_RDWR
@ -133,22 +133,22 @@ proc open*(filename: string, mode: TFileMode = fmRead,
if result.handle == -1:
# XXX: errno is supposed to be set here
# Is there an exception that wraps it?
fail(OSLastError(), "error opening file")
fail(osLastError(), "error opening file")
if newFileSize != -1:
if ftruncate(result.handle, newFileSize) == -1:
fail(OSLastError(), "error setting file size")
fail(osLastError(), "error setting file size")
if mappedSize != -1:
result.size = mappedSize
else:
var stat: Tstat
var stat: TStat
if fstat(result.handle, stat) != -1:
# XXX: Hmm, this could be unsafe
# Why is mmap taking int anyway?
result.size = int(stat.st_size)
else:
fail(OSLastError(), "error getting file size")
fail(osLastError(), "error getting file size")
result.mem = mmap(
nil,
@ -159,7 +159,7 @@ proc open*(filename: string, mode: TFileMode = fmRead,
offset)
if result.mem == cast[pointer](MAP_FAILED):
fail(OSLastError(), "file mapping failed")
fail(osLastError(), "file mapping failed")
proc close*(f: var TMemFile) =
## closes the memory mapped file `f`. All changes are written back to the
@ -176,7 +176,7 @@ proc close*(f: var TMemFile) =
error = (closeHandle(f.fHandle) == 0) or error
else:
if f.handle != 0:
lastErr = OSLastError()
lastErr = osLastError()
error = munmap(f.mem, f.size) != 0
error = (close(f.handle) != 0) or error

24
lib/pure/os.nim
View file

@ -157,7 +157,7 @@ else: # UNIX-like operating system
CurDir* = '.'
ParDir* = ".."
DirSep* = '/'
AltSep* = Dirsep
AltSep* = DirSep
PathSep* = ':'
FileSystemCaseSensitive* = true
ExeExt* = ""
@ -448,7 +448,7 @@ proc getCurrentDir*(): string {.rtl, extern: "nos$1", tags: [].} =
else:
result = newString(bufsize)
if getcwd(result, bufsize) != nil:
setlen(result, c_strlen(result))
setLen(result, c_strlen(result))
else:
osError(osLastError())
@ -687,7 +687,7 @@ proc expandFilename*(filename: string): string {.rtl, extern: "nos$1",
result = newString(pathMax)
var r = realpath(filename, result)
if r.isNil: osError(osLastError())
setlen(result, c_strlen(result))
setLen(result, c_strlen(result))
proc changeFileExt*(filename, ext: string): string {.
noSideEffect, rtl, extern: "nos$1".} =
@ -939,12 +939,12 @@ proc copyFile*(source, dest: string) {.rtl, extern: "nos$1",
if not open(d, dest, fmWrite):
close(s)
osError(osLastError())
var buf = alloc(bufsize)
var buf = alloc(bufSize)
while true:
var bytesread = readBuffer(s, buf, bufsize)
var bytesread = readBuffer(s, buf, bufSize)
if bytesread > 0:
var byteswritten = writeBuffer(d, buf, bytesread)
if bytesread != bytesWritten:
if bytesread != byteswritten:
dealloc(buf)
close(s)
close(d)
@ -992,7 +992,7 @@ proc removeFile*(file: string) {.rtl, extern: "nos$1", tags: [FWriteDir].} =
if deleteFile(f) == 0:
osError(osLastError())
else:
if cremove(file) != 0'i32 and errno != ENOENT:
if c_remove(file) != 0'i32 and errno != ENOENT:
raise newException(EOS, $strerror(errno))
proc execShellCmd*(command: string): int {.rtl, extern: "nos$1",
@ -1124,7 +1124,7 @@ proc putEnv*(key, val: string) {.tags: [FWriteEnv].} =
add environment, (key & '=' & val)
indx = high(environment)
when defined(unix):
if cputenv(environment[indx]) != 0'i32:
if c_putenv(environment[indx]) != 0'i32:
osError(osLastError())
else:
when useWinUnicode:
@ -1217,10 +1217,10 @@ iterator walkDir*(dir: string): tuple[kind: TPathComponent, path: string] {.
if findNextFile(h, f) == 0'i32: break
findClose(h)
else:
var d = openDir(dir)
var d = opendir(dir)
if d != nil:
while true:
var x = readDir(d)
var x = readdir(d)
if x == nil: break
var y = $x.d_name
if y != "." and y != "..":
@ -1231,7 +1231,7 @@ iterator walkDir*(dir: string): tuple[kind: TPathComponent, path: string] {.
if S_ISDIR(s.st_mode): k = pcDir
if S_ISLNK(s.st_mode): k = succ(k)
yield (k, y)
discard closeDir(d)
discard closedir(d)
iterator walkDirRec*(dir: string, filter={pcFile, pcDir}): string {.
tags: [FReadDir].} =
@ -1524,7 +1524,7 @@ when defined(linux) or defined(solaris) or defined(bsd) or defined(aix):
if len > 256:
result = newString(len+1)
len = readlink(procPath, result, len)
setlen(result, len)
setLen(result, len)
when defined(macosx):
type

54
lib/pure/osproc.nim
View file

@ -561,13 +561,13 @@ elif not defined(useNimRtl):
readIdx = 0
writeIdx = 1
proc addCmdArgs(command: string, args: openarray[string]): string =
proc addCmdArgs(command: string, args: openArray[string]): string =
result = quoteShell(command)
for i in 0 .. high(args):
add(result, " ")
add(result, quoteShell(args[i]))
proc toCStringArray(b, a: openarray[string]): cstringArray =
proc toCStringArray(b, a: openArray[string]): cstringArray =
result = cast[cstringArray](alloc0((a.len + b.len + 1) * sizeof(cstring)))
for i in 0..high(b):
result[i] = cast[cstring](alloc(b[i].len+1))
@ -576,7 +576,7 @@ elif not defined(useNimRtl):
result[i+b.len] = cast[cstring](alloc(a[i].len+1))
copyMem(result[i+b.len], cstring(a[i]), a[i].len+1)
proc ToCStringArray(t: PStringTable): cstringArray =
proc toCStringArray(t: PStringTable): cstringArray =
result = cast[cstringArray](alloc0((t.len + 1) * sizeof(cstring)))
var i = 0
for key, val in pairs(t):
@ -585,7 +585,7 @@ elif not defined(useNimRtl):
copyMem(result[i], addr(x[0]), x.len+1)
inc(i)
proc EnvToCStringArray(): cstringArray =
proc envToCStringArray(): cstringArray =
var counter = 0
for key, val in envPairs(): inc counter
result = cast[cstringArray](alloc0((counter + 1) * sizeof(cstring)))
@ -598,16 +598,16 @@ elif not defined(useNimRtl):
proc startProcess(command: string,
workingDir: string = "",
args: openarray[string] = [],
args: openArray[string] = [],
env: PStringTable = nil,
options: set[TProcessOption] = {poStdErrToStdOut}): PProcess =
var
p_stdin, p_stdout, p_stderr: array [0..1, cint]
pStdin, pStdout, pStderr: array [0..1, cint]
new(result)
result.exitCode = -3 # for ``waitForExit``
if poParentStreams notin options:
if pipe(p_stdin) != 0'i32 or pipe(p_stdout) != 0'i32 or
pipe(p_stderr) != 0'i32:
if pipe(pStdin) != 0'i32 or pipe(pStdout) != 0'i32 or
pipe(pStderr) != 0'i32:
osError(osLastError())
var pid: TPid
@ -631,17 +631,17 @@ elif not defined(useNimRtl):
POSIX_SPAWN_SETPGROUP)
if poParentStreams notin options:
chck posix_spawn_file_actions_addclose(fops, p_stdin[writeIdx])
chck posix_spawn_file_actions_adddup2(fops, p_stdin[readIdx], readIdx)
chck posix_spawn_file_actions_addclose(fops, p_stdout[readIdx])
chck posix_spawn_file_actions_adddup2(fops, p_stdout[writeIdx], writeIdx)
chck posix_spawn_file_actions_addclose(fops, p_stderr[readIdx])
chck posix_spawn_file_actions_addclose(fops, pStdin[writeIdx])
chck posix_spawn_file_actions_adddup2(fops, pStdin[readIdx], readIdx)
chck posix_spawn_file_actions_addclose(fops, pStdout[readIdx])
chck posix_spawn_file_actions_adddup2(fops, pStdout[writeIdx], writeIdx)
chck posix_spawn_file_actions_addclose(fops, pStderr[readIdx])
if poStdErrToStdOut in options:
chck posix_spawn_file_actions_adddup2(fops, p_stdout[writeIdx], 2)
chck posix_spawn_file_actions_adddup2(fops, pStdout[writeIdx], 2)
else:
chck posix_spawn_file_actions_adddup2(fops, p_stderr[writeIdx], 2)
chck posix_spawn_file_actions_adddup2(fops, pStderr[writeIdx], 2)
var e = if env == nil: EnvToCStringArray() else: ToCStringArray(env)
var e = if env == nil: envToCStringArray() else: toCStringArray(env)
var a: cstringArray
var res: cint
if workingDir.len > 0: os.setCurrentDir(workingDir)
@ -709,16 +709,16 @@ elif not defined(useNimRtl):
else:
result.errHandle = 2
else:
result.inHandle = p_stdin[writeIdx]
result.outHandle = p_stdout[readIdx]
result.inHandle = pStdin[writeIdx]
result.outHandle = pStdout[readIdx]
if poStdErrToStdOut in options:
result.errHandle = result.outHandle
discard close(p_stderr[readIdx])
discard close(pStderr[readIdx])
else:
result.errHandle = p_stderr[readIdx]
discard close(p_stderr[writeIdx])
discard close(p_stdin[readIdx])
discard close(p_stdout[writeIdx])
result.errHandle = pStderr[readIdx]
discard close(pStderr[writeIdx])
discard close(pStdin[readIdx])
discard close(pStdout[writeIdx])
proc close(p: PProcess) =
if p.inStream != nil: close(p.inStream)
@ -735,7 +735,7 @@ elif not defined(useNimRtl):
if kill(-p.id, SIGCONT) != 0'i32: osError(osLastError())
proc running(p: PProcess): bool =
var ret = waitPid(p.id, p.exitCode, WNOHANG)
var ret = waitpid(p.id, p.exitCode, WNOHANG)
if ret == 0: return true # Can't establish status. Assume running.
result = ret == int(p.id)
@ -751,14 +751,14 @@ elif not defined(useNimRtl):
# ``running`` probably set ``p.exitCode`` for us. Since ``p.exitCode`` is
# initialized with -3, wrong success exit codes are prevented.
if p.exitCode != -3: return p.exitCode
if waitPid(p.id, p.exitCode, 0) < 0:
if waitpid(p.id, p.exitCode, 0) < 0:
p.exitCode = -3
osError(osLastError())
result = int(p.exitCode) shr 8
proc peekExitCode(p: PProcess): int =
if p.exitCode != -3: return p.exitCode
var ret = waitPid(p.id, p.exitCode, WNOHANG)
var ret = waitpid(p.id, p.exitCode, WNOHANG)
var b = ret == int(p.id)
if b: result = -1
if p.exitCode == -3: result = -1
@ -808,7 +808,7 @@ elif not defined(useNimRtl):
setLen(s, L)
proc select(readfds: var seq[PProcess], timeout = 500): int =
var tv: TTimeVal
var tv: Ttimeval
tv.tv_sec = 0
tv.tv_usec = timeout * 1000

80
lib/pure/sockets.nim
View file

@ -230,7 +230,7 @@ proc socket*(domain: TDomain = AF_INET, typ: TType = SOCK_STREAM,
when defined(Windows):
result = newTSocket(winlean.socket(ord(domain), ord(typ), ord(protocol)), buffered)
else:
result = newTSocket(posix.socket(ToInt(domain), ToInt(typ), ToInt(protocol)), buffered)
result = newTSocket(posix.socket(toInt(domain), toInt(typ), toInt(protocol)), buffered)
when defined(ssl):
CRYPTO_malloc_init()
@ -371,7 +371,7 @@ proc socketError*(socket: TSocket, err: int = -1, async = false) =
else:
if lastError.int32 == EAGAIN or lastError.int32 == EWOULDBLOCK:
return
else: OSError(lastError)
else: osError(lastError)
else: osError(lastError)
proc listen*(socket: TSocket, backlog = SOMAXCONN) {.tags: [FReadIO].} =
@ -436,16 +436,16 @@ proc bindAddr*(socket: TSocket, port = TPort(0), address = "") {.
name.sin_port = sockets.htons(int16(port))
name.sin_addr.s_addr = sockets.htonl(INADDR_ANY)
if bindSocket(socket.fd, cast[ptr TSockAddr](addr(name)),
sizeof(name).TSockLen) < 0'i32:
sizeof(name).TSocklen) < 0'i32:
osError(osLastError())
else:
var hints: TAddrInfo
var aiList: ptr TAddrInfo = nil
var hints: Taddrinfo
var aiList: ptr Taddrinfo = nil
hints.ai_family = toInt(AF_INET)
hints.ai_socktype = toInt(SOCK_STREAM)
hints.ai_protocol = toInt(IPPROTO_TCP)
gaiNim(address, port, hints, aiList)
if bindSocket(socket.fd, aiList.ai_addr, aiList.ai_addrlen.TSockLen) < 0'i32:
if bindSocket(socket.fd, aiList.ai_addr, aiList.ai_addrlen.TSocklen) < 0'i32:
osError(osLastError())
proc getSockName*(socket: TSocket): TPort =
@ -457,7 +457,7 @@ proc getSockName*(socket: TSocket): TPort =
name.sin_family = posix.AF_INET
#name.sin_port = htons(cint16(port))
#name.sin_addr.s_addr = htonl(INADDR_ANY)
var namelen = sizeof(name).TSockLen
var namelen = sizeof(name).TSocklen
if getsockname(socket.fd, cast[ptr TSockAddr](addr(name)),
addr(namelen)) == -1'i32:
osError(osLastError())
@ -467,7 +467,7 @@ template acceptAddrPlain(noClientRet, successRet: expr,
sslImplementation: stmt): stmt {.immediate.} =
assert(client != nil)
var sockAddress: Tsockaddr_in
var addrLen = sizeof(sockAddress).TSockLen
var addrLen = sizeof(sockAddress).TSocklen
var sock = accept(server.fd, cast[ptr TSockAddr](addr(sockAddress)),
addr(addrLen))
@ -679,10 +679,10 @@ proc getHostByAddr*(ip: string): Thostent {.tags: [FReadIO].} =
cint(sockets.AF_INET))
if s == nil: osError(osLastError())
else:
var s = posix.gethostbyaddr(addr(myaddr), sizeof(myaddr).TSockLen,
var s = posix.gethostbyaddr(addr(myaddr), sizeof(myaddr).TSocklen,
cint(posix.AF_INET))
if s == nil:
raise newException(EOS, $hStrError(h_errno))
raise newException(EOS, $hstrerror(h_errno))
result.name = $s.h_name
result.aliases = cstringArrayToSeq(s.h_aliases)
@ -690,9 +690,9 @@ proc getHostByAddr*(ip: string): Thostent {.tags: [FReadIO].} =
result.addrtype = TDomain(s.h_addrtype)
else:
if s.h_addrtype == posix.AF_INET:
result.addrType = AF_INET
result.addrtype = AF_INET
elif s.h_addrtype == posix.AF_INET6:
result.addrType = AF_INET6
result.addrtype = AF_INET6
else:
raise newException(EOS, "unknown h_addrtype")
result.addrList = cstringArrayToSeq(s.h_addr_list)
@ -711,9 +711,9 @@ proc getHostByName*(name: string): Thostent {.tags: [FReadIO].} =
result.addrtype = TDomain(s.h_addrtype)
else:
if s.h_addrtype == posix.AF_INET:
result.addrType = AF_INET
result.addrtype = AF_INET
elif s.h_addrtype == posix.AF_INET6:
result.addrType = AF_INET6
result.addrtype = AF_INET6
else:
raise newException(EOS, "unknown h_addrtype")
result.addrList = cstringArrayToSeq(s.h_addr_list)
@ -723,7 +723,7 @@ proc getSockOptInt*(socket: TSocket, level, optname: int): int {.
tags: [FReadIO].} =
## getsockopt for integer options.
var res: cint
var size = sizeof(res).TSockLen
var size = sizeof(res).TSocklen
if getsockopt(socket.fd, cint(level), cint(optname),
addr(res), addr(size)) < 0'i32:
osError(osLastError())
@ -734,7 +734,7 @@ proc setSockOptInt*(socket: TSocket, level, optname, optval: int) {.
## setsockopt for integer options.
var value = cint(optval)
if setsockopt(socket.fd, cint(level), cint(optname), addr(value),
sizeof(value).TSockLen) < 0'i32:
sizeof(value).TSocklen) < 0'i32:
osError(osLastError())
proc toCInt(opt: TSOBool): cint =
@ -751,7 +751,7 @@ proc getSockOpt*(socket: TSocket, opt: TSOBool, level = SOL_SOCKET): bool {.
tags: [FReadIO].} =
## Retrieves option ``opt`` as a boolean value.
var res: cint
var size = sizeof(res).TSockLen
var size = sizeof(res).TSocklen
if getsockopt(socket.fd, cint(level), toCInt(opt),
addr(res), addr(size)) < 0'i32:
osError(osLastError())
@ -762,7 +762,7 @@ proc setSockOpt*(socket: TSocket, opt: TSOBool, value: bool, level = SOL_SOCKET)
## Sets option ``opt`` to a boolean value specified by ``value``.
var valuei = cint(if value: 1 else: 0)
if setsockopt(socket.fd, cint(level), toCInt(opt), addr(valuei),
sizeof(valuei).TSockLen) < 0'i32:
sizeof(valuei).TSocklen) < 0'i32:
osError(osLastError())
proc connect*(socket: TSocket, address: string, port = TPort(0),
@ -773,8 +773,8 @@ proc connect*(socket: TSocket, address: string, port = TPort(0),
## not do it.
##
## If ``socket`` is an SSL socket a handshake will be automatically performed.
var hints: TAddrInfo
var aiList: ptr TAddrInfo = nil
var hints: Taddrinfo
var aiList: ptr Taddrinfo = nil
hints.ai_family = toInt(af)
hints.ai_socktype = toInt(SOCK_STREAM)
hints.ai_protocol = toInt(IPPROTO_TCP)
@ -784,7 +784,7 @@ proc connect*(socket: TSocket, address: string, port = TPort(0),
var lastError: TOSErrorCode
var it = aiList
while it != nil:
if connect(socket.fd, it.ai_addr, it.ai_addrlen.TSockLen) == 0'i32:
if connect(socket.fd, it.ai_addr, it.ai_addrlen.TSocklen) == 0'i32:
success = true
break
else: lastError = osLastError()
@ -836,8 +836,8 @@ proc connectAsync*(socket: TSocket, name: string, port = TPort(0),
##
## **Note**: For SSL sockets, the ``handshake`` procedure must be called
## whenever the socket successfully connects to a server.
var hints: TAddrInfo
var aiList: ptr TAddrInfo = nil
var hints: Taddrinfo
var aiList: ptr Taddrinfo = nil
hints.ai_family = toInt(af)
hints.ai_socktype = toInt(SOCK_STREAM)
hints.ai_protocol = toInt(IPPROTO_TCP)
@ -847,7 +847,7 @@ proc connectAsync*(socket: TSocket, name: string, port = TPort(0),
var lastError: TOSErrorCode
var it = aiList
while it != nil:
var ret = connect(socket.fd, it.ai_addr, it.ai_addrlen.TSockLen)
var ret = connect(socket.fd, it.ai_addr, it.ai_addrlen.TSocklen)
if ret == 0'i32:
success = true
break
@ -912,7 +912,7 @@ when defined(ssl):
else:
SSLError("Socket is not an SSL socket.")
proc timeValFromMilliseconds(timeout = 500): TTimeval =
proc timeValFromMilliseconds(timeout = 500): Ttimeval =
if timeout != -1:
var seconds = timeout div 1000
result.tv_sec = seconds.int32
@ -970,7 +970,7 @@ proc select*(readfds, writefds, exceptfds: var seq[TSocket],
if buffersFilled > 0:
return buffersFilled
var tv {.noInit.}: TTimeval = timeValFromMilliseconds(timeout)
var tv {.noInit.}: Ttimeval = timeValFromMilliseconds(timeout)
var rd, wr, ex: TFdSet
var m = 0
@ -993,7 +993,7 @@ proc select*(readfds, writefds: var seq[TSocket],
let buffersFilled = checkBuffer(readfds)
if buffersFilled > 0:
return buffersFilled
var tv {.noInit.}: TTimeval = timeValFromMilliseconds(timeout)
var tv {.noInit.}: Ttimeval = timeValFromMilliseconds(timeout)
var rd, wr: TFdSet
var m = 0
@ -1017,7 +1017,7 @@ proc selectWrite*(writefds: var seq[TSocket],
##
## ``timeout`` is specified in miliseconds and ``-1`` can be specified for
## an unlimited time.
var tv {.noInit.}: TTimeval = timeValFromMilliseconds(timeout)
var tv {.noInit.}: Ttimeval = timeValFromMilliseconds(timeout)
var wr: TFdSet
var m = 0
@ -1035,7 +1035,7 @@ proc select*(readfds: var seq[TSocket], timeout = 500): int =
let buffersFilled = checkBuffer(readfds)
if buffersFilled > 0:
return buffersFilled
var tv {.noInit.}: TTimeval = timeValFromMilliseconds(timeout)
var tv {.noInit.}: Ttimeval = timeValFromMilliseconds(timeout)
var rd: TFdSet
var m = 0
@ -1461,8 +1461,8 @@ proc recvAsync*(socket: TSocket, s: var TaintedString): bool {.
else: osError(err)
else:
if err.int32 == EAGAIN or err.int32 == EWOULDBLOCK:
return False
else: OSError(err)
return false
else: osError(err)
setLen(s.string, pos + bytesRead)
if bytesRead != bufSize-1: break
@ -1488,7 +1488,7 @@ proc recvFrom*(socket: TSocket, data: var string, length: int,
# TODO: Buffered sockets
data.setLen(length)
var sockAddress: Tsockaddr_in
var addrLen = sizeof(sockAddress).TSockLen
var addrLen = sizeof(sockAddress).TSocklen
result = recvfrom(socket.fd, cstring(data), length.cint, flags.cint,
cast[ptr TSockAddr](addr(sockAddress)), addr(addrLen))
@ -1514,8 +1514,8 @@ proc recvFromAsync*(socket: TSocket, data: var string, length: int,
else: osError(err)
else:
if err.int32 == EAGAIN or err.int32 == EWOULDBLOCK:
return False
else: OSError(err)
return false
else: osError(err)
proc skip*(socket: TSocket) {.tags: [FReadIO], deprecated.} =
## skips all the data that is pending for the socket
@ -1606,7 +1606,7 @@ proc sendAsync*(socket: TSocket, data: string): int {.tags: [FWriteIO].} =
else:
if err.int32 == EAGAIN or err.int32 == EWOULDBLOCK:
return 0
else: OSError(err)
else: osError(err)
proc trySend*(socket: TSocket, data: string): bool {.tags: [FWriteIO].} =
@ -1622,8 +1622,8 @@ proc sendTo*(socket: TSocket, address: string, port: TPort, data: pointer,
## this function will try each IP of that hostname.
##
## **Note:** This proc is not available for SSL sockets.
var hints: TAddrInfo
var aiList: ptr TAddrInfo = nil
var hints: Taddrinfo
var aiList: ptr Taddrinfo = nil
hints.ai_family = toInt(af)
hints.ai_socktype = toInt(SOCK_STREAM)
hints.ai_protocol = toInt(IPPROTO_TCP)
@ -1634,7 +1634,7 @@ proc sendTo*(socket: TSocket, address: string, port: TPort, data: pointer,
var it = aiList
while it != nil:
result = sendto(socket.fd, data, size.cint, flags.cint, it.ai_addr,
it.ai_addrlen.TSockLen)
it.ai_addrlen.TSocklen)
if result != -1'i32:
success = true
break
@ -1666,11 +1666,11 @@ proc setBlocking(s: TSocket, blocking: bool) =
else: # BSD sockets
var x: int = fcntl(s.fd, F_GETFL, 0)
if x == -1:
OSError(OSLastError())
osError(osLastError())
else:
var mode = if blocking: x and not O_NONBLOCK else: x or O_NONBLOCK
if fcntl(s.fd, F_SETFL, mode) == -1:
OSError(OSLastError())
osError(osLastError())
s.nonblocking = not blocking
discard """ proc setReuseAddr*(s: TSocket) =

4
lib/system/dyncalls.nim
View file

@ -56,7 +56,7 @@ when defined(posix):
RTLD_NOW {.importc: "RTLD_NOW", header: "<dlfcn.h>".}: int
proc dlclose(lib: TLibHandle) {.importc, header: "<dlfcn.h>".}
proc dlopen(path: CString, mode: int): TLibHandle {.
proc dlopen(path: cstring, mode: int): TLibHandle {.
importc, header: "<dlfcn.h>".}
proc dlsym(lib: TLibHandle, name: cstring): TProcAddr {.
importc, header: "<dlfcn.h>".}
@ -72,7 +72,7 @@ when defined(posix):
proc nimGetProcAddr(lib: TLibHandle, name: cstring): TProcAddr =
result = dlsym(lib, name)
if result == nil: ProcAddrError(name)
if result == nil: procAddrError(name)
elif defined(windows) or defined(dos):
#