libcpp/init.c

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