VirtualBox

source: kBuild/trunk/src/gmake/main.c@ 218

Last change on this file since 218 was 218, checked in by bird, 20 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette