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 ((struct cpp_options *));
 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_options *,
 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(' ') 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_OPTIONS (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 (opts)
 393      struct cpp_options *opts;
 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   qtail = opts->pending->quote_tail;
 400   btail = opts->pending->brack_tail;
 401   stail = opts->pending->systm_tail;
 402   atail = opts->pending->after_tail;
 403
 404   quote = opts->pending->quote_head;
 405   brack = opts->pending->brack_head;
 406   systm = opts->pending->systm_head;
 407   after = opts->pending->after_head;
 408
 409   /* Paste together bracket, system, and after include chains. */
 410   if (stail)
 411     stail->next = after;
 412   else
 413     systm = after;
 414   if (btail)
 415     btail->next = systm;
 416   else
 417     brack = systm;
 418
 419   /* This is a bit tricky.
 420      First we drop dupes from the quote-include list.
 421      Then we drop dupes from the bracket-include list.
 422      Finally, if qtail and brack are the same directory,
 423      we cut out qtail.
 424
 425      We can't just merge the lists and then uniquify them because
 426      then we may lose directories from the <> search path that should
 427      be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
 428      safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
 429      -Ibar -I- -Ifoo -Iquux.
 430
 431      Note that this algorithm is quadratic in the number of -I switches,
 432      which is acceptable since there aren't usually that many of them.  */
 433
 434   for (cur = quote, prev = NULL; cur; cur = cur->next)
 435     {
 436       for (other = quote; other != cur; other = other->next)
 437         if (INO_T_EQ (cur->ino, other->ino)
 438             && cur->dev == other->dev)
 439           {
 440             if (opts->verbose)
 441               fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 442                        cur->name);
 443
 444             prev->next = cur->next;
 445             free (cur->name);
 446             free (cur);
 447             cur = prev;
 448             break;
 449           }
 450       prev = cur;
 451     }
 452   qtail = prev;
 453
 454   for (cur = brack; cur; cur = cur->next)
 455     {
 456       for (other = brack; other != cur; other = other->next)
 457         if (INO_T_EQ (cur->ino, other->ino)
 458             && cur->dev == other->dev)
 459           {
 460             if (opts->verbose)
 461               fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 462                        cur->name);
 463
 464             prev->next = cur->next;
 465             free (cur->name);
 466             free (cur);
 467             cur = prev;
 468             break;
 469           }
 470       prev = cur;
 471     }
 472
 473   if (quote)
 474     {
 475       if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
 476         {
 477           if (quote == qtail)
 478             {
 479               if (opts->verbose)
 480                 fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 481                          quote->name);
 482
 483               free (quote->name);
 484               free (quote);
 485               quote = brack;
 486             }
 487           else
 488             {
 489               cur = quote;
 490               while (cur->next != qtail)
 491                   cur = cur->next;
 492               cur->next = brack;
 493               if (opts->verbose)
 494                 fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 495                          qtail->name);
 496
 497               free (qtail->name);
 498               free (qtail);
 499             }
 500         }
 501       else
 502           qtail->next = brack;
 503     }
 504   else
 505       quote = brack;
 506
 507   opts->quote_include = quote;
 508   opts->bracket_include = brack;
 509 }
 510
 511
 512 /* Write out a #define command for the special named MACRO_NAME
 513    to PFILE's token_buffer.  */
 514
 515 static void
 516 dump_special_to_buffer (pfile, macro_name)
 517      cpp_reader *pfile;
 518      const char *macro_name;
 519 {
 520   static const char define_directive[] = "#define ";
 521   int macro_name_length = strlen (macro_name);
 522   _cpp_output_line_command (pfile, same_file);
 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_options structure. */
 532 void
 533 cpp_options_init (opts)
 534      cpp_options *opts;
 535 {
 536   memset ((char *) opts, 0, sizeof (struct cpp_options));
 537
 538   opts->dollars_in_ident = 1;
 539   opts->cplusplus_comments = 1;
 540   opts->warn_import = 1;
 541   opts->discard_comments = 1;
 542
 543   opts->pending =
 544     (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
 545 }
 546
 547 /* Initialize a cpp_reader structure. */
 548 void
 549 cpp_reader_init (pfile)
 550      cpp_reader *pfile;
 551 {
 552   memset ((char *) pfile, 0, sizeof (cpp_reader));
 553
 554   pfile->token_buffer_size = 200;
 555   pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
 556   CPP_SET_WRITTEN (pfile, 0);
 557
 558   _cpp_init_macro_hash (pfile);
 559   _cpp_init_include_hash (pfile);
 560 }
 561
 562 /* Free resources used by PFILE.
 563    This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology).  */
 564 void
 565 cpp_cleanup (pfile)
 566      cpp_reader *pfile;
 567 {
 568   while (CPP_BUFFER (pfile) != NULL)
 569     cpp_pop_buffer (pfile);
 570
 571   if (pfile->token_buffer)
 572     {
 573       free (pfile->token_buffer);
 574       pfile->token_buffer = NULL;
 575     }
 576
 577   if (pfile->input_buffer)
 578     {
 579       free (pfile->input_buffer);
 580       free (pfile->input_speccase);
 581       pfile->input_buffer = pfile->input_speccase = NULL;
 582       pfile->input_buffer_len = 0;
 583     }
 584
 585   if (pfile->deps)
 586     deps_free (pfile->deps);
 587
 588   htab_delete (pfile->hashtab);
 589   htab_delete (pfile->all_include_files);
 590 }
 591
 592
 593 /* This structure defines one built-in macro.  A node of type TYPE will
 594    be entered in the macro hash table under the name NAME, with value
 595    VALUE (if any).  FLAGS tweaks the behavior a little:
 596    DUMP         write debug info for this macro
 597    STDC         define only if not -traditional
 598    ULP          value is the global user_label_prefix (which can't be
 599                 put directly into the table).
 600  */
 601
 602 struct builtin
 603 {
 604   const char *name;
 605   const char *value;
 606   unsigned short type;
 607   unsigned short flags;
 608 };
 609 #define DUMP 0x01
 610 #define STDC 0x02
 611 #define VERS 0x04
 612 #define ULP  0x08
 613
 614 static const struct builtin builtin_array[] =
 615 {
 616   { "__TIME__",                 0, T_TIME,              DUMP },
 617   { "__DATE__",                 0, T_DATE,              DUMP },
 618   { "__FILE__",                 0, T_FILE,              0    },
 619   { "__BASE_FILE__",            0, T_BASE_FILE,         0    },
 620   { "__LINE__",                 0, T_SPECLINE,          0    },
 621   { "__INCLUDE_LEVEL__",        0, T_INCLUDE_LEVEL,     0    },
 622   { "__VERSION__",              0, T_VERSION,           DUMP|VERS },
 623   { "__STDC__",                 0, T_STDC,              DUMP|STDC },
 624
 625   { "__USER_LABEL_PREFIX__",    0,               T_CONST, ULP  },
 626   { "__REGISTER_PREFIX__",      REGISTER_PREFIX, T_CONST, 0    },
 627   { "__HAVE_BUILTIN_SETJMP__",  "1",             T_CONST, 0    },
 628 #ifndef NO_BUILTIN_SIZE_TYPE
 629   { "__SIZE_TYPE__",            SIZE_TYPE,       T_CONST, DUMP },
 630 #endif
 631 #ifndef NO_BUILTIN_PTRDIFF_TYPE
 632   { "__PTRDIFF_TYPE__",         PTRDIFF_TYPE,    T_CONST, DUMP },
 633 #endif
 634 #ifndef NO_BUILTIN_WCHAR_TYPE
 635   { "__WCHAR_TYPE__",           WCHAR_TYPE,      T_CONST, DUMP },
 636 #endif
 637   { 0, 0, 0, 0 }
 638 };
 639
 640 /* Subroutine of cpp_start_read; reads the builtins table above and
 641    enters the macros into the hash table.  */
 642 static void
 643 initialize_builtins (pfile)
 644      cpp_reader *pfile;
 645 {
 646   int len;
 647   const struct builtin *b;
 648   const char *val;
 649   HASHNODE *hp;
 650   for(b = builtin_array; b->name; b++)
 651     {
 652       if ((b->flags & STDC) && CPP_TRADITIONAL (pfile))
 653         continue;
 654
 655       if (b->flags & ULP)
 656         val = user_label_prefix;
 657       else if (b->flags & VERS)
 658         val = version_string;
 659       else
 660         val = b->value;
 661
 662       len = strlen (b->name);
 663       hp = _cpp_make_hashnode (b->name, len, b->type, -1);
 664       hp->value.cpval = val;
 665       *(htab_find_slot (pfile->hashtab, (void *)hp, 1)) = hp;
 666
 667       if ((b->flags & DUMP) && CPP_OPTIONS (pfile)->debug_output)
 668         dump_special_to_buffer (pfile, b->name);
 669     }
 670
 671 }
 672 #undef DUMP
 673 #undef STDC
 674 #undef VERS
 675 #undef ULP
 676
 677 /* Another subroutine of cpp_start_read.  This one sets up to do
 678    dependency-file output. */
 679 static void
 680 initialize_dependency_output (pfile)
 681      cpp_reader *pfile;
 682 {
 683   cpp_options *opts = CPP_OPTIONS (pfile);
 684   char *spec, *s, *output_file;
 685
 686   /* Either of two environment variables can specify output of deps.
 687      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
 688      where OUTPUT_FILE is the file to write deps info to
 689      and DEPS_TARGET is the target to mention in the deps.  */
 690
 691   if (opts->print_deps == 0)
 692     {
 693       spec = getenv ("DEPENDENCIES_OUTPUT");
 694       if (spec)
 695         opts->print_deps = 1;
 696       else
 697         {
 698           spec = getenv ("SUNPRO_DEPENDENCIES");
 699           if (spec)
 700             opts->print_deps = 2;
 701           else
 702             return;
 703         }
 704
 705       /* Find the space before the DEPS_TARGET, if there is one.  */
 706       s = strchr (spec, ' ');
 707       if (s)
 708         {
 709           opts->deps_target = s + 1;
 710           output_file = (char *) xmalloc (s - spec + 1);
 711           memcpy (output_file, spec, s - spec);
 712           output_file[s - spec] = 0;
 713         }
 714       else
 715         {
 716           opts->deps_target = 0;
 717           output_file = spec;
 718         }
 719
 720       opts->deps_file = output_file;
 721       opts->print_deps_append = 1;
 722     }
 723
 724   pfile->deps = deps_init ();
 725
 726   /* Print the expected object file name as the target of this Make-rule.  */
 727   if (opts->deps_target)
 728     deps_add_target (pfile->deps, opts->deps_target);
 729   else if (*opts->in_fname == 0)
 730     deps_add_target (pfile->deps, "-");
 731   else
 732     deps_calc_target (pfile->deps, opts->in_fname);
 733
 734   if (opts->in_fname)
 735     deps_add_dep (pfile->deps, opts->in_fname);
 736 }
 737
 738 /* And another subroutine.  This one sets up the standard include path.  */
 739 static void
 740 initialize_standard_includes (pfile)
 741      cpp_reader *pfile;
 742 {
 743   cpp_options *opts = CPP_OPTIONS (pfile);
 744   char *path;
 745   const struct default_include *p;
 746   const char *specd_prefix = opts->include_prefix;
 747
 748   /* Several environment variables may add to the include search path.
 749      CPATH specifies an additional list of directories to be searched
 750      as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
 751      etc. specify an additional list of directories to be searched as
 752      if specified with -isystem, for the language indicated.  */
 753
 754   GET_ENV_PATH_LIST (path, "CPATH");
 755   if (path != 0 && *path != 0)
 756     path_include (pfile, opts->pending, path, BRACKET);
 757
 758   switch ((opts->objc << 1) + opts->cplusplus)
 759     {
 760     case 0:
 761       GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
 762       break;
 763     case 1:
 764       GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
 765       break;
 766     case 2:
 767       GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
 768       break;
 769     case 3:
 770       GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
 771       break;
 772     }
 773   if (path != 0 && *path != 0)
 774     path_include (pfile, opts->pending, path, SYSTEM);
 775
 776   /* Search "translated" versions of GNU directories.
 777      These have /usr/local/lib/gcc... replaced by specd_prefix.  */
 778   if (specd_prefix != 0)
 779     {
 780       char *default_prefix = alloca (sizeof GCC_INCLUDE_DIR - 7);
 781       /* Remove the `include' from /usr/local/lib/gcc.../include.
 782          GCC_INCLUDE_DIR will always end in /include. */
 783       int default_len = sizeof GCC_INCLUDE_DIR - 8;
 784       int specd_len = strlen (specd_prefix);
 785
 786       memcpy (default_prefix, GCC_INCLUDE_DIR, default_len);
 787       default_prefix[default_len] = '\0';
 788
 789       for (p = include_defaults_array; p->fname; p++)
 790         {
 791           /* Some standard dirs are only for C++.  */
 792           if (!p->cplusplus
 793               || (opts->cplusplus
 794                   && !opts->no_standard_cplusplus_includes))
 795             {
 796               /* Does this dir start with the prefix?  */
 797               if (!strncmp (p->fname, default_prefix, default_len))
 798                 {
 799                   /* Yes; change prefix and add to search list.  */
 800                   int flen = strlen (p->fname);
 801                   int this_len = specd_len + flen - default_len;
 802                   char *str = (char *) xmalloc (this_len + 1);
 803                   memcpy (str, specd_prefix, specd_len);
 804                   memcpy (str + specd_len,
 805                           p->fname + default_len,
 806                           flen - default_len + 1);
 807
 808                   append_include_chain (pfile, opts->pending,
 809                                         str, SYSTEM, p->cxx_aware);
 810                 }
 811             }
 812         }
 813     }
 814
 815   /* Search ordinary names for GNU include directories.  */
 816   for (p = include_defaults_array; p->fname; p++)
 817     {
 818       /* Some standard dirs are only for C++.  */
 819       if (!p->cplusplus
 820           || (opts->cplusplus
 821               && !opts->no_standard_cplusplus_includes))
 822         {
 823           /* XXX Potential memory leak! */
 824           char *str = xstrdup (update_path (p->fname, p->component));
 825           append_include_chain (pfile, opts->pending, str, SYSTEM,
 826                                 p->cxx_aware);
 827         }
 828     }
 829 }
 830
 831 /* This is called after options have been processed.
 832  * Check options for consistency, and setup for processing input
 833  * from the file named FNAME.  (Use standard input if FNAME==NULL.)
 834  * Return 1 on success, 0 on failure.
 835  */
 836
 837 int
 838 cpp_start_read (pfile, fname)
 839      cpp_reader *pfile;
 840      const char *fname;
 841 {
 842   struct cpp_options *opts = CPP_OPTIONS (pfile);
 843   struct pending_option *p, *q;
 844
 845   /* -MG doesn't select the form of output and must be specified with one of
 846      -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
 847      inhibit compilation.  */
 848   if (opts->print_deps_missing_files
 849       && (opts->print_deps == 0 || !opts->no_output))
 850     {
 851       cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
 852       return 0;
 853     }
 854
 855   /* Chill should not be used with -trigraphs. */
 856   if (opts->chill && opts->trigraphs)
 857     {
 858       cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive");
 859       opts->trigraphs = 0;
 860     }
 861
 862   /* Set this if it hasn't been set already. */
 863   if (user_label_prefix == NULL)
 864     user_label_prefix = USER_LABEL_PREFIX;
 865
 866   /* Don't bother trying to do macro expansion if we've already done
 867      preprocessing.  */
 868   if (opts->preprocessed)
 869     pfile->no_macro_expand++;
 870
 871   /* Set up the IStable.  This doesn't do anything if we were compiled
 872      with a compiler that supports C99 designated initializers.  */
 873   init_IStable ();
 874
 875   /* Set up the tables used by read_and_prescan.  */
 876   _cpp_init_input_buffer (pfile);
 877
 878   /* Set up the include search path now.  */
 879   if (! opts->no_standard_includes)
 880     initialize_standard_includes (pfile);
 881
 882   merge_include_chains (opts);
 883
 884   /* With -v, print the list of dirs to search.  */
 885   if (opts->verbose)
 886     {
 887       struct file_name_list *l;
 888       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 889       for (l = opts->quote_include; l; l = l->next)
 890         {
 891           if (l == opts->bracket_include)
 892             fprintf (stderr, _("#include <...> search starts here:\n"));
 893           fprintf (stderr, " %s\n", l->name);
 894         }
 895       fprintf (stderr, _("End of search list.\n"));
 896     }
 897
 898   initialize_dependency_output (pfile);
 899
 900   /* Open the main input file.  This must be done before -D processing
 901      so we have a buffer to stand on.  */
 902   if (opts->in_fname == NULL || *opts->in_fname == 0)
 903     {
 904       opts->in_fname = fname;
 905       if (opts->in_fname == NULL)
 906         opts->in_fname = "";
 907     }
 908
 909   if (!cpp_read_file (pfile, fname))
 910     return 0;
 911
 912   /* -D and friends may produce output, which should be identified
 913      as line 0.  */
 914
 915   CPP_BUFFER (pfile)->lineno = 0;
 916
 917   /* Install __LINE__, etc.  */
 918   initialize_builtins (pfile);
 919
 920   /* Do -U's, -D's and -A's in the order they were seen.  */
 921   p = opts->pending->directive_head;
 922   while (p)
 923     {
 924       (*p->handler) (pfile, p->arg);
 925       q = p->next;
 926       free (p);
 927       p = q;
 928     }
 929
 930   opts->done_initializing = 1;
 931   CPP_BUFFER (pfile)->lineno = 1;
 932
 933   if (opts->preprocessed)
 934     /* If we've already processed this code, we want to trust the #line
 935        directives in the input.  But we still need to update our line
 936        counter accordingly.  */
 937     pfile->lineno = CPP_BUFFER (pfile)->lineno;
 938   else
 939     _cpp_output_line_command (pfile, same_file);
 940   pfile->only_seen_white = 2;
 941
 942   /* The -imacros files can be scanned now, but the -include files
 943      have to be pushed onto the include stack and processed later,
 944      in the main loop calling cpp_get_token.  */
 945
 946   opts->no_output++;
 947   p = opts->pending->imacros_head;
 948   while (p)
 949     {
 950       if (cpp_read_file (pfile, p->arg))
 951         cpp_scan_buffer (pfile);
 952
 953       q = p->next;
 954       free (p);
 955       p = q;
 956     }
 957   opts->no_output--;
 958
 959   p = opts->pending->include_head;
 960   while (p)
 961     {
 962       if (cpp_read_file (pfile, p->arg))
 963         _cpp_output_line_command (pfile, enter_file);
 964
 965       q = p->next;
 966       free (p);
 967       p = q;
 968     }
 969
 970   free (opts->pending);
 971   opts->pending = NULL;
 972
 973   return 1;
 974 }
 975
 976 /* This is called at the end of preprocessing.  It pops the
 977    last buffer and writes dependency output.  It should also
 978    clear macro definitions, such that you could call cpp_start_read
 979    with a new filename to restart processing. */
 980 void
 981 cpp_finish (pfile)
 982      cpp_reader *pfile;
 983 {
 984   struct cpp_options *opts = CPP_OPTIONS (pfile);
 985
 986   if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
 987     cpp_ice (pfile, "buffers still stacked in cpp_finish");
 988   while (CPP_BUFFER (pfile))
 989     cpp_pop_buffer (pfile);
 990
 991   /* Don't write the deps file if preprocessing has failed.  */
 992   if (opts->print_deps && pfile->errors == 0)
 993     {
 994       /* Stream on which to print the dependency information.  */
 995       FILE *deps_stream = 0;
 996
 997       const char *deps_mode = opts->print_deps_append ? "a" : "w";
 998       if (opts->deps_file == 0)
 999         deps_stream = stdout;
1000       else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
1001         cpp_notice_from_errno (pfile, opts->deps_file);
1002
1003       if (deps_stream)
1004         {
1005           deps_write (pfile->deps, deps_stream, 72);
1006           if (opts->deps_file)
1007             {
1008               if (ferror (deps_stream) || fclose (deps_stream) != 0)
1009                 cpp_fatal (pfile, "I/O error on output");
1010             }
1011         }
1012     }
1013
1014   if (opts->dump_macros == dump_only)
1015     _cpp_dump_macro_hash (pfile);
1016 }
1017
1018 static void
1019 new_pending_directive (opts, text, handler)
1020      struct cpp_options *opts;
1021      const char *text;
1022      cl_directive_handler handler;
1023 {
1024   struct pending_option *o = (struct pending_option *)
1025     xmalloc (sizeof (struct pending_option));
1026
1027   o->arg = text;
1028   o->next = NULL;
1029   o->handler = handler;
1030   APPEND (opts->pending, directive, o);
1031 }
1032
1033 enum opt_code
1034 {
1035   OPT_stdin_stdout = 0, OPT_dollar, OPT_plus,
1036   OPT__help, OPT__version,
1037   OPT_A, OPT_C, OPT_D, OPT_H, OPT_I, OPT_M,
1038   OPT_MD, OPT_MG, OPT_MM, OPT_MMD,
1039   OPT_P, OPT_U, OPT_W,
1040   OPT_d,
1041   OPT_fleading_underscore, OPT_fno_leading_underscore,
1042   OPT_fpreprocessed, OPT_fno_preprocessed,
1043   OPT_g, OPT_h,
1044   OPT_idirafter, OPT_imacros, OPT_include,
1045   OPT_iprefix, OPT_isystem, OPT_iwithprefix, OPT_iwithprefixbefore,
1046   OPT_lang_asm, OPT_lang_c, OPT_lang_cplusplus, OPT_lang_c89,
1047   OPT_lang_chill, OPT_lang_fortran, OPT_lang_objc, OPT_lang_objcplusplus,
1048   OPT_nostdinc, OPT_nostdincplusplus,
1049   OPT_o,
1050   OPT_pedantic, OPT_pedantic_errors, OPT_remap,
1051   OPT_std_c89, OPT_std_c99, OPT_std_c9x, OPT_std_gnu89, OPT_std_gnu99,
1052   OPT_std_gnu9x, OPT_std_iso9899_1990, OPT_std_iso9899_199409,
1053   OPT_std_iso9899_1999, OPT_std_iso9899_199x,
1054   OPT_traditional, OPT_trigraphs,
1055   OPT_v, OPT_w,
1056   N_OPTS
1057 };
1058
1059 struct cl_option
1060 {
1061   const char *opt_text;
1062   const char *msg;
1063   size_t opt_len;
1064   enum opt_code opt_code;
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' option")
1071 #define no_ass N_("Assertion missing after `%s' option")
1072 #define no_dir N_("Directory name missing after `%s' option")
1073 #define no_fil N_("File name missing after `%s' option")
1074 #define no_mac N_("Macro name missing after `%s' option")
1075 #define no_pth N_("Path name missing after `%s' option")
1076
1077 /* This list must be ASCII sorted. Make enum order above match this. */
1078 #define DEF_OPT(text, msg, code) {text, msg, sizeof(text) - 1, code}
1079
1080 #ifdef HOST_EBCDIC
1081 static struct cl_option cl_options[] =
1082 #else
1083 static const struct cl_option cl_options[] =
1084 #endif
1085 {
1086   DEF_OPT("",                         0,      OPT_stdin_stdout),
1087   DEF_OPT("$",                        0,      OPT_dollar),
1088   DEF_OPT("+",                        0,      OPT_plus),
1089   DEF_OPT("-help",                    0,      OPT__help),
1090   DEF_OPT("-version",                 0,      OPT__version),
1091   DEF_OPT("A",                        no_ass, OPT_A),
1092   DEF_OPT("C",                        0,      OPT_C),
1093   DEF_OPT("D",                        no_mac, OPT_D),
1094   DEF_OPT("H",                        0,      OPT_H),
1095   DEF_OPT("I",                        no_dir, OPT_I),
1096   DEF_OPT("M",                        0,      OPT_M),
1097   DEF_OPT("MD",                       no_fil, OPT_MD),
1098   DEF_OPT("MG",                       0,      OPT_MG),
1099   DEF_OPT("MM",                       0,      OPT_MM),
1100   DEF_OPT("MMD",                      no_fil, OPT_MMD),
1101   DEF_OPT("P",                        0,      OPT_P),
1102   DEF_OPT("U",                        no_mac, OPT_U),
1103   /* NB: Immed arg only, and not reqd */
1104   DEF_OPT("W",                        no_arg, OPT_W),
1105   DEF_OPT("d",                        no_arg, OPT_d),
1106   DEF_OPT("fleading-underscore",      0,      OPT_fleading_underscore),
1107   DEF_OPT("fno-leading-underscore",   0,      OPT_fno_leading_underscore),
1108   DEF_OPT("fpreprocessed",            0,      OPT_fpreprocessed),
1109   DEF_OPT("fno-preprocessed",         0,      OPT_fno_preprocessed),
1110   /* NB: Immed arg only, and not reqd */
1111   DEF_OPT("g",                        no_arg, OPT_g),
1112   DEF_OPT("h",                        0,      OPT_h),
1113   DEF_OPT("idirafter",                no_dir, OPT_idirafter),
1114   DEF_OPT("imacros",                  no_fil, OPT_imacros),
1115   DEF_OPT("include",                  no_fil, OPT_include),
1116   DEF_OPT("iprefix",                  no_pth, OPT_iprefix),
1117   DEF_OPT("isystem",                  no_dir, OPT_isystem),
1118   DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix),
1119   DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore),
1120   DEF_OPT("lang-asm",                 0,      OPT_lang_asm),
1121   DEF_OPT("lang-c",                   0,      OPT_lang_c),
1122   DEF_OPT("lang-c++",                 0,      OPT_lang_cplusplus),
1123   DEF_OPT("lang-c89",                 0,      OPT_lang_c89),
1124   DEF_OPT("lang-chill",               0,      OPT_lang_chill),
1125   DEF_OPT("lang-fortran",             0,      OPT_lang_fortran),
1126   DEF_OPT("lang-objc",                0,      OPT_lang_objc),
1127   DEF_OPT("lang-objc++",              0,      OPT_lang_objcplusplus),
1128   DEF_OPT("nostdinc",                 0,      OPT_nostdinc),
1129   DEF_OPT("nostdinc++",               0,      OPT_nostdincplusplus),
1130   DEF_OPT("o",                        no_fil, OPT_o),
1131   DEF_OPT("pedantic",                 0,      OPT_pedantic),
1132   DEF_OPT("pedantic-errors",          0,      OPT_pedantic_errors),
1133   DEF_OPT("remap",                    0,      OPT_remap),
1134   DEF_OPT("std=c89",                  0,      OPT_std_c89),
1135   DEF_OPT("std=c99",                  0,      OPT_std_c99),
1136   DEF_OPT("std=c9x",                  0,      OPT_std_c9x),
1137   DEF_OPT("std=gnu89",                0,      OPT_std_gnu89),
1138   DEF_OPT("std=gnu99",                0,      OPT_std_gnu99),
1139   DEF_OPT("std=gnu9x",                0,      OPT_std_gnu9x),
1140   DEF_OPT("std=iso9899:1990",         0,      OPT_std_iso9899_1990),
1141   DEF_OPT("std=iso9899:199409",       0,      OPT_std_iso9899_199409),
1142   DEF_OPT("std=iso9899:1999",         0,      OPT_std_iso9899_1999),
1143   DEF_OPT("std=iso9899:199x",         0,      OPT_std_iso9899_199x),
1144   DEF_OPT("traditional",              0,      OPT_traditional),
1145   DEF_OPT("trigraphs",                0,      OPT_trigraphs),
1146   DEF_OPT("v",                        0,      OPT_v),
1147   DEF_OPT("w",                        0,      OPT_w)
1148 };
1149 #undef DEF_OPT
1150
1151 /* Perform a binary search to find which, if any, option the given
1152    command-line matches.  Returns its index in the option array,
1153    negative on failure.  Complications arise since some options can be
1154    suffixed with an argument, and multiple complete matches can occur,
1155    e.g. -iwithprefix and -iwithprefixbefore.  Moreover, we want to
1156    accept options beginning with -g and -W that we do not recognise,
1157    but not to swallow any subsequent command line argument; these are
1158    handled as special cases in cpp_handle_option */
1159 static int
1160 parse_option (input)
1161      const char *input;
1162 {
1163   unsigned int md, mn, mx;
1164   size_t opt_len;
1165   int comp;
1166
1167   mn = 0;
1168   mx = N_OPTS;
1169
1170   while (mx > mn)
1171     {
1172       md = (mn + mx) / 2;
1173
1174       opt_len = cl_options[md].opt_len;
1175       comp = strncmp (input, cl_options[md].opt_text, opt_len);
1176
1177       if (comp > 0)
1178         mn = md + 1;
1179       else if (comp < 0)
1180         mx = md;
1181       else
1182         {
1183           if (input[opt_len] == '\0')
1184             return md;
1185           /* We were passed more text.  If the option takes an argument,
1186              we may match a later option or we may have been passed the
1187              argument.  The longest possible option match succeeds.
1188              If the option takes no arguments we have not matched and
1189              continue the search (e.g. input="stdc++" match was "stdc") */
1190           mn = md + 1;
1191           if (cl_options[md].msg)
1192             {
1193               /* Scan forwards.  If we get an exact match, return it.
1194                  Otherwise, return the longest option-accepting match.
1195                  This loops no more than twice with current options */
1196               mx = md;
1197               for (; mn < N_OPTS; mn++)
1198                 {
1199                   opt_len = cl_options[mn].opt_len;
1200                   if (strncmp (input, cl_options[mn].opt_text, opt_len))
1201                     break;
1202                   if (input[opt_len] == '\0')
1203                     return mn;
1204                   if (cl_options[mn].msg)
1205                     mx = mn;
1206                 }
1207               return mx;
1208             }
1209         }
1210     }
1211
1212   return -1;
1213 }
1214
1215 /* Handle one command-line option in (argc, argv).
1216    Can be called multiple times, to handle multiple sets of options.
1217    Returns number of strings consumed.  */
1218
1219 static int
1220 handle_option (pfile, argc, argv)
1221      cpp_reader *pfile;
1222      int argc;
1223      char **argv;
1224 {
1225   struct cpp_options *opts = CPP_OPTIONS (pfile);
1226   int i = 0;
1227
1228   if (argv[i][0] != '-')
1229     {
1230       if (opts->out_fname != NULL)
1231         {
1232           print_help ();
1233           cpp_fatal (pfile, "Too many arguments");
1234         }
1235       else if (opts->in_fname != NULL)
1236         opts->out_fname = argv[i];
1237       else
1238         opts->in_fname = argv[i];
1239     }
1240   else
1241     {
1242       enum opt_code opt_code;
1243       int opt_index;
1244       const char *arg = 0;
1245
1246       /* Skip over '-' */
1247       opt_index = parse_option (&argv[i][1]);
1248       if (opt_index < 0)
1249         return i;
1250
1251       opt_code = cl_options[opt_index].opt_code;
1252       if (cl_options[opt_index].msg)
1253         {
1254           arg = &argv[i][cl_options[opt_index].opt_len + 1];
1255
1256           /* Yuk. Special case for -g and -W as they must not swallow
1257              up any following argument.  If this becomes common, add
1258              another field to the cl_options table */
1259           if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
1260             {
1261               arg = argv[++i];
1262               if (!arg)
1263                 {
1264                   cpp_fatal (pfile, _(cl_options[opt_index].msg), argv[i - 1]);
1265                   return argc;
1266                 }
1267             }
1268         }
1269
1270       switch (opt_code)
1271         {
1272         case N_OPTS: /* shut GCC up */
1273           break;
1274         case OPT_fleading_underscore:
1275           user_label_prefix = "_";
1276           break;
1277         case OPT_fno_leading_underscore:
1278           user_label_prefix = "";
1279           break;
1280         case OPT_fpreprocessed:
1281           opts->preprocessed = 1;
1282           break;
1283         case OPT_fno_preprocessed:
1284           opts->preprocessed = 0;
1285           break;
1286         case OPT_w:
1287           opts->inhibit_warnings = 1;
1288           break;
1289         case OPT_g:  /* Silently ignore anything but -g3 */
1290           if (!strcmp(&argv[i][2], "3"))
1291             opts->debug_output = 1;
1292           break;
1293         case OPT_h:
1294         case OPT__help:
1295           print_help ();
1296           exit (0);  /* XXX */
1297           break;
1298         case OPT__version:
1299           fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1300           exit (0);  /* XXX */
1301           break;
1302         case OPT_C:
1303           opts->discard_comments = 0;
1304           break;
1305         case OPT_P:
1306           opts->no_line_commands = 1;
1307           break;
1308         case OPT_dollar:                /* Don't include $ in identifiers.  */
1309           opts->dollars_in_ident = 0;
1310           break;
1311         case OPT_H:
1312           opts->print_include_names = 1;
1313           break;
1314         case OPT_D:
1315           new_pending_directive (opts, arg, cpp_define);
1316           break;
1317         case OPT_pedantic_errors:
1318           opts->pedantic_errors = 1;
1319           /* fall through */
1320         case OPT_pedantic:
1321           opts->pedantic = 1;
1322           break;
1323         case OPT_traditional:
1324           opts->traditional = 1;
1325           opts->cplusplus_comments = 0;
1326           opts->trigraphs = 0;
1327           opts->warn_trigraphs = 0;
1328           break;
1329         case OPT_trigraphs:
1330           opts->trigraphs = 1;
1331           break;
1332         case OPT_plus:
1333           opts->cplusplus = 1;
1334           opts->cplusplus_comments = 1;
1335           break;
1336         case OPT_remap:
1337           opts->remap = 1;
1338           break;
1339         case OPT_iprefix:
1340           opts->include_prefix = arg;
1341           opts->include_prefix_len = strlen (arg);
1342           break;
1343         case OPT_lang_c:
1344           opts->cplusplus = 0, opts->cplusplus_comments = 1;
1345           opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
1346           break;
1347         case OPT_lang_c89:
1348           opts->cplusplus = 0, opts->cplusplus_comments = 0;
1349           opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
1350           opts->trigraphs = 1;
1351           new_pending_directive (opts, "__STRICT_ANSI__", cpp_define);
1352           break;
1353         case OPT_lang_cplusplus:
1354           opts->cplusplus = 1, opts->cplusplus_comments = 1;
1355           opts->c89 = 0, opts->c99 = 0, opts->objc = 0;
1356           break;
1357         case OPT_lang_objc:
1358         case OPT_lang_objcplusplus:
1359           opts->cplusplus = opt_code == OPT_lang_objcplusplus;
1360           opts->cplusplus_comments = 1;
1361           opts->c89 = 0, opts->c99 = 0, opts->objc = 1;
1362           break;
1363         case OPT_lang_asm:
1364           opts->lang_asm = 1;
1365           break;
1366         case OPT_lang_fortran:
1367           opts->lang_fortran = 1, opts->cplusplus_comments = 0;
1368           break;
1369         case OPT_lang_chill:
1370           opts->objc = 0, opts->cplusplus = 0;
1371           opts->chill = 1, opts->traditional = 1;
1372           break;
1373         case OPT_nostdinc:
1374           /* -nostdinc causes no default include directories.
1375              You must specify all include-file directories with -I.  */
1376           opts->no_standard_includes = 1;
1377           break;
1378         case OPT_nostdincplusplus:
1379           /* -nostdinc++ causes no default C++-specific include directories. */
1380           opts->no_standard_cplusplus_includes = 1;
1381           break;
1382         case OPT_std_gnu89:
1383           opts->cplusplus = 0, opts->cplusplus_comments = 1;
1384           opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
1385           break;
1386         case OPT_std_gnu9x:
1387         case OPT_std_gnu99:
1388           opts->cplusplus = 0, opts->cplusplus_comments = 1;
1389           opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
1390           new_pending_directive (opts, "__STDC_VERSION__=199901L", cpp_define);
1391           break;
1392         case OPT_std_iso9899_199409:
1393           new_pending_directive (opts, "__STDC_VERSION__=199409L", cpp_define);
1394           /* Fall through */
1395         case OPT_std_iso9899_1990:
1396         case OPT_std_c89:
1397           opts->cplusplus = 0, opts->cplusplus_comments = 0;
1398           opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
1399           opts->trigraphs = 1;
1400           new_pending_directive (opts, "__STRICT_ANSI__", cpp_define);
1401           break;
1402         case OPT_std_iso9899_199x:
1403         case OPT_std_iso9899_1999:
1404         case OPT_std_c9x:
1405         case OPT_std_c99:
1406           opts->cplusplus = 0, opts->cplusplus_comments = 1;
1407           opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
1408           opts->trigraphs = 1;
1409           new_pending_directive (opts, "__STRICT_ANSI__", cpp_define);
1410           new_pending_directive (opts, "__STDC_VERSION__=199901L", cpp_define);
1411           break;
1412         case OPT_o:
1413           if (opts->out_fname != NULL)
1414             {
1415               cpp_fatal (pfile, "Output filename specified twice");
1416               return argc;
1417             }
1418           opts->out_fname = arg;
1419           if (!strcmp (opts->out_fname, "-"))
1420             opts->out_fname = "";
1421           break;
1422         case OPT_v:
1423           fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1424 #ifdef TARGET_VERSION
1425           TARGET_VERSION;
1426 #endif
1427           fputc ('\n', stderr);
1428           opts->verbose = 1;
1429           break;
1430         case OPT_stdin_stdout:
1431           /* JF handle '-' as file name meaning stdin or stdout */
1432           if (opts->in_fname == NULL)
1433             opts->in_fname = "";
1434           else if (opts->out_fname == NULL)
1435             opts->out_fname = "";
1436           break;
1437         case OPT_d:
1438           /* Args to -d specify what parts of macros to dump.
1439              Silently ignore unrecognised options; they may
1440              be aimed at the compiler proper. */
1441           {
1442             char c;
1443
1444             while ((c = *arg++) != '\0')
1445               switch (c)
1446                 {
1447                 case 'M':
1448                   opts->dump_macros = dump_only;
1449                   opts->no_output = 1;
1450                   break;
1451                 case 'N':
1452                   opts->dump_macros = dump_names;
1453                   break;
1454                 case 'D':
1455                   opts->dump_macros = dump_definitions;
1456                   break;
1457                 case 'I':
1458                   opts->dump_includes = 1;
1459                   break;
1460                 }
1461           }
1462           break;
1463           /* The style of the choices here is a bit mixed.
1464              The chosen scheme is a hybrid of keeping all options in one string
1465              and specifying each option in a separate argument:
1466              -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
1467              -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1468              -M[M][G][D file].  This is awkward to handle in specs, and is not
1469              as extensible.  */
1470           /* ??? -MG must be specified in addition to one of -M or -MM.
1471              This can be relaxed in the future without breaking anything.
1472              The converse isn't true.  */
1473
1474           /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
1475         case OPT_MG:
1476           opts->print_deps_missing_files = 1;
1477           break;
1478         case OPT_M:
1479         case OPT_MD:
1480         case OPT_MM:
1481         case OPT_MMD:
1482           if (opt_code == OPT_M || opt_code == OPT_MD)
1483             opts->print_deps = 2;
1484           else
1485             opts->print_deps = 1;
1486
1487           /* For -MD and -MMD options, write deps on file named by next arg */
1488           /* For -M and -MM, write deps on standard output
1489              and suppress the usual output.  */
1490           if (opt_code == OPT_MD || opt_code == OPT_MMD)
1491               opts->deps_file = arg;
1492           else
1493               opts->no_output = 1;
1494           break;
1495         case OPT_A:
1496           if (arg[0] == '-')
1497             {
1498               /* -A with an argument beginning with '-' acts as
1499                  #unassert on whatever immediately follows the '-'.
1500                  If "-" is the whole argument, we eliminate all
1501                  predefined macros and assertions, including those
1502                  that were specified earlier on the command line.
1503                  That way we can get rid of any that were passed
1504                  automatically in from GCC.  */
1505
1506               if (arg[1] == '\0')
1507                 {
1508                   struct pending_option *o1, *o2;
1509
1510                   o1 = opts->pending->directive_head;
1511                   while (o1)
1512                     {
1513                       o2 = o1->next;
1514                       free (o1);
1515                       o1 = o2;
1516                     }
1517                   opts->pending->directive_head = NULL;
1518                   opts->pending->directive_tail = NULL;
1519                 }
1520               else
1521                 new_pending_directive (opts, arg + 1, cpp_unassert);
1522             }
1523           else
1524             new_pending_directive (opts, arg, cpp_assert);
1525           break;
1526         case OPT_U:
1527           new_pending_directive (opts, arg, cpp_undef);
1528           break;
1529         case OPT_I:           /* Add directory to path for includes.  */
1530           if (!strcmp (arg, "-"))
1531             {
1532               /* -I- means:
1533                  Use the preceding -I directories for #include "..."
1534                  but not #include <...>.
1535                  Don't search the directory of the present file
1536                  for #include "...".  (Note that -I. -I- is not the same as
1537                  the default setup; -I. uses the compiler's working dir.)  */
1538               if (! opts->ignore_srcdir)
1539                 {
1540                   opts->ignore_srcdir = 1;
1541                   opts->pending->quote_head = opts->pending->brack_head;
1542                   opts->pending->quote_tail = opts->pending->brack_tail;
1543                   opts->pending->brack_head = 0;
1544                   opts->pending->brack_tail = 0;
1545                 }
1546               else
1547                 {
1548                   cpp_fatal (pfile, "-I- specified twice");
1549                   return argc;
1550                 }
1551             }
1552           else
1553             append_include_chain (pfile, opts->pending,
1554                                   xstrdup (arg), BRACKET, 0);
1555           break;
1556         case OPT_isystem:
1557           /* Add directory to beginning of system include path, as a system
1558              include directory. */
1559           append_include_chain (pfile, opts->pending,
1560                                 xstrdup (arg), SYSTEM, 0);
1561           break;
1562         case OPT_include:
1563           {
1564             struct pending_option *o = (struct pending_option *)
1565               xmalloc (sizeof (struct pending_option));
1566             o->arg = arg;
1567
1568             /* This list has to be built in reverse order so that
1569                when cpp_start_read pushes all the -include files onto
1570                the buffer stack, they will be scanned in forward order.  */
1571             o->next = opts->pending->include_head;
1572             opts->pending->include_head = o;
1573           }
1574           break;
1575         case OPT_imacros:
1576           {
1577             struct pending_option *o = (struct pending_option *)
1578               xmalloc (sizeof (struct pending_option));
1579             o->arg = arg;
1580             o->next = NULL;
1581
1582             APPEND (opts->pending, imacros, o);
1583           }
1584           break;
1585         case OPT_iwithprefix:
1586           /* Add directory to end of path for includes,
1587              with the default prefix at the front of its name.  */
1588           /* fall through */
1589         case OPT_iwithprefixbefore:
1590           /* Add directory to main path for includes,
1591              with the default prefix at the front of its name.  */
1592           {
1593             char *fname;
1594             int len;
1595
1596             len = strlen (arg);
1597
1598             if (opts->include_prefix != 0)
1599               {
1600                 fname = xmalloc (opts->include_prefix_len + len + 1);
1601                 memcpy (fname, opts->include_prefix, opts->include_prefix_len);
1602                 memcpy (fname + opts->include_prefix_len, arg, len + 1);
1603               }
1604             else
1605               {
1606                 fname = xmalloc (sizeof GCC_INCLUDE_DIR - 8 + len);
1607                 memcpy (fname, GCC_INCLUDE_DIR, sizeof GCC_INCLUDE_DIR - 9);
1608                 memcpy (fname + sizeof GCC_INCLUDE_DIR - 9, arg, len + 1);
1609               }
1610
1611             append_include_chain (pfile, opts->pending, fname,
1612                           opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1613           }
1614           break;
1615         case OPT_idirafter:
1616           /* Add directory to end of path for includes.  */
1617           append_include_chain (pfile, opts->pending,
1618                                 xstrdup (arg), AFTER, 0);
1619           break;
1620         case OPT_W:
1621           /* Silently ignore unrecognised options */
1622           if (!strcmp (argv[i], "-Wall"))
1623             {
1624               opts->warn_trigraphs = 1;
1625               opts->warn_comments = 1;
1626             }
1627           else if (!strcmp (argv[i], "-Wtraditional"))
1628             opts->warn_stringify = 1;
1629           else if (!strcmp (argv[i], "-Wtrigraphs"))
1630             opts->warn_trigraphs = 1;
1631           else if (!strcmp (argv[i], "-Wcomment"))
1632             opts->warn_comments = 1;
1633           else if (!strcmp (argv[i], "-Wcomments"))
1634             opts->warn_comments = 1;
1635           else if (!strcmp (argv[i], "-Wundef"))
1636             opts->warn_undef = 1;
1637           else if (!strcmp (argv[i], "-Wimport"))
1638             opts->warn_import = 1;
1639           else if (!strcmp (argv[i], "-Werror"))
1640             opts->warnings_are_errors = 1;
1641           else if (!strcmp (argv[i], "-Wno-traditional"))
1642             opts->warn_stringify = 0;
1643           else if (!strcmp (argv[i], "-Wno-trigraphs"))
1644             opts->warn_trigraphs = 0;
1645           else if (!strcmp (argv[i], "-Wno-comment"))
1646             opts->warn_comments = 0;
1647           else if (!strcmp (argv[i], "-Wno-comments"))
1648             opts->warn_comments = 0;
1649           else if (!strcmp (argv[i], "-Wno-undef"))
1650             opts->warn_undef = 0;
1651           else if (!strcmp (argv[i], "-Wno-import"))
1652             opts->warn_import = 0;
1653           else if (!strcmp (argv[i], "-Wno-error"))
1654             opts->warnings_are_errors = 0;
1655           break;
1656         }
1657     }
1658   return i + 1;
1659 }
1660
1661 #ifdef HOST_EBCDIC
1662 static int
1663 opt_comp (const void *p1, const void *p2)
1664 {
1665   return strcmp (((struct cl_option *)p1)->opt_text,
1666                  ((struct cl_option *)p2)->opt_text);
1667 }
1668 #endif
1669
1670 /* Handle command-line options in (argc, argv).
1671    Can be called multiple times, to handle multiple sets of options.
1672    Returns if an unrecognized option is seen.
1673    Returns number of strings consumed.  */
1674 int
1675 cpp_handle_options (pfile, argc, argv)
1676      cpp_reader *pfile;
1677      int argc;
1678      char **argv;
1679 {
1680   int i;
1681   int strings_processed;
1682
1683 #ifdef HOST_EBCDIC
1684   static int opts_sorted = 0;
1685
1686   if (!opts_sorted)
1687     {
1688       opts_sorted = 1;
1689       /* For non-ASCII hosts, the array needs to be sorted at runtime */
1690       qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
1691     }
1692 #endif
1693
1694   for (i = 0; i < argc; i += strings_processed)
1695     {
1696       strings_processed = handle_option (pfile, argc - i, argv + i);
1697       if (strings_processed == 0)
1698         break;
1699     }
1700   return i;
1701 }
1702
1703 static void
1704 print_help ()
1705 {
1706   fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1707   fputs (_("\
1708 Switches:\n\
1709   -include <file>           Include the contents of <file> before other files\n\
1710   -imacros <file>           Accept definition of macros in <file>\n\
1711   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1712   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1713   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1714   -isystem <dir>            Add <dir> to the start of the system include path\n\
1715   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1716   -I <dir>                  Add <dir> to the end of the main include path\n\
1717   -I-                       Fine-grained include path control; see info docs\n\
1718   -nostdinc                 Do not search system include directories\n\
1719                              (dirs specified with -isystem will still be used)\n\
1720   -nostdinc++               Do not search system include directories for C++\n\
1721   -o <file>                 Put output into <file>\n\
1722   -pedantic                 Issue all warnings demanded by strict ANSI C\n\
1723   -pedantic-errors          Issue -pedantic warnings as errors instead\n\
1724   -traditional              Follow K&R pre-processor behaviour\n\
1725   -trigraphs                Support ANSI C trigraphs\n\
1726   -lang-c                   Assume that the input sources are in C\n\
1727   -lang-c89                 Assume that the input sources are in C89\n\
1728   -lang-c++                 Assume that the input sources are in C++\n\
1729   -lang-objc                Assume that the input sources are in ObjectiveC\n\
1730   -lang-objc++              Assume that the input sources are in ObjectiveC++\n\
1731   -lang-asm                 Assume that the input sources are in assembler\n\
1732   -lang-fortran             Assume that the input sources are in Fortran\n\
1733   -lang-chill               Assume that the input sources are in Chill\n\
1734   -std=<std name>           Specify the conformance standard; one of:\n\
1735                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1736                             iso9899:199409, iso9899:1999\n\
1737   -+                        Allow parsing of C++ style features\n\
1738   -w                        Inhibit warning messages\n\
1739   -Wtrigraphs               Warn if trigraphs are encountered\n\
1740   -Wno-trigraphs            Do not warn about trigraphs\n\
1741   -Wcomment{s}              Warn if one comment starts inside another\n\
1742   -Wno-comment{s}           Do not warn about comments\n\
1743   -Wtraditional             Warn if a macro argument is/would be turned into\n\
1744                              a string if -traditional is specified\n\
1745   -Wno-traditional          Do not warn about stringification\n\
1746   -Wundef                   Warn if an undefined macro is used by #if\n\
1747   -Wno-undef                Do not warn about testing undefined macros\n\
1748   -Wimport                  Warn about the use of the #import directive\n\
1749   -Wno-import               Do not warn about the use of #import\n\
1750   -Werror                   Treat all warnings as errors\n\
1751   -Wno-error                Do not treat warnings as errors\n\
1752   -Wall                     Enable all preprocessor warnings\n\
1753   -M                        Generate make dependencies\n\
1754   -MM                       As -M, but ignore system header files\n\
1755   -MD                       As -M, but put output in a .d file\n\
1756   -MMD                      As -MD, but ignore system header files\n\
1757   -MG                       Treat missing header file as generated files\n\
1758   -g3                       Include #define and #undef directives in the output\n\
1759   -D<macro>                 Define a <macro> with string '1' as its value\n\
1760   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1761   -A<question> (<answer>)   Assert the <answer> to <question>\n\
1762   -A-<question> (<answer>)  Disable the <answer> to <question>\n\
1763   -U<macro>                 Undefine <macro> \n\
1764   -v                        Display the version number\n\
1765   -H                        Print the name of header files as they are used\n\
1766   -C                        Do not discard comments\n\
1767   -dM                       Display a list of macro definitions active at end\n\
1768   -dD                       Preserve macro definitions in output\n\
1769   -dN                       As -dD except that only the names are preserved\n\
1770   -dI                       Include #include directives in the output\n\
1771   -P                        Do not generate #line directives\n\
1772   -$                        Do not allow '$' in identifiers\n\
1773   -remap                    Remap file names when including files.\n\
1774   --version                 Display version information\n\
1775   -h or --help              Display this information\n\
1776 "), stdout);
1777 }