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