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 -imacros
  53    switch.  There are four lists: one for -D and -U, one for -A, one
  54    for -include, one for -imacros.  `undef' is set for -U, clear for
  55    -D, ignored for the others.
  56    (Future: add an equivalent of -U for -A) */
  57
  58 typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
  59 struct pending_option
  60 {
  61   struct pending_option *next;
  62   const char *arg;
  63   cl_directive_handler handler;
  64 };
  65
  66 /* The `pending' structure accumulates all the options that are not
  67    actually processed until we hit cpp_start_read.  It consists of
  68    several lists, one for each type of option.  We keep both head and
  69    tail pointers for quick insertion. */
  70 struct cpp_pending
  71 {
  72   struct pending_option *directive_head, *directive_tail;
  73
  74   struct file_name_list *quote_head, *quote_tail;
  75   struct file_name_list *brack_head, *brack_tail;
  76   struct file_name_list *systm_head, *systm_tail;
  77   struct file_name_list *after_head, *after_tail;
  78
  79   struct pending_option *imacros_head, *imacros_tail;
  80   struct pending_option *include_head, *include_tail;
  81 };
  82
  83 #ifdef __STDC__
  84 #define APPEND(pend, list, elt) \
  85   do {  if (!(pend)->list##_head) (pend)->list##_head = (elt); \
  86         else (pend)->list##_tail->next = (elt); \
  87         (pend)->list##_tail = (elt); \
  88   } while (0)
  89 #else
  90 #define APPEND(pend, list, elt) \
  91   do {  if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
  92         else (pend)->list/**/_tail->next = (elt); \
  93         (pend)->list/**/_tail = (elt); \
  94   } while (0)
  95 #endif
  96
  97 static void print_help                  PARAMS ((void));
  98 static void path_include                PARAMS ((cpp_reader *,
  99                                                  char *, int));
 100 static void initialize_builtins         PARAMS ((cpp_reader *));
 101 static void append_include_chain        PARAMS ((cpp_reader *,
 102                                                  char *, int, int));
 103 struct file_name_list * remove_dup_dir  PARAMS ((cpp_reader *,
 104                                                  struct file_name_list *));
 105 struct file_name_list * remove_dup_dirs PARAMS ((cpp_reader *,
 106                                                  struct file_name_list *));
 107 static void merge_include_chains        PARAMS ((cpp_reader *));
 108
 109 static void initialize_dependency_output PARAMS ((cpp_reader *));
 110 static void initialize_standard_includes PARAMS ((cpp_reader *));
 111 static void new_pending_directive       PARAMS ((struct cpp_pending *,
 112                                                  const char *,
 113                                                  cl_directive_handler));
 114 #ifdef HOST_EBCDIC
 115 static int opt_comp                     PARAMS ((const void *, const void *));
 116 #endif
 117 static int parse_option                 PARAMS ((const char *));
 118
 119 /* Fourth argument to append_include_chain: chain to use */
 120 enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
 121
 122 /* If we have designated initializers (GCC >2.7) these tables can be
 123    initialized, constant data.  Otherwise, they have to be filled in at
 124    runtime.  */
 125 #if HAVE_DESIGNATED_INITIALIZERS
 126
 127 #define init_IStable()  /* nothing */
 128 #define ISTABLE __extension__ const U_CHAR _cpp_IStable[UCHAR_MAX + 1] = {
 129
 130 #define init_trigraph_map()  /* nothing */
 131 #define TRIGRAPH_MAP \
 132 __extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
 133
 134 #define END };
 135 #define s(p, v) [p] = v,
 136
 137 #else
 138
 139 #define ISTABLE unsigned char _cpp_IStable[UCHAR_MAX + 1] = { 0 }; \
 140  static void init_IStable PARAMS ((void)) { \
 141  unsigned char *x = _cpp_IStable;
 142
 143 #define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
 144  static void init_trigraph_map PARAMS ((void)) { \
 145  unsigned char *x = _cpp_trigraph_map;
 146
 147 #define END }
 148 #define s(p, v) x[p] = v;
 149
 150 #endif
 151
 152 #define A(x) s(x, ISidnum|ISidstart)
 153 #define N(x) s(x, ISidnum|ISnumstart)
 154 #define H(x) s(x, IShspace|ISspace)
 155 #define V(x) s(x, ISvspace|ISspace)
 156 #define S(x) s(x, ISspace)
 157
 158 ISTABLE
 159   A('_')
 160
 161   A('a') A('b') A('c') A('d') A('e') A('f') A('g') A('h') A('i')
 162   A('j') A('k') A('l') A('m') A('n') A('o') A('p') A('q') A('r')
 163   A('s') A('t') A('u') A('v') A('w') A('x') A('y') A('z')
 164
 165   A('A') A('B') A('C') A('D') A('E') A('F') A('G') A('H') A('I')
 166   A('J') A('K') A('L') A('M') A('N') A('O') A('P') A('Q') A('R')
 167   A('S') A('T') A('U') A('V') A('W') A('X') A('Y') A('Z')
 168
 169   N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0')
 170
 171   H(' ') H('\t')
 172
 173   V('\n') V('\r')
 174
 175   S('\0') S('\v') S('\f')
 176 END
 177
 178 TRIGRAPH_MAP
 179   s('=', '#')   s(')', ']')     s('!', '|')
 180   s('(', '[')   s('\'', '^')    s('>', '}')
 181   s('/', '\\')  s('<', '{')     s('-', '~')
 182 END
 183
 184 #undef A
 185 #undef N
 186 #undef H
 187 #undef V
 188 #undef S
 189 #undef s
 190 #undef ISTABLE
 191 #undef END
 192 #undef TRIGRAPH_MAP
 193
 194 /* Given a colon-separated list of file names PATH,
 195    add all the names to the search path for include files.  */
 196
 197 static void
 198 path_include (pfile, list, path)
 199      cpp_reader *pfile;
 200      char *list;
 201      int path;
 202 {
 203   char *p, *q, *name;
 204
 205   p = list;
 206
 207   do
 208     {
 209       /* Find the end of this name.  */
 210       q = p;
 211       while (*q != 0 && *q != PATH_SEPARATOR) q++;
 212       if (q == p)
 213         {
 214           /* An empty name in the path stands for the current directory.  */
 215           name = (char *) xmalloc (2);
 216           name[0] = '.';
 217           name[1] = 0;
 218         }
 219       else
 220         {
 221           /* Otherwise use the directory that is named.  */
 222           name = (char *) xmalloc (q - p + 1);
 223           memcpy (name, p, q - p);
 224           name[q - p] = 0;
 225         }
 226
 227       append_include_chain (pfile, name, path, 0);
 228
 229       /* Advance past this name.  */
 230       if (*q == 0)
 231         break;
 232       p = q + 1;
 233     }
 234   while (1);
 235 }
 236
 237 /* Append DIR to include path PATH.  DIR must be permanently allocated
 238    and writable. */
 239 static void
 240 append_include_chain (pfile, dir, path, cxx_aware)
 241      cpp_reader *pfile;
 242      char *dir;
 243      int path;
 244      int cxx_aware;
 245 {
 246   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 247   struct file_name_list *new;
 248   struct stat st;
 249   unsigned int len;
 250
 251   _cpp_simplify_pathname (dir);
 252   if (stat (dir, &st))
 253     {
 254       /* Dirs that don't exist are silently ignored. */
 255       if (errno != ENOENT)
 256         cpp_notice_from_errno (pfile, dir);
 257       else if (CPP_OPTION (pfile, verbose))
 258         fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
 259       return;
 260     }
 261
 262   if (!S_ISDIR (st.st_mode))
 263     {
 264       cpp_notice (pfile, "%s: Not a directory", dir);
 265       return;
 266     }
 267
 268   len = strlen (dir);
 269   if (len > pfile->max_include_len)
 270     pfile->max_include_len = len;
 271
 272   new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
 273   new->name = dir;
 274   new->nlen = len;
 275   new->ino  = st.st_ino;
 276   new->dev  = st.st_dev;
 277   if (path == SYSTEM)
 278     new->sysp = cxx_aware ? 1 : 2;
 279   else
 280     new->sysp = 0;
 281   new->name_map = NULL;
 282   new->next = NULL;
 283   new->alloc = NULL;
 284
 285   switch (path)
 286     {
 287     case QUOTE:         APPEND (pend, quote, new); break;
 288     case BRACKET:       APPEND (pend, brack, new); break;
 289     case SYSTEM:        APPEND (pend, systm, new); break;
 290     case AFTER:         APPEND (pend, after, new); break;
 291     }
 292 }
 293
 294 /* Handle a duplicated include path.  PREV is the link in the chain
 295    before the duplicate.  The duplicate is removed from the chain and
 296    freed.  Returns PREV.  */
 297 struct file_name_list *
 298 remove_dup_dir (pfile, prev)
 299      cpp_reader *pfile;
 300      struct file_name_list *prev;
 301 {
 302   struct file_name_list *cur = prev->next;
 303
 304   if (CPP_OPTION (pfile, verbose))
 305     fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
 306
 307   prev->next = cur->next;
 308   free (cur->name);
 309   free (cur);
 310
 311   return prev;
 312 }
 313
 314 /* Remove duplicate directories from a chain.  Returns the tail of the
 315    chain, or NULL if the chain is empty.  This algorithm is quadratic
 316    in the number of -I switches, which is acceptable since there
 317    aren't usually that many of them.  */
 318 struct file_name_list *
 319 remove_dup_dirs (pfile, head)
 320      cpp_reader *pfile;
 321      struct file_name_list *head;
 322 {
 323   struct file_name_list *prev = NULL, *cur, *other;
 324
 325   for (cur = head; cur; cur = cur->next)
 326     {
 327       for (other = head; other != cur; other = other->next)
 328         if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
 329           {
 330             cur = remove_dup_dir (pfile, prev);
 331             break;
 332           }
 333       prev = cur;
 334     }
 335
 336   return prev;
 337 }
 338
 339 /* Merge the four include chains together in the order quote, bracket,
 340    system, after.  Remove duplicate dirs (as determined by
 341    INO_T_EQ()).  The system_include and after_include chains are never
 342    referred to again after this function; all access is through the
 343    bracket_include path.
 344
 345    For the future: Check if the directory is empty (but
 346    how?) and possibly preload the include hash. */
 347
 348 static void
 349 merge_include_chains (pfile)
 350      cpp_reader *pfile;
 351 {
 352   struct file_name_list *quote, *brack, *systm, *qtail;
 353
 354   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 355
 356   quote = pend->quote_head;
 357   brack = pend->brack_head;
 358   systm = pend->systm_head;
 359   qtail = pend->quote_tail;
 360
 361   /* Paste together bracket, system, and after include chains.  */
 362   if (systm)
 363     pend->systm_tail->next = pend->after_head;
 364   else
 365     systm = pend->after_head;
 366
 367   if (brack)
 368     pend->brack_tail->next = systm;
 369   else
 370     brack = systm;
 371
 372   /* This is a bit tricky.  First we drop dupes from the quote-include
 373      list.  Then we drop dupes from the bracket-include list.
 374      Finally, if qtail and brack are the same directory, we cut out
 375      brack.
 376
 377      We can't just merge the lists and then uniquify them because
 378      then we may lose directories from the <> search path that should
 379      be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
 380      safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
 381      -Ibar -I- -Ifoo -Iquux.  */
 382
 383   remove_dup_dirs (pfile, brack);
 384   qtail = remove_dup_dirs (pfile, quote);
 385
 386   if (quote)
 387     {
 388       qtail->next = brack;
 389
 390       /* If brack == qtail, remove brack as it's simpler.  */
 391       if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
 392         brack = remove_dup_dir (pfile, qtail);
 393     }
 394   else
 395       quote = brack;
 396
 397   CPP_OPTION (pfile, quote_include) = quote;
 398   CPP_OPTION (pfile, bracket_include) = brack;
 399 }
 400
 401 /* cpp_init initializes library global state.  It might not need to do
 402    anything depending on the platform and compiler, so we have a static
 403    flag to make sure it gets called before cpp_reader_init.  */
 404
 405 static int cpp_init_completed = 0;
 406
 407 void
 408 cpp_init ()
 409 {
 410 #ifdef HOST_EBCDIC
 411   /* For non-ASCII hosts, the cl_options array needs to be sorted at
 412      runtime.  */
 413   qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
 414 #endif
 415
 416   /* Set up the trigraph map and the IStable.  These don't need to do
 417      anything if we were compiled with a compiler that supports C99
 418      designated initializers.  */
 419   init_trigraph_map ();
 420   init_IStable ();
 421
 422   cpp_init_completed = 1;
 423 }
 424
 425 /* Initialize a cpp_reader structure. */
 426 void
 427 cpp_reader_init (pfile)
 428      cpp_reader *pfile;
 429 {
 430   struct spec_nodes *s;
 431
 432   memset ((char *) pfile, 0, sizeof (cpp_reader));
 433
 434   /* If cpp_init hasn't been called, generate a fatal error (by hand)
 435      and call it here.  */
 436   if (!cpp_init_completed)
 437     {
 438       fputs ("cpp_reader_init: internal error: cpp_init not called.\n", stderr);
 439       pfile->errors = CPP_FATAL_LIMIT;
 440       cpp_init ();
 441     }
 442
 443   CPP_OPTION (pfile, dollars_in_ident) = 1;
 444   CPP_OPTION (pfile, cplusplus_comments) = 1;
 445   CPP_OPTION (pfile, warn_import) = 1;
 446   CPP_OPTION (pfile, warn_paste) = 1;
 447   CPP_OPTION (pfile, digraphs) = 1;
 448   CPP_OPTION (pfile, discard_comments) = 1;
 449   CPP_OPTION (pfile, show_column) = 1;
 450   CPP_OPTION (pfile, tabstop) = 8;
 451
 452   CPP_OPTION (pfile, pending) =
 453     (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
 454
 455   /* Initialize comment saving state.  */
 456   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 457
 458   /* Indicate date and time not yet calculated.  */
 459   pfile->date.type = CPP_EOF;
 460
 461   /* Initialise the base context.  */
 462   pfile->context = &pfile->base_context;
 463   pfile->base_context.macro = 0;
 464   pfile->base_context.prev = pfile->base_context.next = 0;
 465
 466   /* Identifier pool initially 8K.  Unaligned, permanent pool.  */
 467   _cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0);
 468
 469   /* String and number pool initially 4K.  Unaligned, temporary pool.  */
 470   _cpp_init_pool (&pfile->temp_string_pool, 4 * 1024, 1, 1);
 471
 472   /* Argument pool initially 8K.  Aligned, temporary pool.  */
 473   _cpp_init_pool (&pfile->argument_pool, 8 * 1024, 0, 1);
 474
 475   /* Macro pool initially 8K.  Aligned, permanent pool.  */
 476   _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
 477
 478   /* Start with temporary pool.   */
 479   pfile->string_pool = &pfile->temp_string_pool;
 480
 481   _cpp_init_hashtable (pfile);
 482   _cpp_init_stacks (pfile);
 483   _cpp_init_includes (pfile);
 484   _cpp_init_internal_pragmas (pfile);
 485
 486   /* Initialize the special nodes.  */
 487   s = &pfile->spec_nodes;
 488   s->n_L                = cpp_lookup (pfile, DSC("L"));
 489   s->n_defined          = cpp_lookup (pfile, DSC("defined"));
 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           /* XXX Potential memory leak! */
 826           char *str = xstrdup (update_path (p->fname, p->component));
 827           append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
 828         }
 829     }
 830 }
 831
 832 /* This is called after options have been processed.
 833  * Check options for consistency, and setup for processing input
 834  * from the file named FNAME.  (Use standard input if FNAME==NULL.)
 835  * Return 1 on success, 0 on failure.
 836  */
 837
 838 int
 839 cpp_start_read (pfile, fname)
 840      cpp_reader *pfile;
 841      const char *fname;
 842 {
 843   struct pending_option *p, *q;
 844
 845   /* -MG doesn't select the form of output and must be specified with one of
 846      -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
 847      inhibit compilation.  */
 848   if (CPP_OPTION (pfile, print_deps_missing_files)
 849       && (CPP_OPTION (pfile, print_deps) == 0
 850           || !CPP_OPTION (pfile, no_output)))
 851     {
 852       cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
 853       return 0;
 854     }
 855
 856   /* -Wtraditional is not useful in C++ mode.  */
 857   if (CPP_OPTION (pfile, cplusplus))
 858     CPP_OPTION (pfile, warn_traditional) = 0;
 859
 860   /* Do not warn about invalid token pasting if -lang-asm.  */
 861   if (CPP_OPTION (pfile, lang_asm))
 862     CPP_OPTION (pfile, warn_paste) = 0;
 863
 864   /* Set this if it hasn't been set already. */
 865   if (CPP_OPTION (pfile, user_label_prefix) == NULL)
 866     CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
 867
 868   /* Set up the include search path now.  */
 869   if (! CPP_OPTION (pfile, no_standard_includes))
 870     initialize_standard_includes (pfile);
 871
 872   merge_include_chains (pfile);
 873
 874   /* With -v, print the list of dirs to search.  */
 875   if (CPP_OPTION (pfile, verbose))
 876     {
 877       struct file_name_list *l;
 878       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 879       for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
 880         {
 881           if (l == CPP_OPTION (pfile, bracket_include))
 882             fprintf (stderr, _("#include <...> search starts here:\n"));
 883           fprintf (stderr, " %s\n", l->name);
 884         }
 885       fprintf (stderr, _("End of search list.\n"));
 886     }
 887
 888   /* Open the main input file.  This must be done early, so we have a
 889      buffer to stand on.  */
 890   if (CPP_OPTION (pfile, in_fname) == NULL
 891       || *CPP_OPTION (pfile, in_fname) == 0)
 892     {
 893       CPP_OPTION (pfile, in_fname) = fname;
 894       if (CPP_OPTION (pfile, in_fname) == NULL)
 895         CPP_OPTION (pfile, in_fname) = "";
 896     }
 897   if (CPP_OPTION (pfile, out_fname) == NULL)
 898     CPP_OPTION (pfile, out_fname) = "";
 899
 900   if (!cpp_read_file (pfile, fname))
 901     return 0;
 902
 903   initialize_dependency_output (pfile);
 904
 905   /* Install __LINE__, etc.  */
 906   initialize_builtins (pfile);
 907
 908   /* Do -U's, -D's and -A's in the order they were seen.  */
 909   p = CPP_OPTION (pfile, pending)->directive_head;
 910   while (p)
 911     {
 912       (*p->handler) (pfile, p->arg);
 913       q = p->next;
 914       free (p);
 915       p = q;
 916     }
 917   pfile->done_initializing = 1;
 918
 919   /* The -imacros files can be scanned now, but the -include files
 920      have to be pushed onto the include stack and processed later,
 921      in the main loop calling cpp_get_token.  */
 922
 923   p = CPP_OPTION (pfile, pending)->imacros_head;
 924   while (p)
 925     {
 926       if (cpp_read_file (pfile, p->arg))
 927         cpp_scan_buffer_nooutput (pfile);
 928       q = p->next;
 929       free (p);
 930       p = q;
 931     }
 932
 933   p = CPP_OPTION (pfile, pending)->include_head;
 934   while (p)
 935     {
 936       cpp_read_file (pfile, p->arg);
 937       q = p->next;
 938       free (p);
 939       p = q;
 940     }
 941
 942   free (CPP_OPTION (pfile, pending));
 943   CPP_OPTION (pfile, pending) = NULL;
 944
 945   return 1;
 946 }
 947
 948 /* This is called at the end of preprocessing.  It pops the
 949    last buffer and writes dependency output.  It should also
 950    clear macro definitions, such that you could call cpp_start_read
 951    with a new filename to restart processing. */
 952 void
 953 cpp_finish (pfile)
 954      cpp_reader *pfile;
 955 {
 956   if (CPP_BUFFER (pfile))
 957     {
 958       cpp_ice (pfile, "buffers still stacked in cpp_finish");
 959       while (CPP_BUFFER (pfile))
 960         cpp_pop_buffer (pfile);
 961     }
 962
 963   /* Don't write the deps file if preprocessing has failed.  */
 964   if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
 965     {
 966       /* Stream on which to print the dependency information.  */
 967       FILE *deps_stream = 0;
 968       const char *deps_mode
 969         = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
 970       if (CPP_OPTION (pfile, deps_file) == 0)
 971         deps_stream = stdout;
 972       else
 973         {
 974           deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
 975           if (deps_stream == 0)
 976             cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
 977         }
 978       if (deps_stream)
 979         {
 980           deps_write (pfile->deps, deps_stream, 72);
 981           if (CPP_OPTION (pfile, deps_file))
 982             {
 983               if (ferror (deps_stream) || fclose (deps_stream) != 0)
 984                 cpp_fatal (pfile, "I/O error on output");
 985             }
 986         }
 987     }
 988
 989   /* Report on headers that could use multiple include guards.  */
 990   if (CPP_OPTION (pfile, print_include_names))
 991     _cpp_report_missing_guards (pfile);
 992 }
 993
 994 static void
 995 new_pending_directive (pend, text, handler)
 996      struct cpp_pending *pend;
 997      const char *text;
 998      cl_directive_handler handler;
 999 {
1000   struct pending_option *o = (struct pending_option *)
1001     xmalloc (sizeof (struct pending_option));
1002
1003   o->arg = text;
1004   o->next = NULL;
1005   o->handler = handler;
1006   APPEND (pend, directive, o);
1007 }
1008
1009 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1010    I.e. a const string initializer with parens around it.  That is
1011    what N_("string") resolves to, so we make no_* be macros instead.  */
1012 #define no_arg N_("Argument missing after %s")
1013 #define no_ass N_("Assertion missing after %s")
1014 #define no_dir N_("Directory name missing after %s")
1015 #define no_fil N_("File name missing after %s")
1016 #define no_mac N_("Macro name missing after %s")
1017 #define no_pth N_("Path name missing after %s")
1018 #define no_num N_("Number missing after %s")
1019
1020 /* This is the list of all command line options, with the leading
1021    "-" removed.  It must be sorted in ASCII collating order.  */
1022 #define COMMAND_LINE_OPTIONS                                                  \
1023   DEF_OPT("",                         0,      OPT_stdin_stdout)               \
1024   DEF_OPT("$",                        0,      OPT_dollar)                     \
1025   DEF_OPT("+",                        0,      OPT_plus)                       \
1026   DEF_OPT("-help",                    0,      OPT__help)                      \
1027   DEF_OPT("-version",                 0,      OPT__version)                   \
1028   DEF_OPT("A",                        no_ass, OPT_A)                          \
1029   DEF_OPT("C",                        0,      OPT_C)                          \
1030   DEF_OPT("D",                        no_mac, OPT_D)                          \
1031   DEF_OPT("H",                        0,      OPT_H)                          \
1032   DEF_OPT("I",                        no_dir, OPT_I)                          \
1033   DEF_OPT("M",                        0,      OPT_M)                          \
1034   DEF_OPT("MD",                       no_fil, OPT_MD)                         \
1035   DEF_OPT("MG",                       0,      OPT_MG)                         \
1036   DEF_OPT("MM",                       0,      OPT_MM)                         \
1037   DEF_OPT("MMD",                      no_fil, OPT_MMD)                        \
1038   DEF_OPT("P",                        0,      OPT_P)                          \
1039   DEF_OPT("U",                        no_mac, OPT_U)                          \
1040   DEF_OPT("W",                        no_arg, OPT_W)  /* arg optional */      \
1041   DEF_OPT("d",                        no_arg, OPT_d)                          \
1042   DEF_OPT("fleading-underscore",      0,      OPT_fleading_underscore)        \
1043   DEF_OPT("fno-leading-underscore",   0,      OPT_fno_leading_underscore)     \
1044   DEF_OPT("fno-preprocessed",         0,      OPT_fno_preprocessed)           \
1045   DEF_OPT("fno-show-column",          0,      OPT_fno_show_column)            \
1046   DEF_OPT("fpreprocessed",            0,      OPT_fpreprocessed)              \
1047   DEF_OPT("fshow-column",             0,      OPT_fshow_column)               \
1048   DEF_OPT("ftabstop=",                no_num, OPT_ftabstop)                   \
1049   DEF_OPT("g",                        no_arg, OPT_g)  /* arg optional */      \
1050   DEF_OPT("h",                        0,      OPT_h)                          \
1051   DEF_OPT("idirafter",                no_dir, OPT_idirafter)                  \
1052   DEF_OPT("imacros",                  no_fil, OPT_imacros)                    \
1053   DEF_OPT("include",                  no_fil, OPT_include)                    \
1054   DEF_OPT("iprefix",                  no_pth, OPT_iprefix)                    \
1055   DEF_OPT("isystem",                  no_dir, OPT_isystem)                    \
1056   DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix)                \
1057   DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore)          \
1058   DEF_OPT("lang-asm",                 0,      OPT_lang_asm)                   \
1059   DEF_OPT("lang-c",                   0,      OPT_lang_c)                     \
1060   DEF_OPT("lang-c++",                 0,      OPT_lang_cplusplus)             \
1061   DEF_OPT("lang-c89",                 0,      OPT_lang_c89)                   \
1062   DEF_OPT("lang-objc",                0,      OPT_lang_objc)                  \
1063   DEF_OPT("lang-objc++",              0,      OPT_lang_objcplusplus)          \
1064   DEF_OPT("nostdinc",                 0,      OPT_nostdinc)                   \
1065   DEF_OPT("nostdinc++",               0,      OPT_nostdincplusplus)           \
1066   DEF_OPT("o",                        no_fil, OPT_o)                          \
1067   DEF_OPT("pedantic",                 0,      OPT_pedantic)                   \
1068   DEF_OPT("pedantic-errors",          0,      OPT_pedantic_errors)            \
1069   DEF_OPT("remap",                    0,      OPT_remap)                      \
1070   DEF_OPT("std=c89",                  0,      OPT_std_c89)                    \
1071   DEF_OPT("std=c99",                  0,      OPT_std_c99)                    \
1072   DEF_OPT("std=c9x",                  0,      OPT_std_c9x)                    \
1073   DEF_OPT("std=gnu89",                0,      OPT_std_gnu89)                  \
1074   DEF_OPT("std=gnu99",                0,      OPT_std_gnu99)                  \
1075   DEF_OPT("std=gnu9x",                0,      OPT_std_gnu9x)                  \
1076   DEF_OPT("std=iso9899:1990",         0,      OPT_std_iso9899_1990)           \
1077   DEF_OPT("std=iso9899:199409",       0,      OPT_std_iso9899_199409)         \
1078   DEF_OPT("std=iso9899:1999",         0,      OPT_std_iso9899_1999)           \
1079   DEF_OPT("std=iso9899:199x",         0,      OPT_std_iso9899_199x)           \
1080   DEF_OPT("trigraphs",                0,      OPT_trigraphs)                  \
1081   DEF_OPT("v",                        0,      OPT_v)                          \
1082   DEF_OPT("w",                        0,      OPT_w)
1083
1084 #define DEF_OPT(text, msg, code) code,
1085 enum opt_code
1086 {
1087   COMMAND_LINE_OPTIONS
1088   N_OPTS
1089 };
1090 #undef DEF_OPT
1091
1092 struct cl_option
1093 {
1094   const char *opt_text;
1095   const char *msg;
1096   size_t opt_len;
1097   enum opt_code opt_code;
1098 };
1099
1100 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1101 #ifdef HOST_EBCDIC
1102 static struct cl_option cl_options[] =
1103 #else
1104 static const struct cl_option cl_options[] =
1105 #endif
1106 {
1107   COMMAND_LINE_OPTIONS
1108 };
1109 #undef DEF_OPT
1110 #undef COMMAND_LINE_OPTIONS
1111
1112 /* Perform a binary search to find which, if any, option the given
1113    command-line matches.  Returns its index in the option array,
1114    negative on failure.  Complications arise since some options can be
1115    suffixed with an argument, and multiple complete matches can occur,
1116    e.g. -iwithprefix and -iwithprefixbefore.  Moreover, we want to
1117    accept options beginning with -g and -W that we do not recognise,
1118    but not to swallow any subsequent command line argument; these are
1119    handled as special cases in cpp_handle_option */
1120 static int
1121 parse_option (input)
1122      const char *input;
1123 {
1124   unsigned int md, mn, mx;
1125   size_t opt_len;
1126   int comp;
1127
1128   mn = 0;
1129   mx = N_OPTS;
1130
1131   while (mx > mn)
1132     {
1133       md = (mn + mx) / 2;
1134
1135       opt_len = cl_options[md].opt_len;
1136       comp = memcmp (input, cl_options[md].opt_text, opt_len);
1137
1138       if (comp > 0)
1139         mn = md + 1;
1140       else if (comp < 0)
1141         mx = md;
1142       else
1143         {
1144           if (input[opt_len] == '\0')
1145             return md;
1146           /* We were passed more text.  If the option takes an argument,
1147              we may match a later option or we may have been passed the
1148              argument.  The longest possible option match succeeds.
1149              If the option takes no arguments we have not matched and
1150              continue the search (e.g. input="stdc++" match was "stdc") */
1151           mn = md + 1;
1152           if (cl_options[md].msg)
1153             {
1154               /* Scan forwards.  If we get an exact match, return it.
1155                  Otherwise, return the longest option-accepting match.
1156                  This loops no more than twice with current options */
1157               mx = md;
1158               for (; mn < N_OPTS; mn++)
1159                 {
1160                   opt_len = cl_options[mn].opt_len;
1161                   if (memcmp (input, cl_options[mn].opt_text, opt_len))
1162                     break;
1163                   if (input[opt_len] == '\0')
1164                     return mn;
1165                   if (cl_options[mn].msg)
1166                     mx = mn;
1167                 }
1168               return mx;
1169             }
1170         }
1171     }
1172
1173   return -1;
1174 }
1175
1176 /* Handle one command-line option in (argc, argv).
1177    Can be called multiple times, to handle multiple sets of options.
1178    Returns number of strings consumed.  */
1179
1180 int
1181 cpp_handle_option (pfile, argc, argv)
1182      cpp_reader *pfile;
1183      int argc;
1184      char **argv;
1185 {
1186   int i = 0;
1187   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1188
1189   if (argv[i][0] != '-')
1190     {
1191       if (CPP_OPTION (pfile, out_fname) != NULL)
1192         cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
1193                    progname);
1194       else if (CPP_OPTION (pfile, in_fname) != NULL)
1195         CPP_OPTION (pfile, out_fname) = argv[i];
1196       else
1197         CPP_OPTION (pfile, in_fname) = argv[i];
1198     }
1199   else
1200     {
1201       enum opt_code opt_code;
1202       int opt_index;
1203       const char *arg = 0;
1204
1205       /* Skip over '-' */
1206       opt_index = parse_option (&argv[i][1]);
1207       if (opt_index < 0)
1208         return i;
1209
1210       opt_code = cl_options[opt_index].opt_code;
1211       if (cl_options[opt_index].msg)
1212         {
1213           arg = &argv[i][cl_options[opt_index].opt_len + 1];
1214
1215           /* Yuk. Special case for -g and -W as they must not swallow
1216              up any following argument.  If this becomes common, add
1217              another field to the cl_options table */
1218           if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
1219             {
1220               arg = argv[++i];
1221               if (!arg)
1222                 {
1223                   cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1224                   return argc;
1225                 }
1226             }
1227         }
1228
1229       switch (opt_code)
1230         {
1231         case N_OPTS: /* shut GCC up */
1232           break;
1233         case OPT_fleading_underscore:
1234           CPP_OPTION (pfile, user_label_prefix) = "_";
1235           break;
1236         case OPT_fno_leading_underscore:
1237           CPP_OPTION (pfile, user_label_prefix) = "";
1238           break;
1239         case OPT_fpreprocessed:
1240           CPP_OPTION (pfile, preprocessed) = 1;
1241           break;
1242         case OPT_fno_preprocessed:
1243           CPP_OPTION (pfile, preprocessed) = 0;
1244           break;
1245         case OPT_fshow_column:
1246           CPP_OPTION (pfile, show_column) = 1;
1247           break;
1248         case OPT_fno_show_column:
1249           CPP_OPTION (pfile, show_column) = 0;
1250           break;
1251         case OPT_ftabstop:
1252           /* Silently ignore empty string, non-longs and silly values.  */
1253           if (arg[0] != '\0')
1254             {
1255               char *endptr;
1256               long tabstop = strtol (arg, &endptr, 10);
1257               if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1258                 CPP_OPTION (pfile, tabstop) = tabstop;
1259             }
1260           break;
1261         case OPT_w:
1262           CPP_OPTION (pfile, inhibit_warnings) = 1;
1263           break;
1264         case OPT_g:  /* Silently ignore anything but -g3 */
1265           if (!strcmp(&argv[i][2], "3"))
1266             CPP_OPTION (pfile, debug_output) = 1;
1267           break;
1268         case OPT_h:
1269         case OPT__help:
1270           print_help ();
1271           exit (0);  /* XXX */
1272           break;
1273         case OPT__version:
1274           fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1275           exit (0);  /* XXX */
1276           break;
1277         case OPT_C:
1278           CPP_OPTION (pfile, discard_comments) = 0;
1279           break;
1280         case OPT_P:
1281           CPP_OPTION (pfile, no_line_commands) = 1;
1282           break;
1283         case OPT_dollar:                /* Don't include $ in identifiers.  */
1284           CPP_OPTION (pfile, dollars_in_ident) = 0;
1285           break;
1286         case OPT_H:
1287           CPP_OPTION (pfile, print_include_names) = 1;
1288           break;
1289         case OPT_D:
1290           new_pending_directive (pend, arg, cpp_define);
1291           break;
1292         case OPT_pedantic_errors:
1293           CPP_OPTION (pfile, pedantic_errors) = 1;
1294           /* fall through */
1295         case OPT_pedantic:
1296           CPP_OPTION (pfile, pedantic) = 1;
1297           break;
1298         case OPT_trigraphs:
1299           CPP_OPTION (pfile, trigraphs) = 1;
1300           break;
1301         case OPT_plus:
1302           CPP_OPTION (pfile, cplusplus) = 1;
1303           CPP_OPTION (pfile, cplusplus_comments) = 1;
1304           break;
1305         case OPT_remap:
1306           CPP_OPTION (pfile, remap) = 1;
1307           break;
1308         case OPT_iprefix:
1309           CPP_OPTION (pfile, include_prefix) = arg;
1310           CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1311           break;
1312         case OPT_lang_c:
1313           CPP_OPTION (pfile, cplusplus) = 0;
1314           CPP_OPTION (pfile, cplusplus_comments) = 1;
1315           CPP_OPTION (pfile, c89) = 0;
1316           CPP_OPTION (pfile, c99) = 1;
1317           CPP_OPTION (pfile, digraphs) = 1;
1318           CPP_OPTION (pfile, objc) = 0;
1319           break;
1320         case OPT_lang_cplusplus:
1321           CPP_OPTION (pfile, cplusplus) = 1;
1322           CPP_OPTION (pfile, cplusplus_comments) = 1;
1323           CPP_OPTION (pfile, c89) = 0;
1324           CPP_OPTION (pfile, c99) = 0;
1325           CPP_OPTION (pfile, objc) = 0;
1326           CPP_OPTION (pfile, digraphs) = 1;
1327           new_pending_directive (pend, "__cplusplus", cpp_define);
1328           break;
1329         case OPT_lang_objcplusplus:
1330           CPP_OPTION (pfile, cplusplus) = 1;
1331           new_pending_directive (pend, "__cplusplus", cpp_define);
1332           /* fall through */
1333         case OPT_lang_objc:
1334           CPP_OPTION (pfile, cplusplus_comments) = 1;
1335           CPP_OPTION (pfile, c89) = 0;
1336           CPP_OPTION (pfile, c99) = 0;
1337           CPP_OPTION (pfile, objc) = 1;
1338           new_pending_directive (pend, "__OBJC__", cpp_define);
1339           break;
1340         case OPT_lang_asm:
1341           CPP_OPTION (pfile, lang_asm) = 1;
1342           CPP_OPTION (pfile, dollars_in_ident) = 0;
1343           new_pending_directive (pend, "__ASSEMBLER__", cpp_define);
1344           break;
1345         case OPT_nostdinc:
1346           /* -nostdinc causes no default include directories.
1347              You must specify all include-file directories with -I.  */
1348           CPP_OPTION (pfile, no_standard_includes) = 1;
1349           break;
1350         case OPT_nostdincplusplus:
1351           /* -nostdinc++ causes no default C++-specific include directories. */
1352           CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1353           break;
1354         case OPT_std_gnu89:
1355           CPP_OPTION (pfile, cplusplus) = 0;
1356           CPP_OPTION (pfile, cplusplus_comments) = 1;
1357           CPP_OPTION (pfile, c89) = 1;
1358           CPP_OPTION (pfile, c99) = 0;
1359           CPP_OPTION (pfile, objc) = 0;
1360           CPP_OPTION (pfile, digraphs) = 1;
1361           break;
1362         case OPT_std_gnu9x:
1363         case OPT_std_gnu99:
1364           CPP_OPTION (pfile, cplusplus) = 0;
1365           CPP_OPTION (pfile, cplusplus_comments) = 1;
1366           CPP_OPTION (pfile, c89) = 0;
1367           CPP_OPTION (pfile, c99) = 1;
1368           CPP_OPTION (pfile, digraphs) = 1;
1369           CPP_OPTION (pfile, objc) = 0;
1370           new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
1371           break;
1372         case OPT_std_iso9899_199409:
1373           new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define);
1374           /* Fall through */
1375         case OPT_std_iso9899_1990:
1376         case OPT_std_c89:
1377         case OPT_lang_c89:
1378           CPP_OPTION (pfile, cplusplus) = 0;
1379           CPP_OPTION (pfile, cplusplus_comments) = 0;
1380           CPP_OPTION (pfile, c89) = 1;
1381           CPP_OPTION (pfile, c99) = 0;
1382           CPP_OPTION (pfile, objc) = 0;
1383           CPP_OPTION (pfile, digraphs) = opt_code == OPT_std_iso9899_199409;
1384           CPP_OPTION (pfile, trigraphs) = 1;
1385           new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
1386           break;
1387         case OPT_std_iso9899_199x:
1388         case OPT_std_iso9899_1999:
1389         case OPT_std_c9x:
1390         case OPT_std_c99:
1391           CPP_OPTION (pfile, cplusplus) = 0;
1392           CPP_OPTION (pfile, cplusplus_comments) = 1;
1393           CPP_OPTION (pfile, c89) = 0;
1394           CPP_OPTION (pfile, c99) = 1;
1395           CPP_OPTION (pfile, objc) = 0;
1396           CPP_OPTION (pfile, digraphs) = 1;
1397           CPP_OPTION (pfile, trigraphs) = 1;
1398           new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
1399           new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
1400           break;
1401         case OPT_o:
1402           if (CPP_OPTION (pfile, out_fname) != NULL)
1403             {
1404               cpp_fatal (pfile, "Output filename specified twice");
1405               return argc;
1406             }
1407           CPP_OPTION (pfile, out_fname) = arg;
1408           if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
1409             CPP_OPTION (pfile, out_fname) = "";
1410           break;
1411         case OPT_v:
1412           fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1413 #ifdef TARGET_VERSION
1414           TARGET_VERSION;
1415 #endif
1416           fputc ('\n', stderr);
1417           CPP_OPTION (pfile, verbose) = 1;
1418           break;
1419         case OPT_stdin_stdout:
1420           /* JF handle '-' as file name meaning stdin or stdout */
1421           if (CPP_OPTION (pfile, in_fname) == NULL)
1422             CPP_OPTION (pfile, in_fname) = "";
1423           else if (CPP_OPTION (pfile, out_fname) == NULL)
1424             CPP_OPTION (pfile, out_fname) = "";
1425           break;
1426         case OPT_d:
1427           /* Args to -d specify what parts of macros to dump.
1428              Silently ignore unrecognised options; they may
1429              be aimed at the compiler proper. */
1430           {
1431             char c;
1432
1433             while ((c = *arg++) != '\0')
1434               switch (c)
1435                 {
1436                 case 'M':
1437                   CPP_OPTION (pfile, dump_macros) = dump_only;
1438                   CPP_OPTION (pfile, no_output) = 1;
1439                   break;
1440                 case 'N':
1441                   CPP_OPTION (pfile, dump_macros) = dump_names;
1442                   break;
1443                 case 'D':
1444                   CPP_OPTION (pfile, dump_macros) = dump_definitions;
1445                   break;
1446                 case 'I':
1447                   CPP_OPTION (pfile, dump_includes) = 1;
1448                   break;
1449                 }
1450           }
1451           break;
1452           /* The style of the choices here is a bit mixed.
1453              The chosen scheme is a hybrid of keeping all options in one string
1454              and specifying each option in a separate argument:
1455              -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
1456              -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1457              -M[M][G][D file].  This is awkward to handle in specs, and is not
1458              as extensible.  */
1459           /* ??? -MG must be specified in addition to one of -M or -MM.
1460              This can be relaxed in the future without breaking anything.
1461              The converse isn't true.  */
1462
1463           /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
1464         case OPT_MG:
1465           CPP_OPTION (pfile, print_deps_missing_files) = 1;
1466           break;
1467         case OPT_M:
1468         case OPT_MD:
1469         case OPT_MM:
1470         case OPT_MMD:
1471           if (opt_code == OPT_M || opt_code == OPT_MD)
1472             CPP_OPTION (pfile, print_deps) = 2;
1473           else
1474             CPP_OPTION (pfile, print_deps) = 1;
1475
1476           /* For -MD and -MMD options, write deps on file named by next arg */
1477           /* For -M and -MM, write deps on standard output
1478              and suppress the usual output.  */
1479           if (opt_code == OPT_MD || opt_code == OPT_MMD)
1480               CPP_OPTION (pfile, deps_file) = arg;
1481           else
1482               CPP_OPTION (pfile, no_output) = 1;
1483           break;
1484         case OPT_A:
1485           if (arg[0] == '-')
1486             {
1487               /* -A with an argument beginning with '-' acts as
1488                  #unassert on whatever immediately follows the '-'.
1489                  If "-" is the whole argument, we eliminate all
1490                  predefined macros and assertions, including those
1491                  that were specified earlier on the command line.
1492                  That way we can get rid of any that were passed
1493                  automatically in from GCC.  */
1494
1495               if (arg[1] == '\0')
1496                 {
1497                   struct pending_option *o1, *o2;
1498
1499                   o1 = pend->directive_head;
1500                   while (o1)
1501                     {
1502                       o2 = o1->next;
1503                       free (o1);
1504                       o1 = o2;
1505                     }
1506                   pend->directive_head = NULL;
1507                   pend->directive_tail = NULL;
1508                 }
1509               else
1510                 new_pending_directive (pend, arg + 1, cpp_unassert);
1511             }
1512           else
1513             new_pending_directive (pend, arg, cpp_assert);
1514           break;
1515         case OPT_U:
1516           new_pending_directive (pend, arg, cpp_undef);
1517           break;
1518         case OPT_I:           /* Add directory to path for includes.  */
1519           if (!strcmp (arg, "-"))
1520             {
1521               /* -I- means:
1522                  Use the preceding -I directories for #include "..."
1523                  but not #include <...>.
1524                  Don't search the directory of the present file
1525                  for #include "...".  (Note that -I. -I- is not the same as
1526                  the default setup; -I. uses the compiler's working dir.)  */
1527               if (! CPP_OPTION (pfile, ignore_srcdir))
1528                 {
1529                   pend->quote_head = pend->brack_head;
1530                   pend->quote_tail = pend->brack_tail;
1531                   pend->brack_head = 0;
1532                   pend->brack_tail = 0;
1533                   CPP_OPTION (pfile, ignore_srcdir) = 1;
1534                 }
1535               else
1536                 {
1537                   cpp_fatal (pfile, "-I- specified twice");
1538                   return argc;
1539                 }
1540             }
1541           else
1542             append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1543           break;
1544         case OPT_isystem:
1545           /* Add directory to beginning of system include path, as a system
1546              include directory. */
1547           append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1548           break;
1549         case OPT_include:
1550           {
1551             struct pending_option *o = (struct pending_option *)
1552               xmalloc (sizeof (struct pending_option));
1553             o->arg = arg;
1554
1555             /* This list has to be built in reverse order so that
1556                when cpp_start_read pushes all the -include files onto
1557                the buffer stack, they will be scanned in forward order.  */
1558             o->next = pend->include_head;
1559             pend->include_head = o;
1560           }
1561           break;
1562         case OPT_imacros:
1563           {
1564             struct pending_option *o = (struct pending_option *)
1565               xmalloc (sizeof (struct pending_option));
1566             o->arg = arg;
1567             o->next = NULL;
1568
1569             APPEND (pend, imacros, o);
1570           }
1571           break;
1572         case OPT_iwithprefix:
1573           /* Add directory to end of path for includes,
1574              with the default prefix at the front of its name.  */
1575           /* fall through */
1576         case OPT_iwithprefixbefore:
1577           /* Add directory to main path for includes,
1578              with the default prefix at the front of its name.  */
1579           {
1580             char *fname;
1581             int len;
1582
1583             len = strlen (arg);
1584
1585             if (CPP_OPTION (pfile, include_prefix) != 0)
1586               {
1587                 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1588                 fname = xmalloc (ipl + len + 1);
1589                 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1590                 memcpy (fname + ipl, arg, len + 1);
1591               }
1592             else if (cpp_GCC_INCLUDE_DIR_len)
1593               {
1594                 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1595                 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1596                 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1597               }
1598             else
1599               fname = xstrdup (arg);
1600
1601             append_include_chain (pfile, fname,
1602                           opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1603           }
1604           break;
1605         case OPT_idirafter:
1606           /* Add directory to end of path for includes.  */
1607           append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1608           break;
1609         case OPT_W:
1610           /* Silently ignore unrecognised options */
1611           if (!strcmp (argv[i], "-Wall"))
1612             {
1613               CPP_OPTION (pfile, warn_trigraphs) = 1;
1614               CPP_OPTION (pfile, warn_comments) = 1;
1615             }
1616           else if (!strcmp (argv[i], "-Wtraditional"))
1617             CPP_OPTION (pfile, warn_traditional) = 1;
1618           else if (!strcmp (argv[i], "-Wtrigraphs"))
1619             CPP_OPTION (pfile, warn_trigraphs) = 1;
1620           else if (!strcmp (argv[i], "-Wcomment"))
1621             CPP_OPTION (pfile, warn_comments) = 1;
1622           else if (!strcmp (argv[i], "-Wcomments"))
1623             CPP_OPTION (pfile, warn_comments) = 1;
1624           else if (!strcmp (argv[i], "-Wundef"))
1625             CPP_OPTION (pfile, warn_undef) = 1;
1626           else if (!strcmp (argv[i], "-Wimport"))
1627             CPP_OPTION (pfile, warn_import) = 1;
1628           else if (!strcmp (argv[i], "-Wpaste"))
1629             CPP_OPTION (pfile, warn_paste) = 1;
1630           else if (!strcmp (argv[i], "-Werror"))
1631             CPP_OPTION (pfile, warnings_are_errors) = 1;
1632           else if (!strcmp (argv[i], "-Wsystem-headers"))
1633             CPP_OPTION (pfile, warn_system_headers) = 1;
1634           else if (!strcmp (argv[i], "-Wno-traditional"))
1635             CPP_OPTION (pfile, warn_traditional) = 0;
1636           else if (!strcmp (argv[i], "-Wno-trigraphs"))
1637             CPP_OPTION (pfile, warn_trigraphs) = 0;
1638           else if (!strcmp (argv[i], "-Wno-comment"))
1639             CPP_OPTION (pfile, warn_comments) = 0;
1640           else if (!strcmp (argv[i], "-Wno-comments"))
1641             CPP_OPTION (pfile, warn_comments) = 0;
1642           else if (!strcmp (argv[i], "-Wno-undef"))
1643             CPP_OPTION (pfile, warn_undef) = 0;
1644           else if (!strcmp (argv[i], "-Wno-import"))
1645             CPP_OPTION (pfile, warn_import) = 0;
1646           else if (!strcmp (argv[i], "-Wno-paste"))
1647             CPP_OPTION (pfile, warn_paste) = 0;
1648           else if (!strcmp (argv[i], "-Wno-error"))
1649             CPP_OPTION (pfile, warnings_are_errors) = 0;
1650           else if (!strcmp (argv[i], "-Wno-system-headers"))
1651             CPP_OPTION (pfile, warn_system_headers) = 0;
1652           break;
1653         }
1654     }
1655   return i + 1;
1656 }
1657
1658 #ifdef HOST_EBCDIC
1659 static int
1660 opt_comp (const void *p1, const void *p2)
1661 {
1662   return strcmp (((struct cl_option *)p1)->opt_text,
1663                  ((struct cl_option *)p2)->opt_text);
1664 }
1665 #endif
1666
1667 /* Handle command-line options in (argc, argv).
1668    Can be called multiple times, to handle multiple sets of options.
1669    Returns if an unrecognized option is seen.
1670    Returns number of strings consumed.  */
1671 int
1672 cpp_handle_options (pfile, argc, argv)
1673      cpp_reader *pfile;
1674      int argc;
1675      char **argv;
1676 {
1677   int i;
1678   int strings_processed;
1679
1680   for (i = 0; i < argc; i += strings_processed)
1681     {
1682       strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1683       if (strings_processed == 0)
1684         break;
1685     }
1686   return i;
1687 }
1688
1689 static void
1690 print_help ()
1691 {
1692   fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1693   /* To keep the lines from getting too long for some compilers, limit
1694      to about 500 characters (6 lines) per chunk. */
1695   fputs (_("\
1696 Switches:\n\
1697   -include <file>           Include the contents of <file> before other files\n\
1698   -imacros <file>           Accept definition of macros in <file>\n\
1699   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1700   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1701   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1702   -isystem <dir>            Add <dir> to the start of the system include path\n\
1703 "), stdout);
1704   fputs (_("\
1705   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1706   -I <dir>                  Add <dir> to the end of the main include path\n\
1707   -I-                       Fine-grained include path control; see info docs\n\
1708   -nostdinc                 Do not search system include directories\n\
1709                              (dirs specified with -isystem will still be used)\n\
1710   -nostdinc++               Do not search system include directories for C++\n\
1711   -o <file>                 Put output into <file>\n\
1712 "), stdout);
1713   fputs (_("\
1714   -pedantic                 Issue all warnings demanded by strict ISO C\n\
1715   -pedantic-errors          Issue -pedantic warnings as errors instead\n\
1716   -trigraphs                Support ISO C trigraphs\n\
1717   -lang-c                   Assume that the input sources are in C\n\
1718   -lang-c89                 Assume that the input sources are in C89\n\
1719 "), stdout);
1720   fputs (_("\
1721   -lang-c++                 Assume that the input sources are in C++\n\
1722   -lang-objc                Assume that the input sources are in ObjectiveC\n\
1723   -lang-objc++              Assume that the input sources are in ObjectiveC++\n\
1724   -lang-asm                 Assume that the input sources are in assembler\n\
1725 "), stdout);
1726   fputs (_("\
1727   -std=<std name>           Specify the conformance standard; one of:\n\
1728                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1729                             iso9899:199409, iso9899:1999\n\
1730   -+                        Allow parsing of C++ style features\n\
1731   -w                        Inhibit warning messages\n\
1732   -Wtrigraphs               Warn if trigraphs are encountered\n\
1733   -Wno-trigraphs            Do not warn about trigraphs\n\
1734   -Wcomment{s}              Warn if one comment starts inside another\n\
1735 "), stdout);
1736   fputs (_("\
1737   -Wno-comment{s}           Do not warn about comments\n\
1738   -Wtraditional             Warn about features not present in traditional C\n\
1739   -Wno-traditional          Do not warn about traditional C\n\
1740   -Wundef                   Warn if an undefined macro is used by #if\n\
1741   -Wno-undef                Do not warn about testing undefined macros\n\
1742   -Wimport                  Warn about the use of the #import directive\n\
1743 "), stdout);
1744   fputs (_("\
1745   -Wno-import               Do not warn about the use of #import\n\
1746   -Werror                   Treat all warnings as errors\n\
1747   -Wno-error                Do not treat warnings as errors\n\
1748   -Wsystem-headers          Do not suppress warnings from system headers\n\
1749   -Wno-system-headers       Suppress warnings from system headers\n\
1750   -Wall                     Enable all preprocessor warnings\n\
1751 "), stdout);
1752   fputs (_("\
1753   -M                        Generate make dependencies\n\
1754   -MM                       As -M, but ignore system header files\n\
1755   -MD                       As -M, but put output in a .d file\n\
1756   -MMD                      As -MD, but ignore system header files\n\
1757   -MG                       Treat missing header file as generated files\n\
1758   -g3                       Include #define and #undef directives in the output\n\
1759 "), stdout);
1760   fputs (_("\
1761   -D<macro>                 Define a <macro> with string '1' as its value\n\
1762   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1763   -A<question> (<answer>)   Assert the <answer> to <question>\n\
1764   -A-<question> (<answer>)  Disable the <answer> to <question>\n\
1765   -U<macro>                 Undefine <macro> \n\
1766   -v                        Display the version number\n\
1767 "), stdout);
1768   fputs (_("\
1769   -H                        Print the name of header files as they are used\n\
1770   -C                        Do not discard comments\n\
1771   -dM                       Display a list of macro definitions active at end\n\
1772   -dD                       Preserve macro definitions in output\n\
1773   -dN                       As -dD except that only the names are preserved\n\
1774   -dI                       Include #include directives in the output\n\
1775 "), stdout);
1776   fputs (_("\
1777   -ftabstop=<number>        Distance between tab stops for column reporting\n\
1778   -P                        Do not generate #line directives\n\
1779   -$                        Do not allow '$' in identifiers\n\
1780   -remap                    Remap file names when including files.\n\
1781   --version                 Display version information\n\
1782   -h or --help              Display this information\n\
1783 "), stdout);
1784 }