libcpp/init.c

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