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