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