gcc/cppinit.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001 Free Software Foundation, Inc.
   4    Contributed by Per Bothner, 1994-95.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "cpplib.h"
  25 #include "cpphash.h"
  26 #include "output.h"
  27 #include "prefix.h"
  28 #include "intl.h"
  29 #include "version.h"
  30 #include "mkdeps.h"
  31 #include "cppdefault.h"
  32
  33 /* Predefined symbols, built-in macros, and the default include path.  */
  34
  35 #ifndef GET_ENV_PATH_LIST
  36 #define GET_ENV_PATH_LIST(VAR,NAME)     do { (VAR) = getenv (NAME); } while (0)
  37 #endif
  38
  39 /* Windows does not natively support inodes, and neither does MSDOS.
  40    Cygwin's emulation can generate non-unique inodes, so don't use it.
  41    VMS has non-numeric inodes.  */
  42 #ifdef VMS
  43 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
  44 # define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
  45 #else
  46 # if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
  47 #  define INO_T_EQ(A, B) 0
  48 # else
  49 #  define INO_T_EQ(A, B) ((A) == (B))
  50 # endif
  51 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
  52 #endif
  53
  54 /* Internal structures and prototypes.  */
  55
  56 /* A `struct pending_option' remembers one -D, -A, -U, -include, or
  57    -imacros switch.  */
  58
  59 typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
  60 struct pending_option
  61 {
  62   struct pending_option *next;
  63   const char *arg;
  64   cl_directive_handler handler;
  65 };
  66
  67 /* The `pending' structure accumulates all the options that are not
  68    actually processed until we hit cpp_read_main_file.  It consists of
  69    several lists, one for each type of option.  We keep both head and
  70    tail pointers for quick insertion.  */
  71 struct cpp_pending
  72 {
  73   struct pending_option *directive_head, *directive_tail;
  74
  75   struct search_path *quote_head, *quote_tail;
  76   struct search_path *brack_head, *brack_tail;
  77   struct search_path *systm_head, *systm_tail;
  78   struct search_path *after_head, *after_tail;
  79
  80   struct pending_option *imacros_head, *imacros_tail;
  81   struct pending_option *include_head, *include_tail;
  82 };
  83
  84 #ifdef __STDC__
  85 #define APPEND(pend, list, elt) \
  86   do {  if (!(pend)->list##_head) (pend)->list##_head = (elt); \
  87         else (pend)->list##_tail->next = (elt); \
  88         (pend)->list##_tail = (elt); \
  89   } while (0)
  90 #else
  91 #define APPEND(pend, list, elt) \
  92   do {  if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
  93         else (pend)->list/**/_tail->next = (elt); \
  94         (pend)->list/**/_tail = (elt); \
  95   } while (0)
  96 #endif
  97
  98 static void print_help                  PARAMS ((void));
  99 static void path_include                PARAMS ((cpp_reader *,
 100                                                  char *, int));
 101 static void init_library                PARAMS ((void));
 102 static void init_builtins               PARAMS ((cpp_reader *));
 103 static void append_include_chain        PARAMS ((cpp_reader *,
 104                                                  char *, int, int));
 105 static struct search_path * remove_dup_dir      PARAMS ((cpp_reader *,
 106                                                  struct search_path *));
 107 static struct search_path * remove_dup_dirs PARAMS ((cpp_reader *,
 108                                                  struct search_path *));
 109 static void merge_include_chains        PARAMS ((cpp_reader *));
 110 static bool push_include                PARAMS ((cpp_reader *,
 111                                                  struct pending_option *));
 112 static void free_chain                  PARAMS ((struct pending_option *));
 113 static void set_lang                    PARAMS ((cpp_reader *, enum c_lang));
 114 static void init_dependency_output      PARAMS ((cpp_reader *));
 115 static void init_standard_includes      PARAMS ((cpp_reader *));
 116 static void read_original_filename      PARAMS ((cpp_reader *));
 117 static void new_pending_directive       PARAMS ((struct cpp_pending *,
 118                                                  const char *,
 119                                                  cl_directive_handler));
 120 static void output_deps                 PARAMS ((cpp_reader *));
 121 static int parse_option                 PARAMS ((const char *));
 122
 123 /* Fourth argument to append_include_chain: chain to use.
 124    Note it's never asked to append to the quote chain.  */
 125 enum { BRACKET = 0, SYSTEM, AFTER };
 126
 127 /* If we have designated initializers (GCC >2.7) these tables can be
 128    initialized, constant data.  Otherwise, they have to be filled in at
 129    runtime.  */
 130 #if HAVE_DESIGNATED_INITIALIZERS
 131
 132 #define init_trigraph_map()  /* Nothing.  */
 133 #define TRIGRAPH_MAP \
 134 __extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
 135
 136 #define END };
 137 #define s(p, v) [p] = v,
 138
 139 #else
 140
 141 #define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
 142  static void init_trigraph_map PARAMS ((void)) { \
 143  unsigned char *x = _cpp_trigraph_map;
 144
 145 #define END }
 146 #define s(p, v) x[p] = v;
 147
 148 #endif
 149
 150 TRIGRAPH_MAP
 151   s('=', '#')   s(')', ']')     s('!', '|')
 152   s('(', '[')   s('\'', '^')    s('>', '}')
 153   s('/', '\\')  s('<', '{')     s('-', '~')
 154 END
 155
 156 #undef s
 157 #undef END
 158 #undef TRIGRAPH_MAP
 159
 160 /* Given a colon-separated list of file names PATH,
 161    add all the names to the search path for include files.  */
 162
 163 static void
 164 path_include (pfile, list, path)
 165      cpp_reader *pfile;
 166      char *list;
 167      int path;
 168 {
 169   char *p, *q, *name;
 170
 171   p = list;
 172
 173   do
 174     {
 175       /* Find the end of this name.  */
 176       q = p;
 177       while (*q != 0 && *q != PATH_SEPARATOR) q++;
 178       if (q == p)
 179         {
 180           /* An empty name in the path stands for the current directory.  */
 181           name = (char *) xmalloc (2);
 182           name[0] = '.';
 183           name[1] = 0;
 184         }
 185       else
 186         {
 187           /* Otherwise use the directory that is named.  */
 188           name = (char *) xmalloc (q - p + 1);
 189           memcpy (name, p, q - p);
 190           name[q - p] = 0;
 191         }
 192
 193       append_include_chain (pfile, name, path, 0);
 194
 195       /* Advance past this name.  */
 196       if (*q == 0)
 197         break;
 198       p = q + 1;
 199     }
 200   while (1);
 201 }
 202
 203 /* Append DIR to include path PATH.  DIR must be allocated on the
 204    heap; this routine takes responsibility for freeing it.  */
 205 static void
 206 append_include_chain (pfile, dir, path, cxx_aware)
 207      cpp_reader *pfile;
 208      char *dir;
 209      int path;
 210      int cxx_aware ATTRIBUTE_UNUSED;
 211 {
 212   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 213   struct search_path *new;
 214   struct stat st;
 215   unsigned int len;
 216
 217   if (*dir == '\0')
 218     {
 219       free (dir);
 220       dir = xstrdup (".");
 221     }
 222   _cpp_simplify_pathname (dir);
 223
 224   if (stat (dir, &st))
 225     {
 226       /* Dirs that don't exist are silently ignored.  */
 227       if (errno != ENOENT)
 228         cpp_notice_from_errno (pfile, dir);
 229       else if (CPP_OPTION (pfile, verbose))
 230         fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
 231       free (dir);
 232       return;
 233     }
 234
 235   if (!S_ISDIR (st.st_mode))
 236     {
 237       cpp_notice (pfile, "%s: Not a directory", dir);
 238       free (dir);
 239       return;
 240     }
 241
 242   len = strlen (dir);
 243   if (len > pfile->max_include_len)
 244     pfile->max_include_len = len;
 245
 246   new = (struct search_path *) xmalloc (sizeof (struct search_path));
 247   new->name = dir;
 248   new->len = len;
 249   INO_T_COPY (new->ino, st.st_ino);
 250   new->dev  = st.st_dev;
 251   /* Both systm and after include file lists should be treated as system
 252      include files since these two lists are really just a concatenation
 253      of one "system" list.  */
 254   if (path == SYSTEM || path == AFTER)
 255 #ifdef NO_IMPLICIT_EXTERN_C
 256     new->sysp = 1;
 257 #else
 258     new->sysp = cxx_aware ? 1 : 2;
 259 #endif
 260   else
 261     new->sysp = 0;
 262   new->name_map = NULL;
 263   new->next = NULL;
 264
 265   switch (path)
 266     {
 267     case BRACKET:       APPEND (pend, brack, new); break;
 268     case SYSTEM:        APPEND (pend, systm, new); break;
 269     case AFTER:         APPEND (pend, after, new); break;
 270     }
 271 }
 272
 273 /* Handle a duplicated include path.  PREV is the link in the chain
 274    before the duplicate.  The duplicate is removed from the chain and
 275    freed.  Returns PREV.  */
 276 static struct search_path *
 277 remove_dup_dir (pfile, prev)
 278      cpp_reader *pfile;
 279      struct search_path *prev;
 280 {
 281   struct search_path *cur = prev->next;
 282
 283   if (CPP_OPTION (pfile, verbose))
 284     fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
 285
 286   prev->next = cur->next;
 287   free ((PTR) cur->name);
 288   free (cur);
 289
 290   return prev;
 291 }
 292
 293 /* Remove duplicate directories from a chain.  Returns the tail of the
 294    chain, or NULL if the chain is empty.  This algorithm is quadratic
 295    in the number of -I switches, which is acceptable since there
 296    aren't usually that many of them.  */
 297 static struct search_path *
 298 remove_dup_dirs (pfile, head)
 299      cpp_reader *pfile;
 300      struct search_path *head;
 301 {
 302   struct search_path *prev = NULL, *cur, *other;
 303
 304   for (cur = head; cur; cur = cur->next)
 305     {
 306       for (other = head; other != cur; other = other->next)
 307         if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
 308           {
 309             if (cur->sysp && !other->sysp)
 310               {
 311                 cpp_warning (pfile,
 312                              "changing search order for system directory \"%s\"",
 313                              cur->name);
 314                 if (strcmp (cur->name, other->name))
 315                   cpp_warning (pfile,
 316                                "  as it is the same as non-system directory \"%s\"",
 317                                other->name);
 318                 else
 319                   cpp_warning (pfile,
 320                                "  as it has already been specified as a non-system directory");
 321               }
 322             cur = remove_dup_dir (pfile, prev);
 323             break;
 324           }
 325       prev = cur;
 326     }
 327
 328   return prev;
 329 }
 330
 331 /* Merge the four include chains together in the order quote, bracket,
 332    system, after.  Remove duplicate dirs (as determined by
 333    INO_T_EQ()).  The system_include and after_include chains are never
 334    referred to again after this function; all access is through the
 335    bracket_include path.
 336
 337    For the future: Check if the directory is empty (but
 338    how?) and possibly preload the include hash.  */
 339
 340 static void
 341 merge_include_chains (pfile)
 342      cpp_reader *pfile;
 343 {
 344   struct search_path *quote, *brack, *systm, *qtail;
 345
 346   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 347
 348   quote = pend->quote_head;
 349   brack = pend->brack_head;
 350   systm = pend->systm_head;
 351   qtail = pend->quote_tail;
 352
 353   /* Paste together bracket, system, and after include chains.  */
 354   if (systm)
 355     pend->systm_tail->next = pend->after_head;
 356   else
 357     systm = pend->after_head;
 358
 359   if (brack)
 360     pend->brack_tail->next = systm;
 361   else
 362     brack = systm;
 363
 364   /* This is a bit tricky.  First we drop dupes from the quote-include
 365      list.  Then we drop dupes from the bracket-include list.
 366      Finally, if qtail and brack are the same directory, we cut out
 367      brack and move brack up to point to qtail.
 368
 369      We can't just merge the lists and then uniquify them because
 370      then we may lose directories from the <> search path that should
 371      be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
 372      safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
 373      -Ibar -I- -Ifoo -Iquux.  */
 374
 375   remove_dup_dirs (pfile, brack);
 376   qtail = remove_dup_dirs (pfile, quote);
 377
 378   if (quote)
 379     {
 380       qtail->next = brack;
 381
 382       /* If brack == qtail, remove brack as it's simpler.  */
 383       if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
 384         brack = remove_dup_dir (pfile, qtail);
 385     }
 386   else
 387     quote = brack;
 388
 389   CPP_OPTION (pfile, quote_include) = quote;
 390   CPP_OPTION (pfile, bracket_include) = brack;
 391 }
 392
 393 /* Sets internal flags correctly for a given language, and defines
 394    macros if necessary.  */
 395
 396 struct lang_flags
 397 {
 398   char c99;
 399   char objc;
 400   char cplusplus;
 401   char extended_numbers;
 402   char trigraphs;
 403   char dollars_in_ident;
 404   char cplusplus_comments;
 405   char digraphs;
 406 };
 407
 408 /* ??? Enable $ in identifiers in assembly? */
 409 static const struct lang_flags lang_defaults[] =
 410 { /*              c99 objc c++ xnum trig dollar c++comm digr  */
 411   /* GNUC89 */  { 0,  0,   0,  1,   0,   1,     1,      1     },
 412   /* GNUC99 */  { 1,  0,   0,  1,   0,   1,     1,      1     },
 413   /* STDC89 */  { 0,  0,   0,  0,   1,   0,     0,      0     },
 414   /* STDC94 */  { 0,  0,   0,  0,   1,   0,     0,      1     },
 415   /* STDC99 */  { 1,  0,   0,  1,   1,   0,     1,      1     },
 416   /* GNUCXX */  { 0,  0,   1,  1,   0,   1,     1,      1     },
 417   /* CXX98  */  { 0,  0,   1,  1,   1,   0,     1,      1     },
 418   /* OBJC   */  { 0,  1,   0,  1,   0,   1,     1,      1     },
 419   /* OBJCXX */  { 0,  1,   1,  1,   0,   1,     1,      1     },
 420   /* ASM    */  { 0,  0,   0,  1,   0,   0,     1,      0     }
 421 };
 422
 423 static void
 424 set_lang (pfile, lang)
 425      cpp_reader *pfile;
 426      enum c_lang lang;
 427 {
 428   const struct lang_flags *l = &lang_defaults[(int) lang];
 429
 430   CPP_OPTION (pfile, lang) = lang;
 431
 432   CPP_OPTION (pfile, c99)                = l->c99;
 433   CPP_OPTION (pfile, objc)               = l->objc;
 434   CPP_OPTION (pfile, cplusplus)          = l->cplusplus;
 435   CPP_OPTION (pfile, extended_numbers)   = l->extended_numbers;
 436   CPP_OPTION (pfile, trigraphs)          = l->trigraphs;
 437   CPP_OPTION (pfile, dollars_in_ident)   = l->dollars_in_ident;
 438   CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
 439   CPP_OPTION (pfile, digraphs)           = l->digraphs;
 440 }
 441
 442 #ifdef HOST_EBCDIC
 443 static int opt_comp PARAMS ((const void *, const void *));
 444
 445 /* Run-time sorting of options array.  */
 446 static int
 447 opt_comp (p1, p2)
 448      const void *p1, *p2;
 449 {
 450   return strcmp (((struct cl_option *) p1)->opt_text,
 451                  ((struct cl_option *) p2)->opt_text);
 452 }
 453 #endif
 454
 455 /* init initializes library global state.  It might not need to
 456    do anything depending on the platform and compiler.  */
 457
 458 static void
 459 init_library ()
 460 {
 461   static int initialized = 0;
 462
 463   if (! initialized)
 464     {
 465       initialized = 1;
 466
 467 #ifdef HOST_EBCDIC
 468       /* For non-ASCII hosts, the cl_options array needs to be sorted at
 469          runtime.  */
 470       qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
 471 #endif
 472
 473       /* Set up the trigraph map.  This doesn't need to do anything if
 474          we were compiled with a compiler that supports C99 designated
 475          initializers.  */
 476       init_trigraph_map ();
 477     }
 478 }
 479
 480 /* Initialize a cpp_reader structure.  */
 481 cpp_reader *
 482 cpp_create_reader (lang)
 483      enum c_lang lang;
 484 {
 485   cpp_reader *pfile;
 486
 487   /* Initialise this instance of the library if it hasn't been already.  */
 488   init_library ();
 489
 490   pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
 491
 492   set_lang (pfile, lang);
 493   CPP_OPTION (pfile, warn_import) = 1;
 494   CPP_OPTION (pfile, discard_comments) = 1;
 495   CPP_OPTION (pfile, show_column) = 1;
 496   CPP_OPTION (pfile, tabstop) = 8;
 497   CPP_OPTION (pfile, operator_names) = 1;
 498
 499   CPP_OPTION (pfile, pending) =
 500     (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
 501
 502   /* It's simplest to just create this struct whether or not it will
 503      be needed.  */
 504   pfile->deps = deps_init ();
 505
 506   /* Initialise the line map.  Start at logical line 1, so we can use
 507      a line number of zero for special states.  */
 508   init_line_maps (&pfile->line_maps);
 509   pfile->line = 1;
 510
 511   /* Initialize lexer state.  */
 512   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 513
 514   /* Set up static tokens.  */
 515   pfile->date.type = CPP_EOF;
 516   pfile->avoid_paste.type = CPP_PADDING;
 517   pfile->avoid_paste.val.source = NULL;
 518   pfile->eof.type = CPP_EOF;
 519   pfile->eof.flags = 0;
 520
 521   /* Create a token buffer for the lexer.  */
 522   _cpp_init_tokenrun (&pfile->base_run, 250);
 523   pfile->cur_run = &pfile->base_run;
 524   pfile->cur_token = pfile->base_run.base;
 525
 526   /* Initialise the base context.  */
 527   pfile->context = &pfile->base_context;
 528   pfile->base_context.macro = 0;
 529   pfile->base_context.prev = pfile->base_context.next = 0;
 530
 531   /* Aligned and unaligned storage.  */
 532   pfile->a_buff = _cpp_get_buff (pfile, 0);
 533   pfile->u_buff = _cpp_get_buff (pfile, 0);
 534
 535   /* Initialise the buffer obstack.  */
 536   gcc_obstack_init (&pfile->buffer_ob);
 537
 538   _cpp_init_includes (pfile);
 539
 540   return pfile;
 541 }
 542
 543 /* Free resources used by PFILE.  Accessing PFILE after this function
 544    returns leads to undefined behaviour.  */
 545 int
 546 cpp_destroy (pfile)
 547      cpp_reader *pfile;
 548 {
 549   int result;
 550   struct search_path *dir, *dirn;
 551   cpp_context *context, *contextn;
 552   tokenrun *run, *runn;
 553
 554   while (CPP_BUFFER (pfile) != NULL)
 555     _cpp_pop_buffer (pfile);
 556
 557   if (pfile->macro_buffer)
 558     {
 559       free ((PTR) pfile->macro_buffer);
 560       pfile->macro_buffer = NULL;
 561       pfile->macro_buffer_len = 0;
 562     }
 563
 564   deps_free (pfile->deps);
 565   obstack_free (&pfile->buffer_ob, 0);
 566
 567   _cpp_destroy_hashtable (pfile);
 568   _cpp_cleanup_includes (pfile);
 569
 570   _cpp_free_buff (pfile->a_buff);
 571   _cpp_free_buff (pfile->u_buff);
 572   _cpp_free_buff (pfile->free_buffs);
 573
 574   for (run = &pfile->base_run; run; run = runn)
 575     {
 576       runn = run->next;
 577       free (run->base);
 578       if (run != &pfile->base_run)
 579         free (run);
 580     }
 581
 582   for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
 583     {
 584       dirn = dir->next;
 585       free ((PTR) dir->name);
 586       free (dir);
 587     }
 588
 589   for (context = pfile->base_context.next; context; context = contextn)
 590     {
 591       contextn = context->next;
 592       free (context);
 593     }
 594
 595   free_line_maps (&pfile->line_maps);
 596
 597   result = pfile->errors;
 598   free (pfile);
 599
 600   return result;
 601 }
 602
 603
 604 /* This structure defines one built-in identifier.  A node will be
 605    entered in the hash table under the name NAME, with value VALUE (if
 606    any).  If flags has OPERATOR, the node's operator field is used; if
 607    flags has BUILTIN the node's builtin field is used.  Macros that are
 608    known at build time should not be flagged BUILTIN, as then they do
 609    not appear in macro dumps with e.g. -dM or -dD.
 610
 611    Two values are not compile time constants, so we tag
 612    them in the FLAGS field instead:
 613    VERS         value is the global version_string, quoted
 614    ULP          value is the global user_label_prefix
 615
 616    Also, macros with CPLUS set in the flags field are entered only for C++.  */
 617
 618 struct builtin
 619 {
 620   const U_CHAR *name;
 621   const char *value;
 622   unsigned char builtin;
 623   unsigned char operator;
 624   unsigned short flags;
 625   unsigned short len;
 626 };
 627 #define VERS            0x01
 628 #define ULP             0x02
 629 #define CPLUS           0x04
 630 #define BUILTIN         0x08
 631 #define OPERATOR        0x10
 632
 633 #define B(n, t)       { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
 634 #define C(n, v)       { U n, v, 0, 0, 0, sizeof n - 1 }
 635 #define X(n, f)       { U n, 0, 0, 0, f, sizeof n - 1 }
 636 #define O(n, c, f)    { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
 637 static const struct builtin builtin_array[] =
 638 {
 639   B("__TIME__",          BT_TIME),
 640   B("__DATE__",          BT_DATE),
 641   B("__FILE__",          BT_FILE),
 642   B("__BASE_FILE__",     BT_BASE_FILE),
 643   B("__LINE__",          BT_SPECLINE),
 644   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
 645   B("_Pragma",           BT_PRAGMA),
 646
 647   X("__VERSION__",              VERS),
 648   X("__USER_LABEL_PREFIX__",    ULP),
 649   C("__REGISTER_PREFIX__",      REGISTER_PREFIX),
 650   C("__HAVE_BUILTIN_SETJMP__",  "1"),
 651 #ifndef NO_BUILTIN_SIZE_TYPE
 652   C("__SIZE_TYPE__",            SIZE_TYPE),
 653 #endif
 654 #ifndef NO_BUILTIN_PTRDIFF_TYPE
 655   C("__PTRDIFF_TYPE__",         PTRDIFF_TYPE),
 656 #endif
 657 #ifndef NO_BUILTIN_WCHAR_TYPE
 658   C("__WCHAR_TYPE__",           WCHAR_TYPE),
 659 #endif
 660 #ifndef NO_BUILTIN_WINT_TYPE
 661   C("__WINT_TYPE__",            WINT_TYPE),
 662 #endif
 663 #ifdef STDC_0_IN_SYSTEM_HEADERS
 664   B("__STDC__",          BT_STDC),
 665 #else
 666   C("__STDC__",          "1"),
 667 #endif
 668
 669   /* Named operators known to the preprocessor.  These cannot be #defined
 670      and always have their stated meaning.  They are treated like normal
 671      identifiers except for the type code and the meaning.  Most of them
 672      are only for C++ (but see iso646.h).  */
 673   O("and",      CPP_AND_AND, CPLUS),
 674   O("and_eq",   CPP_AND_EQ,  CPLUS),
 675   O("bitand",   CPP_AND,     CPLUS),
 676   O("bitor",    CPP_OR,      CPLUS),
 677   O("compl",    CPP_COMPL,   CPLUS),
 678   O("not",      CPP_NOT,     CPLUS),
 679   O("not_eq",   CPP_NOT_EQ,  CPLUS),
 680   O("or",       CPP_OR_OR,   CPLUS),
 681   O("or_eq",    CPP_OR_EQ,   CPLUS),
 682   O("xor",      CPP_XOR,     CPLUS),
 683   O("xor_eq",   CPP_XOR_EQ,  CPLUS)
 684 };
 685 #undef B
 686 #undef C
 687 #undef X
 688 #undef O
 689 #define builtin_array_end \
 690  builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
 691
 692 /* Subroutine of cpp_read_main_file; reads the builtins table above and
 693    enters the macros into the hash table.  */
 694 static void
 695 init_builtins (pfile)
 696      cpp_reader *pfile;
 697 {
 698   const struct builtin *b;
 699
 700   for(b = builtin_array; b < builtin_array_end; b++)
 701     {
 702       if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus))
 703         continue;
 704
 705       if ((b->flags & OPERATOR) && ! CPP_OPTION (pfile, operator_names))
 706         continue;
 707
 708       if (b->flags & (OPERATOR | BUILTIN))
 709         {
 710           cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 711           if (b->flags & OPERATOR)
 712             {
 713               hp->flags |= NODE_OPERATOR;
 714               hp->value.operator = b->operator;
 715             }
 716           else
 717             {
 718               hp->type = NT_MACRO;
 719               hp->flags |= NODE_BUILTIN | NODE_WARN;
 720               hp->value.builtin = b->builtin;
 721             }
 722         }
 723       else                      /* A standard macro of some kind.  */
 724         {
 725           const char *val;
 726           char *str;
 727
 728           if (b->flags & VERS)
 729             {
 730               /* Allocate enough space for 'name "value"\n\0'.  */
 731               str = alloca (b->len + strlen (version_string) + 5);
 732               sprintf (str, "%s \"%s\"\n", b->name, version_string);
 733             }
 734           else
 735             {
 736               if (b->flags & ULP)
 737                 val = CPP_OPTION (pfile, user_label_prefix);
 738               else
 739                 val = b->value;
 740
 741               /* Allocate enough space for "name value\n\0".  */
 742               str = alloca (b->len + strlen (val) + 3);
 743               sprintf(str, "%s %s\n", b->name, val);
 744             }
 745
 746           _cpp_define_builtin (pfile, str);
 747         }
 748     }
 749
 750   if (CPP_OPTION (pfile, cplusplus))
 751     {
 752       _cpp_define_builtin (pfile, "__cplusplus 1");
 753       if (SUPPORTS_ONE_ONLY)
 754         _cpp_define_builtin (pfile, "__GXX_WEAK__ 1");
 755       else
 756         _cpp_define_builtin (pfile, "__GXX_WEAK__ 0");
 757     }
 758   if (CPP_OPTION (pfile, objc))
 759     _cpp_define_builtin (pfile, "__OBJC__ 1");
 760
 761   if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 762     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 763   else if (CPP_OPTION (pfile, c99))
 764     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 765
 766   if (CPP_OPTION (pfile, lang) == CLK_STDC89
 767       || CPP_OPTION (pfile, lang) == CLK_STDC94
 768       || CPP_OPTION (pfile, lang) == CLK_STDC99)
 769     _cpp_define_builtin (pfile, "__STRICT_ANSI__ 1");
 770   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 771     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 772 }
 773 #undef BUILTIN
 774 #undef OPERATOR
 775 #undef VERS
 776 #undef ULP
 777 #undef CPLUS
 778 #undef builtin_array_end
 779
 780 /* And another subroutine.  This one sets up the standard include path.  */
 781 static void
 782 init_standard_includes (pfile)
 783      cpp_reader *pfile;
 784 {
 785   char *path;
 786   const struct default_include *p;
 787   const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
 788
 789   /* Several environment variables may add to the include search path.
 790      CPATH specifies an additional list of directories to be searched
 791      as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
 792      etc. specify an additional list of directories to be searched as
 793      if specified with -isystem, for the language indicated.  */
 794
 795   GET_ENV_PATH_LIST (path, "CPATH");
 796   if (path != 0 && *path != 0)
 797     path_include (pfile, path, BRACKET);
 798
 799   switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
 800     {
 801     case 0:
 802       GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
 803       break;
 804     case 1:
 805       GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
 806       break;
 807     case 2:
 808       GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
 809       break;
 810     case 3:
 811       GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
 812       break;
 813     }
 814   if (path != 0 && *path != 0)
 815     path_include (pfile, path, SYSTEM);
 816
 817   /* Search "translated" versions of GNU directories.
 818      These have /usr/local/lib/gcc... replaced by specd_prefix.  */
 819   if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
 820     {
 821       /* Remove the `include' from /usr/local/lib/gcc.../include.
 822          GCC_INCLUDE_DIR will always end in /include.  */
 823       int default_len = cpp_GCC_INCLUDE_DIR_len;
 824       char *default_prefix = (char *) alloca (default_len + 1);
 825       int specd_len = strlen (specd_prefix);
 826
 827       memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
 828       default_prefix[default_len] = '\0';
 829
 830       for (p = cpp_include_defaults; p->fname; p++)
 831         {
 832           /* Some standard dirs are only for C++.  */
 833           if (!p->cplusplus
 834               || (CPP_OPTION (pfile, cplusplus)
 835                   && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
 836             {
 837               /* Does this dir start with the prefix?  */
 838               if (!memcmp (p->fname, default_prefix, default_len))
 839                 {
 840                   /* Yes; change prefix and add to search list.  */
 841                   int flen = strlen (p->fname);
 842                   int this_len = specd_len + flen - default_len;
 843                   char *str = (char *) xmalloc (this_len + 1);
 844                   memcpy (str, specd_prefix, specd_len);
 845                   memcpy (str + specd_len,
 846                           p->fname + default_len,
 847                           flen - default_len + 1);
 848
 849                   append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
 850                 }
 851             }
 852         }
 853     }
 854
 855   /* Search ordinary names for GNU include directories.  */
 856   for (p = cpp_include_defaults; p->fname; p++)
 857     {
 858       /* Some standard dirs are only for C++.  */
 859       if (!p->cplusplus
 860           || (CPP_OPTION (pfile, cplusplus)
 861               && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
 862         {
 863           char *str = update_path (p->fname, p->component);
 864           append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
 865         }
 866     }
 867 }
 868
 869 /* Pushes a -imacro and -include file given on the command line onto
 870    the buffer stack.  Returns non-zero if successful.  */
 871 static bool
 872 push_include (pfile, p)
 873      cpp_reader *pfile;
 874      struct pending_option *p;
 875 {
 876   cpp_token header;
 877
 878   /* Later: maybe update this to use the #include "" search path
 879      if cpp_read_file fails.  */
 880   header.type = CPP_STRING;
 881   header.val.str.text = (const unsigned char *) p->arg;
 882   header.val.str.len = strlen (p->arg);
 883   /* Make the command line directive take up a line.  */
 884   pfile->line++;
 885
 886   return _cpp_execute_include (pfile, &header, IT_CMDLINE);
 887 }
 888
 889 /* Frees a pending_option chain.  */
 890 static void
 891 free_chain (head)
 892      struct pending_option *head;
 893 {
 894   struct pending_option *next;
 895
 896   while (head)
 897     {
 898       next = head->next;
 899       free (head);
 900       head = next;
 901     }
 902 }
 903
 904 /* This is called after options have been parsed, and partially
 905    processed.  Setup for processing input from the file named FNAME,
 906    or stdin if it is the empty string.  Return the original filename
 907    on success (e.g. foo.i->foo.c), or NULL on failure.  */
 908 const char *
 909 cpp_read_main_file (pfile, fname, table)
 910      cpp_reader *pfile;
 911      const char *fname;
 912      hash_table *table;
 913 {
 914   /* The front ends don't set up the hash table until they have
 915      finished processing the command line options, so initializing the
 916      hashtable is deferred until now.  */
 917   _cpp_init_hashtable (pfile, table);
 918
 919   /* Set up the include search path now.  */
 920   if (! CPP_OPTION (pfile, no_standard_includes))
 921     init_standard_includes (pfile);
 922
 923   merge_include_chains (pfile);
 924
 925   /* With -v, print the list of dirs to search.  */
 926   if (CPP_OPTION (pfile, verbose))
 927     {
 928       struct search_path *l;
 929       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 930       for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
 931         {
 932           if (l == CPP_OPTION (pfile, bracket_include))
 933             fprintf (stderr, _("#include <...> search starts here:\n"));
 934           fprintf (stderr, " %s\n", l->name);
 935         }
 936       fprintf (stderr, _("End of search list.\n"));
 937     }
 938
 939   if (CPP_OPTION (pfile, print_deps))
 940     /* Set the default target (if there is none already).  */
 941     deps_add_default_target (pfile->deps, fname);
 942
 943   /* Open the main input file.  */
 944   if (!_cpp_read_file (pfile, fname))
 945     return NULL;
 946
 947   /* Set this after cpp_post_options so the client can change the
 948      option if it wishes, and after stacking the main file so we don't
 949      trace the main file.  */
 950   pfile->line_maps.trace_includes = CPP_OPTION (pfile, print_include_names);
 951
 952   /* For foo.i, read the original filename foo.c now, for the benefit
 953      of the front ends.  */
 954   if (CPP_OPTION (pfile, preprocessed))
 955     read_original_filename (pfile);
 956
 957   return pfile->map->to_file;
 958 }
 959
 960 /* For preprocessed files, if the first tokens are of the form # NUM.
 961    handle the directive so we know the original file name.  This will
 962    generate file_change callbacks, which the front ends must handle
 963    appropriately given their state of initialization.  */
 964 static void
 965 read_original_filename (pfile)
 966      cpp_reader *pfile;
 967 {
 968   const cpp_token *token, *token1;
 969
 970   /* Lex ahead; if the first tokens are of the form # NUM, then
 971      process the directive, otherwise back up.  */
 972   token = _cpp_lex_direct (pfile);
 973   if (token->type == CPP_HASH)
 974     {
 975       token1 = _cpp_lex_direct (pfile);
 976       _cpp_backup_tokens (pfile, 1);
 977
 978       /* If it's a #line directive, handle it.  */
 979       if (token1->type == CPP_NUMBER)
 980         {
 981           _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
 982           return;
 983         }
 984     }
 985
 986   /* Backup as if nothing happened.  */
 987   _cpp_backup_tokens (pfile, 1);
 988 }
 989
 990 /* Handle pending command line options: -D, -U, -A, -imacros and
 991    -include.  This should be called after debugging has been properly
 992    set up in the front ends.  */
 993 void
 994 cpp_finish_options (pfile)
 995      cpp_reader *pfile;
 996 {
 997   /* Install builtins and process command line macros etc. in the order
 998      they appeared, but only if not already preprocessed.  */
 999   if (! CPP_OPTION (pfile, preprocessed))
1000     {
1001       struct pending_option *p;
1002
1003       _cpp_do_file_change (pfile, LC_RENAME, _("<builtin>"), 1, 0);
1004       init_builtins (pfile);
1005       _cpp_do_file_change (pfile, LC_RENAME, _("<command line>"), 1, 0);
1006       for (p = CPP_OPTION (pfile, pending)->directive_head; p; p = p->next)
1007         (*p->handler) (pfile, p->arg);
1008
1009       /* Scan -imacros files after command line defines, but before
1010          files given with -include.  */
1011       while ((p = CPP_OPTION (pfile, pending)->imacros_head) != NULL)
1012         {
1013           if (push_include (pfile, p))
1014             {
1015               pfile->buffer->return_at_eof = true;
1016               cpp_scan_nooutput (pfile);
1017             }
1018           CPP_OPTION (pfile, pending)->imacros_head = p->next;
1019           free (p);
1020         }
1021     }
1022
1023   free_chain (CPP_OPTION (pfile, pending)->directive_head);
1024   _cpp_push_next_buffer (pfile);
1025 }
1026
1027 /* Called to push the next buffer on the stack given by -include.  If
1028    there are none, free the pending structure and restore the line map
1029    for the main file.  */
1030 bool
1031 _cpp_push_next_buffer (pfile)
1032      cpp_reader *pfile;
1033 {
1034   bool pushed = false;
1035
1036   /* This is't pretty; we'd rather not be relying on this as a boolean
1037      for reverting the line map.  Further, we only free the chains in
1038      this conditional, so an early call to cpp_finish / cpp_destroy
1039      will leak that memory.  */
1040   if (CPP_OPTION (pfile, pending)
1041       && CPP_OPTION (pfile, pending)->imacros_head == NULL)
1042     {
1043       while (!pushed)
1044         {
1045           struct pending_option *p = CPP_OPTION (pfile, pending)->include_head;
1046
1047           if (p == NULL)
1048             break;
1049           if (! CPP_OPTION (pfile, preprocessed))
1050             pushed = push_include (pfile, p);
1051           CPP_OPTION (pfile, pending)->include_head = p->next;
1052           free (p);
1053         }
1054
1055       if (!pushed)
1056         {
1057           free (CPP_OPTION (pfile, pending));
1058           CPP_OPTION (pfile, pending) = NULL;
1059
1060           /* Restore the line map for the main file.  */
1061           if (! CPP_OPTION (pfile, preprocessed))
1062             _cpp_do_file_change (pfile, LC_RENAME,
1063                                  pfile->line_maps.maps[0].to_file, 1, 0);
1064         }
1065     }
1066
1067   return pushed;
1068 }
1069
1070 /* Use mkdeps.c to output dependency information.  */
1071 static void
1072 output_deps (pfile)
1073      cpp_reader *pfile;
1074 {
1075   /* Stream on which to print the dependency information.  */
1076   FILE *deps_stream = 0;
1077   const char *const deps_mode =
1078     CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
1079
1080   if (CPP_OPTION (pfile, deps_file) == 0)
1081     deps_stream = stdout;
1082   else
1083     {
1084       deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
1085       if (deps_stream == 0)
1086         {
1087           cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
1088           return;
1089         }
1090     }
1091
1092   deps_write (pfile->deps, deps_stream, 72);
1093
1094   if (CPP_OPTION (pfile, deps_phony_targets))
1095     deps_phony_targets (pfile->deps, deps_stream);
1096
1097   /* Don't close stdout.  */
1098   if (CPP_OPTION (pfile, deps_file))
1099     {
1100       if (ferror (deps_stream) || fclose (deps_stream) != 0)
1101         cpp_fatal (pfile, "I/O error on output");
1102     }
1103 }
1104
1105 /* This is called at the end of preprocessing.  It pops the
1106    last buffer and writes dependency output.  It should also
1107    clear macro definitions, such that you could call cpp_start_read
1108    with a new filename to restart processing.  */
1109 void
1110 cpp_finish (pfile)
1111      cpp_reader *pfile;
1112 {
1113   /* cpplex.c leaves the final buffer on the stack.  This it so that
1114      it returns an unending stream of CPP_EOFs to the client.  If we
1115      popped the buffer, we'd dereference a NULL buffer pointer and
1116      segfault.  It's nice to allow the client to do worry-free excess
1117      cpp_get_token calls.  */
1118   while (pfile->buffer)
1119     _cpp_pop_buffer (pfile);
1120
1121   /* Don't write the deps file if preprocessing has failed.  */
1122   if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
1123     output_deps (pfile);
1124
1125   /* Report on headers that could use multiple include guards.  */
1126   if (CPP_OPTION (pfile, print_include_names))
1127     _cpp_report_missing_guards (pfile);
1128 }
1129
1130 static void
1131 new_pending_directive (pend, text, handler)
1132      struct cpp_pending *pend;
1133      const char *text;
1134      cl_directive_handler handler;
1135 {
1136   struct pending_option *o = (struct pending_option *)
1137     xmalloc (sizeof (struct pending_option));
1138
1139   o->arg = text;
1140   o->next = NULL;
1141   o->handler = handler;
1142   APPEND (pend, directive, o);
1143 }
1144
1145 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1146    I.e. a const string initializer with parens around it.  That is
1147    what N_("string") resolves to, so we make no_* be macros instead.  */
1148 #define no_arg N_("Argument missing after %s")
1149 #define no_ass N_("Assertion missing after %s")
1150 #define no_dir N_("Directory name missing after %s")
1151 #define no_fil N_("File name missing after %s")
1152 #define no_mac N_("Macro name missing after %s")
1153 #define no_pth N_("Path name missing after %s")
1154 #define no_num N_("Number missing after %s")
1155 #define no_tgt N_("Target missing after %s")
1156
1157 /* This is the list of all command line options, with the leading
1158    "-" removed.  It must be sorted in ASCII collating order.  */
1159 #define COMMAND_LINE_OPTIONS                                                  \
1160   DEF_OPT("$",                        0,      OPT_dollar)                     \
1161   DEF_OPT("+",                        0,      OPT_plus)                       \
1162   DEF_OPT("-help",                    0,      OPT__help)                      \
1163   DEF_OPT("-target-help",             0,      OPT_target__help)               \
1164   DEF_OPT("-version",                 0,      OPT__version)                   \
1165   DEF_OPT("A",                        no_ass, OPT_A)                          \
1166   DEF_OPT("C",                        0,      OPT_C)                          \
1167   DEF_OPT("D",                        no_mac, OPT_D)                          \
1168   DEF_OPT("H",                        0,      OPT_H)                          \
1169   DEF_OPT("I",                        no_dir, OPT_I)                          \
1170   DEF_OPT("M",                        0,      OPT_M)                          \
1171   DEF_OPT("MD",                       no_fil, OPT_MD)                         \
1172   DEF_OPT("MF",                       no_fil, OPT_MF)                         \
1173   DEF_OPT("MG",                       0,      OPT_MG)                         \
1174   DEF_OPT("MM",                       0,      OPT_MM)                         \
1175   DEF_OPT("MMD",                      no_fil, OPT_MMD)                        \
1176   DEF_OPT("MP",                       0,      OPT_MP)                         \
1177   DEF_OPT("MQ",                       no_tgt, OPT_MQ)                         \
1178   DEF_OPT("MT",                       no_tgt, OPT_MT)                         \
1179   DEF_OPT("P",                        0,      OPT_P)                          \
1180   DEF_OPT("U",                        no_mac, OPT_U)                          \
1181   DEF_OPT("W",                        no_arg, OPT_W)  /* arg optional */      \
1182   DEF_OPT("d",                        no_arg, OPT_d)                          \
1183   DEF_OPT("fleading-underscore",      0,      OPT_fleading_underscore)        \
1184   DEF_OPT("fno-leading-underscore",   0,      OPT_fno_leading_underscore)     \
1185   DEF_OPT("fno-operator-names",       0,      OPT_fno_operator_names)         \
1186   DEF_OPT("fno-preprocessed",         0,      OPT_fno_preprocessed)           \
1187   DEF_OPT("fno-show-column",          0,      OPT_fno_show_column)            \
1188   DEF_OPT("fpreprocessed",            0,      OPT_fpreprocessed)              \
1189   DEF_OPT("fshow-column",             0,      OPT_fshow_column)               \
1190   DEF_OPT("ftabstop=",                no_num, OPT_ftabstop)                   \
1191   DEF_OPT("h",                        0,      OPT_h)                          \
1192   DEF_OPT("idirafter",                no_dir, OPT_idirafter)                  \
1193   DEF_OPT("imacros",                  no_fil, OPT_imacros)                    \
1194   DEF_OPT("include",                  no_fil, OPT_include)                    \
1195   DEF_OPT("iprefix",                  no_pth, OPT_iprefix)                    \
1196   DEF_OPT("isystem",                  no_dir, OPT_isystem)                    \
1197   DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix)                \
1198   DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore)          \
1199   DEF_OPT("lang-asm",                 0,      OPT_lang_asm)                   \
1200   DEF_OPT("lang-c",                   0,      OPT_lang_c)                     \
1201   DEF_OPT("lang-c++",                 0,      OPT_lang_cplusplus)             \
1202   DEF_OPT("lang-c89",                 0,      OPT_lang_c89)                   \
1203   DEF_OPT("lang-objc",                0,      OPT_lang_objc)                  \
1204   DEF_OPT("lang-objc++",              0,      OPT_lang_objcplusplus)          \
1205   DEF_OPT("nostdinc",                 0,      OPT_nostdinc)                   \
1206   DEF_OPT("nostdinc++",               0,      OPT_nostdincplusplus)           \
1207   DEF_OPT("o",                        no_fil, OPT_o)                          \
1208   DEF_OPT("pedantic",                 0,      OPT_pedantic)                   \
1209   DEF_OPT("pedantic-errors",          0,      OPT_pedantic_errors)            \
1210   DEF_OPT("remap",                    0,      OPT_remap)                      \
1211   DEF_OPT("std=c++98",                0,      OPT_std_cplusplus98)            \
1212   DEF_OPT("std=c89",                  0,      OPT_std_c89)                    \
1213   DEF_OPT("std=c99",                  0,      OPT_std_c99)                    \
1214   DEF_OPT("std=c9x",                  0,      OPT_std_c9x)                    \
1215   DEF_OPT("std=gnu89",                0,      OPT_std_gnu89)                  \
1216   DEF_OPT("std=gnu99",                0,      OPT_std_gnu99)                  \
1217   DEF_OPT("std=gnu9x",                0,      OPT_std_gnu9x)                  \
1218   DEF_OPT("std=iso9899:1990",         0,      OPT_std_iso9899_1990)           \
1219   DEF_OPT("std=iso9899:199409",       0,      OPT_std_iso9899_199409)         \
1220   DEF_OPT("std=iso9899:1999",         0,      OPT_std_iso9899_1999)           \
1221   DEF_OPT("std=iso9899:199x",         0,      OPT_std_iso9899_199x)           \
1222   DEF_OPT("trigraphs",                0,      OPT_trigraphs)                  \
1223   DEF_OPT("v",                        0,      OPT_v)                          \
1224   DEF_OPT("version",                  0,      OPT_version)                    \
1225   DEF_OPT("w",                        0,      OPT_w)
1226
1227 #define DEF_OPT(text, msg, code) code,
1228 enum opt_code
1229 {
1230   COMMAND_LINE_OPTIONS
1231   N_OPTS
1232 };
1233 #undef DEF_OPT
1234
1235 struct cl_option
1236 {
1237   const char *opt_text;
1238   const char *msg;
1239   size_t opt_len;
1240   enum opt_code opt_code;
1241 };
1242
1243 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1244 #ifdef HOST_EBCDIC
1245 static struct cl_option cl_options[] =
1246 #else
1247 static const struct cl_option cl_options[] =
1248 #endif
1249 {
1250   COMMAND_LINE_OPTIONS
1251 };
1252 #undef DEF_OPT
1253 #undef COMMAND_LINE_OPTIONS
1254
1255 /* Perform a binary search to find which, if any, option the given
1256    command-line matches.  Returns its index in the option array,
1257    negative on failure.  Complications arise since some options can be
1258    suffixed with an argument, and multiple complete matches can occur,
1259    e.g. -iwithprefix and -iwithprefixbefore.  Moreover, we need to
1260    accept options beginning with -W that we do not recognise, but not
1261    to swallow any subsequent command line argument; this is handled as
1262    special cases in cpp_handle_option.  */
1263 static int
1264 parse_option (input)
1265      const char *input;
1266 {
1267   unsigned int md, mn, mx;
1268   size_t opt_len;
1269   int comp;
1270
1271   mn = 0;
1272   mx = N_OPTS;
1273
1274   while (mx > mn)
1275     {
1276       md = (mn + mx) / 2;
1277
1278       opt_len = cl_options[md].opt_len;
1279       comp = memcmp (input, cl_options[md].opt_text, opt_len);
1280
1281       if (comp > 0)
1282         mn = md + 1;
1283       else if (comp < 0)
1284         mx = md;
1285       else
1286         {
1287           if (input[opt_len] == '\0')
1288             return md;
1289           /* We were passed more text.  If the option takes an argument,
1290              we may match a later option or we may have been passed the
1291              argument.  The longest possible option match succeeds.
1292              If the option takes no arguments we have not matched and
1293              continue the search (e.g. input="stdc++" match was "stdc").  */
1294           mn = md + 1;
1295           if (cl_options[md].msg)
1296             {
1297               /* Scan forwards.  If we get an exact match, return it.
1298                  Otherwise, return the longest option-accepting match.
1299                  This loops no more than twice with current options.  */
1300               mx = md;
1301               for (; mn < (unsigned int) N_OPTS; mn++)
1302                 {
1303                   opt_len = cl_options[mn].opt_len;
1304                   if (memcmp (input, cl_options[mn].opt_text, opt_len))
1305                     break;
1306                   if (input[opt_len] == '\0')
1307                     return mn;
1308                   if (cl_options[mn].msg)
1309                     mx = mn;
1310                 }
1311               return mx;
1312             }
1313         }
1314     }
1315
1316   return -1;
1317 }
1318
1319 /* Handle one command-line option in (argc, argv).
1320    Can be called multiple times, to handle multiple sets of options.
1321    Returns number of strings consumed.  */
1322
1323 int
1324 cpp_handle_option (pfile, argc, argv)
1325      cpp_reader *pfile;
1326      int argc;
1327      char **argv;
1328 {
1329   int i = 0;
1330   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1331
1332   /* Interpret "-" or a non-option as a file name.  */
1333   if (argv[i][0] != '-' || argv[i][1] == '\0')
1334     {
1335       if (CPP_OPTION (pfile, in_fname) == NULL)
1336         CPP_OPTION (pfile, in_fname) = argv[i];
1337       else if (CPP_OPTION (pfile, out_fname) == NULL)
1338         CPP_OPTION (pfile, out_fname) = argv[i];
1339       else
1340         cpp_fatal (pfile, "Too many filenames. Type %s --help for usage info",
1341                    progname);
1342     }
1343   else
1344     {
1345       enum opt_code opt_code;
1346       int opt_index;
1347       const char *arg = 0;
1348
1349       /* Skip over '-'.  */
1350       opt_index = parse_option (&argv[i][1]);
1351       if (opt_index < 0)
1352         return i;
1353
1354       opt_code = cl_options[opt_index].opt_code;
1355       if (cl_options[opt_index].msg)
1356         {
1357           arg = &argv[i][cl_options[opt_index].opt_len + 1];
1358
1359           /* Yuk. Special case for -W as it must not swallow
1360              up any following argument.  If this becomes common, add
1361              another field to the cl_options table.  */
1362           if (arg[0] == '\0' && opt_code != OPT_W)
1363             {
1364               arg = argv[++i];
1365               if (!arg)
1366                 {
1367                   cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1368                   return argc;
1369                 }
1370             }
1371         }
1372
1373       switch (opt_code)
1374         {
1375         case N_OPTS: /* Shut GCC up.  */
1376           break;
1377         case OPT_fleading_underscore:
1378           CPP_OPTION (pfile, user_label_prefix) = "_";
1379           break;
1380         case OPT_fno_leading_underscore:
1381           CPP_OPTION (pfile, user_label_prefix) = "";
1382           break;
1383         case OPT_fno_operator_names:
1384           CPP_OPTION (pfile, operator_names) = 0;
1385           break;
1386         case OPT_fpreprocessed:
1387           CPP_OPTION (pfile, preprocessed) = 1;
1388           break;
1389         case OPT_fno_preprocessed:
1390           CPP_OPTION (pfile, preprocessed) = 0;
1391           break;
1392         case OPT_fshow_column:
1393           CPP_OPTION (pfile, show_column) = 1;
1394           break;
1395         case OPT_fno_show_column:
1396           CPP_OPTION (pfile, show_column) = 0;
1397           break;
1398         case OPT_ftabstop:
1399           /* Silently ignore empty string, non-longs and silly values.  */
1400           if (arg[0] != '\0')
1401             {
1402               char *endptr;
1403               long tabstop = strtol (arg, &endptr, 10);
1404               if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1405                 CPP_OPTION (pfile, tabstop) = tabstop;
1406             }
1407           break;
1408         case OPT_w:
1409           CPP_OPTION (pfile, inhibit_warnings) = 1;
1410           break;
1411         case OPT_h:
1412         case OPT__help:
1413           print_help ();
1414           CPP_OPTION (pfile, help_only) = 1;
1415           break;
1416         case OPT_target__help:
1417           /* Print if any target specific options. cpplib has none, but
1418              make sure help_only gets set.  */
1419           CPP_OPTION (pfile, help_only) = 1;
1420           break;
1421
1422           /* --version inhibits compilation, -version doesn't. -v means
1423              verbose and -version.  Historical reasons, don't ask.  */
1424         case OPT__version:
1425           CPP_OPTION (pfile, help_only) = 1;
1426           pfile->print_version = 1;
1427           break;
1428         case OPT_v:
1429           CPP_OPTION (pfile, verbose) = 1;
1430           pfile->print_version = 1;
1431           break;
1432         case OPT_version:
1433           pfile->print_version = 1;
1434           break;
1435
1436         case OPT_C:
1437           CPP_OPTION (pfile, discard_comments) = 0;
1438           break;
1439         case OPT_P:
1440           CPP_OPTION (pfile, no_line_commands) = 1;
1441           break;
1442         case OPT_dollar:        /* Don't include $ in identifiers.  */
1443           CPP_OPTION (pfile, dollars_in_ident) = 0;
1444           break;
1445         case OPT_H:
1446           CPP_OPTION (pfile, print_include_names) = 1;
1447           break;
1448         case OPT_D:
1449           new_pending_directive (pend, arg, cpp_define);
1450           break;
1451         case OPT_pedantic_errors:
1452           CPP_OPTION (pfile, pedantic_errors) = 1;
1453           /* fall through */
1454         case OPT_pedantic:
1455           CPP_OPTION (pfile, pedantic) = 1;
1456           break;
1457         case OPT_trigraphs:
1458           CPP_OPTION (pfile, trigraphs) = 1;
1459           break;
1460         case OPT_plus:
1461           CPP_OPTION (pfile, cplusplus) = 1;
1462           CPP_OPTION (pfile, cplusplus_comments) = 1;
1463           break;
1464         case OPT_remap:
1465           CPP_OPTION (pfile, remap) = 1;
1466           break;
1467         case OPT_iprefix:
1468           CPP_OPTION (pfile, include_prefix) = arg;
1469           CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1470           break;
1471         case OPT_lang_c:
1472           set_lang (pfile, CLK_GNUC89);
1473           break;
1474         case OPT_lang_cplusplus:
1475           set_lang (pfile, CLK_GNUCXX);
1476           break;
1477         case OPT_lang_objc:
1478           set_lang (pfile, CLK_OBJC);
1479           break;
1480         case OPT_lang_objcplusplus:
1481           set_lang (pfile, CLK_OBJCXX);
1482           break;
1483         case OPT_lang_asm:
1484           set_lang (pfile, CLK_ASM);
1485           break;
1486         case OPT_std_cplusplus98:
1487           set_lang (pfile, CLK_CXX98);
1488           break;
1489         case OPT_std_gnu89:
1490           set_lang (pfile, CLK_GNUC89);
1491           break;
1492         case OPT_std_gnu9x:
1493         case OPT_std_gnu99:
1494           set_lang (pfile, CLK_GNUC99);
1495           break;
1496         case OPT_std_iso9899_199409:
1497           set_lang (pfile, CLK_STDC94);
1498           break;
1499         case OPT_std_iso9899_1990:
1500         case OPT_std_c89:
1501         case OPT_lang_c89:
1502           set_lang (pfile, CLK_STDC89);
1503           break;
1504         case OPT_std_iso9899_199x:
1505         case OPT_std_iso9899_1999:
1506         case OPT_std_c9x:
1507         case OPT_std_c99:
1508           set_lang (pfile, CLK_STDC99);
1509           break;
1510         case OPT_nostdinc:
1511           /* -nostdinc causes no default include directories.
1512              You must specify all include-file directories with -I.  */
1513           CPP_OPTION (pfile, no_standard_includes) = 1;
1514           break;
1515         case OPT_nostdincplusplus:
1516           /* -nostdinc++ causes no default C++-specific include directories.  */
1517           CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1518           break;
1519         case OPT_o:
1520           if (CPP_OPTION (pfile, out_fname) == NULL)
1521             CPP_OPTION (pfile, out_fname) = arg;
1522           else
1523             {
1524               cpp_fatal (pfile, "output filename specified twice");
1525               return argc;
1526             }
1527           break;
1528         case OPT_d:
1529           /* Args to -d specify what parts of macros to dump.
1530              Silently ignore unrecognised options; they may
1531              be aimed at the compiler proper.  */
1532           {
1533             char c;
1534
1535             while ((c = *arg++) != '\0')
1536               switch (c)
1537                 {
1538                 case 'M':
1539                   CPP_OPTION (pfile, dump_macros) = dump_only;
1540                   CPP_OPTION (pfile, no_output) = 1;
1541                   break;
1542                 case 'N':
1543                   CPP_OPTION (pfile, dump_macros) = dump_names;
1544                   break;
1545                 case 'D':
1546                   CPP_OPTION (pfile, dump_macros) = dump_definitions;
1547                   break;
1548                 case 'I':
1549                   CPP_OPTION (pfile, dump_includes) = 1;
1550                   break;
1551                 }
1552           }
1553           break;
1554
1555         case OPT_MG:
1556           CPP_OPTION (pfile, print_deps_missing_files) = 1;
1557           break;
1558         case OPT_M:
1559           CPP_OPTION (pfile, print_deps) = 2;
1560           break;
1561         case OPT_MM:
1562           CPP_OPTION (pfile, print_deps) = 1;
1563           break;
1564         case OPT_MF:
1565           CPP_OPTION (pfile, deps_file) = arg;
1566           break;
1567         case OPT_MP:
1568           CPP_OPTION (pfile, deps_phony_targets) = 1;
1569           break;
1570         case OPT_MQ:
1571         case OPT_MT:
1572           /* Add a target.  -MQ quotes for Make.  */
1573           deps_add_target (pfile->deps, arg, opt_code == OPT_MQ);
1574           break;
1575
1576           /* -MD and -MMD for cpp0 are deprecated and undocumented
1577              (use -M or -MM with -MF instead), and probably should be
1578              removed with the next major GCC version.  For the moment
1579              we allow these for the benefit of Automake 1.4, which
1580              uses these when dependency tracking is enabled.  Automake
1581              1.5 will fix this.  */
1582         case OPT_MD:
1583           CPP_OPTION (pfile, print_deps) = 2;
1584           CPP_OPTION (pfile, deps_file) = arg;
1585           break;
1586         case OPT_MMD:
1587           CPP_OPTION (pfile, print_deps) = 1;
1588           CPP_OPTION (pfile, deps_file) = arg;
1589           break;
1590
1591         case OPT_A:
1592           if (arg[0] == '-')
1593             {
1594               /* -A with an argument beginning with '-' acts as
1595                  #unassert on whatever immediately follows the '-'.
1596                  If "-" is the whole argument, we eliminate all
1597                  predefined macros and assertions, including those
1598                  that were specified earlier on the command line.
1599                  That way we can get rid of any that were passed
1600                  automatically in from GCC.  */
1601
1602               if (arg[1] == '\0')
1603                 {
1604                   free_chain (pend->directive_head);
1605                   pend->directive_head = NULL;
1606                   pend->directive_tail = NULL;
1607                 }
1608               else
1609                 new_pending_directive (pend, arg + 1, cpp_unassert);
1610             }
1611           else
1612             new_pending_directive (pend, arg, cpp_assert);
1613           break;
1614         case OPT_U:
1615           new_pending_directive (pend, arg, cpp_undef);
1616           break;
1617         case OPT_I:           /* Add directory to path for includes.  */
1618           if (!strcmp (arg, "-"))
1619             {
1620               /* -I- means:
1621                  Use the preceding -I directories for #include "..."
1622                  but not #include <...>.
1623                  Don't search the directory of the present file
1624                  for #include "...".  (Note that -I. -I- is not the same as
1625                  the default setup; -I. uses the compiler's working dir.)  */
1626               if (! CPP_OPTION (pfile, ignore_srcdir))
1627                 {
1628                   pend->quote_head = pend->brack_head;
1629                   pend->quote_tail = pend->brack_tail;
1630                   pend->brack_head = 0;
1631                   pend->brack_tail = 0;
1632                   CPP_OPTION (pfile, ignore_srcdir) = 1;
1633                 }
1634               else
1635                 {
1636                   cpp_fatal (pfile, "-I- specified twice");
1637                   return argc;
1638                 }
1639             }
1640           else
1641             append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1642           break;
1643         case OPT_isystem:
1644           /* Add directory to beginning of system include path, as a system
1645              include directory.  */
1646           append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1647           break;
1648         case OPT_include:
1649         case OPT_imacros:
1650           {
1651             struct pending_option *o = (struct pending_option *)
1652               xmalloc (sizeof (struct pending_option));
1653             o->arg = arg;
1654             o->next = NULL;
1655
1656             if (opt_code == OPT_include)
1657               APPEND (pend, include, o);
1658             else
1659               APPEND (pend, imacros, o);
1660           }
1661           break;
1662         case OPT_iwithprefix:
1663           /* Add directory to end of path for includes,
1664              with the default prefix at the front of its name.  */
1665           /* fall through */
1666         case OPT_iwithprefixbefore:
1667           /* Add directory to main path for includes,
1668              with the default prefix at the front of its name.  */
1669           {
1670             char *fname;
1671             int len;
1672
1673             len = strlen (arg);
1674
1675             if (CPP_OPTION (pfile, include_prefix) != 0)
1676               {
1677                 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1678                 fname = xmalloc (ipl + len + 1);
1679                 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1680                 memcpy (fname + ipl, arg, len + 1);
1681               }
1682             else if (cpp_GCC_INCLUDE_DIR_len)
1683               {
1684                 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1685                 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1686                 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1687               }
1688             else
1689               fname = xstrdup (arg);
1690
1691             append_include_chain (pfile, fname,
1692                           opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1693           }
1694           break;
1695         case OPT_idirafter:
1696           /* Add directory to end of path for includes.  */
1697           append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1698           break;
1699         case OPT_W:
1700           /* Silently ignore unrecognised options.  */
1701           if (!strcmp (argv[i], "-Wall"))
1702             {
1703               CPP_OPTION (pfile, warn_trigraphs) = 1;
1704               CPP_OPTION (pfile, warn_comments) = 1;
1705             }
1706           else if (!strcmp (argv[i], "-Wtraditional"))
1707             CPP_OPTION (pfile, warn_traditional) = 1;
1708           else if (!strcmp (argv[i], "-Wtrigraphs"))
1709             CPP_OPTION (pfile, warn_trigraphs) = 1;
1710           else if (!strcmp (argv[i], "-Wcomment"))
1711             CPP_OPTION (pfile, warn_comments) = 1;
1712           else if (!strcmp (argv[i], "-Wcomments"))
1713             CPP_OPTION (pfile, warn_comments) = 1;
1714           else if (!strcmp (argv[i], "-Wundef"))
1715             CPP_OPTION (pfile, warn_undef) = 1;
1716           else if (!strcmp (argv[i], "-Wimport"))
1717             CPP_OPTION (pfile, warn_import) = 1;
1718           else if (!strcmp (argv[i], "-Werror"))
1719             CPP_OPTION (pfile, warnings_are_errors) = 1;
1720           else if (!strcmp (argv[i], "-Wsystem-headers"))
1721             CPP_OPTION (pfile, warn_system_headers) = 1;
1722           else if (!strcmp (argv[i], "-Wno-traditional"))
1723             CPP_OPTION (pfile, warn_traditional) = 0;
1724           else if (!strcmp (argv[i], "-Wno-trigraphs"))
1725             CPP_OPTION (pfile, warn_trigraphs) = 0;
1726           else if (!strcmp (argv[i], "-Wno-comment"))
1727             CPP_OPTION (pfile, warn_comments) = 0;
1728           else if (!strcmp (argv[i], "-Wno-comments"))
1729             CPP_OPTION (pfile, warn_comments) = 0;
1730           else if (!strcmp (argv[i], "-Wno-undef"))
1731             CPP_OPTION (pfile, warn_undef) = 0;
1732           else if (!strcmp (argv[i], "-Wno-import"))
1733             CPP_OPTION (pfile, warn_import) = 0;
1734           else if (!strcmp (argv[i], "-Wno-error"))
1735             CPP_OPTION (pfile, warnings_are_errors) = 0;
1736           else if (!strcmp (argv[i], "-Wno-system-headers"))
1737             CPP_OPTION (pfile, warn_system_headers) = 0;
1738           break;
1739         }
1740     }
1741   return i + 1;
1742 }
1743
1744 /* Handle command-line options in (argc, argv).
1745    Can be called multiple times, to handle multiple sets of options.
1746    Returns if an unrecognized option is seen.
1747    Returns number of strings consumed.  */
1748 int
1749 cpp_handle_options (pfile, argc, argv)
1750      cpp_reader *pfile;
1751      int argc;
1752      char **argv;
1753 {
1754   int i;
1755   int strings_processed;
1756
1757   for (i = 0; i < argc; i += strings_processed)
1758     {
1759       strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1760       if (strings_processed == 0)
1761         break;
1762     }
1763
1764   return i;
1765 }
1766
1767 /* Extra processing when all options are parsed, after all calls to
1768    cpp_handle_option[s].  Consistency checks etc.  */
1769 void
1770 cpp_post_options (pfile)
1771      cpp_reader *pfile;
1772 {
1773   if (pfile->print_version)
1774     {
1775       fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1776 #ifdef TARGET_VERSION
1777       TARGET_VERSION;
1778 #endif
1779       fputc ('\n', stderr);
1780     }
1781
1782   /* Canonicalize in_fname and out_fname.  We guarantee they are not
1783      NULL, and that the empty string represents stdin / stdout.  */
1784   if (CPP_OPTION (pfile, in_fname) == NULL
1785       || !strcmp (CPP_OPTION (pfile, in_fname), "-"))
1786     CPP_OPTION (pfile, in_fname) = "";
1787
1788   if (CPP_OPTION (pfile, out_fname) == NULL
1789       || !strcmp (CPP_OPTION (pfile, out_fname), "-"))
1790     CPP_OPTION (pfile, out_fname) = "";
1791
1792   /* -Wtraditional is not useful in C++ mode.  */
1793   if (CPP_OPTION (pfile, cplusplus))
1794     CPP_OPTION (pfile, warn_traditional) = 0;
1795
1796   /* Set this if it hasn't been set already.  */
1797   if (CPP_OPTION (pfile, user_label_prefix) == NULL)
1798     CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
1799
1800   /* Permanently disable macro expansion if we are rescanning
1801      preprocessed text.  */
1802   if (CPP_OPTION (pfile, preprocessed))
1803     pfile->state.prevent_expansion = 1;
1804
1805   /* We need to do this after option processing and before
1806      cpp_start_read, as cppmain.c relies on the options->no_output to
1807      set its callbacks correctly before calling cpp_start_read.  */
1808   init_dependency_output (pfile);
1809
1810   /* After checking the environment variables, check if -M or -MM has
1811      not been specified, but other -M options have.  */
1812   if (CPP_OPTION (pfile, print_deps) == 0 &&
1813       (CPP_OPTION (pfile, print_deps_missing_files)
1814        || CPP_OPTION (pfile, deps_file)
1815        || CPP_OPTION (pfile, deps_phony_targets)))
1816     cpp_fatal (pfile, "you must additionally specify either -M or -MM");
1817 }
1818
1819 /* Set up dependency-file output.  */
1820 static void
1821 init_dependency_output (pfile)
1822      cpp_reader *pfile;
1823 {
1824   char *spec, *s, *output_file;
1825
1826   /* Either of two environment variables can specify output of deps.
1827      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1828      where OUTPUT_FILE is the file to write deps info to
1829      and DEPS_TARGET is the target to mention in the deps.  */
1830
1831   if (CPP_OPTION (pfile, print_deps) == 0)
1832     {
1833       spec = getenv ("DEPENDENCIES_OUTPUT");
1834       if (spec)
1835         CPP_OPTION (pfile, print_deps) = 1;
1836       else
1837         {
1838           spec = getenv ("SUNPRO_DEPENDENCIES");
1839           if (spec)
1840             CPP_OPTION (pfile, print_deps) = 2;
1841           else
1842             return;
1843         }
1844
1845       /* Find the space before the DEPS_TARGET, if there is one.  */
1846       s = strchr (spec, ' ');
1847       if (s)
1848         {
1849           /* Let the caller perform MAKE quoting.  */
1850           deps_add_target (pfile->deps, s + 1, 0);
1851           output_file = (char *) xmalloc (s - spec + 1);
1852           memcpy (output_file, spec, s - spec);
1853           output_file[s - spec] = 0;
1854         }
1855       else
1856         output_file = spec;
1857
1858       /* Command line overrides environment variables.  */
1859       if (CPP_OPTION (pfile, deps_file) == 0)
1860         CPP_OPTION (pfile, deps_file) = output_file;
1861       CPP_OPTION (pfile, print_deps_append) = 1;
1862     }
1863
1864   /* If dependencies go to standard output, or -MG is used, we should
1865      suppress output, including -dM, -dI etc.  */
1866   if (CPP_OPTION (pfile, deps_file) == 0
1867       || CPP_OPTION (pfile, print_deps_missing_files))
1868     {
1869       CPP_OPTION (pfile, no_output) = 1;
1870       CPP_OPTION (pfile, dump_macros) = 0;
1871       CPP_OPTION (pfile, dump_includes) = 0;
1872     }
1873 }
1874
1875 static void
1876 print_help ()
1877 {
1878   fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1879   /* To keep the lines from getting too long for some compilers, limit
1880      to about 500 characters (6 lines) per chunk.  */
1881   fputs (_("\
1882 Switches:\n\
1883   -include <file>           Include the contents of <file> before other files\n\
1884   -imacros <file>           Accept definition of macros in <file>\n\
1885   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1886   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1887   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1888   -isystem <dir>            Add <dir> to the start of the system include path\n\
1889 "), stdout);
1890   fputs (_("\
1891   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1892   -I <dir>                  Add <dir> to the end of the main include path\n\
1893   -I-                       Fine-grained include path control; see info docs\n\
1894   -nostdinc                 Do not search system include directories\n\
1895                              (dirs specified with -isystem will still be used)\n\
1896   -nostdinc++               Do not search system include directories for C++\n\
1897   -o <file>                 Put output into <file>\n\
1898 "), stdout);
1899   fputs (_("\
1900   -pedantic                 Issue all warnings demanded by strict ISO C\n\
1901   -pedantic-errors          Issue -pedantic warnings as errors instead\n\
1902   -trigraphs                Support ISO C trigraphs\n\
1903   -lang-c                   Assume that the input sources are in C\n\
1904   -lang-c89                 Assume that the input sources are in C89\n\
1905 "), stdout);
1906   fputs (_("\
1907   -lang-c++                 Assume that the input sources are in C++\n\
1908   -lang-objc                Assume that the input sources are in ObjectiveC\n\
1909   -lang-objc++              Assume that the input sources are in ObjectiveC++\n\
1910   -lang-asm                 Assume that the input sources are in assembler\n\
1911 "), stdout);
1912   fputs (_("\
1913   -std=<std name>           Specify the conformance standard; one of:\n\
1914                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1915                             iso9899:199409, iso9899:1999\n\
1916   -+                        Allow parsing of C++ style features\n\
1917   -w                        Inhibit warning messages\n\
1918   -Wtrigraphs               Warn if trigraphs are encountered\n\
1919   -Wno-trigraphs            Do not warn about trigraphs\n\
1920   -Wcomment{s}              Warn if one comment starts inside another\n\
1921 "), stdout);
1922   fputs (_("\
1923   -Wno-comment{s}           Do not warn about comments\n\
1924   -Wtraditional             Warn about features not present in traditional C\n\
1925   -Wno-traditional          Do not warn about traditional C\n\
1926   -Wundef                   Warn if an undefined macro is used by #if\n\
1927   -Wno-undef                Do not warn about testing undefined macros\n\
1928   -Wimport                  Warn about the use of the #import directive\n\
1929 "), stdout);
1930   fputs (_("\
1931   -Wno-import               Do not warn about the use of #import\n\
1932   -Werror                   Treat all warnings as errors\n\
1933   -Wno-error                Do not treat warnings as errors\n\
1934   -Wsystem-headers          Do not suppress warnings from system headers\n\
1935   -Wno-system-headers       Suppress warnings from system headers\n\
1936   -Wall                     Enable all preprocessor warnings\n\
1937 "), stdout);
1938   fputs (_("\
1939   -M                        Generate make dependencies\n\
1940   -MM                       As -M, but ignore system header files\n\
1941   -MF <file>                Write dependency output to the given file\n\
1942   -MG                       Treat missing header file as generated files\n\
1943 "), stdout);
1944   fputs (_("\
1945   -MP                       Generate phony targets for all headers\n\
1946   -MQ <target>              Add a MAKE-quoted target\n\
1947   -MT <target>              Add an unquoted target\n\
1948 "), stdout);
1949   fputs (_("\
1950   -D<macro>                 Define a <macro> with string '1' as its value\n\
1951   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1952   -A<question> (<answer>)   Assert the <answer> to <question>\n\
1953   -A-<question> (<answer>)  Disable the <answer> to <question>\n\
1954   -U<macro>                 Undefine <macro> \n\
1955   -v                        Display the version number\n\
1956 "), stdout);
1957   fputs (_("\
1958   -H                        Print the name of header files as they are used\n\
1959   -C                        Do not discard comments\n\
1960   -dM                       Display a list of macro definitions active at end\n\
1961   -dD                       Preserve macro definitions in output\n\
1962   -dN                       As -dD except that only the names are preserved\n\
1963   -dI                       Include #include directives in the output\n\
1964 "), stdout);
1965   fputs (_("\
1966   -fpreprocessed            Treat the input file as already preprocessed\n\
1967   -ftabstop=<number>        Distance between tab stops for column reporting\n\
1968   -P                        Do not generate #line directives\n\
1969   -$                        Do not allow '$' in identifiers\n\
1970   -remap                    Remap file names when including files.\n\
1971   --version                 Display version information\n\
1972   -h or --help              Display this information\n\
1973 "), stdout);
1974 }