gcc-4_7-mobile/libcpp/init.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
   4    2009, 2010, 2011 Free Software Foundation, Inc.
   5    Contributed by Per Bothner, 1994-95.
   6    Based on CCCP program by Paul Rubin, June 1986
   7    Adapted to ANSI C, Richard Stallman, Jan 1987
   8
   9 This program is free software; you can redistribute it and/or modify it
  10 under the terms of the GNU General Public License as published by the
  11 Free Software Foundation; either version 3, or (at your option) any
  12 later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "cpplib.h"
  26 #include "internal.h"
  27 #include "mkdeps.h"
  28 #include "localedir.h"
  29 #include "filenames.h"
  30
  31 static void init_library (void);
  32 static void mark_named_operators (cpp_reader *, int);
  33 static void read_original_filename (cpp_reader *);
  34 static void read_original_directory (cpp_reader *);
  35 static void post_options (cpp_reader *);
  36
  37 /* If we have designated initializers (GCC >2.7) these tables can be
  38    initialized, constant data.  Otherwise, they have to be filled in at
  39    runtime.  */
  40 #if HAVE_DESIGNATED_INITIALIZERS
  41
  42 #define init_trigraph_map()  /* Nothing.  */
  43 #define TRIGRAPH_MAP \
  44 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
  45
  46 #define END };
  47 #define s(p, v) [p] = v,
  48
  49 #else
  50
  51 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
  52  static void init_trigraph_map (void) { \
  53  unsigned char *x = _cpp_trigraph_map;
  54
  55 #define END }
  56 #define s(p, v) x[p] = v;
  57
  58 #endif
  59
  60 TRIGRAPH_MAP
  61   s('=', '#')   s(')', ']')     s('!', '|')
  62   s('(', '[')   s('\'', '^')    s('>', '}')
  63   s('/', '\\')  s('<', '{')     s('-', '~')
  64 END
  65
  66 #undef s
  67 #undef END
  68 #undef TRIGRAPH_MAP
  69
  70 /* A set of booleans indicating what CPP features each source language
  71    requires.  */
  72 struct lang_flags
  73 {
  74   char c99;
  75   char cplusplus;
  76   char extended_numbers;
  77   char extended_identifiers;
  78   char std;
  79   char cplusplus_comments;
  80   char digraphs;
  81   char uliterals;
  82   char rliterals;
  83   char user_literals;
  84 };
  85
  86 static const struct lang_flags lang_defaults[] =
  87 { /*              c99 c++ xnum xid std  //   digr ulit rlit user_literals */
  88   /* GNUC89   */  { 0,  0,  1,   0,  0,   1,   1,   0,   0,    0 },
  89   /* GNUC99   */  { 1,  0,  1,   0,  0,   1,   1,   1,   1,    0 },
  90   /* GNUC11   */  { 1,  0,  1,   0,  0,   1,   1,   1,   1,    0 },
  91   /* STDC89   */  { 0,  0,  0,   0,  1,   0,   0,   0,   0,    0 },
  92   /* STDC94   */  { 0,  0,  0,   0,  1,   0,   1,   0,   0,    0 },
  93   /* STDC99   */  { 1,  0,  1,   0,  1,   1,   1,   0,   0,    0 },
  94   /* STDC11   */  { 1,  0,  1,   0,  1,   1,   1,   1,   0,    0 },
  95   /* GNUCXX   */  { 0,  1,  1,   0,  0,   1,   1,   0,   0,    0 },
  96   /* CXX98    */  { 0,  1,  1,   0,  1,   1,   1,   0,   0,    0 },
  97   /* GNUCXX11 */  { 1,  1,  1,   0,  0,   1,   1,   1,   1,    1 },
  98   /* CXX11    */  { 1,  1,  1,   0,  1,   1,   1,   1,   1,    1 },
  99   /* ASM      */  { 0,  0,  1,   0,  0,   1,   0,   0,   0,    0 }
 100   /* xid should be 1 for GNUC99, STDC99, GNUCXX, CXX98, GNUCXX11, and
 101      CXX11 when no longer experimental (when all uses of identifiers
 102      in the compiler have been audited for correct handling of
 103      extended identifiers).  */
 104 };
 105
 106 /* Sets internal flags correctly for a given language.  */
 107 void
 108 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
 109 {
 110   const struct lang_flags *l = &lang_defaults[(int) lang];
 111
 112   CPP_OPTION (pfile, lang) = lang;
 113
 114   CPP_OPTION (pfile, c99)                        = l->c99;
 115   CPP_OPTION (pfile, cplusplus)                  = l->cplusplus;
 116   CPP_OPTION (pfile, extended_numbers)           = l->extended_numbers;
 117   CPP_OPTION (pfile, extended_identifiers)       = l->extended_identifiers;
 118   CPP_OPTION (pfile, std)                        = l->std;
 119   CPP_OPTION (pfile, trigraphs)                  = l->std;
 120   CPP_OPTION (pfile, cplusplus_comments)         = l->cplusplus_comments;
 121   CPP_OPTION (pfile, digraphs)                   = l->digraphs;
 122   CPP_OPTION (pfile, uliterals)                  = l->uliterals;
 123   CPP_OPTION (pfile, rliterals)                  = l->rliterals;
 124   CPP_OPTION (pfile, user_literals)              = l->user_literals;
 125 }
 126
 127 /* Initialize library global state.  */
 128 static void
 129 init_library (void)
 130 {
 131   static int initialized = 0;
 132
 133   if (! initialized)
 134     {
 135       initialized = 1;
 136
 137       _cpp_init_lexer ();
 138
 139       /* Set up the trigraph map.  This doesn't need to do anything if
 140          we were compiled with a compiler that supports C99 designated
 141          initializers.  */
 142       init_trigraph_map ();
 143
 144 #ifdef ENABLE_NLS
 145        (void) bindtextdomain (PACKAGE, LOCALEDIR);
 146 #endif
 147     }
 148 }
 149
 150 /* Initialize a cpp_reader structure.  */
 151 cpp_reader *
 152 cpp_create_reader (enum c_lang lang, hash_table *table,
 153                    struct line_maps *line_table)
 154 {
 155   cpp_reader *pfile;
 156
 157   /* Initialize this instance of the library if it hasn't been already.  */
 158   init_library ();
 159
 160   pfile = XCNEW (cpp_reader);
 161   memset (&pfile->base_context, 0, sizeof (pfile->base_context));
 162
 163   cpp_set_lang (pfile, lang);
 164   CPP_OPTION (pfile, warn_multichar) = 1;
 165   CPP_OPTION (pfile, discard_comments) = 1;
 166   CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
 167   CPP_OPTION (pfile, tabstop) = 8;
 168   CPP_OPTION (pfile, operator_names) = 1;
 169   CPP_OPTION (pfile, warn_trigraphs) = 2;
 170   CPP_OPTION (pfile, warn_endif_labels) = 1;
 171   CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
 172   CPP_OPTION (pfile, cpp_warn_long_long) = 0;
 173   CPP_OPTION (pfile, dollars_in_ident) = 1;
 174   CPP_OPTION (pfile, warn_dollars) = 1;
 175   CPP_OPTION (pfile, warn_variadic_macros) = 1;
 176   CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
 177   CPP_OPTION (pfile, warn_normalize) = normalized_C;
 178   CPP_OPTION (pfile, warn_literal_suffix) = 1;
 179
 180   /* Default CPP arithmetic to something sensible for the host for the
 181      benefit of dumb users like fix-header.  */
 182   CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
 183   CPP_OPTION (pfile, char_precision) = CHAR_BIT;
 184   CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
 185   CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
 186   CPP_OPTION (pfile, unsigned_char) = 0;
 187   CPP_OPTION (pfile, unsigned_wchar) = 1;
 188   CPP_OPTION (pfile, bytes_big_endian) = 1;  /* does not matter */
 189
 190   /* Default to no charset conversion.  */
 191   CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
 192   CPP_OPTION (pfile, wide_charset) = 0;
 193
 194   /* Default the input character set to UTF-8.  */
 195   CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
 196
 197   /* A fake empty "directory" used as the starting point for files
 198      looked up without a search path.  Name cannot be '/' because we
 199      don't want to prepend anything at all to filenames using it.  All
 200      other entries are correct zero-initialized.  */
 201   pfile->no_search_path.name = (char *) "";
 202
 203   /* Initialize the line map.  */
 204   pfile->line_table = line_table;
 205
 206   /* Initialize lexer state.  */
 207   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 208
 209   /* Set up static tokens.  */
 210   pfile->avoid_paste.type = CPP_PADDING;
 211   pfile->avoid_paste.val.source = NULL;
 212   pfile->eof.type = CPP_EOF;
 213   pfile->eof.flags = 0;
 214
 215   /* Create a token buffer for the lexer.  */
 216   _cpp_init_tokenrun (&pfile->base_run, 250);
 217   pfile->cur_run = &pfile->base_run;
 218   pfile->cur_token = pfile->base_run.base;
 219
 220   /* Initialize the base context.  */
 221   pfile->context = &pfile->base_context;
 222   pfile->base_context.c.macro = 0;
 223   pfile->base_context.prev = pfile->base_context.next = 0;
 224
 225   /* Aligned and unaligned storage.  */
 226   pfile->a_buff = _cpp_get_buff (pfile, 0);
 227   pfile->u_buff = _cpp_get_buff (pfile, 0);
 228
 229   /* Initialize table for push_macro/pop_macro.  */
 230   pfile->pushed_macros = 0;
 231
 232   /* Do not force token locations by default.  */
 233   pfile->forced_token_location_p = NULL;
 234
 235   /* The expression parser stack.  */
 236   _cpp_expand_op_stack (pfile);
 237
 238   /* Initialize the buffer obstack.  */
 239   _obstack_begin (&pfile->buffer_ob, 0, 0,
 240                   (void *(*) (long)) xmalloc,
 241                   (void (*) (void *)) free);
 242
 243   _cpp_init_files (pfile);
 244
 245   _cpp_init_hashtable (pfile, table);
 246
 247   return pfile;
 248 }
 249
 250 /* Set the line_table entry in PFILE.  This is called after reading a
 251    PCH file, as the old line_table will be incorrect.  */
 252 void
 253 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
 254 {
 255   pfile->line_table = line_table;
 256 }
 257
 258 /* Free resources used by PFILE.  Accessing PFILE after this function
 259    returns leads to undefined behavior.  Returns the error count.  */
 260 void
 261 cpp_destroy (cpp_reader *pfile)
 262 {
 263   cpp_context *context, *contextn;
 264   struct def_pragma_macro *pmacro;
 265   tokenrun *run, *runn;
 266   int i;
 267
 268   free (pfile->op_stack);
 269
 270   while (CPP_BUFFER (pfile) != NULL)
 271     _cpp_pop_buffer (pfile);
 272
 273   free (pfile->out.base);
 274
 275   if (pfile->macro_buffer)
 276     {
 277       free (pfile->macro_buffer);
 278       pfile->macro_buffer = NULL;
 279       pfile->macro_buffer_len = 0;
 280     }
 281
 282   if (pfile->deps)
 283     deps_free (pfile->deps);
 284   obstack_free (&pfile->buffer_ob, 0);
 285
 286   _cpp_destroy_hashtable (pfile);
 287   _cpp_cleanup_files (pfile);
 288   _cpp_destroy_iconv (pfile);
 289
 290   _cpp_free_buff (pfile->a_buff);
 291   _cpp_free_buff (pfile->u_buff);
 292   _cpp_free_buff (pfile->free_buffs);
 293
 294   for (run = &pfile->base_run; run; run = runn)
 295     {
 296       runn = run->next;
 297       free (run->base);
 298       if (run != &pfile->base_run)
 299         free (run);
 300     }
 301
 302   for (context = pfile->base_context.next; context; context = contextn)
 303     {
 304       contextn = context->next;
 305       free (context);
 306     }
 307
 308   if (pfile->comments.entries)
 309     {
 310       for (i = 0; i < pfile->comments.count; i++)
 311         free (pfile->comments.entries[i].comment);
 312
 313       free (pfile->comments.entries);
 314     }
 315   if (pfile->pushed_macros)
 316     {
 317       do
 318         {
 319           pmacro = pfile->pushed_macros;
 320           pfile->pushed_macros = pmacro->next;
 321           free (pmacro->name);
 322           free (pmacro);
 323         }
 324       while (pfile->pushed_macros);
 325     }
 326
 327   free (pfile);
 328 }
 329
 330 /* This structure defines one built-in identifier.  A node will be
 331    entered in the hash table under the name NAME, with value VALUE.
 332
 333    There are two tables of these.  builtin_array holds all the
 334    "builtin" macros: these are handled by builtin_macro() in
 335    macro.c.  Builtin is somewhat of a misnomer -- the property of
 336    interest is that these macros require special code to compute their
 337    expansions.  The value is a "cpp_builtin_type" enumerator.
 338
 339    operator_array holds the C++ named operators.  These are keywords
 340    which act as aliases for punctuators.  In C++, they cannot be
 341    altered through #define, and #if recognizes them as operators.  In
 342    C, these are not entered into the hash table at all (but see
 343    <iso646.h>).  The value is a token-type enumerator.  */
 344 struct builtin_macro
 345 {
 346   const uchar *const name;
 347   const unsigned short len;
 348   const unsigned short value;
 349   const bool always_warn_if_redefined;
 350 };
 351
 352 #define B(n, t, f)    { DSC(n), t, f }
 353 static const struct builtin_macro builtin_array[] =
 354 {
 355   B("__TIMESTAMP__",     BT_TIMESTAMP,     false),
 356   B("__TIME__",          BT_TIME,          false),
 357   B("__DATE__",          BT_DATE,          false),
 358   B("__FILE__",          BT_FILE,          false),
 359   B("__BASE_FILE__",     BT_BASE_FILE,     false),
 360   B("__LINE__",          BT_SPECLINE,      true),
 361   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
 362   B("__COUNTER__",       BT_COUNTER,       true),
 363   /* Keep builtins not used for -traditional-cpp at the end, and
 364      update init_builtins() if any more are added.  */
 365   B("_Pragma",           BT_PRAGMA,        true),
 366   B("__STDC__",          BT_STDC,          true),
 367 };
 368 #undef B
 369
 370 struct builtin_operator
 371 {
 372   const uchar *const name;
 373   const unsigned short len;
 374   const unsigned short value;
 375 };
 376
 377 #define B(n, t)    { DSC(n), t }
 378 static const struct builtin_operator operator_array[] =
 379 {
 380   B("and",      CPP_AND_AND),
 381   B("and_eq",   CPP_AND_EQ),
 382   B("bitand",   CPP_AND),
 383   B("bitor",    CPP_OR),
 384   B("compl",    CPP_COMPL),
 385   B("not",      CPP_NOT),
 386   B("not_eq",   CPP_NOT_EQ),
 387   B("or",       CPP_OR_OR),
 388   B("or_eq",    CPP_OR_EQ),
 389   B("xor",      CPP_XOR),
 390   B("xor_eq",   CPP_XOR_EQ)
 391 };
 392 #undef B
 393
 394 /* Mark the C++ named operators in the hash table.  */
 395 static void
 396 mark_named_operators (cpp_reader *pfile, int flags)
 397 {
 398   const struct builtin_operator *b;
 399
 400   for (b = operator_array;
 401        b < (operator_array + ARRAY_SIZE (operator_array));
 402        b++)
 403     {
 404       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 405       hp->flags |= flags;
 406       hp->is_directive = 0;
 407       hp->directive_index = b->value;
 408     }
 409 }
 410
 411 /* Helper function of cpp_type2name. Return the string associated with
 412    named operator TYPE.  */
 413 const char *
 414 cpp_named_operator2name (enum cpp_ttype type)
 415 {
 416   const struct builtin_operator *b;
 417
 418   for (b = operator_array;
 419        b < (operator_array + ARRAY_SIZE (operator_array));
 420        b++)
 421     {
 422       if (type == b->value)
 423         return (const char *) b->name;
 424     }
 425
 426   return NULL;
 427 }
 428
 429 void
 430 cpp_init_special_builtins (cpp_reader *pfile)
 431 {
 432   const struct builtin_macro *b;
 433   size_t n = ARRAY_SIZE (builtin_array);
 434
 435   if (CPP_OPTION (pfile, traditional))
 436     n -= 2;
 437   else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 438            || CPP_OPTION (pfile, std))
 439     n--;
 440
 441   for (b = builtin_array; b < builtin_array + n; b++)
 442     {
 443       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 444       hp->type = NT_MACRO;
 445       hp->flags |= NODE_BUILTIN;
 446       if (b->always_warn_if_redefined
 447           || CPP_OPTION (pfile, warn_builtin_macro_redefined))
 448         hp->flags |= NODE_WARN;
 449       hp->value.builtin = (enum cpp_builtin_type) b->value;
 450     }
 451 }
 452
 453 /* Read the builtins table above and enter them, and language-specific
 454    macros, into the hash table.  HOSTED is true if this is a hosted
 455    environment.  */
 456 void
 457 cpp_init_builtins (cpp_reader *pfile, int hosted)
 458 {
 459   cpp_init_special_builtins (pfile);
 460
 461   if (!CPP_OPTION (pfile, traditional)
 462       && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 463           || CPP_OPTION (pfile, std)))
 464     _cpp_define_builtin (pfile, "__STDC__ 1");
 465
 466   if (CPP_OPTION (pfile, cplusplus))
 467     {
 468       if (CPP_OPTION (pfile, lang) == CLK_CXX11
 469            || CPP_OPTION (pfile, lang) == CLK_GNUCXX11)
 470         _cpp_define_builtin (pfile, "__cplusplus 201103L");
 471       else
 472         _cpp_define_builtin (pfile, "__cplusplus 199711L");
 473     }
 474   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 475     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 476   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 477     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 478   else if (CPP_OPTION (pfile, lang) == CLK_STDC11
 479            || CPP_OPTION (pfile, lang) == CLK_GNUC11)
 480     _cpp_define_builtin (pfile, "__STDC_VERSION__ 201112L");
 481   else if (CPP_OPTION (pfile, c99))
 482     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 483
 484   if (CPP_OPTION (pfile, uliterals)
 485       && !CPP_OPTION (pfile, cplusplus))
 486     {
 487       _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1");
 488       _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1");
 489     }
 490
 491   if (hosted)
 492     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
 493   else
 494     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
 495
 496   if (CPP_OPTION (pfile, objc))
 497     _cpp_define_builtin (pfile, "__OBJC__ 1");
 498 }
 499
 500 /* Sanity-checks are dependent on command-line options, so it is
 501    called as a subroutine of cpp_read_main_file ().  */
 502 #if ENABLE_CHECKING
 503 static void sanity_checks (cpp_reader *);
 504 static void sanity_checks (cpp_reader *pfile)
 505 {
 506   cppchar_t test = 0;
 507   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
 508
 509   /* Sanity checks for assumptions about CPP arithmetic and target
 510      type precisions made by cpplib.  */
 511   test--;
 512   if (test < 1)
 513     cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
 514
 515   if (CPP_OPTION (pfile, precision) > max_precision)
 516     cpp_error (pfile, CPP_DL_ICE,
 517                "preprocessor arithmetic has maximum precision of %lu bits;"
 518                " target requires %lu bits",
 519                (unsigned long) max_precision,
 520                (unsigned long) CPP_OPTION (pfile, precision));
 521
 522   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
 523     cpp_error (pfile, CPP_DL_ICE,
 524                "CPP arithmetic must be at least as precise as a target int");
 525
 526   if (CPP_OPTION (pfile, char_precision) < 8)
 527     cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
 528
 529   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
 530     cpp_error (pfile, CPP_DL_ICE,
 531                "target wchar_t is narrower than target char");
 532
 533   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
 534     cpp_error (pfile, CPP_DL_ICE,
 535                "target int is narrower than target char");
 536
 537   /* This is assumed in eval_token() and could be fixed if necessary.  */
 538   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
 539     cpp_error (pfile, CPP_DL_ICE,
 540                "CPP half-integer narrower than CPP character");
 541
 542   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
 543     cpp_error (pfile, CPP_DL_ICE,
 544                "CPP on this host cannot handle wide character constants over"
 545                " %lu bits, but the target requires %lu bits",
 546                (unsigned long) BITS_PER_CPPCHAR_T,
 547                (unsigned long) CPP_OPTION (pfile, wchar_precision));
 548 }
 549 #else
 550 # define sanity_checks(PFILE)
 551 #endif
 552
 553 /* This is called after options have been parsed, and partially
 554    processed.  */
 555 void
 556 cpp_post_options (cpp_reader *pfile)
 557 {
 558   int flags;
 559
 560   sanity_checks (pfile);
 561
 562   post_options (pfile);
 563
 564   /* Mark named operators before handling command line macros.  */
 565   flags = 0;
 566   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
 567     flags |= NODE_OPERATOR;
 568   if (CPP_OPTION (pfile, warn_cxx_operator_names))
 569     flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR;
 570   if (flags != 0)
 571     mark_named_operators (pfile, flags);
 572 }
 573
 574 /* Setup for processing input from the file named FNAME, or stdin if
 575    it is the empty string.  Return the original filename
 576    on success (e.g. foo.i->foo.c), or NULL on failure.  */
 577 const char *
 578 cpp_read_main_file (cpp_reader *pfile, const char *fname)
 579 {
 580   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
 581     {
 582       if (!pfile->deps)
 583         pfile->deps = deps_init ();
 584
 585       /* Set the default target (if there is none already).  */
 586       deps_add_default_target (pfile->deps, fname);
 587     }
 588
 589   pfile->main_file
 590     = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
 591   if (_cpp_find_failed (pfile->main_file))
 592     return NULL;
 593
 594   _cpp_stack_file (pfile, pfile->main_file, false);
 595
 596   /* For foo.i, read the original filename foo.c now, for the benefit
 597      of the front ends.  */
 598   if (CPP_OPTION (pfile, preprocessed))
 599     {
 600       read_original_filename (pfile);
 601       fname =
 602         ORDINARY_MAP_FILE_NAME
 603         ((LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table)));
 604     }
 605   return fname;
 606 }
 607
 608 /* For preprocessed files, if the first tokens are of the form # NUM.
 609    handle the directive so we know the original file name.  This will
 610    generate file_change callbacks, which the front ends must handle
 611    appropriately given their state of initialization.  */
 612 static void
 613 read_original_filename (cpp_reader *pfile)
 614 {
 615   const cpp_token *token, *token1;
 616
 617   /* Lex ahead; if the first tokens are of the form # NUM, then
 618      process the directive, otherwise back up.  */
 619   token = _cpp_lex_direct (pfile);
 620   if (token->type == CPP_HASH)
 621     {
 622       pfile->state.in_directive = 1;
 623       token1 = _cpp_lex_direct (pfile);
 624       _cpp_backup_tokens (pfile, 1);
 625       pfile->state.in_directive = 0;
 626
 627       /* If it's a #line directive, handle it.  */
 628       if (token1->type == CPP_NUMBER
 629           && _cpp_handle_directive (pfile, token->flags & PREV_WHITE))
 630         {
 631           read_original_directory (pfile);
 632           return;
 633         }
 634     }
 635
 636   /* Backup as if nothing happened.  */
 637   _cpp_backup_tokens (pfile, 1);
 638 }
 639
 640 /* For preprocessed files, if the tokens following the first filename
 641    line is of the form # <line> "/path/name//", handle the
 642    directive so we know the original current directory.  */
 643 static void
 644 read_original_directory (cpp_reader *pfile)
 645 {
 646   const cpp_token *hash, *token;
 647
 648   /* Lex ahead; if the first tokens are of the form # NUM, then
 649      process the directive, otherwise back up.  */
 650   hash = _cpp_lex_direct (pfile);
 651   if (hash->type != CPP_HASH)
 652     {
 653       _cpp_backup_tokens (pfile, 1);
 654       return;
 655     }
 656
 657   token = _cpp_lex_direct (pfile);
 658
 659   if (token->type != CPP_NUMBER)
 660     {
 661       _cpp_backup_tokens (pfile, 2);
 662       return;
 663     }
 664
 665   token = _cpp_lex_direct (pfile);
 666
 667   if (token->type != CPP_STRING
 668       || ! (token->val.str.len >= 5
 669             && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-2])
 670             && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-3])))
 671     {
 672       _cpp_backup_tokens (pfile, 3);
 673       return;
 674     }
 675
 676   if (pfile->cb.dir_change)
 677     {
 678       char *debugdir = (char *) alloca (token->val.str.len - 3);
 679
 680       memcpy (debugdir, (const char *) token->val.str.text + 1,
 681               token->val.str.len - 4);
 682       debugdir[token->val.str.len - 4] = '\0';
 683
 684       pfile->cb.dir_change (pfile, debugdir);
 685     }
 686 }
 687
 688 /* This is called at the end of preprocessing.  It pops the last
 689    buffer and writes dependency output.
 690
 691    Maybe it should also reset state, such that you could call
 692    cpp_start_read with a new filename to restart processing.  */
 693 void
 694 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
 695 {
 696   /* Warn about unused macros before popping the final buffer.  */
 697   if (CPP_OPTION (pfile, warn_unused_macros))
 698     cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
 699
 700   /* lex.c leaves the final buffer on the stack.  This it so that
 701      it returns an unending stream of CPP_EOFs to the client.  If we
 702      popped the buffer, we'd dereference a NULL buffer pointer and
 703      segfault.  It's nice to allow the client to do worry-free excess
 704      cpp_get_token calls.  */
 705   while (pfile->buffer)
 706     _cpp_pop_buffer (pfile);
 707
 708   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
 709       && deps_stream)
 710     {
 711       deps_write (pfile->deps, deps_stream, 72);
 712
 713       if (CPP_OPTION (pfile, deps.phony_targets))
 714         deps_phony_targets (pfile->deps, deps_stream);
 715     }
 716
 717   /* Report on headers that could use multiple include guards.  */
 718   if (CPP_OPTION (pfile, print_include_names))
 719     _cpp_report_missing_guards (pfile);
 720 }
 721
 722 static void
 723 post_options (cpp_reader *pfile)
 724 {
 725   /* -Wtraditional is not useful in C++ mode.  */
 726   if (CPP_OPTION (pfile, cplusplus))
 727     CPP_OPTION (pfile, cpp_warn_traditional) = 0;
 728
 729   /* Permanently disable macro expansion if we are rescanning
 730      preprocessed text.  Read preprocesed source in ISO mode.  */
 731   if (CPP_OPTION (pfile, preprocessed))
 732     {
 733       if (!CPP_OPTION (pfile, directives_only))
 734         pfile->state.prevent_expansion = 1;
 735       CPP_OPTION (pfile, traditional) = 0;
 736     }
 737
 738   if (CPP_OPTION (pfile, warn_trigraphs) == 2)
 739     CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
 740
 741   if (CPP_OPTION (pfile, traditional))
 742     {
 743       CPP_OPTION (pfile, cplusplus_comments) = 0;
 744
 745       CPP_OPTION (pfile, trigraphs) = 0;
 746       CPP_OPTION (pfile, warn_trigraphs) = 0;
 747     }
 748 }