(w_addword): Free word if realloc fails and it was allocated here.
[kopensolaris-gnu/glibc.git] / posix / wordexp.c
index 1df552a..8dc0706 100644 (file)
@@ -1,56 +1,65 @@
 /* POSIX.2 wordexp implementation.
-   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1997-2002, 2003, 2005, 2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Tim Waugh <tim@cyberelk.demon.co.uk>.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
-#include <wordexp.h>
+#include <alloca.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+#include <glob.h>
+#include <libintl.h>
+#include <paths.h>
+#include <pwd.h>
 #include <signal.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include <pwd.h>
-#include <sys/types.h>
 #include <string.h>
-#include <glob.h>
-#include <ctype.h>
+#include <sys/param.h>
+#include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <paths.h>
-#include <errno.h>
-#include <sys/param.h>
-#include <stdio.h>
-#include <fnmatch.h>
+#ifdef USE_IN_LIBIO
+# include <wchar.h>
+#endif
+#include <wordexp.h>
 
+#include <bits/libc-lock.h>
 #include <stdio-common/_itoa.h>
 
 /* Undefine the following line for the production version.  */
 /* #define NDEBUG 1 */
 #include <assert.h>
 
+/* Get some device information.  */
+#include <device-nrs.h>
+
 /*
  * This is a recursive-descent-style word expansion routine.
  */
 
 /* These variables are defined and initialized in the startup code.  */
-extern int __libc_argc;
-extern char **__libc_argv;
+extern int __libc_argc attribute_hidden;
+extern char **__libc_argv attribute_hidden;
 
 /* Some forward declarations */
 static int parse_dollars (char **word, size_t *word_length, size_t *max_length,
@@ -74,19 +83,26 @@ static int eval_expr (char *expr, long int *result) internal_function;
 
 #define W_CHUNK        (100)
 
+/* Result of w_newword will be ignored if it's the last word. */
 static inline char *
+w_newword (size_t *actlen, size_t *maxlen)
+{
+  *actlen = *maxlen = 0;
+  return NULL;
+}
+
+static char *
 w_addchar (char *buffer, size_t *actlen, size_t *maxlen, char ch)
      /* (lengths exclude trailing zero) */
 {
-  /* Add a character to the buffer, allocating room for it if needed.
-   */
+  /* Add a character to the buffer, allocating room for it if needed.  */
 
   if (*actlen == *maxlen)
     {
       char *old_buffer = buffer;
       assert (buffer == NULL || *maxlen != 0);
       *maxlen += W_CHUNK;
-      buffer = realloc (buffer, 1 + *maxlen);
+      buffer = (char *) realloc (buffer, 1 + *maxlen);
 
       if (buffer == NULL)
        free (old_buffer);
@@ -128,7 +144,6 @@ w_addmem (char *buffer, size_t *actlen, size_t *maxlen, const char *str,
   return buffer;
 }
 
-
 static char *
 internal_function
 w_addstr (char *buffer, size_t *actlen, size_t *maxlen, const char *str)
@@ -151,17 +166,33 @@ w_addword (wordexp_t *pwordexp, char *word)
   /* Add a word to the wordlist */
   size_t num_p;
   char **new_wordv;
+  bool allocated = false;
+
+  /* Internally, NULL acts like "".  Convert NULLs to "" before
+   * the caller sees them.
+   */
+  if (word == NULL)
+    {
+      word = __strdup ("");
+      if (word == NULL)
+       goto no_space;
+      allocated = true;
+    }
 
   num_p = 2 + pwordexp->we_wordc + pwordexp->we_offs;
   new_wordv = realloc (pwordexp->we_wordv, sizeof (char *) * num_p);
   if (new_wordv != NULL)
     {
       pwordexp->we_wordv = new_wordv;
-      pwordexp->we_wordv[pwordexp->we_wordc++] = word;
-      pwordexp->we_wordv[pwordexp->we_wordc] = NULL;
+      pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc++] = word;
+      pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc] = NULL;
       return 0;
     }
 
+  if (allocated)
+    free (word);
+
+no_space:
   return WRDE_NOSPACE;
 }
 
@@ -281,35 +312,48 @@ parse_tilde (char **word, size_t *word_length, size_t *max_length,
       uid_t uid;
       struct passwd pwd, *tpwd;
       int buflen = 1000;
-      char* buffer = __alloca (buflen);
+      char* home;
+      char* buffer;
       int result;
 
-      uid = getuid ();
-
-      while ((result = __getpwuid_r (uid, &pwd, buffer, buflen, &tpwd)) != 0
-            && errno == ERANGE)
-       {
-         buflen += 1000;
-         buffer = __alloca (buflen);
-       }
+      /* POSIX.2 says ~ expands to $HOME and if HOME is unset the
+        results are unspecified.  We do a lookup on the uid if
+        HOME is unset. */
 
-      if (result == 0 && pwd.pw_dir != NULL)
+      home = getenv ("HOME");
+      if (home != NULL)
        {
-         *word = w_addstr (*word, word_length, max_length, pwd.pw_dir);
+         *word = w_addstr (*word, word_length, max_length, home);
          if (*word == NULL)
            return WRDE_NOSPACE;
        }
       else
        {
-         *word = w_addchar (*word, word_length, max_length, '~');
-         if (*word == NULL)
-           return WRDE_NOSPACE;
+         uid = __getuid ();
+         buffer = __alloca (buflen);
+
+         while ((result = __getpwuid_r (uid, &pwd, buffer, buflen, &tpwd)) != 0
+                && errno == ERANGE)
+           buffer = extend_alloca (buffer, buflen, buflen + 1000);
+
+         if (result == 0 && tpwd != NULL && pwd.pw_dir != NULL)
+           {
+             *word = w_addstr (*word, word_length, max_length, pwd.pw_dir);
+             if (*word == NULL)
+               return WRDE_NOSPACE;
+           }
+         else
+           {
+             *word = w_addchar (*word, word_length, max_length, '~');
+             if (*word == NULL)
+               return WRDE_NOSPACE;
+           }
        }
     }
   else
     {
       /* Look up user name in database to get home directory */
-      char *user = __strndup (&words[1 + *offset], i - *offset);
+      char *user = strndupa (&words[1 + *offset], i - (1 + *offset));
       struct passwd pwd, *tpwd;
       int buflen = 1000;
       char* buffer = __alloca (buflen);
@@ -317,12 +361,9 @@ parse_tilde (char **word, size_t *word_length, size_t *max_length,
 
       while ((result = __getpwnam_r (user, &pwd, buffer, buflen, &tpwd)) != 0
             && errno == ERANGE)
-       {
-         buflen += 1000;
-         buffer = __alloca (buflen);
-       }
+       buffer = extend_alloca (buffer, buflen, buflen + 1000);
 
-      if (result == 0 && pwd.pw_dir)
+      if (result == 0 && tpwd != NULL && pwd.pw_dir)
        *word = w_addstr (*word, word_length, max_length, pwd.pw_dir);
       else
        {
@@ -337,6 +378,64 @@ parse_tilde (char **word, size_t *word_length, size_t *max_length,
   return *word ? 0 : WRDE_NOSPACE;
 }
 
+
+static int
+internal_function
+do_parse_glob (const char *glob_word, char **word, size_t *word_length,
+              size_t *max_length, wordexp_t *pwordexp, const char *ifs,
+              const char *ifs_white)
+{
+  int error;
+  unsigned int match;
+  glob_t globbuf;
+
+  error = glob (glob_word, GLOB_NOCHECK, NULL, &globbuf);
+
+  if (error != 0)
+    {
+      /* We can only run into memory problems.  */
+      assert (error == GLOB_NOSPACE);
+      return WRDE_NOSPACE;
+    }
+
+  if (ifs && !*ifs)
+    {
+      /* No field splitting allowed. */
+      assert (globbuf.gl_pathv[0] != NULL);
+      *word = w_addstr (*word, word_length, max_length, globbuf.gl_pathv[0]);
+      for (match = 1; match < globbuf.gl_pathc && *word != NULL; ++match)
+       {
+         *word = w_addchar (*word, word_length, max_length, ' ');
+         if (*word != NULL)
+           *word = w_addstr (*word, word_length, max_length,
+                             globbuf.gl_pathv[match]);
+       }
+
+      globfree (&globbuf);
+      return *word ? 0 : WRDE_NOSPACE;
+    }
+
+  assert (ifs == NULL || *ifs != '\0');
+  if (*word != NULL)
+    {
+      free (*word);
+      *word = w_newword (word_length, max_length);
+    }
+
+  for (match = 0; match < globbuf.gl_pathc; ++match)
+    {
+      char *matching_word = __strdup (globbuf.gl_pathv[match]);
+      if (matching_word == NULL || w_addword (pwordexp, matching_word))
+       {
+         globfree (&globbuf);
+         return WRDE_NOSPACE;
+       }
+    }
+
+  globfree (&globbuf);
+  return 0;
+}
+
 static int
 internal_function
 parse_glob (char **word, size_t *word_length, size_t *max_length,
@@ -344,13 +443,15 @@ parse_glob (char **word, size_t *word_length, size_t *max_length,
            wordexp_t *pwordexp, const char *ifs, const char *ifs_white)
 {
   /* We are poised just after a '*', a '[' or a '?'. */
-  int error;
-  glob_t globbuf;
-  int match;
-  char *matching_word;
+  int error = WRDE_NOSPACE;
   int quoted = 0; /* 1 if singly-quoted, 2 if doubly */
+  size_t i;
+  wordexp_t glob_list; /* List of words to glob */
 
-  for (; words[*offset]; (*offset)++)
+  glob_list.we_wordc = 0;
+  glob_list.we_wordv = NULL;
+  glob_list.we_offs = 0;
+  for (; words[*offset] != '\0'; ++*offset)
     {
       if ((ifs && strchr (ifs, words[*offset])) ||
          (!ifs && strchr (" \t\n", words[*offset])))
@@ -359,6 +460,7 @@ parse_glob (char **word, size_t *word_length, size_t *max_length,
 
       /* Sort out quoting */
       if (words[*offset] == '\'')
+       {
          if (quoted == 0)
            {
              quoted = 1;
@@ -369,118 +471,66 @@ parse_glob (char **word, size_t *word_length, size_t *max_length,
              quoted = 0;
              continue;
            }
+       }
       else if (words[*offset] == '"')
-       if (quoted == 0)
-         {
-           quoted = 2;
-           continue;
-         }
-       else if (quoted == 2)
-         {
-           quoted = 0;
-           continue;
-         }
+       {
+         if (quoted == 0)
+           {
+             quoted = 2;
+             continue;
+           }
+         else if (quoted == 2)
+           {
+             quoted = 0;
+             continue;
+           }
+       }
 
       /* Sort out other special characters */
       if (quoted != 1 && words[*offset] == '$')
        {
-         error = parse_dollars (word, word_length, max_length, words, offset,
-                                flags, pwordexp, ifs, ifs_white, quoted == 2);
+         error = parse_dollars (word, word_length, max_length, words,
+                                offset, flags, &glob_list, ifs, ifs_white,
+                                quoted == 2);
          if (error)
-           return error;
+           goto tidy_up;
 
          continue;
        }
       else if (words[*offset] == '\\')
        {
          if (quoted)
-           error = parse_qtd_backslash (word, word_length, max_length, words,
-                                        offset);
+           error = parse_qtd_backslash (word, word_length, max_length,
+                                        words, offset);
          else
-           error = parse_backslash (word, word_length, max_length, words,
-                                    offset);
+           error = parse_backslash (word, word_length, max_length,
+                                    words, offset);
 
          if (error)
-           return error;
+           goto tidy_up;
 
          continue;
        }
 
       *word = w_addchar (*word, word_length, max_length, words[*offset]);
       if (*word == NULL)
-       return WRDE_NOSPACE;
-    }
-
-  error = glob (*word, GLOB_NOCHECK, NULL, &globbuf);
-
-  if (error != 0)
-    {
-      /* We can only run into memory problems.  */
-      assert (error == GLOB_NOSPACE);
-
-      return WRDE_NOSPACE;
-    }
-
-  if (ifs && !*ifs)
-    {
-      /* No field splitting allowed */
-      size_t length = strlen (globbuf.gl_pathv[0]);
-      char *old_word = *word;
-      *word = realloc (*word, length + 1);
-      if (*word == NULL)
-       {
-         free (old_word);
-         goto no_space;
-       }
-
-      memcpy (*word, globbuf.gl_pathv[0], length + 1);
-      *word_length = length;
-
-      for (match = 1; match < globbuf.gl_pathc && *word != NULL; ++match)
-       {
-         *word = w_addchar (*word, word_length, max_length, ' ');
-         if (*word != NULL)
-           *word = w_addstr (*word, word_length, max_length,
-                             globbuf.gl_pathv[match]);
-       }
-
-      /* Re-parse white space on return */
-      globfree (&globbuf);
-      --(*offset);
-      return *word ? 0 : WRDE_NOSPACE;
-    }
-
-  /* here ifs != "" */
-  free (*word);
-  *word = NULL;
-  *word_length = 0;
-
-  matching_word = __strdup (globbuf.gl_pathv[0]);
-  if (matching_word == NULL)
-    goto no_space;
-
-  if (w_addword (pwordexp, matching_word) == WRDE_NOSPACE)
-    goto no_space;
-
-  for (match = 1; match < globbuf.gl_pathc; ++match)
-    {
-      matching_word = __strdup (globbuf.gl_pathv[match]);
-      if (matching_word == NULL)
-       goto no_space;
-
-      if (w_addword (pwordexp, matching_word) == WRDE_NOSPACE)
-       goto no_space;
+       goto tidy_up;
     }
 
-  globfree (&globbuf);
+  /* Don't forget to re-parse the character we stopped at. */
+  --*offset;
 
-  /* Re-parse white space on return */
-  --(*offset);
-  return 0;
+  /* Glob the words */
+  error = w_addword (&glob_list, *word);
+  *word = w_newword (word_length, max_length);
+  for (i = 0; error == 0 && i < glob_list.we_wordc; i++)
+    error = do_parse_glob (glob_list.we_wordv[i], word, word_length,
+                          max_length, pwordexp, ifs, ifs_white);
 
-no_space:
-  globfree (&globbuf);
-  return WRDE_NOSPACE;
+  /* Now tidy up */
+tidy_up:
+  wordfree (&glob_list);
+  return error;
 }
 
 static int
@@ -509,16 +559,13 @@ static int
 internal_function
 eval_expr_val (char **expr, long int *result)
 {
-  int sgn = +1;
   char *digit;
 
   /* Skip white space */
   for (digit = *expr; digit && *digit && isspace (*digit); ++digit);
 
-  switch (*digit)
+  if (*digit == '(')
     {
-    case '(':
-
       /* Scan for closing paren */
       for (++digit; **expr && **expr != ')'; ++(*expr));
 
@@ -532,27 +579,14 @@ eval_expr_val (char **expr, long int *result)
        return WRDE_SYNTAX;
 
       return 0;
-
-    case '+':  /* Positive value */
-      ++digit;
-      break;
-
-    case '-':  /* Negative value */
-      ++digit;
-      sgn = -1;
-      break;
-
-    default:
-      if (!isdigit (*digit))
-       return WRDE_SYNTAX;
     }
 
-  *result = 0;
-  for (; *digit && isdigit (*digit); ++digit)
-    *result = (*result * 10) + (*digit - '0');
+  /* POSIX requires that decimal, octal, and hexadecimal constants are
+     recognized.  Therefore we pass 0 as the third parameter to strtol.  */
+  *result = strtol (digit, expr, 0);
+  if (digit == *expr)
+    return WRDE_SYNTAX;
 
-  *expr = digit;
-  *result *= sgn;
   return 0;
 }
 
@@ -638,10 +672,11 @@ parse_arith (char **word, size_t *word_length, size_t *max_length,
   /* We are poised just after "$((" or "$[" */
   int error;
   int paren_depth = 1;
-  size_t expr_length = 0;
-  size_t expr_maxlen = 0;
-  char *expr = NULL;
+  size_t expr_length;
+  size_t expr_maxlen;
+  char *expr;
 
+  expr = w_newword (&expr_length, &expr_maxlen);
   for (; words[*offset]; ++(*offset))
     {
       switch (words[*offset])
@@ -695,13 +730,19 @@ parse_arith (char **word, size_t *word_length, size_t *max_length,
              long long int convertme;
 
              if (bracket || words[1 + *offset] != ')')
-               return WRDE_SYNTAX;
+               {
+                 free (expr);
+                 return WRDE_SYNTAX;
+               }
 
              ++(*offset);
 
              /* Go - evaluate. */
              if (*expr && eval_expr (expr, &numresult) != 0)
-               return WRDE_SYNTAX;
+               {
+                 free (expr);
+                 return WRDE_SYNTAX;
+               }
 
              if (numresult < 0)
                {
@@ -736,7 +777,10 @@ parse_arith (char **word, size_t *word_length, size_t *max_length,
 
              /* Go - evaluate. */
              if (*expr && eval_expr (expr, &numresult) != 0)
-               return WRDE_SYNTAX;
+               {
+                 free (expr);
+                 return WRDE_SYNTAX;
+               }
 
              result[20] = '\0';
              *word = w_addstr (*word, word_length, max_length,
@@ -769,6 +813,57 @@ parse_arith (char **word, size_t *word_length, size_t *max_length,
   return WRDE_SYNTAX;
 }
 
+/* Function called by child process in exec_comm() */
+static inline void
+internal_function __attribute__ ((always_inline))
+exec_comm_child (char *comm, int *fildes, int showerr, int noexec)
+{
+  const char *args[4] = { _PATH_BSHELL, "-c", comm, NULL };
+
+  /* Execute the command, or just check syntax? */
+  if (noexec)
+    args[1] = "-nc";
+
+  /* Redirect output.  */
+  __dup2 (fildes[1], STDOUT_FILENO);
+  __close (fildes[1]);
+
+  /* Redirect stderr to /dev/null if we have to.  */
+  if (showerr == 0)
+    {
+      struct stat64 st;
+      int fd;
+      __close (2);
+      fd = __open (_PATH_DEVNULL, O_WRONLY);
+      if (fd >= 0 && fd != 2)
+       {
+         __dup2 (fd, STDERR_FILENO);
+         __close (fd);
+       }
+      /* Be paranoid.  Check that we actually opened the /dev/null
+         device.  */
+      if (__builtin_expect (__fxstat64 (_STAT_VER, STDERR_FILENO, &st), 0) != 0
+         || __builtin_expect (S_ISCHR (st.st_mode), 1) == 0
+#if defined DEV_NULL_MAJOR && defined DEV_NULL_MINOR
+         || st.st_rdev != makedev (DEV_NULL_MAJOR, DEV_NULL_MINOR)
+#endif
+         )
+       /* It's not the /dev/null device.  Stop right here.  The
+           problem is: how do we stop?  We use _exit() with an
+           hopefully unusual exit code.  */
+       _exit (90);
+    }
+
+  /* Make sure the subshell doesn't field-split on our behalf. */
+  __unsetenv ("IFS");
+
+  __close (fildes[0]);
+  __execve (_PATH_BSHELL, (char *const *) args, __environ);
+
+  /* Bad.  What now?  */
+  abort ();
+}
+
 /* Function to execute a command and retrieve the results */
 /* pwordexp contains NULL if field-splitting is forbidden */
 static int
@@ -778,81 +873,67 @@ exec_comm (char *comm, char **word, size_t *word_length, size_t *max_length,
           const char *ifs_white)
 {
   int fildes[2];
-  int bufsize = 128;
+#define bufsize 128
   int buflen;
   int i;
-  char *buffer;
+  int status = 0;
+  size_t maxnewlines = 0;
+  char buffer[bufsize];
   pid_t pid;
+  int noexec = 0;
 
   /* Don't fork() unless necessary */
   if (!comm || !*comm)
     return 0;
 
-  if (pipe (fildes))
+  if (__pipe (fildes))
     /* Bad */
     return WRDE_NOSPACE;
 
-  if ((pid = fork ()) < 0)
+ again:
+  if ((pid = __fork ()) < 0)
     {
       /* Bad */
+      if (fildes[0] != -1)
+       __close (fildes[0]);
+      if (fildes[1] != -1)
+       __close (fildes[1]);
       return WRDE_NOSPACE;
     }
 
   if (pid == 0)
-    {
-      /* Child */
-      const char *args[4] = { _PATH_BSHELL, "-c", comm, NULL };
-
-      /* Redirect output.  */
-      dup2 (fildes[1], 1);
-      close (fildes[1]);
-
-      /* Redirect stderr to /dev/null if we have to.  */
-      if ((flags & WRDE_SHOWERR) == 0)
-       {
-         int fd;
-         close (2);
-         fd = open (_PATH_DEVNULL, O_WRONLY);
-         if (fd >= 0 && fd != 2)
-           {
-             dup2 (fd, 2);
-             close (fd);
-           }
-       }
-
-      close (fildes[0]);
-      __execve (_PATH_BSHELL, (char *const *) args, __environ);
-
-      /* Bad.  What now?  */
-      abort ();
-    }
+    exec_comm_child (comm, fildes, noexec ? 0 : flags & WRDE_SHOWERR, noexec);
 
   /* Parent */
 
-  close (fildes[1]);
-  buffer = __alloca (bufsize);
+  /* If we are just testing the syntax, only wait.  */
+  if (noexec)
+    return (TEMP_FAILURE_RETRY (__waitpid (pid, &status, 0)) == pid
+           && status != 0) ? WRDE_SYNTAX : 0;
 
-  if (!pwordexp)
-    { /* Quoted - no field splitting */
+  __close (fildes[1]);
+  fildes[1] = -1;
 
+  if (!pwordexp)
+    /* Quoted - no field splitting */
+    {
       while (1)
        {
-         if ((buflen = read (fildes[0], buffer, bufsize)) < 1)
+         if ((buflen = TEMP_FAILURE_RETRY (__read (fildes[0], buffer,
+                                                   bufsize))) < 1)
            {
-             if (__waitpid (pid, NULL, WNOHANG) == 0)
+             if (TEMP_FAILURE_RETRY (__waitpid (pid, &status, WNOHANG)) == 0)
                continue;
-             if ((buflen = read (fildes[0], buffer, bufsize)) < 1)
+             if ((buflen = TEMP_FAILURE_RETRY (__read (fildes[0], buffer,
+                                                       bufsize))) < 1)
                break;
            }
 
+         maxnewlines += buflen;
+
          *word = w_addmem (*word, word_length, max_length, buffer, buflen);
          if (*word == NULL)
-           {
-             kill (pid, SIGKILL);
-             __waitpid (pid, NULL, 0);
-             close (fildes[0]);
-             return WRDE_NOSPACE;
-           }
+           goto no_space;
        }
     }
   else
@@ -863,15 +944,18 @@ exec_comm (char *comm, char **word, size_t *word_length, size_t *max_length,
        *  0 when searching for first character in a field not IFS white space
        *  1 when copying the text of a field
        *  2 when searching for possible non-whitespace IFS
+       *  3 when searching for non-newline after copying field
        */
 
       while (1)
        {
-         if ((buflen = read (fildes[0], buffer, bufsize)) < 1)
+         if ((buflen = TEMP_FAILURE_RETRY (__read (fildes[0], buffer,
+                                                   bufsize))) < 1)
            {
-             if (__waitpid (pid, NULL, WNOHANG) == 0)
+             if (TEMP_FAILURE_RETRY (__waitpid (pid, &status, WNOHANG)) == 0)
                continue;
-             if ((read (fildes[0], buffer, bufsize)) < 1)
+             if ((buflen = TEMP_FAILURE_RETRY (__read (fildes[0], buffer,
+                                                       bufsize))) < 1)
                break;
            }
 
@@ -901,71 +985,111 @@ exec_comm (char *comm, char **word, size_t *word_length, size_t *max_length,
                    }
                  else
                    {
-                     /* Current character is IFS white space */
-
-                     /* If not copying a field, ignore it */
-                     if (copying != 1)
-                       continue;
+                     if (buffer[i] == '\n')
+                       {
+                         /* Current character is (IFS) newline */
 
-                     /* End of field (search for non-IFS afterwards) */
-                     copying = 2;
-                   }
+                         /* If copying a field, this is the end of it,
+                            but maybe all that's left is trailing newlines.
+                            So start searching for a non-newline. */
+                         if (copying == 1)
+                           copying = 3;
 
-                 /* First IFS white space, or IFS non-whitespace.
-                  * Delimit the field. */
-                 if (!*word)
-                   {
-                     /* This field is null, so make it an empty string */
-                     *word = w_addchar (*word, word_length, max_length, 0);
-                     if (*word == NULL)
+                         continue;
+                       }
+                     else
                        {
-                         kill (pid, SIGKILL);
-                         __waitpid (pid, NULL, 0);
-                         close (fildes[0]);
-                         return WRDE_NOSPACE;
+                         /* Current character is IFS white space, but
+                            not a newline */
+
+                         /* If not either copying a field or searching
+                            for non-newline after a field, ignore it */
+                         if (copying != 1 && copying != 3)
+                           continue;
+
+                         /* End of field (search for non-ws IFS afterwards) */
+                         copying = 2;
                        }
                    }
 
+                 /* First IFS white space (non-newline), or IFS non-whitespace.
+                  * Delimit the field.  Nulls are converted by w_addword. */
                  if (w_addword (pwordexp, *word) == WRDE_NOSPACE)
-                   {
-                     kill (pid, SIGKILL);
-                     __waitpid (pid, NULL, 0);
-                     close (fildes[0]);
-                     return WRDE_NOSPACE;
-                   }
+                   goto no_space;
 
-                 *word = NULL;
-                 *word_length = 0;
-                 *max_length = 0;
+                 *word = w_newword (word_length, max_length);
+
+                 maxnewlines = 0;
                  /* fall back round the loop.. */
                }
              else
                {
                  /* Not IFS character */
+
+                 if (copying == 3)
+                   {
+                     /* Nothing but (IFS) newlines since the last field,
+                        so delimit it here before starting new word */
+                     if (w_addword (pwordexp, *word) == WRDE_NOSPACE)
+                       goto no_space;
+
+                     *word = w_newword (word_length, max_length);
+                   }
+
                  copying = 1;
+
+                 if (buffer[i] == '\n') /* happens if newline not in IFS */
+                   maxnewlines++;
+                 else
+                   maxnewlines = 0;
+
                  *word = w_addchar (*word, word_length, max_length,
                                     buffer[i]);
                  if (*word == NULL)
-                   {
-                     kill (pid, SIGKILL);
-                     __waitpid (pid, NULL, 0);
-                     close (fildes[0]);
-                     return WRDE_NOSPACE;
-                   }
+                   goto no_space;
                }
            }
        }
     }
 
-  /* Bash chops off trailing newlines, which seems sensible.  */
-  while (*word_length > 0 && (*word)[*word_length - 1] == '\n')
-    (*word)[--*word_length] = '\0';
+  /* Chop off trailing newlines (required by POSIX.2)  */
+  /* Ensure we don't go back further than the beginning of the
+     substitution (i.e. remove maxnewlines bytes at most) */
+  while (maxnewlines-- != 0 &&
+         *word_length > 0 && (*word)[*word_length - 1] == '\n')
+    {
+      (*word)[--*word_length] = '\0';
+
+      /* If the last word was entirely newlines, turn it into a new word
+       * which can be ignored if there's nothing following it. */
+      if (*word_length == 0)
+       {
+         free (*word);
+         *word = w_newword (word_length, max_length);
+         break;
+       }
+    }
+
+  __close (fildes[0]);
+  fildes[0] = -1;
+
+  /* Check for syntax error (re-execute but with "-n" flag) */
+  if (buflen < 1 && status != 0)
+    {
+      noexec = 1;
+      goto again;
+    }
 
-  close (fildes[0]);
   return 0;
-}
 
-static int
+no_space:
+  __kill (pid, SIGKILL);
+  TEMP_FAILURE_RETRY (__waitpid (pid, NULL, 0));
+  __close (fildes[0]);
+  return WRDE_NOSPACE;
+}
+
+static int
 internal_function
 parse_comm (char **word, size_t *word_length, size_t *max_length,
            const char *words, size_t *offset, int flags, wordexp_t *pwordexp,
@@ -974,10 +1098,10 @@ parse_comm (char **word, size_t *word_length, size_t *max_length,
   /* We are poised just after "$(" */
   int paren_depth = 1;
   int error = 0;
-  size_t comm_length = 0;
-  size_t comm_maxlen = 0;
-  char *comm = NULL;
   int quoted = 0; /* 1 for singly-quoted, 2 for doubly-quoted */
+  size_t comm_length;
+  size_t comm_maxlen;
+  char *comm = w_newword (&comm_length, &comm_maxlen);
 
   for (; words[*offset]; ++(*offset))
     {
@@ -1005,8 +1129,25 @@ parse_comm (char **word, size_t *word_length, size_t *max_length,
              /* Go -- give script to the shell */
              if (comm)
                {
+#ifdef __libc_ptf_call
+                 /* We do not want the exec_comm call to be cut short
+                    by a thread cancellation since cleanup is very
+                    ugly.  Therefore disable cancellation for
+                    now.  */
+                 // XXX Ideally we do want the thread being cancelable.
+                 // XXX If demand is there we'll change it.
+                 int state = PTHREAD_CANCEL_ENABLE;
+                 __libc_ptf_call (pthread_setcancelstate,
+                                  (PTHREAD_CANCEL_DISABLE, &state), 0);
+#endif
+
                  error = exec_comm (comm, word, word_length, max_length,
                                     flags, pwordexp, ifs, ifs_white);
+
+#ifdef __libc_ptf_call
+                 __libc_ptf_call (pthread_setcancelstate, (state, NULL), 0);
+#endif
+
                  free (comm);
                }
 
@@ -1052,13 +1193,13 @@ parse_param (char **word, size_t *word_length, size_t *max_length,
     ACT_NONNULL_SUBST = '+',
     ACT_NULL_ASSIGN = '='
   };
-  size_t env_length = 0;
-  size_t env_maxlen = 0;
-  size_t pat_length = 0;
-  size_t pat_maxlen = 0;
+  size_t env_length;
+  size_t env_maxlen;
+  size_t pat_length;
+  size_t pat_maxlen;
   size_t start = *offset;
-  char *env = NULL;
-  char *pattern = NULL;
+  char *env;
+  char *pattern;
   char *value = NULL;
   enum action action = ACT_NONE;
   int depth = 0;
@@ -1067,332 +1208,452 @@ parse_param (char **word, size_t *word_length, size_t *max_length,
   int free_value = 0;
   int pattern_is_quoted = 0; /* 1 for singly-quoted, 2 for doubly-quoted */
   int error;
+  int special = 0;
+  char buffer[21];
   int brace = words[*offset] == '{';
 
+  env = w_newword (&env_length, &env_maxlen);
+  pattern = w_newword (&pat_length, &pat_maxlen);
+
   if (brace)
     ++*offset;
 
-  for (; words[*offset]; ++(*offset))
+  /* First collect the parameter name. */
+
+  if (words[*offset] == '#')
     {
-      int special;
+      seen_hash = 1;
+      if (!brace)
+       goto envsubst;
+      ++*offset;
+    }
 
-      if (action != ACT_NONE)
+  if (isalpha (words[*offset]) || words[*offset] == '_')
+    {
+      /* Normal parameter name. */
+      do
        {
-         switch (words[*offset])
-           {
-           case '{':
-             if (!pattern_is_quoted)
-               ++depth;
-             break;
-
-           case '}':
-             if (!pattern_is_quoted)
-               {
-                 if (depth == 0)
-                   goto envsubst;
-                 --depth;
-               }
-             break;
-
-           case '\\':
-             if (!pattern_is_quoted && words[++*offset] == '\0')
-               goto syntax;
-             break;
-
-           case '\'':
-             if (pattern_is_quoted == 0)
-               pattern_is_quoted = 1;
-             else if (pattern_is_quoted == 1)
-               pattern_is_quoted = 0;
-
-             break;
-
-           case '"':
-             if (pattern_is_quoted == 0)
-               pattern_is_quoted = 2;
-             else if (pattern_is_quoted == 2)
-               pattern_is_quoted = 0;
-
-             break;
-           }
-
-         pattern = w_addchar (pattern, &pat_length, &pat_maxlen,
-                              words[*offset]);
-         if (pattern == NULL)
+         env = w_addchar (env, &env_length, &env_maxlen,
+                          words[*offset]);
+         if (env == NULL)
            goto no_space;
-
-         continue;
        }
+      while (isalnum (words[++*offset]) || words[*offset] == '_');
+    }
+  else if (isdigit (words[*offset]))
+    {
+      /* Numeric parameter name. */
+      special = 1;
+      do
+       {
+         env = w_addchar (env, &env_length, &env_maxlen,
+                          words[*offset]);
+         if (env == NULL)
+           goto no_space;
+         if (!brace)
+           goto envsubst;
+       }
+      while (isdigit(words[++*offset]));
+    }
+  else if (strchr ("*@$", words[*offset]) != NULL)
+    {
+      /* Special parameter. */
+      special = 1;
+      env = w_addchar (env, &env_length, &env_maxlen,
+                      words[*offset]);
+      if (env == NULL)
+       goto no_space;
+      ++*offset;
+    }
+  else
+    {
+      if (brace)
+       goto syntax;
+    }
 
+  if (brace)
+    {
+      /* Check for special action to be applied to the value. */
       switch (words[*offset])
        {
        case '}':
-         if (!brace)
-           goto end_of_word;
-
-         if (env == NULL)
-           goto syntax;
-
          /* Evaluate. */
          goto envsubst;
 
        case '#':
-         /* '#' only has special meaning inside braces or as the very
-          * first character after $ */
-         if (*offset == start)
-           {
-             seen_hash = 1;
-             goto envsubst;
-           }
-
-         if (!brace)
-           /* Evaluate */
-           /* (and re-parse this character) */
-           goto end_of_word;
-
-         /* At the start? (i.e. 'string length') */
-         if (env == NULL)
-           {
-             seen_hash = 1;
-             continue;
-           }
-         else if (seen_hash)
-           goto syntax;
-
          action = ACT_RP_SHORT_LEFT;
          if (words[1 + *offset] == '#')
            {
              ++*offset;
              action = ACT_RP_LONG_LEFT;
            }
-
-         continue;
+         break;
 
        case '%':
-         if (!brace)
-           /* Re-parse this character after substitution */
-           goto end_of_word;
-
-         if (!env || !*env)
-           goto syntax;
-
-         if (seen_hash)
-           goto syntax;
-
          action = ACT_RP_SHORT_RIGHT;
          if (words[1 + *offset] == '%')
            {
              ++*offset;
              action = ACT_RP_LONG_RIGHT;
            }
-
-         continue;
+         break;
 
        case ':':
-         if (!brace)
-           goto end_of_word;
-
-         if (!env || !*env)
-           goto syntax;
-
-         if (seen_hash)
-           goto syntax;
-
-         if (words[1 + *offset] != '-' && words[1 + *offset] != '='
-             && words[1 + *offset] != '?' && words[1 + *offset] != '+')
+         if (strchr ("-=?+", words[1 + *offset]) == NULL)
            goto syntax;
 
          colon_seen = 1;
          action = words[++*offset];
-         continue;
+         break;
 
        case '-':
        case '=':
        case '?':
        case '+':
-         if (!brace)
-           goto end_of_word;
-
-         if (!env || !*env)
-           goto syntax;
-
          action = words[*offset];
-         continue;
+         break;
+
+       default:
+         goto syntax;
        }
 
-      special = strchr ("*@$", words[*offset]) != NULL;
+      /* Now collect the pattern, but don't expand it yet. */
+      ++*offset;
+      for (; words[*offset]; ++(*offset))
+       {
+         switch (words[*offset])
+           {
+           case '{':
+             if (!pattern_is_quoted)
+               ++depth;
+             break;
 
-      if (!isalnum (words[*offset]) && !special)
-       /* Stop and evaluate, remembering char we stopped at */
-       break;
+           case '}':
+             if (!pattern_is_quoted)
+               {
+                 if (depth == 0)
+                   goto envsubst;
+                 --depth;
+               }
+             break;
 
-      env = w_addchar (env, &env_length, &env_maxlen,
-                          words[*offset]);
-      if (env == NULL)
-       goto no_space;
+           case '\\':
+             if (pattern_is_quoted)
+               /* Quoted; treat as normal character. */
+               break;
 
-      if (special)
-       {
-         if (brace)
-           ++*offset;
-         goto envsubst;
+             /* Otherwise, it's an escape: next character is literal. */
+             if (words[++*offset] == '\0')
+               goto syntax;
+
+             pattern = w_addchar (pattern, &pat_length, &pat_maxlen, '\\');
+             if (pattern == NULL)
+               goto no_space;
+
+             break;
+
+           case '\'':
+             if (pattern_is_quoted == 0)
+               pattern_is_quoted = 1;
+             else if (pattern_is_quoted == 1)
+               pattern_is_quoted = 0;
+
+             break;
+
+           case '"':
+             if (pattern_is_quoted == 0)
+               pattern_is_quoted = 2;
+             else if (pattern_is_quoted == 2)
+               pattern_is_quoted = 0;
+
+             break;
+           }
+
+         pattern = w_addchar (pattern, &pat_length, &pat_maxlen,
+                              words[*offset]);
+         if (pattern == NULL)
+           goto no_space;
        }
     }
 
-  /* End of input string -- remember to reparse the character that we stopped
-   * at.  */
-end_of_word:
+  /* End of input string -- remember to reparse the character that we
+   * stopped at.  */
   --(*offset);
 
 envsubst:
   if (words[start] == '{' && words[*offset] != '}')
     goto syntax;
 
-  if (!env || !*env)
+  if (env == NULL)
     {
       if (seen_hash)
        {
          /* $# expands to the number of positional parameters */
-         char buffer[21];
          buffer[20] = '\0';
-         *word = w_addstr (*word, word_length, max_length,
-                           _itoa_word (__libc_argc - 1, &buffer[20], 10, 0));
+         value = _itoa_word (__libc_argc - 1, &buffer[20], 10, 0);
+         seen_hash = 0;
        }
       else
        {
          /* Just $ on its own */
          *offset = start - 1;
          *word = w_addchar (*word, word_length, max_length, '$');
+         return *word ? 0 : WRDE_NOSPACE;
        }
-
-      if (env)
-       free (env);
-
-      return *word ? 0 : WRDE_NOSPACE;
     }
+  /* Is it a numeric parameter? */
+  else if (isdigit (env[0]))
+    {
+      int n = atoi (env);
 
+      if (n >= __libc_argc)
+       /* Substitute NULL. */
+       value = NULL;
+      else
+       /* Replace with appropriate positional parameter. */
+       value = __libc_argv[n];
+    }
   /* Is it a special parameter? */
-  if (strpbrk (env, "*@$") || isdigit (*env))
+  else if (special)
     {
-      if ((isdigit(*env) && strcspn (env, "1234567890")) ||
-         (!isdigit(*env) && env[1] != '\0'))
-       {
-         /* Bad substitution if it isn't "*", "@", "$", or just a number.  */
-       bad_subst:
-         free (env);
-         fprintf (stderr, "${%s}: bad substitution\n", env);
-         return WRDE_SYNTAX;
-       }
-
-      /* Is it a digit? */
-      if (isdigit(*env))
+      /* Is it `$$'? */
+      if (*env == '$')
        {
-         char *endp;
-         int n = strtol (env, &endp, 10);
-
-         if (*endp != '\0')
-           goto bad_subst;
-
-         free (env);
-         if (n >= __libc_argc)
-           /* Substitute NULL */
-           return 0;
-
-         /* Replace with the appropriate positional parameter */
-         value = __libc_argv[n];
-         goto maybe_fieldsplit;
+         buffer[20] = '\0';
+         value = _itoa_word (__getpid (), &buffer[20], 10, 0);
        }
-      /* Is it `$$' ? */
-      else if (*env == '$')
+      /* Is it `${#*}' or `${#@}'? */
+      else if ((*env == '*' || *env == '@') && seen_hash)
        {
-         char pidstr[21];
-
+         buffer[20] = '\0';
+         value = _itoa_word (__libc_argc > 0 ? __libc_argc - 1 : 0,
+                             &buffer[20], 10, 0);
+         *word = w_addstr (*word, word_length, max_length, value);
          free (env);
-         pidstr[20] = '\0';
-         *word = w_addstr (*word, word_length, max_length,
-                           _itoa_word (getpid(), &pidstr[20], 10, 0));
+         if (pattern)
+           free (pattern);
          return *word ? 0 : WRDE_NOSPACE;
        }
       /* Is it `$*' or `$@' (unquoted) ? */
       else if (*env == '*' || (*env == '@' && !quoted))
        {
-         size_t plist_len = 1;
+         size_t plist_len = 0;
          int p;
+         char *end;
 
          /* Build up value parameter by parameter (copy them) */
-         free (env);
+         for (p = 1; __libc_argv[p]; ++p)
+           plist_len += strlen (__libc_argv[p]) + 1; /* for space */
+         value = malloc (plist_len);
+         if (value == NULL)
+           goto no_space;
+         end = value;
+         *end = 0;
          for (p = 1; __libc_argv[p]; ++p)
            {
-             char *old_pointer = value;
-             size_t argv_len = strlen (__libc_argv[p]);
-             size_t old_plist_len = plist_len;
+             if (p > 1)
+               *end++ = ' ';
+             end = __stpcpy (end, __libc_argv[p]);
+           }
 
-             if (value)
-               value[plist_len - 1] = 0;
+         free_value = 1;
+       }
+      else
+       {
+         /* Must be a quoted `$@' */
+         assert (*env == '@' && quoted);
 
-             plist_len += 1 + argv_len;
+         /* Each parameter is a separate word ("$@") */
+         if (__libc_argc == 2)
+           value = __libc_argv[1];
+         else if (__libc_argc > 2)
+           {
+             int p;
 
-             /* First realloc will act as malloc because value is
-              * initialised to NULL. */
-             value = realloc (value, plist_len);
-             if (value == NULL)
-               {
-                 free (old_pointer);
-                 return WRDE_NOSPACE;
-               }
+             /* Append first parameter to current word. */
+             value = w_addstr (*word, word_length, max_length,
+                               __libc_argv[1]);
+             if (value == NULL || w_addword (pwordexp, value))
+               goto no_space;
 
-             memcpy (&value[old_plist_len - 1], __libc_argv[p], argv_len + 1);
-             if (__libc_argv[p + 1])
+             for (p = 2; __libc_argv[p + 1]; p++)
                {
-                 value[plist_len - 1] = '\0';
-                 value[plist_len - 2] = ' ';
+                 char *newword = __strdup (__libc_argv[p]);
+                 if (newword == NULL || w_addword (pwordexp, newword))
+                   goto no_space;
                }
-           }
 
-         free_value = 1;
-         if (value)
-           goto maybe_fieldsplit;
-
-         return 0;
+             /* Start a new word with the last parameter. */
+             *word = w_newword (word_length, max_length);
+             value = __libc_argv[p];
+           }
+         else
+           {
+             free (env);
+             free (pattern);
+             return 0;
+           }
        }
+    }
+  else
+    value = getenv (env);
+
+  if (value == NULL && (flags & WRDE_UNDEF))
+    {
+      /* Variable not defined. */
+      error = WRDE_BADVAL;
+      goto do_error;
+    }
 
-      /* Must be a quoted `$@' */
-      assert (*env == '@');
-      assert (quoted);
-      free (env);
+  if (action != ACT_NONE)
+    {
+      int expand_pattern = 0;
 
-      /* Each parameter is a separate word ("$@") */
-      if (__libc_argv[0] != NULL && __libc_argv[1] != NULL)
+      /* First, find out if we need to expand pattern (i.e. if we will
+       * use it). */
+      switch (action)
        {
-         /* Append first parameter to current word. */
-         int p;
+       case ACT_RP_SHORT_LEFT:
+       case ACT_RP_LONG_LEFT:
+       case ACT_RP_SHORT_RIGHT:
+       case ACT_RP_LONG_RIGHT:
+         /* Always expand for these. */
+         expand_pattern = 1;
+         break;
 
-         *word = w_addstr (*word, word_length, max_length, __libc_argv[1]);
-         if (*word == NULL)
-           return WRDE_NOSPACE;
+       case ACT_NULL_ERROR:
+       case ACT_NULL_SUBST:
+       case ACT_NULL_ASSIGN:
+         if (!value || (!*value && colon_seen))
+           /* If param is unset, or set but null and a colon has been seen,
+              the expansion of the pattern will be needed. */
+           expand_pattern = 1;
+
+         break;
 
-         for (p = 2; __libc_argv[p]; p++)
+       case ACT_NONNULL_SUBST:
+         /* Expansion of word will be needed if parameter is set and not null,
+            or set null but no colon has been seen. */
+         if (value && (*value || !colon_seen))
+           expand_pattern = 1;
+
+         break;
+
+       default:
+         assert (! "Unrecognised action!");
+       }
+
+      if (expand_pattern)
+       {
+         /* We need to perform tilde expansion, parameter expansion,
+             command substitution, and arithmetic expansion.  We also
+            have to be a bit careful with wildcard characters, as
+            pattern might be given to fnmatch soon.  To do this, we
+            convert quotes to escapes. */
+
+         char *expanded;
+         size_t exp_len;
+         size_t exp_maxl;
+         char *p;
+         int quoted = 0; /* 1: single quotes; 2: double */
+
+         expanded = w_newword (&exp_len, &exp_maxl);
+         for (p = pattern; p && *p; p++)
            {
-             size_t len;
-             char *s;
-             if (w_addword (pwordexp, *word))
-               return WRDE_NOSPACE;
-             len = strlen (__libc_argv[p]) + 1;
-             s = malloc (len);
-             if (s == NULL)
-               return WRDE_NOSPACE;
-             *word = memcpy (s, __libc_argv[p], len);
-             *max_length = *word_length = len - 1;
+             size_t offset;
+
+             switch (*p)
+               {
+               case '"':
+                 if (quoted == 2)
+                   quoted = 0;
+                 else if (quoted == 0)
+                   quoted = 2;
+                 else break;
+
+                 continue;
+
+               case '\'':
+                 if (quoted == 1)
+                   quoted = 0;
+                 else if (quoted == 0)
+                   quoted = 1;
+                 else break;
+
+                 continue;
+
+               case '*':
+               case '?':
+                 if (quoted)
+                   {
+                     /* Convert quoted wildchar to escaped wildchar. */
+                     expanded = w_addchar (expanded, &exp_len,
+                                           &exp_maxl, '\\');
+
+                     if (expanded == NULL)
+                       goto no_space;
+                   }
+                 break;
+
+               case '$':
+                 offset = 0;
+                 error = parse_dollars (&expanded, &exp_len, &exp_maxl, p,
+                                        &offset, flags, NULL, NULL, NULL, 1);
+                 if (error)
+                   {
+                     if (free_value)
+                       free (value);
+
+                     if (expanded)
+                       free (expanded);
+
+                     goto do_error;
+                   }
+
+                 p += offset;
+                 continue;
+
+               case '~':
+                 if (quoted || exp_len)
+                   break;
+
+                 offset = 0;
+                 error = parse_tilde (&expanded, &exp_len, &exp_maxl, p,
+                                      &offset, 0);
+                 if (error)
+                   {
+                     if (free_value)
+                       free (value);
+
+                     if (expanded)
+                       free (expanded);
+
+                     goto do_error;
+                   }
+
+                 p += offset;
+                 continue;
+
+               case '\\':
+                 expanded = w_addchar (expanded, &exp_len, &exp_maxl, '\\');
+                 ++p;
+                 assert (*p); /* checked when extracted initially */
+                 if (expanded == NULL)
+                   goto no_space;
+               }
+
+             expanded = w_addchar (expanded, &exp_len, &exp_maxl, *p);
+
+             if (expanded == NULL)
+               goto no_space;
            }
-       }
 
-      return 0;
-    }
+         if (pattern)
+                 free (pattern);
 
-  value = getenv (env);
+         pattern = expanded;
+       }
 
-  if (action != ACT_NONE)
-    {
       switch (action)
        {
        case ACT_RP_SHORT_LEFT:
@@ -1404,14 +1665,11 @@ envsubst:
            char c;
            char *end;
 
-           if (!pattern || !*pattern)
+           if (value == NULL || pattern == NULL || *pattern == '\0')
              break;
 
            end = value + strlen (value);
 
-           if (value == NULL)
-             break;
-
            switch (action)
              {
              case ACT_RP_SHORT_LEFT:
@@ -1422,7 +1680,19 @@ envsubst:
                    if (fnmatch (pattern, value, 0) != FNM_NOMATCH)
                      {
                        *p = c;
-                       value = p;
+                       if (free_value)
+                         {
+                           char *newval = __strdup (p);
+                           if (newval == NULL)
+                             {
+                               free (value);
+                               goto no_space;
+                             }
+                           free (value);
+                           value = newval;
+                         }
+                       else
+                         value = p;
                        break;
                      }
                    *p = c;
@@ -1438,7 +1708,19 @@ envsubst:
                    if (fnmatch (pattern, value, 0) != FNM_NOMATCH)
                      {
                        *p = c;
-                       value = p;
+                       if (free_value)
+                         {
+                           char *newval = __strdup (p);
+                           if (newval == NULL)
+                             {
+                               free (value);
+                               goto no_space;
+                             }
+                           free (value);
+                           value = newval;
+                         }
+                       else
+                         value = p;
                        break;
                      }
                    *p = c;
@@ -1451,7 +1733,21 @@ envsubst:
                  {
                    if (fnmatch (pattern, p, 0) != FNM_NOMATCH)
                      {
-                       *p = '\0';
+                       char *newval;
+                       newval = malloc (p - value + 1);
+
+                       if (newval == NULL)
+                         {
+                           if (free_value)
+                             free (value);
+                           goto no_space;
+                         }
+
+                       *(char *) __mempcpy (newval, value, p - value) = '\0';
+                       if (free_value)
+                         free (value);
+                       value = newval;
+                       free_value = 1;
                        break;
                      }
                  }
@@ -1463,7 +1759,21 @@ envsubst:
                  {
                    if (fnmatch (pattern, p, 0) != FNM_NOMATCH)
                      {
-                       *p = '\0';
+                       char *newval;
+                       newval = malloc (p - value + 1);
+
+                       if (newval == NULL)
+                         {
+                           if (free_value)
+                             free (value);
+                           goto no_space;
+                         }
+
+                       *(char *) __mempcpy (newval, value, p - value) = '\0';
+                       if (free_value)
+                         free (value);
+                       value = newval;
+                       free_value = 1;
                        break;
                      }
                  }
@@ -1482,143 +1792,63 @@ envsubst:
            /* Substitute parameter */
            break;
 
+         error = 0;
          if (!colon_seen && value)
+           /* Substitute NULL */
+           ;
+         else
            {
-             /* Substitute NULL */
-             free (env);
-             free (pattern);
-             return 0;
-           }
-
-         if (*pattern)
-           {
-             /* Expand 'pattern' and write it to stderr */
-             wordexp_t we;
-
-             error = wordexp (pattern, &we, flags);
-
-             if (error == 0)
-               {
-                 int i;
-
-                 fprintf (stderr, "%s:", env);
-
-                 for (i = 0; i < we.we_wordc; ++i)
-                   {
-                     fprintf (stderr, " %s", we.we_wordv[i]);
-                   }
+             const char *str = pattern;
 
-                 fprintf (stderr, "\n");
-                 error = WRDE_BADVAL;
-               }
+             if (str[0] == '\0')
+               str = _("parameter null or not set");
 
-             wordfree (&we);
-             free (env);
-             free (pattern);
-             return error;
+             __fxprintf (NULL, "%s: %s\n", env, str);
            }
 
-         fprintf (stderr, "%s: parameter null or not set\n", env);
-         free (env);
-         free (pattern);
-         return WRDE_BADVAL;
+         if (free_value)
+           free (value);
+         goto do_error;
 
        case ACT_NULL_SUBST:
          if (value && *value)
            /* Substitute parameter */
            break;
 
-         if (!colon_seen && value)
-           {
-             /* Substitute NULL */
-             free (env);
-             free (pattern);
-             return 0;
-           }
+         if (free_value && value)
+           free (value);
 
-       subst_word:
-         {
-           /* Substitute word */
-           wordexp_t we;
-           int i;
+         if (!colon_seen && value)
+           /* Substitute NULL */
+           goto success;
 
-           if (quoted)
-             {
-               /* No field-splitting is allowed, so imagine
-                  quotes around the word.  */
-               char *qtd_pattern = malloc (3 + strlen (pattern));
-               if (qtd_pattern)
-                 sprintf (qtd_pattern, "\"%s\"", pattern);
-               free (pattern);
-               pattern = qtd_pattern;
-             }
+         value = pattern ? __strdup (pattern) : pattern;
+         free_value = 1;
 
-           if (pattern == NULL && (pattern = __strdup ("")) == NULL)
-             goto no_space;
+         if (pattern && !value)
+           goto no_space;
 
-           error = wordexp (pattern, &we, flags);
-           if (error)
-             {
-               free (env);
-               free (pattern);
-               return error;
-             }
+         break;
 
-           /* Fingers crossed that the quotes worked.. */
-           assert (!quoted || we.we_wordc == 1);
+       case ACT_NONNULL_SUBST:
+         if (value && (*value || !colon_seen))
+           {
+             if (free_value && value)
+               free (value);
 
-           /* Substitute */
-           for (i = 0; i < we.we_wordc; ++i)
-             if (w_addword (pwordexp, __strdup (we.we_wordv[i]))
-                 == WRDE_NOSPACE)
-               break;
+             value = pattern ? __strdup (pattern) : pattern;
+             free_value = 1;
 
-           if (i < we.we_wordc)
-             {
-               /* Ran out of space */
-               wordfree (&we);
+             if (pattern && !value)
                goto no_space;
-             }
-
-           if (action == ACT_NULL_ASSIGN)
-             {
-               char *words;
-               char *cp;
-               size_t words_size = 0;
-
-               for (i = 0; i < we.we_wordc; i++)
-                 words_size += strlen (we.we_wordv[i]) + 1; /* for <space> */
-               words_size++;
-
-               cp = words = __alloca (words_size);
-               *words = 0;
-               for (i = 0; i < we.we_wordc - 1; i++)
-                 {
-                   cp = __stpcpy (cp, we.we_wordv[i]);
-                   *cp++ = ' ';
-                 }
-
-               __stpcpy (cp, we.we_wordv[i]);
-
-               /* Also assign */
-               setenv (env, words, 1);
-             }
 
-           wordfree (&we);
-           return 0;
-         }
-
-       case ACT_NONNULL_SUBST:
-         if (value && *value)
-           goto subst_word;
-
-         if (!colon_seen && value)
-           goto subst_word;
+             break;
+           }
 
          /* Substitute NULL */
-         free (env);
-         free (pattern);
-         return 0;
+         if (free_value)
+           free (value);
+         goto success;
 
        case ACT_NULL_ASSIGN:
          if (value && *value)
@@ -1628,41 +1858,50 @@ envsubst:
          if (!colon_seen && value)
            {
              /* Substitute NULL */
-             free (env);
-             free (pattern);
-             return 0;
+             if (free_value)
+               free (value);
+             goto success;
            }
 
-         /* This checks for '=' so it knows to assign */
-         goto subst_word;
+         if (free_value && value)
+           free (value);
+
+         value = pattern ? __strdup (pattern) : pattern;
+         free_value = 1;
+
+         if (pattern && !value)
+           goto no_space;
+
+         __setenv (env, value, 1);
+         break;
 
        default:
          assert (! "Unrecognised action!");
        }
     }
 
-  free (env);
-  free (pattern);
-
-  if (value == NULL)
-    {
-      /* Variable not defined */
-      if (flags & WRDE_UNDEF)
-       return WRDE_BADVAL;
-
-      return 0;
-    }
+  free (env); env = NULL;
+  free (pattern); pattern = NULL;
 
   if (seen_hash)
     {
       char param_length[21];
       param_length[20] = '\0';
       *word = w_addstr (*word, word_length, max_length,
-                       _itoa_word (strlen (value), &param_length[20], 10, 0));
+                       _itoa_word (value ? strlen (value) : 0,
+                                   &param_length[20], 10, 0));
+      if (free_value)
+       {
+         assert (value != NULL);
+         free (value);
+       }
+
       return *word ? 0 : WRDE_NOSPACE;
     }
 
- maybe_fieldsplit:
+  if (value == NULL)
+    return 0;
+
   if (quoted || !pwordexp)
     {
       /* Quoted - no field split */
@@ -1683,7 +1922,7 @@ envsubst:
        free (value);
 
       if (value_copy == NULL)
-       return WRDE_NOSPACE;
+       goto no_space;
 
       do
        {
@@ -1696,36 +1935,29 @@ envsubst:
              if (w_addword (pwordexp, *word) == WRDE_NOSPACE)
                {
                  free (value_copy);
-                 return WRDE_NOSPACE;
+                 goto no_space;
                }
 
-             *word = NULL;
-             *word_length = *max_length = 0;
+             *word = w_newword (word_length, max_length);
            }
 
          /* Skip IFS whitespace before the field */
-         while (*field_begin && strchr (ifs_white, *field_begin) != NULL)
-           field_begin++;
+         field_begin += strspn (field_begin, ifs_white);
 
          if (!seen_nonws_ifs && *field_begin == 0)
            /* Nothing but whitespace */
            break;
 
          /* Search for the end of the field */
-         field_end = field_begin;
-         while (*field_end && strchr (ifs, *field_end) == NULL)
-           field_end++;
-
-         /* Set up pointer to the character after end of field */
-         next_field = *field_end ? field_end : NULL;
+         field_end = field_begin + strcspn (field_begin, ifs);
 
-         /* Skip whitespace IFS after the field */
-         while (next_field && *next_field && strchr (ifs_white, *next_field))
-           next_field++;
+         /* Set up pointer to the character after end of field and
+             skip whitespace IFS after it. */
+         next_field = field_end + strspn (field_end, ifs_white);
 
          /* Skip at most one non-whitespace IFS character after the field */
          seen_nonws_ifs = 0;
-         if (next_field && *next_field && strchr (ifs, *next_field))
+         if (*next_field && strchr (ifs, *next_field))
            {
              seen_nonws_ifs = 1;
              next_field++;
@@ -1737,38 +1969,40 @@ envsubst:
          /* Tag a copy onto the current word */
          *word = w_addstr (*word, word_length, max_length, field_begin);
 
-         if (*word == NULL)
+         if (*word == NULL && *field_begin != '\0')
            {
              free (value_copy);
-             return WRDE_NOSPACE;
+             goto no_space;
            }
 
          field_begin = next_field;
        }
-      while (seen_nonws_ifs || (field_begin != NULL && *field_begin));
+      while (seen_nonws_ifs || *field_begin);
 
       free (value_copy);
     }
 
   return 0;
 
-no_space:
-  if (env)
-    free (env);
-
-  if (pattern)
-    free (pattern);
+success:
+  error = 0;
+  goto do_error;
 
-  return WRDE_NOSPACE;
+no_space:
+  error = WRDE_NOSPACE;
+  goto do_error;
 
 syntax:
+  error = WRDE_SYNTAX;
+
+do_error:
   if (env)
     free (env);
 
   if (pattern)
     free (pattern);
 
-  return WRDE_SYNTAX;
+  return error;
 }
 
 static int
@@ -1834,16 +2068,17 @@ parse_dollars (char **word, size_t *word_length, size_t *max_length,
 }
 
 static int
+internal_function
 parse_backtick (char **word, size_t *word_length, size_t *max_length,
                const char *words, size_t *offset, int flags,
                wordexp_t *pwordexp, const char *ifs, const char *ifs_white)
 {
   /* We are poised just after "`" */
   int error;
-  size_t comm_length = 0;
-  size_t comm_maxlen = 0;
-  char *comm = NULL;
   int squoting = 0;
+  size_t comm_length;
+  size_t comm_maxlen;
+  char *comm = w_newword (&comm_length, &comm_maxlen);
 
   for (; words[*offset]; ++(*offset))
     {
@@ -1979,6 +2214,7 @@ wordfree (wordexp_t *pwordexp)
       pwordexp->we_wordv = NULL;
     }
 }
+libc_hidden_def (wordfree)
 
 /*
  * wordexp()
@@ -1987,43 +2223,47 @@ wordfree (wordexp_t *pwordexp)
 int
 wordexp (const char *words, wordexp_t *pwordexp, int flags)
 {
-  size_t wordv_offset;
   size_t words_offset;
-  size_t word_length = 0;
-  size_t max_length = 0;
-  char *word = NULL;
+  size_t word_length;
+  size_t max_length;
+  char *word = w_newword (&word_length, &max_length);
   int error;
   char *ifs;
   char ifs_white[4];
-  char **old_wordv = pwordexp->we_wordv;
-  size_t old_wordc = (flags & WRDE_REUSE) ? pwordexp->we_wordc : 0;
+  wordexp_t old_word = *pwordexp;
 
   if (flags & WRDE_REUSE)
     {
       /* Minimal implementation of WRDE_REUSE for now */
       wordfree (pwordexp);
-      old_wordv = NULL;
+      old_word.we_wordv = NULL;
     }
 
-  if (flags & WRDE_DOOFFS)
-    {
-      pwordexp->we_wordv = calloc (1 + pwordexp->we_offs, sizeof (char *));
-      if (pwordexp->we_wordv == NULL)
-       return WRDE_NOSPACE;
-    }
-  else
+  if ((flags & WRDE_APPEND) == 0)
     {
-      pwordexp->we_wordv = calloc (1, sizeof (char *));
-      if (pwordexp->we_wordv == NULL)
-       return WRDE_NOSPACE;
+      pwordexp->we_wordc = 0;
 
-      pwordexp->we_offs = 0;
-    }
-
-  if ((flags & WRDE_APPEND) == 0)
-    pwordexp->we_wordc = 0;
+      if (flags & WRDE_DOOFFS)
+       {
+         pwordexp->we_wordv = calloc (1 + pwordexp->we_offs, sizeof (char *));
+         if (pwordexp->we_wordv == NULL)
+           {
+             error = WRDE_NOSPACE;
+             goto do_error;
+           }
+       }
+      else
+       {
+         pwordexp->we_wordv = calloc (1, sizeof (char *));
+         if (pwordexp->we_wordv == NULL)
+           {
+             error = WRDE_NOSPACE;
+             goto do_error;
+           }
 
-  wordv_offset = pwordexp->we_offs + pwordexp->we_wordc;
+         pwordexp->we_offs = 0;
+       }
+    }
 
   /* Find out what the field separators are.
    * There are two types: whitespace and non-whitespace.
@@ -2031,8 +2271,8 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
   ifs = getenv ("IFS");
 
   if (!ifs)
-    /* NULL IFS means no field-splitting is to be performed */
-    ifs = strcpy (ifs_white, "");
+    /* IFS unset - use <space><tab><newline>. */
+    ifs = strcpy (ifs_white, " \t\n");
   else
     {
       char *ifsch = ifs;
@@ -2064,22 +2304,6 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
   for (words_offset = 0 ; words[words_offset] ; ++words_offset)
     switch (words[words_offset])
       {
-      case '\n':
-      case '|':
-      case '&':
-      case ';':
-      case '<':
-      case '>':
-      case '(':
-      case ')':
-       case '{':
-      case '}':
-       /* Fail */
-       wordfree (pwordexp);
-       pwordexp->we_wordc = 0;
-       pwordexp->we_wordv = old_wordv;
-       return WRDE_BADCHAR;
-
       case '\\':
        error = parse_backslash (&word, &word_length, &max_length, words,
                                 &words_offset);
@@ -2101,7 +2325,10 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
 
       case '`':
        if (flags & WRDE_NOCMD)
-         return WRDE_CMDSUB;
+         {
+           error = WRDE_CMDSUB;
+           goto do_error;
+         }
 
        ++words_offset;
        error = parse_backtick (&word, &word_length, &max_length, words,
@@ -2121,6 +2348,14 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
        if (error)
          goto do_error;
 
+       if (!word_length)
+         {
+           error = w_addword (pwordexp, NULL);
+
+           if (error)
+             return error;
+         }
+
        break;
 
       case '\'':
@@ -2131,6 +2366,14 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
        if (error)
          goto do_error;
 
+       if (!word_length)
+         {
+           error = w_addword (pwordexp, NULL);
+
+           if (error)
+             return error;
+         }
+
        break;
 
       case '~':
@@ -2154,65 +2397,46 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
        break;
 
       default:
-       /* Is it a field separator? */
-       if (strchr (ifs, words[words_offset]) == NULL)
+       /* Is it a word separator? */
+       if (strchr (" \t", words[words_offset]) == NULL)
          {
-           /* "Ordinary" character -- add it to word */
+           char ch = words[words_offset];
 
-           word = w_addchar (word, &word_length, &max_length,
-                             words[words_offset]);
-           if (word == NULL)
+           /* Not a word separator -- but is it a valid word char? */
+           if (strchr ("\n|&;<>(){}", ch))
              {
-               error = WRDE_NOSPACE;
+               /* Fail */
+               error = WRDE_BADCHAR;
                goto do_error;
              }
 
-           break;
-         }
-
-       /* Field separator */
-       if (strchr (ifs_white, words[words_offset]))
-         {
-           /* It's a whitespace IFS char.  Ignore it at the beginning
-              of a line and ignore multiple instances.  */
-           if (!word || !*word)
-             break;
-
-           if (w_addword (pwordexp, word) == WRDE_NOSPACE)
+           /* "Ordinary" character -- add it to word */
+           word = w_addchar (word, &word_length, &max_length,
+                             ch);
+           if (word == NULL)
              {
                error = WRDE_NOSPACE;
                goto do_error;
              }
 
-           word = NULL;
-           word_length = 0;
-           max_length = 0;
            break;
          }
 
-       /* It's a non-whitespace IFS char */
-
-       /* Multiple non-whitespace IFS chars are treated as one;
-        * IS THIS CORRECT?
-        */
+       /* If a word has been delimited, add it to the list. */
        if (word != NULL)
          {
-           if (w_addword (pwordexp, word) == WRDE_NOSPACE)
-             {
-               error = WRDE_NOSPACE;
-               goto do_error;
-             }
+           error = w_addword (pwordexp, word);
+           if (error)
+             goto do_error;
          }
 
-       word = NULL;
-       word_length = 0;
-       max_length = 0;
+       word = w_newword (&word_length, &max_length);
       }
 
   /* End of string */
 
-  /* There was a field separator at the end */
-  if (word == NULL)
+  /* There was a word separator at the end */
+  if (word == NULL) /* i.e. w_newword */
     return 0;
 
   /* There was no field separator at the end */
@@ -2221,17 +2445,18 @@ wordexp (const char *words, wordexp_t *pwordexp, int flags)
 do_error:
   /* Error:
    *   free memory used (unless error is WRDE_NOSPACE), and
-   *   set we_wordc and wd_wordv back to what they were.
+   *   set pwordexp members back to what they were.
    */
 
+  if (word != NULL)
+    free (word);
+
   if (error == WRDE_NOSPACE)
     return WRDE_NOSPACE;
 
-  if (word != NULL)
-    free (word);
+  if ((flags & WRDE_APPEND) == 0)
+    wordfree (pwordexp);
 
-  wordfree (pwordexp);
-  pwordexp->we_wordv = old_wordv;
-  pwordexp->we_wordc = old_wordc;
+  *pwordexp = old_word;
   return error;
 }