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