2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
4 2009, 2010, 2011 Free Software Foundation, Inc.
5 Contributed by Per Bothner, 1994-95.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
28 #include "localedir.h"
29 #include "filenames.h"
31 static void init_library (void);
32 static void mark_named_operators (cpp_reader *, int);
33 static void read_original_filename (cpp_reader *);
34 static void read_original_directory (cpp_reader *);
35 static void post_options (cpp_reader *);
37 /* If we have designated initializers (GCC >2.7) these tables can be
38 initialized, constant data. Otherwise, they have to be filled in at
40 #if HAVE_DESIGNATED_INITIALIZERS
42 #define init_trigraph_map() /* Nothing. */
43 #define TRIGRAPH_MAP \
44 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
47 #define s(p, v) [p] = v,
51 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
52 static void init_trigraph_map (void) { \
53 unsigned char *x = _cpp_trigraph_map;
56 #define s(p, v) x[p] = v;
61 s('=', '#') s(')', ']') s('!', '|')
62 s('(', '[') s('\'', '^') s('>', '}')
63 s('/', '\\') s('<', '{') s('-', '~')
70 /* A set of booleans indicating what CPP features each source language
76 char extended_numbers;
77 char extended_identifiers;
79 char cplusplus_comments;
85 static const struct lang_flags lang_defaults[] =
86 { /* c99 c++ xnum xid std // digr ulit rlit */
87 /* GNUC89 */ { 0, 0, 1, 0, 0, 1, 1, 0, 0 },
88 /* GNUC99 */ { 1, 0, 1, 0, 0, 1, 1, 1, 1 },
89 /* GNUC1X */ { 1, 0, 1, 0, 0, 1, 1, 1, 1 },
90 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0, 0 },
91 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 1, 0, 0 },
92 /* STDC99 */ { 1, 0, 1, 0, 1, 1, 1, 0, 0 },
93 /* STDC1X */ { 1, 0, 1, 0, 1, 1, 1, 1, 0 },
94 /* GNUCXX */ { 0, 1, 1, 0, 0, 1, 1, 0, 0 },
95 /* CXX98 */ { 0, 1, 1, 0, 1, 1, 1, 0, 0 },
96 /* GNUCXX0X */ { 1, 1, 1, 0, 0, 1, 1, 1, 1 },
97 /* CXX0X */ { 1, 1, 1, 0, 1, 1, 1, 1, 1 },
98 /* ASM */ { 0, 0, 1, 0, 0, 1, 0, 0, 0 }
99 /* xid should be 1 for GNUC99, STDC99, GNUCXX, CXX98, GNUCXX0X, and
100 CXX0X when no longer experimental (when all uses of identifiers
101 in the compiler have been audited for correct handling of
102 extended identifiers). */
105 /* Sets internal flags correctly for a given language. */
107 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
109 const struct lang_flags *l = &lang_defaults[(int) lang];
111 CPP_OPTION (pfile, lang) = lang;
113 CPP_OPTION (pfile, c99) = l->c99;
114 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
115 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
116 CPP_OPTION (pfile, extended_identifiers) = l->extended_identifiers;
117 CPP_OPTION (pfile, std) = l->std;
118 CPP_OPTION (pfile, trigraphs) = l->std;
119 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
120 CPP_OPTION (pfile, digraphs) = l->digraphs;
121 CPP_OPTION (pfile, uliterals) = l->uliterals;
122 CPP_OPTION (pfile, rliterals) = l->rliterals;
125 /* Initialize library global state. */
129 static int initialized = 0;
135 /* Set up the trigraph map. This doesn't need to do anything if
136 we were compiled with a compiler that supports C99 designated
138 init_trigraph_map ();
141 (void) bindtextdomain (PACKAGE, LOCALEDIR);
146 /* Initialize a cpp_reader structure. */
148 cpp_create_reader (enum c_lang lang, hash_table *table,
149 struct line_maps *line_table)
153 /* Initialize this instance of the library if it hasn't been already. */
156 pfile = XCNEW (cpp_reader);
158 cpp_set_lang (pfile, lang);
159 CPP_OPTION (pfile, warn_multichar) = 1;
160 CPP_OPTION (pfile, discard_comments) = 1;
161 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
162 CPP_OPTION (pfile, tabstop) = 8;
163 CPP_OPTION (pfile, operator_names) = 1;
164 CPP_OPTION (pfile, warn_trigraphs) = 2;
165 CPP_OPTION (pfile, warn_endif_labels) = 1;
166 CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
167 CPP_OPTION (pfile, cpp_warn_long_long) = 0;
168 CPP_OPTION (pfile, dollars_in_ident) = 1;
169 CPP_OPTION (pfile, warn_dollars) = 1;
170 CPP_OPTION (pfile, warn_variadic_macros) = 1;
171 CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
172 CPP_OPTION (pfile, warn_normalize) = normalized_C;
174 /* Default CPP arithmetic to something sensible for the host for the
175 benefit of dumb users like fix-header. */
176 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
177 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
178 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
179 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
180 CPP_OPTION (pfile, unsigned_char) = 0;
181 CPP_OPTION (pfile, unsigned_wchar) = 1;
182 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
184 /* Default to no charset conversion. */
185 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
186 CPP_OPTION (pfile, wide_charset) = 0;
188 /* Default the input character set to UTF-8. */
189 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
191 /* A fake empty "directory" used as the starting point for files
192 looked up without a search path. Name cannot be '/' because we
193 don't want to prepend anything at all to filenames using it. All
194 other entries are correct zero-initialized. */
195 pfile->no_search_path.name = (char *) "";
197 /* Initialize the line map. */
198 pfile->line_table = line_table;
200 /* Initialize lexer state. */
201 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
203 /* Set up static tokens. */
204 pfile->avoid_paste.type = CPP_PADDING;
205 pfile->avoid_paste.val.source = NULL;
206 pfile->eof.type = CPP_EOF;
207 pfile->eof.flags = 0;
209 /* Create a token buffer for the lexer. */
210 _cpp_init_tokenrun (&pfile->base_run, 250);
211 pfile->cur_run = &pfile->base_run;
212 pfile->cur_token = pfile->base_run.base;
214 /* Initialize the base context. */
215 pfile->context = &pfile->base_context;
216 pfile->base_context.macro = 0;
217 pfile->base_context.prev = pfile->base_context.next = 0;
219 /* Aligned and unaligned storage. */
220 pfile->a_buff = _cpp_get_buff (pfile, 0);
221 pfile->u_buff = _cpp_get_buff (pfile, 0);
223 /* Initialize table for push_macro/pop_macro. */
224 pfile->pushed_macros = 0;
226 /* Do not force token locations by default. */
227 pfile->forced_token_location_p = NULL;
229 /* The expression parser stack. */
230 _cpp_expand_op_stack (pfile);
232 /* Initialize the buffer obstack. */
233 _obstack_begin (&pfile->buffer_ob, 0, 0,
234 (void *(*) (long)) xmalloc,
235 (void (*) (void *)) free);
237 _cpp_init_files (pfile);
239 _cpp_init_hashtable (pfile, table);
244 /* Set the line_table entry in PFILE. This is called after reading a
245 PCH file, as the old line_table will be incorrect. */
247 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
249 pfile->line_table = line_table;
252 /* Free resources used by PFILE. Accessing PFILE after this function
253 returns leads to undefined behavior. Returns the error count. */
255 cpp_destroy (cpp_reader *pfile)
257 cpp_context *context, *contextn;
258 struct def_pragma_macro *pmacro;
259 tokenrun *run, *runn;
262 free (pfile->op_stack);
264 while (CPP_BUFFER (pfile) != NULL)
265 _cpp_pop_buffer (pfile);
267 free (pfile->out.base);
269 if (pfile->macro_buffer)
271 free (pfile->macro_buffer);
272 pfile->macro_buffer = NULL;
273 pfile->macro_buffer_len = 0;
277 deps_free (pfile->deps);
278 obstack_free (&pfile->buffer_ob, 0);
280 _cpp_destroy_hashtable (pfile);
281 _cpp_cleanup_files (pfile);
282 _cpp_destroy_iconv (pfile);
284 _cpp_free_buff (pfile->a_buff);
285 _cpp_free_buff (pfile->u_buff);
286 _cpp_free_buff (pfile->free_buffs);
288 for (run = &pfile->base_run; run; run = runn)
292 if (run != &pfile->base_run)
296 for (context = pfile->base_context.next; context; context = contextn)
298 contextn = context->next;
302 if (pfile->comments.entries)
304 for (i = 0; i < pfile->comments.count; i++)
305 free (pfile->comments.entries[i].comment);
307 free (pfile->comments.entries);
309 if (pfile->pushed_macros)
313 pmacro = pfile->pushed_macros;
314 pfile->pushed_macros = pmacro->next;
318 while (pfile->pushed_macros);
324 /* This structure defines one built-in identifier. A node will be
325 entered in the hash table under the name NAME, with value VALUE.
327 There are two tables of these. builtin_array holds all the
328 "builtin" macros: these are handled by builtin_macro() in
329 macro.c. Builtin is somewhat of a misnomer -- the property of
330 interest is that these macros require special code to compute their
331 expansions. The value is a "cpp_builtin_type" enumerator.
333 operator_array holds the C++ named operators. These are keywords
334 which act as aliases for punctuators. In C++, they cannot be
335 altered through #define, and #if recognizes them as operators. In
336 C, these are not entered into the hash table at all (but see
337 <iso646.h>). The value is a token-type enumerator. */
340 const uchar *const name;
341 const unsigned short len;
342 const unsigned short value;
343 const bool always_warn_if_redefined;
346 #define B(n, t, f) { DSC(n), t, f }
347 static const struct builtin_macro builtin_array[] =
349 B("__TIMESTAMP__", BT_TIMESTAMP, false),
350 B("__TIME__", BT_TIME, false),
351 B("__DATE__", BT_DATE, false),
352 B("__FILE__", BT_FILE, false),
353 B("__BASE_FILE__", BT_BASE_FILE, false),
354 B("__LINE__", BT_SPECLINE, true),
355 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
356 B("__COUNTER__", BT_COUNTER, true),
357 /* Keep builtins not used for -traditional-cpp at the end, and
358 update init_builtins() if any more are added. */
359 B("_Pragma", BT_PRAGMA, true),
360 B("__STDC__", BT_STDC, true),
364 struct builtin_operator
366 const uchar *const name;
367 const unsigned short len;
368 const unsigned short value;
371 #define B(n, t) { DSC(n), t }
372 static const struct builtin_operator operator_array[] =
374 B("and", CPP_AND_AND),
375 B("and_eq", CPP_AND_EQ),
376 B("bitand", CPP_AND),
378 B("compl", CPP_COMPL),
380 B("not_eq", CPP_NOT_EQ),
382 B("or_eq", CPP_OR_EQ),
384 B("xor_eq", CPP_XOR_EQ)
388 /* Mark the C++ named operators in the hash table. */
390 mark_named_operators (cpp_reader *pfile, int flags)
392 const struct builtin_operator *b;
394 for (b = operator_array;
395 b < (operator_array + ARRAY_SIZE (operator_array));
398 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
400 hp->is_directive = 0;
401 hp->directive_index = b->value;
405 /* Helper function of cpp_type2name. Return the string associated with
406 named operator TYPE. */
408 cpp_named_operator2name (enum cpp_ttype type)
410 const struct builtin_operator *b;
412 for (b = operator_array;
413 b < (operator_array + ARRAY_SIZE (operator_array));
416 if (type == b->value)
417 return (const char *) b->name;
424 cpp_init_special_builtins (cpp_reader *pfile)
426 const struct builtin_macro *b;
427 size_t n = ARRAY_SIZE (builtin_array);
429 if (CPP_OPTION (pfile, traditional))
431 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
432 || CPP_OPTION (pfile, std))
435 for (b = builtin_array; b < builtin_array + n; b++)
437 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
439 hp->flags |= NODE_BUILTIN;
440 if (b->always_warn_if_redefined
441 || CPP_OPTION (pfile, warn_builtin_macro_redefined))
442 hp->flags |= NODE_WARN;
443 hp->value.builtin = (enum cpp_builtin_type) b->value;
447 /* Read the builtins table above and enter them, and language-specific
448 macros, into the hash table. HOSTED is true if this is a hosted
451 cpp_init_builtins (cpp_reader *pfile, int hosted)
453 cpp_init_special_builtins (pfile);
455 if (!CPP_OPTION (pfile, traditional)
456 && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
457 || CPP_OPTION (pfile, std)))
458 _cpp_define_builtin (pfile, "__STDC__ 1");
460 if (CPP_OPTION (pfile, cplusplus))
461 _cpp_define_builtin (pfile, "__cplusplus 199711L");
462 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
463 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
464 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
465 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
466 else if (CPP_OPTION (pfile, lang) == CLK_STDC1X
467 || CPP_OPTION (pfile, lang) == CLK_GNUC1X)
468 _cpp_define_builtin (pfile, "__STDC_VERSION__ 201000L");
469 else if (CPP_OPTION (pfile, c99))
470 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
472 if (CPP_OPTION (pfile, uliterals)
473 && !CPP_OPTION (pfile, cplusplus))
475 _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1");
476 _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1");
480 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
482 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
484 if (CPP_OPTION (pfile, objc))
485 _cpp_define_builtin (pfile, "__OBJC__ 1");
488 /* Sanity-checks are dependent on command-line options, so it is
489 called as a subroutine of cpp_read_main_file (). */
491 static void sanity_checks (cpp_reader *);
492 static void sanity_checks (cpp_reader *pfile)
495 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
497 /* Sanity checks for assumptions about CPP arithmetic and target
498 type precisions made by cpplib. */
501 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
503 if (CPP_OPTION (pfile, precision) > max_precision)
504 cpp_error (pfile, CPP_DL_ICE,
505 "preprocessor arithmetic has maximum precision of %lu bits;"
506 " target requires %lu bits",
507 (unsigned long) max_precision,
508 (unsigned long) CPP_OPTION (pfile, precision));
510 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
511 cpp_error (pfile, CPP_DL_ICE,
512 "CPP arithmetic must be at least as precise as a target int");
514 if (CPP_OPTION (pfile, char_precision) < 8)
515 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
517 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
518 cpp_error (pfile, CPP_DL_ICE,
519 "target wchar_t is narrower than target char");
521 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
522 cpp_error (pfile, CPP_DL_ICE,
523 "target int is narrower than target char");
525 /* This is assumed in eval_token() and could be fixed if necessary. */
526 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
527 cpp_error (pfile, CPP_DL_ICE,
528 "CPP half-integer narrower than CPP character");
530 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
531 cpp_error (pfile, CPP_DL_ICE,
532 "CPP on this host cannot handle wide character constants over"
533 " %lu bits, but the target requires %lu bits",
534 (unsigned long) BITS_PER_CPPCHAR_T,
535 (unsigned long) CPP_OPTION (pfile, wchar_precision));
538 # define sanity_checks(PFILE)
541 /* This is called after options have been parsed, and partially
544 cpp_post_options (cpp_reader *pfile)
548 sanity_checks (pfile);
550 post_options (pfile);
552 /* Mark named operators before handling command line macros. */
554 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
555 flags |= NODE_OPERATOR;
556 if (CPP_OPTION (pfile, warn_cxx_operator_names))
557 flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR;
559 mark_named_operators (pfile, flags);
562 /* Setup for processing input from the file named FNAME, or stdin if
563 it is the empty string. Return the original filename
564 on success (e.g. foo.i->foo.c), or NULL on failure. */
566 cpp_read_main_file (cpp_reader *pfile, const char *fname)
568 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
571 pfile->deps = deps_init ();
573 /* Set the default target (if there is none already). */
574 deps_add_default_target (pfile->deps, fname);
578 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
579 if (_cpp_find_failed (pfile->main_file))
582 _cpp_stack_file (pfile, pfile->main_file, false);
584 /* For foo.i, read the original filename foo.c now, for the benefit
585 of the front ends. */
586 if (CPP_OPTION (pfile, preprocessed))
588 read_original_filename (pfile);
589 fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
594 /* For preprocessed files, if the first tokens are of the form # NUM.
595 handle the directive so we know the original file name. This will
596 generate file_change callbacks, which the front ends must handle
597 appropriately given their state of initialization. */
599 read_original_filename (cpp_reader *pfile)
601 const cpp_token *token, *token1;
603 /* Lex ahead; if the first tokens are of the form # NUM, then
604 process the directive, otherwise back up. */
605 token = _cpp_lex_direct (pfile);
606 if (token->type == CPP_HASH)
608 pfile->state.in_directive = 1;
609 token1 = _cpp_lex_direct (pfile);
610 _cpp_backup_tokens (pfile, 1);
611 pfile->state.in_directive = 0;
613 /* If it's a #line directive, handle it. */
614 if (token1->type == CPP_NUMBER
615 && _cpp_handle_directive (pfile, token->flags & PREV_WHITE))
617 read_original_directory (pfile);
622 /* Backup as if nothing happened. */
623 _cpp_backup_tokens (pfile, 1);
626 /* For preprocessed files, if the tokens following the first filename
627 line is of the form # <line> "/path/name//", handle the
628 directive so we know the original current directory. */
630 read_original_directory (cpp_reader *pfile)
632 const cpp_token *hash, *token;
634 /* Lex ahead; if the first tokens are of the form # NUM, then
635 process the directive, otherwise back up. */
636 hash = _cpp_lex_direct (pfile);
637 if (hash->type != CPP_HASH)
639 _cpp_backup_tokens (pfile, 1);
643 token = _cpp_lex_direct (pfile);
645 if (token->type != CPP_NUMBER)
647 _cpp_backup_tokens (pfile, 2);
651 token = _cpp_lex_direct (pfile);
653 if (token->type != CPP_STRING
654 || ! (token->val.str.len >= 5
655 && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-2])
656 && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-3])))
658 _cpp_backup_tokens (pfile, 3);
662 if (pfile->cb.dir_change)
664 char *debugdir = (char *) alloca (token->val.str.len - 3);
666 memcpy (debugdir, (const char *) token->val.str.text + 1,
667 token->val.str.len - 4);
668 debugdir[token->val.str.len - 4] = '\0';
670 pfile->cb.dir_change (pfile, debugdir);
674 /* This is called at the end of preprocessing. It pops the last
675 buffer and writes dependency output.
677 Maybe it should also reset state, such that you could call
678 cpp_start_read with a new filename to restart processing. */
680 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
682 /* Warn about unused macros before popping the final buffer. */
683 if (CPP_OPTION (pfile, warn_unused_macros))
684 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
686 /* lex.c leaves the final buffer on the stack. This it so that
687 it returns an unending stream of CPP_EOFs to the client. If we
688 popped the buffer, we'd dereference a NULL buffer pointer and
689 segfault. It's nice to allow the client to do worry-free excess
690 cpp_get_token calls. */
691 while (pfile->buffer)
692 _cpp_pop_buffer (pfile);
694 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
697 deps_write (pfile->deps, deps_stream, 72);
699 if (CPP_OPTION (pfile, deps.phony_targets))
700 deps_phony_targets (pfile->deps, deps_stream);
703 /* Report on headers that could use multiple include guards. */
704 if (CPP_OPTION (pfile, print_include_names))
705 _cpp_report_missing_guards (pfile);
709 post_options (cpp_reader *pfile)
711 /* -Wtraditional is not useful in C++ mode. */
712 if (CPP_OPTION (pfile, cplusplus))
713 CPP_OPTION (pfile, cpp_warn_traditional) = 0;
715 /* Permanently disable macro expansion if we are rescanning
716 preprocessed text. Read preprocesed source in ISO mode. */
717 if (CPP_OPTION (pfile, preprocessed))
719 if (!CPP_OPTION (pfile, directives_only))
720 pfile->state.prevent_expansion = 1;
721 CPP_OPTION (pfile, traditional) = 0;
724 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
725 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
727 if (CPP_OPTION (pfile, traditional))
729 CPP_OPTION (pfile, cplusplus_comments) = 0;
731 CPP_OPTION (pfile, trigraphs) = 0;
732 CPP_OPTION (pfile, warn_trigraphs) = 0;