Context Navigation

source: trunk/src/kmk/main.c@ 1915

Last change on this file since 1915 was 1915, checked in by bird, 17 years ago
kmk: CONFIG_WITH_MINIMAL_STATS vs. CONFIG_WITH_MAKE_STATS - require special builds for expensive statistics.
Property svn:eol-style set to `native`
File size: 109.0 KB

Line
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 Free Software
4	Foundation, Inc.
5	This file is part of GNU Make.
6
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 2, or (at your option) any later version.
10
11	GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License along with
16	GNU Make; see the file COPYING. If not, write to the Free Software
17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
18
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"
28	#ifdef KMK
29	# include "kbuild.h"
30	#endif
31
32	#include <assert.h>
33	#ifdef _AMIGA
34	# include <dos/dos.h>
35	# include <proto/dos.h>
36	#endif
37	#ifdef WINDOWS32
38	#include <windows.h>
39	#include <io.h>
40	#include "pathstuff.h"
41	#endif
42	#ifdef __EMX__
43	# include <sys/types.h>
44	# include <sys/wait.h>
45	#endif
46	#ifdef HAVE_FCNTL_H
47	# include <fcntl.h>
48	#endif
49
50	#ifdef KMK /* for get_online_cpu_count */
51	# if defined(__APPLE__) \|\| defined(__FreeBSD__) \|\| defined(__NetBSD__) \|\| defined(__OpenBSD__)
52	# include <sys/sysctl.h>
53	# endif
54	# ifdef __OS2__
55	# define INCL_BASE
56	# include <os2.h>
57	# endif
58	#endif /* KMK*/
59
60	#if defined(HAVE_SYS_RESOURCE_H) && defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT)
61	# define SET_STACK_SIZE
62	#endif
63
64	#ifdef SET_STACK_SIZE
65	# include <sys/resource.h>
66	#endif
67
68	#ifdef _AMIGA
69	int __stack = 20000; /* Make sure we have 20K of stack space */
70	#endif
71
72	void init_dir (void);
73	void remote_setup (void);
74	void remote_cleanup (void);
75	RETSIGTYPE fatal_error_signal (int sig);
76
77	void print_variable_data_base (void);
78	void print_dir_data_base (void);
79	void print_rule_data_base (void);
80	void print_file_data_base (void);
81	void print_vpath_data_base (void);
82
83	void verify_file_data_base (void);
84
85	#if defined HAVE_WAITPID \|\| defined HAVE_WAIT3
86	# define HAVE_WAIT_NOHANG
87	#endif
88
89	#if !defined(HAVE_UNISTD_H) && !defined(_MSC_VER) /* bird */
90	int chdir ();
91	#endif
92	#ifndef STDC_HEADERS
93	# ifndef sun /* Sun has an incorrect decl in a header. */
94	void exit (int) __attribute__ ((noreturn));
95	# endif
96	double atof ();
97	#endif
98
99	static void clean_jobserver (int status);
100	static void print_data_base (void);
101	static void print_version (void);
102	static void decode_switches (int argc, char **argv, int env);
103	static void decode_env_switches (char *envar, unsigned int len);
104	static void define_makeflags (int all, int makefile);
105	static char quote_for_env (char out, const char *in);
106	static void initialize_global_hash_tables (void);
107
108
109
110	/* The structure that describes an accepted command switch. */
111
112	struct command_switch
113	{
114	int c; /* The switch character. */
115
116	enum /* Type of the value. */
117	{
118	flag, /* Turn int flag on. */
119	flag_off, /* Turn int flag off. */
120	string, /* One string per switch. */
121	filename, /* A string containing a file name. */
122	positive_int, /* A positive integer. */
123	floating, /* A floating-point number (double). */
124	ignore /* Ignored. */
125	} type;
126
127	void value_ptr; / Pointer to the value-holding variable. */
128
129	unsigned int env:1; /* Can come from MAKEFLAGS. */
130	unsigned int toenv:1; /* Should be put in MAKEFLAGS. */
131	unsigned int no_makefile:1; /* Don't propagate when remaking makefiles. */
132
133	const void noarg_value; / Pointer to value used if no arg given. */
134	const void default_value; / Pointer to default value. */
135
136	char long_name; / Long option name. */
137	};
138
139	/* True if C is a switch value that corresponds to a short option. */
140
141	#define short_option(c) ((c) <= CHAR_MAX)
142
143	/* The structure used to hold the list of strings given
144	in command switches of a type that takes string arguments. */
145
146	struct stringlist
147	{
148	const char *list; / Nil-terminated list of strings. */
149	unsigned int idx; /* Index into above. */
150	unsigned int max; /* Number of pointers allocated. */
151	};
152
153
154	/* The recognized command switches. */
155
156	/* Nonzero means do not print commands to be executed (-s). */
157
158	int silent_flag;
159
160	/* Nonzero means just touch the files
161	that would appear to need remaking (-t) */
162
163	int touch_flag;
164
165	/* Nonzero means just print what commands would need to be executed,
166	don't actually execute them (-n). */
167
168	int just_print_flag;
169
170	#ifdef CONFIG_PRETTY_COMMAND_PRINTING
171	/* Nonzero means to print commands argument for argument skipping blanks. */
172
173	int pretty_command_printing;
174	#endif
175
176	/* Print debugging info (--debug). */
177
178	static struct stringlist *db_flags;
179	static int debug_flag = 0;
180
181	int db_level = 0;
182
183	/* Output level (--verbosity). */
184
185	static struct stringlist *verbosity_flags;
186
187	#ifdef WINDOWS32
188	/* Suspend make in main for a short time to allow debugger to attach */
189
190	int suspend_flag = 0;
191	#endif
192
193	/* Environment variables override makefile definitions. */
194
195	int env_overrides = 0;
196
197	/* Nonzero means ignore status codes returned by commands
198	executed to remake files. Just treat them all as successful (-i). */
199
200	int ignore_errors_flag = 0;
201
202	/* Nonzero means don't remake anything, just print the data base
203	that results from reading the makefile (-p). */
204
205	int print_data_base_flag = 0;
206
207	/* Nonzero means don't remake anything; just return a nonzero status
208	if the specified targets are not up to date (-q). */
209
210	int question_flag = 0;
211
212	/* Nonzero means do not use any of the builtin rules (-r) / variables (-R). */
213
214	int no_builtin_rules_flag = 0;
215	int no_builtin_variables_flag = 0;
216
217	/* Nonzero means keep going even if remaking some file fails (-k). */
218
219	int keep_going_flag;
220	int default_keep_going_flag = 0;
221
222	/* Nonzero means check symlink mtimes. */
223
224	int check_symlink_flag = 0;
225
226	/* Nonzero means print directory before starting and when done (-w). */
227
228	int print_directory_flag = 0;
229
230	/* Nonzero means ignore print_directory_flag and never print the directory.
231	This is necessary because print_directory_flag is set implicitly. */
232
233	int inhibit_print_directory_flag = 0;
234
235	/* Nonzero means print version information. */
236
237	int print_version_flag = 0;
238
239	/* List of makefiles given with -f switches. */
240
241	static struct stringlist *makefiles = 0;
242
243	/* Number of job slots (commands that can be run at once). */
244
245	unsigned int job_slots = 1;
246	unsigned int default_job_slots = 1;
247	static unsigned int master_job_slots = 0;
248
249	/* Value of job_slots that means no limit. */
250
251	static unsigned int inf_jobs = 0;
252
253	/* File descriptors for the jobs pipe. */
254
255	static struct stringlist *jobserver_fds = 0;
256
257	int job_fds[2] = { -1, -1 };
258	int job_rfd = -1;
259
260	/* Maximum load average at which multiple jobs will be run.
261	Negative values mean unlimited, while zero means limit to
262	zero load (which could be useful to start infinite jobs remotely
263	but one at a time locally). */
264	#ifndef NO_FLOAT
265	double max_load_average = -1.0;
266	double default_load_average = -1.0;
267	#else
268	int max_load_average = -1;
269	int default_load_average = -1;
270	#endif
271
272	/* List of directories given with -C switches. */
273
274	static struct stringlist *directories = 0;
275
276	/* List of include directories given with -I switches. */
277
278	static struct stringlist *include_directories = 0;
279
280	/* List of files given with -o switches. */
281
282	static struct stringlist *old_files = 0;
283
284	/* List of files given with -W switches. */
285
286	static struct stringlist *new_files = 0;
287
288	/* If nonzero, we should just print usage and exit. */
289
290	static int print_usage_flag = 0;
291
292	/* If nonzero, we should print a warning message
293	for each reference to an undefined variable. */
294
295	int warn_undefined_variables_flag;
296
297	/* If nonzero, always build all targets, regardless of whether
298	they appear out of date or not. */
299
300	static int always_make_set = 0;
301	int always_make_flag = 0;
302
303	/* If nonzero, we're in the "try to rebuild makefiles" phase. */
304
305	int rebuilding_makefiles = 0;
306
307	/* Remember the original value of the SHELL variable, from the environment. */
308
309	struct variable shell_var;
310
311	/* This character introduces a command: it's the first char on the line. */
312
313	char cmd_prefix = '\t';
314
315	#ifdef KMK
316	/* Process priority.
317	0 = no change;
318	1 = idle / max nice;
319	2 = below normal / nice 10;
320	3 = normal / nice 0;
321	4 = high / nice -10;
322	5 = realtime / nice -19; */
323
324	int process_priority = 0;
325
326	/* Process affinity mask; 0 means any CPU. */
327
328	int process_affinity = 0;
329	#endif /* KMK */
330
331	#if defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)
332	/* When set, we'll gather expensive statistics like for the heap. */
333
334	int make_expensive_statistics = 0;
335	#endif
336
337
338
339	/* The usage output. We write it this way to make life easier for the
340	translators, especially those trying to translate to right-to-left
341	languages like Hebrew. */
342
343	static const char *const usage[] =
344	{
345	N_("Options:\n"),
346	N_("\
347	-b, -m Ignored for compatibility.\n"),
348	N_("\
349	-B, --always-make Unconditionally make all targets.\n"),
350	N_("\
351	-C DIRECTORY, --directory=DIRECTORY\n\
352	Change to DIRECTORY before doing anything.\n"),
353	N_("\
354	-d Print lots of debugging information.\n"),
355	N_("\
356	--debug[=FLAGS] Print various types of debugging information.\n"),
357	N_("\
358	-e, --environment-overrides\n\
359	Environment variables override makefiles.\n"),
360	N_("\
361	-f FILE, --file=FILE, --makefile=FILE\n\
362	Read FILE as a makefile.\n"),
363	N_("\
364	-h, --help Print this message and exit.\n"),
365	N_("\
366	-i, --ignore-errors Ignore errors from commands.\n"),
367	N_("\
368	-I DIRECTORY, --include-dir=DIRECTORY\n\
369	Search DIRECTORY for included makefiles.\n"),
370	#ifdef KMK
371	N_("\
372	-j [N], --jobs[=N] Allow N jobs at once; infinite jobs with no arg.\n\
373	The default is the number of active CPUs.\n"),
374	#else
375	N_("\
376	-j [N], --jobs[=N] Allow N jobs at once; infinite jobs with no arg.\n"),
377	#endif
378	N_("\
379	-k, --keep-going Keep going when some targets can't be made.\n"),
380	N_("\
381	-l [N], --load-average[=N], --max-load[=N]\n\
382	Don't start multiple jobs unless load is below N.\n"),
383	N_("\
384	-L, --check-symlink-times Use the latest mtime between symlinks and target.\n"),
385	N_("\
386	-n, --just-print, --dry-run, --recon\n\
387	Don't actually run any commands; just print them.\n"),
388	N_("\
389	-o FILE, --old-file=FILE, --assume-old=FILE\n\
390	Consider FILE to be very old and don't remake it.\n"),
391	N_("\
392	-p, --print-data-base Print make's internal database.\n"),
393	N_("\
394	-q, --question Run no commands; exit status says if up to date.\n"),
395	N_("\
396	-r, --no-builtin-rules Disable the built-in implicit rules.\n"),
397	N_("\
398	-R, --no-builtin-variables Disable the built-in variable settings.\n"),
399	N_("\
400	-s, --silent, --quiet Don't echo commands.\n"),
401	N_("\
402	-S, --no-keep-going, --stop\n\
403	Turns off -k.\n"),
404	N_("\
405	-t, --touch Touch targets instead of remaking them.\n"),
406	N_("\
407	-v, --version Print the version number of make and exit.\n"),
408	N_("\
409	-w, --print-directory Print the current directory.\n"),
410	N_("\
411	--no-print-directory Turn off -w, even if it was turned on implicitly.\n"),
412	N_("\
413	-W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE\n\
414	Consider FILE to be infinitely new.\n"),
415	N_("\
416	--warn-undefined-variables Warn when an undefined variable is referenced.\n"),
417	#ifdef KMK
418	N_("\
419	--affinity=mask Sets the CPU affinity on some hosts.\n"),
420	N_("\
421	--priority=1-5 Sets the process priority / nice level:\n\
422	1 = idle / max nice;\n\
423	2 = below normal / nice 10;\n\
424	3 = normal / nice 0;\n\
425	4 = high / nice -10;\n\
426	5 = realtime / nice -19;\n"),
427	#endif /* KMK */
428	#ifdef CONFIG_PRETTY_COMMAND_PRINTING
429	N_("\
430	--pretty-command-printing Makes the command echo easier to read.\n"),
431	#endif
432	#ifdef CONFIG_WITH_MAKE_STATS
433	N_("\
434	--statistics Gather extra statistics for $(make-stats ).\n"),
435	#endif
436	NULL
437	};
438
439	/* The table of command switches. */
440
441	static const struct command_switch switches[] =
442	{
443	{ 'b', ignore, 0, 0, 0, 0, 0, 0, 0 },
444	{ 'B', flag, &always_make_set, 1, 1, 0, 0, 0, "always-make" },
445	{ 'C', filename, &directories, 0, 0, 0, 0, 0, "directory" },
446	{ 'd', flag, &debug_flag, 1, 1, 0, 0, 0, 0 },
447	{ CHAR_MAX+1, string, &db_flags, 1, 1, 0, "basic", 0, "debug" },
448	#ifdef WINDOWS32
449	{ 'D', flag, &suspend_flag, 1, 1, 0, 0, 0, "suspend-for-debug" },
450	#endif
451	{ 'e', flag, &env_overrides, 1, 1, 0, 0, 0, "environment-overrides", },
452	{ 'f', filename, &makefiles, 0, 0, 0, 0, 0, "file" },
453	{ 'h', flag, &print_usage_flag, 0, 0, 0, 0, 0, "help" },
454	{ 'i', flag, &ignore_errors_flag, 1, 1, 0, 0, 0, "ignore-errors" },
455	{ 'I', filename, &include_directories, 1, 1, 0, 0, 0,
456	"include-dir" },
457	{ 'j', positive_int, &job_slots, 1, 1, 0, &inf_jobs, &default_job_slots,
458	"jobs" },
459	{ CHAR_MAX+2, string, &jobserver_fds, 1, 1, 0, 0, 0, "jobserver-fds" },
460	{ 'k', flag, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
461	"keep-going" },
462	#ifndef NO_FLOAT
463	{ 'l', floating, &max_load_average, 1, 1, 0, &default_load_average,
464	&default_load_average, "load-average" },
465	#else
466	{ 'l', positive_int, &max_load_average, 1, 1, 0, &default_load_average,
467	&default_load_average, "load-average" },
468	#endif
469	{ 'L', flag, &check_symlink_flag, 1, 1, 0, 0, 0, "check-symlink-times" },
470	{ 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },
471	{ 'n', flag, &just_print_flag, 1, 1, 1, 0, 0, "just-print" },
472	{ 'o', filename, &old_files, 0, 0, 0, 0, 0, "old-file" },
473	{ 'p', flag, &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base" },
474	#ifdef CONFIG_PRETTY_COMMAND_PRINTING
475	{ CHAR_MAX+10, flag, (char *) &pretty_command_printing, 1, 1, 1, 0, 0,
476	"pretty-command-printing" },
477	#endif
478	#ifdef KMK
479	{ CHAR_MAX+11, positive_int, (char *) &process_priority, 1, 1, 0,
480	(char ) &process_priority, (char ) &process_priority, "priority" },
481	{ CHAR_MAX+12, positive_int, (char *) &process_affinity, 1, 1, 0,
482	(char ) &process_affinity, (char ) &process_affinity, "affinity" },
483	#endif
484	{ 'q', flag, &question_flag, 1, 1, 1, 0, 0, "question" },
485	{ 'r', flag, &no_builtin_rules_flag, 1, 1, 0, 0, 0, "no-builtin-rules" },
486	{ 'R', flag, &no_builtin_variables_flag, 1, 1, 0, 0, 0,
487	"no-builtin-variables" },
488	{ 's', flag, &silent_flag, 1, 1, 0, 0, 0, "silent" },
489	{ 'S', flag_off, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
490	"no-keep-going" },
491	#if defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)
492	{ CHAR_MAX+14, flag, (char *) &make_expensive_statistics, 1, 1, 1, 0, 0,
493	"statistics" },
494	#endif
495	{ 't', flag, &touch_flag, 1, 1, 1, 0, 0, "touch" },
496	{ 'v', flag, &print_version_flag, 1, 1, 0, 0, 0, "version" },
497	{ CHAR_MAX+3, string, &verbosity_flags, 1, 1, 0, 0, 0,
498	"verbosity" },
499	{ 'w', flag, &print_directory_flag, 1, 1, 0, 0, 0, "print-directory" },
500	{ CHAR_MAX+4, flag, &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
501	"no-print-directory" },
502	{ 'W', filename, &new_files, 0, 0, 0, 0, 0, "what-if" },
503	{ CHAR_MAX+5, flag, &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
504	"warn-undefined-variables" },
505	{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }
506	};
507
508	/* Secondary long names for options. */
509
510	static struct option long_option_aliases[] =
511	{
512	{ "quiet", no_argument, 0, 's' },
513	{ "stop", no_argument, 0, 'S' },
514	{ "new-file", required_argument, 0, 'W' },
515	{ "assume-new", required_argument, 0, 'W' },
516	{ "assume-old", required_argument, 0, 'o' },
517	{ "max-load", optional_argument, 0, 'l' },
518	{ "dry-run", no_argument, 0, 'n' },
519	{ "recon", no_argument, 0, 'n' },
520	{ "makefile", required_argument, 0, 'f' },
521	};
522
523	/* List of goal targets. */
524
525	static struct dep goals, lastgoal;
526
527	/* List of variables which were defined on the command line
528	(or, equivalently, in MAKEFLAGS). */
529
530	struct command_variable
531	{
532	struct command_variable *next;
533	struct variable *variable;
534	};
535	static struct command_variable *command_variables;
536
537
538	/* The name we were invoked with. */
539
540	char *program;
541
542	/* Our current directory before processing any -C options. */
543
544	char *directory_before_chdir;
545
546	/* Our current directory after processing all -C options. */
547
548	char *starting_directory;
549
550	/* Value of the MAKELEVEL variable at startup (or 0). */
551
552	unsigned int makelevel;
553
554	/* First file defined in the makefile whose name does not
555	start with `.'. This is the default to remake if the
556	command line does not specify. */
557
558	struct file *default_goal_file;
559
560	/* Pointer to the value of the .DEFAULT_GOAL special
561	variable. */
562	char ** default_goal_name;
563
564	/* Pointer to structure for the file .DEFAULT
565	whose commands are used for any file that has none of its own.
566	This is zero if the makefiles do not define .DEFAULT. */
567
568	struct file *default_file;
569
570	/* Nonzero if we have seen the magic `.POSIX' target.
571	This turns on pedantic compliance with POSIX.2. */
572
573	int posix_pedantic;
574
575	/* Nonzero if we have seen the '.SECONDEXPANSION' target.
576	This turns on secondary expansion of prerequisites. */
577
578	int second_expansion;
579
580	#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
581	/* Nonzero if we have seen the '.SECONDTARGETEXPANSION' target.
582	This turns on secondary expansion of targets. */
583
584	int second_target_expansion;
585	#endif
586
587	#ifndef CONFIG_WITH_EXTENDED_NOTPARALLEL
588	/* Nonzero if we have seen the `.NOTPARALLEL' target.
589	This turns off parallel builds for this invocation of make. */
590
591	#else /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
592
593	/* Negative if we have seen the `.NOTPARALLEL' target with an
594	empty dependency list.
595
596	Zero if no `.NOTPARALLEL' or no file in the dependency list
597	is being executed.
598
599	Positive when a file in the `.NOTPARALLEL' dependency list
600	is in progress, the value is the number of notparallel files
601	in progress (running or queued for running).
602
603	In short, any nonzero value means no more parallel builing. */
604	#endif /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
605
606	int not_parallel;
607
608	/* Nonzero if some rule detected clock skew; we keep track so (a) we only
609	print one warning about it during the run, and (b) we can print a final
610	warning at the end of the run. */
611
612	int clock_skew_detected;
613
614
615	/* Mask of signals that are being caught with fatal_error_signal. */
616
617	#ifdef POSIX
618	sigset_t fatal_signal_set;
619	#else
620	# ifdef HAVE_SIGSETMASK
621	int fatal_signal_mask;
622	# endif
623	#endif
624
625	#if !defined HAVE_BSD_SIGNAL && !defined bsd_signal
626	# if !defined HAVE_SIGACTION
627	# define bsd_signal signal
628	# else
629	typedef RETSIGTYPE (*bsd_signal_ret_t) ();
630
631	static bsd_signal_ret_t
632	bsd_signal (int sig, bsd_signal_ret_t func)
633	{
634	struct sigaction act, oact;
635	act.sa_handler = func;
636	act.sa_flags = SA_RESTART;
637	sigemptyset (&act.sa_mask);
638	sigaddset (&act.sa_mask, sig);
639	if (sigaction (sig, &act, &oact) != 0)
640	return SIG_ERR;
641	return oact.sa_handler;
642	}
643	# endif
644	#endif
645
646	#ifdef CONFIG_WITH_ALLOC_CACHES
647	struct alloccache dep_cache;
648	struct alloccache file_cache;
649	struct alloccache commands_cache;
650	struct alloccache nameseq_cache;
651	struct alloccache variable_cache;
652	struct alloccache variable_set_cache;
653	struct alloccache variable_set_list_cache;
654
655	static void
656	initialize_global_alloc_caches (void)
657	{
658	alloccache_init (&dep_cache, sizeof (struct dep), "dep", NULL, NULL);
659	alloccache_init (&file_cache, sizeof (struct file), "file", NULL, NULL);
660	alloccache_init (&commands_cache, sizeof (struct commands), "commands", NULL, NULL);
661	alloccache_init (&nameseq_cache, sizeof (struct nameseq), "nameseq", NULL, NULL);
662	alloccache_init (&variable_cache, sizeof (struct variable), "variable", NULL, NULL);
663	alloccache_init (&variable_set_cache, sizeof (struct variable_set), "variable_set", NULL, NULL);
664	alloccache_init (&variable_set_list_cache, sizeof (struct variable_set_list), "variable_set_list", NULL, NULL);
665	}
666	#endif
667
668	static void
669	initialize_global_hash_tables (void)
670	{
671	init_hash_global_variable_set ();
672	strcache_init ();
673	init_hash_files ();
674	hash_init_directories ();
675	hash_init_function_table ();
676	}
677
678	static const char *
679	expand_command_line_file (char *name)
680	{
681	const char *cp;
682	char *expanded = 0;
683
684	if (name[0] == '\0')
685	fatal (NILF, _("empty string invalid as file name"));
686
687	if (name[0] == '~')
688	{
689	expanded = tilde_expand (name);
690	if (expanded != 0)
691	name = expanded;
692	}
693
694	/* This is also done in parse_file_seq, so this is redundant
695	for names read from makefiles. It is here for names passed
696	on the command line. */
697	while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
698	{
699	name += 2;
700	while (*name == '/')
701	/* Skip following slashes: ".//foo" is "foo", not "/foo". */
702	++name;
703	}
704
705	if (*name == '\0')
706	{
707	/* It was all slashes! Move back to the dot and truncate
708	it after the first slash, so it becomes just "./". */
709	do
710	--name;
711	while (name[0] != '.');
712	name[2] = '\0';
713	}
714
715	cp = strcache_add (name);
716
717	if (expanded)
718	free (expanded);
719
720	return cp;
721	}
722
723	/* Toggle -d on receipt of SIGUSR1. */
724
725	#ifdef SIGUSR1
726	static RETSIGTYPE
727	debug_signal_handler (int sig UNUSED)
728	{
729	db_level = db_level ? DB_NONE : DB_BASIC;
730	}
731	#endif
732
733	static void
734	decode_debug_flags (void)
735	{
736	const char **pp;
737
738	if (debug_flag)
739	db_level = DB_ALL;
740
741	if (!db_flags)
742	return;
743
744	for (pp=db_flags->list; *pp; ++pp)
745	{
746	const char p = pp;
747
748	while (1)
749	{
750	switch (tolower (p[0]))
751	{
752	case 'a':
753	db_level \|= DB_ALL;
754	break;
755	case 'b':
756	db_level \|= DB_BASIC;
757	break;
758	case 'i':
759	db_level \|= DB_BASIC \| DB_IMPLICIT;
760	break;
761	case 'j':
762	db_level \|= DB_JOBS;
763	break;
764	case 'm':
765	db_level \|= DB_BASIC \| DB_MAKEFILES;
766	break;
767	case 'v':
768	db_level \|= DB_BASIC \| DB_VERBOSE;
769	break;
770	#ifdef DB_KMK
771	case 'k':
772	db_level \|= DB_KMK;
773	break;
774	#endif
775	default:
776	fatal (NILF, _("unknown debug level specification `%s'"), p);
777	}
778
779	while (*(++p) != '\0')
780	if (p == ',' \|\| p == ' ')
781	break;
782
783	if (*p == '\0')
784	break;
785
786	++p;
787	}
788	}
789	}
790
791
792	#ifdef KMK
793	static void
794	set_make_priority_and_affinity (void)
795	{
796	#ifdef WINDOWS32
797	DWORD dwPriority;
798	if (process_affinity)
799	if (!SetProcessAffinityMask (GetCurrentProcess (), process_affinity))
800	fprintf (stderr, "warning: SetPriorityClass (,%#x) failed with last error %d\n",
801	process_affinity, GetLastError());
802
803	switch (process_priority)
804	{
805	case 0: return;
806	case 1: dwPriority = IDLE_PRIORITY_CLASS; break;
807	case 2: dwPriority = BELOW_NORMAL_PRIORITY_CLASS; break;
808	case 3: dwPriority = NORMAL_PRIORITY_CLASS; break;
809	case 4: dwPriority = HIGH_PRIORITY_CLASS; break;
810	case 5: dwPriority = REALTIME_PRIORITY_CLASS; break;
811	default: fatal(NILF, _("invalid priority %d\n"), process_priority);
812	}
813	if (!SetPriorityClass (GetCurrentProcess (), dwPriority))
814	fprintf (stderr, "warning: SetPriorityClass (,%#x) failed with last error %d\n",
815	dwPriority, GetLastError ());
816
817	#else /#elif HAVE_NICE /
818	int nice_level = 0;
819	switch (process_priority)
820	{
821	case 0: return;
822	case 1: nice_level = 19; break;
823	case 2: nice_level = 10; break;
824	case 3: nice_level = 0; break;
825	case 4: nice_level = -10; break;
826	case 5: nice_level = -19; break;
827	default: fatal(NILF, _("invalid priority %d\n"), process_priority);
828	}
829	errno = 0;
830	if (nice (nice_level) == -1 && errno != 0)
831	fprintf (stderr, "warning: nice (%d) failed: %s\n",
832	nice_level, strerror (errno));
833	#endif
834	}
835	#endif
836
837
838	#ifdef WINDOWS32
839	/*
840	* HANDLE runtime exceptions by avoiding a requestor on the GUI. Capture
841	* exception and print it to stderr instead.
842	*
843	* If ! DB_VERBOSE, just print a simple message and exit.
844	* If DB_VERBOSE, print a more verbose message.
845	* If compiled for DEBUG, let exception pass through to GUI so that
846	* debuggers can attach.
847	*/
848	LONG WINAPI
849	handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
850	{
851	PEXCEPTION_RECORD exrec = exinfo->ExceptionRecord;
852	LPSTR cmdline = GetCommandLine();
853	LPSTR prg = strtok(cmdline, " ");
854	CHAR errmsg[1024];
855	#ifdef USE_EVENT_LOG
856	HANDLE hEventSource;
857	LPTSTR lpszStrings[1];
858	#endif
859
860	if (! ISDB (DB_VERBOSE))
861	{
862	sprintf(errmsg,
863	_("%s: Interrupt/Exception caught (code = 0x%lx, addr = 0x%lx)\n"),
864	prg, exrec->ExceptionCode, (DWORD)exrec->ExceptionAddress);
865	fprintf(stderr, errmsg);
866	exit(255);
867	}
868
869	sprintf(errmsg,
870	_("\nUnhandled exception filter called from program %s\nExceptionCode = %lx\nExceptionFlags = %lx\nExceptionAddress = %lx\n"),
871	prg, exrec->ExceptionCode, exrec->ExceptionFlags,
872	(DWORD)exrec->ExceptionAddress);
873
874	if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION
875	&& exrec->NumberParameters >= 2)
876	sprintf(&errmsg[strlen(errmsg)],
877	(exrec->ExceptionInformation[0]
878	? _("Access violation: write operation at address %lx\n")
879	: _("Access violation: read operation at address %lx\n")),
880	exrec->ExceptionInformation[1]);
881
882	/* turn this on if we want to put stuff in the event log too */
883	#ifdef USE_EVENT_LOG
884	hEventSource = RegisterEventSource(NULL, "GNU Make");
885	lpszStrings[0] = errmsg;
886
887	if (hEventSource != NULL)
888	{
889	ReportEvent(hEventSource, /* handle of event source */
890	EVENTLOG_ERROR_TYPE, /* event type */
891	0, /* event category */
892	0, /* event ID */
893	NULL, /* current user's SID */
894	1, /* strings in lpszStrings */
895	0, /* no bytes of raw data */
896	lpszStrings, /* array of error strings */
897	NULL); /* no raw data */
898
899	(VOID) DeregisterEventSource(hEventSource);
900	}
901	#endif
902
903	/* Write the error to stderr too */
904	fprintf(stderr, errmsg);
905
906	#ifdef DEBUG
907	return EXCEPTION_CONTINUE_SEARCH;
908	#else
909	exit(255);
910	return (255); /* not reached */
911	#endif
912	}
913
914	/*
915	* On WIN32 systems we don't have the luxury of a /bin directory that
916	* is mapped globally to every drive mounted to the system. Since make could
917	* be invoked from any drive, and we don't want to propogate /bin/sh
918	* to every single drive. Allow ourselves a chance to search for
919	* a value for default shell here (if the default path does not exist).
920	*/
921
922	int
923	find_and_set_default_shell (const char *token)
924	{
925	int sh_found = 0;
926	char *atoken = 0;
927	char *search_token;
928	char *tokend;
929	PATH_VAR(sh_path);
930	extern char *default_shell;
931
932	if (!token)
933	search_token = default_shell;
934	else
935	atoken = search_token = xstrdup (token);
936
937	/* If the user explicitly requests the DOS cmd shell, obey that request.
938	However, make sure that's what they really want by requiring the value
939	of SHELL either equal, or have a final path element of, "cmd" or
940	"cmd.exe" case-insensitive. */
941	tokend = search_token + strlen (search_token) - 3;
942	if (((tokend == search_token
943	\|\| (tokend > search_token
944	&& (tokend[-1] == '/' \|\| tokend[-1] == '\\')))
945	&& !strcasecmp (tokend, "cmd"))
946	\|\| ((tokend - 4 == search_token
947	\|\| (tokend - 4 > search_token
948	&& (tokend[-5] == '/' \|\| tokend[-5] == '\\')))
949	&& !strcasecmp (tokend - 4, "cmd.exe"))) {
950	batch_mode_shell = 1;
951	unixy_shell = 0;
952	sprintf (sh_path, "%s", search_token);
953	default_shell = xstrdup (w32ify (sh_path, 0));
954	DB (DB_VERBOSE,
955	(_("find_and_set_shell setting default_shell = %s\n"), default_shell));
956	sh_found = 1;
957	} else if (!no_default_sh_exe &&
958	(token == NULL \|\| !strcmp (search_token, default_shell))) {
959	/* no new information, path already set or known */
960	sh_found = 1;
961	} else if (file_exists_p (search_token)) {
962	/* search token path was found */
963	sprintf (sh_path, "%s", search_token);
964	default_shell = xstrdup (w32ify (sh_path, 0));
965	DB (DB_VERBOSE,
966	(_("find_and_set_shell setting default_shell = %s\n"), default_shell));
967	sh_found = 1;
968	} else {
969	char *p;
970	struct variable *v = lookup_variable (STRING_SIZE_TUPLE ("PATH"));
971
972	/* Search Path for shell */
973	if (v && v->value) {
974	char *ep;
975
976	p = v->value;
977	ep = strchr (p, PATH_SEPARATOR_CHAR);
978
979	while (ep && *ep) {
980	*ep = '\0';
981
982	if (dir_file_exists_p (p, search_token)) {
983	sprintf (sh_path, "%s/%s", p, search_token);
984	default_shell = xstrdup (w32ify (sh_path, 0));
985	sh_found = 1;
986	*ep = PATH_SEPARATOR_CHAR;
987
988	/* terminate loop */
989	p += strlen (p);
990	} else {
991	*ep = PATH_SEPARATOR_CHAR;
992	p = ++ep;
993	}
994
995	ep = strchr (p, PATH_SEPARATOR_CHAR);
996	}
997
998	/* be sure to check last element of Path */
999	if (p && *p && dir_file_exists_p (p, search_token)) {
1000	sprintf (sh_path, "%s/%s", p, search_token);
1001	default_shell = xstrdup (w32ify (sh_path, 0));
1002	sh_found = 1;
1003	}
1004
1005	if (sh_found)
1006	DB (DB_VERBOSE,
1007	(_("find_and_set_shell path search set default_shell = %s\n"),
1008	default_shell));
1009	}
1010	}
1011
1012	#if 0/* def KMK - has been fixed in sub_proc.c */
1013	/* WORKAROUND:
1014	With GNU Make 3.81, this kludge was necessary to get double quotes
1015	working correctly again (worked fine with the 3.81beta1 code).
1016	beta1 was forcing batch_mode_shell I think, so let's enforce that
1017	for the kBuild shell. */
1018	if (sh_found && strstr(default_shell, "kmk_ash")) {
1019	unixy_shell = 1;
1020	batch_mode_shell = 1;
1021	} else
1022	#endif
1023	/* naive test */
1024	if (!unixy_shell && sh_found &&
1025	(strstr (default_shell, "sh") \|\| strstr (default_shell, "SH"))) {
1026	unixy_shell = 1;
1027	batch_mode_shell = 0;
1028	}
1029
1030	#ifdef BATCH_MODE_ONLY_SHELL
1031	batch_mode_shell = 1;
1032	#endif
1033
1034	if (atoken)
1035	free (atoken);
1036
1037	return (sh_found);
1038	}
1039
1040	/* bird: */
1041	#ifdef CONFIG_NEW_WIN32_CTRL_EVENT
1042	#include <process.h>
1043	static UINT g_tidMainThread = 0;
1044	static int volatile g_sigPending = 0; /* lazy bird */
1045	# ifndef _M_IX86
1046	static LONG volatile g_lTriggered = 0;
1047	static CONTEXT g_Ctx;
1048	# endif
1049
1050	# ifdef _M_IX86
1051	static __declspec(naked) void dispatch_stub(void)
1052	{
1053	__asm {
1054	pushfd
1055	pushad
1056	cld
1057	}
1058	fflush(stdout);
1059	/fprintf(stderr, "dbg: raising %s on the main thread (%d)\n", g_sigPending == SIGINT ? "SIGINT" : "SIGBREAK", _getpid());/
1060	raise(g_sigPending);
1061	__asm {
1062	popad
1063	popfd
1064	ret
1065	}
1066	}
1067	# else /* !_M_IX86 */
1068	static void dispatch_stub(void)
1069	{
1070	fflush(stdout);
1071	/fprintf(stderr, "dbg: raising %s on the main thread (%d)\n", g_sigPending == SIGINT ? "SIGINT" : "SIGBREAK", _getpid());/
1072	raise(g_sigPending);
1073
1074	SetThreadContext(GetCurrentThread(), &g_Ctx);
1075	fprintf(stderr, "fatal error: SetThreadContext failed with last error %d\n", GetLastError());
1076	for (;;)
1077	exit(131);
1078	}
1079	# endif /* !_M_IX86 */
1080
1081	static BOOL WINAPI ctrl_event(DWORD CtrlType)
1082	{
1083	int sig = (CtrlType == CTRL_C_EVENT) ? SIGINT : SIGBREAK;
1084	HANDLE hThread;
1085	CONTEXT Ctx;
1086
1087	#ifndef _M_IX86
1088	/* only once. */
1089	if (InterlockedExchange(&g_lTriggered, 1))
1090	{
1091	Sleep(1);
1092	return TRUE;
1093	}
1094	#endif
1095
1096	/* open the main thread and suspend it. */
1097	hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, g_tidMainThread);
1098	SuspendThread(hThread);
1099
1100	/* Get the thread context and if we've get a valid Esp, dispatch
1101	it on the main thread otherwise raise the signal in the
1102	ctrl-event thread (this). */
1103	memset(&Ctx, 0, sizeof(Ctx));
1104	Ctx.ContextFlags = CONTEXT_FULL;
1105	if (GetThreadContext(hThread, &Ctx)
1106	#ifdef _M_IX86
1107	&& Ctx.Esp >= 0x1000
1108	#else
1109	&& Ctx.Rsp >= 0x1000
1110	#endif
1111	)
1112	{
1113	#ifdef _M_IX86
1114	((uintptr_t *)Ctx.Esp)[-1] = Ctx.Eip;
1115	Ctx.Esp -= sizeof(uintptr_t);
1116	Ctx.Eip = (uintptr_t)&dispatch_stub;
1117	#else
1118	g_Ctx = Ctx;
1119	Ctx.Rsp -= 0x20;
1120	Ctx.Rsp &= ~(uintptr_t)0xf;
1121	Ctx.Rip = (uintptr_t)&dispatch_stub;
1122	#endif
1123
1124	SetThreadContext(hThread, &Ctx);
1125	g_sigPending = sig;
1126	ResumeThread(hThread);
1127	CloseHandle(hThread);
1128	}
1129	else
1130	{
1131	fprintf(stderr, "dbg: raising %s on the ctrl-event thread (%d)\n", sig == SIGINT ? "SIGINT" : "SIGBREAK", _getpid());
1132	raise(sig);
1133	ResumeThread(hThread);
1134	CloseHandle(hThread);
1135	exit(130);
1136	}
1137
1138	Sleep(1);
1139	return TRUE;
1140	}
1141	#endif /* CONFIG_NEW_WIN32_CTRL_EVENT */
1142
1143	#endif /* WINDOWS32 */
1144
1145	#ifdef KMK
1146	/* Determins the number of CPUs that are currently online.
1147	This is used to setup the default number of job slots. */
1148	static int
1149	get_online_cpu_count(void)
1150	{
1151	# ifdef WINDOWS32
1152	/* Windows: Count the active CPUs. */
1153	int cpus, i;
1154	SYSTEM_INFO si;
1155	GetSystemInfo(&si);
1156	for (i = cpus = 0; i < sizeof(si.dwActiveProcessorMask) * 8; i++)
1157	{
1158	if (si.dwActiveProcessorMask & 1)
1159	cpus++;
1160	si.dwActiveProcessorMask >>= 1;
1161	}
1162	return cpus ? cpus : 1;
1163
1164	# elif defined(__OS2__)
1165	/* OS/2: Count the active CPUs. */
1166	int cpus, i, j;
1167	MPAFFINITY mp;
1168	if (DosQueryThreadAffinity(AFNTY_SYSTEM, &mp))
1169	return 1;
1170	for (j = cpus = 0; j < sizeof(mp.mask) / sizeof(mp.mask[0]); j++)
1171	for (i = 0; i < 32; i++)
1172	if (mp.mask[j] & (1UL << i))
1173	cpus++;
1174	return cpus ? cpus : 1;
1175
1176	# else
1177	/* UNIX like systems, try sysconf and sysctl. */
1178	int cpus = -1;
1179	# if defined(CTL_HW)
1180	int mib[2];
1181	size_t sz;
1182	# endif
1183
1184	# ifdef _SC_NPROCESSORS_ONLN
1185	cpus = sysconf(_SC_NPROCESSORS_ONLN);
1186	if (cpus >= 1)
1187	return cpus;
1188	cpus = -1;
1189	# endif
1190
1191	# if defined(CTL_HW)
1192	# ifdef HW_AVAILCPU
1193	sz = sizeof(cpus);
1194	mib[0] = CTL_HW;
1195	mib[1] = HW_AVAILCPU;
1196	if (!sysctl(mib, 2, &cpus, &sz, NULL, 0)
1197	&& cpus >= 1)
1198	return cpus;
1199	cpus = -1;
1200	# endif /* HW_AVAILCPU */
1201
1202	sz = sizeof(cpus);
1203	mib[0] = CTL_HW;
1204	mib[1] = HW_NCPU;
1205	if (!sysctl(mib, 2, &cpus, &sz, NULL, 0)
1206	&& cpus >= 1)
1207	return cpus;
1208	cpus = -1;
1209	# endif /* CTL_HW */
1210
1211	/* no idea / failure, just return 1. */
1212	return 1;
1213	# endif
1214	}
1215	#endif /* KMK */
1216
1217	#ifdef __MSDOS__
1218	static void
1219	msdos_return_to_initial_directory (void)
1220	{
1221	if (directory_before_chdir)
1222	chdir (directory_before_chdir);
1223	}
1224	#endif /* __MSDOS__ */
1225
1226	#ifndef _MSC_VER /* bird */
1227	char mktemp (char template);
1228	#endif
1229	int mkstemp (char *template);
1230
1231	FILE *
1232	open_tmpfile(char *name, const char template)
1233	{
1234	#ifdef HAVE_FDOPEN
1235	int fd;
1236	#endif
1237
1238	#if defined HAVE_MKSTEMP \|\| defined HAVE_MKTEMP
1239	# define TEMPLATE_LEN strlen (template)
1240	#else
1241	# define TEMPLATE_LEN L_tmpnam
1242	#endif
1243	*name = xmalloc (TEMPLATE_LEN + 1);
1244	strcpy (*name, template);
1245
1246	#if defined HAVE_MKSTEMP && defined HAVE_FDOPEN
1247	/* It's safest to use mkstemp(), if we can. */
1248	fd = mkstemp (*name);
1249	if (fd == -1)
1250	return 0;
1251	return fdopen (fd, "w");
1252	#else
1253	# ifdef HAVE_MKTEMP
1254	(void) mktemp (*name);
1255	# else
1256	(void) tmpnam (*name);
1257	# endif
1258
1259	# ifdef HAVE_FDOPEN
1260	/* Can't use mkstemp(), but guard against a race condition. */
1261	fd = open (*name, O_CREAT\|O_EXCL\|O_WRONLY, 0600);
1262	if (fd == -1)
1263	return 0;
1264	return fdopen (fd, "w");
1265	# else
1266	/* Not secure, but what can we do? */
1267	return fopen (*name, "w");
1268	# endif
1269	#endif
1270	}
1271
1272	#if defined(set_space_map_entry) /bird/
1273	char space_map[space_map_size];
1274	#endif
1275
1276
1277	#ifdef _AMIGA
1278	int
1279	main (int argc, char **argv)
1280	#else
1281	int
1282	main (int argc, char argv, char envp)
1283	#endif
1284	{
1285	static char *stdin_nm = 0;
1286	int makefile_status = MAKE_SUCCESS;
1287	struct dep *read_makefiles;
1288	PATH_VAR (current_directory);
1289	unsigned int restarts = 0;
1290	#ifdef WINDOWS32
1291	char *unix_path = NULL;
1292	char *windows32_path = NULL;
1293
1294	#ifndef ELECTRIC_HEAP /* Drop this because it prevent JIT debugging. */
1295	SetUnhandledExceptionFilter(handle_runtime_exceptions);
1296	#endif /* !ELECTRIC_HEAP */
1297
1298	/* start off assuming we have no shell */
1299	unixy_shell = 0;
1300	no_default_sh_exe = 1;
1301	#endif
1302	# if defined(set_space_map_entry) /* bird */
1303	memset (space_map, '\0', sizeof(space_map));
1304	set_space_map_entry (' ');
1305	set_space_map_entry ('\f');
1306	set_space_map_entry ('\n');
1307	set_space_map_entry ('\r');
1308	set_space_map_entry ('\t');
1309	set_space_map_entry ('\v');
1310	# endif
1311
1312	#ifdef SET_STACK_SIZE
1313	/* Get rid of any avoidable limit on stack size. */
1314	{
1315	struct rlimit rlim;
1316
1317	/* Set the stack limit huge so that alloca does not fail. */
1318	if (getrlimit (RLIMIT_STACK, &rlim) == 0)
1319	{
1320	rlim.rlim_cur = rlim.rlim_max;
1321	setrlimit (RLIMIT_STACK, &rlim);
1322	}
1323	}
1324	#endif
1325
1326	#ifdef HAVE_ATEXIT
1327	atexit (close_stdout);
1328	#endif
1329
1330	/* Needed for OS/2 */
1331	initialize_main(&argc, &argv);
1332
1333	#ifdef KMK
1334	init_kbuild (argc, argv);
1335	#endif
1336
1337	default_goal_file = 0;
1338	reading_file = 0;
1339
1340	#if defined (__MSDOS__) && !defined (_POSIX_SOURCE)
1341	/* Request the most powerful version of `system', to
1342	make up for the dumb default shell. */
1343	__system_flags = (__system_redirect
1344	\| __system_use_shell
1345	\| __system_allow_multiple_cmds
1346	\| __system_allow_long_cmds
1347	\| __system_handle_null_commands
1348	\| __system_emulate_chdir);
1349
1350	#endif
1351
1352	/* Set up gettext/internationalization support. */
1353	setlocale (LC_ALL, "");
1354	#ifdef LOCALEDIR /* bird */
1355	bindtextdomain (PACKAGE, LOCALEDIR);
1356	textdomain (PACKAGE);
1357	#endif
1358
1359	#ifdef POSIX
1360	sigemptyset (&fatal_signal_set);
1361	#define ADD_SIG(sig) sigaddset (&fatal_signal_set, sig)
1362	#else
1363	#ifdef HAVE_SIGSETMASK
1364	fatal_signal_mask = 0;
1365	#define ADD_SIG(sig) fatal_signal_mask \|= sigmask (sig)
1366	#else
1367	#define ADD_SIG(sig)
1368	#endif
1369	#endif
1370
1371	#define FATAL_SIG(sig) \
1372	if (bsd_signal (sig, fatal_error_signal) == SIG_IGN) \
1373	bsd_signal (sig, SIG_IGN); \
1374	else \
1375	ADD_SIG (sig);
1376
1377	#ifdef SIGHUP
1378	FATAL_SIG (SIGHUP);
1379	#endif
1380	#ifdef SIGQUIT
1381	FATAL_SIG (SIGQUIT);
1382	#endif
1383	FATAL_SIG (SIGINT);
1384	FATAL_SIG (SIGTERM);
1385
1386	#ifdef __MSDOS__
1387	/* Windows 9X delivers FP exceptions in child programs to their
1388	parent! We don't want Make to die when a child divides by zero,
1389	so we work around that lossage by catching SIGFPE. */
1390	FATAL_SIG (SIGFPE);
1391	#endif
1392
1393	#ifdef SIGDANGER
1394	FATAL_SIG (SIGDANGER);
1395	#endif
1396	#ifdef SIGXCPU
1397	FATAL_SIG (SIGXCPU);
1398	#endif
1399	#ifdef SIGXFSZ
1400	FATAL_SIG (SIGXFSZ);
1401	#endif
1402
1403	#ifdef CONFIG_NEW_WIN32_CTRL_EVENT
1404	/* bird: dispatch signals in our own way to try avoid deadlocks. */
1405	g_tidMainThread = GetCurrentThreadId ();
1406	SetConsoleCtrlHandler (ctrl_event, TRUE);
1407	#endif /* CONFIG_NEW_WIN32_CTRL_EVENT */
1408
1409	#undef FATAL_SIG
1410
1411	/* Do not ignore the child-death signal. This must be done before
1412	any children could possibly be created; otherwise, the wait
1413	functions won't work on systems with the SVR4 ECHILD brain
1414	damage, if our invoker is ignoring this signal. */
1415
1416	#ifdef HAVE_WAIT_NOHANG
1417	# if defined SIGCHLD
1418	(void) bsd_signal (SIGCHLD, SIG_DFL);
1419	# endif
1420	# if defined SIGCLD && SIGCLD != SIGCHLD
1421	(void) bsd_signal (SIGCLD, SIG_DFL);
1422	# endif
1423	#endif
1424
1425	/* Make sure stdout is line-buffered. */
1426
1427	#ifdef HAVE_SETVBUF
1428	# ifdef SETVBUF_REVERSED
1429	setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ);
1430	# else /* setvbuf not reversed. */
1431	/* Some buggy systems lose if we pass 0 instead of allocating ourselves. */
1432	setvbuf (stdout, 0, _IOLBF, BUFSIZ);
1433	# endif /* setvbuf reversed. */
1434	#elif HAVE_SETLINEBUF
1435	setlinebuf (stdout);
1436	#endif /* setlinebuf missing. */
1437
1438	/* Figure out where this program lives. */
1439
1440	if (argv[0] == 0)
1441	argv[0] = "";
1442	if (argv[0][0] == '\0')
1443	#ifdef KMK
1444	program = "kmk";
1445	#else
1446	program = "make";
1447	#endif
1448	else
1449	{
1450	#ifdef VMS
1451	program = strrchr (argv[0], ']');
1452	#else
1453	program = strrchr (argv[0], '/');
1454	#endif
1455	#if defined(__MSDOS__) \|\| defined(__EMX__)
1456	if (program == 0)
1457	program = strrchr (argv[0], '\\');
1458	else
1459	{
1460	/* Some weird environments might pass us argv[0] with
1461	both kinds of slashes; we must find the rightmost. */
1462	char *p = strrchr (argv[0], '\\');
1463	if (p && p > program)
1464	program = p;
1465	}
1466	if (program == 0 && argv[0][1] == ':')
1467	program = argv[0] + 1;
1468	#endif
1469	#ifdef WINDOWS32
1470	if (program == 0)
1471	{
1472	/* Extract program from full path */
1473	int argv0_len;
1474	program = strrchr (argv[0], '\\');
1475	if (program)
1476	{
1477	argv0_len = strlen(program);
1478	if (argv0_len > 4 && streq (&program[argv0_len - 4], ".exe"))
1479	/* Remove .exe extension */
1480	program[argv0_len - 4] = '\0';
1481	}
1482	}
1483	#endif
1484	if (program == 0)
1485	program = argv[0];
1486	else
1487	++program;
1488	}
1489
1490	/* Set up to access user data (files). */
1491	user_access ();
1492
1493	#ifdef CONFIG_WITH_ALLOC_CACHES
1494	initialize_global_alloc_caches ();
1495	#endif
1496	initialize_global_hash_tables ();
1497
1498	/* Figure out where we are. */
1499
1500	#ifdef WINDOWS32
1501	if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1502	#else
1503	if (getcwd (current_directory, GET_PATH_MAX) == 0)
1504	#endif
1505	{
1506	#ifdef HAVE_GETCWD
1507	perror_with_name ("getcwd", "");
1508	#else
1509	error (NILF, "getwd: %s", current_directory);
1510	#endif
1511	current_directory[0] = '\0';
1512	directory_before_chdir = 0;
1513	}
1514	else
1515	directory_before_chdir = xstrdup (current_directory);
1516	#ifdef __MSDOS__
1517	/* Make sure we will return to the initial directory, come what may. */
1518	atexit (msdos_return_to_initial_directory);
1519	#endif
1520
1521	/* Initialize the special variables. */
1522	define_variable (".VARIABLES", 10, "", o_default, 0)->special = 1;
1523	/* define_variable (".TARGETS", 8, "", o_default, 0)->special = 1; */
1524
1525	/* Set up .FEATURES */
1526	define_variable (".FEATURES", 9,
1527	"target-specific order-only second-expansion else-if",
1528	o_default, 0);
1529	#ifndef NO_ARCHIVES
1530	do_variable_definition (NILF, ".FEATURES", "archives",
1531	o_default, f_append, 0);
1532	#endif
1533	#ifdef MAKE_JOBSERVER
1534	do_variable_definition (NILF, ".FEATURES", "jobserver",
1535	o_default, f_append, 0);
1536	#endif
1537	#ifdef MAKE_SYMLINKS
1538	do_variable_definition (NILF, ".FEATURES", "check-symlink",
1539	o_default, f_append, 0);
1540	#endif
1541	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1542	do_variable_definition (NILF, ".FEATURES", "explicit-multitarget",
1543	o_default, f_append, 0);
1544	#endif
1545	#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1546	do_variable_definition (NILF, ".FEATURES", "prepend-assignment",
1547	o_default, f_append, 0);
1548	#endif
1549
1550	#ifdef KMK
1551	/* Initialize the default number of jobs to the cpu/core/smt count. */
1552	default_job_slots = job_slots = get_online_cpu_count ();
1553	#endif /* KMK */
1554
1555	/* Read in variables from the environment. It is important that this be
1556	done before $(MAKE) is figured out so its definitions will not be
1557	from the environment. */
1558
1559	#ifndef _AMIGA
1560	{
1561	unsigned int i;
1562
1563	for (i = 0; envp[i] != 0; ++i)
1564	{
1565	int do_not_define = 0;
1566	char *ep = envp[i];
1567
1568	while (ep != '\0' && ep != '=')
1569	++ep;
1570	#ifdef WINDOWS32
1571	if (!unix_path && strneq(envp[i], "PATH=", 5))
1572	unix_path = ep+1;
1573	else if (!strnicmp(envp[i], "Path=", 5)) {
1574	do_not_define = 1; /* it gets defined after loop exits */
1575	if (!windows32_path)
1576	windows32_path = ep+1;
1577	}
1578	#endif
1579	/* The result of pointer arithmetic is cast to unsigned int for
1580	machines where ptrdiff_t is a different size that doesn't widen
1581	the same. */
1582	if (!do_not_define)
1583	{
1584	struct variable *v;
1585
1586	v = define_variable (envp[i], (unsigned int) (ep - envp[i]),
1587	ep + 1, o_env, 1);
1588	/* Force exportation of every variable culled from the
1589	environment. We used to rely on target_environment's
1590	v_default code to do this. But that does not work for the
1591	case where an environment variable is redefined in a makefile
1592	with `override'; it should then still be exported, because it
1593	was originally in the environment. */
1594	v->export = v_export;
1595
1596	/* Another wrinkle is that POSIX says the value of SHELL set in
1597	the makefile won't change the value of SHELL given to
1598	subprocesses. */
1599	if (streq (v->name, "SHELL"))
1600	{
1601	#ifndef __MSDOS__
1602	v->export = v_noexport;
1603	#endif
1604	shell_var.name = "SHELL";
1605	shell_var.value = xstrdup (ep + 1);
1606	}
1607
1608	/* If MAKE_RESTARTS is set, remember it but don't export it. */
1609	if (streq (v->name, "MAKE_RESTARTS"))
1610	{
1611	v->export = v_noexport;
1612	restarts = (unsigned int) atoi (ep + 1);
1613	}
1614	}
1615	}
1616	}
1617	#ifdef WINDOWS32
1618	/* If we didn't find a correctly spelled PATH we define PATH as
1619	* either the first mispelled value or an empty string
1620	*/
1621	if (!unix_path)
1622	define_variable("PATH", 4,
1623	windows32_path ? windows32_path : "",
1624	o_env, 1)->export = v_export;
1625	#endif
1626	#else /* For Amiga, read the ENV: device, ignoring all dirs */
1627	{
1628	BPTR env, file, old;
1629	char buffer[1024];
1630	int len;
1631	__aligned struct FileInfoBlock fib;
1632
1633	env = Lock ("ENV:", ACCESS_READ);
1634	if (env)
1635	{
1636	old = CurrentDir (DupLock(env));
1637	Examine (env, &fib);
1638
1639	while (ExNext (env, &fib))
1640	{
1641	if (fib.fib_DirEntryType < 0) /* File */
1642	{
1643	/* Define an empty variable. It will be filled in
1644	variable_lookup(). Makes startup quite a bit
1645	faster. */
1646	define_variable (fib.fib_FileName,
1647	strlen (fib.fib_FileName),
1648	"", o_env, 1)->export = v_export;
1649	}
1650	}
1651	UnLock (env);
1652	UnLock(CurrentDir(old));
1653	}
1654	}
1655	#endif
1656
1657	/* Decode the switches. */
1658
1659	#ifdef KMK
1660	decode_env_switches (STRING_SIZE_TUPLE ("KMK_FLAGS"));
1661	#else /* !KMK */
1662	decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
1663	#if 0
1664	/* People write things like:
1665	MFLAGS="CC=gcc -pipe" "CFLAGS=-g"
1666	and we set the -p, -i and -e switches. Doesn't seem quite right. */
1667	decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
1668	#endif
1669	#endif /* !KMK */
1670	decode_switches (argc, argv, 0);
1671	#ifdef WINDOWS32
1672	if (suspend_flag) {
1673	fprintf(stderr, "%s (pid = %ld)\n", argv[0], GetCurrentProcessId());
1674	fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]);
1675	Sleep(30 * 1000);
1676	fprintf(stderr, _("done sleep(30). Continuing.\n"));
1677	}
1678	#endif
1679
1680	decode_debug_flags ();
1681
1682	#ifdef KMK
1683	set_make_priority_and_affinity ();
1684	#endif
1685
1686	/* Set always_make_flag if -B was given and we've not restarted already. */
1687	always_make_flag = always_make_set && (restarts == 0);
1688
1689	/* Print version information. */
1690	if (print_version_flag \|\| print_data_base_flag \|\| db_level)
1691	{
1692	print_version ();
1693
1694	/* `make --version' is supposed to just print the version and exit. */
1695	if (print_version_flag)
1696	die (0);
1697	}
1698
1699	#ifndef VMS
1700	/* Set the "MAKE_COMMAND" variable to the name we were invoked with.
1701	(If it is a relative pathname with a slash, prepend our directory name
1702	so the result will run the same program regardless of the current dir.
1703	If it is a name with no slash, we can only hope that PATH did not
1704	find it in the current directory.) */
1705	#ifdef WINDOWS32
1706	/*
1707	* Convert from backslashes to forward slashes for
1708	* programs like sh which don't like them. Shouldn't
1709	* matter if the path is one way or the other for
1710	* CreateProcess().
1711	*/
1712	if (strpbrk(argv[0], "/:\\") \|\|
1713	strstr(argv[0], "..") \|\|
1714	strneq(argv[0], "//", 2))
1715	argv[0] = xstrdup(w32ify(argv[0],1));
1716	#else /* WINDOWS32 */
1717	#if defined (__MSDOS__) \|\| defined (__EMX__)
1718	if (strchr (argv[0], '\\'))
1719	{
1720	char *p;
1721
1722	argv[0] = xstrdup (argv[0]);
1723	for (p = argv[0]; *p; p++)
1724	if (*p == '\\')
1725	*p = '/';
1726	}
1727	/* If argv[0] is not in absolute form, prepend the current
1728	directory. This can happen when Make is invoked by another DJGPP
1729	program that uses a non-absolute name. */
1730	if (current_directory[0] != '\0'
1731	&& argv[0] != 0
1732	&& (argv[0][0] != '/' && (argv[0][0] == '\0' \|\| argv[0][1] != ':'))
1733	# ifdef __EMX__
1734	/* do not prepend cwd if argv[0] contains no '/', e.g. "make" */
1735	&& (strchr (argv[0], '/') != 0 \|\| strchr (argv[0], '\\') != 0)
1736	# endif
1737	)
1738	argv[0] = xstrdup (concat (current_directory, "/", argv[0]));
1739	#else /* !__MSDOS__ */
1740	if (current_directory[0] != '\0'
1741	&& argv[0] != 0 && argv[0][0] != '/' && strchr (argv[0], '/') != 0
1742	#ifdef HAVE_DOS_PATHS
1743	&& (argv[0][0] != '\\' && (!argv[0][0] \|\| argv[0][1] != ':'))
1744	&& strchr (argv[0], '\\') != 0
1745	#endif
1746	)
1747	argv[0] = xstrdup (concat (current_directory, "/", argv[0]));
1748	#endif /* !__MSDOS__ */
1749	#endif /* WINDOWS32 */
1750	#endif
1751
1752	/* The extra indirection through $(MAKE_COMMAND) is done
1753	for hysterical raisins. */
1754	(void) define_variable ("MAKE_COMMAND", 12, argv[0], o_default, 0);
1755	(void) define_variable ("MAKE", 4, "$(MAKE_COMMAND)", o_default, 1);
1756	#ifdef KMK
1757	(void) define_variable ("KMK", 3, argv[0], o_default, 1);
1758	#endif
1759
1760	if (command_variables != 0)
1761	{
1762	struct command_variable *cv;
1763	struct variable *v;
1764	unsigned int len = 0;
1765	char value, p;
1766
1767	/* Figure out how much space will be taken up by the command-line
1768	variable definitions. */
1769	for (cv = command_variables; cv != 0; cv = cv->next)
1770	{
1771	v = cv->variable;
1772	len += 2 * strlen (v->name);
1773	if (! v->recursive)
1774	++len;
1775	++len;
1776	len += 2 * strlen (v->value);
1777	++len;
1778	}
1779
1780	/* Now allocate a buffer big enough and fill it. */
1781	p = value = alloca (len);
1782	for (cv = command_variables; cv != 0; cv = cv->next)
1783	{
1784	v = cv->variable;
1785	p = quote_for_env (p, v->name);
1786	if (! v->recursive)
1787	*p++ = ':';
1788	*p++ = '=';
1789	p = quote_for_env (p, v->value);
1790	*p++ = ' ';
1791	}
1792	p[-1] = '\0'; /* Kill the final space and terminate. */
1793
1794	/* Define an unchangeable variable with a name that no POSIX.2
1795	makefile could validly use for its own variable. */
1796	(void) define_variable ("--command-variables--", 23,
1797	value, o_automatic, 0);
1798
1799	/* Define the variable; this will not override any user definition.
1800	Normally a reference to this variable is written into the value of
1801	MAKEFLAGS, allowing the user to override this value to affect the
1802	exported value of MAKEFLAGS. In POSIX-pedantic mode, we cannot
1803	allow the user's setting of MAKEOVERRIDES to affect MAKEFLAGS, so
1804	a reference to this hidden variable is written instead. */
1805	#ifdef KMK
1806	(void) define_variable ("KMK_OVERRIDES", 13,
1807	"${--command-variables--}", o_env, 1);
1808	#else
1809	(void) define_variable ("MAKEOVERRIDES", 13,
1810	"${--command-variables--}", o_env, 1);
1811	#endif
1812	}
1813
1814	/* If there were -C flags, move ourselves about. */
1815	if (directories != 0)
1816	{
1817	unsigned int i;
1818	for (i = 0; directories->list[i] != 0; ++i)
1819	{
1820	const char *dir = directories->list[i];
1821	#ifdef WINDOWS32
1822	/* WINDOWS32 chdir() doesn't work if the directory has a trailing '/'
1823	But allow -C/ just in case someone wants that. */
1824	{
1825	char p = (char )dir + strlen (dir) - 1;
1826	while (p > dir && (p[0] == '/' \|\| p[0] == '\\'))
1827	--p;
1828	p[1] = '\0';
1829	}
1830	#endif
1831	if (chdir (dir) < 0)
1832	pfatal_with_name (dir);
1833	}
1834	}
1835
1836	#ifdef KMK
1837	/* Check for [Mm]akefile.kup and change directory when found.
1838	Makefile.kmk overrides Makefile.kup but not plain Makefile.
1839	If no -C arguments were given, fake one to indicate chdir. */
1840	if (makefiles == 0)
1841	{
1842	struct stat st;
1843	if (( ( stat ("Makefile.kup", &st) == 0
1844	&& S_ISREG (st.st_mode) )
1845	\|\| ( stat ("makefile.kup", &st) == 0
1846	&& S_ISREG (st.st_mode) ) )
1847	&& stat ("Makefile.kmk", &st) < 0
1848	&& stat ("makefile.kmk", &st) < 0)
1849	{
1850	static char fake_path[3*16 + 32] = "..";
1851	char *cur = &fake_path[2];
1852	int up_levels = 1;
1853	while (up_levels < 16)
1854	{
1855	/* File with higher precedence.s */
1856	strcpy (cur, "/Makefile.kmk");
1857	if (stat (fake_path, &st) == 0)
1858	break;
1859	strcpy (cur, "/makefile.kmk");
1860	if (stat (fake_path, &st) == 0)
1861	break;
1862
1863	/* the .kup files */
1864	strcpy (cur, "/Makefile.kup");
1865	if ( stat (fake_path, &st) != 0
1866	\|\| !S_ISREG (st.st_mode))
1867	{
1868	strcpy (cur, "/makefile.kup");
1869	if ( stat (fake_path, &st) != 0
1870	\|\| !S_ISREG (st.st_mode))
1871	break;
1872	}
1873
1874	/* ok */
1875	strcpy (cur, "/..");
1876	cur += 3;
1877	up_levels++;
1878	}
1879
1880	if (up_levels >= 16)
1881	fatal (NILF, _("Makefile.kup recursion is too deep."));
1882
1883	/* attempt to change to the directory. */
1884	*cur = '\0';
1885	if (chdir (fake_path) < 0)
1886	pfatal_with_name (fake_path);
1887
1888	/* add the string to the directories. */
1889	if (!directories)
1890	{
1891	directories = xmalloc (sizeof(*directories));
1892	directories->list = xmalloc (5 * sizeof (char *));
1893	directories->max = 5;
1894	directories->idx = 0;
1895	}
1896	else if (directories->idx == directories->max - 1)
1897	{
1898	directories->max += 5;
1899	directories->list = xrealloc ((void *)directories->list,
1900	directories->max * sizeof (char *));
1901	}
1902	directories->list[directories->idx++] = fake_path;
1903	}
1904	}
1905	#endif /* KMK */
1906
1907	#ifdef WINDOWS32
1908	/*
1909	* THIS BLOCK OF CODE MUST COME AFTER chdir() CALL ABOVE IN ORDER
1910	* TO NOT CONFUSE THE DEPENDENCY CHECKING CODE IN implicit.c.
1911	*
1912	* The functions in dir.c can incorrectly cache information for "."
1913	* before we have changed directory and this can cause file
1914	* lookups to fail because the current directory (.) was pointing
1915	* at the wrong place when it was first evaluated.
1916	*/
1917	#ifdef KMK /* this is really a candidate for all platforms... */
1918	{
1919	extern char *default_shell;
1920	const char *bin = get_kbuild_bin_path();
1921	size_t len = strlen (bin);
1922	default_shell = xmalloc (len + sizeof("/kmk_ash.exe"));
1923	memcpy (default_shell, bin, len);
1924	strcpy (default_shell + len, "/kmk_ash.exe");
1925	no_default_sh_exe = 0;
1926	batch_mode_shell = 1;
1927	}
1928	#else /* !KMK */
1929	no_default_sh_exe = !find_and_set_default_shell(NULL);
1930	#endif /* !KMK */
1931	#endif /* WINDOWS32 */
1932	/* Figure out the level of recursion. */
1933	{
1934	struct variable *v = lookup_variable (STRING_SIZE_TUPLE (MAKELEVEL_NAME));
1935	if (v != 0 && v->value[0] != '\0' && v->value[0] != '-')
1936	makelevel = (unsigned int) atoi (v->value);
1937	else
1938	makelevel = 0;
1939	}
1940
1941	/* Except under -s, always do -w in sub-makes and under -C. */
1942	if (!silent_flag && (directories != 0 \|\| makelevel > 0))
1943	print_directory_flag = 1;
1944
1945	/* Let the user disable that with --no-print-directory. */
1946	if (inhibit_print_directory_flag)
1947	print_directory_flag = 0;
1948
1949	/* If -R was given, set -r too (doesn't make sense otherwise!) */
1950	if (no_builtin_variables_flag)
1951	no_builtin_rules_flag = 1;
1952
1953	/* Construct the list of include directories to search. */
1954
1955	construct_include_path (include_directories == 0
1956	? 0 : include_directories->list);
1957
1958	/* Figure out where we are now, after chdir'ing. */
1959	if (directories == 0)
1960	/* We didn't move, so we're still in the same place. */
1961	starting_directory = current_directory;
1962	else
1963	{
1964	#ifdef WINDOWS32
1965	if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1966	#else
1967	if (getcwd (current_directory, GET_PATH_MAX) == 0)
1968	#endif
1969	{
1970	#ifdef HAVE_GETCWD
1971	perror_with_name ("getcwd", "");
1972	#else
1973	error (NILF, "getwd: %s", current_directory);
1974	#endif
1975	starting_directory = 0;
1976	}
1977	else
1978	starting_directory = current_directory;
1979	}
1980
1981	(void) define_variable ("CURDIR", 6, current_directory, o_file, 0);
1982
1983	/* Read any stdin makefiles into temporary files. */
1984
1985	if (makefiles != 0)
1986	{
1987	unsigned int i;
1988	for (i = 0; i < makefiles->idx; ++i)
1989	if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0')
1990	{
1991	/* This makefile is standard input. Since we may re-exec
1992	and thus re-read the makefiles, we read standard input
1993	into a temporary file and read from that. */
1994	FILE *outfile;
1995	char template, tmpdir;
1996
1997	if (stdin_nm)
1998	fatal (NILF, _("Makefile from standard input specified twice."));
1999
2000	#ifdef VMS
2001	# define DEFAULT_TMPDIR "sys$scratch:"
2002	#else
2003	# ifdef P_tmpdir
2004	# define DEFAULT_TMPDIR P_tmpdir
2005	# else
2006	# define DEFAULT_TMPDIR "/tmp"
2007	# endif
2008	#endif
2009	#define DEFAULT_TMPFILE "GmXXXXXX"
2010
2011	if (((tmpdir = getenv ("TMPDIR")) == NULL \|\| *tmpdir == '\0')
2012	#if defined (__MSDOS__) \|\| defined (WINDOWS32) \|\| defined (__EMX__)
2013	/* These are also used commonly on these platforms. */
2014	&& ((tmpdir = getenv ("TEMP")) == NULL \|\| *tmpdir == '\0')
2015	&& ((tmpdir = getenv ("TMP")) == NULL \|\| *tmpdir == '\0')
2016	#endif
2017	)
2018	tmpdir = DEFAULT_TMPDIR;
2019
2020	template = alloca (strlen (tmpdir) + sizeof (DEFAULT_TMPFILE) + 1);
2021	strcpy (template, tmpdir);
2022
2023	#ifdef HAVE_DOS_PATHS
2024	if (strchr ("/\\", template[strlen (template) - 1]) == NULL)
2025	strcat (template, "/");
2026	#else
2027	# ifndef VMS
2028	if (template[strlen (template) - 1] != '/')
2029	strcat (template, "/");
2030	# endif /* !VMS */
2031	#endif /* !HAVE_DOS_PATHS */
2032
2033	strcat (template, DEFAULT_TMPFILE);
2034	outfile = open_tmpfile (&stdin_nm, template);
2035	if (outfile == 0)
2036	pfatal_with_name (_("fopen (temporary file)"));
2037	while (!feof (stdin) && ! ferror (stdin))
2038	{
2039	char buf[2048];
2040	unsigned int n = fread (buf, 1, sizeof (buf), stdin);
2041	if (n > 0 && fwrite (buf, 1, n, outfile) != n)
2042	pfatal_with_name (_("fwrite (temporary file)"));
2043	}
2044	fclose (outfile);
2045
2046	/* Replace the name that read_all_makefiles will
2047	see with the name of the temporary file. */
2048	makefiles->list[i] = strcache_add (stdin_nm);
2049
2050	/* Make sure the temporary file will not be remade. */
2051	{
2052	struct file *f = enter_file (strcache_add (stdin_nm));
2053	f->updated = 1;
2054	f->update_status = 0;
2055	f->command_state = cs_finished;
2056	/* Can't be intermediate, or it'll be removed too early for
2057	make re-exec. */
2058	f->intermediate = 0;
2059	f->dontcare = 0;
2060	}
2061	}
2062	}
2063
2064	#if !defined(__EMX__) \|\| defined(__KLIBC__) /* Don't use a SIGCHLD handler for good old EMX (bird) */
2065	#if defined(MAKE_JOBSERVER) \|\| !defined(HAVE_WAIT_NOHANG)
2066	/* Set up to handle children dying. This must be done before
2067	reading in the makefiles so that `shell' function calls will work.
2068
2069	If we don't have a hanging wait we have to fall back to old, broken
2070	functionality here and rely on the signal handler and counting
2071	children.
2072
2073	If we're using the jobs pipe we need a signal handler so that
2074	SIGCHLD is not ignored; we need it to interrupt the read(2) of the
2075	jobserver pipe in job.c if we're waiting for a token.
2076
2077	If none of these are true, we don't need a signal handler at all. */
2078	{
2079	RETSIGTYPE child_handler (int sig);
2080	# if defined SIGCHLD
2081	bsd_signal (SIGCHLD, child_handler);
2082	# endif
2083	# if defined SIGCLD && SIGCLD != SIGCHLD
2084	bsd_signal (SIGCLD, child_handler);
2085	# endif
2086	}
2087	#endif
2088	#endif
2089
2090	/* Let the user send us SIGUSR1 to toggle the -d flag during the run. */
2091	#ifdef SIGUSR1
2092	bsd_signal (SIGUSR1, debug_signal_handler);
2093	#endif
2094
2095	/* Define the initial list of suffixes for old-style rules. */
2096
2097	set_default_suffixes ();
2098
2099	/* Define the file rules for the built-in suffix rules. These will later
2100	be converted into pattern rules. We used to do this in
2101	install_default_implicit_rules, but since that happens after reading
2102	makefiles, it results in the built-in pattern rules taking precedence
2103	over makefile-specified suffix rules, which is wrong. */
2104
2105	install_default_suffix_rules ();
2106
2107	/* Define some internal and special variables. */
2108
2109	define_automatic_variables ();
2110
2111	/* Set up the MAKEFLAGS and MFLAGS variables
2112	so makefiles can look at them. */
2113
2114	define_makeflags (0, 0);
2115
2116	/* Define the default variables. */
2117	define_default_variables ();
2118
2119	default_file = enter_file (strcache_add (".DEFAULT"));
2120
2121	{
2122	struct variable *v = define_variable (".DEFAULT_GOAL", 13, "", o_file, 0);
2123	default_goal_name = &v->value;
2124	}
2125
2126	/* Read all the makefiles. */
2127
2128	read_makefiles
2129	= read_all_makefiles (makefiles == 0 ? 0 : makefiles->list);
2130
2131	#ifdef WINDOWS32
2132	/* look one last time after reading all Makefiles */
2133	if (no_default_sh_exe)
2134	no_default_sh_exe = !find_and_set_default_shell(NULL);
2135	#endif /* WINDOWS32 */
2136
2137	#if defined (__MSDOS__) \|\| defined (__EMX__)
2138	/* We need to know what kind of shell we will be using. */
2139	{
2140	extern int _is_unixy_shell (const char *_path);
2141	struct variable *shv = lookup_variable (STRING_SIZE_TUPLE ("SHELL"));
2142	extern int unixy_shell;
2143	extern char *default_shell;
2144
2145	if (shv && *shv->value)
2146	{
2147	char *shell_path = recursively_expand(shv);
2148
2149	if (shell_path && _is_unixy_shell (shell_path))
2150	unixy_shell = 1;
2151	else
2152	unixy_shell = 0;
2153	if (shell_path)
2154	default_shell = shell_path;
2155	}
2156	}
2157	#endif /* __MSDOS__ \|\| __EMX__ */
2158
2159	/* Decode switches again, in case the variables were set by the makefile. */
2160	#ifdef KMK
2161	decode_env_switches (STRING_SIZE_TUPLE ("KMK_FLAGS"));
2162	#else /* !KMK */
2163	decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
2164	#if 0
2165	decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
2166	#endif
2167	#endif /* !KMK */
2168
2169	#if defined (__MSDOS__) \|\| defined (__EMX__)
2170	if (job_slots != 1
2171	# ifdef __EMX__
2172	&& _osmode != OS2_MODE /* turn off -j if we are in DOS mode */
2173	# endif
2174	)
2175	{
2176	error (NILF,
2177	_("Parallel jobs (-j) are not supported on this platform."));
2178	error (NILF, _("Resetting to single job (-j1) mode."));
2179	job_slots = 1;
2180	}
2181	#endif
2182
2183	#ifdef MAKE_JOBSERVER
2184	/* If the jobserver-fds option is seen, make sure that -j is reasonable. */
2185
2186	if (jobserver_fds)
2187	{
2188	const char *cp;
2189	unsigned int ui;
2190
2191	for (ui=1; ui < jobserver_fds->idx; ++ui)
2192	if (!streq (jobserver_fds->list[0], jobserver_fds->list[ui]))
2193	fatal (NILF, _("internal error: multiple --jobserver-fds options"));
2194
2195	/* Now parse the fds string and make sure it has the proper format. */
2196
2197	cp = jobserver_fds->list[0];
2198
2199	if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2)
2200	fatal (NILF,
2201	_("internal error: invalid --jobserver-fds string `%s'"), cp);
2202
2203	DB (DB_JOBS,
2204	(_("Jobserver client (fds %d,%d)\n"), job_fds[0], job_fds[1]));
2205
2206	/* The combination of a pipe + !job_slots means we're using the
2207	jobserver. If !job_slots and we don't have a pipe, we can start
2208	infinite jobs. If we see both a pipe and job_slots >0 that means the
2209	user set -j explicitly. This is broken; in this case obey the user
2210	(ignore the jobserver pipe for this make) but print a message. */
2211
2212	if (job_slots > 0)
2213	error (NILF,
2214	_("warning: -jN forced in submake: disabling jobserver mode."));
2215
2216	/* Create a duplicate pipe, that will be closed in the SIGCHLD
2217	handler. If this fails with EBADF, the parent has closed the pipe
2218	on us because it didn't think we were a submake. If so, print a
2219	warning then default to -j1. */
2220
2221	else if ((job_rfd = dup (job_fds[0])) < 0)
2222	{
2223	if (errno != EBADF)
2224	pfatal_with_name (_("dup jobserver"));
2225
2226	error (NILF,
2227	_("warning: jobserver unavailable: using -j1. Add `+' to parent make rule."));
2228	job_slots = 1;
2229	}
2230
2231	if (job_slots > 0)
2232	{
2233	close (job_fds[0]);
2234	close (job_fds[1]);
2235	job_fds[0] = job_fds[1] = -1;
2236	free (jobserver_fds->list);
2237	free (jobserver_fds);
2238	jobserver_fds = 0;
2239	}
2240	}
2241
2242	/* If we have >1 slot but no jobserver-fds, then we're a top-level make.
2243	Set up the pipe and install the fds option for our children. */
2244
2245	if (job_slots > 1)
2246	{
2247	char *cp;
2248	char c = '+';
2249
2250	if (pipe (job_fds) < 0 \|\| (job_rfd = dup (job_fds[0])) < 0)
2251	pfatal_with_name (_("creating jobs pipe"));
2252
2253	/* Every make assumes that it always has one job it can run. For the
2254	submakes it's the token they were given by their parent. For the
2255	top make, we just subtract one from the number the user wants. We
2256	want job_slots to be 0 to indicate we're using the jobserver. */
2257
2258	master_job_slots = job_slots;
2259
2260	while (--job_slots)
2261	{
2262	int r;
2263
2264	EINTRLOOP (r, write (job_fds[1], &c, 1));
2265	if (r != 1)
2266	pfatal_with_name (_("init jobserver pipe"));
2267	}
2268
2269	/* Fill in the jobserver_fds struct for our children. */
2270
2271	cp = xmalloc ((sizeof ("1024")*2)+1);
2272	sprintf (cp, "%d,%d", job_fds[0], job_fds[1]);
2273
2274	jobserver_fds = (struct stringlist *)
2275	xmalloc (sizeof (struct stringlist));
2276	jobserver_fds->list = xmalloc (sizeof (char *));
2277	jobserver_fds->list[0] = cp;
2278	jobserver_fds->idx = 1;
2279	jobserver_fds->max = 1;
2280	}
2281	#endif
2282
2283	#ifndef MAKE_SYMLINKS
2284	if (check_symlink_flag)
2285	{
2286	error (NILF, _("Symbolic links not supported: disabling -L."));
2287	check_symlink_flag = 0;
2288	}
2289	#endif
2290
2291	/* Set up MAKEFLAGS and MFLAGS again, so they will be right. */
2292
2293	define_makeflags (1, 0);
2294
2295	/* Make each `struct dep' point at the `struct file' for the file
2296	depended on. Also do magic for special targets. */
2297
2298	snap_deps ();
2299
2300	/* Convert old-style suffix rules to pattern rules. It is important to
2301	do this before installing the built-in pattern rules below, so that
2302	makefile-specified suffix rules take precedence over built-in pattern
2303	rules. */
2304
2305	convert_to_pattern ();
2306
2307	/* Install the default implicit pattern rules.
2308	This used to be done before reading the makefiles.
2309	But in that case, built-in pattern rules were in the chain
2310	before user-defined ones, so they matched first. */
2311
2312	install_default_implicit_rules ();
2313
2314	/* Compute implicit rule limits. */
2315
2316	count_implicit_rule_limits ();
2317
2318	/* Construct the listings of directories in VPATH lists. */
2319
2320	build_vpath_lists ();
2321
2322	/* Mark files given with -o flags as very old and as having been updated
2323	already, and files given with -W flags as brand new (time-stamp as far
2324	as possible into the future). If restarts is set we'll do -W later. */
2325
2326	if (old_files != 0)
2327	{
2328	const char **p;
2329	for (p = old_files->list; *p != 0; ++p)
2330	{
2331	struct file f = enter_file (p);
2332	f->last_mtime = f->mtime_before_update = OLD_MTIME;
2333	f->updated = 1;
2334	f->update_status = 0;
2335	f->command_state = cs_finished;
2336	}
2337	}
2338
2339	if (!restarts && new_files != 0)
2340	{
2341	const char **p;
2342	for (p = new_files->list; *p != 0; ++p)
2343	{
2344	struct file f = enter_file (p);
2345	f->last_mtime = f->mtime_before_update = NEW_MTIME;
2346	}
2347	}
2348
2349	/* Initialize the remote job module. */
2350	remote_setup ();
2351
2352	if (read_makefiles != 0)
2353	{
2354	/* Update any makefiles if necessary. */
2355
2356	FILE_TIMESTAMP *makefile_mtimes = 0;
2357	unsigned int mm_idx = 0;
2358	char **nargv = argv;
2359	int nargc = argc;
2360	int orig_db_level = db_level;
2361	int status;
2362
2363	if (! ISDB (DB_MAKEFILES))
2364	db_level = DB_NONE;
2365
2366	DB (DB_BASIC, (_("Updating makefiles....\n")));
2367
2368	/* Remove any makefiles we don't want to try to update.
2369	Also record the current modtimes so we can compare them later. */
2370	{
2371	register struct dep d, last;
2372	last = 0;
2373	d = read_makefiles;
2374	while (d != 0)
2375	{
2376	struct file *f = d->file;
2377	if (f->double_colon)
2378	for (f = f->double_colon; f != NULL; f = f->prev)
2379	{
2380	if (f->deps == 0 && f->cmds != 0)
2381	{
2382	/* This makefile is a :: target with commands, but
2383	no dependencies. So, it will always be remade.
2384	This might well cause an infinite loop, so don't
2385	try to remake it. (This will only happen if
2386	your makefiles are written exceptionally
2387	stupidly; but if you work for Athena, that's how
2388	you write your makefiles.) */
2389
2390	DB (DB_VERBOSE,
2391	(_("Makefile `%s' might loop; not remaking it.\n"),
2392	f->name));
2393
2394	if (last == 0)
2395	read_makefiles = d->next;
2396	else
2397	last->next = d->next;
2398
2399	/* Free the storage. */
2400	free_dep (d);
2401
2402	d = last == 0 ? read_makefiles : last->next;
2403
2404	break;
2405	}
2406	}
2407	if (f == NULL \|\| !f->double_colon)
2408	{
2409	makefile_mtimes = xrealloc (makefile_mtimes,
2410	(mm_idx+1)
2411	* sizeof (FILE_TIMESTAMP));
2412	makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file);
2413	last = d;
2414	d = d->next;
2415	}
2416	}
2417	}
2418
2419	/* Set up `MAKEFLAGS' specially while remaking makefiles. */
2420	define_makeflags (1, 1);
2421
2422	rebuilding_makefiles = 1;
2423	status = update_goal_chain (read_makefiles);
2424	rebuilding_makefiles = 0;
2425
2426	switch (status)
2427	{
2428	case 1:
2429	/* The only way this can happen is if the user specified -q and asked
2430	* for one of the makefiles to be remade as a target on the command
2431	* line. Since we're not actually updating anything with -q we can
2432	* treat this as "did nothing".
2433	*/
2434
2435	case -1:
2436	/* Did nothing. */
2437	break;
2438
2439	case 2:
2440	/* Failed to update. Figure out if we care. */
2441	{
2442	/* Nonzero if any makefile was successfully remade. */
2443	int any_remade = 0;
2444	/* Nonzero if any makefile we care about failed
2445	in updating or could not be found at all. */
2446	int any_failed = 0;
2447	unsigned int i;
2448	struct dep *d;
2449
2450	for (i = 0, d = read_makefiles; d != 0; ++i, d = d->next)
2451	{
2452	/* Reset the considered flag; we may need to look at the file
2453	again to print an error. */
2454	d->file->considered = 0;
2455
2456	if (d->file->updated)
2457	{
2458	/* This makefile was updated. */
2459	if (d->file->update_status == 0)
2460	{
2461	/* It was successfully updated. */
2462	any_remade \|= (file_mtime_no_search (d->file)
2463	!= makefile_mtimes[i]);
2464	}
2465	else if (! (d->changed & RM_DONTCARE))
2466	{
2467	FILE_TIMESTAMP mtime;
2468	/* The update failed and this makefile was not
2469	from the MAKEFILES variable, so we care. */
2470	error (NILF, _("Failed to remake makefile `%s'."),
2471	d->file->name);
2472	mtime = file_mtime_no_search (d->file);
2473	any_remade \|= (mtime != NONEXISTENT_MTIME
2474	&& mtime != makefile_mtimes[i]);
2475	makefile_status = MAKE_FAILURE;
2476	}
2477	}
2478	else
2479	/* This makefile was not found at all. */
2480	if (! (d->changed & RM_DONTCARE))
2481	{
2482	/* This is a makefile we care about. See how much. */
2483	if (d->changed & RM_INCLUDED)
2484	/* An included makefile. We don't need
2485	to die, but we do want to complain. */
2486	error (NILF,
2487	_("Included makefile `%s' was not found."),
2488	dep_name (d));
2489	else
2490	{
2491	/* A normal makefile. We must die later. */
2492	error (NILF, _("Makefile `%s' was not found"),
2493	dep_name (d));
2494	any_failed = 1;
2495	}
2496	}
2497	}
2498	/* Reset this to empty so we get the right error message below. */
2499	read_makefiles = 0;
2500
2501	if (any_remade)
2502	goto re_exec;
2503	if (any_failed)
2504	die (2);
2505	break;
2506	}
2507
2508	case 0:
2509	re_exec:
2510	/* Updated successfully. Re-exec ourselves. */
2511
2512	remove_intermediates (0);
2513
2514	if (print_data_base_flag)
2515	print_data_base ();
2516
2517	log_working_directory (0);
2518
2519	clean_jobserver (0);
2520
2521	if (makefiles != 0)
2522	{
2523	/* These names might have changed. */
2524	int i, j = 0;
2525	for (i = 1; i < argc; ++i)
2526	if (strneq (argv[i], "-f", 2)) /* XXX */
2527	{
2528	char *p = &argv[i][2];
2529	if (*p == '\0')
2530	/* This cast is OK since we never modify argv. */
2531	argv[++i] = (char *) makefiles->list[j];
2532	else
2533	argv[i] = xstrdup (concat ("-f", makefiles->list[j], ""));
2534	++j;
2535	}
2536	}
2537
2538	/* Add -o option for the stdin temporary file, if necessary. */
2539	if (stdin_nm)
2540	{
2541	nargv = xmalloc ((nargc + 2) * sizeof (char *));
2542	memcpy (nargv, argv, argc * sizeof (char *));
2543	nargv[nargc++] = xstrdup (concat ("-o", stdin_nm, ""));
2544	nargv[nargc] = 0;
2545	}
2546
2547	if (directories != 0 && directories->idx > 0)
2548	{
2549	int bad = 1;
2550	if (directory_before_chdir != 0)
2551	{
2552	if (chdir (directory_before_chdir) < 0)
2553	perror_with_name ("chdir", "");
2554	else
2555	bad = 0;
2556	}
2557	if (bad)
2558	fatal (NILF, _("Couldn't change back to original directory."));
2559	}
2560
2561	++restarts;
2562
2563	if (ISDB (DB_BASIC))
2564	{
2565	char **p;
2566	printf (_("Re-executing[%u]:"), restarts);
2567	for (p = nargv; *p != 0; ++p)
2568	printf (" %s", *p);
2569	putchar ('\n');
2570	}
2571
2572	#ifndef _AMIGA
2573	{
2574	char **p;
2575	for (p = environ; *p != 0; ++p)
2576	{
2577	if (strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH)
2578	&& (*p)[MAKELEVEL_LENGTH] == '=')
2579	{
2580	*p = alloca (40);
2581	sprintf (*p, "%s=%u", MAKELEVEL_NAME, makelevel);
2582	}
2583	if (strneq (*p, "MAKE_RESTARTS=", 14))
2584	{
2585	*p = alloca (40);
2586	sprintf (*p, "MAKE_RESTARTS=%u", restarts);
2587	restarts = 0;
2588	}
2589	}
2590	}
2591	#else /* AMIGA */
2592	{
2593	char buffer[256];
2594
2595	sprintf (buffer, "%u", makelevel);
2596	SetVar (MAKELEVEL_NAME, buffer, -1, GVF_GLOBAL_ONLY);
2597
2598	sprintf (buffer, "%u", restarts);
2599	SetVar ("MAKE_RESTARTS", buffer, -1, GVF_GLOBAL_ONLY);
2600	restarts = 0;
2601	}
2602	#endif
2603
2604	/* If we didn't set the restarts variable yet, add it. */
2605	if (restarts)
2606	{
2607	char *b = alloca (40);
2608	sprintf (b, "MAKE_RESTARTS=%u", restarts);
2609	putenv (b);
2610	}
2611
2612	fflush (stdout);
2613	fflush (stderr);
2614
2615	/* Close the dup'd jobserver pipe if we opened one. */
2616	if (job_rfd >= 0)
2617	close (job_rfd);
2618
2619	#ifdef _AMIGA
2620	exec_command (nargv);
2621	exit (0);
2622	#elif defined (__EMX__)
2623	{
2624	/* It is not possible to use execve() here because this
2625	would cause the parent process to be terminated with
2626	exit code 0 before the child process has been terminated.
2627	Therefore it may be the best solution simply to spawn the
2628	child process including all file handles and to wait for its
2629	termination. */
2630	int pid;
2631	int status;
2632	pid = child_execute_job (0, 1, nargv, environ);
2633
2634	/* is this loop really necessary? */
2635	do {
2636	pid = wait (&status);
2637	} while (pid <= 0);
2638	/* use the exit code of the child process */
2639	exit (WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
2640	}
2641	#else
2642	exec_command (nargv, environ);
2643	#endif
2644	/* NOTREACHED */
2645
2646	default:
2647	#define BOGUS_UPDATE_STATUS 0
2648	assert (BOGUS_UPDATE_STATUS);
2649	break;
2650	}
2651
2652	db_level = orig_db_level;
2653
2654	/* Free the makefile mtimes (if we allocated any). */
2655	if (makefile_mtimes)
2656	free (makefile_mtimes);
2657	}
2658
2659	/* Set up `MAKEFLAGS' again for the normal targets. */
2660	define_makeflags (1, 0);
2661
2662	/* Set always_make_flag if -B was given. */
2663	always_make_flag = always_make_set;
2664
2665	/* If restarts is set we haven't set up -W files yet, so do that now. */
2666	if (restarts && new_files != 0)
2667	{
2668	const char **p;
2669	for (p = new_files->list; *p != 0; ++p)
2670	{
2671	struct file f = enter_file (p);
2672	f->last_mtime = f->mtime_before_update = NEW_MTIME;
2673	}
2674	}
2675
2676	/* If there is a temp file from reading a makefile from stdin, get rid of
2677	it now. */
2678	if (stdin_nm && unlink (stdin_nm) < 0 && errno != ENOENT)
2679	perror_with_name (_("unlink (temporary file): "), stdin_nm);
2680
2681	{
2682	int status;
2683
2684	/* If there were no command-line goals, use the default. */
2685	if (goals == 0)
2686	{
2687	if (**default_goal_name != '\0')
2688	{
2689	if (default_goal_file == 0 \|\|
2690	strcmp (*default_goal_name, default_goal_file->name) != 0)
2691	{
2692	default_goal_file = lookup_file (*default_goal_name);
2693
2694	/* In case user set .DEFAULT_GOAL to a non-existent target
2695	name let's just enter this name into the table and let
2696	the standard logic sort it out. */
2697	if (default_goal_file == 0)
2698	{
2699	struct nameseq *ns;
2700	char p = default_goal_name;
2701
2702	#ifndef CONFIG_WITH_ALLOC_CACHES
2703	ns = multi_glob (
2704	parse_file_seq (&p, '\0', sizeof (struct nameseq), 1),
2705	sizeof (struct nameseq));
2706	#else
2707	ns = multi_glob (
2708	parse_file_seq (&p, '\0', &nameseq_cache, 1),
2709	&nameseq_cache);
2710	#endif
2711
2712	/* .DEFAULT_GOAL should contain one target. */
2713	if (ns->next != 0)
2714	fatal (NILF, _(".DEFAULT_GOAL contains more than one target"));
2715
2716	#ifndef CONFIG_WITH_VALUE_LENGTH
2717	default_goal_file = enter_file (strcache_add (ns->name));
2718	#else
2719	default_goal_file = enter_file (ns->name);
2720	#endif
2721
2722	ns->name = 0; /* It was reused by enter_file(). */
2723	free_ns_chain (ns);
2724	}
2725	}
2726
2727	goals = alloc_dep ();
2728	goals->file = default_goal_file;
2729	}
2730	}
2731	else
2732	lastgoal->next = 0;
2733
2734
2735	if (!goals)
2736	{
2737	if (read_makefiles == 0)
2738	fatal (NILF, _("No targets specified and no makefile found"));
2739
2740	fatal (NILF, _("No targets"));
2741	}
2742
2743	/* Update the goals. */
2744
2745	DB (DB_BASIC, (_("Updating goal targets....\n")));
2746
2747	switch (update_goal_chain (goals))
2748	{
2749	case -1:
2750	/* Nothing happened. */
2751	case 0:
2752	/* Updated successfully. */
2753	status = makefile_status;
2754	break;
2755	case 1:
2756	/* We are under -q and would run some commands. */
2757	status = MAKE_TROUBLE;
2758	break;
2759	case 2:
2760	/* Updating failed. POSIX.2 specifies exit status >1 for this;
2761	but in VMS, there is only success and failure. */
2762	status = MAKE_FAILURE;
2763	break;
2764	default:
2765	abort ();
2766	}
2767
2768	/* If we detected some clock skew, generate one last warning */
2769	if (clock_skew_detected)
2770	error (NILF,
2771	_("warning: Clock skew detected. Your build may be incomplete."));
2772
2773	/* Exit. */
2774	die (status);
2775	}
2776
2777	/* NOTREACHED */
2778	return 0;
2779	}
2780
2781
2782	/* Parsing of arguments, decoding of switches. */
2783
2784	static char options[1 + sizeof (switches) / sizeof (switches[0]) * 3];
2785	static struct option long_options[(sizeof (switches) / sizeof (switches[0])) +
2786	(sizeof (long_option_aliases) /
2787	sizeof (long_option_aliases[0]))];
2788
2789	/* Fill in the string and vector for getopt. */
2790	static void
2791	init_switches (void)
2792	{
2793	char *p;
2794	unsigned int c;
2795	unsigned int i;
2796
2797	if (options[0] != '\0')
2798	/* Already done. */
2799	return;
2800
2801	p = options;
2802
2803	/* Return switch and non-switch args in order, regardless of
2804	POSIXLY_CORRECT. Non-switch args are returned as option 1. */
2805	*p++ = '-';
2806
2807	for (i = 0; switches[i].c != '\0'; ++i)
2808	{
2809	long_options[i].name = (switches[i].long_name == 0 ? "" :
2810	switches[i].long_name);
2811	long_options[i].flag = 0;
2812	long_options[i].val = switches[i].c;
2813	if (short_option (switches[i].c))
2814	*p++ = switches[i].c;
2815	switch (switches[i].type)
2816	{
2817	case flag:
2818	case flag_off:
2819	case ignore:
2820	long_options[i].has_arg = no_argument;
2821	break;
2822
2823	case string:
2824	case filename:
2825	case positive_int:
2826	case floating:
2827	if (short_option (switches[i].c))
2828	*p++ = ':';
2829	if (switches[i].noarg_value != 0)
2830	{
2831	if (short_option (switches[i].c))
2832	*p++ = ':';
2833	long_options[i].has_arg = optional_argument;
2834	}
2835	else
2836	long_options[i].has_arg = required_argument;
2837	break;
2838	}
2839	}
2840	*p = '\0';
2841	for (c = 0; c < (sizeof (long_option_aliases) /
2842	sizeof (long_option_aliases[0]));
2843	++c)
2844	long_options[i++] = long_option_aliases[c];
2845	long_options[i].name = 0;
2846	}
2847
2848	static void
2849	handle_non_switch_argument (char *arg, int env)
2850	{
2851	/* Non-option argument. It might be a variable definition. */
2852	struct variable *v;
2853	if (arg[0] == '-' && arg[1] == '\0')
2854	/* Ignore plain `-' for compatibility. */
2855	return;
2856	#ifndef CONFIG_WITH_VALUE_LENGTH
2857	v = try_variable_definition (0, arg, o_command, 0);
2858	#else
2859	v = try_variable_definition (0, arg, NULL, o_command, 0);
2860	#endif
2861	if (v != 0)
2862	{
2863	/* It is indeed a variable definition. If we don't already have this
2864	one, record a pointer to the variable for later use in
2865	define_makeflags. */
2866	struct command_variable *cv;
2867
2868	for (cv = command_variables; cv != 0; cv = cv->next)
2869	if (cv->variable == v)
2870	break;
2871
2872	if (! cv) {
2873	cv = xmalloc (sizeof (*cv));
2874	cv->variable = v;
2875	cv->next = command_variables;
2876	command_variables = cv;
2877	}
2878	}
2879	else if (! env)
2880	{
2881	/* Not an option or variable definition; it must be a goal
2882	target! Enter it as a file and add it to the dep chain of
2883	goals. */
2884	struct file *f = enter_file (strcache_add (expand_command_line_file (arg)));
2885	f->cmd_target = 1;
2886
2887	if (goals == 0)
2888	{
2889	goals = alloc_dep ();
2890	lastgoal = goals;
2891	}
2892	else
2893	{
2894	lastgoal->next = alloc_dep ();
2895	lastgoal = lastgoal->next;
2896	}
2897
2898	lastgoal->file = f;
2899
2900	{
2901	/* Add this target name to the MAKECMDGOALS variable. */
2902	struct variable *gv;
2903	const char *value;
2904
2905	gv = lookup_variable (STRING_SIZE_TUPLE ("MAKECMDGOALS"));
2906	if (gv == 0)
2907	value = f->name;
2908	else
2909	{
2910	/* Paste the old and new values together */
2911	unsigned int oldlen, newlen;
2912	char *vp;
2913
2914	oldlen = strlen (gv->value);
2915	newlen = strlen (f->name);
2916	vp = alloca (oldlen + 1 + newlen + 1);
2917	memcpy (vp, gv->value, oldlen);
2918	vp[oldlen] = ' ';
2919	memcpy (&vp[oldlen + 1], f->name, newlen + 1);
2920	value = vp;
2921	}
2922	define_variable ("MAKECMDGOALS", 12, value, o_default, 0);
2923	}
2924	}
2925	}
2926
2927	/* Print a nice usage method. */
2928
2929	static void
2930	print_usage (int bad)
2931	{
2932	const char const cpp;
2933	FILE *usageto;
2934
2935	if (print_version_flag)
2936	print_version ();
2937
2938	usageto = bad ? stderr : stdout;
2939
2940	fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program);
2941
2942	for (cpp = usage; *cpp; ++cpp)
2943	fputs (_(*cpp), usageto);
2944
2945	#ifdef KMK
2946	if (!remote_description \|\| *remote_description == '\0')
2947	printf (_("\nThis program is built for %s/%s/%s [" __DATE__ " " __TIME__ "]\n"),
2948	KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU);
2949	else
2950	printf (_("\nThis program is built for %s/%s/%s (%s) [" __DATE__ " " __TIME__ "]\n"),
2951	KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU, remote_description);
2952	#else /* !KMK */
2953	if (!remote_description \|\| *remote_description == '\0')
2954	fprintf (usageto, _("\nThis program built for %s\n"), make_host);
2955	else
2956	fprintf (usageto, _("\nThis program built for %s (%s)\n"),
2957	make_host, remote_description);
2958	#endif /* !KMK */
2959
2960	fprintf (usageto, _("Report bugs to <bug-make@gnu.org>\n"));
2961	}
2962
2963	/* Decode switches from ARGC and ARGV.
2964	They came from the environment if ENV is nonzero. */
2965
2966	static void
2967	decode_switches (int argc, char **argv, int env)
2968	{
2969	int bad = 0;
2970	register const struct command_switch *cs;
2971	register struct stringlist *sl;
2972	register int c;
2973
2974	/* getopt does most of the parsing for us.
2975	First, get its vectors set up. */
2976
2977	init_switches ();
2978
2979	/* Let getopt produce error messages for the command line,
2980	but not for options from the environment. */
2981	opterr = !env;
2982	/* Reset getopt's state. */
2983	optind = 0;
2984
2985	while (optind < argc)
2986	{
2987	/* Parse the next argument. */
2988	c = getopt_long (argc, argv, options, long_options, (int *) 0);
2989	if (c == EOF)
2990	/* End of arguments, or "--" marker seen. */
2991	break;
2992	else if (c == 1)
2993	/* An argument not starting with a dash. */
2994	handle_non_switch_argument (optarg, env);
2995	else if (c == '?')
2996	/* Bad option. We will print a usage message and die later.
2997	But continue to parse the other options so the user can
2998	see all he did wrong. */
2999	bad = 1;
3000	else
3001	for (cs = switches; cs->c != '\0'; ++cs)
3002	if (cs->c == c)
3003	{
3004	/* Whether or not we will actually do anything with
3005	this switch. We test this individually inside the
3006	switch below rather than just once outside it, so that
3007	options which are to be ignored still consume args. */
3008	int doit = !env \|\| cs->env;
3009
3010	switch (cs->type)
3011	{
3012	default:
3013	abort ();
3014
3015	case ignore:
3016	break;
3017
3018	case flag:
3019	case flag_off:
3020	if (doit)
3021	(int ) cs->value_ptr = cs->type == flag;
3022	break;
3023
3024	case string:
3025	case filename:
3026	if (!doit)
3027	break;
3028
3029	if (optarg == 0)
3030	optarg = xstrdup (cs->noarg_value);
3031	else if (*optarg == '\0')
3032	{
3033	error (NILF, _("the `-%c' option requires a non-empty string argument"),
3034	cs->c);
3035	bad = 1;
3036	}
3037
3038	sl = (struct stringlist *) cs->value_ptr;
3039	if (sl == 0)
3040	{
3041	sl = (struct stringlist *)
3042	xmalloc (sizeof (struct stringlist));
3043	sl->max = 5;
3044	sl->idx = 0;
3045	sl->list = xmalloc (5 * sizeof (char *));
3046	(struct stringlist *) cs->value_ptr = sl;
3047	}
3048	else if (sl->idx == sl->max - 1)
3049	{
3050	sl->max += 5;
3051	sl->list = xrealloc ((void )sl->list, / bird */
3052	sl->max * sizeof (char *));
3053	}
3054	if (cs->type == filename)
3055	sl->list[sl->idx++] = expand_command_line_file (optarg);
3056	else
3057	sl->list[sl->idx++] = optarg;
3058	sl->list[sl->idx] = 0;
3059	break;
3060
3061	case positive_int:
3062	/* See if we have an option argument; if we do require that
3063	it's all digits, not something like "10foo". */
3064	if (optarg == 0 && argc > optind)
3065	{
3066	const char *cp;
3067	for (cp=argv[optind]; ISDIGIT (cp[0]); ++cp)
3068	;
3069	if (cp[0] == '\0')
3070	optarg = argv[optind++];
3071	}
3072
3073	if (!doit)
3074	break;
3075
3076	if (optarg != 0)
3077	{
3078	int i = atoi (optarg);
3079	const char *cp;
3080
3081	/* Yes, I realize we're repeating this in some cases. */
3082	for (cp = optarg; ISDIGIT (cp[0]); ++cp)
3083	;
3084
3085	if (i < 1 \|\| cp[0] != '\0')
3086	{
3087	error (NILF, _("the `-%c' option requires a positive integral argument"),
3088	cs->c);
3089	bad = 1;
3090	}
3091	else
3092	(unsigned int ) cs->value_ptr = i;
3093	}
3094	else
3095	(unsigned int ) cs->value_ptr
3096	= (unsigned int ) cs->noarg_value;
3097	break;
3098
3099	#ifndef NO_FLOAT
3100	case floating:
3101	if (optarg == 0 && optind < argc
3102	&& (ISDIGIT (argv[optind][0]) \|\| argv[optind][0] == '.'))
3103	optarg = argv[optind++];
3104
3105	if (doit)
3106	(double ) cs->value_ptr
3107	= (optarg != 0 ? atof (optarg)
3108	: (double ) cs->noarg_value);
3109
3110	break;
3111	#endif
3112	}
3113
3114	/* We've found the switch. Stop looking. */
3115	break;
3116	}
3117	}
3118
3119	/* There are no more options according to getting getopt, but there may
3120	be some arguments left. Since we have asked for non-option arguments
3121	to be returned in order, this only happens when there is a "--"
3122	argument to prevent later arguments from being options. */
3123	while (optind < argc)
3124	handle_non_switch_argument (argv[optind++], env);
3125
3126
3127	if (!env && (bad \|\| print_usage_flag))
3128	{
3129	print_usage (bad);
3130	die (bad ? 2 : 0);
3131	}
3132	}
3133
3134	/* Decode switches from environment variable ENVAR (which is LEN chars long).
3135	We do this by chopping the value into a vector of words, prepending a
3136	dash to the first word if it lacks one, and passing the vector to
3137	decode_switches. */
3138
3139	static void
3140	decode_env_switches (char *envar, unsigned int len)
3141	{
3142	char *varref = alloca (2 + len + 2);
3143	char value, p;
3144	int argc;
3145	char **argv;
3146
3147	/* Get the variable's value. */
3148	varref[0] = '$';
3149	varref[1] = '(';
3150	memcpy (&varref[2], envar, len);
3151	varref[2 + len] = ')';
3152	varref[2 + len + 1] = '\0';
3153	value = variable_expand (varref);
3154
3155	/* Skip whitespace, and check for an empty value. */
3156	value = next_token (value);
3157	len = strlen (value);
3158	if (len == 0)
3159	return;
3160
3161	/* Allocate a vector that is definitely big enough. */
3162	argv = alloca ((1 + len + 1) * sizeof (char *));
3163
3164	/* Allocate a buffer to copy the value into while we split it into words
3165	and unquote it. We must use permanent storage for this because
3166	decode_switches may store pointers into the passed argument words. */
3167	p = xmalloc (2 * len);
3168
3169	/* getopt will look at the arguments starting at ARGV[1].
3170	Prepend a spacer word. */
3171	argv[0] = 0;
3172	argc = 1;
3173	argv[argc] = p;
3174	while (*value != '\0')
3175	{
3176	if (*value == '\\' && value[1] != '\0')
3177	++value; /* Skip the backslash. */
3178	else if (isblank ((unsigned char)*value))
3179	{
3180	/* End of the word. */
3181	*p++ = '\0';
3182	argv[++argc] = p;
3183	do
3184	++value;
3185	while (isblank ((unsigned char)*value));
3186	continue;
3187	}
3188	p++ = value++;
3189	}
3190	*p = '\0';
3191	argv[++argc] = 0;
3192
3193	if (argv[1][0] != '-' && strchr (argv[1], '=') == 0)
3194	/* The first word doesn't start with a dash and isn't a variable
3195	definition. Add a dash and pass it along to decode_switches. We
3196	need permanent storage for this in case decode_switches saves
3197	pointers into the value. */
3198	argv[1] = xstrdup (concat ("-", argv[1], ""));
3199
3200	/* Parse those words. */
3201	decode_switches (argc, argv, 1);
3202	}
3203
3204
3205	/* Quote the string IN so that it will be interpreted as a single word with
3206	no magic by decode_env_switches; also double dollar signs to avoid
3207	variable expansion in make itself. Write the result into OUT, returning
3208	the address of the next character to be written.
3209	Allocating space for OUT twice the length of IN is always sufficient. */
3210
3211	static char *
3212	quote_for_env (char out, const char in)
3213	{
3214	while (*in != '\0')
3215	{
3216	if (*in == '$')
3217	*out++ = '$';
3218	else if (isblank ((unsigned char)in) \|\| in == '\\')
3219	*out++ = '\\';
3220	out++ = in++;
3221	}
3222
3223	return out;
3224	}
3225
3226	/* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the
3227	command switches. Include options with args if ALL is nonzero.
3228	Don't include options with the `no_makefile' flag set if MAKEFILE. */
3229
3230	static void
3231	define_makeflags (int all, int makefile)
3232	{
3233	#ifdef KMK
3234	static const char ref[] = "$(KMK_OVERRIDES)";
3235	#else
3236	static const char ref[] = "$(MAKEOVERRIDES)";
3237	#endif
3238	static const char posixref[] = "$(--command-variables--)";
3239	register const struct command_switch *cs;
3240	char *flagstring;
3241	register char *p;
3242	unsigned int words;
3243	struct variable *v;
3244
3245	/* We will construct a linked list of `struct flag's describing
3246	all the flags which need to go in MAKEFLAGS. Then, once we
3247	know how many there are and their lengths, we can put them all
3248	together in a string. */
3249
3250	struct flag
3251	{
3252	struct flag *next;
3253	const struct command_switch *cs;
3254	const char *arg;
3255	};
3256	struct flag *flags = 0;
3257	unsigned int flagslen = 0;
3258	#define ADD_FLAG(ARG, LEN) \
3259	do { \
3260	struct flag *new = alloca (sizeof (struct flag)); \
3261	new->cs = cs; \
3262	new->arg = (ARG); \
3263	new->next = flags; \
3264	flags = new; \
3265	if (new->arg == 0) \
3266	++flagslen; /* Just a single flag letter. */ \
3267	else \
3268	flagslen += 1 + 1 + 1 + 1 + 3 * (LEN); /* " -x foo" */ \
3269	if (!short_option (cs->c)) \
3270	/* This switch has no single-letter version, so we use the long. */ \
3271	flagslen += 2 + strlen (cs->long_name); \
3272	} while (0)
3273
3274	for (cs = switches; cs->c != '\0'; ++cs)
3275	if (cs->toenv && (!makefile \|\| !cs->no_makefile))
3276	switch (cs->type)
3277	{
3278	case ignore:
3279	break;
3280
3281	case flag:
3282	case flag_off:
3283	if (!(int ) cs->value_ptr == (cs->type == flag_off)
3284	&& (cs->default_value == 0
3285	\|\| (int ) cs->value_ptr != (int ) cs->default_value))
3286	ADD_FLAG (0, 0);
3287	break;
3288
3289	case positive_int:
3290	if (all)
3291	{
3292	if ((cs->default_value != 0
3293	&& ((unsigned int ) cs->value_ptr
3294	== (unsigned int ) cs->default_value)))
3295	break;
3296	else if (cs->noarg_value != 0
3297	&& ((unsigned int ) cs->value_ptr ==
3298	(unsigned int ) cs->noarg_value))
3299	ADD_FLAG ("", 0); /* Optional value omitted; see below. */
3300	#if !defined(KMK) \|\| !defined(WINDOWS32) /* jobserver stuff doesn't work on windows???. */
3301	else if (cs->c == 'j')
3302	/* Special case for `-j'. */
3303	ADD_FLAG ("1", 1);
3304	#endif
3305	else
3306	{
3307	char *buf = alloca (30);
3308	sprintf (buf, "%u", (unsigned int ) cs->value_ptr);
3309	ADD_FLAG (buf, strlen (buf));
3310	}
3311	}
3312	break;
3313
3314	#ifndef NO_FLOAT
3315	case floating:
3316	if (all)
3317	{
3318	if (cs->default_value != 0
3319	&& ((double ) cs->value_ptr
3320	== (double ) cs->default_value))
3321	break;
3322	else if (cs->noarg_value != 0
3323	&& ((double ) cs->value_ptr
3324	== (double ) cs->noarg_value))
3325	ADD_FLAG ("", 0); /* Optional value omitted; see below. */
3326	else
3327	{
3328	char *buf = alloca (100);
3329	sprintf (buf, "%g", (double ) cs->value_ptr);
3330	ADD_FLAG (buf, strlen (buf));
3331	}
3332	}
3333	break;
3334	#endif
3335
3336	case filename:
3337	case string:
3338	if (all)
3339	{
3340	struct stringlist sl = (struct stringlist **) cs->value_ptr;
3341	if (sl != 0)
3342	{
3343	/* Add the elements in reverse order, because all the flags
3344	get reversed below; and the order matters for some
3345	switches (like -I). */
3346	unsigned int i = sl->idx;
3347	while (i-- > 0)
3348	ADD_FLAG (sl->list[i], strlen (sl->list[i]));
3349	}
3350	}
3351	break;
3352
3353	default:
3354	abort ();
3355	}
3356
3357	flagslen += 4 + sizeof posixref; /* Four more for the possible " -- ". */
3358
3359	#undef ADD_FLAG
3360
3361	/* Construct the value in FLAGSTRING.
3362	We allocate enough space for a preceding dash and trailing null. */
3363	flagstring = alloca (1 + flagslen + 1);
3364	memset (flagstring, '\0', 1 + flagslen + 1);
3365	p = flagstring;
3366	words = 1;
3367	*p++ = '-';
3368	while (flags != 0)
3369	{
3370	/* Add the flag letter or name to the string. */
3371	if (short_option (flags->cs->c))
3372	*p++ = flags->cs->c;
3373	else
3374	{
3375	if (*p != '-')
3376	{
3377	*p++ = ' ';
3378	*p++ = '-';
3379	}
3380	*p++ = '-';
3381	strcpy (p, flags->cs->long_name);
3382	p += strlen (p);
3383	}
3384	if (flags->arg != 0)
3385	{
3386	/* A flag that takes an optional argument which in this case is
3387	omitted is specified by ARG being "". We must distinguish
3388	because a following flag appended without an intervening " -"
3389	is considered the arg for the first. */
3390	if (flags->arg[0] != '\0')
3391	{
3392	/* Add its argument too. */
3393	*p++ = !short_option (flags->cs->c) ? '=' : ' ';
3394	p = quote_for_env (p, flags->arg);
3395	}
3396	++words;
3397	/* Write a following space and dash, for the next flag. */
3398	*p++ = ' ';
3399	*p++ = '-';
3400	}
3401	else if (!short_option (flags->cs->c))
3402	{
3403	++words;
3404	/* Long options must each go in their own word,
3405	so we write the following space and dash. */
3406	*p++ = ' ';
3407	*p++ = '-';
3408	}
3409	flags = flags->next;
3410	}
3411
3412	/* Define MFLAGS before appending variable definitions. */
3413
3414	if (p == &flagstring[1])
3415	/* No flags. */
3416	flagstring[0] = '\0';
3417	else if (p[-1] == '-')
3418	{
3419	/* Kill the final space and dash. */
3420	p -= 2;
3421	*p = '\0';
3422	}
3423	else
3424	/* Terminate the string. */
3425	*p = '\0';
3426
3427	#ifdef KMK
3428	/* Since MFLAGS is not parsed for flags, there is no reason to
3429	override any makefile redefinition. */
3430	(void) define_variable ("MFLAGS", 6, flagstring, o_env, 1);
3431	#endif /* !KMK */
3432
3433	if (all && command_variables != 0)
3434	{
3435	/* Now write a reference to $(MAKEOVERRIDES), which contains all the
3436	command-line variable definitions. */
3437
3438	if (p == &flagstring[1])
3439	/* No flags written, so elide the leading dash already written. */
3440	p = flagstring;
3441	else
3442	{
3443	/* Separate the variables from the switches with a "--" arg. */
3444	if (p[-1] != '-')
3445	{
3446	/* We did not already write a trailing " -". */
3447	*p++ = ' ';
3448	*p++ = '-';
3449	}
3450	/* There is a trailing " -"; fill it out to " -- ". */
3451	*p++ = '-';
3452	*p++ = ' ';
3453	}
3454
3455	/* Copy in the string. */
3456	if (posix_pedantic)
3457	{
3458	memcpy (p, posixref, sizeof posixref - 1);
3459	p += sizeof posixref - 1;
3460	}
3461	else
3462	{
3463	memcpy (p, ref, sizeof ref - 1);
3464	p += sizeof ref - 1;
3465	}
3466	}
3467	else if (p == &flagstring[1])
3468	{
3469	words = 0;
3470	--p;
3471	}
3472	else if (p[-1] == '-')
3473	/* Kill the final space and dash. */
3474	p -= 2;
3475	/* Terminate the string. */
3476	*p = '\0';
3477
3478	#ifdef KMK
3479	v = define_variable ("KMK_FLAGS", 9,
3480	/* If there are switches, omit the leading dash
3481	unless it is a single long option with two
3482	leading dashes. */
3483	&flagstring[(flagstring[0] == '-'
3484	&& flagstring[1] != '-')
3485	? 1 : 0],
3486	/* This used to use o_env, but that lost when a
3487	makefile defined MAKEFLAGS. Makefiles set
3488	MAKEFLAGS to add switches, but we still want
3489	to redefine its value with the full set of
3490	switches. Of course, an override or command
3491	definition will still take precedence. */
3492	o_file, 1);
3493	#else
3494	v = define_variable ("MAKEFLAGS", 9,
3495	/* If there are switches, omit the leading dash
3496	unless it is a single long option with two
3497	leading dashes. */
3498	&flagstring[(flagstring[0] == '-'
3499	&& flagstring[1] != '-')
3500	? 1 : 0],
3501	/* This used to use o_env, but that lost when a
3502	makefile defined MAKEFLAGS. Makefiles set
3503	MAKEFLAGS to add switches, but we still want
3504	to redefine its value with the full set of
3505	switches. Of course, an override or command
3506	definition will still take precedence. */
3507	o_file, 1);
3508	#endif
3509	if (! all)
3510	/* The first time we are called, set MAKEFLAGS to always be exported.
3511	We should not do this again on the second call, because that is
3512	after reading makefiles which might have done `unexport MAKEFLAGS'. */
3513	v->export = v_export;
3514
3515	#ifdef KMK
3516	/* Provide simple access to some of the options. */
3517	{
3518	char val[32];
3519	sprintf (val, "%u", job_slots);
3520	define_variable ("KMK_OPTS_JOBS", sizeof("KMK_OPTS_JOBS") - 1,
3521	val, o_default, 1);
3522	define_variable ("KMK_OPTS_KEEP_GOING", sizeof("KMK_OPTS_KEEP_GOING") - 1,
3523	keep_going_flag ? "1" : "0", o_default, 1);
3524	define_variable ("KMK_OPTS_JUST_PRINT", sizeof("KMK_OPTS_JUST_PRINT") - 1,
3525	just_print_flag ? "1" : "0", o_default, 1);
3526	define_variable ("KMK_OPTS_PRETTY_COMMAND_PRINTING", sizeof("KMK_OPTS_PRETTY_COMMAND_PRINTING") - 1,
3527	pretty_command_printing ? "1" : "0", o_default, 1);
3528	sprintf (val, "%u", process_priority);
3529	define_variable ("KMK_OPTS_PRORITY", sizeof("KMK_OPTS_PRORITY") - 1,
3530	val, o_default, 1);
3531	sprintf (val, "%u", process_affinity);
3532	define_variable ("KMK_OPTS_AFFINITY", sizeof("KMK_OPTS_AFFINITY") - 1,
3533	val, o_default, 1);
3534	#if defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)
3535	define_variable ("KMK_OPTS_STATISTICS", sizeof("KMK_OPTS_STATISTICS") - 1,
3536	make_expensive_statistics ? "1" : "0", o_default, 1);
3537	# endif
3538	}
3539	#endif
3540	}
3541
3542
3543	/* Print version information. */
3544
3545	static void
3546	print_version (void)
3547	{
3548	static int printed_version = 0;
3549
3550	char *precede = print_data_base_flag ? "# " : "";
3551
3552	if (printed_version)
3553	/* Do it only once. */
3554	return;
3555
3556	/* Print this untranslated. The coding standards recommend translating the
3557	(C) to the copyright symbol, but this string is going to change every
3558	year, and none of the rest of it should be translated (including the
3559	word "Copyright", so it hardly seems worth it. */
3560
3561	#ifdef KMK
3562	printf ("%skmk - kBuild version %d.%d.%d (r%u)\n\
3563	\n\
3564	%sBased on GNU Make %s:\n\
3565	%s Copyright (C) 2006 Free Software Foundation, Inc.\n\
3566	\n\
3567	%skBuild modifications:\n\
3568	%s Copyright (C) 2005-2008 Knut St. Osmundsen.\n\
3569	\n\
3570	%skmkbuiltin commands derived from *BSD sources:\n\
3571	%s Copyright (c) 1983 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994\n\
3572	%s The Regents of the University of California. All rights reserved.\n\
3573	%s Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>\n\
3574	%s\n",
3575	precede, KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR,
3576	KBUILD_VERSION_PATCH, KBUILD_SVN_REV,
3577	precede, version_string,
3578	precede, precede, precede, precede, precede, precede,
3579	precede, precede);
3580	#else
3581	printf ("%sGNU Make %s\n\
3582	%sCopyright (C) 2006 Free Software Foundation, Inc.\n",
3583	precede, version_string, precede);
3584	#endif
3585
3586	printf (_("%sThis is free software; see the source for copying conditions.\n\
3587	%sThere is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n\
3588	%sPARTICULAR PURPOSE.\n"),
3589	precede, precede, precede);
3590
3591	#ifdef KMK
3592	# ifdef KBUILD_PATH
3593	printf (_("%s\n\
3594	%sKBUILD_PATH: '%s' (default '%s')\n\
3595	%sKBUILD_BIN_PATH: '%s' (default '%s')\n"),
3596	precede,
3597	precede, get_kbuild_path(), KBUILD_PATH,
3598	precede, get_kbuild_bin_path(), KBUILD_BIN_PATH);
3599	# else /* !KBUILD_PATH */
3600	printf (_("%s\n\
3601	%sKBUILD_PATH: '%s'\n\
3602	%sKBUILD_BIN_PATH: '%s'\n"),
3603	precede,
3604	precede, get_kbuild_path(),
3605	precede, get_kbuild_bin_path());
3606	# endif /* !KBUILD_PATH */
3607	if (!remote_description \|\| *remote_description == '\0')
3608	printf (_("\n%sThis program is built for %s/%s/%s [" __DATE__ " " __TIME__ "]\n"),
3609	precede, KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU);
3610	else
3611	printf (_("\n%sThis program is built for %s/%s/%s (%s) [" __DATE__ " " __TIME__ "]\n"),
3612	precede, KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU, remote_description);
3613	#else
3614	if (!remote_description \|\| *remote_description == '\0')
3615	printf (_("\n%sThis program built for %s\n"), precede, make_host);
3616	else
3617	printf (_("\n%sThis program built for %s (%s)\n"),
3618	precede, make_host, remote_description);
3619	#endif
3620
3621	printed_version = 1;
3622
3623	/* Flush stdout so the user doesn't have to wait to see the
3624	version information while things are thought about. */
3625	fflush (stdout);
3626	}
3627
3628	/* Print a bunch of information about this and that. */
3629
3630	static void
3631	print_data_base ()
3632	{
3633	time_t when;
3634
3635	when = time ((time_t *) 0);
3636	printf (_("\n# Make data base, printed on %s"), ctime (&when));
3637
3638	print_variable_data_base ();
3639	print_dir_data_base ();
3640	print_rule_data_base ();
3641	print_file_data_base ();
3642	print_vpath_data_base ();
3643	#ifndef CONFIG_WITH_STRCACHE2
3644	strcache_print_stats ("#");
3645	#else
3646	strcache2_print_stats_all ("#");
3647	#endif
3648	#ifdef CONFIG_WITH_ALLOC_CACHES
3649	alloccache_print_all ();
3650	#endif
3651
3652	when = time ((time_t *) 0);
3653	printf (_("\n# Finished Make data base on %s\n"), ctime (&when));
3654	}
3655
3656	static void
3657	clean_jobserver (int status)
3658	{
3659	char token = '+';
3660
3661	/* Sanity: have we written all our jobserver tokens back? If our
3662	exit status is 2 that means some kind of syntax error; we might not
3663	have written all our tokens so do that now. If tokens are left
3664	after any other error code, that's bad. */
3665
3666	if (job_fds[0] != -1 && jobserver_tokens)
3667	{
3668	if (status != 2)
3669	error (NILF,
3670	"INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
3671	jobserver_tokens);
3672	else
3673	while (jobserver_tokens--)
3674	{
3675	int r;
3676
3677	EINTRLOOP (r, write (job_fds[1], &token, 1));
3678	if (r != 1)
3679	perror_with_name ("write", "");
3680	}
3681	}
3682
3683
3684	/* Sanity: If we're the master, were all the tokens written back? */
3685
3686	if (master_job_slots)
3687	{
3688	/* We didn't write one for ourself, so start at 1. */
3689	unsigned int tcnt = 1;
3690
3691	/* Close the write side, so the read() won't hang. */
3692	close (job_fds[1]);
3693
3694	while (read (job_fds[0], &token, 1) == 1)
3695	++tcnt;
3696
3697	if (tcnt != master_job_slots)
3698	error (NILF,
3699	"INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
3700	tcnt, master_job_slots);
3701
3702	close (job_fds[0]);
3703	}
3704	}
3705
3706
3707	/* Exit with STATUS, cleaning up as necessary. */
3708
3709	void
3710	die (int status)
3711	{
3712	static char dying = 0;
3713
3714	if (!dying)
3715	{
3716	int err;
3717
3718	dying = 1;
3719
3720	if (print_version_flag)
3721	print_version ();
3722
3723	/* Wait for children to die. */
3724	err = (status != 0);
3725	while (job_slots_used > 0)
3726	reap_children (1, err);
3727
3728	/* Let the remote job module clean up its state. */
3729	remote_cleanup ();
3730
3731	/* Remove the intermediate files. */
3732	remove_intermediates (0);
3733
3734	if (print_data_base_flag)
3735	print_data_base ();
3736
3737	#ifdef NDEBUG /* bird: Don't waste time on debug sanity checks. */
3738	if (print_data_base_flag \|\| db_level)
3739	#endif
3740	verify_file_data_base ();
3741
3742	clean_jobserver (status);
3743
3744	/* Try to move back to the original directory. This is essential on
3745	MS-DOS (where there is really only one process), and on Unix it
3746	puts core files in the original directory instead of the -C
3747	directory. Must wait until after remove_intermediates(), or unlinks
3748	of relative pathnames fail. */
3749	if (directory_before_chdir != 0)
3750	chdir (directory_before_chdir);
3751
3752	log_working_directory (0);
3753	}
3754
3755	exit (status);
3756	}
3757
3758
3759	/* Write a message indicating that we've just entered or
3760	left (according to ENTERING) the current directory. */
3761
3762	void
3763	log_working_directory (int entering)
3764	{
3765	static int entered = 0;
3766
3767	/* Print nothing without the flag. Don't print the entering message
3768	again if we already have. Don't print the leaving message if we
3769	haven't printed the entering message. */
3770	if (! print_directory_flag \|\| entering == entered)
3771	return;
3772
3773	entered = entering;
3774
3775	if (print_data_base_flag)
3776	fputs ("# ", stdout);
3777
3778	/* Use entire sentences to give the translators a fighting chance. */
3779
3780	if (makelevel == 0)
3781	if (starting_directory == 0)
3782	if (entering)
3783	printf (_("%s: Entering an unknown directory\n"), program);
3784	else
3785	printf (_("%s: Leaving an unknown directory\n"), program);
3786	else
3787	if (entering)
3788	printf (_("%s: Entering directory `%s'\n"),
3789	program, starting_directory);
3790	else
3791	printf (_("%s: Leaving directory `%s'\n"),
3792	program, starting_directory);
3793	else
3794	if (starting_directory == 0)
3795	if (entering)
3796	printf (_("%s[%u]: Entering an unknown directory\n"),
3797	program, makelevel);
3798	else
3799	printf (_("%s[%u]: Leaving an unknown directory\n"),
3800	program, makelevel);
3801	else
3802	if (entering)
3803	printf (_("%s[%u]: Entering directory `%s'\n"),
3804	program, makelevel, starting_directory);
3805	else
3806	printf (_("%s[%u]: Leaving directory `%s'\n"),
3807	program, makelevel, starting_directory);
3808
3809	/* Flush stdout to be sure this comes before any stderr output. */
3810	fflush (stdout);
3811	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: