Imported GNU Make 3.81upstream/3.82upstream

1 files changed, 959 insertions, 0 deletions

diff --git a/misc.c b/misc.c
new file mode 100644
index 0000000..7a6f773
--- /dev/null
+++ b/misc.c
@@ -0,0 +1,959 @@
+/* Miscellaneous generic support functions for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+2010 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "make.h"
+#include "dep.h"
+#include "debug.h"
+
+/* Variadic functions.  We go through contortions to allow proper function
+   prototypes for both ANSI and pre-ANSI C compilers, and also for those
+   which support stdarg.h vs. varargs.h, and finally those which have
+   vfprintf(), etc. and those who have _doprnt... or nothing.
+
+   This fancy stuff all came from GNU fileutils, except for the VA_PRINTF and
+   VA_END macros used here since we have multiple print functions.  */
+
+#if USE_VARIADIC
+# if HAVE_STDARG_H
+#  include <stdarg.h>
+#  define VA_START(args, lastarg) va_start(args, lastarg)
+# else
+#  include <varargs.h>
+#  define VA_START(args, lastarg) va_start(args)
+# endif
+# if HAVE_VPRINTF
+#  define VA_PRINTF(fp, lastarg, args) vfprintf((fp), (lastarg), (args))
+# else
+#  define VA_PRINTF(fp, lastarg, args) _doprnt((lastarg), (args), (fp))
+# endif
+# define VA_END(args) va_end(args)
+#else
+/* We can't use any variadic interface! */
+# define va_alist a1, a2, a3, a4, a5, a6, a7, a8
+# define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
+# define VA_START(args, lastarg)
+# define VA_PRINTF(fp, lastarg, args) fprintf((fp), (lastarg), va_alist)
+# define VA_END(args)
+#endif
+
+
+/* Compare strings *S1 and *S2.
+   Return negative if the first is less, positive if it is greater,
+   zero if they are equal.  */
+
+int
+alpha_compare (const void *v1, const void *v2)
+{
+  const char *s1 = *((char **)v1);
+  const char *s2 = *((char **)v2);
+
+  if (*s1 != *s2)
+    return *s1 - *s2;
+  return strcmp (s1, s2);
+}
+
+/* Discard each backslash-newline combination from LINE.
+   Backslash-backslash-newline combinations become backslash-newlines.
+   This is done by copying the text at LINE into itself.  */
+
+void
+collapse_continuations (char *line)
+{
+  register char *in, *out, *p;
+  register int backslash;
+  register unsigned int bs_write;
+
+  in = strchr (line, '\n');
+  if (in == 0)
+    return;
+
+  out = in;
+  while (out > line && out[-1] == '\\')
+    --out;
+
+  while (*in != '\0')
+    {
+      /* BS_WRITE gets the number of quoted backslashes at
+	 the end just before IN, and BACKSLASH gets nonzero
+	 if the next character is quoted.  */
+      backslash = 0;
+      bs_write = 0;
+      for (p = in - 1; p >= line && *p == '\\'; --p)
+	{
+	  if (backslash)
+	    ++bs_write;
+	  backslash = !backslash;
+
+	  /* It should be impossible to go back this far without exiting,
+	     but if we do, we can't get the right answer.  */
+	  if (in == out - 1)
+	    abort ();
+	}
+
+      /* Output the appropriate number of backslashes.  */
+      while (bs_write-- > 0)
+	*out++ = '\\';
+
+      /* Skip the newline.  */
+      ++in;
+
+      /* If the newline is escaped, discard following whitespace leaving just
+	 one space.  POSIX requires that each backslash/newline/following
+	 whitespace sequence be reduced to a single space.  */
+      if (backslash)
+	{
+	  in = next_token (in);
+          /* Removing this loop will fix Savannah bug #16670: do we want to? */
+	  while (out > line && isblank ((unsigned char)out[-1]))
+	    --out;
+	  *out++ = ' ';
+	}
+      else
+	/* If the newline isn't quoted, put it in the output.  */
+	*out++ = '\n';
+
+      /* Now copy the following line to the output.
+	 Stop when we find backslashes followed by a newline.  */
+      while (*in != '\0')
+	if (*in == '\\')
+	  {
+	    p = in + 1;
+	    while (*p == '\\')
+	      ++p;
+	    if (*p == '\n')
+	      {
+		in = p;
+		break;
+	      }
+	    while (in < p)
+	      *out++ = *in++;
+	  }
+	else
+	  *out++ = *in++;
+    }
+
+  *out = '\0';
+}
+
+/* Print N spaces (used in debug for target-depth).  */
+
+void
+print_spaces (unsigned int n)
+{
+  while (n-- > 0)
+    putchar (' ');
+}
+
+
+/* Return a string whose contents concatenate the NUM strings provided
+   This string lives in static, re-used memory.  */
+
+const char *
+#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
+concat (unsigned int num, ...)
+#else
+concat (num, va_alist)
+     unsigned int num;
+     va_dcl
+#endif
+{
+  static unsigned int rlen = 0;
+  static char *result = NULL;
+  int ri = 0;
+
+#if USE_VARIADIC
+  va_list args;
+#endif
+
+  VA_START (args, num);
+
+  while (num-- > 0)
+    {
+      const char *s = va_arg (args, const char *);
+      unsigned int l = s ? strlen (s) : 0;
+
+      if (l == 0)
+        continue;
+
+      if (ri + l > rlen)
+        {
+          rlen = ((rlen ? rlen : 60) + l) * 2;
+          result = xrealloc (result, rlen);
+        }
+
+      memcpy (result + ri, s, l);
+      ri += l;
+    }
+
+  VA_END (args);
+
+  /* Get some more memory if we don't have enough space for the
+     terminating '\0'.   */
+  if (ri == rlen)
+    {
+      rlen = (rlen ? rlen : 60) * 2;
+      result = xrealloc (result, rlen);
+    }
+
+  result[ri] = '\0';
+
+  return result;
+}
+
+/* Print a message on stdout.  */
+
+void
+#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
+message (int prefix, const char *fmt, ...)
+#else
+message (prefix, fmt, va_alist)
+     int prefix;
+     const char *fmt;
+     va_dcl
+#endif
+{
+#if USE_VARIADIC
+  va_list args;
+#endif
+
+  log_working_directory (1);
+
+  if (fmt != 0)
+    {
+      if (prefix)
+	{
+	  if (makelevel == 0)
+	    printf ("%s: ", program);
+	  else
+	    printf ("%s[%u]: ", program, makelevel);
+	}
+      VA_START (args, fmt);
+      VA_PRINTF (stdout, fmt, args);
+      VA_END (args);
+      putchar ('\n');
+    }
+
+  fflush (stdout);
+}
+
+/* Print an error message.  */
+
+void
+#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
+error (const struct floc *flocp, const char *fmt, ...)
+#else
+error (flocp, fmt, va_alist)
+     const struct floc *flocp;
+     const char *fmt;
+     va_dcl
+#endif
+{
+#if USE_VARIADIC
+  va_list args;
+#endif
+
+  log_working_directory (1);
+
+  if (flocp && flocp->filenm)
+    fprintf (stderr, "%s:%lu: ", flocp->filenm, flocp->lineno);
+  else if (makelevel == 0)
+    fprintf (stderr, "%s: ", program);
+  else
+    fprintf (stderr, "%s[%u]: ", program, makelevel);
+
+  VA_START(args, fmt);
+  VA_PRINTF (stderr, fmt, args);
+  VA_END (args);
+
+  putc ('\n', stderr);
+  fflush (stderr);
+}
+
+/* Print an error message and exit.  */
+
+void
+#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
+fatal (const struct floc *flocp, const char *fmt, ...)
+#else
+fatal (flocp, fmt, va_alist)
+     const struct floc *flocp;
+     const char *fmt;
+     va_dcl
+#endif
+{
+#if USE_VARIADIC
+  va_list args;
+#endif
+
+  log_working_directory (1);
+
+  if (flocp && flocp->filenm)
+    fprintf (stderr, "%s:%lu: *** ", flocp->filenm, flocp->lineno);
+  else if (makelevel == 0)
+    fprintf (stderr, "%s: *** ", program);
+  else
+    fprintf (stderr, "%s[%u]: *** ", program, makelevel);
+
+  VA_START(args, fmt);
+  VA_PRINTF (stderr, fmt, args);
+  VA_END (args);
+
+  fputs (_(".  Stop.\n"), stderr);
+
+  die (2);
+}
+
+#ifndef HAVE_STRERROR
+
+#undef	strerror
+
+char *
+strerror (int errnum)
+{
+  extern int errno, sys_nerr;
+#ifndef __DECC
+  extern char *sys_errlist[];
+#endif
+  static char buf[] = "Unknown error 12345678901234567890";
+
+  if (errno < sys_nerr)
+    return sys_errlist[errnum];
+
+  sprintf (buf, _("Unknown error %d"), errnum);
+  return buf;
+}
+#endif
+
+/* Print an error message from errno.  */
+
+void
+perror_with_name (const char *str, const char *name)
+{
+  error (NILF, _("%s%s: %s"), str, name, strerror (errno));
+}
+
+/* Print an error message from errno and exit.  */
+
+void
+pfatal_with_name (const char *name)
+{
+  fatal (NILF, _("%s: %s"), name, strerror (errno));
+
+  /* NOTREACHED */
+}
+
+/* Like malloc but get fatal error if memory is exhausted.  */
+/* Don't bother if we're using dmalloc; it provides these for us.  */
+
+#ifndef HAVE_DMALLOC_H
+
+#undef xmalloc
+#undef xcalloc
+#undef xrealloc
+#undef xstrdup
+
+void *
+xmalloc (unsigned int size)
+{
+  /* Make sure we don't allocate 0, for pre-ISO implementations.  */
+  void *result = malloc (size ? size : 1);
+  if (result == 0)
+    fatal (NILF, _("virtual memory exhausted"));
+  return result;
+}
+
+
+void *
+xcalloc (unsigned int size)
+{
+  /* Make sure we don't allocate 0, for pre-ISO implementations.  */
+  void *result = calloc (size ? size : 1, 1);
+  if (result == 0)
+    fatal (NILF, _("virtual memory exhausted"));
+  return result;
+}
+
+
+void *
+xrealloc (void *ptr, unsigned int size)
+{
+  void *result;
+
+  /* Some older implementations of realloc() don't conform to ISO.  */
+  if (! size)
+    size = 1;
+  result = ptr ? realloc (ptr, size) : malloc (size);
+  if (result == 0)
+    fatal (NILF, _("virtual memory exhausted"));
+  return result;
+}
+
+
+char *
+xstrdup (const char *ptr)
+{
+  char *result;
+
+#ifdef HAVE_STRDUP
+  result = strdup (ptr);
+#else
+  result = malloc (strlen (ptr) + 1);
+#endif
+
+  if (result == 0)
+    fatal (NILF, _("virtual memory exhausted"));
+
+#ifdef HAVE_STRDUP
+  return result;
+#else
+  return strcpy (result, ptr);
+#endif
+}
+
+#endif  /* HAVE_DMALLOC_H */
+
+char *
+xstrndup (const char *str, unsigned int length)
+{
+  char *result;
+
+#ifdef HAVE_STRNDUP
+  result = strndup (str, length);
+  if (result == 0)
+    fatal (NILF, _("virtual memory exhausted"));
+#else
+  result = xmalloc (length + 1);
+  if (length > 0)
+    strncpy (result, str, length);
+  result[length] = '\0';
+#endif
+
+  return result;
+}
+
+
+/* Limited INDEX:
+   Search through the string STRING, which ends at LIMIT, for the character C.
+   Returns a pointer to the first occurrence, or nil if none is found.
+   Like INDEX except that the string searched ends where specified
+   instead of at the first null.  */
+
+char *
+lindex (const char *s, const char *limit, int c)
+{
+  while (s < limit)
+    if (*s++ == c)
+      return (char *)(s - 1);
+
+  return 0;
+}
+
+/* Return the address of the first whitespace or null in the string S.  */
+
+char *
+end_of_token (const char *s)
+{
+  while (*s != '\0' && !isblank ((unsigned char)*s))
+    ++s;
+  return (char *)s;
+}
+
+#ifdef WINDOWS32
+/*
+ * Same as end_of_token, but take into account a stop character
+ */
+char *
+end_of_token_w32 (const char *s, char stopchar)
+{
+  const char *p = s;
+  int backslash = 0;
+
+  while (*p != '\0' && *p != stopchar
+	 && (backslash || !isblank ((unsigned char)*p)))
+    {
+      if (*p++ == '\\')
+        {
+          backslash = !backslash;
+          while (*p == '\\')
+            {
+              backslash = !backslash;
+              ++p;
+            }
+        }
+      else
+        backslash = 0;
+    }
+
+  return (char *)p;
+}
+#endif
+
+/* Return the address of the first nonwhitespace or null in the string S.  */
+
+char *
+next_token (const char *s)
+{
+  while (isblank ((unsigned char)*s))
+    ++s;
+  return (char *)s;
+}
+
+/* Find the next token in PTR; return the address of it, and store the length
+   of the token into *LENGTHPTR if LENGTHPTR is not nil.  Set *PTR to the end
+   of the token, so this function can be called repeatedly in a loop.  */
+
+char *
+find_next_token (const char **ptr, unsigned int *lengthptr)
+{
+  const char *p = next_token (*ptr);
+
+  if (*p == '\0')
+    return 0;
+
+  *ptr = end_of_token (p);
+  if (lengthptr != 0)
+    *lengthptr = *ptr - p;
+
+  return (char *)p;
+}
+
+
+/* Copy a chain of `struct dep'.  For 2nd expansion deps, dup the name.  */
+
+struct dep *
+copy_dep_chain (const struct dep *d)
+{
+  struct dep *firstnew = 0;
+  struct dep *lastnew = 0;
+
+  while (d != 0)
+    {
+      struct dep *c = xmalloc (sizeof (struct dep));
+      memcpy (c, d, sizeof (struct dep));
+
+      if (c->need_2nd_expansion)
+        c->name = xstrdup (c->name);
+
+      c->next = 0;
+      if (firstnew == 0)
+	firstnew = lastnew = c;
+      else
+	lastnew = lastnew->next = c;
+
+      d = d->next;
+    }
+
+  return firstnew;
+}
+
+/* Free a chain of 'struct dep'.  */
+
+void
+free_dep_chain (struct dep *d)
+{
+  while (d != 0)
+    {
+      struct dep *df = d;
+      d = d->next;
+      free_dep (df);
+    }
+}
+
+/* Free a chain of struct nameseq.
+   For struct dep chains use free_dep_chain.  */
+
+void
+free_ns_chain (struct nameseq *ns)
+{
+  while (ns != 0)
+    {
+      struct nameseq *t = ns;
+      ns = ns->next;
+      free (t);
+    }
+}
+
+
+#if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
+
+/* If we don't have strcasecmp() (from POSIX), or anything that can substitute
+   for it, define our own version.  */
+
+int
+strcasecmp (const char *s1, const char *s2)
+{
+  while (1)
+    {
+      int c1 = (int) *(s1++);
+      int c2 = (int) *(s2++);
+
+      if (isalpha (c1))
+        c1 = tolower (c1);
+      if (isalpha (c2))
+        c2 = tolower (c2);
+
+      if (c1 != '\0' && c1 == c2)
+        continue;
+
+      return (c1 - c2);
+    }
+}
+#endif
+
+#if !HAVE_STRNCASECMP && !HAVE_STRNICMP && !HAVE_STRNCMPI
+
+/* If we don't have strncasecmp() (from POSIX), or anything that can
+   substitute for it, define our own version.  */
+
+int
+strncasecmp (const char *s1, const char *s2, int n)
+{
+  while (n-- > 0)
+    {
+      int c1 = (int) *(s1++);
+      int c2 = (int) *(s2++);
+
+      if (isalpha (c1))
+        c1 = tolower (c1);
+      if (isalpha (c2))
+        c2 = tolower (c2);
+
+      if (c1 != '\0' && c1 == c2)
+        continue;
+
+      return (c1 - c2);
+    }
+
+  return 0;
+}
+#endif
+
+#ifdef	GETLOADAVG_PRIVILEGED
+
+#ifdef POSIX
+
+/* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
+   functions, they work as POSIX.1 says.  Some systems (Alpha OSF/1 1.2,
+   for example) which claim to be POSIX.1 also have the BSD setreuid and
+   setregid functions, but they don't work as in BSD and only the POSIX.1
+   way works.  */
+
+#undef HAVE_SETREUID
+#undef HAVE_SETREGID
+
+#else	/* Not POSIX.  */
+
+/* Some POSIX.1 systems have the seteuid and setegid functions.  In a
+   POSIX-like system, they are the best thing to use.  However, some
+   non-POSIX systems have them too but they do not work in the POSIX style
+   and we must use setreuid and setregid instead.  */
+
+#undef HAVE_SETEUID
+#undef HAVE_SETEGID
+
+#endif	/* POSIX.  */
+
+#ifndef	HAVE_UNISTD_H
+extern int getuid (), getgid (), geteuid (), getegid ();
+extern int setuid (), setgid ();
+#ifdef HAVE_SETEUID
+extern int seteuid ();
+#else
+#ifdef	HAVE_SETREUID
+extern int setreuid ();
+#endif	/* Have setreuid.  */
+#endif	/* Have seteuid.  */
+#ifdef HAVE_SETEGID
+extern int setegid ();
+#else
+#ifdef	HAVE_SETREGID
+extern int setregid ();
+#endif	/* Have setregid.  */
+#endif	/* Have setegid.  */
+#endif	/* No <unistd.h>.  */
+
+/* Keep track of the user and group IDs for user- and make- access.  */
+static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
+#define	access_inited	(user_uid != -1)
+static enum { make, user } current_access;
+
+
+/* Under -d, write a message describing the current IDs.  */
+
+static void
+log_access (const char *flavor)
+{
+  if (! ISDB (DB_JOBS))
+    return;
+
+  /* All the other debugging messages go to stdout,
+     but we write this one to stderr because it might be
+     run in a child fork whose stdout is piped.  */
+
+  fprintf (stderr, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
+	   flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
+           (unsigned long) getegid (), (unsigned long) getgid ());
+  fflush (stderr);
+}
+
+
+static void
+init_access (void)
+{
+#ifndef VMS
+  user_uid = getuid ();
+  user_gid = getgid ();
+
+  make_uid = geteuid ();
+  make_gid = getegid ();
+
+  /* Do these ever fail?  */
+  if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
+    pfatal_with_name ("get{e}[gu]id");
+
+  log_access (_("Initialized access"));
+
+  current_access = make;
+#endif
+}
+
+#endif	/* GETLOADAVG_PRIVILEGED */
+
+/* Give the process appropriate permissions for access to
+   user data (i.e., to stat files, or to spawn a child process).  */
+void
+user_access (void)
+{
+#ifdef	GETLOADAVG_PRIVILEGED
+
+  if (!access_inited)
+    init_access ();
+
+  if (current_access == user)
+    return;
+
+  /* We are in "make access" mode.  This means that the effective user and
+     group IDs are those of make (if it was installed setuid or setgid).
+     We now want to set the effective user and group IDs to the real IDs,
+     which are the IDs of the process that exec'd make.  */
+
+#ifdef	HAVE_SETEUID
+
+  /* Modern systems have the seteuid/setegid calls which set only the
+     effective IDs, which is ideal.  */
+
+  if (seteuid (user_uid) < 0)
+    pfatal_with_name ("user_access: seteuid");
+
+#else	/* Not HAVE_SETEUID.  */
+
+#ifndef	HAVE_SETREUID
+
+  /* System V has only the setuid/setgid calls to set user/group IDs.
+     There is an effective ID, which can be set by setuid/setgid.
+     It can be set (unless you are root) only to either what it already is
+     (returned by geteuid/getegid, now in make_uid/make_gid),
+     the real ID (return by getuid/getgid, now in user_uid/user_gid),
+     or the saved set ID (what the effective ID was before this set-ID
+     executable (make) was exec'd).  */
+
+  if (setuid (user_uid) < 0)
+    pfatal_with_name ("user_access: setuid");
+
+#else	/* HAVE_SETREUID.  */
+
+  /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
+     They may be set to themselves or each other.  So you have two alternatives
+     at any one time.  If you use setuid/setgid, the effective will be set to
+     the real, leaving only one alternative.  Using setreuid/setregid, however,
+     you can toggle between your two alternatives by swapping the values in a
+     single setreuid or setregid call.  */
+
+  if (setreuid (make_uid, user_uid) < 0)
+    pfatal_with_name ("user_access: setreuid");
+
+#endif	/* Not HAVE_SETREUID.  */
+#endif	/* HAVE_SETEUID.  */
+
+#ifdef	HAVE_SETEGID
+  if (setegid (user_gid) < 0)
+    pfatal_with_name ("user_access: setegid");
+#else
+#ifndef	HAVE_SETREGID
+  if (setgid (user_gid) < 0)
+    pfatal_with_name ("user_access: setgid");
+#else
+  if (setregid (make_gid, user_gid) < 0)
+    pfatal_with_name ("user_access: setregid");
+#endif
+#endif
+
+  current_access = user;
+
+  log_access (_("User access"));
+
+#endif	/* GETLOADAVG_PRIVILEGED */
+}
+
+/* Give the process appropriate permissions for access to
+   make data (i.e., the load average).  */
+void
+make_access (void)
+{
+#ifdef	GETLOADAVG_PRIVILEGED
+
+  if (!access_inited)
+    init_access ();
+
+  if (current_access == make)
+    return;
+
+  /* See comments in user_access, above.  */
+
+#ifdef	HAVE_SETEUID
+  if (seteuid (make_uid) < 0)
+    pfatal_with_name ("make_access: seteuid");
+#else
+#ifndef	HAVE_SETREUID
+  if (setuid (make_uid) < 0)
+    pfatal_with_name ("make_access: setuid");
+#else
+  if (setreuid (user_uid, make_uid) < 0)
+    pfatal_with_name ("make_access: setreuid");
+#endif
+#endif
+
+#ifdef	HAVE_SETEGID
+  if (setegid (make_gid) < 0)
+    pfatal_with_name ("make_access: setegid");
+#else
+#ifndef	HAVE_SETREGID
+  if (setgid (make_gid) < 0)
+    pfatal_with_name ("make_access: setgid");
+#else
+  if (setregid (user_gid, make_gid) < 0)
+    pfatal_with_name ("make_access: setregid");
+#endif
+#endif
+
+  current_access = make;
+
+  log_access (_("Make access"));
+
+#endif	/* GETLOADAVG_PRIVILEGED */
+}
+
+/* Give the process appropriate permissions for a child process.
+   This is like user_access, but you can't get back to make_access.  */
+void
+child_access (void)
+{
+#ifdef	GETLOADAVG_PRIVILEGED
+
+  if (!access_inited)
+    abort ();
+
+  /* Set both the real and effective UID and GID to the user's.
+     They cannot be changed back to make's.  */
+
+#ifndef	HAVE_SETREUID
+  if (setuid (user_uid) < 0)
+    pfatal_with_name ("child_access: setuid");
+#else
+  if (setreuid (user_uid, user_uid) < 0)
+    pfatal_with_name ("child_access: setreuid");
+#endif
+
+#ifndef	HAVE_SETREGID
+  if (setgid (user_gid) < 0)
+    pfatal_with_name ("child_access: setgid");
+#else
+  if (setregid (user_gid, user_gid) < 0)
+    pfatal_with_name ("child_access: setregid");
+#endif
+
+  log_access (_("Child access"));
+
+#endif	/* GETLOADAVG_PRIVILEGED */
+}
+
+#ifdef NEED_GET_PATH_MAX
+unsigned int
+get_path_max (void)
+{
+  static unsigned int value;
+
+  if (value == 0)
+    {
+      long int x = pathconf ("/", _PC_PATH_MAX);
+      if (x > 0)
+	value = x;
+      else
+	return MAXPATHLEN;
+    }
+
+  return value;
+}
+#endif
+
+
+/* This code is stolen from gnulib.
+   If/when we abandon the requirement to work with K&R compilers, we can
+   remove this (and perhaps other parts of GNU make!) and migrate to using
+   gnulib directly.
+
+   This is called only through atexit(), which means die() has already been
+   invoked.  So, call exit() here directly.  Apparently that works...?
+*/
+
+/* Close standard output, exiting with status 'exit_failure' on failure.
+   If a program writes *anything* to stdout, that program should close
+   stdout and make sure that it succeeds before exiting.  Otherwise,
+   suppose that you go to the extreme of checking the return status
+   of every function that does an explicit write to stdout.  The last
+   printf can succeed in writing to the internal stream buffer, and yet
+   the fclose(stdout) could still fail (due e.g., to a disk full error)
+   when it tries to write out that buffered data.  Thus, you would be
+   left with an incomplete output file and the offending program would
+   exit successfully.  Even calling fflush is not always sufficient,
+   since some file systems (NFS and CODA) buffer written/flushed data
+   until an actual close call.
+
+   Besides, it's wasteful to check the return value from every call
+   that writes to stdout -- just let the internal stream state record
+   the failure.  That's what the ferror test is checking below.
+
+   It's important to detect such failures and exit nonzero because many
+   tools (most notably `make' and other build-management systems) depend
+   on being able to detect failure in other tools via their exit status.  */
+
+void
+close_stdout (void)
+{
+  int prev_fail = ferror (stdout);
+  int fclose_fail = fclose (stdout);
+
+  if (prev_fail || fclose_fail)
+    {
+      if (fclose_fail)
+        error (NILF, _("write error: %s"), strerror (errno));
+      else
+        error (NILF, _("write error"));
+      exit (EXIT_FAILURE);
+    }
+}