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