libcpp/init.c

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