Improve wordsplit

* src/wordsplit.c: Implement default assignment, word
expansion in variable defaults, distinction between
${variable:-word} and ${variable-word}.
* doc/wordsplit.3: New file.
* src/wordsplit.h (wordsplit)<ws_envbuf,ws_envidx>
<ws_envsiz>: New members.
(WRDSF_ARGV): Remove.
(WRDSF_OPTIONS): New flag.
(WRDSO_ARGV): New option bit.
* tests/wordsplit.at: Add new tests.
* tests/wsp.c: Set WRDSF_OPTIONS flag if one of the options is requested.

2 files changed, 310 insertions, 94 deletions

diff --git a/src/wordsplit.c b/src/wordsplit.c
index 4a69725..c726239 100644
--- a/src/wordsplit.c
+++ b/src/wordsplit.c
@@ -114,11 +114,30 @@ _wsplt_subsplit (struct wordsplit *wsp, struct wordsplit *wss,
   wss->ws_error = wsp->ws_error;
   wss->ws_alloc_die = wsp->ws_alloc_die;
 
+  if (!(flags & WRDSF_NOVAR))
+    {
+      wss->ws_env = wsp->ws_env;
+      wss->ws_getvar = wsp->ws_getvar;
+      flags |= wsp->ws_flags & (WRDSF_ENV | WRDSF_ENV_KV | WRDSF_GETVAR);
+    }
+  if (!(flags & WRDSF_NOCMD))
+    {
+      wss->ws_command = wsp->ws_command;
+    }
+
+  if ((flags & (WRDSF_NOVAR|WRDSF_NOCMD)) != (WRDSF_NOVAR|WRDSF_NOCMD))
+    {
+      wss->ws_closure = wsp->ws_closure;
+      flags |= wsp->ws_flags & WRDSF_CLOSURE;
+    }
+
+  wss->ws_options = wsp->ws_options;
+  
   flags |= WRDSF_DELIM
          | WRDSF_ALLOC_DIE
          | WRDSF_ERROR
          | WRDSF_DEBUG
-         | (wsp->ws_flags & (WRDSF_SHOWDBG | WRDSF_SHOWERR));
+         | (wsp->ws_flags & (WRDSF_SHOWDBG | WRDSF_SHOWERR | WRDSF_OPTIONS));
             
   return wordsplit_run (str, len, wss, flags, wsp->ws_lvl + 1);
 }
@@ -168,12 +187,11 @@ wordsplit_init (struct wordsplit *wsp, const char *input, size_t len,
   if (!(wsp->ws_flags & WRDSF_ERROR))
     wsp->ws_error = _wsplt_error;
 
-  if (!(wsp->ws_flags & WRDSF_NOVAR)
-      && !(wsp->ws_flags & (WRDSF_ENV | WRDSF_GETVAR)))
+  if (!(wsp->ws_flags & WRDSF_NOVAR))
     {
-      _wsplt_seterr (wsp, WRDSE_USAGE);
-      errno = EINVAL;
-      return wsp->ws_errno;
+      /* These will be initialized on first variable assignment */
+      wsp->ws_envidx = wsp->ws_envsiz = 0;
+      wsp->ws_envbuf = NULL;
     }
 
   if (!(wsp->ws_flags & WRDSF_NOCMD))
@@ -214,6 +232,9 @@ wordsplit_init (struct wordsplit *wsp, const char *input, size_t len,
   if (!(wsp->ws_flags & WRDSF_CLOSURE))
     wsp->ws_closure = NULL;
 
+  if (!(wsp->ws_flags & WRDSF_OPTIONS))
+    wsp->ws_options = 0;
+  
   wsp->ws_endp = 0;
 
   wordsplit_init0 (wsp);
@@ -717,13 +738,14 @@ find_closing_paren (const char *str, size_t i, size_t len, size_t *poff,
   return 1;
 }
 
-static const char *
-wordsplit_find_env (struct wordsplit *wsp, const char *name, size_t len)
+static int
+wordsplit_find_env (struct wordsplit *wsp, const char *name, size_t len,
+                    char const **ret)
 {
   size_t i;
 
   if (!(wsp->ws_flags & WRDSF_ENV))
-    return NULL;
+    return WRDSE_UNDEF;
 
   if (wsp->ws_flags & WRDSF_ENV_KV)
     {
@@ -732,14 +754,17 @@ wordsplit_find_env (struct wordsplit *wsp, const char *name, size_t len)
         {
           size_t elen = strlen (wsp->ws_env[i]);
           if (elen == len && memcmp (wsp->ws_env[i], name, elen) == 0)
-            return wsp->ws_env[i + 1];
+            {
+              *ret = wsp->ws_env[i + 1];
+              return WRDSE_OK;
+            }
           /* Skip the value.  Break the loop if it is NULL. */
           i++;
           if (wsp->ws_env[i] == NULL)
             break;
         }
     }
-  else
+  else if (wsp->ws_env)
     {
       /* Usual (A=B) environment. */
       for (i = 0; wsp->ws_env[i]; i++)
@@ -751,10 +776,117 @@ wordsplit_find_env (struct wordsplit *wsp, const char *name, size_t len)
             if (name[j] != var[j])
               break;
           if (j == len && var[j] == '=')
-            return var + j + 1;
+            {
+              *ret = var + j + 1;
+              return WRDSE_OK;
+            }
+        }
+    }
+  return WRDSE_UNDEF;
+}
+
+static int
+wsplt_assign_var (struct wordsplit *wsp, const char *name, size_t namelen,
+                  char *value)
+{
+  int n = (wsp->ws_flags & WRDSF_ENV_KV) ? 2 : 1;
+  char *v;
+  
+  if (wsp->ws_envidx + n >= wsp->ws_envsiz)
+    {
+      size_t sz;
+      char **newenv;
+
+      if (!wsp->ws_envbuf)
+        {
+          if (wsp->ws_flags & WRDSF_ENV)
+            {
+              size_t i = 0, j;
+
+              if (wsp->ws_env)
+                {
+                  for (; wsp->ws_env[i]; i++)
+                    ;
+                }
+              
+              sz = i + n + 1;
+
+              newenv = calloc (sz, sizeof(newenv[0]));
+              if (!newenv)
+                return _wsplt_nomem (wsp);
+
+              for (j = 0; j < i; j++)
+                {
+                  newenv[j] = strdup (wsp->ws_env[j]);
+                  if (!newenv[j])
+                    {
+                      for (; j > 1; j--)
+                        free (newenv[j-1]);
+                      free (newenv[j-1]);
+                      return _wsplt_nomem (wsp);
+                    }
+                }
+              newenv[j] = NULL;
+              
+              wsp->ws_envbuf = newenv;
+              wsp->ws_envidx = i;
+              wsp->ws_envsiz = sz;
+              wsp->ws_env = (const char**) wsp->ws_envbuf;
+            }
+          else
+            {
+              newenv = calloc (WORDSPLIT_ENV_INIT, sizeof(newenv[0]));
+              if (!newenv)
+                return _wsplt_nomem (wsp);
+              wsp->ws_envbuf = newenv;
+              wsp->ws_envidx = 0;
+              wsp->ws_envsiz = WORDSPLIT_ENV_INIT;
+              wsp->ws_env = (const char**) wsp->ws_envbuf;
+              wsp->ws_flags |= WRDSF_ENV;
+            }
+        }
+      else
+        {
+          wsp->ws_envsiz *= 2;
+          newenv = realloc (wsp->ws_envbuf,
+                            wsp->ws_envsiz * sizeof (wsp->ws_envbuf[0]));
+          if (!newenv)
+            return _wsplt_nomem (wsp);
+          wsp->ws_envbuf = newenv;
+          wsp->ws_env = (const char**) wsp->ws_envbuf;
         }
     }
-  return NULL;
+  
+  if (wsp->ws_flags & WRDSF_ENV_KV)
+    {
+      /* A key-value pair environment */
+      char *p = malloc (namelen + 1);
+      if (!p)
+        return _wsplt_nomem (wsp);
+      memcpy (p, name, namelen);
+      p[namelen] = 0;
+
+      v = strdup (value);
+      if (!v)
+        {
+          free (p);
+          return _wsplt_nomem (wsp);
+        }
+      wsp->ws_env[wsp->ws_envidx++] = p;
+      wsp->ws_env[wsp->ws_envidx++] = v;
+    }
+  else
+    {
+      v = malloc (namelen + strlen(value) + 2);
+      if (!v)
+        return _wsplt_nomem (wsp);
+      memcpy (v, name, namelen);
+      v[namelen++] = '=';
+      strcpy(v + namelen, value);
+      wsp->ws_env[wsp->ws_envidx++] = v;
+    }
+  wsp->ws_env[wsp->ws_envidx++] = NULL;
+  return WRDSE_OK;