Add missing load.c file to POTFILES.in
[make.git] / misc.c
blobcf371bed9330684fc398a7effc6955601d0cd5a3
1 /* Miscellaneous generic support functions for GNU Make.
2 Copyright (C) 1988-2012 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
8 version.
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
17 #include "make.h"
18 #include "dep.h"
19 #include "debug.h"
21 /* Variadic functions. We go through contortions to allow proper function
22 prototypes for both ANSI and pre-ANSI C compilers, and also for those
23 which support stdarg.h vs. varargs.h, and finally those which have
24 vfprintf(), etc. and those who have _doprnt... or nothing.
26 This fancy stuff all came from GNU fileutils, except for the VA_PRINTF and
27 VA_END macros used here since we have multiple print functions. */
29 #if USE_VARIADIC
30 # if HAVE_STDARG_H
31 # include <stdarg.h>
32 # define VA_START(args, lastarg) va_start(args, lastarg)
33 # else
34 # include <varargs.h>
35 # define VA_START(args, lastarg) va_start(args)
36 # endif
37 # if HAVE_VPRINTF
38 # define VA_PRINTF(fp, lastarg, args) vfprintf((fp), (lastarg), (args))
39 # else
40 # define VA_PRINTF(fp, lastarg, args) _doprnt((lastarg), (args), (fp))
41 # endif
42 # define VA_END(args) va_end(args)
43 #else
44 /* We can't use any variadic interface! */
45 # define va_alist a1, a2, a3, a4, a5, a6, a7, a8
46 # define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
47 # define VA_START(args, lastarg)
48 # define VA_PRINTF(fp, lastarg, args) fprintf((fp), (lastarg), va_alist)
49 # define VA_END(args)
50 #endif
53 /* Compare strings *S1 and *S2.
54 Return negative if the first is less, positive if it is greater,
55 zero if they are equal. */
57 int
58 alpha_compare (const void *v1, const void *v2)
60 const char *s1 = *((char **)v1);
61 const char *s2 = *((char **)v2);
63 if (*s1 != *s2)
64 return *s1 - *s2;
65 return strcmp (s1, s2);
68 /* Discard each backslash-newline combination from LINE.
69 Backslash-backslash-newline combinations become backslash-newlines.
70 This is done by copying the text at LINE into itself. */
72 void
73 collapse_continuations (char *line)
75 register char *in, *out, *p;
76 register int backslash;
77 register unsigned int bs_write;
79 in = strchr (line, '\n');
80 if (in == 0)
81 return;
83 out = in;
84 while (out > line && out[-1] == '\\')
85 --out;
87 while (*in != '\0')
89 /* BS_WRITE gets the number of quoted backslashes at
90 the end just before IN, and BACKSLASH gets nonzero
91 if the next character is quoted. */
92 backslash = 0;
93 bs_write = 0;
94 for (p = in - 1; p >= line && *p == '\\'; --p)
96 if (backslash)
97 ++bs_write;
98 backslash = !backslash;
100 /* It should be impossible to go back this far without exiting,
101 but if we do, we can't get the right answer. */
102 if (in == out - 1)
103 abort ();
106 /* Output the appropriate number of backslashes. */
107 while (bs_write-- > 0)
108 *out++ = '\\';
110 /* Skip the newline. */
111 ++in;
113 if (backslash)
115 /* Backslash/newline handling:
116 In traditional GNU make all trailing whitespace, consecutive
117 backslash/newlines, and any leading whitespace on the next line
118 is reduced to a single space.
119 In POSIX, each backslash/newline and is replaced by a space. */
120 in = next_token (in);
121 if (! posix_pedantic)
122 while (out > line && isblank ((unsigned char)out[-1]))
123 --out;
124 *out++ = ' ';
126 else
127 /* If the newline isn't quoted, put it in the output. */
128 *out++ = '\n';
130 /* Now copy the following line to the output.
131 Stop when we find backslashes followed by a newline. */
132 while (*in != '\0')
133 if (*in == '\\')
135 p = in + 1;
136 while (*p == '\\')
137 ++p;
138 if (*p == '\n')
140 in = p;
141 break;
143 while (in < p)
144 *out++ = *in++;
146 else
147 *out++ = *in++;
150 *out = '\0';
153 /* Print N spaces (used in debug for target-depth). */
155 void
156 print_spaces (unsigned int n)
158 while (n-- > 0)
159 putchar (' ');
163 /* Return a string whose contents concatenate the NUM strings provided
164 This string lives in static, re-used memory. */
166 const char *
167 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
168 concat (unsigned int num, ...)
169 #else
170 concat (num, va_alist)
171 unsigned int num;
172 va_dcl
173 #endif
175 static unsigned int rlen = 0;
176 static char *result = NULL;
177 unsigned int ri = 0;
179 #if USE_VARIADIC
180 va_list args;
181 #endif
183 VA_START (args, num);
185 while (num-- > 0)
187 const char *s = va_arg (args, const char *);
188 unsigned int l = s ? strlen (s) : 0;
190 if (l == 0)
191 continue;
193 if (ri + l > rlen)
195 rlen = ((rlen ? rlen : 60) + l) * 2;
196 result = xrealloc (result, rlen);
199 memcpy (result + ri, s, l);
200 ri += l;
203 VA_END (args);
205 /* Get some more memory if we don't have enough space for the
206 terminating '\0'. */
207 if (ri == rlen)
209 rlen = (rlen ? rlen : 60) * 2;
210 result = xrealloc (result, rlen);
213 result[ri] = '\0';
215 return result;
218 /* Print a message on stdout. */
220 void
221 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
222 message (int prefix, const char *fmt, ...)
223 #else
224 message (prefix, fmt, va_alist)
225 int prefix;
226 const char *fmt;
227 va_dcl
228 #endif
230 #if USE_VARIADIC
231 va_list args;
232 #endif
234 log_working_directory (1);
236 if (fmt != 0)
238 if (prefix)
240 if (makelevel == 0)
241 printf ("%s: ", program);
242 else
243 printf ("%s[%u]: ", program, makelevel);
245 VA_START (args, fmt);
246 VA_PRINTF (stdout, fmt, args);
247 VA_END (args);
248 putchar ('\n');
251 fflush (stdout);
254 /* Print an error message. */
256 void
257 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
258 error (const struct floc *flocp, const char *fmt, ...)
259 #else
260 error (flocp, fmt, va_alist)
261 const struct floc *flocp;
262 const char *fmt;
263 va_dcl
264 #endif
266 #if USE_VARIADIC
267 va_list args;
268 #endif
270 log_working_directory (1);
272 if (flocp && flocp->filenm)
273 fprintf (stderr, "%s:%lu: ", flocp->filenm, flocp->lineno);
274 else if (makelevel == 0)
275 fprintf (stderr, "%s: ", program);
276 else
277 fprintf (stderr, "%s[%u]: ", program, makelevel);
279 VA_START(args, fmt);
280 VA_PRINTF (stderr, fmt, args);
281 VA_END (args);
283 putc ('\n', stderr);
284 fflush (stderr);
287 /* Print an error message and exit. */
289 void
290 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
291 fatal (const struct floc *flocp, const char *fmt, ...)
292 #else
293 fatal (flocp, fmt, va_alist)
294 const struct floc *flocp;
295 const char *fmt;
296 va_dcl
297 #endif
299 #if USE_VARIADIC
300 va_list args;
301 #endif
303 log_working_directory (1);
305 if (flocp && flocp->filenm)
306 fprintf (stderr, "%s:%lu: *** ", flocp->filenm, flocp->lineno);
307 else if (makelevel == 0)
308 fprintf (stderr, "%s: *** ", program);
309 else
310 fprintf (stderr, "%s[%u]: *** ", program, makelevel);
312 VA_START(args, fmt);
313 VA_PRINTF (stderr, fmt, args);
314 VA_END (args);
316 fputs (_(". Stop.\n"), stderr);
318 die (2);
321 #ifndef HAVE_STRERROR
323 #undef strerror
325 char *
326 strerror (int errnum)
328 extern int errno, sys_nerr;
329 #ifndef __DECC
330 extern char *sys_errlist[];
331 #endif
332 static char buf[] = "Unknown error 12345678901234567890";
334 if (errno < sys_nerr)
335 return sys_errlist[errnum];
337 sprintf (buf, _("Unknown error %d"), errnum);
338 return buf;
340 #endif
342 /* Print an error message from errno. */
344 void
345 perror_with_name (const char *str, const char *name)
347 error (NILF, _("%s%s: %s"), str, name, strerror (errno));
350 /* Print an error message from errno and exit. */
352 void
353 pfatal_with_name (const char *name)
355 fatal (NILF, _("%s: %s"), name, strerror (errno));
357 /* NOTREACHED */
360 /* Like malloc but get fatal error if memory is exhausted. */
361 /* Don't bother if we're using dmalloc; it provides these for us. */
363 #ifndef HAVE_DMALLOC_H
365 #undef xmalloc
366 #undef xcalloc
367 #undef xrealloc
368 #undef xstrdup
370 void *
371 xmalloc (unsigned int size)
373 /* Make sure we don't allocate 0, for pre-ISO implementations. */
374 void *result = malloc (size ? size : 1);
375 if (result == 0)
376 fatal (NILF, _("virtual memory exhausted"));
377 return result;
381 void *
382 xcalloc (unsigned int size)
384 /* Make sure we don't allocate 0, for pre-ISO implementations. */
385 void *result = calloc (size ? size : 1, 1);
386 if (result == 0)
387 fatal (NILF, _("virtual memory exhausted"));
388 return result;
392 void *
393 xrealloc (void *ptr, unsigned int size)
395 void *result;
397 /* Some older implementations of realloc() don't conform to ISO. */
398 if (! size)
399 size = 1;
400 result = ptr ? realloc (ptr, size) : malloc (size);
401 if (result == 0)
402 fatal (NILF, _("virtual memory exhausted"));
403 return result;
407 char *
408 xstrdup (const char *ptr)
410 char *result;
412 #ifdef HAVE_STRDUP
413 result = strdup (ptr);
414 #else
415 result = malloc (strlen (ptr) + 1);
416 #endif
418 if (result == 0)
419 fatal (NILF, _("virtual memory exhausted"));
421 #ifdef HAVE_STRDUP
422 return result;
423 #else
424 return strcpy (result, ptr);
425 #endif
428 #endif /* HAVE_DMALLOC_H */
430 char *
431 xstrndup (const char *str, unsigned int length)
433 char *result;
435 #ifdef HAVE_STRNDUP
436 result = strndup (str, length);
437 if (result == 0)
438 fatal (NILF, _("virtual memory exhausted"));
439 #else
440 result = xmalloc (length + 1);
441 if (length > 0)
442 strncpy (result, str, length);
443 result[length] = '\0';
444 #endif
446 return result;
450 /* Limited INDEX:
451 Search through the string STRING, which ends at LIMIT, for the character C.
452 Returns a pointer to the first occurrence, or nil if none is found.
453 Like INDEX except that the string searched ends where specified
454 instead of at the first null. */
456 char *
457 lindex (const char *s, const char *limit, int c)
459 while (s < limit)
460 if (*s++ == c)
461 return (char *)(s - 1);
463 return 0;
466 /* Return the address of the first whitespace or null in the string S. */
468 char *
469 end_of_token (const char *s)
471 while (*s != '\0' && !isblank ((unsigned char)*s))
472 ++s;
473 return (char *)s;
476 #ifdef WINDOWS32
478 * Same as end_of_token, but take into account a stop character
480 char *
481 end_of_token_w32 (const char *s, char stopchar)
483 const char *p = s;
484 int backslash = 0;
486 while (*p != '\0' && *p != stopchar
487 && (backslash || !isblank ((unsigned char)*p)))
489 if (*p++ == '\\')
491 backslash = !backslash;
492 while (*p == '\\')
494 backslash = !backslash;
495 ++p;
498 else
499 backslash = 0;
502 return (char *)p;
504 #endif
506 /* Return the address of the first nonwhitespace or null in the string S. */
508 char *
509 next_token (const char *s)
511 while (isblank ((unsigned char)*s))
512 ++s;
513 return (char *)s;
516 /* Find the next token in PTR; return the address of it, and store the length
517 of the token into *LENGTHPTR if LENGTHPTR is not nil. Set *PTR to the end
518 of the token, so this function can be called repeatedly in a loop. */
520 char *
521 find_next_token (const char **ptr, unsigned int *lengthptr)
523 const char *p = next_token (*ptr);
525 if (*p == '\0')
526 return 0;
528 *ptr = end_of_token (p);
529 if (lengthptr != 0)
530 *lengthptr = *ptr - p;
532 return (char *)p;
536 /* Copy a chain of 'struct dep'. For 2nd expansion deps, dup the name. */
538 struct dep *
539 copy_dep_chain (const struct dep *d)
541 struct dep *firstnew = 0;
542 struct dep *lastnew = 0;
544 while (d != 0)
546 struct dep *c = xmalloc (sizeof (struct dep));
547 memcpy (c, d, sizeof (struct dep));
549 if (c->need_2nd_expansion)
550 c->name = xstrdup (c->name);
552 c->next = 0;
553 if (firstnew == 0)
554 firstnew = lastnew = c;
555 else
556 lastnew = lastnew->next = c;
558 d = d->next;
561 return firstnew;
564 /* Free a chain of 'struct dep'. */
566 void
567 free_dep_chain (struct dep *d)
569 while (d != 0)
571 struct dep *df = d;
572 d = d->next;
573 free_dep (df);
577 /* Free a chain of struct nameseq.
578 For struct dep chains use free_dep_chain. */
580 void
581 free_ns_chain (struct nameseq *ns)
583 while (ns != 0)
585 struct nameseq *t = ns;
586 ns = ns->next;
587 free (t);
592 #if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
594 /* If we don't have strcasecmp() (from POSIX), or anything that can substitute
595 for it, define our own version. */
598 strcasecmp (const char *s1, const char *s2)
600 while (1)
602 int c1 = (int) *(s1++);
603 int c2 = (int) *(s2++);
605 if (isalpha (c1))
606 c1 = tolower (c1);
607 if (isalpha (c2))
608 c2 = tolower (c2);
610 if (c1 != '\0' && c1 == c2)
611 continue;
613 return (c1 - c2);
616 #endif
618 #if !HAVE_STRNCASECMP && !HAVE_STRNICMP && !HAVE_STRNCMPI
620 /* If we don't have strncasecmp() (from POSIX), or anything that can
621 substitute for it, define our own version. */
624 strncasecmp (const char *s1, const char *s2, int n)
626 while (n-- > 0)
628 int c1 = (int) *(s1++);
629 int c2 = (int) *(s2++);
631 if (isalpha (c1))
632 c1 = tolower (c1);
633 if (isalpha (c2))
634 c2 = tolower (c2);
636 if (c1 != '\0' && c1 == c2)
637 continue;
639 return (c1 - c2);
642 return 0;
644 #endif
646 #ifdef GETLOADAVG_PRIVILEGED
648 #ifdef POSIX
650 /* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
651 functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2,
652 for example) which claim to be POSIX.1 also have the BSD setreuid and
653 setregid functions, but they don't work as in BSD and only the POSIX.1
654 way works. */
656 #undef HAVE_SETREUID
657 #undef HAVE_SETREGID
659 #else /* Not POSIX. */
661 /* Some POSIX.1 systems have the seteuid and setegid functions. In a
662 POSIX-like system, they are the best thing to use. However, some
663 non-POSIX systems have them too but they do not work in the POSIX style
664 and we must use setreuid and setregid instead. */
666 #undef HAVE_SETEUID
667 #undef HAVE_SETEGID
669 #endif /* POSIX. */
671 #ifndef HAVE_UNISTD_H
672 extern int getuid (), getgid (), geteuid (), getegid ();
673 extern int setuid (), setgid ();
674 #ifdef HAVE_SETEUID
675 extern int seteuid ();
676 #else
677 #ifdef HAVE_SETREUID
678 extern int setreuid ();
679 #endif /* Have setreuid. */
680 #endif /* Have seteuid. */
681 #ifdef HAVE_SETEGID
682 extern int setegid ();
683 #else
684 #ifdef HAVE_SETREGID
685 extern int setregid ();
686 #endif /* Have setregid. */
687 #endif /* Have setegid. */
688 #endif /* No <unistd.h>. */
690 /* Keep track of the user and group IDs for user- and make- access. */
691 static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
692 #define access_inited (user_uid != -1)
693 static enum { make, user } current_access;
696 /* Under -d, write a message describing the current IDs. */
698 static void
699 log_access (const char *flavor)
701 if (! ISDB (DB_JOBS))
702 return;
704 /* All the other debugging messages go to stdout,
705 but we write this one to stderr because it might be
706 run in a child fork whose stdout is piped. */
708 fprintf (stderr, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
709 flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
710 (unsigned long) getegid (), (unsigned long) getgid ());
711 fflush (stderr);
715 static void
716 init_access (void)
718 #ifndef VMS
719 user_uid = getuid ();
720 user_gid = getgid ();
722 make_uid = geteuid ();
723 make_gid = getegid ();
725 /* Do these ever fail? */
726 if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
727 pfatal_with_name ("get{e}[gu]id");
729 log_access (_("Initialized access"));
731 current_access = make;
732 #endif
735 #endif /* GETLOADAVG_PRIVILEGED */
737 /* Give the process appropriate permissions for access to
738 user data (i.e., to stat files, or to spawn a child process). */
739 void
740 user_access (void)
742 #ifdef GETLOADAVG_PRIVILEGED
744 if (!access_inited)
745 init_access ();
747 if (current_access == user)
748 return;
750 /* We are in "make access" mode. This means that the effective user and
751 group IDs are those of make (if it was installed setuid or setgid).
752 We now want to set the effective user and group IDs to the real IDs,
753 which are the IDs of the process that exec'd make. */
755 #ifdef HAVE_SETEUID
757 /* Modern systems have the seteuid/setegid calls which set only the
758 effective IDs, which is ideal. */
760 if (seteuid (user_uid) < 0)
761 pfatal_with_name ("user_access: seteuid");
763 #else /* Not HAVE_SETEUID. */
765 #ifndef HAVE_SETREUID
767 /* System V has only the setuid/setgid calls to set user/group IDs.
768 There is an effective ID, which can be set by setuid/setgid.
769 It can be set (unless you are root) only to either what it already is
770 (returned by geteuid/getegid, now in make_uid/make_gid),
771 the real ID (return by getuid/getgid, now in user_uid/user_gid),
772 or the saved set ID (what the effective ID was before this set-ID
773 executable (make) was exec'd). */
775 if (setuid (user_uid) < 0)
776 pfatal_with_name ("user_access: setuid");
778 #else /* HAVE_SETREUID. */
780 /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
781 They may be set to themselves or each other. So you have two alternatives
782 at any one time. If you use setuid/setgid, the effective will be set to
783 the real, leaving only one alternative. Using setreuid/setregid, however,
784 you can toggle between your two alternatives by swapping the values in a
785 single setreuid or setregid call. */
787 if (setreuid (make_uid, user_uid) < 0)
788 pfatal_with_name ("user_access: setreuid");
790 #endif /* Not HAVE_SETREUID. */
791 #endif /* HAVE_SETEUID. */
793 #ifdef HAVE_SETEGID
794 if (setegid (user_gid) < 0)
795 pfatal_with_name ("user_access: setegid");
796 #else
797 #ifndef HAVE_SETREGID
798 if (setgid (user_gid) < 0)
799 pfatal_with_name ("user_access: setgid");
800 #else
801 if (setregid (make_gid, user_gid) < 0)
802 pfatal_with_name ("user_access: setregid");
803 #endif
804 #endif
806 current_access = user;
808 log_access (_("User access"));
810 #endif /* GETLOADAVG_PRIVILEGED */
813 /* Give the process appropriate permissions for access to
814 make data (i.e., the load average). */
815 void
816 make_access (void)
818 #ifdef GETLOADAVG_PRIVILEGED
820 if (!access_inited)
821 init_access ();
823 if (current_access == make)
824 return;
826 /* See comments in user_access, above. */
828 #ifdef HAVE_SETEUID
829 if (seteuid (make_uid) < 0)
830 pfatal_with_name ("make_access: seteuid");
831 #else
832 #ifndef HAVE_SETREUID
833 if (setuid (make_uid) < 0)
834 pfatal_with_name ("make_access: setuid");
835 #else
836 if (setreuid (user_uid, make_uid) < 0)
837 pfatal_with_name ("make_access: setreuid");
838 #endif
839 #endif
841 #ifdef HAVE_SETEGID
842 if (setegid (make_gid) < 0)
843 pfatal_with_name ("make_access: setegid");
844 #else
845 #ifndef HAVE_SETREGID
846 if (setgid (make_gid) < 0)
847 pfatal_with_name ("make_access: setgid");
848 #else
849 if (setregid (user_gid, make_gid) < 0)
850 pfatal_with_name ("make_access: setregid");
851 #endif
852 #endif
854 current_access = make;
856 log_access (_("Make access"));
858 #endif /* GETLOADAVG_PRIVILEGED */
861 /* Give the process appropriate permissions for a child process.
862 This is like user_access, but you can't get back to make_access. */
863 void
864 child_access (void)
866 #ifdef GETLOADAVG_PRIVILEGED
868 if (!access_inited)
869 abort ();
871 /* Set both the real and effective UID and GID to the user's.
872 They cannot be changed back to make's. */
874 #ifndef HAVE_SETREUID
875 if (setuid (user_uid) < 0)
876 pfatal_with_name ("child_access: setuid");
877 #else
878 if (setreuid (user_uid, user_uid) < 0)
879 pfatal_with_name ("child_access: setreuid");
880 #endif
882 #ifndef HAVE_SETREGID
883 if (setgid (user_gid) < 0)
884 pfatal_with_name ("child_access: setgid");
885 #else
886 if (setregid (user_gid, user_gid) < 0)
887 pfatal_with_name ("child_access: setregid");
888 #endif
890 log_access (_("Child access"));
892 #endif /* GETLOADAVG_PRIVILEGED */
895 #ifdef NEED_GET_PATH_MAX
896 unsigned int
897 get_path_max (void)
899 static unsigned int value;
901 if (value == 0)
903 long int x = pathconf ("/", _PC_PATH_MAX);
904 if (x > 0)
905 value = x;
906 else
907 return MAXPATHLEN;
910 return value;
912 #endif
915 /* This code is stolen from gnulib.
916 If/when we abandon the requirement to work with K&R compilers, we can
917 remove this (and perhaps other parts of GNU make!) and migrate to using
918 gnulib directly.
920 This is called only through atexit(), which means die() has already been
921 invoked. So, call exit() here directly. Apparently that works...?
924 /* Close standard output, exiting with status 'exit_failure' on failure.
925 If a program writes *anything* to stdout, that program should close
926 stdout and make sure that it succeeds before exiting. Otherwise,
927 suppose that you go to the extreme of checking the return status
928 of every function that does an explicit write to stdout. The last
929 printf can succeed in writing to the internal stream buffer, and yet
930 the fclose(stdout) could still fail (due e.g., to a disk full error)
931 when it tries to write out that buffered data. Thus, you would be
932 left with an incomplete output file and the offending program would
933 exit successfully. Even calling fflush is not always sufficient,
934 since some file systems (NFS and CODA) buffer written/flushed data
935 until an actual close call.
937 Besides, it's wasteful to check the return value from every call
938 that writes to stdout -- just let the internal stream state record
939 the failure. That's what the ferror test is checking below.
941 It's important to detect such failures and exit nonzero because many
942 tools (most notably 'make' and other build-management systems) depend
943 on being able to detect failure in other tools via their exit status. */
945 void
946 close_stdout (void)
948 int prev_fail = ferror (stdout);
949 int fclose_fail = fclose (stdout);
951 if (prev_fail || fclose_fail)
953 if (fclose_fail)
954 error (NILF, _("write error: %s"), strerror (errno));
955 else
956 error (NILF, _("write error"));
957 exit (EXIT_FAILURE);