gcc/cppinit.c

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