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