main.c@ 3122

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

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

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

Download in other formats: