Changeset 3140 for trunk/src/kmk/read.c

Timestamp:

Mar 14, 2018, 10:28:10 PM (7 years ago)

Author:

bird

Message:

kmk: Merged in changes from GNU make 4.2.1 (2e55f5e4abdc0e38c1d64be703b446695e70b3b6 / ​https://git.savannah.gnu.org/git/make.git).

Location:

trunk/src/kmk

Files:

• . (modified) (1 prop)
• read.c (modified) (155 diffs)

trunk/src/kmk/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"
@@ -35 +31 @@
 #endif
 
-#ifndef WINDOWS32
+#ifdef WINDOWS32
+#include <windows.h>
+#include "sub_proc.h"
+#else  /* !WINDOWS32 */
 #ifndef _AMIGA
 #ifndef VMS
@@ -59 +58 @@
     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).  */
   };
 
@@ -82 +81 @@
 
 
-/* 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'?  */
 #ifdef KMK
     char ignoring_first[8];
@@ -154 +153 @@
    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);
 
@@ -169 +168 @@
                                    enum variable_origin origin, struct ebuffer *ebuf);
 #ifndef CONFIG_WITH_VALUE_LENGTH
-static int conditional_line (char *line, int len, const struct floc *flocp);
-#else
-static int conditional_line (char *line, char *eol, int len, const struct floc *flocp);
+static int conditional_line (char *line, int len, const floc *flocp);
+#else
+static int conditional_line (char *line, char *eol, int len, const floc *flocp);
 #endif
 static void record_files (struct nameseq *filenames, const char *pattern,
@@ -177 +176 @@
                           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);
 #ifndef CONFIG_WITH_VALUE_LENGTH
 static void remove_comments (char *line);
-static char *find_char_unquote (char *string, int stop1, int stop2,
-                                int blank, int ignorevars);
-#else  /* CONFIG_WITH_VALUE_LENGTH */
-__inline static char *remove_comments (char *line, char *eol);
-__inline static char *find_char_unquote_0 (char *string, int stop1, char **eosp);
-static char * find_char_unquote_2 (char *string, int stop1, int stop2,
-                                   int blank, int ignorevars,
-                                   unsigned int string_len);
-MY_INLINE char *
-find_char_unquote (char *string, int stop1, int stop2, int blank, int ignorevars)
-{
-    if (!stop2 && !blank && !ignorevars)
-      {
-        char *p = strchr (string, stop1);
-        if (!p)
-          return NULL;
-        if (p <= string || p[-1] != '\\')
-          return p;
-        /* fall back on find_char_unquote_2 */
-      }
-    return find_char_unquote_2 (string, stop1, stop2, blank, ignorevars, 0);
-}
+static char *find_char_unquote (char *string, int map);
+#else /* CONFIG_WITH_VALUE_LENGTH */
+static char *remove_comments (char *line, char *eos);
+static char *find_char_unquote (char *string, int map, unsigned int string_len);
+K_INLINE char *find_char_unquote_0 (char *string, int stop1, int map, char **eosp);
 #endif /* CONFIG_WITH_VALUE_LENGTH */
+static char *unescape_char (char *string, int c);
 
 
@@ -214 +197 @@
    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)
 {
@@ -261 +244 @@
     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);
       }
 
@@ -274 +257 @@
     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;
       }
 
@@ -295 +272 @@
   if (num_makefiles == 0)
     {
-      static char *default_makefiles[] =
+      static const char *default_makefiles[] =
 #ifdef VMS
-        /* all lower case since readdir() (the vms version) 'lowercasifies' */
+        /* all lower case since readdir() (the vms version) 'lowercasifies' */
+        /* TODO: Above is not always true, this needs more work */
 # ifdef KMK
-        { "makefile.kmk", "makefile.vms", "gnumakefile.", "makefile.", 0 };
+        { "makefile.kmk", "makefile.vms", "gnumakefile.", "makefile.", 0 };
 # else
-        { "makefile.vms", "gnumakefile.", "makefile.", 0 };
+        { "makefile.vms", "gnumakefile", "makefile", 0 };
 # endif
 #else
 #ifdef _AMIGA
-        /* what's the deal here? no dots? */
 # ifdef KMK
-        { "Makefile.kmk", "makefile.kmk", "GNUmakefile", "Makefile", "SMakefile", 0 };
+        { "Makefile.kmk", "makefile.kmk", "GNUmakefile", "Makefile", "SMakefile", 0 };
 # else
-        { "GNUmakefile", "Makefile", "SMakefile", 0 };
+        { "GNUmakefile", "Makefile", "SMakefile", 0 };
 # endif
 #else /* !Amiga && !VMS */
+#ifdef WINDOWS32
 # ifdef KMK
-        { "Makefile.kmk", "makefile.kmk", "GNUmakefile", "makefile", "Makefile", 0 };
+        { "Makefile.kmk", "makefile.kmk", "GNUmakefile", "makefile", "Makefile", "makefile.mak", 0 };
 # else
-        { "GNUmakefile", "makefile", "Makefile", 0 };
+        { "GNUmakefile", "makefile", "Makefile", "makefile.mak", 0 };
+# endif       
+#else /* !Amiga && !VMS && !WINDOWS32 */
+# ifdef KMK
+        { "Makefile.kmk", "makefile.kmk", "GNUmakefile", "makefile", "Makefile", 0 };
+# else
+        { "GNUmakefile", "makefile", "Makefile", 0 };
 # endif
+#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;
-        }
+        {
+          /* 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_makefiles;
+  return read_files;
 }
 
@@ -386 +371 @@
   /* Free any space allocated by conditional_line.  */
 #ifdef KMK
-  if (conditionals->allocated > sizeof (conditionals->ignoring_first))
-#endif
-    {
-      if (conditionals->ignoring)
-        free (conditionals->ignoring);
-      if (conditionals->seen_else)
-        free (conditionals->seen_else);
-    }
+ if (conditionals->allocated > sizeof (conditionals->ignoring_first))
+ {
+#endif
+  free (conditionals->ignoring);
+  free (conditionals->seen_else);
+#ifdef KMK
+ }
+#endif
 
   /* Restore state.  */
@@ -400 +385 @@
 
 
-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 ("...");
     }
@@ -429 +414 @@
   /* 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] == '~')
@@ -435 +420 @@
       expanded = tilde_expand (filename);
       if (expanded != 0)
-        filename = expanded;
+        filename = expanded;
     }
 
-  ebuf.fp = fopen (filename, "r");
+  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 != '/')
@@ -449 +451 @@
       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;
 #ifndef CONFIG_WITH_STRCACHE2
   deps->file = lookup_file (filename);
@@ -473 +479 @@
     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.  */
@@ -485 +488 @@
     {
       /* 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;
     }
 
@@ -576 +579 @@
   alloca (0);
 
-  return 1;
+  errno = 0;
+  return deps;
 }
 
 void
-#ifndef CONFIG_WITH_VALUE_LENGTH
-eval_buffer (char *buffer)
-#else
-eval_buffer (char *buffer, char *eos)
-#endif
+eval_buffer (char *buffer, const floc *flocp IF_WITH_VALUE_LENGTH_PARAM(char *eos))
 {
   struct ebuffer ebuf;
   struct conditionals *saved;
   struct conditionals new;
-  const struct floc *curfile;
+  const floc *curfile;
 
   /* Evaluate the buffer */
@@ -603 +603 @@
   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;
@@ -641 +647 @@
 
   /* 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;
@@ -650 +656 @@
       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.  */
@@ -713 +719 @@
   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;
+  floc *fstart;
+  floc fi;
 #ifdef CONFIG_WITH_VALUE_LENGTH
   unsigned int tmp_len;
@@ -730 +737 @@
 #endif
 
-#define record_waiting_files()                                                \
-  do                                                                          \
-    {                                                                         \
-      if (filenames != 0)                                                     \
+#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;                                                            \
@@ -758 +766 @@
 
      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);
@@ -785 +792 @@
         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;
@@ -798 +821 @@
 
       /* 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.
@@ -850 +860 @@
 
       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);
+        }
 #ifndef CONFIG_WITH_VALUE_LENGTH
       strcpy (collapsed, line);
@@ -873 +882 @@
       /* 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)
         {
@@ -885 +893 @@
 
           /* If we're ignoring then we're done now.  */
-          if (ignoring)
+          if (ignoring)
             {
               if (vmod.define_v)
@@ -892 +900 @@
             }
 
+          /* 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)
@@ -912 +921 @@
 
           /* 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.  */
@@ -943 +952 @@
           {
             if (i == -1)
-              fatal (fstart, _("invalid syntax in conditional"));
+              O (fatal, fstart, _("invalid syntax in conditional"));
 
             ignoring = i;
@@ -952 +961 @@
       /* Nothing to see here... move along.  */
       if (ignoring)
-        continue;
+        continue;
 
 #ifdef CONFIG_WITH_LOCAL_VARIABLES
@@ -958 +967 @@
         {
           if (*p2 == '\0')
-            error (fstart, _("empty `local' directive"));
+            O (error, fstart, _("empty `local' directive"));
 
           if (strneq (p2, "define", 6)
-              && (isblank ((unsigned char)p2[6]) || p2[6] == '\0'))
+              && (ISBLANK (p2[6]) || p2[6] == '\0'))
             {
               if (ignoring)
@@ -969 +978 @@
                   p2 = next_token (p2 + 6);
                   if (*p2 == '\0')
-                    fatal (fstart, _("empty variable name"));
+                    O (fatal, fstart, _("empty variable name"));
 
                   /* Let the variable name be the whole rest of the line,
@@ -976 +985 @@
                      reference that might contain blanks.  */
                   p = strchr (p2, '\0');
-                  while (isblank ((unsigned char)p[-1]))
+                  while (ISBLANK (p[-1]))
                     --p;
                   do_define (p2 IF_WITH_VALUE_LENGTH_PARAM(p), o_local, ebuf);
@@ -983 +992 @@
           else if (!ignoring
                    && !try_variable_definition (fstart, p2 IF_WITH_VALUE_LENGTH_PARAM(eol), o_local, 0))
-            error (fstart, _("invalid `local' directive"));
+            O (error, fstart, _("invalid `local' directive"));
 
           continue;
@@ -998 +1007 @@
             {
               if (krc != 0)
-                error (fstart, _("krc=%d"), krc);
+                ON (error, fstart, _("krc=%d"), krc);
               continue;
             }
@@ -1007 +1016 @@
          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
@@ -1033 +1045 @@
                   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;
                 }
@@ -1043 +1055 @@
 #endif
             }
-          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;
+        }
 
 #ifdef CONFIG_WITH_INCLUDEDEP
@@ -1092 +1107 @@
               free_me = name = allocated_variable_expand_3 (name, eol - name, &name_len, &buf_len);
               eol = name + name_len;
-              while (isspace ((unsigned char)*name))
+              while (ISSPACE (*name))
                 ++name;
             }
 
-          while (eol > name && isspace ((unsigned char)eol[-1]))
+          while (eol > name && ISSPACE (eol[-1]))
             --eol;
 
@@ -1104 +1119 @@
           if (free_me)
             recycle_variable_buffer (free_me, buf_len);
-          goto rule_complete;
+          continue;
         }
 #endif /* CONFIG_WITH_INCLUDEDEP */
@@ -1110 +1125 @@
       /* 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');
+          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');
+#ifdef CONFIG_WITH_VALUE_LENGTH
+          unsigned int buf_len;
+#endif
+
+          /* Include ends the previous rule.  */
+          record_waiting_files ();
 
 #ifndef CONFIG_WITH_VALUE_LENGTH
-          p = allocated_variable_expand (p2);
-#else
-          unsigned int buf_len;
+          p = allocated_variable_expand (p2);
+#else
           p = allocated_variable_expand_3 (p2, eol - p2, NULL, &buf_len);
 #endif
 
+
           /* If no filenames, it's a no-op.  */
-          if (*p == '\0')
+          if (*p == '\0')
             {
 #ifndef CONFIG_WITH_VALUE_LENGTH
@@ -1138 +1159 @@
             }
 
-          /* 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);
 #ifndef CONFIG_WITH_VALUE_LENGTH
-          free (p);
+          free (p);
 #else
           recycle_variable_buffer (p, buf_len);
 #endif
 
-          /* 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;
+          /* 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
@@ -1184 +1266 @@
          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. */
 
@@ -1210 +1292 @@
         /* Search the line for an unquoted ; that is not after an
            unquoted #.  */
-#ifndef CONFIG_WITH_VALUE_LENGTH
-        cmdleft = find_char_unquote (line, ';', '#', 0, 1);
-#else
-        cmdleft = find_char_unquote_2 (line, ';', '#', 0, 1, ebuf->eol - line);
-#endif
+        cmdleft = find_char_unquote (line, MAP_SEMI|MAP_COMMENT|MAP_VARIABLE IF_WITH_VALUE_LENGTH_PARAM(ebuf->eol - line));
         if (cmdleft != 0 && *cmdleft == '#')
           {
@@ -1236 +1314 @@
            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?).  */
@@ -1257 +1335 @@
           }
 
-
 #ifndef CONFIG_WITH_VALUE_LENGTH
-        p2 = variable_expand_string(NULL, lb_next, wlen);
+        p2 = variable_expand_string (NULL, lb_next, wlen);
 #else
         p2 = variable_expand_string_2 (NULL, lb_next, wlen, &eol);
@@ -1272 +1349 @@
                 /* Look for a semicolon in the expanded line.  */
 #ifndef CONFIG_WITH_VALUE_LENGTH
-                cmdleft = find_char_unquote (p2, ';', 0, 0, 0);
-#else
-                cmdleft = find_char_unquote_0 (p2, ';', &eol);
+                cmdleft = find_char_unquote (p2, MAP_SEMI);
+#else
+                cmdleft = find_char_unquote_0 (p2, ';', MAP_SEMI, &eol); 
 #endif
 
@@ -1282 +1359 @@
                     unsigned long cmd_off = cmdleft - variable_buffer;
 #ifndef CONFIG_WITH_VALUE_LENGTH
-                    char *pend = p2 + strlen(p2);
+                    char *pend = p2 + strlen (p2);
 #endif
 
@@ -1293 +1370 @@
                        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. */
 #ifndef CONFIG_WITH_VALUE_LENGTH
-                    (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);
 #else
                     tmp_len = strlen (lb_next);
@@ -1311 +1388 @@
 
 #ifndef CONFIG_WITH_VALUE_LENGTH
-            colonp = find_char_unquote(p2, ':', 0, 0, 0);
-#else
-            colonp = find_char_unquote_0 (p2, ':', &eol);
+            colonp = find_char_unquote (p2, MAP_COLON);
+#else
+            colonp = find_char_unquote_0 (p2, ':', MAP_COLON, &eol);
 #endif
 #ifdef HAVE_DOS_PATHS
@@ -1324 +1401 @@
                    (colonp == p2 + 1 || strchr (" \t(", colonp[-2]) != 0))
 # ifndef CONFIG_WITH_VALUE_LENGTH
-              colonp = find_char_unquote(colonp + 1, ':', 0, 0, 0);
+              colonp = find_char_unquote (colonp + 1, MAP_COLON);
 # else
-              colonp = find_char_unquote_0 (colonp + 1, ':', &eol);
+              colonp = find_char_unquote_0 (colonp + 1, ':', MAP_COLON, &eol);
 # endif
 #endif
@@ -1332 +1409 @@
               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;
 
 #ifndef CONFIG_WITH_VALUE_LENGTH
-            p2 += strlen(p2);
+            p2 += strlen (p2);
             *(p2++) = ' ';
-            p2 = variable_expand_string(p2, lb_next, wlen);
+            p2 = variable_expand_string (p2, lb_next, wlen);
 #else
             *(eol++) = ' ';
@@ -1356 +1433 @@
         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)
@@ -1406 +1486 @@
             if (semip)
               {
-                unsigned int l = p - variable_buffer;
+                unsigned int l = p2 - variable_buffer;
                 *(--semip) = ';';
 #ifndef CONFIG_WITH_VALUE_LENGTH
@@ -1415 +1495 @@
                 variable_buffer_output (p2 + strlen (p2),
                                         semip, strlen (semip)+1);
-                p = variable_buffer + l;
+                p2 = variable_buffer + l;
               }
             record_target_var (filenames, p2,
@@ -1426 +1506 @@
         /* This is a normal target, _not_ a target-specific variable.
            Unquote any = in the dependency list.  */
-        find_char_unquote (lb_next, '=', 0, 0, 0);
+#ifndef CONFIG_WITH_VALUE_LENGTH
+        find_char_unquote (lb_next, MAP_EQUALS);
+#else
+        {
+          char *tmp_eos = strchr(lb_next, '\0'); /** @todo see if we can optimize this away... */
+          find_char_unquote_0 (lb_next, '=', MAP_EQUALS, &tmp_eos);
+        }
+#endif
+
+        /* Remember the command prefix for this target.  */
+        prefix = cmd_prefix;
 
         /* We have some targets, so don't ignore the following commands.  */
@@ -1447 +1537 @@
               {
 #ifndef CONFIG_WITH_VALUE_LENGTH
-                cmdleft = find_char_unquote (p2, ';', 0, 0, 0);
-#else
-                cmdleft = find_char_unquote_0 (p2, ';', &eos);
+                cmdleft = find_char_unquote (p2, MAP_SEMI);
+#else
+                cmdleft = find_char_unquote_0 (p2, ';', MAP_SEMI, &eos);
 #endif
                 if (cmdleft != 0)
@@ -1456 +1546 @@
           }
 
-        /* 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] == '\\')
@@ -1482 +1572 @@
            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
@@ -1504 +1593 @@
           {
             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 (target `%s')"), target->name); /* bird */
+              OS (fatal, fstart, _("multiple target patterns (target '%s')"), target->name); /* bird added target */
             pattern_percent = find_percent_cached (&target->name);
             pattern = target->name;
             if (pattern_percent == 0)
-              fatal (fstart, _("target pattern contains no `%%' (target `%s')"), target->name); /* bird */
+              OS (fatal, fstart, _("target pattern contains no '%%' (target '%s')"), target->name); /* bird added target */
             free_ns (target);
           }
@@ -1567 +1656 @@
         if (set_default && default_goal_var->value[0] == '\0')
           {
-            const char *name;
             struct dep *d;
             struct nameseq *t = filenames;
@@ -1574 +1662 @@
               {
                 int reject = 0;
-                name = t->name;
+                const char *name = t->name;
 
                 /* We have nothing to do if this is an implicit rule. */
@@ -1580 +1668 @@
                   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
@@ -1633 +1721 @@
 
       /* 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'"));
 #ifdef KMK
 
   if (kdata != NULL)
-    fatal (fstart, _("missing `kBuild-endef-*'"));
+    O (fatal, fstart, _("missing `kBuild-endef-*'"));
 #endif
 
@@ -1652 +1739 @@
   record_waiting_files ();
 
-  if (collapsed)
-    free (collapsed);
+  free (collapsed);
   free (commands);
 }
@@ -1665 +1751 @@
 static void
 remove_comments (char *line)
+#else
+static char *
+remove_comments (char *line, char *eos)
+#endif
 {
   char *comment;
 
-  comment = find_char_unquote (line, '#', 0, 0, 0);
+#ifndef CONFIG_WITH_VALUE_LENGTH
+  comment = find_char_unquote (line, MAP_COMMENT);
 
   if (comment != 0)
     /* Cut off the line at the #.  */
     *comment = '\0';
+#else
+  comment = find_char_unquote_0 (line, '#', MAP_COMMENT, &eos);
+  if (comment)
+    {
+      /* Cut off the line at the #.  */
+      *comment = '\0';
+      return comment;
+    }
+  return eos;
+#endif
 }
-#else  /* CONFIG_WITH_VALUE_LENGTH */
-__inline static char *
-remove_comments (char *line, char *eol)
-{
-  unsigned int string_len = eol - line;
-  register int ch;
-  char *p;
-
-  /* Hope for simple (no comments). */
-  p = memchr (line, '#', string_len);
-  if (!p)
-    return eol;
-
-  /* Found potential comment, enter the slow route. */
-  for (;;)
-    {
-      if (p > line && p[-1] == '\\')
-        {
-          /* Search for more backslashes.  */
-          int i = -2;
-          while (&p[i] >= line && p[i] == '\\')
-            --i;
-          ++i;
-
-          /* 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 - line)) - (i/2) + 1);
-          p += i/2;
-          if (i % 2 == 0)
-            {
-              /* All the backslashes quoted each other; the STOPCHAR was
-                 unquoted.  */
-              *p = '\0';
-              return p;
-            }
-
-          /* The '#' was quoted by a backslash.  Look for another.  */
-        }
-      else
-        {
-          /* No backslash in sight.  */
-          *p = '\0';
-          return p;
-        }
-
-      /* lazy, string_len isn't correct so do it the slow way. */
-      while ((ch = *p) != '#')
-        {
-          if (ch == '\0')
-            return p;
-          ++p;
-        }
-    }
-  /* won't ever get here. */
-}
-#endif /* CONFIG_WITH_VALUE_LENGTH */
-
-/* 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. */
@@ -1744 +1789 @@
   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';
@@ -1754 +1799 @@
 }
 
-/* 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.  */
@@ -1763 +1808 @@
 {
   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';
+#ifndef CONFIG_WITH_STRCACHE2
+      var.name[var.length] = '\0';
+#else
+      assert (!strcache2_is_cached (&variable_strcache, var.name));
+      ((char *)var.name)[var.length] = '\0';
+#endif
     }
 
   /* 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';
@@ -1805 +1855 @@
       /* 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;
@@ -1829 +1879 @@
 
           /* 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;
@@ -1835 +1885 @@
           /* 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))
             {
@@ -1845 +1895 @@
 #endif
               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)
@@ -1879 +1929 @@
 
 #ifndef CONFIG_WITH_VALUE_LENGTH
-  v = do_variable_definition (&defstart, name, definition, origin, flavor, 0);
+  v = do_variable_definition (&defstart, name,
+                              definition, origin, var.flavor, 0);
 #else
   v = do_variable_definition_2 (&defstart, name, definition,
-                                idx ? idx - 1 : idx,  flavor == f_simple,
-                                0 /* free_value */, origin, flavor,
+                                idx ? idx - 1 : idx,  var.flavor == f_simple,
+                                0 /* free_value */, origin, var.flavor,
                                 0 /*target_var*/);
 #endif
   free (definition);
-  free (var);
+  free (n);
   return (v);
 }
@@ -1905 +1956 @@
 
 static int
-#ifndef CONFIG_WITH_VALUE_LENGTH
-conditional_line (char *line, int len, const struct floc *flocp)
-#else
-conditional_line (char *line, char *eol, int len, const struct floc *flocp)
-#endif
+conditional_line (char *line IF_WITH_VALUE_LENGTH_PARAM(char *eol), int len, const floc *flocp)
 {
-  char *cmdname;
+  const char *cmdname;
   enum { c_ifdef, c_ifndef, c_ifeq, c_ifneq,
 #ifdef CONFIG_WITH_SET_CONDITIONALS
@@ -1928 +1975 @@
 
   /* 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.  */
@@ -1949 +1996 @@
 
   /* 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  */
@@ -1957 +2006 @@
     {
       if (*line != '\0')
-        EXTRANEOUS ();
+        EXTRATEXT ();
 
       if (!conditionals->if_cmds)
-        fatal (flocp, _("extraneous `%s'"), cmdname);
+        EXTRACMD ();
 
       --conditionals->if_cmds;
@@ -1974 +2023 @@
 
       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.  */
@@ -2005 +2054 @@
 
       /* 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")
-#ifndef CONFIG_WITH_VALUE_LENGTH
-          || conditional_line (line, len, flocp) < 0)
-#else
-          || conditional_line (line, eol, len, flocp) < 0)
-#endif
-        EXTRANEOUS ();
+      if (word1eq ("else") || word1eq ("endif")
+          || conditional_line (line IF_WITH_VALUE_LENGTH_PARAM(eol), len, flocp) < 0)
+        EXTRATEXT ();
       else
         {
@@ -2068 +2113 @@
     }
 
-  /* 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;
 
@@ -2075 +2120 @@
     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;
       }
 
@@ -2099 +2144 @@
       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';
@@ -2137 +2182 @@
 
       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';
 #ifdef CONFIG_WITH_VALUE_LENGTH
           l = p - s1;
 #endif
-        }
+        }
       else
         {
@@ -2175 +2220 @@
           l = line - s1;
 #endif
-          *line++ = '\0';
+          *line++ = '\0';
         }
 
@@ -2181 +2226 @@
       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);
@@ -2190 +2235 @@
 
       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';
+        return -1;
+
 #ifdef CONFIG_WITH_VALUE_LENGTH
       l = line - s2;
 #endif
-      line = next_token (++line);
+      *(line++) = '\0';
+      NEXT_TOKEN (line);
       if (*line != '\0')
-        EXTRANEOUS ();
+        EXTRATEXT ();
 
 #ifndef CONFIG_WITH_VALUE_LENGTH
@@ -2291 +2336 @@
 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;
@@ -2305 +2350 @@
       struct variable *v;
       const char *name = filenames->name;
-      const char *fname;
       const char *percent;
       struct pattern_var *p;
+#ifdef CONFIG_WITH_VALUE_LENGTH
+      const char *fname;
+#endif
 
       nextf = filenames->next;
@@ -2339 +2386 @@
           v->value_alloc_len = v->value_length + 1;
 #endif
-
-          fname = p->target;
         }
       else
@@ -2365 +2410 @@
 
           initialize_file_variables (f, 1);
-          fname = f->name;
 
           current_variable_set_list = f->variables;
           v = try_variable_definition (flocp, defn IF_WITH_VALUE_LENGTH_PARAM(NULL), origin, 1);
           if (!v)
-            fatal (flocp, _("Malformed target-specific variable definition"));
+            O (fatal, flocp, _("Malformed target-specific variable definition"));
           current_variable_set_list = global;
         }
@@ -2385 +2429 @@
           struct variable *gv;
 #ifndef CONFIG_WITH_STRCACHE2
-          int len = strlen(v->name);
+          int len = strlen (v->name);
 #else
           int len = !percent
@@ -2393 +2437 @@
 
           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))
             {
 #ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
               assert (!v->rdonly_val); /* paranoia */
 #endif
-              if (v->value != 0)
-                free (v->value);
+              free (v->value);
 #ifndef CONFIG_WITH_VALUE_LENGTH
               v->value = xstrdup (gv->value);
@@ -2420 +2464 @@
    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
@@ -2432 +2476 @@
               unsigned int cmds_started, char *commands,
               unsigned int commands_idx, int two_colon,
-              const struct floc *flocp)
+              char prefix, const floc *flocp)
 {
 #ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
@@ -2449 +2493 @@
      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.  */
@@ -2465 +2509 @@
       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;
 #ifdef CONFIG_WITH_MEMORY_OPTIMIZATIONS
       cmds->refs = 0;
@@ -2478 +2524 @@
   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);
+        }
     }
 
@@ -2509 +2559 @@
 
       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.
@@ -2532 +2582 @@
 
           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;
 
@@ -2565 +2615 @@
           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"))
@@ -2572 +2629 @@
         second_target_expansion = 1;
 #endif
-#if !defined(WINDOWS32) && !defined (__MSDOS__) && !defined (__EMX__)
+#if !defined (__MSDOS__) && !defined (__EMX__)
       else if (streq (name, ".ONESHELL"))
         one_shell = 1;
@@ -2621 +2678 @@
 
       /* 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
@@ -2633 +2691 @@
       /* 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.  */
+        {
+          /* Single-colon.  Combine this rule with the file's existing record,
+             if any.  */
 #ifndef KMK
-          f = enter_file (strcache_add (name));
+          f = enter_file (strcache_add (name));
 #else  /* KMK - the name is already in the cache, don't waste time.  */
           f = enter_file (name);
 #endif
-          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'"),
+          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 .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;
 
 #ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
@@ -2684 +2743 @@
 
               if (f == suffix_file)
-                error (flocp,
-                       _(".SUFFIXES encountered in an explicit multi target rule"));
+                O (error, flocp,
+                   _(".SUFFIXES encountered in an explicit multi target rule"));
             }
           prev_file = f;
 #endif
 
-          /* Defining .SUFFIXES with no dependencies clears out the list of
-             suffixes.  */
-          if (f == suffix_file && this == 0)
-            {
+          /* 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.  */
+        {
+          /* Double-colon.  Make a new record even if there already is one.  */
 #ifndef CONFIG_WITH_STRCACHE2
           f = lookup_file (name);
@@ -2707 +2766 @@
 #endif /* CONFIG_WITH_STRCACHE2 */
 
-          /* 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);
+          /* 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);
 
 #ifndef KMK
-          f = enter_file (strcache_add (name));
+          f = enter_file (strcache_add (name));
 #else  /* KMK - the name is already in the cache, don't waste time.  */
-          f = enter_file (name);
-#endif
-          /* 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 = enter_file (name);
+#endif
+          /* 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)
@@ -2796 +2855 @@
       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"));
     }
 }
@@ -2810 +2870 @@
    STOPCHAR _cannot_ be '$' if IGNOREVARS is true.  */
 
-#ifndef CONFIG_WITH_VALUE_LENGTH
 static char *
-find_char_unquote (char *string, int stop1, int stop2, int blank,
-                   int ignorevars)
-#else
-static char *
-find_char_unquote_2 (char *string, int stop1, int stop2, int blank,
-                     int ignorevars, unsigned int string_len)
-#endif
+find_char_unquote (char *string, int map IF_WITH_VALUE_LENGTH_PARAM(unsigned int string_len))
 {
 #ifndef CONFIG_WITH_VALUE_LENGTH
@@ -2824 +2877 @@
 #endif
   char *p = string;
-  register int ch; /* bird: 'optimiziations' */
 #ifdef CONFIG_WITH_VALUE_LENGTH
   assert (string_len == 0 || string_len == strlen (string));
 #endif
 
-  if (ignorevars)
-    ignorevars = '$';
+  /* Always stop on NUL.  */
+  map |= MAP_NUL;
 
   while (1)
     {
-      if (stop2 && blank)
-        while ((ch = *p) != '\0' && ch != ignorevars && ch != stop1 && ch != stop2
-               && ! isblank ((unsigned char) ch))
-          ++p;
-      else if (stop2)
-        while ((ch = *p) != '\0' && ch != ignorevars && ch != stop1 && ch != stop2)
-          ++p;
-      else if (blank)
-        while ((ch = *p) != '\0' && ch != ignorevars && ch != stop1
-               && ! isblank ((unsigned char) ch))
-          ++p;
-      else
-        while ((ch = *p) != '\0' && ch != ignorevars && ch != stop1)
-          ++p;
-
-      if (ch == '\0')
-        break;
+      while (! STOP_SET (*p, map))
+        ++p;
+
+      if (*p == '\0')
+        break;
 
       /* If we stopped due to a variable reference, skip over its contents.  */
-      if (ch == 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;
@@ -2864 +2908 @@
               unsigned int pcount = 1;
               char closeparen = (openparen == '(' ? ')' : '}');
+              char ch; /* bird */
 
               while ((ch = *p))
@@ -2884 +2929 @@
 
       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;
     }
 
@@ -2914 +2959 @@
 
 #ifdef CONFIG_WITH_VALUE_LENGTH
-/* Special case version of find_char_unquote that only takes stop1.
-   This is so common that it makes a lot of sense to specialize this.
-   */
-__inline static char *
-find_char_unquote_0 (char *string, int stop1, char **eosp)
+/* Special case version of find_char_unquote that only takes stop character.
+   This is so common that it makes a lot of sense to specialize this. */
+
+K_INLINE char *
+find_char_unquote_0 (char *string, int stop1, int map, char **eosp)
 {
   unsigned int string_len = *eosp - string;
-  char *p = (char *)memchr (string, stop1, string_len);
+  char *p;
+
   assert (strlen (string) == string_len);
+  assert (!(map & MAP_VARIABLE) && map != 0);
+  assert ((stopchar_map[(unsigned char)stop1] & map) == map);
+
+  p = (char *)memchr (string, stop1, string_len);
   if (!p)
     return NULL;
-  if (p <= string || p[-1] != '\\')
+  if (p <= string || p[-1] != '\\') 
     return p;
 
-  p = find_char_unquote_2 (string, stop1, 0, 0, 0, string_len);
+  p = find_char_unquote (string, map, string_len);
   *eosp = memchr (string, '\0', string_len);
   return p;
@@ -2934 +2984 @@
 #endif
 
+/* 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.  */
 
@@ -2939 +3037 @@
 find_percent (char *pattern)
 {
-  return find_char_unquote (pattern, '%', 0, 0, 0);
+#ifndef CONFIG_WITH_VALUE_LENGTH
+  return find_char_unquote (pattern, MAP_PERCENT);
+#else
+  char *eos = strchr(pattern, '\0');
+  return find_char_unquote_0 (pattern, '%', MAP_PERCENT, &eos);
+#endif
 }
 
@@ -2962 +3065 @@
   while (1)
     {
-      while (*p != '\0' && *p != '%')
+      while (! STOP_SET (*p, MAP_PERCENT|MAP_NUL))
         ++p;
 
@@ -3032 +3135 @@
  */
 
-static unsigned long
+static long
 readstring (struct ebuffer *ebuf)
 {
@@ -3125 +3228 @@
       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.  */
@@ -3154 +3257 @@
         {
           --p;
-          p[-1] = '\n';
+          memmove (p-1, p, strlen (p) + 1);
         }
 #endif
@@ -3160 +3263 @@
       backslash = 0;
       for (p2 = p - 2; p2 >= start; --p2)
-        {
-          if (*p2 != '\\')
-            break;
+        {
+          if (*p2 != '\\')
+            break;
           backslash = !backslash;
-        }
+        }
 
       if (!backslash)
-        {
-          p[-1] = '\0';
+        {
+          p[-1] = '\0';
 #ifdef CONFIG_WITH_VALUE_LENGTH
           ebuf->eol = p - 1;
 #endif
-          break;
-        }
+          break;
+        }
 
       /* It was a backslash/newline combo.  If we have more space, read
@@ -3225 +3328 @@
      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
@@ -3239 +3342 @@
 
   /* Skip any leading whitespace.  */
-  while (isblank ((unsigned char)*p))
+  while (ISBLANK (*p))
     ++p;
 
@@ -3264 +3367 @@
         case ':':
           ++p;
-          wtype = w_dcolon;
+          if (p[1] != '=')
+            wtype = w_dcolon;
+          else
+            {
+              wtype = w_varassign;
+              ++p;
+            }
           break;
 
@@ -3276 +3385 @@
     case '+':
     case '?':
+    case '!':
 #ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
     case '>':
@@ -3298 +3408 @@
   /* 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
@@ -3320 +3430 @@
         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] == '(')))
-#endif
-          goto done_word;
+          /* 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;
 
         case '$':
@@ -3333 +3443 @@
           if (c == '$')
             break;
+          if (c == '\0')
+            goto done_word;
 
           /* This is a variable reference, so note that it's expandable.
@@ -3405 +3517 @@
 construct_include_path (const char **arg_dirs)
 {
-#ifdef VAXC             /* just don't ask ... */
+#ifdef VAXC             /* just don't ask ... */
   stat_t stbuf;
 #else
@@ -3440 +3552 @@
     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);
@@ -3463 +3575 @@
           }
 
-        if (expanded)
-          free (expanded);
+        free (expanded);
       }
 
@@ -3478 +3589 @@
       {
         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)
@@ -3536 +3647 @@
   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;
+        /* Turn off --warn-undefined-variables while we expand HOME.  */
+        int save = warn_undefined_variables_flag;
+        warn_undefined_variables_flag = 0;
 
 #ifndef CONFIG_WITH_VALUE_LENGTH
-        home_dir = allocated_variable_expand ("$(HOME)");
-#else
-        home_dir = allocated_variable_expand_2 (STRING_SIZE_TUPLE("$(HOME)"), NULL);
-#endif
-
-        warn_undefined_variables_flag = save;
+        home_dir = allocated_variable_expand ("$(HOME)");
+#else
+        home_dir = allocated_variable_expand_2 (STRING_SIZE_TUPLE("$(HOME)"), NULL);
+#endif
+
+        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)
@@ -3588 +3697 @@
       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 */
@@ -3630 +3739 @@
 
 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
                 IF_WITH_ALLOC_CACHES_PARAM(struct alloccache *alloc_cache) )
 {
-  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;
@@ -3665 +3771 @@
   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)
@@ -3695 +3799 @@
       const char **nlist = 0;
       char *tildep = 0;
+      int globme = 1;
 #ifndef NO_ARCHIVES
       char *arname = 0;
@@ -3704 +3809 @@
 
       /* 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 IF_WITH_VALUE_LENGTH_PARAM(0));
 #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
@@ -3728 +3832 @@
        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 IF_WITH_VALUE_LENGTH_PARAM(0));
 #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] == '/')
-#endif
-          {
+        /* 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.
@@ -3757 +3864 @@
       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';
@@ -3772 +3877 @@
         }
       else
-        {
+        {
 #ifdef VMS
 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
@@ -3778 +3883 @@
  * 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);
@@ -3803 +3908 @@
 
          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
@@ -3811 +3916 @@
          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] != ')')
         {
@@ -3819 +3924 @@
               /* 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] == ')')
                     {
@@ -3837 +3945 @@
                       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;
@@ -3847 +3950 @@
                 }
               while (*e != '\0');
+
+              /* If we have just "lib(", part of something like "lib( a b)",
+                 go to the next item.  */
+              if (! nlen)
+                continue;
             }
         }
@@ -3873 +3981 @@
       /* 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;
         }
@@ -3882 +3990 @@
          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
@@ -3896 +4004 @@
          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.  */
@@ -3943 +4059 @@
               {
                 /* 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.  */
@@ -3965 +4084 @@
           NEWELT (concat (2, prefix, nlist[i]));
 
+      if (globme)
         globfree (&gl);
 
 #ifndef NO_ARCHIVES
-      if (arname)
-        free (arname);
-#endif
-
-      if (tildep)
-        free (tildep);
+      free (arname);
+#endif
+
+      free (tildep);
     }