Changeset 280 for branches/GNU/src/gmake/read.c

Timestamp:

May 16, 2005, 6:54:02 PM (20 years ago)

Author:

bird

Message:

Current make snaphot, 2005-05-16.

Location:

branches/GNU/src/gmake

Files:

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

branches/GNU/src/gmake

@@ -34 +34 @@
 README.DOS
 README.W32
+README.OS2
 aclocal.m4
 autom4te.cache

@@ -34 +34 @@
 README.DOS
 README.W32
+README.OS2
 aclocal.m4
 autom4te.cache

branches/GNU/src/gmake/read.c

@@ -79 +79 @@
     unsigned int if_cmds;       /* Depth of conditional nesting.  */
     unsigned int allocated;     /* Elts allocated in following arrays.  */
-    char *ignoring;             /* Are we ignoring or interepreting?  */
+    char *ignoring;             /* Are we ignoring or interpreting?
+                                   0=interpreting, 1=not yet interpreted,
+                                   2=already interpreted */
     char *seen_else;            /* Have we already seen an `else'?  */
   };
@@ -131 +133 @@
                                enum variable_origin origin,
                                struct ebuffer *ebuf));
-static int conditional_line PARAMS ((char *line, const struct floc *flocp));
+static int conditional_line PARAMS ((char *line, int len, const struct floc *flocp));
 static void record_files PARAMS ((struct nameseq *filenames, char *pattern, char *pattern_percent,
                         struct dep *deps, unsigned int cmds_started, char *commands,
                         unsigned int commands_idx, int two_colon,
-                        int have_sysv_atvar,
-                        const struct floc *flocp, int set_default));
+                        const struct floc *flocp));
 static void record_target_var PARAMS ((struct nameseq *filenames, char *defn,
                                        enum variable_origin origin,
@@ -256 +257 @@
               d->file->dontcare = 1;
               d->ignore_mtime = 0;
+              d->need_2nd_expansion = 0;
               /* 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.  */
@@ -371 +373 @@
   deps->file = lookup_file (filename);
   if (deps->file == 0)
-    {
-      deps->file = enter_file (xstrdup (filename));
-      if (flags & RM_DONTCARE)
-        deps->file->dontcare = 1;
-    }
+    deps->file = enter_file (xstrdup (filename));
   if (filename != ebuf.floc.filenm)
     free (filename);
@@ -381 +379 @@
   deps->changed = flags;
   deps->ignore_mtime = 0;
+  deps->need_2nd_expansion = 0;
+  if (flags & RM_DONTCARE)
+    deps->file->dontcare = 1;
 
   /* If the makefile can't be found at all, give up entirely.  */
@@ -412 +413 @@
 
   free (ebuf.bufstart);
+  alloca (0);
   return r;
 }
@@ -443 +445 @@
   reading_file = curfile;
 
+  alloca (0);
   return r;
 }
@@ -464 +467 @@
   int ignoring = 0, in_ignored_define = 0;
   int no_targets = 0;           /* Set when reading a rule without targets.  */
-  int have_sysv_atvar = 0;
   struct nameseq *filenames = 0;
   struct dep *deps = 0;
@@ -481 +483 @@
           record_files (filenames, pattern, pattern_percent, deps,            \
                         cmds_started, commands, commands_idx, two_colon,      \
-                        have_sysv_atvar, &fi, set_default);                   \
+                        &fi);                                                 \
         }                                                                     \
       filenames = 0;                                                          \
@@ -618 +620 @@
          following lines.  */
 
-      if (!in_ignored_define
-          && (word1eq ("ifdef") || word1eq ("ifndef")
-              || word1eq ("ifeq") || word1eq ("ifneq")
-              || word1eq ("else") || word1eq ("endif")))
-        {
-          int i = conditional_line (p, fstart);
-          if (i < 0)
-            fatal (fstart, _("invalid syntax in conditional"));
-
-          ignoring = i;
-          continue;
+      if (!in_ignored_define)
+        {
+          int i = conditional_line (p, len, fstart);
+          if (i != -2)
+            {
+              if (i == -1)
+                fatal (fstart, _("invalid syntax in conditional"));
+
+              ignoring = i;
+              continue;
+            }
         }
 
@@ -853 +855 @@
         goto rule_complete;
 
+      /* This line starts with a tab but was not caught above because there
+         was no preceding target, and the line might have been usable as a
+         variable definition.  But now we know it is definitely lossage.  */
       if (line[0] == '\t')
-        {
-          p = collapsed;        /* Ignore comments, etc.  */
-          while (isblank ((unsigned char)*p))
-            ++p;
-          if (*p == '\0')
-            /* The line is completely blank; that is harmless.  */
-            continue;
-
-          /* This line starts with a tab but was not caught above
-             because there was no preceding target, and the line
-             might have been usable as a variable definition.
-             But now we know it is definitely lossage.  */
-          fatal(fstart, _("commands commence before first target"));
-        }
+        fatal(fstart, _("commands commence before first target"));
 
       /* This line describes some target files.  This is complicated by
@@ -886 +878 @@
         unsigned int len, plen = 0;
         char *colonp;
+        const char *end, *beg; /* Helpers for whitespace stripping. */
 
         /* Record the previous rule.  */
@@ -934 +927 @@
 
         p2 = variable_expand_string(NULL, lb_next, len);
+
         while (1)
           {
@@ -1040 +1034 @@
         if (*lb_next != '\0')
           {
-            unsigned int l = p - variable_buffer;
-            unsigned int l2 = p2 - variable_buffer;
+            unsigned int l = p2 - variable_buffer;
             plen = strlen (p2);
             (void) variable_buffer_output (p2+plen,
                                            lb_next, strlen (lb_next)+1);
-            p = variable_buffer + l;
-            p2 = variable_buffer + l2;
+            p2 = variable_buffer + l;
           }
 
@@ -1112 +1104 @@
               }
           }
-
-        /* Do any of the prerequisites appear to have $@ etc.?  */
-        have_sysv_atvar = 0;
-        if (!posix_pedantic)
-          for (p = strchr (p2, '$'); p != 0; p = strchr (p+1, '$'))
-            if (p[1] == '@' || ((p[1] == '(' || p[1] == '{') && p[2] == '@'))
-              {
-                have_sysv_atvar = 1;
-                break;
-              }
 
         /* Is this a static pattern rule: `target: %targ: %dep; ...'?  */
@@ -1187 +1169 @@
           pattern = 0;
 
-        /* Parse the dependencies.  */
-        deps = (struct dep *)
-          multi_glob (parse_file_seq (&p2, '|', sizeof (struct dep), 1),
-                      sizeof (struct dep));
-        if (*p2)
+        /* Strip leading and trailing whitespaces. */
+        beg = p2;
+        end = beg + strlen (beg) - 1;
+        strip_whitespace (&beg, &end);
+
+        if (beg <= end && *beg != '\0')
           {
-            /* Files that follow '|' are special prerequisites that
-               need only exist in order to satisfy the dependency.
-               Their modification times are irrelevant.  */
-            struct dep **deps_ptr = &deps;
-            struct dep *d;
-            for (deps_ptr = &deps; *deps_ptr; deps_ptr = &(*deps_ptr)->next)
-              ;
-            ++p2;
-            *deps_ptr = (struct dep *)
-              multi_glob (parse_file_seq (&p2, '\0', sizeof (struct dep), 1),
-                          sizeof (struct dep));
-            for (d = *deps_ptr; d != 0; d = d->next)
-              d->ignore_mtime = 1;
+            char *top;
+            const char *fromp = beg;
+
+            /* Make a copy of the dependency string.  Note if we find '$'.  */
+            deps = (struct dep*) xmalloc (sizeof (struct dep));
+            deps->next = 0;
+            deps->name = top = (char *) xmalloc (end - beg + 2);
+            deps->need_2nd_expansion = 0;
+            while (fromp <= end)
+              {
+                if (*fromp == '$')
+                  deps->need_2nd_expansion = 1;
+                *(top++) = *(fromp++);
+              }
+            *top = '\0';
+            deps->file = 0;
           }
+        else
+          deps = 0;
 
         commands_idx = 0;
@@ -1225 +1213 @@
             commands_idx += len;
             commands[commands_idx++] = '\n';
+          }
+
+        /* Determine if this target should be made default. We used to do
+           this in record_files() but because of the delayed target recording
+           and because preprocessor directives are legal in target's commands
+           it is too late. Consider this fragment for example:
+
+           foo:
+
+           ifeq ($(.DEFAULT_GOAL),foo)
+              ...
+           endif
+
+           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)
+          {
+            char* name;
+            struct dep *d;
+            struct nameseq *t = filenames;
+
+            for (; t != 0; t = t->next)
+              {
+                int reject = 0;
+                name = t->name;
+
+                /* We have nothing to do if this is an implicit rule. */
+                if (strchr (name, '%') != 0)
+                  break;
+
+                /* See if this target's name does not start with a `.',
+                   unless it contains a slash.  */
+                if (*name == '.' && strchr (name, '/') == 0
+#ifdef HAVE_DOS_PATHS
+                    && strchr (name, '\\') == 0
+#endif
+                    )
+                  continue;
+
+
+                /* If this file is a suffix, don't let it be
+                   the default goal file.  */
+                for (d = suffix_file->deps; d != 0; d = d->next)
+                  {
+                    register struct dep *d2;
+                    if (*dep_name (d) != '.' && streq (name, dep_name (d)))
+                      {
+                        reject = 1;
+                        break;
+                      }
+                    for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
+                      {
+                        register unsigned int len = strlen (dep_name (d2));
+                        if (!strneq (name, dep_name (d2), len))
+                          continue;
+                        if (streq (name + len, dep_name (d)))
+                          {
+                            reject = 1;
+                            break;
+                          }
+                      }
+
+                    if (reject)
+                      break;
+                  }
+
+                if (!reject)
+                  {
+                    define_variable_global (".DEFAULT_GOAL", 13, t->name,
+                                            o_file, 0, NILF);
+                    break;
+                  }
+              }
           }
 
@@ -1283 +1347 @@
       char *line;
 
+      nlines = readline (ebuf);
       ebuf->floc.lineno += nlines;
-      nlines = readline (ebuf);
 
       /* If there is nothing left to eval, we're done. */
@@ -1365 +1429 @@
    current makefile.  They are used for error messages.
 
-   Value is -1 if the line is invalid,
+   Value is -2 if the line is not a conditional at all,
+   -1 if the line is an invalid conditional,
    0 if following text should be interpreted,
    1 if following text should be ignored.  */
 
 static int
-conditional_line (char *line, const struct floc *flocp)
+conditional_line (char *line, int len, const struct floc *flocp)
 {
-  int notdef;
   char *cmdname;
-  register unsigned int i;
-
-  if (*line == 'i')
-    {
-      /* It's an "if..." command.  */
-      notdef = line[2] == 'n';
-      if (notdef)
-        {
-          cmdname = line[3] == 'd' ? "ifndef" : "ifneq";
-          line += cmdname[3] == 'd' ? 7 : 6;
-        }
-      else
-        {
-          cmdname = line[2] == 'd' ? "ifdef" : "ifeq";
-          line += cmdname[2] == 'd' ? 6 : 5;
-        }
-    }
+  enum { c_ifdef, c_ifndef, c_ifeq, c_ifneq, c_else, c_endif } cmdtype;
+  unsigned int i;
+  unsigned int o;
+
+  /* Compare a word, both length and contents. */
+#define word1eq(s)      (len == sizeof(s)-1 && strneq (s, line, sizeof(s)-1))
+#define chkword(s, t)   if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
+
+  /* Make sure this line is a conditional.  */
+  chkword ("ifdef", c_ifdef)
+  else chkword ("ifndef", c_ifndef)
+  else chkword ("ifeq", c_ifeq)
+  else chkword ("ifneq", c_ifneq)
+  else chkword ("else", c_else)
+  else chkword ("endif", c_endif)
   else
-    {
-      /* It's an "else" or "endif" command.  */
-      notdef = line[1] == 'n';
-      cmdname = notdef ? "endif" : "else";
-      line += notdef ? 5 : 4;
-    }
-
-  line = next_token (line);
-
-  if (*cmdname == 'e')
+    return -2;
+
+  /* Found one: skip past it and any whitespace after it.  */
+  line = next_token (line + len);
+
+#define EXTRANEOUS() error (flocp, _("Extraneous text after `%s' directive"), cmdname)
+
+  /* An 'endif' cannot contain extra text, and reduces the if-depth by 1  */
+  if (cmdtype == c_endif)
     {
       if (*line != '\0')
-        error (flocp, _("Extraneous text after `%s' directive"), cmdname);
-      /* "Else" or "endif".  */
-      if (conditionals->if_cmds == 0)
+        EXTRANEOUS ();
+
+      if (!conditionals->if_cmds)
         fatal (flocp, _("extraneous `%s'"), cmdname);
-      /* NOTDEF indicates an `endif' command.  */
-      if (notdef)
-        --conditionals->if_cmds;
-      else if (conditionals->seen_else[conditionals->if_cmds - 1])
-        fatal (flocp, _("only one `else' per conditional"));
+
+      --conditionals->if_cmds;
+
+      goto DONE;
+    }
+
+  /* An 'else' statement can either be simple, or it can have another
+     conditional after it.  */
+  if (cmdtype == c_else)
+    {
+      const char *p;
+
+      if (!conditionals->if_cmds)
+        fatal (flocp, _("extraneous `%s'"), cmdname);
+
+      o = conditionals->if_cmds - 1;
+
+      if (conditionals->seen_else[o])
+        fatal (flocp, _("only one `else' per conditional"));
+
+      /* Change the state of ignorance.  */
+      switch (conditionals->ignoring[o])
+        {
+          case 0:
+            /* We've just been interpreting.  Never do it again.  */
+            conditionals->ignoring[o] = 2;
+            break;
+          case 1:
+            /* We've never interpreted yet.  Maybe this time!  */
+            conditionals->ignoring[o] = 0;
+            break;
+        }
+
+      /* It's a simple 'else'.  */
+      if (*line == '\0')
+        {
+          conditionals->seen_else[o] = 1;
+          goto DONE;
+        }
+
+      /* The 'else' has extra text.  That text must be another conditional
+         and cannot be an 'else' or 'endif'.  */
+
+      /* Find the length of the next word.  */
+      for (p = line+1; *p != '\0' && !isspace ((unsigned char)*p); ++p)
+        ;
+      len = p - line;
+
+      /* If it's 'else' or 'endif' or an illegal conditional, fail.  */
+      if (word1eq("else") || word1eq("endif")
+          || conditional_line (line, len, flocp) < 0)
+        EXTRANEOUS ();
       else
-        {
-          /* Toggle the state of ignorance.  */
-          conditionals->ignoring[conditionals->if_cmds - 1]
-            = !conditionals->ignoring[conditionals->if_cmds - 1];
-          /* Record that we have seen an `else' in this conditional.
-             A second `else' will be erroneous.  */
-          conditionals->seen_else[conditionals->if_cmds - 1] = 1;
-        }
-      for (i = 0; i < conditionals->if_cmds; ++i)
-        if (conditionals->ignoring[i])
-          return 1;
-      return 0;
+        {
+          /* conditional_line() created a new level of conditional.
+             Raise it back to this level.  */
+          if (conditionals->ignoring[o] < 2)
+            conditionals->ignoring[o] = conditionals->ignoring[o+1];
+          --conditionals->if_cmds;
+        }
+
+      goto DONE;
     }
 
@@ -1435 +1540 @@
     }
 
-  ++conditionals->if_cmds;
+  o = conditionals->if_cmds++;
   if (conditionals->if_cmds > conditionals->allocated)
     {
@@ -1446 +1551 @@
 
   /* Record that we have seen an `if...' but no `else' so far.  */
-  conditionals->seen_else[conditionals->if_cmds - 1] = 0;
+  conditionals->seen_else[o] = 0;
 
   /* Search through the stack to see if we're already ignoring.  */
-  for (i = 0; i < conditionals->if_cmds - 1; ++i)
+  for (i = 0; i < o; ++i)
     if (conditionals->ignoring[i])
       {
-        /* We are already ignoring, so just push a level
-           to match the next "else" or "endif", and keep ignoring.
-           We don't want to expand variables in the condition.  */
-        conditionals->ignoring[conditionals->if_cmds - 1] = 1;
+        /* We are already ignoring, so just push a level to match the next
+           "else" or "endif", and keep ignoring.  We don't want to expand
+           variables in the condition.  */
+        conditionals->ignoring[o] = 1;
         return 1;
       }
 
-  if (cmdname[notdef ? 3 : 2] == 'd')
+  if (cmdtype == c_ifdef || cmdtype == c_ifndef)
     {
-      /* "Ifdef" or "ifndef".  */
       char *var;
       struct variable *v;
-      register char *p;
+      char *p;
 
       /* Expand the thing we're looking up, so we can use indirect and
@@ -1478 +1582 @@
 
       var[i] = '\0';
-      v = lookup_variable (var, strlen (var));
-      conditionals->ignoring[conditionals->if_cmds - 1]
-        = (v != 0 && *v->value != '\0') == notdef;
+      v = lookup_variable (var, i);
+
+      conditionals->ignoring[o] =
+        ((v != 0 && *v->value != '\0') == (cmdtype == c_ifndef));
 
       free (var);
@@ -1498 +1603 @@
       if (termin == ',')
         {
-          register int count = 0;
+          int count = 0;
           for (; *line != '\0'; ++line)
             if (*line == '(')
@@ -1572 +1677 @@
       line = next_token (++line);
       if (*line != '\0')
-        error (flocp, _("Extraneous text after `%s' directive"), cmdname);
+        EXTRANEOUS ();
 
       s2 = variable_expand (s2);
-      conditionals->ignoring[conditionals->if_cmds - 1]
-        = streq (s1, s2) == notdef;
+      conditionals->ignoring[o] = (streq (s1, s2) == (cmdtype == c_ifneq));
     }
 
+ DONE:
   /* Search through the stack to see if we're ignoring.  */
   for (i = 0; i < conditionals->if_cmds; ++i)
@@ -1694 +1799 @@
           p = create_pattern_var (name, percent);
           p->variable.fileinfo = *flocp;
+          /* I don't think this can fail since we already determined it was a
+             variable definition.  */
           v = parse_variable_definition (&p->variable, defn);
-          v->value = xstrdup (v->value);
-          if (!v)
-            error (flocp, _("Malformed pattern-specific variable definition"));
+          assert (v != 0);
+
+          if (v->flavor == f_simple)
+            v->value = allocated_variable_expand (v->value);
+          else
+            v->value = xstrdup (v->value);
+
           fname = p->target;
         }
@@ -1771 +1882 @@
               struct dep *deps, unsigned int cmds_started, char *commands,
               unsigned int commands_idx, int two_colon,
-              int have_sysv_atvar, const struct floc *flocp, int set_default)
+              const struct floc *flocp)
 {
   struct nameseq *nextf;
@@ -1778 +1889 @@
   char **targets = 0, **target_percents = 0;
   struct commands *cmds;
+
+  /* If we've already snapped deps, that means we're in an eval being
+     resolved after the makefiles have been read in.  We can't add more rules
+     at this time, since they won't get snapped and we'll get core dumps.
+     See Savannah bug # 12124.  */
+  if (snapped_deps)
+    fatal (flocp, _("prerequisites cannot be defined in command scripts"));
 
   if (commands_idx > 0)
@@ -1843 +1961 @@
       /* 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 data base.  */
+         to go in more than one place in the database.  */
       this = nextf != 0 ? copy_dep_chain (deps) : deps;
 
@@ -1860 +1978 @@
             }
           else
-            {
-              /* We use patsubst_expand to do the work of translating
-                 the target pattern, the target's name and the dependencies'
-                 patterns into plain dependency names.  */
-              char *buffer = variable_expand ("");
-
-              for (d = this; d != 0; d = d->next)
-                {
-                  char *o;
-                  char *percent = find_percent (d->name);
-                  if (percent == 0)
-                    continue;
-                  o = patsubst_expand (buffer, name, pattern, d->name,
-                                       pattern_percent, percent);
-                  /* If the name expanded to the empty string, that's
-                     illegal.  */
-                  if (o == buffer)
-                    fatal (flocp,
-                           _("target `%s' leaves prerequisite pattern empty"),
-                           name);
-                  free (d->name);
-                  d->name = savestring (buffer, o - buffer);
-                }
-            }
-        }
-
-      /* If at least one of the dependencies uses $$@ etc. deal with that.
-         It would be very nice and very simple to just expand everything, but
-         it would break a lot of backward compatibility.  Maybe that's OK
-         since we're just emulating a SysV function, and if we do that then
-         why not emulate it completely (that's what SysV make does: it
-         re-expands the entire prerequisite list, all the time, with $@
-         etc. in scope).  But, it would be a pain indeed to document this
-         ("iff you use $$@, your prerequisite lists is expanded twice...")
-         Ouch.  Maybe better to make the code more complex.  */
-
-      if (have_sysv_atvar)
-        {
-          char *p;
-          int tlen = strlen (name);
-          char *fnp = strrchr (name, '/');
-          int dlen;
-          int flen;
-
-          if (fnp)
-            {
-              dlen = fnp - name;
-              ++fnp;
-              flen = strlen (fnp);
-            }
-          else
-            {
-              dlen = 0;
-              fnp = name;
-              flen = tlen;
-            }
-
-
-          for (d = this; d != 0; d = d->next)
-            for (p = strchr (d->name, '$'); p != 0; p = strchr (p+1, '$'))
+            /* We use subst_expand to do the work of translating % to $* in
+               the dependency line.  */
+
+            if (this != 0 && find_percent (this->name) != 0)
               {
-                char *s = p;
-                char *at;
-                int atlen;
-
-                /* If it's '$@', '$(@', or '${@', it's escaped */
-                if ((++p)[0] == '$'
-                    && (p[1] == '@'
-                        || ((p[1] == '(' || p[1] == '{') && p[2] == '@')))
-                  {
-                    bcopy (p, s, strlen (p)+1);
-                    continue;
-                  }
-
-                /* Maybe found one.  We like anything of any form matching @,
-                   [({]@[}):], or [({]@[DF][}):].  */
-
-                if (! (p[0] == '@'
-                       || ((p[0] == '(' || p[0] == '{') && (++p)[0] == '@'
-                           && (((++p)[0] == ')' || p[0] == '}' || p[0] == ':')
-                               || ((p[1] == ')' || p[1] == '}' || p[1] == ':')
-                                   && (p[0] == 'D' || p[0] == 'F'))))))
-                  continue;
-
-                /* Found one.  Compute the length and string ptr.  Move p
-                   past the variable reference.  */
-                switch (p[0])
-                  {
-                  case 'D':
-                    atlen = dlen;
-                    at = name;
-                    p += 2;
-                    break;
-
-                  case 'F':
-                    atlen = flen;
-                    at = fnp;
-                    p += 2;
-                    break;
-
-                  default:
-                    atlen = tlen;
-                    at = name;
-                    ++p;
-                    break;
-                  }
-
-                /* Get more space.  */
-                {
-                  int soff = s - d->name;
-                  int poff = p - d->name;
-                  d->name = (char *) xrealloc (d->name,
-                                               strlen (d->name) + atlen + 1);
-                  s = d->name + soff;
-                  p = d->name + poff;
-                }
-
-                /* Copy the string over.  */
-                bcopy(p, s+atlen, strlen (p)+1);
-                bcopy(at, s, atlen);
-                p = s + atlen - 1;
+                char *o;
+                char *buffer = variable_expand ("");
+
+                o = subst_expand (buffer, this->name, "%", "$*", 1, 2, 0);
+
+                free (this->name);
+                this->name = savestring (buffer, o - buffer);
+                this->need_2nd_expansion = 1;
               }
-        }
+        }
 
       if (!two_colon)
@@ -2021 +2031 @@
           if (cmds != 0)
             f->cmds = cmds;
+
           /* Defining .SUFFIXES with no dependencies
              clears out the list of suffixes.  */
@@ -2035 +2046 @@
               f->deps = 0;
             }
-          else if (f->deps != 0)
+          else if (this != 0)
             {
               /* Add the file's old deps and the new ones in THIS together.  */
 
-              struct dep *firstdeps, *moredeps;
-              if (cmds != 0)
-                {
-                  /* This is the rule with commands, so put its deps first.
-                     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.  */
-                  firstdeps = this;
-                  moredeps = f->deps;
-                }
-              else
-                {
-                  /* Append the new deps to the old ones.  */
-                  firstdeps = f->deps;
-                  moredeps = this;
-                }
-
-              if (firstdeps == 0)
-                firstdeps = moredeps;
-              else
-                {
-                  d = firstdeps;
-                  while (d->next != 0)
-                    d = d->next;
-                  d->next = moredeps;
-                }
-
-              f->deps = firstdeps;
+              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
-            f->deps = this;
 
           /* If this is a static pattern rule, set the file's stem to
@@ -2079 +2112 @@
               char *buffer = variable_expand ("");
               char *o = patsubst_expand (buffer, name, pattern, percent,
-                                         pattern_percent, percent);
+                                         pattern_percent+1, percent+1);
               f->stem = savestring (buffer, o - buffer);
             }
@@ -2115 +2148 @@
         }
 
-      /* See if this is first target seen whose name does
-         not start with a `.', unless it contains a slash.  */
-      if (default_goal_file == 0 && set_default
-          && (*name != '.' || strchr (name, '/') != 0
-#ifdef HAVE_DOS_PATHS
-                           || strchr (name, '\\') != 0
-#endif
-              ))
-        {
-          int reject = 0;
-
-          /* If this file is a suffix, don't
-             let it be the default goal file.  */
-
-          for (d = suffix_file->deps; d != 0; d = d->next)
-            {
-              register struct dep *d2;
-              if (*dep_name (d) != '.' && streq (name, dep_name (d)))
-                {
-                  reject = 1;
-                  break;
-                }
-              for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
-                {
-                  register unsigned int len = strlen (dep_name (d2));
-                  if (!strneq (name, dep_name (d2), len))
-                    continue;
-                  if (streq (name + len, dep_name (d)))
-                    {
-                      reject = 1;
-                      break;
-                    }
-                }
-              if (reject)
-                break;
-            }
-
-          if (!reject)
-            default_goal_file = f;
-        }
+      /* If this target is a default target, update DEFAULT_GOAL_FILE.  */
+      if (strcmp (*default_goal_name, name) == 0
+          && (default_goal_file == 0
+              || strcmp (default_goal_file->name, name) != 0))
+        default_goal_file = f;
     }
 
@@ -2498 +2496 @@
 readstring (struct ebuffer *ebuf)
 {
-  char *p;
+  char *eol;
 
   /* If there is nothing left in this buffer, return 0.  */
-  if (ebuf->bufnext > ebuf->bufstart + ebuf->size)
+  if (ebuf->bufnext >= ebuf->bufstart + ebuf->size)
     return -1;
 
@@ -2507 +2505 @@
      next logical line (taking into account backslash/newline pairs).  */
 
-  p = ebuf->buffer = ebuf->bufnext;
+  eol = ebuf->buffer = ebuf->bufnext;
 
   while (1)
     {
       int backslash = 0;
-
-      /* Find the next newline.  Keep track of backslashes as we look.  */
-      for (; *p != '\n' && *p != '\0'; ++p)
-        if (*p == '\\')
-          backslash = !backslash;
-
-      /* If we got to the end of the string or a newline with no backslash,
-         we're done. */
-      if (*p == '\0' || !backslash)
+      char *bol = eol;
+      char *p;
+
+      /* Find the next newline.  At EOS, stop.  */
+      eol = p = 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.  */
-  *p = '\0';
-  ebuf->bufnext = p+1;
+  *eol = '\0';
+  ebuf->bufnext = eol+1;
 
   return 0;

@@ -34 +34 @@
 README.DOS
 README.W32
+README.OS2
 aclocal.m4
 autom4te.cache