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

Timestamp:

Jun 20, 2012, 12:44:52 AM (13 years ago)

Author:

bird

Message:

gnumake/current -> 3.82-cvs.

Location:

vendor/gnumake/current

Files:

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

vendor/gnumake/current/read.c

@@ -1 +1 @@
 /* Reading and parsing of makefiles for GNU Make.
 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
-Foundation, Inc.
+1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+2010 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -55 +55 @@
     FILE *fp;           /* File, or NULL if this is an internal buffer.  */
     struct floc floc;   /* Info on the file in fp (if any).  */
+  };
+
+/* Track the modifiers we can have on variable assignments */
+
+struct vmodifiers
+  {
+    unsigned int assign_v:1;
+    unsigned int define_v:1;
+    unsigned int undefine_v:1;
+    unsigned int export_v:1;
+    unsigned int override_v:1;
+    unsigned int private_v:1;
   };
 
@@ -123 +135 @@
 
 static int eval_makefile (const char *filename, int flags);
-static int eval (struct ebuffer *buffer, int flags);
+static void eval (struct ebuffer *buffer, int flags);
 
 static long readline (struct ebuffer *ebuf);
-static void do_define (char *name, unsigned int namelen,
-                       enum variable_origin origin, struct ebuffer *ebuf);
+static void do_undefine (char *name, enum variable_origin origin,
+                         struct ebuffer *ebuf);
+static struct variable *do_define (char *name, enum variable_origin origin,
+                                   struct ebuffer *ebuf);
 static int conditional_line (char *line, int len, const struct floc *flocp);
 static void record_files (struct nameseq *filenames, const char *pattern,
-                          const char *pattern_percent, struct dep *deps,
+                          const char *pattern_percent, char *depstr,
                           unsigned int cmds_started, char *commands,
                           unsigned int commands_idx, int two_colon,
                           const struct floc *flocp);
 static void record_target_var (struct nameseq *filenames, char *defn,
-                               enum variable_origin origin, int enabled,
+                               enum variable_origin origin,
+                               struct vmodifiers *vmod,
                                const struct floc *flocp);
 static enum make_word_type get_next_mword (char *buffer, char *delim,
@@ -144 +159 @@
 
 
+/* Compare a word, both length and contents.
+   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.  */
 
@@ -154 +176 @@
      we will be reading. */
 
-  define_variable ("MAKEFILE_LIST", sizeof ("MAKEFILE_LIST")-1, "", o_file, 0);
+  define_variable_cname ("MAKEFILE_LIST", "", o_file, 0);
 
   DB (DB_BASIC, (_("Reading makefiles...\n")));
@@ -249 +271 @@
               struct dep *d = alloc_dep ();
               d->file = enter_file (strcache_add (*p));
-              d->file->dontcare = 1;
+              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.  */
@@ -305 +327 @@
   char *expanded = 0;
   int makefile_errno;
-  int r;
 
   filename = strcache_add (filename);
@@ -348 +369 @@
       for (i = 0; include_directories[i] != 0; ++i)
         {
-          const char *included = concat (include_directories[i], "/", filename);
+          const char *included = concat (3, include_directories[i],
+                                         "/", filename);
           ebuf.fp = fopen (included, "r");
           if (ebuf.fp)
@@ -368 +390 @@
   deps->changed = flags;
   if (flags & RM_DONTCARE)
-    deps->file->dontcare = 1;
+    deps->dontcare = 1;
 
   if (expanded)
@@ -384 +406 @@
     }
 
+  /* Set close-on-exec to avoid leaking the makefile to children, such as
+     $(shell ...).  */
+#ifdef HAVE_FILENO
+  CLOSE_ON_EXEC (fileno (ebuf.fp));
+#endif
+
   /* Add this makefile to the list. */
   do_variable_definition (&ebuf.floc, "MAKEFILE_LIST", filename, o_file,
@@ -396 +424 @@
   reading_file = &ebuf.floc;
 
-  r = eval (&ebuf, !(flags & RM_NO_DEFAULT_GOAL));
+  eval (&ebuf, !(flags & RM_NO_DEFAULT_GOAL));
 
   reading_file = curfile;
@@ -404 +432 @@
   free (ebuf.bufstart);
   alloca (0);
-  return r;
+
+  return 1;
 }
 
-int
+void
 eval_buffer (char *buffer)
 {
@@ -414 +443 @@
   struct conditionals new;
   const struct floc *curfile;
-  int r;
 
   /* Evaluate the buffer */
@@ -422 +450 @@
   ebuf.fp = NULL;
 
-  ebuf.floc = *reading_file;
+  if (reading_file)
+    ebuf.floc = *reading_file;
+  else
+    ebuf.floc.filenm = NULL;
 
   curfile = reading_file;
@@ -429 +460 @@
   saved = install_conditionals (&new);
 
-  r = eval (&ebuf, 1);
+  eval (&ebuf, 1);
 
   restore_conditionals (saved);
@@ -436 +467 @@
 
   alloca (0);
-  return r;
 }
 
 
+/* Check LINE to see if it's a variable assignment or undefine.
+
+   It might use one of the modifiers "export", "override", "private", or it
+   might be one of the conditional tokens like "ifdef", "include", etc.
+
+   If it's not a variable assignment or undefine, VMOD.V_ASSIGN is 0.
+   Returns LINE.
+
+   Returns a pointer to the first non-modifier character, and sets VMOD
+   based on the modifiers found if any, plus V_ASSIGN is 1.
+ */
+static char *
+parse_var_assignment (const char *line, struct vmodifiers *vmod)
+{
+  const char *p;
+  memset (vmod, '\0', sizeof (*vmod));
+
+  /* Find the start of the next token.  If there isn't one we're done.  */
+  line = next_token (line);
+  if (*line == '\0')
+    return (char *)line;
+
+  p = line;
+  while (1)
+    {
+      int wlen;
+      const char *p2;
+      enum variable_flavor flavor;
+
+      p2 = parse_variable_definition (p, &flavor);
+
+      /* If this is a variable assignment, we're done.  */
+      if (p2)
+        break;
+
+      /* It's not a variable; see if it's a modifier.  */
+      p2 = end_of_token (p);
+      wlen = p2 - p;
+
+      if (word1eq ("export"))
+        vmod->export_v = 1;
+      else if (word1eq ("override"))
+        vmod->override_v = 1;
+      else if (word1eq ("private"))
+        vmod->private_v = 1;
+      else if (word1eq ("define"))
+        {
+          /* We can't have modifiers after 'define' */
+          vmod->define_v = 1;
+          p = next_token (p2);
+          break;
+        }
+      else if (word1eq ("undefine"))
+        {
+          /* We can't have modifiers after 'undefine' */
+          vmod->undefine_v = 1;
+          p = next_token (p2);
+          break;
+        }
+      else
+        /* Not a variable or modifier: this is not a variable assignment.  */
+        return (char *)line;
+
+      /* It was a modifier.  Try the next word.  */
+      p = next_token (p2);
+      if (*p == '\0')
+        return (char *)line;
+    }
+
+  /* Found a variable assignment or undefine.  */
+  vmod->assign_v = 1;
+  return (char *)p;
+}
+
+
 
 /* Read file FILENAME as a makefile and add its contents to the data base.
@@ -445 +550 @@
    SET_DEFAULT is true if we are allowed to set the default goal.  */
 
-
-static int
+static void
 eval (struct ebuffer *ebuf, int set_default)
 {
@@ -458 +562 @@
   int no_targets = 0;           /* Set when reading a rule without targets.  */
   struct nameseq *filenames = 0;
-  struct dep *deps = 0;
+  char *depstr = 0;
   long nlines = 0;
   int two_colon = 0;
@@ -472 +576 @@
         {                                                                     \
           fi.lineno = tgts_started;                                           \
-          record_files (filenames, pattern, pattern_percent, deps,            \
+          record_files (filenames, pattern, pattern_percent, depstr,          \
                         cmds_started, commands, commands_idx, two_colon,      \
                         &fi);                                                 \
+          filenames = 0;                                                      \
         }                                                                     \
-      filenames = 0;                                                          \
       commands_idx = 0;                                                       \
       no_targets = 0;                                                         \
@@ -507 +611 @@
       char *p;
       char *p2;
-
+      struct vmodifiers vmod;
+
+      /* At the top of this loop, we are starting a brand new line.  */
       /* Grab the next line to be evaluated */
       ebuf->floc.lineno += nlines;
@@ -532 +638 @@
 
           /* If there is no preceding rule line, don't treat this line
-             as a command, even though it begins with a tab character.
+             as a command, even though it begins with a recipe prefix.
              SunOS 4 make appears to behave this way.  */
 
@@ -571 +677 @@
         }
 
-      /* This line is not a shell command line.  Don't worry about tabs.
+      /* This line is not a shell command line.  Don't worry about whitespace.
          Get more space if we need it; we don't need to preserve the current
          contents of the buffer.  */
@@ -580 +686 @@
           if (collapsed)
             free (collapsed);
+          /* Don't need xrealloc: we don't need to preserve the content.  */
           collapsed = xmalloc (collapsed_length);
         }
@@ -587 +694 @@
       remove_comments (collapsed);
 
-      /* Compare a word, both length and contents. */
-#define word1eq(s)      (wlen == sizeof(s)-1 && strneq (s, p, sizeof(s)-1))
+      /* Get rid if starting space (including formfeed, vtab, etc.)  */
       p = collapsed;
       while (isspace ((unsigned char)*p))
-        ++p;
-
-      if (*p == '\0')
-        /* This line is completely empty--ignore it.  */
-        continue;
-
-      /* Find the end of the first token.  Note we don't need to worry about
-       * ":" here since we compare tokens by length (so "export" will never
-       * be equal to "export:").
-       */
-      for (p2 = p+1; *p2 != '\0' && !isspace ((unsigned char)*p2); ++p2)
-        ;
-      wlen = p2 - p;
-
-      /* Find the start of the second token.  If it looks like a target or
-         variable definition it can't be a preprocessor token so skip
-         them--this allows variables/targets named `ifdef', `export', etc. */
-      while (isspace ((unsigned char)*p2))
-        ++p2;
-
-      if ((p2[0] == ':' || p2[0] == '+' || p2[0] == '=') && p2[1] == '\0')
+        ++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);
+      if (vmod.assign_v)
         {
-          /* It can't be a preprocessor token so skip it if we're ignoring */
-          if (ignoring)
-            continue;
-
-          goto skip_conditionals;
-        }
-
-      /* We must first check for conditional and `define' directives before
-         ignoring anything, since they control what we will do with
-         following lines.  */
-
-      if (!in_ignored_define)
-        {
-          int i = conditional_line (p, wlen, fstart);
-          if (i != -2)
+          struct variable *v;
+          enum variable_origin origin = vmod.override_v ? o_override : o_file;
+
+          /* If we're ignoring then we're done now.  */
+          if (ignoring)
             {
-              if (i == -1)
-                fatal (fstart, _("invalid syntax in conditional"));
-
-              ignoring = i;
+              if (vmod.define_v)
+                in_ignored_define = 1;
               continue;
             }
-        }
-
-      if (word1eq ("endef"))
+
+          if (vmod.undefine_v)
+          {
+            do_undefine (p, origin, ebuf);
+
+            /* This line has been dealt with.  */
+            goto rule_complete;
+          }
+          else if (vmod.define_v)
+            v = do_define (p, origin, ebuf);
+          else
+            v = try_variable_definition (fstart, p, origin, 0);
+
+          assert (v != NULL);
+
+          if (vmod.export_v)
+            v->export = v_export;
+          if (vmod.private_v)
+            v->private_var = 1;
+
+          /* This line has been dealt with.  */
+          goto rule_complete;
+        }
+
+      /* If this line is completely empty, ignore it.  */
+      if (*p == '\0')
+        continue;
+
+      p2 = end_of_token (p);
+      wlen = p2 - p;
+      p2 = next_token (p2);
+
+      /* If we're in an ignored define, skip this line (but maybe get out).  */
+      if (in_ignored_define)
         {
-          if (!in_ignored_define)
-            fatal (fstart, _("extraneous `endef'"));
-          in_ignored_define = 0;
+          /* See if this is an endef line (plus optional comment).  */
+          if (word1eq ("endef") && (*p2 == '\0' || *p2 == '#'))
+            in_ignored_define = 0;
+
           continue;
         }
 
-      if (word1eq ("define"))
+      /* Check for conditional state changes.  */
+      {
+        int i = conditional_line (p, wlen, fstart);
+        if (i != -2)
+          {
+            if (i == -1)
+              fatal (fstart, _("invalid syntax in conditional"));
+
+            ignoring = i;
+            continue;
+          }
+      }
+
+      /* Nothing to see here... move along.  */
+      if (ignoring)
+        continue;
+
+      /* Manage the "export" keyword used outside of variable assignment
+         as well as "unexport".  */
+      if (word1eq ("export") || word1eq ("unexport"))
         {
-          if (ignoring)
-            in_ignored_define = 1;
-          else
-            {
-              if (*p2 == '\0')
-                fatal (fstart, _("empty variable name"));
-
-              /* Let the variable name be the whole rest of the line,
-                 with trailing blanks stripped (comments have already been
-                 removed), so it could be a complex variable/function
-                 reference that might contain blanks.  */
-              p = strchr (p2, '\0');
-              while (isblank ((unsigned char)p[-1]))
-                --p;
-              do_define (p2, p - p2, o_file, ebuf);
-            }
-          continue;
-        }
-
-      if (word1eq ("override"))
-        {
+          int exporting = *p == 'u' ? 0 : 1;
+
+          /* (un)export by itself causes everything to be (un)exported. */
           if (*p2 == '\0')
-            error (fstart, _("empty `override' directive"));
-
-          if (strneq (p2, "define", 6)
-              && (isblank ((unsigned char)p2[6]) || p2[6] == '\0'))
-            {
-              if (ignoring)
-                in_ignored_define = 1;
-              else
-                {
-                  p2 = next_token (p2 + 6);
-                  if (*p2 == '\0')
-                    fatal (fstart, _("empty variable name"));
-
-                  /* Let the variable name be the whole rest of the line,
-                     with trailing blanks stripped (comments have already been
-                     removed), so it could be a complex variable/function
-                     reference that might contain blanks.  */
-                  p = strchr (p2, '\0');
-                  while (isblank ((unsigned char)p[-1]))
-                    --p;
-                  do_define (p2, p - p2, o_override, ebuf);
-                }
-            }
-          else if (!ignoring
-                   && !try_variable_definition (fstart, p2, o_override, 0))
-            error (fstart, _("invalid `override' directive"));
-
-          continue;
-        }
-
-      if (ignoring)
-        /* Ignore the line.  We continue here so conditionals
-           can appear in the middle of a rule.  */
-        continue;
-
-      if (word1eq ("export"))
-        {
-          /* 'export' by itself causes everything to be exported. */
-          if (*p2 == '\0')
-            export_all_variables = 1;
-          else
-            {
-              struct variable *v;
-
-              v = try_variable_definition (fstart, p2, o_file, 0);
-              if (v != 0)
-                v->export = v_export;
-              else
-                {
-                  unsigned int l;
-                  const char *cp;
-                  char *ap;
-
-                  /* Expand the line so we can use indirect and constructed
-                     variable names in an export command.  */
-                  cp = ap = allocated_variable_expand (p2);
-
-                  for (p = find_next_token (&cp, &l); p != 0;
-                       p = find_next_token (&cp, &l))
-                    {
-                      v = lookup_variable (p, l);
-                      if (v == 0)
-                        v = define_variable_loc (p, l, "", o_file, 0, fstart);
-                      v->export = v_export;
-                    }
-
-                  free (ap);
-                }
-            }
-          goto rule_complete;
-        }
-
-      if (word1eq ("unexport"))
-        {
-          if (*p2 == '\0')
-            export_all_variables = 0;
+            export_all_variables = exporting;
           else
             {
               unsigned int l;
-              struct variable *v;
               const char *cp;
               char *ap;
 
               /* Expand the line so we can use indirect and constructed
-                 variable names in an unexport command.  */
+                 variable names in an (un)export command.  */
               cp = ap = allocated_variable_expand (p2);
 
@@ -759 +795 @@
                    p = find_next_token (&cp, &l))
                 {
-                  v = lookup_variable (p, l);
+                  struct variable *v = lookup_variable (p, l);
                   if (v == 0)
                     v = define_variable_loc (p, l, "", o_file, 0, fstart);
-
-                  v->export = v_noexport;
+                  v->export = exporting ? v_export : v_noexport;
                 }
 
@@ -771 +806 @@
         }
 
- skip_conditionals:
+      /* Handle the special syntax for vpath.  */
       if (word1eq ("vpath"))
         {
@@ -781 +816 @@
           if (p != 0)
             {
-              vpat = savestring (p, l);
+              vpat = xstrndup (p, l);
               p = find_next_token (&cp, &l);
               /* No searchpath means remove all previous
@@ -796 +831 @@
         }
 
+      /* Handle include and variants.  */
       if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude"))
         {
@@ -816 +852 @@
             }
 
-          /* Parse the list of file names.  */
+          /* Parse the list of file names.  Don't expand archive references!  */
           p2 = p;
-          files = multi_glob (parse_file_seq (&p2, '\0',
-                                              sizeof (struct nameseq),
-                                              1),
-                              sizeof (struct nameseq));
+          files = PARSE_FILE_SEQ (&p2, struct nameseq, '\0', NULL,
+                                  PARSEFS_NOAR);
           free (p);
 
@@ -839 +873 @@
               int r;
 
-              free (files);
+              free_ns (files);
               files = next;
 
-              r = eval_makefile (name, (RM_INCLUDED | RM_NO_TILDE
-                                        | (noerror ? RM_DONTCARE : 0)));
+              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));
@@ -853 +889 @@
           goto rule_complete;
         }
-
-      if (try_variable_definition (fstart, p, o_file, 0))
-        /* This line has been dealt with.  */
-        goto rule_complete;
 
       /* This line starts with a tab but was not caught above because there
@@ -876 +908 @@
       {
         enum make_word_type wtype;
-        enum variable_origin v_origin;
-        int exported;
         char *cmdleft, *semip, *lb_next;
         unsigned int plen = 0;
@@ -1009 +1039 @@
            looking for targets.  */
         *colonp = '\0';
-        filenames = multi_glob (parse_file_seq (&p2, '\0',
-                                                sizeof (struct nameseq),
-                                                1),
-                                sizeof (struct nameseq));
+        filenames = PARSE_FILE_SEQ (&p2, struct nameseq, '\0', NULL, 0);
         *p2 = ':';
 
@@ -1043 +1070 @@
           }
 
-        /* See if it's an "override" or "export" keyword; if so see if what
-           comes after it looks like a variable definition.  */
-
-        wtype = get_next_mword (p2, NULL, &p, &wlen);
-
-        v_origin = o_file;
-        exported = 0;
-        if (wtype == w_static)
-          {
-            if (word1eq ("override"))
-              {
-                v_origin = o_override;
-                wtype = get_next_mword (p+wlen, NULL, &p, &wlen);
-              }
-            else if (word1eq ("export"))
-              {
-                exported = 1;
-                wtype = get_next_mword (p+wlen, NULL, &p, &wlen);
-              }
-          }
-
-        if (wtype != w_eol)
-          wtype = get_next_mword (p+wlen, NULL, NULL, NULL);
-
-        if (wtype == w_varassign)
+        p2 = parse_var_assignment (p2, &vmod);
+        if (vmod.assign_v)
           {
             /* If there was a semicolon found, add it back, plus anything
@@ -1075 +1079 @@
                 unsigned int l = p - variable_buffer;
                 *(--semip) = ';';
+                collapse_continuations (semip);
                 variable_buffer_output (p2 + strlen (p2),
                                         semip, strlen (semip)+1);
                 p = variable_buffer + l;
               }
-            record_target_var (filenames, p, v_origin, exported, fstart);
+            record_target_var (filenames, p2,
+                               vmod.override_v ? o_override : o_file,
+                               &vmod, fstart);
             filenames = 0;
             continue;
@@ -1111 +1118 @@
         while (p != 0 && p[-1] == '\\')
           {
-            register char *q = &p[-1];
-            register int backslash = 0;
+            char *q = &p[-1];
+            int backslash = 0;
             while (*q-- == '\\')
               backslash = !backslash;
@@ -1155 +1162 @@
           {
             struct nameseq *target;
-            target = parse_file_seq (&p2, ':', sizeof (struct nameseq), 1);
+            target = PARSE_FILE_SEQ (&p2, struct nameseq, ':', NULL,
+                                     PARSEFS_NOGLOB);
             ++p2;
             if (target == 0)
@@ -1165 +1173 @@
             if (pattern_percent == 0)
               fatal (fstart, _("target pattern contains no `%%'"));
-            free (target);
+            free_ns (target);
           }
         else
@@ -1175 +1183 @@
         strip_whitespace (&beg, &end);
 
+        /* Put all the prerequisites here; they'll be parsed later.  */
         if (beg <= end && *beg != '\0')
-          {
-            /* Put all the prerequisites here; they'll be parsed later.  */
-            deps = alloc_dep ();
-            deps->name = strcache_add_len (beg, end - beg + 1);
-          }
+          depstr = xstrndup (beg, end - beg + 1);
         else
-          deps = 0;
+          depstr = 0;
 
         commands_idx = 0;
@@ -1216 +1221 @@
            Because the target is not recorded until after ifeq directive is
            evaluated the .DEFAULT_GOAL does not contain foo yet as one
-           would expect. Because of this we have to move some of the logic
-           here.  */
-
-        if (**default_goal_name == '\0' && set_default)
+           would expect. Because of this we have to move the logic here.  */
+
+        if (set_default && default_goal_var->value[0] == '\0')
           {
             const char *name;
@@ -1300 +1304 @@
     free (collapsed);
   free (commands);
-
-  return 1;
 }
 
@@ -1321 +1323 @@
 }
 
+/* Execute a `undefine' directive.
+   The undefine line has already been read, and NAME is the name of
+   the variable to be undefined. */
+
+static void
+do_undefine (char *name, enum variable_origin origin, struct ebuffer *ebuf)
+{
+  char *p, *var;
+
+  /* Expand the variable name and find the beginning (NAME) and end.  */
+  var = allocated_variable_expand (name);
+  name = next_token (var);
+  if (*name == '\0')
+    fatal (&ebuf->floc, _("empty variable name"));
+  p = name + strlen (name) - 1;
+  while (p > name && isblank ((unsigned char)*p))
+    --p;
+  p[1] = '\0';
+
+  undefine_variable_global (name, p - name + 1, origin);
+  free (var);
+}
+
 /* 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.  */
 
-static void
-do_define (char *name, unsigned int namelen,
-           enum variable_origin origin, struct ebuffer *ebuf)
+static struct variable *
+do_define (char *name, enum variable_origin origin, struct ebuffer *ebuf)
 {
+  struct variable *v;
+  enum variable_flavor flavor;
   struct floc defstart;
-  long nlines = 0;
   int nlevels = 1;
   unsigned int length = 100;
   char *definition = xmalloc (length);
   unsigned int idx = 0;
-  char *p;
-
-  /* Expand the variable name.  */
-  char *var = alloca (namelen + 1);
-  memcpy (var, name, namelen);
-  var[namelen] = '\0';
-  var = variable_expand (var);
+  char *p, *var;
 
   defstart = ebuf->floc;
 
+  p = parse_variable_definition (name, &flavor);
+  if (p == NULL)
+    /* No assignment token, so assume recursive.  */
+    flavor = f_recursive;
+  else
+    {
+      if (*(next_token (p)) != '\0')
+        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';
+    }
+
+  /* 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"));
+  p = name + strlen (name) - 1;
+  while (p > name && isblank ((unsigned char)*p))
+    --p;
+  p[1] = '\0';
+
+  /* Now read the value of the variable.  */
   while (1)
     {
       unsigned int len;
       char *line;
-
-      nlines = readline (ebuf);
+      long nlines = readline (ebuf);
+
+      /* If there is nothing left to be eval'd, there's no 'endef'!!  */
+      if (nlines < 0)
+        fatal (&defstart, _("missing `endef', unterminated `define'"));
+
       ebuf->floc.lineno += nlines;
-
-      /* If there is nothing left to eval, we're done. */
-      if (nlines < 0)
-        break;
-
       line = ebuf->buffer;
 
@@ -1362 +1404 @@
 
       /* If the line doesn't begin with a tab, test to see if it introduces
-         another define, or ends one.  */
-
-      /* Stop if we find an 'endef' */
+         another define, or ends one.  Stop if we find an 'endef' */
       if (line[0] != cmd_prefix)
         {
@@ -1382 +1422 @@
               p += 5;
               remove_comments (p);
-              if (*next_token (p) != '\0')
+              if (*(next_token (p)) != '\0')
                 error (&ebuf->floc,
-                       _("Extraneous text after `endef' directive"));
+                       _("extraneous text after `endef' directive"));
 
               if (--nlevels == 0)
-                {
-                  /* Define the variable.  */
-                  if (idx == 0)
-                    definition[0] = '\0';
-                  else
-                    definition[idx - 1] = '\0';
-
-                  /* Always define these variables in the global set.  */
-                  define_variable_global (var, strlen (var), definition,
-                                          origin, 1, &defstart);
-                  free (definition);
-                  return;
-                }
+                break;
             }
         }
 
-      /* Otherwise add this line to the variable definition.  */
+      /* Add this line to the variable definition.  */
       len = strlen (line);
       if (idx + len + 1 > length)
@@ -1417 +1445 @@
     }
 
-  /* No `endef'!!  */
-  fatal (&defstart, _("missing `endef', unterminated `define'"));
-
-  /* NOTREACHED */
-  return;
+  /* We've got what we need; define the variable.  */
+  if (idx == 0)
+    definition[0] = '\0';
+  else
+    definition[idx - 1] = '\0';
+
+  v = do_variable_definition (&defstart, name, definition, origin, flavor, 0);
+  free (definition);
+  free (var);
+  return (v);
 }
 
@@ -1695 +1728 @@
 
 
-/* Remove duplicate dependencies in CHAIN.  */
-
-static unsigned long
-dep_hash_1 (const void *key)
-{
-  return_STRING_HASH_1 (dep_name ((struct dep const *) key));
-}
-
-static unsigned long
-dep_hash_2 (const void *key)
-{
-  return_STRING_HASH_2 (dep_name ((struct dep const *) key));
-}
-
-static int
-dep_hash_cmp (const void *x, const void *y)
-{
-  struct dep *dx = (struct dep *) x;
-  struct dep *dy = (struct dep *) y;
-  int cmp = strcmp (dep_name (dx), dep_name (dy));
-
-  /* If the names are the same but ignore_mtimes are not equal, one of these
-     is an order-only prerequisite and one isn't.  That means that we should
-     remove the one that isn't and keep the one that is.  */
-
-  if (!cmp && dx->ignore_mtime != dy->ignore_mtime)
-    dx->ignore_mtime = dy->ignore_mtime = 0;
-
-  return cmp;
-}
-
-
-void
-uniquize_deps (struct dep *chain)
-{
-  struct hash_table deps;
-  register struct dep **depp;
-
-  hash_init (&deps, 500, dep_hash_1, dep_hash_2, dep_hash_cmp);
-
-  /* Make sure that no dependencies are repeated.  This does not
-     really matter for the purpose of updating targets, but it
-     might make some names be listed twice for $^ and $?.  */
-
-  depp = &chain;
-  while (*depp)
-    {
-      struct dep *dep = *depp;
-      struct dep **dep_slot = (struct dep **) hash_find_slot (&deps, dep);
-      if (HASH_VACANT (*dep_slot))
-        {
-          hash_insert_at (&deps, dep, dep_slot);
-          depp = &dep->next;
-        }
-      else
-        {
-          /* Don't bother freeing duplicates.
-             It's dangerous and little benefit accrues.  */
-          *depp = dep->next;
-        }
-    }
-
-  hash_free (&deps, 0);
-}
-
 
 /* Record target-specific variable values for files FILENAMES.
@@ -1772 +1740 @@
 static void
 record_target_var (struct nameseq *filenames, char *defn,
-                   enum variable_origin origin, int exported,
+                   enum variable_origin origin, struct vmodifiers *vmod,
                    const struct floc *flocp)
 {
@@ -1792 +1760 @@
 
       nextf = filenames->next;
-      free (filenames);
+      free_ns (filenames);
 
       /* If it's a pattern target, then add it to the pattern-specific
@@ -1804 +1772 @@
           /* I don't think this can fail since we already determined it was a
              variable definition.  */
-          v = parse_variable_definition (&p->variable, defn);
+          v = assign_variable_definition (&p->variable, defn);
           assert (v != 0);
 
+          v->origin = origin;
           if (v->flavor == f_simple)
             v->value = allocated_variable_expand (v->value);
@@ -1834 +1803 @@
           v = try_variable_definition (flocp, defn, origin, 1);
           if (!v)
-            error (flocp, _("Malformed target-specific variable definition"));
+            fatal (flocp, _("Malformed target-specific variable definition"));
           current_variable_set_list = global;
         }
 
       /* Set up the variable to be *-specific.  */
-      v->origin = origin;
       v->per_target = 1;
-      v->export = exported ? v_export : v_default;
+      v->private_var = vmod->private_v;
+      v->export = vmod->export_v ? v_export : v_default;
 
       /* If it's not an override, check to see if there was a command-line
          setting.  If so, reset the value.  */
-      if (origin != o_override)
+      if (v->origin != o_override)
         {
           struct variable *gv;
@@ -1878 +1847 @@
 static void
 record_files (struct nameseq *filenames, const char *pattern,
-              const char *pattern_percent, struct dep *deps,
+              const char *pattern_percent, char *depstr,
               unsigned int cmds_started, char *commands,
               unsigned int commands_idx, int two_colon,
               const struct floc *flocp)
 {
-  struct nameseq *nextf;
-  int implicit = 0;
-  unsigned int max_targets = 0, target_idx = 0;
-  const char **targets = 0, **target_percents = 0;
   struct commands *cmds;
+  struct dep *deps;
+  const char *implicit_percent;
+  const char *name;
 
   /* If we've already snapped deps, that means we're in an eval being
@@ -1896 +1864 @@
     fatal (flocp, _("prerequisites cannot be defined in recipes"));
 
+  /* Determine if this is a pattern rule or not.  */
+  name = filenames->name;
+  implicit_percent = find_percent_cached (&name);
+
+  /* If there's a recipe, set up a struct for it.  */
   if (commands_idx > 0)
     {
@@ -1901 +1874 @@
       cmds->fileinfo.filenm = flocp->filenm;
       cmds->fileinfo.lineno = cmds_started;
-      cmds->commands = savestring (commands, commands_idx);
+      cmds->commands = xstrndup (commands, commands_idx);
       cmds->command_lines = 0;
     }
   else
-    cmds = 0;
-
-  for (; filenames != 0; filenames = nextf)
+     cmds = 0;
+
+  /* If there's a prereq string then parse it--unless it's eligible for 2nd
+     expansion: if so, snap_deps() will do it.  */
+  if (depstr == 0)
+    deps = 0;
+  else if (second_expansion && strchr (depstr, '$'))
     {
-      const char *name = filenames->name;
+      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);
+    }
+
+  /* For implicit rules, _all_ the targets must have a pattern.  That means we
+     can test the first one to see if we're working with an implicit rule; if
+     so we handle it specially. */
+
+  if (implicit_percent)
+    {
+      struct nameseq *nextf;
+      const char **targets, **target_pats;
+      unsigned int c;
+
+      if (pattern != 0)
+        fatal (flocp, _("mixed implicit and static pattern rules"));
+
+      /* Count the targets to create an array of target names.
+         We already have the first one.  */
+      nextf = filenames->next;
+      free_ns (filenames);
+      filenames = nextf;
+
+      for (c = 1; nextf; ++c, nextf = nextf->next)
+        ;
+      targets = xmalloc (c * sizeof (const char *));
+      target_pats = xmalloc (c * sizeof (const char *));
+
+      targets[0] = name;
+      target_pats[0] = implicit_percent;
+
+      c = 1;
+      while (filenames)
+        {
+          name = filenames->name;
+          implicit_percent = find_percent_cached (&name);
+
+          if (implicit_percent == 0)
+            fatal (flocp, _("mixed implicit and normal rules"));
+
+          targets[c] = name;
+          target_pats[c] = implicit_percent;
+          ++c;
+
+          nextf = filenames->next;
+          free_ns (filenames);
+          filenames = nextf;
+        }
+
+      create_pattern_rule (targets, target_pats, c, two_colon, deps, cmds, 1);
+
+      return;
+    }
+
+
+  /* Walk through each target and create it in the database.
+     We already set up the first target, above.  */
+  while (1)
+    {
+      struct nameseq *nextf = filenames->next;
       struct file *f;
       struct dep *this = 0;
-      const char *implicit_percent;
-
-      nextf = filenames->next;
-      free (filenames);
+
+      free_ns (filenames);
 
       /* Check for special targets.  Do it here instead of, say, snap_deps()
          so that we can immediately use the value.  */
-
       if (streq (name, ".POSIX"))
-        posix_pedantic = 1;
+        {
+          posix_pedantic = 1;
+          define_variable_cname (".SHELLFLAGS", "-ec", o_default, 0);
+        }
       else if (streq (name, ".SECONDEXPANSION"))
         second_expansion = 1;
-
-      implicit_percent = find_percent_cached (&name);
-      implicit |= implicit_percent != 0;
-
-      if (implicit)
-        {
-          if (pattern != 0)
-            fatal (flocp, _("mixed implicit and static pattern rules"));
-
-          if (implicit_percent == 0)
-            fatal (flocp, _("mixed implicit and normal rules"));
-
-          if (targets == 0)
-            {
-              max_targets = 5;
-              targets = xmalloc (5 * sizeof (char *));
-              target_percents = xmalloc (5 * sizeof (char *));
-              target_idx = 0;
-            }
-          else if (target_idx == max_targets - 1)
-            {
-              max_targets += 5;
-              targets = xrealloc (targets, max_targets * sizeof (char *));
-              target_percents = xrealloc (target_percents,
-                                          max_targets * sizeof (char *));
-            }
-          targets[target_idx] = name;
-          target_percents[target_idx] = implicit_percent;
-          ++target_idx;
-          continue;
-        }
+#if !defined(WINDOWS32) && !defined (__MSDOS__) && !defined (__EMX__)
+      else if (streq (name, ".ONESHELL"))
+        one_shell = 1;
+#endif
 
       /* If this is a static pattern rule:
-         `targets: target%pattern: dep%pattern; cmds',
+         `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);
       else if (deps)
-        {
-          /* If there are multiple filenames, copy the chain DEPS for all but
-             the last one.  It is not safe for the same deps to go in more
-             than one place in the database.  */
-          this = nextf != 0 ? copy_dep_chain (deps) : deps;
-          this->need_2nd_expansion = (second_expansion
-                                      && strchr (this->name, '$'));
-        }
-
+        /* If there are multiple targets, copy the chain DEPS for all but the
+           last one.  It is not safe for the same deps to go in more than one
+           place in the database.  */
+        this = nextf != 0 ? copy_dep_chain (deps) : deps;
+
+      /* Find or create an entry in the file database for this target.  */
       if (!two_colon)
         {
-          /* Single-colon.  Combine these dependencies
-             with others in file's existing record, if any.  */
+          /* Single-colon.  Combine this rule with the file's existing record,
+             if any.  */
           f = enter_file (strcache_add (name));
-
           if (f->double_colon)
             fatal (flocp,
@@ -2001 +2020 @@
             }
 
-          f->is_target = 1;
-
           /* Defining .DEFAULT with no deps or cmds clears it.  */
           if (f == default_file && this == 0 && cmds == 0)
@@ -2016 +2033 @@
               f->deps = 0;
             }
-          else if (this != 0)
-            {
-              /* Add the file's old deps and the new ones in THIS together.  */
-
-              if (f->deps != 0)
-                {
-                  struct dep **d_ptr = &f->deps;
-
-                  while ((*d_ptr)->next != 0)
-                    d_ptr = &(*d_ptr)->next;
-
-                  if (cmds != 0)
-                    /* This is the rule with commands, so put its deps
-                       last. The rationale behind this is that $< expands to
-                       the first dep in the chain, and commands use $<
-                       expecting to get the dep that rule specifies.  However
-                       the second expansion algorithm reverses the order thus
-                       we need to make it last here.  */
-                    (*d_ptr)->next = this;
-                  else
-                    {
-                      /* This is the rule without commands. Put its
-                         dependencies at the end but before dependencies from
-                         the rule with commands (if any). This way everything
-                         appears in makefile order.  */
-
-                      if (f->cmds != 0)
-                        {
-                          this->next = *d_ptr;
-                          *d_ptr = this;
-                        }
-                      else
-                        (*d_ptr)->next = this;
-                    }
-                }
-              else
-                f->deps = this;
-
-              /* This is a hack. I need a way to communicate to snap_deps()
-                 that the last dependency line in this file came with commands
-                 (so that logic in snap_deps() can put it in front and all
-                 this $< -logic works). I cannot simply rely on file->cmds
-                 being not 0 because of the cases like the following:
-
-                 foo: bar
-                 foo:
-                     ...
-
-                 I am going to temporarily "borrow" UPDATING member in
-                 `struct file' for this.   */
-
-              if (cmds != 0)
-                f->updating = 1;
-            }
         }
       else
@@ -2076 +2039 @@
           f = lookup_file (name);
 
-          /* Check for both : and :: rules.  Check is_target so
-             we don't lose on default suffix rules or makefiles.  */
+          /* Check for both : and :: rules.  Check is_target so we don't lose
+             on default suffix rules or makefiles.  */
           if (f != 0 && f->is_target && !f->double_colon)
             fatal (flocp,
                    _("target file `%s' has both : and :: entries"), f->name);
+
           f = enter_file (strcache_add (name));
           /* If there was an existing entry and it was a double-colon entry,
@@ -2090 +2054 @@
                double_colon pointer to itself.  */
             f->double_colon = f;
-          f->is_target = 1;
-          f->deps = this;
+
           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
-         commands.  */
+         commands.  If we didn't do it before, enter the prereqs now.  */
       if (pattern)
         {
@@ -2107 +2072 @@
           if (this)
             {
-              this->staticpattern = 1;
-              this->stem = f->stem;
+              if (! this->need_2nd_expansion)
+                this = enter_prereqs (this, f->stem);
+              else
+                this->stem = f->stem;
             }
         }
 
+      /* Add the dependencies to this file entry.  */
+      if (this != 0)
+        {
+          /* Add the file's old deps and the new ones in THIS together.  */
+          if (f->deps == 0)
+            f->deps = this;
+          else if (cmds != 0)
+            {
+              struct dep *d = this;
+
+              /* If this rule has commands, put these deps first.  */
+              while (d->next != 0)
+                d = d->next;
+
+              d->next = f->deps;
+              f->deps = this;
+            }
+          else
+            {
+              struct dep *d = f->deps;
+
+              /* A rule without commands: put its prereqs at the end.  */
+              while (d->next != 0)
+                d = d->next;
+
+              d->next = this;
+            }
+        }
+
       name = f->name;
 
-      /* If this target is a default target, update DEFAULT_GOAL_FILE.  */
-      if (streq (*default_goal_name, name)
-          && (default_goal_file == 0
-              || ! streq (default_goal_file->name, name)))
-        default_goal_file = f;
-    }
-
-  if (implicit)
-    {
-      if (deps)
-        deps->need_2nd_expansion = second_expansion;
-      create_pattern_rule (targets, target_percents, target_idx,
-                           two_colon, deps, cmds, 1);
+      /* All done!  Set up for the next one.  */
+      if (nextf == 0)
+        break;
+
+      filenames = nextf;
+
+      /* Reduce escaped percents.  If there are any unescaped it's an error  */
+      name = filenames->name;
+      if (find_percent_cached (&name))
+        fatal (flocp, _("mixed implicit and normal rules"));
     }
 }
@@ -2250 +2243 @@
   const char *p = *string;
   char *new = 0;
-  int slen;
+  int slen = 0;
 
   /* If the first char is a % return now.  This lets us avoid extra tests
@@ -2316 +2309 @@
 
 
-/* Parse a string into a sequence of filenames represented as a
-   chain of struct nameseq's in reverse order and return that chain.
+/* Find the next line of text in an eval buffer, combining continuation lines
+   into one line.
+   Return the number of actual lines read (> 1 if continuation lines).
+   Returns -1 if there's nothing left in the buffer.
+
+   After this function, ebuf->buffer points to the first character of the
+   line we just found.
+ */
+
+/* Read a line of text from a STRING.
+   Since we aren't really reading from a file, don't bother with linenumbers.
+ */
+
+static unsigned long
+readstring (struct ebuffer *ebuf)
+{
+  char *eol;
+
+  /* If there is nothing left in this buffer, return 0.  */
+  if (ebuf->bufnext >= ebuf->bufstart + ebuf->size)
+    return -1;
+
+  /* Set up a new starting point for the buffer, and find the end of the
+     next logical line (taking into account backslash/newline pairs).  */
+
+  eol = ebuf->buffer = ebuf->bufnext;
+
+  while (1)
+    {
+      int backslash = 0;
+      const char *bol = eol;
+      const char *p;
+
+      /* Find the next newline.  At EOS, stop.  */
+      p = eol = strchr (eol , '\n');
+      if (!eol)
+        {
+          ebuf->bufnext = ebuf->bufstart + ebuf->size + 1;
+          return 0;
+        }
+
+      /* Found a newline; if it's escaped continue; else we're done.  */
+      while (p > bol && *(--p) == '\\')
+        backslash = !backslash;
+      if (!backslash)
+        break;
+      ++eol;
+    }
+
+  /* Overwrite the newline char.  */
+  *eol = '\0';
+  ebuf->bufnext = eol+1;
+
+  return 0;
+}
+
+static long
+readline (struct ebuffer *ebuf)
+{
+  char *p;
+  char *end;
+  char *start;
+  long nlines = 0;
+
+  /* The behaviors between string and stream buffers are different enough to
+     warrant different functions.  Do the Right Thing.  */
+
+  if (!ebuf->fp)
+    return readstring (ebuf);
+
+  /* When reading from a file, we always start over at the beginning of the
+     buffer for each new line.  */
+
+  p = start = ebuf->bufstart;
+  end = p + ebuf->size;
+  *p = '\0';
+
+  while (fgets (p, end - p, ebuf->fp) != 0)
+    {
+      char *p2;
+      unsigned long len;
+      int backslash;
+
+      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;
+        }
+
+      /* Jump past the text we just read.  */
+      p += len;
+
+      /* If the last char isn't a newline, the whole line didn't fit into the
+         buffer.  Get some more buffer and try again.  */
+      if (p[-1] != '\n')
+        goto more_buffer;
+
+      /* We got a newline, so add one to the count of lines.  */
+      ++nlines;
+
+#if !defined(WINDOWS32) && !defined(__MSDOS__) && !defined(__EMX__)
+      /* Check to see if the line was really ended with CRLF; if so ignore
+         the CR.  */
+      if ((p - start) > 1 && p[-2] == '\r')
+        {
+          --p;
+          p[-1] = '\n';
+        }
+#endif
+
+      backslash = 0;
+      for (p2 = p - 2; p2 >= start; --p2)
+        {
+          if (*p2 != '\\')
+            break;
+          backslash = !backslash;
+        }
+
+      if (!backslash)
+        {
+          p[-1] = '\0';
+          break;
+        }
+
+      /* It was a backslash/newline combo.  If we have more space, read
+         another line.  */
+      if (end - p >= 80)
+        continue;
+
+      /* We need more space at the end of our buffer, so realloc it.
+         Make sure to preserve the current offset of p.  */
+    more_buffer:
+      {
+        unsigned long off = p - start;
+        ebuf->size *= 2;
+        start = ebuf->buffer = ebuf->bufstart = xrealloc (start, ebuf->size);
+        p = start + off;
+        end = start + ebuf->size;
+        *p = '\0';
+      }
+    }
+
+  if (ferror (ebuf->fp))
+    pfatal_with_name (ebuf->floc.filenm);
+
+  /* If we found some lines, return how many.
+     If we didn't, but we did find _something_, that indicates we read the last
+     line of a file with no final newline; return 1.
+     If we read nothing, we're at EOF; return -1.  */
+
+  return nlines ? nlines : p == ebuf->bufstart ? -1 : 1;
+}
+
+
+/* Parse the next "makefile word" from the input buffer, and return info
+   about it.
+
+   A "makefile word" is one of:
+
+     w_bogus        Should never happen
+     w_eol          End of input
+     w_static       A static word; cannot be expanded
+     w_variable     A word containing one or more variables/functions
+     w_colon        A colon
+     w_dcolon       A double-colon
+     w_semicolon    A semicolon
+     w_varassign    A variable assignment operator (=, :=, +=, or ?=)
+
+   Note that this function is only used when reading certain parts of the
+   makefile.  Don't use it where special rules hold sway (RHS of a variable,
+   in a command list, etc.)  */
+
+static enum make_word_type
+get_next_mword (char *buffer, char *delim, char **startp, unsigned int *length)
+{
+  enum make_word_type wtype = w_bogus;
+  char *p = buffer, *beg;
+  char c;
+
+  /* Skip any leading whitespace.  */
+  while (isblank ((unsigned char)*p))
+    ++p;
+
+  beg = p;
+  c = *(p++);
+  switch (c)
+    {
+    case '\0':
+      wtype = w_eol;
+      break;
+
+    case ';':
+      wtype = w_semicolon;
+      break;
+
+    case '=':
+      wtype = w_varassign;
+      break;
+
+    case ':':
+      wtype = w_colon;
+      switch (*p)
+        {
+        case ':':
+          ++p;
+          wtype = w_dcolon;
+          break;
+
+        case '=':
+          ++p;
+          wtype = w_varassign;
+          break;
+        }
+      break;
+
+    case '+':
+    case '?':
+      if (*p == '=')
+        {
+          ++p;
+          wtype = w_varassign;
+          break;
+        }
+
+    default:
+      if (delim && strchr (delim, c))
+        wtype = w_static;
+      break;
+    }
+
+  /* Did we find something?  If so, return now.  */
+  if (wtype != w_bogus)
+    goto done;
+
+  /* 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.  */
+
+  /* We start out assuming a static word; if we see a variable we'll
+     adjust our assumptions then.  */
+  wtype = w_static;
+
+  /* We already found the first value of "c", above.  */
+  while (1)
+    {
+      char closeparen;
+      int count;
+
+      switch (c)
+        {
+        case '\0':
+        case ' ':
+        case '\t':
+        case '=':
+          goto done_word;
+
+        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;
+
+        case '$':
+          c = *(p++);
+          if (c == '$')
+            break;
+
+          /* This is a variable reference, so note that it's expandable.
+             Then read it to the matching close paren.  */
+          wtype = w_variable;
+
+          if (c == '(')
+            closeparen = ')';
+          else if (c == '{')
+            closeparen = '}';
+          else
+            /* This is a single-letter variable reference.  */
+            break;
+
+          for (count=0; *p != '\0'; ++p)
+            {
+              if (*p == c)
+                ++count;
+              else if (*p == closeparen && --count < 0)
+                {
+                  ++p;
+                  break;
+                }
+            }
+          break;
+
+        case '?':
+        case '+':
+          if (*p == '=')
+            goto done_word;
+          break;
+
+        case '\\':
+          switch (*p)
+            {
+            case ':':
+            case ';':
+            case '=':
+            case '\\':
+              ++p;
+              break;
+            }
+          break;
+
+        default:
+          if (delim && strchr (delim, c))
+            goto done_word;
+          break;
+        }
+
+      c = *(p++);
+    }
+ done_word:
+  --p;
+
+ done:
+  if (startp)
+    *startp = beg;
+  if (length)
+    *length = p - beg;
+  return wtype;
+}
+
+
+/* Construct the list of include directories
+   from the arguments and the default list.  */
+
+void
+construct_include_path (const char **arg_dirs)
+{
+#ifdef VAXC             /* just don't ask ... */
+  stat_t stbuf;
+#else
+  struct stat stbuf;
+#endif
+  const char **dirs;
+  const char **cpp;
+  unsigned int idx;
+
+  /* Compute the number of pointers we need in the table.  */
+  idx = sizeof (default_include_directories) / sizeof (const char *);
+  if (arg_dirs)
+    for (cpp = arg_dirs; *cpp != 0; ++cpp)
+      ++idx;
+
+#ifdef  __MSDOS__
+  /* Add one for $DJDIR.  */
+  ++idx;
+#endif
+
+  dirs = xmalloc (idx * sizeof (const char *));
+
+  idx = 0;
+  max_incl_len = 0;
+
+  /* First consider any dirs specified with -I switches.
+     Ignore any that don't exist.  Remember the maximum string length.  */
+
+  if (arg_dirs)
+    while (*arg_dirs != 0)
+      {
+        const char *dir = *(arg_dirs++);
+        char *expanded = 0;
+        int e;
+
+        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))
+          {
+            unsigned int len = strlen (dir);
+            /* If dir name is written with trailing slashes, discard them.  */
+            while (len > 1 && dir[len - 1] == '/')
+              --len;
+            if (len > max_incl_len)
+              max_incl_len = len;
+            dirs[idx++] = strcache_add_len (dir, len);
+          }
+
+        if (expanded)
+          free (expanded);
+      }
+
+  /* Now add the standard default dirs at the end.  */
+
+#ifdef  __MSDOS__
+  {
+    /* The environment variable $DJDIR holds the root of the DJGPP directory
+       tree; add ${DJDIR}/include.  */
+    struct variable *djdir = lookup_variable ("DJDIR", 5);
+
+    if (djdir)
+      {
+        unsigned int len = strlen (djdir->value) + 8;
+        char *defdir = alloca (len + 1);
+
+        strcat (strcpy (defdir, djdir->value), "/include");
+        dirs[idx++] = strcache_add (defdir);
+
+        if (len > max_incl_len)
+          max_incl_len = len;
+      }
+  }
+#endif
+
+  for (cpp = default_include_directories; *cpp != 0; ++cpp)
+    {
+      int e;
+
+      EINTRLOOP (e, stat (*cpp, &stbuf));
+      if (e == 0 && S_ISDIR (stbuf.st_mode))
+        {
+          unsigned int len = strlen (*cpp);
+          /* If dir name is written with trailing slashes, discard them.  */
+          while (len > 1 && (*cpp)[len - 1] == '/')
+            --len;
+          if (len > max_incl_len)
+            max_incl_len = len;
+          dirs[idx++] = strcache_add_len (*cpp, len);
+        }
+    }
+
+  dirs[idx] = 0;
+
+  /* Now add each dir to the .INCLUDE_DIRS variable.  */
+
+  for (cpp = dirs; *cpp != 0; ++cpp)
+    do_variable_definition (NILF, ".INCLUDE_DIRS", *cpp,
+                            o_default, f_append, 0);
+
+  include_directories = dirs;
+}
+
+
+/* Expand ~ or ~USER at the beginning of NAME.
+   Return a newly malloc'd string or 0.  */
+
+char *
+tilde_expand (const char *name)
+{
+#ifndef VMS
+  if (name[1] == '/' || name[1] == '\0')
+    {
+      extern char *getenv ();
+      char *home_dir;
+      int is_variable;
+
+      {
+        /* Turn off --warn-undefined-variables while we expand HOME.  */
+        int save = warn_undefined_variables_flag;
+        warn_undefined_variables_flag = 0;
+
+        home_dir = allocated_variable_expand ("$(HOME)");
+
+        warn_undefined_variables_flag = save;
+      }
+
+      is_variable = home_dir[0] != '\0';
+      if (!is_variable)
+        {
+          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;
+            }
+        }
+# endif /* !AMIGA && !WINDOWS32 */
+      if (home_dir != 0)
+        {
+          char *new = xstrdup (concat (2, home_dir, name + 1));
+          if (is_variable)
+            free (home_dir);
+          return new;
+        }
+    }
+# if !defined(_AMIGA) && !defined(WINDOWS32)
+  else
+    {
+      struct passwd *pwent;
+      char *userend = strchr (name + 1, '/');
+      if (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));
+        }
+      else if (userend != 0)
+        *userend = '/';
+    }
+# endif /* !AMIGA && !WINDOWS32 */
+#endif /* !VMS */
+  return 0;
+}
+
+
+/* Parse a string into a sequence of filenames represented as a chain of
+   struct nameseq's and return that chain.  Optionally expand the strings via
+   glob().
 
    The string is passed as STRINGP, the address of a string pointer.
@@ -2327 +2853 @@
    that have room for additional info.
 
-   If STRIP is nonzero, strip `./'s off the beginning.  */
-
-struct nameseq *
-parse_file_seq (char **stringp, int stopchar, unsigned int size, int strip)
+   PREFIX, if non-null, is added to the beginning of each filename.
+
+   FLAGS allows one or more of the following bitflags to be set:
+        PARSEFS_NOSTRIP - Do no strip './'s off the beginning
+        PARSEFS_NOAR    - Do not check filenames for archive references
+        PARSEFS_NOGLOB  - Do not expand globbing characters
+        PARSEFS_EXISTS  - Only return globbed files that actually exist
+                          (cannot also set NOGLOB)
+        PARSEFS_NOCACHE - Do not add filenames to the strcache (caller frees)
+  */
+
+void *
+parse_file_seq (char **stringp, unsigned int size, int stopchar,
+                const char *prefix, int flags)
 {
+  extern void dir_setup_glob (glob_t *glob);
+
+  /* tmp points to tmpbuf after the prefix, if any.
+     tp is the end of the buffer. */
+  static char *tmpbuf = NULL;
+  static int tmpbuf_len = 0;
+
+  int cachep = (! (flags & PARSEFS_NOCACHE));
+
   struct nameseq *new = 0;
-  struct nameseq *new1, *lastnew1;
-  char *p = *stringp;
+  struct nameseq **newp = &new;
+#define NEWELT(_n)  do { \
+                        const char *__n = (_n); \
+                        *newp = xcalloc (size); \
+                        (*newp)->name = (cachep ? strcache_add (__n) : xstrdup (__n)); \
+                        newp = &(*newp)->next; \
+                    } while(0)
+
+  char *p;
+  glob_t gl;
+  char *tp;
 
 #ifdef VMS
@@ -2342 +2896 @@
 #endif
 
+  if (size < sizeof (struct nameseq))
+    size = sizeof (struct nameseq);
+
+  if (! (flags & PARSEFS_NOGLOB))
+    dir_setup_glob (&gl);
+
+  /* Get enough temporary space to construct the largest possible target.  */
+  {
+    int l = strlen (*stringp) + 1;
+    if (l > tmpbuf_len)
+      {
+        tmpbuf = xrealloc (tmpbuf, l);
+        tmpbuf_len = l;
+      }
+  }
+  tp = tmpbuf;
+
+  /* Parse STRING.  P will always point to the end of the parsed content.  */
+  p = *stringp;
   while (1)
     {
       const char *name;
-      char *q;
-
-      /* Skip whitespace; see if any more names are left.  */
+      const char **nlist = 0;
+      char *tildep = 0;
+#ifndef NO_ARCHIVES
+      char *arname = 0;
+      char *memname = 0;
+#endif
+      char *s;
+      int nlen;
+      int i;
+
+      /* Skip whitespace; at the end of the string or STOPCHAR we're done.  */
       p = next_token (p);
-      if (*p == '\0')
+      if (*p == '\0' || *p == stopchar)
         break;
-      if (*p == stopchar)
-        break;
-
-      /* There are, so find the end of the next name.  */
-      q = p;
-      p = find_char_unquote (q, stopchar, VMS_COMMA, 1, 0);
+
+      /* 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);
 #ifdef VMS
         /* convert comma separated list to space separated */
@@ -2379 +2959 @@
 #endif
       if (p == 0)
-        p = q + strlen (q);
-
-      if (strip)
+        p = s + strlen (s);
+
+      /* Strip leading "this directory" references.  */
+      if (! (flags & PARSEFS_NOSTRIP))
 #ifdef VMS
         /* Skip leading `[]'s.  */
-        while (p - q > 2 && q[0] == '[' && q[1] == ']')
+        while (p - s > 2 && s[0] == '[' && s[1] == ']')
 #else
         /* Skip leading `./'s.  */
-        while (p - q > 2 && q[0] == '.' && q[1] == '/')
+        while (p - s > 2 && s[0] == '.' && s[1] == '/')
 #endif
           {
-            q += 2;             /* Skip "./".  */
-            while (q < p && *q == '/')
-              /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
-              ++q;
+            /* Skip "./" and all following slashes.  */
+            s += 2;
+            while (*s == '/')
+              ++s;
           }
 
-      /* Extract the filename just found, and skip it.  */
-
-      if (q == p)
-        /* ".///" was stripped to "". */
+      /* Extract the filename just found, and skip it.
+         Set NAME to the string, and NLEN to its length.  */
+
+      if (s == p)
+        {
+        /* The name was stripped to empty ("./"). */
 #if defined(VMS)
-        continue;
+          continue;
 #elif defined(_AMIGA)
-        name = "";
+          /* PDS-- This cannot be right!! */
+          tp[0] = '\0';
+          nlen = 0;
 #else
-        name = "./";
+          tp[0] = '.';
+          tp[1] = '/';
+          tp[2] = '\0';
+          nlen = 2;
 #endif
+        }
       else
+        {
 #ifdef VMS
 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
  *  to remove this '\' before we can use the filename.
- * Savestring called because q may be read-only string constant.
+ * xstrdup called because S may be read-only string constant.
  */
-        {
-          char *qbase = xstrdup (q);
-          char *pbase = qbase + (p-q);
-          char *q1 = qbase;
-          char *q2 = q1;
-          char *p1 = pbase;
-
-          while (q1 != pbase)
+          char *n = tp;
+          while (s < p)
             {
-              if (*q1 == '\\' && *(q1+1) == ':')
-                {
-                  q1++;
-                  p1--;
-                }
-              *q2++ = *q1++;
+              if (s[0] == '\\' && s[1] == ':')
+                ++s;
+              *(n++) = *(s++);
             }
-          name = strcache_add_len (qbase, p1 - qbase);
-          free (qbase);
-        }
+          n[0] = '\0';
+          nlen = strlen (tp);
 #else
-        name = strcache_add_len (q, p - q);
+          nlen = p - s;
+          memcpy (tp, s, nlen);
+          tp[nlen] = '\0';
 #endif
-
-      /* Add it to the front of the chain.  */
-      new1 = xmalloc (size);
-      memset (new1, '\0', size);
-      new1->name = name;
-      new1->next = new;
-      new = new1;
-    }
+        }
+
+      /* At this point, TP points to the element and NLEN is its length.  */
 
 #ifndef NO_ARCHIVES
-
-  /* Look for multi-word archive references.
-     They are indicated by a elt ending with an unmatched `)' and
-     an elt further down the chain (i.e., previous in the file list)
-     with an unmatched `(' (e.g., "lib(mem").  */
-
-  new1 = new;
-  lastnew1 = 0;
-  while (new1 != 0)
-    if (new1->name[0] != '('    /* Don't catch "(%)" and suchlike.  */
-        && new1->name[strlen (new1->name) - 1] == ')'
-        && strchr (new1->name, '(') == 0)
-      {
-        /* NEW1 ends with a `)' but does not contain a `('.
-           Look back for an elt with an opening `(' but no closing `)'.  */
-
-        struct nameseq *n = new1->next, *lastn = new1;
-        char *paren = 0;
-        while (n != 0 && (paren = strchr (n->name, '(')) == 0)
-          {
-            lastn = n;
-            n = n->next;
-          }
-        if (n != 0
-            /* Ignore 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).  */
-            && n->name[0] != '(')
-          {
-            /* N is the first element in the archive group.
-               Its name looks like "lib(mem" (with no closing `)').  */
-
-            char *libname;
-
-            /* Copy "lib(" into LIBNAME.  */
-            ++paren;
-            libname = alloca (paren - n->name + 1);
-            memcpy (libname, n->name, paren - n->name);
-            libname[paren - n->name] = '\0';
-
-            if (*paren == '\0')
-              {
-                /* N was just "lib(", part of something like "lib( a b)".
-                   Edit it out of the chain and free its storage.  */
-                lastn->next = n->next;
-                free (n);
-                /* LASTN->next is the new stopping elt for the loop below.  */
-                n = lastn->next;
-              }
-            else
-              {
-                /* Replace N's name with the full archive reference.  */
-                n->name = strcache_add (concat (libname, paren, ")"));
-              }
-
-            if (new1->name[1] == '\0')
-              {
-                /* NEW1 is just ")", part of something like "lib(a b )".
-                   Omit it from the chain and free its storage.  */
-                if (lastnew1 == 0)
-                  new = new1->next;
-                else
-                  lastnew1->next = new1->next;
-                lastn = new1;
-                new1 = new1->next;
-                free (lastn);
-              }
-            else
-              {
-                /* Replace also NEW1->name, which already has closing `)'.  */
-                new1->name = strcache_add (concat (libname, new1->name, ""));
-                new1 = new1->next;
-              }
-
-            /* Trace back from NEW1 (the end of the list) until N
-               (the beginning of the list), rewriting each name
-               with the full archive reference.  */
-
-            while (new1 != n)
-              {
-                new1->name = strcache_add (concat (libname, new1->name, ")"));
-                lastnew1 = new1;
-                new1 = new1->next;
-              }
-          }
-        else
-          {
-            /* No frobnication happening.  Just step down the list.  */
-            lastnew1 = new1;
-            new1 = new1->next;
-          }
-      }
-    else
-      {
-        lastnew1 = new1;
-        new1 = new1->next;
-      }
-
-#endif
-
-  *stringp = p;
-  return new;
-}
-
-
-/* Find the next line of text in an eval buffer, combining continuation lines
-   into one line.
-   Return the number of actual lines read (> 1 if continuation lines).
-   Returns -1 if there's nothing left in the buffer.
-
-   After this function, ebuf->buffer points to the first character of the
-   line we just found.
- */
-
-/* Read a line of text from a STRING.
-   Since we aren't really reading from a file, don't bother with linenumbers.
- */
-
-static unsigned long
-readstring (struct ebuffer *ebuf)
-{
-  char *eol;
-
-  /* If there is nothing left in this buffer, return 0.  */
-  if (ebuf->bufnext >= ebuf->bufstart + ebuf->size)
-    return -1;
-
-  /* Set up a new starting point for the buffer, and find the end of the
-     next logical line (taking into account backslash/newline pairs).  */
-
-  eol = ebuf->buffer = ebuf->bufnext;
-
-  while (1)
-    {
-      int backslash = 0;
-      char *bol = eol;
-      char *p;
-
-      /* Find the next newline.  At EOS, stop.  */
-      eol = p = strchr (eol , '\n');
-      if (!eol)
+      /* If this is the start of an archive group that isn't complete, set up
+         to add the archive prefix for future files.  A file list like:
+         "libf.a(x.o y.o z.o)" needs to be expanded as:
+         "libf.a(x.o) libf.a(y.o) libf.a(z.o)"
+
+         TP == TMP means we're not already in an archive group.  Ignore
+         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
+         it's a complete reference so we don't need to treat it specially.
+
+         Finally, note that archive groups must end with ')' as the last
+         character, so ensure there's some word ending like that before
+         considering this an archive group.  */
+      if (! (flags & PARSEFS_NOAR)
+          && tp == tmpbuf && tp[0] != '(' && tp[nlen-1] != ')')
         {
-          ebuf->bufnext = ebuf->bufstart + ebuf->size + 1;
-          return 0;
+          char *n = strchr (tp, '(');
+          if (n)
+            {
+              /* 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;
+              do
+                {
+                  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))
+                    ++e;
+                  if (e[-1] == ')')
+                    {
+                      /* Found the end, so this is the first element in an
+                         open archive group.  It looks like "lib(mem".
+                         Reset TP past the open paren.  */
+                      nlen -= (n + 1) - tp;
+                      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;
+                    }
+                }
+              while (*e != '\0');
+            }
         }
 
-      /* Found a newline; if it's escaped continue; else we're done.  */
-      while (p > bol && *(--p) == '\\')
-        backslash = !backslash;
-      if (!backslash)
-        break;
-      ++eol;
-    }
-
-  /* Overwrite the newline char.  */
-  *eol = '\0';
-  ebuf->bufnext = eol+1;
-
-  return 0;
-}
-
-static long
-readline (struct ebuffer *ebuf)
-{
-  char *p;
-  char *end;
-  char *start;
-  long nlines = 0;
-
-  /* The behaviors between string and stream buffers are different enough to
-     warrant different functions.  Do the Right Thing.  */
-
-  if (!ebuf->fp)
-    return readstring (ebuf);
-
-  /* When reading from a file, we always start over at the beginning of the
-     buffer for each new line.  */
-
-  p = start = ebuf->bufstart;
-  end = p + ebuf->size;
-  *p = '\0';
-
-  while (fgets (p, end - p, ebuf->fp) != 0)
-    {
-      char *p2;
-      unsigned long len;
-      int backslash;
-
-      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;
-        }
-
-      /* Jump past the text we just read.  */
-      p += len;
-
-      /* If the last char isn't a newline, the whole line didn't fit into the
-         buffer.  Get some more buffer and try again.  */
-      if (p[-1] != '\n')
-        goto more_buffer;
-
-      /* We got a newline, so add one to the count of lines.  */
-      ++nlines;
-
-#if !defined(WINDOWS32) && !defined(__MSDOS__) && !defined(__EMX__)
-      /* Check to see if the line was really ended with CRLF; if so ignore
-         the CR.  */
-      if ((p - start) > 1 && p[-2] == '\r')
+      /* If we are inside an archive group, make sure it has an end.  */
+      if (tp > tmpbuf)
         {
-          --p;
-          p[-1] = '\n';
+          if (tp[nlen-1] == ')')
+            {
+              /* This is the natural end; reset TP.  */
+              tp = tmpbuf;
+
+              /* This is just ")", something like "lib(a b )": skip it.  */
+              if (nlen == 1)
+                continue;
+            }
+          else
+            {
+              /* Not the end, so add a "fake" end.  */
+              tp[nlen++] = ')';
+              tp[nlen] = '\0';
+            }
         }
 #endif
 
-      backslash = 0;
-      for (p2 = p - 2; p2 >= start; --p2)
+      /* 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));
+          continue;
+        }
+
+      /* If we get here we know we're doing glob expansion.
+         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;
+
+      /* Expand tilde if applicable.  */
+      if (tp[0] == '~')
         {
-          if (*p2 != '\\')
-            break;
-          backslash = !backslash;
+          tildep = tilde_expand (tp);
+          if (tildep != 0)
+            name = tildep;
         }
 
-      if (!backslash)
+#ifndef NO_ARCHIVES
+      /* If NAME is an archive member reference replace it with the archive
+         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))
         {
-          p[-1] = '\0';
-          break;
+          ar_parse_name (name, &arname, &memname);
+          name = arname;
         }
-
-      /* It was a backslash/newline combo.  If we have more space, read
-         another line.  */
-      if (end - p >= 80)
-        continue;
-
-      /* We need more space at the end of our buffer, so realloc it.
-         Make sure to preserve the current offset of p.  */
-    more_buffer:
-      {
-        unsigned long off = p - start;
-        ebuf->size *= 2;
-        start = ebuf->buffer = ebuf->bufstart = xrealloc (start, ebuf->size);
-        p = start + off;
-        end = start + ebuf->size;
-        *p = '\0';
-      }
-    }
-
-  if (ferror (ebuf->fp))
-    pfatal_with_name (ebuf->floc.filenm);
-
-  /* If we found some lines, return how many.
-     If we didn't, but we did find _something_, that indicates we read the last
-     line of a file with no final newline; return 1.
-     If we read nothing, we're at EOF; return -1.  */
-
-  return nlines ? nlines : p == ebuf->bufstart ? -1 : 1;
-}
-
-
-/* Parse the next "makefile word" from the input buffer, and return info
-   about it.
-
-   A "makefile word" is one of:
-
-     w_bogus        Should never happen
-     w_eol          End of input
-     w_static       A static word; cannot be expanded
-     w_variable     A word containing one or more variables/functions
-     w_colon        A colon
-     w_dcolon       A double-colon
-     w_semicolon    A semicolon
-     w_varassign    A variable assignment operator (=, :=, +=, or ?=)
-
-   Note that this function is only used when reading certain parts of the
-   makefile.  Don't use it where special rules hold sway (RHS of a variable,
-   in a command list, etc.)  */
-
-static enum make_word_type
-get_next_mword (char *buffer, char *delim, char **startp, unsigned int *length)
-{
-  enum make_word_type wtype = w_bogus;
-  char *p = buffer, *beg;
-  char c;
-
-  /* Skip any leading whitespace.  */
-  while (isblank ((unsigned char)*p))
-    ++p;
-
-  beg = p;
-  c = *(p++);
-  switch (c)
-    {
-    case '\0':
-      wtype = w_eol;
-      break;
-
-    case ';':
-      wtype = w_semicolon;
-      break;
-
-    case '=':
-      wtype = w_varassign;
-      break;
-
-    case ':':
-      wtype = w_colon;
-      switch (*p)
-        {
-        case ':':
-          ++p;
-          wtype = w_dcolon;
+#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 '=':
-          ++p;
-          wtype = w_varassign;
-          break;
-        }
-      break;
-
-    case '+':
-    case '?':
-      if (*p == '=')
-        {
-          ++p;
-          wtype = w_varassign;
-          break;
-        }
-
-    default:
-      if (delim && strchr (delim, c))
-        wtype = w_static;
-      break;
-    }
-
-  /* Did we find something?  If so, return now.  */
-  if (wtype != w_bogus)
-    goto done;
-
-  /* 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.  */
-
-  /* We start out assuming a static word; if we see a variable we'll
-     adjust our assumptions then.  */
-  wtype = w_static;
-
-  /* We already found the first value of "c", above.  */
-  while (1)
-    {
-      char closeparen;
-      int count;
-
-      switch (c)
-        {
-        case '\0':
-        case ' ':
-        case '\t':
-        case '=':
-          goto done_word;
-
-        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;
-
-        case '$':
-          c = *(p++);
-          if (c == '$')
-            break;
-
-          /* This is a variable reference, so note that it's expandable.
-             Then read it to the matching close paren.  */
-          wtype = w_variable;
-
-          if (c == '(')
-            closeparen = ')';
-          else if (c == '{')
-            closeparen = '}';
-          else
-            /* This is a single-letter variable reference.  */
-            break;
-
-          for (count=0; *p != '\0'; ++p)
+        case GLOB_NOMATCH:
+          /* If we want only existing items, skip this one.  */
+          if (flags & PARSEFS_EXISTS)
             {
-              if (*p == c)
-                ++count;
-              else if (*p == closeparen && --count < 0)
-                {
-                  ++p;
-                  break;
-                }
-            }
-          break;
-
-        case '?':
-        case '+':
-          if (*p == '=')
-            goto done_word;
-          break;
-
-        case '\\':
-          switch (*p)
-            {
-            case ':':
-            case ';':
-            case '=':
-            case '\\':
-              ++p;
+              i = 0;
               break;
             }
+          /* FALLTHROUGH */
+
+        default:
+          /* By default keep this name.  */
+          i = 1;
+          nlist = &name;
           break;
-
-        default:
-          if (delim && strchr (delim, c))
-            goto done_word;
-          break;
-        }
-
-      c = *(p++);
-    }
- done_word:
-  --p;
-
- done:
-  if (startp)
-    *startp = beg;
-  if (length)
-    *length = p - beg;
-  return wtype;
-}
-
-
-/* Construct the list of include directories
-   from the arguments and the default list.  */
-
-void
-construct_include_path (const char **arg_dirs)
-{
-#ifdef VAXC             /* just don't ask ... */
-  stat_t stbuf;
-#else
-  struct stat stbuf;
-#endif
-  const char **dirs;
-  const char **cpp;
-  unsigned int idx;
-
-  /* Compute the number of pointers we need in the table.  */
-  idx = sizeof (default_include_directories) / sizeof (const char *);
-  if (arg_dirs)
-    for (cpp = arg_dirs; *cpp != 0; ++cpp)
-      ++idx;
-
-#ifdef  __MSDOS__
-  /* Add one for $DJDIR.  */
-  ++idx;
-#endif
-
-  dirs = xmalloc (idx * sizeof (const char *));
-
-  idx = 0;
-  max_incl_len = 0;
-
-  /* First consider any dirs specified with -I switches.
-     Ignore any that don't exist.  Remember the maximum string length.  */
-
-  if (arg_dirs)
-    while (*arg_dirs != 0)
-      {
-        const char *dir = *(arg_dirs++);
-        char *expanded = 0;
-        int e;
-
-        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))
+        }
+
+      /* For each matched element, add it to the list.  */
+      while (i-- > 0)
+#ifndef NO_ARCHIVES
+        if (memname != 0)
           {
-            unsigned int len = strlen (dir);
-            /* If dir name is written with trailing slashes, discard them.  */
-            while (len > 1 && dir[len - 1] == '/')
-              --len;
-            if (len > max_incl_len)
-              max_incl_len = len;
-            dirs[idx++] = strcache_add_len (dir, len);
+            /* Try to glob on MEMNAME within the archive.  */
+            struct nameseq *found = ar_glob (nlist[i], memname, size);
+            if (! found)
+              /* No matches.  Use MEMNAME as-is.  */
+              NEWELT (concat (5, prefix, nlist[i], "(", memname, ")"));
+            else
+              {
+                /* We got a chain of items.  Attach them.  */
+                (*newp)->next = found;
+
+                /* Find and set the new end.  Massage names if necessary.  */
+                while (1)
+                  {
+                    if (! cachep)
+                      found->name = xstrdup (concat (2, prefix, name));
+                    else if (prefix)
+                      found->name = strcache_add (concat (2, prefix, name));
+
+                    if (found->next == 0)
+                      break;
+
+                    found = found->next;
+                  }
+                newp = &found->next;
+              }
           }
-
-        if (expanded)
-          free (expanded);
-      }
-
-  /* Now add the standard default dirs at the end.  */
-
-#ifdef  __MSDOS__
-  {
-    /* The environment variable $DJDIR holds the root of the DJGPP directory
-       tree; add ${DJDIR}/include.  */
-    struct variable *djdir = lookup_variable ("DJDIR", 5);
-
-    if (djdir)
-      {
-        unsigned int len = strlen (djdir->value) + 8;
-        char *defdir = alloca (len + 1);
-
-        strcat (strcpy (defdir, djdir->value), "/include");
-        dirs[idx++] = strcache_add (defdir);
-
-        if (len > max_incl_len)
-          max_incl_len = len;
-      }
-  }
-#endif
-
-  for (cpp = default_include_directories; *cpp != 0; ++cpp)
-    {
-      int e;
-
-      EINTRLOOP (e, stat (*cpp, &stbuf));
-      if (e == 0 && S_ISDIR (stbuf.st_mode))
-        {
-          unsigned int len = strlen (*cpp);
-          /* If dir name is written with trailing slashes, discard them.  */
-          while (len > 1 && (*cpp)[len - 1] == '/')
-            --len;
-          if (len > max_incl_len)
-            max_incl_len = len;
-          dirs[idx++] = strcache_add_len (*cpp, len);
-        }
-    }
-
-  dirs[idx] = 0;
-
-  /* Now add each dir to the .INCLUDE_DIRS variable.  */
-
-  for (cpp = dirs; *cpp != 0; ++cpp)
-    do_variable_definition (NILF, ".INCLUDE_DIRS", *cpp,
-                            o_default, f_append, 0);
-
-  include_directories = dirs;
-}
-
-
-/* Expand ~ or ~USER at the beginning of NAME.
-   Return a newly malloc'd string or 0.  */
-
-char *
-tilde_expand (const char *name)
-{
-#ifndef VMS
-  if (name[1] == '/' || name[1] == '\0')
-    {
-      extern char *getenv ();
-      char *home_dir;
-      int is_variable;
-
-      {
-        /* Turn off --warn-undefined-variables while we expand HOME.  */
-        int save = warn_undefined_variables_flag;
-        warn_undefined_variables_flag = 0;
-
-        home_dir = allocated_variable_expand ("$(HOME)");
-
-        warn_undefined_variables_flag = save;
-      }
-
-      is_variable = home_dir[0] != '\0';
-      if (!is_variable)
-        {
-          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;
-            }
-        }
-# endif /* !AMIGA && !WINDOWS32 */
-      if (home_dir != 0)
-        {
-          char *new = xstrdup (concat (home_dir, "", name + 1));
-          if (is_variable)
-            free (home_dir);
-          return new;
-        }
-    }
-# if !defined(_AMIGA) && !defined(WINDOWS32)
-  else
-    {
-      struct passwd *pwent;
-      char *userend = strchr (name + 1, '/');
-      if (userend != 0)
-        *userend = '\0';
-      pwent = getpwnam (name + 1);
-      if (pwent != 0)
-        {
-          if (userend == 0)
-            return xstrdup (pwent->pw_dir);
-          else
-            return xstrdup (concat (pwent->pw_dir, "/", userend + 1));
-        }
-      else if (userend != 0)
-        *userend = '/';
-    }
-# endif /* !AMIGA && !WINDOWS32 */
-#endif /* !VMS */
-  return 0;
-}
-
-/* Given a chain of struct nameseq's describing a sequence of filenames,
-   in reverse of the intended order, return a new chain describing the
-   result of globbing the filenames.  The new chain is in forward order.
-   The links of the old chain are freed or used in the new chain.
-   Likewise for the names in the old chain.
-
-   SIZE is how big to construct chain elements.
-   This is useful if we want them actually to be other structures
-   that have room for additional info.  */
-
-struct nameseq *
-multi_glob (struct nameseq *chain, unsigned int size)
-{
-  void dir_setup_glob (glob_t *);
-  struct nameseq *new = 0;
-  struct nameseq *old;
-  struct nameseq *nexto;
-  glob_t gl;
-
-  dir_setup_glob (&gl);
-
-  for (old = chain; old != 0; old = nexto)
-    {
-      const char *gname;
-#ifndef NO_ARCHIVES
-      char *arname = 0;
-      char *memname = 0;
-#endif
-      nexto = old->next;
-      gname = old->name;
-
-      if (gname[0] == '~')
-        {
-          char *newname = tilde_expand (old->name);
-          if (newname != 0)
-            gname = newname;
-        }
-
-#ifndef NO_ARCHIVES
-      if (ar_name (gname))
-        {
-          /* OLD->name is an archive member reference.  Replace it with the
-             archive file name, and save the member name in MEMNAME.  We will
-             glob on the archive name and then reattach MEMNAME later.  */
-          ar_parse_name (gname, &arname, &memname);
-          gname = arname;
-        }
+        else
 #endif /* !NO_ARCHIVES */
-
-      switch (glob (gname, GLOB_NOCHECK|GLOB_ALTDIRFUNC, NULL, &gl))
-        {
-        case 0:                 /* Success.  */
-          {
-            int i = gl.gl_pathc;
-            while (i-- > 0)
-              {
-#ifndef NO_ARCHIVES
-                if (memname != 0)
-                  {
-                    /* Try to glob on MEMNAME within the archive.  */
-                    struct nameseq *found
-                      = ar_glob (gl.gl_pathv[i], memname, size);
-                    if (! found)
-                      {
-                        /* No matches.  Use MEMNAME as-is.  */
-                        unsigned int alen = strlen (gl.gl_pathv[i]);
-                        unsigned int mlen = strlen (memname);
-                        char *name;
-                        struct nameseq *elt = xmalloc (size);
-                        memset (elt, '\0', size);
-
-                        name = alloca (alen + 1 + mlen + 2);
-                        memcpy (name, gl.gl_pathv[i], alen);
-                        name[alen] = '(';
-                        memcpy (name+alen+1, memname, mlen);
-                        name[alen + 1 + mlen] = ')';
-                        name[alen + 1 + mlen + 1] = '\0';
-                        elt->name = strcache_add (name);
-                        elt->next = new;
-                        new = elt;
-                      }
-                    else
-                      {
-                        /* Find the end of the FOUND chain.  */
-                        struct nameseq *f = found;
-                        while (f->next != 0)
-                          f = f->next;
-
-                        /* Attach the chain being built to the end of the FOUND
-                           chain, and make FOUND the new NEW chain.  */
-                        f->next = new;
-                        new = found;
-                      }
-                  }
-                else
-#endif /* !NO_ARCHIVES */
-                  {
-                    struct nameseq *elt = xmalloc (size);
-                    memset (elt, '\0', size);
-                    elt->name = strcache_add (gl.gl_pathv[i]);
-                    elt->next = new;
-                    new = elt;
-                  }
-              }
-            globfree (&gl);
-            free (old);
-            break;
-          }
-
-        case GLOB_NOSPACE:
-          fatal (NILF, _("virtual memory exhausted"));
-          break;
-
-        default:
-          old->next = new;
-          new = old;
-          break;
-        }
+          NEWELT (concat (2, prefix, nlist[i]));
+
+      globfree (&gl);
 
 #ifndef NO_ARCHIVES
@@ -3204 +3196 @@
         free (arname);
 #endif
+
+      if (tildep)
+        free (tildep);
     }
 
+  *stringp = p;
   return new;
 }