Permissive stream open mode strings.

There is more to this patch than just more permissive
mode strings. Now if a socket can be opened with mode
"l2" for instance, and these options are effectively applied
to the socket-specific "r+b" default, not to "r".

* stream.c (parse_mode): New argument specifying a default
mode. The syntax is relaxed, allowing previously required
elements to be omitted.
(normalize_mode): New argument specifying a default mode.
Format mode is always called now, because an input string
is no longer necessarily a valid fopen string even in cases
when it doesn't specify any extensions.
(open_file, open_fileno, open_tail, open_command,
open_process): Use new normalize_mode argument for defaulting;
normalize_mode no longer defaults to "r".

* stream.h (stdio_mode_init_trivial): Macro removed.
(stdio_mode_init_blank, stdio_mode_init_r,
stdio_mode_init_rpb): New initializer macros.
(parse_mode, normalize_mode): Declarations updated.

* socket.c (sock_accept): In datagram socket case, use new
parse_mode argument for defaulting using stdio_mode_init_rpb,
rather than overriding a missing string with "r+b".
(open_sockfd): Likewise, and use new normalize_mode
argument similarly for defaulting the mode on a stream socket.

* txr.1: Documented mode string permissiveness.

1 files changed, 8 insertions, 9 deletions

diff --git a/socket.c b/socket.c
index 9b78eb52..9684e608 100644
--- a/socket.c
+++ b/socket.c
@@ -766,7 +766,7 @@ failed:
               num(errno), string_utf8(strerror(errno)), nao);
 }
 
-static val sock_accept(val sock, val mode_str_in, val timeout_in)
+static val sock_accept(val sock, val mode_str, val timeout_in)
 {
   val sfd = stream_fd(sock);
   int fd = sfd ? c_num(sfd) : -1;
@@ -850,7 +850,7 @@ static val sock_accept(val sock, val mode_str_in, val timeout_in)
 
     {
       int afd = dup(fd);
-      val mode_str = default_arg(mode_str_in, lit("r+b"));
+      struct stdio_mode mode_rpb = stdio_mode_init_rpb;
       mem_t *shrink = chk_realloc(dgram, nbytes);
 
       if (shrink)
@@ -864,7 +864,7 @@ static val sock_accept(val sock, val mode_str_in, val timeout_in)
       }
       return make_dgram_sock_stream(afd, family, peer, dgram, nbytes,
                                     coerce(struct sockaddr *, &sa), salen,
-                                    parse_mode(mode_str), d);
+                                    parse_mode(mode_str, mode_rpb), d);
     }
   } else {
     int afd = -1;
@@ -888,7 +888,7 @@ static val sock_accept(val sock, val mode_str_in, val timeout_in)
                 family, nao);
 
     {
-      val stream = open_sockfd(num(afd), family, num_fast(SOCK_STREAM), mode_str_in);
+      val stream = open_sockfd(num(afd), family, num_fast(SOCK_STREAM), mode_str);
       sock_set_peer(stream, peer);
       return stream;
     }
@@ -944,16 +944,15 @@ static val sock_recv_timeout(val sock, val usec)
 #endif
 
 
-val open_sockfd(val fd, val family, val type, val mode_str_in)
+val open_sockfd(val fd, val family, val type, val mode_str)
 {
-  struct stdio_mode m;
-  val mode_str = default_arg(mode_str_in, lit("r+b"));
+  struct stdio_mode m, m_rpb = stdio_mode_init_rpb;
 
   if (type == num_fast(SOCK_DGRAM)) {
     return make_dgram_sock_stream(c_num(fd), family, nil, 0, 0, 0, 0,
-                                  parse_mode(mode_str), 0);
+                                  parse_mode(mode_str, m_rpb), 0);
   } else {
-    FILE *f = (errno = 0, w_fdopen(c_num(fd), c_str(normalize_mode(&m, mode_str))));
+    FILE *f = (errno = 0, w_fdopen(c_num(fd), c_str(normalize_mode(&m, mode_str, m_rpb))));
 
     if (!f) {
       close(c_num(fd));