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