main.c@ 1822

Last change on this file since 1822 was 1811, checked in by bird, 17 years ago
kmk: More string length optimizations.
Property svn:eol-style set to `native`
File size: 106.7 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	#ifndef CONFIG_WITH_VALUE_LENGTH
2808	v = try_variable_definition (0, arg, o_command, 0);
2809	#else
2810	v = try_variable_definition (0, arg, NULL, o_command, 0);
2811	#endif
2812	if (v != 0)
2813	{
2814	/* It is indeed a variable definition. If we don't already have this
2815	one, record a pointer to the variable for later use in
2816	define_makeflags. */
2817	struct command_variable *cv;
2818
2819	for (cv = command_variables; cv != 0; cv = cv->next)
2820	if (cv->variable == v)
2821	break;
2822
2823	if (! cv) {
2824	cv = xmalloc (sizeof (*cv));
2825	cv->variable = v;
2826	cv->next = command_variables;
2827	command_variables = cv;
2828	}
2829	}
2830	else if (! env)
2831	{
2832	/* Not an option or variable definition; it must be a goal
2833	target! Enter it as a file and add it to the dep chain of
2834	goals. */
2835	struct file *f = enter_file (strcache_add (expand_command_line_file (arg)));
2836	f->cmd_target = 1;
2837
2838	if (goals == 0)
2839	{
2840	goals = alloc_dep ();
2841	lastgoal = goals;
2842	}
2843	else
2844	{
2845	lastgoal->next = alloc_dep ();
2846	lastgoal = lastgoal->next;
2847	}
2848
2849	lastgoal->file = f;
2850
2851	{
2852	/* Add this target name to the MAKECMDGOALS variable. */
2853	struct variable *gv;
2854	const char *value;
2855
2856	gv = lookup_variable (STRING_SIZE_TUPLE ("MAKECMDGOALS"));
2857	if (gv == 0)
2858	value = f->name;
2859	else
2860	{
2861	/* Paste the old and new values together */
2862	unsigned int oldlen, newlen;
2863	char *vp;
2864
2865	oldlen = strlen (gv->value);
2866	newlen = strlen (f->name);
2867	vp = alloca (oldlen + 1 + newlen + 1);
2868	memcpy (vp, gv->value, oldlen);
2869	vp[oldlen] = ' ';
2870	memcpy (&vp[oldlen + 1], f->name, newlen + 1);
2871	value = vp;
2872	}
2873	define_variable ("MAKECMDGOALS", 12, value, o_default, 0);
2874	}
2875	}
2876	}
2877
2878	/* Print a nice usage method. */
2879
2880	static void
2881	print_usage (int bad)
2882	{
2883	const char const cpp;
2884	FILE *usageto;
2885
2886	if (print_version_flag)
2887	print_version ();
2888
2889	usageto = bad ? stderr : stdout;
2890
2891	fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program);
2892
2893	for (cpp = usage; *cpp; ++cpp)
2894	fputs (_(*cpp), usageto);
2895
2896	#ifdef KMK
2897	if (!remote_description \|\| *remote_description == '\0')
2898	printf (_("\nThis program is built for %s/%s/%s [" __DATE__ " " __TIME__ "]\n"),
2899	KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU, remote_description);
2900	else
2901	printf (_("\nThis program is built for %s/%s/%s (%s) [" __DATE__ " " __TIME__ "]\n"),
2902	KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU, remote_description);
2903	#else /* !KMK */
2904	if (!remote_description \|\| *remote_description == '\0')
2905	fprintf (usageto, _("\nThis program built for %s\n"), make_host);
2906	else
2907	fprintf (usageto, _("\nThis program built for %s (%s)\n"),
2908	make_host, remote_description);
2909	#endif /* !KMK */
2910
2911	fprintf (usageto, _("Report bugs to <bug-make@gnu.org>\n"));
2912	}
2913
2914	/* Decode switches from ARGC and ARGV.
2915	They came from the environment if ENV is nonzero. */
2916
2917	static void
2918	decode_switches (int argc, char **argv, int env)
2919	{
2920	int bad = 0;
2921	register const struct command_switch *cs;
2922	register struct stringlist *sl;
2923	register int c;
2924
2925	/* getopt does most of the parsing for us.
2926	First, get its vectors set up. */
2927
2928	init_switches ();
2929
2930	/* Let getopt produce error messages for the command line,
2931	but not for options from the environment. */
2932	opterr = !env;
2933	/* Reset getopt's state. */
2934	optind = 0;
2935
2936	while (optind < argc)
2937	{
2938	/* Parse the next argument. */
2939	c = getopt_long (argc, argv, options, long_options, (int *) 0);
2940	if (c == EOF)
2941	/* End of arguments, or "--" marker seen. */
2942	break;
2943	else if (c == 1)
2944	/* An argument not starting with a dash. */
2945	handle_non_switch_argument (optarg, env);
2946	else if (c == '?')
2947	/* Bad option. We will print a usage message and die later.
2948	But continue to parse the other options so the user can
2949	see all he did wrong. */
2950	bad = 1;
2951	else
2952	for (cs = switches; cs->c != '\0'; ++cs)
2953	if (cs->c == c)
2954	{
2955	/* Whether or not we will actually do anything with
2956	this switch. We test this individually inside the
2957	switch below rather than just once outside it, so that
2958	options which are to be ignored still consume args. */
2959	int doit = !env \|\| cs->env;
2960
2961	switch (cs->type)
2962	{
2963	default:
2964	abort ();
2965
2966	case ignore:
2967	break;
2968
2969	case flag:
2970	case flag_off:
2971	if (doit)
2972	(int ) cs->value_ptr = cs->type == flag;
2973	break;
2974
2975	case string:
2976	case filename:
2977	if (!doit)
2978	break;
2979
2980	if (optarg == 0)
2981	optarg = xstrdup (cs->noarg_value);
2982	else if (*optarg == '\0')
2983	{
2984	error (NILF, _("the `-%c' option requires a non-empty string argument"),
2985	cs->c);
2986	bad = 1;
2987	}
2988
2989	sl = (struct stringlist *) cs->value_ptr;
2990	if (sl == 0)
2991	{
2992	sl = (struct stringlist *)
2993	xmalloc (sizeof (struct stringlist));
2994	sl->max = 5;
2995	sl->idx = 0;
2996	sl->list = xmalloc (5 * sizeof (char *));
2997	(struct stringlist *) cs->value_ptr = sl;
2998	}
2999	else if (sl->idx == sl->max - 1)
3000	{
3001	sl->max += 5;
3002	sl->list = xrealloc ((void )sl->list, / bird */
3003	sl->max * sizeof (char *));
3004	}
3005	if (cs->type == filename)
3006	sl->list[sl->idx++] = expand_command_line_file (optarg);
3007	else
3008	sl->list[sl->idx++] = optarg;
3009	sl->list[sl->idx] = 0;
3010	break;
3011
3012	case positive_int:
3013	/* See if we have an option argument; if we do require that
3014	it's all digits, not something like "10foo". */
3015	if (optarg == 0 && argc > optind)
3016	{
3017	const char *cp;
3018	for (cp=argv[optind]; ISDIGIT (cp[0]); ++cp)
3019	;
3020	if (cp[0] == '\0')
3021	optarg = argv[optind++];
3022	}
3023
3024	if (!doit)
3025	break;
3026
3027	if (optarg != 0)
3028	{
3029	int i = atoi (optarg);
3030	const char *cp;
3031
3032	/* Yes, I realize we're repeating this in some cases. */
3033	for (cp = optarg; ISDIGIT (cp[0]); ++cp)
3034	;
3035
3036	if (i < 1 \|\| cp[0] != '\0')
3037	{
3038	error (NILF, _("the `-%c' option requires a positive integral argument"),
3039	cs->c);
3040	bad = 1;
3041	}
3042	else
3043	(unsigned int ) cs->value_ptr = i;
3044	}
3045	else
3046	(unsigned int ) cs->value_ptr
3047	= (unsigned int ) cs->noarg_value;
3048	break;
3049
3050	#ifndef NO_FLOAT
3051	case floating:
3052	if (optarg == 0 && optind < argc
3053	&& (ISDIGIT (argv[optind][0]) \|\| argv[optind][0] == '.'))
3054	optarg = argv[optind++];
3055
3056	if (doit)
3057	(double ) cs->value_ptr
3058	= (optarg != 0 ? atof (optarg)
3059	: (double ) cs->noarg_value);
3060
3061	break;
3062	#endif
3063	}
3064
3065	/* We've found the switch. Stop looking. */
3066	break;
3067	}
3068	}
3069
3070	/* There are no more options according to getting getopt, but there may
3071	be some arguments left. Since we have asked for non-option arguments
3072	to be returned in order, this only happens when there is a "--"
3073	argument to prevent later arguments from being options. */
3074	while (optind < argc)
3075	handle_non_switch_argument (argv[optind++], env);
3076
3077
3078	if (!env && (bad \|\| print_usage_flag))
3079	{
3080	print_usage (bad);
3081	die (bad ? 2 : 0);
3082	}
3083	}
3084
3085	/* Decode switches from environment variable ENVAR (which is LEN chars long).
3086	We do this by chopping the value into a vector of words, prepending a
3087	dash to the first word if it lacks one, and passing the vector to
3088	decode_switches. */
3089
3090	static void
3091	decode_env_switches (char *envar, unsigned int len)
3092	{
3093	char *varref = alloca (2 + len + 2);
3094	char value, p;
3095	int argc;
3096	char **argv;
3097
3098	/* Get the variable's value. */
3099	varref[0] = '$';
3100	varref[1] = '(';
3101	memcpy (&varref[2], envar, len);
3102	varref[2 + len] = ')';
3103	varref[2 + len + 1] = '\0';
3104	value = variable_expand (varref);
3105
3106	/* Skip whitespace, and check for an empty value. */
3107	value = next_token (value);
3108	len = strlen (value);
3109	if (len == 0)
3110	return;
3111
3112	/* Allocate a vector that is definitely big enough. */
3113	argv = alloca ((1 + len + 1) * sizeof (char *));
3114
3115	/* Allocate a buffer to copy the value into while we split it into words
3116	and unquote it. We must use permanent storage for this because
3117	decode_switches may store pointers into the passed argument words. */
3118	p = xmalloc (2 * len);
3119
3120	/* getopt will look at the arguments starting at ARGV[1].
3121	Prepend a spacer word. */
3122	argv[0] = 0;
3123	argc = 1;
3124	argv[argc] = p;
3125	while (*value != '\0')
3126	{
3127	if (*value == '\\' && value[1] != '\0')
3128	++value; /* Skip the backslash. */
3129	else if (isblank ((unsigned char)*value))
3130	{
3131	/* End of the word. */
3132	*p++ = '\0';
3133	argv[++argc] = p;
3134	do
3135	++value;
3136	while (isblank ((unsigned char)*value));
3137	continue;
3138	}
3139	p++ = value++;
3140	}
3141	*p = '\0';
3142	argv[++argc] = 0;
3143
3144	if (argv[1][0] != '-' && strchr (argv[1], '=') == 0)
3145	/* The first word doesn't start with a dash and isn't a variable
3146	definition. Add a dash and pass it along to decode_switches. We
3147	need permanent storage for this in case decode_switches saves
3148	pointers into the value. */
3149	argv[1] = xstrdup (concat ("-", argv[1], ""));
3150
3151	/* Parse those words. */
3152	decode_switches (argc, argv, 1);
3153	}
3154
3155
3156	/* Quote the string IN so that it will be interpreted as a single word with
3157	no magic by decode_env_switches; also double dollar signs to avoid
3158	variable expansion in make itself. Write the result into OUT, returning
3159	the address of the next character to be written.
3160	Allocating space for OUT twice the length of IN is always sufficient. */
3161
3162	static char *
3163	quote_for_env (char out, const char in)
3164	{
3165	while (*in != '\0')
3166	{
3167	if (*in == '$')
3168	*out++ = '$';
3169	else if (isblank ((unsigned char)in) \|\| in == '\\')
3170	*out++ = '\\';
3171	out++ = in++;
3172	}
3173
3174	return out;
3175	}
3176
3177	/* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the
3178	command switches. Include options with args if ALL is nonzero.
3179	Don't include options with the `no_makefile' flag set if MAKEFILE. */
3180
3181	static void
3182	define_makeflags (int all, int makefile)
3183	{
3184	#ifdef KMK
3185	static const char ref[] = "$(KMK_OVERRIDES)";
3186	#else
3187	static const char ref[] = "$(MAKEOVERRIDES)";
3188	#endif
3189	static const char posixref[] = "$(--command-variables--)";
3190	register const struct command_switch *cs;
3191	char *flagstring;
3192	register char *p;
3193	unsigned int words;
3194	struct variable *v;
3195
3196	/* We will construct a linked list of `struct flag's describing
3197	all the flags which need to go in MAKEFLAGS. Then, once we
3198	know how many there are and their lengths, we can put them all
3199	together in a string. */
3200
3201	struct flag
3202	{
3203	struct flag *next;
3204	const struct command_switch *cs;
3205	const char *arg;
3206	};
3207	struct flag *flags = 0;
3208	unsigned int flagslen = 0;
3209	#define ADD_FLAG(ARG, LEN) \
3210	do { \
3211	struct flag *new = alloca (sizeof (struct flag)); \
3212	new->cs = cs; \
3213	new->arg = (ARG); \
3214	new->next = flags; \
3215	flags = new; \
3216	if (new->arg == 0) \
3217	++flagslen; /* Just a single flag letter. */ \
3218	else \
3219	flagslen += 1 + 1 + 1 + 1 + 3 * (LEN); /* " -x foo" */ \
3220	if (!short_option (cs->c)) \
3221	/* This switch has no single-letter version, so we use the long. */ \
3222	flagslen += 2 + strlen (cs->long_name); \
3223	} while (0)
3224
3225	for (cs = switches; cs->c != '\0'; ++cs)
3226	if (cs->toenv && (!makefile \|\| !cs->no_makefile))
3227	switch (cs->type)
3228	{
3229	case ignore:
3230	break;
3231
3232	case flag:
3233	case flag_off:
3234	if (!(int ) cs->value_ptr == (cs->type == flag_off)
3235	&& (cs->default_value == 0
3236	\|\| (int ) cs->value_ptr != (int ) cs->default_value))
3237	ADD_FLAG (0, 0);
3238	break;
3239
3240	case positive_int:
3241	if (all)
3242	{
3243	if ((cs->default_value != 0
3244	&& ((unsigned int ) cs->value_ptr
3245	== (unsigned int ) cs->default_value)))
3246	break;
3247	else if (cs->noarg_value != 0
3248	&& ((unsigned int ) cs->value_ptr ==
3249	(unsigned int ) cs->noarg_value))
3250	ADD_FLAG ("", 0); /* Optional value omitted; see below. */
3251	#if !defined(KMK) \|\| !defined(WINDOWS32) /* jobserver stuff doesn't work on windows???. */
3252	else if (cs->c == 'j')
3253	/* Special case for `-j'. */
3254	ADD_FLAG ("1", 1);
3255	#endif
3256	else
3257	{
3258	char *buf = alloca (30);
3259	sprintf (buf, "%u", (unsigned int ) cs->value_ptr);
3260	ADD_FLAG (buf, strlen (buf));
3261	}
3262	}
3263	break;
3264
3265	#ifndef NO_FLOAT
3266	case floating:
3267	if (all)
3268	{
3269	if (cs->default_value != 0
3270	&& ((double ) cs->value_ptr
3271	== (double ) cs->default_value))
3272	break;
3273	else if (cs->noarg_value != 0
3274	&& ((double ) cs->value_ptr
3275	== (double ) cs->noarg_value))
3276	ADD_FLAG ("", 0); /* Optional value omitted; see below. */
3277	else
3278	{
3279	char *buf = alloca (100);
3280	sprintf (buf, "%g", (double ) cs->value_ptr);
3281	ADD_FLAG (buf, strlen (buf));
3282	}
3283	}
3284	break;
3285	#endif
3286
3287	case filename:
3288	case string:
3289	if (all)
3290	{
3291	struct stringlist sl = (struct stringlist **) cs->value_ptr;
3292	if (sl != 0)
3293	{
3294	/* Add the elements in reverse order, because all the flags
3295	get reversed below; and the order matters for some
3296	switches (like -I). */
3297	unsigned int i = sl->idx;
3298	while (i-- > 0)
3299	ADD_FLAG (sl->list[i], strlen (sl->list[i]));
3300	}
3301	}
3302	break;
3303
3304	default:
3305	abort ();
3306	}
3307
3308	flagslen += 4 + sizeof posixref; /* Four more for the possible " -- ". */
3309
3310	#undef ADD_FLAG
3311
3312	/* Construct the value in FLAGSTRING.
3313	We allocate enough space for a preceding dash and trailing null. */
3314	flagstring = alloca (1 + flagslen + 1);
3315	memset (flagstring, '\0', 1 + flagslen + 1);
3316	p = flagstring;
3317	words = 1;
3318	*p++ = '-';
3319	while (flags != 0)
3320	{
3321	/* Add the flag letter or name to the string. */
3322	if (short_option (flags->cs->c))
3323	*p++ = flags->cs->c;
3324	else
3325	{
3326	if (*p != '-')
3327	{
3328	*p++ = ' ';
3329	*p++ = '-';
3330	}
3331	*p++ = '-';
3332	strcpy (p, flags->cs->long_name);
3333	p += strlen (p);
3334	}
3335	if (flags->arg != 0)
3336	{
3337	/* A flag that takes an optional argument which in this case is
3338	omitted is specified by ARG being "". We must distinguish
3339	because a following flag appended without an intervening " -"
3340	is considered the arg for the first. */
3341	if (flags->arg[0] != '\0')
3342	{
3343	/* Add its argument too. */
3344	*p++ = !short_option (flags->cs->c) ? '=' : ' ';
3345	p = quote_for_env (p, flags->arg);
3346	}
3347	++words;
3348	/* Write a following space and dash, for the next flag. */
3349	*p++ = ' ';
3350	*p++ = '-';
3351	}
3352	else if (!short_option (flags->cs->c))
3353	{
3354	++words;
3355	/* Long options must each go in their own word,
3356	so we write the following space and dash. */
3357	*p++ = ' ';
3358	*p++ = '-';
3359	}
3360	flags = flags->next;
3361	}
3362
3363	/* Define MFLAGS before appending variable definitions. */
3364
3365	if (p == &flagstring[1])
3366	/* No flags. */
3367	flagstring[0] = '\0';
3368	else if (p[-1] == '-')
3369	{
3370	/* Kill the final space and dash. */
3371	p -= 2;
3372	*p = '\0';
3373	}
3374	else
3375	/* Terminate the string. */
3376	*p = '\0';
3377
3378	#ifdef KMK
3379	/* Since MFLAGS is not parsed for flags, there is no reason to
3380	override any makefile redefinition. */
3381	(void) define_variable ("MFLAGS", 6, flagstring, o_env, 1);
3382	#endif /* !KMK */
3383
3384	if (all && command_variables != 0)
3385	{
3386	/* Now write a reference to $(MAKEOVERRIDES), which contains all the
3387	command-line variable definitions. */
3388
3389	if (p == &flagstring[1])
3390	/* No flags written, so elide the leading dash already written. */
3391	p = flagstring;
3392	else
3393	{
3394	/* Separate the variables from the switches with a "--" arg. */
3395	if (p[-1] != '-')
3396	{
3397	/* We did not already write a trailing " -". */
3398	*p++ = ' ';
3399	*p++ = '-';
3400	}
3401	/* There is a trailing " -"; fill it out to " -- ". */
3402	*p++ = '-';
3403	*p++ = ' ';
3404	}
3405
3406	/* Copy in the string. */
3407	if (posix_pedantic)
3408	{
3409	memcpy (p, posixref, sizeof posixref - 1);
3410	p += sizeof posixref - 1;
3411	}
3412	else
3413	{
3414	memcpy (p, ref, sizeof ref - 1);
3415	p += sizeof ref - 1;
3416	}
3417	}
3418	else if (p == &flagstring[1])
3419	{
3420	words = 0;
3421	--p;
3422	}
3423	else if (p[-1] == '-')
3424	/* Kill the final space and dash. */
3425	p -= 2;
3426	/* Terminate the string. */
3427	*p = '\0';
3428
3429	#ifdef KMK
3430	v = define_variable ("KMK_FLAGS", 9,
3431	/* If there are switches, omit the leading dash
3432	unless it is a single long option with two
3433	leading dashes. */
3434	&flagstring[(flagstring[0] == '-'
3435	&& flagstring[1] != '-')
3436	? 1 : 0],
3437	/* This used to use o_env, but that lost when a
3438	makefile defined MAKEFLAGS. Makefiles set
3439	MAKEFLAGS to add switches, but we still want
3440	to redefine its value with the full set of
3441	switches. Of course, an override or command
3442	definition will still take precedence. */
3443	o_file, 1);
3444	#else
3445	v = define_variable ("MAKEFLAGS", 9,
3446	/* If there are switches, omit the leading dash
3447	unless it is a single long option with two
3448	leading dashes. */
3449	&flagstring[(flagstring[0] == '-'
3450	&& flagstring[1] != '-')
3451	? 1 : 0],
3452	/* This used to use o_env, but that lost when a
3453	makefile defined MAKEFLAGS. Makefiles set
3454	MAKEFLAGS to add switches, but we still want
3455	to redefine its value with the full set of
3456	switches. Of course, an override or command
3457	definition will still take precedence. */
3458	o_file, 1);
3459	#endif
3460	if (! all)
3461	/* The first time we are called, set MAKEFLAGS to always be exported.
3462	We should not do this again on the second call, because that is
3463	after reading makefiles which might have done `unexport MAKEFLAGS'. */
3464	v->export = v_export;
3465
3466	#ifdef KMK
3467	/* Provide simple access to some of the options. */
3468	{
3469	char val[32];
3470	sprintf (val, "%u", job_slots);
3471	define_variable ("KMK_OPTS_JOBS", sizeof("KMK_OPTS_JOBS") - 1,
3472	val, o_default, 1);
3473	define_variable ("KMK_OPTS_KEEP_GOING", sizeof("KMK_OPTS_KEEP_GOING") - 1,
3474	keep_going_flag ? "1" : "0", o_default, 1);
3475	define_variable ("KMK_OPTS_JUST_PRINT", sizeof("KMK_OPTS_JUST_PRINT") - 1,
3476	just_print_flag ? "1" : "0", o_default, 1);
3477	define_variable ("KMK_OPTS_PRETTY_COMMAND_PRINTING", sizeof("KMK_OPTS_PRETTY_COMMAND_PRINTING") - 1,
3478	pretty_command_printing ? "1" : "0", o_default, 1);
3479	sprintf (val, "%u", process_priority);
3480	define_variable ("KMK_OPTS_PRORITY", sizeof("KMK_OPTS_PRORITY") - 1,
3481	val, o_default, 1);
3482	sprintf (val, "%u", process_affinity);
3483	define_variable ("KMK_OPTS_AFFINITY", sizeof("KMK_OPTS_AFFINITY") - 1,
3484	val, o_default, 1);
3485	define_variable ("KMK_OPTS_STATISTICS", sizeof("KMK_OPTS_STATISTICS") - 1,
3486	make_expensive_statistics ? "1" : "0", o_default, 1);
3487	}
3488	#endif
3489	}
3490
3491
3492	/* Print version information. */
3493
3494	static void
3495	print_version (void)
3496	{
3497	static int printed_version = 0;
3498
3499	char *precede = print_data_base_flag ? "# " : "";
3500
3501	if (printed_version)
3502	/* Do it only once. */
3503	return;
3504
3505	/* Print this untranslated. The coding standards recommend translating the
3506	(C) to the copyright symbol, but this string is going to change every
3507	year, and none of the rest of it should be translated (including the
3508	word "Copyright", so it hardly seems worth it. */
3509
3510	#ifdef KMK
3511	printf ("%skmk - kBuild version %d.%d.%d (r%u)\n\
3512	\n\
3513	%sBased on GNU Make %s:\n\
3514	%s Copyright (C) 2006 Free Software Foundation, Inc.\n\
3515	\n\
3516	%skBuild modifications:\n\
3517	%s Copyright (C) 2005-2008 Knut St. Osmundsen.\n\
3518	\n\
3519	%skmkbuiltin commands derived from *BSD sources:\n\
3520	%s Copyright (c) 1983 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994\n\
3521	%s The Regents of the University of California. All rights reserved.\n\
3522	%s Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>\n\
3523	%s\n",
3524	precede, KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR,
3525	KBUILD_VERSION_PATCH, KBUILD_SVN_REV,
3526	precede, version_string,
3527	precede, precede, precede, precede, precede, precede,
3528	precede, precede);
3529	#else
3530	printf ("%sGNU Make %s\n\
3531	%sCopyright (C) 2006 Free Software Foundation, Inc.\n",
3532	precede, version_string, precede);
3533	#endif
3534
3535	printf (_("%sThis is free software; see the source for copying conditions.\n\
3536	%sThere is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n\
3537	%sPARTICULAR PURPOSE.\n"),
3538	precede, precede, precede);
3539
3540	#ifdef KMK
3541	# ifdef KBUILD_PATH
3542	printf (_("%s\n\
3543	%sKBUILD_PATH: '%s' (default '%s')\n\
3544	%sKBUILD_BIN_PATH: '%s' (default '%s')\n"),
3545	precede,
3546	precede, get_kbuild_path(), KBUILD_PATH,
3547	precede, get_kbuild_bin_path(), KBUILD_BIN_PATH);
3548	# else /* !KBUILD_PATH */
3549	printf (_("%s\n\
3550	%sKBUILD_PATH: '%s'\n\
3551	%sKBUILD_BIN_PATH: '%s'\n"),
3552	precede,
3553	precede, get_kbuild_path(),
3554	precede, get_kbuild_bin_path());
3555	# endif /* !KBUILD_PATH */
3556	if (!remote_description \|\| *remote_description == '\0')
3557	printf (_("\n%sThis program is built for %s/%s/%s [" __DATE__ " " __TIME__ "]\n"),
3558	precede, KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU, remote_description);
3559	else
3560	printf (_("\n%sThis program is built for %s/%s/%s (%s) [" __DATE__ " " __TIME__ "]\n"),
3561	precede, KBUILD_HOST, KBUILD_HOST_ARCH, KBUILD_HOST_CPU, remote_description);
3562	#else
3563	if (!remote_description \|\| *remote_description == '\0')
3564	printf (_("\n%sThis program built for %s\n"), precede, make_host);
3565	else
3566	printf (_("\n%sThis program built for %s (%s)\n"),
3567	precede, make_host, remote_description);
3568	#endif
3569
3570	printed_version = 1;
3571
3572	/* Flush stdout so the user doesn't have to wait to see the
3573	version information while things are thought about. */
3574	fflush (stdout);
3575	}
3576
3577	/* Print a bunch of information about this and that. */
3578
3579	static void
3580	print_data_base ()
3581	{
3582	time_t when;
3583
3584	when = time ((time_t *) 0);
3585	printf (_("\n# Make data base, printed on %s"), ctime (&when));
3586
3587	print_variable_data_base ();
3588	print_dir_data_base ();
3589	print_rule_data_base ();
3590	print_file_data_base ();
3591	print_vpath_data_base ();
3592	strcache_print_stats ("#");
3593
3594	when = time ((time_t *) 0);
3595	printf (_("\n# Finished Make data base on %s\n"), ctime (&when));
3596	}
3597
3598	static void
3599	clean_jobserver (int status)
3600	{
3601	char token = '+';
3602
3603	/* Sanity: have we written all our jobserver tokens back? If our
3604	exit status is 2 that means some kind of syntax error; we might not
3605	have written all our tokens so do that now. If tokens are left
3606	after any other error code, that's bad. */
3607
3608	if (job_fds[0] != -1 && jobserver_tokens)
3609	{
3610	if (status != 2)
3611	error (NILF,
3612	"INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
3613	jobserver_tokens);
3614	else
3615	while (jobserver_tokens--)
3616	{
3617	int r;
3618
3619	EINTRLOOP (r, write (job_fds[1], &token, 1));
3620	if (r != 1)
3621	perror_with_name ("write", "");
3622	}
3623	}
3624
3625
3626	/* Sanity: If we're the master, were all the tokens written back? */
3627
3628	if (master_job_slots)
3629	{
3630	/* We didn't write one for ourself, so start at 1. */
3631	unsigned int tcnt = 1;
3632
3633	/* Close the write side, so the read() won't hang. */
3634	close (job_fds[1]);
3635
3636	while (read (job_fds[0], &token, 1) == 1)
3637	++tcnt;
3638
3639	if (tcnt != master_job_slots)
3640	error (NILF,
3641	"INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
3642	tcnt, master_job_slots);
3643
3644	close (job_fds[0]);
3645	}
3646	}
3647
3648
3649	/* Exit with STATUS, cleaning up as necessary. */
3650
3651	void
3652	die (int status)
3653	{
3654	static char dying = 0;
3655
3656	if (!dying)
3657	{
3658	int err;
3659
3660	dying = 1;
3661
3662	if (print_version_flag)
3663	print_version ();
3664
3665	/* Wait for children to die. */
3666	err = (status != 0);
3667	while (job_slots_used > 0)
3668	reap_children (1, err);
3669
3670	/* Let the remote job module clean up its state. */
3671	remote_cleanup ();
3672
3673	/* Remove the intermediate files. */
3674	remove_intermediates (0);
3675
3676	if (print_data_base_flag)
3677	print_data_base ();
3678
3679	verify_file_data_base ();
3680
3681	clean_jobserver (status);
3682
3683	/* Try to move back to the original directory. This is essential on
3684	MS-DOS (where there is really only one process), and on Unix it
3685	puts core files in the original directory instead of the -C
3686	directory. Must wait until after remove_intermediates(), or unlinks
3687	of relative pathnames fail. */
3688	if (directory_before_chdir != 0)
3689	chdir (directory_before_chdir);
3690
3691	log_working_directory (0);
3692	}
3693
3694	exit (status);
3695	}
3696
3697
3698	/* Write a message indicating that we've just entered or
3699	left (according to ENTERING) the current directory. */
3700
3701	void
3702	log_working_directory (int entering)
3703	{
3704	static int entered = 0;
3705
3706	/* Print nothing without the flag. Don't print the entering message
3707	again if we already have. Don't print the leaving message if we
3708	haven't printed the entering message. */
3709	if (! print_directory_flag \|\| entering == entered)
3710	return;
3711
3712	entered = entering;
3713
3714	if (print_data_base_flag)
3715	fputs ("# ", stdout);
3716
3717	/* Use entire sentences to give the translators a fighting chance. */
3718
3719	if (makelevel == 0)
3720	if (starting_directory == 0)
3721	if (entering)
3722	printf (_("%s: Entering an unknown directory\n"), program);
3723	else
3724	printf (_("%s: Leaving an unknown directory\n"), program);
3725	else
3726	if (entering)
3727	printf (_("%s: Entering directory `%s'\n"),
3728	program, starting_directory);
3729	else
3730	printf (_("%s: Leaving directory `%s'\n"),
3731	program, starting_directory);
3732	else
3733	if (starting_directory == 0)
3734	if (entering)
3735	printf (_("%s[%u]: Entering an unknown directory\n"),
3736	program, makelevel);
3737	else
3738	printf (_("%s[%u]: Leaving an unknown directory\n"),
3739	program, makelevel);
3740	else
3741	if (entering)
3742	printf (_("%s[%u]: Entering directory `%s'\n"),
3743	program, makelevel, starting_directory);
3744	else
3745	printf (_("%s[%u]: Leaving directory `%s'\n"),
3746	program, makelevel, starting_directory);
3747
3748	/* Flush stdout to be sure this comes before any stderr output. */
3749	fflush (stdout);
3750	}

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

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

Download in other formats: