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
 249   free (pfile->op_stack);
 250
 251   while (CPP_BUFFER (pfile) != NULL)
 252     _cpp_pop_buffer (pfile);
 253
 254   if (pfile->out.base)
 255     free (pfile->out.base);
 256
 257   if (pfile->macro_buffer)
 258     {
 259       free (pfile->macro_buffer);
 260       pfile->macro_buffer = NULL;
 261       pfile->macro_buffer_len = 0;
 262     }
 263
 264   if (pfile->deps)
 265     deps_free (pfile->deps);
 266   obstack_free (&pfile->buffer_ob, 0);
 267
 268   _cpp_destroy_hashtable (pfile);
 269   _cpp_cleanup_files (pfile);
 270   _cpp_destroy_iconv (pfile);
 271
 272   _cpp_free_buff (pfile->a_buff);
 273   _cpp_free_buff (pfile->u_buff);
 274   _cpp_free_buff (pfile->free_buffs);
 275
 276   for (run = &pfile->base_run; run; run = runn)
 277     {
 278       runn = run->next;
 279       free (run->base);
 280       if (run != &pfile->base_run)
 281         free (run);
 282     }
 283
 284   for (context = pfile->base_context.next; context; context = contextn)
 285     {
 286       contextn = context->next;
 287       free (context);
 288     }
 289
 290   free (pfile);
 291 }
 292
 293 /* This structure defines one built-in identifier.  A node will be
 294    entered in the hash table under the name NAME, with value VALUE.
 295
 296    There are two tables of these.  builtin_array holds all the
 297    "builtin" macros: these are handled by builtin_macro() in
 298    macro.c.  Builtin is somewhat of a misnomer -- the property of
 299    interest is that these macros require special code to compute their
 300    expansions.  The value is a "builtin_type" enumerator.
 301
 302    operator_array holds the C++ named operators.  These are keywords
 303    which act as aliases for punctuators.  In C++, they cannot be
 304    altered through #define, and #if recognizes them as operators.  In
 305    C, these are not entered into the hash table at all (but see
 306    <iso646.h>).  The value is a token-type enumerator.  */
 307 struct builtin_macro
 308 {
 309   const uchar *const name;
 310   const unsigned short len;
 311   const unsigned short value;
 312   const bool always_warn_if_redefined;
 313 };
 314
 315 #define B(n, t, f)    { DSC(n), t, f }
 316 static const struct builtin_macro builtin_array[] =
 317 {
 318   B("__TIMESTAMP__",     BT_TIMESTAMP,     false),
 319   B("__TIME__",          BT_TIME,          false),
 320   B("__DATE__",          BT_DATE,          false),
 321   B("__FILE__",          BT_FILE,          false),
 322   B("__BASE_FILE__",     BT_BASE_FILE,     false),
 323   B("__LINE__",          BT_SPECLINE,      true),
 324   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
 325   B("__COUNTER__",       BT_COUNTER,       true),
 326   /* Keep builtins not used for -traditional-cpp at the end, and
 327      update init_builtins() if any more are added.  */
 328   B("_Pragma",           BT_PRAGMA,        true),
 329   B("__STDC__",          BT_STDC,          true),
 330 };
 331 #undef B
 332
 333 struct builtin_operator
 334 {
 335   const uchar *const name;
 336   const unsigned short len;
 337   const unsigned short value;
 338 };
 339
 340 #define B(n, t)    { DSC(n), t }
 341 static const struct builtin_operator operator_array[] =
 342 {
 343   B("and",      CPP_AND_AND),
 344   B("and_eq",   CPP_AND_EQ),
 345   B("bitand",   CPP_AND),
 346   B("bitor",    CPP_OR),
 347   B("compl",    CPP_COMPL),
 348   B("not",      CPP_NOT),
 349   B("not_eq",   CPP_NOT_EQ),
 350   B("or",       CPP_OR_OR),
 351   B("or_eq",    CPP_OR_EQ),
 352   B("xor",      CPP_XOR),
 353   B("xor_eq",   CPP_XOR_EQ)
 354 };
 355 #undef B
 356
 357 /* Mark the C++ named operators in the hash table.  */
 358 static void
 359 mark_named_operators (cpp_reader *pfile)
 360 {
 361   const struct builtin_operator *b;
 362
 363   for (b = operator_array;
 364        b < (operator_array + ARRAY_SIZE (operator_array));
 365        b++)
 366     {
 367       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 368       hp->flags |= NODE_OPERATOR;
 369       hp->is_directive = 0;
 370       hp->directive_index = b->value;
 371     }
 372 }
 373
 374 void
 375 cpp_init_special_builtins (cpp_reader *pfile)
 376 {
 377   const struct builtin_macro *b;
 378   size_t n = ARRAY_SIZE (builtin_array);
 379
 380   if (CPP_OPTION (pfile, traditional))
 381     n -= 2;
 382   else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 383            || CPP_OPTION (pfile, std))
 384     n--;
 385
 386   for (b = builtin_array; b < builtin_array + n; b++)
 387     {
 388       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 389       hp->type = NT_MACRO;
 390       hp->flags |= NODE_BUILTIN;
 391       if (b->always_warn_if_redefined
 392           || CPP_OPTION (pfile, warn_builtin_macro_redefined))
 393         hp->flags |= NODE_WARN;
 394       hp->value.builtin = (enum builtin_type) b->value;
 395     }
 396 }
 397
 398 /* Read the builtins table above and enter them, and language-specific
 399    macros, into the hash table.  HOSTED is true if this is a hosted
 400    environment.  */
 401 void
 402 cpp_init_builtins (cpp_reader *pfile, int hosted)
 403 {
 404   cpp_init_special_builtins (pfile);
 405
 406   if (!CPP_OPTION (pfile, traditional)
 407       && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
 408           || CPP_OPTION (pfile, std)))
 409     _cpp_define_builtin (pfile, "__STDC__ 1");
 410
 411   if (CPP_OPTION (pfile, cplusplus))
 412     _cpp_define_builtin (pfile, "__cplusplus 1");
 413   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 414     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 415   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 416     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 417   else if (CPP_OPTION (pfile, c99))
 418     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 419
 420   if (hosted)
 421     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
 422   else
 423     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
 424
 425   if (CPP_OPTION (pfile, objc))
 426     _cpp_define_builtin (pfile, "__OBJC__ 1");
 427 }
 428
 429 /* Sanity-checks are dependent on command-line options, so it is
 430    called as a subroutine of cpp_read_main_file ().  */
 431 #if ENABLE_CHECKING
 432 static void sanity_checks (cpp_reader *);
 433 static void sanity_checks (cpp_reader *pfile)
 434 {
 435   cppchar_t test = 0;
 436   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
 437
 438   /* Sanity checks for assumptions about CPP arithmetic and target
 439      type precisions made by cpplib.  */
 440   test--;
 441   if (test < 1)
 442     cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
 443
 444   if (CPP_OPTION (pfile, precision) > max_precision)
 445     cpp_error (pfile, CPP_DL_ICE,
 446                "preprocessor arithmetic has maximum precision of %lu bits;"
 447                " target requires %lu bits",
 448                (unsigned long) max_precision,
 449                (unsigned long) CPP_OPTION (pfile, precision));
 450
 451   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
 452     cpp_error (pfile, CPP_DL_ICE,
 453                "CPP arithmetic must be at least as precise as a target int");
 454
 455   if (CPP_OPTION (pfile, char_precision) < 8)
 456     cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
 457
 458   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
 459     cpp_error (pfile, CPP_DL_ICE,
 460                "target wchar_t is narrower than target char");
 461
 462   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
 463     cpp_error (pfile, CPP_DL_ICE,
 464                "target int is narrower than target char");
 465
 466   /* This is assumed in eval_token() and could be fixed if necessary.  */
 467   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
 468     cpp_error (pfile, CPP_DL_ICE,
 469                "CPP half-integer narrower than CPP character");
 470
 471   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
 472     cpp_error (pfile, CPP_DL_ICE,
 473                "CPP on this host cannot handle wide character constants over"
 474                " %lu bits, but the target requires %lu bits",
 475                (unsigned long) BITS_PER_CPPCHAR_T,
 476                (unsigned long) CPP_OPTION (pfile, wchar_precision));
 477 }
 478 #else
 479 # define sanity_checks(PFILE)
 480 #endif
 481
 482 /* This is called after options have been parsed, and partially
 483    processed.  */
 484 void
 485 cpp_post_options (cpp_reader *pfile)
 486 {
 487   sanity_checks (pfile);
 488
 489   post_options (pfile);
 490
 491   /* Mark named operators before handling command line macros.  */
 492   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
 493     mark_named_operators (pfile);
 494 }
 495
 496 /* Setup for processing input from the file named FNAME, or stdin if
 497    it is the empty string.  Return the original filename
 498    on success (e.g. foo.i->foo.c), or NULL on failure.  */
 499 const char *
 500 cpp_read_main_file (cpp_reader *pfile, const char *fname)
 501 {
 502   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
 503     {
 504       if (!pfile->deps)
 505         pfile->deps = deps_init ();
 506
 507       /* Set the default target (if there is none already).  */
 508       deps_add_default_target (pfile->deps, fname);
 509     }
 510
 511   pfile->main_file
 512     = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
 513   if (_cpp_find_failed (pfile->main_file))
 514     return NULL;
 515
 516   _cpp_stack_file (pfile, pfile->main_file, false);
 517
 518   /* For foo.i, read the original filename foo.c now, for the benefit
 519      of the front ends.  */
 520   if (CPP_OPTION (pfile, preprocessed))
 521     {
 522       read_original_filename (pfile);
 523       fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
 524     }
 525   return fname;
 526 }
 527
 528 /* For preprocessed files, if the first tokens are of the form # NUM.
 529    handle the directive so we know the original file name.  This will
 530    generate file_change callbacks, which the front ends must handle
 531    appropriately given their state of initialization.  */
 532 static void
 533 read_original_filename (cpp_reader *pfile)
 534 {
 535   const cpp_token *token, *token1;
 536
 537   /* Lex ahead; if the first tokens are of the form # NUM, then
 538      process the directive, otherwise back up.  */
 539   token = _cpp_lex_direct (pfile);
 540   if (token->type == CPP_HASH)
 541     {
 542       pfile->state.in_directive = 1;
 543       token1 = _cpp_lex_direct (pfile);
 544       _cpp_backup_tokens (pfile, 1);
 545       pfile->state.in_directive = 0;
 546
 547       /* If it's a #line directive, handle it.  */
 548       if (token1->type == CPP_NUMBER)
 549         {
 550           _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
 551           read_original_directory (pfile);
 552           return;
 553         }
 554     }
 555
 556   /* Backup as if nothing happened.  */
 557   _cpp_backup_tokens (pfile, 1);
 558 }
 559
 560 /* For preprocessed files, if the tokens following the first filename
 561    line is of the form # <line> "/path/name//", handle the
 562    directive so we know the original current directory.  */
 563 static void
 564 read_original_directory (cpp_reader *pfile)
 565 {
 566   const cpp_token *hash, *token;
 567
 568   /* Lex ahead; if the first tokens are of the form # NUM, then
 569      process the directive, otherwise back up.  */
 570   hash = _cpp_lex_direct (pfile);
 571   if (hash->type != CPP_HASH)
 572     {
 573       _cpp_backup_tokens (pfile, 1);
 574       return;
 575     }
 576
 577   token = _cpp_lex_direct (pfile);
 578
 579   if (token->type != CPP_NUMBER)
 580     {
 581       _cpp_backup_tokens (pfile, 2);
 582       return;
 583     }
 584
 585   token = _cpp_lex_direct (pfile);
 586
 587   if (token->type != CPP_STRING
 588       || ! (token->val.str.len >= 5
 589             && token->val.str.text[token->val.str.len-2] == '/'
 590             && token->val.str.text[token->val.str.len-3] == '/'))
 591     {
 592       _cpp_backup_tokens (pfile, 3);
 593       return;
 594     }
 595
 596   if (pfile->cb.dir_change)
 597     {
 598       char *debugdir = (char *) alloca (token->val.str.len - 3);
 599
 600       memcpy (debugdir, (const char *) token->val.str.text + 1,
 601               token->val.str.len - 4);
 602       debugdir[token->val.str.len - 4] = '\0';
 603
 604       pfile->cb.dir_change (pfile, debugdir);
 605     }
 606 }
 607
 608 /* This is called at the end of preprocessing.  It pops the last
 609    buffer and writes dependency output, and returns the number of
 610    errors.
 611
 612    Maybe it should also reset state, such that you could call
 613    cpp_start_read with a new filename to restart processing.  */
 614 int
 615 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
 616 {
 617   /* Warn about unused macros before popping the final buffer.  */
 618   if (CPP_OPTION (pfile, warn_unused_macros))
 619     cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
 620
 621   /* lex.c leaves the final buffer on the stack.  This it so that
 622      it returns an unending stream of CPP_EOFs to the client.  If we
 623      popped the buffer, we'd dereference a NULL buffer pointer and
 624      segfault.  It's nice to allow the client to do worry-free excess
 625      cpp_get_token calls.  */
 626   while (pfile->buffer)
 627     _cpp_pop_buffer (pfile);
 628
 629   /* Don't write the deps file if there are errors.  */
 630   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
 631       && deps_stream && pfile->errors == 0)
 632     {
 633       deps_write (pfile->deps, deps_stream, 72);
 634
 635       if (CPP_OPTION (pfile, deps.phony_targets))
 636         deps_phony_targets (pfile->deps, deps_stream);
 637     }
 638
 639   /* Report on headers that could use multiple include guards.  */
 640   if (CPP_OPTION (pfile, print_include_names))
 641     _cpp_report_missing_guards (pfile);
 642
 643   return pfile->errors;
 644 }
 645
 646 static void
 647 post_options (cpp_reader *pfile)
 648 {
 649   /* -Wtraditional is not useful in C++ mode.  */
 650   if (CPP_OPTION (pfile, cplusplus))
 651     CPP_OPTION (pfile, warn_traditional) = 0;
 652
 653   /* Permanently disable macro expansion if we are rescanning
 654      preprocessed text.  Read preprocesed source in ISO mode.  */
 655   if (CPP_OPTION (pfile, preprocessed))
 656     {
 657       if (!CPP_OPTION (pfile, directives_only))
 658         pfile->state.prevent_expansion = 1;
 659       CPP_OPTION (pfile, traditional) = 0;
 660     }
 661
 662   if (CPP_OPTION (pfile, warn_trigraphs) == 2)
 663     CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
 664
 665   if (CPP_OPTION (pfile, traditional))
 666     {
 667       CPP_OPTION (pfile, cplusplus_comments) = 0;
 668
 669       /* Traditional CPP does not accurately track column information.  */
 670       CPP_OPTION (pfile, show_column) = 0;
 671       CPP_OPTION (pfile, trigraphs) = 0;
 672       CPP_OPTION (pfile, warn_trigraphs) = 0;
 673     }
 674 }