/[make]/make/main.c
ViewVC logotype

Contents of /make/main.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.183 - (show annotations) (download)
Wed Oct 22 04:35:27 2003 UTC (20 years, 6 months ago) by psmith
Branch: MAIN
Changes since 1.182: +4 -4 lines
File MIME type: text/plain
Build fixes due to changes in the FSF web site.
Add new language support.
Minor configure, etc. cleanups.

1 /* Argument parsing and main program of GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3 2002, 2003 Free Software Foundation, Inc.
4 This file is part of GNU Make.
5
6 GNU Make is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU Make is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Make; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
19 MA 02111-1307, USA. */
20
21 #include "make.h"
22 #include "dep.h"
23 #include "filedef.h"
24 #include "variable.h"
25 #include "job.h"
26 #include "commands.h"
27 #include "rule.h"
28 #include "debug.h"
29 #include "getopt.h"
30
31 #include <assert.h>
32 #ifdef _AMIGA
33 # include <dos/dos.h>
34 # include <proto/dos.h>
35 #endif
36 #ifdef WINDOWS32
37 #include <windows.h>
38 #include "pathstuff.h"
39 #endif
40 #ifdef __EMX__
41 # include <sys/types.h>
42 # include <sys/wait.h>
43 #endif
44 #ifdef HAVE_FCNTL_H
45 # include <fcntl.h>
46 #endif
47
48 #ifdef _AMIGA
49 int __stack = 20000; /* Make sure we have 20K of stack space */
50 #endif
51
52 extern void init_dir PARAMS ((void));
53 extern void remote_setup PARAMS ((void));
54 extern void remote_cleanup PARAMS ((void));
55 extern RETSIGTYPE fatal_error_signal PARAMS ((int sig));
56
57 extern void print_variable_data_base PARAMS ((void));
58 extern void print_dir_data_base PARAMS ((void));
59 extern void print_rule_data_base PARAMS ((void));
60 extern void print_file_data_base PARAMS ((void));
61 extern void print_vpath_data_base PARAMS ((void));
62
63 #if defined HAVE_WAITPID || defined HAVE_WAIT3
64 # define HAVE_WAIT_NOHANG
65 #endif
66
67 #ifndef HAVE_UNISTD_H
68 extern int chdir ();
69 #endif
70 #ifndef STDC_HEADERS
71 # ifndef sun /* Sun has an incorrect decl in a header. */
72 extern void exit PARAMS ((int)) __attribute__ ((noreturn));
73 # endif
74 extern double atof ();
75 #endif
76
77 static void print_data_base PARAMS ((void));
78 static void print_version PARAMS ((void));
79 static void decode_switches PARAMS ((int argc, char **argv, int env));
80 static void decode_env_switches PARAMS ((char *envar, unsigned int len));
81 static void define_makeflags PARAMS ((int all, int makefile));
82 static char *quote_for_env PARAMS ((char *out, char *in));
83 static void initialize_global_hash_tables PARAMS ((void));
84
85
86 /* The structure that describes an accepted command switch. */
87
88 struct command_switch
89 {
90 int c; /* The switch character. */
91
92 enum /* Type of the value. */
93 {
94 flag, /* Turn int flag on. */
95 flag_off, /* Turn int flag off. */
96 string, /* One string per switch. */
97 positive_int, /* A positive integer. */
98 floating, /* A floating-point number (double). */
99 ignore /* Ignored. */
100 } type;
101
102 char *value_ptr; /* Pointer to the value-holding variable. */
103
104 unsigned int env:1; /* Can come from MAKEFLAGS. */
105 unsigned int toenv:1; /* Should be put in MAKEFLAGS. */
106 unsigned int no_makefile:1; /* Don't propagate when remaking makefiles. */
107
108 char *noarg_value; /* Pointer to value used if no argument is given. */
109 char *default_value;/* Pointer to default value. */
110
111 char *long_name; /* Long option name. */
112 };
113
114 /* True if C is a switch value that corresponds to a short option. */
115
116 #define short_option(c) ((c) <= CHAR_MAX)
117
118 /* The structure used to hold the list of strings given
119 in command switches of a type that takes string arguments. */
120
121 struct stringlist
122 {
123 char **list; /* Nil-terminated list of strings. */
124 unsigned int idx; /* Index into above. */
125 unsigned int max; /* Number of pointers allocated. */
126 };
127
128
129 /* The recognized command switches. */
130
131 /* Nonzero means do not print commands to be executed (-s). */
132
133 int silent_flag;
134
135 /* Nonzero means just touch the files
136 that would appear to need remaking (-t) */
137
138 int touch_flag;
139
140 /* Nonzero means just print what commands would need to be executed,
141 don't actually execute them (-n). */
142
143 int just_print_flag;
144
145 /* Print debugging info (--debug). */
146
147 static struct stringlist *db_flags;
148 static int debug_flag = 0;
149
150 int db_level = 0;
151
152 #ifdef WINDOWS32
153 /* Suspend make in main for a short time to allow debugger to attach */
154
155 int suspend_flag = 0;
156 #endif
157
158 /* Environment variables override makefile definitions. */
159
160 int env_overrides = 0;
161
162 /* Nonzero means ignore status codes returned by commands
163 executed to remake files. Just treat them all as successful (-i). */
164
165 int ignore_errors_flag = 0;
166
167 /* Nonzero means don't remake anything, just print the data base
168 that results from reading the makefile (-p). */
169
170 int print_data_base_flag = 0;
171
172 /* Nonzero means don't remake anything; just return a nonzero status
173 if the specified targets are not up to date (-q). */
174
175 int question_flag = 0;
176
177 /* Nonzero means do not use any of the builtin rules (-r) / variables (-R). */
178
179 int no_builtin_rules_flag = 0;
180 int no_builtin_variables_flag = 0;
181
182 /* Nonzero means keep going even if remaking some file fails (-k). */
183
184 int keep_going_flag;
185 int default_keep_going_flag = 0;
186
187 /* Nonzero means print directory before starting and when done (-w). */
188
189 int print_directory_flag = 0;
190
191 /* Nonzero means ignore print_directory_flag and never print the directory.
192 This is necessary because print_directory_flag is set implicitly. */
193
194 int inhibit_print_directory_flag = 0;
195
196 /* Nonzero means print version information. */
197
198 int print_version_flag = 0;
199
200 /* List of makefiles given with -f switches. */
201
202 static struct stringlist *makefiles = 0;
203
204 /* Number of job slots (commands that can be run at once). */
205
206 unsigned int job_slots = 1;
207 unsigned int default_job_slots = 1;
208
209 /* Value of job_slots that means no limit. */
210
211 static unsigned int inf_jobs = 0;
212
213 /* File descriptors for the jobs pipe. */
214
215 static struct stringlist *jobserver_fds = 0;
216
217 int job_fds[2] = { -1, -1 };
218 int job_rfd = -1;
219
220 /* Maximum load average at which multiple jobs will be run.
221 Negative values mean unlimited, while zero means limit to
222 zero load (which could be useful to start infinite jobs remotely
223 but one at a time locally). */
224 #ifndef NO_FLOAT
225 double max_load_average = -1.0;
226 double default_load_average = -1.0;
227 #else
228 int max_load_average = -1;
229 int default_load_average = -1;
230 #endif
231
232 /* List of directories given with -C switches. */
233
234 static struct stringlist *directories = 0;
235
236 /* List of include directories given with -I switches. */
237
238 static struct stringlist *include_directories = 0;
239
240 /* List of files given with -o switches. */
241
242 static struct stringlist *old_files = 0;
243
244 /* List of files given with -W switches. */
245
246 static struct stringlist *new_files = 0;
247
248 /* If nonzero, we should just print usage and exit. */
249
250 static int print_usage_flag = 0;
251
252 /* If nonzero, we should print a warning message
253 for each reference to an undefined variable. */
254
255 int warn_undefined_variables_flag;
256
257 /* If nonzero, always build all targets, regardless of whether
258 they appear out of date or not. */
259
260 int always_make_flag = 0;
261
262 /* The usage output. We write it this way to make life easier for the
263 translators, especially those trying to translate to right-to-left
264 languages like Hebrew. */
265
266 static const char *const usage[] =
267 {
268 N_("Options:\n"),
269 N_("\
270 -b, -m Ignored for compatibility.\n"),
271 N_("\
272 -B, --always-make Unconditionally make all targets.\n"),
273 N_("\
274 -C DIRECTORY, --directory=DIRECTORY\n\
275 Change to DIRECTORY before doing anything.\n"),
276 N_("\
277 -d Print lots of debugging information.\n"),
278 N_("\
279 --debug[=FLAGS] Print various types of debugging information.\n"),
280 N_("\
281 -e, --environment-overrides\n\
282 Environment variables override makefiles.\n"),
283 N_("\
284 -f FILE, --file=FILE, --makefile=FILE\n\
285 Read FILE as a makefile.\n"),
286 N_("\
287 -h, --help Print this message and exit.\n"),
288 N_("\
289 -i, --ignore-errors Ignore errors from commands.\n"),
290 N_("\
291 -I DIRECTORY, --include-dir=DIRECTORY\n\
292 Search DIRECTORY for included makefiles.\n"),
293 N_("\
294 -j [N], --jobs[=N] Allow N jobs at once; infinite jobs with no arg.\n"),
295 N_("\
296 -k, --keep-going Keep going when some targets can't be made.\n"),
297 N_("\
298 -l [N], --load-average[=N], --max-load[=N]\n\
299 Don't start multiple jobs unless load is below N.\n"),
300 N_("\
301 -n, --just-print, --dry-run, --recon\n\
302 Don't actually run any commands; just print them.\n"),
303 N_("\
304 -o FILE, --old-file=FILE, --assume-old=FILE\n\
305 Consider FILE to be very old and don't remake it.\n"),
306 N_("\
307 -p, --print-data-base Print make's internal database.\n"),
308 N_("\
309 -q, --question Run no commands; exit status says if up to date.\n"),
310 N_("\
311 -r, --no-builtin-rules Disable the built-in implicit rules.\n"),
312 N_("\
313 -R, --no-builtin-variables Disable the built-in variable settings.\n"),
314 N_("\
315 -s, --silent, --quiet Don't echo commands.\n"),
316 N_("\
317 -S, --no-keep-going, --stop\n\
318 Turns off -k.\n"),
319 N_("\
320 -t, --touch Touch targets instead of remaking them.\n"),
321 N_("\
322 -v, --version Print the version number of make and exit.\n"),
323 N_("\
324 -w, --print-directory Print the current directory.\n"),
325 N_("\
326 --no-print-directory Turn off -w, even if it was turned on implicitly.\n"),
327 N_("\
328 -W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE\n\
329 Consider FILE to be infinitely new.\n"),
330 N_("\
331 --warn-undefined-variables Warn when an undefined variable is referenced.\n"),
332 NULL
333 };
334
335 /* The table of command switches. */
336
337 static const struct command_switch switches[] =
338 {
339 { 'b', ignore, 0, 0, 0, 0, 0, 0, 0 },
340 { 'B', flag, (char *) &always_make_flag, 1, 1, 0, 0, 0, "always-make" },
341 { 'C', string, (char *) &directories, 0, 0, 0, 0, 0, "directory" },
342 { 'd', flag, (char *) &debug_flag, 1, 1, 0, 0, 0, 0 },
343 { CHAR_MAX+1, string, (char *) &db_flags, 1, 1, 0, "basic", 0, "debug" },
344 #ifdef WINDOWS32
345 { 'D', flag, (char *) &suspend_flag, 1, 1, 0, 0, 0, "suspend-for-debug" },
346 #endif
347 { 'e', flag, (char *) &env_overrides, 1, 1, 0, 0, 0,
348 "environment-overrides", },
349 { 'f', string, (char *) &makefiles, 0, 0, 0, 0, 0, "file" },
350 { 'h', flag, (char *) &print_usage_flag, 0, 0, 0, 0, 0, "help" },
351 { 'i', flag, (char *) &ignore_errors_flag, 1, 1, 0, 0, 0,
352 "ignore-errors" },
353 { 'I', string, (char *) &include_directories, 1, 1, 0, 0, 0,
354 "include-dir" },
355 { 'j', positive_int, (char *) &job_slots, 1, 1, 0, (char *) &inf_jobs,
356 (char *) &default_job_slots, "jobs" },
357 { CHAR_MAX+2, string, (char *) &jobserver_fds, 1, 1, 0, 0, 0,
358 "jobserver-fds" },
359 { 'k', flag, (char *) &keep_going_flag, 1, 1, 0, 0,
360 (char *) &default_keep_going_flag, "keep-going" },
361 #ifndef NO_FLOAT
362 { 'l', floating, (char *) &max_load_average, 1, 1, 0,
363 (char *) &default_load_average, (char *) &default_load_average,
364 "load-average" },
365 #else
366 { 'l', positive_int, (char *) &max_load_average, 1, 1, 0,
367 (char *) &default_load_average, (char *) &default_load_average,
368 "load-average" },
369 #endif
370 { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },
371 { 'n', flag, (char *) &just_print_flag, 1, 1, 1, 0, 0, "just-print" },
372 { 'o', string, (char *) &old_files, 0, 0, 0, 0, 0, "old-file" },
373 { 'p', flag, (char *) &print_data_base_flag, 1, 1, 0, 0, 0,
374 "print-data-base" },
375 { 'q', flag, (char *) &question_flag, 1, 1, 1, 0, 0, "question" },
376 { 'r', flag, (char *) &no_builtin_rules_flag, 1, 1, 0, 0, 0,
377 "no-builtin-rules" },
378 { 'R', flag, (char *) &no_builtin_variables_flag, 1, 1, 0, 0, 0,
379 "no-builtin-variables" },
380 { 's', flag, (char *) &silent_flag, 1, 1, 0, 0, 0, "silent" },
381 { 'S', flag_off, (char *) &keep_going_flag, 1, 1, 0, 0,
382 (char *) &default_keep_going_flag, "no-keep-going" },
383 { 't', flag, (char *) &touch_flag, 1, 1, 1, 0, 0, "touch" },
384 { 'v', flag, (char *) &print_version_flag, 1, 1, 0, 0, 0, "version" },
385 { 'w', flag, (char *) &print_directory_flag, 1, 1, 0, 0, 0,
386 "print-directory" },
387 { CHAR_MAX+3, flag, (char *) &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
388 "no-print-directory" },
389 { 'W', string, (char *) &new_files, 0, 0, 0, 0, 0, "what-if" },
390 { CHAR_MAX+4, flag, (char *) &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
391 "warn-undefined-variables" },
392 { '\0', }
393 };
394
395 /* Secondary long names for options. */
396
397 static struct option long_option_aliases[] =
398 {
399 { "quiet", no_argument, 0, 's' },
400 { "stop", no_argument, 0, 'S' },
401 { "new-file", required_argument, 0, 'W' },
402 { "assume-new", required_argument, 0, 'W' },
403 { "assume-old", required_argument, 0, 'o' },
404 { "max-load", optional_argument, 0, 'l' },
405 { "dry-run", no_argument, 0, 'n' },
406 { "recon", no_argument, 0, 'n' },
407 { "makefile", required_argument, 0, 'f' },
408 };
409
410 /* List of goal targets. */
411
412 static struct dep *goals, *lastgoal;
413
414 /* List of variables which were defined on the command line
415 (or, equivalently, in MAKEFLAGS). */
416
417 struct command_variable
418 {
419 struct command_variable *next;
420 struct variable *variable;
421 };
422 static struct command_variable *command_variables;
423
424 /* The name we were invoked with. */
425
426 char *program;
427
428 /* Our current directory before processing any -C options. */
429
430 char *directory_before_chdir;
431
432 /* Our current directory after processing all -C options. */
433
434 char *starting_directory;
435
436 /* Value of the MAKELEVEL variable at startup (or 0). */
437
438 unsigned int makelevel;
439
440 /* First file defined in the makefile whose name does not
441 start with `.'. This is the default to remake if the
442 command line does not specify. */
443
444 struct file *default_goal_file;
445
446 /* Pointer to structure for the file .DEFAULT
447 whose commands are used for any file that has none of its own.
448 This is zero if the makefiles do not define .DEFAULT. */
449
450 struct file *default_file;
451
452 /* Nonzero if we have seen the magic `.POSIX' target.
453 This turns on pedantic compliance with POSIX.2. */
454
455 int posix_pedantic;
456
457 /* Nonzero if we have seen the `.NOTPARALLEL' target.
458 This turns off parallel builds for this invocation of make. */
459
460 int not_parallel;
461
462 /* Nonzero if some rule detected clock skew; we keep track so (a) we only
463 print one warning about it during the run, and (b) we can print a final
464 warning at the end of the run. */
465
466 int clock_skew_detected;
467
468 /* Mask of signals that are being caught with fatal_error_signal. */
469
470 #ifdef POSIX
471 sigset_t fatal_signal_set;
472 #else
473 # ifdef HAVE_SIGSETMASK
474 int fatal_signal_mask;
475 # endif
476 #endif
477
478 #if !defined HAVE_BSD_SIGNAL && !defined bsd_signal
479 # if !defined HAVE_SIGACTION
480 # define bsd_signal signal
481 # else
482 typedef RETSIGTYPE (*bsd_signal_ret_t) ();
483
484 static bsd_signal_ret_t
485 bsd_signal (int sig, bsd_signal_ret_t func)
486 {
487 struct sigaction act, oact;
488 act.sa_handler = func;
489 act.sa_flags = SA_RESTART;
490 sigemptyset (&act.sa_mask);
491 sigaddset (&act.sa_mask, sig);
492 if (sigaction (sig, &act, &oact) != 0)
493 return SIG_ERR;
494 return oact.sa_handler;
495 }
496 # endif
497 #endif
498
499 static void
500 initialize_global_hash_tables (void)
501 {
502 init_hash_global_variable_set ();
503 init_hash_files ();
504 hash_init_directories ();
505 hash_init_function_table ();
506 }
507
508 static struct file *
509 enter_command_line_file (char *name)
510 {
511 if (name[0] == '\0')
512 fatal (NILF, _("empty string invalid as file name"));
513
514 if (name[0] == '~')
515 {
516 char *expanded = tilde_expand (name);
517 if (expanded != 0)
518 name = expanded; /* Memory leak; I don't care. */
519 }
520
521 /* This is also done in parse_file_seq, so this is redundant
522 for names read from makefiles. It is here for names passed
523 on the command line. */
524 while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
525 {
526 name += 2;
527 while (*name == '/')
528 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
529 ++name;
530 }
531
532 if (*name == '\0')
533 {
534 /* It was all slashes! Move back to the dot and truncate
535 it after the first slash, so it becomes just "./". */
536 do
537 --name;
538 while (name[0] != '.');
539 name[2] = '\0';
540 }
541
542 return enter_file (xstrdup (name));
543 }
544
545 /* Toggle -d on receipt of SIGUSR1. */
546
547 static RETSIGTYPE
548 debug_signal_handler (int sig)
549 {
550 db_level = db_level ? DB_NONE : DB_BASIC;
551 }
552
553 static void
554 decode_debug_flags (void)
555 {
556 char **pp;
557
558 if (debug_flag)
559 db_level = DB_ALL;
560
561 if (!db_flags)
562 return;
563
564 for (pp=db_flags->list; *pp; ++pp)
565 {
566 const char *p = *pp;
567
568 while (1)
569 {
570 switch (tolower (p[0]))
571 {
572 case 'a':
573 db_level |= DB_ALL;
574 break;
575 case 'b':
576 db_level |= DB_BASIC;
577 break;
578 case 'i':
579 db_level |= DB_BASIC | DB_IMPLICIT;
580 break;
581 case 'j':
582 db_level |= DB_JOBS;
583 break;
584 case 'm':
585 db_level |= DB_BASIC | DB_MAKEFILES;
586 break;
587 case 'v':
588 db_level |= DB_BASIC | DB_VERBOSE;
589 break;
590 default:
591 fatal (NILF, _("unknown debug level specification `%s'"), p);
592 }
593
594 while (*(++p) != '\0')
595 if (*p == ',' || *p == ' ')
596 break;
597
598 if (*p == '\0')
599 break;
600
601 ++p;
602 }
603 }
604 }
605
606 #ifdef WINDOWS32
607 /*
608 * HANDLE runtime exceptions by avoiding a requestor on the GUI. Capture
609 * exception and print it to stderr instead.
610 *
611 * If ! DB_VERBOSE, just print a simple message and exit.
612 * If DB_VERBOSE, print a more verbose message.
613 * If compiled for DEBUG, let exception pass through to GUI so that
614 * debuggers can attach.
615 */
616 LONG WINAPI
617 handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
618 {
619 PEXCEPTION_RECORD exrec = exinfo->ExceptionRecord;
620 LPSTR cmdline = GetCommandLine();
621 LPSTR prg = strtok(cmdline, " ");
622 CHAR errmsg[1024];
623 #ifdef USE_EVENT_LOG
624 HANDLE hEventSource;
625 LPTSTR lpszStrings[1];
626 #endif
627
628 if (! ISDB (DB_VERBOSE))
629 {
630 sprintf(errmsg,
631 _("%s: Interrupt/Exception caught (code = 0x%x, addr = 0x%x)\n"),
632 prg, exrec->ExceptionCode, exrec->ExceptionAddress);
633 fprintf(stderr, errmsg);
634 exit(255);
635 }
636
637 sprintf(errmsg,
638 _("\nUnhandled exception filter called from program %s\nExceptionCode = %x\nExceptionFlags = %x\nExceptionAddress = %x\n"),
639 prg, exrec->ExceptionCode, exrec->ExceptionFlags,
640 exrec->ExceptionAddress);
641
642 if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION
643 && exrec->NumberParameters >= 2)
644 sprintf(&errmsg[strlen(errmsg)],
645 (exrec->ExceptionInformation[0]
646 ? _("Access violation: write operation at address %x\n")
647 : _("Access violation: read operation at address %x\n")),
648 exrec->ExceptionInformation[1]);
649
650 /* turn this on if we want to put stuff in the event log too */
651 #ifdef USE_EVENT_LOG
652 hEventSource = RegisterEventSource(NULL, "GNU Make");
653 lpszStrings[0] = errmsg;
654
655 if (hEventSource != NULL)
656 {
657 ReportEvent(hEventSource, /* handle of event source */
658 EVENTLOG_ERROR_TYPE, /* event type */
659 0, /* event category */
660 0, /* event ID */
661 NULL, /* current user's SID */
662 1, /* strings in lpszStrings */
663 0, /* no bytes of raw data */
664 lpszStrings, /* array of error strings */
665 NULL); /* no raw data */
666
667 (VOID) DeregisterEventSource(hEventSource);
668 }
669 #endif
670
671 /* Write the error to stderr too */
672 fprintf(stderr, errmsg);
673
674 #ifdef DEBUG
675 return EXCEPTION_CONTINUE_SEARCH;
676 #else
677 exit(255);
678 return (255); /* not reached */
679 #endif
680 }
681
682 /*
683 * On WIN32 systems we don't have the luxury of a /bin directory that
684 * is mapped globally to every drive mounted to the system. Since make could
685 * be invoked from any drive, and we don't want to propogate /bin/sh
686 * to every single drive. Allow ourselves a chance to search for
687 * a value for default shell here (if the default path does not exist).
688 */
689
690 int
691 find_and_set_default_shell (char *token)
692 {
693 int sh_found = 0;
694 char* search_token;
695 PATH_VAR(sh_path);
696 extern char *default_shell;
697
698 if (!token)
699 search_token = default_shell;
700 else
701 search_token = token;
702
703 if (!no_default_sh_exe &&
704 (token == NULL || !strcmp(search_token, default_shell))) {
705 /* no new information, path already set or known */
706 sh_found = 1;
707 } else if (file_exists_p(search_token)) {
708 /* search token path was found */
709 sprintf(sh_path, "%s", search_token);
710 default_shell = xstrdup(w32ify(sh_path,0));
711 DB (DB_VERBOSE,
712 (_("find_and_set_shell setting default_shell = %s\n"), default_shell));
713 sh_found = 1;
714 } else {
715 char *p;
716 struct variable *v = lookup_variable ("Path", 4);
717
718 /*
719 * Search Path for shell
720 */
721 if (v && v->value) {
722 char *ep;
723
724 p = v->value;
725 ep = strchr(p, PATH_SEPARATOR_CHAR);
726
727 while (ep && *ep) {
728 *ep = '\0';
729
730 if (dir_file_exists_p(p, search_token)) {
731 sprintf(sh_path, "%s/%s", p, search_token);
732 default_shell = xstrdup(w32ify(sh_path,0));
733 sh_found = 1;
734 *ep = PATH_SEPARATOR_CHAR;
735
736 /* terminate loop */
737 p += strlen(p);
738 } else {
739 *ep = PATH_SEPARATOR_CHAR;
740 p = ++ep;
741 }
742
743 ep = strchr(p, PATH_SEPARATOR_CHAR);
744 }
745
746 /* be sure to check last element of Path */
747 if (p && *p && dir_file_exists_p(p, search_token)) {
748 sprintf(sh_path, "%s/%s", p, search_token);
749 default_shell = xstrdup(w32ify(sh_path,0));
750 sh_found = 1;
751 }
752
753 if (sh_found)
754 DB (DB_VERBOSE,
755 (_("find_and_set_shell path search set default_shell = %s\n"),
756 default_shell));
757 }
758 }
759
760 /* naive test */
761 if (!unixy_shell && sh_found &&
762 (strstr(default_shell, "sh") || strstr(default_shell, "SH"))) {
763 unixy_shell = 1;
764 batch_mode_shell = 0;
765 }
766
767 #ifdef BATCH_MODE_ONLY_SHELL
768 batch_mode_shell = 1;
769 #endif
770
771 return (sh_found);
772 }
773 #endif /* WINDOWS32 */
774
775 #ifdef __MSDOS__
776
777 static void
778 msdos_return_to_initial_directory (void)
779 {
780 if (directory_before_chdir)
781 chdir (directory_before_chdir);
782 }
783 #endif
784
785 extern char *mktemp PARAMS ((char *template));
786 extern int mkstemp PARAMS ((char *template));
787
788 FILE *
789 open_tmpfile(char **name, const char *template)
790 {
791 int fd;
792
793 #if defined HAVE_MKSTEMP || defined HAVE_MKTEMP
794 # define TEMPLATE_LEN strlen (template)
795 #else
796 # define TEMPLATE_LEN L_tmpnam
797 #endif
798 *name = xmalloc (TEMPLATE_LEN + 1);
799 strcpy (*name, template);
800
801 #if defined HAVE_MKSTEMP && defined HAVE_FDOPEN
802 /* It's safest to use mkstemp(), if we can. */
803 fd = mkstemp (*name);
804 if (fd == -1)
805 return 0;
806 return fdopen (fd, "w");
807 #else
808 # ifdef HAVE_MKTEMP
809 (void) mktemp (*name);
810 # else
811 (void) tmpnam (*name);
812 # endif
813
814 # ifdef HAVE_FDOPEN
815 /* Can't use mkstemp(), but guard against a race condition. */
816 fd = open (*name, O_CREAT|O_EXCL|O_WRONLY, 0600);
817 if (fd == -1)
818 return 0;
819 return fdopen (fd, "w");
820 # else
821 /* Not secure, but what can we do? */
822 return fopen (*name, "w");
823 # endif
824 #endif
825 }
826
827
828 #ifdef _AMIGA
829 int
830 main (int argc, char **argv)
831 #else
832 int
833 main (int argc, char **argv, char **envp)
834 #endif
835 {
836 static char *stdin_nm = 0;
837 register struct file *f;
838 register unsigned int i;
839 char **p;
840 struct dep *read_makefiles;
841 PATH_VAR (current_directory);
842 #ifdef WINDOWS32
843 char *unix_path = NULL;
844 char *windows32_path = NULL;
845
846 SetUnhandledExceptionFilter(handle_runtime_exceptions);
847
848 /* start off assuming we have no shell */
849 unixy_shell = 0;
850 no_default_sh_exe = 1;
851 #endif
852
853 /* Needed for OS/2 */
854 initialize_main(&argc, &argv);
855
856 default_goal_file = 0;
857 reading_file = 0;
858
859 #if defined (__MSDOS__) && !defined (_POSIX_SOURCE)
860 /* Request the most powerful version of `system', to
861 make up for the dumb default shell. */
862 __system_flags = (__system_redirect
863 | __system_use_shell
864 | __system_allow_multiple_cmds
865 | __system_allow_long_cmds
866 | __system_handle_null_commands
867 | __system_emulate_chdir);
868
869 #endif
870
871 /* Set up gettext/internationalization support. */
872 setlocale (LC_ALL, "");
873 bindtextdomain (PACKAGE, LOCALEDIR);
874 textdomain (PACKAGE);
875
876 #ifdef POSIX
877 sigemptyset (&fatal_signal_set);
878 #define ADD_SIG(sig) sigaddset (&fatal_signal_set, sig)
879 #else
880 #ifdef HAVE_SIGSETMASK
881 fatal_signal_mask = 0;
882 #define ADD_SIG(sig) fatal_signal_mask |= sigmask (sig)
883 #else
884 #define ADD_SIG(sig)
885 #endif
886 #endif
887
888 #define FATAL_SIG(sig) \
889 if (bsd_signal (sig, fatal_error_signal) == SIG_IGN) \
890 bsd_signal (sig, SIG_IGN); \
891 else \
892 ADD_SIG (sig);
893
894 #ifdef SIGHUP
895 FATAL_SIG (SIGHUP);
896 #endif
897 #ifdef SIGQUIT
898 FATAL_SIG (SIGQUIT);
899 #endif
900 FATAL_SIG (SIGINT);
901 FATAL_SIG (SIGTERM);
902
903 #ifdef __MSDOS__
904 /* Windows 9X delivers FP exceptions in child programs to their
905 parent! We don't want Make to die when a child divides by zero,
906 so we work around that lossage by catching SIGFPE. */
907 FATAL_SIG (SIGFPE);
908 #endif
909
910 #ifdef SIGDANGER
911 FATAL_SIG (SIGDANGER);
912 #endif
913 #ifdef SIGXCPU
914 FATAL_SIG (SIGXCPU);
915 #endif
916 #ifdef SIGXFSZ
917 FATAL_SIG (SIGXFSZ);
918 #endif
919
920 #undef FATAL_SIG
921
922 /* Do not ignore the child-death signal. This must be done before
923 any children could possibly be created; otherwise, the wait
924 functions won't work on systems with the SVR4 ECHILD brain
925 damage, if our invoker is ignoring this signal. */
926
927 #ifdef HAVE_WAIT_NOHANG
928 # if defined SIGCHLD
929 (void) bsd_signal (SIGCHLD, SIG_DFL);
930 # endif
931 # if defined SIGCLD && SIGCLD != SIGCHLD
932 (void) bsd_signal (SIGCLD, SIG_DFL);
933 # endif
934 #endif
935
936 /* Make sure stdout is line-buffered. */
937
938 #ifdef HAVE_SETVBUF
939 # ifdef SETVBUF_REVERSED
940 setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ);
941 # else /* setvbuf not reversed. */
942 /* Some buggy systems lose if we pass 0 instead of allocating ourselves. */
943 setvbuf (stdout, (char *) 0, _IOLBF, BUFSIZ);
944 # endif /* setvbuf reversed. */
945 #elif HAVE_SETLINEBUF
946 setlinebuf (stdout);
947 #endif /* setlinebuf missing. */
948
949 /* Figure out where this program lives. */
950
951 if (argv[0] == 0)
952 argv[0] = "";
953 if (argv[0][0] == '\0')
954 program = "make";
955 else
956 {
957 #ifdef VMS
958 program = strrchr (argv[0], ']');
959 #else
960 program = strrchr (argv[0], '/');
961 #endif
962 #if defined(__MSDOS__) || defined(__EMX__)
963 if (program == 0)
964 program = strrchr (argv[0], '\\');
965 else
966 {
967 /* Some weird environments might pass us argv[0] with
968 both kinds of slashes; we must find the rightmost. */
969 char *p = strrchr (argv[0], '\\');
970 if (p && p > program)
971 program = p;
972 }
973 if (program == 0 && argv[0][1] == ':')
974 program = argv[0] + 1;
975 #endif
976 if (program == 0)
977 program = argv[0];
978 else
979 ++program;
980 }
981
982 /* Set up to access user data (files). */
983 user_access ();
984
985 initialize_global_hash_tables ();
986
987 /* Figure out where we are. */
988
989 #ifdef WINDOWS32
990 if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
991 #else
992 if (getcwd (current_directory, GET_PATH_MAX) == 0)
993 #endif
994 {
995 #ifdef HAVE_GETCWD
996 perror_with_name ("getcwd: ", "");
997 #else
998 error (NILF, "getwd: %s", current_directory);
999 #endif
1000 current_directory[0] = '\0';
1001 directory_before_chdir = 0;
1002 }
1003 else
1004 directory_before_chdir = xstrdup (current_directory);
1005 #ifdef __MSDOS__
1006 /* Make sure we will return to the initial directory, come what may. */
1007 atexit (msdos_return_to_initial_directory);
1008 #endif
1009
1010 /* Initialize the special variables. */
1011 define_variable (".VARIABLES", 10, "", o_default, 0)->special = 1;
1012 /* define_variable (".TARGETS", 8, "", o_default, 0); */
1013
1014 /* Read in variables from the environment. It is important that this be
1015 done before $(MAKE) is figured out so its definitions will not be
1016 from the environment. */
1017
1018 #ifndef _AMIGA
1019 for (i = 0; envp[i] != 0; ++i)
1020 {
1021 int do_not_define;
1022 register char *ep = envp[i];
1023
1024 /* by default, everything gets defined and exported */
1025 do_not_define = 0;
1026
1027 while (*ep != '=')
1028 ++ep;
1029 #ifdef WINDOWS32
1030 if (!unix_path && strneq(envp[i], "PATH=", 5))
1031 unix_path = ep+1;
1032 else if (!windows32_path && !strnicmp(envp[i], "Path=", 5)) {
1033 do_not_define = 1; /* it gets defined after loop exits */
1034 windows32_path = ep+1;
1035 }
1036 #endif
1037 /* The result of pointer arithmetic is cast to unsigned int for
1038 machines where ptrdiff_t is a different size that doesn't widen
1039 the same. */
1040 if (!do_not_define)
1041 define_variable (envp[i], (unsigned int) (ep - envp[i]),
1042 ep + 1, o_env, 1)
1043 /* Force exportation of every variable culled from the environment.
1044 We used to rely on target_environment's v_default code to do this.
1045 But that does not work for the case where an environment variable
1046 is redefined in a makefile with `override'; it should then still
1047 be exported, because it was originally in the environment. */
1048 ->export = v_export;
1049 }
1050 #ifdef WINDOWS32
1051 /*
1052 * Make sure that this particular spelling of 'Path' is available
1053 */
1054 if (windows32_path)
1055 define_variable("Path", 4, windows32_path, o_env, 1)->export = v_export;
1056 else if (unix_path)
1057 define_variable("Path", 4, unix_path, o_env, 1)->export = v_export;
1058 else
1059 define_variable("Path", 4, "", o_env, 1)->export = v_export;
1060
1061 /*
1062 * PATH defaults to Path iff PATH not found and Path is found.
1063 */
1064 if (!unix_path && windows32_path)
1065 define_variable("PATH", 4, windows32_path, o_env, 1)->export = v_export;
1066 #endif
1067 #else /* For Amiga, read the ENV: device, ignoring all dirs */
1068 {
1069 BPTR env, file, old;
1070 char buffer[1024];
1071 int len;
1072 __aligned struct FileInfoBlock fib;
1073
1074 env = Lock ("ENV:", ACCESS_READ);
1075 if (env)
1076 {
1077 old = CurrentDir (DupLock(env));
1078 Examine (env, &fib);
1079
1080 while (ExNext (env, &fib))
1081 {
1082 if (fib.fib_DirEntryType < 0) /* File */
1083 {
1084 /* Define an empty variable. It will be filled in
1085 variable_lookup(). Makes startup quite a bit
1086 faster. */
1087 define_variable (fib.fib_FileName,
1088 strlen (fib.fib_FileName),
1089 "", o_env, 1)->export = v_export;
1090 }
1091 }
1092 UnLock (env);
1093 UnLock(CurrentDir(old));
1094 }
1095 }
1096 #endif
1097
1098 /* Decode the switches. */
1099
1100 decode_env_switches ("MAKEFLAGS", 9);
1101 #if 0
1102 /* People write things like:
1103 MFLAGS="CC=gcc -pipe" "CFLAGS=-g"
1104 and we set the -p, -i and -e switches. Doesn't seem quite right. */
1105 decode_env_switches ("MFLAGS", 6);
1106 #endif
1107 decode_switches (argc, argv, 0);
1108 #ifdef WINDOWS32
1109 if (suspend_flag) {
1110 fprintf(stderr, "%s (pid = %d)\n", argv[0], GetCurrentProcessId());
1111 fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]);
1112 Sleep(30 * 1000);
1113 fprintf(stderr, _("done sleep(30). Continuing.\n"));
1114 }
1115 #endif
1116
1117 decode_debug_flags ();
1118
1119 /* Print version information. */
1120
1121 if (print_version_flag || print_data_base_flag || db_level)
1122 print_version ();
1123
1124 /* `make --version' is supposed to just print the version and exit. */
1125 if (print_version_flag)
1126 die (0);
1127
1128 #ifndef VMS
1129 /* Set the "MAKE_COMMAND" variable to the name we were invoked with.
1130 (If it is a relative pathname with a slash, prepend our directory name
1131 so the result will run the same program regardless of the current dir.
1132 If it is a name with no slash, we can only hope that PATH did not
1133 find it in the current directory.) */
1134 #ifdef WINDOWS32
1135 /*
1136 * Convert from backslashes to forward slashes for
1137 * programs like sh which don't like them. Shouldn't
1138 * matter if the path is one way or the other for
1139 * CreateProcess().
1140 */
1141 if (strpbrk(argv[0], "/:\\") ||
1142 strstr(argv[0], "..") ||
1143 strneq(argv[0], "//", 2))
1144 argv[0] = xstrdup(w32ify(argv[0],1));
1145 #else /* WINDOWS32 */
1146 #if defined (__MSDOS__) || defined (__EMX__)
1147 if (strchr (argv[0], '\\'))
1148 {
1149 char *p;
1150
1151 argv[0] = xstrdup (argv[0]);
1152 for (p = argv[0]; *p; p++)
1153 if (*p == '\\')
1154 *p = '/';
1155 }
1156 /* If argv[0] is not in absolute form, prepend the current
1157 directory. This can happen when Make is invoked by another DJGPP
1158 program that uses a non-absolute name. */
1159 if (current_directory[0] != '\0'
1160 && argv[0] != 0
1161 && (argv[0][0] != '/' && (argv[0][0] == '\0' || argv[0][1] != ':')))
1162 argv[0] = concat (current_directory, "/", argv[0]);
1163 #else /* !__MSDOS__ */
1164 if (current_directory[0] != '\0'
1165 && argv[0] != 0 && argv[0][0] != '/' && strchr (argv[0], '/') != 0)
1166 argv[0] = concat (current_directory, "/", argv[0]);
1167 #endif /* !__MSDOS__ */
1168 #endif /* WINDOWS32 */
1169 #endif
1170
1171 /* The extra indirection through $(MAKE_COMMAND) is done
1172 for hysterical raisins. */
1173 (void) define_variable ("MAKE_COMMAND", 12, argv[0], o_default, 0);
1174 (void) define_variable ("MAKE", 4, "$(MAKE_COMMAND)", o_default, 1);
1175
1176 if (command_variables != 0)
1177 {
1178 struct command_variable *cv;
1179 struct variable *v;
1180 unsigned int len = 0;
1181 char *value, *p;
1182
1183 /* Figure out how much space will be taken up by the command-line
1184 variable definitions. */
1185 for (cv = command_variables; cv != 0; cv = cv->next)
1186 {
1187 v = cv->variable;
1188 len += 2 * strlen (v->name);
1189 if (! v->recursive)
1190 ++len;
1191 ++len;
1192 len += 2 * strlen (v->value);
1193 ++len;
1194 }
1195
1196 /* Now allocate a buffer big enough and fill it. */
1197 p = value = (char *) alloca (len);
1198 for (cv = command_variables; cv != 0; cv = cv->next)
1199 {
1200 v = cv->variable;
1201 p = quote_for_env (p, v->name);
1202 if (! v->recursive)
1203 *p++ = ':';
1204 *p++ = '=';
1205 p = quote_for_env (p, v->value);
1206 *p++ = ' ';
1207 }
1208 p[-1] = '\0'; /* Kill the final space and terminate. */
1209
1210 /* Define an unchangeable variable with a name that no POSIX.2
1211 makefile could validly use for its own variable. */
1212 (void) define_variable ("-*-command-variables-*-", 23,
1213 value, o_automatic, 0);
1214
1215 /* Define the variable; this will not override any user definition.
1216 Normally a reference to this variable is written into the value of
1217 MAKEFLAGS, allowing the user to override this value to affect the
1218 exported value of MAKEFLAGS. In POSIX-pedantic mode, we cannot
1219 allow the user's setting of MAKEOVERRIDES to affect MAKEFLAGS, so
1220 a reference to this hidden variable is written instead. */
1221 (void) define_variable ("MAKEOVERRIDES", 13,
1222 "${-*-command-variables-*-}", o_env, 1);
1223 }
1224
1225 /* If there were -C flags, move ourselves about. */
1226 if (directories != 0)
1227 for (i = 0; directories->list[i] != 0; ++i)
1228 {
1229 char *dir = directories->list[i];
1230 if (dir[0] == '~')
1231 {
1232 char *expanded = tilde_expand (dir);
1233 if (expanded != 0)
1234 dir = expanded;
1235 }
1236 if (chdir (dir) < 0)
1237 pfatal_with_name (dir);
1238 if (dir != directories->list[i])
1239 free (dir);
1240 }
1241
1242 #ifdef WINDOWS32
1243 /*
1244 * THIS BLOCK OF CODE MUST COME AFTER chdir() CALL ABOVE IN ORDER
1245 * TO NOT CONFUSE THE DEPENDENCY CHECKING CODE IN implicit.c.
1246 *
1247 * The functions in dir.c can incorrectly cache information for "."
1248 * before we have changed directory and this can cause file
1249 * lookups to fail because the current directory (.) was pointing
1250 * at the wrong place when it was first evaluated.
1251 */
1252 no_default_sh_exe = !find_and_set_default_shell(NULL);
1253
1254 #endif /* WINDOWS32 */
1255 /* Figure out the level of recursion. */
1256 {
1257 struct variable *v = lookup_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH);
1258 if (v != 0 && v->value[0] != '\0' && v->value[0] != '-')
1259 makelevel = (unsigned int) atoi (v->value);
1260 else
1261 makelevel = 0;
1262 }
1263
1264 /* Except under -s, always do -w in sub-makes and under -C. */
1265 if (!silent_flag && (directories != 0 || makelevel > 0))
1266 print_directory_flag = 1;
1267
1268 /* Let the user disable that with --no-print-directory. */
1269 if (inhibit_print_directory_flag)
1270 print_directory_flag = 0;
1271
1272 /* If -R was given, set -r too (doesn't make sense otherwise!) */
1273 if (no_builtin_variables_flag)
1274 no_builtin_rules_flag = 1;
1275
1276 /* Construct the list of include directories to search. */
1277
1278 construct_include_path (include_directories == 0 ? (char **) 0
1279 : include_directories->list);
1280
1281 /* Figure out where we are now, after chdir'ing. */
1282 if (directories == 0)
1283 /* We didn't move, so we're still in the same place. */
1284 starting_directory = current_directory;
1285 else
1286 {
1287 #ifdef WINDOWS32
1288 if (getcwd_fs (current_directory, GET_PATH_MAX) == 0)
1289 #else
1290 if (getcwd (current_directory, GET_PATH_MAX) == 0)
1291 #endif
1292 {
1293 #ifdef HAVE_GETCWD
1294 perror_with_name ("getcwd: ", "");
1295 #else
1296 error (NILF, "getwd: %s", current_directory);
1297 #endif
1298 starting_directory = 0;
1299 }
1300 else
1301 starting_directory = current_directory;
1302 }
1303
1304 (void) define_variable ("CURDIR", 6, current_directory, o_default, 0);
1305
1306 /* Read any stdin makefiles into temporary files. */
1307
1308 if (makefiles != 0)
1309 {
1310 register unsigned int i;
1311 for (i = 0; i < makefiles->idx; ++i)
1312 if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0')
1313 {
1314 /* This makefile is standard input. Since we may re-exec
1315 and thus re-read the makefiles, we read standard input
1316 into a temporary file and read from that. */
1317 FILE *outfile;
1318 char *template, *tmpdir;
1319
1320 if (stdin_nm)
1321 fatal (NILF, _("Makefile from standard input specified twice."));
1322
1323 #ifdef VMS
1324 # define DEFAULT_TMPDIR "sys$scratch:"
1325 #else
1326 # ifdef P_tmpdir
1327 # define DEFAULT_TMPDIR P_tmpdir
1328 # else
1329 # define DEFAULT_TMPDIR "/tmp"
1330 # endif
1331 #endif
1332 #define DEFAULT_TMPFILE "GmXXXXXX"
1333
1334 if (((tmpdir = getenv ("TMPDIR")) == NULL || *tmpdir == '\0')
1335 #if defined (__MSDOS__) || defined (WINDOWS32) || defined (__EMX__)
1336 /* These are also used commonly on these platforms. */
1337 && ((tmpdir = getenv ("TEMP")) == NULL || *tmpdir == '\0')
1338 && ((tmpdir = getenv ("TMP")) == NULL || *tmpdir == '\0')
1339 #endif
1340 )
1341 tmpdir = DEFAULT_TMPDIR;
1342
1343 template = (char *) alloca (strlen (tmpdir)
1344 + sizeof (DEFAULT_TMPFILE) + 1);
1345 strcpy (template, tmpdir);
1346
1347 #ifdef HAVE_DOS_PATHS
1348 if (strchr ("/\\", template[strlen (template) - 1]) == NULL)
1349 strcat (template, "/");
1350 #else
1351 # ifndef VMS
1352 if (template[strlen (template) - 1] != '/')
1353 strcat (template, "/");
1354 # endif /* !VMS */
1355 #endif /* !HAVE_DOS_PATHS */
1356
1357 strcat (template, DEFAULT_TMPFILE);
1358 outfile = open_tmpfile (&stdin_nm, template);
1359 if (outfile == 0)
1360 pfatal_with_name (_("fopen (temporary file)"));
1361 while (!feof (stdin))
1362 {
1363 char buf[2048];
1364 unsigned int n = fread (buf, 1, sizeof (buf), stdin);
1365 if (n > 0 && fwrite (buf, 1, n, outfile) != n)
1366 pfatal_with_name (_("fwrite (temporary file)"));
1367 }
1368 (void) fclose (outfile);
1369
1370 /* Replace the name that read_all_makefiles will
1371 see with the name of the temporary file. */
1372 makefiles->list[i] = xstrdup (stdin_nm);
1373
1374 /* Make sure the temporary file will not be remade. */
1375 f = enter_file (stdin_nm);
1376 f->updated = 1;
1377 f->update_status = 0;
1378 f->command_state = cs_finished;
1379 /* Can't be intermediate, or it'll be removed too early for
1380 make re-exec. */
1381 f->intermediate = 0;
1382 f->dontcare = 0;
1383 }
1384 }
1385
1386 #ifndef __EMX__ /* Don't use a SIGCHLD handler for OS/2 */
1387 #if defined(MAKE_JOBSERVER) || !defined(HAVE_WAIT_NOHANG)
1388 /* Set up to handle children dying. This must be done before
1389 reading in the makefiles so that `shell' function calls will work.
1390
1391 If we don't have a hanging wait we have to fall back to old, broken
1392 functionality here and rely on the signal handler and counting
1393 children.
1394
1395 If we're using the jobs pipe we need a signal handler so that
1396 SIGCHLD is not ignored; we need it to interrupt the read(2) of the
1397 jobserver pipe in job.c if we're waiting for a token.
1398
1399 If none of these are true, we don't need a signal handler at all. */
1400 {
1401 extern RETSIGTYPE child_handler PARAMS ((int sig));
1402 # if defined SIGCHLD
1403 bsd_signal (SIGCHLD, child_handler);
1404 # endif
1405 # if defined SIGCLD && SIGCLD != SIGCHLD
1406 bsd_signal (SIGCLD, child_handler);
1407 # endif
1408 }
1409 #endif
1410 #endif
1411
1412 /* Let the user send us SIGUSR1 to toggle the -d flag during the run. */
1413 #ifdef SIGUSR1
1414 bsd_signal (SIGUSR1, debug_signal_handler);
1415 #endif
1416
1417 /* Define the initial list of suffixes for old-style rules. */
1418
1419 set_default_suffixes ();
1420
1421 /* Define the file rules for the built-in suffix rules. These will later
1422 be converted into pattern rules. We used to do this in
1423 install_default_implicit_rules, but since that happens after reading
1424 makefiles, it results in the built-in pattern rules taking precedence
1425 over makefile-specified suffix rules, which is wrong. */
1426
1427 install_default_suffix_rules ();
1428
1429 /* Define some internal and special variables. */
1430
1431 define_automatic_variables ();
1432
1433 /* Set up the MAKEFLAGS and MFLAGS variables
1434 so makefiles can look at them. */
1435
1436 define_makeflags (0, 0);
1437
1438 /* Define the default variables. */
1439 define_default_variables ();
1440
1441 /* Read all the makefiles. */
1442
1443 default_file = enter_file (".DEFAULT");
1444
1445 read_makefiles
1446 = read_all_makefiles (makefiles == 0 ? (char **) 0 : makefiles->list);
1447
1448 #ifdef WINDOWS32
1449 /* look one last time after reading all Makefiles */
1450 if (no_default_sh_exe)
1451 no_default_sh_exe = !find_and_set_default_shell(NULL);
1452
1453 if (no_default_sh_exe && job_slots != 1) {
1454 error (NILF, _("Do not specify -j or --jobs if sh.exe is not available."));
1455 error (NILF, _("Resetting make for single job mode."));
1456 job_slots = 1;
1457 }
1458 #endif /* WINDOWS32 */
1459
1460 #if defined (__MSDOS__) || defined (__EMX__)
1461 /* We need to know what kind of shell we will be using. */
1462 {
1463 extern int _is_unixy_shell (const char *_path);
1464 struct variable *shv = lookup_variable ("SHELL", 5);
1465 extern int unixy_shell;
1466 extern char *default_shell;
1467
1468 if (shv && *shv->value)
1469 {
1470 char *shell_path = recursively_expand(shv);
1471
1472 if (shell_path && _is_unixy_shell (shell_path))
1473 unixy_shell = 1;
1474 else
1475 unixy_shell = 0;
1476 if (shell_path)
1477 default_shell = shell_path;
1478 }
1479 }
1480 #endif /* __MSDOS__ || __EMX__ */
1481
1482 /* Decode switches again, in case the variables were set by the makefile. */
1483 decode_env_switches ("MAKEFLAGS", 9);
1484 #if 0
1485 decode_env_switches ("MFLAGS", 6);
1486 #endif
1487
1488 #if defined (__MSDOS__) || defined (__EMX__)
1489 if (job_slots != 1
1490 # ifdef __EMX__
1491 && _osmode != OS2_MODE /* turn off -j if we are in DOS mode */
1492 # endif
1493 )
1494 {
1495 error (NILF,
1496 _("Parallel jobs (-j) are not supported on this platform."));
1497 error (NILF, _("Resetting to single job (-j1) mode."));
1498 job_slots = 1;
1499 }
1500 #endif
1501
1502 #ifdef MAKE_JOBSERVER
1503 /* If the jobserver-fds option is seen, make sure that -j is reasonable. */
1504
1505 if (jobserver_fds)
1506 {
1507 char *cp;
1508
1509 for (i=1; i < jobserver_fds->idx; ++i)
1510 if (!streq (jobserver_fds->list[0], jobserver_fds->list[i]))
1511 fatal (NILF, _("internal error: multiple --jobserver-fds options"));
1512
1513 /* Now parse the fds string and make sure it has the proper format. */
1514
1515 cp = jobserver_fds->list[0];
1516
1517 if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2)
1518 fatal (NILF,
1519 _("internal error: invalid --jobserver-fds string `%s'"), cp);
1520
1521 /* The combination of a pipe + !job_slots means we're using the
1522 jobserver. If !job_slots and we don't have a pipe, we can start
1523 infinite jobs. If we see both a pipe and job_slots >0 that means the
1524 user set -j explicitly. This is broken; in this case obey the user
1525 (ignore the jobserver pipe for this make) but print a message. */
1526
1527 if (job_slots > 0)
1528 error (NILF,
1529 _("warning: -jN forced in submake: disabling jobserver mode."));
1530
1531 /* Create a duplicate pipe, that will be closed in the SIGCHLD
1532 handler. If this fails with EBADF, the parent has closed the pipe
1533 on us because it didn't think we were a submake. If so, print a
1534 warning then default to -j1. */
1535
1536 else if ((job_rfd = dup (job_fds[0])) < 0)
1537 {
1538 if (errno != EBADF)
1539 pfatal_with_name (_("dup jobserver"));
1540
1541 error (NILF,
1542 _("warning: jobserver unavailable: using -j1. Add `+' to parent make rule."));
1543 job_slots = 1;
1544 }
1545
1546 if (job_slots > 0)
1547 {
1548 close (job_fds[0]);
1549 close (job_fds[1]);
1550 job_fds[0] = job_fds[1] = -1;
1551 free (jobserver_fds->list);
1552 free (jobserver_fds);
1553 jobserver_fds = 0;
1554 }
1555 }
1556
1557 /* If we have >1 slot but no jobserver-fds, then we're a top-level make.
1558 Set up the pipe and install the fds option for our children. */
1559
1560 if (job_slots > 1)
1561 {
1562 char c = '+';
1563
1564 if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0)
1565 pfatal_with_name (_("creating jobs pipe"));
1566
1567 /* Every make assumes that it always has one job it can run. For the
1568 submakes it's the token they were given by their parent. For the
1569 top make, we just subtract one from the number the user wants. We
1570 want job_slots to be 0 to indicate we're using the jobserver. */
1571
1572 while (--job_slots)
1573 {
1574 int r;
1575
1576 EINTRLOOP (r, write (job_fds[1], &c, 1));
1577 if (r != 1)
1578 pfatal_with_name (_("init jobserver pipe"));
1579 }
1580
1581 /* Fill in the jobserver_fds struct for our children. */
1582
1583 jobserver_fds = (struct stringlist *)
1584 xmalloc (sizeof (struct stringlist));
1585 jobserver_fds->list = (char **) xmalloc (sizeof (char *));
1586 jobserver_fds->list[0] = xmalloc ((sizeof ("1024")*2)+1);
1587
1588 sprintf (jobserver_fds->list[0], "%d,%d", job_fds[0], job_fds[1]);
1589 jobserver_fds->idx = 1;
1590 jobserver_fds->max = 1;
1591 }
1592 #endif
1593
1594 /* Set up MAKEFLAGS and MFLAGS again, so they will be right. */
1595
1596 define_makeflags (1, 0);
1597
1598 /* Make each `struct dep' point at the `struct file' for the file
1599 depended on. Also do magic for special targets. */
1600
1601 snap_deps ();
1602
1603 /* Convert old-style suffix rules to pattern rules. It is important to
1604 do this before installing the built-in pattern rules below, so that
1605 makefile-specified suffix rules take precedence over built-in pattern
1606 rules. */
1607
1608 convert_to_pattern ();
1609
1610 /* Install the default implicit pattern rules.
1611 This used to be done before reading the makefiles.
1612 But in that case, built-in pattern rules were in the chain
1613 before user-defined ones, so they matched first. */
1614
1615 install_default_implicit_rules ();
1616
1617 /* Compute implicit rule limits. */
1618
1619 count_implicit_rule_limits ();
1620
1621 /* Construct the listings of directories in VPATH lists. */
1622
1623 build_vpath_lists ();
1624
1625 /* Mark files given with -o flags as very old
1626 and as having been updated already, and files given with -W flags as
1627 brand new (time-stamp as far as possible into the future). */
1628
1629 if (old_files != 0)
1630 for (p = old_files->list; *p != 0; ++p)
1631 {
1632 f = enter_command_line_file (*p);
1633 f->last_mtime = f->mtime_before_update = OLD_MTIME;
1634 f->updated = 1;
1635 f->update_status = 0;
1636 f->command_state = cs_finished;
1637 }
1638
1639 if (new_files != 0)
1640 {
1641 for (p = new_files->list; *p != 0; ++p)
1642 {
1643 f = enter_command_line_file (*p);
1644 f->last_mtime = f->mtime_before_update = NEW_MTIME;
1645 }
1646 }
1647
1648 /* Initialize the remote job module. */
1649 remote_setup ();
1650
1651 if (read_makefiles != 0)
1652 {
1653 /* Update any makefiles if necessary. */
1654
1655 FILE_TIMESTAMP *makefile_mtimes = 0;
1656 unsigned int mm_idx = 0;
1657 char **nargv = argv;
1658 int nargc = argc;
1659 int orig_db_level = db_level;
1660
1661 if (! ISDB (DB_MAKEFILES))
1662 db_level = DB_NONE;
1663
1664 DB (DB_BASIC, (_("Updating makefiles....\n")));
1665
1666 /* Remove any makefiles we don't want to try to update.
1667 Also record the current modtimes so we can compare them later. */
1668 {
1669 register struct dep *d, *last;
1670 last = 0;
1671 d = read_makefiles;
1672 while (d != 0)
1673 {
1674 register struct file *f = d->file;
1675 if (f->double_colon)
1676 for (f = f->double_colon; f != NULL; f = f->prev)
1677 {
1678 if (f->deps == 0 && f->cmds != 0)
1679 {
1680 /* This makefile is a :: target with commands, but
1681 no dependencies. So, it will always be remade.
1682 This might well cause an infinite loop, so don't
1683 try to remake it. (This will only happen if
1684 your makefiles are written exceptionally
1685 stupidly; but if you work for Athena, that's how
1686 you write your makefiles.) */
1687
1688 DB (DB_VERBOSE,
1689 (_("Makefile `%s' might loop; not remaking it.\n"),
1690 f->name));
1691
1692 if (last == 0)
1693 read_makefiles = d->next;
1694 else
1695 last->next = d->next;
1696
1697 /* Free the storage. */
1698 free ((char *) d);
1699
1700 d = last == 0 ? read_makefiles : last->next;
1701
1702 break;
1703 }
1704 }
1705 if (f == NULL || !f->double_colon)
1706 {
1707 makefile_mtimes = (FILE_TIMESTAMP *)
1708 xrealloc ((char *) makefile_mtimes,
1709 (mm_idx + 1) * sizeof (FILE_TIMESTAMP));
1710 makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file);
1711 last = d;
1712 d = d->next;
1713 }
1714 }
1715 }
1716
1717 /* Set up `MAKEFLAGS' specially while remaking makefiles. */
1718 define_makeflags (1, 1);
1719
1720 switch (update_goal_chain (read_makefiles, 1))
1721 {
1722 case 1:
1723 /* The only way this can happen is if the user specified -q and asked
1724 * for one of the makefiles to be remade as a target on the command
1725 * line. Since we're not actually updating anything with -q we can
1726 * treat this as "did nothing".
1727 */
1728
1729 case -1:
1730 /* Did nothing. */
1731 break;
1732
1733 case 2:
1734 /* Failed to update. Figure out if we care. */
1735 {
1736 /* Nonzero if any makefile was successfully remade. */
1737 int any_remade = 0;
1738 /* Nonzero if any makefile we care about failed
1739 in updating or could not be found at all. */
1740 int any_failed = 0;
1741 register unsigned int i;
1742 struct dep *d;
1743
1744 for (i = 0, d = read_makefiles; d != 0; ++i, d = d->next)
1745 {
1746 /* Reset the considered flag; we may need to look at the file
1747 again to print an error. */
1748 d->file->considered = 0;
1749
1750 if (d->file->updated)
1751 {
1752 /* This makefile was updated. */
1753 if (d->file->update_status == 0)
1754 {
1755 /* It was successfully updated. */
1756 any_remade |= (file_mtime_no_search (d->file)
1757 != makefile_mtimes[i]);
1758 }
1759 else if (! (d->changed & RM_DONTCARE))
1760 {
1761 FILE_TIMESTAMP mtime;
1762 /* The update failed and this makefile was not
1763 from the MAKEFILES variable, so we care. */
1764 error (NILF, _("Failed to remake makefile `%s'."),
1765 d->file->name);
1766 mtime = file_mtime_no_search (d->file);
1767 any_remade |= (mtime != NONEXISTENT_MTIME
1768 && mtime != makefile_mtimes[i]);
1769 }
1770 }
1771 else
1772 /* This makefile was not found at all. */
1773 if (! (d->changed & RM_DONTCARE))
1774 {
1775 /* This is a makefile we care about. See how much. */
1776 if (d->changed & RM_INCLUDED)
1777 /* An included makefile. We don't need
1778 to die, but we do want to complain. */
1779 error (NILF,
1780 _("Included makefile `%s' was not found."),
1781 dep_name (d));
1782 else
1783 {
1784 /* A normal makefile. We must die later. */
1785 error (NILF, _("Makefile `%s' was not found"),
1786 dep_name (d));
1787 any_failed = 1;
1788 }
1789 }
1790 }
1791 /* Reset this to empty so we get the right error message below. */
1792 read_makefiles = 0;
1793
1794 if (any_remade)
1795 goto re_exec;
1796 if (any_failed)
1797 die (2);
1798 break;
1799 }
1800
1801 case 0:
1802 re_exec:
1803 /* Updated successfully. Re-exec ourselves. */
1804
1805 remove_intermediates (0);
1806
1807 if (print_data_base_flag)
1808 print_data_base ();
1809
1810 log_working_directory (0);
1811
1812 if (makefiles != 0)
1813 {
1814 /* These names might have changed. */
1815 register unsigned int i, j = 0;
1816 for (i = 1; i < argc; ++i)
1817 if (strneq (argv[i], "-f", 2)) /* XXX */
1818 {
1819 char *p = &argv[i][2];
1820 if (*p == '\0')
1821 argv[++i] = makefiles->list[j];
1822 else
1823 argv[i] = concat ("-f", makefiles->list[j], "");
1824 ++j;
1825 }
1826 }
1827
1828 /* Add -o option for the stdin temporary file, if necessary. */
1829 if (stdin_nm)
1830 {
1831 nargv = (char **) xmalloc ((nargc + 2) * sizeof (char *));
1832 bcopy ((char *) argv, (char *) nargv, argc * sizeof (char *));
1833 nargv[nargc++] = concat ("-o", stdin_nm, "");
1834 nargv[nargc] = 0;
1835 }
1836
1837 if (directories != 0 && directories->idx > 0)
1838 {
1839 char bad;
1840 if (directory_before_chdir != 0)
1841 {
1842 if (chdir (directory_before_chdir) < 0)
1843 {
1844 perror_with_name ("chdir", "");
1845 bad = 1;
1846 }
1847 else
1848 bad = 0;
1849 }
1850 else
1851 bad = 1;
1852 if (bad)
1853 fatal (NILF, _("Couldn't change back to original directory."));
1854 }
1855
1856 #ifndef _AMIGA
1857 for (p = environ; *p != 0; ++p)
1858 if ((*p)[MAKELEVEL_LENGTH] == '='
1859 && strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH))
1860 {
1861 /* The SGI compiler apparently can't understand
1862 the concept of storing the result of a function
1863 in something other than a local variable. */
1864 char *sgi_loses;
1865 sgi_loses = (char *) alloca (40);
1866 *p = sgi_loses;
1867 sprintf (*p, "%s=%u", MAKELEVEL_NAME, makelevel);
1868 break;
1869 }
1870 #else /* AMIGA */
1871 {
1872 char buffer[256];
1873 int len;
1874
1875 len = GetVar (MAKELEVEL_NAME, buffer, sizeof (buffer), GVF_GLOBAL_ONLY);
1876
1877 if (len != -1)
1878 {
1879 sprintf (buffer, "%u", makelevel);
1880 SetVar (MAKELEVEL_NAME, buffer, -1, GVF_GLOBAL_ONLY);
1881 }
1882 }
1883 #endif
1884
1885 if (ISDB (DB_BASIC))
1886 {
1887 char **p;
1888 fputs (_("Re-executing:"), stdout);
1889 for (p = nargv; *p != 0; ++p)
1890 printf (" %s", *p);
1891 putchar ('\n');
1892 }
1893
1894 fflush (stdout);
1895 fflush (stderr);
1896
1897 /* Close the dup'd jobserver pipe if we opened one. */
1898 if (job_rfd >= 0)
1899 close (job_rfd);
1900
1901 #ifdef _AMIGA
1902 exec_command (nargv);
1903 exit (0);
1904 #elif defined (__EMX__)
1905 {
1906 /* It is not possible to use execve() here because this
1907 would cause the parent process to be terminated with
1908 exit code 0 before the child process has been terminated.
1909 Therefore it may be the best solution simply to spawn the
1910 child process including all file handles and to wait for its
1911 termination. */
1912 int pid;
1913 int status;
1914 pid = child_execute_job(0, 1, nargv, environ);
1915
1916 /* is this loop really necessary? */
1917 do {
1918 pid = wait(&status);
1919 } while(pid <= 0);
1920 /* use the exit code of the child process */
1921 exit(WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
1922 }
1923 #else
1924 exec_command (nargv, environ);
1925 #endif
1926 /* NOTREACHED */
1927
1928 default:
1929 #define BOGUS_UPDATE_STATUS 0
1930 assert (BOGUS_UPDATE_STATUS);
1931 break;
1932 }
1933
1934 db_level = orig_db_level;
1935 }
1936
1937 /* Set up `MAKEFLAGS' again for the normal targets. */
1938 define_makeflags (1, 0);
1939
1940 /* If there is a temp file from reading a makefile from stdin, get rid of
1941 it now. */
1942 if (stdin_nm && unlink (stdin_nm) < 0 && errno != ENOENT)
1943 perror_with_name (_("unlink (temporary file): "), stdin_nm);
1944
1945 {
1946 int status;
1947
1948 /* If there were no command-line goals, use the default. */
1949 if (goals == 0)
1950 {
1951 if (default_goal_file != 0)
1952 {
1953 goals = (struct dep *) xmalloc (sizeof (struct dep));
1954 goals->next = 0;
1955 goals->name = 0;
1956 goals->ignore_mtime = 0;
1957 goals->file = default_goal_file;
1958 }
1959 }
1960 else
1961 lastgoal->next = 0;
1962
1963 if (!goals)
1964 {
1965 if (read_makefiles == 0)
1966 fatal (NILF, _("No targets specified and no makefile found"));
1967
1968 fatal (NILF, _("No targets"));
1969 }
1970
1971 /* Update the goals. */
1972
1973 DB (DB_BASIC, (_("Updating goal targets....\n")));
1974
1975 switch (update_goal_chain (goals, 0))
1976 {
1977 case -1:
1978 /* Nothing happened. */
1979 case 0:
1980 /* Updated successfully. */
1981 status = MAKE_SUCCESS;
1982 break;
1983 case 1:
1984 /* We are under -q and would run some commands. */
1985 status = MAKE_TROUBLE;
1986 break;
1987 case 2:
1988 /* Updating failed. POSIX.2 specifies exit status >1 for this;
1989 but in VMS, there is only success and failure. */
1990 status = MAKE_FAILURE;
1991 break;
1992 default:
1993 abort ();
1994 }
1995
1996 /* If we detected some clock skew, generate one last warning */
1997 if (clock_skew_detected)
1998 error (NILF,
1999 _("warning: Clock skew detected. Your build may be incomplete."));
2000
2001 /* Exit. */
2002 die (status);
2003 }
2004
2005 return 0;
2006 }
2007
2008 /* Parsing of arguments, decoding of switches. */
2009
2010 static char options[1 + sizeof (switches) / sizeof (switches[0]) * 3];
2011 static struct option long_options[(sizeof (switches) / sizeof (switches[0])) +
2012 (sizeof (long_option_aliases) /
2013 sizeof (long_option_aliases[0]))];
2014
2015 /* Fill in the string and vector for getopt. */
2016 static void
2017 init_switches (void)
2018 {
2019 register char *p;
2020 register int c;
2021 register unsigned int i;
2022
2023 if (options[0] != '\0')
2024 /* Already done. */
2025 return;
2026
2027 p = options;
2028
2029 /* Return switch and non-switch args in order, regardless of
2030 POSIXLY_CORRECT. Non-switch args are returned as option 1. */
2031 *p++ = '-';
2032
2033 for (i = 0; switches[i].c != '\0'; ++i)
2034 {
2035 long_options[i].name = (switches[i].long_name == 0 ? "" :
2036 switches[i].long_name);
2037 long_options[i].flag = 0;
2038 long_options[i].val = switches[i].c;
2039 if (short_option (switches[i].c))
2040 *p++ = switches[i].c;
2041 switch (switches[i].type)
2042 {
2043 case flag:
2044 case flag_off:
2045 case ignore:
2046 long_options[i].has_arg = no_argument;
2047 break;
2048
2049 case string:
2050 case positive_int:
2051 case floating:
2052 if (short_option (switches[i].c))
2053 *p++ = ':';
2054 if (switches[i].noarg_value != 0)
2055 {
2056 if (short_option (switches[i].c))
2057 *p++ = ':';
2058 long_options[i].has_arg = optional_argument;
2059 }
2060 else
2061 long_options[i].has_arg = required_argument;
2062 break;
2063 }
2064 }
2065 *p = '\0';
2066 for (c = 0; c < (sizeof (long_option_aliases) /
2067 sizeof (long_option_aliases[0]));
2068 ++c)
2069 long_options[i++] = long_option_aliases[c];
2070 long_options[i].name = 0;
2071 }
2072
2073 static void
2074 handle_non_switch_argument (char *arg, int env)
2075 {
2076 /* Non-option argument. It might be a variable definition. */
2077 struct variable *v;
2078 if (arg[0] == '-' && arg[1] == '\0')
2079 /* Ignore plain `-' for compatibility. */
2080 return;
2081 v = try_variable_definition (0, arg, o_command, 0);
2082 if (v != 0)
2083 {
2084 /* It is indeed a variable definition. Record a pointer to
2085 the variable for later use in define_makeflags. */
2086 struct command_variable *cv
2087 = (struct command_variable *) xmalloc (sizeof (*cv));
2088 cv->variable = v;
2089 cv->next = command_variables;
2090 command_variables = cv;
2091 }
2092 else if (! env)
2093 {
2094 /* Not an option or variable definition; it must be a goal
2095 target! Enter it as a file and add it to the dep chain of
2096 goals. */
2097 struct file *f = enter_command_line_file (arg);
2098 f->cmd_target = 1;
2099
2100 if (goals == 0)
2101 {
2102 goals = (struct dep *) xmalloc (sizeof (struct dep));
2103 lastgoal = goals;
2104 }
2105 else
2106 {
2107 lastgoal->next = (struct dep *) xmalloc (sizeof (struct dep));
2108 lastgoal = lastgoal->next;
2109 }
2110 lastgoal->name = 0;
2111 lastgoal->file = f;
2112 lastgoal->ignore_mtime = 0;
2113
2114 {
2115 /* Add this target name to the MAKECMDGOALS variable. */
2116 struct variable *v;
2117 char *value;
2118
2119 v = lookup_variable ("MAKECMDGOALS", 12);
2120 if (v == 0)
2121 value = f->name;
2122 else
2123 {
2124 /* Paste the old and new values together */
2125 unsigned int oldlen, newlen;
2126
2127 oldlen = strlen (v->value);
2128 newlen = strlen (f->name);
2129 value = (char *) alloca (oldlen + 1 + newlen + 1);
2130 bcopy (v->value, value, oldlen);
2131 value[oldlen] = ' ';
2132 bcopy (f->name, &value[oldlen + 1], newlen + 1);
2133 }
2134 define_variable ("MAKECMDGOALS", 12, value, o_default, 0);
2135 }
2136 }
2137 }
2138
2139 /* Print a nice usage method. */
2140
2141 static void
2142 print_usage (int bad)
2143 {
2144 extern char *make_host;
2145 const char *const *cpp;
2146 FILE *usageto;
2147
2148 if (print_version_flag)
2149 print_version ();
2150
2151 usageto = bad ? stderr : stdout;
2152
2153 fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program);
2154
2155 for (cpp = usage; *cpp; ++cpp)
2156 fputs (_(*cpp), usageto);
2157
2158 if (!remote_description || *remote_description == '\0')
2159 fprintf (usageto, _("\nThis program built for %s\n"), make_host);
2160 else
2161 fprintf (usageto, _("\nThis program built for %s (%s)\n"),
2162 make_host, remote_description);
2163
2164 fprintf (usageto, _("Report bugs to <bug-make@gnu.org>\n"));
2165 }
2166
2167 /* Decode switches from ARGC and ARGV.
2168 They came from the environment if ENV is nonzero. */
2169
2170 static void
2171 decode_switches (int argc, char **argv, int env)
2172 {
2173 int bad = 0;
2174 register const struct command_switch *cs;
2175 register struct stringlist *sl;
2176 register int c;
2177
2178 /* getopt does most of the parsing for us.
2179 First, get its vectors set up. */
2180
2181 init_switches ();
2182
2183 /* Let getopt produce error messages for the command line,
2184 but not for options from the environment. */
2185 opterr = !env;
2186 /* Reset getopt's state. */
2187 optind = 0;
2188
2189 while (optind < argc)
2190 {
2191 /* Parse the next argument. */
2192 c = getopt_long (argc, argv, options, long_options, (int *) 0);
2193 if (c == EOF)
2194 /* End of arguments, or "--" marker seen. */
2195 break;
2196 else if (c == 1)
2197 /* An argument not starting with a dash. */
2198 handle_non_switch_argument (optarg, env);
2199 else if (c == '?')
2200 /* Bad option. We will print a usage message and die later.
2201 But continue to parse the other options so the user can
2202 see all he did wrong. */
2203 bad = 1;
2204 else
2205 for (cs = switches; cs->c != '\0'; ++cs)
2206 if (cs->c == c)
2207 {
2208 /* Whether or not we will actually do anything with
2209 this switch. We test this individually inside the
2210 switch below rather than just once outside it, so that
2211 options which are to be ignored still consume args. */
2212 int doit = !env || cs->env;
2213
2214 switch (cs->type)
2215 {
2216 default:
2217 abort ();
2218
2219 case ignore:
2220 break;
2221
2222 case flag:
2223 case flag_off:
2224 if (doit)
2225 *(int *) cs->value_ptr = cs->type == flag;
2226 break;
2227
2228 case string:
2229 if (!doit)
2230 break;
2231
2232 if (optarg == 0)
2233 optarg = cs->noarg_value;
2234
2235 sl = *(struct stringlist **) cs->value_ptr;
2236 if (sl == 0)
2237 {
2238 sl = (struct stringlist *)
2239 xmalloc (sizeof (struct stringlist));
2240 sl->max = 5;
2241 sl->idx = 0;
2242 sl->list = (char **) xmalloc (5 * sizeof (char *));
2243 *(struct stringlist **) cs->value_ptr = sl;
2244 }
2245 else if (sl->idx == sl->max - 1)
2246 {
2247 sl->max += 5;
2248 sl->list = (char **)
2249 xrealloc ((char *) sl->list,
2250 sl->max * sizeof (char *));
2251 }
2252 sl->list[sl->idx++] = optarg;
2253 sl->list[sl->idx] = 0;
2254 break;
2255
2256 case positive_int:
2257 /* See if we have an option argument; if we do require that
2258 it's all digits, not something like "10foo". */
2259 if (optarg == 0 && argc > optind)
2260 {
2261 const char *cp;
2262 for (cp=argv[optind]; ISDIGIT (cp[0]); ++cp)
2263 ;
2264 if (cp[0] == '\0')
2265 optarg = argv[optind++];
2266 }
2267
2268 if (!doit)
2269 break;
2270
2271 if (optarg != 0)
2272 {
2273 int i = atoi (optarg);
2274 const char *cp;
2275
2276 /* Yes, I realize we're repeating this in some cases. */
2277 for (cp = optarg; ISDIGIT (cp[0]); ++cp)
2278 ;
2279
2280 if (i < 1 || cp[0] != '\0')
2281 {
2282 error (NILF, _("the `-%c' option requires a positive integral argument"),
2283 cs->c);
2284 bad = 1;
2285 }
2286 else
2287 *(unsigned int *) cs->value_ptr = i;
2288 }
2289 else
2290 *(unsigned int *) cs->value_ptr
2291 = *(unsigned int *) cs->noarg_value;
2292 break;
2293
2294 #ifndef NO_FLOAT
2295 case floating:
2296 if (optarg == 0 && optind < argc
2297 && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.'))
2298 optarg = argv[optind++];
2299
2300 if (doit)
2301 *(double *) cs->value_ptr
2302 = (optarg != 0 ? atof (optarg)
2303 : *(double *) cs->noarg_value);
2304
2305 break;
2306 #endif
2307 }
2308
2309 /* We've found the switch. Stop looking. */
2310 break;
2311 }
2312 }
2313
2314 /* There are no more options according to getting getopt, but there may
2315 be some arguments left. Since we have asked for non-option arguments
2316 to be returned in order, this only happens when there is a "--"
2317 argument to prevent later arguments from being options. */
2318 while (optind < argc)
2319 handle_non_switch_argument (argv[optind++], env);
2320
2321
2322 if (!env && (bad || print_usage_flag))
2323 {
2324 print_usage (bad);
2325 die (bad ? 2 : 0);
2326 }
2327 }
2328
2329 /* Decode switches from environment variable ENVAR (which is LEN chars long).
2330 We do this by chopping the value into a vector of words, prepending a
2331 dash to the first word if it lacks one, and passing the vector to
2332 decode_switches. */
2333
2334 static void
2335 decode_env_switches (char *envar, unsigned int len)
2336 {
2337 char *varref = (char *) alloca (2 + len + 2);
2338 char *value, *p;
2339 int argc;
2340 char **argv;
2341
2342 /* Get the variable's value. */
2343 varref[0] = '$';
2344 varref[1] = '(';
2345 bcopy (envar, &varref[2], len);
2346 varref[2 + len] = ')';
2347 varref[2 + len + 1] = '\0';
2348 value = variable_expand (varref);
2349
2350 /* Skip whitespace, and check for an empty value. */
2351 value = next_token (value);
2352 len = strlen (value);
2353 if (len == 0)
2354 return;
2355
2356 /* Allocate a vector that is definitely big enough. */
2357 argv = (char **) alloca ((1 + len + 1) * sizeof (char *));
2358
2359 /* Allocate a buffer to copy the value into while we split it into words
2360 and unquote it. We must use permanent storage for this because
2361 decode_switches may store pointers into the passed argument words. */
2362 p = (char *) xmalloc (2 * len);
2363
2364 /* getopt will look at the arguments starting at ARGV[1].
2365 Prepend a spacer word. */
2366 argv[0] = 0;
2367 argc = 1;
2368 argv[argc] = p;
2369 while (*value != '\0')
2370 {
2371 if (*value == '\\' && value[1] != '\0')
2372 ++value; /* Skip the backslash. */
2373 else if (isblank ((unsigned char)*value))
2374 {
2375 /* End of the word. */
2376 *p++ = '\0';
2377 argv[++argc] = p;
2378 do
2379 ++value;
2380 while (isblank ((unsigned char)*value));
2381 continue;
2382 }
2383 *p++ = *value++;
2384 }
2385 *p = '\0';
2386 argv[++argc] = 0;
2387
2388 if (argv[1][0] != '-' && strchr (argv[1], '=') == 0)
2389 /* The first word doesn't start with a dash and isn't a variable
2390 definition. Add a dash and pass it along to decode_switches. We
2391 need permanent storage for this in case decode_switches saves
2392 pointers into the value. */
2393 argv[1] = concat ("-", argv[1], "");
2394
2395 /* Parse those words. */
2396 decode_switches (argc, argv, 1);
2397 }
2398
2399 /* Quote the string IN so that it will be interpreted as a single word with
2400 no magic by decode_env_switches; also double dollar signs to avoid
2401 variable expansion in make itself. Write the result into OUT, returning
2402 the address of the next character to be written.
2403 Allocating space for OUT twice the length of IN is always sufficient. */
2404
2405 static char *
2406 quote_for_env (char *out, char *in)
2407 {
2408 while (*in != '\0')
2409 {
2410 if (*in == '$')
2411 *out++ = '$';
2412 else if (isblank ((unsigned char)*in) || *in == '\\')
2413 *out++ = '\\';
2414 *out++ = *in++;
2415 }
2416
2417 return out;
2418 }
2419
2420 /* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the
2421 command switches. Include options with args if ALL is nonzero.
2422 Don't include options with the `no_makefile' flag set if MAKEFILE. */
2423
2424 static void
2425 define_makeflags (int all, int makefile)
2426 {
2427 static const char ref[] = "$(MAKEOVERRIDES)";
2428 static const char posixref[] = "$(-*-command-variables-*-)";
2429 register const struct command_switch *cs;
2430 char *flagstring;
2431 register char *p;
2432 unsigned int words;
2433 struct variable *v;
2434
2435 /* We will construct a linked list of `struct flag's describing
2436 all the flags which need to go in MAKEFLAGS. Then, once we
2437 know how many there are and their lengths, we can put them all
2438 together in a string. */
2439
2440 struct flag
2441 {
2442 struct flag *next;
2443 const struct command_switch *cs;
2444 char *arg;
2445 };
2446 struct flag *flags = 0;
2447 unsigned int flagslen = 0;
2448 #define ADD_FLAG(ARG, LEN) \
2449 do { \
2450 struct flag *new = (struct flag *) alloca (sizeof (struct flag)); \
2451 new->cs = cs; \
2452 new->arg = (ARG); \
2453 new->next = flags; \
2454 flags = new; \
2455 if (new->arg == 0) \
2456 ++flagslen; /* Just a single flag letter. */ \
2457 else \
2458 flagslen += 1 + 1 + 1 + 1 + 3 * (LEN); /* " -x foo" */ \
2459 if (!short_option (cs->c)) \
2460 /* This switch has no single-letter version, so we use the long. */ \
2461 flagslen += 2 + strlen (cs->long_name); \
2462 } while (0)
2463
2464 for (cs = switches; cs->c != '\0'; ++cs)
2465 if (cs->toenv && (!makefile || !cs->no_makefile))
2466 switch (cs->type)
2467 {
2468 default:
2469 abort ();
2470
2471 case ignore:
2472 break;
2473
2474 case flag:
2475 case flag_off:
2476 if (!*(int *) cs->value_ptr == (cs->type == flag_off)
2477 && (cs->default_value == 0
2478 || *(int *) cs->value_ptr != *(int *) cs->default_value))
2479 ADD_FLAG (0, 0);
2480 break;
2481
2482 case positive_int:
2483 if (all)
2484 {
2485 if ((cs->default_value != 0
2486 && (*(unsigned int *) cs->value_ptr
2487 == *(unsigned int *) cs->default_value)))
2488 break;
2489 else if (cs->noarg_value != 0
2490 && (*(unsigned int *) cs->value_ptr ==
2491 *(unsigned int *) cs->noarg_value))
2492 ADD_FLAG ("", 0); /* Optional value omitted; see below. */
2493 else if (cs->c == 'j')
2494 /* Special case for `-j'. */
2495 ADD_FLAG ("1", 1);
2496 else
2497 {
2498 char *buf = (char *) alloca (30);
2499 sprintf (buf, "%u", *(unsigned int *) cs->value_ptr);
2500 ADD_FLAG (buf, strlen (buf));
2501 }
2502 }
2503 break;
2504
2505 #ifndef NO_FLOAT
2506 case floating:
2507 if (all)
2508 {
2509 if (cs->default_value != 0
2510 && (*(double *) cs->value_ptr
2511 == *(double *) cs->default_value))
2512 break;
2513 else if (cs->noarg_value != 0
2514 && (*(double *) cs->value_ptr
2515 == *(double *) cs->noarg_value))
2516 ADD_FLAG ("", 0); /* Optional value omitted; see below. */
2517 else
2518 {
2519 char *buf = (char *) alloca (100);
2520 sprintf (buf, "%g", *(double *) cs->value_ptr);
2521 ADD_FLAG (buf, strlen (buf));
2522 }
2523 }
2524 break;
2525 #endif
2526
2527 case string:
2528 if (all)
2529 {
2530 struct stringlist *sl = *(struct stringlist **) cs->value_ptr;
2531 if (sl != 0)
2532 {
2533 /* Add the elements in reverse order, because
2534 all the flags get reversed below; and the order
2535 matters for some switches (like -I). */
2536 register unsigned int i = sl->idx;
2537 while (i-- > 0)
2538 ADD_FLAG (sl->list[i], strlen (sl->list[i]));
2539 }
2540 }
2541 break;
2542 }
2543
2544 flagslen += 4 + sizeof posixref; /* Four more for the possible " -- ". */
2545
2546 #undef ADD_FLAG
2547
2548 /* Construct the value in FLAGSTRING.
2549 We allocate enough space for a preceding dash and trailing null. */
2550 flagstring = (char *) alloca (1 + flagslen + 1);
2551 bzero (flagstring, 1 + flagslen + 1);
2552 p = flagstring;
2553 words = 1;
2554 *p++ = '-';
2555 while (flags != 0)
2556 {
2557 /* Add the flag letter or name to the string. */
2558 if (short_option (flags->cs->c))
2559 *p++ = flags->cs->c;
2560 else
2561 {
2562 if (*p != '-')
2563 {
2564 *p++ = ' ';
2565 *p++ = '-';
2566 }
2567 *p++ = '-';
2568 strcpy (p, flags->cs->long_name);
2569 p += strlen (p);
2570 }
2571 if (flags->arg != 0)
2572 {
2573 /* A flag that takes an optional argument which in this case is
2574 omitted is specified by ARG being "". We must distinguish
2575 because a following flag appended without an intervening " -"
2576 is considered the arg for the first. */
2577 if (flags->arg[0] != '\0')
2578 {
2579 /* Add its argument too. */
2580 *p++ = !short_option (flags->cs->c) ? '=' : ' ';
2581 p = quote_for_env (p, flags->arg);
2582 }
2583 ++words;
2584 /* Write a following space and dash, for the next flag. */
2585 *p++ = ' ';
2586 *p++ = '-';
2587 }
2588 else if (!short_option (flags->cs->c))
2589 {
2590 ++words;
2591 /* Long options must each go in their own word,
2592 so we write the following space and dash. */
2593 *p++ = ' ';
2594 *p++ = '-';
2595 }
2596 flags = flags->next;
2597 }
2598
2599 /* Define MFLAGS before appending variable definitions. */
2600
2601 if (p == &flagstring[1])
2602 /* No flags. */
2603 flagstring[0] = '\0';
2604 else if (p[-1] == '-')
2605 {
2606 /* Kill the final space and dash. */
2607 p -= 2;
2608 *p = '\0';
2609 }
2610 else
2611 /* Terminate the string. */
2612 *p = '\0';
2613
2614 /* Since MFLAGS is not parsed for flags, there is no reason to
2615 override any makefile redefinition. */
2616 (void) define_variable ("MFLAGS", 6, flagstring, o_env, 1);
2617
2618 if (all && command_variables != 0)
2619 {
2620 /* Now write a reference to $(MAKEOVERRIDES), which contains all the
2621 command-line variable definitions. */
2622
2623 if (p == &flagstring[1])
2624 /* No flags written, so elide the leading dash already written. */
2625 p = flagstring;
2626 else
2627 {
2628 /* Separate the variables from the switches with a "--" arg. */
2629 if (p[-1] != '-')
2630 {
2631 /* We did not already write a trailing " -". */
2632 *p++ = ' ';
2633 *p++ = '-';
2634 }
2635 /* There is a trailing " -"; fill it out to " -- ". */
2636 *p++ = '-';
2637 *p++ = ' ';
2638 }
2639
2640 /* Copy in the string. */
2641 if (posix_pedantic)
2642 {
2643 bcopy (posixref, p, sizeof posixref - 1);
2644 p += sizeof posixref - 1;
2645 }
2646 else
2647 {
2648 bcopy (ref, p, sizeof ref - 1);
2649 p += sizeof ref - 1;
2650 }
2651 }
2652 else if (p == &flagstring[1])
2653 {
2654 words = 0;
2655 --p;
2656 }
2657 else if (p[-1] == '-')
2658 /* Kill the final space and dash. */
2659 p -= 2;
2660 /* Terminate the string. */
2661 *p = '\0';
2662
2663 v = define_variable ("MAKEFLAGS", 9,
2664 /* If there are switches, omit the leading dash
2665 unless it is a single long option with two
2666 leading dashes. */
2667 &flagstring[(flagstring[0] == '-'
2668 && flagstring[1] != '-')
2669 ? 1 : 0],
2670 /* This used to use o_env, but that lost when a
2671 makefile defined MAKEFLAGS. Makefiles set
2672 MAKEFLAGS to add switches, but we still want
2673 to redefine its value with the full set of
2674 switches. Of course, an override or command
2675 definition will still take precedence. */
2676 o_file, 1);
2677 if (! all)
2678 /* The first time we are called, set MAKEFLAGS to always be exported.
2679 We should not do this again on the second call, because that is
2680 after reading makefiles which might have done `unexport MAKEFLAGS'. */
2681 v->export = v_export;
2682 }
2683
2684 /* Print version information. */
2685
2686 static void
2687 print_version (void)
2688 {
2689 static int printed_version = 0;
2690
2691 char *precede = print_data_base_flag ? "# " : "";
2692
2693 if (printed_version)
2694 /* Do it only once. */
2695 return;
2696
2697 /* Print this untranslated. The coding standards recommend translating the
2698 (C) to the copyright symbol, but this string is going to change every
2699 year, and none of the rest of it should be translated (including the
2700 word "Copyright", so it hardly seems worth it. */
2701
2702 printf ("%sGNU Make %s\n\
2703 %sCopyright (C) 2002 Free Software Foundation, Inc.\n",
2704 precede, version_string, precede);
2705
2706 printf (_("%sThis is free software; see the source for copying conditions.\n\
2707 %sThere is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n\
2708 %sPARTICULAR PURPOSE.\n"),
2709 precede, precede, precede);
2710
2711 printed_version = 1;
2712
2713 /* Flush stdout so the user doesn't have to wait to see the
2714 version information while things are thought about. */
2715 fflush (stdout);
2716 }
2717
2718 /* Print a bunch of information about this and that. */
2719
2720 static void
2721 print_data_base (void)
2722 {
2723 time_t when;
2724
2725 when = time ((time_t *) 0);
2726 printf (_("\n# Make data base, printed on %s"), ctime (&when));
2727
2728 print_variable_data_base ();
2729 print_dir_data_base ();
2730 print_rule_data_base ();
2731 print_file_data_base ();
2732 print_vpath_data_base ();
2733
2734 when = time ((time_t *) 0);
2735 printf (_("\n# Finished Make data base on %s\n"), ctime (&when));
2736 }
2737
2738 /* Exit with STATUS, cleaning up as necessary. */
2739
2740 void
2741 die (int status)
2742 {
2743 static char dying = 0;
2744
2745 if (!dying)
2746 {
2747 int err;
2748
2749 dying = 1;
2750
2751 if (print_version_flag)
2752 print_version ();
2753
2754 /* Wait for children to die. */
2755 for (err = (status != 0); job_slots_used > 0; err = 0)
2756 reap_children (1, err);
2757
2758 /* Let the remote job module clean up its state. */
2759 remote_cleanup ();
2760
2761 /* Remove the intermediate files. */
2762 remove_intermediates (0);
2763
2764 if (print_data_base_flag)
2765 print_data_base ();
2766
2767 /* Try to move back to the original directory. This is essential on
2768 MS-DOS (where there is really only one process), and on Unix it
2769 puts core files in the original directory instead of the -C
2770 directory. Must wait until after remove_intermediates(), or unlinks
2771 of relative pathnames fail. */
2772 if (directory_before_chdir != 0)
2773 chdir (directory_before_chdir);
2774
2775 log_working_directory (0);
2776 }
2777
2778 exit (status);
2779 }
2780
2781 /* Write a message indicating that we've just entered or
2782 left (according to ENTERING) the current directory. */
2783
2784 void
2785 log_working_directory (int entering)
2786 {
2787 static int entered = 0;
2788
2789 /* Print nothing without the flag. Don't print the entering message
2790 again if we already have. Don't print the leaving message if we
2791 haven't printed the entering message. */
2792 if (! print_directory_flag || entering == entered)
2793 return;
2794
2795 entered = entering;
2796
2797 if (print_data_base_flag)
2798 fputs ("# ", stdout);
2799
2800 /* Use entire sentences to give the translators a fighting chance. */
2801
2802 if (makelevel == 0)
2803 if (starting_directory == 0)
2804 if (entering)
2805 printf (_("%s: Entering an unknown directory\n"), program);
2806 else
2807 printf (_("%s: Leaving an unknown directory\n"), program);
2808 else
2809 if (entering)
2810 printf (_("%s: Entering directory `%s'\n"),
2811 program, starting_directory);
2812 else
2813 printf (_("%s: Leaving directory `%s'\n"),
2814 program, starting_directory);
2815 else
2816 if (starting_directory == 0)
2817 if (entering)
2818 printf (_("%s[%u]: Entering an unknown directory\n"),
2819 program, makelevel);
2820 else
2821 printf (_("%s[%u]: Leaving an unknown directory\n"),
2822 program, makelevel);
2823 else
2824 if (entering)
2825 printf (_("%s[%u]: Entering directory `%s'\n"),
2826 program, makelevel, starting_directory);
2827 else
2828 printf (_("%s[%u]: Leaving directory `%s'\n"),
2829 program, makelevel, starting_directory);
2830 }

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26