gcc/cppinit.c

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