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