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