libcpp/init.c

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