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