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.

4 files changed, 66 insertions, 43 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));
diff --git a/stream.c b/stream.c
index 9029ddc1..713671cb 100644
--- a/stream.c
+++ b/stream.c
@@ -1148,9 +1148,9 @@ static struct strm_ops pipe_ops =
                 stdio_clear_error,
                 stdio_get_fd);
 
-struct stdio_mode parse_mode(val mode_str)
+struct stdio_mode parse_mode(val mode_str, struct stdio_mode m_dfl)
 {
-  struct stdio_mode m = stdio_mode_init_trivial(0);
+  struct stdio_mode m = stdio_mode_init_blank;
   const wchar_t *ms = c_str(mode_str);
 
   switch (*ms) {
@@ -1169,8 +1169,7 @@ struct stdio_mode parse_mode(val mode_str)
     m.append = 1;
     break;
   default:
-    m.malformed = 1;
-    return m;
+    break;
   }
 
   if (*ms == '+') {
@@ -1180,6 +1179,9 @@ struct stdio_mode parse_mode(val mode_str)
     m.read = 1;
   }
 
+  if (!m.read && !m.write)
+    m = m_dfl;
+
   for (; *ms; ms++) {
     switch (*ms) {
     case 'b':
@@ -1247,24 +1249,16 @@ static val format_mode(const struct stdio_mode m)
   return string(buf);
 }
 
-val normalize_mode(struct stdio_mode *m, val mode_str)
+val normalize_mode(struct stdio_mode *m, val mode_str_in, struct stdio_mode m_dfl)
 {
-  struct stdio_mode blank = stdio_mode_init_trivial(1);
+  val mode_str = default_arg(mode_str_in, lit(""));
 
-  if (null_or_missing_p(mode_str)) {
-    *m = blank;
-    return lit("r");
-  } else {
-    *m = parse_mode(mode_str);
+  *m = parse_mode(mode_str, m_dfl);
 
-    if (m->malformed)
-      uw_throwf(file_error_s, lit("invalid file open mode ~a"), mode_str, nao);
+  if (m->malformed)
+    uw_throwf(file_error_s, lit("invalid file open mode ~a"), mode_str, nao);
 
-    if (!m->interactive)
-      return mode_str;
-
-    return format_mode(*m);
-  }
+  return format_mode(*m);
 }
 
 val set_mode_props(const struct stdio_mode m, val stream)
@@ -3358,8 +3352,8 @@ val open_directory(val path)
 
 val open_file(val path, val mode_str)
 {
-  struct stdio_mode m;
-  FILE *f = w_fopen(c_str(path), c_str(normalize_mode(&m, mode_str)));
+  struct stdio_mode m, m_r = stdio_mode_init_r;
+  FILE *f = w_fopen(c_str(path), c_str(normalize_mode(&m, mode_str, m_r)));
 
   if (!f)
     uw_throwf(file_error_s, lit("error opening ~a: ~d/~s"),
@@ -3370,8 +3364,8 @@ val open_file(val path, val mode_str)
 
 val open_fileno(val fd, val mode_str)
 {
-  struct stdio_mode m;
-  FILE *f = (errno = 0, w_fdopen(c_num(fd), c_str(normalize_mode(&m, mode_str))));
+  struct stdio_mode m, m_r = stdio_mode_init_r;
+  FILE *f = (errno = 0, w_fdopen(c_num(fd), c_str(normalize_mode(&m, mode_str, m_r))));
 
   if (!f) {
     close(c_num(fd));
@@ -3386,8 +3380,8 @@ val open_fileno(val fd, val mode_str)
 
 val open_tail(val path, val mode_str, val seek_end_p)
 {
-  struct stdio_mode m;
-  val mode = normalize_mode(&m, mode_str);
+  struct stdio_mode m, m_r = stdio_mode_init_r;
+  val mode = normalize_mode(&m, mode_str, m_r);
   FILE *f = w_fopen(c_str(path), c_str(mode));
   struct stdio_handle *h;
   val stream;
@@ -3408,8 +3402,8 @@ val open_tail(val path, val mode_str, val seek_end_p)
 
 val open_command(val path, val mode_str)
 {
-  struct stdio_mode m;
-  FILE *f = w_popen(c_str(path), c_str(normalize_mode(&m, mode_str)));
+  struct stdio_mode m, m_r = stdio_mode_init_r;
+  FILE *f = w_popen(c_str(path), c_str(normalize_mode(&m, mode_str, m_r)));
 
   if (!f)
     uw_throwf(file_error_s, lit("error opening pipe ~a: ~d/~s"),
@@ -3421,8 +3415,8 @@ val open_command(val path, val mode_str)
 #if HAVE_FORK_STUFF
 val open_process(val name, val mode_str, val args)
 {
-  struct stdio_mode m;
-  val mode = normalize_mode(&m, mode_str);
+  struct stdio_mode m, m_r = stdio_mode_init_r;
+  val mode = normalize_mode(&m, mode_str, m_r);
   int input = m.read != 0;
   int fd[2];
   pid_t pid;
diff --git a/stream.h b/stream.h
index abb0bec0..c1699c05 100644
--- a/stream.h
+++ b/stream.h
@@ -95,7 +95,9 @@ struct stdio_mode {
   int buforder : 5;
 };
 
-#define stdio_mode_init_trivial(read) { 0, read, 0, 0, 0, 0, 0, 0, 0, -1 }
+#define stdio_mode_init_blank { 0, 0, 0, 0, 0, 0, 0, 0, 0, -1 }
+#define stdio_mode_init_r     { 0, 1, 0, 0, 0, 0, 0, 0, 0, -1 }
+#define stdio_mode_init_rpb   { 0, 1, 1, 0, 0, 1, 0, 0, 0, -1 }
 
 #define std_input (deref(lookup_var_l(nil, stdin_s)))
 #define std_output (deref(lookup_var_l(nil, stdout_s)))
@@ -126,8 +128,8 @@ void fill_stream_ops(struct strm_ops *ops);
 void stream_print_op(val stream, val out, val pretty);
 void stream_mark_op(val stream);
 void stream_destroy_op(val stream);
-struct stdio_mode parse_mode(val mode_str);
-val normalize_mode(struct stdio_mode *m, val mode_str);
+struct stdio_mode parse_mode(val mode_str, struct stdio_mode m_dfl);
+val normalize_mode(struct stdio_mode *m, val mode_str, struct stdio_mode m_dfl);
 val set_mode_props(const struct stdio_mode m, val stream);
 val generic_get_line(val stream);
 val errno_to_string(val err);
diff --git a/txr.1 b/txr.1
index ff3d6481..8129b2f4 100644
--- a/txr.1
+++ b/txr.1
@@ -34416,7 +34416,7 @@ The
 argument is a string which uses the same
 conventions as the mode argument of the C language
 .code fopen
-function, with some extensions.
+function, with greater permissiveness, and some extensions.
 The mode string determines whether the stream is an input stream
 or output stream. Note that the
 .str b
@@ -34426,9 +34426,13 @@ are invoked on it.
 
 If the
 .meta mode-string
-argument is omitted, mode
+argument is omitted, the behavior is as if mode
 .str r
-is used.
+were specified. This default is not true of all functions which accepts a
+.meta mode-string
+argument: socket-related functions have a
+.str r+b
+default mode.
 
 Additional option letters are supported in
 .meta mode-string
@@ -34482,6 +34486,30 @@ stream uses a default buffer size. It is erroneous for the
 size order digit to be present together with the option
 .strn u .
 
+\*(TX mode strings are more permissive than the C
+.code fopen
+mode strings in two regards.
+Firstly, the data direction or disposition letter
+.strn r ,
+.str w
+or
+.str a
+may be omitted. If it is missing, and if the optional
+.str +
+is also missing, then the function-specific default mode applies
+(which is
+.str r
+in the case of
+.codn open-file )
+and any remaining options in apply on top of that default.
+This implies that a completely empty mode string is valid,
+and denotes the default mode.
+Secondly, if the
+.str +
+is present, but not preceded by anything, then defaulting is not
+applied; it is taken as equivalent to
+.strn r+ .
+
 .coNP Function @ open-tail
 .synb
 .mets (open-tail < path >> [ mode-string <> [ seek-to-end-p ]])