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