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