Changeset 3138 for vendor/gnumake/current/read.c

Timestamp:

Mar 12, 2018, 8:32:29 PM (7 years ago)

Author:

bird

Message:

Imported make 4.2.1 (2e55f5e4abdc0e38c1d64be703b446695e70b3b6) from ​https://git.savannah.gnu.org/git/make.git.

File:

• vendor/gnumake/current/read.c (modified) (132 diffs)

vendor/gnumake/current/read.c

@@ -1 +1 @@
 /* Reading and parsing of makefiles for GNU Make.
-Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-2010 Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -17 +15 @@
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#include "make.h"
+#include "makeint.h"
 
 #include <assert.h>
 
-#include <glob.h>
-
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "job.h"
 #include "commands.h"
@@ -33 +29 @@
 
 
-#ifndef WINDOWS32
+#ifdef WINDOWS32
+#include <windows.h>
+#include "sub_proc.h"
+#else  /* !WINDOWS32 */
 #ifndef _AMIGA
 #ifndef VMS
@@ -54 +53 @@
     unsigned int size;  /* Malloc'd size of buffer. */
     FILE *fp;           /* File, or NULL if this is an internal buffer.  */
-    struct floc floc;   /* Info on the file in fp (if any).  */
+    floc floc;          /* Info on the file in fp (if any).  */
   };
 
@@ -77 +76 @@
 
 
-/* A `struct conditionals' contains the information describing
+/* A 'struct conditionals' contains the information describing
    all the active conditionals in a makefile.
 
-   The global variable `conditionals' contains the conditionals
+   The global variable 'conditionals' contains the conditionals
    information for the current makefile.  It is initialized from
-   the static structure `toplevel_conditionals' and is later changed
+   the static structure 'toplevel_conditionals' and is later changed
    to new structures for included makefiles.  */
 
 struct conditionals
   {
-    unsigned int if_cmds;       /* Depth of conditional nesting.  */
-    unsigned int allocated;     /* Elts allocated in following arrays.  */
-    char *ignoring;             /* Are we ignoring or interpreting?
+    unsigned int if_cmds;       /* Depth of conditional nesting.  */
+    unsigned int allocated;     /* Elts allocated in following arrays.  */
+    char *ignoring;             /* Are we ignoring or interpreting?
                                    0=interpreting, 1=not yet interpreted,
                                    2=already interpreted */
-    char *seen_else;            /* Have we already seen an `else'?  */
+    char *seen_else;            /* Have we already seen an 'else'?  */
   };
 
@@ -128 +127 @@
    makefile currently being read in.  */
 
-const struct floc *reading_file = 0;
-
-/* The chain of makefiles read by read_makefile.  */
-
-static struct dep *read_makefiles = 0;
-
-static int eval_makefile (const char *filename, int flags);
+const floc *reading_file = 0;
+
+/* The chain of files read by read_all_makefiles.  */
+
+static struct goaldep *read_files = 0;
+
+static struct goaldep *eval_makefile (const char *filename, int flags);
 static void eval (struct ebuffer *buffer, int flags);
 
@@ -142 +141 @@
 static struct variable *do_define (char *name, enum variable_origin origin,
                                    struct ebuffer *ebuf);
-static int conditional_line (char *line, int len, const struct floc *flocp);
+static int conditional_line (char *line, int len, const floc *flocp);
 static void record_files (struct nameseq *filenames, const char *pattern,
                           const char *pattern_percent, char *depstr,
                           unsigned int cmds_started, char *commands,
                           unsigned int commands_idx, int two_colon,
-                          const struct floc *flocp);
+                          char prefix, const floc *flocp);
 static void record_target_var (struct nameseq *filenames, char *defn,
                                enum variable_origin origin,
                                struct vmodifiers *vmod,
-                               const struct floc *flocp);
+                               const floc *flocp);
 static enum make_word_type get_next_mword (char *buffer, char *delim,
                                            char **startp, unsigned int *length);
 static void remove_comments (char *line);
-static char *find_char_unquote (char *string, int stop1, int stop2,
-                                int blank, int ignorevars);
+static char *find_char_unquote (char *string, int map);
+static char *unescape_char (char *string, int c);
 
 
@@ -162 +161 @@
    P must point to the word to be tested, and WLEN must be the length.
 */
-#define word1eq(s)      (wlen == sizeof(s)-1 && strneq (s, p, sizeof(s)-1))
-
-
-
-/* Read in all the makefiles and return the chain of their names.  */
-
-struct dep *
+#define word1eq(s)      (wlen == CSTRLEN (s) && strneq (s, p, CSTRLEN (s)))
+
+
+
+/* Read in all the makefiles and return a chain of targets to rebuild.  */
+
+struct goaldep *
 read_all_makefiles (const char **makefiles)
 {
@@ -205 +204 @@
     while ((name = find_next_token ((const char **)&p, &length)) != 0)
       {
-        if (*p != '\0')
-          *p++ = '\0';
-        eval_makefile (name, RM_NO_DEFAULT_GOAL|RM_INCLUDED|RM_DONTCARE);
+        if (*p != '\0')
+          *p++ = '\0';
+        eval_makefile (name, RM_NO_DEFAULT_GOAL|RM_INCLUDED|RM_DONTCARE);
       }
 
@@ -218 +217 @@
     while (*makefiles != 0)
       {
-        struct dep *tail = read_makefiles;
-        register struct dep *d;
-
-        if (! eval_makefile (*makefiles, 0))
-          perror_with_name ("", *makefiles);
-
-        /* Find the right element of read_makefiles.  */
-        d = read_makefiles;
-        while (d->next != tail)
-          d = d->next;
-
-        /* Use the storage read_makefile allocates.  */
-        *makefiles = dep_name (d);
-        ++num_makefiles;
-        ++makefiles;
+        struct goaldep *d = eval_makefile (*makefiles, 0);
+
+        if (errno)
+          perror_with_name ("", *makefiles);
+
+        /* Reuse the storage allocated for the read_file.  */
+        *makefiles = dep_name (d);
+        ++num_makefiles;
+        ++makefiles;
       }
 
@@ -239 +232 @@
   if (num_makefiles == 0)
     {
-      static char *default_makefiles[] =
+      static const char *default_makefiles[] =
 #ifdef VMS
-        /* all lower case since readdir() (the vms version) 'lowercasifies' */
-        { "makefile.vms", "gnumakefile.", "makefile.", 0 };
+        /* all lower case since readdir() (the vms version) 'lowercasifies' */
+        /* TODO: Above is not always true, this needs more work */
+        { "makefile.vms", "gnumakefile", "makefile", 0 };
 #else
 #ifdef _AMIGA
-        { "GNUmakefile", "Makefile", "SMakefile", 0 };
+        { "GNUmakefile", "Makefile", "SMakefile", 0 };
 #else /* !Amiga && !VMS */
-        { "GNUmakefile", "makefile", "Makefile", 0 };
+#ifdef WINDOWS32
+        { "GNUmakefile", "makefile", "Makefile", "makefile.mak", 0 };
+#else /* !Amiga && !VMS && !WINDOWS32 */
+        { "GNUmakefile", "makefile", "Makefile", 0 };
+#endif /* !Amiga && !VMS && !WINDOWS32 */
 #endif /* AMIGA */
 #endif /* VMS */
-      register char **p = default_makefiles;
+      const char **p = default_makefiles;
       while (*p != 0 && !file_exists_p (*p))
-        ++p;
+        ++p;
 
       if (*p != 0)
-        {
-          if (! eval_makefile (*p, 0))
-            perror_with_name ("", *p);
-        }
+        {
+          eval_makefile (*p, 0);
+          if (errno)
+            perror_with_name ("", *p);
+        }
       else
-        {
-          /* No default makefile was found.  Add the default makefiles to the
-             `read_makefiles' chain so they will be updated if possible.  */
-          struct dep *tail = read_makefiles;
-          /* Add them to the tail, after any MAKEFILES variable makefiles.  */
-          while (tail != 0 && tail->next != 0)
-            tail = tail->next;
-          for (p = default_makefiles; *p != 0; ++p)
-            {
-              struct dep *d = alloc_dep ();
-              d->file = enter_file (strcache_add (*p));
-              d->dontcare = 1;
-              /* Tell update_goal_chain to bail out as soon as this file is
-                 made, and main not to die if we can't make this file.  */
-              d->changed = RM_DONTCARE;
-              if (tail == 0)
-                read_makefiles = d;
-              else
-                tail->next = d;
-              tail = d;
-            }
-          if (tail != 0)
-            tail->next = 0;
-        }
-    }
-
-  return read_makefiles;
+        {
+          /* No default makefile was found.  Add the default makefiles to the
+             'read_files' chain so they will be updated if possible.  */
+          struct goaldep *tail = read_files;
+          /* Add them to the tail, after any MAKEFILES variable makefiles.  */
+          while (tail != 0 && tail->next != 0)
+            tail = tail->next;
+          for (p = default_makefiles; *p != 0; ++p)
+            {
+              struct goaldep *d = alloc_goaldep ();
+              d->file = enter_file (strcache_add (*p));
+              /* Tell update_goal_chain to bail out as soon as this file is
+                 made, and main not to die if we can't make this file.  */
+              d->flags = RM_DONTCARE;
+              if (tail == 0)
+                read_files = d;
+              else
+                tail->next = d;
+              tail = d;
+            }
+          if (tail != 0)
+            tail->next = 0;
+        }
+    }
+
+  return read_files;
 }
 
@@ -309 +307 @@
 {
   /* Free any space allocated by conditional_line.  */
-  if (conditionals->ignoring)
-    free (conditionals->ignoring);
-  if (conditionals->seen_else)
-    free (conditionals->seen_else);
+  free (conditionals->ignoring);
+  free (conditionals->seen_else);
 
   /* Restore state.  */
@@ -319 +315 @@
 
 
-static int
+static struct goaldep *
 eval_makefile (const char *filename, int flags)
 {
-  struct dep *deps;
+  struct goaldep *deps;
   struct ebuffer ebuf;
-  const struct floc *curfile;
+  const floc *curfile;
   char *expanded = 0;
   int makefile_errno;
 
-  filename = strcache_add (filename);
-  ebuf.floc.filenm = filename;
+  ebuf.floc.filenm = filename; /* Use the original file name.  */
   ebuf.floc.lineno = 1;
+  ebuf.floc.offset = 0;
 
   if (ISDB (DB_VERBOSE))
     {
-      printf (_("Reading makefile `%s'"), filename);
+      printf (_("Reading makefile '%s'"), filename);
       if (flags & RM_NO_DEFAULT_GOAL)
-        printf (_(" (no default goal)"));
+        printf (_(" (no default goal)"));
       if (flags & RM_INCLUDED)
-        printf (_(" (search path)"));
+        printf (_(" (search path)"));
       if (flags & RM_DONTCARE)
-        printf (_(" (don't care)"));
+        printf (_(" (don't care)"));
       if (flags & RM_NO_TILDE)
-        printf (_(" (no ~ expansion)"));
+        printf (_(" (no ~ expansion)"));
       puts ("...");
     }
@@ -348 +344 @@
   /* First, get a stream to read.  */
 
-  /* Expand ~ in FILENAME unless it came from `include',
+  /* Expand ~ in FILENAME unless it came from 'include',
      in which case it was already done.  */
   if (!(flags & RM_NO_TILDE) && filename[0] == '~')
@@ -354 +350 @@
       expanded = tilde_expand (filename);
       if (expanded != 0)
-        filename = expanded;
-    }
-
-  ebuf.fp = fopen (filename, "r");
+        filename = expanded;
+    }
+
+  ENULLLOOP (ebuf.fp, fopen (filename, "r"));
+
   /* Save the error code so we print the right message later.  */
   makefile_errno = errno;
 
+  /* Check for unrecoverable errors: out of mem or FILE slots.  */
+  switch (makefile_errno)
+    {
+#ifdef EMFILE
+    case EMFILE:
+#endif
+#ifdef ENFILE
+    case ENFILE:
+#endif
+    case ENOMEM:
+      {
+        const char *err = strerror (makefile_errno);
+        OS (fatal, reading_file, "%s", err);
+      }
+    }
+
   /* If the makefile wasn't found and it's either a makefile from
-     the `MAKEFILES' variable or an included makefile,
+     the 'MAKEFILES' variable or an included makefile,
      search the included makefile search path for this makefile.  */
   if (ebuf.fp == 0 && (flags & RM_INCLUDED) && *filename != '/')
@@ -368 +381 @@
       unsigned int i;
       for (i = 0; include_directories[i] != 0; ++i)
-        {
-          const char *included = concat (3, include_directories[i],
+        {
+          const char *included = concat (3, include_directories[i],
                                          "/", filename);
-          ebuf.fp = fopen (included, "r");
-          if (ebuf.fp)
-            {
-              filename = strcache_add (included);
-              break;
-            }
-        }
-    }
+          ebuf.fp = fopen (included, "r");
+          if (ebuf.fp)
+            {
+              filename = included;
+              break;
+            }
+        }
+    }
+
+  /* Now we have the final name for this makefile. Enter it into
+     the cache.  */
+  filename = strcache_add (filename);
 
   /* Add FILENAME to the chain of read makefiles.  */
-  deps = alloc_dep ();
-  deps->next = read_makefiles;
-  read_makefiles = deps;
+  deps = alloc_goaldep ();
+  deps->next = read_files;
+  read_files = deps;
   deps->file = lookup_file (filename);
   if (deps->file == 0)
     deps->file = enter_file (filename);
   filename = deps->file->name;
-  deps->changed = flags;
-  if (flags & RM_DONTCARE)
-    deps->dontcare = 1;
-
-  if (expanded)
-    free (expanded);
+  deps->flags = flags;
+
+  free (expanded);
 
   /* If the makefile can't be found at all, give up entirely.  */
@@ -400 +414 @@
     {
       /* If we did some searching, errno has the error from the last
-         attempt, rather from FILENAME itself.  Restore it in case the
-         caller wants to use it in a message.  */
+         attempt, rather from FILENAME itself.  Store it in case the
+         caller wants to use it in a message.  */
       errno = makefile_errno;
-      return 0;
+      return deps;
     }
 
@@ -433 +447 @@
   alloca (0);
 
-  return 1;
+  errno = 0;
+  return deps;
 }
 
 void
-eval_buffer (char *buffer)
+eval_buffer (char *buffer, const floc *flocp)
 {
   struct ebuffer ebuf;
   struct conditionals *saved;
   struct conditionals new;
-  const struct floc *curfile;
+  const floc *curfile;
 
   /* Evaluate the buffer */
@@ -450 +465 @@
   ebuf.fp = NULL;
 
-  if (reading_file)
+  if (flocp)
+    ebuf.floc = *flocp;
+  else if (reading_file)
     ebuf.floc = *reading_file;
   else
-    ebuf.floc.filenm = NULL;
+    {
+      ebuf.floc.filenm = NULL;
+      ebuf.floc.lineno = 1;
+      ebuf.floc.offset = 0;
+    }
 
   curfile = reading_file;
@@ -488 +509 @@
 
   /* Find the start of the next token.  If there isn't one we're done.  */
-  line = next_token (line);
+  NEXT_TOKEN (line);
   if (*line == '\0')
     return (char *)line;
@@ -497 +518 @@
       int wlen;
       const char *p2;
-      enum variable_flavor flavor;
-
-      p2 = parse_variable_definition (p, &flavor);
+      struct variable v;
+
+      p2 = parse_variable_definition (p, &v);
 
       /* If this is a variable assignment, we're done.  */
@@ -560 +581 @@
   unsigned int cmds_started, tgts_started;
   int ignoring = 0, in_ignored_define = 0;
-  int no_targets = 0;           /* Set when reading a rule without targets.  */
+  int no_targets = 0;           /* Set when reading a rule without targets.  */
   struct nameseq *filenames = 0;
   char *depstr = 0;
   long nlines = 0;
   int two_colon = 0;
+  char prefix = cmd_prefix;
   const char *pattern = 0;
   const char *pattern_percent;
-  struct floc *fstart;
-  struct floc fi;
-
-#define record_waiting_files()                                                \
-  do                                                                          \
-    {                                                                         \
-      if (filenames != 0)                                                     \
+  floc *fstart;
+  floc fi;
+
+#define record_waiting_files()                                                \
+  do                                                                          \
+    {                                                                         \
+      if (filenames != 0)                                                     \
         {                                                                     \
-          fi.lineno = tgts_started;                                           \
-          record_files (filenames, pattern, pattern_percent, depstr,          \
+          fi.lineno = tgts_started;                                           \
+          fi.offset = 0;                                                      \
+          record_files (filenames, pattern, pattern_percent, depstr,          \
                         cmds_started, commands, commands_idx, two_colon,      \
-                        &fi);                                                 \
-          filenames = 0;                                                      \
+                        prefix, &fi);                                         \
+          filenames = 0;                                                      \
         }                                                                     \
-      commands_idx = 0;                                                       \
+      commands_idx = 0;                                                       \
       no_targets = 0;                                                         \
       pattern = 0;                                                            \
@@ -598 +621 @@
 
      When you see a "continue" in the loop below, that means we are moving on
-     to the next line _without_ ending any rule that we happen to be working
-     with at the moment.  If you see a "goto rule_complete", then the
-     statement we just parsed also finishes the previous rule.  */
+     to the next line.  If you see record_waiting_files(), then the statement
+     we are parsing also finishes the previous rule.  */
 
   commands = xmalloc (200);
@@ -622 +644 @@
         break;
 
+      line = ebuf->buffer;
+
+      /* If this is the first line, check for a UTF-8 BOM and skip it.  */
+      if (ebuf->floc.lineno == 1 && line[0] == (char)0xEF
+          && line[1] == (char)0xBB && line[2] == (char)0xBF)
+        {
+          line += 3;
+          if (ISDB(DB_BASIC))
+            {
+              if (ebuf->floc.filenm)
+                printf (_("Skipping UTF-8 BOM in makefile '%s'\n"),
+                        ebuf->floc.filenm);
+              else
+                printf (_("Skipping UTF-8 BOM in makefile buffer\n"));
+            }
+        }
+
       /* If this line is empty, skip it.  */
-      line = ebuf->buffer;
       if (line[0] == '\0')
         continue;
@@ -630 +668 @@
 
       /* Check for a shell command line first.
-         If it is not one, we can stop treating tab specially.  */
+         If it is not one, we can stop treating cmd_prefix specially.  */
       if (line[0] == cmd_prefix)
-        {
-          if (no_targets)
-            /* Ignore the commands in a rule with no targets.  */
-            continue;
-
-          /* If there is no preceding rule line, don't treat this line
-             as a command, even though it begins with a recipe prefix.
-             SunOS 4 make appears to behave this way.  */
-
-          if (filenames != 0)
-            {
-              if (ignoring)
-                /* Yep, this is a shell command, and we don't care.  */
-                continue;
-
-              /* Append this command line to the line being accumulated.
-                 Strip command prefix chars that appear after newlines.  */
-              if (commands_idx == 0)
-                cmds_started = ebuf->floc.lineno;
-
-              if (linelen + commands_idx > commands_len)
-                {
-                  commands_len = (linelen + commands_idx) * 2;
-                  commands = xrealloc (commands, commands_len);
-                }
-              p = &commands[commands_idx];
-              p2 = line + 1;
-              while (--linelen)
+        {
+          if (no_targets)
+            /* Ignore the commands in a rule with no targets.  */
+            continue;
+
+          /* If there is no preceding rule line, don't treat this line
+             as a command, even though it begins with a recipe prefix.
+             SunOS 4 make appears to behave this way.  */
+
+          if (filenames != 0)
+            {
+              if (ignoring)
+                /* Yep, this is a shell command, and we don't care.  */
+                continue;
+
+              if (commands_idx == 0)
+                cmds_started = ebuf->floc.lineno;
+
+              /* Append this command line to the line being accumulated.
+                 Skip the initial command prefix character.  */
+              if (linelen + commands_idx > commands_len)
                 {
-                  ++commands_idx;
-                  *(p++) = *p2;
-                  if (p2[0] == '\n' && p2[1] == cmd_prefix)
-                    {
-                      ++p2;
-                      --linelen;
-                    }
-                  ++p2;
+                  commands_len = (linelen + commands_idx) * 2;
+                  commands = xrealloc (commands, commands_len);
                 }
-              *p = '\n';
-              ++commands_idx;
-
-              continue;
-            }
-        }
+              memcpy (&commands[commands_idx], line + 1, linelen - 1);
+              commands_idx += linelen - 1;
+              commands[commands_idx++] = '\n';
+              continue;
+            }
+        }
 
       /* This line is not a shell command line.  Don't worry about whitespace.
@@ -682 +707 @@
 
       if (collapsed_length < linelen+1)
-        {
-          collapsed_length = linelen+1;
-          if (collapsed)
-            free (collapsed);
+        {
+          collapsed_length = linelen+1;
+          free (collapsed);
           /* Don't need xrealloc: we don't need to preserve the content.  */
-          collapsed = xmalloc (collapsed_length);
-        }
+          collapsed = xmalloc (collapsed_length);
+        }
       strcpy (collapsed, line);
       /* Collapse continuation lines.  */
@@ -696 +720 @@
       /* Get rid if starting space (including formfeed, vtab, etc.)  */
       p = collapsed;
-      while (isspace ((unsigned char)*p))
-        ++p;
+      NEXT_TOKEN (p);
 
       /* See if this is a variable assignment.  We need to do this early, to
          allow variables with names like 'ifdef', 'export', 'private', etc.  */
-      p = parse_var_assignment(p, &vmod);
+      p = parse_var_assignment (p, &vmod);
       if (vmod.assign_v)
         {
@@ -708 +731 @@
 
           /* If we're ignoring then we're done now.  */
-          if (ignoring)
+          if (ignoring)
             {
               if (vmod.define_v)
@@ -715 +738 @@
             }
 
+          /* Variable assignment ends the previous rule.  */
+          record_waiting_files ();
+
           if (vmod.undefine_v)
           {
             do_undefine (p, origin, ebuf);
-
-            /* This line has been dealt with.  */
-            goto rule_complete;
+            continue;
           }
           else if (vmod.define_v)
@@ -735 +759 @@
 
           /* This line has been dealt with.  */
-          goto rule_complete;
+          continue;
         }
 
       /* If this line is completely empty, ignore it.  */
       if (*p == '\0')
-        continue;
+        continue;
 
       p2 = end_of_token (p);
       wlen = p2 - p;
-      p2 = next_token (p2);
+      NEXT_TOKEN (p2);
 
       /* If we're in an ignored define, skip this line (but maybe get out).  */
       if (in_ignored_define)
-        {
+        {
           /* See if this is an endef line (plus optional comment).  */
-          if (word1eq ("endef") && (*p2 == '\0' || *p2 == '#'))
+          if (word1eq ("endef") && STOP_SET (*p2, MAP_COMMENT|MAP_NUL))
             in_ignored_define = 0;
 
-          continue;
-        }
+          continue;
+        }
 
       /* Check for conditional state changes.  */
@@ -762 +786 @@
           {
             if (i == -1)
-              fatal (fstart, _("invalid syntax in conditional"));
+              O (fatal, fstart, _("invalid syntax in conditional"));
 
             ignoring = i;
@@ -771 +795 @@
       /* Nothing to see here... move along.  */
       if (ignoring)
-        continue;
+        continue;
 
       /* Manage the "export" keyword used outside of variable assignment
          as well as "unexport".  */
       if (word1eq ("export") || word1eq ("unexport"))
-        {
+        {
           int exporting = *p == 'u' ? 0 : 1;
 
+          /* Export/unexport ends the previous rule.  */
+          record_waiting_files ();
+
           /* (un)export by itself causes everything to be (un)exported. */
-          if (*p2 == '\0')
+          if (*p2 == '\0')
             export_all_variables = exporting;
           else
@@ -797 +824 @@
                   struct variable *v = lookup_variable (p, l);
                   if (v == 0)
-                    v = define_variable_loc (p, l, "", o_file, 0, fstart);
+                    v = define_variable_global (p, l, "", o_file, 0, fstart);
                   v->export = exporting ? v_export : v_noexport;
                 }
@@ -803 +830 @@
               free (ap);
             }
-          goto rule_complete;
-        }
+          continue;
+        }
 
       /* Handle the special syntax for vpath.  */
       if (word1eq ("vpath"))
-        {
+        {
           const char *cp;
-          char *vpat;
-          unsigned int l;
-          cp = variable_expand (p2);
-          p = find_next_token (&cp, &l);
-          if (p != 0)
-            {
-              vpat = xstrndup (p, l);
-              p = find_next_token (&cp, &l);
-              /* No searchpath means remove all previous
-                 selective VPATH's with the same pattern.  */
-            }
-          else
-            /* No pattern means remove all previous selective VPATH's.  */
-            vpat = 0;
-          construct_vpath_list (vpat, p);
-          if (vpat != 0)
-            free (vpat);
-
-          goto rule_complete;
-        }
+          char *vpat;
+          unsigned int l;
+
+          /* vpath ends the previous rule.  */
+          record_waiting_files ();
+
+          cp = variable_expand (p2);
+          p = find_next_token (&cp, &l);
+          if (p != 0)
+            {
+              vpat = xstrndup (p, l);
+              p = find_next_token (&cp, &l);
+              /* No searchpath means remove all previous
+                 selective VPATH's with the same pattern.  */
+            }
+          else
+            /* No pattern means remove all previous selective VPATH's.  */
+            vpat = 0;
+          construct_vpath_list (vpat, p);
+          free (vpat);
+
+          continue;
+        }
 
       /* Handle include and variants.  */
       if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude"))
-        {
-          /* We have found an `include' line specifying a nested
-             makefile to be read at this point.  */
-          struct conditionals *save;
+        {
+          /* We have found an 'include' line specifying a nested
+             makefile to be read at this point.  */
+          struct conditionals *save;
           struct conditionals new_conditionals;
-          struct nameseq *files;
-          /* "-include" (vs "include") says no error if the file does not
-             exist.  "sinclude" is an alias for this from SGI.  */
-          int noerror = (p[0] != 'i');
-
-          p = allocated_variable_expand (p2);
+          struct nameseq *files;
+          /* "-include" (vs "include") says no error if the file does not
+             exist.  "sinclude" is an alias for this from SGI.  */
+          int noerror = (p[0] != 'i');
+
+          /* Include ends the previous rule.  */
+          record_waiting_files ();
+
+          p = allocated_variable_expand (p2);
 
           /* If no filenames, it's a no-op.  */
-          if (*p == '\0')
+          if (*p == '\0')
             {
               free (p);
@@ -852 +885 @@
             }
 
-          /* Parse the list of file names.  Don't expand archive references!  */
-          p2 = p;
-          files = PARSE_FILE_SEQ (&p2, struct nameseq, '\0', NULL,
+          /* Parse the list of file names.  Don't expand archive references!  */
+          p2 = p;
+          files = PARSE_FILE_SEQ (&p2, struct nameseq, MAP_NUL, NULL,
                                   PARSEFS_NOAR);
-          free (p);
-
-          /* Save the state of conditionals and start
-             the included makefile with a clean slate.  */
-          save = install_conditionals (&new_conditionals);
-
-          /* Record the rules that are waiting so they will determine
-             the default goal before those in the included makefile.  */
-          record_waiting_files ();
-
-          /* Read each included makefile.  */
-          while (files != 0)
-            {
-              struct nameseq *next = files->next;
-              const char *name = files->name;
+          free (p);
+
+          /* Save the state of conditionals and start
+             the included makefile with a clean slate.  */
+          save = install_conditionals (&new_conditionals);
+
+          /* Record the rules that are waiting so they will determine
+             the default goal before those in the included makefile.  */
+          record_waiting_files ();
+
+          /* Read each included makefile.  */
+          while (files != 0)
+            {
+              struct nameseq *next = files->next;
+              int flags = (RM_INCLUDED | RM_NO_TILDE
+                           | (noerror ? RM_DONTCARE : 0)
+                           | (set_default ? 0 : RM_NO_DEFAULT_GOAL));
+
+              struct goaldep *d = eval_makefile (files->name, flags);
+
+              if (errno)
+                {
+                  d->error = (unsigned short)errno;
+                  d->floc = *fstart;
+                }
+
+              free_ns (files);
+              files = next;
+            }
+
+          /* Restore conditional state.  */
+          restore_conditionals (save);
+
+          continue;
+        }
+
+      /* Handle the load operations.  */
+      if (word1eq ("load") || word1eq ("-load"))
+        {
+          /* A 'load' line specifies a dynamic object to load.  */
+          struct nameseq *files;
+          int noerror = (p[0] == '-');
+
+          /* Load ends the previous rule.  */
+          record_waiting_files ();
+
+          p = allocated_variable_expand (p2);
+
+          /* If no filenames, it's a no-op.  */
+          if (*p == '\0')
+            {
+              free (p);
+              continue;
+            }
+
+          /* Parse the list of file names.
+             Don't expand archive references or strip "./"  */
+          p2 = p;
+          files = PARSE_FILE_SEQ (&p2, struct nameseq, MAP_NUL, NULL,
+                                  PARSEFS_NOAR);
+          free (p);
+
+          /* Load each file.  */
+          while (files != 0)
+            {
+              struct nameseq *next = files->next;
+              const char *name = files->name;
+              struct goaldep *deps;
               int r;
 
-              free_ns (files);
-              files = next;
-
-              r = eval_makefile (name,
-                                 (RM_INCLUDED | RM_NO_TILDE
-                                  | (noerror ? RM_DONTCARE : 0)
-                                  | (set_default ? 0 : RM_NO_DEFAULT_GOAL)));
-              if (!r && !noerror)
-                error (fstart, "%s: %s", name, strerror (errno));
-            }
-
-          /* Restore conditional state.  */
-          restore_conditionals (save);
-
-          goto rule_complete;
-        }
+              /* Load the file.  0 means failure.  */
+              r = load_file (&ebuf->floc, &name, noerror);
+              if (! r && ! noerror)
+                OS (fatal, &ebuf->floc, _("%s: failed to load"), name);
+
+              free_ns (files);
+              files = next;
+
+              /* Return of -1 means a special load: don't rebuild it.  */
+              if (r == -1)
+                continue;
+
+              /* It succeeded, so add it to the list "to be rebuilt".  */
+              deps = alloc_goaldep ();
+              deps->next = read_files;
+              read_files = deps;
+              deps->file = lookup_file (name);
+              if (deps->file == 0)
+                deps->file = enter_file (name);
+              deps->file->loaded = 1;
+            }
+
+          continue;
+        }
 
       /* This line starts with a tab but was not caught above because there
@@ -894 +988 @@
          variable definition.  But now we know it is definitely lossage.  */
       if (line[0] == cmd_prefix)
-        fatal(fstart, _("recipe commences before first target"));
+        O (fatal, fstart, _("recipe commences before first target"));
 
       /* This line describes some target files.  This is complicated by
          the existence of target-specific variables, because we can't
          expand the entire line until we know if we have one or not.  So
-         we expand the line word by word until we find the first `:',
+         we expand the line word by word until we find the first ':',
          then check to see if it's a target-specific variable.
 
-         In this algorithm, `lb_next' will point to the beginning of the
-         unexpanded parts of the input buffer, while `p2' points to the
+         In this algorithm, 'lb_next' will point to the beginning of the
+         unexpanded parts of the input buffer, while 'p2' points to the
          parts of the expanded buffer we haven't searched yet. */
 
@@ -920 +1014 @@
         /* Search the line for an unquoted ; that is not after an
            unquoted #.  */
-        cmdleft = find_char_unquote (line, ';', '#', 0, 1);
+        cmdleft = find_char_unquote (line, MAP_SEMI|MAP_COMMENT|MAP_VARIABLE);
         if (cmdleft != 0 && *cmdleft == '#')
           {
@@ -938 +1032 @@
            beginning, expanding as we go, and looking for "interesting"
            chars.  The first word is always expandable.  */
-        wtype = get_next_mword(line, NULL, &lb_next, &wlen);
+        wtype = get_next_mword (line, NULL, &lb_next, &wlen);
         switch (wtype)
           {
           case w_eol:
             if (cmdleft != 0)
-              fatal(fstart, _("missing rule before recipe"));
+              O (fatal, fstart, _("missing rule before recipe"));
             /* This line contained something but turned out to be nothing
                but whitespace (a comment?).  */
@@ -959 +1053 @@
           }
 
-        p2 = variable_expand_string(NULL, lb_next, wlen);
+        p2 = variable_expand_string (NULL, lb_next, wlen);
 
         while (1)
@@ -967 +1061 @@
               {
                 /* Look for a semicolon in the expanded line.  */
-                cmdleft = find_char_unquote (p2, ';', 0, 0, 0);
+                cmdleft = find_char_unquote (p2, MAP_SEMI);
 
                 if (cmdleft != 0)
@@ -973 +1067 @@
                     unsigned long p2_off = p2 - variable_buffer;
                     unsigned long cmd_off = cmdleft - variable_buffer;
-                    char *pend = p2 + strlen(p2);
+                    char *pend = p2 + strlen (p2);
 
                     /* Append any remnants of lb, then cut the line short
@@ -983 +1077 @@
                        and into a command script.  However, the old parser
                        expanded the whole line, so we continue that for
-                       backwards-compatiblity.  Also, it wouldn't be
+                       backwards-compatibility.  Also, it wouldn't be
                        entirely consistent, since we do an unconditional
                        expand below once we know we don't have a
                        target-specific variable. */
-                    (void)variable_expand_string(pend, lb_next, (long)-1);
-                    lb_next += strlen(lb_next);
+                    (void)variable_expand_string (pend, lb_next, (long)-1);
+                    lb_next += strlen (lb_next);
                     p2 = variable_buffer + p2_off;
                     cmdleft = variable_buffer + cmd_off + 1;
@@ -994 +1088 @@
               }
 
-            colonp = find_char_unquote(p2, ':', 0, 0, 0);
+            colonp = find_char_unquote (p2, MAP_COLON);
 #ifdef HAVE_DOS_PATHS
             /* The drive spec brain-damage strikes again...  */
@@ -1003 +1097 @@
                    colonp > p2 && isalpha ((unsigned char)colonp[-1]) &&
                    (colonp == p2 + 1 || strchr (" \t(", colonp[-2]) != 0))
-              colonp = find_char_unquote(colonp + 1, ':', 0, 0, 0);
+              colonp = find_char_unquote (colonp + 1, MAP_COLON);
 #endif
             if (colonp != 0)
               break;
 
-            wtype = get_next_mword(lb_next, NULL, &lb_next, &wlen);
+            wtype = get_next_mword (lb_next, NULL, &lb_next, &wlen);
             if (wtype == w_eol)
               break;
 
-            p2 += strlen(p2);
+            p2 += strlen (p2);
             *(p2++) = ' ';
-            p2 = variable_expand_string(p2, lb_next, wlen);
+            p2 = variable_expand_string (p2, lb_next, wlen);
             /* We don't need to worry about cmdleft here, because if it was
                found in the variable_buffer the entire buffer has already
@@ -1027 +1121 @@
         if (wtype == w_eol)
           {
-            if (*p2 != '\0')
-              /* There's no need to be ivory-tower about this: check for
-                 one of the most common bugs found in makefiles...  */
-              fatal (fstart, _("missing separator%s"),
-                     (cmd_prefix == '\t' && !strneq(line, "        ", 8))
-                     ? "" : _(" (did you mean TAB instead of 8 spaces?)"));
-            continue;
+            if (*p2 == '\0')
+              continue;
+
+            /* There's no need to be ivory-tower about this: check for
+               one of the most common bugs found in makefiles...  */
+            if (cmd_prefix == '\t' && strneq (line, "        ", 8))
+              O (fatal, fstart, _("missing separator (did you mean TAB instead of 8 spaces?)"));
+            else
+              O (fatal, fstart, _("missing separator"));
           }
 
         /* Make the colon the end-of-string so we know where to stop
-           looking for targets.  */
+           looking for targets.  Start there again once we're done.  */
         *colonp = '\0';
-        filenames = PARSE_FILE_SEQ (&p2, struct nameseq, '\0', NULL, 0);
-        *p2 = ':';
+        filenames = PARSE_SIMPLE_SEQ (&p2, struct nameseq);
+        *colonp = ':';
+        p2 = colonp;
 
         if (!filenames)
@@ -1077 +1174 @@
             if (semip)
               {
-                unsigned int l = p - variable_buffer;
+                unsigned int l = p2 - variable_buffer;
                 *(--semip) = ';';
                 collapse_continuations (semip);
                 variable_buffer_output (p2 + strlen (p2),
                                         semip, strlen (semip)+1);
-                p = variable_buffer + l;
+                p2 = variable_buffer + l;
               }
             record_target_var (filenames, p2,
@@ -1093 +1190 @@
         /* This is a normal target, _not_ a target-specific variable.
            Unquote any = in the dependency list.  */
-        find_char_unquote (lb_next, '=', 0, 0, 0);
+        find_char_unquote (lb_next, MAP_EQUALS);
+
+        /* Remember the command prefix for this target.  */
+        prefix = cmd_prefix;
 
         /* We have some targets, so don't ignore the following commands.  */
@@ -1108 +1208 @@
             if (cmdleft == 0)
               {
-                cmdleft = find_char_unquote (p2, ';', 0, 0, 0);
+                cmdleft = find_char_unquote (p2, MAP_SEMI);
                 if (cmdleft != 0)
                   *(cmdleft++) = '\0';
@@ -1114 +1214 @@
           }
 
-        /* Is this a static pattern rule: `target: %targ: %dep; ...'?  */
+        /* Is this a static pattern rule: 'target: %targ: %dep; ...'?  */
         p = strchr (p2, ':');
         while (p != 0 && p[-1] == '\\')
@@ -1140 +1240 @@
            OR a space around the :.
         */
-        if (p && !(isspace ((unsigned char)p[1]) || !p[1]
-                   || isspace ((unsigned char)p[-1])))
+        if (p && !(ISSPACE (p[1]) || !p[1] || ISSPACE (p[-1])))
           p = 0;
 #endif
@@ -1162 +1261 @@
           {
             struct nameseq *target;
-            target = PARSE_FILE_SEQ (&p2, struct nameseq, ':', NULL,
+            target = PARSE_FILE_SEQ (&p2, struct nameseq, MAP_COLON, NULL,
                                      PARSEFS_NOGLOB);
             ++p2;
             if (target == 0)
-              fatal (fstart, _("missing target pattern"));
+              O (fatal, fstart, _("missing target pattern"));
             else if (target->next != 0)
-              fatal (fstart, _("multiple target patterns"));
+              O (fatal, fstart, _("multiple target patterns"));
             pattern_percent = find_percent_cached (&target->name);
             pattern = target->name;
             if (pattern_percent == 0)
-              fatal (fstart, _("target pattern contains no `%%'"));
+              O (fatal, fstart, _("target pattern contains no '%%'"));
             free_ns (target);
           }
@@ -1225 +1324 @@
         if (set_default && default_goal_var->value[0] == '\0')
           {
-            const char *name;
             struct dep *d;
             struct nameseq *t = filenames;
@@ -1232 +1330 @@
               {
                 int reject = 0;
-                name = t->name;
+                const char *name = t->name;
 
                 /* We have nothing to do if this is an implicit rule. */
@@ -1238 +1336 @@
                   break;
 
-                /* See if this target's name does not start with a `.',
+                /* See if this target's name does not start with a '.',
                    unless it contains a slash.  */
                 if (*name == '.' && strchr (name, '/') == 0
@@ -1287 +1385 @@
 
       /* We get here except in the case that we just read a rule line.
-         Record now the last rule we read, so following spurious
-         commands are properly diagnosed.  */
- rule_complete:
+         Record now the last rule we read, so following spurious
+         commands are properly diagnosed.  */
       record_waiting_files ();
     }
 
-#undef  word1eq
+#undef word1eq
 
   if (conditionals->if_cmds)
-    fatal (fstart, _("missing `endif'"));
+    O (fatal, fstart, _("missing 'endif'"));
 
   /* At eof, record the last rule.  */
   record_waiting_files ();
 
-  if (collapsed)
-    free (collapsed);
+  free (collapsed);
   free (commands);
 }
@@ -1316 +1412 @@
   char *comment;
 
-  comment = find_char_unquote (line, '#', 0, 0, 0);
+  comment = find_char_unquote (line, MAP_COMMENT);
 
   if (comment != 0)
@@ -1323 +1419 @@
 }
 
-/* Execute a `undefine' directive.
+/* Execute a 'undefine' directive.
    The undefine line has already been read, and NAME is the name of
    the variable to be undefined. */
@@ -1336 +1432 @@
   name = next_token (var);
   if (*name == '\0')
-    fatal (&ebuf->floc, _("empty variable name"));
+    O (fatal, &ebuf->floc, _("empty variable name"));
   p = name + strlen (name) - 1;
-  while (p > name && isblank ((unsigned char)*p))
+  while (p > name && ISBLANK (*p))
     --p;
   p[1] = '\0';
@@ -1346 +1442 @@
 }
 
-/* Execute a `define' directive.
+/* Execute a 'define' directive.
    The first line has already been read, and NAME is the name of
    the variable to be defined.  The following lines remain to be read.  */
@@ -1354 +1450 @@
 {
   struct variable *v;
-  enum variable_flavor flavor;
-  struct floc defstart;
+  struct variable var;
+  floc defstart;
   int nlevels = 1;
   unsigned int length = 100;
   char *definition = xmalloc (length);
   unsigned int idx = 0;
-  char *p, *var;
+  char *p, *n;
 
   defstart = ebuf->floc;
 
-  p = parse_variable_definition (name, &flavor);
+  p = parse_variable_definition (name, &var);
   if (p == NULL)
     /* No assignment token, so assume recursive.  */
-    flavor = f_recursive;
+    var.flavor = f_recursive;
   else
     {
-      if (*(next_token (p)) != '\0')
-        error (&defstart, _("extraneous text after `define' directive"));
+      if (var.value[0] != '\0')
+        O (error, &defstart, _("extraneous text after 'define' directive"));
 
       /* Chop the string before the assignment token to get the name.  */
-      p[flavor == f_recursive ? -1 : -2] = '\0';
+      var.name[var.length] = '\0';
     }
 
   /* Expand the variable name and find the beginning (NAME) and end.  */
-  var = allocated_variable_expand (name);
-  name = next_token (var);
-  if (*name == '\0')
-    fatal (&defstart, _("empty variable name"));
+  n = allocated_variable_expand (name);
+  name = next_token (n);
+  if (name[0] == '\0')
+    O (fatal, &defstart, _("empty variable name"));
   p = name + strlen (name) - 1;
-  while (p > name && isblank ((unsigned char)*p))
+  while (p > name && ISBLANK (*p))
     --p;
   p[1] = '\0';
@@ -1396 +1492 @@
       /* If there is nothing left to be eval'd, there's no 'endef'!!  */
       if (nlines < 0)
-        fatal (&defstart, _("missing `endef', unterminated `define'"));
+        O (fatal, &defstart, _("missing 'endef', unterminated 'define'"));
 
       ebuf->floc.lineno += nlines;
@@ -1411 +1507 @@
 
           /* If this is another 'define', increment the level count.  */
-          if ((len == 6 || (len > 6 && isblank ((unsigned char)p[6])))
+          if ((len == 6 || (len > 6 && ISBLANK (p[6])))
               && strneq (p, "define", 6))
             ++nlevels;
@@ -1417 +1513 @@
           /* If this is an 'endef', decrement the count.  If it's now 0,
              we've found the last one.  */
-          else if ((len == 5 || (len > 5 && isblank ((unsigned char)p[5])))
+          else if ((len == 5 || (len > 5 && ISBLANK (p[5])))
                    && strneq (p, "endef", 5))
             {
@@ -1423 +1519 @@
               remove_comments (p);
               if (*(next_token (p)) != '\0')
-                error (&ebuf->floc,
-                       _("extraneous text after `endef' directive"));
+                O (error, &ebuf->floc,
+                   _("extraneous text after 'endef' directive"));
 
               if (--nlevels == 0)
@@ -1451 +1547 @@
     definition[idx - 1] = '\0';
 
-  v = do_variable_definition (&defstart, name, definition, origin, flavor, 0);
+  v = do_variable_definition (&defstart, name,
+                              definition, origin, var.flavor, 0);
   free (definition);
-  free (var);
+  free (n);
   return (v);
 }
@@ -1471 +1568 @@
 
 static int
-conditional_line (char *line, int len, const struct floc *flocp)
+conditional_line (char *line, int len, const floc *flocp)
 {
-  char *cmdname;
+  const char *cmdname;
   enum { c_ifdef, c_ifndef, c_ifeq, c_ifneq, c_else, c_endif } cmdtype;
   unsigned int i;
@@ -1479 +1576 @@
 
   /* Compare a word, both length and contents. */
-#define word1eq(s)      (len == sizeof(s)-1 && strneq (s, line, sizeof(s)-1))
-#define chkword(s, t)   if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
+#define word1eq(s)      (len == CSTRLEN (s) && strneq (s, line, CSTRLEN (s)))
+#define chkword(s, t)   if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
 
   /* Make sure this line is a conditional.  */
@@ -1493 +1590 @@
 
   /* Found one: skip past it and any whitespace after it.  */
-  line = next_token (line + len);
-
-#define EXTRANEOUS() error (flocp, _("Extraneous text after `%s' directive"), cmdname)
+  line += len;
+  NEXT_TOKEN (line);
+
+#define EXTRATEXT() OS (error, flocp, _("extraneous text after '%s' directive"), cmdname)
+#define EXTRACMD()  OS (fatal, flocp, _("extraneous '%s'"), cmdname)
 
   /* An 'endif' cannot contain extra text, and reduces the if-depth by 1  */
@@ -1501 +1600 @@
     {
       if (*line != '\0')
-        EXTRANEOUS ();
+        EXTRATEXT ();
 
       if (!conditionals->if_cmds)
-        fatal (flocp, _("extraneous `%s'"), cmdname);
+        EXTRACMD ();
 
       --conditionals->if_cmds;
@@ -1518 +1617 @@
 
       if (!conditionals->if_cmds)
-        fatal (flocp, _("extraneous `%s'"), cmdname);
+        EXTRACMD ();
 
       o = conditionals->if_cmds - 1;
 
       if (conditionals->seen_else[o])
-        fatal (flocp, _("only one `else' per conditional"));
+        O (fatal, flocp, _("only one 'else' per conditional"));
 
       /* Change the state of ignorance.  */
@@ -1549 +1648 @@
 
       /* Find the length of the next word.  */
-      for (p = line+1; *p != '\0' && !isspace ((unsigned char)*p); ++p)
+      for (p = line+1; ! STOP_SET (*p, MAP_SPACE|MAP_NUL); ++p)
         ;
       len = p - line;
 
       /* If it's 'else' or 'endif' or an illegal conditional, fail.  */
-      if (word1eq("else") || word1eq("endif")
+      if (word1eq ("else") || word1eq ("endif")
           || conditional_line (line, len, flocp) < 0)
-        EXTRANEOUS ();
+        EXTRATEXT ();
       else
         {
@@ -1586 +1685 @@
     }
 
-  /* Record that we have seen an `if...' but no `else' so far.  */
+  /* Record that we have seen an 'if...' but no 'else' so far.  */
   conditionals->seen_else[o] = 0;
 
@@ -1593 +1692 @@
     if (conditionals->ignoring[i])
       {
-        /* We are already ignoring, so just push a level to match the next
-           "else" or "endif", and keep ignoring.  We don't want to expand
-           variables in the condition.  */
-        conditionals->ignoring[o] = 1;
-        return 1;
+        /* We are already ignoring, so just push a level to match the next
+           "else" or "endif", and keep ignoring.  We don't want to expand
+           variables in the condition.  */
+        conditionals->ignoring[o] = 1;
+        return 1;
       }
 
@@ -1613 +1712 @@
       p = end_of_token (var);
       i = p - var;
-      p = next_token (p);
+      NEXT_TOKEN (p);
       if (*p != '\0')
-        return -1;
+        return -1;
 
       var[i] = '\0';
@@ -1633 +1732 @@
 
       if (termin != ',' && termin != '"' && termin != '\'')
-        return -1;
+        return -1;
 
       s1 = ++line;
       /* Find the end of the first string.  */
       if (termin == ',')
-        {
-          int count = 0;
-          for (; *line != '\0'; ++line)
-            if (*line == '(')
-              ++count;
-            else if (*line == ')')
-              --count;
-            else if (*line == ',' && count <= 0)
-              break;
-        }
+        {
+          int count = 0;
+          for (; *line != '\0'; ++line)
+            if (*line == '(')
+              ++count;
+            else if (*line == ')')
+              --count;
+            else if (*line == ',' && count <= 0)
+              break;
+        }
       else
-        while (*line != '\0' && *line != termin)
-          ++line;
+        while (*line != '\0' && *line != termin)
+          ++line;
 
       if (*line == '\0')
-        return -1;
+        return -1;
 
       if (termin == ',')
-        {
-          /* Strip blanks after the first string.  */
-          char *p = line++;
-          while (isblank ((unsigned char)p[-1]))
-            --p;
-          *p = '\0';
-        }
+        {
+          /* Strip blanks after the first string.  */
+          char *p = line++;
+          while (ISBLANK (p[-1]))
+            --p;
+          *p = '\0';
+        }
       else
-        *line++ = '\0';
+        *line++ = '\0';
 
       s2 = variable_expand (s1);
       /* We must allocate a new copy of the expanded string because
-         variable_expand re-uses the same buffer.  */
+         variable_expand re-uses the same buffer.  */
       l = strlen (s2);
       s1 = alloca (l + 1);
@@ -1674 +1773 @@
 
       if (termin != ',')
-        /* Find the start of the second string.  */
-        line = next_token (line);
+        /* Find the start of the second string.  */
+        NEXT_TOKEN (line);
 
       termin = termin == ',' ? ')' : *line;
       if (termin != ')' && termin != '"' && termin != '\'')
-        return -1;
+        return -1;
 
       /* Find the end of the second string.  */
       if (termin == ')')
-        {
-          int count = 0;
-          s2 = next_token (line);
-          for (line = s2; *line != '\0'; ++line)
-            {
-              if (*line == '(')
-                ++count;
-              else if (*line == ')')
-                {
-                  if (count <= 0)
-                    break;
-                  else
-                    --count;
-                }
-            }
-        }
+        {
+          int count = 0;
+          s2 = next_token (line);
+          for (line = s2; *line != '\0'; ++line)
+            {
+              if (*line == '(')
+                ++count;
+              else if (*line == ')')
+                {
+                  if (count <= 0)
+                    break;
+                  else
+                    --count;
+                }
+            }
+        }
       else
-        {
-          ++line;
-          s2 = line;
-          while (*line != '\0' && *line != termin)
-            ++line;
-        }
+        {
+          ++line;
+          s2 = line;
+          while (*line != '\0' && *line != termin)
+            ++line;
+        }
 
       if (*line == '\0')
-        return -1;
-
-      *line = '\0';
-      line = next_token (++line);
+        return -1;
+
+      *(line++) = '\0';
+      NEXT_TOKEN (line);
       if (*line != '\0')
-        EXTRANEOUS ();
+        EXTRATEXT ();
 
       s2 = variable_expand (s2);
@@ -1741 +1840 @@
 record_target_var (struct nameseq *filenames, char *defn,
                    enum variable_origin origin, struct vmodifiers *vmod,
-                   const struct floc *flocp)
+                   const floc *flocp)
 {
   struct nameseq *nextf;
@@ -1755 +1854 @@
       struct variable *v;
       const char *name = filenames->name;
-      const char *fname;
       const char *percent;
       struct pattern_var *p;
@@ -1780 +1878 @@
           else
             v->value = xstrdup (v->value);
-
-          fname = p->target;
         }
       else
@@ -1798 +1894 @@
 
           initialize_file_variables (f, 1);
-          fname = f->name;
 
           current_variable_set_list = f->variables;
           v = try_variable_definition (flocp, defn, origin, 1);
           if (!v)
-            fatal (flocp, _("Malformed target-specific variable definition"));
+            O (fatal, flocp, _("Malformed target-specific variable definition"));
           current_variable_set_list = global;
         }
@@ -1817 +1912 @@
         {
           struct variable *gv;
-          int len = strlen(v->name);
+          int len = strlen (v->name);
 
           gv = lookup_variable (v->name, len);
-          if (gv && (gv->origin == o_env_override || gv->origin == o_command))
+          if (gv && v != gv
+              && (gv->origin == o_env_override || gv->origin == o_command))
             {
-              if (v->value != 0)
-                free (v->value);
+              free (v->value);
               v->value = xstrdup (gv->value);
               v->origin = gv->origin;
@@ -1838 +1933 @@
    by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
    TWO_COLON is nonzero if a double colon was used.
-   If not nil, PATTERN is the `%' pattern to make this
+   If not nil, PATTERN is the '%' pattern to make this
    a static pattern rule, and PATTERN_PERCENT is a pointer
-   to the `%' within it.
+   to the '%' within it.
 
    The links of FILENAMES are freed, and so are any names in it
@@ -1850 +1945 @@
               unsigned int cmds_started, char *commands,
               unsigned int commands_idx, int two_colon,
-              const struct floc *flocp)
+              char prefix, const floc *flocp)
 {
   struct commands *cmds;
@@ -1862 +1957 @@
      See Savannah bug # 12124.  */
   if (snapped_deps)
-    fatal (flocp, _("prerequisites cannot be defined in recipes"));
+    O (fatal, flocp, _("prerequisites cannot be defined in recipes"));
 
   /* Determine if this is a pattern rule or not.  */
@@ -1874 +1969 @@
       cmds->fileinfo.filenm = flocp->filenm;
       cmds->fileinfo.lineno = cmds_started;
+      cmds->fileinfo.offset = 0;
       cmds->commands = xstrndup (commands, commands_idx);
       cmds->command_lines = 0;
+      cmds->recipe_prefix = prefix;
     }
   else
@@ -1884 +1981 @@
   if (depstr == 0)
     deps = 0;
-  else if (second_expansion && strchr (depstr, '$'))
-    {
-      deps = alloc_dep ();
-      deps->name = depstr;
-      deps->need_2nd_expansion = 1;
-      deps->staticpattern = pattern != 0;
-    }
   else
     {
-      deps = split_prereqs (depstr);
-      free (depstr);
-
-      /* We'll enter static pattern prereqs later when we have the stem.  We
-         don't want to enter pattern rules at all so that we don't think that
-         they ought to exist (make manual "Implicit Rule Search Algorithm",
-         item 5c).  */
-      if (! pattern && ! implicit_percent)
-        deps = enter_prereqs (deps, NULL);
+      depstr = unescape_char (depstr, ':');
+      if (second_expansion && strchr (depstr, '$'))
+        {
+          deps = alloc_dep ();
+          deps->name = depstr;
+          deps->need_2nd_expansion = 1;
+          deps->staticpattern = pattern != 0;
+        }
+      else
+        {
+          deps = split_prereqs (depstr);
+          free (depstr);
+
+          /* We'll enter static pattern prereqs later when we have the stem.
+             We don't want to enter pattern rules at all so that we don't
+             think that they ought to exist (make manual "Implicit Rule Search
+             Algorithm", item 5c).  */
+          if (! pattern && ! implicit_percent)
+            deps = enter_prereqs (deps, NULL);
+        }
     }
 
@@ -1915 +2016 @@
 
       if (pattern != 0)
-        fatal (flocp, _("mixed implicit and static pattern rules"));
+        O (fatal, flocp, _("mixed implicit and static pattern rules"));
 
       /* Count the targets to create an array of target names.
@@ -1938 +2039 @@
 
           if (implicit_percent == 0)
-            fatal (flocp, _("mixed implicit and normal rules"));
-
-          targets[c] = name;
-          target_pats[c] = implicit_percent;
+            O (fatal, flocp, _("mixed implicit and normal rules"));
+
+          targets[c] = name;
+          target_pats[c] = implicit_percent;
           ++c;
 
@@ -1971 +2072 @@
           posix_pedantic = 1;
           define_variable_cname (".SHELLFLAGS", "-ec", o_default, 0);
+          /* These default values are based on IEEE Std 1003.1-2008.  */
+          define_variable_cname ("ARFLAGS", "-rv", o_default, 0);
+          define_variable_cname ("CC", "c99", o_default, 0);
+          define_variable_cname ("CFLAGS", "-O", o_default, 0);
+          define_variable_cname ("FC", "fort77", o_default, 0);
+          define_variable_cname ("FFLAGS", "-O 1", o_default, 0);
+          define_variable_cname ("SCCSGETFLAGS", "-s", o_default, 0);
         }
       else if (streq (name, ".SECONDEXPANSION"))
         second_expansion = 1;
-#if !defined(WINDOWS32) && !defined (__MSDOS__) && !defined (__EMX__)
+#if !defined (__MSDOS__) && !defined (__EMX__)
       else if (streq (name, ".ONESHELL"))
         one_shell = 1;
@@ -1980 +2088 @@
 
       /* If this is a static pattern rule:
-         `targets: target%pattern: prereq%pattern; recipe',
+         'targets: target%pattern: prereq%pattern; recipe',
          make sure the pattern matches this target name.  */
       if (pattern && !pattern_matches (pattern, pattern_percent, name))
-        error (flocp, _("target `%s' doesn't match the target pattern"), name);
+        OS (error, flocp,
+            _("target '%s' doesn't match the target pattern"), name);
       else if (deps)
         /* If there are multiple targets, copy the chain DEPS for all but the
@@ -1992 +2101 @@
       /* Find or create an entry in the file database for this target.  */
       if (!two_colon)
-        {
-          /* Single-colon.  Combine this rule with the file's existing record,
-             if any.  */
-          f = enter_file (strcache_add (name));
-          if (f->double_colon)
-            fatal (flocp,
-                   _("target file `%s' has both : and :: entries"), f->name);
-
-          /* If CMDS == F->CMDS, this target was listed in this rule
-             more than once.  Just give a warning since this is harmless.  */
-          if (cmds != 0 && cmds == f->cmds)
-            error (flocp,
-                   _("target `%s' given more than once in the same rule."),
-                   f->name);
-
-          /* Check for two single-colon entries both with commands.
-             Check is_target so that we don't lose on files such as .c.o
-             whose commands were preinitialized.  */
-          else if (cmds != 0 && f->cmds != 0 && f->is_target)
-            {
-              error (&cmds->fileinfo,
-                     _("warning: overriding recipe for target `%s'"),
+        {
+          /* Single-colon.  Combine this rule with the file's existing record,
+             if any.  */
+          f = enter_file (strcache_add (name));
+          if (f->double_colon)
+            OS (fatal, flocp,
+                _("target file '%s' has both : and :: entries"), f->name);
+
+          /* If CMDS == F->CMDS, this target was listed in this rule
+             more than once.  Just give a warning since this is harmless.  */
+          if (cmds != 0 && cmds == f->cmds)
+            OS (error, flocp,
+                _("target '%s' given more than once in the same rule"),
+                f->name);
+
+          /* Check for two single-colon entries both with commands.
+             Check is_target so that we don't lose on files such as .c.o
+             whose commands were preinitialized.  */
+          else if (cmds != 0 && f->cmds != 0 && f->is_target)
+            {
+              size_t l = strlen (f->name);
+              error (&cmds->fileinfo, l,
+                     _("warning: overriding recipe for target '%s'"),
                      f->name);
-              error (&f->cmds->fileinfo,
-                     _("warning: ignoring old recipe for target `%s'"),
+              error (&f->cmds->fileinfo, l,
+                     _("warning: ignoring old recipe for target '%s'"),
                      f->name);
-            }
-
-          /* Defining .DEFAULT with no deps or cmds clears it.  */
-          if (f == default_file && this == 0 && cmds == 0)
-            f->cmds = 0;
-          if (cmds != 0)
-            f->cmds = cmds;
-
-          /* Defining .SUFFIXES with no dependencies clears out the list of
-             suffixes.  */
-          if (f == suffix_file && this == 0)
-            {
+            }
+
+          /* Defining .DEFAULT with no deps or cmds clears it.  */
+          if (f == default_file && this == 0 && cmds == 0)
+            f->cmds = 0;
+          if (cmds != 0)
+            f->cmds = cmds;
+
+          /* Defining .SUFFIXES with no dependencies clears out the list of
+             suffixes.  */
+          if (f == suffix_file && this == 0)
+            {
               free_dep_chain (f->deps);
-              f->deps = 0;
-            }
-        }
+              f->deps = 0;
+            }
+        }
       else
-        {
-          /* Double-colon.  Make a new record even if there already is one.  */
-          f = lookup_file (name);
-
-          /* Check for both : and :: rules.  Check is_target so we don't lose
-             on default suffix rules or makefiles.  */
-          if (f != 0 && f->is_target && !f->double_colon)
-            fatal (flocp,
-                   _("target file `%s' has both : and :: entries"), f->name);
-
-          f = enter_file (strcache_add (name));
-          /* If there was an existing entry and it was a double-colon entry,
-             enter_file will have returned a new one, making it the prev
-             pointer of the old one, and setting its double_colon pointer to
-             the first one.  */
-          if (f->double_colon == 0)
-            /* This is the first entry for this name, so we must set its
-               double_colon pointer to itself.  */
-            f->double_colon = f;
-
-          f->cmds = cmds;
-        }
+        {
+          /* Double-colon.  Make a new record even if there already is one.  */
+          f = lookup_file (name);
+
+          /* Check for both : and :: rules.  Check is_target so we don't lose
+             on default suffix rules or makefiles.  */
+          if (f != 0 && f->is_target && !f->double_colon)
+            OS (fatal, flocp,
+                _("target file '%s' has both : and :: entries"), f->name);
+
+          f = enter_file (strcache_add (name));
+          /* If there was an existing entry and it was a double-colon entry,
+             enter_file will have returned a new one, making it the prev
+             pointer of the old one, and setting its double_colon pointer to
+             the first one.  */
+          if (f->double_colon == 0)
+            /* This is the first entry for this name, so we must set its
+               double_colon pointer to itself.  */
+            f->double_colon = f;
+
+          f->cmds = cmds;
+        }
 
       f->is_target = 1;
 
       /* If this is a static pattern rule, set the stem to the part of its
-         name that matched the `%' in the pattern, so you can use $* in the
+         name that matched the '%' in the pattern, so you can use $* in the
          commands.  If we didn't do it before, enter the prereqs now.  */
       if (pattern)
@@ -2119 +2229 @@
       name = filenames->name;
       if (find_percent_cached (&name))
-        fatal (flocp, _("mixed implicit and normal rules"));
+        O (error, flocp,
+           _("*** mixed implicit and normal rules: deprecated syntax"));
     }
 }
@@ -2134 +2245 @@
 
 static char *
-find_char_unquote (char *string, int stop1, int stop2, int blank,
-                   int ignorevars)
+find_char_unquote (char *string, int map)
 {
   unsigned int string_len = 0;
   char *p = string;
 
-  if (ignorevars)
-    ignorevars = '$';
+  /* Always stop on NUL.  */
+  map |= MAP_NUL;
 
   while (1)
     {
-      if (stop2 && blank)
-        while (*p != '\0' && *p != ignorevars && *p != stop1 && *p != stop2
-               && ! isblank ((unsigned char) *p))
-          ++p;
-      else if (stop2)
-        while (*p != '\0' && *p != ignorevars && *p != stop1 && *p != stop2)
-          ++p;
-      else if (blank)
-        while (*p != '\0' && *p != ignorevars && *p != stop1
-               && ! isblank ((unsigned char) *p))
-          ++p;
-      else
-        while (*p != '\0' && *p != ignorevars && *p != stop1)
-          ++p;
+      while (! STOP_SET (*p, map))
+        ++p;
 
       if (*p == '\0')
-        break;
+        break;
 
       /* If we stopped due to a variable reference, skip over its contents.  */
-      if (*p == ignorevars)
+      if (STOP_SET (*p, MAP_VARIABLE))
         {
           char openparen = p[1];
+
+          /* Check if '$' is the last character in the string.  */
+          if (openparen == '\0')
+            break;
 
           p += 2;
@@ -2195 +2297 @@
 
       if (p > string && p[-1] == '\\')
-        {
-          /* Search for more backslashes.  */
-          int i = -2;
-          while (&p[i] >= string && p[i] == '\\')
-            --i;
-          ++i;
-          /* Only compute the length if really needed.  */
-          if (string_len == 0)
-            string_len = strlen (string);
-          /* The number of backslashes is now -I.
-             Copy P over itself to swallow half of them.  */
-          memmove (&p[i], &p[i/2], (string_len - (p - string)) - (i/2) + 1);
-          p += i/2;
-          if (i % 2 == 0)
-            /* All the backslashes quoted each other; the STOPCHAR was
-               unquoted.  */
-            return p;
-
-          /* The STOPCHAR was quoted by a backslash.  Look for another.  */
-        }
+        {
+          /* Search for more backslashes.  */
+          int i = -2;
+          while (&p[i] >= string && p[i] == '\\')
+            --i;
+          ++i;
+          /* Only compute the length if really needed.  */
+          if (string_len == 0)
+            string_len = strlen (string);
+          /* The number of backslashes is now -I.
+             Copy P over itself to swallow half of them.  */
+          memmove (&p[i], &p[i/2], (string_len - (p - string)) - (i/2) + 1);
+          p += i/2;
+          if (i % 2 == 0)
+            /* All the backslashes quoted each other; the STOPCHAR was
+               unquoted.  */
+            return p;
+
+          /* The STOPCHAR was quoted by a backslash.  Look for another.  */
+        }
       else
-        /* No backslash in sight.  */
-        return p;
+        /* No backslash in sight.  */
+        return p;
     }
 
@@ -2224 +2326 @@
 }
 
+/* Unescape a character in a string.  The string is compressed onto itself.  */
+
+static char *
+unescape_char (char *string, int c)
+{
+  char *p = string;
+  char *s = string;
+
+  while (*s != '\0')
+    {
+      if (*s == '\\')
+        {
+          char *e = s;
+          int l;
+
+          /* We found a backslash.  See if it's escaping our character.  */
+          while (*e == '\\')
+            ++e;
+          l = e - s;
+
+          if (*e != c || l%2 == 0)
+            {
+              /* It's not; just take it all without unescaping.  */
+              memmove (p, s, l);
+              p += l;
+
+              // If we hit the end of the string, we're done
+              if (*e == '\0')
+                break;
+            }
+          else if (l > 1)
+            {
+              /* It is, and there's >1 backslash.  Take half of them.  */
+              l /= 2;
+              memmove (p, s, l);
+              p += l;
+            }
+
+          s = e;
+        }
+
+      *(p++) = *(s++);
+    }
+
+  *p = '\0';
+  return string;
+}
+
 /* Search PATTERN for an unquoted % and handle quoting.  */
 
@@ -2229 +2379 @@
 find_percent (char *pattern)
 {
-  return find_char_unquote (pattern, '%', 0, 0, 0);
+  return find_char_unquote (pattern, MAP_PERCENT);
 }
 
@@ -2252 +2402 @@
   while (1)
     {
-      while (*p != '\0' && *p != '%')
+      while (! STOP_SET (*p, MAP_PERCENT|MAP_NUL))
         ++p;
 
@@ -2322 +2472 @@
  */
 
-static unsigned long
+static long
 readstring (struct ebuffer *ebuf)
 {
@@ -2394 +2544 @@
       len = strlen (p);
       if (len == 0)
-        {
-          /* This only happens when the first thing on the line is a '\0'.
-             It is a pretty hopeless case, but (wonder of wonders) Athena
-             lossage strikes again!  (xmkmf puts NULs in its makefiles.)
-             There is nothing really to be done; we synthesize a newline so
-             the following line doesn't appear to be part of this line.  */
-          error (&ebuf->floc,
-                 _("warning: NUL character seen; rest of line ignored"));
-          p[0] = '\n';
-          len = 1;
-        }
+        {
+          /* This only happens when the first thing on the line is a '\0'.
+             It is a pretty hopeless case, but (wonder of wonders) Athena
+             lossage strikes again!  (xmkmf puts NULs in its makefiles.)
+             There is nothing really to be done; we synthesize a newline so
+             the following line doesn't appear to be part of this line.  */
+          O (error, &ebuf->floc,
+             _("warning: NUL character seen; rest of line ignored"));
+          p[0] = '\n';
+          len = 1;
+        }
 
       /* Jump past the text we just read.  */
@@ -2423 +2573 @@
         {
           --p;
-          p[-1] = '\n';
+          memmove (p-1, p, strlen (p) + 1);
         }
 #endif
@@ -2429 +2579 @@
       backslash = 0;
       for (p2 = p - 2; p2 >= start; --p2)
-        {
-          if (*p2 != '\\')
-            break;
+        {
+          if (*p2 != '\\')
+            break;
           backslash = !backslash;
-        }
+        }
 
       if (!backslash)
-        {
-          p[-1] = '\0';
-          break;
-        }
+        {
+          p[-1] = '\0';
+          break;
+        }
 
       /* It was a backslash/newline combo.  If we have more space, read
@@ -2483 +2633 @@
      w_dcolon       A double-colon
      w_semicolon    A semicolon
-     w_varassign    A variable assignment operator (=, :=, +=, or ?=)
+     w_varassign    A variable assignment operator (=, :=, ::=, +=, ?=, or !=)
 
    Note that this function is only used when reading certain parts of the
@@ -2497 +2647 @@
 
   /* Skip any leading whitespace.  */
-  while (isblank ((unsigned char)*p))
+  while (ISBLANK (*p))
     ++p;
 
@@ -2522 +2672 @@
         case ':':
           ++p;
-          wtype = w_dcolon;
+          if (p[1] != '=')
+            wtype = w_dcolon;
+          else
+            {
+              wtype = w_varassign;
+              ++p;
+            }
           break;
 
@@ -2534 +2690 @@
     case '+':
     case '?':
+    case '!':
       if (*p == '=')
         {
@@ -2553 +2710 @@
   /* This is some non-operator word.  A word consists of the longest
      string of characters that doesn't contain whitespace, one of [:=#],
-     or [?+]=, or one of the chars in the DELIM string.  */
+     or [?+!]=, or one of the chars in the DELIM string.  */
 
   /* We start out assuming a static word; if we see a variable we'll
@@ -2575 +2732 @@
         case ':':
 #ifdef HAVE_DOS_PATHS
-          /* A word CAN include a colon in its drive spec.  The drive
-             spec is allowed either at the beginning of a word, or as part
-             of the archive member name, like in "libfoo.a(d:/foo/bar.o)".  */
-          if (!(p - beg >= 2
-                && (*p == '/' || *p == '\\') && isalpha ((unsigned char)p[-2])
-                && (p - beg == 2 || p[-3] == '(')))
+          /* A word CAN include a colon in its drive spec.  The drive
+             spec is allowed either at the beginning of a word, or as part
+             of the archive member name, like in "libfoo.a(d:/foo/bar.o)".  */
+          if (!(p - beg >= 2
+                && (*p == '/' || *p == '\\') && isalpha ((unsigned char)p[-2])
+                && (p - beg == 2 || p[-3] == '(')))
 #endif
-          goto done_word;
+          goto done_word;
 
         case '$':
@@ -2588 +2745 @@
           if (c == '$')
             break;
+          if (c == '\0')
+            goto done_word;
 
           /* This is a variable reference, so note that it's expandable.
@@ -2657 +2816 @@
 construct_include_path (const char **arg_dirs)
 {
-#ifdef VAXC             /* just don't ask ... */
+#ifdef VAXC             /* just don't ask ... */
   stat_t stbuf;
 #else
@@ -2688 +2847 @@
     while (*arg_dirs != 0)
       {
-        const char *dir = *(arg_dirs++);
+        const char *dir = *(arg_dirs++);
         char *expanded = 0;
         int e;
 
-        if (dir[0] == '~')
-          {
-            expanded = tilde_expand (dir);
-            if (expanded != 0)
-              dir = expanded;
-          }
+        if (dir[0] == '~')
+          {
+            expanded = tilde_expand (dir);
+            if (expanded != 0)
+              dir = expanded;
+          }
 
         EINTRLOOP (e, stat (dir, &stbuf));
-        if (e == 0 && S_ISDIR (stbuf.st_mode))
+        if (e == 0 && S_ISDIR (stbuf.st_mode))
           {
             unsigned int len = strlen (dir);
@@ -2711 +2870 @@
           }
 
-        if (expanded)
-          free (expanded);
+        free (expanded);
       }
 
@@ -2726 +2884 @@
       {
         unsigned int len = strlen (djdir->value) + 8;
-        char *defdir = alloca (len + 1);
-
-        strcat (strcpy (defdir, djdir->value), "/include");
-        dirs[idx++] = strcache_add (defdir);
+        char *defdir = alloca (len + 1);
+
+        strcat (strcpy (defdir, djdir->value), "/include");
+        dirs[idx++] = strcache_add (defdir);
 
         if (len > max_incl_len)
@@ -2775 +2933 @@
   if (name[1] == '/' || name[1] == '\0')
     {
-      extern char *getenv ();
       char *home_dir;
       int is_variable;
 
       {
-        /* Turn off --warn-undefined-variables while we expand HOME.  */
-        int save = warn_undefined_variables_flag;
-        warn_undefined_variables_flag = 0;
-
-        home_dir = allocated_variable_expand ("$(HOME)");
-
-        warn_undefined_variables_flag = save;
+        /* Turn off --warn-undefined-variables while we expand HOME.  */
+        int save = warn_undefined_variables_flag;
+        warn_undefined_variables_flag = 0;
+
+        home_dir = allocated_variable_expand ("$(HOME)");
+
+        warn_undefined_variables_flag = save;
       }
 
       is_variable = home_dir[0] != '\0';
       if (!is_variable)
-        {
-          free (home_dir);
-          home_dir = getenv ("HOME");
-        }
+        {
+          free (home_dir);
+          home_dir = getenv ("HOME");
+        }
 # if !defined(_AMIGA) && !defined(WINDOWS32)
       if (home_dir == 0 || home_dir[0] == '\0')
-        {
-          extern char *getlogin ();
-          char *logname = getlogin ();
-          home_dir = 0;
-          if (logname != 0)
-            {
-              struct passwd *p = getpwnam (logname);
-              if (p != 0)
-                home_dir = p->pw_dir;
-            }
-        }
+        {
+          char *logname = getlogin ();
+          home_dir = 0;
+          if (logname != 0)
+            {
+              struct passwd *p = getpwnam (logname);
+              if (p != 0)
+                home_dir = p->pw_dir;
+            }
+        }
 # endif /* !AMIGA && !WINDOWS32 */
       if (home_dir != 0)
-        {
-          char *new = xstrdup (concat (2, home_dir, name + 1));
-          if (is_variable)
-            free (home_dir);
-          return new;
-        }
+        {
+          char *new = xstrdup (concat (2, home_dir, name + 1));
+          if (is_variable)
+            free (home_dir);
+          return new;
+        }
     }
 # if !defined(_AMIGA) && !defined(WINDOWS32)
@@ -2823 +2979 @@
       char *userend = strchr (name + 1, '/');
       if (userend != 0)
-        *userend = '\0';
+        *userend = '\0';
       pwent = getpwnam (name + 1);
       if (pwent != 0)
-        {
-          if (userend == 0)
-            return xstrdup (pwent->pw_dir);
-          else
-            return xstrdup (concat (3, pwent->pw_dir, "/", userend + 1));
-        }
+        {
+          if (userend == 0)
+            return xstrdup (pwent->pw_dir);
+          else
+            return xstrdup (concat (3, pwent->pw_dir, "/", userend + 1));
+        }
       else if (userend != 0)
-        *userend = '/';
+        *userend = '/';
     }
 # endif /* !AMIGA && !WINDOWS32 */
@@ -2865 +3021 @@
 
 void *
-parse_file_seq (char **stringp, unsigned int size, int stopchar,
+parse_file_seq (char **stringp, unsigned int size, int stopmap,
                 const char *prefix, int flags)
 {
-  extern void dir_setup_glob (glob_t *glob);
-
   /* tmp points to tmpbuf after the prefix, if any.
      tp is the end of the buffer. */
   static char *tmpbuf = NULL;
-  static int tmpbuf_len = 0;
-
-  int cachep = (! (flags & PARSEFS_NOCACHE));
+
+  int cachep = NONE_SET (flags, PARSEFS_NOCACHE);
 
   struct nameseq *new = 0;
@@ -2890 +3043 @@
   char *tp;
 
-#ifdef VMS
-# define VMS_COMMA ','
-#else
-# define VMS_COMMA 0
-#endif
+  /* Always stop on NUL.  */
+  stopmap |= MAP_NUL;
 
   if (size < sizeof (struct nameseq))
     size = sizeof (struct nameseq);
 
-  if (! (flags & PARSEFS_NOGLOB))
+  if (NONE_SET (flags, PARSEFS_NOGLOB))
     dir_setup_glob (&gl);
 
   /* Get enough temporary space to construct the largest possible target.  */
   {
+    static int tmpbuf_len = 0;
     int l = strlen (*stringp) + 1;
     if (l > tmpbuf_len)
@@ -2920 +3071 @@
       const char **nlist = 0;
       char *tildep = 0;
+      int globme = 1;
 #ifndef NO_ARCHIVES
       char *arname = 0;
@@ -2929 +3081 @@
 
       /* Skip whitespace; at the end of the string or STOPCHAR we're done.  */
-      p = next_token (p);
-      if (*p == '\0' || *p == stopchar)
-        break;
+      NEXT_TOKEN (p);
+      if (STOP_SET (*p, stopmap))
+        break;
 
       /* There are names left, so find the end of the next name.
          Throughout this iteration S points to the start.  */
       s = p;
-      p = find_char_unquote (p, stopchar, VMS_COMMA, 1, 0);
+      p = find_char_unquote (p, stopmap|MAP_VMSCOMMA|MAP_BLANK);
 #ifdef VMS
-        /* convert comma separated list to space separated */
+        /* convert comma separated list to space separated */
       if (p && *p == ',')
-        *p =' ';
+        *p =' ';
 #endif
 #ifdef _AMIGA
-      if (stopchar == ':' && p && *p == ':'
-          && !(isspace ((unsigned char)p[1]) || !p[1]
-               || isspace ((unsigned char)p[-1])))
-        p = find_char_unquote (p+1, stopchar, VMS_COMMA, 1, 0);
+      if (p && STOP_SET (*p, stopmap & MAP_COLON)
+          && !(ISSPACE (p[1]) || !p[1] || ISSPACE (p[-1])))
+        p = find_char_unquote (p+1, stopmap|MAP_VMSCOMMA|MAP_BLANK);
 #endif
 #ifdef HAVE_DOS_PATHS
@@ -2953 +3104 @@
        Note that tokens separated by spaces should be treated as separate
        tokens since make doesn't allow path names with spaces */
-    if (stopchar == ':')
-      while (p != 0 && !isspace ((unsigned char)*p) &&
+    if (stopmap | MAP_COLON)
+      while (p != 0 && !ISSPACE (*p) &&
              (p[1] == '\\' || p[1] == '/') && isalpha ((unsigned char)p[-1]))
-        p = find_char_unquote (p + 1, stopchar, VMS_COMMA, 1, 0);
+        p = find_char_unquote (p + 1, stopmap|MAP_VMSCOMMA|MAP_BLANK);
 #endif
       if (p == 0)
-        p = s + strlen (s);
+        p = s + strlen (s);
 
       /* Strip leading "this directory" references.  */
-      if (! (flags & PARSEFS_NOSTRIP))
+      if (NONE_SET (flags, PARSEFS_NOSTRIP))
 #ifdef VMS
-        /* Skip leading `[]'s.  */
-        while (p - s > 2 && s[0] == '[' && s[1] == ']')
-#else
-        /* Skip leading `./'s.  */
-        while (p - s > 2 && s[0] == '.' && s[1] == '/')
+        /* Skip leading '[]'s. should only be one set or bug somwhere else */
+        if (p - s > 2 && s[0] == '[' && s[1] == ']')
+            s += 2;
+        /* Skip leading '<>'s. should only be one set or bug somwhere else */
+        if (p - s > 2 && s[0] == '<' && s[1] == '>')
+            s += 2;
 #endif
-          {
+        /* Skip leading './'s.  */
+        while (p - s > 2 && s[0] == '.' && s[1] == '/')
+          {
             /* Skip "./" and all following slashes.  */
-            s += 2;
-            while (*s == '/')
-              ++s;
-          }
+            s += 2;
+            while (*s == '/')
+              ++s;
+          }
 
       /* Extract the filename just found, and skip it.
@@ -2982 +3136 @@
       if (s == p)
         {
-        /* The name was stripped to empty ("./"). */
-#if defined(VMS)
-          continue;
-#elif defined(_AMIGA)
+        /* The name was stripped to empty ("./"). */
+#if defined(_AMIGA)
           /* PDS-- This cannot be right!! */
           tp[0] = '\0';
@@ -2997 +3149 @@
         }
       else
-        {
+        {
 #ifdef VMS
 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
@@ -3003 +3155 @@
  * xstrdup called because S may be read-only string constant.
  */
-          char *n = tp;
-          while (s < p)
-            {
-              if (s[0] == '\\' && s[1] == ':')
+          char *n = tp;
+          while (s < p)
+            {
+              if (s[0] == '\\' && s[1] == ':')
                 ++s;
-              *(n++) = *(s++);
-            }
+              *(n++) = *(s++);
+            }
           n[0] = '\0';
           nlen = strlen (tp);
@@ -3028 +3180 @@
 
          TP == TMP means we're not already in an archive group.  Ignore
-         something starting with `(', as that cannot actually be an
+         something starting with '(', as that cannot actually be an
          archive-member reference (and treating it as such results in an empty
          file name, which causes much lossage).  Also if it ends in ")" then
@@ -3036 +3188 @@
          character, so ensure there's some word ending like that before
          considering this an archive group.  */
-      if (! (flags & PARSEFS_NOAR)
+      if (NONE_SET (flags, PARSEFS_NOAR)
           && tp == tmpbuf && tp[0] != '(' && tp[nlen-1] != ')')
         {
@@ -3044 +3196 @@
               /* This looks like the first element in an open archive group.
                  A valid group MUST have ')' as the last character.  */
-              const char *e = p + nlen;
+              const char *e = p;
               do
                 {
-                  e = next_token (e);
+                  const char *o = e;
+                  NEXT_TOKEN (e);
                   /* Find the end of this word.  We don't want to unquote and
                      we don't care about quoting since we're looking for the
                      last char in the word. */
-                  while (*e != '\0' && *e != stopchar && *e != VMS_COMMA
-                         && ! isblank ((unsigned char) *e))
+                  while (! STOP_SET (*e, stopmap|MAP_BLANK|MAP_VMSCOMMA))
                     ++e;
+                  /* If we didn't move, we're done now.  */
+                  if (e == o)
+                    break;
                   if (e[-1] == ')')
                     {
@@ -3062 +3217 @@
                       tp = n + 1;
 
-                      /* If we have just "lib(", part of something like
-                         "lib( a b)", go to the next item.  */
-                      if (! nlen)
-                        continue;
-
                       /* We can stop looking now.  */
                       break;
@@ -3072 +3222 @@
                 }
               while (*e != '\0');
+
+              /* If we have just "lib(", part of something like "lib( a b)",
+                 go to the next item.  */
+              if (! nlen)
+                continue;
             }
         }
@@ -3098 +3253 @@
       /* If we're not globbing we're done: add it to the end of the chain.
          Go to the next item in the string.  */
-      if (flags & PARSEFS_NOGLOB)
-        {
-          NEWELT (concat (2, prefix, tp));
+      if (ANY_SET (flags, PARSEFS_NOGLOB))
+        {
+          NEWELT (concat (2, prefix, tmpbuf));
           continue;
         }
@@ -3107 +3262 @@
          TP is a string in tmpbuf.  NLEN is no longer used.
          We may need to do more work: after this NAME will be set.  */
-      name = tp;
+      name = tmpbuf;
 
       /* Expand tilde if applicable.  */
-      if (tp[0] == '~')
-        {
-          tildep = tilde_expand (tp);
-          if (tildep != 0)
+      if (tmpbuf[0] == '~')
+        {
+          tildep = tilde_expand (tmpbuf);
+          if (tildep != 0)
             name = tildep;
-        }
+        }
 
 #ifndef NO_ARCHIVES
@@ -3121 +3276 @@
          file name, and save the member name in MEMNAME.  We will glob on the
          archive name and then reattach MEMNAME later.  */
-      if (! (flags & PARSEFS_NOAR) && ar_name (name))
-        {
-          ar_parse_name (name, &arname, &memname);
-          name = arname;
-        }
+      if (NONE_SET (flags, PARSEFS_NOAR) && ar_name (name))
+        {
+          ar_parse_name (name, &arname, &memname);
+          name = arname;
+        }
 #endif /* !NO_ARCHIVES */
 
-      switch (glob (name, GLOB_NOSORT|GLOB_ALTDIRFUNC, NULL, &gl))
-        {
-        case GLOB_NOSPACE:
-          fatal (NILF, _("virtual memory exhausted"));
-
-        case 0:
-          /* Success.  */
-          i = gl.gl_pathc;
-          nlist = (const char **)gl.gl_pathv;
-          break;
-
-        case GLOB_NOMATCH:
-          /* If we want only existing items, skip this one.  */
-          if (flags & PARSEFS_EXISTS)
-            {
-              i = 0;
-              break;
-            }
-          /* FALLTHROUGH */
-
-        default:
-          /* By default keep this name.  */
+      /* glob() is expensive: don't call it unless we need to.  */
+      if (NONE_SET (flags, PARSEFS_EXISTS) && strpbrk (name, "?*[") == NULL)
+        {
+          globme = 0;
           i = 1;
           nlist = &name;
-          break;
-        }
+        }
+      else
+        switch (glob (name, GLOB_NOSORT|GLOB_ALTDIRFUNC, NULL, &gl))
+          {
+          case GLOB_NOSPACE:
+            OUT_OF_MEM();
+
+          case 0:
+            /* Success.  */
+            i = gl.gl_pathc;
+            nlist = (const char **)gl.gl_pathv;
+            break;
+
+          case GLOB_NOMATCH:
+            /* If we want only existing items, skip this one.  */
+            if (ANY_SET (flags, PARSEFS_EXISTS))
+              {
+                i = 0;
+                break;
+              }
+            /* FALLTHROUGH */
+
+          default:
+            /* By default keep this name.  */
+            i = 1;
+            nlist = &name;
+            break;
+          }
 
       /* For each matched element, add it to the list.  */
@@ -3168 +3331 @@
               {
                 /* We got a chain of items.  Attach them.  */
-                (*newp)->next = found;
+                if (*newp)
+                  (*newp)->next = found;
+                else
+                  *newp = found;
 
                 /* Find and set the new end.  Massage names if necessary.  */
@@ -3190 +3356 @@
           NEWELT (concat (2, prefix, nlist[i]));
 
-      globfree (&gl);
+      if (globme)
+        globfree (&gl);
 
 #ifndef NO_ARCHIVES
-      if (arname)
-        free (arname);
+      free (arname);
 #endif
 
-      if (tildep)
-        free (tildep);
+      free (tildep);
     }