diff --git a/lib/posix/posix.nim b/lib/posix/posix.nim
index 806c255ee9..685a1dafce 100644
--- a/lib/posix/posix.nim
+++ b/lib/posix/posix.nim
@@ -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>".}
 
 
diff --git a/lib/pure/memfiles.nim b/lib/pure/memfiles.nim
index d8a27fde39..8c404abe84 100644
--- a/lib/pure/memfiles.nim
+++ b/lib/pure/memfiles.nim
@@ -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
 
diff --git a/lib/pure/os.nim b/lib/pure/os.nim
index 9b08fea6f1..504343d676 100644
--- a/lib/pure/os.nim
+++ b/lib/pure/os.nim
@@ -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
diff --git a/lib/pure/osproc.nim b/lib/pure/osproc.nim
index 76765ff8e9..fe4303d8a7 100644
--- a/lib/pure/osproc.nim
+++ b/lib/pure/osproc.nim
@@ -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
     
diff --git a/lib/pure/sockets.nim b/lib/pure/sockets.nim
index 61df82640b..de445dd368 100644
--- a/lib/pure/sockets.nim
+++ b/lib/pure/sockets.nim
@@ -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) =
diff --git a/lib/system/dyncalls.nim b/lib/system/dyncalls.nim
index 65f8cbb092..9ef1a99ca6 100644
--- a/lib/system/dyncalls.nim
+++ b/lib/system/dyncalls.nim
@@ -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):
   #