gcc/cppinit.c

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