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