Changeset 287 in kBuild for trunk

Timestamp:

May 16, 2005 11:34:55 PM (20 years ago)

Author:

bird

Message:

join + optimizations.

Location:

trunk/src/gmake

Files:

• Makefile.kmk (modified) (2 diffs)
• commands.c (modified) (5 diffs)
• commands.h (modified) (1 diff)
• default.c (modified) (1 diff)
• dir.c (modified) (3 diffs)
• file.c (modified) (8 diffs)
• function.c (modified) (25 diffs)
• hash.h (modified) (12 diffs)
• job.c (modified) (34 diffs)
• job.h (modified) (1 diff)
• main.c (modified) (42 diffs)
• read.c (modified) (36 diffs)
• remake.c (modified) (18 diffs)
• variable.c (modified) (7 diffs)

trunk/src/gmake/Makefile.kmk

@@ -13 +13 @@
 kmk_DEFS            = \
         HAVE_CONFIG_H \
+    NO_ARCHIVES \
         CONFIG_NO_DEFAULT_SUFFIXES \
         CONFIG_NO_DEFAULT_PATTERN_RULES \
@@ -111 +112 @@
 #                       
 $(PATH_TARGET)/config.h: config.h.$(BUILD_TARGET)
+        $(MKDIR) -p $(dir $@)
         $(CP) $^ $@
 

trunk/src/gmake/commands.c

@@ -40 +40 @@
 /* Set FILE's automatic variables up.  */
 
-static void
+void
 set_file_variables (struct file *file)
 {
+  struct dep *d;
   char *at, *percent, *star, *less;
 
@@ -107 +108 @@
   star = file->stem;
 
-  /* $< is the first dependency.  */
-  less = file->deps != 0 ? dep_name (file->deps) : "";
+  /* $< is the first not order-only dependency.  */
+  less = "";
+  for (d = file->deps; d != 0; d = d->next)
+    if (!d->ignore_mtime)
+      {
+        less = dep_name (d);
+        break;
+      }
 
   if (file->cmds == default_file->cmds)
@@ -136 +143 @@
     char *qp;
     char *bp;
-    struct dep *d;
     unsigned int len;
 
@@ -343 +349 @@
             break;
           }
-      if (!(flags & COMMANDS_RECURSE))
-        {
-          unsigned int len = strlen (p);
-          if (sindex (p, len, "$(MAKE)", 7) != 0
-              || sindex (p, len, "${MAKE}", 7) != 0)
-            flags |= COMMANDS_RECURSE;
-        }
+
+      /* If no explicit '+' was given, look for MAKE variable references.  */
+      if (!(flags & COMMANDS_RECURSE)
+          && (strstr (p, "$(MAKE)") != 0 || strstr (p, "${MAKE}") != 0))
+        flags |= COMMANDS_RECURSE;
+
 #ifdef CONFIG_WITH_KMK_BUILTIN
+      /* check if kmk builtin command */
       if (!strncmp(p, "kmk_builtin_", sizeof("kmk_builtin_") - 1))
-          flags |= COMMANDS_BUILTIN;
+        flags |= COMMANDS_BUILTIN;
 #endif
 
@@ -486 +492 @@
 #endif
 
+#ifdef WINDOWS32
+  /* Cannot call W32_kill with a pid (it needs a handle) */
+  exit (EXIT_FAILURE);
+#else
   /* Signal the same code; this time it will really be fatal.  The signal
      will be unblocked when we return and arrive then to kill us.  */
   if (kill (getpid (), sig) < 0)
     pfatal_with_name ("kill");
+#endif /* not WINDOWS32 */
 #endif /* not Amiga */
 #endif /* not __MSDOS__  */

trunk/src/gmake/commands.h

@@ -43 +43 @@
 extern void delete_child_targets PARAMS ((struct child *child));
 extern void chop_commands PARAMS ((struct commands *cmds));
+extern void set_file_variables PARAMS ((struct file *file));

trunk/src/gmake/default.c

@@ -318 +318 @@
 #ifdef __ALPHA
     "ARCH", "ALPHA",
-#else
+#endif
+#ifdef __ia64
+    "ARCH", "IA64",
+#endif
+#ifdef __VAX
     "ARCH", "VAX",
 #endif

trunk/src/gmake/dir.c

@@ -124 +124 @@
 downcase (char *filename)
 {
-#ifdef _AMIGA
-  static char new_filename[136];
-#else
-  static char new_filename[PATH_MAX];
-#endif
+  static PATH_VAR (new_filename);
   char *df;
   int i;
@@ -1142 +1138 @@
           d = (struct dirent *) buf;
 #ifdef __MINGW32__
-# if __MINGW32_VERSION_MAJOR < 3 || (__MINGW32_VERSION_MAJOR == 3 && \
-                                     __MINGW32_VERSION_MINOR == 0)
+# if __MINGW32_MAJOR_VERSION < 3 || (__MINGW32_MAJOR_VERSION == 3 && \
+                                     __MINGW32_MINOR_VERSION == 0)
           d->d_name = xmalloc(len);
 # endif
@@ -1163 +1159 @@
 
 static void
-ansi_free(void *p)
-{
-    if (p)
-      free(p);
+ansi_free (void *p)
+{
+  if (p)
+    free(p);
 }
 

trunk/src/gmake/file.c

@@ -31 +31 @@
 #include "hash.h"
 
+
+/* Remember whether snap_deps has been invoked: we need this to be sure we
+   don't add new rules (via $(eval ...)) afterwards.  In the future it would
+   be nice to support this, but it means we'd need to re-run snap_deps() or
+   at least its functionality... it might mean changing snap_deps() to be run
+   per-file, so we can invoke it after the eval... or remembering which files
+   in the hash have been snapped (a new boolean flag?) and having snap_deps()
+   only work on files which have not yet been snapped. */
+int snapped_deps = 0;
 
 /* Hash table of files the makefile knows how to make.  */
@@ -345 +354 @@
       {
         register struct file *f = *file_slot;
+        /* Is this file eligible for automatic deletion?
+           Yes, IFF: it's marked intermediate, it's not secondary, it wasn't
+           given on the command-line, and it's either a -include makefile or
+           it's not precious.  */
         if (f->intermediate && (f->dontcare || !f->precious)
             && !f->secondary && !f->cmd_target)
@@ -405 +418 @@
 }
 
+/* Expand and parse each dependency line. */
+static void
+expand_deps (struct file *f)
+{
+  struct dep *d, *d1;
+  struct dep *new = 0;
+  struct dep *old = f->deps;
+  unsigned int last_dep_has_cmds = f->updating;
+  int initialized = 0;
+
+  f->updating = 0;
+  f->deps = 0;
+
+  for (d = old; d != 0; d = d->next)
+    {
+      if (d->name != 0)
+        {
+          char *p;
+
+          /* If we need a second expansion on these, set up the file
+             variables, etc.  It takes a lot of extra memory and processing
+             to do this, so only do it if it's needed.  */
+          if (! d->need_2nd_expansion)
+            p = d->name;
+          else
+            {
+              /* We are going to do second expansion so initialize file
+                 variables for the file. */
+              if (!initialized)
+                {
+                  initialize_file_variables (f, 0);
+                  initialized = 1;
+                }
+
+              set_file_variables (f);
+
+              p = variable_expand_for_file (d->name, f);
+            }
+
+          /* Parse the dependencies.  */
+          new = (struct dep *)
+            multi_glob (
+              parse_file_seq (&p, '|', sizeof (struct dep), 1),
+              sizeof (struct dep));
+
+          if (*p)
+            {
+              /* Files that follow '|' are special prerequisites that
+                 need only exist in order to satisfy the dependency.
+                 Their modification times are irrelevant.  */
+              struct dep **d_ptr;
+
+              for (d_ptr = &new; *d_ptr; d_ptr = &(*d_ptr)->next)
+                ;
+              ++p;
+
+              *d_ptr = (struct dep *)
+                multi_glob (
+                  parse_file_seq (&p, '\0', sizeof (struct dep), 1),
+                  sizeof (struct dep));
+
+              for (d1 = *d_ptr; d1 != 0; d1 = d1->next)
+                d1->ignore_mtime = 1;
+            }
+
+          /* Enter them as files. */
+          for (d1 = new; d1 != 0; d1 = d1->next)
+            {
+              d1->file = lookup_file (d1->name);
+              if (d1->file == 0)
+                d1->file = enter_file (d1->name);
+              else
+                free (d1->name);
+              d1->name = 0;
+              d1->need_2nd_expansion = 0;
+            }
+
+          /* Add newly parsed deps to f->deps. If this is the last
+             dependency line and this target has commands then put
+             it in front so the last dependency line (the one with
+             commands) ends up being the first. This is important
+             because people expect $< to hold first prerequisite
+             from the rule with commands. If it is not the last
+             dependency line or the rule does not have commands
+             then link it at the end so it appears in makefile
+             order.  */
+
+          if (new != 0)
+            {
+              if (d->next == 0 && last_dep_has_cmds)
+                {
+                  struct dep **d_ptr;
+                  for (d_ptr = &new; *d_ptr; d_ptr = &(*d_ptr)->next)
+                    ;
+
+                  *d_ptr = f->deps;
+                  f->deps = new;
+                }
+              else
+                {
+                  struct dep **d_ptr;
+                  for (d_ptr = &f->deps; *d_ptr; d_ptr = &(*d_ptr)->next)
+                    ;
+
+                  *d_ptr = new;
+                }
+            }
+        }
+    }
+
+  free_ns_chain ((struct nameseq *) old);
+}
+
 /* For each dependency of each file, make the `struct dep' point
    at the appropriate `struct file' (which may have to be created).
@@ -414 +540 @@
 snap_deps (void)
 {
-  register struct file *f;
-  register struct file *f2;
-  register struct dep *d;
-  register struct file **file_slot_0;
-  register struct file **file_slot;
-  register struct file **file_end;
-
-  /* Enter each dependency name as a file.  */
+  struct file *f;
+  struct file *f2;
+  struct dep *d;
+  struct file **file_slot_0;
+  struct file **file_slot;
+  struct file **file_end;
+
+  /* Perform second expansion and enter each dependency
+     name as a file. */
+
+  /* Expand .SUFFIXES first; it's dependencies are used for
+     $$* calculation. */
+  for (f = lookup_file (".SUFFIXES"); f != 0; f = f->prev)
+    expand_deps (f);
+
   /* We must use hash_dump (), because within this loop
      we might add new files to the table, possibly causing
@@ -428 +561 @@
   file_end = file_slot_0 + files.ht_fill;
   for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
-    for (f2 = *file_slot; f2 != 0; f2 = f2->prev)
-      for (d = f2->deps; d != 0; d = d->next)
-        if (d->name != 0)
-          {
-            d->file = lookup_file (d->name);
-            if (d->file == 0)
-              d->file = enter_file (d->name);
-            else
-              free (d->name);
-            d->name = 0;
-          }
+    for (f = *file_slot; f != 0; f = f->prev)
+      {
+        if (strcmp (f->name, ".SUFFIXES") != 0)
+          expand_deps (f);
+      }
   free (file_slot_0);
 
@@ -455 +582 @@
       for (f2 = d->file; f2 != 0; f2 = f2->prev)
         {
-          /* Mark this file as phony and nonexistent.  */
+          /* Mark this file as phony nonexistent target.  */
           f2->phony = 1;
+          f2->is_target = 1;
           f2->last_mtime = NONEXISTENT_MTIME;
           f2->mtime_before_update = NONEXISTENT_MTIME;
@@ -537 +665 @@
     }
 
+  /* Remember that we've done this. */
+  snapped_deps = 1;
 }
 
@@ -699 +829 @@
     puts (_("#  Command-line target."));
   if (f->dontcare)
-    puts (_("#  A default or MAKEFILES makefile."));
+    puts (_("#  A default, MAKEFILES, or -include/sinclude makefile."));
   puts (f->tried_implicit
         ? _("#  Implicit rule search has been done.")

trunk/src/gmake/function.c

@@ -74 +74 @@
    the length of SUBST and RLEN is the length of REPLACE.  If BY_WORD is
    nonzero, substitutions are done only on matches which are complete
-   whitespace-delimited words.  If SUFFIX_ONLY is nonzero, substitutions are
-   done only at the ends of whitespace-delimited words.  */
+   whitespace-delimited words.  */
 
 char *
 subst_expand (char *o, char *text, char *subst, char *replace,
-              unsigned int slen, unsigned int rlen,
-              int by_word, int suffix_only)
+              unsigned int slen, unsigned int rlen, int by_word)
 {
   char *t = text;
-  unsigned int tlen = strlen (text);
   char *p;
 
-  if (slen == 0 && !by_word && !suffix_only)
+  if (slen == 0 && !by_word)
     {
       /* The first occurrence of "" in any string is its end.  */
-      o = variable_buffer_output (o, t, tlen);
+      o = variable_buffer_output (o, t, strlen (t));
       if (rlen > 0)
         o = variable_buffer_output (o, replace, rlen);
@@ -97 +94 @@
   do
     {
-      if ((by_word | suffix_only) && slen == 0)
+      if (by_word && slen == 0)
         /* When matching by words, the empty string should match
            the end of each word, rather than the end of the whole text.  */
@@ -103 +100 @@
       else
         {
-          p = sindex (t, tlen, subst, slen);
+          p = strstr (t, subst);
           if (p == 0)
             {
               /* No more matches.  Output everything left on the end.  */
-              o = variable_buffer_output (o, t, tlen);
+              o = variable_buffer_output (o, t, strlen (t));
               return o;
             }
@@ -118 +115 @@
       /* If we're substituting only by fully matched words,
          or only at the ends of words, check that this case qualifies.  */
-      if ((by_word
-           && ((p > t && !isblank ((unsigned char)p[-1]))
-               || (p[slen] != '\0' && !isblank ((unsigned char)p[slen]))))
-          || (suffix_only
-              && (p[slen] != '\0' && !isblank ((unsigned char)p[slen]))))
+      if (by_word
+          && ((p > text && !isblank ((unsigned char)p[-1]))
+              || (p[slen] != '\0' && !isblank ((unsigned char)p[slen]))))
         /* Struck out.  Output the rest of the string that is
            no longer to be replaced.  */
@@ -130 +125 @@
         o = variable_buffer_output (o, replace, rlen);
 
-      /* Advance T past the string to be replaced; adjust tlen.  */
+      /* Advance T past the string to be replaced.  */
       {
         char *nt = p + slen;
-        tlen -= nt - t;
         t = nt;
       }
@@ -140 +134 @@
   return o;
 }
+
 
 
@@ -147 +142 @@
    run through find_percent, and PATTERN_PERCENT is the result.
    If REPLACE_PERCENT is not nil, REPLACE has already been
-   run through find_percent, and REPLACE_PERCENT is the result.  */
+   run through find_percent, and REPLACE_PERCENT is the result.
+   Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
+   character _AFTER_ the %, not to the % itself.
+*/
 
 char *
@@ -154 +152 @@
 {
   unsigned int pattern_prepercent_len, pattern_postpercent_len;
-  unsigned int replace_prepercent_len, replace_postpercent_len = 0;
+  unsigned int replace_prepercent_len, replace_postpercent_len;
   char *t;
   unsigned int len;
@@ -161 +159 @@
   /* We call find_percent on REPLACE before checking PATTERN so that REPLACE
      will be collapsed before we call subst_expand if PATTERN has no %.  */
-  if (replace_percent == 0)
-    replace_percent = find_percent (replace);
-  if (replace_percent != 0)
-    {
-      /* Record the length of REPLACE before and after the % so
-         we don't have to compute these lengths more than once.  */
-      replace_prepercent_len = replace_percent - replace;
-      replace_postpercent_len = strlen (replace_percent + 1);
+  if (!replace_percent)
+    {
+      replace_percent = find_percent (replace);
+      if (replace_percent)
+        ++replace_percent;
+    }
+
+  /* Record the length of REPLACE before and after the % so we don't have to
+     compute these lengths more than once.  */
+  if (replace_percent)
+    {
+      replace_prepercent_len = replace_percent - replace - 1;
+      replace_postpercent_len = strlen (replace_percent);
     }
   else
-    /* We store the length of the replacement
-       so we only need to compute it once.  */
-    replace_prepercent_len = strlen (replace);
-
-  if (pattern_percent == 0)
-    pattern_percent = find_percent (pattern);
-  if (pattern_percent == 0)
+    {
+      replace_prepercent_len = strlen (replace);
+      replace_postpercent_len = 0;
+    }
+
+  if (!pattern_percent)
+    {
+      pattern_percent = find_percent (pattern);
+      if (pattern_percent)
+        ++pattern_percent;
+    }
+  if (!pattern_percent)
     /* With no % in the pattern, this is just a simple substitution.  */
     return subst_expand (o, text, pattern, replace,
-                         strlen (pattern), strlen (replace), 1, 0);
+                         strlen (pattern), strlen (replace), 1);
 
   /* Record the length of PATTERN before and after the %
      so we don't have to compute it more than once.  */
-  pattern_prepercent_len = pattern_percent - pattern;
-  pattern_postpercent_len = strlen (pattern_percent + 1);
+  pattern_prepercent_len = pattern_percent - pattern - 1;
+  pattern_postpercent_len = strlen (pattern_percent);
 
   while ((t = find_next_token (&text, &len)) != 0)
@@ -198 +206 @@
       if (!fail && pattern_prepercent_len > 0
           && (*t != *pattern
-              || t[pattern_prepercent_len - 1] != pattern_percent[-1]
+              || t[pattern_prepercent_len - 1] != pattern_percent[-2]
               || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1)))
         fail = 1;
@@ -204 +212 @@
       /* Does the suffix match? */
       if (!fail && pattern_postpercent_len > 0
-          && (t[len - 1] != pattern_percent[pattern_postpercent_len]
-              || t[len - pattern_postpercent_len] != pattern_percent[1]
+          && (t[len - 1] != pattern_percent[pattern_postpercent_len - 1]
+              || t[len - pattern_postpercent_len] != *pattern_percent
               || !strneq (&t[len - pattern_postpercent_len],
-                          &pattern_percent[1], pattern_postpercent_len - 1)))
+                          pattern_percent, pattern_postpercent_len - 1)))
         fail = 1;
 
@@ -228 +236 @@
                                                  + pattern_postpercent_len));
               /* Output the part of the replacement after the %.  */
-              o = variable_buffer_output (o, replace_percent + 1,
+              o = variable_buffer_output (o, replace_percent,
                                           replace_postpercent_len);
             }
@@ -648 +656 @@
 {
   o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]),
-                    strlen (argv[1]), 0, 0);
+                    strlen (argv[1]), 0);
 
   return o;
@@ -667 +675 @@
 }
 
+static char *
+func_lastword (char *o, char **argv, const char *funcname UNUSED)
+{
+  unsigned int i;
+  char *words = argv[0];    /* Use a temp variable for find_next_token */
+  char *p = 0;
+  char *t;
+
+  while ((t = find_next_token (&words, &i)))
+    p = t;
+
+  if (p != 0)
+    o = variable_buffer_output (o, p, i);
+
+  return o;
+}
 
 static char *
@@ -690 +714 @@
  * begpp-1.
  */
-static char *
+char *
 strip_whitespace (const char **begpp, const char **endpp)
 {
@@ -755 +779 @@
 
   start = atoi (argv[0]);
+  if (start < 1)
+    fatal (reading_file,
+           "invalid first argument to `wordlist' function: `%d'", start);
+
   count = atoi (argv[1]) - start + 1;
 
@@ -784 +812 @@
 {
   /* Find the first occurrence of the first string in the second.  */
-  int i = strlen (argv[0]);
-  if (sindex (argv[1], 0, argv[0], i) != 0)
-    o = variable_buffer_output (o, argv[0], i);
+  if (strstr (argv[1], argv[0]) != 0)
+    o = variable_buffer_output (o, argv[0], strlen (argv[0]));
 
   return o;
@@ -1067 +1094 @@
   strcpy (p, *argvp);
 
-  if (*funcname == 'e')
-    fatal (reading_file, "%s", msg);
+  switch (*funcname) {
+    case 'e':
+      fatal (reading_file, "%s", msg);
+
+    case 'w':
+      error (reading_file, "%s", msg);
+      break;
+
+    case 'i':
+      printf ("%s\n", msg);
+      break;
+
+    default:
+      fatal (reading_file, "Internal error: func_error: '%s'", funcname);
+  }
 
   /* The warning function expands to the empty string.  */
-  error (reading_file, "%s", msg);
-
   return o;
 }
@@ -1457 +1495 @@
 
   /* For error messages.  */
-  if (reading_file != 0)
+  if (reading_file && reading_file->filenm)
     {
       error_prefix = (char *) alloca (strlen (reading_file->filenm)+11+4);
@@ -1700 +1738 @@
  */
 static char *
-func_eq (char* o, char **argv, char *funcname)
+func_eq (char *o, char **argv, char *funcname)
 {
   int result = ! strcmp (argv[0], argv[1]);
@@ -1712 +1750 @@
  */
 static char *
-func_not (char* o, char **argv, char *funcname)
-{
-  char * s = argv[0];
+func_not (char *o, char **argv, char *funcname)
+{
+  char *s = argv[0];
   int result = 0;
   while (isspace ((unsigned char)*s))
@@ -1726 +1764 @@
 
 
+/* Return the absolute name of file NAME which does not contain any `.',
+   `..' components nor any repeated path separators ('/').   */
+
+static char *
+abspath (const char *name, char *apath)
+{
+  char *dest;
+  const char *start, *end, *apath_limit;
+
+  if (name[0] == '\0' || apath == NULL)
+    return NULL;
+
+  apath_limit = apath + GET_PATH_MAX;
+
+  if (name[0] != '/')
+    {
+      /* It is unlikely we would make it until here but just to make sure. */
+      if (!starting_directory)
+        return NULL;
+
+      strcpy (apath, starting_directory);
+
+      dest = strchr (apath, '\0');
+    }
+  else
+    {
+      apath[0] = '/';
+      dest = apath + 1;
+    }
+
+  for (start = end = name; *start != '\0'; start = end)
+    {
+      unsigned long len;
+
+      /* Skip sequence of multiple path-separators.  */
+      while (*start == '/')
+        ++start;
+
+      /* Find end of path component.  */
+      for (end = start; *end != '\0' && *end != '/'; ++end)
+        ;
+
+      len = end - start;
+
+      if (len == 0)
+        break;
+      else if (len == 1 && start[0] == '.')
+        /* nothing */;
+      else if (len == 2 && start[0] == '.' && start[1] == '.')
+        {
+          /* Back up to previous component, ignore if at root already.  */
+          if (dest > apath + 1)
+            while ((--dest)[-1] != '/');
+        }
+      else
+        {
+          if (dest[-1] != '/')
+            *dest++ = '/';
+
+          if (dest + len >= apath_limit)
+            return NULL;
+
+          dest = memcpy (dest, start, len);
+          dest += len;
+          *dest = '\0';
+        }
+    }
+
+  /* Unless it is root strip trailing separator.  */
+  if (dest > apath + 1 && dest[-1] == '/')
+    --dest;
+
+  *dest = '\0';
+
+  return apath;
+}
+
+
+static char *
+func_realpath (char *o, char **argv, const char *funcname UNUSED)
+{
+  /* Expand the argument.  */
+  char *p = argv[0];
+  char *path = 0;
+  int doneany = 0;
+  unsigned int len = 0;
+  PATH_VAR (in);
+  PATH_VAR (out);
+
+  while ((path = find_next_token (&p, &len)) != 0)
+    {
+      if (len < GET_PATH_MAX)
+        {
+          strncpy (in, path, len);
+          in[len] = '\0';
+
+          if
+          (
+#ifdef HAVE_REALPATH
+            realpath (in, out)
+#else
+            abspath (in, out)
+#endif
+          )
+            {
+              o = variable_buffer_output (o, out, strlen (out));
+              o = variable_buffer_output (o, " ", 1);
+              doneany = 1;
+            }
+        }
+    }
+
+  /* Kill last space.  */
+  if (doneany)
+    --o;
+
+ return o;
+}
+
+static char *
+func_abspath (char *o, char **argv, const char *funcname UNUSED)
+{
+  /* Expand the argument.  */
+  char *p = argv[0];
+  char *path = 0;
+  int doneany = 0;
+  unsigned int len = 0;
+  PATH_VAR (in);
+  PATH_VAR (out);
+
+  while ((path = find_next_token (&p, &len)) != 0)
+    {
+      if (len < GET_PATH_MAX)
+        {
+          strncpy (in, path, len);
+          in[len] = '\0';
+
+          if (abspath (in, out))
+            {
+              o = variable_buffer_output (o, out, strlen (out));
+              o = variable_buffer_output (o, " ", 1);
+              doneany = 1;
+            }
+        }
+    }
+
+  /* Kill last space.  */
+  if (doneany)
+    --o;
+
+ return o;
+}
+
 /* Lookup table for builtin functions.
 
@@ -1744 +1935 @@
 {
  /* Name/size */                    /* MIN MAX EXP? Function */
+  { STRING_SIZE_TUPLE("abspath"),       0,  1,  1,  func_abspath},
   { STRING_SIZE_TUPLE("addprefix"),     2,  2,  1,  func_addsuffix_addprefix},
   { STRING_SIZE_TUPLE("addsuffix"),     2,  2,  1,  func_addsuffix_addprefix},
@@ -1756 +1948 @@
   { STRING_SIZE_TUPLE("firstword"),     0,  1,  1,  func_firstword},
   { STRING_SIZE_TUPLE("join"),          2,  2,  1,  func_join},
+  { STRING_SIZE_TUPLE("lastword"),      0,  1,  1,  func_lastword},
   { STRING_SIZE_TUPLE("patsubst"),      3,  3,  1,  func_patsubst},
+  { STRING_SIZE_TUPLE("realpath"),      0,  1,  1,  func_realpath},
   { STRING_SIZE_TUPLE("shell"),         0,  1,  1,  func_shell},
   { STRING_SIZE_TUPLE("sort"),          0,  1,  1,  func_sort},
@@ -1767 +1961 @@
   { STRING_SIZE_TUPLE("foreach"),       3,  3,  0,  func_foreach},
   { STRING_SIZE_TUPLE("call"),          1,  0,  1,  func_call},
+  { STRING_SIZE_TUPLE("info"),          0,  1,  1,  func_error},
   { STRING_SIZE_TUPLE("error"),         0,  1,  1,  func_error},
   { STRING_SIZE_TUPLE("warning"),       0,  1,  1,  func_error},

trunk/src/gmake/hash.h

@@ -83 +83 @@
 /* hash and comparison macros for case-sensitive string keys. */
 
+#if 0
 #define STRING_HASH_1(KEY, RESULT) do { \
   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
@@ -88 +89 @@
     (RESULT) += (*_key_ << (_key_[1] & 0xf)); \
 } while (0)
+#else
+#define STRING_HASH_1(KEY, RESULT) do { \
+  unsigned char const *_key_ = (unsigned char const *) (KEY); \
+  unsigned int _ch_ = *_key_; \
+  while (_ch_) \
+    { \
+      unsigned char _ch2_ = *++_key_; \
+     (RESULT) += (_ch_ << (_ch2_ & 0xf)); \
+     _ch_ = _ch2_; \
+    } \
+} while (0)
+#endif 
 #define return_STRING_HASH_1(KEY) do { \
   unsigned long _result_ = 0; \
@@ -94 +107 @@
 } while (0)
 
+#if 0
 #define STRING_HASH_2(KEY, RESULT) do { \
   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
@@ -99 +113 @@
     (RESULT) += (*_key_ << (_key_[1] & 0x7)); \
 } while (0)
+#else
+#define STRING_HASH_2(KEY, RESULT) do { \
+  unsigned char const *_key_ = (unsigned char const *) (KEY); \
+  unsigned int _ch_ = *_key_; \
+  while (_ch_) \
+    { \
+      unsigned char _ch2_ = *++_key_; \
+     (RESULT) += (_ch_ << (_ch2_ & 0x7)); \
+     _ch_ = _ch2_; \
+    } \
+} while (0)
+#endif 
 #define return_STRING_HASH_2(KEY) do { \
   unsigned long _result_ = 0; \
@@ -112 +138 @@
 } while (0)
 
-
-#define STRING_N_HASH_1(KEY, N, RESULT) do { \
+#if 0
+#define _STRING_N_HASH_1(KEY, N, RESULT) do { \
   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
   int _n_ = (N); \
@@ -121 +147 @@
   (RESULT) += *++_key_; \
 } while (0)
+#else
+#define STRING_N_HASH_1(KEY, N, RESULT) do { \
+  unsigned char const *_key_ = (unsigned char const *) (KEY); \
+  unsigned int _ch_ = *_key_; \
+  int _n_ = (N); \
+  if (_n_) \
+    { \
+      for (;;) \
+        { \
+          unsigned char _ch2_; \
+          if (!--_n_) \
+            { \
+              (RESULT) += _ch_; \
+              break; \
+            } \
+          _ch2_ = *++_key_; \
+          (RESULT) += (_ch_ << (_ch2_ & 0xf)); \
+          _ch_ = _ch2_; \
+          if (!_ch_) break; \
+        } \
+    } \
+  else \
+    (RESULT) += _ch_; \
+} while (0)
+#endif 
 #define return_STRING_N_HASH_1(KEY, N) do { \
   unsigned long _result_ = 0; \
@@ -127 +178 @@
 } while (0)
 
+#if 0
 #define STRING_N_HASH_2(KEY, N, RESULT) do { \
   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
@@ -135 +187 @@
   (RESULT) += *++_key_; \
 } while (0)
+#else
+#define STRING_N_HASH_2(KEY, N, RESULT) do { \
+  unsigned char const *_key_ = (unsigned char const *) (KEY); \
+  unsigned int _ch_ = *_key_; \
+  int _n_ = (N); \
+  if (_n_) \
+    { \
+      for (;;) \
+        { \
+          unsigned char _ch2_; \
+          if (!--_n_) \
+            { \
+              (RESULT) += _ch_; \
+              break; \
+            } \
+          _ch2_ = *++_key_; \
+          (RESULT) += (_ch_ << (_ch2_ & 0x7)); \
+          _ch_ = _ch2_; \
+          if (!_ch_) break; \
+        } \
+    } \
+  else \
+    (RESULT) += _ch_; \
+} while (0)
+#endif 
 #define return_STRING_N_HASH_2(KEY, N) do { \
   unsigned long _result_ = 0; \
@@ -152 +229 @@
 /* hash and comparison macros for case-insensitive string _key_s. */
 
+#if 1 /* testme */
 #define ISTRING_HASH_1(KEY, RESULT) do { \
   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
@@ -157 +235 @@
     (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0xf)); \
 } while (0)
+#else
+#define ISTRING_HASH_1(KEY, RESULT) do { \
+  unsigned char const *_key_ = (unsigned char const *) (KEY); \
+  unsigned int _ch_ = *_key_;
+  while (_ch_) \
+    { \
+      unsigned _ch2_ = *++_key_; \
+      (RESULT) += ((isupper (_ch_) ? tolower (_ch_) : _ch_) << (_ch2_ & 0xf)); \
+      _ch_ = _ch2_; \
+    } \
+} while (0)
+#endif 
 #define return_ISTRING_HASH_1(KEY) do { \
   unsigned long _result_ = 0; \
@@ -163 +253 @@
 } while (0)
 
+#if 1 /* testme */
 #define ISTRING_HASH_2(KEY, RESULT) do { \
   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
@@ -168 +259 @@
     (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0x7)); \
 } while (0)
+#else
+#define ISTRING_HASH_2(KEY, RESULT) do { \
+  unsigned char const *_key_ = (unsigned char const *) (KEY); \
+  unsigned int _ch_ = *_key_;
+  while (_ch_) \
+    { \
+      unsigned _ch2_ = *++_key_; \
+      (RESULT) += ((isupper (_ch_) ? tolower (_ch_) : _ch_) << (_ch2_ & 0x7)); \
+      _ch_ = _ch2_; \
+    } \
+} while (0)
+#endif 
 #define return_ISTRING_HASH_2(KEY) do { \
   unsigned long _result_ = 0; \

trunk/src/gmake/job.c

@@ -1 +1 @@
 /* Job execution and handling for GNU Make.
-Copyright (C) 1988,89,90,91,92,93,94,95,96,97,99 Free Software Foundation, Inc.
+Copyright (C) 1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1999,
+2000,2001,2002,2003,2004,2005 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -69 +70 @@
 
 # include <descrip.h>
+char default_shell[] = "";
+int batch_mode_shell = 0;
+
+#elif defined (__riscos__)
+
 char default_shell[] = "";
 int batch_mode_shell = 0;
@@ -176 +182 @@
 #endif  /* Don't have `union wait'.  */
 
-#ifdef VMS
-static int vms_jobsefnmask = 0;
-#endif /* !VMS */
-
 #ifndef HAVE_UNISTD_H
 extern int dup2 ();
@@ -207 +209 @@
 static int job_next_command PARAMS ((struct child *));
 static int start_waiting_job PARAMS ((struct child *));
-#ifdef VMS
-static void vmsWaitForChildren PARAMS ((int *));
-#endif
 #ifdef MAKE_DLLSHELL
 static int spawn_command PARAMS ((char **argv, char **envp, struct child *child));
@@ -239 +238 @@
 unsigned long job_counter = 0;
 
+/* Number of jobserver tokens this instance is currently using.  */
+
+unsigned int jobserver_tokens = 0;
 
 
@@ -248 +250 @@
 w32_kill(int pid, int sig)
 {
-  return ((process_kill(pid, sig) == TRUE) ? 0 : -1);
+  return ((process_kill((HANDLE)pid, sig) == TRUE) ? 0 : -1);
+}
+
+/* This function creates a temporary file name with the given extension
+ * the unixy param controls both the extension and the path separator
+ * return an xmalloc'ed string of a newly created temp file or die.  */
+static char *
+create_batch_filename(char const *base, int unixy)
+{
+  const char *const ext = unixy ? "sh" : "bat";
+  const char *error = NULL;
+  char temp_path[MAXPATHLEN]; /* need to know its length */
+  unsigned path_size = GetTempPath(sizeof temp_path, temp_path);
+  int path_is_dot = 0;
+  unsigned uniq = 1;
+  const unsigned sizemax = strlen (base) + strlen (ext) + 10;
+
+  if (path_size == 0)
+    {
+      path_size = GetCurrentDirectory (sizeof temp_path, temp_path);
+      path_is_dot = 1;
+    }
+
+  while (path_size > 0 &&
+         path_size + sizemax < sizeof temp_path &&
+         uniq < 0x10000)
+    {
+      unsigned size = sprintf (temp_path + path_size,
+                               "%s%s-%x.%s",
+                               temp_path[path_size - 1] == '\\' ? "" : "\\",
+                               base, uniq, ext);
+      HANDLE h = CreateFile (temp_path,  /* file name */
+                             GENERIC_READ | GENERIC_WRITE, /* desired access */
+                             0,                            /* no share mode */
+                             NULL,                         /* default security attributes */
+                             CREATE_NEW,                   /* creation disposition */
+                             FILE_ATTRIBUTE_NORMAL |       /* flags and attributes */
+                             FILE_ATTRIBUTE_TEMPORARY,     /* we'll delete it */
+                             NULL);                        /* no template file */
+
+      if (h == INVALID_HANDLE_VALUE)
+        {
+          const DWORD er = GetLastError();
+
+          if (er == ERROR_FILE_EXISTS || er == ERROR_ALREADY_EXISTS)
+            ++uniq;
+
+          /* the temporary path is not guaranteed to exist */
+          else if (path_is_dot == 0)
+            {
+              path_size = GetCurrentDirectory (sizeof temp_path, temp_path);
+              path_is_dot = 1;
+            }
+
+          else
+            {
+              error = map_windows32_error_to_string (er);
+              break;
+            }
+        }
+      else
+        {
+          const unsigned final_size = path_size + size + 1;
+          char *const path = (char *) xmalloc (final_size);
+          memcpy (path, temp_path, final_size);
+          CloseHandle (h);
+          if (unixy)
+            {
+              char *p;
+              int ch;
+              for (p = path; (ch = *p) != 0; ++p)
+                if (ch == '\\')
+                  *p = '/';
+            }
+          return path; /* good return */
+        }
+    }
+
+  if (error == NULL)
+    error = _("Cannot create a temporary file\n");
+  fatal (NILF, error);
+
+  /* not reached */
+  return NULL;
 }
 #endif /* WINDOWS32 */
@@ -328 +413 @@
 
 
-#ifdef VMS
-/* Wait for nchildren children to terminate */
-static void
-vmsWaitForChildren(int *status)
-{
-  while (1)
-    {
-      if (!vms_jobsefnmask)
-        {
-          *status = 0;
-          return;
-        }
-
-      *status = sys$wflor (32, vms_jobsefnmask);
-    }
-  return;
-}
-
-/* Set up IO redirection.  */
-
-char *
-vms_redirect (struct dsc$descriptor_s *desc, char *fname, char *ibuf)
-{
-  char *fptr;
-  extern char *vmsify ();
-
-  ibuf++;
-  while (isspace ((unsigned char)*ibuf))
-    ibuf++;
-  fptr = ibuf;
-  while (*ibuf && !isspace ((unsigned char)*ibuf))
-    ibuf++;
-  *ibuf = 0;
-  if (strcmp (fptr, "/dev/null") != 0)
-    {
-      strcpy (fname, vmsify (fptr, 0));
-      if (strchr (fname, '.') == 0)
-        strcat (fname, ".");
-    }
-  desc->dsc$w_length = strlen(fname);
-  desc->dsc$a_pointer = fname;
-  desc->dsc$b_dtype = DSC$K_DTYPE_T;
-  desc->dsc$b_class = DSC$K_CLASS_S;
-
-  if (*fname == 0)
-    printf (_("Warning: Empty redirection\n"));
-  return ibuf;
-}
-
-
-/* found apostrophe at (p-1)
-   inc p until after closing apostrophe.
- */
-
-static char *
-vms_handle_apos (char *p)
-{
-  int alast;
-
-#define SEPCHARS ",/()= "
-
-  alast = 0;
-
-  while (*p != 0)
-    {
-      if (*p == '"')
-        {
-          if (alast)
-            {
-              alast = 0;
-              p++;
-            }
-          else
-            {
-              p++;
-              if (strchr (SEPCHARS, *p))
-                break;
-              alast = 1;
-            }
-        }
-      else
-        p++;
-    }
-
-  return p;
-}
-
-#endif
-
 
 /* Handle a dead child.  This handler may or may not ever be installed.
@@ -485 +481 @@
     {
       int remote = 0;
-      register int pid;
+      pid_t pid;
       int exit_code, exit_sig, coredump;
       register struct child *lastc, *c;
@@ -569 +565 @@
             {
 #ifdef VMS
+              static void vmsWaitForChildren PARAMS ((int *));
               vmsWaitForChildren (&status);
               pid = c->pid;
@@ -644 +641 @@
             HANDLE hPID;
             int err;
+            exit_code = 0;
+            exit_sig = 0;
+            coredump = 0;
 
             /* wait for anything to finish */
-            if (hPID = process_wait_for_any()) {
-
-              /* was an error found on this process? */
-              err = process_last_err(hPID);
-
-              /* get exit data */
-              exit_code = process_exit_code(hPID);
-
-              if (err)
-                fprintf(stderr, "make (e=%d): %s",
-                  exit_code, map_windows32_error_to_string(exit_code));
-
-              /* signal */
-              exit_sig = process_signal(hPID);
-
-              /* cleanup process */
-              process_cleanup(hPID);
-
-              coredump = 0;
-            }
-            pid = (int) hPID;
+            hPID = process_wait_for_any();
+            if (hPID)
+              {
+
+                /* was an error found on this process? */
+                err = process_last_err(hPID);
+
+                /* get exit data */
+                exit_code = process_exit_code(hPID);
+
+                if (err)
+                  fprintf(stderr, "make (e=%d): %s",
+                          exit_code, map_windows32_error_to_string(exit_code));
+
+                /* signal */
+                exit_sig = process_signal(hPID);
+
+                /* cleanup process */
+                process_cleanup(hPID);
+
+                coredump = 0;
+              }
+            pid = (pid_t) hPID;
           }
 #endif /* WINDOWS32 */
@@ -840 +842 @@
 free_child (struct child *child)
 {
-  /* If this child is the only one it was our "free" job, so don't put a
-     token back for it.  This child has already been removed from the list,
-     so if there any left this wasn't the last one.  */
-
-  if (job_fds[1] >= 0 && children)
+  if (!jobserver_tokens)
+    fatal (NILF, "INTERNAL: Freeing child 0x%08lx (%s) but no tokens left!\n",
+           (unsigned long int) child, child->file->name);
+
+  /* If we're using the jobserver and this child is not the only outstanding
+     job, put a token back into the pipe for it.  */
+
+  if (job_fds[1] >= 0 && jobserver_tokens > 1)
     {
       char token = '+';
@@ -858 +863 @@
                     (unsigned long int) child, child->file->name));
     }
+
+  --jobserver_tokens;
 
   if (handling_fatal_signal) /* Don't bother free'ing if about to die.  */
@@ -898 +905 @@
 }
 
-#ifdef  POSIX
+#ifdef POSIX
 void
 unblock_sigs (void)
@@ -909 +916 @@
 
 #ifdef MAKE_JOBSERVER
+RETSIGTYPE
+job_noop (int sig UNUSED)
+{
+}
 /* Set the child handler action flags to FLAGS.  */
 static void
-set_child_handler_action_flags (int flags)
+set_child_handler_action_flags (int set_handler, int set_alarm)
 {
   struct sigaction sa;
+
+#ifdef __EMX__
+  /* The child handler must be turned off here.  */
+  signal (SIGCHLD, SIG_DFL);
+#endif
+
   bzero ((char *) &sa, sizeof sa);
   sa.sa_handler = child_handler;
-  sa.sa_flags = flags;
+  sa.sa_flags = set_handler ? 0 : SA_RESTART;
 #if defined SIGCHLD
   sigaction (SIGCHLD, &sa, NULL);
@@ -922 +939 @@
 #if defined SIGCLD && SIGCLD != SIGCHLD
   sigaction (SIGCLD, &sa, NULL);
+#endif
+#if defined SIGALRM
+  if (set_alarm)
+    {
+      /* If we're about to enter the read(), set an alarm to wake up in a
+         second so we can check if the load has dropped and we can start more
+         work.  On the way out, turn off the alarm and set SIG_DFL.  */
+      alarm (set_handler ? 1 : 0);
+      sa.sa_handler = set_handler ? job_noop : SIG_DFL;
+      sa.sa_flags = 0;
+      sigaction (SIGALRM, &sa, NULL);
+    }
 #endif
 }
@@ -1226 +1255 @@
 
 #ifdef VMS
-
       if (!child_execute_job (argv, child)) {
         /* Fork failed!  */
@@ -1670 +1698 @@
 
         /* If we don't already have a job started, use our "free" token.  */
-        if (!children)
+        if (!jobserver_tokens)
           break;
 
@@ -1705 +1733 @@
         reap_children (0, 0);
 
-        /* If our "free" token has become available, use it.  */
+        /* Kick off any jobs we have waiting for an opportunity that
+           can run now (ie waiting for load). */
+        start_waiting_jobs ();
+
+        /* If our "free" slot has become available, use it; we don't need an
+           actual token.  */
+        if (!jobserver_tokens)
+          break;
+
+        /* There must be at least one child already, or we have no business
+           waiting for a token. */
         if (!children)
-          break;
+          fatal (NILF, "INTERNAL: no children as we go to sleep on read\n");
 
         /* Set interruptible system calls, and read() for a job token.  */
-        set_child_handler_action_flags (0);
+        set_child_handler_action_flags (1, waiting_jobs != NULL);
         got_token = read (job_rfd, &token, 1);
         saved_errno = errno;
-#if defined(__EMX__) && !defined(__INNOTEK_LIBC__)
-        /* The child handler must be turned off here.  */
-        signal (SIGCHLD, SIG_DFL);
-#endif
-        set_child_handler_action_flags (SA_RESTART);
+        set_child_handler_action_flags (0, waiting_jobs != NULL);
 
         /* If we got one, we're done here.  */
@@ -1736 +1770 @@
       }
 #endif
+
+  ++jobserver_tokens;
 
   /* The job is now primed.  Start it running.
@@ -1816 +1852 @@
 load_too_high (void)
 {
-#if defined(__MSDOS__) || defined(VMS) || defined(_AMIGA)
+#if defined(__MSDOS__) || defined(VMS) || defined(_AMIGA) || defined(__riscos__)
   return 1;
 #else
@@ -1900 +1936 @@
 
 #ifndef WINDOWS32
-#ifdef VMS
-#include <descrip.h>
-#include <clidef.h>
-
-/* This is called as an AST when a child process dies (it won't get
-   interrupted by anything except a higher level AST).
-*/
-int vmsHandleChildTerm(struct child *child)
-{
-    int status;
-    register struct child *lastc, *c;
-    int child_failed;
-
-    vms_jobsefnmask &= ~(1 << (child->efn - 32));
-
-    lib$free_ef(&child->efn);
-
-    (void) sigblock (fatal_signal_mask);
-
-    child_failed = !(child->cstatus & 1 || ((child->cstatus & 7) == 0));
-
-    /* Search for a child matching the deceased one.  */
-    lastc = 0;
-#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
-    for (c = children; c != 0 && c != child; lastc = c, c = c->next);
-#else
-    c = child;
-#endif
-
-    if (child_failed && !c->noerror && !ignore_errors_flag)
-      {
-        /* The commands failed.  Write an error message,
-           delete non-precious targets, and abort.  */
-        child_error (c->file->name, c->cstatus, 0, 0, 0);
-        c->file->update_status = 1;
-        delete_child_targets (c);
-      }
-    else
-      {
-        if (child_failed)
-          {
-            /* The commands failed, but we don't care.  */
-            child_error (c->file->name, c->cstatus, 0, 0, 1);
-            child_failed = 0;
-          }
-
-#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
-        /* If there are more commands to run, try to start them.  */
-        start_job (c);
-
-        switch (c->file->command_state)
-          {
-          case cs_running:
-            /* Successfully started.  */
-            break;
-
-          case cs_finished:
-            if (c->file->update_status != 0) {
-                /* We failed to start the commands.  */
-                delete_child_targets (c);
-            }
-            break;
-
-          default:
-            error (NILF, _("internal error: `%s' command_state"),
-                   c->file->name);
-            abort ();
-            break;
-          }
-#endif /* RECURSIVEJOBS */
-      }
-
-    /* Set the state flag to say the commands have finished.  */
-    c->file->command_state = cs_finished;
-    notice_finished_file (c->file);
-
-#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
-    /* Remove the child from the chain and free it.  */
-    if (lastc == 0)
-      children = c->next;
-    else
-      lastc->next = c->next;
-    free_child (c);
-#endif /* RECURSIVEJOBS */
-
-    /* There is now another slot open.  */
-    if (job_slots_used > 0)
-      --job_slots_used;
-
-    /* If the job failed, and the -k flag was not given, die.  */
-    if (child_failed && !keep_going_flag)
-      die (EXIT_FAILURE);
-
-    (void) sigsetmask (sigblock (0) & ~(fatal_signal_mask));
-
-    return 1;
-}
-
-/* VMS:
-   Spawn a process executing the command in ARGV and return its pid. */
-
-#define MAXCMDLEN 200
-
-/* local helpers to make ctrl+c and ctrl+y working, see below */
-#include <iodef.h>
-#include <libclidef.h>
-#include <ssdef.h>
-
-static int ctrlMask= LIB$M_CLI_CTRLY;
-static int oldCtrlMask;
-static int setupYAstTried= 0;
-static int pidToAbort= 0;
-static int chan= 0;
-
-static void reEnableAst(void) {
-        lib$enable_ctrl (&oldCtrlMask,0);
-}
-
-static astHandler (void) {
-        if (pidToAbort) {
-                sys$forcex (&pidToAbort, 0, SS$_ABORT);
-                pidToAbort= 0;
-        }
-        kill (getpid(),SIGQUIT);
-}
-
-static void tryToSetupYAst(void) {
-        $DESCRIPTOR(inputDsc,"SYS$COMMAND");
-        int     status;
-        struct {
-                short int       status, count;
-                int     dvi;
-        } iosb;
-
-        setupYAstTried++;
-
-        if (!chan) {
-                status= sys$assign(&inputDsc,&chan,0,0);
-                if (!(status&SS$_NORMAL)) {
-                        lib$signal(status);
-                        return;
-                }
-        }
-        status= sys$qiow (0, chan, IO$_SETMODE|IO$M_CTRLYAST,&iosb,0,0,
-                astHandler,0,0,0,0,0);
-        if (status==SS$_ILLIOFUNC) {
-                sys$dassgn(chan);
-#ifdef  CTRLY_ENABLED_ANYWAY
-                fprintf (stderr,
-                         _("-warning, CTRL-Y will leave sub-process(es) around.\n"));
-#else
-                return;
-#endif
-        }
-        if (status==SS$_NORMAL)
-                status= iosb.status;
-        if (!(status&SS$_NORMAL)) {
-                lib$signal(status);
-                return;
-        }
-
-        /* called from AST handler ? */
-        if (setupYAstTried>1)
-                return;
-        if (atexit(reEnableAst))
-                fprintf (stderr,
-                         _("-warning, you may have to re-enable CTRL-Y handling from DCL.\n"));
-        status= lib$disable_ctrl (&ctrlMask, &oldCtrlMask);
-        if (!(status&SS$_NORMAL)) {
-                lib$signal(status);
-                return;
-        }
-}
-int
-child_execute_job (char *argv, struct child *child)
-{
-  int i;
-  static struct dsc$descriptor_s cmddsc;
-  static struct dsc$descriptor_s pnamedsc;
-  static struct dsc$descriptor_s ifiledsc;
-  static struct dsc$descriptor_s ofiledsc;
-  static struct dsc$descriptor_s efiledsc;
-  int have_redirection = 0;
-  int have_newline = 0;
-
-  int spflags = CLI$M_NOWAIT;
-  int status;
-  char *cmd = alloca (strlen (argv) + 512), *p, *q;
-  char ifile[256], ofile[256], efile[256];
-  char *comname = 0;
-  char procname[100];
-
-  /* Parse IO redirection.  */
-
-  ifile[0] = 0;
-  ofile[0] = 0;
-  efile[0] = 0;
-
-  DB (DB_JOBS, ("child_execute_job (%s)\n", argv));
-
-  while (isspace ((unsigned char)*argv))
-    argv++;
-
-  if (*argv == 0)
-    return 0;
-
-  sprintf (procname, "GMAKE_%05x", getpid () & 0xfffff);
-  pnamedsc.dsc$w_length = strlen(procname);
-  pnamedsc.dsc$a_pointer = procname;
-  pnamedsc.dsc$b_dtype = DSC$K_DTYPE_T;
-  pnamedsc.dsc$b_class = DSC$K_CLASS_S;
-
-  /* Handle comments and redirection. */
-  for (p = argv, q = cmd; *p; p++, q++)
-    {
-      switch (*p)
-        {
-          case '#':
-            *p-- = 0;
-            *q-- = 0;
-            break;
-          case '\\':
-            p++;
-            if (*p == '\n')
-              p++;
-            if (isspace ((unsigned char)*p))
-              {
-                do { p++; } while (isspace ((unsigned char)*p));
-                p--;
-              }
-            *q = *p;
-            break;
-          case '<':
-            p = vms_redirect (&ifiledsc, ifile, p);
-            *q = ' ';
-            have_redirection = 1;
-            break;
-          case '>':
-            have_redirection = 1;
-            if (*(p-1) == '2')
-              {
-                q--;
-                if (strncmp (p, ">&1", 3) == 0)
-                  {
-                    p += 3;
-                    strcpy (efile, "sys$output");
-                    efiledsc.dsc$w_length = strlen(efile);
-                    efiledsc.dsc$a_pointer = efile;
-                    efiledsc.dsc$b_dtype = DSC$K_DTYPE_T;
-                    efiledsc.dsc$b_class = DSC$K_CLASS_S;
-                  }
-                else
-                  {
-                    p = vms_redirect (&efiledsc, efile, p);
-                  }
-              }
-            else
-              {
-                p = vms_redirect (&ofiledsc, ofile, p);
-              }
-            *q = ' ';
-            break;
-          case '\n':
-            have_newline = 1;
-          default:
-            *q = *p;
-            break;
-        }
-    }
-  *q = *p;
-
-  if (strncmp (cmd, "builtin_", 8) == 0)
-    {
-      child->pid = 270163;
-      child->efn = 0;
-      child->cstatus = 1;
-
-      DB (DB_JOBS, (_("BUILTIN [%s][%s]\n"), cmd, cmd+8));
-
-      p = cmd + 8;
-
-      if ((*(p) == 'c')
-          && (*(p+1) == 'd')
-          && ((*(p+2) == ' ') || (*(p+2) == '\t')))
-        {
-          p += 3;
-          while ((*p == ' ') || (*p == '\t'))
-            p++;
-          DB (DB_JOBS, (_("BUILTIN CD %s\n"), p));
-          if (chdir (p))
-            return 0;
-          else
-            return 1;
-        }
-      else if ((*(p) == 'r')
-          && (*(p+1) == 'm')
-          && ((*(p+2) == ' ') || (*(p+2) == '\t')))
-        {
-          int in_arg;
-
-          /* rm  */
-          p += 3;
-          while ((*p == ' ') || (*p == '\t'))
-            p++;
-          in_arg = 1;
-
-          DB (DB_JOBS, (_("BUILTIN RM %s\n"), p));
-          while (*p)
-            {
-              switch (*p)
-                {
-                  case ' ':
-                  case '\t':
-                    if (in_arg)
-                      {
-                        *p++ = ';';
-                        in_arg = 0;
-                      }
-                    break;
-                  default:
-                    break;
-                }
-              p++;
-            }
-        }
-      else
-        {
-          printf(_("Unknown builtin command '%s'\n"), cmd);
-          fflush(stdout);
-          return 0;
-        }
-    }
-
-  /* Create a *.com file if either the command is too long for
-     lib$spawn, or the command contains a newline, or if redirection
-     is desired. Forcing commands with newlines into DCLs allows to
-     store search lists on user mode logicals.  */
-
-  if (strlen (cmd) > MAXCMDLEN
-      || (have_redirection != 0)
-      || (have_newline != 0))
-    {
-      FILE *outfile;
-      char c;
-      char *sep;
-      int alevel = 0;   /* apostrophe level */
-
-      if (strlen (cmd) == 0)
-        {
-          printf (_("Error, empty command\n"));
-          fflush (stdout);
-          return 0;
-        }
-
-      outfile = open_tmpfile (&comname, "sys$scratch:CMDXXXXXX.COM");
-      if (outfile == 0)
-        pfatal_with_name (_("fopen (temporary file)"));
-
-      if (ifile[0])
-        {
-          fprintf (outfile, "$ assign/user %s sys$input\n", ifile);
-          DB (DB_JOBS, (_("Redirected input from %s\n"), ifile));
-          ifiledsc.dsc$w_length = 0;
-        }
-
-      if (efile[0])
-        {
-          fprintf (outfile, "$ define sys$error %s\n", efile);
-          DB (DB_JOBS, (_("Redirected error to %s\n"), efile));
-          efiledsc.dsc$w_length = 0;
-        }
-
-      if (ofile[0])
-        {
-          fprintf (outfile, "$ define sys$output %s\n", ofile);
-          DB (DB_JOBS, (_("Redirected output to %s\n"), ofile));
-          ofiledsc.dsc$w_length = 0;
-        }
-
-      p = sep = q = cmd;
-      for (c = '\n'; c; c = *q++)
-        {
-          switch (c)
-            {
-            case '\n':
-              /* At a newline, skip any whitespace around a leading $
-                 from the command and issue exactly one $ into the DCL. */
-              while (isspace ((unsigned char)*p))
-                p++;
-              if (*p == '$')
-                p++;
-              while (isspace ((unsigned char)*p))
-                p++;
-              fwrite (p, 1, q - p, outfile);
-              fputc ('$', outfile);
-              fputc (' ', outfile);
-              /* Reset variables. */
-              p = sep = q;
-              break;
-
-              /* Nice places for line breaks are after strings, after
-                 comma or space and before slash. */
-            case '"':
-              q = vms_handle_apos (q);
-              sep = q;
-              break;
-            case ',':
-            case ' ':
-              sep = q;
-              break;
-            case '/':
-            case '\0':
-              sep = q - 1;
-              break;
-            default:
-              break;
-            }
-          if (sep - p > 78)
-            {
-              /* Enough stuff for a line. */
-              fwrite (p, 1, sep - p, outfile);
-              p = sep;
-              if (*sep)
-                {
-                  /* The command continues.  */
-                  fputc ('-', outfile);
-                }
-              fputc ('\n', outfile);
-            }
-        }
-
-      fwrite (p, 1, q - p, outfile);
-      fputc ('\n', outfile);
-
-      fclose (outfile);
-
-      sprintf (cmd, "$ @%s", comname);
-
-      DB (DB_JOBS, (_("Executing %s instead\n"), cmd));
-    }
-
-  cmddsc.dsc$w_length = strlen(cmd);
-  cmddsc.dsc$a_pointer = cmd;
-  cmddsc.dsc$b_dtype = DSC$K_DTYPE_T;
-  cmddsc.dsc$b_class = DSC$K_CLASS_S;
-
-  child->efn = 0;
-  while (child->efn < 32 || child->efn > 63)
-    {
-      status = lib$get_ef ((unsigned long *)&child->efn);
-      if (!(status & 1))
-        return 0;
-    }
-
-  sys$clref (child->efn);
-
-  vms_jobsefnmask |= (1 << (child->efn - 32));
-
-/*
-             LIB$SPAWN  [command-string]
-                        [,input-file]
-                        [,output-file]
-                        [,flags]
-                        [,process-name]
-                        [,process-id] [,completion-status-address] [,byte-integer-event-flag-num]
-                        [,AST-address] [,varying-AST-argument]
-                        [,prompt-string] [,cli] [,table]
-*/
-
-#ifndef DONTWAITFORCHILD
-/*
- *      Code to make ctrl+c and ctrl+y working.
- *      The problem starts with the synchronous case where after lib$spawn is
- *      called any input will go to the child. But with input re-directed,
- *      both control characters won't make it to any of the programs, neither
- *      the spawning nor to the spawned one. Hence the caller needs to spawn
- *      with CLI$M_NOWAIT to NOT give up the input focus. A sys$waitfr
- *      has to follow to simulate the wanted synchronous behaviour.
- *      The next problem is ctrl+y which isn't caught by the crtl and
- *      therefore isn't converted to SIGQUIT (for a signal handler which is
- *      already established). The only way to catch ctrl+y, is an AST
- *      assigned to the input channel. But ctrl+y handling of DCL needs to be
- *      disabled, otherwise it will handle it. Not to mention the previous
- *      ctrl+y handling of DCL needs to be re-established before make exits.
- *      One more: At the time of LIB$SPAWN signals are blocked. SIGQUIT will
- *      make it to the signal handler after the child "normally" terminates.
- *      This isn't enough. It seems reasonable for simple command lines like
- *      a 'cc foobar.c' spawned in a subprocess but it is unacceptable for
- *      spawning make. Therefore we need to abort the process in the AST.
- *
- *      Prior to the spawn it is checked if an AST is already set up for
- *      ctrl+y, if not one is set up for a channel to SYS$COMMAND. In general
- *      this will work except if make is run in a batch environment, but there
- *      nobody can press ctrl+y. During the setup the DCL handling of ctrl+y
- *      is disabled and an exit handler is established to re-enable it.
- *      If the user interrupts with ctrl+y, the assigned AST will fire, force
- *      an abort to the subprocess and signal SIGQUIT, which will be caught by
- *      the already established handler and will bring us back to common code.
- *      After the spawn (now /nowait) a sys$waitfr simulates the /wait and
- *      enables the ctrl+y be delivered to this code. And the ctrl+c too,
- *      which the crtl converts to SIGINT and which is caught by the common
- *      signal handler. Because signals were blocked before entering this code
- *      sys$waitfr will always complete and the SIGQUIT will be processed after
- *      it (after termination of the current block, somewhere in common code).
- *      And SIGINT too will be delayed. That is ctrl+c can only abort when the
- *      current command completes. Anyway it's better than nothing :-)
- */
-
-  if (!setupYAstTried)
-    tryToSetupYAst();
-  status = lib$spawn (&cmddsc,                                  /* cmd-string  */
-                      (ifiledsc.dsc$w_length == 0)?0:&ifiledsc, /* input-file  */
-                      (ofiledsc.dsc$w_length == 0)?0:&ofiledsc, /* output-file */
-                      &spflags,                                 /* flags  */
-                      &pnamedsc,                                /* proc name  */
-                      &child->pid, &child->cstatus, &child->efn,
-                      0, 0,
-                      0, 0, 0);
-  if (status & 1)
-    {
-      pidToAbort= child->pid;
-      status= sys$waitfr (child->efn);
-      pidToAbort= 0;
-      vmsHandleChildTerm(child);
-    }
-#else
-  status = lib$spawn (&cmddsc,
-                      (ifiledsc.dsc$w_length == 0)?0:&ifiledsc,
-                      (ofiledsc.dsc$w_length == 0)?0:&ofiledsc,
-                      &spflags,
-                      &pnamedsc,
-                      &child->pid, &child->cstatus, &child->efn,
-                      vmsHandleChildTerm, child,
-                      0, 0, 0);
-#endif
-
-  if (!(status & 1))
-    {
-      printf (_("Error spawning, %d\n") ,status);
-      fflush (stdout);
-      switch (status)
-        {
-        case 0x1c:
-          errno = EPROCLIM;
-          break;
-        default:
-          errno = EFAIL;
-        }
-    }
-
-  if (comname && !ISDB (DB_JOBS))
-    unlink (comname);
-
-  return (status & 1);
-}
-
-#else /* !VMS */
 
 /* EMX: Start a child process. This function returns the new pid.  */
-# if defined __MSDOS__ ||  defined __EMX__
 /* The child argument can be NULL (that's why we return the pid), if it is
    and the shell is a dllshell:// a child structure is created and inserted
@@ -2466 +1944 @@
    BTW. the name of this function in this port is very misleading, spawn_job
    would perhaps be more appropriate. */
-
+# if defined __MSDOS__ || defined __EMX__
 int
 child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp,
@@ -2509 +1987 @@
 #endif
 
-  /* Restore stdout/stdin of the parent process.  */
-  if (stdin_fd != 0 && dup2 (save_stdin, 0) != 0)
-    fatal (NILF, _("restoring of stdin failed\n"));
-  if (stdout_fd != 1 && dup2 (save_stdout, 1) != 1)
-    fatal (NILF, _("restoring of stdout failed\n"));
-
-  /* Cleanup handles */
+  /* Restore stdout/stdin of the parent and close temporary FDs.  */
   if (stdin_fd != 0)
-    close (save_stdin);
+    {
+      if (dup2 (save_stdin, 0) != 0)
+        fatal (NILF, _("Could not restore stdin\n"));
+      else
+        close (save_stdin);
+    }
+
   if (stdout_fd != 1)
-    close (save_stdout);
+    {
+      if (dup2 (save_stdout, 1) != 1)
+        fatal (NILF, _("Could not restore stdout\n"));
+      else
+        close (save_stdout);
+    }
 
   return pid;
@@ -2546 +2029 @@
 }
 #endif /* !AMIGA && !__MSDOS__ */
-#endif /* !VMS */
 #endif /* !WINDOWS32 */
 
@@ -2678 +2160 @@
 int
 # else
- void
+void
 # endif
 exec_command (char **argv, char **envp)
@@ -2718 +2200 @@
 
   /* wait and reap last child */
-  while (hWaitPID = process_wait_for_any())
+  hWaitPID = process_wait_for_any();
+  while (hWaitPID)
     {
       /* was an error found on this process? */
@@ -2786 +2269 @@
         char **new_argv;
         int argc;
+        int i=1;
 
 # ifdef __EMX__
@@ -2804 +2288 @@
           ++argc;
 
+# ifdef __EMX__
+        if (!unixy_shell)
+          ++argc;
+# endif
+
         new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *));
         new_argv[0] = shell;
-        new_argv[1] = argv[0];
+
+# ifdef __EMX__
+        if (!unixy_shell)
+          {
+            new_argv[1] = "/c";
+            ++i;
+            --argc;
+          }
+# endif
+
+        new_argv[i] = argv[0];
         while (argc > 0)
           {
-            new_argv[1 + argc] = argv[argc];
+            new_argv[i + argc] = argv[argc];
             --argc;
           }
@@ -2977 +2476 @@
   char*  sh_chars;
   char** sh_cmds;
+#elif defined(__riscos__)
+  static char sh_chars[] = "";
+  static char *sh_cmds[] = { 0 };
 #else  /* must be UNIX-ish */
   static char sh_chars[] = "#;\"*?[]&|<>(){}$`^~!";
@@ -3254 +2756 @@
                 register int j;
                 for (j = 0; sh_cmds[j] != 0; ++j)
-                  if (streq (sh_cmds[j], new_argv[0]))
-                    goto slow;
+                  {
+                    if (streq (sh_cmds[j], new_argv[0]))
+                      goto slow;
+# ifdef __EMX__
+                    /* Non-Unix shells are case insensitive.  */
+                    if (!unixy_shell
+                        && strcasecmp (sh_cmds[j], new_argv[0]) == 0)
+                      goto slow;
+# endif
+                  }
               }
 
@@ -3293 +2803 @@
     /* Line was empty.  */
     return 0;
-  else
-    return new_argv;
+
+  return new_argv;
 
  slow:;
@@ -3443 +2953 @@
       int id = GetCurrentProcessId();
       PATH_VAR(fbuf);
-      char* fname = NULL;
 
       /* create a file name */
       sprintf(fbuf, "make%d", id);
-      fname = tempnam(".", fbuf);
-
-          /* create batch file name */
-      *batch_filename_ptr = xmalloc(strlen(fname) + 5);
-      strcpy(*batch_filename_ptr, fname);
-
-      /* make sure path name is in DOS backslash format */
-      if (!unixy_shell) {
-        fname = *batch_filename_ptr;
-        for (i = 0; fname[i] != '\0'; ++i)
-          if (fname[i] == '/')
-            fname[i] = '\\';
-        strcat(*batch_filename_ptr, ".bat");
-      } else {
-        strcat(*batch_filename_ptr, ".sh");
-      }
+      *batch_filename_ptr = create_batch_filename (fbuf, unixy_shell);
 
       DB (DB_JOBS, (_("Creating temporary batch file %s\n"),
@@ -3491 +2985 @@
                                                   (char *) 0, (char *) 0,
                                                   (char **) 0);
-# ifdef __EMX__
+#ifdef __EMX__
     else if (!unixy_shell)
       {
-        /* new_line is local, must not be freed therefore */
-        char *p, *q;
-        int quote;
-        size_t index;
-        size_t len;
-
-        /* handle quotes
-           We have to remove all double quotes and to split the line
-           into distinct arguments because of the strange handling
-           of builtin commands by cmd: 'echo "bla"' prints "bla"
-           (with quotes) while 'c:\bin\echo.exe "bla"' prints bla
-           (without quotes). Some programs like autoconf rely
-           on the second behaviour. */
-
-        len = strlen (new_line) + 1;
-
-        /* More than 1 arg per character is impossible.  */
-        new_argv = (char **) xmalloc (len * sizeof (char *));
-
-        /* All the args can fit in a buffer as big as new_line is.   */
-        new_argv[0] = (char *) xmalloc (len);
-
-        index = 0;
-        quote = 0;
-        q = new_line;
-        p = new_argv[index];
-        while(*q != '\0')
-          {
-            /* searching for closing quote */
-            if (quote)
-              {
-                if (*q == quote)
-                  {
-                    /* remove the quote */
-                    q++;
-                    quote = 0;
-                  }
-                else /* normal character: copy it */
-                  *p++ = *q++;
-              }
-
-            /* searching for opening quote */
-            else if (*q == '\"'
-#  ifndef NO_CMD_DEFAULT
-                     || *q == '\''
-#  endif
-                     )
-              {
-                /* remove opening quote */
-                quote = *q;
-                q++;
-              }
-
-            /* spaces outside of a quoted string: remove them
-               and start a new argument */
-            else if (*q == ' ' || *q == '\t')
-              {
-                *p++ = '\0'; /* trailing '\0' for last argument */
-
-                /* remove all successive spaces */
-                do
-                  {
-                    q++;
-                  }
-                while(*q == ' ' || *q == '\t');
-
-                /* start new argument */
-                index++;
-                new_argv[index] = p;
-              }
-
-            /* normal character (no space) outside a quoted string*/
-            else
-              *p++ = *q++;
-          } /* end while() */
-
-        *p = '\0'; /* trailing '\0' for the last argument */
-        new_argv[index + 1] = NULL;
-
-#  ifndef NO_CMD_DEFAULT
-        /* special case: echo x="y"
-           (e.g. autoconf uses this to determine whether make works)
-           this is pure idioty but cmd works this way:
-           if 'echo' and 'x="y"' are two different arguments cmd
-           will print '"x="y""' but if they are only one argument
-           cmd will print 'bla="blurb"' as it should be
-           note: if we do not allow cmd to be the default shell
-           we do not need this kind of voodoo */
-        if (index == 3 && strcasecmp(new_argv[2], "echo") == 0)
-          {
-            new_argv[2][4] = ' ';
-            new_argv[3] = NULL;
-          }
-#  endif
+        /* new_line is local, must not be freed therefore
+           We use line here instead of new_line because we run the shell
+           manually.  */
+        size_t line_len = strlen (line);
+        char *p = new_line;
+        char *q = new_line;
+        memcpy (new_line, line, line_len + 1);
+        /* replace all backslash-newline combination and also following tabs */
+        while (*q != '\0')
+          {
+            if (q[0] == '\\' && q[1] == '\n')
+              {
+                q += 2; /* remove '\\' and '\n' */
+                if (q[0] == '\t')
+                  q++; /* remove 1st tab in the next line */
+              }
+            else
+              *p++ = *q++;
+          }
+        *p = '\0';
+
+# ifndef NO_CMD_DEFAULT
+        if (strnicmp (new_line, "echo", 4) == 0
+            && (new_line[4] == ' ' || new_line[4] == '\t'))
+          {
+            /* the builtin echo command: handle it separately */
+            size_t echo_len = line_len - 5;
+            char *echo_line = new_line + 5;
+
+            /* special case: echo 'x="y"'
+               cmd works this way: a string is printed as is, i.e., no quotes
+               are removed. But autoconf uses a command like echo 'x="y"' to
+               determine whether make works. autoconf expects the output x="y"
+               so we will do exactly that.
+               Note: if we do not allow cmd to be the default shell
+               we do not need this kind of voodoo */
+            if (echo_line[0] == '\''
+                && echo_line[echo_len - 1] == '\''
+                && strncmp (echo_line + 1, "ac_maketemp=",
+                            strlen ("ac_maketemp=")) == 0)
+              {
+                /* remove the enclosing quotes */
+                memmove (echo_line, echo_line + 1, echo_len - 2);
+                echo_line[echo_len - 2] = '\0';
+              }
+          }
+# endif
+
+        {
+          /* Let the shell decide what to do. Put the command line into the
+             2nd command line argument and hope for the best ;-)  */
+          size_t sh_len = strlen (shell);
+
+          /* exactly 3 arguments + NULL */
+          new_argv = (char **) xmalloc (4 * sizeof (char *));
+          /* Exactly strlen(shell) + strlen("/c") + strlen(line) + 3 times
+             the trailing '\0' */
+          new_argv[0] = (char *) malloc (sh_len + line_len + 5);
+          memcpy (new_argv[0], shell, sh_len + 1);
+          new_argv[1] = new_argv[0] + sh_len + 1;
+          memcpy (new_argv[1], "/c", 3);
+          new_argv[2] = new_argv[1] + 3;
+          memcpy (new_argv[2], new_line, line_len + 1);
+          new_argv[3] = NULL;
+        }
       }
 #elif defined(__MSDOS__)
@@ -3768 +3233 @@
 }
 #endif /* !HAPE_DUP2 && !_AMIGA */
+
+/* On VMS systems, include special VMS functions.  */
+
+#ifdef VMS
+#include "vmsjobs.c"
+#endif

trunk/src/gmake/job.h

@@ -109 +109 @@
 #endif
 
+extern unsigned int jobserver_tokens;
+
 #ifdef MAKE_DLLSHELL
 extern pid_t wait_jobs PARAMS ((int *status, int block));

trunk/src/gmake/main.c

@@ -1 +1 @@
 /* Argument parsing and main program of GNU Make.
 Copyright (C) 1988, 1989, 1990, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
-2002, 2003 Free Software Foundation, Inc.
+2002, 2003, 2005 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -36 +36 @@
 #ifdef WINDOWS32
 #include <windows.h>
+#include <io.h>
 #include "pathstuff.h"
 #endif
@@ -44 +45 @@
 #ifdef HAVE_FCNTL_H
 # include <fcntl.h>
+#endif
+
+#if defined(HAVE_SYS_RESOURCE_H) && defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT)
+# define SET_STACK_SIZE
+#endif
+
+#ifdef SET_STACK_SIZE
+# include <sys/resource.h>
 #endif
 
@@ -186 +195 @@
 int default_keep_going_flag = 0;
 
+/* Nonzero means check symlink mtimes.  */
+
+int check_symlink_flag = 0;
+
 /* Nonzero means print directory before starting and when done (-w).  */
 
@@ -207 +220 @@
 unsigned int job_slots = 1;
 unsigned int default_job_slots = 1;
+static unsigned int master_job_slots = 0;
 
 /* Value of job_slots that means no limit.  */
@@ -260 +274 @@
 
 int always_make_flag = 0;
+
+/* If nonzero, we're in the "try to rebuild makefiles" phase.  */
+
+int rebuilding_makefiles = 0;
+
+/* Remember the original value of the SHELL variable, from the environment.  */
+
+struct variable shell_var;
+
 
 
@@ -301 +324 @@
                               Don't start multiple jobs unless load is below N.\n"),
     N_("\
+  -L, --check-symlink-times   Use the latest mtime between symlinks and target.\n"),
+    N_("\
   -n, --just-print, --dry-run, --recon\n\
                               Don't actually run any commands; just print them.\n"),
@@ -348 +373 @@
 #endif
     { 'e', flag, (char *) &env_overrides, 1, 1, 0, 0, 0,
-        "environment-overrides", },
+      "environment-overrides", },
     { 'f', string, (char *) &makefiles, 0, 0, 0, 0, 0, "file" },
     { 'h', flag, (char *) &print_usage_flag, 0, 0, 0, 0, 0, "help" },
     { 'i', flag, (char *) &ignore_errors_flag, 1, 1, 0, 0, 0,
-        "ignore-errors" },
+      "ignore-errors" },
     { 'I', string, (char *) &include_directories, 1, 1, 0, 0, 0,
-        "include-dir" },
+      "include-dir" },
     { 'j', positive_int, (char *) &job_slots, 1, 1, 0, (char *) &inf_jobs,
-        (char *) &default_job_slots, "jobs" },
+      (char *) &default_job_slots, "jobs" },
     { CHAR_MAX+2, string, (char *) &jobserver_fds, 1, 1, 0, 0, 0,
-        "jobserver-fds" },
+      "jobserver-fds" },
     { 'k', flag, (char *) &keep_going_flag, 1, 1, 0, 0,
-        (char *) &default_keep_going_flag, "keep-going" },
+      (char *) &default_keep_going_flag, "keep-going" },
 #ifndef NO_FLOAT
     { 'l', floating, (char *) &max_load_average, 1, 1, 0,
-        (char *) &default_load_average, (char *) &default_load_average,
-        "load-average" },
+      (char *) &default_load_average, (char *) &default_load_average,
+      "load-average" },
 #else
     { 'l', positive_int, (char *) &max_load_average, 1, 1, 0,
-        (char *) &default_load_average, (char *) &default_load_average,
-        "load-average" },
-#endif
+      (char *) &default_load_average, (char *) &default_load_average,
+      "load-average" },
+#endif
+    { 'L', flag, (char *) &check_symlink_flag, 1, 1, 0, 0, 0,
+      "check-symlink-times" },
     { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },
     { 'n', flag, (char *) &just_print_flag, 1, 1, 1, 0, 0, "just-print" },
     { 'o', string, (char *) &old_files, 0, 0, 0, 0, 0, "old-file" },
     { 'p', flag, (char *) &print_data_base_flag, 1, 1, 0, 0, 0,
-        "print-data-base" },
+      "print-data-base" },
     { 'q', flag, (char *) &question_flag, 1, 1, 1, 0, 0, "question" },
     { 'r', flag, (char *) &no_builtin_rules_flag, 1, 1, 0, 0, 0,
       "no-builtin-rules" },
     { 'R', flag, (char *) &no_builtin_variables_flag, 1, 1, 0, 0, 0,
-        "no-builtin-variables" },
+      "no-builtin-variables" },
     { 's', flag, (char *) &silent_flag, 1, 1, 0, 0, 0, "silent" },
     { 'S', flag_off, (char *) &keep_going_flag, 1, 1, 0, 0,
@@ -386 +413 @@
     { 'v', flag, (char *) &print_version_flag, 1, 1, 0, 0, 0, "version" },
     { 'w', flag, (char *) &print_directory_flag, 1, 1, 0, 0, 0,
-        "print-directory" },
+      "print-directory" },
     { CHAR_MAX+3, flag, (char *) &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
-        "no-print-directory" },
+      "no-print-directory" },
     { 'W', string, (char *) &new_files, 0, 0, 0, 0, 0, "what-if" },
     { CHAR_MAX+4, flag, (char *) &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
-        "warn-undefined-variables" },
+      "warn-undefined-variables" },
     { 0 }
   };
@@ -446 +473 @@
 
 struct file *default_goal_file;
+
+/* Pointer to the value of the .DEFAULT_GOAL special
+   variable.  */
+char ** default_goal_name;
 
 /* Pointer to structure for the file .DEFAULT
@@ -551 +582 @@
 /* Toggle -d on receipt of SIGUSR1.  */
 
+#ifdef SIGUSR1
 static RETSIGTYPE
 debug_signal_handler (int sig UNUSED)
@@ -556 +588 @@
   db_level = db_level ? DB_NONE : DB_BASIC;
 }
+#endif
 
 static void
@@ -701 +734 @@
 {
   int sh_found = 0;
-  char* search_token;
+  char *search_token;
+  char *tokend;
   PATH_VAR(sh_path);
   extern char *default_shell;
@@ -710 +744 @@
     search_token = token;
 
-  if (!no_default_sh_exe &&
-      (token == NULL || !strcmp(search_token, default_shell))) {
+
+  /* If the user explicitly requests the DOS cmd shell, obey that request.
+     However, make sure that's what they really want by requiring the value
+     of SHELL either equal, or have a final path element of, "cmd" or
+     "cmd.exe" case-insensitive.  */
+  tokend = search_token + strlen (search_token) - 3;
+  if (((tokend == search_token
+        || (tokend > search_token
+            && (tokend[-1] == '/' || tokend[-1] == '\\')))
+       && !strcmpi (tokend, "cmd"))
+      || ((tokend - 4 == search_token
+           || (tokend - 4 > search_token
+               && (tokend[-5] == '/' || tokend[-5] == '\\')))
+          && !strcmpi (tokend - 4, "cmd.exe"))) {
+    batch_mode_shell = 1;
+    unixy_shell = 0;
+    sh_found = 0;
+  } else if (!no_default_sh_exe &&
+             (token == NULL || !strcmp (search_token, default_shell))) {
     /* no new information, path already set or known */
     sh_found = 1;
@@ -723 +774 @@
   } else {
     char *p;
-    struct variable *v = lookup_variable ("Path", 4);
-
-    /*
-     * Search Path for shell
-     */
+    struct variable *v = lookup_variable ("PATH", 4);
+
+    /* Search Path for shell */
     if (v && v->value) {
       char *ep;
@@ -846 +895 @@
   struct file *f;
   int i;
+  int makefile_status = MAKE_SUCCESS;
   char **p;
   struct dep *read_makefiles;
@@ -858 +908 @@
   unixy_shell = 0;
   no_default_sh_exe = 1;
+#endif
+
+#ifdef SET_STACK_SIZE
+ /* Get rid of any avoidable limit on stack size.  */
+  {
+    struct rlimit rlim;
+
+    /* Set the stack limit huge so that alloca does not fail.  */
+    if (getrlimit (RLIMIT_STACK, &rlim) == 0)
+      {
+        rlim.rlim_cur = rlim.rlim_max;
+        setrlimit (RLIMIT_STACK, &rlim);
+      }
+  }
 #endif
 
@@ -983 +1047 @@
         program = argv[0] + 1;
 #endif
+#ifdef WINDOWS32
+      if (program == 0)
+        {
+          /* Extract program from full path */
+          int argv0_len;
+          char *p = strrchr (argv[0], '\\');
+          if (!p)
+            p = argv[0];
+          argv0_len = strlen(p);
+          if (argv0_len > 4
+              && streq (&p[argv0_len - 4], ".exe"))
+            {
+              /* Remove .exe extension */
+              p[argv0_len - 4] = '\0';
+              /* Increment past the initial '\' */
+              program = p + 1;
+            }
+        }
+#endif
       if (program == 0)
         program = argv[0];
@@ -1003 +1086 @@
     {
 #ifdef  HAVE_GETCWD
-      perror_with_name ("getcwd: ", "");
+      perror_with_name ("getcwd", "");
 #else
       error (NILF, "getwd: %s", current_directory);
@@ -1019 +1102 @@
   /* Initialize the special variables.  */
   define_variable (".VARIABLES", 10, "", o_default, 0)->special = 1;
-  /* define_variable (".TARGETS", 8, "", o_default, 0); */
+  /* define_variable (".TARGETS", 8, "", o_default, 0)->special = 1; */
+
+  /* Set up .FEATURES */
+  define_variable (".FEATURES", 9,
+                   "target-specific order-only second-expansion",
+                   o_default, 0);
+#ifdef MAKE_JOBSERVER
+  do_variable_definition (NILF, ".FEATURES", "jobserver",
+                          o_default, f_append, 0);
+#endif
+#ifdef MAKE_SYMLINKS
+  do_variable_definition (NILF, ".FEATURES", "check-symlink",
+                          o_default, f_append, 0);
+#endif
 
   /* Read in variables from the environment.  It is important that this be
@@ -1028 +1124 @@
   for (i = 0; envp[i] != 0; ++i)
     {
-      int do_not_define;
-      register char *ep = envp[i];
-
-      /* by default, everything gets defined and exported */
-      do_not_define = 0;
-
-      while (*ep != '=')
+      int do_not_define = 0;
+      char *ep = envp[i];
+
+      while (*ep != '\0' && *ep != '=')
         ++ep;
 #ifdef WINDOWS32
       if (!unix_path && strneq(envp[i], "PATH=", 5))
         unix_path = ep+1;
-      else if (!windows32_path && !strnicmp(envp[i], "Path=", 5)) {
+      else if (!strnicmp(envp[i], "Path=", 5)) {
         do_not_define = 1; /* it gets defined after loop exits */
-        windows32_path = ep+1;
+        if (!windows32_path)
+          windows32_path = ep+1;
       }
 #endif
@@ -1048 +1142 @@
          the same.  */
       if (!do_not_define)
-        define_variable (envp[i], (unsigned int) (ep - envp[i]),
-                         ep + 1, o_env, 1)
-        /* Force exportation of every variable culled from the environment.
-           We used to rely on target_environment's v_default code to do this.
-           But that does not work for the case where an environment variable
-           is redefined in a makefile with `override'; it should then still
-           be exported, because it was originally in the environment.  */
-        ->export = v_export;
+        {
+          struct variable *v;
+
+          v = define_variable (envp[i], (unsigned int) (ep - envp[i]),
+                               ep + 1, o_env, 1);
+          /* Force exportation of every variable culled from the environment.
+             We used to rely on target_environment's v_default code to do this.
+             But that does not work for the case where an environment variable
+             is redefined in a makefile with `override'; it should then still
+             be exported, because it was originally in the environment.  */
+          v->export = v_export;
+
+          /* Another wrinkle is that POSIX says the value of SHELL set in the
+             makefile should not change the value of SHELL given to
+             subprocesses, which seems silly to me but...  */
+          if (strncmp (envp[i], "SHELL=", 6) == 0)
+            {
+#ifndef __MSDOS__
+              v->export = v_noexport;
+#endif
+              shell_var.name = "SHELL";
+              shell_var.value = xstrdup (ep + 1);
+            }
+        }
     }
 #ifdef WINDOWS32
-    /*
-     * Make sure that this particular spelling of 'Path' is available
+    /* If we didn't find a correctly spelled PATH we define PATH as
+     * either the first mispelled value or an empty string
      */
-    if (windows32_path)
-      define_variable("Path", 4, windows32_path, o_env, 1)->export = v_export;
-    else if (unix_path)
-      define_variable("Path", 4, unix_path, o_env, 1)->export = v_export;
-    else
-      define_variable("Path", 4, "", o_env, 1)->export = v_export;
-
-    /*
-     * PATH defaults to Path iff PATH not found and Path is found.
-     */
-    if (!unix_path && windows32_path)
-      define_variable("PATH", 4, windows32_path, o_env, 1)->export = v_export;
+    if (!unix_path)
+      define_variable("PATH", 4,
+                      windows32_path ? windows32_path : "",
+                      o_env, 1)->export = v_export;
 #endif
 #else /* For Amiga, read the ENV: device, ignoring all dirs */
@@ -1242 +1344 @@
       {
         char *dir = directories->list[i];
+        char *expanded = 0;
         if (dir[0] == '~')
           {
-            char *expanded = tilde_expand (dir);
+            expanded = tilde_expand (dir);
             if (expanded != 0)
               dir = expanded;
           }
+#ifdef WINDOWS32
+        /* WINDOWS32 chdir() doesn't work if the directory has a trailing '/'
+           But allow -C/ just in case someone wants that.  */
+        {
+          char *p = dir + strlen (dir) - 1;
+          while (p > dir && (p[0] == '/' || p[0] == '\\'))
+            --p;
+          p[1] = '\0';
+        }
+#endif
         if (chdir (dir) < 0)
           pfatal_with_name (dir);
-        if (dir != directories->list[i])
-          free (dir);
+        if (expanded)
+          free (expanded);
       }
 
@@ -1306 +1419 @@
         {
 #ifdef  HAVE_GETCWD
-          perror_with_name ("getcwd: ", "");
+          perror_with_name ("getcwd", "");
 #else
           error (NILF, "getwd: %s", current_directory);
@@ -1373 +1486 @@
             if (outfile == 0)
               pfatal_with_name (_("fopen (temporary file)"));
-            while (!feof (stdin))
+            while (!feof (stdin) && ! ferror (stdin))
               {
                 char buf[2048];
@@ -1453 +1566 @@
   define_default_variables ();
 
+  default_file = enter_file (".DEFAULT");
+
+  {
+    struct variable *v = define_variable (".DEFAULT_GOAL", 13, "", o_file, 0);
+    default_goal_name = &v->value;
+  }
+
   /* Read all the makefiles.  */
-
-  default_file = enter_file (".DEFAULT");
 
   read_makefiles
@@ -1585 +1703 @@
          want job_slots to be 0 to indicate we're using the jobserver.  */
 
+      master_job_slots = job_slots;
+
       while (--job_slots)
         {
@@ -1604 +1724 @@
       jobserver_fds->idx = 1;
       jobserver_fds->max = 1;
+    }
+#endif
+
+#ifndef MAKE_SYMLINKS
+  if (check_symlink_flag)
+    {
+      error (NILF, _("Symbolic links not supported: disabling -L."));
+      check_symlink_flag = 0;
     }
 #endif
@@ -1673 +1801 @@
       int nargc = argc;
       int orig_db_level = db_level;
+      int status;
 
       if (! ISDB (DB_MAKEFILES))
@@ -1733 +1862 @@
       define_makeflags (1, 1);
 
-      switch (update_goal_chain (read_makefiles, 1))
+      rebuilding_makefiles = 1;
+      status = update_goal_chain (read_makefiles);
+      rebuilding_makefiles = 0;
+
+      switch (status)
         {
         case 1:
@@ -1782 +1915 @@
                         any_remade |= (mtime != NONEXISTENT_MTIME
                                        && mtime != makefile_mtimes[i]);
+                        makefile_status = MAKE_FAILURE;
                       }
                   }
@@ -1871 +2005 @@
 #ifndef _AMIGA
           for (p = environ; *p != 0; ++p)
-            if ((*p)[MAKELEVEL_LENGTH] == '='
-                && strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH))
+            if (strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH)
+                && (*p)[MAKELEVEL_LENGTH] == '=')
               {
                 /* The SGI compiler apparently can't understand
@@ -1927 +2061 @@
             int pid;
             int status;
-            pid = child_execute_job(0, 1, nargv, environ, NULL);
+            pid = child_execute_job (0, 1, nargv, environ, NULL);
 
             /* is this loop really necessary? */
             do {
-              pid = wait(&status);
-            } while(pid <= 0);
+              pid = wait (&status);
+            } while (pid <= 0);
             /* use the exit code of the child process */
-            exit(WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
+            exit (WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
           }
 #else
@@ -1948 +2082 @@
 
       db_level = orig_db_level;
+
+      /* Free the makefile mtimes (if we allocated any).  */
+      if (makefile_mtimes)
+        free ((char *) makefile_mtimes);
     }
 
@@ -1964 +2102 @@
     if (goals == 0)
       {
-        if (default_goal_file != 0)
-          {
-            goals = (struct dep *) xmalloc (sizeof (struct dep));
-            goals->next = 0;
-            goals->name = 0;
+        if (**default_goal_name != '\0')
+          {
+            if (default_goal_file == 0 ||
+                strcmp (*default_goal_name, default_goal_file->name) != 0)
+              {
+                default_goal_file = lookup_file (*default_goal_name);
+
+                /* In case user set .DEFAULT_GOAL to a non-existent target
+                   name let's just enter this name into the table and let
+                   the standard logic sort it out. */
+                if (default_goal_file == 0)
+                  {
+                    struct nameseq *ns;
+                    char *p = *default_goal_name;
+
+                    ns = multi_glob (
+                      parse_file_seq (&p, '\0', sizeof (struct nameseq), 1),
+                      sizeof (struct nameseq));
+
+                    /* .DEFAULT_GOAL should contain one target. */
+                    if (ns->next != 0)
+                      fatal (NILF, _(".DEFAULT_GOAL contains more than one target"));
+
+                    default_goal_file = enter_file (ns->name);
+
+                    ns->name = 0; /* It was reused by enter_file(). */
+                    free_ns_chain (ns);
+                  }
+              }
+
+            goals = (struct dep *) xmalloc (sizeof (struct dep));
+            goals->next = 0;
+            goals->name = 0;
             goals->ignore_mtime = 0;
-            goals->file = default_goal_file;
-          }
+            goals->need_2nd_expansion = 0;
+            goals->file = default_goal_file;
+          }
       }
     else
       lastgoal->next = 0;
+
 
     if (!goals)
@@ -1988 +2156 @@
     DB (DB_BASIC, (_("Updating goal targets....\n")));
 
-    switch (update_goal_chain (goals, 0))
+    switch (update_goal_chain (goals))
     {
       case -1:
@@ -1994 +2162 @@
       case 0:
         /* Updated successfully.  */
-        status = MAKE_SUCCESS;
+        status = makefile_status;
         break;
       case 1:
@@ -2098 +2266 @@
   if (v != 0)
     {
-      /* It is indeed a variable definition.  Record a pointer to
-         the variable for later use in define_makeflags.  */
-      struct command_variable *cv
-        = (struct command_variable *) xmalloc (sizeof (*cv));
-      cv->variable = v;
-      cv->next = command_variables;
-      command_variables = cv;
+      /* It is indeed a variable definition.  If we don't already have this
+         one, record a pointer to the variable for later use in
+         define_makeflags.  */
+      struct command_variable *cv;
+
+      for (cv = command_variables; cv != 0; cv = cv->next)
+        if (cv->variable == v)
+          break;
+
+      if (! cv) {
+        cv = (struct command_variable *) xmalloc (sizeof (*cv));
+        cv->variable = v;
+        cv->next = command_variables;
+        command_variables = cv;
+      }
     }
   else if (! env)
@@ -2127 +2303 @@
       lastgoal->file = f;
       lastgoal->ignore_mtime = 0;
+      lastgoal->need_2nd_expansion = 0;
 
       {
@@ -2775 +2952 @@
   if (!dying)
     {
+      char token = '+';
       int err;
 
@@ -2794 +2972 @@
       if (print_data_base_flag)
         print_data_base ();
+
+      /* Sanity: have we written all our jobserver tokens back?  If our
+         exit status is 2 that means some kind of syntax error; we might not
+         have written all our tokens so do that now.  If tokens are left
+         after any other error code, that's bad.  */
+
+      if (job_fds[0] != -1 && jobserver_tokens)
+        {
+          if (status != 2)
+            error (NILF,
+                   "INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
+                   jobserver_tokens);
+          else
+            while (jobserver_tokens--)
+              {
+                int r;
+
+                EINTRLOOP (r, write (job_fds[1], &token, 1));
+                if (r != 1)
+                  perror_with_name ("write", "");
+              }
+        }
+
+
+      /* Sanity: If we're the master, were all the tokens written back?  */
+
+      if (master_job_slots)
+        {
+          /* We didn't write one for ourself, so start at 1.  */
+          unsigned int tcnt = 1;
+
+          /* Close the write side, so the read() won't hang.  */
+          close (job_fds[1]);
+
+          while ((err = read (job_fds[0], &token, 1)) == 1)
+            ++tcnt;
+
+          if (tcnt != master_job_slots)
+            error (NILF,
+                   "INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
+                   tcnt, master_job_slots);
+        }
 
       /* Try to move back to the original directory.  This is essential on
@@ -2859 +3079 @@
         printf (_("%s[%u]: Leaving directory `%s'\n"),
                 program, makelevel, starting_directory);
+
+  /* Flush stdout to be sure this comes before any stderr output.  */
+  fflush (stdout);
 }

trunk/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,
@@ -257 +258 @@
               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.  */
@@ -372 +374 @@
   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);
@@ -382 +380 @@
   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.  */
@@ -413 +414 @@
 
   free (ebuf.bufstart);
+  alloca (0);
   return r;
 }
@@ -444 +446 @@
   reading_file = curfile;
 
+  alloca (0);
   return r;
 }
@@ -465 +468 @@
   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;
@@ -482 +484 @@
           record_files (filenames, pattern, pattern_percent, deps,            \
                         cmds_started, commands, commands_idx, two_colon,      \
-                        have_sysv_atvar, &fi, set_default);                   \
+                        &fi);                                                 \
         }                                                                     \
       filenames = 0;                                                          \
@@ -619 +621 @@
          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;
+            }
         }
 
@@ -854 +856 @@
         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
@@ -887 +879 @@
         unsigned int len, plen = 0;
         char *colonp;
+        const char *end, *beg; /* Helpers for whitespace stripping. */
 
         /* Record the previous rule.  */
@@ -935 +928 @@
 
         p2 = variable_expand_string(NULL, lb_next, len);
+
         while (1)
           {
@@ -1041 +1035 @@
         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;
           }
 
@@ -1113 +1105 @@
               }
           }
-
-        /* 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; ...'?  */
@@ -1188 +1170 @@
           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;
@@ -1226 +1214 @@
             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;
+                  }
+              }
           }
 
@@ -1284 +1348 @@
       char *line;
 
+      nlines = readline (ebuf);
       ebuf->floc.lineno += nlines;
-      nlines = readline (ebuf);
 
       /* If there is nothing left to eval, we're done. */
@@ -1366 +1430 @@
    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;
     }
 
@@ -1436 +1541 @@
     }
 
-  ++conditionals->if_cmds;
+  o = conditionals->if_cmds++;
   if (conditionals->if_cmds > conditionals->allocated)
     {
@@ -1447 +1552 @@
 
   /* 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
@@ -1479 +1583 @@
 
       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);
@@ -1499 +1604 @@
       if (termin == ',')
         {
-          register int count = 0;
+          int count = 0;
           for (; *line != '\0'; ++line)
             if (*line == '(')
@@ -1573 +1678 @@
       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)
@@ -1695 +1800 @@
           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;
         }
@@ -1772 +1883 @@
               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;
@@ -1779 +1890 @@
   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)
@@ -1844 +1962 @@
       /* 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;
 
@@ -1861 +1979 @@
             }
           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)
@@ -2022 +2032 @@
           if (cmds != 0)
             f->cmds = cmds;
+
           /* Defining .SUFFIXES with no dependencies
              clears out the list of suffixes.  */
@@ -2036 +2047 @@
               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
@@ -2080 +2113 @@
               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);
             }
@@ -2116 +2149 @@
         }
 
-      /* 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;
     }
 
@@ -2179 +2177 @@
   unsigned int string_len = 0;
   register char *p = string;
+  register int ch;
 
   while (1)
     {
       if (stop2 && blank)
-        while (*p != '\0' && *p != stop1 && *p != stop2
-               && ! isblank ((unsigned char) *p))
+        while ((ch = *p) != '\0' && ch != stop1 && ch != stop2
+               && ! isblank ((unsigned char) ch))
           ++p;
       else if (stop2)
-        while (*p != '\0' && *p != stop1 && *p != stop2)
+        while ((ch = *p) != '\0' && ch != stop1 && ch != stop2)
           ++p;
       else if (blank)
-        while (*p != '\0' && *p != stop1
-               && ! isblank ((unsigned char) *p))
+        while ((ch = *p) != '\0' && ch != stop1
+               && ! isblank ((unsigned char) ch))
           ++p;
       else
-        while (*p != '\0' && *p != stop1)
+        while ((ch = *p) != '\0' && ch != stop1)
           ++p;
 
-      if (*p == '\0')
+      if (ch == '\0')
         break;
 
@@ -2499 +2498 @@
 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;
 
@@ -2508 +2507 @@
      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;

trunk/src/gmake/remake.c

@@ -75 +75 @@
 /* Remake all the goals in the `struct dep' chain GOALS.  Return -1 if nothing
    was done, 0 if all goals were updated successfully, or 1 if a goal failed.
-   If MAKEFILES is nonzero, these goals are makefiles, so -t, -q, and -n should
-   be disabled for them unless they were also command-line targets, and we
-   should only make one goal at a time and return as soon as one goal whose
-   `changed' member is nonzero is successfully made.  */
+
+   If rebuilding_makefiles is nonzero, these goals are makefiles, so -t, -q,
+   and -n should be disabled for them unless they were also command-line
+   targets, and we should only make one goal at a time and return as soon as
+   one goal whose `changed' member is nonzero is successfully made.  */
 
 int
-update_goal_chain (struct dep *goals, int makefiles)
+update_goal_chain (struct dep *goals)
 {
   int t = touch_flag, q = question_flag, n = just_print_flag;
@@ -87 +88 @@
   int status = -1;
 
-#define MTIME(file) (makefiles ? file_mtime_no_search (file) \
+#define MTIME(file) (rebuilding_makefiles ? file_mtime_no_search (file) \
                      : file_mtime (file))
 
@@ -137 +138 @@
               int x;
               check_renamed (file);
-              if (makefiles)
+              if (rebuilding_makefiles)
                 {
                   if (file->cmd_target)
@@ -154 +155 @@
               ocommands_started = commands_started;
 
-              x = update_file (file, makefiles ? 1 : 0);
+              x = update_file (file, rebuilding_makefiles ? 1 : 0);
               check_renamed (file);
 
@@ -177 +178 @@
                          matter how much more we run, since we already know
                          the answer to return.  */
-                      stop = (!keep_going_flag && !question_flag
-                              && !makefiles);
+                      stop = (question_flag && !keep_going_flag
+                              && !rebuilding_makefiles);
                     }
                   else
@@ -194 +195 @@
                              If STATUS is changed, we will get re-exec'd, and
                              enter an infinite loop.  */
-                          if (!makefiles
+                          if (!rebuilding_makefiles
                               || (!just_print_flag && !question_flag))
                             status = 0;
-                          if (makefiles && file->dontcare)
+                          if (rebuilding_makefiles && file->dontcare)
                             /* This is a default makefile; stop remaking.  */
                             stop = 1;
@@ -220 +221 @@
                  print a message saying nothing needs doing.  */
 
-              if (!makefiles
+              if (!rebuilding_makefiles
                   /* If the update_status is zero, we updated successfully
                      or not at all.  G->changed will have been set above if
@@ -259 +260 @@
     }
 
-  if (makefiles)
+  if (rebuilding_makefiles)
     {
       touch_flag = t;
@@ -309 +310 @@
       check_renamed (f);
 
+      /* If we got an error, don't bother with double_colon etc.  */
       if (status != 0 && !keep_going_flag)
-        break;
+        return status;
 
       if (f->command_state == cs_running
@@ -324 +326 @@
   /* Process the remaining rules in the double colon chain so they're marked
      considered.  Start their prerequisites, too.  */
-  for (; f != 0 ; f = f->prev)
-    {
-      struct dep *d;
-
-      f->considered = considered;
-
-      for (d = f->deps; d != 0; d = d->next)
-        status |= update_file (d->file, depth + 1);
-    }
+  if (file->double_colon)
+    for (; f != 0 ; f = f->prev)
+      {
+        struct dep *d;
+
+        f->considered = considered;
+
+        for (d = f->deps; d != 0; d = d->next)
+          status |= update_file (d->file, depth + 1);
+      }
 
   return status;
 }
 
+
+/* Show a message stating the target failed to build.  */
+
+static void
+complain (const struct file *file)
+{
+  const char *msg_noparent
+    = _("%sNo rule to make target `%s'%s");
+  const char *msg_parent
+    = _("%sNo rule to make target `%s', needed by `%s'%s");
+
+  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)
+    error (NILF, msg_noparent, "*** ", file->name, ".");
+  else
+    error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
+}
 
 /* Consider a single `struct file' and update it as appropriate.  */
@@ -357 +384 @@
           DBF (DB_VERBOSE,
                _("Recently tried and failed to update file `%s'.\n"));
+
+          /* If the file we tried to make is marked dontcare 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;
+              complain (file);
+            }
+
           return file->update_status;
         }
@@ -435 +473 @@
       FILE_TIMESTAMP mtime;
       int maybe_make;
+      int dontcare = 0;
 
       check_renamed (d->file);
@@ -458 +497 @@
       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;
@@ -495 +548 @@
         if (d->file->intermediate)
           {
+            int dontcare = 0;
+
             FILE_TIMESTAMP mtime = file_mtime (d->file);
             check_renamed (d->file);
             d->file->parent = file;
+
+            /* Inherit dontcare flag from our parent. */
+            if (rebuilding_makefiles)
+              {
+                dontcare = d->file->dontcare;
+                d->file->dontcare = file->dontcare;
+              }
+
+
             dep_status |= update_file (d->file, depth);
+
+            /* Restore original dontcare flag. */
+            if (rebuilding_makefiles)
+              d->file->dontcare = dontcare;
+
             check_renamed (d->file);
 
@@ -856 +925 @@
   start_updating (file);
 
-  if (!file->intermediate)
-    /* If this is a non-intermediate file, update it and record
-       whether it is newer than THIS_MTIME.  */
-    {
+  if (file->phony || !file->intermediate)
+    {
+      /* If this is a non-intermediate file, update it and record
+         whether it is newer than THIS_MTIME.  */
       FILE_TIMESTAMP mtime;
       dep_status = update_file (file, depth);
@@ -1026 +1095 @@
       else
         {
-          const char *msg_noparent
-            = _("%sNo rule to make target `%s'%s");
-          const char *msg_parent
-            = _("%sNo rule to make target `%s', needed by `%s'%s");
-
           /* This is a dependency file we cannot remake.  Fail.  */
-          if (!keep_going_flag && !file->dontcare)
-            {
-              if (file->parent == 0)
-                fatal (NILF, msg_noparent, "", file->name, "");
-
-              fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
-            }
-
-          if (!file->dontcare)
-            {
-              if (file->parent == 0)
-                error (NILF, msg_noparent, "*** ", file->name, ".");
-              else
-                error (NILF, msg_parent, "*** ",
-                       file->name, file->parent->name, ".");
-            }
+          if (!rebuilding_makefiles || !file->dontcare)
+            complain (file);
           file->update_status = 2;
         }
@@ -1283 +1333 @@
 /* Return the mtime of the file or archive-member reference NAME.  */
 
+/* First, we check with stat().  If the file does not exist, then we return
+   NONEXISTENT_MTIME.  If it does, and the symlink check flag is set, then
+   examine each indirection of the symlink and find the newest mtime.
+   This causes one duplicate stat() when -L is being used, but the code is
+   much cleaner.  */
+
 static FILE_TIMESTAMP
 name_mtime (char *name)
 {
+  FILE_TIMESTAMP mtime;
   struct stat st;
   int e;
@@ -1293 +1350 @@
     {
       if (errno != ENOENT && errno != ENOTDIR)
-        perror_with_name ("stat:", name);
+        perror_with_name ("stat: ", name);
       return NONEXISTENT_MTIME;
     }
-
-  return FILE_TIMESTAMP_STAT_MODTIME (name, st);
+  mtime = FILE_TIMESTAMP_STAT_MODTIME (name, st);
+
+#ifdef MAKE_SYMLINKS
+#ifndef S_ISLNK
+# define S_ISLNK(_m)     (((_m)&S_IFMT)==S_IFLNK)
+#endif
+  if (check_symlink_flag)
+    {
+      PATH_VAR (lpath);
+
+      /* Check each symbolic link segment (if any).  Find the latest mtime
+         amongst all of them (and the target file of course).
+         Note that we have already successfully dereferenced all the links
+         above.  So, if we run into any error trying to lstat(), or
+         readlink(), or whatever, something bizarre-o happened.  Just give up
+         and use whatever mtime we've already computed at that point.  */
+      strcpy (lpath, name);
+      while (1)
+        {
+          FILE_TIMESTAMP ltime;
+          PATH_VAR (lbuf);
+          long llen;
+          char *p;
+
+          EINTRLOOP (e, lstat (lpath, &st));
+          if (e)
+            {
+              /* Eh?  Just take what we have.  */
+              perror_with_name ("lstat: ", lpath);
+              break;
+            }
+
+          /* If this is not a symlink, we're done (we started with the real
+             file's mtime so we don't need to test it again).  */
+          if (!S_ISLNK (st.st_mode))
+            break;
+
+          /* If this mtime is newer than what we had, keep the new one.  */
+          ltime = FILE_TIMESTAMP_STAT_MODTIME (lpath, st);
+          if (ltime > mtime)
+            mtime = ltime;
+
+          /* Set up to check the file pointed to by this link.  */
+          EINTRLOOP (llen, readlink (lpath, lbuf, GET_PATH_MAX));
+          if (llen < 0)
+            {
+              /* Eh?  Just take what we have.  */
+              perror_with_name ("readlink: ", lpath);
+              break;
+            }
+          lbuf[llen] = '\0';
+
+          /* If the target is fully-qualified or the source is just a
+             filename, then the new path is the target.  Otherwise it's the
+             source directory plus the target.  */
+          if (lbuf[0] == '/' || (p = strrchr (lpath, '/')) == NULL)
+            strcpy (lpath, lbuf);
+          else if ((p - lpath) + llen + 2 > GET_PATH_MAX)
+            /* Eh?  Path too long!  Again, just go with what we have.  */
+            break;
+          else
+            /* Create the next step in the symlink chain.  */
+            strcpy (p+1, lbuf);
+        }
+    }
+#endif
+
+  return mtime;
 }
 

trunk/src/gmake/variable.c

@@ -500 +500 @@
 
           do
-            /* We found one, so insert it into the set.  */
-            do_variable_definition (&p->variable.fileinfo, p->variable.name,
-                                    p->variable.value, p->variable.origin,
-                                    p->variable.flavor, 1);
+            {
+              /* We found one, so insert it into the set.  */
+
+              struct variable *v;
+
+              if (p->variable.flavor == f_simple)
+                {
+                  v = define_variable_loc (
+                    p->variable.name, strlen (p->variable.name),
+                    p->variable.value, p->variable.origin,
+                    0, &p->variable.fileinfo);
+
+                  v->flavor = f_simple;
+                }
+              else
+                {
+                  v = do_variable_definition (
+                    &p->variable.fileinfo, p->variable.name,
+                    p->variable.value, p->variable.origin,
+                    p->variable.flavor, 1);
+                }
+
+              /* Also mark it as a per-target and copy export status. */
+              v->per_target = p->variable.per_target;
+              v->export = p->variable.export;
+            }
           while ((p = lookup_pattern_var (p, file->name)) != 0);
 
@@ -735 +757 @@
 #endif
 
-  /* This won't override any definition, but it
-     will provide one if there isn't one there.  */
+  /* This won't override any definition, but it will provide one if there
+     isn't one there.  */
   v = define_variable ("SHELL", 5, default_shell, o_default, 0);
-  v->export = v_export;         /* Always export SHELL.  */
-
-  /* On MSDOS we do use SHELL from environment, since
-     it isn't a standard environment variable on MSDOS,
-     so whoever sets it, does that on purpose.
-     On OS/2 we do not use SHELL from environment but
-     we have already handled that problem above. */
+
+  /* On MSDOS we do use SHELL from environment, since it isn't a standard
+     environment variable on MSDOS, so whoever sets it, does that on purpose.
+     On OS/2 we do not use SHELL from environment but we have already handled
+     that problem above. */
 #if !defined(__MSDOS__) && !defined(__EMX__)
   /* Don't let SHELL come from the environment.  */
@@ -862 +882 @@
 
               case v_noexport:
-                continue;
+                /* If this is the SHELL variable and it's not exported, then
+                   add the value from our original environment.  */
+                if (streq (v->name, "SHELL"))
+                  {
+                    extern struct variable shell_var;
+                    v = &shell_var;
+                    break;
+                  }
+                continue;
 
               case v_ifset:
@@ -977 +1005 @@
             v = lookup_variable_in_set (varname, strlen (varname),
                                         current_variable_set_list->set);
+
+            /* Don't append from the global set if a previous non-appending
+               target-specific variable definition exists. */
+            if (v && !v->append)
+              append = 0;
           }
         else
@@ -1035 +1068 @@
       && strcmp (varname, "SHELL") == 0)
     {
-      char shellpath[PATH_MAX];
+      PATH_VAR (shellpath);
       extern char * __dosexec_find_on_path (const char *, char *[], char *);
 
@@ -1420 +1453 @@
 sync_Path_environment (void)
 {
-  char *path = allocated_variable_expand ("$(Path)");
+  char *path = allocated_variable_expand ("$(PATH)");
   static char *environ_path = NULL;
 
@@ -1437 +1470 @@
    */
   convert_Path_to_windows32 (path, ';');
-  environ_path = concat ("Path", "=", path);
+  environ_path = concat ("PATH", "=", path);
   putenv (environ_path);
   free (path);