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