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