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