main.c@ 1810

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

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

source: kBuild/trunk/src/kmk/main.c@ 1810

Download in other formats: