gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 This paragraph is here to try to keep Sun CC from dying.
  21 The number of chars here seems crucial!!!!  */
  22
  23 /* This program is the user interface to the C compiler and possibly to
  24 other compilers.  It is used because compilation is a complicated procedure
  25 which involves running several programs and passing temporary files between
  26 them, forwarding the users switches to those programs selectively,
  27 and deleting the temporary files at the end.
  28
  29 CC recognizes how to compile each input file by suffixes in the file names.
  30 Once it knows which kind of compilation to perform, the procedure for
  31 compilation is specified by a string called a "spec".  */
  32 \f
  33 #include <sys/types.h>
  34 #include <ctype.h>
  35 #include <signal.h>
  36 #include <sys/stat.h>
  37 #include <sys/file.h>   /* May get R_OK, etc. on some systems.  */
  38
  39 #include "config.h"
  40 #include "obstack.h"
  41 #ifdef __STDC__
  42 #include <stdarg.h>
  43 #else
  44 #include <varargs.h>
  45 #endif
  46 #include <stdio.h>
  47
  48 #ifndef R_OK
  49 #define R_OK 4
  50 #define W_OK 2
  51 #define X_OK 1
  52 #endif
  53
  54 /* Add prototype support.  */
  55 #ifndef PROTO
  56 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
  57 #define PROTO(ARGS) ARGS
  58 #else
  59 #define PROTO(ARGS) ()
  60 #endif
  61 #endif
  62
  63 #ifndef VPROTO
  64 #ifdef __STDC__
  65 #define PVPROTO(ARGS)           ARGS
  66 #define VPROTO(ARGS)            ARGS
  67 #define VA_START(va_list,var)   va_start(va_list,var)
  68 #else
  69 #define PVPROTO(ARGS)           ()
  70 #define VPROTO(ARGS)            (va_alist) va_dcl
  71 #define VA_START(va_list,var)   va_start(va_list)
  72 #endif
  73 #endif
  74
  75 /* Define a generic NULL if one hasn't already been defined.  */
  76
  77 #ifndef NULL
  78 #define NULL 0
  79 #endif
  80
  81 #ifndef GENERIC_PTR
  82 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
  83 #define GENERIC_PTR void *
  84 #else
  85 #define GENERIC_PTR char *
  86 #endif
  87 #endif
  88
  89 #ifndef NULL_PTR
  90 #define NULL_PTR ((GENERIC_PTR)0)
  91 #endif
  92
  93 #ifdef USG
  94 #define vfork fork
  95 #endif /* USG */
  96
  97 /* On MSDOS, write temp files in current dir
  98    because there's no place else we can expect to use.  */
  99 #ifdef __MSDOS__
 100 #ifndef P_tmpdir
 101 #define P_tmpdir "."
 102 #endif
 103 #endif
 104
 105 /* Test if something is a normal file.  */
 106 #ifndef S_ISREG
 107 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 108 #endif
 109
 110 /* Test if something is a directory.  */
 111 #ifndef S_ISDIR
 112 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 113 #endif
 114
 115 /* By default there is no special suffix for executables.  */
 116 #ifndef EXECUTABLE_SUFFIX
 117 #define EXECUTABLE_SUFFIX ""
 118 #endif
 119
 120 /* By default, colon separates directories in a path.  */
 121 #ifndef PATH_SEPARATOR
 122 #define PATH_SEPARATOR ':'
 123 #endif
 124
 125 #define obstack_chunk_alloc xmalloc
 126 #define obstack_chunk_free free
 127
 128 extern void free ();
 129 extern char *getenv ();
 130
 131 extern int errno, sys_nerr;
 132 #if defined(bsd4_4)
 133 extern const char *const sys_errlist[];
 134 #else
 135 extern char *sys_errlist[];
 136 #endif
 137
 138 extern int execv (), execvp ();
 139
 140 /* If a stage of compilation returns an exit status >= 1,
 141    compilation of that file ceases.  */
 142
 143 #define MIN_FATAL_STATUS 1
 144
 145 /* Flag saying to print the full filename of this file
 146    as found through our usual search mechanism.  */
 147
 148 static char *print_file_name = NULL;
 149
 150 /* As print_file_name, but search for executable file. */
 151
 152 static char *print_prog_name = NULL;
 153
 154 /* Flag indicating whether we should print the command and arguments */
 155
 156 static int verbose_flag;
 157
 158 /* Nonzero means write "temp" files in source directory
 159    and use the source file's name in them, and don't delete them.  */
 160
 161 static int save_temps_flag;
 162
 163 /* The compiler version.  */
 164
 165 static char *compiler_version;
 166
 167 /* The target version specified with -V */
 168
 169 static char *spec_version = DEFAULT_TARGET_VERSION;
 170
 171 /* The target machine specified with -b.  */
 172
 173 static char *spec_machine = DEFAULT_TARGET_MACHINE;
 174
 175 /* Nonzero if cross-compiling.
 176    When -b is used, the value comes from the `specs' file.  */
 177
 178 #ifdef CROSS_COMPILE
 179 static int cross_compile = 1;
 180 #else
 181 static int cross_compile = 0;
 182 #endif
 183
 184 /* The number of errors that have occurred; the link phase will not be
 185    run if this is non-zero.  */
 186 static int error_count = 0;
 187
 188 /* This is the obstack which we use to allocate many strings.  */
 189
 190 static struct obstack obstack;
 191
 192 /* This is the obstack to build an environment variable to pass to
 193    collect2 that describes all of the relevant switches of what to
 194    pass the compiler in building the list of pointers to constructors
 195    and destructors.  */
 196
 197 static struct obstack collect_obstack;
 198
 199 extern char *version_string;
 200
 201 /* Forward declaration for prototypes.  */
 202 struct path_prefix;
 203
 204 static void set_spec            PROTO((char *, char *));
 205 static struct compiler *lookup_compiler PROTO((char *, int, char *));
 206 static char *find_a_file        PROTO((struct path_prefix *, char *, int));
 207 static void add_prefix          PROTO((struct path_prefix *, char *, int, int, int *));
 208 static char *skip_whitespace    PROTO((char *));
 209 static void record_temp_file    PROTO((char *, int, int));
 210 static int check_live_switch    PROTO((int, int));
 211 static char *handle_braces      PROTO((char *));
 212 static char *save_string        PROTO((char *, int));
 213 static char *concat             PROTO((char *, char *, char *));
 214 static int do_spec              PROTO((char *));
 215 static int do_spec_1            PROTO((char *, int, char *));
 216 static char *find_file          PROTO((char *));
 217 static int is_directory         PROTO((char *, char *, int));
 218 static void validate_switches   PROTO((char *));
 219 static void validate_all_switches PROTO((void));
 220 static void give_switch         PROTO((int, int));
 221 static void pfatal_with_name    PROTO((char *));
 222 static void perror_with_name    PROTO((char *));
 223 static void perror_exec         PROTO((char *));
 224 #ifdef HAVE_VPRINTF
 225 static void fatal               PVPROTO((char *, ...));
 226 static void error               PVPROTO((char *, ...));
 227 #else
 228 /* We must not provide any prototype here, even if ANSI C.  */
 229 static void fatal               PROTO(());
 230 static void error               PROTO(());
 231 #endif
 232
 233 void fancy_abort ();
 234 char *xmalloc ();
 235 char *xrealloc ();
 236 \f
 237 /* Specs are strings containing lines, each of which (if not blank)
 238 is made up of a program name, and arguments separated by spaces.
 239 The program name must be exact and start from root, since no path
 240 is searched and it is unreliable to depend on the current working directory.
 241 Redirection of input or output is not supported; the subprograms must
 242 accept filenames saying what files to read and write.
 243
 244 In addition, the specs can contain %-sequences to substitute variable text
 245 or for conditional text.  Here is a table of all defined %-sequences.
 246 Note that spaces are not generated automatically around the results of
 247 expanding these sequences; therefore, you can concatenate them together
 248 or with constant text in a single argument.
 249
 250  %%     substitute one % into the program name or argument.
 251  %i     substitute the name of the input file being processed.
 252  %b     substitute the basename of the input file being processed.
 253         This is the substring up to (and not including) the last period
 254         and not including the directory.
 255  %g     substitute the temporary-file-name-base.  This is a string chosen
 256         once per compilation.  Different temporary file names are made by
 257         concatenation of constant strings on the end, as in `%g.s'.
 258         %g also has the same effect of %d.
 259  %u     like %g, but make the temporary file name unique.
 260  %U     returns the last file name generated with %u.
 261  %d     marks the argument containing or following the %d as a
 262         temporary file name, so that that file will be deleted if CC exits
 263         successfully.  Unlike %g, this contributes no text to the argument.
 264  %w     marks the argument containing or following the %w as the
 265         "output file" of this compilation.  This puts the argument
 266         into the sequence of arguments that %o will substitute later.
 267  %W{...}
 268         like %{...} but mark last argument supplied within
 269         as a file to be deleted on failure.
 270  %o     substitutes the names of all the output files, with spaces
 271         automatically placed around them.  You should write spaces
 272         around the %o as well or the results are undefined.
 273         %o is for use in the specs for running the linker.
 274         Input files whose names have no recognized suffix are not compiled
 275         at all, but they are included among the output files, so they will
 276         be linked.
 277  %p     substitutes the standard macro predefinitions for the
 278         current target machine.  Use this when running cpp.
 279  %P     like %p, but puts `__' before and after the name of each macro.
 280         (Except macros that already have __.)
 281         This is for ANSI C.
 282  %I     Substitute a -iprefix option made from GCC_EXEC_PREFIX.
 283  %s     current argument is the name of a library or startup file of some sort.
 284         Search for that file in a standard list of directories
 285         and substitute the full name found.
 286  %eSTR  Print STR as an error message.  STR is terminated by a newline.
 287         Use this when inconsistent options are detected.
 288  %x{OPTION}     Accumulate an option for %X.
 289  %X     Output the accumulated linker options specified by compilations.
 290  %Y     Output the accumulated assembler options specified by compilations.
 291  %v1    Substitute the major version number of GCC.
 292         (For version 2.5.n, this is 2.)
 293  %v2    Substitute the minor version number of GCC.
 294         (For version 2.5.n, this is 5.)
 295  %a     process ASM_SPEC as a spec.
 296         This allows config.h to specify part of the spec for running as.
 297  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
 298         used here.  This can be used to run a post-processor after the
 299         assembler has done it's job.
 300  %D     Dump out a -L option for each directory in startfile_prefix.
 301  %l     process LINK_SPEC as a spec.
 302  %L     process LIB_SPEC as a spec.
 303  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
 304  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
 305  %c     process SIGNED_CHAR_SPEC as a spec.
 306  %C     process CPP_SPEC as a spec.  A capital C is actually used here.
 307  %1     process CC1_SPEC as a spec.
 308  %2     process CC1PLUS_SPEC as a spec.
 309  %|     output "-" if the input for the current command is coming from a pipe.
 310  %*     substitute the variable part of a matched option.  (See below.)
 311         Note that each comma in the substituted string is replaced by
 312         a single space.
 313  %{S}   substitutes the -S switch, if that switch was given to CC.
 314         If that switch was not specified, this substitutes nothing.
 315         Here S is a metasyntactic variable.
 316  %{S*}  substitutes all the switches specified to CC whose names start
 317         with -S.  This is used for -o, -D, -I, etc; switches that take
 318         arguments.  CC considers `-o foo' as being one switch whose
 319         name starts with `o'.  %{o*} would substitute this text,
 320         including the space; thus, two arguments would be generated.
 321  %{S*:X} substitutes X if one or more switches whose names start with -S are
 322         specified to CC.  Note that the tail part of the -S option
 323         (i.e. the part matched by the `*') will be substituted for each
 324         occurrence of %* within X.
 325  %{S:X} substitutes X, but only if the -S switch was given to CC.
 326  %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
 327  %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
 328  %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
 329  %{.S:X} substitutes X, but only if processing a file with suffix S.
 330  %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
 331  %(Spec) processes a specification defined in a specs file as *Spec:
 332  %[Spec] as above, but put __ around -D arguments
 333
 334 The conditional text X in a %{S:X} or %{!S:X} construct may contain
 335 other nested % constructs or spaces, or even newlines.  They are
 336 processed as usual, as described above.
 337
 338 The -O, -f, -m, and -w switches are handled specifically in these
 339 constructs.  If another value of -O or the negated form of a -f, -m, or
 340 -W switch is found later in the command line, the earlier switch
 341 value is ignored.
 342
 343 The character | is used to indicate that a command should be piped to
 344 the following command, but only if -pipe is specified.
 345
 346 Note that it is built into CC which switches take arguments and which
 347 do not.  You might think it would be useful to generalize this to
 348 allow each compiler's spec to say which switches take arguments.  But
 349 this cannot be done in a consistent fashion.  CC cannot even decide
 350 which input files have been specified without knowing which switches
 351 take arguments, and it must know which input files to compile in order
 352 to tell which compilers to run.
 353
 354 CC also knows implicitly that arguments starting in `-l' are to be
 355 treated as compiler output files, and passed to the linker in their
 356 proper position among the other output files.  */
 357 \f
 358 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1.  */
 359
 360 /* config.h can define ASM_SPEC to provide extra args to the assembler
 361    or extra switch-translations.  */
 362 #ifndef ASM_SPEC
 363 #define ASM_SPEC ""
 364 #endif
 365
 366 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 367    the assembler has run.  */
 368 #ifndef ASM_FINAL_SPEC
 369 #define ASM_FINAL_SPEC ""
 370 #endif
 371
 372 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 373    or extra switch-translations.  */
 374 #ifndef CPP_SPEC
 375 #define CPP_SPEC ""
 376 #endif
 377
 378 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 379    or extra switch-translations.  */
 380 #ifndef CC1_SPEC
 381 #define CC1_SPEC ""
 382 #endif
 383
 384 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 385    or extra switch-translations.  */
 386 #ifndef CC1PLUS_SPEC
 387 #define CC1PLUS_SPEC ""
 388 #endif
 389
 390 /* config.h can define LINK_SPEC to provide extra args to the linker
 391    or extra switch-translations.  */
 392 #ifndef LINK_SPEC
 393 #define LINK_SPEC ""
 394 #endif
 395
 396 /* config.h can define LIB_SPEC to override the default libraries.  */
 397 #ifndef LIB_SPEC
 398 #define LIB_SPEC "%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
 399 #endif
 400
 401 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 402 #ifndef STARTFILE_SPEC
 403 #define STARTFILE_SPEC  \
 404   "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
 405 #endif
 406
 407 /* config.h can define SWITCHES_NEED_SPACES to control passing -o and -L.
 408    Make the string nonempty to require spaces there.  */
 409 #ifndef SWITCHES_NEED_SPACES
 410 #define SWITCHES_NEED_SPACES ""
 411 #endif
 412
 413 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
 414 #ifndef ENDFILE_SPEC
 415 #define ENDFILE_SPEC ""
 416 #endif
 417
 418 /* This spec is used for telling cpp whether char is signed or not.  */
 419 #ifndef SIGNED_CHAR_SPEC
 420 /* Use #if rather than ?:
 421    because MIPS C compiler rejects like ?: in initializers.  */
 422 #if DEFAULT_SIGNED_CHAR
 423 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
 424 #else
 425 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
 426 #endif
 427 #endif
 428
 429 static char *cpp_spec = CPP_SPEC;
 430 static char *cpp_predefines = CPP_PREDEFINES;
 431 static char *cc1_spec = CC1_SPEC;
 432 static char *cc1plus_spec = CC1PLUS_SPEC;
 433 static char *signed_char_spec = SIGNED_CHAR_SPEC;
 434 static char *asm_spec = ASM_SPEC;
 435 static char *asm_final_spec = ASM_FINAL_SPEC;
 436 static char *link_spec = LINK_SPEC;
 437 static char *lib_spec = LIB_SPEC;
 438 static char *endfile_spec = ENDFILE_SPEC;
 439 static char *startfile_spec = STARTFILE_SPEC;
 440 static char *switches_need_spaces = SWITCHES_NEED_SPACES;
 441
 442 /* This defines which switch letters take arguments.  */
 443
 444 #ifndef SWITCH_TAKES_ARG
 445 #define SWITCH_TAKES_ARG(CHAR)      \
 446   ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
 447    || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
 448    || (CHAR) == 'I' || (CHAR) == 'm' \
 449    || (CHAR) == 'L' || (CHAR) == 'A')
 450 #endif
 451
 452 /* This defines which multi-letter switches take arguments.  */
 453
 454 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR)              \
 455  (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext")      \
 456   || !strcmp (STR, "Tbss") || !strcmp (STR, "include")  \
 457   || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
 458   || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
 459   || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore"))
 460
 461 #ifndef WORD_SWITCH_TAKES_ARG
 462 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
 463 #endif
 464 \f
 465 /* Record the mapping from file suffixes for compilation specs.  */
 466
 467 struct compiler
 468 {
 469   char *suffix;                 /* Use this compiler for input files
 470                                    whose names end in this suffix.  */
 471
 472   char *spec[4];                /* To use this compiler, concatenate these
 473                                    specs and pass to do_spec.  */
 474 };
 475
 476 /* Pointer to a vector of `struct compiler' that gives the spec for
 477    compiling a file, based on its suffix.
 478    A file that does not end in any of these suffixes will be passed
 479    unchanged to the loader and nothing else will be done to it.
 480
 481    An entry containing two 0s is used to terminate the vector.
 482
 483    If multiple entries match a file, the last matching one is used.  */
 484
 485 static struct compiler *compilers;
 486
 487 /* Number of entries in `compilers', not counting the null terminator.  */
 488
 489 static int n_compilers;
 490
 491 /* The default list of file name suffixes and their compilation specs.  */
 492
 493 static struct compiler default_compilers[] =
 494 {
 495   {".c", "@c"},
 496   {"@c",
 497    "cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 498         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 499         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
 500         -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 501         %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 502         %{!undef:%{!ansi:%p} %P} %{trigraphs} \
 503         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 504         %{traditional-cpp:-traditional}\
 505         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 506         %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 507    "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
 508                    %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a}\
 509                    %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
 510                    %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
 511                    %{aux-info*}\
 512                    %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 513                    %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 514               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 515                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 516                       %{!pipe:%g.s} %A\n }}}}"},
 517   {"-",
 518    "%{E:cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 519         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 520         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
 521         -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 522         %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 523         %{!undef:%{!ansi:%p} %P} %{trigraphs}\
 524         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 525         %{traditional-cpp:-traditional}\
 526         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 527         %i %W{o*}}\
 528     %{!E:%e-E required when input is from standard input}"},
 529   {".m", "@objective-c"},
 530   {"@objective-c",
 531    "cpp -lang-objc %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 532         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 533         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
 534         -undef -D__OBJC__ -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 535          %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 536         %{!undef:%{!ansi:%p} %P} %{trigraphs}\
 537         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 538         %{traditional-cpp:-traditional}\
 539         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 540         %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 541    "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \
 542                    %{!Q:-quiet} -dumpbase %b.m %{d*} %{m*} %{a}\
 543                    %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
 544                    %{traditional} %{v:-version} %{pg:-p} %{p} %{f*} \
 545                    -lang-objc %{gen-decls} \
 546                    %{aux-info*}\
 547                    %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 548                    %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 549               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 550                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 551                       %{!pipe:%g.s} %A\n }}}}"},
 552   {".h", "@c-header"},
 553   {"@c-header",
 554    "%{!E:%eCompilation of header file requested} \
 555     cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 556         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 557          %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
 558         -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 559          %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 560         %{!undef:%{!ansi:%p} %P} %{trigraphs}\
 561         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 562         %{traditional-cpp:-traditional}\
 563         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 564         %i %W{o*}"},
 565   {".cc", "@c++"},
 566   {".cxx", "@c++"},
 567   {".cpp", "@c++"},
 568   {".C", "@c++"},
 569   {"@c++",
 570    "cpp -lang-c++ %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 571         %{C:%{!E:%eGNU C++ does not support -C without using -E}}\
 572         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
 573         -undef -D__GNUC__=%v1 -D__GNUG__=%v1 -D__cplusplus -D__GNUC_MINOR__=%v2\
 574         %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!undef:%{!ansi:%p} %P}\
 575         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 576         %{traditional-cpp:-traditional} %{trigraphs}\
 577         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 578         %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 579    "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\
 580                             %{!Q:-quiet} -dumpbase %b.cc %{d*} %{m*} %{a}\
 581                             %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 582                             %{traditional} %{v:-version} %{pg:-p} %{p}\
 583                             %{f*} %{+e*} %{aux-info*}\
 584                             %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 585                             %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}}|\n\
 586               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 587                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 588                       %{!pipe:%g.s} %A\n }}}}"},
 589   {".i", "@cpp-output"},
 590   {"@cpp-output",
 591    "%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a}\
 592                         %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 593                         %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
 594                         %{aux-info*}\
 595                         %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 596                         %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 597                      %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 598                              %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 599                              %{!pipe:%g.s} %A\n }}}}"},
 600   {".ii", "@c++-cpp-output"},
 601   {"@c++-cpp-output",
 602    "%{!M:%{!MM:%{!E:cc1plus %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
 603                             %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 604                             %{traditional} %{v:-version} %{pg:-p} %{p}\
 605                             %{f*} %{+e*} %{aux-info*}\
 606                             %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 607                             %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 608                     %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 609                             %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 610                             %{!pipe:%g.s} %A\n }}}}"},
 611   {".s", "@assembler"},
 612   {"@assembler",
 613    "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 614                             %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 615                             %i %A\n }}}}"},
 616   {".S", "@assembler-with-cpp"},
 617   {"@assembler-with-cpp",
 618    "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 619         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 620         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{trigraphs} \
 621         -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
 622         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 623         %{traditional-cpp:-traditional}\
 624         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 625         %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 626    "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 627                     %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 628                     %{!pipe:%g.s} %A\n }}}}"},
 629   {".ads", "@ada"},
 630   {".adb", "@ada"},
 631   {".ada", "@ada"},
 632   {"@ada",
 633    "%{!M:%{!MM:%{!E:gnat1 %{k8:-gnatk8} %{w:-gnatws} %{!Q:-quiet}\
 634                            -dumpbase %b.ada %{g*} %{O*} %{p} %{pg:-p} %{f*}\
 635                           %{d*}\
 636                           %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 637                           %i %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 638                     %{!S:%{!gnatc:%{!gnats:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 639                                               %{c:%W{o*}%{!o*:-o %w%b.o}}\
 640                                               %{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n}}}}}} "},
 641   /* Mark end of table */
 642   {0, 0}
 643 };
 644
 645 /* Number of elements in default_compilers, not counting the terminator.  */
 646
 647 static int n_default_compilers
 648   = (sizeof default_compilers / sizeof (struct compiler)) - 1;
 649
 650 /* Here is the spec for running the linker, after compiling all files.  */
 651
 652 /* -u* was put back because both BSD and SysV seem to support it.  */
 653 /* %{static:} simply prevents an error message if the target machine
 654    doesn't handle -static.  */
 655 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
 656    scripts which exist in user specified directories, or in standard
 657    directories.  */
 658 #ifdef LINK_LIBGCC_SPECIAL_1
 659 /* Have gcc do the search for libgcc.a, but generate -L options as usual.  */
 660 static char *link_command_spec = "\
 661 %{!fsyntax-only: \
 662  %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
 663                         %{r} %{s} %{t} %{u*} %{x} %{z}\
 664                         %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
 665                         %{L*} %D %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
 666 #else
 667 #ifdef LINK_LIBGCC_SPECIAL
 668 /* Have gcc do the search for libgcc.a, and don't generate -L options.  */
 669 static char *link_command_spec = "\
 670 %{!fsyntax-only: \
 671  %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
 672                         %{r} %{s} %{t} %{u*} %{x} %{z}\
 673                         %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
 674                         %{L*} %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
 675 #else
 676 /* Use -L and have the linker do the search for -lgcc.  */
 677 static char *link_command_spec = "\
 678 %{!fsyntax-only: \
 679  %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
 680                         %{r} %{s} %{t} %{u*} %{x} %{z}\
 681                         %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
 682                         %{L*} %D %{T*} %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}}";
 683 #endif
 684 #endif
 685
 686 /* A vector of options to give to the linker.
 687    These options are accumulated by -Xlinker and -Wl,
 688    and substituted into the linker command with %X.  */
 689 static int n_linker_options;
 690 static char **linker_options;
 691
 692 /* A vector of options to give to the assembler.
 693    These options are accumulated by -Wa,
 694    and substituted into the assembler command with %X.  */
 695 static int n_assembler_options;
 696 static char **assembler_options;
 697 \f
 698 /* Define how to map long options into short ones.  */
 699
 700 /* This structure describes one mapping.  */
 701 struct option_map
 702 {
 703   /* The long option's name.  */
 704   char *name;
 705   /* The equivalent short option.  */
 706   char *equivalent;
 707   /* Argument info.  A string of flag chars; NULL equals no options.
 708      a => argument required.
 709      o => argument optional.
 710      j => join argument to equivalent, making one word.
 711      * => allow other text after NAME as an argument.  */
 712   char *arg_info;
 713 };
 714
 715 /* This is the table of mappings.  Mappings are tried sequentially
 716    for each option encountered; the first one that matches, wins.  */
 717
 718 struct option_map option_map[] =
 719  {
 720    {"--profile-blocks", "-a", 0},
 721    {"--target", "-b", "a"},
 722    {"--compile", "-c", 0},
 723    {"--dump", "-d", "a"},
 724    {"--entry", "-e", 0},
 725    {"--debug", "-g", "oj"},
 726    {"--include", "-include", "a"},
 727    {"--imacros", "-imacros", "a"},
 728    {"--include-prefix", "-iprefix", "a"},
 729    {"--include-directory-after", "-idirafter", "a"},
 730    {"--include-with-prefix", "-iwithprefix", "a"},
 731    {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
 732    {"--include-with-prefix-after", "-iwithprefix", "a"},
 733    {"--machine-", "-m", "*j"},
 734    {"--machine", "-m", "aj"},
 735    {"--no-standard-includes", "-nostdinc", 0},
 736    {"--no-standard-libraries", "-nostdlib", 0},
 737    {"--no-precompiled-includes", "-noprecomp", 0},
 738    {"--output", "-o", "a"},
 739    {"--profile", "-p", 0},
 740    {"--quiet", "-q", 0},
 741    {"--silent", "-q", 0},
 742    {"--force-link", "-u", "a"},
 743    {"--verbose", "-v", 0},
 744    {"--version", "-dumpversion", 0},
 745    {"--no-warnings", "-w", 0},
 746    {"--language", "-x", "a"},
 747
 748    {"--assert", "-A", "a"},
 749    {"--prefix", "-B", "a"},
 750    {"--comments", "-C", 0},
 751    {"--define-macro", "-D", "a"},
 752    {"--preprocess", "-E", 0},
 753    {"--trace-includes", "-H", 0},
 754    {"--include-directory", "-I", "a"},
 755    {"--include-barrier", "-I-", 0},
 756    {"--library-directory", "-L", "a"},
 757    {"--dependencies", "-M", 0},
 758    {"--user-dependencies", "-MM", 0},
 759    {"--write-dependencies", "-MD", 0},
 760    {"--write-user-dependencies", "-MMD", 0},
 761    {"--optimize", "-O", "oj"},
 762    {"--no-line-commands", "-P", 0},
 763    {"--assemble", "-S", 0},
 764    {"--undefine-macro", "-U", "a"},
 765    {"--use-version", "-V", "a"},
 766    {"--for-assembler", "-Wa", "a"},
 767    {"--extra-warnings", "-W", 0},
 768    {"--all-warnings", "-Wall", 0},
 769    {"--warn-", "-W", "*j"},
 770    {"--for-linker", "-Xlinker", "a"},
 771
 772    {"--ansi", "-ansi", 0},
 773    {"--traditional", "-traditional", 0},
 774    {"--traditional-cpp", "-traditional-cpp", 0},
 775    {"--trigraphs", "-trigraphs", 0},
 776    {"--pipe", "-pipe", 0},
 777    {"--dumpbase", "-dumpbase", "a"},
 778    {"--pedantic", "-pedantic", 0},
 779    {"--pedantic-errors", "-pedantic-errors", 0},
 780    {"--save-temps", "-save-temps", 0},
 781    {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
 782    {"--print-file-name", "-print-file-name=", "aj"},
 783    {"--print-prog-name", "-print-prog-name=", "aj"},
 784    {"--static", "-static", 0},
 785    {"--shared", "-shared", 0},
 786    {"--symbolic", "-symbolic", 0},
 787    {"--", "-f", "*j"}
 788  };
 789 \f
 790 /* Translate the options described by *ARGCP and *ARGVP.
 791    Make a new vector and store it back in *ARGVP,
 792    and store its length in *ARGVC.  */
 793
 794 static void
 795 translate_options (argcp, argvp)
 796      int *argcp;
 797      char ***argvp;
 798 {
 799   int i, j;
 800   int argc = *argcp;
 801   char **argv = *argvp;
 802   char **newv = (char **) xmalloc ((argc + 2) * 2 * sizeof (char *));
 803   int newindex = 0;
 804
 805   i = 0;
 806   newv[newindex++] = argv[i++];
 807
 808   while (i < argc)
 809     {
 810       /* Translate -- options.  */
 811       if (argv[i][0] == '-' && argv[i][1] == '-')
 812         {
 813           /* Find a mapping that applies to this option.  */
 814           for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
 815             {
 816               int optlen = strlen (option_map[j].name);
 817               int complen = strlen (argv[i]);
 818               char *arginfo = option_map[j].arg_info;
 819
 820               if (arginfo == 0)
 821                 arginfo = "";
 822               if (complen > optlen)
 823                 complen = optlen;
 824               if (!strncmp (argv[i], option_map[j].name, complen))
 825                 {
 826                   int extra = strlen (argv[i]) > optlen;
 827                   char *arg = 0;
 828
 829                   if (extra)
 830                     {
 831                       /* If the option has an argument, accept that.  */
 832                       if (argv[i][optlen] == '=')
 833                         arg = argv[i] + optlen + 1;
 834                       /* If this mapping allows extra text at end of name,
 835                          accept that as "argument".  */
 836                       else if (index (arginfo, '*') != 0)
 837                         arg = argv[i] + optlen;
 838                       /* Otherwise, extra text at end means mismatch.
 839                          Try other mappings.  */
 840                       else
 841                         continue;
 842                     }
 843                   else if (index (arginfo, '*') != 0)
 844                     error ("Incomplete `%s' option", option_map[j].name);
 845
 846                   /* Handle arguments.  */
 847                   if (index (arginfo, 'o') != 0)
 848                     {
 849                       if (arg == 0)
 850                         {
 851                           if (i + 1 == argc)
 852                             error ("Missing argument to `%s' option",
 853                                    option_map[j].name);
 854                           arg = argv[++i];
 855                         }
 856                     }
 857                   else if (index (arginfo, '*') != 0)
 858                     ;
 859                   else if (index (arginfo, 'a') == 0)
 860                     {
 861                       if (arg != 0)
 862                         error ("Extraneous argument to `%s' option",
 863                                option_map[j].name);
 864                       arg = 0;
 865                     }
 866
 867                   /* Store the translation as one argv elt or as two.  */
 868                   if (arg != 0 && index (arginfo, 'j') != 0)
 869                     newv[newindex++] = concat (option_map[j].equivalent,
 870                                                arg, "");
 871                   else if (arg != 0)
 872                     {
 873                       newv[newindex++] = option_map[j].equivalent;
 874                       newv[newindex++] = arg;
 875                     }
 876                   else
 877                     newv[newindex++] = option_map[j].equivalent;
 878
 879                   break;
 880                 }
 881             }
 882           i++;
 883         }
 884       /* Handle old-fashioned options--just copy them through,
 885          with their arguments.  */
 886       else if (argv[i][0] == '-')
 887         {
 888           char *p = argv[i] + 1;
 889           int c = *p;
 890           int nskip = 1;
 891
 892           if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
 893             nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
 894           else if (WORD_SWITCH_TAKES_ARG (p))
 895             nskip += WORD_SWITCH_TAKES_ARG (p);
 896           else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
 897                    && p[1] == 0)
 898             nskip += 1;
 899           else if (! strcmp (p, "Xlinker"))
 900             nskip += 1;
 901
 902           while (nskip > 0)
 903             {
 904               newv[newindex++] = argv[i++];
 905               nskip--;
 906             }
 907         }
 908       else
 909         /* Ordinary operands, or +e options.  */
 910         newv[newindex++] = argv[i++];
 911     }
 912
 913   newv[newindex] = 0;
 914
 915   *argvp = newv;
 916   *argcp = newindex;
 917 }
 918 \f
 919 /* Read compilation specs from a file named FILENAME,
 920    replacing the default ones.
 921
 922    A suffix which starts with `*' is a definition for
 923    one of the machine-specific sub-specs.  The "suffix" should be
 924    *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
 925    The corresponding spec is stored in asm_spec, etc.,
 926    rather than in the `compilers' vector.
 927
 928    Anything invalid in the file is a fatal error.  */
 929
 930 static void
 931 read_specs (filename)
 932      char *filename;
 933 {
 934   int desc;
 935   struct stat statbuf;
 936   char *buffer;
 937   register char *p;
 938
 939   if (verbose_flag)
 940     fprintf (stderr, "Reading specs from %s\n", filename);
 941
 942   /* Open and stat the file.  */
 943   desc = open (filename, 0, 0);
 944   if (desc < 0)
 945     pfatal_with_name (filename);
 946   if (stat (filename, &statbuf) < 0)
 947     pfatal_with_name (filename);
 948
 949   /* Read contents of file into BUFFER.  */
 950   buffer = xmalloc ((unsigned) statbuf.st_size + 1);
 951   read (desc, buffer, (unsigned) statbuf.st_size);
 952   buffer[statbuf.st_size] = 0;
 953   close (desc);
 954
 955   /* Scan BUFFER for specs, putting them in the vector.  */
 956   p = buffer;
 957   while (1)
 958     {
 959       char *suffix;
 960       char *spec;
 961       char *in, *out, *p1, *p2;
 962
 963       /* Advance P in BUFFER to the next nonblank nocomment line.  */
 964       p = skip_whitespace (p);
 965       if (*p == 0)
 966         break;
 967
 968       /* Find the colon that should end the suffix.  */
 969       p1 = p;
 970       while (*p1 && *p1 != ':' && *p1 != '\n') p1++;
 971       /* The colon shouldn't be missing.  */
 972       if (*p1 != ':')
 973         fatal ("specs file malformed after %d characters", p1 - buffer);
 974       /* Skip back over trailing whitespace.  */
 975       p2 = p1;
 976       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) p2--;
 977       /* Copy the suffix to a string.  */
 978       suffix = save_string (p, p2 - p);
 979       /* Find the next line.  */
 980       p = skip_whitespace (p1 + 1);
 981       if (p[1] == 0)
 982         fatal ("specs file malformed after %d characters", p - buffer);
 983       p1 = p;
 984       /* Find next blank line.  */
 985       while (*p1 && !(*p1 == '\n' && p1[1] == '\n')) p1++;
 986       /* Specs end at the blank line and do not include the newline.  */
 987       spec = save_string (p, p1 - p);
 988       p = p1;
 989
 990       /* Delete backslash-newline sequences from the spec.  */
 991       in = spec;
 992       out = spec;
 993       while (*in != 0)
 994         {
 995           if (in[0] == '\\' && in[1] == '\n')
 996             in += 2;
 997           else if (in[0] == '#')
 998             {
 999               while (*in && *in != '\n') in++;
1000             }
1001           else
1002             *out++ = *in++;
1003         }
1004       *out = 0;
1005
1006       if (suffix[0] == '*')
1007         {
1008           if (! strcmp (suffix, "*link_command"))
1009             link_command_spec = spec;
1010           else
1011             set_spec (suffix + 1, spec);
1012         }
1013       else
1014         {
1015           /* Add this pair to the vector.  */
1016           compilers
1017             = ((struct compiler *)
1018                xrealloc (compilers, (n_compilers + 2) * sizeof (struct compiler)));
1019           compilers[n_compilers].suffix = suffix;
1020           bzero (compilers[n_compilers].spec,
1021                  sizeof compilers[n_compilers].spec);
1022           compilers[n_compilers].spec[0] = spec;
1023           n_compilers++;
1024           bzero (&compilers[n_compilers], sizeof compilers[n_compilers]);
1025         }
1026
1027       if (*suffix == 0)
1028         link_command_spec = spec;
1029     }
1030
1031   if (link_command_spec == 0)
1032     fatal ("spec file has no spec for linking");
1033 }
1034
1035 static char *
1036 skip_whitespace (p)
1037      char *p;
1038 {
1039   while (1)
1040     {
1041       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1042          be considered whitespace.  */
1043       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1044         return p + 1;
1045       else if (*p == '\n' || *p == ' ' || *p == '\t')
1046         p++;
1047       else if (*p == '#')
1048         {
1049           while (*p != '\n') p++;
1050           p++;
1051         }
1052       else
1053         break;
1054     }
1055
1056   return p;
1057 }
1058 \f
1059 /* Structure to keep track of the specs that have been defined so far.  These
1060    are accessed using %(specname) or %[specname] in a compiler or link spec. */
1061
1062 struct spec_list
1063 {
1064   char *name;                 /* Name of the spec. */
1065   char *spec;                 /* The spec itself. */
1066   struct spec_list *next;     /* Next spec in linked list. */
1067 };
1068
1069 /* List of specs that have been defined so far. */
1070
1071 static struct spec_list *specs = (struct spec_list *) 0;
1072 \f
1073 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1074    removed; If the spec starts with a + then SPEC is added to the end of the
1075    current spec. */
1076
1077 static void
1078 set_spec (name, spec)
1079      char *name;
1080      char *spec;
1081 {
1082   struct spec_list *sl;
1083   char *old_spec;
1084
1085   /* See if the spec already exists */
1086   for (sl = specs; sl; sl = sl->next)
1087     if (strcmp (sl->name, name) == 0)
1088       break;
1089
1090   if (!sl)
1091     {
1092       /* Not found - make it */
1093       sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1094       sl->name = save_string (name, strlen (name));
1095       sl->spec = save_string ("", 0);
1096       sl->next = specs;
1097       specs = sl;
1098     }
1099
1100   old_spec = sl->spec;
1101   if (name && spec[0] == '+' && isspace (spec[1]))
1102     sl->spec = concat (old_spec, spec + 1, "");
1103   else
1104     sl->spec = save_string (spec, strlen (spec));
1105
1106   if (! strcmp (name, "asm"))
1107     asm_spec = sl->spec;
1108   else if (! strcmp (name, "asm_final"))
1109     asm_final_spec = sl->spec;
1110   else if (! strcmp (name, "cc1"))
1111     cc1_spec = sl->spec;
1112   else if (! strcmp (name, "cc1plus"))
1113     cc1plus_spec = sl->spec;
1114   else if (! strcmp (name, "cpp"))
1115     cpp_spec = sl->spec;
1116   else if (! strcmp (name, "endfile"))
1117     endfile_spec = sl->spec;
1118   else if (! strcmp (name, "lib"))
1119     lib_spec = sl->spec;
1120   else if (! strcmp (name, "link"))
1121     link_spec = sl->spec;
1122   else if (! strcmp (name, "predefines"))
1123     cpp_predefines = sl->spec;
1124   else if (! strcmp (name, "signed_char"))
1125     signed_char_spec = sl->spec;
1126   else if (! strcmp (name, "startfile"))
1127     startfile_spec = sl->spec;
1128   else if (! strcmp (name, "switches_need_spaces"))
1129     switches_need_spaces = sl->spec;
1130   else if (! strcmp (name, "cross_compile"))
1131     cross_compile = atoi (sl->spec);
1132   /* Free the old spec */
1133   if (old_spec)
1134     free (old_spec);
1135 }
1136 \f
1137 /* Accumulate a command (program name and args), and run it.  */
1138
1139 /* Vector of pointers to arguments in the current line of specifications.  */
1140
1141 static char **argbuf;
1142
1143 /* Number of elements allocated in argbuf.  */
1144
1145 static int argbuf_length;
1146
1147 /* Number of elements in argbuf currently in use (containing args).  */
1148
1149 static int argbuf_index;
1150
1151 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1152    temp file.  Used only if MKTEMP_EACH_FILE.  */
1153
1154 static struct temp_name {
1155   char *suffix;         /* suffix associated with the code.  */
1156   int length;           /* strlen (suffix).  */
1157   int unique;           /* Indicates whether %g or %u/%U was used.  */
1158   char *filename;       /* associated filename.  */
1159   int filename_length;  /* strlen (filename).  */
1160   struct temp_name *next;
1161 } *temp_names;
1162
1163 /* Number of commands executed so far.  */
1164
1165 static int execution_count;
1166
1167 /* Number of commands that exited with a signal.  */
1168
1169 static int signal_count;
1170
1171 /* Name with which this program was invoked.  */
1172
1173 static char *programname;
1174 \f
1175 /* Structures to keep track of prefixes to try when looking for files. */
1176
1177 struct prefix_list
1178 {
1179   char *prefix;               /* String to prepend to the path. */
1180   struct prefix_list *next;   /* Next in linked list. */
1181   int require_machine_suffix; /* Don't use without machine_suffix.  */
1182   /* 2 means try both machine_suffix and just_machine_suffix.  */
1183   int *used_flag_ptr;         /* 1 if a file was found with this prefix.  */
1184 };
1185
1186 struct path_prefix
1187 {
1188   struct prefix_list *plist;  /* List of prefixes to try */
1189   int max_len;                /* Max length of a prefix in PLIST */
1190   char *name;                 /* Name of this list (used in config stuff) */
1191 };
1192
1193 /* List of prefixes to try when looking for executables. */
1194
1195 static struct path_prefix exec_prefix = { 0, 0, "exec" };
1196
1197 /* List of prefixes to try when looking for startup (crt0) files. */
1198
1199 static struct path_prefix startfile_prefix = { 0, 0, "startfile" };
1200
1201 /* List of prefixes to try when looking for include files.  */
1202
1203 static struct path_prefix include_prefix = { 0, 0, "include" };
1204
1205 /* Suffix to attach to directories searched for commands.
1206    This looks like `MACHINE/VERSION/'.  */
1207
1208 static char *machine_suffix = 0;
1209
1210 /* Suffix to attach to directories searched for commands.
1211    This is just `MACHINE/'.  */
1212
1213 static char *just_machine_suffix = 0;
1214
1215 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1216
1217 static char *gcc_exec_prefix;
1218
1219 /* Default prefixes to attach to command names.  */
1220
1221 #ifdef CROSS_COMPILE  /* Don't use these prefixes for a cross compiler.  */
1222 #undef MD_EXEC_PREFIX
1223 #undef MD_STARTFILE_PREFIX
1224 #undef MD_STARTFILE_PREFIX_1
1225 #endif
1226
1227 #ifndef STANDARD_EXEC_PREFIX
1228 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1229 #endif /* !defined STANDARD_EXEC_PREFIX */
1230
1231 static char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1232 static char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1233 #ifdef MD_EXEC_PREFIX
1234 static char *md_exec_prefix = MD_EXEC_PREFIX;
1235 #endif
1236
1237 #ifndef STANDARD_STARTFILE_PREFIX
1238 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1239 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1240
1241 #ifdef MD_STARTFILE_PREFIX
1242 static char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1243 #endif
1244 #ifdef MD_STARTFILE_PREFIX_1
1245 static char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1246 #endif
1247 static char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1248 static char *standard_startfile_prefix_1 = "/lib/";
1249 static char *standard_startfile_prefix_2 = "/usr/lib/";
1250
1251 #ifndef TOOLDIR_BASE_PREFIX
1252 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1253 #endif
1254 static char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1255 static char *tooldir_prefix;
1256
1257 /* Clear out the vector of arguments (after a command is executed).  */
1258
1259 static void
1260 clear_args ()
1261 {
1262   argbuf_index = 0;
1263 }
1264
1265 /* Add one argument to the vector at the end.
1266    This is done when a space is seen or at the end of the line.
1267    If DELETE_ALWAYS is nonzero, the arg is a filename
1268     and the file should be deleted eventually.
1269    If DELETE_FAILURE is nonzero, the arg is a filename
1270     and the file should be deleted if this compilation fails.  */
1271
1272 static void
1273 store_arg (arg, delete_always, delete_failure)
1274      char *arg;
1275      int delete_always, delete_failure;
1276 {
1277   if (argbuf_index + 1 == argbuf_length)
1278     {
1279       argbuf = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
1280     }
1281
1282   argbuf[argbuf_index++] = arg;
1283   argbuf[argbuf_index] = 0;
1284
1285   if (delete_always || delete_failure)
1286     record_temp_file (arg, delete_always, delete_failure);
1287 }
1288 \f
1289 /* Record the names of temporary files we tell compilers to write,
1290    and delete them at the end of the run.  */
1291
1292 /* This is the common prefix we use to make temp file names.
1293    It is chosen once for each run of this program.
1294    It is substituted into a spec by %g.
1295    Thus, all temp file names contain this prefix.
1296    In practice, all temp file names start with this prefix.
1297
1298    This prefix comes from the envvar TMPDIR if it is defined;
1299    otherwise, from the P_tmpdir macro if that is defined;
1300    otherwise, in /usr/tmp or /tmp.  */
1301
1302 static char *temp_filename;
1303
1304 /* Length of the prefix.  */
1305
1306 static int temp_filename_length;
1307
1308 /* Define the list of temporary files to delete.  */
1309
1310 struct temp_file
1311 {
1312   char *name;
1313   struct temp_file *next;
1314 };
1315
1316 /* Queue of files to delete on success or failure of compilation.  */
1317 static struct temp_file *always_delete_queue;
1318 /* Queue of files to delete on failure of compilation.  */
1319 static struct temp_file *failure_delete_queue;
1320
1321 /* Record FILENAME as a file to be deleted automatically.
1322    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1323    otherwise delete it in any case.
1324    FAIL_DELETE nonzero means delete it if a compilation step fails;
1325    otherwise delete it in any case.  */
1326
1327 static void
1328 record_temp_file (filename, always_delete, fail_delete)
1329      char *filename;
1330      int always_delete;
1331      int fail_delete;
1332 {
1333   register char *name;
1334   name = xmalloc (strlen (filename) + 1);
1335   strcpy (name, filename);
1336
1337   if (always_delete)
1338     {
1339       register struct temp_file *temp;
1340       for (temp = always_delete_queue; temp; temp = temp->next)
1341         if (! strcmp (name, temp->name))
1342           goto already1;
1343       temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1344       temp->next = always_delete_queue;
1345       temp->name = name;
1346       always_delete_queue = temp;
1347     already1:;
1348     }
1349
1350   if (fail_delete)
1351     {
1352       register struct temp_file *temp;
1353       for (temp = failure_delete_queue; temp; temp = temp->next)
1354         if (! strcmp (name, temp->name))
1355           goto already2;
1356       temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1357       temp->next = failure_delete_queue;
1358       temp->name = name;
1359       failure_delete_queue = temp;
1360     already2:;
1361     }
1362 }
1363
1364 /* Delete all the temporary files whose names we previously recorded.  */
1365
1366 static void
1367 delete_temp_files ()
1368 {
1369   register struct temp_file *temp;
1370
1371   for (temp = always_delete_queue; temp; temp = temp->next)
1372     {
1373 #ifdef DEBUG
1374       int i;
1375       printf ("Delete %s? (y or n) ", temp->name);
1376       fflush (stdout);
1377       i = getchar ();
1378       if (i != '\n')
1379         while (getchar () != '\n') ;
1380       if (i == 'y' || i == 'Y')
1381 #endif /* DEBUG */
1382         {
1383           struct stat st;
1384           if (stat (temp->name, &st) >= 0)
1385             {
1386               /* Delete only ordinary files.  */
1387               if (S_ISREG (st.st_mode))
1388                 if (unlink (temp->name) < 0)
1389                   if (verbose_flag)
1390                     perror_with_name (temp->name);
1391             }
1392         }
1393     }
1394
1395   always_delete_queue = 0;
1396 }
1397
1398 /* Delete all the files to be deleted on error.  */
1399
1400 static void
1401 delete_failure_queue ()
1402 {
1403   register struct temp_file *temp;
1404
1405   for (temp = failure_delete_queue; temp; temp = temp->next)
1406     {
1407 #ifdef DEBUG
1408       int i;
1409       printf ("Delete %s? (y or n) ", temp->name);
1410       fflush (stdout);
1411       i = getchar ();
1412       if (i != '\n')
1413         while (getchar () != '\n') ;
1414       if (i == 'y' || i == 'Y')
1415 #endif /* DEBUG */
1416         {
1417           if (unlink (temp->name) < 0)
1418             if (verbose_flag)
1419               perror_with_name (temp->name);
1420         }
1421     }
1422 }
1423
1424 static void
1425 clear_failure_queue ()
1426 {
1427   failure_delete_queue = 0;
1428 }
1429
1430 /* Compute a string to use as the base of all temporary file names.
1431    It is substituted for %g.  */
1432
1433 static char *
1434 choose_temp_base_try (try, base)
1435 char *try;
1436 char *base;
1437 {
1438   char *rv;
1439   if (base)
1440     rv = base;
1441   else if (try == (char *)0)
1442     rv = 0;
1443   else if (access (try, R_OK | W_OK) != 0)
1444     rv = 0;
1445   else
1446     rv = try;
1447   return rv;
1448 }
1449
1450 static void
1451 choose_temp_base ()
1452 {
1453   char *base = 0;
1454   int len;
1455
1456   base = choose_temp_base_try (getenv ("TMPDIR"), base);
1457   base = choose_temp_base_try (getenv ("TMP"), base);
1458   base = choose_temp_base_try (getenv ("TEMP"), base);
1459
1460 #ifdef P_tmpdir
1461   base = choose_temp_base_try (P_tmpdir, base);
1462 #endif
1463
1464   base = choose_temp_base_try ("/usr/tmp", base);
1465   base = choose_temp_base_try ("/tmp", base);
1466
1467   /* If all else fails, use the current directory! */
1468   if (base == (char *)0)
1469     base = "./";
1470
1471   len = strlen (base);
1472   temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1);
1473   strcpy (temp_filename, base);
1474   if (len > 0 && temp_filename[len-1] != '/')
1475     temp_filename[len++] = '/';
1476   strcpy (temp_filename + len, "ccXXXXXX");
1477
1478   mktemp (temp_filename);
1479   temp_filename_length = strlen (temp_filename);
1480   if (temp_filename_length == 0)
1481     abort ();
1482 }
1483 \f
1484
1485 /* Routine to add variables to the environment.  We do this to pass
1486    the pathname of the gcc driver, and the directories search to the
1487    collect2 program, which is being run as ld.  This way, we can be
1488    sure of executing the right compiler when collect2 wants to build
1489    constructors and destructors.  Since the environment variables we
1490    use come from an obstack, we don't have to worry about allocating
1491    space for them.  */
1492
1493 #ifndef HAVE_PUTENV
1494
1495 void
1496 putenv (str)
1497      char *str;
1498 {
1499 #ifndef VMS                     /* nor about VMS */
1500
1501   extern char **environ;
1502   char **old_environ = environ;
1503   char **envp;
1504   int num_envs = 0;
1505   int name_len = 1;
1506   int str_len = strlen (str);
1507   char *p = str;
1508   int ch;
1509
1510   while ((ch = *p++) != '\0' && ch != '=')
1511     name_len++;
1512
1513   if (!ch)
1514     abort ();
1515
1516   /* Search for replacing an existing environment variable, and
1517      count the number of total environment variables.  */
1518   for (envp = old_environ; *envp; envp++)
1519     {
1520       num_envs++;
1521       if (!strncmp (str, *envp, name_len))
1522         {
1523           *envp = str;
1524           return;
1525         }
1526     }
1527
1528   /* Add a new environment variable */
1529   environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1530   *environ = str;
1531   bcopy (old_environ, environ+1, sizeof (char *) * (num_envs+1));
1532
1533 #endif  /* VMS */
1534 }
1535
1536 #endif  /* HAVE_PUTENV */
1537
1538 \f
1539 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect.  */
1540
1541 static void
1542 putenv_from_prefixes (paths, env_var)
1543      struct path_prefix *paths;
1544      char *env_var;
1545 {
1546   int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1547   int just_suffix_len
1548     = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
1549   int first_time = TRUE;
1550   struct prefix_list *pprefix;
1551
1552   obstack_grow (&collect_obstack, env_var, strlen (env_var));
1553
1554   for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1555     {
1556       int len = strlen (pprefix->prefix);
1557
1558       if (machine_suffix
1559           && is_directory (pprefix->prefix, machine_suffix, 0))
1560         {
1561           if (!first_time)
1562             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1563
1564           first_time = FALSE;
1565           obstack_grow (&collect_obstack, pprefix->prefix, len);
1566           obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1567         }
1568
1569       if (just_machine_suffix
1570           && pprefix->require_machine_suffix == 2
1571           && is_directory (pprefix->prefix, just_machine_suffix, 0))
1572         {
1573           if (!first_time)
1574             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1575
1576           first_time = FALSE;
1577           obstack_grow (&collect_obstack, pprefix->prefix, len);
1578           obstack_grow (&collect_obstack, just_machine_suffix,
1579                         just_suffix_len);
1580         }
1581
1582       if (!pprefix->require_machine_suffix)
1583         {
1584           if (!first_time)
1585             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1586
1587           first_time = FALSE;
1588           obstack_grow (&collect_obstack, pprefix->prefix, len);
1589         }
1590     }
1591   obstack_1grow (&collect_obstack, '\0');
1592   putenv (obstack_finish (&collect_obstack));
1593 }
1594
1595 \f
1596 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
1597    access to check permissions.
1598    Return 0 if not found, otherwise return its name, allocated with malloc. */
1599
1600 static char *
1601 find_a_file (pprefix, name, mode)
1602      struct path_prefix *pprefix;
1603      char *name;
1604      int mode;
1605 {
1606   char *temp;
1607   char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
1608   struct prefix_list *pl;
1609   int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
1610
1611   if (machine_suffix)
1612     len += strlen (machine_suffix);
1613
1614   temp = xmalloc (len);
1615
1616   /* Determine the filename to execute (special case for absolute paths).  */
1617
1618   if (*name == '/')
1619     {
1620       if (access (name, mode))
1621         {
1622           strcpy (temp, name);
1623           return temp;
1624         }
1625     }
1626   else
1627     for (pl = pprefix->plist; pl; pl = pl->next)
1628       {
1629         if (machine_suffix)
1630           {
1631             strcpy (temp, pl->prefix);
1632             strcat (temp, machine_suffix);
1633             strcat (temp, name);
1634             if (access (temp, mode) == 0)
1635               {
1636                 if (pl->used_flag_ptr != 0)
1637                   *pl->used_flag_ptr = 1;
1638                 return temp;
1639               }
1640             /* Some systems have a suffix for executable files.
1641                So try appending that.  */
1642             if (file_suffix[0] != 0)
1643               {
1644                 strcat (temp, file_suffix);
1645                 if (access (temp, mode) == 0)
1646                   {
1647                     if (pl->used_flag_ptr != 0)
1648                       *pl->used_flag_ptr = 1;
1649                     return temp;
1650                   }
1651               }
1652           }
1653         /* Certain prefixes are tried with just the machine type,
1654            not the version.  This is used for finding as, ld, etc.  */
1655         if (just_machine_suffix && pl->require_machine_suffix == 2)
1656           {
1657             strcpy (temp, pl->prefix);
1658             strcat (temp, just_machine_suffix);
1659             strcat (temp, name);
1660             if (access (temp, mode) == 0)
1661               {
1662                 if (pl->used_flag_ptr != 0)
1663                   *pl->used_flag_ptr = 1;
1664                 return temp;
1665               }
1666             /* Some systems have a suffix for executable files.
1667                So try appending that.  */
1668             if (file_suffix[0] != 0)
1669               {
1670                 strcat (temp, file_suffix);
1671                 if (access (temp, mode) == 0)
1672                   {
1673                     if (pl->used_flag_ptr != 0)
1674                       *pl->used_flag_ptr = 1;
1675                     return temp;
1676                   }
1677               }
1678           }
1679         /* Certain prefixes can't be used without the machine suffix
1680            when the machine or version is explicitly specified.  */
1681         if (!pl->require_machine_suffix)
1682           {
1683             strcpy (temp, pl->prefix);
1684             strcat (temp, name);
1685             if (access (temp, mode) == 0)
1686               {
1687                 if (pl->used_flag_ptr != 0)
1688                   *pl->used_flag_ptr = 1;
1689                 return temp;
1690               }
1691             /* Some systems have a suffix for executable files.
1692                So try appending that.  */
1693             if (file_suffix[0] != 0)
1694               {
1695                 strcat (temp, file_suffix);
1696                 if (access (temp, mode) == 0)
1697                   {
1698                     if (pl->used_flag_ptr != 0)
1699                       *pl->used_flag_ptr = 1;
1700                     return temp;
1701                   }
1702               }
1703           }
1704       }
1705
1706   free (temp);
1707   return 0;
1708 }
1709
1710 /* Add an entry for PREFIX in PLIST.  If FIRST is set, it goes
1711    at the start of the list, otherwise it goes at the end.
1712
1713    If WARN is nonzero, we will warn if no file is found
1714    through this prefix.  WARN should point to an int
1715    which will be set to 1 if this entry is used.
1716
1717    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
1718    the complete value of machine_suffix.
1719    2 means try both machine_suffix and just_machine_suffix.  */
1720
1721 static void
1722 add_prefix (pprefix, prefix, first, require_machine_suffix, warn)
1723      struct path_prefix *pprefix;
1724      char *prefix;
1725      int first;
1726      int require_machine_suffix;
1727      int *warn;
1728 {
1729   struct prefix_list *pl, **prev;
1730   int len;
1731
1732   if (!first && pprefix->plist)
1733     {
1734       for (pl = pprefix->plist; pl->next; pl = pl->next)
1735         ;
1736       prev = &pl->next;
1737     }
1738   else
1739     prev = &pprefix->plist;
1740
1741   /* Keep track of the longest prefix */
1742
1743   len = strlen (prefix);
1744   if (len > pprefix->max_len)
1745     pprefix->max_len = len;
1746
1747   pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
1748   pl->prefix = save_string (prefix, len);
1749   pl->require_machine_suffix = require_machine_suffix;
1750   pl->used_flag_ptr = warn;
1751   if (warn)
1752     *warn = 0;
1753
1754   if (*prev)
1755     pl->next = *prev;
1756   else
1757     pl->next = (struct prefix_list *) 0;
1758   *prev = pl;
1759 }
1760
1761 /* Print warnings for any prefixes in the list PPREFIX that were not used.  */
1762
1763 static void
1764 unused_prefix_warnings (pprefix)
1765      struct path_prefix *pprefix;
1766 {
1767   struct prefix_list *pl = pprefix->plist;
1768
1769   while (pl)
1770     {
1771       if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
1772         {
1773           error ("file path prefix `%s' never used",
1774                  pl->prefix);
1775           /* Prevent duplicate warnings.  */
1776           *pl->used_flag_ptr = 1;
1777         }
1778       pl = pl->next;
1779     }
1780 }
1781
1782 /* Get rid of all prefixes built up so far in *PLISTP. */
1783
1784 static void
1785 free_path_prefix (pprefix)
1786      struct path_prefix *pprefix;
1787 {
1788   struct prefix_list *pl = pprefix->plist;
1789   struct prefix_list *temp;
1790
1791   while (pl)
1792     {
1793       temp = pl;
1794       pl = pl->next;
1795       free (temp->prefix);
1796       free ((char *) temp);
1797     }
1798   pprefix->plist = (struct prefix_list *) 0;
1799 }
1800 \f
1801 /* stdin file number.  */
1802 #define STDIN_FILE_NO 0
1803
1804 /* stdout file number.  */
1805 #define STDOUT_FILE_NO 1
1806
1807 /* value of `pipe': port index for reading.  */
1808 #define READ_PORT 0
1809
1810 /* value of `pipe': port index for writing.  */
1811 #define WRITE_PORT 1
1812
1813 /* Pipe waiting from last process, to be used as input for the next one.
1814    Value is STDIN_FILE_NO if no pipe is waiting
1815    (i.e. the next command is the first of a group).  */
1816
1817 static int last_pipe_input;
1818
1819 /* Fork one piped subcommand.  FUNC is the system call to use
1820    (either execv or execvp).  ARGV is the arg vector to use.
1821    NOT_LAST is nonzero if this is not the last subcommand
1822    (i.e. its output should be piped to the next one.)  */
1823
1824 #ifndef OS2
1825 #ifdef __MSDOS__
1826
1827 /* Declare these to avoid compilation error.  They won't be called.  */
1828 int execv(const char *a, const char **b){}
1829 int execvp(const char *a, const char **b){}
1830
1831 static int
1832 pexecute (search_flag, program, argv, not_last)
1833      int search_flag;
1834      char *program;
1835      char *argv[];
1836      int not_last;
1837 {
1838   char *scmd, *rf;
1839   FILE *argfile;
1840   int i, el = search_flag ? 0 : 4;
1841
1842   scmd = (char *)malloc (strlen (program) + strlen (temp_filename) + 6 + el);
1843   rf = scmd + strlen(program) + 2 + el;
1844   sprintf (scmd, "%s%s @%s.gp", program,
1845            (search_flag ? "" : ".exe"), temp_filename);
1846   argfile = fopen (rf, "w");
1847   if (argfile == 0)
1848     pfatal_with_name (rf);
1849
1850   for (i=1; argv[i]; i++)
1851     {
1852       char *cp;
1853       for (cp = argv[i]; *cp; cp++)
1854         {
1855           if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
1856             fputc ('\\', argfile);
1857           fputc (*cp, argfile);
1858         }
1859       fputc ('\n', argfile);
1860     }
1861   fclose (argfile);
1862
1863   i = system (scmd);
1864
1865   remove (rf);
1866
1867   if (i == -1)
1868     {
1869       perror_exec (program);
1870       return MIN_FATAL_STATUS << 8;
1871     }
1872
1873   return i << 8;
1874 }
1875
1876 #else /* not __MSDOS__ */
1877
1878 static int
1879 pexecute (search_flag, program, argv, not_last)
1880      int search_flag;
1881      char *program;
1882      char *argv[];
1883      int not_last;
1884 {
1885   int (*func)() = (search_flag ? execv : execvp);
1886   int pid;
1887   int pdes[2];
1888   int input_desc = last_pipe_input;
1889   int output_desc = STDOUT_FILE_NO;
1890   int retries, sleep_interval;
1891
1892   /* If this isn't the last process, make a pipe for its output,
1893      and record it as waiting to be the input to the next process.  */
1894
1895   if (not_last)
1896     {
1897       if (pipe (pdes) < 0)
1898         pfatal_with_name ("pipe");
1899       output_desc = pdes[WRITE_PORT];
1900       last_pipe_input = pdes[READ_PORT];
1901     }
1902   else
1903     last_pipe_input = STDIN_FILE_NO;
1904
1905   /* Fork a subprocess; wait and retry if it fails.  */
1906   sleep_interval = 1;
1907   for (retries = 0; retries < 4; retries++)
1908     {
1909       pid = vfork ();
1910       if (pid >= 0)
1911         break;
1912       sleep (sleep_interval);
1913       sleep_interval *= 2;
1914     }
1915
1916   switch (pid)
1917     {
1918     case -1:
1919 #ifdef vfork
1920       pfatal_with_name ("fork");
1921 #else
1922       pfatal_with_name ("vfork");
1923 #endif
1924       /* NOTREACHED */
1925       return 0;
1926
1927     case 0: /* child */
1928       /* Move the input and output pipes into place, if nec.  */
1929       if (input_desc != STDIN_FILE_NO)
1930         {
1931           close (STDIN_FILE_NO);
1932           dup (input_desc);
1933           close (input_desc);
1934         }
1935       if (output_desc != STDOUT_FILE_NO)
1936         {
1937           close (STDOUT_FILE_NO);
1938           dup (output_desc);
1939           close (output_desc);
1940         }
1941
1942       /* Close the parent's descs that aren't wanted here.  */
1943       if (last_pipe_input != STDIN_FILE_NO)
1944         close (last_pipe_input);
1945
1946       /* Exec the program.  */
1947       (*func) (program, argv);
1948       perror_exec (program);
1949       exit (-1);
1950       /* NOTREACHED */
1951       return 0;
1952
1953     default:
1954       /* In the parent, after forking.
1955          Close the descriptors that we made for this child.  */
1956       if (input_desc != STDIN_FILE_NO)
1957         close (input_desc);
1958       if (output_desc != STDOUT_FILE_NO)
1959         close (output_desc);
1960
1961       /* Return child's process number.  */
1962       return pid;
1963     }
1964 }
1965
1966 #endif /* not __MSDOS__ */
1967 #else /* not OS2 */
1968
1969 static int
1970 pexecute (search_flag, program, argv, not_last)
1971      int search_flag;
1972      char *program;
1973      char *argv[];
1974      int not_last;
1975 {
1976   return (search_flag ? spawnv : spawnvp) (1, program, argv);
1977 }
1978 #endif /* not OS2 */
1979 \f
1980 /* Execute the command specified by the arguments on the current line of spec.
1981    When using pipes, this includes several piped-together commands
1982    with `|' between them.
1983
1984    Return 0 if successful, -1 if failed.  */
1985
1986 static int
1987 execute ()
1988 {
1989   int i;
1990   int n_commands;               /* # of command.  */
1991   char *string;
1992   struct command
1993     {
1994       char *prog;               /* program name.  */
1995       char **argv;              /* vector of args.  */
1996       int pid;                  /* pid of process for this command.  */
1997     };
1998
1999   struct command *commands;     /* each command buffer with above info.  */
2000
2001   /* Count # of piped commands.  */
2002   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2003     if (strcmp (argbuf[i], "|") == 0)
2004       n_commands++;
2005
2006   /* Get storage for each command.  */
2007   commands
2008     = (struct command *) alloca (n_commands * sizeof (struct command));
2009
2010   /* Split argbuf into its separate piped processes,
2011      and record info about each one.
2012      Also search for the programs that are to be run.  */
2013
2014   commands[0].prog = argbuf[0]; /* first command.  */
2015   commands[0].argv = &argbuf[0];
2016   string = find_a_file (&exec_prefix, commands[0].prog, X_OK);
2017   if (string)
2018     commands[0].argv[0] = string;
2019
2020   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2021     if (strcmp (argbuf[i], "|") == 0)
2022       {                         /* each command.  */
2023 #ifdef __MSDOS__
2024         fatal ("-pipe not supported under MS-DOS");
2025 #endif
2026         argbuf[i] = 0;  /* termination of command args.  */
2027         commands[n_commands].prog = argbuf[i + 1];
2028         commands[n_commands].argv = &argbuf[i + 1];
2029         string = find_a_file (&exec_prefix, commands[n_commands].prog, X_OK);
2030         if (string)
2031           commands[n_commands].argv[0] = string;
2032         n_commands++;
2033       }
2034
2035   argbuf[argbuf_index] = 0;
2036
2037   /* If -v, print what we are about to do, and maybe query.  */
2038
2039   if (verbose_flag)
2040     {
2041       /* Print each piped command as a separate line.  */
2042       for (i = 0; i < n_commands ; i++)
2043         {
2044           char **j;
2045
2046           for (j = commands[i].argv; *j; j++)
2047             fprintf (stderr, " %s", *j);
2048
2049           /* Print a pipe symbol after all but the last command.  */
2050           if (i + 1 != n_commands)
2051             fprintf (stderr, " |");
2052           fprintf (stderr, "\n");
2053         }
2054       fflush (stderr);
2055 #ifdef DEBUG
2056       fprintf (stderr, "\nGo ahead? (y or n) ");
2057       fflush (stderr);
2058       i = getchar ();
2059       if (i != '\n')
2060         while (getchar () != '\n') ;
2061       if (i != 'y' && i != 'Y')
2062         return 0;
2063 #endif /* DEBUG */
2064     }
2065
2066   /* Run each piped subprocess.  */
2067
2068   last_pipe_input = STDIN_FILE_NO;
2069   for (i = 0; i < n_commands; i++)
2070     {
2071       char *string = commands[i].argv[0];
2072
2073       commands[i].pid = pexecute (string != commands[i].prog,
2074                                   string, commands[i].argv,
2075                                   i + 1 < n_commands);
2076
2077       if (string != commands[i].prog)
2078         free (string);
2079     }
2080
2081   execution_count++;
2082
2083   /* Wait for all the subprocesses to finish.
2084      We don't care what order they finish in;
2085      we know that N_COMMANDS waits will get them all.  */
2086
2087   {
2088     int ret_code = 0;
2089
2090     for (i = 0; i < n_commands; i++)
2091       {
2092         int status;
2093         int pid;
2094         char *prog = "unknown";
2095
2096 #ifdef __MSDOS__
2097         status = pid = commands[i].pid;
2098 #else
2099         pid = wait (&status);
2100 #endif
2101         if (pid < 0)
2102           abort ();
2103
2104         if (status != 0)
2105           {
2106             int j;
2107             for (j = 0; j < n_commands; j++)
2108               if (commands[j].pid == pid)
2109                 prog = commands[j].prog;
2110
2111             if ((status & 0x7F) != 0)
2112               {
2113                 fatal ("Internal compiler error: program %s got fatal signal %d",
2114                        prog, (status & 0x7F));
2115                 signal_count++;
2116               }
2117             if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS)
2118               ret_code = -1;
2119           }
2120       }
2121     return ret_code;
2122   }
2123 }
2124 \f
2125 /* Find all the switches given to us
2126    and make a vector describing them.
2127    The elements of the vector are strings, one per switch given.
2128    If a switch uses following arguments, then the `part1' field
2129    is the switch itself and the `args' field
2130    is a null-terminated vector containing the following arguments.
2131    The `live_cond' field is 1 if the switch is true in a conditional spec,
2132    -1 if false (overridden by a later switch), and is initialized to zero.
2133    The `valid' field is nonzero if any spec has looked at this switch;
2134    if it remains zero at the end of the run, it must be meaningless.  */
2135
2136 struct switchstr
2137 {
2138   char *part1;
2139   char **args;
2140   int live_cond;
2141   int valid;
2142 };
2143
2144 static struct switchstr *switches;
2145
2146 static int n_switches;
2147
2148 struct infile
2149 {
2150   char *name;
2151   char *language;
2152 };
2153
2154 /* Also a vector of input files specified.  */
2155
2156 static struct infile *infiles;
2157
2158 static int n_infiles;
2159
2160 /* And a vector of corresponding output files is made up later.  */
2161
2162 static char **outfiles;
2163
2164 /* Create the vector `switches' and its contents.
2165    Store its length in `n_switches'.  */
2166
2167 static void
2168 process_command (argc, argv)
2169      int argc;
2170      char **argv;
2171 {
2172   register int i;
2173   char *temp;
2174   char *spec_lang = 0;
2175   int last_language_n_infiles;
2176
2177   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
2178
2179   n_switches = 0;
2180   n_infiles = 0;
2181
2182   /* Figure compiler version from version string.  */
2183
2184   compiler_version = save_string (version_string, strlen (version_string));
2185   for (temp = compiler_version; *temp; ++temp)
2186     {
2187       if (*temp == ' ')
2188         {
2189           *temp = '\0';
2190           break;
2191         }
2192     }
2193
2194   /* Set up the default search paths.  */
2195
2196   if (gcc_exec_prefix)
2197     {
2198       add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
2199       add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
2200     }
2201
2202   /* COMPILER_PATH and LIBRARY_PATH have values
2203      that are lists of directory names with colons.  */
2204
2205   temp = getenv ("COMPILER_PATH");
2206   if (temp)
2207     {
2208       char *startp, *endp;
2209       char *nstore = (char *) alloca (strlen (temp) + 3);
2210
2211       startp = endp = temp;
2212       while (1)
2213         {
2214           if (*endp == PATH_SEPARATOR || *endp == 0)
2215             {
2216               strncpy (nstore, startp, endp-startp);
2217               if (endp == startp)
2218                 {
2219                   strcpy (nstore, "./");
2220                 }
2221               else if (endp[-1] != '/')
2222                 {
2223                   nstore[endp-startp] = '/';
2224                   nstore[endp-startp+1] = 0;
2225                 }
2226               else
2227                 nstore[endp-startp] = 0;
2228               add_prefix (&exec_prefix, nstore, 0, 0, NULL_PTR);
2229               if (*endp == 0)
2230                 break;
2231               endp = startp = endp + 1;
2232             }
2233           else
2234             endp++;
2235         }
2236     }
2237
2238   temp = getenv ("LIBRARY_PATH");
2239   if (temp)
2240     {
2241       char *startp, *endp;
2242       char *nstore = (char *) alloca (strlen (temp) + 3);
2243
2244       startp = endp = temp;
2245       while (1)
2246         {
2247           if (*endp == PATH_SEPARATOR || *endp == 0)
2248             {
2249               strncpy (nstore, startp, endp-startp);
2250               if (endp == startp)
2251                 {
2252                   strcpy (nstore, "./");
2253                 }
2254               else if (endp[-1] != '/')
2255                 {
2256                   nstore[endp-startp] = '/';
2257                   nstore[endp-startp+1] = 0;
2258                 }
2259               else
2260                 nstore[endp-startp] = 0;
2261               add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
2262               if (*endp == 0)
2263                 break;
2264               endp = startp = endp + 1;
2265             }
2266           else
2267             endp++;
2268         }
2269     }
2270
2271   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
2272   temp = getenv ("LPATH");
2273   if (temp)
2274     {
2275       char *startp, *endp;
2276       char *nstore = (char *) alloca (strlen (temp) + 3);
2277
2278       startp = endp = temp;
2279       while (1)
2280         {
2281           if (*endp == PATH_SEPARATOR || *endp == 0)
2282             {
2283               strncpy (nstore, startp, endp-startp);
2284               if (endp == startp)
2285                 {
2286                   strcpy (nstore, "./");
2287                 }
2288               else if (endp[-1] != '/')
2289                 {
2290                   nstore[endp-startp] = '/';
2291                   nstore[endp-startp+1] = 0;
2292                 }
2293               else
2294                 nstore[endp-startp] = 0;
2295               add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
2296               if (*endp == 0)
2297                 break;
2298               endp = startp = endp + 1;
2299             }
2300           else
2301             endp++;
2302         }
2303     }
2304
2305   /* Convert new-style -- options to old-style.  */
2306   translate_options (&argc, &argv);
2307
2308   /* Scan argv twice.  Here, the first time, just count how many switches
2309      there will be in their vector, and how many input files in theirs.
2310      Here we also parse the switches that cc itself uses (e.g. -v).  */
2311
2312   for (i = 1; i < argc; i++)
2313     {
2314       if (! strcmp (argv[i], "-dumpspecs"))
2315         {
2316           printf ("*asm:\n%s\n\n", asm_spec);
2317           printf ("*asm_final:\n%s\n\n", asm_final_spec);
2318           printf ("*cpp:\n%s\n\n", cpp_spec);
2319           printf ("*cc1:\n%s\n\n", cc1_spec);
2320           printf ("*cc1plus:\n%s\n\n", cc1plus_spec);
2321           printf ("*endfile:\n%s\n\n", endfile_spec);
2322           printf ("*link:\n%s\n\n", link_spec);
2323           printf ("*lib:\n%s\n\n", lib_spec);
2324           printf ("*startfile:\n%s\n\n", startfile_spec);
2325           printf ("*switches_need_spaces:\n%s\n\n", switches_need_spaces);
2326           printf ("*signed_char:\n%s\n\n", signed_char_spec);
2327           printf ("*predefines:\n%s\n\n", cpp_predefines);
2328           printf ("*cross_compile:\n%d\n\n", cross_compile);
2329
2330           exit (0);
2331         }
2332       else if (! strcmp (argv[i], "-dumpversion"))
2333         {
2334           printf ("%s\n", version_string);
2335           exit (0);
2336         }
2337       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2338           print_file_name = "libgcc.a";
2339       else if (! strncmp (argv[i], "-print-file-name=", 17))
2340           print_file_name = argv[i] + 17;
2341       else if (! strncmp (argv[i], "-print-prog-name=", 17))
2342           print_prog_name = argv[i] + 17;
2343       else if (! strcmp (argv[i], "-Xlinker"))
2344         {
2345           /* Pass the argument of this option to the linker when we link.  */
2346
2347           if (i + 1 == argc)
2348             fatal ("argument to `-Xlinker' is missing");
2349
2350           n_linker_options++;
2351           if (!linker_options)
2352             linker_options
2353               = (char **) xmalloc (n_linker_options * sizeof (char **));
2354           else
2355             linker_options
2356               = (char **) xrealloc (linker_options,
2357                                     n_linker_options * sizeof (char **));
2358
2359           linker_options[n_linker_options - 1] = argv[++i];
2360         }
2361       else if (! strncmp (argv[i], "-Wl,", 4))
2362         {
2363           int prev, j;
2364           /* Pass the rest of this option to the linker when we link.  */
2365
2366           n_linker_options++;
2367           if (!linker_options)
2368             linker_options
2369               = (char **) xmalloc (n_linker_options * sizeof (char **));
2370           else
2371             linker_options
2372               = (char **) xrealloc (linker_options,
2373                                     n_linker_options * sizeof (char **));
2374
2375           /* Split the argument at commas.  */
2376           prev = 4;
2377           for (j = 4; argv[i][j]; j++)
2378             if (argv[i][j] == ',')
2379               {
2380                 linker_options[n_linker_options - 1]
2381                   = save_string (argv[i] + prev, j - prev);
2382                 n_linker_options++;
2383                 linker_options
2384                   = (char **) xrealloc (linker_options,
2385                                         n_linker_options * sizeof (char **));
2386                 prev = j + 1;
2387               }
2388           /* Record the part after the last comma.  */
2389           linker_options[n_linker_options - 1] = argv[i] + prev;
2390         }
2391       else if (! strncmp (argv[i], "-Wa,", 4))
2392         {
2393           int prev, j;
2394           /* Pass the rest of this option to the assembler.  */
2395
2396           n_assembler_options++;
2397           if (!assembler_options)
2398             assembler_options
2399               = (char **) xmalloc (n_assembler_options * sizeof (char **));
2400           else
2401             assembler_options
2402               = (char **) xrealloc (assembler_options,
2403                                     n_assembler_options * sizeof (char **));
2404
2405           /* Split the argument at commas.  */
2406           prev = 4;
2407           for (j = 4; argv[i][j]; j++)
2408             if (argv[i][j] == ',')
2409               {
2410                 assembler_options[n_assembler_options - 1]
2411                   = save_string (argv[i] + prev, j - prev);
2412                 n_assembler_options++;
2413                 assembler_options
2414                   = (char **) xrealloc (assembler_options,
2415                                         n_assembler_options * sizeof (char **));
2416                 prev = j + 1;
2417               }
2418           /* Record the part after the last comma.  */
2419           assembler_options[n_assembler_options - 1] = argv[i] + prev;
2420         }
2421       else if (argv[i][0] == '+' && argv[i][1] == 'e')
2422         /* The +e options to the C++ front-end.  */
2423         n_switches++;
2424       else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2425         {
2426           register char *p = &argv[i][1];
2427           register int c = *p;
2428
2429           switch (c)
2430             {
2431             case 'b':
2432               if (p[1] == 0 && i + 1 == argc)
2433                 fatal ("argument to `-b' is missing");
2434               if (p[1] == 0)
2435                 spec_machine = argv[++i];
2436               else
2437                 spec_machine = p + 1;
2438               break;
2439
2440             case 'B':
2441               {
2442                 int *temp = (int *) xmalloc (sizeof (int));
2443                 char *value;
2444                 if (p[1] == 0 && i + 1 == argc)
2445                   fatal ("argument to `-B' is missing");
2446                 if (p[1] == 0)
2447                   value = argv[++i];
2448                 else
2449                   value = p + 1;
2450                 add_prefix (&exec_prefix, value, 1, 0, temp);
2451                 add_prefix (&startfile_prefix, value, 1, 0, temp);
2452                 add_prefix (&include_prefix, concat (value, "include", ""),
2453                             1, 0, 0);
2454
2455                 /* As a kludge, if the arg is "[foo/]stageN/", just add
2456                    "include" to the include prefix.  */
2457                 {
2458                   int len = strlen (value);
2459                   if ((len == 7 || (len > 7 && value[len - 8] == '/'))
2460                       && strncmp (value + len - 7, "stage", 5) == 0
2461                       && isdigit (value[len - 2])
2462                       && value[len - 1] == '/')
2463                     add_prefix (&include_prefix, "include", 1, 0, 0);
2464                 }
2465               }
2466               break;
2467
2468             case 'v':   /* Print our subcommands and print versions.  */
2469               n_switches++;
2470               /* If they do anything other than exactly `-v', don't set
2471                  verbose_flag; rather, continue on to give the error.  */
2472               if (p[1] != 0)
2473                 break;
2474               verbose_flag++;
2475               break;
2476
2477             case 'V':
2478               if (p[1] == 0 && i + 1 == argc)
2479                 fatal ("argument to `-V' is missing");
2480               if (p[1] == 0)
2481                 spec_version = argv[++i];
2482               else
2483                 spec_version = p + 1;
2484               compiler_version = spec_version;
2485               break;
2486
2487             case 's':
2488               if (!strcmp (p, "save-temps"))
2489                 {
2490                   save_temps_flag = 1;
2491                   n_switches++;
2492                   break;
2493                 }
2494             default:
2495               n_switches++;
2496
2497               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
2498                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
2499               else if (WORD_SWITCH_TAKES_ARG (p))
2500                 i += WORD_SWITCH_TAKES_ARG (p);
2501             }
2502         }
2503       else
2504         n_infiles++;
2505     }
2506
2507   /* Set up the search paths before we go looking for config files.  */
2508
2509   /* These come before the md prefixes so that we will find gcc's subcommands
2510      (such as cpp) rather than those of the host system.  */
2511   /* Use 2 as fourth arg meaning try just the machine as a suffix,
2512      as well as trying the machine and the version.  */
2513   add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR);
2514   add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR);
2515
2516   add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
2517   add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
2518
2519   tooldir_prefix = concat (tooldir_base_prefix, spec_machine, "/");
2520
2521   /* If tooldir is relative, base it on exec_prefix.  A relative
2522      tooldir lets us move the installed tree as a unit.
2523
2524      If GCC_EXEC_PREFIX is defined, then we want to add two relative
2525      directories, so that we can search both the user specified directory
2526      and the standard place.  */
2527
2528   if (*tooldir_prefix != '/')
2529     {
2530       if (gcc_exec_prefix)
2531         {
2532           char *gcc_exec_tooldir_prefix
2533             = concat (concat (gcc_exec_prefix, spec_machine, "/"),
2534                       concat (spec_version, "/", tooldir_prefix),
2535                       "");
2536
2537           add_prefix (&exec_prefix, concat (gcc_exec_tooldir_prefix, "bin", "/"),
2538                       0, 0, NULL_PTR);
2539           add_prefix (&startfile_prefix, concat (gcc_exec_tooldir_prefix, "lib", "/"),
2540                       0, 0, NULL_PTR);
2541         }
2542
2543       tooldir_prefix = concat (concat (standard_exec_prefix, spec_machine, "/"),
2544                                concat (spec_version, "/", tooldir_prefix),
2545                                "");
2546     }
2547
2548   add_prefix (&exec_prefix, concat (tooldir_prefix, "bin", "/"),
2549               0, 0, NULL_PTR);
2550   add_prefix (&startfile_prefix, concat (tooldir_prefix, "lib", "/"),
2551               0, 0, NULL_PTR);
2552
2553   /* More prefixes are enabled in main, after we read the specs file
2554      and determine whether this is cross-compilation or not.  */
2555
2556
2557   /* Then create the space for the vectors and scan again.  */
2558
2559   switches = ((struct switchstr *)
2560               xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
2561   infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
2562   n_switches = 0;
2563   n_infiles = 0;
2564   last_language_n_infiles = -1;
2565
2566   /* This, time, copy the text of each switch and store a pointer
2567      to the copy in the vector of switches.
2568      Store all the infiles in their vector.  */
2569
2570   for (i = 1; i < argc; i++)
2571     {
2572       /* Just skip the switches that were handled by the preceding loop.  */
2573       if (!strcmp (argv[i], "-Xlinker"))
2574         i++;
2575       else if (! strncmp (argv[i], "-Wl,", 4))
2576         ;
2577       else if (! strncmp (argv[i], "-Wa,", 4))
2578         ;
2579       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2580         ;
2581       else if (! strncmp (argv[i], "-print-file-name=", 17))
2582         ;
2583       else if (! strncmp (argv[i], "-print-prog-name=", 17))
2584         ;
2585       else if (argv[i][0] == '+' && argv[i][1] == 'e')
2586         {
2587           /* Compensate for the +e options to the C++ front-end;
2588              they're there simply for cfront call-compatibility.  We do
2589              some magic in default_compilers to pass them down properly.
2590              Note we deliberately start at the `+' here, to avoid passing
2591              -e0 or -e1 down into the linker.  */
2592           switches[n_switches].part1 = &argv[i][0];
2593           switches[n_switches].args = 0;
2594           switches[n_switches].live_cond = 0;
2595           switches[n_switches].valid = 0;
2596           n_switches++;
2597         }
2598       else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2599         {
2600           register char *p = &argv[i][1];
2601           register int c = *p;
2602
2603           if (c == 'B' || c == 'b' || c == 'V')
2604             {
2605               /* Skip a separate arg, if any.  */
2606               if (p[1] == 0)
2607                 i++;
2608               continue;
2609             }
2610           if (c == 'x')
2611             {
2612               if (p[1] == 0 && i + 1 == argc)
2613                 fatal ("argument to `-x' is missing");
2614               if (p[1] == 0)
2615                 spec_lang = argv[++i];
2616               else
2617                 spec_lang = p + 1;
2618               if (! strcmp (spec_lang, "none"))
2619                 /* Suppress the warning if -xnone comes after the last input file,
2620                    because alternate command interfaces like g++ might find it
2621                    useful to place -xnone after each input file.  */
2622                 spec_lang = 0;
2623               else
2624                 last_language_n_infiles = n_infiles;
2625               continue;
2626             }
2627           switches[n_switches].part1 = p;
2628           /* Deal with option arguments in separate argv elements.  */
2629           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
2630               || WORD_SWITCH_TAKES_ARG (p))
2631             {
2632               int j = 0;
2633               int n_args = WORD_SWITCH_TAKES_ARG (p);
2634
2635               if (n_args == 0)
2636                 {
2637                   /* Count only the option arguments in separate argv elements.  */
2638                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
2639                 }
2640               if (i + n_args >= argc)
2641                 fatal ("argument to `-%s' is missing", p);
2642               switches[n_switches].args
2643                 = (char **) xmalloc ((n_args + 1) * sizeof (char *));
2644               while (j < n_args)
2645                 switches[n_switches].args[j++] = argv[++i];
2646               /* Null-terminate the vector.  */
2647               switches[n_switches].args[j] = 0;
2648             }
2649           else if (*switches_need_spaces != 0 && (c == 'o' || c == 'L'))
2650             {
2651               /* On some systems, ld cannot handle -o or -L without space.
2652                  So split the -o or -L from its argument.  */
2653               switches[n_switches].part1 = (c == 'o' ? "o" : "L");
2654               switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
2655               switches[n_switches].args[0] = xmalloc (strlen (p));
2656               strcpy (switches[n_switches].args[0], &p[1]);
2657               switches[n_switches].args[1] = 0;
2658             }
2659           else
2660             switches[n_switches].args = 0;
2661
2662           switches[n_switches].live_cond = 0;
2663           switches[n_switches].valid = 0;
2664           /* This is always valid, since gcc.c itself understands it.  */
2665           if (!strcmp (p, "save-temps"))
2666             switches[n_switches].valid = 1;
2667           n_switches++;
2668         }
2669       else
2670         {
2671           if ((argv[i][0] != '-' || argv[i][1] != 'l')
2672               && strcmp (argv[i], "-")
2673               && access (argv[i], R_OK) < 0)
2674             {
2675               perror_with_name (argv[i]);
2676               error_count++;
2677             }
2678           else
2679             {
2680               infiles[n_infiles].language = spec_lang;
2681               infiles[n_infiles++].name = argv[i];
2682             }
2683         }
2684     }
2685
2686   if (n_infiles == last_language_n_infiles && spec_lang != 0)
2687     error ("Warning: `-x %s' after last input file has no effect", spec_lang);
2688
2689   switches[n_switches].part1 = 0;
2690   infiles[n_infiles].name = 0;
2691
2692   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
2693   if (gcc_exec_prefix)
2694     {
2695       temp = (char *) xmalloc (strlen (gcc_exec_prefix) + strlen (spec_version)
2696                                + strlen (spec_machine) + 3);
2697       strcpy (temp, gcc_exec_prefix);
2698       strcat (temp, spec_machine);
2699       strcat (temp, "/");
2700       strcat (temp, spec_version);
2701       strcat (temp, "/");
2702       gcc_exec_prefix = temp;
2703     }
2704 }
2705 \f
2706 /* Process a spec string, accumulating and running commands.  */
2707
2708 /* These variables describe the input file name.
2709    input_file_number is the index on outfiles of this file,
2710    so that the output file name can be stored for later use by %o.
2711    input_basename is the start of the part of the input file
2712    sans all directory names, and basename_length is the number
2713    of characters starting there excluding the suffix .c or whatever.  */
2714
2715 static char *input_filename;
2716 static int input_file_number;
2717 static int input_filename_length;
2718 static int basename_length;
2719 static char *input_basename;
2720 static char *input_suffix;
2721
2722 /* These are variables used within do_spec and do_spec_1.  */
2723
2724 /* Nonzero if an arg has been started and not yet terminated
2725    (with space, tab or newline).  */
2726 static int arg_going;
2727
2728 /* Nonzero means %d or %g has been seen; the next arg to be terminated
2729    is a temporary file name.  */
2730 static int delete_this_arg;
2731
2732 /* Nonzero means %w has been seen; the next arg to be terminated
2733    is the output file name of this compilation.  */
2734 static int this_is_output_file;
2735
2736 /* Nonzero means %s has been seen; the next arg to be terminated
2737    is the name of a library file and we should try the standard
2738    search dirs for it.  */
2739 static int this_is_library_file;
2740
2741 /* Nonzero means that the input of this command is coming from a pipe.  */
2742 static int input_from_pipe;
2743
2744 /* Process the spec SPEC and run the commands specified therein.
2745    Returns 0 if the spec is successfully processed; -1 if failed.  */
2746
2747 static int
2748 do_spec (spec)
2749      char *spec;
2750 {
2751   int value;
2752
2753   clear_args ();
2754   arg_going = 0;
2755   delete_this_arg = 0;
2756   this_is_output_file = 0;
2757   this_is_library_file = 0;
2758   input_from_pipe = 0;
2759
2760   value = do_spec_1 (spec, 0, NULL_PTR);
2761
2762   /* Force out any unfinished command.
2763      If -pipe, this forces out the last command if it ended in `|'.  */
2764   if (value == 0)
2765     {
2766       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2767         argbuf_index--;
2768
2769       if (argbuf_index > 0)
2770         value = execute ();
2771     }
2772
2773   return value;
2774 }
2775
2776 /* Process the sub-spec SPEC as a portion of a larger spec.
2777    This is like processing a whole spec except that we do
2778    not initialize at the beginning and we do not supply a
2779    newline by default at the end.
2780    INSWITCH nonzero means don't process %-sequences in SPEC;
2781    in this case, % is treated as an ordinary character.
2782    This is used while substituting switches.
2783    INSWITCH nonzero also causes SPC not to terminate an argument.
2784
2785    Value is zero unless a line was finished
2786    and the command on that line reported an error.  */
2787
2788 static int
2789 do_spec_1 (spec, inswitch, soft_matched_part)
2790      char *spec;
2791      int inswitch;
2792      char *soft_matched_part;
2793 {
2794   register char *p = spec;
2795   register int c;
2796   int i;
2797   char *string;
2798   int value;
2799
2800   while (c = *p++)
2801     /* If substituting a switch, treat all chars like letters.
2802        Otherwise, NL, SPC, TAB and % are special.  */
2803     switch (inswitch ? 'a' : c)
2804       {
2805       case '\n':
2806         /* End of line: finish any pending argument,
2807            then run the pending command if one has been started.  */
2808         if (arg_going)
2809           {
2810             obstack_1grow (&obstack, 0);
2811             string = obstack_finish (&obstack);
2812             if (this_is_library_file)
2813               string = find_file (string);
2814             store_arg (string, delete_this_arg, this_is_output_file);
2815             if (this_is_output_file)
2816               outfiles[input_file_number] = string;
2817           }
2818         arg_going = 0;
2819
2820         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2821           {
2822             int i;
2823             for (i = 0; i < n_switches; i++)
2824               if (!strcmp (switches[i].part1, "pipe"))
2825                 break;
2826
2827             /* A `|' before the newline means use a pipe here,
2828                but only if -pipe was specified.
2829                Otherwise, execute now and don't pass the `|' as an arg.  */
2830             if (i < n_switches)
2831               {
2832                 input_from_pipe = 1;
2833                 switches[i].valid = 1;
2834                 break;
2835               }
2836             else
2837               argbuf_index--;
2838           }
2839
2840         if (argbuf_index > 0)
2841           {
2842             value = execute ();
2843             if (value)
2844               return value;
2845           }
2846         /* Reinitialize for a new command, and for a new argument.  */
2847         clear_args ();
2848         arg_going = 0;
2849         delete_this_arg = 0;
2850         this_is_output_file = 0;
2851         this_is_library_file = 0;
2852         input_from_pipe = 0;
2853         break;
2854
2855       case '|':
2856         /* End any pending argument.  */
2857         if (arg_going)
2858           {
2859             obstack_1grow (&obstack, 0);
2860             string = obstack_finish (&obstack);
2861             if (this_is_library_file)
2862               string = find_file (string);
2863             store_arg (string, delete_this_arg, this_is_output_file);
2864             if (this_is_output_file)
2865               outfiles[input_file_number] = string;
2866           }
2867
2868         /* Use pipe */
2869         obstack_1grow (&obstack, c);
2870         arg_going = 1;
2871         break;
2872
2873       case '\t':
2874       case ' ':
2875         /* Space or tab ends an argument if one is pending.  */
2876         if (arg_going)
2877           {
2878             obstack_1grow (&obstack, 0);
2879             string = obstack_finish (&obstack);
2880             if (this_is_library_file)
2881               string = find_file (string);
2882             store_arg (string, delete_this_arg, this_is_output_file);
2883             if (this_is_output_file)
2884               outfiles[input_file_number] = string;
2885           }
2886         /* Reinitialize for a new argument.  */
2887         arg_going = 0;
2888         delete_this_arg = 0;
2889         this_is_output_file = 0;
2890         this_is_library_file = 0;
2891         break;
2892
2893       case '%':
2894         switch (c = *p++)
2895           {
2896           case 0:
2897             fatal ("Invalid specification!  Bug in cc.");
2898
2899           case 'b':
2900             obstack_grow (&obstack, input_basename, basename_length);
2901             arg_going = 1;
2902             break;
2903
2904           case 'd':
2905             delete_this_arg = 2;
2906             break;
2907
2908           /* Dump out the directories specified with LIBRARY_PATH,
2909              followed by the absolute directories
2910              that we search for startfiles.  */
2911           case 'D':
2912             {
2913               struct prefix_list *pl = startfile_prefix.plist;
2914               int bufsize = 100;
2915               char *buffer = (char *) xmalloc (bufsize);
2916               int idx;
2917
2918               for (; pl; pl = pl->next)
2919                 {
2920 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
2921                   /* Used on systems which record the specified -L dirs
2922                      and use them to search for dynamic linking.  */
2923                   /* Relative directories always come from -B,
2924                      and it is better not to use them for searching
2925                      at run time.  In particular, stage1 loses  */
2926                   if (pl->prefix[0] != '/')
2927                     continue;
2928 #endif
2929                   if (machine_suffix)
2930                     {
2931                       if (is_directory (pl->prefix, machine_suffix, 1))
2932                         {
2933                           do_spec_1 ("-L", 0, NULL_PTR);
2934 #ifdef SPACE_AFTER_L_OPTION
2935                           do_spec_1 (" ", 0, NULL_PTR);
2936 #endif
2937                           do_spec_1 (pl->prefix, 1, NULL_PTR);
2938                           /* Remove slash from machine_suffix.  */
2939                           if (strlen (machine_suffix) >= bufsize)
2940                             bufsize = strlen (machine_suffix) * 2 + 1;
2941                           buffer = (char *) xrealloc (buffer, bufsize);
2942                           strcpy (buffer, machine_suffix);
2943                           idx = strlen (buffer);
2944                           if (buffer[idx - 1] == '/')
2945                             buffer[idx - 1] = 0;
2946                           do_spec_1 (buffer, 1, NULL_PTR);
2947                           /* Make this a separate argument.  */
2948                           do_spec_1 (" ", 0, NULL_PTR);
2949                         }
2950                     }
2951                   if (!pl->require_machine_suffix)
2952                     {
2953                       if (is_directory (pl->prefix, "", 1))
2954                         {
2955                           do_spec_1 ("-L", 0, NULL_PTR);
2956 #ifdef SPACE_AFTER_L_OPTION
2957                           do_spec_1 (" ", 0, NULL_PTR);
2958 #endif
2959                           /* Remove slash from pl->prefix.  */
2960                           if (strlen (pl->prefix) >= bufsize)
2961                             bufsize = strlen (pl->prefix) * 2 + 1;
2962                           buffer = (char *) xrealloc (buffer, bufsize);
2963                           strcpy (buffer, pl->prefix);
2964                           idx = strlen (buffer);
2965                           if (buffer[idx - 1] == '/')
2966                             buffer[idx - 1] = 0;
2967                           do_spec_1 (buffer, 1, NULL_PTR);
2968                           /* Make this a separate argument.  */
2969                           do_spec_1 (" ", 0, NULL_PTR);
2970                         }
2971                     }
2972                 }
2973               free (buffer);
2974             }
2975             break;
2976
2977           case 'e':
2978             /* {...:%efoo} means report an error with `foo' as error message
2979                and don't execute any more commands for this file.  */
2980             {
2981               char *q = p;
2982               char *buf;
2983               while (*p != 0 && *p != '\n') p++;
2984               buf = (char *) alloca (p - q + 1);
2985               strncpy (buf, q, p - q);
2986               buf[p - q] = 0;
2987               error ("%s", buf);
2988               return -1;
2989             }
2990             break;
2991
2992           case 'g':
2993           case 'u':
2994           case 'U':
2995             if (save_temps_flag)
2996               obstack_grow (&obstack, input_basename, basename_length);
2997             else
2998               {
2999 #ifdef MKTEMP_EACH_FILE
3000                 /* ??? This has a problem: the total number of
3001                    values mktemp can return is limited.
3002                    That matters for the names of object files.
3003                    In 2.4, do something about that.  */
3004                 struct temp_name *t;
3005                 char *suffix = p;
3006                 while (*p == '.' || isalpha (*p))
3007                   p++;
3008
3009                 /* See if we already have an association of %g/%u/%U and
3010                    suffix.  */
3011                 for (t = temp_names; t; t = t->next)
3012                   if (t->length == p - suffix
3013                       && strncmp (t->suffix, suffix, p - suffix) == 0
3014                       && t->unique == (c != 'g'))
3015                     break;
3016
3017                 /* Make a new association if needed.  %u requires one.  */
3018                 if (t == 0 || c == 'u')
3019                   {
3020                     if (t == 0)
3021                       {
3022                         t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
3023                         t->next = temp_names;
3024                         temp_names = t;
3025                       }
3026                     t->length = p - suffix;
3027                     t->suffix = save_string (suffix, p - suffix);
3028                     t->unique = (c != 'g');
3029                     choose_temp_base ();
3030                     t->filename = temp_filename;
3031                     t->filename_length = temp_filename_length;
3032                   }
3033
3034                 obstack_grow (&obstack, t->filename, t->filename_length);
3035                 delete_this_arg = 1;
3036 #else
3037                 obstack_grow (&obstack, temp_filename, temp_filename_length);
3038                 if (c == 'u' || c == 'U')
3039                   {
3040                     static int unique;
3041                     char buff[9];
3042                     if (c == 'u')
3043                       unique++;
3044                     sprintf (buff, "%d", unique);
3045                     obstack_grow (&obstack, buff, strlen (buff));
3046                   }
3047 #endif
3048                 delete_this_arg = 1;
3049               }
3050             arg_going = 1;
3051             break;
3052
3053           case 'i':
3054             obstack_grow (&obstack, input_filename, input_filename_length);
3055             arg_going = 1;
3056             break;
3057
3058           case 'I':
3059             {
3060               struct prefix_list *pl = include_prefix.plist;
3061
3062               if (gcc_exec_prefix)
3063                 {
3064                   do_spec_1 ("-iprefix", 1, NULL_PTR);
3065                   /* Make this a separate argument.  */
3066                   do_spec_1 (" ", 0, NULL_PTR);
3067                   do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
3068                   do_spec_1 (" ", 0, NULL_PTR);
3069                 }
3070
3071               for (; pl; pl = pl->next)
3072                 {
3073                   do_spec_1 ("-isystem", 1, NULL_PTR);
3074                   /* Make this a separate argument.  */
3075                   do_spec_1 (" ", 0, NULL_PTR);
3076                   do_spec_1 (pl->prefix, 1, NULL_PTR);
3077                   do_spec_1 (" ", 0, NULL_PTR);
3078                 }
3079             }
3080             break;
3081
3082           case 'o':
3083             {
3084               register int f;
3085               for (f = 0; f < n_infiles; f++)
3086                 store_arg (outfiles[f], 0, 0);
3087             }
3088             break;
3089
3090           case 's':
3091             this_is_library_file = 1;
3092             break;
3093
3094           case 'w':
3095             this_is_output_file = 1;
3096             break;
3097
3098           case 'W':
3099             {
3100               int index = argbuf_index;
3101               /* Handle the {...} following the %W.  */
3102               if (*p != '{')
3103                 abort ();
3104               p = handle_braces (p + 1);
3105               if (p == 0)
3106                 return -1;
3107               /* If any args were output, mark the last one for deletion
3108                  on failure.  */
3109               if (argbuf_index != index)
3110                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
3111               break;
3112             }
3113
3114           /* %x{OPTION} records OPTION for %X to output.  */
3115           case 'x':
3116             {
3117               char *p1 = p;
3118               char *string;
3119
3120               /* Skip past the option value and make a copy.  */
3121               if (*p != '{')
3122                 abort ();
3123               while (*p++ != '}')
3124                 ;
3125               string = save_string (p1 + 1, p - p1 - 2);
3126
3127               /* See if we already recorded this option.  */
3128               for (i = 0; i < n_linker_options; i++)
3129                 if (! strcmp (string, linker_options[i]))
3130                   {
3131                     free (string);
3132                     return 0;
3133                   }
3134
3135               /* This option is new; add it.  */
3136               n_linker_options++;
3137               if (!linker_options)
3138                 linker_options
3139                   = (char **) xmalloc (n_linker_options * sizeof (char **));
3140               else
3141                 linker_options
3142                   = (char **) xrealloc (linker_options,
3143                                         n_linker_options * sizeof (char **));
3144
3145               linker_options[n_linker_options - 1] = string;
3146             }
3147             break;
3148
3149           /* Dump out the options accumulated previously using %x,
3150              -Xlinker and -Wl,.  */
3151           case 'X':
3152             for (i = 0; i < n_linker_options; i++)
3153               {
3154                 do_spec_1 (linker_options[i], 1, NULL_PTR);
3155                 /* Make each accumulated option a separate argument.  */
3156                 do_spec_1 (" ", 0, NULL_PTR);
3157               }
3158             break;
3159
3160           /* Dump out the options accumulated previously using -Wa,.  */
3161           case 'Y':
3162             for (i = 0; i < n_assembler_options; i++)
3163               {
3164                 do_spec_1 (assembler_options[i], 1, NULL_PTR);
3165                 /* Make each accumulated option a separate argument.  */
3166                 do_spec_1 (" ", 0, NULL_PTR);
3167               }
3168             break;
3169
3170             /* Here are digits and numbers that just process
3171                a certain constant string as a spec.  */
3172
3173           case '1':
3174             value = do_spec_1 (cc1_spec, 0, NULL_PTR);
3175             if (value != 0)
3176               return value;
3177             break;
3178
3179           case '2':
3180             value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
3181             if (value != 0)
3182               return value;
3183             break;
3184
3185           case 'a':
3186             value = do_spec_1 (asm_spec, 0, NULL_PTR);
3187             if (value != 0)
3188               return value;
3189             break;
3190
3191           case 'A':
3192             value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
3193             if (value != 0)
3194               return value;
3195             break;
3196
3197           case 'c':
3198             value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
3199             if (value != 0)
3200               return value;
3201             break;
3202
3203           case 'C':
3204             value = do_spec_1 (cpp_spec, 0, NULL_PTR);
3205             if (value != 0)
3206               return value;
3207             break;
3208
3209           case 'E':
3210             value = do_spec_1 (endfile_spec, 0, NULL_PTR);
3211             if (value != 0)
3212               return value;
3213             break;
3214
3215           case 'l':
3216             value = do_spec_1 (link_spec, 0, NULL_PTR);
3217             if (value != 0)
3218               return value;
3219             break;
3220
3221           case 'L':
3222             value = do_spec_1 (lib_spec, 0, NULL_PTR);
3223             if (value != 0)
3224               return value;
3225             break;
3226
3227           case 'p':
3228             {
3229               char *x = (char *) alloca (strlen (cpp_predefines) + 1);
3230               char *buf = x;
3231               char *y;
3232
3233               /* Copy all of the -D options in CPP_PREDEFINES into BUF.  */
3234               y = cpp_predefines;
3235               while (*y != 0)
3236                 {
3237                   if (! strncmp (y, "-D", 2))
3238                     /* Copy the whole option.  */
3239                     while (*y && *y != ' ' && *y != '\t')
3240                       *x++ = *y++;
3241                   else if (*y == ' ' || *y == '\t')
3242                     /* Copy whitespace to the result.  */
3243                     *x++ = *y++;
3244                   /* Don't copy other options.  */
3245                   else
3246                     y++;
3247                 }
3248
3249               *x = 0;
3250
3251               value = do_spec_1 (buf, 0, NULL_PTR);
3252               if (value != 0)
3253                 return value;
3254             }
3255             break;
3256
3257           case 'P':
3258             {
3259               char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
3260               char *buf = x;
3261               char *y;
3262
3263               /* Copy all of CPP_PREDEFINES into BUF,
3264                  but put __ after every -D and at the end of each arg.  */
3265               y = cpp_predefines;
3266               while (*y != 0)
3267                 {
3268                   if (! strncmp (y, "-D", 2))
3269                     {
3270                       int flag = 0;
3271
3272                       *x++ = *y++;
3273                       *x++ = *y++;
3274
3275                       if (strncmp (y, "__", 2))
3276                         {
3277                           /* Stick __ at front of macro name.  */
3278                           *x++ = '_';
3279                           *x++ = '_';
3280                           /* Arrange to stick __ at the end as well.  */
3281                           flag = 1;
3282                         }
3283
3284                       /* Copy the macro name.  */
3285                       while (*y && *y != '=' && *y != ' ' && *y != '\t')
3286                         *x++ = *y++;
3287
3288                       if (flag)
3289                         {
3290                           *x++ = '_';
3291                           *x++ = '_';
3292                         }
3293
3294                       /* Copy the value given, if any.  */
3295                       while (*y && *y != ' ' && *y != '\t')
3296                         *x++ = *y++;
3297                     }
3298                   else if (*y == ' ' || *y == '\t')
3299                     /* Copy whitespace to the result.  */
3300                     *x++ = *y++;
3301                   /* Don't copy -A options  */
3302                   else
3303                     y++;
3304                 }
3305               *x++ = ' ';
3306
3307               /* Copy all of CPP_PREDEFINES into BUF,
3308                  but put __ after every -D.  */
3309               y = cpp_predefines;
3310               while (*y != 0)
3311                 {
3312                   if (! strncmp (y, "-D", 2))
3313                     {
3314                       y += 2;
3315
3316                       if (strncmp (y, "__", 2))
3317                         {
3318                           /* Stick -D__ at front of macro name.  */
3319                           *x++ = '-';
3320                           *x++ = 'D';
3321                           *x++ = '_';
3322                           *x++ = '_';
3323
3324                           /* Copy the macro name.  */
3325                           while (*y && *y != '=' && *y != ' ' && *y != '\t')
3326                             *x++ = *y++;
3327
3328                           /* Copy the value given, if any.  */
3329                           while (*y && *y != ' ' && *y != '\t')
3330                             *x++ = *y++;
3331                         }
3332                       else
3333                         {
3334                           /* Do not copy this macro - we have just done it before */
3335                           while (*y && *y != ' ' && *y != '\t')
3336                             y++;
3337                         }
3338                     }
3339                   else if (*y == ' ' || *y == '\t')
3340                     /* Copy whitespace to the result.  */
3341                     *x++ = *y++;
3342                   /* Don't copy -A options  */
3343                   else
3344                     y++;
3345                 }
3346               *x++ = ' ';
3347
3348               /* Copy all of the -A options in CPP_PREDEFINES into BUF.  */
3349               y = cpp_predefines;
3350               while (*y != 0)
3351                 {
3352                   if (! strncmp (y, "-A", 2))
3353                     /* Copy the whole option.  */
3354                     while (*y && *y != ' ' && *y != '\t')
3355                       *x++ = *y++;
3356                   else if (*y == ' ' || *y == '\t')
3357                     /* Copy whitespace to the result.  */
3358                     *x++ = *y++;
3359                   /* Don't copy other options.  */
3360                   else
3361                     y++;
3362                 }
3363
3364               *x = 0;
3365
3366               value = do_spec_1 (buf, 0, NULL_PTR);
3367               if (value != 0)
3368                 return value;
3369             }
3370             break;
3371
3372           case 'S':
3373             value = do_spec_1 (startfile_spec, 0, NULL_PTR);
3374             if (value != 0)
3375               return value;
3376             break;
3377
3378             /* Here we define characters other than letters and digits.  */
3379
3380           case '{':
3381             p = handle_braces (p);
3382             if (p == 0)
3383               return -1;
3384             break;
3385
3386           case '%':
3387             obstack_1grow (&obstack, '%');
3388             break;
3389
3390           case '*':
3391             do_spec_1 (soft_matched_part, 1, NULL_PTR);
3392             do_spec_1 (" ", 0, NULL_PTR);
3393             break;
3394
3395             /* Process a string found as the value of a spec given by name.
3396                This feature allows individual machine descriptions
3397                to add and use their own specs.
3398                %[...] modifies -D options the way %P does;
3399                %(...) uses the spec unmodified.  */
3400           case '(':
3401           case '[':
3402             {
3403               char *name = p;
3404               struct spec_list *sl;
3405               int len;
3406
3407               /* The string after the S/P is the name of a spec that is to be
3408                  processed. */
3409               while (*p && *p != ')' && *p != ']')
3410                 p++;
3411
3412               /* See if it's in the list */
3413               for (len = p - name, sl = specs; sl; sl = sl->next)
3414                 if (strncmp (sl->name, name, len) == 0 && !sl->name[len])
3415                   {
3416                     name = sl->spec;
3417                     break;
3418                   }
3419
3420               if (sl)
3421                 {
3422                   if (c == '(')
3423                     {
3424                       value = do_spec_1 (name, 0, NULL_PTR);
3425                       if (value != 0)
3426                         return value;
3427                     }
3428                   else
3429                     {
3430                       char *x = (char *) alloca (strlen (name) * 2 + 1);
3431                       char *buf = x;
3432                       char *y = name;
3433
3434                       /* Copy all of NAME into BUF, but put __ after
3435                          every -D and at the end of each arg,  */
3436                       while (1)
3437                         {
3438                           if (! strncmp (y, "-D", 2))
3439                             {
3440                               *x++ = '-';
3441                               *x++ = 'D';
3442                               *x++ = '_';
3443                               *x++ = '_';
3444                               y += 2;
3445                             }
3446                           else if (*y == ' ' || *y == 0)
3447                             {
3448                               *x++ = '_';
3449                               *x++ = '_';
3450                               if (*y == 0)
3451                                 break;
3452                               else
3453                                 *x++ = *y++;
3454                             }
3455                           else
3456                             *x++ = *y++;
3457                         }
3458                       *x = 0;
3459
3460                       value = do_spec_1 (buf, 0, NULL_PTR);
3461                       if (value != 0)
3462                         return value;
3463                     }
3464                 }
3465
3466               /* Discard the closing paren or bracket.  */
3467               if (*p)
3468                 p++;
3469             }
3470             break;
3471
3472           case 'v':
3473             {
3474               int c1 = *p++;  /* Select first or second version number.  */
3475               char *v = compiler_version;
3476               char *q, *copy;
3477               /* If desired, advance to second version number.  */
3478               if (c1 == '2')
3479                 {
3480                   /* Set P after the first period.  */
3481                   while (*v != 0 && *v != ' ' && *v != '.')
3482                     v++;
3483                   if (*v == '.')
3484                     v++;
3485                 }
3486               /* Set Q at the next period or at the end.  */
3487               q = v;
3488               while (*q != 0 && *q != ' ' && *q != '.')
3489                 q++;
3490               /* Empty string means zero.  */
3491               if (p == q)
3492                 {
3493                   v = "0";
3494                   q = v + 1;
3495                 }
3496               /* Put that part into the command.  */
3497               obstack_grow (&obstack, v, q - v);
3498               arg_going = 1;
3499             }
3500             break;
3501
3502           case '|':
3503             if (input_from_pipe)
3504               do_spec_1 ("-", 0, NULL_PTR);
3505             break;
3506
3507           default:
3508             abort ();
3509           }
3510         break;
3511
3512       case '\\':
3513         /* Backslash: treat next character as ordinary.  */
3514         c = *p++;
3515
3516         /* fall through */
3517       default:
3518         /* Ordinary character: put it into the current argument.  */
3519         obstack_1grow (&obstack, c);
3520         arg_going = 1;
3521       }
3522
3523   return 0;             /* End of string */
3524 }
3525
3526 /* Return 0 if we call do_spec_1 and that returns -1.  */
3527
3528 static char *
3529 handle_braces (p)
3530      register char *p;
3531 {
3532   register char *q;
3533   char *filter;
3534   int pipe = 0;
3535   int negate = 0;
3536   int suffix = 0;
3537
3538   if (*p == '|')
3539     /* A `|' after the open-brace means,
3540        if the test fails, output a single minus sign rather than nothing.
3541        This is used in %{|!pipe:...}.  */
3542     pipe = 1, ++p;
3543
3544   if (*p == '!')
3545     /* A `!' after the open-brace negates the condition:
3546        succeed if the specified switch is not present.  */
3547     negate = 1, ++p;
3548
3549   if (*p == '.')
3550     /* A `.' after the open-brace means test against the current suffix.  */
3551     {
3552       if (pipe)
3553         abort ();
3554
3555       suffix = 1;
3556       ++p;
3557     }
3558
3559   filter = p;
3560   while (*p != ':' && *p != '}') p++;
3561   if (*p != '}')
3562     {
3563       register int count = 1;
3564       q = p + 1;
3565       while (count > 0)
3566         {
3567           if (*q == '{')
3568             count++;
3569           else if (*q == '}')
3570             count--;
3571           else if (*q == 0)
3572             abort ();
3573           q++;
3574         }
3575     }
3576   else
3577     q = p + 1;
3578
3579   if (suffix)
3580     {
3581       int found = (input_suffix != 0
3582                    && strlen (input_suffix) == p - filter
3583                    && strncmp (input_suffix, filter, p - filter) == 0);
3584
3585       if (p[0] == '}')
3586         abort ();
3587
3588       if (negate != found
3589           && do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
3590         return 0;
3591
3592       return q;
3593     }
3594   else if (p[-1] == '*' && p[0] == '}')
3595     {
3596       /* Substitute all matching switches as separate args.  */
3597       register int i;
3598       --p;
3599       for (i = 0; i < n_switches; i++)
3600         if (!strncmp (switches[i].part1, filter, p - filter)
3601             && check_live_switch (i, p - filter))
3602           give_switch (i, 0);
3603     }
3604   else
3605     {
3606       /* Test for presence of the specified switch.  */
3607       register int i;
3608       int present = 0;
3609
3610       /* If name specified ends in *, as in {x*:...},
3611          check for %* and handle that case.  */
3612       if (p[-1] == '*' && !negate)
3613         {
3614           int substitution;
3615           char *r = p;
3616
3617           /* First see whether we have %*.  */
3618           substitution = 0;
3619           while (r < q)
3620             {
3621               if (*r == '%' && r[1] == '*')
3622                 substitution = 1;
3623               r++;
3624             }
3625           /* If we do, handle that case.  */
3626           if (substitution)
3627             {
3628               /* Substitute all matching switches as separate args.
3629                  But do this by substituting for %*
3630                  in the text that follows the colon.  */
3631
3632               unsigned hard_match_len = p - filter - 1;
3633               char *string = save_string (p + 1, q - p - 2);
3634
3635               for (i = 0; i < n_switches; i++)
3636                 if (!strncmp (switches[i].part1, filter, hard_match_len)
3637                     && check_live_switch (i, hard_match_len))
3638                   {
3639                     do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
3640                     /* Pass any arguments this switch has.  */
3641                     give_switch (i, 1);
3642                   }
3643
3644               return q;
3645             }
3646         }
3647
3648       /* If name specified ends in *, as in {x*:...},
3649          check for presence of any switch name starting with x.  */
3650       if (p[-1] == '*')
3651         {
3652           for (i = 0; i < n_switches; i++)
3653             {
3654               unsigned hard_match_len = p - filter - 1;
3655
3656               if (!strncmp (switches[i].part1, filter, hard_match_len)
3657                   && check_live_switch (i, hard_match_len))
3658                 {
3659                   present = 1;
3660                 }
3661             }
3662         }
3663       /* Otherwise, check for presence of exact name specified.  */
3664       else
3665         {
3666           for (i = 0; i < n_switches; i++)
3667             {
3668               if (!strncmp (switches[i].part1, filter, p - filter)
3669                   && switches[i].part1[p - filter] == 0
3670                   && check_live_switch (i, p - filter))
3671                 {
3672                   present = 1;
3673                   break;
3674                 }
3675             }
3676         }
3677
3678       /* If it is as desired (present for %{s...}, absent for %{-s...})
3679          then substitute either the switch or the specified
3680          conditional text.  */
3681       if (present != negate)
3682         {
3683           if (*p == '}')
3684             {
3685               give_switch (i, 0);
3686             }
3687           else
3688             {
3689               if (do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
3690                 return 0;
3691             }
3692         }
3693       else if (pipe)
3694         {
3695           /* Here if a %{|...} conditional fails: output a minus sign,
3696              which means "standard output" or "standard input".  */
3697           do_spec_1 ("-", 0, NULL_PTR);
3698         }
3699     }
3700
3701   return q;
3702 }
3703 \f
3704 /* Return 0 if switch number SWITCHNUM is obsoleted by a later switch
3705    on the command line.  LENGTH is the length of the switch name we
3706    are to compare for.  Otherwise return zero.
3707
3708    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
3709    whose value does not begin with "no-" is obsoleted by the same value
3710    with the "no-", similarly for a switch with the "no-" prefix.  */
3711
3712 static int
3713 check_live_switch (switchnum, length)
3714      int switchnum;
3715      int length;
3716 {
3717   char *name = switches[switchnum].part1;
3718   int i;
3719
3720   /* If we just have a single letter and it isn't "O", a negating
3721      switch would always match, so ignore that case.  We will just
3722      send the conflicting switches to the compiler phase.  */
3723   if (length == 1 && name[0] != 'O')
3724     return 1;
3725
3726   /* If we already processed this switch and determined if it was
3727      live or not, return our past determination.  */
3728   if (switches[switchnum].live_cond != 0)
3729     return switches[switchnum].live_cond > 0;
3730
3731   /* Now search for duplicate in a manner that depends on the name.  */
3732   switch (*name)
3733     {
3734     case 'O':
3735       if (length == 1)
3736         for (i = switchnum + 1; i < n_switches; i++)
3737           if (switches[i].part1[0] == 'O')
3738             {
3739               switches[switchnum].valid = 1;
3740               switches[switchnum].live_cond = -1;
3741               return 0;
3742             }
3743       break;
3744
3745     case 'W':  case 'f':  case 'm':
3746       if (length > 4 && ! strncmp (name + 1, "no-", 3))
3747         {
3748           /* We have Xno-YYY, search for XYYY. */
3749           for (i = switchnum + 1; i < n_switches; i++)
3750             if (switches[i].part1[0] == name[0]
3751                 && ! strcmp (&switches[i].part1[1], &name[4]))
3752             {
3753               switches[switchnum].valid = 1;
3754               switches[switchnum].live_cond = -1;
3755               return 0;
3756             }
3757         }
3758       else
3759         {
3760           /* We have XYYY, search for Xno-YYY.  */
3761           for (i = switchnum + 1; i < n_switches; i++)
3762             if (switches[i].part1[0] == name[0]
3763                 && switches[i].part1[1] == 'n'
3764                 && switches[i].part1[2] == 'o'
3765                 && switches[i].part1[3] == '-'
3766                 && !strcmp (&switches[i].part1[4], &name[1]))
3767             {
3768               switches[switchnum].valid = 1;
3769               switches[switchnum].live_cond = -1;
3770               return 0;
3771             }
3772         }
3773       break;
3774     }
3775
3776   /* Otherwise the switch is live.  */
3777   switches[switchnum].live_cond = 1;
3778   return 1;
3779 }
3780 \f
3781 /* Pass a switch to the current accumulating command
3782    in the same form that we received it.
3783    SWITCHNUM identifies the switch; it is an index into
3784    the vector of switches gcc received, which is `switches'.
3785    This cannot fail since it never finishes a command line.
3786
3787    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
3788
3789 static void
3790 give_switch (switchnum, omit_first_word)
3791      int switchnum;
3792      int omit_first_word;
3793 {
3794   if (!omit_first_word)
3795     {
3796       do_spec_1 ("-", 0, NULL_PTR);
3797       do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
3798     }
3799   do_spec_1 (" ", 0, NULL_PTR);
3800   if (switches[switchnum].args != 0)
3801     {
3802       char **p;
3803       for (p = switches[switchnum].args; *p; p++)
3804         {
3805           do_spec_1 (*p, 1, NULL_PTR);
3806           do_spec_1 (" ", 0, NULL_PTR);
3807         }
3808     }
3809   switches[switchnum].valid = 1;
3810 }
3811 \f
3812 /* Search for a file named NAME trying various prefixes including the
3813    user's -B prefix and some standard ones.
3814    Return the absolute file name found.  If nothing is found, return NAME.  */
3815
3816 static char *
3817 find_file (name)
3818      char *name;
3819 {
3820   char *newname;
3821
3822   newname = find_a_file (&startfile_prefix, name, R_OK);
3823   return newname ? newname : name;
3824 }
3825
3826 /* Determine whether a directory exists.  If LINKER, return 0 for
3827    certain fixed names not needed by the linker.  If not LINKER, it is
3828    only important to return 0 if the host machine has a small ARG_MAX
3829    limit.  */
3830
3831 static int
3832 is_directory (path1, path2, linker)
3833      char *path1;
3834      char *path2;
3835      int linker;
3836 {
3837   int len1 = strlen (path1);
3838   int len2 = strlen (path2);
3839   char *path = (char *) alloca (3 + len1 + len2);
3840   char *cp;
3841   struct stat st;
3842
3843 #ifndef SMALL_ARG_MAX
3844   if (! linker)
3845     return 1;
3846 #endif
3847
3848   /* Construct the path from the two parts.  Ensure the string ends with "/.".
3849      The resulting path will be a directory even if the given path is a
3850      symbolic link.  */
3851   bcopy (path1, path, len1);
3852   bcopy (path2, path + len1, len2);
3853   cp = path + len1 + len2;
3854   if (cp[-1] != '/')
3855     *cp++ = '/';
3856   *cp++ = '.';
3857   *cp = '\0';
3858
3859   /* Exclude directories that the linker is known to search.  */
3860   if (linker
3861       && ((cp - path == 6 && strcmp (path, "/lib/.") == 0)
3862           || (cp - path == 10 && strcmp (path, "/usr/lib/.") == 0)))
3863     return 0;
3864
3865   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
3866 }
3867 \f
3868 /* On fatal signals, delete all the temporary files.  */
3869
3870 static void
3871 fatal_error (signum)
3872      int signum;
3873 {
3874   signal (signum, SIG_DFL);
3875   delete_failure_queue ();
3876   delete_temp_files ();
3877   /* Get the same signal again, this time not handled,
3878      so its normal effect occurs.  */
3879   kill (getpid (), signum);
3880 }
3881
3882 int
3883 main (argc, argv)
3884      int argc;
3885      char **argv;
3886 {
3887   register int i;
3888   int j;
3889   int value;
3890   int linker_was_run = 0;
3891   char *explicit_link_files;
3892   char *specs_file;
3893   char *p;
3894
3895   p = argv[0] + strlen (argv[0]);
3896   while (p != argv[0] && p[-1] != '/') --p;
3897   programname = p;
3898
3899   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
3900     signal (SIGINT, fatal_error);
3901 #ifdef SIGHUP
3902   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
3903     signal (SIGHUP, fatal_error);
3904 #endif
3905   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
3906     signal (SIGTERM, fatal_error);
3907 #ifdef SIGPIPE
3908   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
3909     signal (SIGPIPE, fatal_error);
3910 #endif
3911
3912   argbuf_length = 10;
3913   argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
3914
3915   obstack_init (&obstack);
3916
3917   /* Set up to remember the pathname of gcc and any options
3918      needed for collect.  We use argv[0] instead of programname because
3919      we need the complete pathname.  */
3920   obstack_init (&collect_obstack);
3921   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
3922   obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
3923   putenv (obstack_finish (&collect_obstack));
3924
3925   /* Choose directory for temp files.  */
3926
3927   choose_temp_base ();
3928
3929   /* Make a table of what switches there are (switches, n_switches).
3930      Make a table of specified input files (infiles, n_infiles).
3931      Decode switches that are handled locally.  */
3932
3933   process_command (argc, argv);
3934
3935   /* Initialize the vector of specs to just the default.
3936      This means one element containing 0s, as a terminator.  */
3937
3938   compilers = (struct compiler *) xmalloc (sizeof default_compilers);
3939   bcopy (default_compilers, compilers, sizeof default_compilers);
3940   n_compilers = n_default_compilers;
3941
3942   /* Read specs from a file if there is one.  */
3943
3944   machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", ""));
3945   just_machine_suffix = concat (spec_machine, "/", "");
3946
3947   specs_file = find_a_file (&startfile_prefix, "specs", R_OK);
3948   /* Read the specs file unless it is a default one.  */
3949   if (specs_file != 0 && strcmp (specs_file, "specs"))
3950     read_specs (specs_file);
3951
3952   /* If not cross-compiling, look for startfiles in the standard places.  */
3953   /* The fact that these are done here, after reading the specs file,
3954      means that it cannot be found in these directories.
3955      But that's okay.  It should never be there anyway.  */
3956   if (!cross_compile)
3957     {
3958 #ifdef MD_EXEC_PREFIX
3959       add_prefix (&exec_prefix, md_exec_prefix, 0, 0, NULL_PTR);
3960       add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, NULL_PTR);
3961 #endif
3962
3963 #ifdef MD_STARTFILE_PREFIX
3964       add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, NULL_PTR);
3965 #endif
3966
3967 #ifdef MD_STARTFILE_PREFIX_1
3968       add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, NULL_PTR);
3969 #endif
3970
3971       /* If standard_startfile_prefix is relative, base it on
3972          standard_exec_prefix.  This lets us move the installed tree
3973          as a unit.  If GCC_EXEC_PREFIX is defined, base
3974          standard_startfile_prefix on that as well.  */
3975       if (*standard_startfile_prefix == '/')
3976         add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0,
3977                     NULL_PTR);
3978       else
3979         {
3980           if (gcc_exec_prefix)
3981             add_prefix (&startfile_prefix,
3982                         concat (gcc_exec_prefix,
3983                                 standard_startfile_prefix,
3984                                 ""),
3985                         0, 0, NULL_PTR);
3986           add_prefix (&startfile_prefix,
3987                       concat (standard_exec_prefix,
3988                               machine_suffix,
3989                               standard_startfile_prefix),
3990                       0, 0, NULL_PTR);
3991         }
3992
3993       add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0,
3994                   NULL_PTR);
3995       add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0,
3996                   NULL_PTR);
3997 #if 0 /* Can cause surprises, and one can use -B./ instead.  */
3998       add_prefix (&startfile_prefix, "./", 0, 1, NULL_PTR);
3999 #endif
4000     }
4001
4002   /* Now we have the specs.
4003      Set the `valid' bits for switches that match anything in any spec.  */
4004
4005   validate_all_switches ();
4006
4007   /* Warn about any switches that no pass was interested in.  */
4008
4009   for (i = 0; i < n_switches; i++)
4010     if (! switches[i].valid)
4011       error ("unrecognized option `-%s'", switches[i].part1);
4012
4013   /* Obey some of the options.  */
4014
4015   if (print_file_name)
4016     {
4017       printf ("%s\n", find_file (print_file_name));
4018       exit (0);
4019     }
4020
4021   if (print_prog_name)
4022     {
4023       char *newname = find_a_file (&exec_prefix, print_prog_name, X_OK);
4024       printf ("%s\n", (newname ? newname : print_prog_name));
4025       exit (0);
4026     }
4027
4028   if (verbose_flag)
4029     {
4030       fprintf (stderr, "gcc version %s\n", version_string);
4031       if (n_infiles == 0)
4032         exit (0);
4033     }
4034
4035   if (n_infiles == 0)
4036     fatal ("No input files");
4037
4038   /* Make a place to record the compiler output file names
4039      that correspond to the input files.  */
4040
4041   outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
4042   bzero (outfiles, n_infiles * sizeof (char *));
4043
4044   /* Record which files were specified explicitly as link input.  */
4045
4046   explicit_link_files = xmalloc (n_infiles);
4047   bzero (explicit_link_files, n_infiles);
4048
4049   for (i = 0; i < n_infiles; i++)
4050     {
4051       register struct compiler *cp = 0;
4052       int this_file_error = 0;
4053
4054       /* Tell do_spec what to substitute for %i.  */
4055
4056       input_filename = infiles[i].name;
4057       input_filename_length = strlen (input_filename);
4058       input_file_number = i;
4059
4060       /* Use the same thing in %o, unless cp->spec says otherwise.  */
4061
4062       outfiles[i] = input_filename;
4063
4064       /* Figure out which compiler from the file's suffix.  */
4065
4066       cp = lookup_compiler (infiles[i].name, input_filename_length,
4067                             infiles[i].language);
4068
4069       if (cp)
4070         {
4071           /* Ok, we found an applicable compiler.  Run its spec.  */
4072           /* First say how much of input_filename to substitute for %b  */
4073           register char *p;
4074           int len;
4075
4076           input_basename = input_filename;
4077           for (p = input_filename; *p; p++)
4078             if (*p == '/')
4079               input_basename = p + 1;
4080
4081           /* Find a suffix starting with the last period,
4082              and set basename_length to exclude that suffix.  */
4083           basename_length = strlen (input_basename);
4084           p = input_basename + basename_length;
4085           while (p != input_basename && *p != '.') --p;
4086           if (*p == '.' && p != input_basename)
4087             {
4088               basename_length = p - input_basename;
4089               input_suffix = p + 1;
4090             }
4091           else
4092             input_suffix = "";
4093
4094           len = 0;
4095           for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
4096             if (cp->spec[j])
4097               len += strlen (cp->spec[j]);
4098
4099           p = (char *) xmalloc (len + 1);
4100
4101           len = 0;
4102           for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
4103             if (cp->spec[j])
4104               {
4105                 strcpy (p + len, cp->spec[j]);
4106                 len += strlen (cp->spec[j]);
4107               }
4108
4109           value = do_spec (p);
4110           free (p);
4111           if (value < 0)
4112             this_file_error = 1;
4113         }
4114
4115       /* If this file's name does not contain a recognized suffix,
4116          record it as explicit linker input.  */
4117
4118       else
4119         explicit_link_files[i] = 1;
4120
4121       /* Clear the delete-on-failure queue, deleting the files in it
4122          if this compilation failed.  */
4123
4124       if (this_file_error)
4125         {
4126           delete_failure_queue ();
4127           error_count++;
4128         }
4129       /* If this compilation succeeded, don't delete those files later.  */
4130       clear_failure_queue ();
4131     }
4132
4133   /* Run ld to link all the compiler output files.  */
4134
4135   if (error_count == 0)
4136     {
4137       int tmp = execution_count;
4138       int i;
4139       int first_time;
4140
4141       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
4142          for collect.  */
4143       putenv_from_prefixes (&exec_prefix, "COMPILER_PATH=");
4144       putenv_from_prefixes (&startfile_prefix, "LIBRARY_PATH=");
4145
4146       /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4147          the compiler.  */
4148       obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4149                     sizeof ("COLLECT_GCC_OPTIONS=")-1);
4150
4151       first_time = TRUE;
4152       for (i = 0; i < n_switches; i++)
4153         {
4154           char **args;
4155           if (!first_time)
4156             obstack_grow (&collect_obstack, " ", 1);
4157
4158           first_time = FALSE;
4159           obstack_grow (&collect_obstack, "-", 1);
4160           obstack_grow (&collect_obstack, switches[i].part1,
4161                         strlen (switches[i].part1));
4162
4163           for (args = switches[i].args; args && *args; args++)
4164             {
4165               obstack_grow (&collect_obstack, " ", 1);
4166               obstack_grow (&collect_obstack, *args, strlen (*args));
4167             }
4168         }
4169       obstack_grow (&collect_obstack, "\0", 1);
4170       putenv (obstack_finish (&collect_obstack));
4171
4172       value = do_spec (link_command_spec);
4173       if (value < 0)
4174         error_count = 1;
4175       linker_was_run = (tmp != execution_count);
4176     }
4177
4178   /* Warn if a -B option was specified but the prefix was never used.  */
4179   unused_prefix_warnings (&exec_prefix);
4180   unused_prefix_warnings (&startfile_prefix);
4181
4182   /* If options said don't run linker,
4183      complain about input files to be given to the linker.  */
4184
4185   if (! linker_was_run && error_count == 0)
4186     for (i = 0; i < n_infiles; i++)
4187       if (explicit_link_files[i])
4188         error ("%s: linker input file unused since linking not done",
4189                outfiles[i]);
4190
4191   /* Delete some or all of the temporary files we made.  */
4192
4193   if (error_count)
4194     delete_failure_queue ();
4195   delete_temp_files ();
4196
4197   exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
4198   /* NOTREACHED */
4199   return 0;
4200 }
4201
4202 /* Find the proper compilation spec for the file name NAME,
4203    whose length is LENGTH.  LANGUAGE is the specified language,
4204    or 0 if none specified.  */
4205
4206 static struct compiler *
4207 lookup_compiler (name, length, language)
4208      char *name;
4209      int length;
4210      char *language;
4211 {
4212   struct compiler *cp;
4213
4214   /* Look for the language, if one is spec'd.  */
4215   if (language != 0)
4216     {
4217       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
4218         {
4219           if (language != 0)
4220             {
4221               if (cp->suffix[0] == '@'
4222                   && !strcmp (cp->suffix + 1, language))
4223                 return cp;
4224             }
4225         }
4226       error ("language %s not recognized", language);
4227     }
4228
4229   /* Look for a suffix.  */
4230   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
4231     {
4232       if (/* The suffix `-' matches only the file name `-'.  */
4233           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
4234           ||
4235           (strlen (cp->suffix) < length
4236            /* See if the suffix matches the end of NAME.  */
4237            && !strcmp (cp->suffix,
4238                        name + length - strlen (cp->suffix))))
4239         {
4240           if (cp->spec[0][0] == '@')
4241             {
4242               struct compiler *new;
4243               /* An alias entry maps a suffix to a language.
4244                  Search for the language; pass 0 for NAME and LENGTH
4245                  to avoid infinite recursion if language not found.
4246                  Construct the new compiler spec.  */
4247               language = cp->spec[0] + 1;
4248               new = (struct compiler *) xmalloc (sizeof (struct compiler));
4249               new->suffix = cp->suffix;
4250               bcopy (lookup_compiler (NULL_PTR, 0, language)->spec,
4251                      new->spec, sizeof new->spec);
4252               return new;
4253             }
4254           /* A non-alias entry: return it.  */
4255           return cp;
4256         }
4257     }
4258
4259   return 0;
4260 }
4261 \f
4262 char *
4263 xmalloc (size)
4264      unsigned size;
4265 {
4266   register char *value = (char *) malloc (size);
4267   if (value == 0)
4268     fatal ("virtual memory exhausted");
4269   return value;
4270 }
4271
4272 char *
4273 xrealloc (ptr, size)
4274      char *ptr;
4275      unsigned size;
4276 {
4277   register char *value = (char *) realloc (ptr, size);
4278   if (value == 0)
4279     fatal ("virtual memory exhausted");
4280   return value;
4281 }
4282
4283 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
4284
4285 static char *
4286 concat (s1, s2, s3)
4287      char *s1, *s2, *s3;
4288 {
4289   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
4290   char *result = xmalloc (len1 + len2 + len3 + 1);
4291
4292   strcpy (result, s1);
4293   strcpy (result + len1, s2);
4294   strcpy (result + len1 + len2, s3);
4295   *(result + len1 + len2 + len3) = 0;
4296
4297   return result;
4298 }
4299
4300 static char *
4301 save_string (s, len)
4302      char *s;
4303      int len;
4304 {
4305   register char *result = xmalloc (len + 1);
4306
4307   bcopy (s, result, len);
4308   result[len] = 0;
4309   return result;
4310 }
4311
4312 static void
4313 pfatal_with_name (name)
4314      char *name;
4315 {
4316   char *s;
4317
4318   if (errno < sys_nerr)
4319     s = concat ("%s: ", sys_errlist[errno], "");
4320   else
4321     s = "cannot open %s";
4322   fatal (s, name);
4323 }
4324
4325 static void
4326 perror_with_name (name)
4327      char *name;
4328 {
4329   char *s;
4330
4331   if (errno < sys_nerr)
4332     s = concat ("%s: ", sys_errlist[errno], "");
4333   else
4334     s = "cannot open %s";
4335   error (s, name);
4336 }
4337
4338 static void
4339 perror_exec (name)
4340      char *name;
4341 {
4342   char *s;
4343
4344   if (errno < sys_nerr)
4345     s = concat ("installation problem, cannot exec %s: ",
4346                 sys_errlist[errno], "");
4347   else
4348     s = "installation problem, cannot exec %s";
4349   error (s, name);
4350 }
4351
4352 /* More 'friendly' abort that prints the line and file.
4353    config.h can #define abort fancy_abort if you like that sort of thing.  */
4354
4355 void
4356 fancy_abort ()
4357 {
4358   fatal ("Internal gcc abort.");
4359 }
4360 \f
4361 #ifdef HAVE_VPRINTF
4362
4363 /* Output an error message and exit */
4364
4365 static void
4366 fatal VPROTO((char *format, ...))
4367 {
4368 #ifndef __STDC__
4369   char *format;
4370 #endif
4371   va_list ap;
4372
4373   VA_START (ap, format);
4374
4375 #ifndef __STDC__
4376   format = va_arg (ap, char*);
4377 #endif
4378
4379   fprintf (stderr, "%s: ", programname);
4380   vfprintf (stderr, format, ap);
4381   va_end (ap);
4382   fprintf (stderr, "\n");
4383   delete_temp_files ();
4384   exit (1);
4385 }
4386
4387 static void
4388 error VPROTO((char *format, ...))
4389 {
4390 #ifndef __STDC__
4391   char *format;
4392 #endif
4393   va_list ap;
4394
4395   VA_START (ap, format);
4396
4397 #ifndef __STDC__
4398   format = va_arg (ap, char*);
4399 #endif
4400
4401   fprintf (stderr, "%s: ", programname);
4402   vfprintf (stderr, format, ap);
4403   va_end (ap);
4404
4405   fprintf (stderr, "\n");
4406 }
4407
4408 #else /* not HAVE_VPRINTF */
4409
4410 static void
4411 fatal (msg, arg1, arg2)
4412      char *msg, *arg1, *arg2;
4413 {
4414   error (msg, arg1, arg2);
4415   delete_temp_files ();
4416   exit (1);
4417 }
4418
4419 static void
4420 error (msg, arg1, arg2)
4421      char *msg, *arg1, *arg2;
4422 {
4423   fprintf (stderr, "%s: ", programname);
4424   fprintf (stderr, msg, arg1, arg2);
4425   fprintf (stderr, "\n");
4426 }
4427
4428 #endif /* not HAVE_VPRINTF */
4429
4430 \f
4431 static void
4432 validate_all_switches ()
4433 {
4434   struct compiler *comp;
4435   register char *p;
4436   register char c;
4437   struct spec_list *spec;
4438
4439   for (comp = compilers; comp->spec[0]; comp++)
4440     {
4441       int i;
4442       for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
4443         {
4444           p = comp->spec[i];
4445           while (c = *p++)
4446             if (c == '%' && *p == '{')
4447               /* We have a switch spec.  */
4448               validate_switches (p + 1);
4449         }
4450     }
4451
4452   /* look through the linked list of extra specs read from the specs file */
4453   for (spec = specs; spec ; spec = spec->next)
4454     {
4455       p = spec->spec;
4456       while (c = *p++)
4457         if (c == '%' && *p == '{')
4458           /* We have a switch spec.  */
4459           validate_switches (p + 1);
4460     }
4461
4462   p = link_command_spec;
4463   while (c = *p++)
4464     if (c == '%' && *p == '{')
4465       /* We have a switch spec.  */
4466       validate_switches (p + 1);
4467
4468   /* Now notice switches mentioned in the machine-specific specs.  */
4469
4470   p = asm_spec;
4471   while (c = *p++)
4472     if (c == '%' && *p == '{')
4473       /* We have a switch spec.  */
4474       validate_switches (p + 1);
4475
4476   p = asm_final_spec;
4477   while (c = *p++)
4478     if (c == '%' && *p == '{')
4479       /* We have a switch spec.  */
4480       validate_switches (p + 1);
4481
4482   p = cpp_spec;
4483   while (c = *p++)
4484     if (c == '%' && *p == '{')
4485       /* We have a switch spec.  */
4486       validate_switches (p + 1);
4487
4488   p = signed_char_spec;
4489   while (c = *p++)
4490     if (c == '%' && *p == '{')
4491       /* We have a switch spec.  */
4492       validate_switches (p + 1);
4493
4494   p = cc1_spec;
4495   while (c = *p++)
4496     if (c == '%' && *p == '{')
4497       /* We have a switch spec.  */
4498       validate_switches (p + 1);
4499
4500   p = cc1plus_spec;
4501   while (c = *p++)
4502     if (c == '%' && *p == '{')
4503       /* We have a switch spec.  */
4504       validate_switches (p + 1);
4505
4506   p = link_spec;
4507   while (c = *p++)
4508     if (c == '%' && *p == '{')
4509       /* We have a switch spec.  */
4510       validate_switches (p + 1);
4511
4512   p = lib_spec;
4513   while (c = *p++)
4514     if (c == '%' && *p == '{')
4515       /* We have a switch spec.  */
4516       validate_switches (p + 1);
4517
4518   p = startfile_spec;
4519   while (c = *p++)
4520     if (c == '%' && *p == '{')
4521       /* We have a switch spec.  */
4522       validate_switches (p + 1);
4523 }
4524
4525 /* Look at the switch-name that comes after START
4526    and mark as valid all supplied switches that match it.  */
4527
4528 static void
4529 validate_switches (start)
4530      char *start;
4531 {
4532   register char *p = start;
4533   char *filter;
4534   register int i;
4535   int suffix = 0;
4536
4537   if (*p == '|')
4538     ++p;
4539
4540   if (*p == '!')
4541     ++p;
4542
4543   if (*p == '.')
4544     suffix = 1, ++p;
4545
4546   filter = p;
4547   while (*p != ':' && *p != '}') p++;
4548
4549   if (suffix)
4550     ;
4551   else if (p[-1] == '*')
4552     {
4553       /* Mark all matching switches as valid.  */
4554       --p;
4555       for (i = 0; i < n_switches; i++)
4556         if (!strncmp (switches[i].part1, filter, p - filter))
4557           switches[i].valid = 1;
4558     }
4559   else
4560     {
4561       /* Mark an exact matching switch as valid.  */
4562       for (i = 0; i < n_switches; i++)
4563         {
4564           if (!strncmp (switches[i].part1, filter, p - filter)
4565               && switches[i].part1[p - filter] == 0)
4566             switches[i].valid = 1;
4567         }
4568     }
4569 }