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