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