Mercurial > hg > CbC > CbC_gcc

comparison libcpp/init.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 3bfb6c00c1e0
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
1 /* CPP Library.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2009
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
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
12 later version.
13
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.
18
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/>. */
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
30 static void init_library (void);
31 static void mark_named_operators (cpp_reader *);
32 static void read_original_filename (cpp_reader *);
33 static void read_original_directory (cpp_reader *);
34 static 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
59 TRIGRAPH_MAP
60 s('=', '#') s(')', ']') s('!', '|')
61 s('(', '[') s('\'', '^') s('>', '}')
62 s('/', '\\') s('<', '{') s('-', '~')
63 END
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. */
71 struct 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
83 static 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. */
102 void
103 cpp_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. */
121 static void
122 init_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. */
142 cpp_reader *
143 cpp_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
219 /* The expression parser stack. */
220 _cpp_expand_op_stack (pfile);
221
222 /* Initialize the buffer obstack. */
223 _obstack_begin (&pfile->buffer_ob, 0, 0,
224 (void *(*) (long)) xmalloc,
225 (void (*) (void *)) free);
226
227 _cpp_init_files (pfile);
228
229 _cpp_init_hashtable (pfile, table);
230
231 return pfile;
232 }
233
234 /* Set the line_table entry in PFILE. This is called after reading a
235 PCH file, as the old line_table will be incorrect. */
236 void
237 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
238 {
239 pfile->line_table = line_table;
240 }
241
242 /* Free resources used by PFILE. Accessing PFILE after this function
243 returns leads to undefined behavior. Returns the error count. */
244 void
245 cpp_destroy (cpp_reader *pfile)
246 {
247 cpp_context *context, *contextn;
248 tokenrun *run, *runn;
249 int i;
250
251 free (pfile->op_stack);
252
253 while (CPP_BUFFER (pfile) != NULL)
254 _cpp_pop_buffer (pfile);
255
256 if (pfile->out.base)
257 free (pfile->out.base);
258
259 if (pfile->macro_buffer)
260 {
261 free (pfile->macro_buffer);
262 pfile->macro_buffer = NULL;
263 pfile->macro_buffer_len = 0;
264 }
265
266 if (pfile->deps)
267 deps_free (pfile->deps);
268 obstack_free (&pfile->buffer_ob, 0);
269
270 _cpp_destroy_hashtable (pfile);
271 _cpp_cleanup_files (pfile);
272 _cpp_destroy_iconv (pfile);
273
274 _cpp_free_buff (pfile->a_buff);
275 _cpp_free_buff (pfile->u_buff);
276 _cpp_free_buff (pfile->free_buffs);
277
278 for (run = &pfile->base_run; run; run = runn)
279 {
280 runn = run->next;
281 free (run->base);
282 if (run != &pfile->base_run)
283 free (run);
284 }
285
286 for (context = pfile->base_context.next; context; context = contextn)
287 {
288 contextn = context->next;
289 free (context);
290 }
291
292 if (pfile->comments.entries)
293 {
294 for (i = 0; i < pfile->comments.count; i++)
295 free (pfile->comments.entries[i].comment);
296
297 free (pfile->comments.entries);
298 }
299
300 free (pfile);
301 }
302
303 /* This structure defines one built-in identifier. A node will be
304 entered in the hash table under the name NAME, with value VALUE.
305
306 There are two tables of these. builtin_array holds all the
307 "builtin" macros: these are handled by builtin_macro() in
308 macro.c. Builtin is somewhat of a misnomer -- the property of
309 interest is that these macros require special code to compute their
310 expansions. The value is a "builtin_type" enumerator.
311
312 operator_array holds the C++ named operators. These are keywords
313 which act as aliases for punctuators. In C++, they cannot be
314 altered through #define, and #if recognizes them as operators. In
315 C, these are not entered into the hash table at all (but see
316 <iso646.h>). The value is a token-type enumerator. */
317 struct builtin_macro
318 {
319 const uchar *const name;
320 const unsigned short len;
321 const unsigned short value;
322 const bool always_warn_if_redefined;
323 };
324
325 #define B(n, t, f) { DSC(n), t, f }
326 static const struct builtin_macro builtin_array[] =
327 {
328 B("__TIMESTAMP__", BT_TIMESTAMP, false),
329 B("__TIME__", BT_TIME, false),
330 B("__DATE__", BT_DATE, false),
331 B("__FILE__", BT_FILE, false),
332 B("__BASE_FILE__", BT_BASE_FILE, false),
333 B("__LINE__", BT_SPECLINE, true),
334 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
335 B("__COUNTER__", BT_COUNTER, true),
336 /* Keep builtins not used for -traditional-cpp at the end, and
337 update init_builtins() if any more are added. */
338 B("_Pragma", BT_PRAGMA, true),
339 B("__STDC__", BT_STDC, true),
340 };
341 #undef B
342
343 struct builtin_operator
344 {
345 const uchar *const name;
346 const unsigned short len;
347 const unsigned short value;
348 };
349
350 #define B(n, t) { DSC(n), t }
351 static const struct builtin_operator operator_array[] =
352 {
353 B("and", CPP_AND_AND),
354 B("and_eq", CPP_AND_EQ),
355 B("bitand", CPP_AND),
356 B("bitor", CPP_OR),
357 B("compl", CPP_COMPL),
358 B("not", CPP_NOT),
359 B("not_eq", CPP_NOT_EQ),
360 B("or", CPP_OR_OR),
361 B("or_eq", CPP_OR_EQ),
362 B("xor", CPP_XOR),
363 B("xor_eq", CPP_XOR_EQ)
364 };
365 #undef B
366
367 /* Mark the C++ named operators in the hash table. */
368 static void
369 mark_named_operators (cpp_reader *pfile)
370 {
371 const struct builtin_operator *b;
372
373 for (b = operator_array;
374 b < (operator_array + ARRAY_SIZE (operator_array));
375 b++)
376 {
377 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
378 hp->flags |= NODE_OPERATOR;
379 hp->is_directive = 0;
380 hp->directive_index = b->value;
381 }
382 }
383
384 void
385 cpp_init_special_builtins (cpp_reader *pfile)
386 {
387 const struct builtin_macro *b;
388 size_t n = ARRAY_SIZE (builtin_array);
389
390 if (CPP_OPTION (pfile, traditional))
391 n -= 2;
392 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
393 || CPP_OPTION (pfile, std))
394 n--;
395
396 for (b = builtin_array; b < builtin_array + n; b++)
397 {
398 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
399 hp->type = NT_MACRO;
400 hp->flags |= NODE_BUILTIN;
401 if (b->always_warn_if_redefined
402 || CPP_OPTION (pfile, warn_builtin_macro_redefined))
403 hp->flags |= NODE_WARN;
404 hp->value.builtin = (enum builtin_type) b->value;
405 }
406 }
407
408 /* Read the builtins table above and enter them, and language-specific
409 macros, into the hash table. HOSTED is true if this is a hosted
410 environment. */
411 void
412 cpp_init_builtins (cpp_reader *pfile, int hosted)
413 {
414 cpp_init_special_builtins (pfile);
415
416 if (!CPP_OPTION (pfile, traditional)
417 && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
418 || CPP_OPTION (pfile, std)))
419 _cpp_define_builtin (pfile, "__STDC__ 1");
420
421 if (CPP_OPTION (pfile, cplusplus))
422 _cpp_define_builtin (pfile, "__cplusplus 1");
423 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
424 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
425 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
426 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
427 else if (CPP_OPTION (pfile, c99))
428 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
429
430 if (hosted)
431 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
432 else
433 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
434
435 if (CPP_OPTION (pfile, objc))
436 _cpp_define_builtin (pfile, "__OBJC__ 1");
437 }
438
439 /* Sanity-checks are dependent on command-line options, so it is
440 called as a subroutine of cpp_read_main_file (). */
441 #if ENABLE_CHECKING
442 static void sanity_checks (cpp_reader *);
443 static void sanity_checks (cpp_reader *pfile)
444 {
445 cppchar_t test = 0;
446 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
447
448 /* Sanity checks for assumptions about CPP arithmetic and target
449 type precisions made by cpplib. */
450 test--;
451 if (test < 1)
452 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
453
454 if (CPP_OPTION (pfile, precision) > max_precision)
455 cpp_error (pfile, CPP_DL_ICE,
456 "preprocessor arithmetic has maximum precision of %lu bits;"
457 " target requires %lu bits",
458 (unsigned long) max_precision,
459 (unsigned long) CPP_OPTION (pfile, precision));
460
461 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
462 cpp_error (pfile, CPP_DL_ICE,
463 "CPP arithmetic must be at least as precise as a target int");
464
465 if (CPP_OPTION (pfile, char_precision) < 8)
466 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
467
468 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
469 cpp_error (pfile, CPP_DL_ICE,
470 "target wchar_t is narrower than target char");
471
472 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
473 cpp_error (pfile, CPP_DL_ICE,
474 "target int is narrower than target char");
475
476 /* This is assumed in eval_token() and could be fixed if necessary. */
477 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
478 cpp_error (pfile, CPP_DL_ICE,
479 "CPP half-integer narrower than CPP character");
480
481 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
482 cpp_error (pfile, CPP_DL_ICE,
483 "CPP on this host cannot handle wide character constants over"
484 " %lu bits, but the target requires %lu bits",
485 (unsigned long) BITS_PER_CPPCHAR_T,
486 (unsigned long) CPP_OPTION (pfile, wchar_precision));
487 }
488 #else
489 # define sanity_checks(PFILE)
490 #endif
491
492 /* This is called after options have been parsed, and partially
493 processed. */
494 void
495 cpp_post_options (cpp_reader *pfile)
496 {
497 sanity_checks (pfile);
498
499 post_options (pfile);
500
501 /* Mark named operators before handling command line macros. */
502 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
503 mark_named_operators (pfile);
504 }
505
506 /* Setup for processing input from the file named FNAME, or stdin if
507 it is the empty string. Return the original filename
508 on success (e.g. foo.i->foo.c), or NULL on failure. */
509 const char *
510 cpp_read_main_file (cpp_reader *pfile, const char *fname)
511 {
512 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
513 {
514 if (!pfile->deps)
515 pfile->deps = deps_init ();
516
517 /* Set the default target (if there is none already). */
518 deps_add_default_target (pfile->deps, fname);
519 }
520
521 pfile->main_file
522 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
523 if (_cpp_find_failed (pfile->main_file))
524 return NULL;
525
526 _cpp_stack_file (pfile, pfile->main_file, false);
527
528 /* For foo.i, read the original filename foo.c now, for the benefit
529 of the front ends. */
530 if (CPP_OPTION (pfile, preprocessed))
531 {
532 read_original_filename (pfile);
533 fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
534 }
535 return fname;
536 }
537
538 /* For preprocessed files, if the first tokens are of the form # NUM.
539 handle the directive so we know the original file name. This will
540 generate file_change callbacks, which the front ends must handle
541 appropriately given their state of initialization. */
542 static void
543 read_original_filename (cpp_reader *pfile)
544 {
545 const cpp_token *token, *token1;
546
547 /* Lex ahead; if the first tokens are of the form # NUM, then
548 process the directive, otherwise back up. */
549 token = _cpp_lex_direct (pfile);
550 if (token->type == CPP_HASH)
551 {
552 pfile->state.in_directive = 1;
553 token1 = _cpp_lex_direct (pfile);
554 _cpp_backup_tokens (pfile, 1);
555 pfile->state.in_directive = 0;
556
557 /* If it's a #line directive, handle it. */
558 if (token1->type == CPP_NUMBER)
559 {
560 _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
561 read_original_directory (pfile);
562 return;
563 }
564 }
565
566 /* Backup as if nothing happened. */
567 _cpp_backup_tokens (pfile, 1);
568 }
569
570 /* For preprocessed files, if the tokens following the first filename
571 line is of the form # <line> "/path/name//", handle the
572 directive so we know the original current directory. */
573 static void
574 read_original_directory (cpp_reader *pfile)
575 {
576 const cpp_token *hash, *token;
577
578 /* Lex ahead; if the first tokens are of the form # NUM, then
579 process the directive, otherwise back up. */
580 hash = _cpp_lex_direct (pfile);
581 if (hash->type != CPP_HASH)
582 {
583 _cpp_backup_tokens (pfile, 1);
584 return;
585 }
586
587 token = _cpp_lex_direct (pfile);
588
589 if (token->type != CPP_NUMBER)
590 {
591 _cpp_backup_tokens (pfile, 2);
592 return;
593 }
594
595 token = _cpp_lex_direct (pfile);
596
597 if (token->type != CPP_STRING
598 || ! (token->val.str.len >= 5
599 && token->val.str.text[token->val.str.len-2] == '/'
600 && token->val.str.text[token->val.str.len-3] == '/'))
601 {
602 _cpp_backup_tokens (pfile, 3);
603 return;
604 }
605
606 if (pfile->cb.dir_change)
607 {
608 char *debugdir = (char *) alloca (token->val.str.len - 3);
609
610 memcpy (debugdir, (const char *) token->val.str.text + 1,
611 token->val.str.len - 4);
612 debugdir[token->val.str.len - 4] = '\0';
613
614 pfile->cb.dir_change (pfile, debugdir);
615 }
616 }
617
618 /* This is called at the end of preprocessing. It pops the last
619 buffer and writes dependency output, and returns the number of
620 errors.
621
622 Maybe it should also reset state, such that you could call
623 cpp_start_read with a new filename to restart processing. */
624 int
625 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
626 {
627 /* Warn about unused macros before popping the final buffer. */
628 if (CPP_OPTION (pfile, warn_unused_macros))
629 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
630
631 /* lex.c leaves the final buffer on the stack. This it so that
632 it returns an unending stream of CPP_EOFs to the client. If we
633 popped the buffer, we'd dereference a NULL buffer pointer and
634 segfault. It's nice to allow the client to do worry-free excess
635 cpp_get_token calls. */
636 while (pfile->buffer)
637 _cpp_pop_buffer (pfile);
638
639 /* Don't write the deps file if there are errors. */
640 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
641 && deps_stream && pfile->errors == 0)
642 {
643 deps_write (pfile->deps, deps_stream, 72);
644
645 if (CPP_OPTION (pfile, deps.phony_targets))
646 deps_phony_targets (pfile->deps, deps_stream);
647 }
648
649 /* Report on headers that could use multiple include guards. */
650 if (CPP_OPTION (pfile, print_include_names))
651 _cpp_report_missing_guards (pfile);
652
653 return pfile->errors;
654 }
655
656 static void
657 post_options (cpp_reader *pfile)
658 {
659 /* -Wtraditional is not useful in C++ mode. */
660 if (CPP_OPTION (pfile, cplusplus))
661 CPP_OPTION (pfile, warn_traditional) = 0;
662
663 /* Permanently disable macro expansion if we are rescanning
664 preprocessed text. Read preprocesed source in ISO mode. */
665 if (CPP_OPTION (pfile, preprocessed))
666 {
667 if (!CPP_OPTION (pfile, directives_only))
668 pfile->state.prevent_expansion = 1;
669 CPP_OPTION (pfile, traditional) = 0;
670 }
671
672 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
673 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
674
675 if (CPP_OPTION (pfile, traditional))
676 {
677 CPP_OPTION (pfile, cplusplus_comments) = 0;
678
679 /* Traditional CPP does not accurately track column information. */
680 CPP_OPTION (pfile, show_column) = 0;
681 CPP_OPTION (pfile, trigraphs) = 0;
682 CPP_OPTION (pfile, warn_trigraphs) = 0;
683 }
684 }