Forgot to add the ONESHELL regression tests.
[make.git] / main.c
blob61e30d000168bf1c08cdda4230e0f07110505137
1 /* Argument parsing and main program of GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free
4 Software Foundation, Inc.
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
10 version.
12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along with
17 this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "make.h"
20 #include "dep.h"
21 #include "filedef.h"
22 #include "variable.h"
23 #include "job.h"
24 #include "commands.h"
25 #include "rule.h"
26 #include "debug.h"
27 #include "getopt.h"
29 #include <assert.h>
30 #ifdef _AMIGA
31 # include <dos/dos.h>
32 # include <proto/dos.h>
33 #endif
34 #ifdef WINDOWS32
35 #include <windows.h>
36 #include <io.h>
37 #include "pathstuff.h"
38 #endif
39 #ifdef __EMX__
40 # include <sys/types.h>
41 # include <sys/wait.h>
42 #endif
43 #ifdef HAVE_FCNTL_H
44 # include <fcntl.h>
45 #endif
47 #ifdef _AMIGA
48 int __stack = 20000; /* Make sure we have 20K of stack space */
49 #endif
51 void init_dir (void);
52 void remote_setup (void);
53 void remote_cleanup (void);
54 RETSIGTYPE fatal_error_signal (int sig);
56 void print_variable_data_base (void);
57 void print_dir_data_base (void);
58 void print_rule_data_base (void);
59 void print_vpath_data_base (void);
61 void verify_file_data_base (void);
63 #if defined HAVE_WAITPID || defined HAVE_WAIT3
64 # define HAVE_WAIT_NOHANG
65 #endif
67 #ifndef HAVE_UNISTD_H
68 int chdir ();
69 #endif
70 #ifndef STDC_HEADERS
71 # ifndef sun /* Sun has an incorrect decl in a header. */
72 void exit (int) __attribute__ ((noreturn));
73 # endif
74 double atof ();
75 #endif
77 static void clean_jobserver (int status);
78 static void print_data_base (void);
79 static void print_version (void);
80 static void decode_switches (int argc, char **argv, int env);
81 static void decode_env_switches (char *envar, unsigned int len);
82 static const char *define_makeflags (int all, int makefile);
83 static char *quote_for_env (char *out, const char *in);
84 static void initialize_global_hash_tables (void);
87 /* The structure that describes an accepted command switch. */
89 struct command_switch
91 int c; /* The switch character. */
93 enum /* Type of the value. */
95 flag, /* Turn int flag on. */
96 flag_off, /* Turn int flag off. */
97 string, /* One string per switch. */
98 filename, /* A string containing a file name. */
99 positive_int, /* A positive integer. */
100 floating, /* A floating-point number (double). */
101 ignore /* Ignored. */
102 } type;
104 void *value_ptr; /* Pointer to the value-holding variable. */
106 unsigned int env:1; /* Can come from MAKEFLAGS. */
107 unsigned int toenv:1; /* Should be put in MAKEFLAGS. */
108 unsigned int no_makefile:1; /* Don't propagate when remaking makefiles. */
110 const void *noarg_value; /* Pointer to value used if no arg given. */
111 const void *default_value; /* Pointer to default value. */
113 char *long_name; /* Long option name. */
116 /* True if C is a switch value that corresponds to a short option. */
118 #define short_option(c) ((c) <= CHAR_MAX)
120 /* The structure used to hold the list of strings given
121 in command switches of a type that takes string arguments. */
123 struct stringlist
125 const char **list; /* Nil-terminated list of strings. */
126 unsigned int idx; /* Index into above. */
127 unsigned int max; /* Number of pointers allocated. */
131 /* The recognized command switches. */
133 /* Nonzero means do not print commands to be executed (-s). */
135 int silent_flag;
137 /* Nonzero means just touch the files
138 that would appear to need remaking (-t) */
140 int touch_flag;
142 /* Nonzero means just print what commands would need to be executed,
143 don't actually execute them (-n). */
145 int just_print_flag;
147 /* Print debugging info (--debug). */
149 static struct stringlist *db_flags;
150 static int debug_flag = 0;
152 int db_level = 0;
154 /* Output level (--verbosity). */
156 static struct stringlist *verbosity_flags;
158 #ifdef WINDOWS32
159 /* Suspend make in main for a short time to allow debugger to attach */
161 int suspend_flag = 0;
162 #endif
164 /* Environment variables override makefile definitions. */
166 int env_overrides = 0;
168 /* Nonzero means ignore status codes returned by commands
169 executed to remake files. Just treat them all as successful (-i). */
171 int ignore_errors_flag = 0;
173 /* Nonzero means don't remake anything, just print the data base
174 that results from reading the makefile (-p). */
176 int print_data_base_flag = 0;
178 /* Nonzero means don't remake anything; just return a nonzero status
179 if the specified targets are not up to date (-q). */
181 int question_flag = 0;
183 /* Nonzero means do not use any of the builtin rules (-r) / variables (-R). */
185 int no_builtin_rules_flag = 0;
186 int no_builtin_variables_flag = 0;
188 /* Nonzero means keep going even if remaking some file fails (-k). */
190 int keep_going_flag;
191 int default_keep_going_flag = 0;
193 /* Nonzero means check symlink mtimes. */
195 int check_symlink_flag = 0;
197 /* Nonzero means print directory before starting and when done (-w). */
199 int print_directory_flag = 0;
201 /* Nonzero means ignore print_directory_flag and never print the directory.
202 This is necessary because print_directory_flag is set implicitly. */
204 int inhibit_print_directory_flag = 0;
206 /* Nonzero means print version information. */
208 int print_version_flag = 0;
210 /* List of makefiles given with -f switches. */
212 static struct stringlist *makefiles = 0;
214 /* Size of the stack when we started. */
216 #ifdef SET_STACK_SIZE
217 struct rlimit stack_limit;
218 #endif
221 /* Number of job slots (commands that can be run at once). */
223 unsigned int job_slots = 1;
224 unsigned int default_job_slots = 1;
225 static unsigned int master_job_slots = 0;
227 /* Value of job_slots that means no limit. */
229 static unsigned int inf_jobs = 0;
231 /* File descriptors for the jobs pipe. */
233 static struct stringlist *jobserver_fds = 0;
235 int job_fds[2] = { -1, -1 };
236 int job_rfd = -1;
238 /* Maximum load average at which multiple jobs will be run.
239 Negative values mean unlimited, while zero means limit to
240 zero load (which could be useful to start infinite jobs remotely
241 but one at a time locally). */
242 #ifndef NO_FLOAT
243 double max_load_average = -1.0;
244 double default_load_average = -1.0;
245 #else
246 int max_load_average = -1;
247 int default_load_average = -1;
248 #endif
250 /* List of directories given with -C switches. */
252 static struct stringlist *directories = 0;
254 /* List of include directories given with -I switches. */
256 static struct stringlist *include_directories = 0;
258 /* List of files given with -o switches. */
260 static struct stringlist *old_files = 0;
262 /* List of files given with -W switches. */
264 static struct stringlist *new_files = 0;
266 /* List of strings to be eval'd. */
267 static struct stringlist *eval_strings = 0;
269 /* If nonzero, we should just print usage and exit. */
271 static int print_usage_flag = 0;
273 /* If nonzero, we should print a warning message
274 for each reference to an undefined variable. */
276 int warn_undefined_variables_flag;
278 /* If nonzero, always build all targets, regardless of whether
279 they appear out of date or not. */
281 static int always_make_set = 0;
282 int always_make_flag = 0;
284 /* If nonzero, we're in the "try to rebuild makefiles" phase. */
286 int rebuilding_makefiles = 0;
288 /* Remember the original value of the SHELL variable, from the environment. */
290 struct variable shell_var;
292 /* This character introduces a command: it's the first char on the line. */
294 char cmd_prefix = '\t';
297 /* The usage output. We write it this way to make life easier for the
298 translators, especially those trying to translate to right-to-left
299 languages like Hebrew. */
301 static const char *const usage[] =
303 N_("Options:\n"),
304 N_("\
305 -b, -m Ignored for compatibility.\n"),
306 N_("\
307 -B, --always-make Unconditionally make all targets.\n"),
308 N_("\
309 -C DIRECTORY, --directory=DIRECTORY\n\
310 Change to DIRECTORY before doing anything.\n"),
311 N_("\
312 -d Print lots of debugging information.\n"),
313 N_("\
314 --debug[=FLAGS] Print various types of debugging information.\n"),
315 N_("\
316 -e, --environment-overrides\n\
317 Environment variables override makefiles.\n"),
318 N_("\
319 --eval=STRING Evaluate STRING as a makefile statement.\n"),
320 N_("\
321 -f FILE, --file=FILE, --makefile=FILE\n\
322 Read FILE as a makefile.\n"),
323 N_("\
324 -h, --help Print this message and exit.\n"),
325 N_("\
326 -i, --ignore-errors Ignore errors from recipes.\n"),
327 N_("\
328 -I DIRECTORY, --include-dir=DIRECTORY\n\
329 Search DIRECTORY for included makefiles.\n"),
330 N_("\
331 -j [N], --jobs[=N] Allow N jobs at once; infinite jobs with no arg.\n"),
332 N_("\
333 -k, --keep-going Keep going when some targets can't be made.\n"),
334 N_("\
335 -l [N], --load-average[=N], --max-load[=N]\n\
336 Don't start multiple jobs unless load is below N.\n"),
337 N_("\
338 -L, --check-symlink-times Use the latest mtime between symlinks and target.\n"),
339 N_("\
340 -n, --just-print, --dry-run, --recon\n\
341 Don't actually run any recipe; just print them.\n"),
342 N_("\
343 -o FILE, --old-file=FILE, --assume-old=FILE\n\
344 Consider FILE to be very old and don't remake it.\n"),
345 N_("\
346 -p, --print-data-base Print make's internal database.\n"),
347 N_("\
348 -q, --question Run no recipe; exit status says if up to date.\n"),
349 N_("\
350 -r, --no-builtin-rules Disable the built-in implicit rules.\n"),
351 N_("\
352 -R, --no-builtin-variables Disable the built-in variable settings.\n"),
353 N_("\
354 -s, --silent, --quiet Don't echo recipes.\n"),
355 N_("\
356 -S, --no-keep-going, --stop\n\
357 Turns off -k.\n"),
358 N_("\
359 -t, --touch Touch targets instead of remaking them.\n"),
360 N_("\
361 -v, --version Print the version number of make and exit.\n"),
362 N_("\
363 -w, --print-directory Print the current directory.\n"),
364 N_("\
365 --no-print-directory Turn off -w, even if it was turned on implicitly.\n"),
366 N_("\
367 -W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE\n\
368 Consider FILE to be infinitely new.\n"),
369 N_("\
370 --warn-undefined-variables Warn when an undefined variable is referenced.\n"),
371 NULL
374 /* The table of command switches. */
376 static const struct command_switch switches[] =
378 { 'b', ignore, 0, 0, 0, 0, 0, 0, 0 },
379 { 'B', flag, &always_make_set, 1, 1, 0, 0, 0, "always-make" },
380 { 'C', filename, &directories, 0, 0, 0, 0, 0, "directory" },
381 { 'd', flag, &debug_flag, 1, 1, 0, 0, 0, 0 },
382 { CHAR_MAX+1, string, &db_flags, 1, 1, 0, "basic", 0, "debug" },
383 #ifdef WINDOWS32
384 { 'D', flag, &suspend_flag, 1, 1, 0, 0, 0, "suspend-for-debug" },
385 #endif
386 { 'e', flag, &env_overrides, 1, 1, 0, 0, 0, "environment-overrides", },
387 { 'f', filename, &makefiles, 0, 0, 0, 0, 0, "file" },
388 { 'h', flag, &print_usage_flag, 0, 0, 0, 0, 0, "help" },
389 { 'i', flag, &ignore_errors_flag, 1, 1, 0, 0, 0, "ignore-errors" },
390 { 'I', filename, &include_directories, 1, 1, 0, 0, 0,
391 "include-dir" },
392 { 'j', positive_int, &job_slots, 1, 1, 0, &inf_jobs, &default_job_slots,
393 "jobs" },
394 { CHAR_MAX+2, string, &jobserver_fds, 1, 1, 0, 0, 0, "jobserver-fds" },
395 { 'k', flag, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
396 "keep-going" },
397 #ifndef NO_FLOAT
398 { 'l', floating, &max_load_average, 1, 1, 0, &default_load_average,
399 &default_load_average, "load-average" },
400 #else
401 { 'l', positive_int, &max_load_average, 1, 1, 0, &default_load_average,
402 &default_load_average, "load-average" },
403 #endif
404 { 'L', flag, &check_symlink_flag, 1, 1, 0, 0, 0, "check-symlink-times" },
405 { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },
406 { 'n', flag, &just_print_flag, 1, 1, 1, 0, 0, "just-print" },
407 { 'o', filename, &old_files, 0, 0, 0, 0, 0, "old-file" },
408 { 'p', flag, &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base" },
409 { 'q', flag, &question_flag, 1, 1, 1, 0, 0, "question" },
410 { 'r', flag, &no_builtin_rules_flag, 1, 1, 0, 0, 0, "no-builtin-rules" },
411 { 'R', flag, &no_builtin_variables_flag, 1, 1, 0, 0, 0,
412 "no-builtin-variables" },
413 { 's', flag, &silent_flag, 1, 1, 0, 0, 0, "silent" },
414 { 'S', flag_off, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
415 "no-keep-going" },
416 { 't', flag, &touch_flag, 1, 1, 1, 0, 0, "touch" },
417 { 'v', flag, &print_version_flag, 1, 1, 0, 0, 0, "version" },
418 { CHAR_MAX+3, string, &verbosity_flags, 1, 1, 0, 0, 0,
419 "verbosity" },
420 { 'w', flag, &print_directory_flag, 1, 1, 0, 0, 0, "print-directory" },
421 { CHAR_MAX+4, flag, &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
422 "no-print-directory" },
423 { 'W', filename, &new_files, 0, 0, 0, 0, 0, "what-if" },
424 { CHAR_MAX+5, flag, &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
425 "warn-undefined-variables" },
426 { CHAR_MAX+6, string, &eval_strings, 1, 0, 0, 0, 0, "eval" },
427 { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
430 /* Secondary long names for options. */
432 static struct option long_option_aliases[] =
434 { "quiet", no_argument, 0, 's' },
435 { "stop", no_argument, 0, 'S' },
436 { "new-file", required_argument, 0, 'W' },
437 { "assume-new", required_argument, 0, 'W' },
438 { "assume-old", required_argument, 0, 'o' },
439 { "max-load", optional_argument, 0, 'l' },
440 { "dry-run", no_argument, 0, 'n' },
441 { "recon", no_argument, 0, 'n' },
442 { "makefile", required_argument, 0, 'f' },
445 /* List of goal targets. */
447 static struct dep *goals, *lastgoal;
449 /* List of variables which were defined on the command line
450 (or, equivalently, in MAKEFLAGS). */
452 struct command_variable
454 struct command_variable *next;
455 struct variable *variable;
457 static struct command_variable *command_variables;
459 /* The name we were invoked with. */
461 char *program;
463 /* Our current directory before processing any -C options. */
465 char *directory_before_chdir;
467 /* Our current directory after processing all -C options. */
469 char *starting_directory;
471 /* Value of the MAKELEVEL variable at startup (or 0). */
473 unsigned int makelevel;
475 /* Pointer to the value of the .DEFAULT_GOAL special variable.
476 The value will be the name of the goal to remake if the command line
477 does not override it. It can be set by the makefile, or else it's
478 the first target defined in the makefile whose name does not start
479 with '.'. */
481 struct variable * default_goal_var;
483 /* Pointer to structure for the file .DEFAULT
484 whose commands are used for any file that has none of its own.
485 This is zero if the makefiles do not define .DEFAULT. */
487 struct file *default_file;
489 /* Nonzero if we have seen the magic `.POSIX' target.
490 This turns on pedantic compliance with POSIX.2. */
492 int posix_pedantic;
494 /* Nonzero if we have seen the '.SECONDEXPANSION' target.
495 This turns on secondary expansion of prerequisites. */
497 int second_expansion;
499 /* Nonzero if we have seen the '.ONESHELL' target.
500 This causes the entire recipe to be handed to SHELL
501 as a single string, potentially containing newlines. */
503 int one_shell;
505 /* Nonzero if we have seen the `.NOTPARALLEL' target.
506 This turns off parallel builds for this invocation of make. */
508 int not_parallel;
510 /* Nonzero if some rule detected clock skew; we keep track so (a) we only
511 print one warning about it during the run, and (b) we can print a final
512 warning at the end of the run. */
514 int clock_skew_detected;
516 /* Mask of signals that are being caught with fatal_error_signal. */
518 #ifdef POSIX
519 sigset_t fatal_signal_set;
520 #else
521 # ifdef HAVE_SIGSETMASK
522 int fatal_signal_mask;
523 # endif
524 #endif
526 #if !defined HAVE_BSD_SIGNAL && !defined bsd_signal
527 # if !defined HAVE_SIGACTION
528 # define bsd_signal signal
529 # else
530 typedef RETSIGTYPE (*bsd_signal_ret_t) (int);
532 static bsd_signal_ret_t
533 bsd_signal (int sig, bsd_signal_ret_t func)
535 struct sigaction act, oact;
536 act.sa_handler = func;
537 act.sa_flags = SA_RESTART;
538 sigemptyset (&act.sa_mask);
539 sigaddset (&act.sa_mask, sig);
540 if (sigaction (sig, &act, &oact) != 0)
541 return SIG_ERR;
542 return oact.sa_handler;
544 # endif
545 #endif
547 static void
548 initialize_global_hash_tables (void)
550 init_hash_global_variable_set ();
551 strcache_init ();
552 init_hash_files ();
553 hash_init_directories ();
554 hash_init_function_table ();
557 static const char *
558 expand_command_line_file (char *name)
560 const char *cp;
561 char *expanded = 0;
563 if (name[0] == '\0')
564 fatal (NILF, _("empty string invalid as file name"));
566 if (name[0] == '~')
568 expanded = tilde_expand (name);
569 if (expanded != 0)
570 name = expanded;
573 /* This is also done in parse_file_seq, so this is redundant
574 for names read from makefiles. It is here for names passed
575 on the command line. */
576 while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
578 name += 2;
579 while (*name == '/')
580 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
581 ++name;
584 if (*name == '\0')
586 /* It was all slashes! Move back to the dot and truncate
587 it after the first slash, so it becomes just "./". */
589 --name;
590 while (name[0] != '.');
591 name[2] = '\0';
594 cp = strcache_add (name);
596 if (expanded)
597 free (expanded);
599 return cp;
602 /* Toggle -d on receipt of SIGUSR1. */
604 #ifdef SIGUSR1
605 static RETSIGTYPE
606 debug_signal_handler (int sig UNUSED)
608 db_level = db_level ? DB_NONE : DB_BASIC;
610 #endif
612 static void
613 decode_debug_flags (void)
615 const char **pp;
617 if (debug_flag)
618 db_level = DB_ALL;
620 if (!db_flags)
621 return;
623 for (pp=db_flags->list; *pp; ++pp)
625 const char *p = *pp;
627 while (1)
629 switch (tolower (p[0]))
631 case 'a':
632 db_level |= DB_ALL;
633 break;
634 case 'b':
635 db_level |= DB_BASIC;
636 break;
637 case 'i':
638 db_level |= DB_BASIC | DB_IMPLICIT;
639 break;
640 case 'j':
641 db_level |= DB_JOBS;
642 break;
643 case 'm':
644 db_level |= DB_BASIC | DB_MAKEFILES;
645 break;
646 case 'v':
647 db_level |= DB_BASIC | DB_VERBOSE;
648 break;
649 default:
650 fatal (NILF, _("unknown debug level specification `%s'"), p);
653 while (*(++p) != '\0')
654 if (*p == ',' || *p == ' ')
655 break;
657 if (*p == '\0')
658 break;
660 ++p;
665 #ifdef WINDOWS32
667 * HANDLE runtime exceptions by avoiding a requestor on the GUI. Capture
668 * exception and print it to stderr instead.
670 * If ! DB_VERBOSE, just print a simple message and exit.
671 * If DB_VERBOSE, print a more verbose message.
672 * If compiled for DEBUG, let exception pass through to GUI so that
673 * debuggers can attach.
675 LONG WINAPI
676 handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
678 PEXCEPTION_RECORD exrec = exinfo->ExceptionRecord;
679 LPSTR cmdline = GetCommandLine();
680 LPSTR prg = strtok(cmdline, " ");
681 CHAR errmsg[1024];
682 #ifdef USE_EVENT_LOG
683 HANDLE hEventSource;
684 LPTSTR lpszStrings[1];
685 #endif
687 if (! ISDB (DB_VERBOSE))
689 sprintf(errmsg,
690 _("%s: Interrupt/Exception caught (code = 0x%lx, addr = 0x%p)\n"),
691 prg, exrec->ExceptionCode, exrec->ExceptionAddress);
692 fprintf(stderr, errmsg);
693 exit(255);
696 sprintf(errmsg,
697 _("\nUnhandled exception filter called from program %s\nExceptionCode = %lx\nExceptionFlags = %lx\nExceptionAddress = 0x%p\n"),
698 prg, exrec->ExceptionCode, exrec->ExceptionFlags,
699 exrec->ExceptionAddress);
701 if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION
702 && exrec->NumberParameters >= 2)
703 sprintf(&errmsg[strlen(errmsg)],
704 (exrec->ExceptionInformation[0]
705 ? _("Access violation: write operation at address 0x%p\n")
706 : _("Access violation: read operation at address 0x%p\n")),
707 (PVOID)exrec->ExceptionInformation[1]);
709 /* turn this on if we want to put stuff in the event log too */
710 #ifdef USE_EVENT_LOG
711 hEventSource = RegisterEventSource(NULL, "GNU Make");
712 lpszStrings[0] = errmsg;
714 if (hEventSource != NULL)
716 ReportEvent(hEventSource, /* handle of event source */
717 EVENTLOG_ERROR_TYPE, /* event type */
718 0, /* event category */
719 0, /* event ID */
720 NULL, /* current user's SID */
721 1, /* strings in lpszStrings */
722 0, /* no bytes of raw data */
723 lpszStrings, /* array of error strings */
724 NULL); /* no raw data */
726 (VOID) DeregisterEventSource(hEventSource);
728 #endif
730 /* Write the error to stderr too */
731 fprintf(stderr, errmsg);
733 #ifdef DEBUG
734 return EXCEPTION_CONTINUE_SEARCH;
735 #else
736 exit(255);
737 return (255); /* not reached */
738 #endif
742 * On WIN32 systems we don't have the luxury of a /bin directory that
743 * is mapped globally to every drive mounted to the system. Since make could
744 * be invoked from any drive, and we don't want to propogate /bin/sh
745 * to every single drive. Allow ourselves a chance to search for
746 * a value for default shell here (if the default path does not exist).
750 find_and_set_default_shell (const char *token)
752 int sh_found = 0;
753 char *atoken = 0;
754 char *search_token;
755 char *tokend;
756 PATH_VAR(sh_path);
757 extern char *default_shell;
759 if (!token)
760 search_token = default_shell;
761 else
762 atoken = search_token = xstrdup (token);
764 /* If the user explicitly requests the DOS cmd shell, obey that request.
765 However, make sure that's what they really want by requiring the value
766 of SHELL either equal, or have a final path element of, "cmd" or
767 "cmd.exe" case-insensitive. */
768 tokend = search_token + strlen (search_token) - 3;
769 if (((tokend == search_token
770 || (tokend > search_token
771 && (tokend[-1] == '/' || tokend[-1] == '\\')))
772 && !strcasecmp (tokend, "cmd"))
773 || ((tokend - 4 == search_token
774 || (tokend - 4 > search_token
775 && (tokend[-5] == '/' || tokend[-5] == '\\')))
776 && !strcasecmp (tokend - 4, "cmd.exe"))) {
777 batch_mode_shell = 1;
778 unixy_shell = 0;
779 sprintf (sh_path, "%s", search_token);
780 default_shell = xstrdup (w32ify (sh_path, 0));
781 DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
782 default_shell));
783 sh_found = 1;
784 } else if (!no_default_sh_exe &&
785 (token == NULL || !strcmp (search_token, default_shell))) {
786 /* no new information, path already set or known */
787 sh_found = 1;
788 } else if (file_exists_p (search_token)) {
789 /* search token path was found */
790 sprintf (sh_path, "%s", search_token);
791 default_shell = xstrdup (w32ify (sh_path, 0));
792 DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
793 default_shell));
794 sh_found = 1;
795 } else {
796 char *p;
797 struct variable *v = lookup_variable (STRING_SIZE_TUPLE ("PATH"));
799 /* Search Path for shell */
800 if (v && v->value) {
801 char *ep;
803 p = v->value;
804 ep = strchr (p, PATH_SEPARATOR_CHAR);
806 while (ep && *ep) {
807 *ep = '\0';
809 if (dir_file_exists_p (p, search_token)) {
810 sprintf (sh_path, "%s/%s", p, search_token);
811 default_shell = xstrdup (w32ify (sh_path, 0));
812 sh_found = 1;
813 *ep = PATH_SEPARATOR_CHAR;
815 /* terminate loop */
816 p += strlen (p);
817 } else {
818 *ep = PATH_SEPARATOR_CHAR;
819 p = ++ep;
822 ep = strchr (p, PATH_SEPARATOR_CHAR);
825 /* be sure to check last element of Path */
826 if (p && *p && dir_file_exists_p (p, search_token)) {
827 sprintf (sh_path, "%s/%s", p, search_token);
828 default_shell = xstrdup (w32ify (sh_path, 0));
829 sh_found = 1;
832 if (sh_found)
833 DB (DB_VERBOSE,
834 (_("find_and_set_shell() path search set default_shell = %s\n"),
835 default_shell));
839 /* naive test */
840 if (!unixy_shell && sh_found &&
841 (strstr (default_shell, "sh") || strstr (default_shell, "SH"))) {
842 unixy_shell = 1;
843 batch_mode_shell = 0;
846 #ifdef BATCH_MODE_ONLY_SHELL
847 batch_mode_shell = 1;
848 #endif
850 if (atoken)
851 free (atoken);
853 return (sh_found);
855 #endif /* WINDOWS32 */
857 #ifdef __MSDOS__
858 static void
859 msdos_return_to_initial_directory (void)
861 if (directory_before_chdir)
862 chdir (directory_before_chdir);
864 #endif /* __MSDOS__ */
866 char *mktemp (char *template);
867 int mkstemp (char *template);
869 FILE *
870 open_tmpfile(char **name, const char *template)
872 #ifdef HAVE_FDOPEN
873 int fd;
874 #endif
876 #if defined HAVE_MKSTEMP || defined HAVE_MKTEMP
877 # define TEMPLATE_LEN strlen (template)
878 #else
879 # define TEMPLATE_LEN L_tmpnam
880 #endif
881 *name = xmalloc (TEMPLATE_LEN + 1);
882 strcpy (*name, template);
884 #if defined HAVE_MKSTEMP && defined HAVE_FDOPEN
885 /* It's safest to use mkstemp(), if we can. */
886 fd = mkstemp (*name);
887 if (fd == -1)
888 return 0;
889 return fdopen (fd, "w");
890 #else
891 # ifdef HAVE_MKTEMP
892 (void) mktemp (*name);
893 # else
894 (void) tmpnam (*name);
895 # endif
897 # ifdef HAVE_FDOPEN
898 /* Can't use mkstemp(), but guard against a race condition. */
899 fd = open (*name, O_CREAT|O_EXCL|O_WRONLY, 0600);
900 if (fd == -1)
901 return 0;
902 return fdopen (fd, "w");
903 # else
904 /* Not secure, but what can we do? */
905 return fopen (*name, "w");
906 # endif
907 #endif
911 #ifdef _AMIGA
913 main (int argc, char **argv)
914 #else
916 main (int argc, char **argv, char **envp)
917 #endif
919 static char *stdin_nm = 0;
920 int makefile_status = MAKE_SUCCESS;
921 struct dep *read_makefiles;
922 PATH_VAR (current_directory);
923 unsigned int restarts = 0;
924 #ifdef WINDOWS32
925 char *unix_path = NULL;
926 char *windows32_path = NULL;
928 SetUnhandledExceptionFilter(handle_runtime_exceptions);
930 /* start off assuming we have no shell */
931 unixy_shell = 0;
932 no_default_sh_exe = 1;
933 #endif
935 #ifdef SET_STACK_SIZE
936 /* Get rid of any avoidable limit on stack size. */
938 struct rlimit rlim;
940 /* Set the stack limit huge so that alloca does not fail. */
941 if (getrlimit (RLIMIT_STACK, &rlim) == 0
942 && rlim.rlim_cur > 0 && rlim.rlim_cur < rlim.rlim_max)
944 stack_limit = rlim;
945 rlim.rlim_cur = rlim.rlim_max;
946 setrlimit (RLIMIT_STACK, &rlim);
948 else
949 stack_limit.rlim_cur = 0;
951 #endif
953 #ifdef HAVE_ATEXIT
954 atexit (close_stdout);
955 #endif
957 /* Needed for OS/2 */
958 initialize_main(&argc, &argv);
960 reading_file = 0;
962 #if defined (__MSDOS__) && !defined (_POSIX_SOURCE)
963 /* Request the most powerful version of `system', to
964 make up for the dumb default shell. */
965 __system_flags = (__system_redirect
966 | __system_use_shell
967 | __system_allow_multiple_cmds
968 | __system_allow_long_cmds
969 | __system_handle_null_commands
970 | __system_emulate_chdir);
972 #endif
974 /* Set up gettext/internationalization support. */
975 setlocale (LC_ALL, "");
976 /* The cast to void shuts up compiler warnings on systems that
977 disable NLS. */
978 (void)bindtextdomain (PACKAGE, LOCALEDIR);
979 (void)textdomain (PACKAGE);
981 #ifdef POSIX
982 sigemptyset (&fatal_signal_set);
983 #define ADD_SIG(sig) sigaddset (&fatal_signal_set, sig)
984 #else
985 #ifdef HAVE_SIGSETMASK
986 fatal_signal_mask = 0;
987 #define ADD_SIG(sig) fatal_signal_mask |= sigmask (sig)
988 #else
989 #define ADD_SIG(sig)
990 #endif
991 #endif
993 #define FATAL_SIG(sig) \
994 if (bsd_signal (sig, fatal_error_signal) == SIG_IGN) \
995 bsd_signal (sig, SIG_IGN); \
996 else \
997 ADD_SIG (sig);
999 #ifdef SIGHUP
1000 FATAL_SIG (SIGHUP);
1001 #endif
1002 #ifdef SIGQUIT
1003 FATAL_SIG (SIGQUIT);
1004 #endif
1005 FATAL_SIG (SIGINT);
1006 FATAL_SIG (SIGTERM);
1008 #ifdef __MSDOS__
1009 /* Windows 9X delivers FP exceptions in child programs to their
1010 parent! We don't want Make to die when a child divides by zero,
1011 so we work around that lossage by catching SIGFPE. */
1012 FATAL_SIG (SIGFPE);
1013 #endif
1015 #ifdef SIGDANGER
1016 FATAL_SIG (SIGDANGER);
1017 #endif
1018 #ifdef SIGXCPU
1019 FATAL_SIG (SIGXCPU);
1020 #endif
1021 #ifdef SIGXFSZ
1022 FATAL_SIG (SIGXFSZ);
1023 #endif
1025 #undef FATAL_SIG
1027 /* Do not ignore the child-death signal. This must be done before
1028 any children could possibly be created; otherwise, the wait
1029 functions won't work on systems with the SVR4 ECHILD brain
1030 damage, if our invoker is ignoring this signal. */
1032 #ifdef HAVE_WAIT_NOHANG
1033 # if defined SIGCHLD
1034 (void) bsd_signal (SIGCHLD, SIG_DFL);
1035 # endif
1036 # if defined SIGCLD && SIGCLD != SIGCHLD
1037 (void) bsd_signal (SIGCLD, SIG_DFL);
1038 # endif
1039 #endif
1041 /* Make sure stdout is line-buffered. */
1043 #ifdef HAVE_SETVBUF
1044 # ifdef SETVBUF_REVERSED
1045 setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ);
1046 # else /* setvbuf not reversed. */
1047 /* Some buggy systems lose if we pass 0 instead of allocating ourselves. */
1048 setvbuf (stdout, 0, _IOLBF, BUFSIZ);
1049 # endif /* setvbuf reversed. */
1050 #elif HAVE_SETLINEBUF
1051 setlinebuf (stdout);
1052 #endif /* setlinebuf missing. */
1054 /* Figure out where this program lives. */
1056 if (argv[0] == 0)
1057 argv[0] = "";
1058 if (argv[0][0] == '\0')
1059 program = "make";
1060 else
1062 #ifdef VMS
1063 program = strrchr (argv[0], ']');
1064 #else
1065 program = strrchr (argv[0], '/');
1066 #endif
1067 #if defined(__MSDOS__) || defined(__EMX__)
1068 if (program == 0)
1069 program = strrchr (argv[0], '\\');
1070 else
1072 /* Some weird environments might pass us argv[0] with
1073 both kinds of slashes; we must find the rightmost. */
1074 char *p = strrchr (argv[0], '\\');
1075 if (p && p > program)
1076 program = p;
1078 if (program == 0 && argv[0][1] == ':')
1079 program = argv[0] + 1;
1080 #endif
1081 #ifdef WINDOWS32
1082 if (program == 0)
1084 /* Extract program from full path */
1085 int argv0_len;
1086 program = strrchr (argv[0], '\\');
1087 if (program)
1089 argv0_len = strlen(program);
1090 if (argv0_len > 4 && streq (&program[argv0_len - 4], ".exe"))
1091 /* Remove .exe extension */
1092 program[argv0_len - 4] = '\0';
1095 #endif
1096 if (program == 0)
1097 program = argv[0];
1098 else
1099 ++program;
1102 /* Set up to access user data (files). */
1103 user_access ();
1105 initialize_global_hash_tables ();
1107 /* Figure out where we are. */
1109 #ifdef WINDOWS32
1110 if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1111 #else
1112 if (getcwd (current_directory, GET_PATH_MAX) == 0)
1113 #endif
1115 #ifdef HAVE_GETCWD
1116 perror_with_name ("getcwd", "");
1117 #else
1118 error (NILF, "getwd: %s", current_directory);
1119 #endif
1120 current_directory[0] = '\0';
1121 directory_before_chdir = 0;
1123 else
1124 directory_before_chdir = xstrdup (current_directory);
1125 #ifdef __MSDOS__
1126 /* Make sure we will return to the initial directory, come what may. */
1127 atexit (msdos_return_to_initial_directory);
1128 #endif
1130 /* Initialize the special variables. */
1131 define_variable_cname (".VARIABLES", "", o_default, 0)->special = 1;
1132 /* define_variable_cname (".TARGETS", "", o_default, 0)->special = 1; */
1133 define_variable_cname (".RECIPEPREFIX", "", o_default, 0)->special = 1;
1134 define_variable_cname (".SHELLFLAGS", "-c", o_default, 0);
1136 /* Set up .FEATURES
1137 We must do this in multiple calls because define_variable_cname() is
1138 a macro and some compilers (MSVC) don't like conditionals in macros. */
1140 const char *features = "target-specific order-only second-expansion"
1141 " else-if shortest-stem undefine"
1142 #ifndef NO_ARCHIVES
1143 " archives"
1144 #endif
1145 #ifdef MAKE_JOBSERVER
1146 " jobserver"
1147 #endif
1148 #ifdef MAKE_SYMLINKS
1149 " check-symlink"
1150 #endif
1153 define_variable_cname (".FEATURES", features, o_default, 0);
1156 /* Read in variables from the environment. It is important that this be
1157 done before $(MAKE) is figured out so its definitions will not be
1158 from the environment. */
1160 #ifndef _AMIGA
1162 unsigned int i;
1164 for (i = 0; envp[i] != 0; ++i)
1166 int do_not_define = 0;
1167 char *ep = envp[i];
1169 while (*ep != '\0' && *ep != '=')
1170 ++ep;
1171 #ifdef WINDOWS32
1172 if (!unix_path && strneq(envp[i], "PATH=", 5))
1173 unix_path = ep+1;
1174 else if (!strnicmp(envp[i], "Path=", 5)) {
1175 do_not_define = 1; /* it gets defined after loop exits */
1176 if (!windows32_path)
1177 windows32_path = ep+1;
1179 #endif
1180 /* The result of pointer arithmetic is cast to unsigned int for
1181 machines where ptrdiff_t is a different size that doesn't widen
1182 the same. */
1183 if (!do_not_define)
1185 struct variable *v;
1187 v = define_variable (envp[i], (unsigned int) (ep - envp[i]),
1188 ep + 1, o_env, 1);
1189 /* Force exportation of every variable culled from the
1190 environment. We used to rely on target_environment's
1191 v_default code to do this. But that does not work for the
1192 case where an environment variable is redefined in a makefile
1193 with `override'; it should then still be exported, because it
1194 was originally in the environment. */
1195 v->export = v_export;
1197 /* Another wrinkle is that POSIX says the value of SHELL set in
1198 the makefile won't change the value of SHELL given to
1199 subprocesses. */
1200 if (streq (v->name, "SHELL"))
1202 #ifndef __MSDOS__
1203 v->export = v_noexport;
1204 #endif
1205 shell_var.name = "SHELL";
1206 shell_var.length = 5;
1207 shell_var.value = xstrdup (ep + 1);
1210 /* If MAKE_RESTARTS is set, remember it but don't export it. */
1211 if (streq (v->name, "MAKE_RESTARTS"))
1213 v->export = v_noexport;
1214 restarts = (unsigned int) atoi (ep + 1);
1219 #ifdef WINDOWS32
1220 /* If we didn't find a correctly spelled PATH we define PATH as
1221 * either the first mispelled value or an empty string
1223 if (!unix_path)
1224 define_variable_cname ("PATH", windows32_path ? windows32_path : "",
1225 o_env, 1)->export = v_export;
1226 #endif
1227 #else /* For Amiga, read the ENV: device, ignoring all dirs */
1229 BPTR env, file, old;
1230 char buffer[1024];
1231 int len;
1232 __aligned struct FileInfoBlock fib;
1234 env = Lock ("ENV:", ACCESS_READ);
1235 if (env)
1237 old = CurrentDir (DupLock(env));
1238 Examine (env, &fib);
1240 while (ExNext (env, &fib))
1242 if (fib.fib_DirEntryType < 0) /* File */
1244 /* Define an empty variable. It will be filled in
1245 variable_lookup(). Makes startup quite a bit
1246 faster. */
1247 define_variable (fib.fib_FileName,
1248 strlen (fib.fib_FileName),
1249 "", o_env, 1)->export = v_export;
1252 UnLock (env);
1253 UnLock(CurrentDir(old));
1256 #endif
1258 /* Decode the switches. */
1260 decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
1261 #if 0
1262 /* People write things like:
1263 MFLAGS="CC=gcc -pipe" "CFLAGS=-g"
1264 and we set the -p, -i and -e switches. Doesn't seem quite right. */
1265 decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
1266 #endif
1268 decode_switches (argc, argv, 0);
1270 #ifdef WINDOWS32
1271 if (suspend_flag) {
1272 fprintf(stderr, "%s (pid = %ld)\n", argv[0], GetCurrentProcessId());
1273 fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]);
1274 Sleep(30 * 1000);
1275 fprintf(stderr, _("done sleep(30). Continuing.\n"));
1277 #endif
1279 decode_debug_flags ();
1281 /* Set always_make_flag if -B was given and we've not restarted already. */
1282 always_make_flag = always_make_set && (restarts == 0);
1284 /* Print version information. */
1285 if (print_version_flag || print_data_base_flag || db_level)
1287 print_version ();
1289 /* `make --version' is supposed to just print the version and exit. */
1290 if (print_version_flag)
1291 die (0);
1294 #ifndef VMS
1295 /* Set the "MAKE_COMMAND" variable to the name we were invoked with.
1296 (If it is a relative pathname with a slash, prepend our directory name
1297 so the result will run the same program regardless of the current dir.
1298 If it is a name with no slash, we can only hope that PATH did not
1299 find it in the current directory.) */
1300 #ifdef WINDOWS32
1302 * Convert from backslashes to forward slashes for
1303 * programs like sh which don't like them. Shouldn't
1304 * matter if the path is one way or the other for
1305 * CreateProcess().
1307 if (strpbrk(argv[0], "/:\\") ||
1308 strstr(argv[0], "..") ||
1309 strneq(argv[0], "//", 2))
1310 argv[0] = xstrdup(w32ify(argv[0],1));
1311 #else /* WINDOWS32 */
1312 #if defined (__MSDOS__) || defined (__EMX__)
1313 if (strchr (argv[0], '\\'))
1315 char *p;
1317 argv[0] = xstrdup (argv[0]);
1318 for (p = argv[0]; *p; p++)
1319 if (*p == '\\')
1320 *p = '/';
1322 /* If argv[0] is not in absolute form, prepend the current
1323 directory. This can happen when Make is invoked by another DJGPP
1324 program that uses a non-absolute name. */
1325 if (current_directory[0] != '\0'
1326 && argv[0] != 0
1327 && (argv[0][0] != '/' && (argv[0][0] == '\0' || argv[0][1] != ':'))
1328 # ifdef __EMX__
1329 /* do not prepend cwd if argv[0] contains no '/', e.g. "make" */
1330 && (strchr (argv[0], '/') != 0 || strchr (argv[0], '\\') != 0)
1331 # endif
1333 argv[0] = xstrdup (concat (3, current_directory, "/", argv[0]));
1334 #else /* !__MSDOS__ */
1335 if (current_directory[0] != '\0'
1336 && argv[0] != 0 && argv[0][0] != '/' && strchr (argv[0], '/') != 0
1337 #ifdef HAVE_DOS_PATHS
1338 && (argv[0][0] != '\\' && (!argv[0][0] || argv[0][1] != ':'))
1339 && strchr (argv[0], '\\') != 0
1340 #endif
1342 argv[0] = xstrdup (concat (3, current_directory, "/", argv[0]));
1343 #endif /* !__MSDOS__ */
1344 #endif /* WINDOWS32 */
1345 #endif
1347 /* The extra indirection through $(MAKE_COMMAND) is done
1348 for hysterical raisins. */
1349 define_variable_cname ("MAKE_COMMAND", argv[0], o_default, 0);
1350 define_variable_cname ("MAKE", "$(MAKE_COMMAND)", o_default, 1);
1352 if (command_variables != 0)
1354 struct command_variable *cv;
1355 struct variable *v;
1356 unsigned int len = 0;
1357 char *value, *p;
1359 /* Figure out how much space will be taken up by the command-line
1360 variable definitions. */
1361 for (cv = command_variables; cv != 0; cv = cv->next)
1363 v = cv->variable;
1364 len += 2 * strlen (v->name);
1365 if (! v->recursive)
1366 ++len;
1367 ++len;
1368 len += 2 * strlen (v->value);
1369 ++len;
1372 /* Now allocate a buffer big enough and fill it. */
1373 p = value = alloca (len);
1374 for (cv = command_variables; cv != 0; cv = cv->next)
1376 v = cv->variable;
1377 p = quote_for_env (p, v->name);
1378 if (! v->recursive)
1379 *p++ = ':';
1380 *p++ = '=';
1381 p = quote_for_env (p, v->value);
1382 *p++ = ' ';
1384 p[-1] = '\0'; /* Kill the final space and terminate. */
1386 /* Define an unchangeable variable with a name that no POSIX.2
1387 makefile could validly use for its own variable. */
1388 define_variable_cname ("-*-command-variables-*-", value, o_automatic, 0);
1390 /* Define the variable; this will not override any user definition.
1391 Normally a reference to this variable is written into the value of
1392 MAKEFLAGS, allowing the user to override this value to affect the
1393 exported value of MAKEFLAGS. In POSIX-pedantic mode, we cannot
1394 allow the user's setting of MAKEOVERRIDES to affect MAKEFLAGS, so
1395 a reference to this hidden variable is written instead. */
1396 define_variable_cname ("MAKEOVERRIDES", "${-*-command-variables-*-}",
1397 o_env, 1);
1400 /* If there were -C flags, move ourselves about. */
1401 if (directories != 0)
1403 unsigned int i;
1404 for (i = 0; directories->list[i] != 0; ++i)
1406 const char *dir = directories->list[i];
1407 #ifdef WINDOWS32
1408 /* WINDOWS32 chdir() doesn't work if the directory has a trailing '/'
1409 But allow -C/ just in case someone wants that. */
1411 char *p = (char *)dir + strlen (dir) - 1;
1412 while (p > dir && (p[0] == '/' || p[0] == '\\'))
1413 --p;
1414 p[1] = '\0';
1416 #endif
1417 if (chdir (dir) < 0)
1418 pfatal_with_name (dir);
1422 #ifdef WINDOWS32
1424 * THIS BLOCK OF CODE MUST COME AFTER chdir() CALL ABOVE IN ORDER
1425 * TO NOT CONFUSE THE DEPENDENCY CHECKING CODE IN implicit.c.
1427 * The functions in dir.c can incorrectly cache information for "."
1428 * before we have changed directory and this can cause file
1429 * lookups to fail because the current directory (.) was pointing
1430 * at the wrong place when it was first evaluated.
1432 no_default_sh_exe = !find_and_set_default_shell(NULL);
1434 #endif /* WINDOWS32 */
1435 /* Figure out the level of recursion. */
1437 struct variable *v = lookup_variable (STRING_SIZE_TUPLE (MAKELEVEL_NAME));
1438 if (v != 0 && v->value[0] != '\0' && v->value[0] != '-')
1439 makelevel = (unsigned int) atoi (v->value);
1440 else
1441 makelevel = 0;
1444 /* Except under -s, always do -w in sub-makes and under -C. */
1445 if (!silent_flag && (directories != 0 || makelevel > 0))
1446 print_directory_flag = 1;
1448 /* Let the user disable that with --no-print-directory. */
1449 if (inhibit_print_directory_flag)
1450 print_directory_flag = 0;
1452 /* If -R was given, set -r too (doesn't make sense otherwise!) */
1453 if (no_builtin_variables_flag)
1454 no_builtin_rules_flag = 1;
1456 /* Construct the list of include directories to search. */
1458 construct_include_path (include_directories == 0
1459 ? 0 : include_directories->list);
1461 /* Figure out where we are now, after chdir'ing. */
1462 if (directories == 0)
1463 /* We didn't move, so we're still in the same place. */
1464 starting_directory = current_directory;
1465 else
1467 #ifdef WINDOWS32
1468 if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1469 #else
1470 if (getcwd (current_directory, GET_PATH_MAX) == 0)
1471 #endif
1473 #ifdef HAVE_GETCWD
1474 perror_with_name ("getcwd", "");
1475 #else
1476 error (NILF, "getwd: %s", current_directory);
1477 #endif
1478 starting_directory = 0;
1480 else
1481 starting_directory = current_directory;
1484 define_variable_cname ("CURDIR", current_directory, o_file, 0);
1486 /* Read any stdin makefiles into temporary files. */
1488 if (makefiles != 0)
1490 unsigned int i;
1491 for (i = 0; i < makefiles->idx; ++i)
1492 if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0')
1494 /* This makefile is standard input. Since we may re-exec
1495 and thus re-read the makefiles, we read standard input
1496 into a temporary file and read from that. */
1497 FILE *outfile;
1498 char *template, *tmpdir;
1500 if (stdin_nm)
1501 fatal (NILF, _("Makefile from standard input specified twice."));
1503 #ifdef VMS
1504 # define DEFAULT_TMPDIR "sys$scratch:"
1505 #else
1506 # ifdef P_tmpdir
1507 # define DEFAULT_TMPDIR P_tmpdir
1508 # else
1509 # define DEFAULT_TMPDIR "/tmp"
1510 # endif
1511 #endif
1512 #define DEFAULT_TMPFILE "GmXXXXXX"
1514 if (((tmpdir = getenv ("TMPDIR")) == NULL || *tmpdir == '\0')
1515 #if defined (__MSDOS__) || defined (WINDOWS32) || defined (__EMX__)
1516 /* These are also used commonly on these platforms. */
1517 && ((tmpdir = getenv ("TEMP")) == NULL || *tmpdir == '\0')
1518 && ((tmpdir = getenv ("TMP")) == NULL || *tmpdir == '\0')
1519 #endif
1521 tmpdir = DEFAULT_TMPDIR;
1523 template = alloca (strlen (tmpdir) + sizeof (DEFAULT_TMPFILE) + 1);
1524 strcpy (template, tmpdir);
1526 #ifdef HAVE_DOS_PATHS
1527 if (strchr ("/\\", template[strlen (template) - 1]) == NULL)
1528 strcat (template, "/");
1529 #else
1530 # ifndef VMS
1531 if (template[strlen (template) - 1] != '/')
1532 strcat (template, "/");
1533 # endif /* !VMS */
1534 #endif /* !HAVE_DOS_PATHS */
1536 strcat (template, DEFAULT_TMPFILE);
1537 outfile = open_tmpfile (&stdin_nm, template);
1538 if (outfile == 0)
1539 pfatal_with_name (_("fopen (temporary file)"));
1540 while (!feof (stdin) && ! ferror (stdin))
1542 char buf[2048];
1543 unsigned int n = fread (buf, 1, sizeof (buf), stdin);
1544 if (n > 0 && fwrite (buf, 1, n, outfile) != n)
1545 pfatal_with_name (_("fwrite (temporary file)"));
1547 fclose (outfile);
1549 /* Replace the name that read_all_makefiles will
1550 see with the name of the temporary file. */
1551 makefiles->list[i] = strcache_add (stdin_nm);
1553 /* Make sure the temporary file will not be remade. */
1555 struct file *f = enter_file (strcache_add (stdin_nm));
1556 f->updated = 1;
1557 f->update_status = 0;
1558 f->command_state = cs_finished;
1559 /* Can't be intermediate, or it'll be removed too early for
1560 make re-exec. */
1561 f->intermediate = 0;
1562 f->dontcare = 0;
1567 #ifndef __EMX__ /* Don't use a SIGCHLD handler for OS/2 */
1568 #if defined(MAKE_JOBSERVER) || !defined(HAVE_WAIT_NOHANG)
1569 /* Set up to handle children dying. This must be done before
1570 reading in the makefiles so that `shell' function calls will work.
1572 If we don't have a hanging wait we have to fall back to old, broken
1573 functionality here and rely on the signal handler and counting
1574 children.
1576 If we're using the jobs pipe we need a signal handler so that
1577 SIGCHLD is not ignored; we need it to interrupt the read(2) of the
1578 jobserver pipe in job.c if we're waiting for a token.
1580 If none of these are true, we don't need a signal handler at all. */
1582 RETSIGTYPE child_handler (int sig);
1583 # if defined SIGCHLD
1584 bsd_signal (SIGCHLD, child_handler);
1585 # endif
1586 # if defined SIGCLD && SIGCLD != SIGCHLD
1587 bsd_signal (SIGCLD, child_handler);
1588 # endif
1590 #endif
1591 #endif
1593 /* Let the user send us SIGUSR1 to toggle the -d flag during the run. */
1594 #ifdef SIGUSR1
1595 bsd_signal (SIGUSR1, debug_signal_handler);
1596 #endif
1598 /* Define the initial list of suffixes for old-style rules. */
1600 set_default_suffixes ();
1602 /* Define the file rules for the built-in suffix rules. These will later
1603 be converted into pattern rules. We used to do this in
1604 install_default_implicit_rules, but since that happens after reading
1605 makefiles, it results in the built-in pattern rules taking precedence
1606 over makefile-specified suffix rules, which is wrong. */
1608 install_default_suffix_rules ();
1610 /* Define some internal and special variables. */
1612 define_automatic_variables ();
1614 /* Set up the MAKEFLAGS and MFLAGS variables
1615 so makefiles can look at them. */
1617 define_makeflags (0, 0);
1619 /* Define the default variables. */
1620 define_default_variables ();
1622 default_file = enter_file (strcache_add (".DEFAULT"));
1624 default_goal_var = define_variable_cname (".DEFAULT_GOAL", "", o_file, 0);
1626 /* Evaluate all strings provided with --eval.
1627 Also set up the $(-*-eval-flags-*-) variable. */
1629 if (eval_strings)
1631 char *p, *value;
1632 unsigned int i;
1633 unsigned int len = sizeof ("--eval=") * eval_strings->idx;
1635 for (i = 0; i < eval_strings->idx; ++i)
1637 p = xstrdup (eval_strings->list[i]);
1638 len += 2 * strlen (p);
1639 eval_buffer (p);
1640 free (p);
1643 p = value = alloca (len);
1644 for (i = 0; i < eval_strings->idx; ++i)
1646 strcpy (p, "--eval=");
1647 p += strlen (p);
1648 p = quote_for_env (p, eval_strings->list[i]);
1649 *(p++) = ' ';
1651 p[-1] = '\0';
1653 define_variable_cname ("-*-eval-flags-*-", value, o_automatic, 0);
1656 /* Read all the makefiles. */
1658 read_makefiles
1659 = read_all_makefiles (makefiles == 0 ? 0 : makefiles->list);
1661 #ifdef WINDOWS32
1662 /* look one last time after reading all Makefiles */
1663 if (no_default_sh_exe)
1664 no_default_sh_exe = !find_and_set_default_shell(NULL);
1665 #endif /* WINDOWS32 */
1667 #if defined (__MSDOS__) || defined (__EMX__)
1668 /* We need to know what kind of shell we will be using. */
1670 extern int _is_unixy_shell (const char *_path);
1671 struct variable *shv = lookup_variable (STRING_SIZE_TUPLE ("SHELL"));
1672 extern int unixy_shell;
1673 extern char *default_shell;
1675 if (shv && *shv->value)
1677 char *shell_path = recursively_expand(shv);
1679 if (shell_path && _is_unixy_shell (shell_path))
1680 unixy_shell = 1;
1681 else
1682 unixy_shell = 0;
1683 if (shell_path)
1684 default_shell = shell_path;
1687 #endif /* __MSDOS__ || __EMX__ */
1689 /* Decode switches again, in case the variables were set by the makefile. */
1690 decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
1691 #if 0
1692 decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
1693 #endif
1695 #if defined (__MSDOS__) || defined (__EMX__)
1696 if (job_slots != 1
1697 # ifdef __EMX__
1698 && _osmode != OS2_MODE /* turn off -j if we are in DOS mode */
1699 # endif
1702 error (NILF,
1703 _("Parallel jobs (-j) are not supported on this platform."));
1704 error (NILF, _("Resetting to single job (-j1) mode."));
1705 job_slots = 1;
1707 #endif
1709 #ifdef MAKE_JOBSERVER
1710 /* If the jobserver-fds option is seen, make sure that -j is reasonable. */
1712 if (jobserver_fds)
1714 const char *cp;
1715 unsigned int ui;
1717 for (ui=1; ui < jobserver_fds->idx; ++ui)
1718 if (!streq (jobserver_fds->list[0], jobserver_fds->list[ui]))
1719 fatal (NILF, _("internal error: multiple --jobserver-fds options"));
1721 /* Now parse the fds string and make sure it has the proper format. */
1723 cp = jobserver_fds->list[0];
1725 if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2)
1726 fatal (NILF,
1727 _("internal error: invalid --jobserver-fds string `%s'"), cp);
1729 DB (DB_JOBS,
1730 (_("Jobserver client (fds %d,%d)\n"), job_fds[0], job_fds[1]));
1732 /* The combination of a pipe + !job_slots means we're using the
1733 jobserver. If !job_slots and we don't have a pipe, we can start
1734 infinite jobs. If we see both a pipe and job_slots >0 that means the
1735 user set -j explicitly. This is broken; in this case obey the user
1736 (ignore the jobserver pipe for this make) but print a message. */
1738 if (job_slots > 0)
1739 error (NILF,
1740 _("warning: -jN forced in submake: disabling jobserver mode."));
1742 /* Create a duplicate pipe, that will be closed in the SIGCHLD
1743 handler. If this fails with EBADF, the parent has closed the pipe
1744 on us because it didn't think we were a submake. If so, print a
1745 warning then default to -j1. */
1747 else if ((job_rfd = dup (job_fds[0])) < 0)
1749 if (errno != EBADF)
1750 pfatal_with_name (_("dup jobserver"));
1752 error (NILF,
1753 _("warning: jobserver unavailable: using -j1. Add `+' to parent make rule."));
1754 job_slots = 1;
1757 if (job_slots > 0)
1759 close (job_fds[0]);
1760 close (job_fds[1]);
1761 job_fds[0] = job_fds[1] = -1;
1762 free (jobserver_fds->list);
1763 free (jobserver_fds);
1764 jobserver_fds = 0;
1768 /* If we have >1 slot but no jobserver-fds, then we're a top-level make.
1769 Set up the pipe and install the fds option for our children. */
1771 if (job_slots > 1)
1773 char *cp;
1774 char c = '+';
1776 if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0)
1777 pfatal_with_name (_("creating jobs pipe"));
1779 /* Every make assumes that it always has one job it can run. For the
1780 submakes it's the token they were given by their parent. For the
1781 top make, we just subtract one from the number the user wants. We
1782 want job_slots to be 0 to indicate we're using the jobserver. */
1784 master_job_slots = job_slots;
1786 while (--job_slots)
1788 int r;
1790 EINTRLOOP (r, write (job_fds[1], &c, 1));
1791 if (r != 1)
1792 pfatal_with_name (_("init jobserver pipe"));
1795 /* Fill in the jobserver_fds struct for our children. */
1797 cp = xmalloc ((sizeof ("1024")*2)+1);
1798 sprintf (cp, "%d,%d", job_fds[0], job_fds[1]);
1800 jobserver_fds = (struct stringlist *)
1801 xmalloc (sizeof (struct stringlist));
1802 jobserver_fds->list = xmalloc (sizeof (char *));
1803 jobserver_fds->list[0] = cp;
1804 jobserver_fds->idx = 1;
1805 jobserver_fds->max = 1;
1807 #endif
1809 #ifndef MAKE_SYMLINKS
1810 if (check_symlink_flag)
1812 error (NILF, _("Symbolic links not supported: disabling -L."));
1813 check_symlink_flag = 0;
1815 #endif
1817 /* Set up MAKEFLAGS and MFLAGS again, so they will be right. */
1819 define_makeflags (1, 0);
1821 /* Make each `struct dep' point at the `struct file' for the file
1822 depended on. Also do magic for special targets. */
1824 snap_deps ();
1826 /* Convert old-style suffix rules to pattern rules. It is important to
1827 do this before installing the built-in pattern rules below, so that
1828 makefile-specified suffix rules take precedence over built-in pattern
1829 rules. */
1831 convert_to_pattern ();
1833 /* Install the default implicit pattern rules.
1834 This used to be done before reading the makefiles.
1835 But in that case, built-in pattern rules were in the chain
1836 before user-defined ones, so they matched first. */
1838 install_default_implicit_rules ();
1840 /* Compute implicit rule limits. */
1842 count_implicit_rule_limits ();
1844 /* Construct the listings of directories in VPATH lists. */
1846 build_vpath_lists ();
1848 /* Mark files given with -o flags as very old and as having been updated
1849 already, and files given with -W flags as brand new (time-stamp as far
1850 as possible into the future). If restarts is set we'll do -W later. */
1852 if (old_files != 0)
1854 const char **p;
1855 for (p = old_files->list; *p != 0; ++p)
1857 struct file *f = enter_file (*p);
1858 f->last_mtime = f->mtime_before_update = OLD_MTIME;
1859 f->updated = 1;
1860 f->update_status = 0;
1861 f->command_state = cs_finished;
1865 if (!restarts && new_files != 0)
1867 const char **p;
1868 for (p = new_files->list; *p != 0; ++p)
1870 struct file *f = enter_file (*p);
1871 f->last_mtime = f->mtime_before_update = NEW_MTIME;
1875 /* Initialize the remote job module. */
1876 remote_setup ();
1878 if (read_makefiles != 0)
1880 /* Update any makefiles if necessary. */
1882 FILE_TIMESTAMP *makefile_mtimes = 0;
1883 unsigned int mm_idx = 0;
1884 char **nargv;
1885 int nargc;
1886 int orig_db_level = db_level;
1887 int status;
1889 if (! ISDB (DB_MAKEFILES))
1890 db_level = DB_NONE;
1892 DB (DB_BASIC, (_("Updating makefiles....\n")));
1894 /* Remove any makefiles we don't want to try to update.
1895 Also record the current modtimes so we can compare them later. */
1897 register struct dep *d, *last;
1898 last = 0;
1899 d = read_makefiles;
1900 while (d != 0)
1902 struct file *f = d->file;
1903 if (f->double_colon)
1904 for (f = f->double_colon; f != NULL; f = f->prev)
1906 if (f->deps == 0 && f->cmds != 0)
1908 /* This makefile is a :: target with commands, but
1909 no dependencies. So, it will always be remade.
1910 This might well cause an infinite loop, so don't
1911 try to remake it. (This will only happen if
1912 your makefiles are written exceptionally
1913 stupidly; but if you work for Athena, that's how
1914 you write your makefiles.) */
1916 DB (DB_VERBOSE,
1917 (_("Makefile `%s' might loop; not remaking it.\n"),
1918 f->name));
1920 if (last == 0)
1921 read_makefiles = d->next;
1922 else
1923 last->next = d->next;
1925 /* Free the storage. */
1926 free_dep (d);
1928 d = last == 0 ? read_makefiles : last->next;
1930 break;
1933 if (f == NULL || !f->double_colon)
1935 makefile_mtimes = xrealloc (makefile_mtimes,
1936 (mm_idx+1)
1937 * sizeof (FILE_TIMESTAMP));
1938 makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file);
1939 last = d;
1940 d = d->next;
1945 /* Set up `MAKEFLAGS' specially while remaking makefiles. */
1946 define_makeflags (1, 1);
1948 rebuilding_makefiles = 1;
1949 status = update_goal_chain (read_makefiles);
1950 rebuilding_makefiles = 0;
1952 switch (status)
1954 case 1:
1955 /* The only way this can happen is if the user specified -q and asked
1956 * for one of the makefiles to be remade as a target on the command
1957 * line. Since we're not actually updating anything with -q we can
1958 * treat this as "did nothing".
1961 case -1:
1962 /* Did nothing. */
1963 break;
1965 case 2:
1966 /* Failed to update. Figure out if we care. */
1968 /* Nonzero if any makefile was successfully remade. */
1969 int any_remade = 0;
1970 /* Nonzero if any makefile we care about failed
1971 in updating or could not be found at all. */
1972 int any_failed = 0;
1973 unsigned int i;
1974 struct dep *d;
1976 for (i = 0, d = read_makefiles; d != 0; ++i, d = d->next)
1978 /* Reset the considered flag; we may need to look at the file
1979 again to print an error. */
1980 d->file->considered = 0;
1982 if (d->file->updated)
1984 /* This makefile was updated. */
1985 if (d->file->update_status == 0)
1987 /* It was successfully updated. */
1988 any_remade |= (file_mtime_no_search (d->file)
1989 != makefile_mtimes[i]);
1991 else if (! (d->changed & RM_DONTCARE))
1993 FILE_TIMESTAMP mtime;
1994 /* The update failed and this makefile was not
1995 from the MAKEFILES variable, so we care. */
1996 error (NILF, _("Failed to remake makefile `%s'."),
1997 d->file->name);
1998 mtime = file_mtime_no_search (d->file);
1999 any_remade |= (mtime != NONEXISTENT_MTIME
2000 && mtime != makefile_mtimes[i]);
2001 makefile_status = MAKE_FAILURE;
2004 else
2005 /* This makefile was not found at all. */
2006 if (! (d->changed & RM_DONTCARE))
2008 /* This is a makefile we care about. See how much. */
2009 if (d->changed & RM_INCLUDED)
2010 /* An included makefile. We don't need
2011 to die, but we do want to complain. */
2012 error (NILF,
2013 _("Included makefile `%s' was not found."),
2014 dep_name (d));
2015 else
2017 /* A normal makefile. We must die later. */
2018 error (NILF, _("Makefile `%s' was not found"),
2019 dep_name (d));
2020 any_failed = 1;
2024 /* Reset this to empty so we get the right error message below. */
2025 read_makefiles = 0;
2027 if (any_remade)
2028 goto re_exec;
2029 if (any_failed)
2030 die (2);
2031 break;
2034 case 0:
2035 re_exec:
2036 /* Updated successfully. Re-exec ourselves. */
2038 remove_intermediates (0);
2040 if (print_data_base_flag)
2041 print_data_base ();
2043 log_working_directory (0);
2045 clean_jobserver (0);
2047 if (makefiles != 0)
2049 /* These names might have changed. */
2050 int i, j = 0;
2051 for (i = 1; i < argc; ++i)
2052 if (strneq (argv[i], "-f", 2)) /* XXX */
2054 if (argv[i][2] == '\0')
2055 /* This cast is OK since we never modify argv. */
2056 argv[++i] = (char *) makefiles->list[j];
2057 else
2058 argv[i] = xstrdup (concat (2, "-f", makefiles->list[j]));
2059 ++j;
2063 /* Add -o option for the stdin temporary file, if necessary. */
2064 nargc = argc;
2065 if (stdin_nm)
2067 nargv = xmalloc ((nargc + 2) * sizeof (char *));
2068 memcpy (nargv, argv, argc * sizeof (char *));
2069 nargv[nargc++] = xstrdup (concat (2, "-o", stdin_nm));
2070 nargv[nargc] = 0;
2072 else
2073 nargv = argv;
2075 if (directories != 0 && directories->idx > 0)
2077 int bad = 1;
2078 if (directory_before_chdir != 0)
2080 if (chdir (directory_before_chdir) < 0)
2081 perror_with_name ("chdir", "");
2082 else
2083 bad = 0;
2085 if (bad)
2086 fatal (NILF, _("Couldn't change back to original directory."));
2089 ++restarts;
2091 /* Reset makeflags in case they were changed. */
2093 const char *pv = define_makeflags (1, 1);
2094 char *p = alloca (sizeof ("MAKEFLAGS=") + strlen (pv) + 1);
2095 sprintf (p, "MAKEFLAGS=%s", pv);
2096 putenv (p);
2099 if (ISDB (DB_BASIC))
2101 char **p;
2102 printf (_("Re-executing[%u]:"), restarts);
2103 for (p = nargv; *p != 0; ++p)
2104 printf (" %s", *p);
2105 putchar ('\n');
2108 #ifndef _AMIGA
2110 char **p;
2111 for (p = environ; *p != 0; ++p)
2113 if (strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH)
2114 && (*p)[MAKELEVEL_LENGTH] == '=')
2116 *p = alloca (40);
2117 sprintf (*p, "%s=%u", MAKELEVEL_NAME, makelevel);
2119 if (strneq (*p, "MAKE_RESTARTS=", 14))
2121 *p = alloca (40);
2122 sprintf (*p, "MAKE_RESTARTS=%u", restarts);
2123 restarts = 0;
2127 #else /* AMIGA */
2129 char buffer[256];
2131 sprintf (buffer, "%u", makelevel);
2132 SetVar (MAKELEVEL_NAME, buffer, -1, GVF_GLOBAL_ONLY);
2134 sprintf (buffer, "%u", restarts);
2135 SetVar ("MAKE_RESTARTS", buffer, -1, GVF_GLOBAL_ONLY);
2136 restarts = 0;
2138 #endif
2140 /* If we didn't set the restarts variable yet, add it. */
2141 if (restarts)
2143 char *b = alloca (40);
2144 sprintf (b, "MAKE_RESTARTS=%u", restarts);
2145 putenv (b);
2148 fflush (stdout);
2149 fflush (stderr);
2151 /* Close the dup'd jobserver pipe if we opened one. */
2152 if (job_rfd >= 0)
2153 close (job_rfd);
2155 #ifdef _AMIGA
2156 exec_command (nargv);
2157 exit (0);
2158 #elif defined (__EMX__)
2160 /* It is not possible to use execve() here because this
2161 would cause the parent process to be terminated with
2162 exit code 0 before the child process has been terminated.
2163 Therefore it may be the best solution simply to spawn the
2164 child process including all file handles and to wait for its
2165 termination. */
2166 int pid;
2167 int status;
2168 pid = child_execute_job (0, 1, nargv, environ);
2170 /* is this loop really necessary? */
2171 do {
2172 pid = wait (&status);
2173 } while (pid <= 0);
2174 /* use the exit code of the child process */
2175 exit (WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
2177 #else
2178 exec_command (nargv, environ);
2179 #endif
2180 /* NOTREACHED */
2182 default:
2183 #define BOGUS_UPDATE_STATUS 0
2184 assert (BOGUS_UPDATE_STATUS);
2185 break;
2188 db_level = orig_db_level;
2190 /* Free the makefile mtimes (if we allocated any). */
2191 if (makefile_mtimes)
2192 free (makefile_mtimes);
2195 /* Set up `MAKEFLAGS' again for the normal targets. */
2196 define_makeflags (1, 0);
2198 /* Set always_make_flag if -B was given. */
2199 always_make_flag = always_make_set;
2201 /* If restarts is set we haven't set up -W files yet, so do that now. */
2202 if (restarts && new_files != 0)
2204 const char **p;
2205 for (p = new_files->list; *p != 0; ++p)
2207 struct file *f = enter_file (*p);
2208 f->last_mtime = f->mtime_before_update = NEW_MTIME;
2212 /* If there is a temp file from reading a makefile from stdin, get rid of
2213 it now. */
2214 if (stdin_nm && unlink (stdin_nm) < 0 && errno != ENOENT)
2215 perror_with_name (_("unlink (temporary file): "), stdin_nm);
2217 /* If there were no command-line goals, use the default. */
2218 if (goals == 0)
2220 char *p;
2222 if (default_goal_var->recursive)
2223 p = variable_expand (default_goal_var->value);
2224 else
2226 p = variable_buffer_output (variable_buffer, default_goal_var->value,
2227 strlen (default_goal_var->value));
2228 *p = '\0';
2229 p = variable_buffer;
2232 if (*p != '\0')
2234 struct file *f = lookup_file (p);
2236 /* If .DEFAULT_GOAL is a non-existent target, enter it into the
2237 table and let the standard logic sort it out. */
2238 if (f == 0)
2240 struct nameseq *ns;
2242 ns = PARSE_FILE_SEQ (&p, struct nameseq, '\0', NULL, 0);
2243 if (ns)
2245 /* .DEFAULT_GOAL should contain one target. */
2246 if (ns->next != 0)
2247 fatal (NILF, _(".DEFAULT_GOAL contains more than one target"));
2249 f = enter_file (strcache_add (ns->name));
2251 ns->name = 0; /* It was reused by enter_file(). */
2252 free_ns_chain (ns);
2256 if (f)
2258 goals = alloc_dep ();
2259 goals->file = f;
2263 else
2264 lastgoal->next = 0;
2267 if (!goals)
2269 if (read_makefiles == 0)
2270 fatal (NILF, _("No targets specified and no makefile found"));
2272 fatal (NILF, _("No targets"));
2275 /* Update the goals. */
2277 DB (DB_BASIC, (_("Updating goal targets....\n")));
2280 int status;
2282 switch (update_goal_chain (goals))
2284 case -1:
2285 /* Nothing happened. */
2286 case 0:
2287 /* Updated successfully. */
2288 status = makefile_status;
2289 break;
2290 case 1:
2291 /* We are under -q and would run some commands. */
2292 status = MAKE_TROUBLE;
2293 break;
2294 case 2:
2295 /* Updating failed. POSIX.2 specifies exit status >1 for this;
2296 but in VMS, there is only success and failure. */
2297 status = MAKE_FAILURE;
2298 break;
2299 default:
2300 abort ();
2303 /* If we detected some clock skew, generate one last warning */
2304 if (clock_skew_detected)
2305 error (NILF,
2306 _("warning: Clock skew detected. Your build may be incomplete."));
2308 /* Exit. */
2309 die (status);
2312 /* NOTREACHED */
2313 return 0;
2316 /* Parsing of arguments, decoding of switches. */
2318 static char options[1 + sizeof (switches) / sizeof (switches[0]) * 3];
2319 static struct option long_options[(sizeof (switches) / sizeof (switches[0])) +
2320 (sizeof (long_option_aliases) /
2321 sizeof (long_option_aliases[0]))];
2323 /* Fill in the string and vector for getopt. */
2324 static void
2325 init_switches (void)
2327 char *p;
2328 unsigned int c;
2329 unsigned int i;
2331 if (options[0] != '\0')
2332 /* Already done. */
2333 return;
2335 p = options;
2337 /* Return switch and non-switch args in order, regardless of
2338 POSIXLY_CORRECT. Non-switch args are returned as option 1. */
2339 *p++ = '-';
2341 for (i = 0; switches[i].c != '\0'; ++i)
2343 long_options[i].name = (switches[i].long_name == 0 ? "" :
2344 switches[i].long_name);
2345 long_options[i].flag = 0;
2346 long_options[i].val = switches[i].c;
2347 if (short_option (switches[i].c))
2348 *p++ = switches[i].c;
2349 switch (switches[i].type)
2351 case flag:
2352 case flag_off:
2353 case ignore:
2354 long_options[i].has_arg = no_argument;
2355 break;
2357 case string:
2358 case filename:
2359 case positive_int:
2360 case floating:
2361 if (short_option (switches[i].c))
2362 *p++ = ':';
2363 if (switches[i].noarg_value != 0)
2365 if (short_option (switches[i].c))
2366 *p++ = ':';
2367 long_options[i].has_arg = optional_argument;
2369 else
2370 long_options[i].has_arg = required_argument;
2371 break;
2374 *p = '\0';
2375 for (c = 0; c < (sizeof (long_option_aliases) /
2376 sizeof (long_option_aliases[0]));
2377 ++c)
2378 long_options[i++] = long_option_aliases[c];
2379 long_options[i].name = 0;
2382 static void
2383 handle_non_switch_argument (char *arg, int env)
2385 /* Non-option argument. It might be a variable definition. */
2386 struct variable *v;
2387 if (arg[0] == '-' && arg[1] == '\0')
2388 /* Ignore plain `-' for compatibility. */
2389 return;
2390 v = try_variable_definition (0, arg, o_command, 0);
2391 if (v != 0)
2393 /* It is indeed a variable definition. If we don't already have this
2394 one, record a pointer to the variable for later use in
2395 define_makeflags. */
2396 struct command_variable *cv;
2398 for (cv = command_variables; cv != 0; cv = cv->next)
2399 if (cv->variable == v)
2400 break;
2402 if (! cv) {
2403 cv = xmalloc (sizeof (*cv));
2404 cv->variable = v;
2405 cv->next = command_variables;
2406 command_variables = cv;
2409 else if (! env)
2411 /* Not an option or variable definition; it must be a goal
2412 target! Enter it as a file and add it to the dep chain of
2413 goals. */
2414 struct file *f = enter_file (strcache_add (expand_command_line_file (arg)));
2415 f->cmd_target = 1;
2417 if (goals == 0)
2419 goals = alloc_dep ();
2420 lastgoal = goals;
2422 else
2424 lastgoal->next = alloc_dep ();
2425 lastgoal = lastgoal->next;
2428 lastgoal->file = f;
2431 /* Add this target name to the MAKECMDGOALS variable. */
2432 struct variable *gv;
2433 const char *value;
2435 gv = lookup_variable (STRING_SIZE_TUPLE ("MAKECMDGOALS"));
2436 if (gv == 0)
2437 value = f->name;
2438 else
2440 /* Paste the old and new values together */
2441 unsigned int oldlen, newlen;
2442 char *vp;
2444 oldlen = strlen (gv->value);
2445 newlen = strlen (f->name);
2446 vp = alloca (oldlen + 1 + newlen + 1);
2447 memcpy (vp, gv->value, oldlen);
2448 vp[oldlen] = ' ';
2449 memcpy (&vp[oldlen + 1], f->name, newlen + 1);
2450 value = vp;
2452 define_variable_cname ("MAKECMDGOALS", value, o_default, 0);
2457 /* Print a nice usage method. */
2459 static void
2460 print_usage (int bad)
2462 const char *const *cpp;
2463 FILE *usageto;
2465 if (print_version_flag)
2466 print_version ();
2468 usageto = bad ? stderr : stdout;
2470 fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program);
2472 for (cpp = usage; *cpp; ++cpp)
2473 fputs (_(*cpp), usageto);
2475 if (!remote_description || *remote_description == '\0')
2476 fprintf (usageto, _("\nThis program built for %s\n"), make_host);
2477 else
2478 fprintf (usageto, _("\nThis program built for %s (%s)\n"),
2479 make_host, remote_description);
2481 fprintf (usageto, _("Report bugs to <bug-make@gnu.org>\n"));
2484 /* Decode switches from ARGC and ARGV.
2485 They came from the environment if ENV is nonzero. */
2487 static void
2488 decode_switches (int argc, char **argv, int env)
2490 int bad = 0;
2491 register const struct command_switch *cs;
2492 register struct stringlist *sl;
2493 register int c;
2495 /* getopt does most of the parsing for us.
2496 First, get its vectors set up. */
2498 init_switches ();
2500 /* Let getopt produce error messages for the command line,
2501 but not for options from the environment. */
2502 opterr = !env;
2503 /* Reset getopt's state. */
2504 optind = 0;
2506 while (optind < argc)
2508 /* Parse the next argument. */
2509 c = getopt_long (argc, argv, options, long_options, (int *) 0);
2510 if (c == EOF)
2511 /* End of arguments, or "--" marker seen. */
2512 break;
2513 else if (c == 1)
2514 /* An argument not starting with a dash. */
2515 handle_non_switch_argument (optarg, env);
2516 else if (c == '?')
2517 /* Bad option. We will print a usage message and die later.
2518 But continue to parse the other options so the user can
2519 see all he did wrong. */
2520 bad = 1;
2521 else
2522 for (cs = switches; cs->c != '\0'; ++cs)
2523 if (cs->c == c)
2525 /* Whether or not we will actually do anything with
2526 this switch. We test this individually inside the
2527 switch below rather than just once outside it, so that
2528 options which are to be ignored still consume args. */
2529 int doit = !env || cs->env;
2531 switch (cs->type)
2533 default:
2534 abort ();
2536 case ignore:
2537 break;
2539 case flag:
2540 case flag_off:
2541 if (doit)
2542 *(int *) cs->value_ptr = cs->type == flag;
2543 break;
2545 case string:
2546 case filename:
2547 if (!doit)
2548 break;
2550 if (optarg == 0)
2551 optarg = xstrdup (cs->noarg_value);
2552 else if (*optarg == '\0')
2554 char opt[2] = "c";
2555 const char *op = opt;
2557 if (short_option (cs->c))
2558 opt[0] = cs->c;
2559 else
2560 op = cs->long_name;
2562 error (NILF, _("the `%s%s' option requires a non-empty string argument"),
2563 short_option (cs->c) ? "-" : "--", op);
2564 bad = 1;
2567 sl = *(struct stringlist **) cs->value_ptr;
2568 if (sl == 0)
2570 sl = (struct stringlist *)
2571 xmalloc (sizeof (struct stringlist));
2572 sl->max = 5;
2573 sl->idx = 0;
2574 sl->list = xmalloc (5 * sizeof (char *));
2575 *(struct stringlist **) cs->value_ptr = sl;
2577 else if (sl->idx == sl->max - 1)
2579 sl->max += 5;
2580 sl->list = xrealloc (sl->list,
2581 sl->max * sizeof (char *));
2583 if (cs->type == filename)
2584 sl->list[sl->idx++] = expand_command_line_file (optarg);
2585 else
2586 sl->list[sl->idx++] = optarg;
2587 sl->list[sl->idx] = 0;
2588 break;
2590 case positive_int:
2591 /* See if we have an option argument; if we do require that
2592 it's all digits, not something like "10foo". */
2593 if (optarg == 0 && argc > optind)
2595 const char *cp;
2596 for (cp=argv[optind]; ISDIGIT (cp[0]); ++cp)
2598 if (cp[0] == '\0')
2599 optarg = argv[optind++];
2602 if (!doit)
2603 break;
2605 if (optarg != 0)
2607 int i = atoi (optarg);
2608 const char *cp;
2610 /* Yes, I realize we're repeating this in some cases. */
2611 for (cp = optarg; ISDIGIT (cp[0]); ++cp)
2614 if (i < 1 || cp[0] != '\0')
2616 error (NILF, _("the `-%c' option requires a positive integral argument"),
2617 cs->c);
2618 bad = 1;
2620 else
2621 *(unsigned int *) cs->value_ptr = i;
2623 else
2624 *(unsigned int *) cs->value_ptr
2625 = *(unsigned int *) cs->noarg_value;
2626 break;
2628 #ifndef NO_FLOAT
2629 case floating:
2630 if (optarg == 0 && optind < argc
2631 && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.'))
2632 optarg = argv[optind++];
2634 if (doit)
2635 *(double *) cs->value_ptr
2636 = (optarg != 0 ? atof (optarg)
2637 : *(double *) cs->noarg_value);
2639 break;
2640 #endif
2643 /* We've found the switch. Stop looking. */
2644 break;
2648 /* There are no more options according to getting getopt, but there may
2649 be some arguments left. Since we have asked for non-option arguments
2650 to be returned in order, this only happens when there is a "--"
2651 argument to prevent later arguments from being options. */
2652 while (optind < argc)
2653 handle_non_switch_argument (argv[optind++], env);
2656 if (!env && (bad || print_usage_flag))
2658 print_usage (bad);
2659 die (bad ? 2 : 0);
2663 /* Decode switches from environment variable ENVAR (which is LEN chars long).
2664 We do this by chopping the value into a vector of words, prepending a
2665 dash to the first word if it lacks one, and passing the vector to
2666 decode_switches. */
2668 static void
2669 decode_env_switches (char *envar, unsigned int len)
2671 char *varref = alloca (2 + len + 2);
2672 char *value, *p;
2673 int argc;
2674 char **argv;
2676 /* Get the variable's value. */
2677 varref[0] = '$';
2678 varref[1] = '(';
2679 memcpy (&varref[2], envar, len);
2680 varref[2 + len] = ')';
2681 varref[2 + len + 1] = '\0';
2682 value = variable_expand (varref);
2684 /* Skip whitespace, and check for an empty value. */
2685 value = next_token (value);
2686 len = strlen (value);
2687 if (len == 0)
2688 return;
2690 /* Allocate a vector that is definitely big enough. */
2691 argv = alloca ((1 + len + 1) * sizeof (char *));
2693 /* Allocate a buffer to copy the value into while we split it into words
2694 and unquote it. We must use permanent storage for this because
2695 decode_switches may store pointers into the passed argument words. */
2696 p = xmalloc (2 * len);
2698 /* getopt will look at the arguments starting at ARGV[1].
2699 Prepend a spacer word. */
2700 argv[0] = 0;
2701 argc = 1;
2702 argv[argc] = p;
2703 while (*value != '\0')
2705 if (*value == '\\' && value[1] != '\0')
2706 ++value; /* Skip the backslash. */
2707 else if (isblank ((unsigned char)*value))
2709 /* End of the word. */
2710 *p++ = '\0';
2711 argv[++argc] = p;
2713 ++value;
2714 while (isblank ((unsigned char)*value));
2715 continue;
2717 *p++ = *value++;
2719 *p = '\0';
2720 argv[++argc] = 0;
2722 if (argv[1][0] != '-' && strchr (argv[1], '=') == 0)
2723 /* The first word doesn't start with a dash and isn't a variable
2724 definition. Add a dash and pass it along to decode_switches. We
2725 need permanent storage for this in case decode_switches saves
2726 pointers into the value. */
2727 argv[1] = xstrdup (concat (2, "-", argv[1]));
2729 /* Parse those words. */
2730 decode_switches (argc, argv, 1);
2733 /* Quote the string IN so that it will be interpreted as a single word with
2734 no magic by decode_env_switches; also double dollar signs to avoid
2735 variable expansion in make itself. Write the result into OUT, returning
2736 the address of the next character to be written.
2737 Allocating space for OUT twice the length of IN is always sufficient. */
2739 static char *
2740 quote_for_env (char *out, const char *in)
2742 while (*in != '\0')
2744 if (*in == '$')
2745 *out++ = '$';
2746 else if (isblank ((unsigned char)*in) || *in == '\\')
2747 *out++ = '\\';
2748 *out++ = *in++;
2751 return out;
2754 /* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the
2755 command switches. Include options with args if ALL is nonzero.
2756 Don't include options with the `no_makefile' flag set if MAKEFILE. */
2758 static const char *
2759 define_makeflags (int all, int makefile)
2761 const char ref[] = "$(MAKEOVERRIDES)";
2762 const char posixref[] = "$(-*-command-variables-*-)";
2763 const char evalref[] = "$(-*-eval-flags-*-)";
2764 const struct command_switch *cs;
2765 char *flagstring;
2766 register char *p;
2767 unsigned int words;
2768 struct variable *v;
2770 /* We will construct a linked list of `struct flag's describing
2771 all the flags which need to go in MAKEFLAGS. Then, once we
2772 know how many there are and their lengths, we can put them all
2773 together in a string. */
2775 struct flag
2777 struct flag *next;
2778 const struct command_switch *cs;
2779 const char *arg;
2781 struct flag *flags = 0;
2782 unsigned int flagslen = 0;
2783 #define ADD_FLAG(ARG, LEN) \
2784 do { \
2785 struct flag *new = alloca (sizeof (struct flag)); \
2786 new->cs = cs; \
2787 new->arg = (ARG); \
2788 new->next = flags; \
2789 flags = new; \
2790 if (new->arg == 0) \
2791 ++flagslen; /* Just a single flag letter. */ \
2792 else \
2793 /* " -x foo", plus space to expand "foo". */ \
2794 flagslen += 1 + 1 + 1 + 1 + (3 * (LEN)); \
2795 if (!short_option (cs->c)) \
2796 /* This switch has no single-letter version, so we use the long. */ \
2797 flagslen += 2 + strlen (cs->long_name); \
2798 } while (0)
2800 for (cs = switches; cs->c != '\0'; ++cs)
2801 if (cs->toenv && (!makefile || !cs->no_makefile))
2802 switch (cs->type)
2804 case ignore:
2805 break;
2807 case flag:
2808 case flag_off:
2809 if (!*(int *) cs->value_ptr == (cs->type == flag_off)
2810 && (cs->default_value == 0
2811 || *(int *) cs->value_ptr != *(int *) cs->default_value))
2812 ADD_FLAG (0, 0);
2813 break;
2815 case positive_int:
2816 if (all)
2818 if ((cs->default_value != 0
2819 && (*(unsigned int *) cs->value_ptr
2820 == *(unsigned int *) cs->default_value)))
2821 break;
2822 else if (cs->noarg_value != 0
2823 && (*(unsigned int *) cs->value_ptr ==
2824 *(unsigned int *) cs->noarg_value))
2825 ADD_FLAG ("", 0); /* Optional value omitted; see below. */
2826 else if (cs->c == 'j')
2827 /* Special case for `-j'. */
2828 ADD_FLAG ("1", 1);
2829 else
2831 char *buf = alloca (30);
2832 sprintf (buf, "%u", *(unsigned int *) cs->value_ptr);
2833 ADD_FLAG (buf, strlen (buf));
2836 break;
2838 #ifndef NO_FLOAT
2839 case floating:
2840 if (all)
2842 if (cs->default_value != 0
2843 && (*(double *) cs->value_ptr
2844 == *(double *) cs->default_value))
2845 break;
2846 else if (cs->noarg_value != 0
2847 && (*(double *) cs->value_ptr
2848 == *(double *) cs->noarg_value))
2849 ADD_FLAG ("", 0); /* Optional value omitted; see below. */
2850 else
2852 char *buf = alloca (100);
2853 sprintf (buf, "%g", *(double *) cs->value_ptr);
2854 ADD_FLAG (buf, strlen (buf));
2857 break;
2858 #endif
2860 case filename:
2861 case string:
2862 if (all)
2864 struct stringlist *sl = *(struct stringlist **) cs->value_ptr;
2865 if (sl != 0)
2867 /* Add the elements in reverse order, because all the flags
2868 get reversed below; and the order matters for some
2869 switches (like -I). */
2870 unsigned int i = sl->idx;
2871 while (i-- > 0)
2872 ADD_FLAG (sl->list[i], strlen (sl->list[i]));
2875 break;
2877 default:
2878 abort ();
2881 /* Four more for the possible " -- ". */
2882 flagslen += 4 + sizeof (posixref) + sizeof (evalref);
2884 #undef ADD_FLAG
2886 /* Construct the value in FLAGSTRING.
2887 We allocate enough space for a preceding dash and trailing null. */
2888 flagstring = alloca (1 + flagslen + 1);
2889 memset (flagstring, '\0', 1 + flagslen + 1);
2890 p = flagstring;
2891 words = 1;
2892 *p++ = '-';
2893 while (flags != 0)
2895 /* Add the flag letter or name to the string. */
2896 if (short_option (flags->cs->c))
2897 *p++ = flags->cs->c;
2898 else
2900 if (*p != '-')
2902 *p++ = ' ';
2903 *p++ = '-';
2905 *p++ = '-';
2906 strcpy (p, flags->cs->long_name);
2907 p += strlen (p);
2909 if (flags->arg != 0)
2911 /* A flag that takes an optional argument which in this case is
2912 omitted is specified by ARG being "". We must distinguish
2913 because a following flag appended without an intervening " -"
2914 is considered the arg for the first. */
2915 if (flags->arg[0] != '\0')
2917 /* Add its argument too. */
2918 *p++ = !short_option (flags->cs->c) ? '=' : ' ';
2919 p = quote_for_env (p, flags->arg);
2921 ++words;
2922 /* Write a following space and dash, for the next flag. */
2923 *p++ = ' ';
2924 *p++ = '-';
2926 else if (!short_option (flags->cs->c))
2928 ++words;
2929 /* Long options must each go in their own word,
2930 so we write the following space and dash. */
2931 *p++ = ' ';
2932 *p++ = '-';
2934 flags = flags->next;
2937 /* Define MFLAGS before appending variable definitions. */
2939 if (p == &flagstring[1])
2940 /* No flags. */
2941 flagstring[0] = '\0';
2942 else if (p[-1] == '-')
2944 /* Kill the final space and dash. */
2945 p -= 2;
2946 *p = '\0';
2948 else
2949 /* Terminate the string. */
2950 *p = '\0';
2952 /* Since MFLAGS is not parsed for flags, there is no reason to
2953 override any makefile redefinition. */
2954 define_variable_cname ("MFLAGS", flagstring, o_env, 1);
2956 /* Write a reference to -*-eval-flags-*-, which contains all the --eval
2957 flag options. */
2958 if (eval_strings)
2960 if (p == &flagstring[1])
2961 /* No flags written, so elide the leading dash already written. */
2962 p = flagstring;
2963 else
2964 *p++ = ' ';
2965 memcpy (p, evalref, sizeof (evalref) - 1);
2966 p += sizeof (evalref) - 1;
2969 if (all && command_variables != 0)
2971 /* Now write a reference to $(MAKEOVERRIDES), which contains all the
2972 command-line variable definitions. */
2974 if (p == &flagstring[1])
2975 /* No flags written, so elide the leading dash already written. */
2976 p = flagstring;
2977 else
2979 /* Separate the variables from the switches with a "--" arg. */
2980 if (p[-1] != '-')
2982 /* We did not already write a trailing " -". */
2983 *p++ = ' ';
2984 *p++ = '-';
2986 /* There is a trailing " -"; fill it out to " -- ". */
2987 *p++ = '-';
2988 *p++ = ' ';
2991 /* Copy in the string. */
2992 if (posix_pedantic)
2994 memcpy (p, posixref, sizeof (posixref) - 1);
2995 p += sizeof (posixref) - 1;
2997 else
2999 memcpy (p, ref, sizeof (ref) - 1);
3000 p += sizeof (ref) - 1;
3003 else if (p == &flagstring[1])
3005 words = 0;
3006 --p;
3008 else if (p[-1] == '-')
3009 /* Kill the final space and dash. */
3010 p -= 2;
3011 /* Terminate the string. */
3012 *p = '\0';
3014 /* If there are switches, omit the leading dash unless it is a single long
3015 option with two leading dashes. */
3016 if (flagstring[0] == '-' && flagstring[1] != '-')
3017 ++flagstring;
3019 v = define_variable_cname ("MAKEFLAGS", flagstring,
3020 /* This used to use o_env, but that lost when a
3021 makefile defined MAKEFLAGS. Makefiles set
3022 MAKEFLAGS to add switches, but we still want
3023 to redefine its value with the full set of
3024 switches. Of course, an override or command
3025 definition will still take precedence. */
3026 o_file, 1);
3028 if (! all)
3029 /* The first time we are called, set MAKEFLAGS to always be exported.
3030 We should not do this again on the second call, because that is
3031 after reading makefiles which might have done `unexport MAKEFLAGS'. */
3032 v->export = v_export;
3034 return v->value;
3037 /* Print version information. */
3039 static void
3040 print_version (void)
3042 static int printed_version = 0;
3044 char *precede = print_data_base_flag ? "# " : "";
3046 if (printed_version)
3047 /* Do it only once. */
3048 return;
3050 printf ("%sGNU Make %s\n", precede, version_string);
3052 if (!remote_description || *remote_description == '\0')
3053 printf (_("%sBuilt for %s\n"), precede, make_host);
3054 else
3055 printf (_("%sBuilt for %s (%s)\n"),
3056 precede, make_host, remote_description);
3058 /* Print this untranslated. The coding standards recommend translating the
3059 (C) to the copyright symbol, but this string is going to change every
3060 year, and none of the rest of it should be translated (including the
3061 word "Copyright", so it hardly seems worth it. */
3063 printf ("%sCopyright (C) 2009 Free Software Foundation, Inc.\n", precede);
3065 printf (_("%sLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
3066 %sThis is free software: you are free to change and redistribute it.\n\
3067 %sThere is NO WARRANTY, to the extent permitted by law.\n"),
3068 precede, precede, precede);
3070 printed_version = 1;
3072 /* Flush stdout so the user doesn't have to wait to see the
3073 version information while things are thought about. */
3074 fflush (stdout);
3077 /* Print a bunch of information about this and that. */
3079 static void
3080 print_data_base ()
3082 time_t when;
3084 when = time ((time_t *) 0);
3085 printf (_("\n# Make data base, printed on %s"), ctime (&when));
3087 print_variable_data_base ();
3088 print_dir_data_base ();
3089 print_rule_data_base ();
3090 print_file_data_base ();
3091 print_vpath_data_base ();
3092 strcache_print_stats ("#");
3094 when = time ((time_t *) 0);
3095 printf (_("\n# Finished Make data base on %s\n"), ctime (&when));
3098 static void
3099 clean_jobserver (int status)
3101 char token = '+';
3103 /* Sanity: have we written all our jobserver tokens back? If our
3104 exit status is 2 that means some kind of syntax error; we might not
3105 have written all our tokens so do that now. If tokens are left
3106 after any other error code, that's bad. */
3108 if (job_fds[0] != -1 && jobserver_tokens)
3110 if (status != 2)
3111 error (NILF,
3112 "INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
3113 jobserver_tokens);
3114 else
3115 while (jobserver_tokens--)
3117 int r;
3119 EINTRLOOP (r, write (job_fds[1], &token, 1));
3120 if (r != 1)
3121 perror_with_name ("write", "");
3126 /* Sanity: If we're the master, were all the tokens written back? */
3128 if (master_job_slots)
3130 /* We didn't write one for ourself, so start at 1. */
3131 unsigned int tcnt = 1;
3133 /* Close the write side, so the read() won't hang. */
3134 close (job_fds[1]);
3136 while (read (job_fds[0], &token, 1) == 1)
3137 ++tcnt;
3139 if (tcnt != master_job_slots)
3140 error (NILF,
3141 "INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
3142 tcnt, master_job_slots);
3144 close (job_fds[0]);
3146 /* Clean out jobserver_fds so we don't pass this information to any
3147 sub-makes. Also reset job_slots since it will be put on the command
3148 line, not in MAKEFLAGS. */
3149 job_slots = default_job_slots;
3150 if (jobserver_fds)
3152 free (jobserver_fds->list);
3153 free (jobserver_fds);
3154 jobserver_fds = 0;
3159 /* Exit with STATUS, cleaning up as necessary. */
3161 void
3162 die (int status)
3164 static char dying = 0;
3166 if (!dying)
3168 int err;
3170 dying = 1;
3172 if (print_version_flag)
3173 print_version ();
3175 /* Wait for children to die. */
3176 err = (status != 0);
3177 while (job_slots_used > 0)
3178 reap_children (1, err);
3180 /* Let the remote job module clean up its state. */
3181 remote_cleanup ();
3183 /* Remove the intermediate files. */
3184 remove_intermediates (0);
3186 if (print_data_base_flag)
3187 print_data_base ();
3189 verify_file_data_base ();
3191 clean_jobserver (status);
3193 /* Try to move back to the original directory. This is essential on
3194 MS-DOS (where there is really only one process), and on Unix it
3195 puts core files in the original directory instead of the -C
3196 directory. Must wait until after remove_intermediates(), or unlinks
3197 of relative pathnames fail. */
3198 if (directory_before_chdir != 0)
3200 /* If it fails we don't care: shut up GCC. */
3201 int _x;
3202 _x = chdir (directory_before_chdir);
3205 log_working_directory (0);
3208 exit (status);
3211 /* Write a message indicating that we've just entered or
3212 left (according to ENTERING) the current directory. */
3214 void
3215 log_working_directory (int entering)
3217 static int entered = 0;
3219 /* Print nothing without the flag. Don't print the entering message
3220 again if we already have. Don't print the leaving message if we
3221 haven't printed the entering message. */
3222 if (! print_directory_flag || entering == entered)
3223 return;
3225 entered = entering;
3227 if (print_data_base_flag)
3228 fputs ("# ", stdout);
3230 /* Use entire sentences to give the translators a fighting chance. */
3232 if (makelevel == 0)
3233 if (starting_directory == 0)
3234 if (entering)
3235 printf (_("%s: Entering an unknown directory\n"), program);
3236 else
3237 printf (_("%s: Leaving an unknown directory\n"), program);
3238 else
3239 if (entering)
3240 printf (_("%s: Entering directory `%s'\n"),
3241 program, starting_directory);
3242 else
3243 printf (_("%s: Leaving directory `%s'\n"),
3244 program, starting_directory);
3245 else
3246 if (starting_directory == 0)
3247 if (entering)
3248 printf (_("%s[%u]: Entering an unknown directory\n"),
3249 program, makelevel);
3250 else
3251 printf (_("%s[%u]: Leaving an unknown directory\n"),
3252 program, makelevel);
3253 else
3254 if (entering)
3255 printf (_("%s[%u]: Entering directory `%s'\n"),
3256 program, makelevel, starting_directory);
3257 else
3258 printf (_("%s[%u]: Leaving directory `%s'\n"),
3259 program, makelevel, starting_directory);
3261 /* Flush stdout to be sure this comes before any stderr output. */
3262 fflush (stdout);