Changeset 280 for branches/GNU/src/gmake/implicit.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)
• implicit.c (modified) (15 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/implicit.c

@@ -1 +1 @@
 /* Implicit rule searching for GNU Make.
-Copyright (C) 1988,89,90,91,92,93,94,97,2000 Free Software Foundation, Inc.
+Copyright (C) 1988,1989,1990,1991,1992,1993,1994,1997,2000,2004,2005 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -23 +23 @@
 #include "dep.h"
 #include "debug.h"
-
-static int pattern_search PARAMS ((struct file *file, int archive, unsigned int depth,
-                unsigned int recursions));
+#include "variable.h"
+#include "job.h"      /* struct child, used inside commands.h */
+#include "commands.h" /* set_file_variables */
+
+static int
+pattern_search PARAMS ((struct file *file, int archive,
+                        unsigned int depth, unsigned int recursions));
 
 
@@ -64 +68 @@
 
 
+/* Struct idep captures information about implicit prerequisites
+   that come from implicit rules. */
+struct idep
+{
+  struct idep *next;              /* struct dep -compatible interface */
+  char *name;                     /* name of the prerequisite */
+  struct file *intermediate_file; /* intermediate file, 0 otherwise */
+  char *intermediate_pattern;     /* pattern for intermediate file */
+  unsigned char had_stem;         /* had % substituted with stem */
+  unsigned char ignore_mtime;     /* ignore_mtime flag */
+};
+
+static void
+free_idep_chain (struct idep* p)
+{
+  register struct idep* n;
+  register struct file *f;
+
+  for (; p != 0; p = n)
+    {
+      n = p->next;
+
+      if (p->name)
+        {
+          free (p->name);
+
+          f = p->intermediate_file;
+
+          if (f != 0
+              && (f->stem < f->name
+                  || f->stem > f->name + strlen (f->name)))
+            free (f->stem);
+        }
+
+      free (p);
+    }
+}
+
+
+/* Scans the BUFFER for the next word with whitespace as a separator.
+   Returns the pointer to the beginning of the word. LENGTH hold the
+   length of the word.  */
+
+static char *
+get_next_word (char *buffer, unsigned int *length)
+{
+  char *p = buffer, *beg;
+  char c;
+
+  /* Skip any leading whitespace.  */
+  while (isblank ((unsigned char)*p))
+    ++p;
+
+  beg = p;
+  c = *(p++);
+
+  if (c == '\0')
+    return 0;
+
+
+  /* We already found the first value of "c", above.  */
+  while (1)
+    {
+      char closeparen;
+      int count;
+
+      switch (c)
+        {
+        case '\0':
+        case ' ':
+        case '\t':
+          goto done_word;
+
+        case '$':
+          c = *(p++);
+          if (c == '$')
+            break;
+
+          /* This is a variable reference, so read it to the matching
+             close paren.  */
+
+          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 '|':
+          goto done;
+
+        default:
+          break;
+        }
+
+      c = *(p++);
+    }
+ done_word:
+  --p;
+
+ done:
+  if (length)
+    *length = p - beg;
+
+  return beg;
+}
+
 /* Search the pattern rules for a rule with an existing dependency to make
    FILE.  If a rule is found, the appropriate commands and deps are put in FILE
@@ -96 +220 @@
   struct file *intermediate_file = 0;
 
-  /* List of dependencies found recursively.  */
-  struct file **intermediate_files
-    = (struct file **) xmalloc (max_pattern_deps * sizeof (struct file *));
-
-  /* List of the patterns used to find intermediate files.  */
-  char **intermediate_patterns
-    = (char **) alloca (max_pattern_deps * sizeof (char *));
-
-  /* This buffer records all the dependencies actually found for a rule.  */
-  char **found_files = (char **) alloca (max_pattern_deps * sizeof (char *));
-  /* Remember whether the associated dep has an "ignore_mtime" flag set.  */
-  unsigned char *found_files_im = (unsigned char *) alloca (max_pattern_deps * sizeof (unsigned char));
-  /* Number of dep names now in FOUND_FILES.  */
-  unsigned int deps_found = 0;
+  /* This linked list records all the prerequisites actually
+     found for a rule along with some other useful information
+     (see struct idep for details). */
+  struct idep* deps = 0;
+
+  /* 1 if we need to remove explicit prerequisites, 0 otherwise. */
+  unsigned int remove_explicit_deps = 0;
 
   /* Names of possible dependencies are constructed in this buffer.  */
@@ -149 +266 @@
   register unsigned int i = 0;  /* uninit checks OK */
   register struct rule *rule;
-  register struct dep *dep;
-
-  char *p, *vp;
+  register struct dep *dep, *expl_d;
+
+  char *p, *vname;
+
+  struct idep *d;
+  struct idep **id_ptr;
+  struct dep **d_ptr;
+
+  PATH_VAR (stem_str); /* @@ Need to get rid of stem, stemlen, etc. */
 
 #ifndef NO_ARCHIVES
@@ -298 +421 @@
         }
 
+  /* We are going to do second expansion so initialize file variables
+     for the rule. */
+  initialize_file_variables (file, 0);
+
   /* Try each rule once without intermediate files, then once with them.  */
   for (intermed_ok = 0; intermed_ok == !!intermed_ok; ++intermed_ok)
     {
       /* Try each pattern rule till we find one that applies.
-         If it does, copy the names of its dependencies (as substituted)
-         and store them in FOUND_FILES.  DEPS_FOUND is the number of them.  */
+         If it does, expand its dependencies (as substituted)
+         and chain them in DEPS.  */
 
       for (i = 0; i < nrules; i++)
         {
+          struct file *f;
+          unsigned int failed = 0;
           int check_lastslash;
 
           rule = tryrules[i];
+
+          remove_explicit_deps = 0;
 
           /* RULE is nil when we discover that a rule,
@@ -340 +471 @@
                              (int) stemlen, stem));
 
+          strncpy (stem_str, stem, stemlen);
+          stem_str[stemlen] = '\0';
+
+          /* Temporary assign STEM to file->stem and set file variables. */
+          file->stem = stem_str;
+          set_file_variables (file);
+
           /* Try each dependency; see if it "exists".  */
 
-          deps_found = 0;
+          /* @@ There is always only one dep line for any given implicit
+                rule. So the loop is not necessary. Can rule->deps be 0?
+
+                Watch out for conversion of suffix rules to implicit rules.
+          */
+
           for (dep = rule->deps; dep != 0; dep = dep->next)
             {
-              /* If the dependency name has a %, substitute the stem.  */
-              p = strchr (dep_name (dep), '%');
-              if (p != 0)
-                {
-                  register unsigned int i;
-                  if (check_lastslash)
-                    {
-                      /* Copy directory name from the original FILENAME.  */
-                      i = lastslash - filename + 1;
-                      bcopy (filename, depname, i);
-                    }
-                  else
-                    i = 0;
-                  bcopy (dep_name (dep), depname + i, p - dep_name (dep));
-                  i += p - dep_name (dep);
-                  bcopy (stem, depname + i, stemlen);
-                  i += stemlen;
-                  strcpy (depname + i, p + 1);
-                  p = depname;
-                }
-              else
-                p = dep_name (dep);
-
-              /* P is now the actual dependency name as substituted.  */
-
-              if (file_impossible_p (p))
-                {
-                  /* If this dependency has already been ruled
-                     "impossible", then the rule fails and don't
-                     bother trying it on the second pass either
-                     since we know that will fail too.  */
-                  DBS (DB_IMPLICIT,
-                       (p == depname
+              unsigned int len;
+              char *p2;
+              unsigned int order_only = 0; /* Set if '|' was seen. */
+
+              /* In an ideal world we would take the dependency line,
+                 substitute the stem, re-expand the whole line and
+                 chop it into individual prerequisites. Unfortunately
+                 this won't work because of the "check_lastslash" twist.
+                 Instead, we will have to go word by word, taking $()'s
+                 into account, for each word we will substitute the stem,
+                 re-expand, chop it up, and, if check_lastslash != 0,
+                 add the directory part to each resulting prerequisite.  */
+
+              p = get_next_word (dep->name, &len);
+
+              while (1)
+                {
+                  int add_dir = 0;
+                  int had_stem = 0;
+
+                  if (p == 0)
+                    break; /* No more words */
+
+                  /* If the dependency name has %, substitute the stem.
+                     Watch out, we are going to do something tricky here. If
+                     we just replace % with the stem value, later, when we do
+                     the second expansion, we will re-expand this stem value
+                     once again. This is not good especially if you have
+                     certain characters in your setm (like $).
+
+                     Instead, we will replace % with $* and allow the second
+                     expansion to take care of it for us. This way (since $*
+                     is a simple variable) there won't be additional
+                     re-expansion of the stem.  */
+
+                  for (p2 = p; p2 < p + len && *p2 != '%'; ++p2)
+                    ;
+
+                  if (p2 < p + len)
+                    {
+                      register unsigned int i = p2 - p;
+                      bcopy (p, depname, i);
+                      bcopy ("$*", depname + i, 2);
+                      bcopy (p2 + 1, depname + i + 2, len - i - 1);
+                      depname[len + 2 - 1] = '\0';
+
+                      if (check_lastslash)
+                        add_dir = 1;
+
+                      had_stem = 1;
+                    }
+                  else
+                    {
+                      bcopy (p, depname, len);
+                      depname[len] = '\0';
+                    }
+
+                  p2 = variable_expand_for_file (depname, file);
+
+                  /* Parse the dependencies. */
+
+                  while (1)
+                    {
+                      id_ptr = &deps;
+
+                      for (; *id_ptr; id_ptr = &(*id_ptr)->next)
+                        ;
+
+                      *id_ptr = (struct idep *)
+                        multi_glob (
+                          parse_file_seq (&p2,
+                                          order_only ? '\0' : '|',
+                                          sizeof (struct idep),
+                                          1), sizeof (struct idep));
+
+                      /* @@ It would be nice to teach parse_file_seq or
+                         multi_glob to add prefix. This would save us
+                         some reallocations. */
+
+                      if (order_only || add_dir || had_stem)
+                        {
+                          unsigned long l = lastslash - filename + 1;
+
+                          for (d = *id_ptr; d != 0; d = d->next)
+                            {
+                              if (order_only)
+                                d->ignore_mtime = 1;
+
+                              if (add_dir)
+                                {
+                                  char *p = d->name;
+
+                                  d->name = xmalloc (strlen (p) + l + 1);
+
+                                  bcopy (filename, d->name, l);
+                                  bcopy (p, d->name + l, strlen (p) + 1);
+
+                                  free (p);
+                                }
+
+                              if (had_stem)
+                                d->had_stem = 1;
+                            }
+                        }
+
+                      if (!order_only && *p2)
+                      {
+                        ++p2;
+                        order_only = 1;
+                        continue;
+                      }
+
+                      break;
+                    }
+
+                  p += len;
+                  p = get_next_word (p, &len);
+                }
+            }
+
+          /* Reset the stem in FILE. */
+
+          file->stem = 0;
+
+          /* @@ This loop can be combined with the previous one. I do
+             it separately for now for transparency.*/
+
+          for (d = deps; d != 0; d = d->next)
+            {
+              char *name = d->name;
+
+              if (file_impossible_p (name))
+                {
+                  /* If this dependency has already been ruled
+                     "impossible", then the rule fails and don't
+                     bother trying it on the second pass either
+                     since we know that will fail too.  */
+                  DBS (DB_IMPLICIT,
+                       (d->had_stem
                         ? _("Rejecting impossible implicit prerequisite `%s'.\n")
                         : _("Rejecting impossible rule prerequisite `%s'.\n"),
-                        p));
-                  tryrules[i] = 0;
-                  break;
-                }
-
-              intermediate_files[deps_found] = 0;
-
-              DBS (DB_IMPLICIT,
-                   (p == depname
+                        name));
+                  tryrules[i] = 0;
+
+                  failed = 1;
+                  break;
+                }
+
+              DBS (DB_IMPLICIT,
+                   (d->had_stem
                     ? _("Trying implicit prerequisite `%s'.\n")
-                    : _("Trying rule prerequisite `%s'.\n"), p));
-
-              /* The DEP->changed flag says that this dependency resides in a
-                 nonexistent directory.  So we normally can skip looking for
-                 the file.  However, if CHECK_LASTSLASH is set, then the
-                 dependency file we are actually looking for is in a different
-                 directory (the one gotten by prepending FILENAME's directory),
-                 so it might actually exist.  */
-
-              if (lookup_file (p) != 0
-                  || ((!dep->changed || check_lastslash) && file_exists_p (p)))
-                {
-                  found_files_im[deps_found] = dep->ignore_mtime;
-                  found_files[deps_found++] = xstrdup (p);
-                  continue;
-                }
-              /* This code, given FILENAME = "lib/foo.o", dependency name
-                 "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c".  */
-              vp = p;
-              if (vpath_search (&vp, (FILE_TIMESTAMP *) 0))
-                {
-                  DBS (DB_IMPLICIT,
-                       (_("Found prerequisite `%s' as VPATH `%s'\n"), p, vp));
-                  strcpy (vp, p);
-                  found_files_im[deps_found] = dep->ignore_mtime;
-                  found_files[deps_found++] = vp;
-                  continue;
-                }
-
-              /* We could not find the file in any place we should look.
-                 Try to make this dependency as an intermediate file,
-                 but only on the second pass.  */
-
-              if (intermed_ok)
-                {
-                  if (intermediate_file == 0)
-                    intermediate_file
-                      = (struct file *) alloca (sizeof (struct file));
-
-                  DBS (DB_IMPLICIT,
+                    : _("Trying rule prerequisite `%s'.\n"), name));
+
+              /* If this prerequisite also happened to be explicitly
+                 mentioned for FILE skip all the test below since it
+                 it has to be built anyway, no matter which implicit
+                 rule we choose. */
+
+              for (expl_d = file->deps; expl_d != 0; expl_d = expl_d->next)
+                if (strcmp (dep_name (expl_d), name) == 0) break;
+
+              if (expl_d != 0)
+                continue;
+
+
+
+              /* The DEP->changed flag says that this dependency resides in a
+                 nonexistent directory.  So we normally can skip looking for
+                 the file.  However, if CHECK_LASTSLASH is set, then the
+                 dependency file we are actually looking for is in a different
+                 directory (the one gotten by prepending FILENAME's directory),
+                 so it might actually exist.  */
+
+              /* @@ dep->changed check is disabled. */
+              if (((f = lookup_file (name)) != 0 && f->is_target)
+                  /*|| ((!dep->changed || check_lastslash) && */
+                  || file_exists_p (name))
+                {
+                  continue;
+                }
+
+              /* This code, given FILENAME = "lib/foo.o", dependency name
+                 "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c".  */
+              vname = name;
+              if (vpath_search (&vname, (FILE_TIMESTAMP *) 0))
+                {
+                  DBS (DB_IMPLICIT,
+                       (_("Found prerequisite `%s' as VPATH `%s'\n"),
+                        name,
+                        vname));
+
+                  free (vname);
+                  continue;
+                }
+
+
+              /* We could not find the file in any place we should look.
+                 Try to make this dependency as an intermediate file,
+                 but only on the second pass.  */
+
+              if (intermed_ok)
+                {
+                  if (intermediate_file == 0)
+                    intermediate_file
+                      = (struct file *) alloca (sizeof (struct file));
+
+                  DBS (DB_IMPLICIT,
                        (_("Looking for a rule with intermediate file `%s'.\n"),
-                        p));
-
-                  bzero ((char *) intermediate_file, sizeof (struct file));
-                  intermediate_file->name = p;
-                  if (pattern_search (intermediate_file, 0, depth + 1,
-                                      recursions + 1))
-                    {
-                      p = xstrdup (p);
-                      intermediate_patterns[deps_found]
-                        = intermediate_file->name;
-                      intermediate_file->name = p;
-                      intermediate_files[deps_found] = intermediate_file;
-                      intermediate_file = 0;
-                      found_files_im[deps_found] = dep->ignore_mtime;
-                      /* Allocate an extra copy to go in FOUND_FILES,
-                         because every elt of FOUND_FILES is consumed
-                         or freed later.  */
-                      found_files[deps_found++] = xstrdup (p);
-                      continue;
-                    }
-
-                  /* If we have tried to find P as an intermediate
-                     file and failed, mark that name as impossible
-                     so we won't go through the search again later.  */
-                  file_impossible (p);
-                }
-
-              /* A dependency of this rule does not exist.
-                 Therefore, this rule fails.  */
-              break;
-            }
-
-          /* This rule is no longer `in use' for recursive searches.  */
+                        name));
+
+                  bzero ((char *) intermediate_file, sizeof (struct file));
+                  intermediate_file->name = name;
+                  if (pattern_search (intermediate_file,
+                                      0,
+                                      depth + 1,
+                                      recursions + 1))
+                    {
+                      d->intermediate_file = intermediate_file;
+                      d->intermediate_pattern = intermediate_file->name;
+
+                      intermediate_file->name = xstrdup (name);
+                      intermediate_file = 0;
+
+                      continue;
+                    }
+
+                  /* If we have tried to find P as an intermediate
+                     file and failed, mark that name as impossible
+                     so we won't go through the search again later.  */
+                  file_impossible (name);
+                }
+
+              /* A dependency of this rule does not exist. Therefore,
+                 this rule fails.  */
+              failed = 1;
+              break;
+            }
+
+          /* This rule is no longer `in use' for recursive searches.  */
           rule->in_use = 0;
 
-          if (dep != 0)
-            {
-              /* This pattern rule does not apply.
-                 If some of its dependencies succeeded,
-                 free the data structure describing them.  */
-              while (deps_found-- > 0)
-                {
-                  register struct file *f = intermediate_files[deps_found];
-                  free (found_files[deps_found]);
-                  if (f != 0
-                      && (f->stem < f->name
-                          || f->stem > f->name + strlen (f->name)))
-                    free (f->stem);
-                }
-            }
+          if (failed)
+            {
+              /* This pattern rule does not apply. If some of its
+                 dependencies succeeded, free the data structure
+                 describing them.  */
+              free_idep_chain (deps);
+              deps = 0;
+            }
           else
             /* This pattern rule does apply.  Stop looking for one.  */
@@ -512 +768 @@
      Convert them into entries on the deps-chain of FILE.  */
 
-  while (deps_found-- > 0)
+  if (remove_explicit_deps)
+    {
+      /* Remove all the dependencies that didn't come from
+         this implicit rule. */
+
+      dep = file->deps;
+      while (dep != 0)
+        {
+          struct dep *next = dep->next;
+          free (dep->name);
+          free ((char *)dep);
+          dep = next;
+        }
+      file->deps = 0;
+  }
+
+  expl_d = file->deps; /* We will add them at the end. */
+  d_ptr = &file->deps;
+
+  for (d = deps; d != 0; d = d->next)
     {
       register char *s;
 
-      if (intermediate_files[deps_found] != 0)
+      if (d->intermediate_file != 0)
         {
           /* If we need to use an intermediate file,
@@ -525 +800 @@
              of F below are null before we change them.  */
 
-          struct file *imf = intermediate_files[deps_found];
-          register struct file *f = enter_file (imf->name);
+          struct file *imf = d->intermediate_file;
+          register struct file *f = lookup_file (imf->name);
+
+          /* We don't want to delete an intermediate file that happened
+             to be a prerequisite of some (other) target. Mark it as
+             precious.  */
+          if (f != 0)
+            f->precious = 1;
+          else
+            f = enter_file (imf->name);
+
           f->deps = imf->deps;
           f->cmds = imf->cmds;
           f->stem = imf->stem;
           f->also_make = imf->also_make;
-          imf = lookup_file (intermediate_patterns[deps_found]);
-          if (imf != 0 && imf->precious)
-            f->precious = 1;
+          f->is_target = 1;
+
+          if (!f->precious)
+            {
+              imf = lookup_file (d->intermediate_pattern);
+              if (imf != 0 && imf->precious)
+                f->precious = 1;
+            }
+
           f->intermediate = 1;
           f->tried_implicit = 1;
@@ -548 +838 @@
 
       dep = (struct dep *) xmalloc (sizeof (struct dep));
-      dep->ignore_mtime = found_files_im[deps_found];
-      s = found_files[deps_found];
+      dep->ignore_mtime = d->ignore_mtime;
+      dep->need_2nd_expansion = 0;
+      s = d->name; /* Hijacking the name. */
+      d->name = 0;
       if (recursions == 0)
         {
@@ -568 +860 @@
           dep->changed = 0;
         }
-      if (intermediate_files[deps_found] == 0 && tryrules[foundrule]->terminal)
+      if (d->intermediate_file == 0 && tryrules[foundrule]->terminal)
         {
           /* If the file actually existed (was not an intermediate file),
@@ -580 +872 @@
             dep->file->tried_implicit = 1;
         }
-      dep->next = file->deps;
-      file->deps = dep;
+
+      *d_ptr = dep;
+      d_ptr = &dep->next;
     }
+
+  *d_ptr = expl_d;
 
   if (!checked_lastslash[foundrule])
@@ -605 +900 @@
 
   file->cmds = rule->cmds;
+  file->is_target = 1;
 
   /* If this rule builds other targets, too, put the others into FILE's
@@ -616 +912 @@
           /* GKM FIMXE: handle '|' here too */
           new->ignore_mtime = 0;
+          new->need_2nd_expansion = 0;
           new->name = p = (char *) xmalloc (rule->lens[i] + fullstemlen + 1);
           bcopy (rule->targets[i], p,
@@ -630 +927 @@
 
  done:
-  free (intermediate_files);
+  free_idep_chain (deps);
   free (tryrules);
 

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