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