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