Remove dollars from system call support symbols

libc/sock/accept-nt.c

@@ -27,19 +27,19 @@
 #include "libc/sysv/consts/sock.h"
 #include "libc/sysv/errfuns.h"
 
-textwindows int accept$nt(struct Fd *fd, void *addr, uint32_t *addrsize,
+textwindows int sys_accept_nt(struct Fd *fd, void *addr, uint32_t *addrsize,
                           int flags) {
   int64_t h;
   int client;
   uint32_t yes;
   for (;;) {
-    if (!WSAPoll(&(struct pollfd$nt){fd->handle, POLLIN}, 1, 1000)) continue;
+    if (!WSAPoll(&(struct sys_pollfd_nt){fd->handle, POLLIN}, 1, 1000)) continue;
     if ((client = __reservefd()) == -1) return -1;
     if ((h = WSAAccept(fd->handle, addr, (int32_t *)addrsize, 0, 0)) != -1) {
       if (flags & SOCK_NONBLOCK) {
         yes = 1;
-        if (__ioctlsocket$nt(g_fds.p[client].handle, FIONBIO, &yes) == -1) {
-          __closesocket$nt(g_fds.p[client].handle);
+        if (__sys_ioctlsocket_nt(g_fds.p[client].handle, FIONBIO, &yes) == -1) {
+          __sys_closesocket_nt(g_fds.p[client].handle);
           __releasefd(client);
           return __winsockerr();
         }

libc/sock/accept-sysv.c

@@ -19,9 +19,9 @@
 #include "libc/dce.h"
 #include "libc/sock/internal.h"
 
-int accept$sysv(int server, void *addr, uint32_t *addrsize) {
+int sys_accept(int server, void *addr, uint32_t *addrsize) {
   int client;
-  if ((client = __accept$sysv(server, addr, addrsize, 0)) != -1 && IsBsd()) {
+  if ((client = __sys_accept(server, addr, addrsize, 0)) != -1 && IsBsd()) {
     sockaddr2linux(addr);
   }
   return client;

libc/sock/accept4-sysv.c

@@ -23,17 +23,16 @@
 
 #define __NR_accept4_linux 0x0120 /* rhel5:enosysevil */
 
-int accept4$sysv(int server, void *addr, uint32_t *addrsize, int flags) {
+int sys_accept4(int server, void *addr, uint32_t *addrsize, int flags) {
   static bool once, demodernize;
   int olderr, client;
   if (!flags || demodernize) goto TriedAndTrue;
   olderr = errno;
-  client = __accept4$sysv(server, addr, addrsize, flags);
+  client = __sys_accept4(server, addr, addrsize, flags);
   if (client == -1 && errno == ENOSYS) {
     errno = olderr;
   TriedAndTrue:
-    client =
-        fixupnewsockfd$sysv(__accept$sysv(server, addr, addrsize, 0), flags);
+    client = __fixupnewsockfd(__sys_accept(server, addr, addrsize, 0), flags);
   } else if (SupportsLinux() && !once) {
     once = true;
     if (client == __NR_accept4_linux) {

libc/sock/accept4.c

@@ -37,9 +37,9 @@ int accept4(int fd, void *out_addr, uint32_t *inout_addrsize, int flags) {
   if (!out_addr) return efault();
   if (!inout_addrsize) return efault();
   if (!IsWindows()) {
-    return accept4$sysv(fd, out_addr, inout_addrsize, flags);
+    return sys_accept4(fd, out_addr, inout_addrsize, flags);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return accept$nt(&g_fds.p[fd], out_addr, inout_addrsize, flags);
+    return sys_accept_nt(&g_fds.p[fd], out_addr, inout_addrsize, flags);
   } else {
     return ebadf();
   }

libc/sock/bind-nt.c

@@ -23,9 +23,9 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int bind$nt(struct Fd *fd, const void *addr, uint32_t addrsize) {
+textwindows int sys_bind_nt(struct Fd *fd, const void *addr, uint32_t addrsize) {
   assert(fd->kind == kFdSocket);
-  if (__bind$nt(fd->handle, addr, addrsize) != -1) {
+  if (__sys_bind_nt(fd->handle, addr, addrsize) != -1) {
     return 0;
   } else {
     return __winsockerr();

libc/sock/bind.c

@@ -38,17 +38,17 @@ int bind(int fd, const void *addr, uint32_t addrsize) {
   if (addrsize == sizeof(struct sockaddr_in)) {
     if (!IsWindows()) {
       if (!IsBsd()) {
-        return bind$sysv(fd, addr, addrsize);
+        return sys_bind(fd, addr, addrsize);
       } else {
-        struct sockaddr_in$bsd addr2;
+        struct sockaddr_in_bsd addr2;
         _Static_assert(sizeof(struct sockaddr_in) ==
-                       sizeof(struct sockaddr_in$bsd));
+                       sizeof(struct sockaddr_in_bsd));
         memcpy(&addr2, addr, sizeof(struct sockaddr_in));
         sockaddr2bsd(&addr2);
-        return bind$sysv(fd, &addr2, addrsize);
+        return sys_bind(fd, &addr2, addrsize);
       }
     } else if (__isfdkind(fd, kFdSocket)) {
-      return bind$nt(&g_fds.p[fd], addr, addrsize);
+      return sys_bind_nt(&g_fds.p[fd], addr, addrsize);
     } else {
       return ebadf();
     }

libc/sock/closesocket-nt.c

@@ -23,10 +23,10 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int closesocket$nt(int fd) {
+textwindows int sys_closesocket_nt(int fd) {
   int rc;
   if (!__isfdkind(fd, kFdSocket)) return ebadf();
-  if (__closesocket$nt(g_fds.p[fd].handle) != -1) {
+  if (__sys_closesocket_nt(g_fds.p[fd].handle) != -1) {
     rc = 0;
   } else {
     rc = __winsockerr();

libc/sock/connect-nt.c

@@ -23,9 +23,10 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int connect$nt(struct Fd *fd, const void *addr, uint32_t addrsize) {
+textwindows int sys_connect_nt(struct Fd *fd, const void *addr,
+                               uint32_t addrsize) {
   assert(fd->kind == kFdSocket);
-  return winsockblock(
+  return __winsockblock(
       fd->handle, FD_CONNECT_BIT,
       WSAConnect(fd->handle, addr, addrsize, NULL, NULL, NULL, NULL));
 }

libc/sock/connect-sysv.c

@@ -21,16 +21,16 @@
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
-int connect$sysv(int fd, const void *addr, uint32_t addrsize) {
+int sys_connect(int fd, const void *addr, uint32_t addrsize) {
   if (addrsize != sizeof(struct sockaddr_in)) return einval();
   if (!IsBsd()) {
-    return __connect$sysv(fd, addr, addrsize);
+    return __sys_connect(fd, addr, addrsize);
   } else {
-    struct sockaddr_in$bsd addr2;
+    struct sockaddr_in_bsd addr2;
     _Static_assert(sizeof(struct sockaddr_in) ==
-                   sizeof(struct sockaddr_in$bsd));
+                   sizeof(struct sockaddr_in_bsd));
     memcpy(&addr2, addr, sizeof(struct sockaddr_in));
     sockaddr2bsd(&addr2);
-    return connect$sysv(fd, &addr2, addrsize);
+    return sys_connect(fd, &addr2, addrsize);
   }
 }

libc/sock/connect.c

@@ -35,9 +35,9 @@
 int connect(int fd, const void *addr, uint32_t addrsize) {
   if (!addr) return efault();
   if (!IsWindows()) {
-    return connect$sysv(fd, addr, addrsize);
+    return sys_connect(fd, addr, addrsize);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return connect$nt(&g_fds.p[fd], addr, addrsize);
+    return sys_connect_nt(&g_fds.p[fd], addr, addrsize);
   } else {
     return ebadf();
   }

libc/sock/epoll.c

@@ -284,12 +284,12 @@ static int64_t reflock__keyed_event;
 static struct TsTree epoll__handle_tree;
 
 static textwindows void err_map_win_error(void) {
-  errno = MapDosErrorToErrno(GetLastError());
+  errno = __dos2errno(GetLastError());
 }
 
 static textwindows void err_set_win_error(uint32_t error) {
   SetLastError(error);
-  errno = MapDosErrorToErrno(error);
+  errno = __dos2errno(error);
 }
 
 static textwindows int err_check_handle(int64_t handle) {
@@ -1318,7 +1318,7 @@ static textwindows struct PortState *port_state_from_handle_tree_node(
   return CONTAINOF(tree_node, struct PortState, handle_tree_node);
 }
 
-static textwindows noinline int epoll_create1$nt(uint32_t flags) {
+static textwindows noinline int sys_epoll_create1_nt(uint32_t flags) {
   int fd;
   int64_t ephnd;
   struct PortState *port_state;
@@ -1344,13 +1344,13 @@ static textwindows noinline int epoll_create1$nt(uint32_t flags) {
   return fd;
 }
 
-static textwindows noinline int epoll_ctl$nt(int epfd, int op, int fd,
-                                             struct epoll_event *ev) {
+static textwindows noinline int sys_epoll_ctl_nt(int epfd, int op, int fd,
+                                                 struct epoll_event *ev) {
   int r;
   struct PortState *port_state;
   struct TsTreeNode *tree_node;
   if (!IsWindows()) {
-    return epoll_ctl$sysv(epfd, op, fd, ev);
+    return sys_epoll_ctl(epfd, op, fd, ev);
   } else {
     if (wepoll_init() < 0) return -1;
     if (!__isfdopen(fd)) return ebadf();
@@ -1374,9 +1374,10 @@ static textwindows noinline int epoll_ctl$nt(int epfd, int op, int fd,
   }
 }
 
-static textwindows noinline int epoll_wait$nt(int epfd,
-                                              struct epoll_event *events,
-                                              int maxevents, int timeoutms) {
+static textwindows noinline int sys_epoll_wait_nt(int epfd,
+                                                  struct epoll_event *events,
+                                                  int maxevents,
+                                                  int timeoutms) {
   int num_events;
   struct PortState *port_state;
   struct TsTreeNode *tree_node;
@@ -1398,7 +1399,7 @@ err:
   return -1;
 }
 
-static textwindows noinline int close$epoll$nt(int fd) {
+static textwindows noinline int sys_close_epoll_nt(int fd) {
   struct PortState *port_state;
   struct TsTreeNode *tree_node;
   if (wepoll_init() < 0) return -1;
@@ -1416,11 +1417,11 @@ err:
   return -1;
 }
 
-int close$epoll(int fd) {
+int sys_close_epoll(int fd) {
   if (!IsWindows()) {
-    return close$sysv(fd);
+    return sys_close(fd);
   } else {
-    return close$epoll$nt(fd);
+    return sys_close_epoll_nt(fd);
   }
 }
 
@@ -1447,9 +1448,9 @@ int epoll_create1(int flags) {
   int fd;
   if (flags & ~O_CLOEXEC) return einval();
   if (!IsWindows()) {
-    return __ensurefds(fixupnewfd$sysv(epoll_create$sysv(1337), flags));
+    return __ensurefds(__fixupnewfd(sys_epoll_create(1337), flags));
   } else {
-    return epoll_create1$nt(flags);
+    return sys_epoll_create1_nt(flags);
   }
 }
 
@@ -1487,9 +1488,9 @@ int epoll_create1(int flags) {
  */
 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev) {
   if (!IsWindows()) {
-    return epoll_ctl$sysv(epfd, op, fd, ev);
+    return sys_epoll_ctl(epfd, op, fd, ev);
   } else {
-    return epoll_ctl$nt(epfd, op, fd, ev);
+    return sys_epoll_ctl_nt(epfd, op, fd, ev);
   }
 }
 
@@ -1504,8 +1505,8 @@ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev) {
 int epoll_wait(int epfd, struct epoll_event *events, int maxevents,
                int timeoutms) {
   if (!IsWindows()) {
-    return epoll_wait$sysv(epfd, events, maxevents, timeoutms);
+    return sys_epoll_wait(epfd, events, maxevents, timeoutms);
   } else {
-    return epoll_wait$nt(epfd, events, maxevents, timeoutms);
+    return sys_epoll_wait_nt(epfd, events, maxevents, timeoutms);
   }
 }

libc/sock/fixupnewsockfd.c

@@ -26,7 +26,7 @@
  *
  * @param fd of -1 means no-op
  */
-int fixupnewsockfd$sysv(int fd, int flags) {
-  return fixupnewfd$sysv(fd, (((flags & SOCK_CLOEXEC) ? O_CLOEXEC : 0) |
-                              ((flags & SOCK_NONBLOCK) ? O_NONBLOCK : 0)));
+int __fixupnewsockfd(int fd, int flags) {
+  return __fixupnewfd(fd, (((flags & SOCK_CLOEXEC) ? O_CLOEXEC : 0) |
+                           ((flags & SOCK_NONBLOCK) ? O_NONBLOCK : 0)));
 }

libc/sock/getpeername-nt.c

@@ -24,10 +24,10 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int getpeername$nt(struct Fd *fd, void *out_addr,
+textwindows int sys_getpeername_nt(struct Fd *fd, void *out_addr,
                                uint32_t *out_addrsize) {
   assert(fd->kind == kFdSocket);
-  if (__getpeername$nt(fd->handle, out_addr, out_addrsize) != -1) {
+  if (__sys_getpeername_nt(fd->handle, out_addr, out_addrsize) != -1) {
     return 0;
   } else {
     return __winsockerr();

libc/sock/getpeername-sysv.c

@@ -19,8 +19,8 @@
 #include "libc/dce.h"
 #include "libc/sock/internal.h"
 
-int getpeername$sysv(int fd, void *out_addr, uint32_t *out_addrsize) {
-  int rc = __getpeername$sysv(fd, out_addr, out_addrsize);
+int sys_getpeername(int fd, void *out_addr, uint32_t *out_addrsize) {
+  int rc = __sys_getpeername(fd, out_addr, out_addrsize);
   if (rc != -1 && IsBsd()) {
     sockaddr2linux(out_addr);
   }

libc/sock/getpeername.c

@@ -29,9 +29,9 @@
  */
 int getpeername(int fd, void *out_addr, uint32_t *out_addrsize) {
   if (!IsWindows()) {
-    return getpeername$sysv(fd, out_addr, out_addrsize);
+    return sys_getpeername(fd, out_addr, out_addrsize);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return getpeername$nt(&g_fds.p[fd], out_addr, out_addrsize);
+    return sys_getpeername_nt(&g_fds.p[fd], out_addr, out_addrsize);
   } else {
     return ebadf();
   }

libc/sock/getsockname-nt.c

@@ -24,10 +24,10 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int getsockname$nt(struct Fd *fd, void *out_addr,
+textwindows int sys_getsockname_nt(struct Fd *fd, void *out_addr,
                                uint32_t *out_addrsize) {
   assert(fd->kind == kFdSocket);
-  if (__getsockname$nt(fd->handle, out_addr, out_addrsize) != -1) {
+  if (__sys_getsockname_nt(fd->handle, out_addr, out_addrsize) != -1) {
     return 0;
   } else {
     return __winsockerr();

libc/sock/getsockname-sysv.c

@@ -19,8 +19,8 @@
 #include "libc/dce.h"
 #include "libc/sock/internal.h"
 
-int getsockname$sysv(int fd, void *out_addr, uint32_t *out_addrsize) {
-  int rc = __getsockname$sysv(fd, out_addr, out_addrsize);
+int sys_getsockname(int fd, void *out_addr, uint32_t *out_addrsize) {
+  int rc = __sys_getsockname(fd, out_addr, out_addrsize);
   if (rc != -1 && IsBsd()) {
     sockaddr2linux(out_addr);
   }

libc/sock/getsockname.c

@@ -29,9 +29,9 @@
  */
 int getsockname(int fd, void *out_addr, uint32_t *out_addrsize) {
   if (!IsWindows()) {
-    return getsockname$sysv(fd, out_addr, out_addrsize);
+    return sys_getsockname(fd, out_addr, out_addrsize);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return getsockname$nt(&g_fds.p[fd], out_addr, out_addrsize);
+    return sys_getsockname_nt(&g_fds.p[fd], out_addr, out_addrsize);
   } else {
     return ebadf();
   }

libc/sock/getsockopt-nt.c

@@ -23,11 +23,11 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int getsockopt$nt(struct Fd *fd, int level, int optname,
+textwindows int sys_getsockopt_nt(struct Fd *fd, int level, int optname,
                               void *out_opt_optval, uint32_t *out_optlen) {
   /* TODO(jart): Use WSAIoctl? */
   assert(fd->kind == kFdSocket);
-  if (__getsockopt$nt(fd->handle, level, optname, out_opt_optval, out_optlen) !=
+  if (__sys_getsockopt_nt(fd->handle, level, optname, out_opt_optval, out_optlen) !=
       -1) {
     return 0;
   } else {

libc/sock/getsockopt.c

@@ -37,9 +37,9 @@ int getsockopt(int fd, int level, int optname, void *out_opt_optval,
   if (!level || !optname) return enoprotoopt(); /* our sysvconsts definition */
   if (optname == -1) return 0;                  /* our sysvconsts definition */
   if (!IsWindows()) {
-    return getsockopt$sysv(fd, level, optname, out_opt_optval, out_optlen);
+    return sys_getsockopt(fd, level, optname, out_opt_optval, out_optlen);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return getsockopt$nt(&g_fds.p[fd], level, optname, out_opt_optval,
+    return sys_getsockopt_nt(&g_fds.p[fd], level, optname, out_opt_optval,
                          out_optlen);
   } else {
     return ebadf();

libc/sock/internal.h

@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_SOCK_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_SOCK_INTERNAL_H_
-#ifndef __STRICT_ANSI__
 #include "libc/bits/bits.h"
+#include "libc/calls/internal.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/select.h"
 #include "libc/sock/sock.h"
@@ -21,17 +21,13 @@ COSMOPOLITAN_C_START_
 #define FD_CLOSE       (1 << FD_CLOSE_BIT)
 #define FD_CLOSE_BIT   5
 
-struct Fd;
-struct iovec;
-struct timeval;
-
-struct sockaddr$bsd {
+struct sockaddr_bsd {
   uint8_t sa_len;    /* « different type */
   uint8_t sa_family; /* « different type */
   char sa_data[14];
 };
 
-struct sockaddr_in$bsd {
+struct sockaddr_in_bsd {
   uint8_t sin_len;    /* « different type */
   uint8_t sin_family; /* « different type */
   uint16_t sin_port;
@@ -39,7 +35,7 @@ struct sockaddr_in$bsd {
   uint8_t sin_zero[8];
 };
 
-struct msghdr$bsd {
+struct msghdr_bsd {
   void *msg_name;
   uint32_t msg_namelen;
   struct iovec *msg_iov;
@@ -49,69 +45,67 @@ struct msghdr$bsd {
   uint32_t msg_flags; /* « different type */
 };
 
-errno_t MapDosErrorToErrno(uint32_t);
+errno_t __dos2errno(uint32_t);
 
-int32_t __accept$sysv(int32_t, void *, uint32_t *, int) nodiscard hidden;
-int32_t __accept4$sysv(int32_t, void *, uint32_t *, int) nodiscard hidden;
-int32_t __connect$sysv(int32_t, const void *, uint32_t) hidden;
-int32_t __socket$sysv(int32_t, int32_t, int32_t) hidden;
-int32_t __getsockname$sysv(int32_t, void *, uint32_t *) hidden;
-int32_t __getpeername$sysv(int32_t, void *, uint32_t *) hidden;
+int32_t __sys_accept(int32_t, void *, uint32_t *, int) nodiscard hidden;
+int32_t __sys_accept4(int32_t, void *, uint32_t *, int) nodiscard hidden;
+int32_t __sys_connect(int32_t, const void *, uint32_t) hidden;
+int32_t __sys_socket(int32_t, int32_t, int32_t) hidden;
+int32_t __sys_getsockname(int32_t, void *, uint32_t *) hidden;
+int32_t __sys_getpeername(int32_t, void *, uint32_t *) hidden;
 
-int32_t accept4$sysv(int32_t, void *, uint32_t *, int) nodiscard hidden;
-int32_t accept$sysv(int32_t, void *, uint32_t *) hidden;
-int32_t bind$sysv(int32_t, const void *, uint32_t) hidden;
-int32_t connect$sysv(int32_t, const void *, uint32_t) hidden;
-int32_t getsockopt$sysv(int32_t, int32_t, int32_t, void *, uint32_t *) hidden;
-int32_t listen$sysv(int32_t, int32_t) hidden;
-int32_t getsockname$sysv(int32_t, void *, uint32_t *) hidden;
-int32_t getpeername$sysv(int32_t, void *, uint32_t *) hidden;
-int32_t poll$sysv(struct pollfd *, uint64_t, signed) hidden;
-int32_t shutdown$sysv(int32_t, int32_t) hidden;
-int32_t socket$sysv(int32_t, int32_t, int32_t) hidden;
-int64_t readv$sysv(int32_t, const struct iovec *, int32_t) hidden;
-int64_t writev$sysv(int32_t, const struct iovec *, int32_t) hidden;
-ssize_t recvfrom$sysv(int, void *, size_t, int, void *, uint32_t *) hidden;
-ssize_t sendto$sysv(int, const void *, size_t, int, const void *,
-                    uint32_t) hidden;
-int32_t select$sysv(int32_t, fd_set *, fd_set *, fd_set *,
-                    struct timeval *) hidden;
-int setsockopt$sysv(int, int, int, const void *, uint32_t) hidden;
-int32_t epoll_create$sysv(int32_t) hidden;
-int32_t epoll_ctl$sysv(int32_t, int32_t, int32_t, void *) hidden;
-int32_t epoll_wait$sysv(int32_t, void *, int32_t, int32_t) hidden;
+int32_t sys_accept4(int32_t, void *, uint32_t *, int) nodiscard hidden;
+int32_t sys_accept(int32_t, void *, uint32_t *) hidden;
+int32_t sys_bind(int32_t, const void *, uint32_t) hidden;
+int32_t sys_connect(int32_t, const void *, uint32_t) hidden;
+int32_t sys_getsockopt(int32_t, int32_t, int32_t, void *, uint32_t *) hidden;
+int32_t sys_listen(int32_t, int32_t) hidden;
+int32_t sys_getsockname(int32_t, void *, uint32_t *) hidden;
+int32_t sys_getpeername(int32_t, void *, uint32_t *) hidden;
+int32_t sys_poll(struct pollfd *, uint64_t, signed) hidden;
+int32_t sys_shutdown(int32_t, int32_t) hidden;
+int32_t sys_socket(int32_t, int32_t, int32_t) hidden;
+int64_t sys_readv(int32_t, const struct iovec *, int32_t) hidden;
+int64_t sys_writev(int32_t, const struct iovec *, int32_t) hidden;
+ssize_t sys_recvfrom(int, void *, size_t, int, void *, uint32_t *) hidden;
+ssize_t sys_sendto(int, const void *, size_t, int, const void *,
+                   uint32_t) hidden;
+int32_t sys_select(int32_t, fd_set *, fd_set *, fd_set *,
+                   struct timeval *) hidden;
+int sys_setsockopt(int, int, int, const void *, uint32_t) hidden;
+int32_t sys_epoll_create(int32_t) hidden;
+int32_t sys_epoll_ctl(int32_t, int32_t, int32_t, void *) hidden;
+int32_t sys_epoll_wait(int32_t, void *, int32_t, int32_t) hidden;
 
-int poll$nt(struct pollfd *, uint64_t, uint64_t) hidden;
-int getsockopt$nt(struct Fd *, int, int, void *, uint32_t *) hidden;
-int getsockname$nt(struct Fd *, void *, uint32_t *) hidden;
-int getpeername$nt(struct Fd *, void *, uint32_t *) hidden;
-int listen$nt(struct Fd *, int) hidden;
-int connect$nt(struct Fd *, const void *, uint32_t) hidden;
-int bind$nt(struct Fd *, const void *, uint32_t);
-int accept$nt(struct Fd *, void *, uint32_t *, int) hidden;
-int closesocket$nt(int) hidden;
-int socket$nt(int, int, int) hidden;
-int select$nt(int, fd_set *, fd_set *, fd_set *, struct timeval *) hidden;
-int shutdown$nt(struct Fd *, int) hidden;
+int sys_poll_nt(struct pollfd *, uint64_t, uint64_t) hidden;
+int sys_getsockopt_nt(struct Fd *, int, int, void *, uint32_t *) hidden;
+int sys_getsockname_nt(struct Fd *, void *, uint32_t *) hidden;
+int sys_getpeername_nt(struct Fd *, void *, uint32_t *) hidden;
+int sys_listen_nt(struct Fd *, int) hidden;
+int sys_connect_nt(struct Fd *, const void *, uint32_t) hidden;
+int sys_bind_nt(struct Fd *, const void *, uint32_t);
+int sys_accept_nt(struct Fd *, void *, uint32_t *, int) hidden;
+int sys_closesocket_nt(int) hidden;
+int sys_socket_nt(int, int, int) hidden;
+int sys_select_nt(int, fd_set *, fd_set *, fd_set *, struct timeval *) hidden;
+int sys_shutdown_nt(struct Fd *, int) hidden;
 
-size_t iovec2nt(struct NtIovec[hasatleast 16], const struct iovec *,
-                size_t) hidden;
-ssize_t sendto$nt(struct Fd *, const struct iovec *, size_t, uint32_t, void *,
-                  uint32_t) hidden;
-ssize_t recvfrom$nt(struct Fd *, const struct iovec *, size_t, uint32_t, void *,
-                    uint32_t *) hidden;
+size_t __iovec2nt(struct NtIovec[hasatleast 16], const struct iovec *,
+                  size_t) hidden;
+ssize_t sys_sendto_nt(struct Fd *, const struct iovec *, size_t, uint32_t,
+                      void *, uint32_t) hidden;
+ssize_t sys_recvfrom_nt(struct Fd *, const struct iovec *, size_t, uint32_t,
+                        void *, uint32_t *) hidden;
 
-void winsockinit(void) hidden;
+void __winsockinit(void) hidden;
 int64_t __winsockerr(void) nocallback hidden;
-int fixupnewsockfd$sysv(int, int) hidden;
-ssize_t WinSendRecv(int64_t, void *, size_t, uint32_t, struct sockaddr *,
-                    uint32_t *, bool) hidden;
-int64_t winsockblock(int64_t, unsigned, int64_t) hidden;
+int __fixupnewsockfd(int, int) hidden;
+int64_t __winsockblock(int64_t, unsigned, int64_t) hidden;
 
-int close$epoll(int) hidden;
+int sys_close_epoll(int) hidden;
 
 /**
- * Converts sockaddr (Linux/Windows) → sockaddr$bsd (XNU/BSD).
+ * Converts sockaddr (Linux/Windows) → sockaddr_bsd (XNU/BSD).
  */
 forceinline void sockaddr2bsd(void *saddr) {
   uint8_t *p;
@@ -119,13 +113,13 @@ forceinline void sockaddr2bsd(void *saddr) {
   if (saddr) {
     p = saddr;
     fam = READ16LE(p);
-    p[0] = sizeof(struct sockaddr_in$bsd);
+    p[0] = sizeof(struct sockaddr_in_bsd);
     p[1] = fam;
   }
 }
 
 /**
- * Converts sockaddr_in$bsd (XNU/BSD) → sockaddr (Linux/Windows).
+ * Converts sockaddr_in_bsd (XNU/BSD) → sockaddr (Linux/Windows).
  */
 forceinline void sockaddr2linux(void *saddr) {
   uint8_t *p, fam;
@@ -138,5 +132,4 @@ forceinline void sockaddr2linux(void *saddr) {
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* !ANSI */
 #endif /* COSMOPOLITAN_LIBC_SOCK_INTERNAL_H_ */

libc/sock/iovec2nt.c

@@ -28,8 +28,8 @@
  * @return effective iovlen
  * @see IOV_MAX
  */
-textwindows size_t iovec2nt(struct NtIovec iovnt[hasatleast 16],
-                            const struct iovec *iov, size_t iovlen) {
+textwindows size_t __iovec2nt(struct NtIovec iovnt[hasatleast 16],
+                              const struct iovec *iov, size_t iovlen) {
   size_t i, limit;
   for (limit = 0x7ffff000, i = 0; i < MIN(16, iovlen); ++i) {
     iovnt[i].buf = iov[i].iov_base;

libc/sock/kntwsadata.c

@@ -33,13 +33,13 @@
  */
 hidden struct NtWsaData kNtWsaData;
 
-static textwindows void winsockfini(void) {
+static textwindows void __winsockfini(void) {
   WSACleanup();
 }
 
-textwindows noasan void winsockinit(void) {
+textwindows noasan void __winsockinit(void) {
   int rc;
-  atexit(winsockfini);
+  atexit(__winsockfini);
   if ((rc = WSAStartup(VERSION, &kNtWsaData)) != 0 ||
       kNtWsaData.wVersion != VERSION) {
     ExitProcess(123);

libc/sock/listen-nt.c

@@ -23,9 +23,9 @@
 #include "libc/sock/yoink.inc"
 #include "libc/sysv/errfuns.h"
 
-textwindows int listen$nt(struct Fd *fd, int backlog) {
+textwindows int sys_listen_nt(struct Fd *fd, int backlog) {
   assert(fd->kind == kFdSocket);
-  if (__listen$nt(fd->handle, backlog) != -1) {
+  if (__sys_listen_nt(fd->handle, backlog) != -1) {
     return 0;
   } else {
     return __winsockerr();

libc/sock/listen.c

@@ -35,9 +35,9 @@
  */
 int listen(int fd, int backlog) {
   if (!IsWindows()) {
-    return listen$sysv(fd, backlog);
+    return sys_listen(fd, backlog);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return listen$nt(&g_fds.p[fd], backlog);
+    return sys_listen_nt(&g_fds.p[fd], backlog);
   } else {
     return ebadf();
   }

libc/sock/mapdoserrortoerrno.c

@@ -23,7 +23,7 @@
 /**
  * Translates Windows error using superset of consts.sh.
  */
-textwindows errno_t MapDosErrorToErrno(uint32_t error) {
+textwindows errno_t __dos2errno(uint32_t error) {
   switch (error) {
     case kNtErrorModNotFound:
       return ENOSYS;

libc/sock/poll-nt.c

@@ -26,11 +26,11 @@
 #include "libc/sysv/consts/poll.h"
 #include "libc/sysv/errfuns.h"
 
-textwindows int poll$nt(struct pollfd *fds, uint64_t nfds, uint64_t timeoutms) {
+textwindows int sys_poll_nt(struct pollfd *fds, uint64_t nfds, uint64_t timeoutms) {
   int got;
   size_t i;
   uint64_t waitfor;
-  struct pollfd$nt ntfds[64];
+  struct sys_pollfd_nt ntfds[64];
   if (nfds > 64) return einval();
   for (i = 0; i < nfds; ++i) {
     if (!__isfdkind(fds[i].fd, kFdSocket)) return ebadf();

libc/sock/poll.c

@@ -38,8 +38,8 @@
  */
 int poll(struct pollfd *fds, uint64_t nfds, int32_t timeout_ms) {
   if (!IsWindows()) {
-    return poll$sysv(fds, nfds, timeout_ms);
+    return sys_poll(fds, nfds, timeout_ms);
   } else {
-    return poll$nt(fds, nfds, timeout_ms);
+    return sys_poll_nt(fds, nfds, timeout_ms);
   }
 }

libc/sock/recvfrom-nt.c

@@ -27,15 +27,16 @@
  * @param fd must be a socket
  * @return number of bytes received, or -1 w/ errno
  */
-textwindows ssize_t recvfrom$nt(struct Fd *fd, const struct iovec *iov,
-                                size_t iovlen, uint32_t flags,
-                                void *opt_out_srcaddr,
-                                uint32_t *opt_inout_srcaddrsize) {
+textwindows ssize_t sys_recvfrom_nt(struct Fd *fd, const struct iovec *iov,
+                                    size_t iovlen, uint32_t flags,
+                                    void *opt_out_srcaddr,
+                                    uint32_t *opt_inout_srcaddrsize) {
   uint32_t got;
   struct NtIovec iovnt[16];
   got = 0;
-  if (WSARecvFrom(fd->handle, iovnt, iovec2nt(iovnt, iov, iovlen), &got, &flags,
-                  opt_out_srcaddr, opt_inout_srcaddrsize, NULL, NULL) != -1) {
+  if (WSARecvFrom(fd->handle, iovnt, __iovec2nt(iovnt, iov, iovlen), &got,
+                  &flags, opt_out_srcaddr, opt_inout_srcaddrsize, NULL,
+                  NULL) != -1) {
     return got;
   } else {
     return __winsockerr();

libc/sock/recvfrom.c

@@ -44,14 +44,14 @@ ssize_t recvfrom(int fd, void *buf, size_t size, uint32_t flags,
                  void *opt_out_srcaddr, uint32_t *opt_inout_srcaddrsize) {
   ssize_t got;
   if (!IsWindows()) {
-    got = recvfrom$sysv(fd, buf, size, flags, opt_out_srcaddr,
+    got = sys_recvfrom(fd, buf, size, flags, opt_out_srcaddr,
                         opt_inout_srcaddrsize);
     if (opt_out_srcaddr && IsBsd() && got != -1) {
       sockaddr2linux(opt_out_srcaddr);
     }
     return got;
   } else if (__isfdkind(fd, kFdSocket)) {
-    return recvfrom$nt(&g_fds.p[fd], (struct iovec[]){{buf, size}}, 1, flags,
+    return sys_recvfrom_nt(&g_fds.p[fd], (struct iovec[]){{buf, size}}, 1, flags,
                        opt_out_srcaddr, opt_inout_srcaddrsize);
   } else {
     return ebadf();

libc/sock/select-nt.c

@@ -92,7 +92,7 @@ static struct NtTimeval *TimevalToNtTimeval(struct timeval *tv,
   }
 }
 
-int select$nt(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
+int sys_select_nt(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
               struct timeval *timeout) {
   int n, rc;
   struct NtTimeval nttimeout, *nttimeoutp;
@@ -102,7 +102,7 @@ int select$nt(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
   ntwritefds = FdSetToNtFdSet(nfds, writefds);
   ntexceptfds = FdSetToNtFdSet(nfds, exceptfds);
   nttimeoutp = TimevalToNtTimeval(timeout, &nttimeout);
-  rc = __select$nt(0, ntreadfds, ntwritefds, ntexceptfds, nttimeoutp);
+  rc = __sys_select_nt(0, ntreadfds, ntwritefds, ntexceptfds, nttimeoutp);
   NtFdSetToFdSet(nfds, readfds, ntreadfds);
   NtFdSetToFdSet(nfds, writefds, ntwritefds);
   NtFdSetToFdSet(nfds, exceptfds, ntexceptfds);

libc/sock/select.c

@@ -28,8 +28,8 @@
 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
            struct timeval *timeout) {
   if (!IsWindows()) {
-    return select$sysv(nfds, readfds, writefds, exceptfds, timeout);
+    return sys_select(nfds, readfds, writefds, exceptfds, timeout);
   } else {
-    return select$nt(nfds, readfds, writefds, exceptfds, timeout);
+    return sys_select_nt(nfds, readfds, writefds, exceptfds, timeout);
   }
 }

libc/sock/sendfile.c

@@ -25,7 +25,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
-static textwindows ssize_t sendfile$linux2nt(int outfd, int infd,
+static textwindows ssize_t sendfile_linux2nt(int outfd, int infd,
                                              int64_t *inout_opt_inoffset,
                                              size_t uptobytes) {
   struct NtOverlapped Overlapped;
@@ -48,18 +48,18 @@ static textwindows ssize_t sendfile$linux2nt(int outfd, int infd,
   }
 }
 
-static ssize_t sendfile$linux2netflix(int outfd, int infd,
+static ssize_t sendfile_linux2netflix(int outfd, int infd,
                                       int64_t *inout_opt_inoffset,
                                       size_t uptobytes) {
   int sendfile$netflix(int32_t infd, int32_t outfd, int64_t offset,
                        size_t nbytes, const void *opt_hdtr,
                        int64_t *out_opt_sbytes,
-                       int32_t flags) asm("sendfile$sysv") hidden;
+                       int32_t flags) asm("sys_sendfile") hidden;
   int rc;
   int64_t offset, sbytes;
   if (inout_opt_inoffset) {
     offset = *inout_opt_inoffset;
-  } else if ((offset = lseek$sysv(infd, 0, SEEK_CUR)) == -1) {
+  } else if ((offset = sys_lseek(infd, 0, SEEK_CUR)) == -1) {
     return -1;
   }
   if ((rc = sendfile$netflix(infd, outfd, offset, uptobytes, NULL, &sbytes,
@@ -90,11 +90,11 @@ ssize_t sendfile(int outfd, int infd, int64_t *inout_opt_inoffset,
   if (uptobytes > 0x7ffffffe /* Microsoft's off-by-one */) return eoverflow();
   if (IsModeDbg() && uptobytes > 1) uptobytes >>= 1;
   if (IsLinux()) {
-    return sendfile$sysv(outfd, infd, inout_opt_inoffset, uptobytes);
+    return sys_sendfile(outfd, infd, inout_opt_inoffset, uptobytes);
   } else if (IsFreebsd() || IsXnu()) {
-    return sendfile$linux2netflix(outfd, infd, inout_opt_inoffset, uptobytes);
+    return sendfile_linux2netflix(outfd, infd, inout_opt_inoffset, uptobytes);
   } else if (IsWindows()) {
-    return sendfile$linux2nt(outfd, infd, inout_opt_inoffset, uptobytes);
+    return sendfile_linux2nt(outfd, infd, inout_opt_inoffset, uptobytes);
   } else {
     return copyfd(infd, inout_opt_inoffset, outfd, NULL, uptobytes, 0);
   }

libc/sock/sendto-nt.c

@@ -30,12 +30,12 @@
  * @param fd must be a socket
  * @return number of bytes handed off, or -1 w/ errno
  */
-textwindows ssize_t sendto$nt(struct Fd *fd, const struct iovec *iov,
-                              size_t iovlen, uint32_t flags, void *opt_in_addr,
-                              uint32_t in_addrsize) {
+textwindows ssize_t sys_sendto_nt(struct Fd *fd, const struct iovec *iov,
+                                  size_t iovlen, uint32_t flags,
+                                  void *opt_in_addr, uint32_t in_addrsize) {
   uint32_t sent;
   struct NtIovec iovnt[16];
-  if (WSASendTo(fd->handle, iovnt, iovec2nt(iovnt, iov, iovlen), &sent, flags,
+  if (WSASendTo(fd->handle, iovnt, __iovec2nt(iovnt, iov, iovlen), &sent, flags,
                 opt_in_addr, in_addrsize, NULL, NULL) != -1) {
     return sent;
   } else {

libc/sock/sendto.c

@@ -46,19 +46,19 @@
  */
 ssize_t sendto(int fd, const void *buf, size_t size, uint32_t flags,
                const void *opt_addr, uint32_t addrsize) {
-  _Static_assert(sizeof(struct sockaddr_in) == sizeof(struct sockaddr_in$bsd));
+  _Static_assert(sizeof(struct sockaddr_in) == sizeof(struct sockaddr_in_bsd));
   if (!IsWindows()) {
     if (!IsBsd() || !opt_addr) {
-      return sendto$sysv(fd, buf, size, flags, opt_addr, addrsize);
+      return sys_sendto(fd, buf, size, flags, opt_addr, addrsize);
     } else {
-      struct sockaddr_in$bsd addr2;
+      struct sockaddr_in_bsd addr2;
       if (addrsize != sizeof(addr2)) return einval();
       memcpy(&addr2, opt_addr, sizeof(struct sockaddr_in));
       sockaddr2bsd(&addr2);
-      return sendto$sysv(fd, buf, size, flags, &addr2, addrsize);
+      return sys_sendto(fd, buf, size, flags, &addr2, addrsize);
     }
   } else if (__isfdkind(fd, kFdSocket)) {
-    return sendto$nt(&g_fds.p[fd], (struct iovec[]){{buf, size}}, 1, flags,
+    return sys_sendto_nt(&g_fds.p[fd], (struct iovec[]){{buf, size}}, 1, flags,
                      opt_addr, addrsize);
   } else {
     return ebadf();

libc/sock/setsockopt.c

@@ -33,9 +33,9 @@ static bool setsockopt_polyfill(int *optname) {
   return false;
 }
 
-static textwindows int setsockopt$nt(struct Fd *fd, int level, int optname,
+static textwindows int sys_setsockopt_nt(struct Fd *fd, int level, int optname,
                                      const void *optval, uint32_t optlen) {
-  if (__setsockopt$nt(fd->handle, level, optname, optval, optlen) != -1) {
+  if (__sys_setsockopt_nt(fd->handle, level, optname, optval, optlen) != -1) {
     return 0;
   } else {
     return __winsockerr();
@@ -64,13 +64,13 @@ int setsockopt(int fd, int level, int optname, const void *optval,
   if (optname == -1) return 0;                  /* our sysvconsts definition */
   if (!IsWindows()) {
     do {
-      if (setsockopt$sysv(fd, level, optname, optval, optlen) != -1) {
+      if (sys_setsockopt(fd, level, optname, optval, optlen) != -1) {
         return 0;
       }
     } while (setsockopt_polyfill(&optname));
     return -1;
   } else if (__isfdkind(fd, kFdSocket)) {
-    return setsockopt$nt(&g_fds.p[fd], level, optname, optval, optlen);
+    return sys_setsockopt_nt(&g_fds.p[fd], level, optname, optval, optlen);
   } else {
     return ebadf();
   }

libc/sock/shutdown-nt.c

@@ -20,8 +20,8 @@
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 
-textwindows int shutdown$nt(struct Fd *fd, int how) {
-  if (__shutdown$nt(fd->handle, how) != -1) {
+textwindows int sys_shutdown_nt(struct Fd *fd, int how) {
+  if (__sys_shutdown_nt(fd->handle, how) != -1) {
     return 0;
   } else {
     return __winsockerr();

libc/sock/shutdown.c

@@ -32,9 +32,9 @@
  */
 int shutdown(int fd, int how) {
   if (!IsWindows()) {
-    return shutdown$sysv(fd, how);
+    return sys_shutdown(fd, how);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return shutdown$nt(&g_fds.p[fd], how);
+    return sys_shutdown_nt(&g_fds.p[fd], how);
   } else {
     return ebadf();
   }

libc/sock/socket-nt.c

@@ -26,7 +26,7 @@
 #define CLOEXEC  0x00080000
 #define NONBLOCK 0x00000800
 
-textwindows int socket$nt(int family, int type, int protocol) {
+textwindows int sys_socket_nt(int family, int type, int protocol) {
   int fd;
   uint32_t yes;
   if ((fd = __reservefd()) == -1) return -1;
@@ -34,8 +34,8 @@ textwindows int socket$nt(int family, int type, int protocol) {
                                       protocol, NULL, 0, 0)) != -1) {
     if (type & NONBLOCK) {
       yes = 1;
-      if (__ioctlsocket$nt(g_fds.p[fd].handle, FIONBIO, &yes) == -1) {
-        __closesocket$nt(g_fds.p[fd].handle);
+      if (__sys_ioctlsocket_nt(g_fds.p[fd].handle, FIONBIO, &yes) == -1) {
+        __sys_closesocket_nt(g_fds.p[fd].handle);
         return __winsockerr();
       }
     }

libc/sock/socket-sysv.c

@@ -21,16 +21,16 @@
 #include "libc/sock/internal.h"
 #include "libc/sysv/consts/sock.h"
 
-int socket$sysv(int family, int type, int protocol) {
+int sys_socket(int family, int type, int protocol) {
   int rc, olderr, modernflags;
   olderr = errno;
-  rc = __socket$sysv(family, type, protocol);
+  rc = __sys_socket(family, type, protocol);
   if ((SupportsLinux() || SupportsXnu()) &&
       (rc == -1 && errno == EINVAL /* rhel5 behavior */) &&
       (modernflags = (type & (SOCK_CLOEXEC | SOCK_NONBLOCK)))) {
     errno = olderr;
-    rc = fixupnewsockfd$sysv(
-        __socket$sysv(family, type & ~modernflags, protocol), modernflags);
+    rc = __fixupnewsockfd(__sys_socket(family, type & ~modernflags, protocol),
+                          modernflags);
   }
   return rc;
 }

libc/sock/socket.c

@@ -45,8 +45,8 @@ int socket(int family, int type, int protocol) {
     return epfnosupport();
   }
   if (!IsWindows()) {
-    return socket$sysv(family, type, protocol);
+    return sys_socket(family, type, protocol);
   } else {
-    return socket$nt(family, type, protocol);
+    return sys_socket_nt(family, type, protocol);
   }
 }

libc/sock/winsockblock.c

@@ -23,7 +23,7 @@
 #include "libc/sock/sock.h"
 #include "libc/str/str.h"
 
-textwindows int64_t winsockblock(int64_t fh, unsigned eventbit, int64_t rc) {
+textwindows int64_t __winsockblock(int64_t fh, unsigned eventbit, int64_t rc) {
   int64_t eh;
   struct NtWsaNetworkEvents ev;
   if (rc != -1) return rc;

libc/sock/winsockerr.c

@@ -24,6 +24,6 @@
  * Error return path for winsock wrappers.
  */
 textwindows int64_t __winsockerr(void) {
-  errno = MapDosErrorToErrno(WSAGetLastError());
+  errno = __dos2errno(WSAGetLastError());
   return -1;
 }

libc/sock/xinet_ntop.c

@@ -29,7 +29,7 @@
  * @param src is the binary-encoded address, e.g. &addr->sin_addr
  * @return allocated IP address string, which must be free()'d
  */
-char *xinet_ntop(int af, const void *src) {
+char *sys_xinet_ntop(int af, const void *src) {
   char *res, ip[16];
   if (inet_ntop(af, src, ip, sizeof(ip)) && (res = strdup(ip))) {
     return res;

libc/sock/yoink.inc

@@ -1,4 +1,4 @@
-STATIC_YOINK("kNtWsaData");      // for winmain
-STATIC_YOINK("closesocket$nt");  // for close
-STATIC_YOINK("recvfrom$nt");     // for readv
-STATIC_YOINK("sendto$nt");       // for writev
+STATIC_YOINK("kNtWsaData");          // for winmain
+STATIC_YOINK("sys_closesocket_nt");  // for close
+STATIC_YOINK("sys_recvfrom_nt");     // for readv
+STATIC_YOINK("sys_sendto_nt");       // for writev