Fix some style issues in sysdeps/nacl/irt_syscalls.*

sysdeps/nacl/irt_syscalls.c

 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
 #include <nacl_stat.h>
 #include <nacl_syscalls.h>
 #define stat nacl_abi_stat
 #include <irt.h>
 #include <irt_dev.h>
 #undef stat
 #include <irt_syscalls.h>
@@ skipping 144 matching lines @@
 }
 
 static int nacl_irt_dyncode_modify(void *dest, const void *src, size_t size) {
   return -NACL_SYSCALL(dyncode_modify)(dest, src, size);
 }
 
 static int nacl_irt_dyncode_delete(void *dest, size_t size) {
   return -NACL_SYSCALL(dyncode_delete)(dest, size);
 }
 
-static int nacl_irt_thread_create (void *start_user_address, void *stack,
+static int nacl_irt_thread_create (void (*start_user_address)(void),
+                                   void *stack,
                                    void *thread_ptr) {
   return -NACL_SYSCALL (thread_create) (start_user_address, stack,
                                         thread_ptr, 0);
 }
 
 static void nacl_irt_thread_exit (int32_t *stack_flag) {
   NACL_SYSCALL (thread_exit) (stack_flag);
   while (1) (*(void (*)(void)) 0) ();  /* Crash.  */
 }
 
@@ skipping 78 matching lines @@
 /* Load files from DL_DST_LIB using IRT's open_resource. Other paths
    will be processed using regular open syscall.
 
    Note: nacl_mount may change this logic if needed.  */
 static int (*___nacl_irt_open_resource) (const char* file, int *fd);
 static int nacl_irt_open_resource (const char *pathname, int *newfd) {
   if (memcmp (DL_DST_LIB "/", pathname, sizeof (DL_DST_LIB)))
     return __nacl_irt_open (pathname, O_RDONLY, 0, newfd);
   else
     return ___nacl_irt_open_resource (pathname + sizeof (DL_DST_LIB) - 1,
-                                      newfd);
+                                      newfd);
 }
 
 static int nacl_irt_clock_getres(clockid_t clk_id,
                                  struct timespec *res) {
   return -NACL_SYSCALL (clock_getres) (clk_id, res);
 }
 
 static int nacl_irt_clock_gettime(clockid_t clk_id,
                                   struct timespec *tp) {
   return -NACL_SYSCALL (clock_gettime) (clk_id, tp);
 }
 
 static size_t no_interface (const char *interface_ident,
                             void *table, size_t tablesize) {
   return 0;
 }
 
 static int not_implemented() {
   return (38 /* ENOSYS */);
 }
 
 size_t (*__nacl_irt_query) (const char *interface_ident,
-                            void *table, size_t tablesize);
+                            void *table, size_t tablesize);
 
 int (*__nacl_irt_mkdir) (const char* pathname, mode_t mode);
 int (*__nacl_irt_rmdir) (const char* pathname);
 int (*__nacl_irt_chdir) (const char* pathname);
 int (*__nacl_irt_getcwd) (char* buf, size_t size);
 
 void (*__nacl_irt_exit) (int status);
 int (*__nacl_irt_gettod) (struct timeval *tv);
 int (*__nacl_irt_clock) (clock_t *ticks);
 int (*__nacl_irt_nanosleep) (const struct timespec *req, struct timespec *rem);
 int (*__nacl_irt_sched_yield) (void);
 int (*__nacl_irt_sysconf) (int name, int *value);
 
 int (*__nacl_irt_open) (const char *pathname, int oflag, mode_t cmode,
-                        int *newfd);
+                        int *newfd);
 int (*__nacl_irt_close) (int fd);
 int (*__nacl_irt_read) (int fd, void *buf, size_t count, size_t *nread);
-int (*__nacl_irt_write) (int fd, const void *buf, size_t count, size_t *nwrote);
+int (*__nacl_irt_write) (int fd, const void *buf, size_t count,
+                         size_t *nwrote);
 int (*__nacl_irt_seek) (int fd, off_t offset, int whence, off_t *new_offset);
 int (*__nacl_irt_dup) (int fd, int *newfd);
 int (*__nacl_irt_dup2) (int fd, int newfd);
 int (*__nacl_irt_fstat) (int fd, struct nacl_abi_stat *);
 int (*__nacl_irt_stat) (const char *pathname, struct nacl_abi_stat *);
 int (*__nacl_irt_getdents) (int fd, struct dirent *, size_t count,
-                            size_t *nread);
+                            size_t *nread);
 int (*__nacl_irt_socket) (int domain, int type, int protocol, int *sd);
 int (*__nacl_irt_accept) (int sockfd, struct sockaddr *addr,
                           socklen_t *addrlen, int *sd);
-int (*__nacl_irt_bind) (int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int (*__nacl_irt_bind) (int sockfd, const struct sockaddr *addr,
+                        socklen_t addrlen);
 int (*__nacl_irt_listen) (int sockfd, int backlog);
 int (*__nacl_irt_connect) (int sockfd, const struct sockaddr *addr,
                            socklen_t addrlen);
 int (*__nacl_irt_send) (int sockfd, const void *buf, size_t len, int flags,
                         int *count);
 int (*__nacl_irt_sendmsg) (int sockfd, const struct msghdr *msg, int flags,
                            int *count);
 int (*__nacl_irt_sendto) (int sockfd, const void *buf, size_t len, int flags,
                           const struct sockaddr *dest_addr, socklen_t addrlen,
-                                                  int *count);
-int (*__nacl_irt_recv) (int sockfd, void *buf, size_t len, int flags, int *count);
-int (*__nacl_irt_recvmsg) (int sockfd, struct msghdr *msg, int flags, int *count);
+                          int *count);
+int (*__nacl_irt_recv) (int sockfd, void *buf, size_t len, int flags,
+                        int *count);
+int (*__nacl_irt_recvmsg) (int sockfd, struct msghdr *msg, int flags,
+                           int *count);
 int (*__nacl_irt_recvfrom) (int sockfd, void *buf, size_t len, int flags,
-                            struct sockaddr *dest_addr, socklen_t* addrlen, int *count);
+                            struct sockaddr *dest_addr, socklen_t* addrlen,
+                            int *count);
 
 int (*__nacl_irt_epoll_create) (int size, int *fd);
 int (*__nacl_irt_epoll_create1) (int flags, int *fd);
 int (*__nacl_irt_epoll_ctl) (int epfd, int op, int fd,
                              struct epoll_event *event);
 int (*__nacl_irt_epoll_pwait) (int epfd, struct epoll_event *events,
-    int maxevents, int timeout, const sigset_t *sigmask, size_t sigset_size,
-        int *count);
+                               int maxevents, int timeout,
+                               const sigset_t *sigmask, size_t sigset_size,
+                               int *count);
 int (*__nacl_irt_epoll_wait) (int epfd, struct epoll_event *events,
-                                int maxevents, int timeout, int *count);
+                              int maxevents, int timeout, int *count);
 int (*__nacl_irt_poll) (struct pollfd *fds, nfds_t nfds,
-                          int timeout, int *count);
+                        int timeout, int *count);
 int (*__nacl_irt_ppoll) (struct pollfd *fds, nfds_t nfds,
-    const struct timespec *timeout, const sigset_t *sigmask,
-        size_t sigset_size, int *count);
+                         const struct timespec *timeout,
+                         const sigset_t *sigmask,
+                         size_t sigset_size, int *count);
 int (*__nacl_irt_select) (int nfds, fd_set *readfds,
-    fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout,
-        int *count);
+                          fd_set *writefds, fd_set *exceptfds,
+                          const struct timeval *timeout,
+                          int *count);
 int (*__nacl_irt_pselect) (int nfds, fd_set *readfds,
-    fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout,
-        void* sigmask, int *count);
+                           fd_set *writefds, fd_set *exceptfds,
+                           const struct timeval *timeout,
+                           void* sigmask, int *count);
 int (*__nacl_irt_getpeername) (int sockfd, struct sockaddr *addr,
                                socklen_t *addrlen);
 int (*__nacl_irt_getsockname) (int sockfd, struct sockaddr *addr,
                                socklen_t *addrlen);
 int (*__nacl_irt_getsockopt) (int sockfd, int level, int optname,
-               void *optval, socklen_t *optlen);
+                              void *optval, socklen_t *optlen);
 int (*__nacl_irt_setsockopt) (int sockfd, int level, int optname,
-               const void *optval, socklen_t optlen);
+                              const void *optval, socklen_t optlen);
 int (*__nacl_irt_socketpair) (int domain, int type, int protocol, int sv[2]);
 int (*__nacl_irt_shutdown) (int sockfd, int how);
 
 
 int (*__nacl_irt_sysbrk) (void **newbrk);
 int (*__nacl_irt_mmap) (void **addr, size_t len, int prot, int flags,
-                        int fd, off_t off);
+                        int fd, off_t off);
 int (*__nacl_irt_munmap) (void *addr, size_t len);
 int (*__nacl_irt_mprotect) (void *addr, size_t len, int prot);
 
 int (*__nacl_irt_dyncode_create) (void *dest, const void *src, size_t size);
 int (*__nacl_irt_dyncode_modify) (void *dest, const void *src, size_t size);
 int (*__nacl_irt_dyncode_delete) (void *dest, size_t size);
 
-int (*__nacl_irt_thread_create) (void *start_user_address, void *stack,
-                                 void *thread_ptr);
+int (*__nacl_irt_thread_create) (void (*start_user_address)(void),
+                                 void *stack,
+                                 void *thread_ptr);
 void (*__nacl_irt_thread_exit) (int32_t *stack_flag);
 int (*__nacl_irt_thread_nice) (const int nice);
 
 int (*__nacl_irt_mutex_create) (int *mutex_handle);
 int (*__nacl_irt_mutex_destroy) (int mutex_handle);
 int (*__nacl_irt_mutex_lock) (int mutex_handle);
 int (*__nacl_irt_mutex_unlock) (int mutex_handle);
 int (*__nacl_irt_mutex_trylock) (int mutex_handle);
 
 int (*__nacl_irt_cond_create) (int *cond_handle);
 int (*__nacl_irt_cond_destroy) (int cond_handle);
 int (*__nacl_irt_cond_signal) (int cond_handle);
 int (*__nacl_irt_cond_broadcast) (int cond_handle);
 int (*__nacl_irt_cond_wait) (int cond_handle, int mutex_handle);
 int (*__nacl_irt_cond_timed_wait_abs) (int cond_handle, int mutex_handle,
-                                       const struct timespec *abstime);
+                                       const struct timespec *abstime);
 
 int (*__nacl_irt_tls_init) (void *tdb);
 void *(*__nacl_irt_tls_get) (void);
 
 int (*__nacl_irt_open_resource) (const char* file, int *fd);
 
 int (*__nacl_irt_clock_getres) (clockid_t clk_id, struct timespec *res);
 int (*__nacl_irt_clock_gettime) (clockid_t clk_id, struct timespec *tp);
 
 int (*__nacl_irt_getpid) (int *pid);
@@ skipping 34 matching lines @@
     struct nacl_irt_resource_open nacl_irt_resource_open;
     struct nacl_irt_clock nacl_irt_clock;
     struct nacl_irt_dev_getpid nacl_irt_dev_getpid;
     struct nacl_irt_dev_fdio nacl_irt_dev_fdio;
     struct nacl_irt_dev_filename_v0_2 nacl_irt_dev_filename_v0_2;
     struct nacl_irt_dev_filename nacl_irt_dev_filename;
   } u;
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_BASIC_v0_1, &u.nacl_irt_basic,
-                        sizeof(u.nacl_irt_basic)) == sizeof(u.nacl_irt_basic))
+                        sizeof(u.nacl_irt_basic)) == sizeof(u.nacl_irt_basic))
     {
       __nacl_irt_exit = u.nacl_irt_basic.exit;
       __nacl_irt_gettod = u.nacl_irt_basic.gettod;
       __nacl_irt_clock = u.nacl_irt_basic.clock;
       __nacl_irt_nanosleep = u.nacl_irt_basic.nanosleep;
       __nacl_irt_sched_yield = u.nacl_irt_basic.sched_yield;
       __nacl_irt_sysconf = u.nacl_irt_basic.sysconf;
     }
   else
     {
       __nacl_irt_exit = nacl_irt_exit;
       __nacl_irt_gettod = nacl_irt_gettod;
       __nacl_irt_clock = nacl_irt_clock;
       __nacl_irt_nanosleep = nacl_irt_nanosleep;
       __nacl_irt_sched_yield = nacl_irt_sched_yield;
       __nacl_irt_sysconf = nacl_irt_sysconf;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_FDIO_v0_1, &u.nacl_irt_fdio,
-                        sizeof(u.nacl_irt_fdio)) == sizeof(u.nacl_irt_fdio))
+                        sizeof(u.nacl_irt_fdio)) == sizeof(u.nacl_irt_fdio))
     {
       __nacl_irt_close = u.nacl_irt_fdio.close;
       __nacl_irt_dup = u.nacl_irt_fdio.dup;
       __nacl_irt_dup2 = u.nacl_irt_fdio.dup2;
       __nacl_irt_read = u.nacl_irt_fdio.read;
       __nacl_irt_write = u.nacl_irt_fdio.write;
       __nacl_irt_seek = u.nacl_irt_fdio.seek;
       __nacl_irt_fstat = u.nacl_irt_fdio.fstat;
       __nacl_irt_getdents = u.nacl_irt_fdio.getdents;
     }
   else
     {
       __nacl_irt_close = nacl_irt_close;
       __nacl_irt_dup = nacl_irt_dup;
       __nacl_irt_dup2 = nacl_irt_dup2;
       __nacl_irt_read = nacl_irt_read;
       __nacl_irt_write = nacl_irt_write;
       __nacl_irt_seek = nacl_irt_seek;
       __nacl_irt_fstat = nacl_irt_fstat;
       __nacl_irt_getdents = nacl_irt_getdents;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_FILENAME_v0_1, &u.nacl_irt_filename,
-                        sizeof(u.nacl_irt_filename)) == sizeof(u.nacl_irt_filename))
+                        sizeof(u.nacl_irt_filename)) ==
+      sizeof(u.nacl_irt_filename))
     {
       __nacl_irt_open = u.nacl_irt_filename.open;
       __nacl_irt_stat = u.nacl_irt_filename.nacl_abi_stat;
     }
   else
     {
       __nacl_irt_open = nacl_irt_open;
       __nacl_irt_stat = nacl_irt_stat;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_MEMORY_v0_2, &u.nacl_irt_memory,
-                        sizeof(u.nacl_irt_memory)) == sizeof(u.nacl_irt_memory))
+                        sizeof(u.nacl_irt_memory)) ==
+      sizeof(u.nacl_irt_memory))
     {
       __nacl_irt_sysbrk = u.nacl_irt_memory.sysbrk;
       __nacl_irt_mmap = u.nacl_irt_memory.mmap;
       __nacl_irt_munmap = u.nacl_irt_memory.munmap;
       __nacl_irt_mprotect = u.nacl_irt_memory.mprotect;
     }
   else if (__nacl_irt_query &&
            __nacl_irt_query (NACL_IRT_MEMORY_v0_1, &u.nacl_irt_memory,
                              sizeof(struct nacl_irt_memory_v0_1)) ==
-               sizeof(struct nacl_irt_memory_v0_1))
+           sizeof(struct nacl_irt_memory_v0_1))
     {
       __nacl_irt_sysbrk = u.nacl_irt_memory.sysbrk;
       __nacl_irt_mmap = u.nacl_irt_memory.mmap;
       __nacl_irt_munmap = u.nacl_irt_memory.munmap;
       __nacl_irt_mprotect = not_implemented;
     }
   else
     {
       __nacl_irt_sysbrk = nacl_irt_sysbrk;
       __nacl_irt_mmap = nacl_irt_mmap;
       __nacl_irt_munmap = nacl_irt_munmap;
       __nacl_irt_mprotect = nacl_irt_mprotect;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_DYNCODE_v0_1, &u.nacl_irt_dyncode,
-                        sizeof(u.nacl_irt_dyncode)) == sizeof(u.nacl_irt_dyncode))
+                        sizeof(u.nacl_irt_dyncode)) ==
+      sizeof(u.nacl_irt_dyncode))
     {
       __nacl_irt_dyncode_create = u.nacl_irt_dyncode.dyncode_create;
       __nacl_irt_dyncode_modify = u.nacl_irt_dyncode.dyncode_modify;
       __nacl_irt_dyncode_delete = u.nacl_irt_dyncode.dyncode_delete;
     }
   else
     {
       __nacl_irt_dyncode_create = nacl_irt_dyncode_create;
       __nacl_irt_dyncode_modify = nacl_irt_dyncode_modify;
       __nacl_irt_dyncode_delete = nacl_irt_dyncode_delete;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_THREAD_v0_1, &u.nacl_irt_thread,
-                        sizeof(u.nacl_irt_thread)) == sizeof(u.nacl_irt_thread))
+                        sizeof(u.nacl_irt_thread)) ==
+      sizeof(u.nacl_irt_thread))
     {
       __nacl_irt_thread_create = u.nacl_irt_thread.thread_create;
       __nacl_irt_thread_exit = u.nacl_irt_thread.thread_exit;
       __nacl_irt_thread_nice = u.nacl_irt_thread.thread_nice;
     }
   else
     {
       __nacl_irt_thread_create = nacl_irt_thread_create;
       __nacl_irt_thread_exit = nacl_irt_thread_exit;
       __nacl_irt_thread_nice = nacl_irt_thread_nice;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_MUTEX_v0_1, &u.nacl_irt_mutex,
-                        sizeof(u.nacl_irt_mutex)) == sizeof(u.nacl_irt_mutex))
+                        sizeof(u.nacl_irt_mutex)) == sizeof(u.nacl_irt_mutex))
     {
       __nacl_irt_mutex_create = u.nacl_irt_mutex.mutex_create;
       __nacl_irt_mutex_destroy = u.nacl_irt_mutex.mutex_destroy;
       __nacl_irt_mutex_lock = u.nacl_irt_mutex.mutex_lock;
       __nacl_irt_mutex_unlock = u.nacl_irt_mutex.mutex_unlock;
       __nacl_irt_mutex_trylock = u.nacl_irt_mutex.mutex_trylock;
     }
   else
     {
       __nacl_irt_mutex_create = nacl_irt_mutex_create;
       __nacl_irt_mutex_destroy = nacl_irt_mutex_destroy;
       __nacl_irt_mutex_lock = nacl_irt_mutex_lock;
       __nacl_irt_mutex_unlock = nacl_irt_mutex_unlock;
       __nacl_irt_mutex_trylock = nacl_irt_mutex_trylock;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_COND_v0_1, &u.nacl_irt_cond,
-                        sizeof(u.nacl_irt_cond)) == sizeof(u.nacl_irt_cond))
+                        sizeof(u.nacl_irt_cond)) == sizeof(u.nacl_irt_cond))
     {
       __nacl_irt_cond_create = u.nacl_irt_cond.cond_create;
       __nacl_irt_cond_destroy = u.nacl_irt_cond.cond_destroy;
       __nacl_irt_cond_signal = u.nacl_irt_cond.cond_signal;
       __nacl_irt_cond_broadcast = u.nacl_irt_cond.cond_broadcast;
       __nacl_irt_cond_wait = u.nacl_irt_cond.cond_wait;
       __nacl_irt_cond_timed_wait_abs = u.nacl_irt_cond.cond_timed_wait_abs;
     }
   else
     {
       __nacl_irt_cond_create = nacl_irt_cond_create;
       __nacl_irt_cond_destroy = nacl_irt_cond_destroy;
       __nacl_irt_cond_signal = nacl_irt_cond_signal;
       __nacl_irt_cond_broadcast = nacl_irt_cond_broadcast;
       __nacl_irt_cond_wait = nacl_irt_cond_wait;
       __nacl_irt_cond_timed_wait_abs = nacl_irt_cond_timed_wait_abs;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_TLS_v0_1, &u.nacl_irt_tls,
-                        sizeof(u.nacl_irt_tls)) == sizeof(u.nacl_irt_tls))
+                        sizeof(u.nacl_irt_tls)) == sizeof(u.nacl_irt_tls))
     {
       __nacl_irt_tls_init = u.nacl_irt_tls.tls_init;
       __nacl_irt_tls_get = u.nacl_irt_tls.tls_get;
     }
   else
     {
       __nacl_irt_tls_init = nacl_irt_tls_init;
       __nacl_irt_tls_get = nacl_irt_tls_get;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_RESOURCE_OPEN_v0_1, &u.nacl_irt_resource_open,
-          sizeof(u.nacl_irt_resource_open)) == sizeof(u.nacl_irt_resource_open))
+                        sizeof(u.nacl_irt_resource_open)) ==
+      sizeof(u.nacl_irt_resource_open))
     {
       ___nacl_irt_open_resource = u.nacl_irt_resource_open.open_resource;
       __nacl_irt_open_resource = nacl_irt_open_resource;
 #ifdef IS_IN_rtld
       if (_dl_argc == 1)
         {
           static const char *argv[] =
-            {
-              DL_DST_LIB "/runnable-ld.so",
-              DL_DST_LIB "/main.nexe",
-              0
-            };
+        {

[Mark Seaborn, 2014/03/14 17:56:45]

This should be indented deeper

[hamaji, 2014/03/14 18:31:37]

Done.

+          DL_DST_LIB "/runnable-ld.so",
+          DL_DST_LIB "/main.nexe",
+          0
+        };
           _dl_argc = 2;
           _dl_argv = (char **)argv;
         }
 #endif
     }
   else
     __nacl_irt_open_resource = nacl_irt_open_as_resource;
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_CLOCK_v0_1, &u.nacl_irt_clock,
-                        sizeof(u.nacl_irt_clock)) == sizeof(u.nacl_irt_clock))
+                        sizeof(u.nacl_irt_clock)) == sizeof(u.nacl_irt_clock))
     {
       __nacl_irt_clock_getres = u.nacl_irt_clock.clock_getres;
       __nacl_irt_clock_gettime = u.nacl_irt_clock.clock_gettime;
     }
   else
     {
       __nacl_irt_clock_getres = nacl_irt_clock_getres;
       __nacl_irt_clock_gettime = nacl_irt_clock_gettime;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_DEV_GETPID_v0_1, &u.nacl_irt_dev_getpid,
-                        sizeof(u.nacl_irt_dev_getpid)) == sizeof(u.nacl_irt_dev_getpid))
+                        sizeof(u.nacl_irt_dev_getpid)) ==
+      sizeof(u.nacl_irt_dev_getpid))
     {
       __nacl_irt_getpid = u.nacl_irt_dev_getpid.getpid;
     }
   else
     {
       __nacl_irt_getpid = not_implemented;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_DEV_FDIO_v0_2, &u.nacl_irt_dev_fdio,
-                        sizeof(u.nacl_irt_dev_fdio)) == sizeof(u.nacl_irt_dev_fdio))
+                        sizeof(u.nacl_irt_dev_fdio)) ==
+      sizeof(u.nacl_irt_dev_fdio))
     {
       __nacl_irt_fchdir = u.nacl_irt_dev_fdio.fchdir;
       __nacl_irt_fchmod = u.nacl_irt_dev_fdio.fchmod;
       __nacl_irt_fsync = u.nacl_irt_dev_fdio.fsync;
       __nacl_irt_fdatasync = u.nacl_irt_dev_fdio.fdatasync;
       __nacl_irt_ftruncate = u.nacl_irt_dev_fdio.ftruncate;
     }
   else
     {
       __nacl_irt_fchdir = not_implemented;
       __nacl_irt_fchmod = not_implemented;
       __nacl_irt_fsync = not_implemented;
       __nacl_irt_fdatasync = not_implemented;
       __nacl_irt_ftruncate = not_implemented;
     }
 
   if (__nacl_irt_query &&
       __nacl_irt_query (NACL_IRT_DEV_FILENAME_v0_3, &u.nacl_irt_dev_filename,
-                        sizeof(u.nacl_irt_dev_filename)) == sizeof(u.nacl_irt_dev_filename))
+                        sizeof(u.nacl_irt_dev_filename)) ==
+      sizeof(u.nacl_irt_dev_filename))
     {
       __nacl_irt_mkdir = u.nacl_irt_dev_filename.mkdir;
       __nacl_irt_chdir = u.nacl_irt_dev_filename.chdir;
       __nacl_irt_rmdir = u.nacl_irt_dev_filename.rmdir;
       __nacl_irt_getcwd = u.nacl_irt_dev_filename.getcwd;
       __nacl_irt_unlink = u.nacl_irt_dev_filename.unlink;
       __nacl_irt_truncate = u.nacl_irt_dev_filename.truncate;
       __nacl_irt_lstat = u.nacl_irt_dev_filename.lstat;
       __nacl_irt_link = u.nacl_irt_dev_filename.link;
       __nacl_irt_rename = u.nacl_irt_dev_filename.rename;
       __nacl_irt_symlink = u.nacl_irt_dev_filename.symlink;
       __nacl_irt_chmod = u.nacl_irt_dev_filename.chmod;
       __nacl_irt_access = u.nacl_irt_dev_filename.access;
       __nacl_irt_readlink = u.nacl_irt_dev_filename.readlink;
       __nacl_irt_utimes = u.nacl_irt_dev_filename.utimes;
     }
   else if (__nacl_irt_query &&
-           __nacl_irt_query (NACL_IRT_DEV_FILENAME_v0_2, &u.nacl_irt_dev_filename_v0_2,
-                             sizeof(u.nacl_irt_dev_filename_v0_2)) == sizeof(u.nacl_irt_dev_filename_v0_2))
+           __nacl_irt_query (NACL_IRT_DEV_FILENAME_v0_2,
+                             &u.nacl_irt_dev_filename_v0_2,
+                             sizeof(u.nacl_irt_dev_filename_v0_2)) ==
+           sizeof(u.nacl_irt_dev_filename_v0_2))
     {
       __nacl_irt_mkdir = u.nacl_irt_dev_filename_v0_2.mkdir;
       __nacl_irt_chdir = u.nacl_irt_dev_filename_v0_2.chdir;
       __nacl_irt_rmdir = u.nacl_irt_dev_filename_v0_2.rmdir;
       __nacl_irt_getcwd = u.nacl_irt_dev_filename_v0_2.getcwd;
       __nacl_irt_unlink = u.nacl_irt_dev_filename_v0_2.unlink;
       __nacl_irt_truncate = not_implemented;
       __nacl_irt_lstat = not_implemented;
       __nacl_irt_link = not_implemented;
       __nacl_irt_rename = not_implemented;
@@ skipping 49 matching lines @@
   __nacl_irt_getsockopt = not_implemented;
   __nacl_irt_setsockopt = not_implemented;
   __nacl_irt_socketpair = not_implemented;
   __nacl_irt_shutdown = not_implemented;
 }
 
 size_t nacl_interface_query(const char *interface_ident,
                             void *table, size_t tablesize) {
   return (*__nacl_irt_query)(interface_ident, table, tablesize);
 }