gcc/cppinit.c

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