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   /* GNUC1X   */  { 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   /* STDC1X   */  { 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       /* Set up the trigraph map.  This doesn't need to do anything if
 138          we were compiled with a compiler that supports C99 designated
 139          initializers.  */
 140       init_trigraph_map ();
 141
 142 #ifdef ENABLE_NLS
 143        (void) bindtextdomain (PACKAGE, LOCALEDIR);
 144 #endif
 145     }
 146 }
 147
 148 /* Initialize a cpp_reader structure.  */
 149 cpp_reader *
 150 cpp_create_reader (enum c_lang lang, hash_table *table,
 151                    struct line_maps *line_table)
 152 {
 153   cpp_reader *pfile;
 154
 155   /* Initialize this instance of the library if it hasn't been already.  */
 156   init_library ();
 157
 158   pfile = XCNEW (cpp_reader);
 159   memset (&pfile->base_context, 0, sizeof (pfile->base_context));
 160
 161   cpp_set_lang (pfile, lang);
 162   CPP_OPTION (pfile, warn_multichar) = 1;
 163   CPP_OPTION (pfile, discard_comments) = 1;
 164   CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
 165   CPP_OPTION (pfile, tabstop) = 8;
 166   CPP_OPTION (pfile, operator_names) = 1;
 167   CPP_OPTION (pfile, warn_trigraphs) = 2;
 168   CPP_OPTION (pfile, warn_endif_labels) = 1;
 169   CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
 170   CPP_OPTION (pfile, cpp_warn_long_long) = 0;
 171   CPP_OPTION (pfile, dollars_in_ident) = 1;
 172   CPP_OPTION (pfile, warn_dollars) = 1;
 173   CPP_OPTION (pfile, warn_variadic_macros) = 1;
 174   CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
 175   CPP_OPTION (pfile, warn_normalize) = normalized_C;
 176
 177   /* Default CPP arithmetic to something sensible for the host for the
 178      benefit of dumb users like fix-header.  */
 179   CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
 180   CPP_OPTION (pfile, char_precision) = CHAR_BIT;
 181   CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
 182   CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
 183   CPP_OPTION (pfile, unsigned_char) = 0;
 184   CPP_OPTION (pfile, unsigned_wchar) = 1;
 185   CPP_OPTION (pfile, bytes_big_endian) = 1;  /* does not matter */
 186
 187   /* Default to no charset conversion.  */
 188   CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
 189   CPP_OPTION (pfile, wide_charset) = 0;
 190
 191   /* Default the input character set to UTF-8.  */
 192   CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
 193
 194   /* A fake empty "directory" used as the starting point for files
 195      looked up without a search path.  Name cannot be '/' because we
 196      don't want to prepend anything at all to filenames using it.  All
 197      other entries are correct zero-initialized.  */
 198   pfile->no_search_path.name = (char *) "";
 199
 200   /* Initialize the line map.  */
 201   pfile->line_table = line_table;
 202
 203   /* Initialize lexer state.  */
 204   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 205
 206   /* Set up static tokens.  */
 207   pfile->avoid_paste.type = CPP_PADDING;
 208   pfile->avoid_paste.val.source = NULL;
 209   pfile->eof.type = CPP_EOF;
 210   pfile->eof.flags = 0;
 211
 212   /* Create a token buffer for the lexer.  */
 213   _cpp_init_tokenrun (&pfile->base_run, 250);
 214   pfile->cur_run = &pfile->base_run;
 215   pfile->cur_token = pfile->base_run.base;
 216
 217   /* Initialize the base context.  */
 218   pfile->context = &pfile->base_context;
 219   pfile->base_context.c.macro = 0;
 220   pfile->base_context.prev = pfile->base_context.next = 0;
 221
 222   /* Aligned and unaligned storage.  */
 223   pfile->a_buff = _cpp_get_buff (pfile, 0);
 224   pfile->u_buff = _cpp_get_buff (pfile, 0);
 225
 226   /* Initialize table for push_macro/pop_macro.  */
 227   pfile->pushed_macros = 0;
 228
 229   /* Do not force token locations by default.  */
 230   pfile->forced_token_location_p = NULL;
 231
 232   /* The expression parser stack.  */
 233   _cpp_expand_op_stack (pfile);
 234
 235   /* Initialize the buffer obstack.  */
 236   _obstack_begin (&pfile->buffer_ob, 0, 0,
 237                   (void *(*) (long)) xmalloc,
 238                   (void (*) (void *)) free);
 239
 240   _cpp_init_files (pfile);
 241
 242   _cpp_init_hashtable (pfile, table);
 243
 244   return pfile;
 245 }
 246
 247 /* Set the line_table entry in PFILE.  This is called after reading a
 248    PCH file, as the old line_table will be incorrect.  */
 249 void
 250 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
 251 {
 252   pfile->line_table = line_table;
 253 }
 254
 255 /* Free resources used by PFILE.  Accessing PFILE after this function
 256    returns leads to undefined behavior.  Returns the error count.  */
 257 void
 258 cpp_destroy (cpp_reader *pfile)
 259 {
 260   cpp_context *context, *contextn;
 261   struct def_pragma_macro *pmacro;
 262   tokenrun *run, *runn;
 263   int i;
 264
 265   free (pfile->op_stack);
 266
 267   while (CPP_BUFFER (pfile) != NULL)
 268     _cpp_pop_buffer (pfile);
 269
 270   free (pfile->out.base);
 271
 272   if (pfile->macro_buffer)
 273     {
 274       free (pfile->macro_buffer);
 275       pfile->macro_buffer = NULL;
 276       pfile->macro_buffer_len = 0;
 277     }
 278
 279   if (pfile->deps)
 280     deps_free (pfile->deps);
 281   obstack_free (&pfile->buffer_ob, 0);
 282
 283   _cpp_destroy_hashtable (pfile);
 284   _cpp_cleanup_files (pfile);
 285   _cpp_destroy_iconv (pfile);
 286
 287   _cpp_free_buff (pfile->a_buff);
 288   _cpp_free_buff (pfile->u_buff);
 289   _cpp_free_buff (pfile->free_buffs);
 290
 291   for (run = &pfile->base_run; run; run = runn)
 292     {
 293       runn = run->next;
 294       free (run->base);
 295       if (run != &pfile->base_run)
 296         free (run);
 297     }
 298
 299   for (context = pfile->base_context.next; context; context = contextn)
 300     {
 301       contextn = context->next;
 302       free (context);
 303     }
 304
 305   if (pfile->comments.entries)
 306     {
 307       for (i = 0; i < pfile->comments.count; i++)
 308         free (pfile->comments.entries[i].comment);
 309
 310       free (pfile->comments.entries);
 311     }
 312   if (pfile->pushed_macros)
 313     {
 314       do
 315         {
 316           pmacro = pfile->pushed_macros;
 317           pfile->pushed_macros = pmacro->next;
 318           free (pmacro->name);
 319           free (pmacro);
 320         }
 321       while (pfile->pushed_macros);
 322     }
 323
 324   free (pfile);
 325 }
 326
 327 /* This structure defines one built-in identifier.  A node will be
 328    entered in the hash table under the name NAME, with value VALUE.
 329
 330    There are two tables of these.  builtin_array holds all the
 331    "builtin" macros: these are handled by builtin_macro() in
 332    macro.c.  Builtin is somewhat of a misnomer -- the property of
 333    interest is that these macros require special code to compute their
 334    expansions.  The value is a "cpp_builtin_type" enumerator.
 335
 336    operator_array holds the C++ named operators.  These are keywords
 337    which act as aliases for punctuators.  In C++, they cannot be
 338    altered through #define, and #if recognizes them as operators.  In
 339    C, these are not entered into the hash table at all (but see
 340    <iso646.h>).  The value is a token-type enumerator.  */
 341 struct builtin_macro
 342 {
 343   const uchar *const name;
 344   const unsigned short len;
 345   const unsigned short value;
 346   const bool always_warn_if_redefined;
 347 };
 348
 349 #define B(n, t, f)    { DSC(n), t, f }
 350 static const struct builtin_macro builtin_array[] =
 351 {
 352   B("__TIMESTAMP__",     BT_TIMESTAMP,     false),
 353   B("__TIME__",          BT_TIME,          false),
 354   B("__DATE__",          BT_DATE,          false),
 355   B("__FILE__",          BT_FILE,          false),
 356   B("__BASE_FILE__",     BT_BASE_FILE,     false),
 357   B("__LINE__",          BT_SPECLINE,      true),
 358   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
 359   B("__COUNTER__",       BT_COUNTER,       true),
 360   /* Keep builtins not used for -traditional-cpp at the end, and
 361      update init_builtins() if any more are added.  */
 362   B("_Pragma",           BT_PRAGMA,        true),
 363   B("__STDC__",          BT_STDC,          true),
 364 };
 365 #undef B
 366
 367 struct builtin_operator
 368 {
 369   const uchar *const name;
 370   const unsigned short len;
 371   const unsigned short value;
 372 };
 373
 374 #define B(n, t)    { DSC(n), t }
 375 static const struct builtin_operator operator_array[] =
 376 {
 377   B("and",      CPP_AND_AND),
 378   B("and_eq",   CPP_AND_EQ),
 379   B("bitand",   CPP_AND),
 380   B("bitor",    CPP_OR),
 381   B("compl",    CPP_COMPL),
 382   B("not",      CPP_NOT),
 383   B("not_eq",   CPP_NOT_EQ),
 384   B("or",       CPP_OR_OR),
 385   B("or_eq",    CPP_OR_EQ),
 386   B("xor",      CPP_XOR),
 387   B("xor_eq",   CPP_XOR_EQ)
 388 };
 389 #undef B
 390
 391 /* Mark the C++ named operators in the hash table.  */
 392 static void
 393 mark_named_operators (cpp_reader *pfile, int flags)
 394 {
 395   const struct builtin_operator *b;
 396
 397   for (b = operator_array;
 398        b < (operator_array + ARRAY_SIZE (operator_array));
 399        b++)
 400     {
 401       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 402       hp->flags |= flags;
 403       hp->is_directive = 0;
 404       hp->directive_index = b->value;
 405     }
 406 }
 407
 408 /* Helper function of cpp_type2name. Return the string associated with
 409    named operator TYPE.  */
 410 const char *
 411 cpp_named_operator2name (enum cpp_ttype type)
 412 {
 413   const struct builtin_operator *b;
 414
 415   for (b = operator_array;
 416        b < (operator_array + ARRAY_SIZE (operator_array));
 417        b++)
 418     {
 419       if (type == b->value)
 420         return (const char *) b->name;
 421     }
 422
 423   return NULL;
 424 }
 425
 426 void
 427 cpp_init_special_builtins (cpp_reader *pfile)
 428 {
 429   const struct builtin_macro *b;
 430   size_t n = ARRAY_SIZE (builtin_array);
 431
 432   if (CPP_OPTION (pfile, traditional))
 433     n -= 2;
 434   else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 435            || CPP_OPTION (pfile, std))
 436     n--;
 437
 438   for (b = builtin_array; b < builtin_array + n; b++)
 439     {
 440       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 441       hp->type = NT_MACRO;
 442       hp->flags |= NODE_BUILTIN;
 443       if (b->always_warn_if_redefined
 444           || CPP_OPTION (pfile, warn_builtin_macro_redefined))
 445         hp->flags |= NODE_WARN;
 446       hp->value.builtin = (enum cpp_builtin_type) b->value;
 447     }
 448 }
 449
 450 /* Read the builtins table above and enter them, and language-specific
 451    macros, into the hash table.  HOSTED is true if this is a hosted
 452    environment.  */
 453 void
 454 cpp_init_builtins (cpp_reader *pfile, int hosted)
 455 {
 456   cpp_init_special_builtins (pfile);
 457
 458   if (!CPP_OPTION (pfile, traditional)
 459       && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 460           || CPP_OPTION (pfile, std)))
 461     _cpp_define_builtin (pfile, "__STDC__ 1");
 462
 463   if (CPP_OPTION (pfile, cplusplus))
 464     {
 465       if (CPP_OPTION (pfile, lang) == CLK_CXX11
 466            || CPP_OPTION (pfile, lang) == CLK_GNUCXX11)
 467         _cpp_define_builtin (pfile, "__cplusplus 201103L");
 468       else
 469         _cpp_define_builtin (pfile, "__cplusplus 199711L");
 470     }
 471   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 472     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 473   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 474     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 475   else if (CPP_OPTION (pfile, lang) == CLK_STDC1X
 476            || CPP_OPTION (pfile, lang) == CLK_GNUC1X)
 477     _cpp_define_builtin (pfile, "__STDC_VERSION__ 201000L");
 478   else if (CPP_OPTION (pfile, c99))
 479     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 480
 481   if (CPP_OPTION (pfile, uliterals)
 482       && !CPP_OPTION (pfile, cplusplus))
 483     {
 484       _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1");
 485       _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1");
 486     }
 487
 488   if (hosted)
 489     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
 490   else
 491     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
 492
 493   if (CPP_OPTION (pfile, objc))
 494     _cpp_define_builtin (pfile, "__OBJC__ 1");
 495 }
 496
 497 /* Sanity-checks are dependent on command-line options, so it is
 498    called as a subroutine of cpp_read_main_file ().  */
 499 #if ENABLE_CHECKING
 500 static void sanity_checks (cpp_reader *);
 501 static void sanity_checks (cpp_reader *pfile)
 502 {
 503   cppchar_t test = 0;
 504   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
 505
 506   /* Sanity checks for assumptions about CPP arithmetic and target
 507      type precisions made by cpplib.  */
 508   test--;
 509   if (test < 1)
 510     cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
 511
 512   if (CPP_OPTION (pfile, precision) > max_precision)
 513     cpp_error (pfile, CPP_DL_ICE,
 514                "preprocessor arithmetic has maximum precision of %lu bits;"
 515                " target requires %lu bits",
 516                (unsigned long) max_precision,
 517                (unsigned long) CPP_OPTION (pfile, precision));
 518
 519   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
 520     cpp_error (pfile, CPP_DL_ICE,
 521                "CPP arithmetic must be at least as precise as a target int");
 522
 523   if (CPP_OPTION (pfile, char_precision) < 8)
 524     cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
 525
 526   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
 527     cpp_error (pfile, CPP_DL_ICE,
 528                "target wchar_t is narrower than target char");
 529
 530   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
 531     cpp_error (pfile, CPP_DL_ICE,
 532                "target int is narrower than target char");
 533
 534   /* This is assumed in eval_token() and could be fixed if necessary.  */
 535   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
 536     cpp_error (pfile, CPP_DL_ICE,
 537                "CPP half-integer narrower than CPP character");
 538
 539   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
 540     cpp_error (pfile, CPP_DL_ICE,
 541                "CPP on this host cannot handle wide character constants over"
 542                " %lu bits, but the target requires %lu bits",
 543                (unsigned long) BITS_PER_CPPCHAR_T,
 544                (unsigned long) CPP_OPTION (pfile, wchar_precision));
 545 }
 546 #else
 547 # define sanity_checks(PFILE)
 548 #endif
 549
 550 /* This is called after options have been parsed, and partially
 551    processed.  */
 552 void
 553 cpp_post_options (cpp_reader *pfile)
 554 {
 555   int flags;
 556
 557   sanity_checks (pfile);
 558
 559   post_options (pfile);
 560
 561   /* Mark named operators before handling command line macros.  */
 562   flags = 0;
 563   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
 564     flags |= NODE_OPERATOR;
 565   if (CPP_OPTION (pfile, warn_cxx_operator_names))
 566     flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR;
 567   if (flags != 0)
 568     mark_named_operators (pfile, flags);
 569 }
 570
 571 /* Setup for processing input from the file named FNAME, or stdin if
 572    it is the empty string.  Return the original filename
 573    on success (e.g. foo.i->foo.c), or NULL on failure.  */
 574 const char *
 575 cpp_read_main_file (cpp_reader *pfile, const char *fname)
 576 {
 577   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
 578     {
 579       if (!pfile->deps)
 580         pfile->deps = deps_init ();
 581
 582       /* Set the default target (if there is none already).  */
 583       deps_add_default_target (pfile->deps, fname);
 584     }
 585
 586   pfile->main_file
 587     = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
 588   if (_cpp_find_failed (pfile->main_file))
 589     return NULL;
 590
 591   _cpp_stack_file (pfile, pfile->main_file, false);
 592
 593   /* For foo.i, read the original filename foo.c now, for the benefit
 594      of the front ends.  */
 595   if (CPP_OPTION (pfile, preprocessed))
 596     {
 597       read_original_filename (pfile);
 598       fname =
 599         ORDINARY_MAP_FILE_NAME
 600         ((LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table)));
 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 }