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