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