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