gcc/cppinit.c

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