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