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