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 /* The expression parser stack. */
227 _cpp_expand_op_stack (pfile
);
229 /* Initialize the buffer obstack. */
230 _obstack_begin (&pfile
->buffer_ob
, 0, 0,
231 (void *(*) (long)) xmalloc
,
232 (void (*) (void *)) free
);
234 _cpp_init_files (pfile
);
236 _cpp_init_hashtable (pfile
, table
);
241 /* Set the line_table entry in PFILE. This is called after reading a
242 PCH file, as the old line_table will be incorrect. */
244 cpp_set_line_map (cpp_reader
*pfile
, struct line_maps
*line_table
)
246 pfile
->line_table
= line_table
;
249 /* Free resources used by PFILE. Accessing PFILE after this function
250 returns leads to undefined behavior. Returns the error count. */
252 cpp_destroy (cpp_reader
*pfile
)
254 cpp_context
*context
, *contextn
;
255 struct def_pragma_macro
*pmacro
;
256 tokenrun
*run
, *runn
;
259 free (pfile
->op_stack
);
261 while (CPP_BUFFER (pfile
) != NULL
)
262 _cpp_pop_buffer (pfile
);
264 free (pfile
->out
.base
);
266 if (pfile
->macro_buffer
)
268 free (pfile
->macro_buffer
);
269 pfile
->macro_buffer
= NULL
;
270 pfile
->macro_buffer_len
= 0;
274 deps_free (pfile
->deps
);
275 obstack_free (&pfile
->buffer_ob
, 0);
277 _cpp_destroy_hashtable (pfile
);
278 _cpp_cleanup_files (pfile
);
279 _cpp_destroy_iconv (pfile
);
281 _cpp_free_buff (pfile
->a_buff
);
282 _cpp_free_buff (pfile
->u_buff
);
283 _cpp_free_buff (pfile
->free_buffs
);
285 for (run
= &pfile
->base_run
; run
; run
= runn
)
289 if (run
!= &pfile
->base_run
)
293 for (context
= pfile
->base_context
.next
; context
; context
= contextn
)
295 contextn
= context
->next
;
299 if (pfile
->comments
.entries
)
301 for (i
= 0; i
< pfile
->comments
.count
; i
++)
302 free (pfile
->comments
.entries
[i
].comment
);
304 free (pfile
->comments
.entries
);
306 if (pfile
->pushed_macros
)
310 pmacro
= pfile
->pushed_macros
;
311 pfile
->pushed_macros
= pmacro
->next
;
315 while (pfile
->pushed_macros
);
321 /* This structure defines one built-in identifier. A node will be
322 entered in the hash table under the name NAME, with value VALUE.
324 There are two tables of these. builtin_array holds all the
325 "builtin" macros: these are handled by builtin_macro() in
326 macro.c. Builtin is somewhat of a misnomer -- the property of
327 interest is that these macros require special code to compute their
328 expansions. The value is a "cpp_builtin_type" enumerator.
330 operator_array holds the C++ named operators. These are keywords
331 which act as aliases for punctuators. In C++, they cannot be
332 altered through #define, and #if recognizes them as operators. In
333 C, these are not entered into the hash table at all (but see
334 <iso646.h>). The value is a token-type enumerator. */
337 const uchar
*const name
;
338 const unsigned short len
;
339 const unsigned short value
;
340 const bool always_warn_if_redefined
;
343 #define B(n, t, f) { DSC(n), t, f }
344 static const struct builtin_macro builtin_array
[] =
346 B("__TIMESTAMP__", BT_TIMESTAMP
, false),
347 B("__TIME__", BT_TIME
, false),
348 B("__DATE__", BT_DATE
, false),
349 B("__FILE__", BT_FILE
, false),
350 B("__BASE_FILE__", BT_BASE_FILE
, false),
351 B("__LINE__", BT_SPECLINE
, true),
352 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL
, true),
353 B("__COUNTER__", BT_COUNTER
, true),
354 /* Keep builtins not used for -traditional-cpp at the end, and
355 update init_builtins() if any more are added. */
356 B("_Pragma", BT_PRAGMA
, true),
357 B("__STDC__", BT_STDC
, true),
361 struct builtin_operator
363 const uchar
*const name
;
364 const unsigned short len
;
365 const unsigned short value
;
368 #define B(n, t) { DSC(n), t }
369 static const struct builtin_operator operator_array
[] =
371 B("and", CPP_AND_AND
),
372 B("and_eq", CPP_AND_EQ
),
373 B("bitand", CPP_AND
),
375 B("compl", CPP_COMPL
),
377 B("not_eq", CPP_NOT_EQ
),
379 B("or_eq", CPP_OR_EQ
),
381 B("xor_eq", CPP_XOR_EQ
)
385 /* Mark the C++ named operators in the hash table. */
387 mark_named_operators (cpp_reader
*pfile
, int flags
)
389 const struct builtin_operator
*b
;
391 for (b
= operator_array
;
392 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
395 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
397 hp
->is_directive
= 0;
398 hp
->directive_index
= b
->value
;
402 /* Helper function of cpp_type2name. Return the string associated with
403 named operator TYPE. */
405 cpp_named_operator2name (enum cpp_ttype type
)
407 const struct builtin_operator
*b
;
409 for (b
= operator_array
;
410 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
413 if (type
== b
->value
)
414 return (const char *) b
->name
;
421 cpp_init_special_builtins (cpp_reader
*pfile
)
423 const struct builtin_macro
*b
;
424 size_t n
= ARRAY_SIZE (builtin_array
);
426 if (CPP_OPTION (pfile
, traditional
))
428 else if (! CPP_OPTION (pfile
, stdc_0_in_system_headers
)
429 || CPP_OPTION (pfile
, std
))
432 for (b
= builtin_array
; b
< builtin_array
+ n
; b
++)
434 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
436 hp
->flags
|= NODE_BUILTIN
;
437 if (b
->always_warn_if_redefined
438 || CPP_OPTION (pfile
, warn_builtin_macro_redefined
))
439 hp
->flags
|= NODE_WARN
;
440 hp
->value
.builtin
= (enum cpp_builtin_type
) b
->value
;
444 /* Read the builtins table above and enter them, and language-specific
445 macros, into the hash table. HOSTED is true if this is a hosted
448 cpp_init_builtins (cpp_reader
*pfile
, int hosted
)
450 cpp_init_special_builtins (pfile
);
452 if (!CPP_OPTION (pfile
, traditional
)
453 && (! CPP_OPTION (pfile
, stdc_0_in_system_headers
)
454 || CPP_OPTION (pfile
, std
)))
455 _cpp_define_builtin (pfile
, "__STDC__ 1");
457 if (CPP_OPTION (pfile
, cplusplus
))
458 _cpp_define_builtin (pfile
, "__cplusplus 199711L");
459 else if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
460 _cpp_define_builtin (pfile
, "__ASSEMBLER__ 1");
461 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC94
)
462 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199409L");
463 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC1X
464 || CPP_OPTION (pfile
, lang
) == CLK_GNUC1X
)
465 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 201000L");
466 else if (CPP_OPTION (pfile
, c99
))
467 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199901L");
469 if (CPP_OPTION (pfile
, uliterals
)
470 && !CPP_OPTION (pfile
, cplusplus
))
472 _cpp_define_builtin (pfile
, "__STDC_UTF_16__ 1");
473 _cpp_define_builtin (pfile
, "__STDC_UTF_32__ 1");
477 _cpp_define_builtin (pfile
, "__STDC_HOSTED__ 1");
479 _cpp_define_builtin (pfile
, "__STDC_HOSTED__ 0");
481 if (CPP_OPTION (pfile
, objc
))
482 _cpp_define_builtin (pfile
, "__OBJC__ 1");
485 /* Sanity-checks are dependent on command-line options, so it is
486 called as a subroutine of cpp_read_main_file (). */
488 static void sanity_checks (cpp_reader
*);
489 static void sanity_checks (cpp_reader
*pfile
)
492 size_t max_precision
= 2 * CHAR_BIT
* sizeof (cpp_num_part
);
494 /* Sanity checks for assumptions about CPP arithmetic and target
495 type precisions made by cpplib. */
498 cpp_error (pfile
, CPP_DL_ICE
, "cppchar_t must be an unsigned type");
500 if (CPP_OPTION (pfile
, precision
) > max_precision
)
501 cpp_error (pfile
, CPP_DL_ICE
,
502 "preprocessor arithmetic has maximum precision of %lu bits;"
503 " target requires %lu bits",
504 (unsigned long) max_precision
,
505 (unsigned long) CPP_OPTION (pfile
, precision
));
507 if (CPP_OPTION (pfile
, precision
) < CPP_OPTION (pfile
, int_precision
))
508 cpp_error (pfile
, CPP_DL_ICE
,
509 "CPP arithmetic must be at least as precise as a target int");
511 if (CPP_OPTION (pfile
, char_precision
) < 8)
512 cpp_error (pfile
, CPP_DL_ICE
, "target char is less than 8 bits wide");
514 if (CPP_OPTION (pfile
, wchar_precision
) < CPP_OPTION (pfile
, char_precision
))
515 cpp_error (pfile
, CPP_DL_ICE
,
516 "target wchar_t is narrower than target char");
518 if (CPP_OPTION (pfile
, int_precision
) < CPP_OPTION (pfile
, char_precision
))
519 cpp_error (pfile
, CPP_DL_ICE
,
520 "target int is narrower than target char");
522 /* This is assumed in eval_token() and could be fixed if necessary. */
523 if (sizeof (cppchar_t
) > sizeof (cpp_num_part
))
524 cpp_error (pfile
, CPP_DL_ICE
,
525 "CPP half-integer narrower than CPP character");
527 if (CPP_OPTION (pfile
, wchar_precision
) > BITS_PER_CPPCHAR_T
)
528 cpp_error (pfile
, CPP_DL_ICE
,
529 "CPP on this host cannot handle wide character constants over"
530 " %lu bits, but the target requires %lu bits",
531 (unsigned long) BITS_PER_CPPCHAR_T
,
532 (unsigned long) CPP_OPTION (pfile
, wchar_precision
));
535 # define sanity_checks(PFILE)
538 /* This is called after options have been parsed, and partially
541 cpp_post_options (cpp_reader
*pfile
)
545 sanity_checks (pfile
);
547 post_options (pfile
);
549 /* Mark named operators before handling command line macros. */
551 if (CPP_OPTION (pfile
, cplusplus
) && CPP_OPTION (pfile
, operator_names
))
552 flags
|= NODE_OPERATOR
;
553 if (CPP_OPTION (pfile
, warn_cxx_operator_names
))
554 flags
|= NODE_DIAGNOSTIC
| NODE_WARN_OPERATOR
;
556 mark_named_operators (pfile
, flags
);
559 /* Setup for processing input from the file named FNAME, or stdin if
560 it is the empty string. Return the original filename
561 on success (e.g. foo.i->foo.c), or NULL on failure. */
563 cpp_read_main_file (cpp_reader
*pfile
, const char *fname
)
565 if (CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
)
568 pfile
->deps
= deps_init ();
570 /* Set the default target (if there is none already). */
571 deps_add_default_target (pfile
->deps
, fname
);
575 = _cpp_find_file (pfile
, fname
, &pfile
->no_search_path
, false, 0);
576 if (_cpp_find_failed (pfile
->main_file
))
579 _cpp_stack_file (pfile
, pfile
->main_file
, false);
581 /* For foo.i, read the original filename foo.c now, for the benefit
582 of the front ends. */
583 if (CPP_OPTION (pfile
, preprocessed
))
585 read_original_filename (pfile
);
586 fname
= pfile
->line_table
->maps
[pfile
->line_table
->used
-1].to_file
;
591 /* For preprocessed files, if the first tokens are of the form # NUM.
592 handle the directive so we know the original file name. This will
593 generate file_change callbacks, which the front ends must handle
594 appropriately given their state of initialization. */
596 read_original_filename (cpp_reader
*pfile
)
598 const cpp_token
*token
, *token1
;
600 /* Lex ahead; if the first tokens are of the form # NUM, then
601 process the directive, otherwise back up. */
602 token
= _cpp_lex_direct (pfile
);
603 if (token
->type
== CPP_HASH
)
605 pfile
->state
.in_directive
= 1;
606 token1
= _cpp_lex_direct (pfile
);
607 _cpp_backup_tokens (pfile
, 1);
608 pfile
->state
.in_directive
= 0;
610 /* If it's a #line directive, handle it. */
611 if (token1
->type
== CPP_NUMBER
612 && _cpp_handle_directive (pfile
, token
->flags
& PREV_WHITE
))
614 read_original_directory (pfile
);
619 /* Backup as if nothing happened. */
620 _cpp_backup_tokens (pfile
, 1);
623 /* For preprocessed files, if the tokens following the first filename
624 line is of the form # <line> "/path/name//", handle the
625 directive so we know the original current directory. */
627 read_original_directory (cpp_reader
*pfile
)
629 const cpp_token
*hash
, *token
;
631 /* Lex ahead; if the first tokens are of the form # NUM, then
632 process the directive, otherwise back up. */
633 hash
= _cpp_lex_direct (pfile
);
634 if (hash
->type
!= CPP_HASH
)
636 _cpp_backup_tokens (pfile
, 1);
640 token
= _cpp_lex_direct (pfile
);
642 if (token
->type
!= CPP_NUMBER
)
644 _cpp_backup_tokens (pfile
, 2);
648 token
= _cpp_lex_direct (pfile
);
650 if (token
->type
!= CPP_STRING
651 || ! (token
->val
.str
.len
>= 5
652 && IS_DIR_SEPARATOR (token
->val
.str
.text
[token
->val
.str
.len
-2])
653 && IS_DIR_SEPARATOR (token
->val
.str
.text
[token
->val
.str
.len
-3])))
655 _cpp_backup_tokens (pfile
, 3);
659 if (pfile
->cb
.dir_change
)
661 char *debugdir
= (char *) alloca (token
->val
.str
.len
- 3);
663 memcpy (debugdir
, (const char *) token
->val
.str
.text
+ 1,
664 token
->val
.str
.len
- 4);
665 debugdir
[token
->val
.str
.len
- 4] = '\0';
667 pfile
->cb
.dir_change (pfile
, debugdir
);
671 /* This is called at the end of preprocessing. It pops the last
672 buffer and writes dependency output.
674 Maybe it should also reset state, such that you could call
675 cpp_start_read with a new filename to restart processing. */
677 cpp_finish (cpp_reader
*pfile
, FILE *deps_stream
)
679 /* Warn about unused macros before popping the final buffer. */
680 if (CPP_OPTION (pfile
, warn_unused_macros
))
681 cpp_forall_identifiers (pfile
, _cpp_warn_if_unused_macro
, NULL
);
683 /* lex.c leaves the final buffer on the stack. This it so that
684 it returns an unending stream of CPP_EOFs to the client. If we
685 popped the buffer, we'd dereference a NULL buffer pointer and
686 segfault. It's nice to allow the client to do worry-free excess
687 cpp_get_token calls. */
688 while (pfile
->buffer
)
689 _cpp_pop_buffer (pfile
);
691 if (CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
694 deps_write (pfile
->deps
, deps_stream
, 72);
696 if (CPP_OPTION (pfile
, deps
.phony_targets
))
697 deps_phony_targets (pfile
->deps
, deps_stream
);
700 /* Report on headers that could use multiple include guards. */
701 if (CPP_OPTION (pfile
, print_include_names
))
702 _cpp_report_missing_guards (pfile
);
706 post_options (cpp_reader
*pfile
)
708 /* -Wtraditional is not useful in C++ mode. */
709 if (CPP_OPTION (pfile
, cplusplus
))
710 CPP_OPTION (pfile
, cpp_warn_traditional
) = 0;
712 /* Permanently disable macro expansion if we are rescanning
713 preprocessed text. Read preprocesed source in ISO mode. */
714 if (CPP_OPTION (pfile
, preprocessed
))
716 if (!CPP_OPTION (pfile
, directives_only
))
717 pfile
->state
.prevent_expansion
= 1;
718 CPP_OPTION (pfile
, traditional
) = 0;
721 if (CPP_OPTION (pfile
, warn_trigraphs
) == 2)
722 CPP_OPTION (pfile
, warn_trigraphs
) = !CPP_OPTION (pfile
, trigraphs
);
724 if (CPP_OPTION (pfile
, traditional
))
726 CPP_OPTION (pfile
, cplusplus_comments
) = 0;
728 CPP_OPTION (pfile
, trigraphs
) = 0;
729 CPP_OPTION (pfile
, warn_trigraphs
) = 0;