Fix typo 'writeable' -> 'writable'

LibOS/shim/include/shim_fs.h

@@ -96,7 +96,7 @@ struct shim_fs_ops {
     int (*checkin) (struct shim_handle * hdl);
 
     /* poll a single handle */
-    /* POLL_RD|POLL_WR: return POLL_RD|POLL_WR for readable|writeable,
+    /* POLL_RD|POLL_WR: return POLL_RD|POLL_WR for readable|writable,
        POLL_ER for failure, -EAGAIN for unknown. */
     /* POLL_SZ: return total size */
     int (*poll) (struct shim_handle * hdl, int poll_type);

LibOS/shim/include/shim_vma.h

@@ -71,7 +71,7 @@ void free_vma_val_array (struct shim_vma_val * vmas, size_t count)
                                      memory is not actually allocated */
 #define VMA_INTERNAL 0x20000000   /* vma is used internally */
 
-#define VMA_TAINTED  0x40000000   /* vma has been protected as writeable,
+#define VMA_TAINTED  0x40000000   /* vma has been protected as writable,
                                      so it has to be checkpointed during
                                      migration */
 

LibOS/shim/src/fs/chroot/fs.c

@@ -233,9 +233,9 @@ static int __query_attr (struct shim_dentry * dent,
             case pal_type_dev:  data->type = FILE_DEV;     if (dent) dent->type = S_IFCHR; break;
         }
 
-    data->mode = (pal_attr.readable  ? S_IRUSR : 0) |
-                 (pal_attr.writeable ? S_IWUSR : 0) |
-                 (pal_attr.runnable  ? S_IXUSR : 0);
+    data->mode = (pal_attr.readable ? S_IRUSR : 0) |
+                 (pal_attr.writable ? S_IWUSR : 0) |
+                 (pal_attr.runnable ? S_IXUSR : 0);
 
     atomic_set(&data->size, pal_attr.pending_size);
 

LibOS/shim/src/fs/pipe/fs.c

@@ -130,7 +130,7 @@ static int pipe_poll (struct shim_handle * hdl, int poll_type)
         ret |= FS_POLL_ER;
     if ((poll_type & FS_POLL_RD) && attr.readable)
         ret |= FS_POLL_RD;
-    if ((poll_type & FS_POLL_WR) && attr.writeable)
+    if ((poll_type & FS_POLL_WR) && attr.writable)
         ret |= FS_POLL_WR;
 
 out:

LibOS/shim/src/fs/socket/fs.c

@@ -232,7 +232,7 @@ static int socket_poll (struct shim_handle * hdl, int poll_type)
         ret |= FS_POLL_ER;
     if ((poll_type & FS_POLL_RD) && attr.readable)
         ret |= FS_POLL_RD;
-    if ((poll_type & FS_POLL_WR) && attr.writeable)
+    if ((poll_type & FS_POLL_WR) && attr.writable)
         ret |= FS_POLL_WR;
 
 out:

LibOS/shim/src/shim_init.c

@@ -248,7 +248,7 @@ void * allocate_stack (size_t size, size_t protect_size, bool user)
     size = ALIGN_UP(size);
     protect_size = ALIGN_UP(protect_size);
 
-    /* preserve a non-readable, non-writeable page below the user
+    /* preserve a non-readable, non-writable page below the user
        stack to stop user program to clobber other vmas */
     void * stack = NULL;
     int flags = STACK_FLAGS|(user ? 0 : VMA_INTERNAL);

LibOS/shim/src/sys/shim_epoll.c

@@ -354,7 +354,7 @@ retry:
             }
             if (attr.readable)
                 epoll_fd->revents |= EPOLLIN;
-            if (attr.writeable)
+            if (attr.writable)
                 epoll_fd->revents |= EPOLLOUT;
             break;
         }

LibOS/shim/src/sys/shim_poll.c

@@ -195,7 +195,7 @@ no_op:
 
         if (do_w && !(hdl->acc_mode & MAY_WRITE)) {
             p->flags |= KNOWN_W;
-            debug("fd %d known to be not writeable\n", p->fd);
+            debug("fd %d known to be not writable\n", p->fd);
             do_w = false;
         }
 
@@ -236,7 +236,7 @@ no_op:
                     }
 
                     if (polled & FS_POLL_WR) {
-                        debug("fd %d known to be writeable\n", p->fd);
+                        debug("fd %d known to be writable\n", p->fd);
                         p->flags |= KNOWN_W|RET_W;
                         do_w = false;
                     }
@@ -346,8 +346,8 @@ done_finding:
             debug("handle is polled to be readable\n");
             p->flags |= RET_R;
         }
-        if (attr.writeable) {
-            debug("handle is polled to be writeable\n");
+        if (attr.writable) {
+            debug("handle is polled to be writable\n");
             p->flags |= RET_W;
         }
 

Pal/src/host/FreeBSD/db_devices.c

@@ -154,9 +154,9 @@ static int term_attrquery (const char * type, const char * uri,
                            PAL_STREAM_ATTR * attr)
 {
     attr->handle_type = pal_type_dev;
-    attr->readable  = PAL_TRUE;
-    attr->writeable = PAL_TRUE;
-    attr->runnable  = PAL_FALSE;
+    attr->readable = PAL_TRUE;
+    attr->writable = PAL_TRUE;
+    attr->runnable = PAL_FALSE;
     attr->pending_size = 0;
     return 0;
 }
@@ -166,9 +166,9 @@ static int term_attrquerybyhdl (PAL_HANDLE hdl,
                                 PAL_STREAM_ATTR * attr)
 {
     attr->handle_type = pal_type_dev;
-    attr->readable  = (hdl->dev.fd_in  != PAL_IDX_POISON);
-    attr->writeable = (hdl->dev.fd_out != PAL_IDX_POISON);
-    attr->runnable  = PAL_FALSE;
+    attr->readable = (hdl->dev.fd_in  != PAL_IDX_POISON);
+    attr->writable = (hdl->dev.fd_out != PAL_IDX_POISON);
+    attr->runnable = PAL_FALSE;
     attr->pending_size = 0;
     return 0;
 }
@@ -363,9 +363,9 @@ dev_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat)
 {
     attr->handle_type = pal_type_dev;
 	/* readable, writable and runnable are decied by euidstataccess */
-    attr->readable  = stataccess(stat, ACCESS_R);
-    attr->writeable = stataccess(stat, ACCESS_W);
-    attr->runnable  = stataccess(stat, ACCESS_X);
+    attr->readable = stataccess(stat, ACCESS_R);
+    attr->writable = stataccess(stat, ACCESS_W);
+    attr->runnable = stataccess(stat, ACCESS_X);
     attr->pending_size = stat->st_size;
 }
 
@@ -416,9 +416,9 @@ static int dev_attrquerybyhdl (PAL_HANDLE handle,
             stat_out = &stat_buf;
     }
 
-    attr->readable  = (stat_in  && stataccess(stat_in,  ACCESS_R));
-    attr->runnable  = (stat_in  && stataccess(stat_in,  ACCESS_X));
-    attr->writeable = (stat_out && stataccess(stat_out, ACCESS_W));
+    attr->readable = (stat_in  && stataccess(stat_in,  ACCESS_R));
+    attr->runnable = (stat_in  && stataccess(stat_in,  ACCESS_X));
+    attr->writable = (stat_out && stataccess(stat_out, ACCESS_W));
     attr->pending_size = stat_in ? stat_in->st_size :
                          (stat_out ? stat_out->st_size : 0);
     return 0;

Pal/src/host/FreeBSD/db_files.c

@@ -58,7 +58,7 @@ static int file_open (PAL_HANDLE * handle, const char * type, const char * uri,
     int len = strlen(uri);
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(file) + len + 1);
     SET_HANDLE_TYPE(hdl, file);
-    hdl->hdr.flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    hdl->hdr.flags |= RFD(0)|WFD(0)|WRITABLE(0);
     hdl->file.fd = ret;
     hdl->file.offset = 0;
     hdl->file.append = 0;
@@ -218,7 +218,7 @@ file_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat)
     attr->disconnected = PAL_FALSE;
     attr->nonblocking  = PAL_FALSE;
     attr->readable     = stataccess(stat, ACCESS_R);
-    attr->writeable    = stataccess(stat, ACCESS_W);
+    attr->writable     = stataccess(stat, ACCESS_W);
     attr->runnable     = stataccess(stat, ACCESS_X);
     attr->share_flags  = stat->st_mode;
     attr->pending_size = stat->st_size;

Pal/src/host/FreeBSD/db_main.c

@@ -240,7 +240,7 @@ void pal_bsd_main (void * args)
     int len = strlen(argv[0]);
     PAL_HANDLE file = malloc(HANDLE_SIZE(file) + len + 1);
     SET_HANDLE_TYPE(file, file);
-    file->hdr.flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    file->hdr.flags |= RFD(0)|WFD(0)|WRITABLE(0);
     file->file.fd = fd;
     char * path = (void *) file + HANDLE_SIZE(file);
     get_norm_path(argv[0], path, 0, len + 1);

Pal/src/host/FreeBSD/db_object.c

@@ -58,7 +58,7 @@ static int _DkObjectWaitOne (PAL_HANDLE handle, int timeout)
                 events |= POLLIN;
 
             if ((handle->hdr.flags & WFD(i)) &&
-                !(handle->hdr.flags & WRITEABLE(i)) &&
+                !(handle->hdr.flags & WRITABLE(i)) &&
                 !(handle->hdr.flags & ERROR(i)))
                 events |= POLLOUT;
 
@@ -92,7 +92,7 @@ static int _DkObjectWaitOne (PAL_HANDLE handle, int timeout)
             if (!fds[i].revents)
                 continue;
             if (fds[i].revents & POLLOUT)
-                handle->hdr.flags |= WRITEABLE(off[i]);
+                handle->hdr.flags |= WRITABLE(off[i]);
             if (fds[i].revents & (POLLHUP|POLLERR))
                 handle->hdr.flags |= ERROR(off[i]);
         }
@@ -169,7 +169,7 @@ int _DkObjectsWaitAny (int count, PAL_HANDLE * handleArray, uint64_t timeout,
                 events |= POLLIN;
 
             if ((hdl->hdr.flags & WFD(j)) &&
-                !(hdl->hdr.flags & WRITEABLE(j)) &&
+                !(hdl->hdr.flags & WRITABLE(j)) &&
                 !(hdl->hdr.flags & ERROR(j)))
                 events |= POLLOUT;
 
@@ -223,7 +223,7 @@ int _DkObjectsWaitAny (int count, PAL_HANDLE * handleArray, uint64_t timeout,
             continue;
 
         if (fds[i].revents & POLLOUT)
-            hdl->hdr.flags |= WRITEABLE(j);
+            hdl->hdr.flags |= WRITABLE(j);
         if (fds[i].revents & (POLLHUP|POLLERR))
             hdl->hdr.flags |= ERROR(j);
     }

Pal/src/host/FreeBSD/db_pipes.c

@@ -160,14 +160,14 @@ static int pipe_waitforclient (PAL_HANDLE handle, PAL_HANDLE * client)
 
     PAL_HANDLE clnt = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(clnt, pipeprv);
-    clnt->hdr.flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    clnt->hdr.flags |= RFD(0)|WFD(1)|WRITABLE(1);
     clnt->pipeprv.fds[0] = pipes[0];
     clnt->pipeprv.fds[1] = pipes[1];
     *client = clnt;
 #else
     PAL_HANDLE clnt = malloc(HANDLE_SIZE(pipe));
     SET_HANDLE_TYPE(clnt, pipecli);
-    clnt->hdr.flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    clnt->hdr.flags |= RFD(0)|WFD(0)|WRITABLE(0);
     clnt->pipe.fd = newfd;
     clnt->pipe.nonblocking = PAL_FALSE;
     clnt->pipe.pipeid = handle->pipe.pipeid;
@@ -254,7 +254,7 @@ static int pipe_connect (PAL_HANDLE * handle, PAL_NUM pipeid, int options)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(hdl, pipeprv);
-    hdl->hdr.flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    hdl->hdr.flags |= RFD(0)|WFD(1)|WRITABLE(1);
     hdl->pipeprv.fds[0] = pipes[0];
     hdl->pipeprv.fds[1] = pipes[1];
     hdl->pipeprv.nonblocking = (options & O_NONBLOCK) ?
@@ -262,7 +262,7 @@ static int pipe_connect (PAL_HANDLE * handle, PAL_NUM pipeid, int options)
 #else
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipe));
     SET_HANDLE_TYPE(hdl, pipe);
-    hdl->hdr.flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    hdl->hdr.flags |= RFD(0)|WFD(0)|WRITABLE(0);
     hdl->pipe.fd = fd;
     hdl->pipe.pipeid = pipeid;
     hdl->pipe.nonblocking = (options & O_NONBLOCK) ?
@@ -290,7 +290,7 @@ static int pipe_private (PAL_HANDLE * handle, int options)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(hdl, pipeprv);
-    hdl->hdr.flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    hdl->hdr.flags |= RFD(0)|WFD(1)|WRITABLE(1);
     hdl->pipeprv.fds[0] = fds[0];
     hdl->pipeprv.fds[1] = fds[1];
     hdl->pipeprv.nonblocking = (options & O_NONBLOCK) ?
@@ -414,13 +414,13 @@ static int pipe_write (PAL_HANDLE handle, int offset, int len,
     }
 #endif
 
-    PAL_FLG writeable = IS_HANDLE_TYPE(handle, pipeprv) ? WRITEABLE(1) :
-                        WRITEABLE(0);
+    PAL_FLG writable = IS_HANDLE_TYPE(handle, pipeprv) ? WRITABLE(1) :
+                       WRITABLE(0);
 
     if (IS_ERR(bytes))
         switch(ERRNO(bytes)) {
             case EWOULDBLOCK:
-                handle->hdr.flags &= ~writeable;
+                handle->hdr.flags &= ~writable;
                 return-PAL_ERROR_TRYAGAIN;
             case EINTR:
                 return -PAL_ERROR_INTERRUPTED;
@@ -429,9 +429,9 @@ static int pipe_write (PAL_HANDLE handle, int offset, int len,
         }
 
     if (bytes == len)
-        handle->hdr.flags |= writeable;
+        handle->hdr.flags |= writable;
     else
-        handle->hdr.flags &= ~writeable;
+        handle->hdr.flags &= ~writable;
 
     return bytes;
 }
@@ -531,9 +531,9 @@ static int pipe_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
                          handle->pipeprv.nonblocking : handle->pipe.nonblocking;
     attr->readable     = val > 0;
     if (PAL_GET_TYPE(handle) == pal_type_pipeprv)
-        attr->writeable = handle->hdr.flags & WRITEABLE(1);
+        attr->writable = handle->hdr.flags & WRITABLE(1);
     else
-        attr->writeable = handle->hdr.flags & WRITEABLE(0);
+        attr->writable = handle->hdr.flags & WRITABLE(0);
     attr->pending_size = val;
     return 0;
 }

Pal/src/host/FreeBSD/db_process.c

@@ -79,7 +79,7 @@ static inline int create_process_handle (PAL_HANDLE * parent,
     }
 
     SET_HANDLE_TYPE(phdl, process);
-    phdl->hdr.flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITEABLE(1)|WRITEABLE(2);
+    phdl->hdr.flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITABLE(1)|WRITABLE(2);
     phdl->process.stream_in   = proc_fds[0][0];
     phdl->process.stream_out  = proc_fds[0][1];
     phdl->process.cargo       = proc_fds[0][2];
@@ -93,7 +93,7 @@ static inline int create_process_handle (PAL_HANDLE * parent,
     }
 
     SET_HANDLE_TYPE(chdl, process);
-    chdl->hdr.flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITEABLE(1)|WRITEABLE(2);
+    chdl->hdr.flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITABLE(1)|WRITABLE(2);
     chdl->process.stream_in   = proc_fds[1][0];
     chdl->process.stream_out  = proc_fds[1][1];
     chdl->process.cargo       = proc_fds[1][2];
@@ -425,7 +425,7 @@ static int proc_write (PAL_HANDLE handle, int offset, int count,
     if (IS_ERR(bytes))
         switch(ERRNO(bytes)) {
             case EWOULDBLOCK:
-                handle->hdr.flags &= ~WRITEABLE(1);
+                handle->hdr.flags &= ~WRITABLE(1);
                 return-PAL_ERROR_TRYAGAIN;
             case EINTR:
                 return -PAL_ERROR_INTERRUPTED;
@@ -434,9 +434,9 @@ static int proc_write (PAL_HANDLE handle, int offset, int count,
         }
 
     if (bytes == count)
-        handle->hdr.flags |= WRITEABLE(1);
+        handle->hdr.flags |= WRITABLE(1);
     else
-        handle->hdr.flags &= ~WRITEABLE(1);
+        handle->hdr.flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -511,7 +511,7 @@ static int proc_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
     attr->nonblocking  = handle->process.nonblocking;
     attr->disconnected = handle->hdr.flags & (ERROR(0)|ERROR(1));
     attr->readable     = !!val;
-    attr->writeable    = handle->hdr.flags & WRITEABLE(1);
+    attr->writable     = handle->hdr.flags & WRITABLE(1);
     attr->runnable     = PAL_FALSE;
     attr->pending_size = val;
 

Pal/src/host/FreeBSD/db_sockets.c

@@ -622,16 +622,16 @@ static int tcp_write (PAL_HANDLE handle, int offset, int len, const void * buf)
             case EPIPE:
                 return -PAL_ERROR_CONNFAILED;
             case EWOULDBLOCK:
-                handle->hdr.flags &= ~WRITEABLE(0);
+                handle->hdr.flags &= ~WRITABLE(0);
                 return -PAL_ERROR_TRYAGAIN;
             default:
                 return unix_to_pal_error(ERRNO(bytes));
         }
 
     if (bytes == len)
-        handle->hdr.flags |= WRITEABLE(0);
+        handle->hdr.flags |= WRITABLE(0);
     else
-        handle->hdr.flags &= ~WRITEABLE(0);
+        handle->hdr.flags &= ~WRITABLE(0);
 
     return bytes;
 }
@@ -885,7 +885,7 @@ static int udp_send (PAL_HANDLE handle, int offset, int len, const void * buf)
     if (IS_ERR(bytes))
         switch(ERRNO(bytes)) {
             case EAGAIN:
-                handle->hdr.flags &= ~WRITEABLE(0);
+                handle->hdr.flags &= ~WRITABLE(0);
                 return -PAL_ERROR_TRYAGAIN;
             case ECONNRESET:
             case EPIPE:
@@ -895,9 +895,9 @@ static int udp_send (PAL_HANDLE handle, int offset, int len, const void * buf)
         }
 
     if (bytes == len)
-        handle->hdr.flags |= WRITEABLE(0);
+        handle->hdr.flags |= WRITABLE(0);
     else
-        handle->hdr.flags &= ~WRITEABLE(0);
+        handle->hdr.flags &= ~WRITABLE(0);
 
     return bytes;
 }
@@ -946,15 +946,15 @@ static int udp_sendbyaddr (PAL_HANDLE handle, int offset, int len,
             case EPIPE:
                 return -PAL_ERROR_CONNFAILED;
             case EAGAIN:
-                handle->hdr.flags &= ~WRITEABLE(0);
+                handle->hdr.flags &= ~WRITABLE(0);
             default:
                 return unix_to_pal_error(ERRNO(bytes));
         }
 
     if (bytes == len)
-        handle->hdr.flags |= WRITEABLE(0);
+        handle->hdr.flags |= WRITABLE(0);
     else
-        handle->hdr.flags &= ~WRITEABLE(0);
+        handle->hdr.flags &= ~WRITABLE(0);
 
     return bytes;
 }
@@ -1028,7 +1028,7 @@ static int socket_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR  * attr)
     attr->handle_type           = handle->hdr.type;
     attr->disconnected          = handle->hdr.flags & ERROR(0);
     attr->nonblocking           = handle->sock.nonblocking;
-    attr->writeable             = handle->hdr.flags & WRITEABLE(0);
+    attr->writable              = handle->hdr.flags & WRITABLE(0);
     attr->socket.linger         = handle->sock.linger;
     attr->socket.receivebuf     = handle->sock.receivebuf;
     attr->socket.sendbuf        = handle->sock.sendbuf;
@@ -1278,7 +1278,7 @@ static int mcast_s (PAL_HANDLE handle, int port)
     if (IS_ERR(ret))
         return -PAL_ERROR_DENIED;
 
-    handle->hdr.flags |= WFD(1)|WRITEABLE(1);
+    handle->hdr.flags |= WFD(1)|WRITABLE(1);
     handle->mcast.srv = fd;
     return 0;
 }
@@ -1378,16 +1378,16 @@ static int mcast_send (PAL_HANDLE handle, int offset, int size,
             case EPIPE:
                 return -PAL_ERROR_CONNFAILED;
             case EAGAIN:
-                handle->hdr.flags &= ~WRITEABLE(1);
+                handle->hdr.flags &= ~WRITABLE(1);
                 /* fallthrough */
             default:
                 return unix_to_pal_error(ERRNO(bytes));
         }
 
     if (bytes == size)
-        handle->hdr.flags |= WRITEABLE(1);
+        handle->hdr.flags |= WRITABLE(1);
     else
-        handle->hdr.flags &= ~WRITEABLE(1);
+        handle->hdr.flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -1444,7 +1444,7 @@ static int mcast_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
     attr->disconnected = handle->hdr.flags & (ERROR(0)|ERROR(1));
     attr->nonblocking  = handle->mcast.nonblocking;
     attr->readable     = !!val;
-    attr->writeable    = handle->hdr.flags & WRITEABLE(1);
+    attr->writable     = handle->hdr.flags & WRITABLE(1);
     attr->runnable     = PAL_FALSE;
     attr->pending_size = val;
     return 0;

Pal/src/host/FreeBSD/pal_host.h

@@ -174,7 +174,7 @@ typedef union pal_handle
 
 #define RFD(n)          (00001 << (n))
 #define WFD(n)          (00010 << (n))
-#define WRITEABLE(n)    (00100 << (n))
+#define WRITABLE(n)     (00100 << (n))
 #define ERROR(n)        (01000 << (n))
 #define HAS_FDS         00077
 

Pal/src/host/Linux-SGX/db_devices.c

@@ -172,7 +172,7 @@ static int term_attrquery (const char * type, const char * uri,
 
     attr->handle_type = pal_type_dev;
     attr->readable  = PAL_TRUE;
-    attr->writeable = PAL_TRUE;
+    attr->writable  = PAL_TRUE;
     attr->runnable  = PAL_FALSE;
     attr->pending_size = 0;
     return 0;
@@ -184,7 +184,7 @@ static int term_attrquerybyhdl (PAL_HANDLE hdl,
 {
     attr->handle_type = pal_type_dev;
     attr->readable  = (hdl->dev.fd_in  != PAL_IDX_POISON);
-    attr->writeable = (hdl->dev.fd_out != PAL_IDX_POISON);
+    attr->writable  = (hdl->dev.fd_out != PAL_IDX_POISON);
     attr->runnable  = PAL_FALSE;
     attr->pending_size = 0;
     return 0;
@@ -362,9 +362,9 @@ dev_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat)
 {
     attr->handle_type = pal_type_dev;
     /* readable, writable and runnable are decied by euidstataccess */
-    attr->readable  = stataccess(stat, ACCESS_R);
-    attr->writeable = stataccess(stat, ACCESS_W);
-    attr->runnable  = stataccess(stat, ACCESS_X);
+    attr->readable = stataccess(stat, ACCESS_R);
+    attr->writable = stataccess(stat, ACCESS_W);
+    attr->runnable = stataccess(stat, ACCESS_X);
     attr->pending_size = stat->st_size;
 }
 
@@ -418,9 +418,9 @@ static int dev_attrquerybyhdl (PAL_HANDLE handle,
             stat_out = &stat_buf;
     }
 
-    attr->readable  = (stat_in  && stataccess(stat_in,  ACCESS_R));
-    attr->writeable = (stat_in  && stataccess(stat_in,  ACCESS_W));
-    attr->runnable  = (stat_out && stataccess(stat_out, ACCESS_X));
+    attr->readable = (stat_in  && stataccess(stat_in,  ACCESS_R));
+    attr->writable = (stat_in  && stataccess(stat_in,  ACCESS_W));
+    attr->runnable = (stat_out && stataccess(stat_out, ACCESS_X));
     attr->pending_size = stat_in ? stat_in->st_size :
                          (stat_out ? stat_out->st_size : 0);
     return 0;

Pal/src/host/Linux-SGX/db_files.c

@@ -60,7 +60,7 @@ static int file_open (PAL_HANDLE * handle, const char * type, const char * uri,
     int len = strlen(uri);
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(file) + len + 1);
     SET_HANDLE_TYPE(hdl, file);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     hdl->file.fd = fd;
     hdl->file.append = 0;
     hdl->file.pass = 0;
@@ -208,7 +208,7 @@ static int file_map (PAL_HANDLE handle, void ** addr, int prot,
     }
 
     if (!(prot & PAL_PROT_WRITECOPY) && (prot & PAL_PROT_WRITE)) {
-        SGX_DBG(DBG_E, "file_map does not currently support writeable pass-through mappings on SGX.  You may add the PAL_PROT_WRITECOPY (MAP_PRIVATE) flag to your file mapping to keep the writes inside the enclave but they won't be reflected outside of the enclave.\n");
+        SGX_DBG(DBG_E, "file_map does not currently support writable pass-through mappings on SGX.  You may add the PAL_PROT_WRITECOPY (MAP_PRIVATE) flag to your file mapping to keep the writes inside the enclave but they won't be reflected outside of the enclave.\n");
         return -PAL_ERROR_DENIED;
     }
 
@@ -292,11 +292,11 @@ static inline int file_stat_type (struct stat * stat)
 static inline void
 file_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat)
 {
-    attr->handle_type = file_stat_type(stat);
+    attr->handle_type  = file_stat_type(stat);
     attr->disconnected = PAL_FALSE;
     attr->nonblocking  = PAL_FALSE;
     attr->readable     = stataccess(stat, ACCESS_R);
-    attr->writeable    = stataccess(stat, ACCESS_W);
+    attr->writable     = stataccess(stat, ACCESS_W);
     attr->runnable     = stataccess(stat, ACCESS_X);
     attr->share_flags  = stat->st_mode;
     attr->pending_size = stat->st_size;

Pal/src/host/Linux-SGX/db_object.c

@@ -58,7 +58,7 @@ static int _DkObjectWaitOne (PAL_HANDLE handle, PAL_NUM timeout)
                 events |= POLLIN;
 
             if ((HANDLE_HDR(handle)->flags & WFD(i)) &&
-                !(HANDLE_HDR(handle)->flags & WRITEABLE(i)) &&
+                !(HANDLE_HDR(handle)->flags & WRITABLE(i)) &&
                 !(HANDLE_HDR(handle)->flags & ERROR(i)))
                 events |= POLLOUT;
 
@@ -86,7 +86,7 @@ static int _DkObjectWaitOne (PAL_HANDLE handle, PAL_NUM timeout)
             if (!fds[i].revents)
                 continue;
             if (fds[i].revents & POLLOUT)
-                HANDLE_HDR(handle)->flags |= WRITEABLE(off[i]);
+                HANDLE_HDR(handle)->flags |= WRITABLE(off[i]);
             if (fds[i].revents & (POLLHUP|POLLERR))
                 HANDLE_HDR(handle)->flags |= ERROR(off[i]);
         }
@@ -170,7 +170,7 @@ int _DkObjectsWaitAny (int count, PAL_HANDLE * handleArray, PAL_NUM timeout,
                 events |= POLLIN;
 
             if ((HANDLE_HDR(hdl)->flags & WFD(j)) &&
-                !(HANDLE_HDR(hdl)->flags & WRITEABLE(j)) &&
+                !(HANDLE_HDR(hdl)->flags & WRITABLE(j)) &&
                 !(HANDLE_HDR(hdl)->flags & ERROR(j)))
                 events |= POLLOUT;
 
@@ -219,7 +219,7 @@ int _DkObjectsWaitAny (int count, PAL_HANDLE * handleArray, PAL_NUM timeout,
             continue;
 
         if (fds[i].revents & POLLOUT)
-            HANDLE_HDR(hdl)->flags |= WRITEABLE(j);
+            HANDLE_HDR(hdl)->flags |= WRITABLE(j);
         if (fds[i].revents & (POLLHUP|POLLERR))
             HANDLE_HDR(hdl)->flags |= ERROR(j);
     }

Pal/src/host/Linux-SGX/db_pipes.c

@@ -104,7 +104,7 @@ static int pipe_waitforclient (PAL_HANDLE handle, PAL_HANDLE * client)
 
     PAL_HANDLE clnt = malloc(HANDLE_SIZE(pipe));
     SET_HANDLE_TYPE(clnt, pipecli);
-    HANDLE_HDR(clnt)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(clnt)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     clnt->pipe.fd = ret;
     clnt->pipe.nonblocking = PAL_FALSE;
     clnt->pipe.pipeid = handle->pipe.pipeid;
@@ -130,7 +130,7 @@ static int pipe_connect (PAL_HANDLE * handle, PAL_NUM pipeid, int options)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipe));
     SET_HANDLE_TYPE(hdl, pipe);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     hdl->pipe.fd = ret;
     hdl->pipe.pipeid = pipeid;
     hdl->pipe.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
@@ -153,7 +153,7 @@ static int pipe_private (PAL_HANDLE * handle, int options)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(hdl, pipeprv);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITABLE(1);
     hdl->pipeprv.fds[0] = fds[0];
     hdl->pipeprv.fds[1] = fds[1];
     hdl->pipeprv.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
@@ -240,20 +240,20 @@ static int64_t pipe_write (PAL_HANDLE handle, uint64_t offset, uint64_t len,
              handle->pipe.fd;
     int bytes = ocall_sock_send(fd, buffer, len, NULL, 0);
 
-    PAL_FLG writeable = IS_HANDLE_TYPE(handle, pipeprv) ? WRITEABLE(1) :
-                        WRITEABLE(0);
+    PAL_FLG writable = IS_HANDLE_TYPE(handle, pipeprv) ? WRITABLE(1) :
+                       WRITABLE(0);
 
     if (IS_ERR(bytes)) {
         bytes = unix_to_pal_error(ERRNO(bytes));
         if (bytes == -PAL_ERROR_TRYAGAIN)
-            HANDLE_HDR(handle)->flags &= ~writeable;
+            HANDLE_HDR(handle)->flags &= ~writable;
         return bytes;
     }
 
     if ((uint64_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= writeable;
+        HANDLE_HDR(handle)->flags |= writable;
     else
-        HANDLE_HDR(handle)->flags &= ~writeable;
+        HANDLE_HDR(handle)->flags &= ~writable;
 
     return bytes;
 }
@@ -358,11 +358,11 @@ static int pipe_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
             return unix_to_pal_error(ERRNO(ret));
 
         attr->pending_size = ret;
-        attr->writeable    = flags & (
-            IS_HANDLE_TYPE(handle, pipeprv) ? WRITEABLE(1) : WRITEABLE(0));
+        attr->writable     = flags & (
+            IS_HANDLE_TYPE(handle, pipeprv) ? WRITABLE(1) : WRITABLE(0));
     } else {
         attr->pending_size = 0;
-        attr->writeable    = PAL_FALSE;
+        attr->writable     = PAL_FALSE;
     }
 
     struct pollfd pfd = { .fd = read_fd, .events = POLLIN, .revents = 0 };

Pal/src/host/Linux-SGX/db_process.c

@@ -212,7 +212,7 @@ int _DkProcessCreate (PAL_HANDLE * handle, const char * uri, const char ** args)
 
     PAL_HANDLE proc = malloc(HANDLE_SIZE(process));
     SET_HANDLE_TYPE(proc, process);
-    HANDLE_HDR(proc)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITEABLE(1)|WRITEABLE(2);
+    HANDLE_HDR(proc)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITABLE(1)|WRITABLE(2);
     proc->process.stream_in  = proc_fds[0];
     proc->process.stream_out = proc_fds[1];
     proc->process.cargo      = proc_fds[2];
@@ -284,7 +284,7 @@ int init_child_process (PAL_HANDLE * parent_handle)
 {
     PAL_HANDLE parent = malloc(HANDLE_SIZE(process));
     SET_HANDLE_TYPE(parent, process);
-    HANDLE_HDR(parent)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITEABLE(1)|WRITEABLE(2);
+    HANDLE_HDR(parent)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITABLE(1)|WRITABLE(2);
 
     parent->process.stream_in  = pal_sec.proc_fds[0];
     parent->process.stream_out = pal_sec.proc_fds[1];
@@ -371,14 +371,14 @@ static int64_t proc_write (PAL_HANDLE handle, uint64_t offset, uint64_t count,
     if (IS_ERR(bytes)) {
         bytes = unix_to_pal_error(ERRNO(bytes));
         if (bytes == -PAL_ERROR_TRYAGAIN)
-            HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+            HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
         return bytes;
     }
 
     if ((uint64_t)bytes == count)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(1);
+        HANDLE_HDR(handle)->flags |= WRITABLE(1);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -451,7 +451,7 @@ static int proc_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
     attr->pending_size = ret;
     attr->disconnected = HANDLE_HDR(handle)->flags & (ERROR(0)|ERROR(1));
     attr->readable = (attr->pending_size > 0);
-    attr->writeable = HANDLE_HDR(handle)->flags & WRITEABLE(1);
+    attr->writable = HANDLE_HDR(handle)->flags & WRITABLE(1);
     attr->nonblocking = handle->process.nonblocking;
     return 0;
 }

Pal/src/host/Linux-SGX/db_sockets.c

@@ -531,14 +531,14 @@ static int64_t tcp_write (PAL_HANDLE handle, uint64_t offset, uint64_t len,
     if (IS_ERR(bytes)) {
         bytes = unix_to_pal_error(ERRNO(bytes));
         if (bytes == -PAL_ERROR_TRYAGAIN)
-            HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+            HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
         return bytes;
     }
 
     if ((uint64_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(0);
+        HANDLE_HDR(handle)->flags |= WRITABLE(0);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
 
     return bytes;
 }
@@ -726,14 +726,14 @@ static int64_t udp_send (PAL_HANDLE handle, uint64_t offset, uint64_t len,
     if (IS_ERR(bytes)) {
         bytes = unix_to_pal_error(ERRNO(bytes));
         if (bytes == -PAL_ERROR_TRYAGAIN)
-            HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+            HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
         return bytes;
     }
 
     if ((uint64_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(0);
+        HANDLE_HDR(handle)->flags |= WRITABLE(0);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
 
     return bytes;
 }
@@ -775,14 +775,14 @@ static int64_t udp_sendbyaddr (PAL_HANDLE handle, uint64_t offset, uint64_t len,
     if (IS_ERR(bytes)) {
         bytes = unix_to_pal_error(ERRNO(bytes));
         if (bytes == -PAL_ERROR_TRYAGAIN)
-            HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+            HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
         return bytes;
     }
 
     if ((uint64_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(0);
+        HANDLE_HDR(handle)->flags |= WRITABLE(0);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
 
     return bytes;
 }
@@ -841,7 +841,7 @@ static int socket_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR  * attr)
     attr->handle_type           = HANDLE_HDR(handle)->type;
     attr->disconnected          = HANDLE_HDR(handle)->flags & ERROR(0);
     attr->nonblocking           = handle->sock.nonblocking;
-    attr->writeable             = HANDLE_HDR(handle)->flags & WRITEABLE(0);
+    attr->writable              = HANDLE_HDR(handle)->flags & WRITABLE(0);
     attr->pending_size          = 0; /* fill in later */
     attr->socket.linger         = handle->sock.linger;
     attr->socket.receivebuf     = handle->sock.receivebuf;
@@ -1088,7 +1088,7 @@ PAL_HANDLE _DkBroadcastStreamOpen (void)
 {
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(file));
     SET_HANDLE_TYPE(hdl, mcast);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITABLE(1);
     hdl->mcast.port = pal_sec.mcast_port;
     hdl->mcast.srv  = pal_sec.mcast_srv;
     hdl->mcast.cli  = pal_sec.mcast_cli;
@@ -1113,14 +1113,14 @@ static int64_t mcast_send (PAL_HANDLE handle, uint64_t offset, uint64_t size,
     if (IS_ERR(bytes)) {
         bytes = unix_to_pal_error(ERRNO(bytes));
         if (bytes == -PAL_ERROR_TRYAGAIN)
-            HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+            HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
         return bytes;
     }
 
     if ((uint64_t)bytes == size)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(1);
+        HANDLE_HDR(handle)->flags |= WRITABLE(1);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -1144,7 +1144,7 @@ static int64_t mcast_receive (PAL_HANDLE handle, uint64_t offset, uint64_t size,
         bytes = unix_to_pal_error(ERRNO(bytes));
 
     if (bytes == -PAL_ERROR_TRYAGAIN)
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -1175,7 +1175,7 @@ static int mcast_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
     attr->pending_size = ret;
     attr->disconnected = HANDLE_HDR(handle)->flags & (ERROR(0)|ERROR(1));
     attr->readable = (attr->pending_size > 0);
-    attr->writeable = HANDLE_HDR(handle)->flags & WRITEABLE(1);
+    attr->writable = HANDLE_HDR(handle)->flags & WRITABLE(1);
     attr->nonblocking = handle->mcast.nonblocking;
     return 0;
 }

Pal/src/host/Linux-SGX/pal_host.h

@@ -181,7 +181,7 @@ typedef struct pal_handle
 
 #define RFD(n)          (00001 << (n))
 #define WFD(n)          (00010 << (n))
-#define WRITEABLE(n)    (00100 << (n))
+#define WRITABLE(n)     (00100 << (n))
 #define ERROR(n)        (01000 << (n))
 #define HAS_FDS         00077
 

Pal/src/host/Linux/db_devices.c

@@ -163,7 +163,7 @@ static int term_attrquery(const char* type, const char* uri, PAL_STREAM_ATTR* at
 
     attr->handle_type  = pal_type_dev;
     attr->readable     = PAL_TRUE;
-    attr->writeable    = PAL_TRUE;
+    attr->writable     = PAL_TRUE;
     attr->runnable     = PAL_FALSE;
     attr->pending_size = 0;
     return 0;
@@ -173,7 +173,7 @@ static int term_attrquery(const char* type, const char* uri, PAL_STREAM_ATTR* at
 static int term_attrquerybyhdl(PAL_HANDLE hdl, PAL_STREAM_ATTR* attr) {
     attr->handle_type  = pal_type_dev;
     attr->readable     = (hdl->dev.fd_in != PAL_IDX_POISON);
-    attr->writeable    = (hdl->dev.fd_out != PAL_IDX_POISON);
+    attr->writable     = (hdl->dev.fd_out != PAL_IDX_POISON);
     attr->runnable     = PAL_FALSE;
     attr->pending_size = 0;
     return 0;
@@ -366,7 +366,7 @@ static inline void dev_attrcopy(PAL_STREAM_ATTR* attr, struct stat* stat) {
     attr->handle_type = pal_type_dev;
     /* readable, writable and runnable are decied by euidstataccess */
     attr->readable     = stataccess(stat, ACCESS_R);
-    attr->writeable    = stataccess(stat, ACCESS_W);
+    attr->writable     = stataccess(stat, ACCESS_W);
     attr->runnable     = stataccess(stat, ACCESS_X);
     attr->pending_size = stat->st_size;
 }
@@ -421,7 +421,7 @@ static int dev_attrquerybyhdl(PAL_HANDLE handle, PAL_STREAM_ATTR* attr) {
 
     attr->readable     = (stat_in && stataccess(stat_in, ACCESS_R));
     attr->runnable     = (stat_in && stataccess(stat_in, ACCESS_X));
-    attr->writeable    = (stat_out && stataccess(stat_out, ACCESS_W));
+    attr->writable     = (stat_out && stataccess(stat_out, ACCESS_W));
     attr->pending_size = stat_in ? stat_in->st_size : (stat_out ? stat_out->st_size : 0);
     return 0;
 }

Pal/src/host/Linux/db_files.c

@@ -60,7 +60,7 @@ static int file_open (PAL_HANDLE * handle, const char * type, const char * uri,
     size_t len = strlen(uri);
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(file) + len + 1);
     SET_HANDLE_TYPE(hdl, file);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     hdl->file.fd = ret;
     hdl->file.offset = 0;
     hdl->file.append = 0;
@@ -231,7 +231,7 @@ file_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat)
     attr->disconnected = PAL_FALSE;
     attr->nonblocking  = PAL_FALSE;
     attr->readable     = stataccess(stat, ACCESS_R);
-    attr->writeable    = stataccess(stat, ACCESS_W);
+    attr->writable     = stataccess(stat, ACCESS_W);
     attr->runnable     = stataccess(stat, ACCESS_X);
     attr->share_flags  = stat->st_mode;
     attr->pending_size = stat->st_size;

Pal/src/host/Linux/db_main.c

@@ -287,7 +287,7 @@ void pal_linux_main (void * args)
     int len = strlen(argv[0]);
     PAL_HANDLE file = malloc(HANDLE_SIZE(file) + len + 1);
     SET_HANDLE_TYPE(file, file);
-    HANDLE_HDR(file)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(file)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     file->file.fd = fd;
     file->file.offset = 0;
     file->file.append = false;

Pal/src/host/Linux/db_object.c

@@ -71,7 +71,7 @@ static int _DkObjectWaitOne (PAL_HANDLE handle, PAL_NUM timeout)
                 events |= POLLIN;
 
             if ((HANDLE_HDR(handle)->flags & WFD(i)) &&
-                !(HANDLE_HDR(handle)->flags & WRITEABLE(i)) &&
+                !(HANDLE_HDR(handle)->flags & WRITABLE(i)) &&
                 !(HANDLE_HDR(handle)->flags & ERROR(i)))
                 events |= POLLOUT;
 
@@ -107,7 +107,7 @@ static int _DkObjectWaitOne (PAL_HANDLE handle, PAL_NUM timeout)
             if (!fds[i].revents)
                 continue;
             if (fds[i].revents & POLLOUT)
-                HANDLE_HDR(handle)->flags |= WRITEABLE(off[i]);
+                HANDLE_HDR(handle)->flags |= WRITABLE(off[i]);
             if (fds[i].revents & (POLLHUP|POLLERR))
                 HANDLE_HDR(handle)->flags |= ERROR(off[i]);
         }
@@ -191,7 +191,7 @@ int _DkObjectsWaitAny (int count, PAL_HANDLE * handleArray, PAL_NUM timeout,
                 events |= POLLIN;
 
             if ((HANDLE_HDR(hdl)->flags & WFD(j)) &&
-                !(HANDLE_HDR(hdl)->flags & WRITEABLE(j)) &&
+                !(HANDLE_HDR(hdl)->flags & WRITABLE(j)) &&
                 !(HANDLE_HDR(hdl)->flags & ERROR(j)))
                 events |= POLLOUT;
 
@@ -257,7 +257,7 @@ int _DkObjectsWaitAny (int count, PAL_HANDLE * handleArray, PAL_NUM timeout,
             continue;
 
         if (fds[i].revents & POLLOUT)
-            HANDLE_HDR(hdl)->flags |= WRITEABLE(j);
+            HANDLE_HDR(hdl)->flags |= WRITABLE(j);
         if (fds[i].revents & (POLLHUP|POLLERR))
             HANDLE_HDR(hdl)->flags |= ERROR(j);
     }

Pal/src/host/Linux/db_pipes.c

@@ -160,14 +160,14 @@ static int pipe_waitforclient (PAL_HANDLE handle, PAL_HANDLE * client)
 
     PAL_HANDLE clnt = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(clnt, pipeprv);
-    clnt->__in.flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    clnt->__in.flags |= RFD(0)|WFD(1)|WRITABLE(1);
     clnt->pipeprv.fds[0] = pipes[0];
     clnt->pipeprv.fds[1] = pipes[1];
     *client = clnt;
 #else
     PAL_HANDLE clnt = malloc(HANDLE_SIZE(pipe));
     SET_HANDLE_TYPE(clnt, pipecli);
-    HANDLE_HDR(clnt)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(clnt)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     clnt->pipe.fd = newfd;
     clnt->pipe.pipeid = handle->pipe.pipeid;
     clnt->pipe.nonblocking = PAL_FALSE;
@@ -252,7 +252,7 @@ static int pipe_connect (PAL_HANDLE * handle, PAL_NUM pipeid, int options)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(hdl, pipeprv);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITABLE(1);
     hdl->pipeprv.fds[0] = pipes[0];
     hdl->pipeprv.fds[1] = pipes[1];
     hdl->pipeprv.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
@@ -260,7 +260,7 @@ static int pipe_connect (PAL_HANDLE * handle, PAL_NUM pipeid, int options)
 #else
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipe));
     SET_HANDLE_TYPE(hdl, pipe);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITEABLE(0);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(0)|WRITABLE(0);
     hdl->pipe.fd = fd;
     hdl->pipe.pipeid = pipeid;
     hdl->pipe.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
@@ -286,7 +286,7 @@ static int pipe_private (PAL_HANDLE * handle, int options)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(pipeprv));
     SET_HANDLE_TYPE(hdl, pipeprv);
-    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITEABLE(1);
+    HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITABLE(1);
     hdl->pipeprv.fds[0] = fds[0];
     hdl->pipeprv.fds[1] = fds[1];
     hdl->pipeprv.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
@@ -421,13 +421,13 @@ static int64_t pipe_write (PAL_HANDLE handle, uint64_t offset, size_t len,
     }
 #endif
 
-    PAL_FLG writeable = IS_HANDLE_TYPE(handle, pipeprv) ? WRITEABLE(1) :
-                        WRITEABLE(0);
+    PAL_FLG writable = IS_HANDLE_TYPE(handle, pipeprv) ? WRITABLE(1) :
+                       WRITABLE(0);
 
     if (!IS_ERR(bytes) && (size_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= writeable;
+        HANDLE_HDR(handle)->flags |= writable;
     else
-        HANDLE_HDR(handle)->flags &= ~writeable;
+        HANDLE_HDR(handle)->flags &= ~writable;
 
     if (IS_ERR(bytes))
         bytes = unix_to_pal_error(ERRNO(bytes));
@@ -532,15 +532,15 @@ static int pipe_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
             return unix_to_pal_error(ERRNO(ret));
         }
         attr->pending_size = val;
-        attr->writeable    = HANDLE_HDR(handle)->flags & (
-            IS_HANDLE_TYPE(handle, pipeprv) ? WRITEABLE(1) : WRITEABLE(0));
+        attr->writable     = HANDLE_HDR(handle)->flags & (
+            IS_HANDLE_TYPE(handle, pipeprv) ? WRITABLE(1) : WRITABLE(0));
     } else {
         struct pollfd pfd = { .fd = handle->generic.fds[0], .events = POLLIN, .revents = 0 };
         struct timespec tp = { 0, 0 };
         ret = INLINE_SYSCALL(ppoll, 5, &pfd, 1, &tp, NULL, 0);
         attr->readable = (ret == 1 && pfd.revents == POLLIN);
         attr->pending_size = 0;
-        attr->writeable    = PAL_FALSE;
+        attr->writable     = PAL_FALSE;
     }
 
     struct pollfd pfd = { .fd = handle->generic.fds[0], .events = POLLIN, .revents = 0 };

Pal/src/host/Linux/db_process.c

@@ -80,7 +80,7 @@ static inline int create_process_handle (PAL_HANDLE * parent,
     }
 
     SET_HANDLE_TYPE(phdl, process);
-    HANDLE_HDR(phdl)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITEABLE(1)|WRITEABLE(2);
+    HANDLE_HDR(phdl)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITABLE(1)|WRITABLE(2);
     phdl->process.stream_in   = proc_fds[0][0];
     phdl->process.stream_out  = proc_fds[0][1];
     phdl->process.cargo       = proc_fds[0][2];
@@ -94,7 +94,7 @@ static inline int create_process_handle (PAL_HANDLE * parent,
     }
 
     SET_HANDLE_TYPE(chdl, process);
-    HANDLE_HDR(chdl)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITEABLE(1)|WRITEABLE(2);
+    HANDLE_HDR(chdl)->flags |= RFD(0)|WFD(1)|RFD(2)|WFD(2)|WRITABLE(1)|WRITABLE(2);
     chdl->process.stream_in   = proc_fds[1][0];
     chdl->process.stream_out  = proc_fds[1][1];
     chdl->process.cargo       = proc_fds[1][2];
@@ -536,7 +536,7 @@ static int64_t proc_write (PAL_HANDLE handle, uint64_t offset, uint64_t count,
     if (IS_ERR(bytes))
         switch(ERRNO(bytes)) {
             case EWOULDBLOCK:
-                HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+                HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
                 return -PAL_ERROR_TRYAGAIN;
             case EINTR:
                 return -PAL_ERROR_INTERRUPTED;
@@ -546,9 +546,9 @@ static int64_t proc_write (PAL_HANDLE handle, uint64_t offset, uint64_t count,
 
     assert(!IS_ERR(bytes));
     if ((size_t)bytes == count)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(1);
+        HANDLE_HDR(handle)->flags |= WRITABLE(1);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -627,7 +627,7 @@ static int proc_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
     attr->nonblocking  = handle->process.nonblocking;
     attr->disconnected = HANDLE_HDR(handle)->flags & (ERROR(0)|ERROR(1));
     attr->readable     = !!val;
-    attr->writeable    = HANDLE_HDR(handle)->flags & WRITEABLE(1);
+    attr->writable     = HANDLE_HDR(handle)->flags & WRITABLE(1);
     attr->runnable     = PAL_FALSE;
     attr->pending_size = val;
 

Pal/src/host/Linux/db_sockets.c

@@ -648,9 +648,9 @@ static int64_t tcp_write (PAL_HANDLE handle, uint64_t offset, size_t len,
     int64_t bytes = INLINE_SYSCALL(sendmsg, 3, handle->sock.fd, &hdr, MSG_NOSIGNAL);
 
     if (!IS_ERR(bytes) && (size_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(0);
+        HANDLE_HDR(handle)->flags |= WRITABLE(0);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
 
     if (IS_ERR(bytes))
         bytes = unix_to_pal_error(ERRNO(bytes));
@@ -917,9 +917,9 @@ static int64_t udp_send (PAL_HANDLE handle, uint64_t offset, size_t len,
     int64_t bytes = INLINE_SYSCALL(sendmsg, 3, handle->sock.fd, &hdr, MSG_NOSIGNAL);
 
     if (!IS_ERR(bytes) && (size_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(0);
+        HANDLE_HDR(handle)->flags |= WRITABLE(0);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
 
     if (IS_ERR(bytes))
         bytes = unix_to_pal_error(ERRNO(bytes));
@@ -970,9 +970,9 @@ static int64_t udp_sendbyaddr (PAL_HANDLE handle, uint64_t offset, size_t len,
     int64_t bytes = INLINE_SYSCALL(sendmsg, 3, handle->sock.fd, &hdr, MSG_NOSIGNAL);
 
     if (!IS_ERR(bytes) && (size_t)bytes == len)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(0);
+        HANDLE_HDR(handle)->flags |= WRITABLE(0);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(0);
 
     if (IS_ERR(bytes))
         bytes = unix_to_pal_error(ERRNO(bytes));
@@ -1048,7 +1048,7 @@ static int socket_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR  * attr)
     attr->handle_type           = HANDLE_HDR(handle)->type;
     attr->disconnected          = HANDLE_HDR(handle)->flags & ERROR(0);
     attr->nonblocking           = handle->sock.nonblocking;
-    attr->writeable             = HANDLE_HDR(handle)->flags & WRITEABLE(0);
+    attr->writable              = HANDLE_HDR(handle)->flags & WRITABLE(0);
     attr->pending_size          = 0; /* fill in later */
     attr->socket.linger         = handle->sock.linger;
     attr->socket.receivebuf     = handle->sock.receivebuf;
@@ -1351,7 +1351,7 @@ PAL_HANDLE _DkBroadcastStreamOpen (void)
 
     PAL_HANDLE hdl = malloc(HANDLE_SIZE(mcast));
     SET_HANDLE_TYPE(hdl, mcast);
-    HANDLE_HDR(hdl)->flags |= WFD(1)|WRITEABLE(1);
+    HANDLE_HDR(hdl)->flags |= WFD(1)|WRITABLE(1);
     hdl->mcast.srv = srv;
     hdl->mcast.cli = cli;
     hdl->mcast.port = (PAL_NUM) pal_sec.mcast_port;
@@ -1397,7 +1397,7 @@ static int64_t mcast_send (PAL_HANDLE handle, uint64_t offset, uint64_t size,
             case EPIPE:
                 return -PAL_ERROR_CONNFAILED;
             case EAGAIN:
-                HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+                HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
                 /* fallthrough */
             default:
                 return unix_to_pal_error(ERRNO(bytes));
@@ -1405,9 +1405,9 @@ static int64_t mcast_send (PAL_HANDLE handle, uint64_t offset, uint64_t size,
 
     assert(!IS_ERR(bytes));
     if ((size_t)bytes == size)
-        HANDLE_HDR(handle)->flags |= WRITEABLE(1);
+        HANDLE_HDR(handle)->flags |= WRITABLE(1);
     else
-        HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
+        HANDLE_HDR(handle)->flags &= ~WRITABLE(1);
 
     return bytes;
 }
@@ -1456,7 +1456,7 @@ static int mcast_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
     attr->disconnected = HANDLE_HDR(handle)->flags & (ERROR(0)|ERROR(1));
     attr->nonblocking  = handle->mcast.nonblocking;
     attr->readable     = !!val;
-    attr->writeable    = HANDLE_HDR(handle)->flags & WRITEABLE(1);
+    attr->writable     = HANDLE_HDR(handle)->flags & WRITABLE(1);
     attr->runnable     = PAL_FALSE;
     attr->pending_size = val;
 

Pal/src/host/Linux/pal_host.h

@@ -182,7 +182,7 @@ typedef struct pal_handle
 
 #define RFD(n)          (00001 << (n))
 #define WFD(n)          (00010 << (n))
-#define WRITEABLE(n)    (00100 << (n))
+#define WRITABLE(n)     (00100 << (n))
 #define ERROR(n)        (01000 << (n))
 #define HAS_FDS         00077
 

Pal/src/pal.h

@@ -350,7 +350,7 @@ typedef struct {
     PAL_IDX handle_type;
     PAL_BOL disconnected;
     PAL_BOL nonblocking;
-    PAL_BOL readable, writeable, runnable;
+    PAL_BOL readable, writable, runnable;
     PAL_FLG share_flags;
     PAL_NUM pending_size;
     union {