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       /* Don't handle if -fpreprocessed.  Later: maybe update this to
 853          use the #include "" search path if cpp_read_file fails.  */
 854       if (CPP_OPTION (pfile, preprocessed))
 855         cpp_error (pfile, "-include and -imacros cannot be used with -fpreprocessed");
 856       else if (_cpp_read_file (pfile, p->arg) && scan)
 857         cpp_scan_buffer_nooutput (pfile, 0);
 858       q = p->next;
 859       free (p);
 860       p = q;
 861     }
 862 }
 863
 864 /* This is called after options have been processed.  Setup for
 865    processing input from the file named FNAME.  (Use standard input if
 866    FNAME == NULL.)  Return 1 on success, 0 on failure.  */
 867
 868 int
 869 cpp_start_read (pfile, fname)
 870      cpp_reader *pfile;
 871      const char *fname;
 872 {
 873   struct pending_option *p, *q;
 874
 875   /* Set up the include search path now.  */
 876   if (! CPP_OPTION (pfile, no_standard_includes))
 877     init_standard_includes (pfile);
 878
 879   merge_include_chains (pfile);
 880
 881   /* With -v, print the list of dirs to search.  */
 882   if (CPP_OPTION (pfile, verbose))
 883     {
 884       struct file_name_list *l;
 885       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 886       for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
 887         {
 888           if (l == CPP_OPTION (pfile, bracket_include))
 889             fprintf (stderr, _("#include <...> search starts here:\n"));
 890           fprintf (stderr, " %s\n", l->name);
 891         }
 892       fprintf (stderr, _("End of search list.\n"));
 893     }
 894
 895   if (CPP_OPTION (pfile, in_fname) == NULL
 896       || *CPP_OPTION (pfile, in_fname) == 0)
 897     {
 898       CPP_OPTION (pfile, in_fname) = fname;
 899       if (CPP_OPTION (pfile, in_fname) == NULL)
 900         CPP_OPTION (pfile, in_fname) = "";
 901     }
 902   if (CPP_OPTION (pfile, out_fname) == NULL)
 903     CPP_OPTION (pfile, out_fname) = "";
 904
 905   if (CPP_OPTION (pfile, print_deps))
 906     {
 907       /* Set the default target (if there is none already), and
 908          the dependency on the main file.  */
 909       deps_add_default_target (pfile->deps, CPP_OPTION (pfile, in_fname));
 910
 911       deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
 912     }
 913
 914   /* Open the main input file.  This must be done early, so we have a
 915      buffer to stand on.  */
 916   if (!_cpp_read_file (pfile, fname))
 917     return 0;
 918
 919   /* If already preprocessed, don't install __LINE__, etc., and ignore
 920      command line definitions and assertions.  Handle -U's, -D's and
 921      -A's in the order they were seen.  */
 922   if (! CPP_OPTION (pfile, preprocessed))
 923     init_builtins (pfile);
 924
 925   p = CPP_OPTION (pfile, pending)->directive_head;
 926   while (p)
 927     {
 928       if (! CPP_OPTION (pfile, preprocessed))
 929         (*p->handler) (pfile, p->arg);
 930       q = p->next;
 931       free (p);
 932       p = q;
 933     }
 934
 935   pfile->done_initializing = 1;
 936
 937   /* The -imacros files can be scanned now, but the -include files
 938      have to be pushed onto the buffer stack and processed later,
 939      otherwise cppmain.c won't see the tokens.  include_head was built
 940      up as a stack, and popping this stack onto the buffer stack means
 941      we preserve the order of the command line.  */
 942   do_includes (pfile, CPP_OPTION (pfile, pending)->imacros_head, 1);
 943   do_includes (pfile, CPP_OPTION (pfile, pending)->include_head, 0);
 944
 945   free (CPP_OPTION (pfile, pending));
 946   CPP_OPTION (pfile, pending) = NULL;
 947
 948   return 1;
 949 }
 950
 951 /* Use mkdeps.c to output dependency information.  */
 952 static void
 953 output_deps (pfile)
 954      cpp_reader *pfile;
 955 {
 956   /* Stream on which to print the dependency information.  */
 957   FILE *deps_stream = 0;
 958   const char *deps_mode = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
 959
 960   if (CPP_OPTION (pfile, deps_file) == 0)
 961     deps_stream = stdout;
 962   else
 963     {
 964       deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
 965       if (deps_stream == 0)
 966         {
 967           cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
 968           return;
 969         }
 970     }
 971
 972   deps_write (pfile->deps, deps_stream, 72);
 973
 974   if (CPP_OPTION (pfile, deps_phony_targets))
 975     deps_phony_targets (pfile->deps, deps_stream);
 976
 977   /* Don't close stdout.  */
 978   if (CPP_OPTION (pfile, deps_file))
 979     {
 980       if (ferror (deps_stream) || fclose (deps_stream) != 0)
 981         cpp_fatal (pfile, "I/O error on output");
 982     }
 983 }
 984
 985 /* This is called at the end of preprocessing.  It pops the
 986    last buffer and writes dependency output.  It should also
 987    clear macro definitions, such that you could call cpp_start_read
 988    with a new filename to restart processing.  */
 989 void
 990 cpp_finish (pfile)
 991      cpp_reader *pfile;
 992 {
 993   if (CPP_BUFFER (pfile))
 994     {
 995       cpp_ice (pfile, "buffers still stacked in cpp_finish");
 996       while (CPP_BUFFER (pfile))
 997         cpp_pop_buffer (pfile);
 998     }
 999
1000   /* Don't write the deps file if preprocessing has failed.  */
1001   if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
1002     output_deps (pfile);
1003
1004   /* Report on headers that could use multiple include guards.  */
1005   if (CPP_OPTION (pfile, print_include_names))
1006     _cpp_report_missing_guards (pfile);
1007 }
1008
1009 static void
1010 new_pending_directive (pend, text, handler)
1011      struct cpp_pending *pend;
1012      const char *text;
1013      cl_directive_handler handler;
1014 {
1015   struct pending_option *o = (struct pending_option *)
1016     xmalloc (sizeof (struct pending_option));
1017
1018   o->arg = text;
1019   o->next = NULL;
1020   o->handler = handler;
1021   APPEND (pend, directive, o);
1022 }
1023
1024 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1025    I.e. a const string initializer with parens around it.  That is
1026    what N_("string") resolves to, so we make no_* be macros instead.  */
1027 #define no_arg N_("Argument missing after %s")
1028 #define no_ass N_("Assertion missing after %s")
1029 #define no_dir N_("Directory name missing after %s")
1030 #define no_fil N_("File name missing after %s")
1031 #define no_mac N_("Macro name missing after %s")
1032 #define no_pth N_("Path name missing after %s")
1033 #define no_num N_("Number missing after %s")
1034 #define no_tgt N_("Target missing after %s")
1035
1036 /* This is the list of all command line options, with the leading
1037    "-" removed.  It must be sorted in ASCII collating order.  */
1038 #define COMMAND_LINE_OPTIONS                                                  \
1039   DEF_OPT("",                         0,      OPT_stdin_stdout)               \
1040   DEF_OPT("$",                        0,      OPT_dollar)                     \
1041   DEF_OPT("+",                        0,      OPT_plus)                       \
1042   DEF_OPT("-help",                    0,      OPT__help)                      \
1043   DEF_OPT("-target-help",             0,      OPT_target__help)               \
1044   DEF_OPT("-version",                 0,      OPT__version)                   \
1045   DEF_OPT("A",                        no_ass, OPT_A)                          \
1046   DEF_OPT("C",                        0,      OPT_C)                          \
1047   DEF_OPT("D",                        no_mac, OPT_D)                          \
1048   DEF_OPT("H",                        0,      OPT_H)                          \
1049   DEF_OPT("I",                        no_dir, OPT_I)                          \
1050   DEF_OPT("M",                        0,      OPT_M)                          \
1051   DEF_OPT("MD",                       no_fil, OPT_MD)                         \
1052   DEF_OPT("MF",                       no_fil, OPT_MF)                         \
1053   DEF_OPT("MG",                       0,      OPT_MG)                         \
1054   DEF_OPT("MM",                       0,      OPT_MM)                         \
1055   DEF_OPT("MMD",                      no_fil, OPT_MMD)                        \
1056   DEF_OPT("MP",                       0,      OPT_MP)                         \
1057   DEF_OPT("MQ",                       no_tgt, OPT_MQ)                         \
1058   DEF_OPT("MT",                       no_tgt, OPT_MT)                         \
1059   DEF_OPT("P",                        0,      OPT_P)                          \
1060   DEF_OPT("U",                        no_mac, OPT_U)                          \
1061   DEF_OPT("W",                        no_arg, OPT_W)  /* arg optional */      \
1062   DEF_OPT("d",                        no_arg, OPT_d)                          \
1063   DEF_OPT("fleading-underscore",      0,      OPT_fleading_underscore)        \
1064   DEF_OPT("fno-leading-underscore",   0,      OPT_fno_leading_underscore)     \
1065   DEF_OPT("fno-operator-names",       0,      OPT_fno_operator_names)         \
1066   DEF_OPT("fno-preprocessed",         0,      OPT_fno_preprocessed)           \
1067   DEF_OPT("fno-show-column",          0,      OPT_fno_show_column)            \
1068   DEF_OPT("fpreprocessed",            0,      OPT_fpreprocessed)              \
1069   DEF_OPT("fshow-column",             0,      OPT_fshow_column)               \
1070   DEF_OPT("ftabstop=",                no_num, OPT_ftabstop)                   \
1071   DEF_OPT("h",                        0,      OPT_h)                          \
1072   DEF_OPT("idirafter",                no_dir, OPT_idirafter)                  \
1073   DEF_OPT("imacros",                  no_fil, OPT_imacros)                    \
1074   DEF_OPT("include",                  no_fil, OPT_include)                    \
1075   DEF_OPT("iprefix",                  no_pth, OPT_iprefix)                    \
1076   DEF_OPT("isystem",                  no_dir, OPT_isystem)                    \
1077   DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix)                \
1078   DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore)          \
1079   DEF_OPT("lang-asm",                 0,      OPT_lang_asm)                   \
1080   DEF_OPT("lang-c",                   0,      OPT_lang_c)                     \
1081   DEF_OPT("lang-c++",                 0,      OPT_lang_cplusplus)             \
1082   DEF_OPT("lang-c89",                 0,      OPT_lang_c89)                   \
1083   DEF_OPT("lang-objc",                0,      OPT_lang_objc)                  \
1084   DEF_OPT("lang-objc++",              0,      OPT_lang_objcplusplus)          \
1085   DEF_OPT("nostdinc",                 0,      OPT_nostdinc)                   \
1086   DEF_OPT("nostdinc++",               0,      OPT_nostdincplusplus)           \
1087   DEF_OPT("o",                        no_fil, OPT_o)                          \
1088   DEF_OPT("pedantic",                 0,      OPT_pedantic)                   \
1089   DEF_OPT("pedantic-errors",          0,      OPT_pedantic_errors)            \
1090   DEF_OPT("remap",                    0,      OPT_remap)                      \
1091   DEF_OPT("std=c++98",                0,      OPT_std_cplusplus98)            \
1092   DEF_OPT("std=c89",                  0,      OPT_std_c89)                    \
1093   DEF_OPT("std=c99",                  0,      OPT_std_c99)                    \
1094   DEF_OPT("std=c9x",                  0,      OPT_std_c9x)                    \
1095   DEF_OPT("std=gnu89",                0,      OPT_std_gnu89)                  \
1096   DEF_OPT("std=gnu99",                0,      OPT_std_gnu99)                  \
1097   DEF_OPT("std=gnu9x",                0,      OPT_std_gnu9x)                  \
1098   DEF_OPT("std=iso9899:1990",         0,      OPT_std_iso9899_1990)           \
1099   DEF_OPT("std=iso9899:199409",       0,      OPT_std_iso9899_199409)         \
1100   DEF_OPT("std=iso9899:1999",         0,      OPT_std_iso9899_1999)           \
1101   DEF_OPT("std=iso9899:199x",         0,      OPT_std_iso9899_199x)           \
1102   DEF_OPT("trigraphs",                0,      OPT_trigraphs)                  \
1103   DEF_OPT("v",                        0,      OPT_v)                          \
1104   DEF_OPT("version",                  0,      OPT_version)                    \
1105   DEF_OPT("w",                        0,      OPT_w)
1106
1107 #define DEF_OPT(text, msg, code) code,
1108 enum opt_code
1109 {
1110   COMMAND_LINE_OPTIONS
1111   N_OPTS
1112 };
1113 #undef DEF_OPT
1114
1115 struct cl_option
1116 {
1117   const char *opt_text;
1118   const char *msg;
1119   size_t opt_len;
1120   enum opt_code opt_code;
1121 };
1122
1123 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1124 #ifdef HOST_EBCDIC
1125 static struct cl_option cl_options[] =
1126 #else
1127 static const struct cl_option cl_options[] =
1128 #endif
1129 {
1130   COMMAND_LINE_OPTIONS
1131 };
1132 #undef DEF_OPT
1133 #undef COMMAND_LINE_OPTIONS
1134
1135 /* Perform a binary search to find which, if any, option the given
1136    command-line matches.  Returns its index in the option array,
1137    negative on failure.  Complications arise since some options can be
1138    suffixed with an argument, and multiple complete matches can occur,
1139    e.g. -iwithprefix and -iwithprefixbefore.  Moreover, we need to
1140    accept options beginning with -W that we do not recognise, but not
1141    to swallow any subsequent command line argument; this is handled as
1142    special cases in cpp_handle_option.  */
1143 static int
1144 parse_option (input)
1145      const char *input;
1146 {
1147   unsigned int md, mn, mx;
1148   size_t opt_len;
1149   int comp;
1150
1151   mn = 0;
1152   mx = N_OPTS;
1153
1154   while (mx > mn)
1155     {
1156       md = (mn + mx) / 2;
1157
1158       opt_len = cl_options[md].opt_len;
1159       comp = memcmp (input, cl_options[md].opt_text, opt_len);
1160
1161       if (comp > 0)
1162         mn = md + 1;
1163       else if (comp < 0)
1164         mx = md;
1165       else
1166         {
1167           if (input[opt_len] == '\0')
1168             return md;
1169           /* We were passed more text.  If the option takes an argument,
1170              we may match a later option or we may have been passed the
1171              argument.  The longest possible option match succeeds.
1172              If the option takes no arguments we have not matched and
1173              continue the search (e.g. input="stdc++" match was "stdc").  */
1174           mn = md + 1;
1175           if (cl_options[md].msg)
1176             {
1177               /* Scan forwards.  If we get an exact match, return it.
1178                  Otherwise, return the longest option-accepting match.
1179                  This loops no more than twice with current options.  */
1180               mx = md;
1181               for (; mn < N_OPTS; mn++)
1182                 {
1183                   opt_len = cl_options[mn].opt_len;
1184                   if (memcmp (input, cl_options[mn].opt_text, opt_len))
1185                     break;
1186                   if (input[opt_len] == '\0')
1187                     return mn;
1188                   if (cl_options[mn].msg)
1189                     mx = mn;
1190                 }
1191               return mx;
1192             }
1193         }
1194     }
1195
1196   return -1;
1197 }
1198
1199 /* Handle one command-line option in (argc, argv).
1200    Can be called multiple times, to handle multiple sets of options.
1201    Returns number of strings consumed.  */
1202
1203 int
1204 cpp_handle_option (pfile, argc, argv)
1205      cpp_reader *pfile;
1206      int argc;
1207      char **argv;
1208 {
1209   int i = 0;
1210   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1211
1212   if (argv[i][0] != '-')
1213     {
1214       if (CPP_OPTION (pfile, out_fname) != NULL)
1215         cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
1216                    progname);
1217       else if (CPP_OPTION (pfile, in_fname) != NULL)
1218         CPP_OPTION (pfile, out_fname) = argv[i];
1219       else
1220         CPP_OPTION (pfile, in_fname) = argv[i];
1221     }
1222   else
1223     {
1224       enum opt_code opt_code;
1225       int opt_index;
1226       const char *arg = 0;
1227
1228       /* Skip over '-'.  */
1229       opt_index = parse_option (&argv[i][1]);
1230       if (opt_index < 0)
1231         return i;
1232
1233       opt_code = cl_options[opt_index].opt_code;
1234       if (cl_options[opt_index].msg)
1235         {
1236           arg = &argv[i][cl_options[opt_index].opt_len + 1];
1237
1238           /* Yuk. Special case for -W as it must not swallow
1239              up any following argument.  If this becomes common, add
1240              another field to the cl_options table.  */
1241           if (arg[0] == '\0' && opt_code != OPT_W)
1242             {
1243               arg = argv[++i];
1244               if (!arg)
1245                 {
1246                   cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1247                   return argc;
1248                 }
1249             }
1250         }
1251
1252       switch (opt_code)
1253         {
1254         case N_OPTS: /* Shut GCC up.  */
1255           break;
1256         case OPT_fleading_underscore:
1257           CPP_OPTION (pfile, user_label_prefix) = "_";
1258           break;
1259         case OPT_fno_leading_underscore:
1260           CPP_OPTION (pfile, user_label_prefix) = "";
1261           break;
1262         case OPT_fno_operator_names:
1263           CPP_OPTION (pfile, operator_names) = 0;
1264           break;
1265         case OPT_fpreprocessed:
1266           CPP_OPTION (pfile, preprocessed) = 1;
1267           break;
1268         case OPT_fno_preprocessed:
1269           CPP_OPTION (pfile, preprocessed) = 0;
1270           break;
1271         case OPT_fshow_column:
1272           CPP_OPTION (pfile, show_column) = 1;
1273           break;
1274         case OPT_fno_show_column:
1275           CPP_OPTION (pfile, show_column) = 0;
1276           break;
1277         case OPT_ftabstop:
1278           /* Silently ignore empty string, non-longs and silly values.  */
1279           if (arg[0] != '\0')
1280             {
1281               char *endptr;
1282               long tabstop = strtol (arg, &endptr, 10);
1283               if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1284                 CPP_OPTION (pfile, tabstop) = tabstop;
1285             }
1286           break;
1287         case OPT_w:
1288           CPP_OPTION (pfile, inhibit_warnings) = 1;
1289           break;
1290         case OPT_h:
1291         case OPT__help:
1292           print_help ();
1293           CPP_OPTION (pfile, help_only) = 1;
1294           break;
1295         case OPT_target__help:
1296           /* Print if any target specific options. cpplib has none, but
1297              make sure help_only gets set.  */
1298           CPP_OPTION (pfile, help_only) = 1;
1299           break;
1300
1301           /* --version inhibits compilation, -version doesn't. -v means
1302              verbose and -version.  Historical reasons, don't ask.  */
1303         case OPT__version:
1304           CPP_OPTION (pfile, help_only) = 1;
1305           goto version;
1306         case OPT_v:
1307           CPP_OPTION (pfile, verbose) = 1;
1308           goto version;
1309
1310         case OPT_version:
1311         version:
1312           fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1313 #ifdef TARGET_VERSION
1314           TARGET_VERSION;
1315 #endif
1316           fputc ('\n', stderr);
1317           break;
1318
1319         case OPT_C:
1320           CPP_OPTION (pfile, discard_comments) = 0;
1321           break;
1322         case OPT_P:
1323           CPP_OPTION (pfile, no_line_commands) = 1;
1324           break;
1325         case OPT_dollar:        /* Don't include $ in identifiers.  */
1326           CPP_OPTION (pfile, dollars_in_ident) = 0;
1327           break;
1328         case OPT_H:
1329           CPP_OPTION (pfile, print_include_names) = 1;
1330           break;
1331         case OPT_D:
1332           new_pending_directive (pend, arg, cpp_define);
1333           break;
1334         case OPT_pedantic_errors:
1335           CPP_OPTION (pfile, pedantic_errors) = 1;
1336           /* fall through */
1337         case OPT_pedantic:
1338           CPP_OPTION (pfile, pedantic) = 1;
1339           break;
1340         case OPT_trigraphs:
1341           CPP_OPTION (pfile, trigraphs) = 1;
1342           break;
1343         case OPT_plus:
1344           CPP_OPTION (pfile, cplusplus) = 1;
1345           CPP_OPTION (pfile, cplusplus_comments) = 1;
1346           break;
1347         case OPT_remap:
1348           CPP_OPTION (pfile, remap) = 1;
1349           break;
1350         case OPT_iprefix:
1351           CPP_OPTION (pfile, include_prefix) = arg;
1352           CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1353           break;
1354         case OPT_lang_c:
1355           set_lang (pfile, CLK_GNUC89);
1356           break;
1357         case OPT_lang_cplusplus:
1358           set_lang (pfile, CLK_GNUCXX);
1359           break;
1360         case OPT_lang_objc:
1361           set_lang (pfile, CLK_OBJC);
1362           break;
1363         case OPT_lang_objcplusplus:
1364           set_lang (pfile, CLK_OBJCXX);
1365           break;
1366         case OPT_lang_asm:
1367           set_lang (pfile, CLK_ASM);
1368           break;
1369         case OPT_std_cplusplus98:
1370           set_lang (pfile, CLK_CXX98);
1371           break;
1372         case OPT_std_gnu89:
1373           set_lang (pfile, CLK_GNUC89);
1374           break;
1375         case OPT_std_gnu9x:
1376         case OPT_std_gnu99:
1377           set_lang (pfile, CLK_GNUC99);
1378           break;
1379         case OPT_std_iso9899_199409:
1380           set_lang (pfile, CLK_STDC94);
1381           break;
1382         case OPT_std_iso9899_1990:
1383         case OPT_std_c89:
1384         case OPT_lang_c89:
1385           set_lang (pfile, CLK_STDC89);
1386           break;
1387         case OPT_std_iso9899_199x:
1388         case OPT_std_iso9899_1999:
1389         case OPT_std_c9x:
1390         case OPT_std_c99:
1391           set_lang (pfile, CLK_STDC99);
1392           break;
1393         case OPT_nostdinc:
1394           /* -nostdinc causes no default include directories.
1395              You must specify all include-file directories with -I.  */
1396           CPP_OPTION (pfile, no_standard_includes) = 1;
1397           break;
1398         case OPT_nostdincplusplus:
1399           /* -nostdinc++ causes no default C++-specific include directories. */
1400           CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1401           break;
1402         case OPT_o:
1403           if (CPP_OPTION (pfile, out_fname) != NULL)
1404             {
1405               cpp_fatal (pfile, "Output filename specified twice");
1406               return argc;
1407             }
1408           CPP_OPTION (pfile, out_fname) = arg;
1409           if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
1410             CPP_OPTION (pfile, out_fname) = "";
1411           break;
1412         case OPT_stdin_stdout:
1413           /* JF handle '-' as file name meaning stdin or stdout.  */
1414           if (CPP_OPTION (pfile, in_fname) == NULL)
1415             CPP_OPTION (pfile, in_fname) = "";
1416           else if (CPP_OPTION (pfile, out_fname) == NULL)
1417             CPP_OPTION (pfile, out_fname) = "";
1418           break;
1419         case OPT_d:
1420           /* Args to -d specify what parts of macros to dump.
1421              Silently ignore unrecognised options; they may
1422              be aimed at the compiler proper.  */
1423           {
1424             char c;
1425
1426             while ((c = *arg++) != '\0')
1427               switch (c)
1428                 {
1429                 case 'M':
1430                   CPP_OPTION (pfile, dump_macros) = dump_only;
1431                   CPP_OPTION (pfile, no_output) = 1;
1432                   break;
1433                 case 'N':
1434                   CPP_OPTION (pfile, dump_macros) = dump_names;
1435                   break;
1436                 case 'D':
1437                   CPP_OPTION (pfile, dump_macros) = dump_definitions;
1438                   break;
1439                 case 'I':
1440                   CPP_OPTION (pfile, dump_includes) = 1;
1441                   break;
1442                 }
1443           }
1444           break;
1445
1446         case OPT_MG:
1447           CPP_OPTION (pfile, print_deps_missing_files) = 1;
1448           break;
1449         case OPT_M:
1450           CPP_OPTION (pfile, print_deps) = 2;
1451           break;
1452         case OPT_MM:
1453           CPP_OPTION (pfile, print_deps) = 1;
1454           break;
1455         case OPT_MF:
1456           CPP_OPTION (pfile, deps_file) = arg;
1457           break;
1458         case OPT_MP:
1459           CPP_OPTION (pfile, deps_phony_targets) = 1;
1460           break;
1461         case OPT_MQ:
1462         case OPT_MT:
1463           /* Add a target.  -MQ quotes for Make.  */
1464           deps_add_target (pfile->deps, arg, opt_code == OPT_MQ);
1465           break;
1466
1467           /* -MD and -MMD for cpp0 are deprecated and undocumented
1468              (use -M or -MM with -MF instead), and probably should be
1469              removed with the next major GCC version.  For the moment
1470              we allow these for the benefit of Automake 1.4, which
1471              uses these when dependency tracking is enabled.  Automake
1472              1.5 will fix this.  */
1473         case OPT_MD:
1474           CPP_OPTION (pfile, print_deps) = 2;
1475           CPP_OPTION (pfile, deps_file) = arg;
1476           break;
1477         case OPT_MMD:
1478           CPP_OPTION (pfile, print_deps) = 1;
1479           CPP_OPTION (pfile, deps_file) = arg;
1480           break;
1481
1482         case OPT_A:
1483           if (arg[0] == '-')
1484             {
1485               /* -A with an argument beginning with '-' acts as
1486                  #unassert on whatever immediately follows the '-'.
1487                  If "-" is the whole argument, we eliminate all
1488                  predefined macros and assertions, including those
1489                  that were specified earlier on the command line.
1490                  That way we can get rid of any that were passed
1491                  automatically in from GCC.  */
1492
1493               if (arg[1] == '\0')
1494                 {
1495                   struct pending_option *o1, *o2;
1496
1497                   o1 = pend->directive_head;
1498                   while (o1)
1499                     {
1500                       o2 = o1->next;
1501                       free (o1);
1502                       o1 = o2;
1503                     }
1504                   pend->directive_head = NULL;
1505                   pend->directive_tail = NULL;
1506                 }
1507               else
1508                 new_pending_directive (pend, arg + 1, cpp_unassert);
1509             }
1510           else
1511             new_pending_directive (pend, arg, cpp_assert);
1512           break;
1513         case OPT_U:
1514           new_pending_directive (pend, arg, cpp_undef);
1515           break;
1516         case OPT_I:           /* Add directory to path for includes.  */
1517           if (!strcmp (arg, "-"))
1518             {
1519               /* -I- means:
1520                  Use the preceding -I directories for #include "..."
1521                  but not #include <...>.
1522                  Don't search the directory of the present file
1523                  for #include "...".  (Note that -I. -I- is not the same as
1524                  the default setup; -I. uses the compiler's working dir.)  */
1525               if (! CPP_OPTION (pfile, ignore_srcdir))
1526                 {
1527                   pend->quote_head = pend->brack_head;
1528                   pend->quote_tail = pend->brack_tail;
1529                   pend->brack_head = 0;
1530                   pend->brack_tail = 0;
1531                   CPP_OPTION (pfile, ignore_srcdir) = 1;
1532                 }
1533               else
1534                 {
1535                   cpp_fatal (pfile, "-I- specified twice");
1536                   return argc;
1537                 }
1538             }
1539           else
1540             append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1541           break;
1542         case OPT_isystem:
1543           /* Add directory to beginning of system include path, as a system
1544              include directory.  */
1545           append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1546           break;
1547         case OPT_include:
1548           {
1549             struct pending_option *o = (struct pending_option *)
1550               xmalloc (sizeof (struct pending_option));
1551             o->arg = arg;
1552
1553             /* This list has to be built in reverse order so that
1554                when cpp_start_read pushes all the -include files onto
1555                the buffer stack, they will be scanned in forward order.  */
1556             o->next = pend->include_head;
1557             pend->include_head = o;
1558           }
1559           break;
1560         case OPT_imacros:
1561           {
1562             struct pending_option *o = (struct pending_option *)
1563               xmalloc (sizeof (struct pending_option));
1564             o->arg = arg;
1565             o->next = NULL;
1566
1567             APPEND (pend, imacros, o);
1568           }
1569           break;
1570         case OPT_iwithprefix:
1571           /* Add directory to end of path for includes,
1572              with the default prefix at the front of its name.  */
1573           /* fall through */
1574         case OPT_iwithprefixbefore:
1575           /* Add directory to main path for includes,
1576              with the default prefix at the front of its name.  */
1577           {
1578             char *fname;
1579             int len;
1580
1581             len = strlen (arg);
1582
1583             if (CPP_OPTION (pfile, include_prefix) != 0)
1584               {
1585                 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1586                 fname = xmalloc (ipl + len + 1);
1587                 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1588                 memcpy (fname + ipl, arg, len + 1);
1589               }
1590             else if (cpp_GCC_INCLUDE_DIR_len)
1591               {
1592                 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1593                 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1594                 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1595               }
1596             else
1597               fname = xstrdup (arg);
1598
1599             append_include_chain (pfile, fname,
1600                           opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1601           }
1602           break;
1603         case OPT_idirafter:
1604           /* Add directory to end of path for includes.  */
1605           append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1606           break;
1607         case OPT_W:
1608           /* Silently ignore unrecognised options.  */
1609           if (!strcmp (argv[i], "-Wall"))
1610             {
1611               CPP_OPTION (pfile, warn_trigraphs) = 1;
1612               CPP_OPTION (pfile, warn_comments) = 1;
1613             }
1614           else if (!strcmp (argv[i], "-Wtraditional"))
1615             CPP_OPTION (pfile, warn_traditional) = 1;
1616           else if (!strcmp (argv[i], "-Wtrigraphs"))
1617             CPP_OPTION (pfile, warn_trigraphs) = 1;
1618           else if (!strcmp (argv[i], "-Wcomment"))
1619             CPP_OPTION (pfile, warn_comments) = 1;
1620           else if (!strcmp (argv[i], "-Wcomments"))
1621             CPP_OPTION (pfile, warn_comments) = 1;
1622           else if (!strcmp (argv[i], "-Wundef"))
1623             CPP_OPTION (pfile, warn_undef) = 1;
1624           else if (!strcmp (argv[i], "-Wimport"))
1625             CPP_OPTION (pfile, warn_import) = 1;
1626           else if (!strcmp (argv[i], "-Werror"))
1627             CPP_OPTION (pfile, warnings_are_errors) = 1;
1628           else if (!strcmp (argv[i], "-Wsystem-headers"))
1629             CPP_OPTION (pfile, warn_system_headers) = 1;
1630           else if (!strcmp (argv[i], "-Wno-traditional"))
1631             CPP_OPTION (pfile, warn_traditional) = 0;
1632           else if (!strcmp (argv[i], "-Wno-trigraphs"))
1633             CPP_OPTION (pfile, warn_trigraphs) = 0;
1634           else if (!strcmp (argv[i], "-Wno-comment"))
1635             CPP_OPTION (pfile, warn_comments) = 0;
1636           else if (!strcmp (argv[i], "-Wno-comments"))
1637             CPP_OPTION (pfile, warn_comments) = 0;
1638           else if (!strcmp (argv[i], "-Wno-undef"))
1639             CPP_OPTION (pfile, warn_undef) = 0;
1640           else if (!strcmp (argv[i], "-Wno-import"))
1641             CPP_OPTION (pfile, warn_import) = 0;
1642           else if (!strcmp (argv[i], "-Wno-error"))
1643             CPP_OPTION (pfile, warnings_are_errors) = 0;
1644           else if (!strcmp (argv[i], "-Wno-system-headers"))
1645             CPP_OPTION (pfile, warn_system_headers) = 0;
1646           break;
1647         }
1648     }
1649   return i + 1;
1650 }
1651
1652 /* Handle command-line options in (argc, argv).
1653    Can be called multiple times, to handle multiple sets of options.
1654    Returns if an unrecognized option is seen.
1655    Returns number of strings consumed.  */
1656 int
1657 cpp_handle_options (pfile, argc, argv)
1658      cpp_reader *pfile;
1659      int argc;
1660      char **argv;
1661 {
1662   int i;
1663   int strings_processed;
1664
1665   for (i = 0; i < argc; i += strings_processed)
1666     {
1667       strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1668       if (strings_processed == 0)
1669         break;
1670     }
1671
1672   return i;
1673 }
1674
1675 /* Extra processing when all options are parsed, after all calls to
1676    cpp_handle_option[s].  Consistency checks etc.  */
1677 void
1678 cpp_post_options (pfile)
1679      cpp_reader *pfile;
1680 {
1681   /* -Wtraditional is not useful in C++ mode.  */
1682   if (CPP_OPTION (pfile, cplusplus))
1683     CPP_OPTION (pfile, warn_traditional) = 0;
1684
1685   /* Set this if it hasn't been set already. */
1686   if (CPP_OPTION (pfile, user_label_prefix) == NULL)
1687     CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
1688
1689   /* We need to do this after option processing and before
1690      cpp_start_read, as cppmain.c relies on the options->no_output to
1691      set its callbacks correctly before calling cpp_start_read.  */
1692   init_dependency_output (pfile);
1693
1694   /* After checking the environment variables, check if -M or -MM has
1695      not been specified, but other -M options have.  */
1696   if (CPP_OPTION (pfile, print_deps) == 0 &&
1697       (CPP_OPTION (pfile, print_deps_missing_files)
1698        || CPP_OPTION (pfile, deps_file)
1699        || CPP_OPTION (pfile, deps_phony_targets)))
1700     cpp_fatal (pfile, "you must additionally specify either -M or -MM");
1701 }
1702
1703 /* Set up dependency-file output.  */
1704 static void
1705 init_dependency_output (pfile)
1706      cpp_reader *pfile;
1707 {
1708   char *spec, *s, *output_file;
1709
1710   /* Either of two environment variables can specify output of deps.
1711      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1712      where OUTPUT_FILE is the file to write deps info to
1713      and DEPS_TARGET is the target to mention in the deps.  */
1714
1715   if (CPP_OPTION (pfile, print_deps) == 0)
1716     {
1717       spec = getenv ("DEPENDENCIES_OUTPUT");
1718       if (spec)
1719         CPP_OPTION (pfile, print_deps) = 1;
1720       else
1721         {
1722           spec = getenv ("SUNPRO_DEPENDENCIES");
1723           if (spec)
1724             CPP_OPTION (pfile, print_deps) = 2;
1725           else
1726             return;
1727         }
1728
1729       /* Find the space before the DEPS_TARGET, if there is one.  */
1730       s = strchr (spec, ' ');
1731       if (s)
1732         {
1733           /* Let the caller perform MAKE quoting.  */
1734           deps_add_target (pfile->deps, s + 1, 0);
1735           output_file = (char *) xmalloc (s - spec + 1);
1736           memcpy (output_file, spec, s - spec);
1737           output_file[s - spec] = 0;
1738         }
1739       else
1740         output_file = spec;
1741
1742       /* Command line overrides environment variables.  */
1743       if (CPP_OPTION (pfile, deps_file) == 0)
1744         CPP_OPTION (pfile, deps_file) = output_file;
1745       CPP_OPTION (pfile, print_deps_append) = 1;
1746     }
1747
1748   /* If dependencies go to standard output, or -MG is used, we should
1749      suppress output.  The user may be requesting other stuff to
1750      stdout, with -dM, -v etc.  We let them shoot themselves in the
1751      foot.  */
1752   if (CPP_OPTION (pfile, deps_file) == 0
1753       || CPP_OPTION (pfile, print_deps_missing_files))
1754     CPP_OPTION (pfile, no_output) = 1;
1755 }
1756
1757 static void
1758 print_help ()
1759 {
1760   fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1761   /* To keep the lines from getting too long for some compilers, limit
1762      to about 500 characters (6 lines) per chunk. */
1763   fputs (_("\
1764 Switches:\n\
1765   -include <file>           Include the contents of <file> before other files\n\
1766   -imacros <file>           Accept definition of macros in <file>\n\
1767   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1768   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1769   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1770   -isystem <dir>            Add <dir> to the start of the system include path\n\
1771 "), stdout);
1772   fputs (_("\
1773   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1774   -I <dir>                  Add <dir> to the end of the main include path\n\
1775   -I-                       Fine-grained include path control; see info docs\n\
1776   -nostdinc                 Do not search system include directories\n\
1777                              (dirs specified with -isystem will still be used)\n\
1778   -nostdinc++               Do not search system include directories for C++\n\
1779   -o <file>                 Put output into <file>\n\
1780 "), stdout);
1781   fputs (_("\
1782   -pedantic                 Issue all warnings demanded by strict ISO C\n\
1783   -pedantic-errors          Issue -pedantic warnings as errors instead\n\
1784   -trigraphs                Support ISO C trigraphs\n\
1785   -lang-c                   Assume that the input sources are in C\n\
1786   -lang-c89                 Assume that the input sources are in C89\n\
1787 "), stdout);
1788   fputs (_("\
1789   -lang-c++                 Assume that the input sources are in C++\n\
1790   -lang-objc                Assume that the input sources are in ObjectiveC\n\
1791   -lang-objc++              Assume that the input sources are in ObjectiveC++\n\
1792   -lang-asm                 Assume that the input sources are in assembler\n\
1793 "), stdout);
1794   fputs (_("\
1795   -std=<std name>           Specify the conformance standard; one of:\n\
1796                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1797                             iso9899:199409, iso9899:1999\n\
1798   -+                        Allow parsing of C++ style features\n\
1799   -w                        Inhibit warning messages\n\
1800   -Wtrigraphs               Warn if trigraphs are encountered\n\
1801   -Wno-trigraphs            Do not warn about trigraphs\n\
1802   -Wcomment{s}              Warn if one comment starts inside another\n\
1803 "), stdout);
1804   fputs (_("\
1805   -Wno-comment{s}           Do not warn about comments\n\
1806   -Wtraditional             Warn about features not present in traditional C\n\
1807   -Wno-traditional          Do not warn about traditional C\n\
1808   -Wundef                   Warn if an undefined macro is used by #if\n\
1809   -Wno-undef                Do not warn about testing undefined macros\n\
1810   -Wimport                  Warn about the use of the #import directive\n\
1811 "), stdout);
1812   fputs (_("\
1813   -Wno-import               Do not warn about the use of #import\n\
1814   -Werror                   Treat all warnings as errors\n\
1815   -Wno-error                Do not treat warnings as errors\n\
1816   -Wsystem-headers          Do not suppress warnings from system headers\n\
1817   -Wno-system-headers       Suppress warnings from system headers\n\
1818   -Wall                     Enable all preprocessor warnings\n\
1819 "), stdout);
1820   fputs (_("\
1821   -M                        Generate make dependencies\n\
1822   -MM                       As -M, but ignore system header files\n\
1823   -MF <file>                Write dependency output to the given file\n\
1824   -MG                       Treat missing header file as generated files\n\
1825 "), stdout);
1826   fputs (_("\
1827   -MP                       Generate phony targets for all headers\n\
1828   -MQ <target>              Add a MAKE-quoted target\n\
1829   -MT <target>              Add an unquoted target\n\
1830 "), stdout);
1831   fputs (_("\
1832   -D<macro>                 Define a <macro> with string '1' as its value\n\
1833   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1834   -A<question> (<answer>)   Assert the <answer> to <question>\n\
1835   -A-<question> (<answer>)  Disable the <answer> to <question>\n\
1836   -U<macro>                 Undefine <macro> \n\
1837   -v                        Display the version number\n\
1838 "), stdout);
1839   fputs (_("\
1840   -H                        Print the name of header files as they are used\n\
1841   -C                        Do not discard comments\n\
1842   -dM                       Display a list of macro definitions active at end\n\
1843   -dD                       Preserve macro definitions in output\n\
1844   -dN                       As -dD except that only the names are preserved\n\
1845   -dI                       Include #include directives in the output\n\
1846 "), stdout);
1847   fputs (_("\
1848   -ftabstop=<number>        Distance between tab stops for column reporting\n\
1849   -P                        Do not generate #line directives\n\
1850   -$                        Do not allow '$' in identifiers\n\
1851   -remap                    Remap file names when including files.\n\
1852   --version                 Display version information\n\
1853   -h or --help              Display this information\n\
1854 "), stdout);
1855 }