Create a new internal interface for defining new make functions.
[make.git] / main.c
blob9bc5107d3c38d2f0f4127fb6e230f9609e857d28
1 /* Argument parsing and main program of GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free 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 # include "sub_proc.h"
39 # include "w32err.h"
40 #endif
41 #ifdef __EMX__
42 # include <sys/types.h>
43 # include <sys/wait.h>
44 #endif
45 #ifdef HAVE_FCNTL_H
46 # include <fcntl.h>
47 #endif
49 #ifdef _AMIGA
50 int __stack = 20000; /* Make sure we have 20K of stack space */
51 #endif
53 void init_dir (void);
54 void remote_setup (void);
55 void remote_cleanup (void);
56 RETSIGTYPE fatal_error_signal (int sig);
58 void print_variable_data_base (void);
59 void print_dir_data_base (void);
60 void print_rule_data_base (void);
61 void print_vpath_data_base (void);
63 void verify_file_data_base (void);
65 #if defined HAVE_WAITPID || defined HAVE_WAIT3
66 # define HAVE_WAIT_NOHANG
67 #endif
69 #ifndef HAVE_UNISTD_H
70 int chdir ();
71 #endif
72 #ifndef STDC_HEADERS
73 # ifndef sun /* Sun has an incorrect decl in a header. */
74 void exit (int) __attribute__ ((noreturn));
75 # endif
76 double atof ();
77 #endif
79 static void clean_jobserver (int status);
80 static void print_data_base (void);
81 static void print_version (void);
82 static void decode_switches (int argc, char **argv, int env);
83 static void decode_env_switches (char *envar, unsigned int len);
84 static const char *define_makeflags (int all, int makefile);
85 static char *quote_for_env (char *out, const char *in);
86 static void initialize_global_hash_tables (void);
89 /* The structure that describes an accepted command switch. */
91 struct command_switch
93 int c; /* The switch character. */
95 enum /* Type of the value. */
97 flag, /* Turn int flag on. */
98 flag_off, /* Turn int flag off. */
99 string, /* One string per switch. */
100 filename, /* A string containing a file name. */
101 positive_int, /* A positive integer. */
102 floating, /* A floating-point number (double). */
103 ignore /* Ignored. */
104 } type;
106 void *value_ptr; /* Pointer to the value-holding variable. */
108 unsigned int env:1; /* Can come from MAKEFLAGS. */
109 unsigned int toenv:1; /* Should be put in MAKEFLAGS. */
110 unsigned int no_makefile:1; /* Don't propagate when remaking makefiles. */
112 const void *noarg_value; /* Pointer to value used if no arg given. */
113 const void *default_value; /* Pointer to default value. */
115 char *long_name; /* Long option name. */
118 /* True if C is a switch value that corresponds to a short option. */
120 #define short_option(c) ((c) <= CHAR_MAX)
122 /* The structure used to hold the list of strings given
123 in command switches of a type that takes string arguments. */
125 struct stringlist
127 const char **list; /* Nil-terminated list of strings. */
128 unsigned int idx; /* Index into above. */
129 unsigned int max; /* Number of pointers allocated. */
133 /* The recognized command switches. */
135 /* Nonzero means do not print commands to be executed (-s). */
137 int silent_flag;
139 /* Nonzero means just touch the files
140 that would appear to need remaking (-t) */
142 int touch_flag;
144 /* Nonzero means just print what commands would need to be executed,
145 don't actually execute them (-n). */
147 int just_print_flag;
149 /* Print debugging info (--debug). */
151 static struct stringlist *db_flags;
152 static int debug_flag = 0;
154 int db_level = 0;
156 /* Tracing (--trace). */
158 int trace_flag = 0;
160 #ifdef WINDOWS32
161 /* Suspend make in main for a short time to allow debugger to attach */
163 int suspend_flag = 0;
164 #endif
166 /* Environment variables override makefile definitions. */
168 int env_overrides = 0;
170 /* Nonzero means ignore status codes returned by commands
171 executed to remake files. Just treat them all as successful (-i). */
173 int ignore_errors_flag = 0;
175 /* Nonzero means don't remake anything, just print the data base
176 that results from reading the makefile (-p). */
178 int print_data_base_flag = 0;
180 /* Nonzero means don't remake anything; just return a nonzero status
181 if the specified targets are not up to date (-q). */
183 int question_flag = 0;
185 /* Nonzero means do not use any of the builtin rules (-r) / variables (-R). */
187 int no_builtin_rules_flag = 0;
188 int no_builtin_variables_flag = 0;
190 /* Nonzero means keep going even if remaking some file fails (-k). */
192 int keep_going_flag;
193 int default_keep_going_flag = 0;
195 /* Nonzero means check symlink mtimes. */
197 int check_symlink_flag = 0;
199 /* Nonzero means print directory before starting and when done (-w). */
201 int print_directory_flag = 0;
203 /* Nonzero means ignore print_directory_flag and never print the directory.
204 This is necessary because print_directory_flag is set implicitly. */
206 int inhibit_print_directory_flag = 0;
208 /* Nonzero means print version information. */
210 int print_version_flag = 0;
212 /* List of makefiles given with -f switches. */
214 static struct stringlist *makefiles = 0;
216 /* Size of the stack when we started. */
218 #ifdef SET_STACK_SIZE
219 struct rlimit stack_limit;
220 #endif
223 /* Number of job slots (commands that can be run at once). */
225 unsigned int job_slots = 1;
226 unsigned int default_job_slots = 1;
227 static unsigned int master_job_slots = 0;
229 /* Value of job_slots that means no limit. */
231 static unsigned int inf_jobs = 0;
233 /* File descriptors for the jobs pipe. */
235 static struct stringlist *jobserver_fds = 0;
237 int job_fds[2] = { -1, -1 };
238 int job_rfd = -1;
240 /* Maximum load average at which multiple jobs will be run.
241 Negative values mean unlimited, while zero means limit to
242 zero load (which could be useful to start infinite jobs remotely
243 but one at a time locally). */
244 #ifndef NO_FLOAT
245 double max_load_average = -1.0;
246 double default_load_average = -1.0;
247 #else
248 int max_load_average = -1;
249 int default_load_average = -1;
250 #endif
252 /* List of directories given with -C switches. */
254 static struct stringlist *directories = 0;
256 /* List of include directories given with -I switches. */
258 static struct stringlist *include_directories = 0;
260 /* List of files given with -o switches. */
262 static struct stringlist *old_files = 0;
264 /* List of files given with -W switches. */
266 static struct stringlist *new_files = 0;
268 /* List of strings to be eval'd. */
269 static struct stringlist *eval_strings = 0;
271 /* If nonzero, we should just print usage and exit. */
273 static int print_usage_flag = 0;
275 /* If nonzero, we should print a warning message
276 for each reference to an undefined variable. */
278 int warn_undefined_variables_flag;
280 /* If nonzero, always build all targets, regardless of whether
281 they appear out of date or not. */
283 static int always_make_set = 0;
284 int always_make_flag = 0;
286 /* If nonzero, we're in the "try to rebuild makefiles" phase. */
288 int rebuilding_makefiles = 0;
290 /* Remember the original value of the SHELL variable, from the environment. */
292 struct variable shell_var;
294 /* This character introduces a command: it's the first char on the line. */
296 char cmd_prefix = '\t';
299 /* The usage output. We write it this way to make life easier for the
300 translators, especially those trying to translate to right-to-left
301 languages like Hebrew. */
303 static const char *const usage[] =
305 N_("Options:\n"),
306 N_("\
307 -b, -m Ignored for compatibility.\n"),
308 N_("\
309 -B, --always-make Unconditionally make all targets.\n"),
310 N_("\
311 -C DIRECTORY, --directory=DIRECTORY\n\
312 Change to DIRECTORY before doing anything.\n"),
313 N_("\
314 -d Print lots of debugging information.\n"),
315 N_("\
316 --debug[=FLAGS] Print various types of debugging information.\n"),
317 N_("\
318 -e, --environment-overrides\n\
319 Environment variables override makefiles.\n"),
320 N_("\
321 --eval=STRING Evaluate STRING as a makefile statement.\n"),
322 N_("\
323 -f FILE, --file=FILE, --makefile=FILE\n\
324 Read FILE as a makefile.\n"),
325 N_("\
326 -h, --help Print this message and exit.\n"),
327 N_("\
328 -i, --ignore-errors Ignore errors from recipes.\n"),
329 N_("\
330 -I DIRECTORY, --include-dir=DIRECTORY\n\
331 Search DIRECTORY for included makefiles.\n"),
332 N_("\
333 -j [N], --jobs[=N] Allow N jobs at once; infinite jobs with no arg.\n"),
334 N_("\
335 -k, --keep-going Keep going when some targets can't be made.\n"),
336 N_("\
337 -l [N], --load-average[=N], --max-load[=N]\n\
338 Don't start multiple jobs unless load is below N.\n"),
339 N_("\
340 -L, --check-symlink-times Use the latest mtime between symlinks and target.\n"),
341 N_("\
342 -n, --just-print, --dry-run, --recon\n\
343 Don't actually run any recipe; just print them.\n"),
344 N_("\
345 -o FILE, --old-file=FILE, --assume-old=FILE\n\
346 Consider FILE to be very old and don't remake it.\n"),
347 N_("\
348 -p, --print-data-base Print make's internal database.\n"),
349 N_("\
350 -q, --question Run no recipe; exit status says if up to date.\n"),
351 N_("\
352 -r, --no-builtin-rules Disable the built-in implicit rules.\n"),
353 N_("\
354 -R, --no-builtin-variables Disable the built-in variable settings.\n"),
355 N_("\
356 -s, --silent, --quiet Don't echo recipes.\n"),
357 N_("\
358 -S, --no-keep-going, --stop\n\
359 Turns off -k.\n"),
360 N_("\
361 -t, --touch Touch targets instead of remaking them.\n"),
362 N_("\
363 --trace Print tracing information.\n"),
364 N_("\
365 -v, --version Print the version number of make and exit.\n"),
366 N_("\
367 -w, --print-directory Print the current directory.\n"),
368 N_("\
369 --no-print-directory Turn off -w, even if it was turned on implicitly.\n"),
370 N_("\
371 -W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE\n\
372 Consider FILE to be infinitely new.\n"),
373 N_("\
374 --warn-undefined-variables Warn when an undefined variable is referenced.\n"),
375 NULL
378 /* The table of command switches. */
380 static const struct command_switch switches[] =
382 { 'b', ignore, 0, 0, 0, 0, 0, 0, 0 },
383 { 'B', flag, &always_make_set, 1, 1, 0, 0, 0, "always-make" },
384 { 'C', filename, &directories, 0, 0, 0, 0, 0, "directory" },
385 { 'd', flag, &debug_flag, 1, 1, 0, 0, 0, 0 },
386 { CHAR_MAX+1, string, &db_flags, 1, 1, 0, "basic", 0, "debug" },
387 #ifdef WINDOWS32
388 { 'D', flag, &suspend_flag, 1, 1, 0, 0, 0, "suspend-for-debug" },
389 #endif
390 { 'e', flag, &env_overrides, 1, 1, 0, 0, 0, "environment-overrides", },
391 { 'f', filename, &makefiles, 0, 0, 0, 0, 0, "file" },
392 { 'h', flag, &print_usage_flag, 0, 0, 0, 0, 0, "help" },
393 { 'i', flag, &ignore_errors_flag, 1, 1, 0, 0, 0, "ignore-errors" },
394 { 'I', filename, &include_directories, 1, 1, 0, 0, 0,
395 "include-dir" },
396 { 'j', positive_int, &job_slots, 1, 1, 0, &inf_jobs, &default_job_slots,
397 "jobs" },
398 { CHAR_MAX+2, string, &jobserver_fds, 1, 1, 0, 0, 0, "jobserver-fds" },
399 { 'k', flag, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
400 "keep-going" },
401 #ifndef NO_FLOAT
402 { 'l', floating, &max_load_average, 1, 1, 0, &default_load_average,
403 &default_load_average, "load-average" },
404 #else
405 { 'l', positive_int, &max_load_average, 1, 1, 0, &default_load_average,
406 &default_load_average, "load-average" },
407 #endif
408 { 'L', flag, &check_symlink_flag, 1, 1, 0, 0, 0, "check-symlink-times" },
409 { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },
410 { 'n', flag, &just_print_flag, 1, 1, 1, 0, 0, "just-print" },
411 { 'o', filename, &old_files, 0, 0, 0, 0, 0, "old-file" },
412 { 'p', flag, &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base" },
413 { 'q', flag, &question_flag, 1, 1, 1, 0, 0, "question" },
414 { 'r', flag, &no_builtin_rules_flag, 1, 1, 0, 0, 0, "no-builtin-rules" },
415 { 'R', flag, &no_builtin_variables_flag, 1, 1, 0, 0, 0,
416 "no-builtin-variables" },
417 { 's', flag, &silent_flag, 1, 1, 0, 0, 0, "silent" },
418 { 'S', flag_off, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
419 "no-keep-going" },
420 { 't', flag, &touch_flag, 1, 1, 1, 0, 0, "touch" },
421 { CHAR_MAX+3, flag, &trace_flag, 1, 1, 0, 0, 0, "trace" },
422 { 'v', flag, &print_version_flag, 1, 1, 0, 0, 0, "version" },
423 { 'w', flag, &print_directory_flag, 1, 1, 0, 0, 0, "print-directory" },
424 { CHAR_MAX+4, flag, &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
425 "no-print-directory" },
426 { 'W', filename, &new_files, 0, 0, 0, 0, 0, "what-if" },
427 { CHAR_MAX+5, flag, &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
428 "warn-undefined-variables" },
429 { CHAR_MAX+6, string, &eval_strings, 1, 0, 0, 0, 0, "eval" },
430 { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
433 /* Secondary long names for options. */
435 static struct option long_option_aliases[] =
437 { "quiet", no_argument, 0, 's' },
438 { "stop", no_argument, 0, 'S' },
439 { "new-file", required_argument, 0, 'W' },
440 { "assume-new", required_argument, 0, 'W' },
441 { "assume-old", required_argument, 0, 'o' },
442 { "max-load", optional_argument, 0, 'l' },
443 { "dry-run", no_argument, 0, 'n' },
444 { "recon", no_argument, 0, 'n' },
445 { "makefile", required_argument, 0, 'f' },
448 /* List of goal targets. */
450 static struct dep *goals, *lastgoal;
452 /* List of variables which were defined on the command line
453 (or, equivalently, in MAKEFLAGS). */
455 struct command_variable
457 struct command_variable *next;
458 struct variable *variable;
460 static struct command_variable *command_variables;
462 /* The name we were invoked with. */
464 char *program;
466 /* Our current directory before processing any -C options. */
468 char *directory_before_chdir;
470 /* Our current directory after processing all -C options. */
472 char *starting_directory;
474 /* Value of the MAKELEVEL variable at startup (or 0). */
476 unsigned int makelevel;
478 /* Pointer to the value of the .DEFAULT_GOAL special variable.
479 The value will be the name of the goal to remake if the command line
480 does not override it. It can be set by the makefile, or else it's
481 the first target defined in the makefile whose name does not start
482 with '.'. */
484 struct variable * default_goal_var;
486 /* Pointer to structure for the file .DEFAULT
487 whose commands are used for any file that has none of its own.
488 This is zero if the makefiles do not define .DEFAULT. */
490 struct file *default_file;
492 /* Nonzero if we have seen the magic `.POSIX' target.
493 This turns on pedantic compliance with POSIX.2. */
495 int posix_pedantic;
497 /* Nonzero if we have seen the '.SECONDEXPANSION' target.
498 This turns on secondary expansion of prerequisites. */
500 int second_expansion;
502 /* Nonzero if we have seen the '.ONESHELL' target.
503 This causes the entire recipe to be handed to SHELL
504 as a single string, potentially containing newlines. */
506 int one_shell;
508 /* Nonzero if we have seen the `.NOTPARALLEL' target.
509 This turns off parallel builds for this invocation of make. */
511 int not_parallel;
513 /* Nonzero if some rule detected clock skew; we keep track so (a) we only
514 print one warning about it during the run, and (b) we can print a final
515 warning at the end of the run. */
517 int clock_skew_detected;
519 /* Mask of signals that are being caught with fatal_error_signal. */
521 #ifdef POSIX
522 sigset_t fatal_signal_set;
523 #else
524 # ifdef HAVE_SIGSETMASK
525 int fatal_signal_mask;
526 # endif
527 #endif
529 #if !HAVE_DECL_BSD_SIGNAL && !defined bsd_signal
530 # if !defined HAVE_SIGACTION
531 # define bsd_signal signal
532 # else
533 typedef RETSIGTYPE (*bsd_signal_ret_t) (int);
535 static bsd_signal_ret_t
536 bsd_signal (int sig, bsd_signal_ret_t func)
538 struct sigaction act, oact;
539 act.sa_handler = func;
540 act.sa_flags = SA_RESTART;
541 sigemptyset (&act.sa_mask);
542 sigaddset (&act.sa_mask, sig);
543 if (sigaction (sig, &act, &oact) != 0)
544 return SIG_ERR;
545 return oact.sa_handler;
547 # endif
548 #endif
550 static void
551 initialize_global_hash_tables (void)
553 init_hash_global_variable_set ();
554 strcache_init ();
555 init_hash_files ();
556 hash_init_directories ();
557 hash_init_function_table ();
560 static const char *
561 expand_command_line_file (char *name)
563 const char *cp;
564 char *expanded = 0;
566 if (name[0] == '\0')
567 fatal (NILF, _("empty string invalid as file name"));
569 if (name[0] == '~')
571 expanded = tilde_expand (name);
572 if (expanded != 0)
573 name = expanded;
576 /* This is also done in parse_file_seq, so this is redundant
577 for names read from makefiles. It is here for names passed
578 on the command line. */
579 while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
581 name += 2;
582 while (*name == '/')
583 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
584 ++name;
587 if (*name == '\0')
589 /* It was all slashes! Move back to the dot and truncate
590 it after the first slash, so it becomes just "./". */
592 --name;
593 while (name[0] != '.');
594 name[2] = '\0';
597 cp = strcache_add (name);
599 if (expanded)
600 free (expanded);
602 return cp;
605 /* Toggle -d on receipt of SIGUSR1. */
607 #ifdef SIGUSR1
608 static RETSIGTYPE
609 debug_signal_handler (int sig UNUSED)
611 db_level = db_level ? DB_NONE : DB_BASIC;
613 #endif
615 static void
616 decode_debug_flags (void)
618 const char **pp;
620 if (debug_flag)
621 db_level = DB_ALL;
623 if (!db_flags)
624 return;
626 for (pp=db_flags->list; *pp; ++pp)
628 const char *p = *pp;
630 while (1)
632 switch (tolower (p[0]))
634 case 'a':
635 db_level |= DB_ALL;
636 break;
637 case 'b':
638 db_level |= DB_BASIC;
639 break;
640 case 'i':
641 db_level |= DB_BASIC | DB_IMPLICIT;
642 break;
643 case 'j':
644 db_level |= DB_JOBS;
645 break;
646 case 'm':
647 db_level |= DB_BASIC | DB_MAKEFILES;
648 break;
649 case 'v':
650 db_level |= DB_BASIC | DB_VERBOSE;
651 break;
652 default:
653 fatal (NILF, _("unknown debug level specification `%s'"), p);
656 while (*(++p) != '\0')
657 if (*p == ',' || *p == ' ')
658 break;
660 if (*p == '\0')
661 break;
663 ++p;
668 #ifdef WINDOWS32
670 * HANDLE runtime exceptions by avoiding a requestor on the GUI. Capture
671 * exception and print it to stderr instead.
673 * If ! DB_VERBOSE, just print a simple message and exit.
674 * If DB_VERBOSE, print a more verbose message.
675 * If compiled for DEBUG, let exception pass through to GUI so that
676 * debuggers can attach.
678 LONG WINAPI
679 handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
681 PEXCEPTION_RECORD exrec = exinfo->ExceptionRecord;
682 LPSTR cmdline = GetCommandLine();
683 LPSTR prg = strtok(cmdline, " ");
684 CHAR errmsg[1024];
685 #ifdef USE_EVENT_LOG
686 HANDLE hEventSource;
687 LPTSTR lpszStrings[1];
688 #endif
690 if (! ISDB (DB_VERBOSE))
692 sprintf(errmsg,
693 _("%s: Interrupt/Exception caught (code = 0x%lx, addr = 0x%p)\n"),
694 prg, exrec->ExceptionCode, exrec->ExceptionAddress);
695 fprintf(stderr, errmsg);
696 exit(255);
699 sprintf(errmsg,
700 _("\nUnhandled exception filter called from program %s\nExceptionCode = %lx\nExceptionFlags = %lx\nExceptionAddress = 0x%p\n"),
701 prg, exrec->ExceptionCode, exrec->ExceptionFlags,
702 exrec->ExceptionAddress);
704 if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION
705 && exrec->NumberParameters >= 2)
706 sprintf(&errmsg[strlen(errmsg)],
707 (exrec->ExceptionInformation[0]
708 ? _("Access violation: write operation at address 0x%p\n")
709 : _("Access violation: read operation at address 0x%p\n")),
710 (PVOID)exrec->ExceptionInformation[1]);
712 /* turn this on if we want to put stuff in the event log too */
713 #ifdef USE_EVENT_LOG
714 hEventSource = RegisterEventSource(NULL, "GNU Make");
715 lpszStrings[0] = errmsg;
717 if (hEventSource != NULL)
719 ReportEvent(hEventSource, /* handle of event source */
720 EVENTLOG_ERROR_TYPE, /* event type */
721 0, /* event category */
722 0, /* event ID */
723 NULL, /* current user's SID */
724 1, /* strings in lpszStrings */
725 0, /* no bytes of raw data */
726 lpszStrings, /* array of error strings */
727 NULL); /* no raw data */
729 (VOID) DeregisterEventSource(hEventSource);
731 #endif
733 /* Write the error to stderr too */
734 fprintf(stderr, errmsg);
736 #ifdef DEBUG
737 return EXCEPTION_CONTINUE_SEARCH;
738 #else
739 exit(255);
740 return (255); /* not reached */
741 #endif
745 * On WIN32 systems we don't have the luxury of a /bin directory that
746 * is mapped globally to every drive mounted to the system. Since make could
747 * be invoked from any drive, and we don't want to propogate /bin/sh
748 * to every single drive. Allow ourselves a chance to search for
749 * a value for default shell here (if the default path does not exist).
753 find_and_set_default_shell (const char *token)
755 int sh_found = 0;
756 char *atoken = 0;
757 char *search_token;
758 char *tokend;
759 PATH_VAR(sh_path);
760 extern char *default_shell;
762 if (!token)
763 search_token = default_shell;
764 else
765 atoken = search_token = xstrdup (token);
767 /* If the user explicitly requests the DOS cmd shell, obey that request.
768 However, make sure that's what they really want by requiring the value
769 of SHELL either equal, or have a final path element of, "cmd" or
770 "cmd.exe" case-insensitive. */
771 tokend = search_token + strlen (search_token) - 3;
772 if (((tokend == search_token
773 || (tokend > search_token
774 && (tokend[-1] == '/' || tokend[-1] == '\\')))
775 && !strcasecmp (tokend, "cmd"))
776 || ((tokend - 4 == search_token
777 || (tokend - 4 > search_token
778 && (tokend[-5] == '/' || tokend[-5] == '\\')))
779 && !strcasecmp (tokend - 4, "cmd.exe"))) {
780 batch_mode_shell = 1;
781 unixy_shell = 0;
782 sprintf (sh_path, "%s", search_token);
783 default_shell = xstrdup (w32ify (sh_path, 0));
784 DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
785 default_shell));
786 sh_found = 1;
787 } else if (!no_default_sh_exe &&
788 (token == NULL || !strcmp (search_token, default_shell))) {
789 /* no new information, path already set or known */
790 sh_found = 1;
791 } else if (file_exists_p (search_token)) {
792 /* search token path was found */
793 sprintf (sh_path, "%s", search_token);
794 default_shell = xstrdup (w32ify (sh_path, 0));
795 DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
796 default_shell));
797 sh_found = 1;
798 } else {
799 char *p;
800 struct variable *v = lookup_variable (STRING_SIZE_TUPLE ("PATH"));
802 /* Search Path for shell */
803 if (v && v->value) {
804 char *ep;
806 p = v->value;
807 ep = strchr (p, PATH_SEPARATOR_CHAR);
809 while (ep && *ep) {
810 *ep = '\0';
812 if (dir_file_exists_p (p, search_token)) {
813 sprintf (sh_path, "%s/%s", p, search_token);
814 default_shell = xstrdup (w32ify (sh_path, 0));
815 sh_found = 1;
816 *ep = PATH_SEPARATOR_CHAR;
818 /* terminate loop */
819 p += strlen (p);
820 } else {
821 *ep = PATH_SEPARATOR_CHAR;
822 p = ++ep;
825 ep = strchr (p, PATH_SEPARATOR_CHAR);
828 /* be sure to check last element of Path */
829 if (p && *p && dir_file_exists_p (p, search_token)) {
830 sprintf (sh_path, "%s/%s", p, search_token);
831 default_shell = xstrdup (w32ify (sh_path, 0));
832 sh_found = 1;
835 if (sh_found)
836 DB (DB_VERBOSE,
837 (_("find_and_set_shell() path search set default_shell = %s\n"),
838 default_shell));
842 /* naive test */
843 if (!unixy_shell && sh_found &&
844 (strstr (default_shell, "sh") || strstr (default_shell, "SH"))) {
845 unixy_shell = 1;
846 batch_mode_shell = 0;
849 #ifdef BATCH_MODE_ONLY_SHELL
850 batch_mode_shell = 1;
851 #endif
853 if (atoken)
854 free (atoken);
856 return (sh_found);
858 #endif /* WINDOWS32 */
860 #ifdef __MSDOS__
861 static void
862 msdos_return_to_initial_directory (void)
864 if (directory_before_chdir)
865 chdir (directory_before_chdir);
867 #endif /* __MSDOS__ */
869 char *mktemp (char *template);
870 int mkstemp (char *template);
872 FILE *
873 open_tmpfile(char **name, const char *template)
875 #ifdef HAVE_FDOPEN
876 int fd;
877 #endif
879 #if defined HAVE_MKSTEMP || defined HAVE_MKTEMP
880 # define TEMPLATE_LEN strlen (template)
881 #else
882 # define TEMPLATE_LEN L_tmpnam
883 #endif
884 *name = xmalloc (TEMPLATE_LEN + 1);
885 strcpy (*name, template);
887 #if defined HAVE_MKSTEMP && defined HAVE_FDOPEN
888 /* It's safest to use mkstemp(), if we can. */
889 fd = mkstemp (*name);
890 if (fd == -1)
891 return 0;
892 return fdopen (fd, "w");
893 #else
894 # ifdef HAVE_MKTEMP
895 (void) mktemp (*name);
896 # else
897 (void) tmpnam (*name);
898 # endif
900 # ifdef HAVE_FDOPEN
901 /* Can't use mkstemp(), but guard against a race condition. */
902 fd = open (*name, O_CREAT|O_EXCL|O_WRONLY, 0600);
903 if (fd == -1)
904 return 0;
905 return fdopen (fd, "w");
906 # else
907 /* Not secure, but what can we do? */
908 return fopen (*name, "w");
909 # endif
910 #endif
913 #ifdef _AMIGA
915 main (int argc, char **argv)
916 #else
918 main (int argc, char **argv, char **envp)
919 #endif
921 static char *stdin_nm = 0;
922 int makefile_status = MAKE_SUCCESS;
923 struct dep *read_makefiles;
924 PATH_VAR (current_directory);
925 unsigned int restarts = 0;
926 #ifdef WINDOWS32
927 char *unix_path = NULL;
928 char *windows32_path = NULL;
930 SetUnhandledExceptionFilter(handle_runtime_exceptions);
932 /* start off assuming we have no shell */
933 unixy_shell = 0;
934 no_default_sh_exe = 1;
935 #endif
937 #ifdef SET_STACK_SIZE
938 /* Get rid of any avoidable limit on stack size. */
940 struct rlimit rlim;
942 /* Set the stack limit huge so that alloca does not fail. */
943 if (getrlimit (RLIMIT_STACK, &rlim) == 0
944 && rlim.rlim_cur > 0 && rlim.rlim_cur < rlim.rlim_max)
946 stack_limit = rlim;
947 rlim.rlim_cur = rlim.rlim_max;
948 setrlimit (RLIMIT_STACK, &rlim);
950 else
951 stack_limit.rlim_cur = 0;
953 #endif
955 #ifdef HAVE_ATEXIT
956 atexit (close_stdout);
957 #endif
959 /* Needed for OS/2 */
960 initialize_main (&argc, &argv);
962 reading_file = 0;
964 #if defined (__MSDOS__) && !defined (_POSIX_SOURCE)
965 /* Request the most powerful version of `system', to
966 make up for the dumb default shell. */
967 __system_flags = (__system_redirect
968 | __system_use_shell
969 | __system_allow_multiple_cmds
970 | __system_allow_long_cmds
971 | __system_handle_null_commands
972 | __system_emulate_chdir);
974 #endif
976 /* Set up gettext/internationalization support. */
977 setlocale (LC_ALL, "");
978 /* The cast to void shuts up compiler warnings on systems that
979 disable NLS. */
980 (void)bindtextdomain (PACKAGE, LOCALEDIR);
981 (void)textdomain (PACKAGE);
983 #ifdef POSIX
984 sigemptyset (&fatal_signal_set);
985 #define ADD_SIG(sig) sigaddset (&fatal_signal_set, sig)
986 #else
987 #ifdef HAVE_SIGSETMASK
988 fatal_signal_mask = 0;
989 #define ADD_SIG(sig) fatal_signal_mask |= sigmask (sig)
990 #else
991 #define ADD_SIG(sig) (void)sig
992 #endif
993 #endif
995 #define FATAL_SIG(sig) \
996 if (bsd_signal (sig, fatal_error_signal) == SIG_IGN) \
997 bsd_signal (sig, SIG_IGN); \
998 else \
999 ADD_SIG (sig);
1001 #ifdef SIGHUP
1002 FATAL_SIG (SIGHUP);
1003 #endif
1004 #ifdef SIGQUIT
1005 FATAL_SIG (SIGQUIT);
1006 #endif
1007 FATAL_SIG (SIGINT);
1008 FATAL_SIG (SIGTERM);
1010 #ifdef __MSDOS__
1011 /* Windows 9X delivers FP exceptions in child programs to their
1012 parent! We don't want Make to die when a child divides by zero,
1013 so we work around that lossage by catching SIGFPE. */
1014 FATAL_SIG (SIGFPE);
1015 #endif
1017 #ifdef SIGDANGER
1018 FATAL_SIG (SIGDANGER);
1019 #endif
1020 #ifdef SIGXCPU
1021 FATAL_SIG (SIGXCPU);
1022 #endif
1023 #ifdef SIGXFSZ
1024 FATAL_SIG (SIGXFSZ);
1025 #endif
1027 #undef FATAL_SIG
1029 /* Do not ignore the child-death signal. This must be done before
1030 any children could possibly be created; otherwise, the wait
1031 functions won't work on systems with the SVR4 ECHILD brain
1032 damage, if our invoker is ignoring this signal. */
1034 #ifdef HAVE_WAIT_NOHANG
1035 # if defined SIGCHLD
1036 (void) bsd_signal (SIGCHLD, SIG_DFL);
1037 # endif
1038 # if defined SIGCLD && SIGCLD != SIGCHLD
1039 (void) bsd_signal (SIGCLD, SIG_DFL);
1040 # endif
1041 #endif
1043 /* Make sure stdout is line-buffered. */
1045 #ifdef HAVE_SETVBUF
1046 # ifdef SETVBUF_REVERSED
1047 setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ);
1048 # else /* setvbuf not reversed. */
1049 /* Some buggy systems lose if we pass 0 instead of allocating ourselves. */
1050 setvbuf (stdout, 0, _IOLBF, BUFSIZ);
1051 # endif /* setvbuf reversed. */
1052 #elif HAVE_SETLINEBUF
1053 setlinebuf (stdout);
1054 #endif /* setlinebuf missing. */
1056 /* Figure out where this program lives. */
1058 if (argv[0] == 0)
1059 argv[0] = "";
1060 if (argv[0][0] == '\0')
1061 program = "make";
1062 else
1064 #ifdef VMS
1065 program = strrchr (argv[0], ']');
1066 #else
1067 program = strrchr (argv[0], '/');
1068 #endif
1069 #if defined(__MSDOS__) || defined(__EMX__)
1070 if (program == 0)
1071 program = strrchr (argv[0], '\\');
1072 else
1074 /* Some weird environments might pass us argv[0] with
1075 both kinds of slashes; we must find the rightmost. */
1076 char *p = strrchr (argv[0], '\\');
1077 if (p && p > program)
1078 program = p;
1080 if (program == 0 && argv[0][1] == ':')
1081 program = argv[0] + 1;
1082 #endif
1083 #ifdef WINDOWS32
1084 if (program == 0)
1086 /* Extract program from full path */
1087 int argv0_len;
1088 program = strrchr (argv[0], '\\');
1089 if (program)
1091 argv0_len = strlen (program);
1092 if (argv0_len > 4 && streq (&program[argv0_len - 4], ".exe"))
1093 /* Remove .exe extension */
1094 program[argv0_len - 4] = '\0';
1097 #endif
1098 if (program == 0)
1099 program = argv[0];
1100 else
1101 ++program;
1104 /* Set up to access user data (files). */
1105 user_access ();
1107 initialize_global_hash_tables ();
1109 /* Figure out where we are. */
1111 #ifdef WINDOWS32
1112 if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1113 #else
1114 if (getcwd (current_directory, GET_PATH_MAX) == 0)
1115 #endif
1117 #ifdef HAVE_GETCWD
1118 perror_with_name ("getcwd", "");
1119 #else
1120 error (NILF, "getwd: %s", current_directory);
1121 #endif
1122 current_directory[0] = '\0';
1123 directory_before_chdir = 0;
1125 else
1126 directory_before_chdir = xstrdup (current_directory);
1128 #ifdef __MSDOS__
1129 /* Make sure we will return to the initial directory, come what may. */
1130 atexit (msdos_return_to_initial_directory);
1131 #endif
1133 /* Initialize the special variables. */
1134 define_variable_cname (".VARIABLES", "", o_default, 0)->special = 1;
1135 /* define_variable_cname (".TARGETS", "", o_default, 0)->special = 1; */
1136 define_variable_cname (".RECIPEPREFIX", "", o_default, 0)->special = 1;
1137 define_variable_cname (".SHELLFLAGS", "-c", o_default, 0);
1139 /* Set up .FEATURES
1140 Use a separate variable because define_variable_cname() is a macro and
1141 some compilers (MSVC) don't like conditionals in macros. */
1143 const char *features = "target-specific order-only second-expansion"
1144 " else-if shortest-stem undefine oneshell"
1145 #ifndef NO_ARCHIVES
1146 " archives"
1147 #endif
1148 #ifdef MAKE_JOBSERVER
1149 " jobserver"
1150 #endif
1151 #ifdef MAKE_SYMLINKS
1152 " check-symlink"
1153 #endif
1156 define_variable_cname (".FEATURES", features, o_default, 0);
1159 #ifdef HAVE_GUILE
1160 /* Configure GNU Guile support */
1161 setup_guile ();
1162 #endif
1164 /* Read in variables from the environment. It is important that this be
1165 done before $(MAKE) is figured out so its definitions will not be
1166 from the environment. */
1168 #ifndef _AMIGA
1170 unsigned int i;
1172 for (i = 0; envp[i] != 0; ++i)
1174 int do_not_define = 0;
1175 char *ep = envp[i];
1177 while (*ep != '\0' && *ep != '=')
1178 ++ep;
1179 #ifdef WINDOWS32
1180 if (!unix_path && strneq (envp[i], "PATH=", 5))
1181 unix_path = ep+1;
1182 else if (!strnicmp (envp[i], "Path=", 5)) {
1183 do_not_define = 1; /* it gets defined after loop exits */
1184 if (!windows32_path)
1185 windows32_path = ep+1;
1187 #endif
1188 /* The result of pointer arithmetic is cast to unsigned int for
1189 machines where ptrdiff_t is a different size that doesn't widen
1190 the same. */
1191 if (!do_not_define)
1193 struct variable *v;
1195 v = define_variable (envp[i], (unsigned int) (ep - envp[i]),
1196 ep + 1, o_env, 1);
1197 /* Force exportation of every variable culled from the
1198 environment. We used to rely on target_environment's
1199 v_default code to do this. But that does not work for the
1200 case where an environment variable is redefined in a makefile
1201 with `override'; it should then still be exported, because it
1202 was originally in the environment. */
1203 v->export = v_export;
1205 /* Another wrinkle is that POSIX says the value of SHELL set in
1206 the makefile won't change the value of SHELL given to
1207 subprocesses. */
1208 if (streq (v->name, "SHELL"))
1210 #ifndef __MSDOS__
1211 v->export = v_noexport;
1212 #endif
1213 shell_var.name = "SHELL";
1214 shell_var.length = 5;
1215 shell_var.value = xstrdup (ep + 1);
1218 /* If MAKE_RESTARTS is set, remember it but don't export it. */
1219 if (streq (v->name, "MAKE_RESTARTS"))
1221 v->export = v_noexport;
1222 restarts = (unsigned int) atoi (ep + 1);
1227 #ifdef WINDOWS32
1228 /* If we didn't find a correctly spelled PATH we define PATH as
1229 * either the first mispelled value or an empty string
1231 if (!unix_path)
1232 define_variable_cname ("PATH", windows32_path ? windows32_path : "",
1233 o_env, 1)->export = v_export;
1234 #endif
1235 #else /* For Amiga, read the ENV: device, ignoring all dirs */
1237 BPTR env, file, old;
1238 char buffer[1024];
1239 int len;
1240 __aligned struct FileInfoBlock fib;
1242 env = Lock ("ENV:", ACCESS_READ);
1243 if (env)
1245 old = CurrentDir (DupLock(env));
1246 Examine (env, &fib);
1248 while (ExNext (env, &fib))
1250 if (fib.fib_DirEntryType < 0) /* File */
1252 /* Define an empty variable. It will be filled in
1253 variable_lookup(). Makes startup quite a bit
1254 faster. */
1255 define_variable (fib.fib_FileName,
1256 strlen (fib.fib_FileName),
1257 "", o_env, 1)->export = v_export;
1260 UnLock (env);
1261 UnLock(CurrentDir(old));
1264 #endif
1266 /* Decode the switches. */
1268 decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
1269 #if 0
1270 /* People write things like:
1271 MFLAGS="CC=gcc -pipe" "CFLAGS=-g"
1272 and we set the -p, -i and -e switches. Doesn't seem quite right. */
1273 decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
1274 #endif
1276 decode_switches (argc, argv, 0);
1278 #ifdef WINDOWS32
1279 if (suspend_flag) {
1280 fprintf(stderr, "%s (pid = %ld)\n", argv[0], GetCurrentProcessId());
1281 fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]);
1282 Sleep(30 * 1000);
1283 fprintf(stderr, _("done sleep(30). Continuing.\n"));
1285 #endif
1287 decode_debug_flags ();
1289 /* Set always_make_flag if -B was given and we've not restarted already. */
1290 always_make_flag = always_make_set && (restarts == 0);
1292 /* Print version information. */
1293 if (print_version_flag || print_data_base_flag || ISDB (DB_BASIC))
1295 print_version ();
1297 /* `make --version' is supposed to just print the version and exit. */
1298 if (print_version_flag)
1299 die (0);
1302 #ifndef VMS
1303 /* Set the "MAKE_COMMAND" variable to the name we were invoked with.
1304 (If it is a relative pathname with a slash, prepend our directory name
1305 so the result will run the same program regardless of the current dir.
1306 If it is a name with no slash, we can only hope that PATH did not
1307 find it in the current directory.) */
1308 #ifdef WINDOWS32
1310 * Convert from backslashes to forward slashes for
1311 * programs like sh which don't like them. Shouldn't
1312 * matter if the path is one way or the other for
1313 * CreateProcess().
1315 if (strpbrk(argv[0], "/:\\") ||
1316 strstr(argv[0], "..") ||
1317 strneq(argv[0], "//", 2))
1318 argv[0] = xstrdup(w32ify(argv[0],1));
1319 #else /* WINDOWS32 */
1320 #if defined (__MSDOS__) || defined (__EMX__)
1321 if (strchr (argv[0], '\\'))
1323 char *p;
1325 argv[0] = xstrdup (argv[0]);
1326 for (p = argv[0]; *p; p++)
1327 if (*p == '\\')
1328 *p = '/';
1330 /* If argv[0] is not in absolute form, prepend the current
1331 directory. This can happen when Make is invoked by another DJGPP
1332 program that uses a non-absolute name. */
1333 if (current_directory[0] != '\0'
1334 && argv[0] != 0
1335 && (argv[0][0] != '/' && (argv[0][0] == '\0' || argv[0][1] != ':'))
1336 # ifdef __EMX__
1337 /* do not prepend cwd if argv[0] contains no '/', e.g. "make" */
1338 && (strchr (argv[0], '/') != 0 || strchr (argv[0], '\\') != 0)
1339 # endif
1341 argv[0] = xstrdup (concat (3, current_directory, "/", argv[0]));
1342 #else /* !__MSDOS__ */
1343 if (current_directory[0] != '\0'
1344 && argv[0] != 0 && argv[0][0] != '/' && strchr (argv[0], '/') != 0
1345 #ifdef HAVE_DOS_PATHS
1346 && (argv[0][0] != '\\' && (!argv[0][0] || argv[0][1] != ':'))
1347 && strchr (argv[0], '\\') != 0
1348 #endif
1350 argv[0] = xstrdup (concat (3, current_directory, "/", argv[0]));
1351 #endif /* !__MSDOS__ */
1352 #endif /* WINDOWS32 */
1353 #endif
1355 /* The extra indirection through $(MAKE_COMMAND) is done
1356 for hysterical raisins. */
1357 define_variable_cname ("MAKE_COMMAND", argv[0], o_default, 0);
1358 define_variable_cname ("MAKE", "$(MAKE_COMMAND)", o_default, 1);
1360 if (command_variables != 0)
1362 struct command_variable *cv;
1363 struct variable *v;
1364 unsigned int len = 0;
1365 char *value, *p;
1367 /* Figure out how much space will be taken up by the command-line
1368 variable definitions. */
1369 for (cv = command_variables; cv != 0; cv = cv->next)
1371 v = cv->variable;
1372 len += 2 * strlen (v->name);
1373 if (! v->recursive)
1374 ++len;
1375 ++len;
1376 len += 2 * strlen (v->value);
1377 ++len;
1380 /* Now allocate a buffer big enough and fill it. */
1381 p = value = alloca (len);
1382 for (cv = command_variables; cv != 0; cv = cv->next)
1384 v = cv->variable;
1385 p = quote_for_env (p, v->name);
1386 if (! v->recursive)
1387 *p++ = ':';
1388 *p++ = '=';
1389 p = quote_for_env (p, v->value);
1390 *p++ = ' ';
1392 p[-1] = '\0'; /* Kill the final space and terminate. */
1394 /* Define an unchangeable variable with a name that no POSIX.2
1395 makefile could validly use for its own variable. */
1396 define_variable_cname ("-*-command-variables-*-", value, o_automatic, 0);
1398 /* Define the variable; this will not override any user definition.
1399 Normally a reference to this variable is written into the value of
1400 MAKEFLAGS, allowing the user to override this value to affect the
1401 exported value of MAKEFLAGS. In POSIX-pedantic mode, we cannot
1402 allow the user's setting of MAKEOVERRIDES to affect MAKEFLAGS, so
1403 a reference to this hidden variable is written instead. */
1404 define_variable_cname ("MAKEOVERRIDES", "${-*-command-variables-*-}",
1405 o_env, 1);
1408 /* If there were -C flags, move ourselves about. */
1409 if (directories != 0)
1411 unsigned int i;
1412 for (i = 0; directories->list[i] != 0; ++i)
1414 const char *dir = directories->list[i];
1415 #ifdef WINDOWS32
1416 /* WINDOWS32 chdir() doesn't work if the directory has a trailing '/'
1417 But allow -C/ just in case someone wants that. */
1419 char *p = (char *)dir + strlen (dir) - 1;
1420 while (p > dir && (p[0] == '/' || p[0] == '\\'))
1421 --p;
1422 p[1] = '\0';
1424 #endif
1425 if (chdir (dir) < 0)
1426 pfatal_with_name (dir);
1430 #ifdef WINDOWS32
1432 * THIS BLOCK OF CODE MUST COME AFTER chdir() CALL ABOVE IN ORDER
1433 * TO NOT CONFUSE THE DEPENDENCY CHECKING CODE IN implicit.c.
1435 * The functions in dir.c can incorrectly cache information for "."
1436 * before we have changed directory and this can cause file
1437 * lookups to fail because the current directory (.) was pointing
1438 * at the wrong place when it was first evaluated.
1440 no_default_sh_exe = !find_and_set_default_shell(NULL);
1442 #endif /* WINDOWS32 */
1443 /* Figure out the level of recursion. */
1445 struct variable *v = lookup_variable (STRING_SIZE_TUPLE (MAKELEVEL_NAME));
1446 if (v != 0 && v->value[0] != '\0' && v->value[0] != '-')
1447 makelevel = (unsigned int) atoi (v->value);
1448 else
1449 makelevel = 0;
1452 /* Except under -s, always do -w in sub-makes and under -C. */
1453 if (!silent_flag && (directories != 0 || makelevel > 0))
1454 print_directory_flag = 1;
1456 /* Let the user disable that with --no-print-directory. */
1457 if (inhibit_print_directory_flag)
1458 print_directory_flag = 0;
1460 /* If -R was given, set -r too (doesn't make sense otherwise!) */
1461 if (no_builtin_variables_flag)
1462 no_builtin_rules_flag = 1;
1464 /* Construct the list of include directories to search. */
1466 construct_include_path (include_directories == 0
1467 ? 0 : include_directories->list);
1469 /* Figure out where we are now, after chdir'ing. */
1470 if (directories == 0)
1471 /* We didn't move, so we're still in the same place. */
1472 starting_directory = current_directory;
1473 else
1475 #ifdef WINDOWS32
1476 if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1477 #else
1478 if (getcwd (current_directory, GET_PATH_MAX) == 0)
1479 #endif
1481 #ifdef HAVE_GETCWD
1482 perror_with_name ("getcwd", "");
1483 #else
1484 error (NILF, "getwd: %s", current_directory);
1485 #endif
1486 starting_directory = 0;
1488 else
1489 starting_directory = current_directory;
1492 define_variable_cname ("CURDIR", current_directory, o_file, 0);
1494 /* Read any stdin makefiles into temporary files. */
1496 if (makefiles != 0)
1498 unsigned int i;
1499 for (i = 0; i < makefiles->idx; ++i)
1500 if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0')
1502 /* This makefile is standard input. Since we may re-exec
1503 and thus re-read the makefiles, we read standard input
1504 into a temporary file and read from that. */
1505 FILE *outfile;
1506 char *template, *tmpdir;
1508 if (stdin_nm)
1509 fatal (NILF, _("Makefile from standard input specified twice."));
1511 #ifdef VMS
1512 # define DEFAULT_TMPDIR "sys$scratch:"
1513 #else
1514 # ifdef P_tmpdir
1515 # define DEFAULT_TMPDIR P_tmpdir
1516 # else
1517 # define DEFAULT_TMPDIR "/tmp"
1518 # endif
1519 #endif
1520 #define DEFAULT_TMPFILE "GmXXXXXX"
1522 if (((tmpdir = getenv ("TMPDIR")) == NULL || *tmpdir == '\0')
1523 #if defined (__MSDOS__) || defined (WINDOWS32) || defined (__EMX__)
1524 /* These are also used commonly on these platforms. */
1525 && ((tmpdir = getenv ("TEMP")) == NULL || *tmpdir == '\0')
1526 && ((tmpdir = getenv ("TMP")) == NULL || *tmpdir == '\0')
1527 #endif
1529 tmpdir = DEFAULT_TMPDIR;
1531 template = alloca (strlen (tmpdir) + sizeof (DEFAULT_TMPFILE) + 1);
1532 strcpy (template, tmpdir);
1534 #ifdef HAVE_DOS_PATHS
1535 if (strchr ("/\\", template[strlen (template) - 1]) == NULL)
1536 strcat (template, "/");
1537 #else
1538 # ifndef VMS
1539 if (template[strlen (template) - 1] != '/')
1540 strcat (template, "/");
1541 # endif /* !VMS */
1542 #endif /* !HAVE_DOS_PATHS */
1544 strcat (template, DEFAULT_TMPFILE);
1545 outfile = open_tmpfile (&stdin_nm, template);
1546 if (outfile == 0)
1547 pfatal_with_name (_("fopen (temporary file)"));
1548 while (!feof (stdin) && ! ferror (stdin))
1550 char buf[2048];
1551 unsigned int n = fread (buf, 1, sizeof (buf), stdin);
1552 if (n > 0 && fwrite (buf, 1, n, outfile) != n)
1553 pfatal_with_name (_("fwrite (temporary file)"));
1555 fclose (outfile);
1557 /* Replace the name that read_all_makefiles will
1558 see with the name of the temporary file. */
1559 makefiles->list[i] = strcache_add (stdin_nm);
1561 /* Make sure the temporary file will not be remade. */
1563 struct file *f = enter_file (strcache_add (stdin_nm));
1564 f->updated = 1;
1565 f->update_status = 0;
1566 f->command_state = cs_finished;
1567 /* Can't be intermediate, or it'll be removed too early for
1568 make re-exec. */
1569 f->intermediate = 0;
1570 f->dontcare = 0;
1575 #ifndef __EMX__ /* Don't use a SIGCHLD handler for OS/2 */
1576 #if defined(MAKE_JOBSERVER) || !defined(HAVE_WAIT_NOHANG)
1577 /* Set up to handle children dying. This must be done before
1578 reading in the makefiles so that `shell' function calls will work.
1580 If we don't have a hanging wait we have to fall back to old, broken
1581 functionality here and rely on the signal handler and counting
1582 children.
1584 If we're using the jobs pipe we need a signal handler so that
1585 SIGCHLD is not ignored; we need it to interrupt the read(2) of the
1586 jobserver pipe in job.c if we're waiting for a token.
1588 If none of these are true, we don't need a signal handler at all. */
1590 RETSIGTYPE child_handler (int sig);
1591 # if defined SIGCHLD
1592 bsd_signal (SIGCHLD, child_handler);
1593 # endif
1594 # if defined SIGCLD && SIGCLD != SIGCHLD
1595 bsd_signal (SIGCLD, child_handler);
1596 # endif
1598 #endif
1599 #endif
1601 /* Let the user send us SIGUSR1 to toggle the -d flag during the run. */
1602 #ifdef SIGUSR1
1603 bsd_signal (SIGUSR1, debug_signal_handler);
1604 #endif
1606 /* Define the initial list of suffixes for old-style rules. */
1608 set_default_suffixes ();
1610 /* Define the file rules for the built-in suffix rules. These will later
1611 be converted into pattern rules. We used to do this in
1612 install_default_implicit_rules, but since that happens after reading
1613 makefiles, it results in the built-in pattern rules taking precedence
1614 over makefile-specified suffix rules, which is wrong. */
1616 install_default_suffix_rules ();
1618 /* Define some internal and special variables. */
1620 define_automatic_variables ();
1622 /* Set up the MAKEFLAGS and MFLAGS variables
1623 so makefiles can look at them. */
1625 define_makeflags (0, 0);
1627 /* Define the default variables. */
1628 define_default_variables ();
1630 default_file = enter_file (strcache_add (".DEFAULT"));
1632 default_goal_var = define_variable_cname (".DEFAULT_GOAL", "", o_file, 0);
1634 /* Evaluate all strings provided with --eval.
1635 Also set up the $(-*-eval-flags-*-) variable. */
1637 if (eval_strings)
1639 char *p, *value;
1640 unsigned int i;
1641 unsigned int len = sizeof ("--eval=") * eval_strings->idx;
1643 for (i = 0; i < eval_strings->idx; ++i)
1645 p = xstrdup (eval_strings->list[i]);
1646 len += 2 * strlen (p);
1647 eval_buffer (p);
1648 free (p);
1651 p = value = alloca (len);
1652 for (i = 0; i < eval_strings->idx; ++i)
1654 strcpy (p, "--eval=");
1655 p += strlen (p);
1656 p = quote_for_env (p, eval_strings->list[i]);
1657 *(p++) = ' ';
1659 p[-1] = '\0';
1661 define_variable_cname ("-*-eval-flags-*-", value, o_automatic, 0);
1664 /* Read all the makefiles. */
1666 read_makefiles
1667 = read_all_makefiles (makefiles == 0 ? 0 : makefiles->list);
1669 #ifdef WINDOWS32
1670 /* look one last time after reading all Makefiles */
1671 if (no_default_sh_exe)
1672 no_default_sh_exe = !find_and_set_default_shell(NULL);
1673 #endif /* WINDOWS32 */
1675 #if defined (__MSDOS__) || defined (__EMX__)
1676 /* We need to know what kind of shell we will be using. */
1678 extern int _is_unixy_shell (const char *_path);
1679 struct variable *shv = lookup_variable (STRING_SIZE_TUPLE ("SHELL"));
1680 extern int unixy_shell;
1681 extern char *default_shell;
1683 if (shv && *shv->value)
1685 char *shell_path = recursively_expand(shv);
1687 if (shell_path && _is_unixy_shell (shell_path))
1688 unixy_shell = 1;
1689 else
1690 unixy_shell = 0;
1691 if (shell_path)
1692 default_shell = shell_path;
1695 #endif /* __MSDOS__ || __EMX__ */
1697 /* Decode switches again, in case the variables were set by the makefile. */
1698 decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
1699 #if 0
1700 decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
1701 #endif
1703 #if defined (__MSDOS__) || defined (__EMX__)
1704 if (job_slots != 1
1705 # ifdef __EMX__
1706 && _osmode != OS2_MODE /* turn off -j if we are in DOS mode */
1707 # endif
1710 error (NILF,
1711 _("Parallel jobs (-j) are not supported on this platform."));
1712 error (NILF, _("Resetting to single job (-j1) mode."));
1713 job_slots = 1;
1715 #endif
1717 #ifdef MAKE_JOBSERVER
1718 /* If the jobserver-fds option is seen, make sure that -j is reasonable. */
1720 if (jobserver_fds)
1722 const char *cp;
1723 unsigned int ui;
1725 for (ui=1; ui < jobserver_fds->idx; ++ui)
1726 if (!streq (jobserver_fds->list[0], jobserver_fds->list[ui]))
1727 fatal (NILF, _("internal error: multiple --jobserver-fds options"));
1729 /* Now parse the fds string and make sure it has the proper format. */
1731 cp = jobserver_fds->list[0];
1733 #ifdef WINDOWS32
1734 if (! open_jobserver_semaphore(cp))
1736 DWORD err = GetLastError();
1737 fatal (NILF, _("internal error: unable to open jobserver semaphore `%s': (Error %ld: %s)"),
1738 cp, err, map_windows32_error_to_string(err));
1740 DB (DB_JOBS, (_("Jobserver client (semaphore %s)\n"), cp));
1741 #else
1742 if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2)
1743 fatal (NILF,
1744 _("internal error: invalid --jobserver-fds string `%s'"), cp);
1746 DB (DB_JOBS,
1747 (_("Jobserver client (fds %d,%d)\n"), job_fds[0], job_fds[1]));
1748 #endif
1750 /* The combination of a pipe + !job_slots means we're using the
1751 jobserver. If !job_slots and we don't have a pipe, we can start
1752 infinite jobs. If we see both a pipe and job_slots >0 that means the
1753 user set -j explicitly. This is broken; in this case obey the user
1754 (ignore the jobserver pipe for this make) but print a message. */
1756 if (job_slots > 0)
1757 error (NILF,
1758 _("warning: -jN forced in submake: disabling jobserver mode."));
1760 #ifndef WINDOWS32
1761 /* Create a duplicate pipe, that will be closed in the SIGCHLD
1762 handler. If this fails with EBADF, the parent has closed the pipe
1763 on us because it didn't think we were a submake. If so, print a
1764 warning then default to -j1. */
1765 else if ((job_rfd = dup (job_fds[0])) < 0)
1767 if (errno != EBADF)
1768 pfatal_with_name (_("dup jobserver"));
1770 error (NILF,
1771 _("warning: jobserver unavailable: using -j1. Add `+' to parent make rule."));
1772 job_slots = 1;
1774 #endif
1776 if (job_slots > 0)
1778 #ifdef WINDOWS32
1779 free_jobserver_semaphore ();
1780 #else
1781 close (job_fds[0]);
1782 close (job_fds[1]);
1783 #endif
1784 job_fds[0] = job_fds[1] = -1;
1785 free (jobserver_fds->list);
1786 free (jobserver_fds);
1787 jobserver_fds = 0;
1791 /* If we have >1 slot but no jobserver-fds, then we're a top-level make.
1792 Set up the pipe and install the fds option for our children. */
1794 if (job_slots > 1)
1796 char *cp;
1797 char c = '+';
1799 #ifdef WINDOWS32
1800 /* sub_proc.c cannot wait for more than MAXIMUM_WAIT_OBJECTS objects
1801 * and one of them is the job-server semaphore object. Limit the
1802 * number of available job slots to (MAXIMUM_WAIT_OBJECTS - 1). */
1804 if (job_slots >= MAXIMUM_WAIT_OBJECTS)
1806 job_slots = MAXIMUM_WAIT_OBJECTS - 1;
1807 DB (DB_JOBS, (_("Jobserver slots limited to %d\n"), job_slots));
1810 if (! create_jobserver_semaphore(job_slots - 1))
1812 DWORD err = GetLastError();
1813 fatal (NILF, _("creating jobserver semaphore: (Error %ld: %s)"),
1814 err, map_windows32_error_to_string(err));
1816 #else
1817 if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0)
1818 pfatal_with_name (_("creating jobs pipe"));
1819 #endif
1821 /* Every make assumes that it always has one job it can run. For the
1822 submakes it's the token they were given by their parent. For the
1823 top make, we just subtract one from the number the user wants. We
1824 want job_slots to be 0 to indicate we're using the jobserver. */
1826 master_job_slots = job_slots;
1828 #ifdef WINDOWS32
1829 /* We're using the jobserver so set job_slots to 0. */
1830 job_slots = 0;
1831 #else
1832 while (--job_slots)
1834 int r;
1836 EINTRLOOP (r, write (job_fds[1], &c, 1));
1837 if (r != 1)
1838 pfatal_with_name (_("init jobserver pipe"));
1840 #endif
1842 /* Fill in the jobserver_fds struct for our children. */
1844 #ifdef WINDOWS32
1845 cp = xmalloc (MAX_PATH + 1);
1846 strcpy (cp, get_jobserver_semaphore_name());
1847 #else
1848 cp = xmalloc ((sizeof ("1024")*2)+1);
1849 sprintf (cp, "%d,%d", job_fds[0], job_fds[1]);
1850 #endif
1852 jobserver_fds = (struct stringlist *)
1853 xmalloc (sizeof (struct stringlist));
1854 jobserver_fds->list = xmalloc (sizeof (char *));
1855 jobserver_fds->list[0] = cp;
1856 jobserver_fds->idx = 1;
1857 jobserver_fds->max = 1;
1859 #endif
1861 #ifndef MAKE_SYMLINKS
1862 if (check_symlink_flag)
1864 error (NILF, _("Symbolic links not supported: disabling -L."));
1865 check_symlink_flag = 0;
1867 #endif
1869 /* Set up MAKEFLAGS and MFLAGS again, so they will be right. */
1871 define_makeflags (1, 0);
1873 /* Make each `struct dep' point at the `struct file' for the file
1874 depended on. Also do magic for special targets. */
1876 snap_deps ();
1878 /* Convert old-style suffix rules to pattern rules. It is important to
1879 do this before installing the built-in pattern rules below, so that
1880 makefile-specified suffix rules take precedence over built-in pattern
1881 rules. */
1883 convert_to_pattern ();
1885 /* Install the default implicit pattern rules.
1886 This used to be done before reading the makefiles.
1887 But in that case, built-in pattern rules were in the chain
1888 before user-defined ones, so they matched first. */
1890 install_default_implicit_rules ();
1892 /* Compute implicit rule limits. */
1894 count_implicit_rule_limits ();
1896 /* Construct the listings of directories in VPATH lists. */
1898 build_vpath_lists ();
1900 /* Mark files given with -o flags as very old and as having been updated
1901 already, and files given with -W flags as brand new (time-stamp as far
1902 as possible into the future). If restarts is set we'll do -W later. */
1904 if (old_files != 0)
1906 const char **p;
1907 for (p = old_files->list; *p != 0; ++p)
1909 struct file *f = enter_file (*p);
1910 f->last_mtime = f->mtime_before_update = OLD_MTIME;
1911 f->updated = 1;
1912 f->update_status = 0;
1913 f->command_state = cs_finished;
1917 if (!restarts && new_files != 0)
1919 const char **p;
1920 for (p = new_files->list; *p != 0; ++p)
1922 struct file *f = enter_file (*p);
1923 f->last_mtime = f->mtime_before_update = NEW_MTIME;
1927 /* Initialize the remote job module. */
1928 remote_setup ();
1930 if (read_makefiles != 0)
1932 /* Update any makefiles if necessary. */
1934 FILE_TIMESTAMP *makefile_mtimes = 0;
1935 unsigned int mm_idx = 0;
1936 char **nargv;
1937 int nargc;
1938 int orig_db_level = db_level;
1939 int status;
1941 if (! ISDB (DB_MAKEFILES))
1942 db_level = DB_NONE;
1944 DB (DB_BASIC, (_("Updating makefiles....\n")));
1946 /* Remove any makefiles we don't want to try to update.
1947 Also record the current modtimes so we can compare them later. */
1949 register struct dep *d, *last;
1950 last = 0;
1951 d = read_makefiles;
1952 while (d != 0)
1954 struct file *f = d->file;
1955 if (f->double_colon)
1956 for (f = f->double_colon; f != NULL; f = f->prev)
1958 if (f->deps == 0 && f->cmds != 0)
1960 /* This makefile is a :: target with commands, but
1961 no dependencies. So, it will always be remade.
1962 This might well cause an infinite loop, so don't
1963 try to remake it. (This will only happen if
1964 your makefiles are written exceptionally
1965 stupidly; but if you work for Athena, that's how
1966 you write your makefiles.) */
1968 DB (DB_VERBOSE,
1969 (_("Makefile `%s' might loop; not remaking it.\n"),
1970 f->name));
1972 if (last == 0)
1973 read_makefiles = d->next;
1974 else
1975 last->next = d->next;
1977 /* Free the storage. */
1978 free_dep (d);
1980 d = last == 0 ? read_makefiles : last->next;
1982 break;
1985 if (f == NULL || !f->double_colon)
1987 makefile_mtimes = xrealloc (makefile_mtimes,
1988 (mm_idx+1)
1989 * sizeof (FILE_TIMESTAMP));
1990 makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file);
1991 last = d;
1992 d = d->next;
1997 /* Set up `MAKEFLAGS' specially while remaking makefiles. */
1998 define_makeflags (1, 1);
2000 rebuilding_makefiles = 1;
2001 status = update_goal_chain (read_makefiles);
2002 rebuilding_makefiles = 0;
2004 switch (status)
2006 case 1:
2007 /* The only way this can happen is if the user specified -q and asked
2008 * for one of the makefiles to be remade as a target on the command
2009 * line. Since we're not actually updating anything with -q we can
2010 * treat this as "did nothing".
2013 case -1:
2014 /* Did nothing. */
2015 break;
2017 case 2:
2018 /* Failed to update. Figure out if we care. */
2020 /* Nonzero if any makefile was successfully remade. */
2021 int any_remade = 0;
2022 /* Nonzero if any makefile we care about failed
2023 in updating or could not be found at all. */
2024 int any_failed = 0;
2025 unsigned int i;
2026 struct dep *d;
2028 for (i = 0, d = read_makefiles; d != 0; ++i, d = d->next)
2030 /* Reset the considered flag; we may need to look at the file
2031 again to print an error. */
2032 d->file->considered = 0;
2034 if (d->file->updated)
2036 /* This makefile was updated. */
2037 if (d->file->update_status == 0)
2039 /* It was successfully updated. */
2040 any_remade |= (file_mtime_no_search (d->file)
2041 != makefile_mtimes[i]);
2043 else if (! (d->changed & RM_DONTCARE))
2045 FILE_TIMESTAMP mtime;
2046 /* The update failed and this makefile was not
2047 from the MAKEFILES variable, so we care. */
2048 error (NILF, _("Failed to remake makefile `%s'."),
2049 d->file->name);
2050 mtime = file_mtime_no_search (d->file);
2051 any_remade |= (mtime != NONEXISTENT_MTIME
2052 && mtime != makefile_mtimes[i]);
2053 makefile_status = MAKE_FAILURE;
2056 else
2057 /* This makefile was not found at all. */
2058 if (! (d->changed & RM_DONTCARE))
2060 /* This is a makefile we care about. See how much. */
2061 if (d->changed & RM_INCLUDED)
2062 /* An included makefile. We don't need
2063 to die, but we do want to complain. */
2064 error (NILF,
2065 _("Included makefile `%s' was not found."),
2066 dep_name (d));
2067 else
2069 /* A normal makefile. We must die later. */
2070 error (NILF, _("Makefile `%s' was not found"),
2071 dep_name (d));
2072 any_failed = 1;
2076 /* Reset this to empty so we get the right error message below. */
2077 read_makefiles = 0;
2079 if (any_remade)
2080 goto re_exec;
2081 if (any_failed)
2082 die (2);
2083 break;
2086 case 0:
2087 re_exec:
2088 /* Updated successfully. Re-exec ourselves. */
2090 remove_intermediates (0);
2092 if (print_data_base_flag)
2093 print_data_base ();
2095 log_working_directory (0);
2097 clean_jobserver (0);
2099 if (makefiles != 0)
2101 /* These names might have changed. */
2102 int i, j = 0;
2103 for (i = 1; i < argc; ++i)
2104 if (strneq (argv[i], "-f", 2)) /* XXX */
2106 if (argv[i][2] == '\0')
2107 /* This cast is OK since we never modify argv. */
2108 argv[++i] = (char *) makefiles->list[j];
2109 else
2110 argv[i] = xstrdup (concat (2, "-f", makefiles->list[j]));
2111 ++j;
2115 /* Add -o option for the stdin temporary file, if necessary. */
2116 nargc = argc;
2117 if (stdin_nm)
2119 nargv = xmalloc ((nargc + 2) * sizeof (char *));
2120 memcpy (nargv, argv, argc * sizeof (char *));
2121 nargv[nargc++] = xstrdup (concat (2, "-o", stdin_nm));
2122 nargv[nargc] = 0;
2124 else
2125 nargv = argv;
2127 if (directories != 0 && directories->idx > 0)
2129 int bad = 1;
2130 if (directory_before_chdir != 0)
2132 if (chdir (directory_before_chdir) < 0)
2133 perror_with_name ("chdir", "");
2134 else
2135 bad = 0;
2137 if (bad)
2138 fatal (NILF, _("Couldn't change back to original directory."));
2141 ++restarts;
2143 /* If we're re-exec'ing the first make, put back the number of
2144 job slots so define_makefiles() will get it right. */
2145 if (master_job_slots)
2146 job_slots = master_job_slots;
2148 /* Reset makeflags in case they were changed. */
2150 const char *pv = define_makeflags (1, 1);
2151 char *p = alloca (sizeof ("MAKEFLAGS=") + strlen (pv) + 1);
2152 sprintf (p, "MAKEFLAGS=%s", pv);
2153 putenv (allocated_variable_expand (p));
2156 if (ISDB (DB_BASIC))
2158 char **p;
2159 printf (_("Re-executing[%u]:"), restarts);
2160 for (p = nargv; *p != 0; ++p)
2161 printf (" %s", *p);
2162 putchar ('\n');
2165 #ifndef _AMIGA
2167 char **p;
2168 for (p = environ; *p != 0; ++p)
2170 if (strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH)
2171 && (*p)[MAKELEVEL_LENGTH] == '=')
2173 *p = alloca (40);
2174 sprintf (*p, "%s=%u", MAKELEVEL_NAME, makelevel);
2176 if (strneq (*p, "MAKE_RESTARTS=", 14))
2178 *p = alloca (40);
2179 sprintf (*p, "MAKE_RESTARTS=%u", restarts);
2180 restarts = 0;
2184 #else /* AMIGA */
2186 char buffer[256];
2188 sprintf (buffer, "%u", makelevel);
2189 SetVar (MAKELEVEL_NAME, buffer, -1, GVF_GLOBAL_ONLY);
2191 sprintf (buffer, "%u", restarts);
2192 SetVar ("MAKE_RESTARTS", buffer, -1, GVF_GLOBAL_ONLY);
2193 restarts = 0;
2195 #endif
2197 /* If we didn't set the restarts variable yet, add it. */
2198 if (restarts)
2200 char *b = alloca (40);
2201 sprintf (b, "MAKE_RESTARTS=%u", restarts);
2202 putenv (b);
2205 fflush (stdout);
2206 fflush (stderr);
2208 /* Close the dup'd jobserver pipe if we opened one. */
2209 if (job_rfd >= 0)
2210 close (job_rfd);
2212 #ifdef _AMIGA
2213 exec_command (nargv);
2214 exit (0);
2215 #elif defined (__EMX__)
2217 /* It is not possible to use execve() here because this
2218 would cause the parent process to be terminated with
2219 exit code 0 before the child process has been terminated.
2220 Therefore it may be the best solution simply to spawn the
2221 child process including all file handles and to wait for its
2222 termination. */
2223 int pid;
2224 int status;
2225 pid = child_execute_job (0, 1, nargv, environ);
2227 /* is this loop really necessary? */
2228 do {
2229 pid = wait (&status);
2230 } while (pid <= 0);
2231 /* use the exit code of the child process */
2232 exit (WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
2234 #else
2235 exec_command (nargv, environ);
2236 #endif
2237 /* NOTREACHED */
2239 default:
2240 #define BOGUS_UPDATE_STATUS 0
2241 assert (BOGUS_UPDATE_STATUS);
2242 break;
2245 db_level = orig_db_level;
2247 /* Free the makefile mtimes (if we allocated any). */
2248 if (makefile_mtimes)
2249 free (makefile_mtimes);
2252 /* Set up `MAKEFLAGS' again for the normal targets. */
2253 define_makeflags (1, 0);
2255 /* Set always_make_flag if -B was given. */
2256 always_make_flag = always_make_set;
2258 /* If restarts is set we haven't set up -W files yet, so do that now. */
2259 if (restarts && new_files != 0)
2261 const char **p;
2262 for (p = new_files->list; *p != 0; ++p)
2264 struct file *f = enter_file (*p);
2265 f->last_mtime = f->mtime_before_update = NEW_MTIME;
2269 /* If there is a temp file from reading a makefile from stdin, get rid of
2270 it now. */
2271 if (stdin_nm && unlink (stdin_nm) < 0 && errno != ENOENT)
2272 perror_with_name (_("unlink (temporary file): "), stdin_nm);
2274 /* If there were no command-line goals, use the default. */
2275 if (goals == 0)
2277 char *p;
2279 if (default_goal_var->recursive)
2280 p = variable_expand (default_goal_var->value);
2281 else
2283 p = variable_buffer_output (variable_buffer, default_goal_var->value,
2284 strlen (default_goal_var->value));
2285 *p = '\0';
2286 p = variable_buffer;
2289 if (*p != '\0')
2291 struct file *f = lookup_file (p);
2293 /* If .DEFAULT_GOAL is a non-existent target, enter it into the
2294 table and let the standard logic sort it out. */
2295 if (f == 0)
2297 struct nameseq *ns;
2299 ns = PARSE_FILE_SEQ (&p, struct nameseq, '\0', NULL, 0);
2300 if (ns)
2302 /* .DEFAULT_GOAL should contain one target. */
2303 if (ns->next != 0)
2304 fatal (NILF, _(".DEFAULT_GOAL contains more than one target"));
2306 f = enter_file (strcache_add (ns->name));
2308 ns->name = 0; /* It was reused by enter_file(). */
2309 free_ns_chain (ns);
2313 if (f)
2315 goals = alloc_dep ();
2316 goals->file = f;
2320 else
2321 lastgoal->next = 0;
2324 if (!goals)
2326 if (read_makefiles == 0)
2327 fatal (NILF, _("No targets specified and no makefile found"));
2329 fatal (NILF, _("No targets"));
2332 /* Update the goals. */
2334 DB (DB_BASIC, (_("Updating goal targets....\n")));
2337 int status;
2339 switch (update_goal_chain (goals))
2341 case -1:
2342 /* Nothing happened. */
2343 case 0:
2344 /* Updated successfully. */
2345 status = makefile_status;
2346 break;
2347 case 1:
2348 /* We are under -q and would run some commands. */
2349 status = MAKE_TROUBLE;
2350 break;
2351 case 2:
2352 /* Updating failed. POSIX.2 specifies exit status >1 for this;
2353 but in VMS, there is only success and failure. */
2354 status = MAKE_FAILURE;
2355 break;
2356 default:
2357 abort ();
2360 /* If we detected some clock skew, generate one last warning */
2361 if (clock_skew_detected)
2362 error (NILF,
2363 _("warning: Clock skew detected. Your build may be incomplete."));
2365 /* Exit. */
2366 die (status);
2369 /* NOTREACHED */
2370 exit(0);
2373 /* Parsing of arguments, decoding of switches. */
2375 static char options[1 + sizeof (switches) / sizeof (switches[0]) * 3];
2376 static struct option long_options[(sizeof (switches) / sizeof (switches[0])) +
2377 (sizeof (long_option_aliases) /
2378 sizeof (long_option_aliases[0]))];
2380 /* Fill in the string and vector for getopt. */
2381 static void
2382 init_switches (void)
2384 char *p;
2385 unsigned int c;
2386 unsigned int i;
2388 if (options[0] != '\0')
2389 /* Already done. */
2390 return;
2392 p = options;
2394 /* Return switch and non-switch args in order, regardless of
2395 POSIXLY_CORRECT. Non-switch args are returned as option 1. */
2396 *p++ = '-';
2398 for (i = 0; switches[i].c != '\0'; ++i)
2400 long_options[i].name = (switches[i].long_name == 0 ? "" :
2401 switches[i].long_name);
2402 long_options[i].flag = 0;
2403 long_options[i].val = switches[i].c;
2404 if (short_option (switches[i].c))
2405 *p++ = switches[i].c;
2406 switch (switches[i].type)
2408 case flag:
2409 case flag_off:
2410 case ignore:
2411 long_options[i].has_arg = no_argument;
2412 break;
2414 case string:
2415 case filename:
2416 case positive_int:
2417 case floating:
2418 if (short_option (switches[i].c))
2419 *p++ = ':';
2420 if (switches[i].noarg_value != 0)
2422 if (short_option (switches[i].c))
2423 *p++ = ':';
2424 long_options[i].has_arg = optional_argument;
2426 else
2427 long_options[i].has_arg = required_argument;
2428 break;
2431 *p = '\0';
2432 for (c = 0; c < (sizeof (long_option_aliases) /
2433 sizeof (long_option_aliases[0]));
2434 ++c)
2435 long_options[i++] = long_option_aliases[c];
2436 long_options[i].name = 0;
2439 static void
2440 handle_non_switch_argument (char *arg, int env)
2442 /* Non-option argument. It might be a variable definition. */
2443 struct variable *v;
2444 if (arg[0] == '-' && arg[1] == '\0')
2445 /* Ignore plain `-' for compatibility. */
2446 return;
2447 v = try_variable_definition (0, arg, o_command, 0);
2448 if (v != 0)
2450 /* It is indeed a variable definition. If we don't already have this
2451 one, record a pointer to the variable for later use in
2452 define_makeflags. */
2453 struct command_variable *cv;
2455 for (cv = command_variables; cv != 0; cv = cv->next)
2456 if (cv->variable == v)
2457 break;
2459 if (! cv) {
2460 cv = xmalloc (sizeof (*cv));
2461 cv->variable = v;
2462 cv->next = command_variables;
2463 command_variables = cv;
2466 else if (! env)
2468 /* Not an option or variable definition; it must be a goal
2469 target! Enter it as a file and add it to the dep chain of
2470 goals. */
2471 struct file *f = enter_file (strcache_add (expand_command_line_file (arg)));
2472 f->cmd_target = 1;
2474 if (goals == 0)
2476 goals = alloc_dep ();
2477 lastgoal = goals;
2479 else
2481 lastgoal->next = alloc_dep ();
2482 lastgoal = lastgoal->next;
2485 lastgoal->file = f;
2488 /* Add this target name to the MAKECMDGOALS variable. */
2489 struct variable *gv;
2490 const char *value;
2492 gv = lookup_variable (STRING_SIZE_TUPLE ("MAKECMDGOALS"));
2493 if (gv == 0)
2494 value = f->name;
2495 else
2497 /* Paste the old and new values together */
2498 unsigned int oldlen, newlen;
2499 char *vp;
2501 oldlen = strlen (gv->value);
2502 newlen = strlen (f->name);
2503 vp = alloca (oldlen + 1 + newlen + 1);
2504 memcpy (vp, gv->value, oldlen);
2505 vp[oldlen] = ' ';
2506 memcpy (&vp[oldlen + 1], f->name, newlen + 1);
2507 value = vp;
2509 define_variable_cname ("MAKECMDGOALS", value, o_default, 0);
2514 /* Print a nice usage method. */
2516 static void
2517 print_usage (int bad)
2519 const char *const *cpp;
2520 FILE *usageto;
2522 if (print_version_flag)
2523 print_version ();
2525 usageto = bad ? stderr : stdout;
2527 fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program);
2529 for (cpp = usage; *cpp; ++cpp)
2530 fputs (_(*cpp), usageto);
2532 if (!remote_description || *remote_description == '\0')
2533 fprintf (usageto, _("\nThis program built for %s\n"), make_host);
2534 else
2535 fprintf (usageto, _("\nThis program built for %s (%s)\n"),
2536 make_host, remote_description);
2538 fprintf (usageto, _("Report bugs to <bug-make@gnu.org>\n"));
2541 /* Decode switches from ARGC and ARGV.
2542 They came from the environment if ENV is nonzero. */
2544 static void
2545 decode_switches (int argc, char **argv, int env)
2547 int bad = 0;
2548 register const struct command_switch *cs;
2549 register struct stringlist *sl;
2550 register int c;
2552 /* getopt does most of the parsing for us.
2553 First, get its vectors set up. */
2555 init_switches ();
2557 /* Let getopt produce error messages for the command line,
2558 but not for options from the environment. */
2559 opterr = !env;
2560 /* Reset getopt's state. */
2561 optind = 0;
2563 while (optind < argc)
2565 /* Parse the next argument. */
2566 c = getopt_long (argc, argv, options, long_options, (int *) 0);
2567 if (c == EOF)
2568 /* End of arguments, or "--" marker seen. */
2569 break;
2570 else if (c == 1)
2571 /* An argument not starting with a dash. */
2572 handle_non_switch_argument (optarg, env);
2573 else if (c == '?')
2574 /* Bad option. We will print a usage message and die later.
2575 But continue to parse the other options so the user can
2576 see all he did wrong. */
2577 bad = 1;
2578 else
2579 for (cs = switches; cs->c != '\0'; ++cs)
2580 if (cs->c == c)
2582 /* Whether or not we will actually do anything with
2583 this switch. We test this individually inside the
2584 switch below rather than just once outside it, so that
2585 options which are to be ignored still consume args. */
2586 int doit = !env || cs->env;
2588 switch (cs->type)
2590 default:
2591 abort ();
2593 case ignore:
2594 break;
2596 case flag:
2597 case flag_off:
2598 if (doit)
2599 *(int *) cs->value_ptr = cs->type == flag;
2600 break;
2602 case string:
2603 case filename:
2604 if (!doit)
2605 break;
2607 if (optarg == 0)
2608 optarg = xstrdup (cs->noarg_value);
2609 else if (*optarg == '\0')
2611 char opt[2] = "c";
2612 const char *op = opt;
2614 if (short_option (cs->c))
2615 opt[0] = cs->c;
2616 else
2617 op = cs->long_name;
2619 error (NILF, _("the `%s%s' option requires a non-empty string argument"),
2620 short_option (cs->c) ? "-" : "--", op);
2621 bad = 1;
2624 sl = *(struct stringlist **) cs->value_ptr;
2625 if (sl == 0)
2627 sl = (struct stringlist *)
2628 xmalloc (sizeof (struct stringlist));
2629 sl->max = 5;
2630 sl->idx = 0;
2631 sl->list = xmalloc (5 * sizeof (char *));
2632 *(struct stringlist **) cs->value_ptr = sl;
2634 else if (sl->idx == sl->max - 1)
2636 sl->max += 5;
2637 /* MSVC erroneously warns without a cast here. */
2638 sl->list = xrealloc ((void *)sl->list,
2639 sl->max * sizeof (char *));
2641 if (cs->type == filename)
2642 sl->list[sl->idx++] = expand_command_line_file (optarg);
2643 else
2644 sl->list[sl->idx++] = optarg;
2645 sl->list[sl->idx] = 0;
2646 break;
2648 case positive_int:
2649 /* See if we have an option argument; if we do require that
2650 it's all digits, not something like "10foo". */
2651 if (optarg == 0 && argc > optind)
2653 const char *cp;
2654 for (cp=argv[optind]; ISDIGIT (cp[0]); ++cp)
2656 if (cp[0] == '\0')
2657 optarg = argv[optind++];
2660 if (!doit)
2661 break;
2663 if (optarg != 0)
2665 int i = atoi (optarg);
2666 const char *cp;
2668 /* Yes, I realize we're repeating this in some cases. */
2669 for (cp = optarg; ISDIGIT (cp[0]); ++cp)
2672 if (i < 1 || cp[0] != '\0')
2674 error (NILF, _("the `-%c' option requires a positive integral argument"),
2675 cs->c);
2676 bad = 1;
2678 else
2679 *(unsigned int *) cs->value_ptr = i;
2681 else
2682 *(unsigned int *) cs->value_ptr
2683 = *(unsigned int *) cs->noarg_value;
2684 break;
2686 #ifndef NO_FLOAT
2687 case floating:
2688 if (optarg == 0 && optind < argc
2689 && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.'))
2690 optarg = argv[optind++];
2692 if (doit)
2693 *(double *) cs->value_ptr
2694 = (optarg != 0 ? atof (optarg)
2695 : *(double *) cs->noarg_value);
2697 break;
2698 #endif
2701 /* We've found the switch. Stop looking. */
2702 break;
2706 /* There are no more options according to getting getopt, but there may
2707 be some arguments left. Since we have asked for non-option arguments
2708 to be returned in order, this only happens when there is a "--"
2709 argument to prevent later arguments from being options. */
2710 while (optind < argc)
2711 handle_non_switch_argument (argv[optind++], env);
2714 if (!env && (bad || print_usage_flag))
2716 print_usage (bad);
2717 die (bad ? 2 : 0);
2721 /* Decode switches from environment variable ENVAR (which is LEN chars long).
2722 We do this by chopping the value into a vector of words, prepending a
2723 dash to the first word if it lacks one, and passing the vector to
2724 decode_switches. */
2726 static void
2727 decode_env_switches (char *envar, unsigned int len)
2729 char *varref = alloca (2 + len + 2);
2730 char *value, *p;
2731 int argc;
2732 char **argv;
2734 /* Get the variable's value. */
2735 varref[0] = '$';
2736 varref[1] = '(';
2737 memcpy (&varref[2], envar, len);
2738 varref[2 + len] = ')';
2739 varref[2 + len + 1] = '\0';
2740 value = variable_expand (varref);
2742 /* Skip whitespace, and check for an empty value. */
2743 value = next_token (value);
2744 len = strlen (value);
2745 if (len == 0)
2746 return;
2748 /* Allocate a vector that is definitely big enough. */
2749 argv = alloca ((1 + len + 1) * sizeof (char *));
2751 /* Allocate a buffer to copy the value into while we split it into words
2752 and unquote it. We must use permanent storage for this because
2753 decode_switches may store pointers into the passed argument words. */
2754 p = xmalloc (2 * len);
2756 /* getopt will look at the arguments starting at ARGV[1].
2757 Prepend a spacer word. */
2758 argv[0] = 0;
2759 argc = 1;
2760 argv[argc] = p;
2761 while (*value != '\0')
2763 if (*value == '\\' && value[1] != '\0')
2764 ++value; /* Skip the backslash. */
2765 else if (isblank ((unsigned char)*value))
2767 /* End of the word. */
2768 *p++ = '\0';
2769 argv[++argc] = p;
2771 ++value;
2772 while (isblank ((unsigned char)*value));
2773 continue;
2775 *p++ = *value++;
2777 *p = '\0';
2778 argv[++argc] = 0;
2780 if (argv[1][0] != '-' && strchr (argv[1], '=') == 0)
2781 /* The first word doesn't start with a dash and isn't a variable
2782 definition. Add a dash and pass it along to decode_switches. We
2783 need permanent storage for this in case decode_switches saves
2784 pointers into the value. */
2785 argv[1] = xstrdup (concat (2, "-", argv[1]));
2787 /* Parse those words. */
2788 decode_switches (argc, argv, 1);
2791 /* Quote the string IN so that it will be interpreted as a single word with
2792 no magic by decode_env_switches; also double dollar signs to avoid
2793 variable expansion in make itself. Write the result into OUT, returning
2794 the address of the next character to be written.
2795 Allocating space for OUT twice the length of IN is always sufficient. */
2797 static char *
2798 quote_for_env (char *out, const char *in)
2800 while (*in != '\0')
2802 if (*in == '$')
2803 *out++ = '$';
2804 else if (isblank ((unsigned char)*in) || *in == '\\')
2805 *out++ = '\\';
2806 *out++ = *in++;
2809 return out;
2812 /* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the
2813 command switches. Include options with args if ALL is nonzero.
2814 Don't include options with the `no_makefile' flag set if MAKEFILE. */
2816 static const char *
2817 define_makeflags (int all, int makefile)
2819 const char ref[] = "$(MAKEOVERRIDES)";
2820 const char posixref[] = "$(-*-command-variables-*-)";
2821 const char evalref[] = "$(-*-eval-flags-*-)";
2822 const struct command_switch *cs;
2823 char *flagstring;
2824 register char *p;
2825 unsigned int words;
2826 struct variable *v;
2828 /* We will construct a linked list of `struct flag's describing
2829 all the flags which need to go in MAKEFLAGS. Then, once we
2830 know how many there are and their lengths, we can put them all
2831 together in a string. */
2833 struct flag
2835 struct flag *next;
2836 const struct command_switch *cs;
2837 const char *arg;
2839 struct flag *flags = 0;
2840 unsigned int flagslen = 0;
2841 #define ADD_FLAG(ARG, LEN) \
2842 do { \
2843 struct flag *new = alloca (sizeof (struct flag)); \
2844 new->cs = cs; \
2845 new->arg = (ARG); \
2846 new->next = flags; \
2847 flags = new; \
2848 if (new->arg == 0) \
2849 ++flagslen; /* Just a single flag letter. */ \
2850 else \
2851 /* " -x foo", plus space to expand "foo". */ \
2852 flagslen += 1 + 1 + 1 + 1 + (3 * (LEN)); \
2853 if (!short_option (cs->c)) \
2854 /* This switch has no single-letter version, so we use the long. */ \
2855 flagslen += 2 + strlen (cs->long_name); \
2856 } while (0)
2858 for (cs = switches; cs->c != '\0'; ++cs)
2859 if (cs->toenv && (!makefile || !cs->no_makefile))
2860 switch (cs->type)
2862 case ignore:
2863 break;
2865 case flag:
2866 case flag_off:
2867 if (!*(int *) cs->value_ptr == (cs->type == flag_off)
2868 && (cs->default_value == 0
2869 || *(int *) cs->value_ptr != *(int *) cs->default_value))
2870 ADD_FLAG (0, 0);
2871 break;
2873 case positive_int:
2874 if (all)
2876 if ((cs->default_value != 0
2877 && (*(unsigned int *) cs->value_ptr
2878 == *(unsigned int *) cs->default_value)))
2879 break;
2880 else if (cs->noarg_value != 0
2881 && (*(unsigned int *) cs->value_ptr ==
2882 *(unsigned int *) cs->noarg_value))
2883 ADD_FLAG ("", 0); /* Optional value omitted; see below. */
2884 else
2886 char *buf = alloca (30);
2887 sprintf (buf, "%u", *(unsigned int *) cs->value_ptr);
2888 ADD_FLAG (buf, strlen (buf));
2891 break;
2893 #ifndef NO_FLOAT
2894 case floating:
2895 if (all)
2897 if (cs->default_value != 0
2898 && (*(double *) cs->value_ptr
2899 == *(double *) cs->default_value))
2900 break;
2901 else if (cs->noarg_value != 0
2902 && (*(double *) cs->value_ptr
2903 == *(double *) cs->noarg_value))
2904 ADD_FLAG ("", 0); /* Optional value omitted; see below. */
2905 else
2907 char *buf = alloca (100);
2908 sprintf (buf, "%g", *(double *) cs->value_ptr);
2909 ADD_FLAG (buf, strlen (buf));
2912 break;
2913 #endif
2915 case filename:
2916 case string:
2917 if (all)
2919 struct stringlist *sl = *(struct stringlist **) cs->value_ptr;
2920 if (sl != 0)
2922 /* Add the elements in reverse order, because all the flags
2923 get reversed below; and the order matters for some
2924 switches (like -I). */
2925 unsigned int i = sl->idx;
2926 while (i-- > 0)
2927 ADD_FLAG (sl->list[i], strlen (sl->list[i]));
2930 break;
2932 default:
2933 abort ();
2936 /* Four more for the possible " -- ". */
2937 flagslen += 4 + sizeof (posixref) + sizeof (evalref);
2939 #undef ADD_FLAG
2941 /* Construct the value in FLAGSTRING.
2942 We allocate enough space for a preceding dash and trailing null. */
2943 flagstring = alloca (1 + flagslen + 1);
2944 memset (flagstring, '\0', 1 + flagslen + 1);
2945 p = flagstring;
2946 words = 1;
2947 *p++ = '-';
2948 while (flags != 0)
2950 /* Add the flag letter or name to the string. */
2951 if (short_option (flags->cs->c))
2952 *p++ = flags->cs->c;
2953 else
2955 if (*p != '-')
2957 *p++ = ' ';
2958 *p++ = '-';
2960 *p++ = '-';
2961 strcpy (p, flags->cs->long_name);
2962 p += strlen (p);
2964 if (flags->arg != 0)
2966 /* A flag that takes an optional argument which in this case is
2967 omitted is specified by ARG being "". We must distinguish
2968 because a following flag appended without an intervening " -"
2969 is considered the arg for the first. */
2970 if (flags->arg[0] != '\0')
2972 /* Add its argument too. */
2973 *p++ = !short_option (flags->cs->c) ? '=' : ' ';
2974 p = quote_for_env (p, flags->arg);
2976 ++words;
2977 /* Write a following space and dash, for the next flag. */
2978 *p++ = ' ';
2979 *p++ = '-';
2981 else if (!short_option (flags->cs->c))
2983 ++words;
2984 /* Long options must each go in their own word,
2985 so we write the following space and dash. */
2986 *p++ = ' ';
2987 *p++ = '-';
2989 flags = flags->next;
2992 /* Define MFLAGS before appending variable definitions. */
2994 if (p == &flagstring[1])
2995 /* No flags. */
2996 flagstring[0] = '\0';
2997 else if (p[-1] == '-')
2999 /* Kill the final space and dash. */
3000 p -= 2;
3001 *p = '\0';
3003 else
3004 /* Terminate the string. */
3005 *p = '\0';
3007 /* Since MFLAGS is not parsed for flags, there is no reason to
3008 override any makefile redefinition. */
3009 define_variable_cname ("MFLAGS", flagstring, o_env, 1);
3011 /* Write a reference to -*-eval-flags-*-, which contains all the --eval
3012 flag options. */
3013 if (eval_strings)
3015 if (p == &flagstring[1])
3016 /* No flags written, so elide the leading dash already written. */
3017 p = flagstring;
3018 else
3019 *p++ = ' ';
3020 memcpy (p, evalref, sizeof (evalref) - 1);
3021 p += sizeof (evalref) - 1;
3024 if (all && command_variables != 0)
3026 /* Now write a reference to $(MAKEOVERRIDES), which contains all the
3027 command-line variable definitions. */
3029 if (p == &flagstring[1])
3030 /* No flags written, so elide the leading dash already written. */
3031 p = flagstring;
3032 else
3034 /* Separate the variables from the switches with a "--" arg. */
3035 if (p[-1] != '-')
3037 /* We did not already write a trailing " -". */
3038 *p++ = ' ';
3039 *p++ = '-';
3041 /* There is a trailing " -"; fill it out to " -- ". */
3042 *p++ = '-';
3043 *p++ = ' ';
3046 /* Copy in the string. */
3047 if (posix_pedantic)
3049 memcpy (p, posixref, sizeof (posixref) - 1);
3050 p += sizeof (posixref) - 1;
3052 else
3054 memcpy (p, ref, sizeof (ref) - 1);
3055 p += sizeof (ref) - 1;
3058 else if (p == &flagstring[1])
3060 words = 0;
3061 --p;
3063 else if (p[-1] == '-')
3064 /* Kill the final space and dash. */
3065 p -= 2;
3066 /* Terminate the string. */
3067 *p = '\0';
3069 /* If there are switches, omit the leading dash unless it is a single long
3070 option with two leading dashes. */
3071 if (flagstring[0] == '-' && flagstring[1] != '-')
3072 ++flagstring;
3074 v = define_variable_cname ("MAKEFLAGS", flagstring,
3075 /* This used to use o_env, but that lost when a
3076 makefile defined MAKEFLAGS. Makefiles set
3077 MAKEFLAGS to add switches, but we still want
3078 to redefine its value with the full set of
3079 switches. Of course, an override or command
3080 definition will still take precedence. */
3081 o_file, 1);
3083 if (! all)
3084 /* The first time we are called, set MAKEFLAGS to always be exported.
3085 We should not do this again on the second call, because that is
3086 after reading makefiles which might have done `unexport MAKEFLAGS'. */
3087 v->export = v_export;
3089 return v->value;
3092 /* Print version information. */
3094 static void
3095 print_version (void)
3097 static int printed_version = 0;
3099 char *precede = print_data_base_flag ? "# " : "";
3101 if (printed_version)
3102 /* Do it only once. */
3103 return;
3105 printf ("%sGNU Make %s\n", precede, version_string);
3107 if (!remote_description || *remote_description == '\0')
3108 printf (_("%sBuilt for %s\n"), precede, make_host);
3109 else
3110 printf (_("%sBuilt for %s (%s)\n"),
3111 precede, make_host, remote_description);
3113 /* Print this untranslated. The coding standards recommend translating the
3114 (C) to the copyright symbol, but this string is going to change every
3115 year, and none of the rest of it should be translated (including the
3116 word "Copyright", so it hardly seems worth it. */
3118 printf ("%sCopyright (C) 2012 Free Software Foundation, Inc.\n", precede);
3120 printf (_("%sLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
3121 %sThis is free software: you are free to change and redistribute it.\n\
3122 %sThere is NO WARRANTY, to the extent permitted by law.\n"),
3123 precede, precede, precede);
3125 printed_version = 1;
3127 /* Flush stdout so the user doesn't have to wait to see the
3128 version information while things are thought about. */
3129 fflush (stdout);
3132 /* Print a bunch of information about this and that. */
3134 static void
3135 print_data_base ()
3137 time_t when;
3139 when = time ((time_t *) 0);
3140 printf (_("\n# Make data base, printed on %s"), ctime (&when));
3142 print_variable_data_base ();
3143 print_dir_data_base ();
3144 print_rule_data_base ();
3145 print_file_data_base ();
3146 print_vpath_data_base ();
3147 strcache_print_stats ("#");
3149 when = time ((time_t *) 0);
3150 printf (_("\n# Finished Make data base on %s\n"), ctime (&when));
3153 static void
3154 clean_jobserver (int status)
3156 char token = '+';
3158 /* Sanity: have we written all our jobserver tokens back? If our
3159 exit status is 2 that means some kind of syntax error; we might not
3160 have written all our tokens so do that now. If tokens are left
3161 after any other error code, that's bad. */
3163 #ifdef WINDOWS32
3164 if (has_jobserver_semaphore() && jobserver_tokens)
3165 #else
3166 if (job_fds[0] != -1 && jobserver_tokens)
3167 #endif
3169 if (status != 2)
3170 error (NILF,
3171 "INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
3172 jobserver_tokens);
3173 else
3174 /* Don't write back the "free" token */
3175 while (--jobserver_tokens)
3177 #ifdef WINDOWS32
3178 if (! release_jobserver_semaphore())
3179 perror_with_name ("release_jobserver_semaphore", "");
3180 #else
3181 int r;
3183 EINTRLOOP (r, write (job_fds[1], &token, 1));
3184 if (r != 1)
3185 perror_with_name ("write", "");
3186 #endif
3191 /* Sanity: If we're the master, were all the tokens written back? */
3193 if (master_job_slots)
3195 /* We didn't write one for ourself, so start at 1. */
3196 unsigned int tcnt = 1;
3198 #ifdef WINDOWS32
3199 while (acquire_jobserver_semaphore())
3200 ++tcnt;
3201 #else
3202 /* Close the write side, so the read() won't hang. */
3203 close (job_fds[1]);
3205 while (read (job_fds[0], &token, 1) == 1)
3206 ++tcnt;
3207 #endif
3209 if (tcnt != master_job_slots)
3210 error (NILF,
3211 "INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
3212 tcnt, master_job_slots);
3214 #ifdef WINDOWS32
3215 free_jobserver_semaphore();
3216 #else
3217 close (job_fds[0]);
3218 #endif
3220 /* Clean out jobserver_fds so we don't pass this information to any
3221 sub-makes. Also reset job_slots since it will be put on the command
3222 line, not in MAKEFLAGS. */
3223 job_slots = default_job_slots;
3224 if (jobserver_fds)
3226 /* MSVC erroneously warns without a cast here. */
3227 free ((void *)jobserver_fds->list);
3228 free (jobserver_fds);
3229 jobserver_fds = 0;
3234 /* Exit with STATUS, cleaning up as necessary. */
3236 void
3237 die (int status)
3239 static char dying = 0;
3241 if (!dying)
3243 int err;
3245 dying = 1;
3247 if (print_version_flag)
3248 print_version ();
3250 /* Wait for children to die. */
3251 err = (status != 0);
3252 while (job_slots_used > 0)
3253 reap_children (1, err);
3255 /* Let the remote job module clean up its state. */
3256 remote_cleanup ();
3258 /* Remove the intermediate files. */
3259 remove_intermediates (0);
3261 if (print_data_base_flag)
3262 print_data_base ();
3264 verify_file_data_base ();
3266 clean_jobserver (status);
3268 /* Try to move back to the original directory. This is essential on
3269 MS-DOS (where there is really only one process), and on Unix it
3270 puts core files in the original directory instead of the -C
3271 directory. Must wait until after remove_intermediates(), or unlinks
3272 of relative pathnames fail. */
3273 if (directory_before_chdir != 0)
3275 /* If it fails we don't care: shut up GCC. */
3276 int _x;
3277 _x = chdir (directory_before_chdir);
3280 log_working_directory (0);
3283 exit (status);
3286 /* Write a message indicating that we've just entered or
3287 left (according to ENTERING) the current directory. */
3289 void
3290 log_working_directory (int entering)
3292 static int entered = 0;
3294 /* Print nothing without the flag. Don't print the entering message
3295 again if we already have. Don't print the leaving message if we
3296 haven't printed the entering message. */
3297 if (! print_directory_flag || entering == entered)
3298 return;
3300 entered = entering;
3302 if (print_data_base_flag)
3303 fputs ("# ", stdout);
3305 /* Use entire sentences to give the translators a fighting chance. */
3307 if (makelevel == 0)
3308 if (starting_directory == 0)
3309 if (entering)
3310 printf (_("%s: Entering an unknown directory\n"), program);
3311 else
3312 printf (_("%s: Leaving an unknown directory\n"), program);
3313 else
3314 if (entering)
3315 printf (_("%s: Entering directory `%s'\n"),
3316 program, starting_directory);
3317 else
3318 printf (_("%s: Leaving directory `%s'\n"),
3319 program, starting_directory);
3320 else
3321 if (starting_directory == 0)
3322 if (entering)
3323 printf (_("%s[%u]: Entering an unknown directory\n"),
3324 program, makelevel);
3325 else
3326 printf (_("%s[%u]: Leaving an unknown directory\n"),
3327 program, makelevel);
3328 else
3329 if (entering)
3330 printf (_("%s[%u]: Entering directory `%s'\n"),
3331 program, makelevel, starting_directory);
3332 else
3333 printf (_("%s[%u]: Leaving directory `%s'\n"),
3334 program, makelevel, starting_directory);
3336 /* Flush stdout to be sure this comes before any stderr output. */
3337 fflush (stdout);