gcc/cppinit.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002 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 "coretypes.h"
  25 #include "tm.h"
  26 #include "cpplib.h"
  27 #include "cpphash.h"
  28 #include "prefix.h"
  29 #include "intl.h"
  30 #include "mkdeps.h"
  31 #include "cppdefault.h"
  32
  33 /* Windows does not natively support inodes, and neither does MSDOS.
  34    Cygwin's emulation can generate non-unique inodes, so don't use it.
  35    VMS has non-numeric inodes.  */
  36 #ifdef VMS
  37 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
  38 # define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
  39 #else
  40 # if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
  41 #  define INO_T_EQ(A, B) 0
  42 # else
  43 #  define INO_T_EQ(A, B) ((A) == (B))
  44 # endif
  45 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
  46 #endif
  47
  48 /* Internal structures and prototypes.  */
  49
  50 /* A `struct pending_option' remembers one -D, -A, -U, -include, or
  51    -imacros switch.  */
  52 typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
  53 struct pending_option
  54 {
  55   struct pending_option *next;
  56   const char *arg;
  57   cl_directive_handler handler;
  58 };
  59
  60 /* The `pending' structure accumulates all the options that are not
  61    actually processed until we hit cpp_read_main_file.  It consists of
  62    several lists, one for each type of option.  We keep both head and
  63    tail pointers for quick insertion.  */
  64 struct cpp_pending
  65 {
  66   struct pending_option *directive_head, *directive_tail;
  67
  68   struct search_path *quote_head, *quote_tail;
  69   struct search_path *brack_head, *brack_tail;
  70   struct search_path *systm_head, *systm_tail;
  71   struct search_path *after_head, *after_tail;
  72
  73   struct pending_option *imacros_head, *imacros_tail;
  74   struct pending_option *include_head, *include_tail;
  75 };
  76
  77 #ifdef __STDC__
  78 #define APPEND(pend, list, elt) \
  79   do {  if (!(pend)->list##_head) (pend)->list##_head = (elt); \
  80         else (pend)->list##_tail->next = (elt); \
  81         (pend)->list##_tail = (elt); \
  82   } while (0)
  83 #else
  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 #endif
  90
  91 static void path_include                PARAMS ((cpp_reader *,
  92                                                  const char *, int));
  93 static void init_library                PARAMS ((void));
  94 static void init_builtins               PARAMS ((cpp_reader *));
  95 static void mark_named_operators        PARAMS ((cpp_reader *));
  96 static void append_include_chain        PARAMS ((cpp_reader *,
  97                                                  char *, int, int));
  98 static struct search_path * remove_dup_dir      PARAMS ((cpp_reader *,
  99                                                  struct search_path *,
 100                                                  struct search_path **));
 101 static struct search_path * remove_dup_nonsys_dirs PARAMS ((cpp_reader *,
 102                                                  struct search_path **,
 103                                                  struct search_path *));
 104 static struct search_path * remove_dup_dirs PARAMS ((cpp_reader *,
 105                                                  struct search_path **));
 106 static void merge_include_chains        PARAMS ((cpp_reader *));
 107 static bool push_include                PARAMS ((cpp_reader *,
 108                                                  struct pending_option *));
 109 static void free_chain                  PARAMS ((struct pending_option *));
 110 static void init_standard_includes      PARAMS ((cpp_reader *));
 111 static void read_original_filename      PARAMS ((cpp_reader *));
 112 static void new_pending_directive       PARAMS ((struct cpp_pending *,
 113                                                  const char *,
 114                                                  cl_directive_handler));
 115 static int parse_option                 PARAMS ((const char *));
 116 static void post_options                PARAMS ((cpp_reader *));
 117
 118 /* Fourth argument to append_include_chain: chain to use.
 119    Note it's never asked to append to the quote chain.  */
 120 enum { BRACKET = 0, 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_trigraph_map()  /* Nothing.  */
 128 #define TRIGRAPH_MAP \
 129 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
 130
 131 #define END };
 132 #define s(p, v) [p] = v,
 133
 134 #else
 135
 136 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
 137  static void init_trigraph_map PARAMS ((void)) { \
 138  unsigned char *x = _cpp_trigraph_map;
 139
 140 #define END }
 141 #define s(p, v) x[p] = v;
 142
 143 #endif
 144
 145 TRIGRAPH_MAP
 146   s('=', '#')   s(')', ']')     s('!', '|')
 147   s('(', '[')   s('\'', '^')    s('>', '}')
 148   s('/', '\\')  s('<', '{')     s('-', '~')
 149 END
 150
 151 #undef s
 152 #undef END
 153 #undef TRIGRAPH_MAP
 154
 155 /* Read ENV_VAR for a colon-separated list of file names; and
 156    add all the names to the search path for include files.  */
 157 static void
 158 path_include (pfile, env_var, path)
 159      cpp_reader *pfile;
 160      const char *env_var;
 161      int path;
 162 {
 163   char *p, *q, *name;
 164
 165   GET_ENVIRONMENT (q, env_var);
 166   if (!q)
 167     return;
 168
 169   for (p = q; *q; p = q + 1)
 170     {
 171       /* Find the end of this name.  */
 172       q = p;
 173       while (*q != 0 && *q != PATH_SEPARATOR) q++;
 174       if (q == p)
 175         {
 176           /* An empty name in the path stands for the current directory.  */
 177           name = (char *) xmalloc (2);
 178           name[0] = '.';
 179           name[1] = 0;
 180         }
 181       else
 182         {
 183           /* Otherwise use the directory that is named.  */
 184           name = (char *) xmalloc (q - p + 1);
 185           memcpy (name, p, q - p);
 186           name[q - p] = 0;
 187         }
 188
 189       append_include_chain (pfile, name, path, path == SYSTEM);
 190     }
 191 }
 192
 193 /* Append DIR to include path PATH.  DIR must be allocated on the
 194    heap; this routine takes responsibility for freeing it.  CXX_AWARE
 195    is nonzero if the header contains extern "C" guards for C++,
 196    otherwise it is zero.  */
 197 static void
 198 append_include_chain (pfile, dir, path, cxx_aware)
 199      cpp_reader *pfile;
 200      char *dir;
 201      int path;
 202      int cxx_aware;
 203 {
 204   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 205   struct search_path *new;
 206   struct stat st;
 207   unsigned int len;
 208
 209   if (*dir == '\0')
 210     {
 211       free (dir);
 212       dir = xstrdup (".");
 213     }
 214   _cpp_simplify_pathname (dir);
 215
 216   if (stat (dir, &st))
 217     {
 218       /* Dirs that don't exist are silently ignored.  */
 219       if (errno != ENOENT)
 220         cpp_errno (pfile, DL_ERROR, dir);
 221       else if (CPP_OPTION (pfile, verbose))
 222         fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
 223       free (dir);
 224       return;
 225     }
 226
 227   if (!S_ISDIR (st.st_mode))
 228     {
 229       cpp_error_with_line (pfile, DL_ERROR, 0, 0, "%s: Not a directory", dir);
 230       free (dir);
 231       return;
 232     }
 233
 234   len = strlen (dir);
 235   if (len > pfile->max_include_len)
 236     pfile->max_include_len = len;
 237
 238   new = (struct search_path *) xmalloc (sizeof (struct search_path));
 239   new->name = dir;
 240   new->len = len;
 241   INO_T_COPY (new->ino, st.st_ino);
 242   new->dev  = st.st_dev;
 243   /* Both systm and after include file lists should be treated as system
 244      include files since these two lists are really just a concatenation
 245      of one "system" list.  */
 246   if (path == SYSTEM || path == AFTER)
 247     new->sysp = cxx_aware ? 1 : 2;
 248   else
 249     new->sysp = 0;
 250   new->name_map = NULL;
 251   new->next = NULL;
 252
 253   switch (path)
 254     {
 255     case BRACKET:       APPEND (pend, brack, new); break;
 256     case SYSTEM:        APPEND (pend, systm, new); break;
 257     case AFTER:         APPEND (pend, after, new); break;
 258     }
 259 }
 260
 261 /* Handle a duplicated include path.  PREV is the link in the chain
 262    before the duplicate, or NULL if the duplicate is at the head of
 263    the chain.  The duplicate is removed from the chain and freed.
 264    Returns PREV.  */
 265 static struct search_path *
 266 remove_dup_dir (pfile, prev, head_ptr)
 267      cpp_reader *pfile;
 268      struct search_path *prev;
 269      struct search_path **head_ptr;
 270 {
 271   struct search_path *cur;
 272
 273   if (prev != NULL)
 274     {
 275       cur = prev->next;
 276       prev->next = cur->next;
 277     }
 278   else
 279     {
 280       cur = *head_ptr;
 281       *head_ptr = cur->next;
 282     }
 283
 284   if (CPP_OPTION (pfile, verbose))
 285     fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
 286
 287   free ((PTR) cur->name);
 288   free (cur);
 289
 290   return prev;
 291 }
 292
 293 /* Remove duplicate non-system directories for which there is an equivalent
 294    system directory latter in the chain.  The range for removal is between
 295    *HEAD_PTR and END.  Returns the directory before END, or NULL if none.
 296    This algorithm is quadratic in the number system directories, which is
 297    acceptable since there aren't usually that many of them.  */
 298 static struct search_path *
 299 remove_dup_nonsys_dirs (pfile, head_ptr, end)
 300      cpp_reader *pfile;
 301      struct search_path **head_ptr;
 302      struct search_path *end;
 303 {
 304   int sysdir = 0;
 305   struct search_path *prev = NULL, *cur, *other;
 306
 307   for (cur = *head_ptr; cur; cur = cur->next)
 308     {
 309       if (cur->sysp)
 310         {
 311           sysdir = 1;
 312           for (other = *head_ptr, prev = NULL;
 313                other != end;
 314                other = other ? other->next : *head_ptr)
 315             {
 316               if (!other->sysp
 317                   && INO_T_EQ (cur->ino, other->ino)
 318                   && cur->dev == other->dev)
 319                 {
 320                   other = remove_dup_dir (pfile, prev, head_ptr);
 321                   if (CPP_OPTION (pfile, verbose))
 322                     fprintf (stderr,
 323   _("  as it is a non-system directory that duplicates a system directory\n"));
 324                 }
 325               prev = other;
 326             }
 327         }
 328     }
 329
 330   if (!sysdir)
 331     for (cur = *head_ptr; cur != end; cur = cur->next)
 332       prev = cur;
 333
 334   return prev;
 335 }
 336
 337 /* Remove duplicate directories from a chain.  Returns the tail of the
 338    chain, or NULL if the chain is empty.  This algorithm is quadratic
 339    in the number of -I switches, which is acceptable since there
 340    aren't usually that many of them.  */
 341 static struct search_path *
 342 remove_dup_dirs (pfile, head_ptr)
 343      cpp_reader *pfile;
 344      struct search_path **head_ptr;
 345 {
 346   struct search_path *prev = NULL, *cur, *other;
 347
 348   for (cur = *head_ptr; cur; cur = cur->next)
 349     {
 350       for (other = *head_ptr; other != cur; other = other->next)
 351         if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
 352           {
 353             cur = remove_dup_dir (pfile, prev, head_ptr);
 354             break;
 355           }
 356       prev = cur;
 357     }
 358
 359   return prev;
 360 }
 361
 362 /* Merge the four include chains together in the order quote, bracket,
 363    system, after.  Remove duplicate dirs (as determined by
 364    INO_T_EQ()).  The system_include and after_include chains are never
 365    referred to again after this function; all access is through the
 366    bracket_include path.  */
 367 static void
 368 merge_include_chains (pfile)
 369      cpp_reader *pfile;
 370 {
 371   struct search_path *quote, *brack, *systm, *qtail;
 372
 373   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 374
 375   quote = pend->quote_head;
 376   brack = pend->brack_head;
 377   systm = pend->systm_head;
 378   qtail = pend->quote_tail;
 379
 380   /* Paste together bracket, system, and after include chains.  */
 381   if (systm)
 382     pend->systm_tail->next = pend->after_head;
 383   else
 384     systm = pend->after_head;
 385
 386   if (brack)
 387     pend->brack_tail->next = systm;
 388   else
 389     brack = systm;
 390
 391   /* This is a bit tricky.  First we drop non-system dupes of system
 392      directories from the merged bracket-include list.  Next we drop
 393      dupes from the bracket and quote include lists.  Then we drop
 394      non-system dupes from the merged quote-include list.  Finally,
 395      if qtail and brack are the same directory, we cut out brack and
 396      move brack up to point to qtail.
 397
 398      We can't just merge the lists and then uniquify them because
 399      then we may lose directories from the <> search path that should
 400      be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux.  It is however
 401      safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
 402      -Ibar -I- -Ifoo -Iquux.  */
 403
 404   remove_dup_nonsys_dirs (pfile, &brack, systm);
 405   remove_dup_dirs (pfile, &brack);
 406
 407   if (quote)
 408     {
 409       qtail = remove_dup_dirs (pfile, &quote);
 410       qtail->next = brack;
 411
 412       qtail = remove_dup_nonsys_dirs (pfile, &quote, brack);
 413
 414       /* If brack == qtail, remove brack as it's simpler.  */
 415       if (qtail && brack && INO_T_EQ (qtail->ino, brack->ino)
 416           && qtail->dev == brack->dev)
 417         brack = remove_dup_dir (pfile, qtail, &quote);
 418     }
 419   else
 420     quote = brack;
 421
 422   CPP_OPTION (pfile, quote_include) = quote;
 423   CPP_OPTION (pfile, bracket_include) = brack;
 424 }
 425
 426 /* A set of booleans indicating what CPP features each source language
 427    requires.  */
 428 struct lang_flags
 429 {
 430   char c99;
 431   char cplusplus;
 432   char extended_numbers;
 433   char std;
 434   char dollars_in_ident;
 435   char cplusplus_comments;
 436   char digraphs;
 437 };
 438
 439 /* ??? Enable $ in identifiers in assembly? */
 440 static const struct lang_flags lang_defaults[] =
 441 { /*              c99 c++ xnum std dollar c++comm digr  */
 442   /* GNUC89 */  { 0,  0,  1,   0,   1,     1,      1     },
 443   /* GNUC99 */  { 1,  0,  1,   0,   1,     1,      1     },
 444   /* STDC89 */  { 0,  0,  0,   1,   0,     0,      0     },
 445   /* STDC94 */  { 0,  0,  0,   1,   0,     0,      1     },
 446   /* STDC99 */  { 1,  0,  1,   1,   0,     1,      1     },
 447   /* GNUCXX */  { 0,  1,  1,   0,   1,     1,      1     },
 448   /* CXX98  */  { 0,  1,  1,   1,   0,     1,      1     },
 449   /* ASM    */  { 0,  0,  1,   0,   0,     1,      0     }
 450 };
 451
 452 /* Sets internal flags correctly for a given language.  */
 453 void
 454 cpp_set_lang (pfile, lang)
 455      cpp_reader *pfile;
 456      enum c_lang lang;
 457 {
 458   const struct lang_flags *l = &lang_defaults[(int) lang];
 459
 460   CPP_OPTION (pfile, lang) = lang;
 461
 462   CPP_OPTION (pfile, c99)                = l->c99;
 463   CPP_OPTION (pfile, cplusplus)          = l->cplusplus;
 464   CPP_OPTION (pfile, extended_numbers)   = l->extended_numbers;
 465   CPP_OPTION (pfile, std)                = l->std;
 466   CPP_OPTION (pfile, trigraphs)          = l->std;
 467   CPP_OPTION (pfile, dollars_in_ident)   = l->dollars_in_ident;
 468   CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
 469   CPP_OPTION (pfile, digraphs)           = l->digraphs;
 470 }
 471
 472 #ifdef HOST_EBCDIC
 473 static int opt_comp PARAMS ((const void *, const void *));
 474
 475 /* Run-time sorting of options array.  */
 476 static int
 477 opt_comp (p1, p2)
 478      const void *p1, *p2;
 479 {
 480   return strcmp (((struct cl_option *) p1)->opt_text,
 481                  ((struct cl_option *) p2)->opt_text);
 482 }
 483 #endif
 484
 485 /* init initializes library global state.  It might not need to
 486    do anything depending on the platform and compiler.  */
 487 static void
 488 init_library ()
 489 {
 490   static int initialized = 0;
 491
 492   if (! initialized)
 493     {
 494       initialized = 1;
 495
 496 #ifdef HOST_EBCDIC
 497       /* For non-ASCII hosts, the cl_options array needs to be sorted at
 498          runtime.  */
 499       qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
 500 #endif
 501
 502       /* Set up the trigraph map.  This doesn't need to do anything if
 503          we were compiled with a compiler that supports C99 designated
 504          initializers.  */
 505       init_trigraph_map ();
 506     }
 507 }
 508
 509 /* Initialize a cpp_reader structure.  */
 510 cpp_reader *
 511 cpp_create_reader (lang)
 512      enum c_lang lang;
 513 {
 514   cpp_reader *pfile;
 515
 516   /* Initialize this instance of the library if it hasn't been already.  */
 517   init_library ();
 518
 519   pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
 520
 521   cpp_set_lang (pfile, lang);
 522   CPP_OPTION (pfile, warn_import) = 1;
 523   CPP_OPTION (pfile, warn_multichar) = 1;
 524   CPP_OPTION (pfile, discard_comments) = 1;
 525   CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
 526   CPP_OPTION (pfile, show_column) = 1;
 527   CPP_OPTION (pfile, tabstop) = 8;
 528   CPP_OPTION (pfile, operator_names) = 1;
 529   CPP_OPTION (pfile, warn_endif_labels) = 1;
 530   CPP_OPTION (pfile, warn_deprecated) = 1;
 531   CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
 532   CPP_OPTION (pfile, sysroot) = cpp_SYSROOT;
 533
 534   CPP_OPTION (pfile, pending) =
 535     (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
 536
 537   /* Default CPP arithmetic to something sensible for the host for the
 538      benefit of dumb users like fix-header.  */
 539   CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
 540   CPP_OPTION (pfile, char_precision) = CHAR_BIT;
 541   CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
 542   CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
 543   CPP_OPTION (pfile, unsigned_char) = 0;
 544   CPP_OPTION (pfile, unsigned_wchar) = 1;
 545
 546   /* Initialize the line map.  Start at logical line 1, so we can use
 547      a line number of zero for special states.  */
 548   init_line_maps (&pfile->line_maps);
 549   pfile->line = 1;
 550
 551   /* Initialize lexer state.  */
 552   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 553
 554   /* Set up static tokens.  */
 555   pfile->avoid_paste.type = CPP_PADDING;
 556   pfile->avoid_paste.val.source = NULL;
 557   pfile->eof.type = CPP_EOF;
 558   pfile->eof.flags = 0;
 559
 560   /* Create a token buffer for the lexer.  */
 561   _cpp_init_tokenrun (&pfile->base_run, 250);
 562   pfile->cur_run = &pfile->base_run;
 563   pfile->cur_token = pfile->base_run.base;
 564
 565   /* Initialize the base context.  */
 566   pfile->context = &pfile->base_context;
 567   pfile->base_context.macro = 0;
 568   pfile->base_context.prev = pfile->base_context.next = 0;
 569
 570   /* Aligned and unaligned storage.  */
 571   pfile->a_buff = _cpp_get_buff (pfile, 0);
 572   pfile->u_buff = _cpp_get_buff (pfile, 0);
 573
 574   /* The expression parser stack.  */
 575   _cpp_expand_op_stack (pfile);
 576
 577   /* Initialize the buffer obstack.  */
 578   gcc_obstack_init (&pfile->buffer_ob);
 579
 580   _cpp_init_includes (pfile);
 581
 582   return pfile;
 583 }
 584
 585 /* Free resources used by PFILE.  Accessing PFILE after this function
 586    returns leads to undefined behavior.  Returns the error count.  */
 587 void
 588 cpp_destroy (pfile)
 589      cpp_reader *pfile;
 590 {
 591   struct search_path *dir, *dirn;
 592   cpp_context *context, *contextn;
 593   tokenrun *run, *runn;
 594
 595   free_chain (CPP_OPTION (pfile, pending)->include_head);
 596   free (CPP_OPTION (pfile, pending));
 597   free (pfile->op_stack);
 598
 599   while (CPP_BUFFER (pfile) != NULL)
 600     _cpp_pop_buffer (pfile);
 601
 602   if (pfile->out.base)
 603     free (pfile->out.base);
 604
 605   if (pfile->macro_buffer)
 606     {
 607       free ((PTR) pfile->macro_buffer);
 608       pfile->macro_buffer = NULL;
 609       pfile->macro_buffer_len = 0;
 610     }
 611
 612   if (pfile->deps)
 613     deps_free (pfile->deps);
 614   obstack_free (&pfile->buffer_ob, 0);
 615
 616   _cpp_destroy_hashtable (pfile);
 617   _cpp_cleanup_includes (pfile);
 618
 619   _cpp_free_buff (pfile->a_buff);
 620   _cpp_free_buff (pfile->u_buff);
 621   _cpp_free_buff (pfile->free_buffs);
 622
 623   for (run = &pfile->base_run; run; run = runn)
 624     {
 625       runn = run->next;
 626       free (run->base);
 627       if (run != &pfile->base_run)
 628         free (run);
 629     }
 630
 631   for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
 632     {
 633       dirn = dir->next;
 634       free ((PTR) dir->name);
 635       free (dir);
 636     }
 637
 638   for (context = pfile->base_context.next; context; context = contextn)
 639     {
 640       contextn = context->next;
 641       free (context);
 642     }
 643
 644   free_line_maps (&pfile->line_maps);
 645   free (pfile);
 646 }
 647
 648 /* This structure defines one built-in identifier.  A node will be
 649    entered in the hash table under the name NAME, with value VALUE.
 650
 651    There are two tables of these.  builtin_array holds all the
 652    "builtin" macros: these are handled by builtin_macro() in
 653    cppmacro.c.  Builtin is somewhat of a misnomer -- the property of
 654    interest is that these macros require special code to compute their
 655    expansions.  The value is a "builtin_type" enumerator.
 656
 657    operator_array holds the C++ named operators.  These are keywords
 658    which act as aliases for punctuators.  In C++, they cannot be
 659    altered through #define, and #if recognizes them as operators.  In
 660    C, these are not entered into the hash table at all (but see
 661    <iso646.h>).  The value is a token-type enumerator.  */
 662 struct builtin
 663 {
 664   const uchar *name;
 665   unsigned short len;
 666   unsigned short value;
 667 };
 668
 669 #define B(n, t)    { DSC(n), t }
 670 static const struct builtin builtin_array[] =
 671 {
 672   B("__TIME__",          BT_TIME),
 673   B("__DATE__",          BT_DATE),
 674   B("__FILE__",          BT_FILE),
 675   B("__BASE_FILE__",     BT_BASE_FILE),
 676   B("__LINE__",          BT_SPECLINE),
 677   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
 678   /* Keep builtins not used for -traditional-cpp at the end, and
 679      update init_builtins() if any more are added.  */
 680   B("_Pragma",           BT_PRAGMA),
 681   B("__STDC__",          BT_STDC),
 682 };
 683
 684 static const struct builtin operator_array[] =
 685 {
 686   B("and",      CPP_AND_AND),
 687   B("and_eq",   CPP_AND_EQ),
 688   B("bitand",   CPP_AND),
 689   B("bitor",    CPP_OR),
 690   B("compl",    CPP_COMPL),
 691   B("not",      CPP_NOT),
 692   B("not_eq",   CPP_NOT_EQ),
 693   B("or",       CPP_OR_OR),
 694   B("or_eq",    CPP_OR_EQ),
 695   B("xor",      CPP_XOR),
 696   B("xor_eq",   CPP_XOR_EQ)
 697 };
 698 #undef B
 699
 700 /* Mark the C++ named operators in the hash table.  */
 701 static void
 702 mark_named_operators (pfile)
 703      cpp_reader *pfile;
 704 {
 705   const struct builtin *b;
 706
 707   for (b = operator_array;
 708        b < (operator_array + ARRAY_SIZE (operator_array));
 709        b++)
 710     {
 711       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 712       hp->flags |= NODE_OPERATOR;
 713       hp->is_directive = 0;
 714       hp->directive_index = b->value;
 715     }
 716 }
 717
 718 /* Subroutine of cpp_read_main_file; reads the builtins table above and
 719    enters them, and language-specific macros, into the hash table.  */
 720 static void
 721 init_builtins (pfile)
 722      cpp_reader *pfile;
 723 {
 724   const struct builtin *b;
 725   size_t n = ARRAY_SIZE (builtin_array);
 726
 727   if (CPP_OPTION (pfile, traditional))
 728     n -= 2;
 729
 730   for(b = builtin_array; b < builtin_array + n; b++)
 731     {
 732       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 733       hp->type = NT_MACRO;
 734       hp->flags |= NODE_BUILTIN | NODE_WARN;
 735       hp->value.builtin = b->value;
 736     }
 737
 738   if (CPP_OPTION (pfile, cplusplus))
 739     _cpp_define_builtin (pfile, "__cplusplus 1");
 740   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 741     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 742   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 743     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 744   else if (CPP_OPTION (pfile, c99))
 745     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 746
 747   if (CPP_OPTION (pfile, objc))
 748     _cpp_define_builtin (pfile, "__OBJC__ 1");
 749
 750   if (pfile->cb.register_builtins)
 751     (*pfile->cb.register_builtins) (pfile);
 752 }
 753
 754 /* And another subroutine.  This one sets up the standard include path.  */
 755 static void
 756 init_standard_includes (pfile)
 757      cpp_reader *pfile;
 758 {
 759   const struct default_include *p;
 760   const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
 761   int default_len, specd_len;
 762   char *default_prefix;
 763
 764   /* Search "translated" versions of GNU directories.
 765      These have /usr/local/lib/gcc... replaced by specd_prefix.  */
 766   default_len = 0;
 767   specd_len = 0;
 768   default_prefix = NULL;
 769   if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
 770     {
 771       /* Remove the `include' from /usr/local/lib/gcc.../include.
 772          GCC_INCLUDE_DIR will always end in /include.  */
 773       default_len = cpp_GCC_INCLUDE_DIR_len;
 774       default_prefix = (char *) alloca (default_len + 1);
 775       specd_len = strlen (specd_prefix);
 776
 777       memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
 778       default_prefix[default_len] = '\0';
 779     }
 780
 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           char *str;
 789
 790           /* Should this dir start with the sysroot?  */
 791           if (p->add_sysroot && CPP_OPTION (pfile, sysroot))
 792             str = concat (CPP_OPTION (pfile, sysroot), p->fname, NULL);
 793
 794           /* Does this dir start with the prefix?  */
 795           else if (default_len
 796                    && !strncmp (p->fname, default_prefix, default_len))
 797             {
 798               /* Yes; change prefix and add to search list.  */
 799               int flen = strlen (p->fname);
 800               int this_len = specd_len + flen - default_len;
 801
 802               str = (char *) xmalloc (this_len + 1);
 803               memcpy (str, specd_prefix, specd_len);
 804               memcpy (str + specd_len,
 805                       p->fname + default_len,
 806                       flen - default_len + 1);
 807             }
 808
 809           else
 810             str = update_path (p->fname, p->component);
 811
 812           append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
 813         }
 814     }
 815 }
 816
 817 /* Pushes a command line -imacro and -include file indicated by P onto
 818    the buffer stack.  Returns nonzero if successful.  */
 819 static bool
 820 push_include (pfile, p)
 821      cpp_reader *pfile;
 822      struct pending_option *p;
 823 {
 824   cpp_token header;
 825
 826   /* Later: maybe update this to use the #include "" search path
 827      if cpp_read_file fails.  */
 828   header.type = CPP_STRING;
 829   header.val.str.text = (const unsigned char *) p->arg;
 830   header.val.str.len = strlen (p->arg);
 831   /* Make the command line directive take up a line.  */
 832   pfile->line++;
 833
 834   return _cpp_execute_include (pfile, &header, IT_CMDLINE);
 835 }
 836
 837 /* Frees a pending_option chain.  */
 838 static void
 839 free_chain (head)
 840      struct pending_option *head;
 841 {
 842   struct pending_option *next;
 843
 844   while (head)
 845     {
 846       next = head->next;
 847       free (head);
 848       head = next;
 849     }
 850 }
 851
 852 /* Sanity-checks are dependent on command-line options, so it is
 853    called as a subroutine of cpp_read_main_file ().  */
 854 #if ENABLE_CHECKING
 855 static void sanity_checks PARAMS ((cpp_reader *));
 856 static void sanity_checks (pfile)
 857      cpp_reader *pfile;
 858 {
 859   cppchar_t test = 0;
 860   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
 861
 862   /* Sanity checks for assumptions about CPP arithmetic and target
 863      type precisions made by cpplib.  */
 864   test--;
 865   if (test < 1)
 866     cpp_error (pfile, DL_ICE, "cppchar_t must be an unsigned type");
 867
 868   if (CPP_OPTION (pfile, precision) > max_precision)
 869     cpp_error (pfile, DL_ICE,
 870                "preprocessor arithmetic has maximum precision of %lu bits; target requires %lu bits",
 871                (unsigned long) max_precision,
 872                (unsigned long) CPP_OPTION (pfile, precision));
 873
 874   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
 875     cpp_error (pfile, DL_ICE,
 876                "CPP arithmetic must be at least as precise as a target int");
 877
 878   if (CPP_OPTION (pfile, char_precision) < 8)
 879     cpp_error (pfile, DL_ICE, "target char is less than 8 bits wide");
 880
 881   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
 882     cpp_error (pfile, DL_ICE,
 883                "target wchar_t is narrower than target char");
 884
 885   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
 886     cpp_error (pfile, DL_ICE,
 887                "target int is narrower than target char");
 888
 889   /* This is assumed in eval_token() and could be fixed if necessary.  */
 890   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
 891     cpp_error (pfile, DL_ICE, "CPP half-integer narrower than CPP character");
 892
 893   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
 894     cpp_error (pfile, DL_ICE,
 895                "CPP on this host cannot handle wide character constants over %lu bits, but the target requires %lu bits",
 896                (unsigned long) BITS_PER_CPPCHAR_T,
 897                (unsigned long) CPP_OPTION (pfile, wchar_precision));
 898 }
 899 #else
 900 # define sanity_checks(PFILE)
 901 #endif
 902
 903 /* Add a dependency target.  Can be called any number of times before
 904    cpp_read_main_file().  If no targets have been added before
 905    cpp_read_main_file(), then the default target is used.  */
 906 void
 907 cpp_add_dependency_target (pfile, target, quote)
 908      cpp_reader *pfile;
 909      const char *target;
 910      int quote;
 911 {
 912   if (!pfile->deps)
 913     pfile->deps = deps_init ();
 914
 915   deps_add_target (pfile->deps, target, quote);
 916 }
 917
 918 /* This is called after options have been parsed, and partially
 919    processed.  Setup for processing input from the file named FNAME,
 920    or stdin if it is the empty string.  Return the original filename
 921    on success (e.g. foo.i->foo.c), or NULL on failure.  */
 922 const char *
 923 cpp_read_main_file (pfile, fname, table)
 924      cpp_reader *pfile;
 925      const char *fname;
 926      hash_table *table;
 927 {
 928   static const char *const lang_env_vars[] =
 929     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
 930       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
 931   size_t lang;
 932
 933   sanity_checks (pfile);
 934
 935   post_options (pfile);
 936
 937   /* The front ends don't set up the hash table until they have
 938      finished processing the command line options, so initializing the
 939      hashtable is deferred until now.  */
 940   _cpp_init_hashtable (pfile, table);
 941
 942   /* Several environment variables may add to the include search path.
 943      CPATH specifies an additional list of directories to be searched
 944      as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
 945      etc. specify an additional list of directories to be searched as
 946      if specified with -isystem, for the language indicated.  */
 947   path_include (pfile, "CPATH", BRACKET);
 948   lang = (CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus);
 949   path_include (pfile, lang_env_vars[lang], SYSTEM);
 950
 951   /* Set up the include search path now.  */
 952   if (! CPP_OPTION (pfile, no_standard_includes))
 953     init_standard_includes (pfile);
 954
 955   merge_include_chains (pfile);
 956
 957   /* With -v, print the list of dirs to search.  */
 958   if (CPP_OPTION (pfile, verbose))
 959     {
 960       struct search_path *l;
 961       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 962       for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
 963         {
 964           if (l == CPP_OPTION (pfile, bracket_include))
 965             fprintf (stderr, _("#include <...> search starts here:\n"));
 966           fprintf (stderr, " %s\n", l->name);
 967         }
 968       fprintf (stderr, _("End of search list.\n"));
 969     }
 970
 971   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
 972     {
 973       if (!pfile->deps)
 974         pfile->deps = deps_init ();
 975
 976       /* Set the default target (if there is none already).  */
 977       deps_add_default_target (pfile->deps, fname);
 978     }
 979
 980   /* Open the main input file.  */
 981   if (!_cpp_read_file (pfile, fname))
 982     return NULL;
 983
 984   /* Set this here so the client can change the option if it wishes,
 985      and after stacking the main file so we don't trace the main
 986      file.  */
 987   pfile->line_maps.trace_includes = CPP_OPTION (pfile, print_include_names);
 988
 989   /* For foo.i, read the original filename foo.c now, for the benefit
 990      of the front ends.  */
 991   if (CPP_OPTION (pfile, preprocessed))
 992     read_original_filename (pfile);
 993
 994   return pfile->map->to_file;
 995 }
 996
 997 /* For preprocessed files, if the first tokens are of the form # NUM.
 998    handle the directive so we know the original file name.  This will
 999    generate file_change callbacks, which the front ends must handle
1000    appropriately given their state of initialization.  */
1001 static void
1002 read_original_filename (pfile)
1003      cpp_reader *pfile;
1004 {
1005   const cpp_token *token, *token1;
1006
1007   /* Lex ahead; if the first tokens are of the form # NUM, then
1008      process the directive, otherwise back up.  */
1009   token = _cpp_lex_direct (pfile);
1010   if (token->type == CPP_HASH)
1011     {
1012       token1 = _cpp_lex_direct (pfile);
1013       _cpp_backup_tokens (pfile, 1);
1014
1015       /* If it's a #line directive, handle it.  */
1016       if (token1->type == CPP_NUMBER)
1017         {
1018           _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
1019           return;
1020         }
1021     }
1022
1023   /* Backup as if nothing happened.  */
1024   _cpp_backup_tokens (pfile, 1);
1025 }
1026
1027 /* Handle pending command line options: -D, -U, -A, -imacros and
1028    -include.  This should be called after debugging has been properly
1029    set up in the front ends.  */
1030 void
1031 cpp_finish_options (pfile)
1032      cpp_reader *pfile;
1033 {
1034   /* Mark named operators before handling command line macros.  */
1035   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
1036     mark_named_operators (pfile);
1037
1038   /* Install builtins and process command line macros etc. in the order
1039      they appeared, but only if not already preprocessed.  */
1040   if (! CPP_OPTION (pfile, preprocessed))
1041     {
1042       struct pending_option *p;
1043
1044       _cpp_do_file_change (pfile, LC_RENAME, _("<built-in>"), 1, 0);
1045       init_builtins (pfile);
1046       _cpp_do_file_change (pfile, LC_RENAME, _("<command line>"), 1, 0);
1047       for (p = CPP_OPTION (pfile, pending)->directive_head; p; p = p->next)
1048         (*p->handler) (pfile, p->arg);
1049
1050       /* Scan -imacros files after -D, -U, but before -include.
1051          pfile->next_include_file is NULL, so _cpp_pop_buffer does not
1052          push -include files.  */
1053       for (p = CPP_OPTION (pfile, pending)->imacros_head; p; p = p->next)
1054         if (push_include (pfile, p))
1055           cpp_scan_nooutput (pfile);
1056
1057       pfile->next_include_file = &CPP_OPTION (pfile, pending)->include_head;
1058       _cpp_maybe_push_include_file (pfile);
1059     }
1060
1061   pfile->first_unused_line = pfile->line;
1062
1063   free_chain (CPP_OPTION (pfile, pending)->imacros_head);
1064   free_chain (CPP_OPTION (pfile, pending)->directive_head);
1065 }
1066
1067 /* Push the next buffer on the stack given by -include, if any.  */
1068 void
1069 _cpp_maybe_push_include_file (pfile)
1070      cpp_reader *pfile;
1071 {
1072   if (pfile->next_include_file)
1073     {
1074       struct pending_option *head = *pfile->next_include_file;
1075
1076       while (head && !push_include (pfile, head))
1077         head = head->next;
1078
1079       if (head)
1080         pfile->next_include_file = &head->next;
1081       else
1082         {
1083           /* All done; restore the line map from <command line>.  */
1084           _cpp_do_file_change (pfile, LC_RENAME,
1085                                pfile->line_maps.maps[0].to_file, 1, 0);
1086           /* Don't come back here again.  */
1087           pfile->next_include_file = NULL;
1088         }
1089     }
1090 }
1091
1092 /* This is called at the end of preprocessing.  It pops the last
1093    buffer and writes dependency output, and returns the number of
1094    errors.
1095
1096    Maybe it should also reset state, such that you could call
1097    cpp_start_read with a new filename to restart processing.  */
1098 int
1099 cpp_finish (pfile, deps_stream)
1100      cpp_reader *pfile;
1101      FILE *deps_stream;
1102 {
1103   /* Warn about unused macros before popping the final buffer.  */
1104   if (CPP_OPTION (pfile, warn_unused_macros))
1105     cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
1106
1107   /* cpplex.c leaves the final buffer on the stack.  This it so that
1108      it returns an unending stream of CPP_EOFs to the client.  If we
1109      popped the buffer, we'd dereference a NULL buffer pointer and
1110      segfault.  It's nice to allow the client to do worry-free excess
1111      cpp_get_token calls.  */
1112   while (pfile->buffer)
1113     _cpp_pop_buffer (pfile);
1114
1115   /* Don't write the deps file if there are errors.  */
1116   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
1117       && deps_stream && pfile->errors == 0)
1118     {
1119       deps_write (pfile->deps, deps_stream, 72);
1120
1121       if (CPP_OPTION (pfile, deps.phony_targets))
1122         deps_phony_targets (pfile->deps, deps_stream);
1123     }
1124
1125   /* Report on headers that could use multiple include guards.  */
1126   if (CPP_OPTION (pfile, print_include_names))
1127     _cpp_report_missing_guards (pfile);
1128
1129   return pfile->errors;
1130 }
1131
1132 /* Add a directive to be handled later in the initialization phase.  */
1133 static void
1134 new_pending_directive (pend, text, handler)
1135      struct cpp_pending *pend;
1136      const char *text;
1137      cl_directive_handler handler;
1138 {
1139   struct pending_option *o = (struct pending_option *)
1140     xmalloc (sizeof (struct pending_option));
1141
1142   o->arg = text;
1143   o->next = NULL;
1144   o->handler = handler;
1145   APPEND (pend, directive, o);
1146 }
1147
1148 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1149    I.e. a const string initializer with parens around it.  That is
1150    what N_("string") resolves to, so we make no_* be macros instead.  */
1151 #define no_ass N_("assertion missing after %s")
1152 #define no_dir N_("directory name missing after %s")
1153 #define no_fil N_("file name missing after %s")
1154 #define no_mac N_("macro name missing after %s")
1155 #define no_pth N_("path name missing after %s")
1156
1157 /* This is the list of all command line options, with the leading
1158    "-" removed.  It must be sorted in ASCII collating order.  */
1159 #define COMMAND_LINE_OPTIONS                                                  \
1160   DEF_OPT("A",                        no_ass, OPT_A)                          \
1161   DEF_OPT("D",                        no_mac, OPT_D)                          \
1162   DEF_OPT("I",                        no_dir, OPT_I)                          \
1163   DEF_OPT("U",                        no_mac, OPT_U)                          \
1164   DEF_OPT("idirafter",                no_dir, OPT_idirafter)                  \
1165   DEF_OPT("imacros",                  no_fil, OPT_imacros)                    \
1166   DEF_OPT("include",                  no_fil, OPT_include)                    \
1167   DEF_OPT("iprefix",                  no_pth, OPT_iprefix)                    \
1168   DEF_OPT("isysroot",                 no_dir, OPT_isysroot)                   \
1169   DEF_OPT("isystem",                  no_dir, OPT_isystem)                    \
1170   DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix)                \
1171   DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore)
1172
1173 #define DEF_OPT(text, msg, code) code,
1174 enum opt_code
1175 {
1176   COMMAND_LINE_OPTIONS
1177   N_OPTS
1178 };
1179 #undef DEF_OPT
1180
1181 struct cl_option
1182 {
1183   const char *opt_text;
1184   const char *msg;
1185   size_t opt_len;
1186   enum opt_code opt_code;
1187 };
1188
1189 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1190 #ifdef HOST_EBCDIC
1191 static struct cl_option cl_options[] =
1192 #else
1193 static const struct cl_option cl_options[] =
1194 #endif
1195 {
1196   COMMAND_LINE_OPTIONS
1197 };
1198 #undef DEF_OPT
1199 #undef COMMAND_LINE_OPTIONS
1200
1201 /* Perform a binary search to find which, if any, option the given
1202    command-line matches.  Returns its index in the option array,
1203    negative on failure.  Complications arise since some options can be
1204    suffixed with an argument, and multiple complete matches can occur,
1205    e.g. -pedantic and -pedantic-errors.  */
1206 static int
1207 parse_option (input)
1208      const char *input;
1209 {
1210   unsigned int md, mn, mx;
1211   size_t opt_len;
1212   int comp;
1213
1214   mn = 0;
1215   mx = N_OPTS;
1216
1217   while (mx > mn)
1218     {
1219       md = (mn + mx) / 2;
1220
1221       opt_len = cl_options[md].opt_len;
1222       comp = strncmp (input, cl_options[md].opt_text, opt_len);
1223
1224       if (comp > 0)
1225         mn = md + 1;
1226       else if (comp < 0)
1227         mx = md;
1228       else
1229         {
1230           if (input[opt_len] == '\0')
1231             return md;
1232           /* We were passed more text.  If the option takes an argument,
1233              we may match a later option or we may have been passed the
1234              argument.  The longest possible option match succeeds.
1235              If the option takes no arguments we have not matched and
1236              continue the search (e.g. input="stdc++" match was "stdc").  */
1237           mn = md + 1;
1238           if (cl_options[md].msg)
1239             {
1240               /* Scan forwards.  If we get an exact match, return it.
1241                  Otherwise, return the longest option-accepting match.
1242                  This loops no more than twice with current options.  */
1243               mx = md;
1244               for (; mn < (unsigned int) N_OPTS; mn++)
1245                 {
1246                   opt_len = cl_options[mn].opt_len;
1247                   if (strncmp (input, cl_options[mn].opt_text, opt_len))
1248                     break;
1249                   if (input[opt_len] == '\0')
1250                     return mn;
1251                   if (cl_options[mn].msg)
1252                     mx = mn;
1253                 }
1254               return mx;
1255             }
1256         }
1257     }
1258
1259   return -1;
1260 }
1261
1262 /* Handle one command-line option in (argc, argv).
1263    Can be called multiple times, to handle multiple sets of options.
1264    Returns number of strings consumed.  */
1265 int
1266 cpp_handle_option (pfile, argc, argv)
1267      cpp_reader *pfile;
1268      int argc;
1269      char **argv;
1270 {
1271   int i = 0;
1272   struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1273
1274     {
1275       enum opt_code opt_code;
1276       int opt_index;
1277       const char *arg = 0;
1278
1279       /* Skip over '-'.  */
1280       opt_index = parse_option (&argv[i][1]);
1281       if (opt_index < 0)
1282         return i;
1283
1284       opt_code = cl_options[opt_index].opt_code;
1285       if (cl_options[opt_index].msg)
1286         {
1287           arg = &argv[i][cl_options[opt_index].opt_len + 1];
1288           if (arg[0] == '\0')
1289             {
1290               arg = argv[++i];
1291               if (!arg)
1292                 {
1293                   cpp_error (pfile, DL_ERROR,
1294                              cl_options[opt_index].msg, argv[i - 1]);
1295                   return argc;
1296                 }
1297             }
1298         }
1299
1300       switch (opt_code)
1301         {
1302         case N_OPTS: /* Shut GCC up.  */
1303           break;
1304
1305         case OPT_D:
1306           new_pending_directive (pend, arg, cpp_define);
1307           break;
1308         case OPT_iprefix:
1309           CPP_OPTION (pfile, include_prefix) = arg;
1310           CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1311           break;
1312
1313         case OPT_isysroot:
1314           CPP_OPTION (pfile, sysroot) = arg;
1315           break;
1316
1317         case OPT_A:
1318           if (arg[0] == '-')
1319             {
1320               /* -A with an argument beginning with '-' acts as
1321                  #unassert on whatever immediately follows the '-'.
1322                  If "-" is the whole argument, we eliminate all
1323                  predefined macros and assertions, including those
1324                  that were specified earlier on the command line.
1325                  That way we can get rid of any that were passed
1326                  automatically in from GCC.  */
1327
1328               if (arg[1] == '\0')
1329                 {
1330                   free_chain (pend->directive_head);
1331                   pend->directive_head = NULL;
1332                   pend->directive_tail = NULL;
1333                 }
1334               else
1335                 new_pending_directive (pend, arg + 1, cpp_unassert);
1336             }
1337           else
1338             new_pending_directive (pend, arg, cpp_assert);
1339           break;
1340         case OPT_U:
1341           new_pending_directive (pend, arg, cpp_undef);
1342           break;
1343         case OPT_I:           /* Add directory to path for includes.  */
1344           if (!strcmp (arg, "-"))
1345             {
1346               /* -I- means:
1347                  Use the preceding -I directories for #include "..."
1348                  but not #include <...>.
1349                  Don't search the directory of the present file
1350                  for #include "...".  (Note that -I. -I- is not the same as
1351                  the default setup; -I. uses the compiler's working dir.)  */
1352               if (! CPP_OPTION (pfile, ignore_srcdir))
1353                 {
1354                   pend->quote_head = pend->brack_head;
1355                   pend->quote_tail = pend->brack_tail;
1356                   pend->brack_head = 0;
1357                   pend->brack_tail = 0;
1358                   CPP_OPTION (pfile, ignore_srcdir) = 1;
1359                 }
1360               else
1361                 {
1362                   cpp_error (pfile, DL_ERROR, "-I- specified twice");
1363                   return argc;
1364                 }
1365             }
1366           else
1367             append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1368           break;
1369         case OPT_isystem:
1370           /* Add directory to beginning of system include path, as a system
1371              include directory.  */
1372           append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1373           break;
1374         case OPT_include:
1375         case OPT_imacros:
1376           {
1377             struct pending_option *o = (struct pending_option *)
1378               xmalloc (sizeof (struct pending_option));
1379             o->arg = arg;
1380             o->next = NULL;
1381
1382             if (opt_code == OPT_include)
1383               APPEND (pend, include, o);
1384             else
1385               APPEND (pend, imacros, o);
1386           }
1387           break;
1388         case OPT_iwithprefix:
1389           /* Add directory to end of path for includes,
1390              with the default prefix at the front of its name.  */
1391           /* fall through */
1392         case OPT_iwithprefixbefore:
1393           /* Add directory to main path for includes,
1394              with the default prefix at the front of its name.  */
1395           {
1396             char *fname;
1397             int len;
1398
1399             len = strlen (arg);
1400
1401             if (CPP_OPTION (pfile, include_prefix) != 0)
1402               {
1403                 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1404                 fname = xmalloc (ipl + len + 1);
1405                 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1406                 memcpy (fname + ipl, arg, len + 1);
1407               }
1408             else if (cpp_GCC_INCLUDE_DIR_len)
1409               {
1410                 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1411                 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1412                 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1413               }
1414             else
1415               fname = xstrdup (arg);
1416
1417             append_include_chain (pfile, fname,
1418                           opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1419           }
1420           break;
1421         case OPT_idirafter:
1422           /* Add directory to end of path for includes.  */
1423           append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1424           break;
1425         }
1426     }
1427   return i + 1;
1428 }
1429
1430 /* Handle command-line options in (argc, argv).
1431    Can be called multiple times, to handle multiple sets of options.
1432    Returns if an unrecognized option is seen.
1433    Returns number of strings consumed.  */
1434 int
1435 cpp_handle_options (pfile, argc, argv)
1436      cpp_reader *pfile;
1437      int argc;
1438      char **argv;
1439 {
1440   int i;
1441   int strings_processed;
1442
1443   for (i = 0; i < argc; i += strings_processed)
1444     {
1445       strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1446       if (strings_processed == 0)
1447         break;
1448     }
1449
1450   return i;
1451 }
1452
1453 static void
1454 post_options (pfile)
1455      cpp_reader *pfile;
1456 {
1457   /* -Wtraditional is not useful in C++ mode.  */
1458   if (CPP_OPTION (pfile, cplusplus))
1459     CPP_OPTION (pfile, warn_traditional) = 0;
1460
1461   /* Permanently disable macro expansion if we are rescanning
1462      preprocessed text.  Read preprocesed source in ISO mode.  */
1463   if (CPP_OPTION (pfile, preprocessed))
1464     {
1465       pfile->state.prevent_expansion = 1;
1466       CPP_OPTION (pfile, traditional) = 0;
1467     }
1468
1469   /* Traditional CPP does not accurately track column information.  */
1470   if (CPP_OPTION (pfile, traditional))
1471     CPP_OPTION (pfile, show_column) = 0;
1472 }