Changeset 2596 for vendor/gnumake/current/remake.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)
• remake.c (modified) (30 diffs)

vendor/gnumake/current/remake.c

@@ -1 +1 @@
 /* Basic dependency engine 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.
 
@@ -84 +84 @@
 {
   int t = touch_flag, q = question_flag, n = just_print_flag;
-  unsigned int j = job_slots;
   int status = -1;
 
@@ -136 +135 @@
               unsigned int ocommands_started;
               int x;
+
+              file->dontcare = g->dontcare;
+
               check_renamed (file);
               if (rebuilding_makefiles)
@@ -209 +211 @@
               any_not_updated |= !file->updated;
 
+              file->dontcare = 0;
+
               if (stop)
                 break;
@@ -265 +269 @@
       question_flag = q;
       just_print_flag = n;
-      job_slots = j;
     }
 
@@ -298 +301 @@
   if (f->considered == considered)
     {
-      DBF (DB_VERBOSE, _("Pruning file `%s'.\n"));
-      return f->command_state == cs_finished ? f->update_status : 0;
+      /* Check for the case where a target has been tried and failed but
+         the diagnostics hasn't been issued. If we need the diagnostics
+         then we will have to continue. */
+      if (!(f->updated && f->update_status > 0 && !f->dontcare && f->no_diag))
+        {
+          DBF (DB_VERBOSE, _("Pruning file `%s'.\n"));
+          return f->command_state == cs_finished ? f->update_status : 0;
+        }
     }
 
@@ -316 +325 @@
       /* If we got an error, don't bother with double_colon etc.  */
       if (status != 0 && !keep_going_flag)
-        return status;
+        return status;
 
       if (f->command_state == cs_running
@@ -348 +357 @@
 
 static void
-complain (const struct file *file)
+complain (struct file *file)
 {
   const char *msg_noparent
@@ -355 +364 @@
     = _("%sNo rule to make target `%s', needed by `%s'%s");
 
-  if (!keep_going_flag)
-    {
+  /* If this file has no_diag set then it means we tried to update it
+     before in the dontcare mode and failed. The target that actually
+     failed is not necessarily this file but could be one of its direct
+     or indirect dependencies. So traverse this file's dependencies and
+     find the one that actually caused the failure. */
+
+  struct dep *d;
+
+  for (d = file->deps; d != 0; d = d->next)
+    {
+      if (d->file->updated && d->file->update_status > 0 && file->no_diag)
+        {
+          complain (d->file);
+          break;
+        }
+    }
+
+  if (d == 0)
+    {
+      /* Didn't find any dependencies to complain about. */
+      if (!keep_going_flag)
+        {
+          if (file->parent == 0)
+            fatal (NILF, msg_noparent, "", file->name, "");
+
+          fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
+        }
+
       if (file->parent == 0)
-        fatal (NILF, msg_noparent, "", file->name, "");
-
-      fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
-    }
-
-  if (file->parent == 0)
-    error (NILF, msg_noparent, "*** ", file->name, ".");
-  else
-    error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
+        error (NILF, msg_noparent, "*** ", file->name, ".");
+      else
+        error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
+
+      file->no_diag = 0;
+    }
 }
 
@@ -374 +406 @@
 update_file_1 (struct file *file, unsigned int depth)
 {
-  register FILE_TIMESTAMP this_mtime;
+  FILE_TIMESTAMP this_mtime;
   int noexist, must_make, deps_changed;
   int dep_status = 0;
-  register struct dep *d, *lastd;
+  struct file *ofile;
+  struct dep *d, *ad;
+  struct dep amake;
   int running = 0;
 
@@ -389 +423 @@
                _("Recently tried and failed to update file `%s'.\n"));
 
-          /* If the file we tried to make is marked dontcare then no message
+          /* If the file we tried to make is marked no_diag then no message
              was printed about it when it failed during the makefile rebuild.
              If we're trying to build it again in the normal rebuild, print a
              message now.  */
-          if (file->dontcare && !rebuilding_makefiles)
-            {
-              file->dontcare = 0;
+          if (file->no_diag && !file->dontcare)
               complain (file);
-            }
 
           return file->update_status;
@@ -421 +452 @@
     }
 
+  /* Determine whether the diagnostics will be issued should this update
+     fail. */
+  file->no_diag = file->dontcare;
+
   ++depth;
 
   /* Notice recursive update of the same file.  */
   start_updating (file);
+
+  /* We might change file if we find a different one via vpath;
+     remember this one to turn off updating.  */
+  ofile = file;
 
   /* Looking at the file's modtime beforehand allows the possibility
@@ -468 +507 @@
     }
 
-  /* Update all non-intermediate files we depend on, if necessary,
-     and see whether any of them is more recent than this file.  */
-
-  lastd = 0;
-  d = file->deps;
-  while (d != 0)
-    {
-      FILE_TIMESTAMP mtime;
-      int maybe_make;
-      int dontcare = 0;
-
-      check_renamed (d->file);
-
-      mtime = file_mtime (d->file);
-      check_renamed (d->file);
-
-      if (is_updating (d->file))
-        {
-          error (NILF, _("Circular %s <- %s dependency dropped."),
-                 file->name, d->file->name);
-          /* We cannot free D here because our the caller will still have
-             a reference to it when we were called recursively via
-             check_dep below.  */
-          if (lastd == 0)
-            file->deps = d->next;
-          else
-            lastd->next = d->next;
-          d = d->next;
-          continue;
-        }
-
-      d->file->parent = file;
-      maybe_make = must_make;
-
-      /* Inherit dontcare flag from our parent. */
-      if (rebuilding_makefiles)
+  /* Update all non-intermediate files we depend on, if necessary, and see
+     whether any of them is more recent than this file.  We need to walk our
+     deps, AND the deps of any also_make targets to ensure everything happens
+     in the correct order.  */
+
+  amake.file = file;
+  amake.next = file->also_make;
+  ad = &amake;
+  while (ad)
+    {
+      struct dep *lastd = 0;
+
+      /* Find the deps we're scanning */
+      d = ad->file->deps;
+      ad = ad->next;
+
+      while (d)
         {
-          dontcare = d->file->dontcare;
-          d->file->dontcare = file->dontcare;
+          FILE_TIMESTAMP mtime;
+          int maybe_make;
+          int dontcare = 0;
+
+          check_renamed (d->file);
+
+          mtime = file_mtime (d->file);
+          check_renamed (d->file);
+
+          if (is_updating (d->file))
+            {
+              error (NILF, _("Circular %s <- %s dependency dropped."),
+                     file->name, d->file->name);
+              /* We cannot free D here because our the caller will still have
+                 a reference to it when we were called recursively via
+                 check_dep below.  */
+              if (lastd == 0)
+                file->deps = d->next;
+              else
+                lastd->next = d->next;
+              d = d->next;
+              continue;
+            }
+
+          d->file->parent = file;
+          maybe_make = must_make;
+
+          /* Inherit dontcare flag from our parent. */
+          if (rebuilding_makefiles)
+            {
+              dontcare = d->file->dontcare;
+              d->file->dontcare = file->dontcare;
+            }
+
+          dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make);
+
+          /* Restore original dontcare flag. */
+          if (rebuilding_makefiles)
+            d->file->dontcare = dontcare;
+
+          if (! d->ignore_mtime)
+            must_make = maybe_make;
+
+          check_renamed (d->file);
+
+          {
+            register struct file *f = d->file;
+            if (f->double_colon)
+              f = f->double_colon;
+            do
+              {
+                running |= (f->command_state == cs_running
+                            || f->command_state == cs_deps_running);
+                f = f->prev;
+              }
+            while (f != 0);
+          }
+
+          if (dep_status != 0 && !keep_going_flag)
+            break;
+
+          if (!running)
+            /* The prereq is considered changed if the timestamp has changed while
+               it was built, OR it doesn't exist.  */
+            d->changed = ((file_mtime (d->file) != mtime)
+                          || (mtime == NONEXISTENT_MTIME));
+
+          lastd = d;
+          d = d->next;
         }
-
-
-      dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make);
-
-      /* Restore original dontcare flag. */
-      if (rebuilding_makefiles)
-        d->file->dontcare = dontcare;
-
-      if (! d->ignore_mtime)
-        must_make = maybe_make;
-
-      check_renamed (d->file);
-
-      {
-        register struct file *f = d->file;
-        if (f->double_colon)
-          f = f->double_colon;
-        do
-          {
-            running |= (f->command_state == cs_running
-                        || f->command_state == cs_deps_running);
-            f = f->prev;
-          }
-        while (f != 0);
-      }
-
-      if (dep_status != 0 && !keep_going_flag)
-        break;
-
-      if (!running)
-        /* The prereq is considered changed if the timestamp has changed while
-           it was built, OR it doesn't exist.  */
-        d->changed = ((file_mtime (d->file) != mtime)
-                      || (mtime == NONEXISTENT_MTIME));
-
-      lastd = d;
-      d = d->next;
     }
 
@@ -600 +650 @@
 
   finish_updating (file);
+  finish_updating (ofile);
 
   DBF (DB_VERBOSE, _("Finished prerequisites of target file `%s'.\n"));
@@ -859 +910 @@
          would have been updated. */
 
-      if (question_flag || just_print_flag || touch_flag)
+      if ((question_flag || just_print_flag || touch_flag) && file->cmds)
         {
           for (i = file->cmds->ncommand_lines; i > 0; --i)
@@ -937 +988 @@
            FILE_TIMESTAMP this_mtime, int *must_make_ptr)
 {
+  struct file *ofile;
   struct dep *d;
   int dep_status = 0;
@@ -942 +994 @@
   ++depth;
   start_updating (file);
+
+  /* We might change file if we find a different one via vpath;
+     remember this one to turn off updating.  */
+  ofile = file;
 
   if (file->phony || !file->intermediate)
@@ -987 +1043 @@
              necessary, and see whether any of them is more recent than the
              file on whose behalf we are checking.  */
-          struct dep *lastd;
+          struct dep *ld;
           int deps_running = 0;
 
-          /* Reset this target's state so that we check it fresh.  It could be
-             that it's already been checked as part of an order-only
+          /* If this target is not running, set it's state so that we check it
+             fresh.  It could be it was checked as part of an order-only
              prerequisite and so wasn't rebuilt then, but should be now.  */
-          set_command_state (file, cs_not_started);
-
-          lastd = 0;
+          if (file->command_state != cs_running)
+            set_command_state (file, cs_not_started);
+
+          ld = 0;
           d = file->deps;
           while (d != 0)
@@ -1005 +1062 @@
                   error (NILF, _("Circular %s <- %s dependency dropped."),
                          file->name, d->file->name);
-                  if (lastd == 0)
+                  if (ld == 0)
                     {
                       file->deps = d->next;
@@ -1013 +1070 @@
                   else
                     {
-                      lastd->next = d->next;
+                      ld->next = d->next;
                       free_dep (d);
-                      d = lastd->next;
+                      d = ld->next;
                     }
                   continue;
@@ -1034 +1091 @@
                 deps_running = 1;
 
-              lastd = d;
+              ld = d;
               d = d->next;
             }
@@ -1047 +1104 @@
 
   finish_updating (file);
+  finish_updating (ofile);
+
   return dep_status;
 }
@@ -1230 +1289 @@
         {
           /* If name_mtime failed, search VPATH.  */
-          const char *name = vpath_search (file->name, &mtime);
+          const char *name = vpath_search (file->name, &mtime, NULL, NULL);
           if (name
               /* Last resort, is it a library (-lxxx)?  */
@@ -1473 +1532 @@
     };
 
-  static char *libpatterns = NULL;
-
-  const char *libname = lib+2;  /* Name without the '-l'.  */
+  const char *file = 0;
+  char *libpatterns;
   FILE_TIMESTAMP mtime;
 
@@ -1482 +1540 @@
   const char *p2;
   unsigned int len;
+  unsigned int liblen;
+
+  /* Information about the earliest (in the vpath sequence) match.  */
+  unsigned int best_vpath, best_path;
+  unsigned int std_dirs = 0;
 
   char **dp;
 
-  /* If we don't have libpatterns, get it.  */
-  if (!libpatterns)
-    {
-      int save = warn_undefined_variables_flag;
-      warn_undefined_variables_flag = 0;
-
-      libpatterns = xstrdup (variable_expand ("$(strip $(.LIBPATTERNS))"));
-
-      warn_undefined_variables_flag = save;
-    }
-
-  /* Loop through all the patterns in .LIBPATTERNS, and search on each one.  */
+  libpatterns = xstrdup (variable_expand ("$(.LIBPATTERNS)"));
+
+  /* Skip the '-l'.  */
+  lib += 2;
+  liblen = strlen (lib);
+
+  /* Loop through all the patterns in .LIBPATTERNS, and search on each one.
+     To implement the linker-compatible behavior we have to search through
+     all entries in .LIBPATTERNS and choose the "earliest" one.  */
   p2 = libpatterns;
   while ((p = find_next_token (&p2, &len)) != 0)
@@ -1505 +1565 @@
       char *libbuf = variable_expand ("");
 
-      /* Expand the pattern using LIBNAME as a replacement.  */
+      /* Expand the pattern using LIB as a replacement.  */
       {
         char c = p[len];
@@ -1514 +1574 @@
         if (!p3)
           {
-            /* Give a warning if there is no pattern, then remove the
-               pattern so it's ignored next time.  */
+            /* Give a warning if there is no pattern.  */
             error (NILF, _(".LIBPATTERNS element `%s' is not a pattern"), p);
-            for (; len; --len, ++p)
-              *p = ' ';
-            *p = c;
+            p[len] = c;
             continue;
           }
         p4 = variable_buffer_output (libbuf, p, p3-p);
-        p4 = variable_buffer_output (p4, libname, strlen (libname));
+        p4 = variable_buffer_output (p4, lib, liblen);
         p4 = variable_buffer_output (p4, p3+1, len - (p3-p));
         p[len] = c;
@@ -1534 +1591 @@
           if (mtime_ptr != 0)
             *mtime_ptr = mtime;
-          return strcache_add (libbuf);
+          file = strcache_add (libbuf);
+          /* This by definition will have the best index, so stop now.  */
+          break;
         }
 
@@ -1540 +1599 @@
 
       {
-        const char *file = vpath_search (libbuf, mtime_ptr);
-        if (file)
-          return file;
+        unsigned int vpath_index, path_index;
+        const char* f = vpath_search (libbuf, mtime_ptr ? &mtime : NULL,
+                                      &vpath_index, &path_index);
+        if (f)
+          {
+            /* If we have a better match, record it.  */
+            if (file == 0 ||
+                vpath_index < best_vpath ||
+                (vpath_index == best_vpath && path_index < best_path))
+              {
+                file = f;
+                best_vpath = vpath_index;
+                best_path = path_index;
+
+                if (mtime_ptr != 0)
+                  *mtime_ptr = mtime;
+              }
+          }
       }
 
@@ -1548 +1622 @@
 
       if (!buflen)
-        {
-          for (dp = dirs; *dp != 0; ++dp)
-            {
-              int l = strlen (*dp);
-              if (l > libdir_maxlen)
-                libdir_maxlen = l;
-            }
-          buflen = strlen (libbuf);
-          buf = xmalloc(libdir_maxlen + buflen + 2);
-        }
+        {
+          for (dp = dirs; *dp != 0; ++dp)
+            {
+              int l = strlen (*dp);
+              if (l > libdir_maxlen)
+                libdir_maxlen = l;
+              std_dirs++;
+            }
+          buflen = strlen (libbuf);
+          buf = xmalloc(libdir_maxlen + buflen + 2);
+        }
       else if (buflen < strlen (libbuf))
-        {
-          buflen = strlen (libbuf);
-          buf = xrealloc (buf, libdir_maxlen + buflen + 2);
-        }
-
-      for (dp = dirs; *dp != 0; ++dp)
-        {
-          sprintf (buf, "%s/%s", *dp, libbuf);
-          mtime = name_mtime (buf);
-          if (mtime != NONEXISTENT_MTIME)
-            {
-              if (mtime_ptr != 0)
-                *mtime_ptr = mtime;
-              return strcache_add (buf);
-            }
-        }
-    }
-
-  return 0;
+        {
+          buflen = strlen (libbuf);
+          buf = xrealloc (buf, libdir_maxlen + buflen + 2);
+        }
+
+      {
+        /* Use the last std_dirs index for standard directories. This
+           was it will always be greater than the VPATH index.  */
+        unsigned int vpath_index = ~((unsigned int)0) - std_dirs;
+
+        for (dp = dirs; *dp != 0; ++dp)
+          {
+            sprintf (buf, "%s/%s", *dp, libbuf);
+            mtime = name_mtime (buf);
+            if (mtime != NONEXISTENT_MTIME)
+              {
+                if (file == 0 || vpath_index < best_vpath)
+                  {
+                    file = strcache_add (buf);
+                    best_vpath = vpath_index;
+
+                    if (mtime_ptr != 0)
+                      *mtime_ptr = mtime;
+                  }
+              }
+
+            vpath_index++;
+          }
+      }
+
+    }
+
+  free (libpatterns);
+  return file;
 }