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