gcc/cppinit.c

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