Daily bump.
[official-gcc.git] / libcpp / init.c
blob97510003dd813358ea10315dd95c20720e310309
1 /* CPP Library.
2 Copyright (C) 1986-2013 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
10 later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "cpplib.h"
24 #include "internal.h"
25 #include "mkdeps.h"
26 #include "localedir.h"
27 #include "filenames.h"
29 #ifndef ENABLE_CANONICAL_SYSTEM_HEADERS
30 #define ENABLE_CANONICAL_SYSTEM_HEADERS 0
31 #endif
33 static void init_library (void);
34 static void mark_named_operators (cpp_reader *, int);
35 static void read_original_filename (cpp_reader *);
36 static void read_original_directory (cpp_reader *);
37 static void post_options (cpp_reader *);
39 /* If we have designated initializers (GCC >2.7) these tables can be
40 initialized, constant data. Otherwise, they have to be filled in at
41 runtime. */
42 #if HAVE_DESIGNATED_INITIALIZERS
44 #define init_trigraph_map() /* Nothing. */
45 #define TRIGRAPH_MAP \
46 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
48 #define END };
49 #define s(p, v) [p] = v,
51 #else
53 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
54 static void init_trigraph_map (void) { \
55 unsigned char *x = _cpp_trigraph_map;
57 #define END }
58 #define s(p, v) x[p] = v;
60 #endif
62 TRIGRAPH_MAP
63 s('=', '#') s(')', ']') s('!', '|')
64 s('(', '[') s('\'', '^') s('>', '}')
65 s('/', '\\') s('<', '{') s('-', '~')
66 END
68 #undef s
69 #undef END
70 #undef TRIGRAPH_MAP
72 /* A set of booleans indicating what CPP features each source language
73 requires. */
74 struct lang_flags
76 char c99;
77 char cplusplus;
78 char extended_numbers;
79 char extended_identifiers;
80 char std;
81 char cplusplus_comments;
82 char digraphs;
83 char uliterals;
84 char rliterals;
85 char user_literals;
86 char binary_constants;
89 static const struct lang_flags lang_defaults[] =
90 { /* c99 c++ xnum xid std // digr ulit rlit udlit bin_cst */
91 /* GNUC89 */ { 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0 },
92 /* GNUC99 */ { 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0 },
93 /* GNUC11 */ { 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0 },
94 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
95 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
96 /* STDC99 */ { 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0 },
97 /* STDC11 */ { 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0 },
98 /* GNUCXX */ { 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0 },
99 /* CXX98 */ { 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0 },
100 /* GNUCXX11 */ { 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0 },
101 /* CXX11 */ { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 },
102 /* GNUCXX1Y */ { 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1 },
103 /* CXX1Y */ { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
104 /* ASM */ { 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 }
105 /* xid should be 1 for GNUC99, STDC99, GNUCXX, CXX98, GNUCXX11, CXX11,
106 GNUCXX1Y, and CXX1Y when no longer experimental (when all uses of
107 identifiers in the compiler have been audited for correct handling
108 of extended identifiers). */
111 /* Sets internal flags correctly for a given language. */
112 void
113 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
115 const struct lang_flags *l = &lang_defaults[(int) lang];
117 CPP_OPTION (pfile, lang) = lang;
119 CPP_OPTION (pfile, c99) = l->c99;
120 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
121 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
122 CPP_OPTION (pfile, extended_identifiers) = l->extended_identifiers;
123 CPP_OPTION (pfile, std) = l->std;
124 CPP_OPTION (pfile, trigraphs) = l->std;
125 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
126 CPP_OPTION (pfile, digraphs) = l->digraphs;
127 CPP_OPTION (pfile, uliterals) = l->uliterals;
128 CPP_OPTION (pfile, rliterals) = l->rliterals;
129 CPP_OPTION (pfile, user_literals) = l->user_literals;
130 CPP_OPTION (pfile, binary_constants) = l->binary_constants;
133 /* Initialize library global state. */
134 static void
135 init_library (void)
137 static int initialized = 0;
139 if (! initialized)
141 initialized = 1;
143 _cpp_init_lexer ();
145 /* Set up the trigraph map. This doesn't need to do anything if
146 we were compiled with a compiler that supports C99 designated
147 initializers. */
148 init_trigraph_map ();
150 #ifdef ENABLE_NLS
151 (void) bindtextdomain (PACKAGE, LOCALEDIR);
152 #endif
156 /* Initialize a cpp_reader structure. */
157 cpp_reader *
158 cpp_create_reader (enum c_lang lang, cpp_hash_table *table,
159 struct line_maps *line_table)
161 cpp_reader *pfile;
163 /* Initialize this instance of the library if it hasn't been already. */
164 init_library ();
166 pfile = XCNEW (cpp_reader);
167 memset (&pfile->base_context, 0, sizeof (pfile->base_context));
169 cpp_set_lang (pfile, lang);
170 CPP_OPTION (pfile, warn_multichar) = 1;
171 CPP_OPTION (pfile, discard_comments) = 1;
172 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
173 CPP_OPTION (pfile, tabstop) = 8;
174 CPP_OPTION (pfile, operator_names) = 1;
175 CPP_OPTION (pfile, warn_trigraphs) = 2;
176 CPP_OPTION (pfile, warn_endif_labels) = 1;
177 CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
178 CPP_OPTION (pfile, cpp_warn_long_long) = 0;
179 CPP_OPTION (pfile, dollars_in_ident) = 1;
180 CPP_OPTION (pfile, warn_dollars) = 1;
181 CPP_OPTION (pfile, warn_variadic_macros) = 1;
182 CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
183 /* By default, track locations of tokens resulting from macro
184 expansion. The '2' means, track the locations with the highest
185 accuracy. Read the comments for struct
186 cpp_options::track_macro_expansion to learn about the other
187 values. */
188 CPP_OPTION (pfile, track_macro_expansion) = 2;
189 CPP_OPTION (pfile, warn_normalize) = normalized_C;
190 CPP_OPTION (pfile, warn_literal_suffix) = 1;
191 CPP_OPTION (pfile, canonical_system_headers)
192 = ENABLE_CANONICAL_SYSTEM_HEADERS;
193 CPP_OPTION (pfile, ext_numeric_literals) = 1;
195 /* Default CPP arithmetic to something sensible for the host for the
196 benefit of dumb users like fix-header. */
197 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
198 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
199 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
200 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
201 CPP_OPTION (pfile, unsigned_char) = 0;
202 CPP_OPTION (pfile, unsigned_wchar) = 1;
203 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
205 /* Default to no charset conversion. */
206 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
207 CPP_OPTION (pfile, wide_charset) = 0;
209 /* Default the input character set to UTF-8. */
210 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
212 /* A fake empty "directory" used as the starting point for files
213 looked up without a search path. Name cannot be '/' because we
214 don't want to prepend anything at all to filenames using it. All
215 other entries are correct zero-initialized. */
216 pfile->no_search_path.name = (char *) "";
218 /* Initialize the line map. */
219 pfile->line_table = line_table;
221 /* Initialize lexer state. */
222 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
224 /* Set up static tokens. */
225 pfile->avoid_paste.type = CPP_PADDING;
226 pfile->avoid_paste.val.source = NULL;
227 pfile->eof.type = CPP_EOF;
228 pfile->eof.flags = 0;
230 /* Create a token buffer for the lexer. */
231 _cpp_init_tokenrun (&pfile->base_run, 250);
232 pfile->cur_run = &pfile->base_run;
233 pfile->cur_token = pfile->base_run.base;
235 /* Initialize the base context. */
236 pfile->context = &pfile->base_context;
237 pfile->base_context.c.macro = 0;
238 pfile->base_context.prev = pfile->base_context.next = 0;
240 /* Aligned and unaligned storage. */
241 pfile->a_buff = _cpp_get_buff (pfile, 0);
242 pfile->u_buff = _cpp_get_buff (pfile, 0);
244 /* Initialize table for push_macro/pop_macro. */
245 pfile->pushed_macros = 0;
247 /* Do not force token locations by default. */
248 pfile->forced_token_location_p = NULL;
250 /* The expression parser stack. */
251 _cpp_expand_op_stack (pfile);
253 /* Initialize the buffer obstack. */
254 _obstack_begin (&pfile->buffer_ob, 0, 0,
255 (void *(*) (long)) xmalloc,
256 (void (*) (void *)) free);
258 _cpp_init_files (pfile);
260 _cpp_init_hashtable (pfile, table);
262 return pfile;
265 /* Set the line_table entry in PFILE. This is called after reading a
266 PCH file, as the old line_table will be incorrect. */
267 void
268 cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
270 pfile->line_table = line_table;
273 /* Free resources used by PFILE. Accessing PFILE after this function
274 returns leads to undefined behavior. Returns the error count. */
275 void
276 cpp_destroy (cpp_reader *pfile)
278 cpp_context *context, *contextn;
279 struct def_pragma_macro *pmacro;
280 tokenrun *run, *runn;
281 int i;
283 free (pfile->op_stack);
285 while (CPP_BUFFER (pfile) != NULL)
286 _cpp_pop_buffer (pfile);
288 free (pfile->out.base);
290 if (pfile->macro_buffer)
292 free (pfile->macro_buffer);
293 pfile->macro_buffer = NULL;
294 pfile->macro_buffer_len = 0;
297 if (pfile->deps)
298 deps_free (pfile->deps);
299 obstack_free (&pfile->buffer_ob, 0);
301 _cpp_destroy_hashtable (pfile);
302 _cpp_cleanup_files (pfile);
303 _cpp_destroy_iconv (pfile);
305 _cpp_free_buff (pfile->a_buff);
306 _cpp_free_buff (pfile->u_buff);
307 _cpp_free_buff (pfile->free_buffs);
309 for (run = &pfile->base_run; run; run = runn)
311 runn = run->next;
312 free (run->base);
313 if (run != &pfile->base_run)
314 free (run);
317 for (context = pfile->base_context.next; context; context = contextn)
319 contextn = context->next;
320 free (context);
323 if (pfile->comments.entries)
325 for (i = 0; i < pfile->comments.count; i++)
326 free (pfile->comments.entries[i].comment);
328 free (pfile->comments.entries);
330 if (pfile->pushed_macros)
334 pmacro = pfile->pushed_macros;
335 pfile->pushed_macros = pmacro->next;
336 free (pmacro->name);
337 free (pmacro);
339 while (pfile->pushed_macros);
342 free (pfile);
345 /* This structure defines one built-in identifier. A node will be
346 entered in the hash table under the name NAME, with value VALUE.
348 There are two tables of these. builtin_array holds all the
349 "builtin" macros: these are handled by builtin_macro() in
350 macro.c. Builtin is somewhat of a misnomer -- the property of
351 interest is that these macros require special code to compute their
352 expansions. The value is a "cpp_builtin_type" enumerator.
354 operator_array holds the C++ named operators. These are keywords
355 which act as aliases for punctuators. In C++, they cannot be
356 altered through #define, and #if recognizes them as operators. In
357 C, these are not entered into the hash table at all (but see
358 <iso646.h>). The value is a token-type enumerator. */
359 struct builtin_macro
361 const uchar *const name;
362 const unsigned short len;
363 const unsigned short value;
364 const bool always_warn_if_redefined;
367 #define B(n, t, f) { DSC(n), t, f }
368 static const struct builtin_macro builtin_array[] =
370 B("__TIMESTAMP__", BT_TIMESTAMP, false),
371 B("__TIME__", BT_TIME, false),
372 B("__DATE__", BT_DATE, false),
373 B("__FILE__", BT_FILE, false),
374 B("__BASE_FILE__", BT_BASE_FILE, false),
375 B("__LINE__", BT_SPECLINE, true),
376 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
377 B("__COUNTER__", BT_COUNTER, true),
378 /* Keep builtins not used for -traditional-cpp at the end, and
379 update init_builtins() if any more are added. */
380 B("_Pragma", BT_PRAGMA, true),
381 B("__STDC__", BT_STDC, true),
383 #undef B
385 struct builtin_operator
387 const uchar *const name;
388 const unsigned short len;
389 const unsigned short value;
392 #define B(n, t) { DSC(n), t }
393 static const struct builtin_operator operator_array[] =
395 B("and", CPP_AND_AND),
396 B("and_eq", CPP_AND_EQ),
397 B("bitand", CPP_AND),
398 B("bitor", CPP_OR),
399 B("compl", CPP_COMPL),
400 B("not", CPP_NOT),
401 B("not_eq", CPP_NOT_EQ),
402 B("or", CPP_OR_OR),
403 B("or_eq", CPP_OR_EQ),
404 B("xor", CPP_XOR),
405 B("xor_eq", CPP_XOR_EQ)
407 #undef B
409 /* Mark the C++ named operators in the hash table. */
410 static void
411 mark_named_operators (cpp_reader *pfile, int flags)
413 const struct builtin_operator *b;
415 for (b = operator_array;
416 b < (operator_array + ARRAY_SIZE (operator_array));
417 b++)
419 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
420 hp->flags |= flags;
421 hp->is_directive = 0;
422 hp->directive_index = b->value;
426 /* Helper function of cpp_type2name. Return the string associated with
427 named operator TYPE. */
428 const char *
429 cpp_named_operator2name (enum cpp_ttype type)
431 const struct builtin_operator *b;
433 for (b = operator_array;
434 b < (operator_array + ARRAY_SIZE (operator_array));
435 b++)
437 if (type == b->value)
438 return (const char *) b->name;
441 return NULL;
444 void
445 cpp_init_special_builtins (cpp_reader *pfile)
447 const struct builtin_macro *b;
448 size_t n = ARRAY_SIZE (builtin_array);
450 if (CPP_OPTION (pfile, traditional))
451 n -= 2;
452 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
453 || CPP_OPTION (pfile, std))
454 n--;
456 for (b = builtin_array; b < builtin_array + n; b++)
458 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
459 hp->type = NT_MACRO;
460 hp->flags |= NODE_BUILTIN;
461 if (b->always_warn_if_redefined
462 || CPP_OPTION (pfile, warn_builtin_macro_redefined))
463 hp->flags |= NODE_WARN;
464 hp->value.builtin = (enum cpp_builtin_type) b->value;
468 /* Read the builtins table above and enter them, and language-specific
469 macros, into the hash table. HOSTED is true if this is a hosted
470 environment. */
471 void
472 cpp_init_builtins (cpp_reader *pfile, int hosted)
474 cpp_init_special_builtins (pfile);
476 if (!CPP_OPTION (pfile, traditional)
477 && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
478 || CPP_OPTION (pfile, std)))
479 _cpp_define_builtin (pfile, "__STDC__ 1");
481 if (CPP_OPTION (pfile, cplusplus))
483 if (CPP_OPTION (pfile, lang) == CLK_CXX1Y
484 || CPP_OPTION (pfile, lang) == CLK_GNUCXX1Y)
485 _cpp_define_builtin (pfile, "__cplusplus 201300L");
486 else if (CPP_OPTION (pfile, lang) == CLK_CXX11
487 || CPP_OPTION (pfile, lang) == CLK_GNUCXX11)
488 _cpp_define_builtin (pfile, "__cplusplus 201103L");
489 else
490 _cpp_define_builtin (pfile, "__cplusplus 199711L");
492 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
493 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
494 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
495 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
496 else if (CPP_OPTION (pfile, lang) == CLK_STDC11
497 || CPP_OPTION (pfile, lang) == CLK_GNUC11)
498 _cpp_define_builtin (pfile, "__STDC_VERSION__ 201112L");
499 else if (CPP_OPTION (pfile, c99))
500 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
502 if (CPP_OPTION (pfile, uliterals)
503 && !CPP_OPTION (pfile, cplusplus))
505 _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1");
506 _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1");
509 if (hosted)
510 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
511 else
512 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
514 if (CPP_OPTION (pfile, objc))
515 _cpp_define_builtin (pfile, "__OBJC__ 1");
518 /* Sanity-checks are dependent on command-line options, so it is
519 called as a subroutine of cpp_read_main_file (). */
520 #if ENABLE_CHECKING
521 static void sanity_checks (cpp_reader *);
522 static void sanity_checks (cpp_reader *pfile)
524 cppchar_t test = 0;
525 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
527 /* Sanity checks for assumptions about CPP arithmetic and target
528 type precisions made by cpplib. */
529 test--;
530 if (test < 1)
531 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
533 if (CPP_OPTION (pfile, precision) > max_precision)
534 cpp_error (pfile, CPP_DL_ICE,
535 "preprocessor arithmetic has maximum precision of %lu bits;"
536 " target requires %lu bits",
537 (unsigned long) max_precision,
538 (unsigned long) CPP_OPTION (pfile, precision));
540 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
541 cpp_error (pfile, CPP_DL_ICE,
542 "CPP arithmetic must be at least as precise as a target int");
544 if (CPP_OPTION (pfile, char_precision) < 8)
545 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
547 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
548 cpp_error (pfile, CPP_DL_ICE,
549 "target wchar_t is narrower than target char");
551 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
552 cpp_error (pfile, CPP_DL_ICE,
553 "target int is narrower than target char");
555 /* This is assumed in eval_token() and could be fixed if necessary. */
556 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
557 cpp_error (pfile, CPP_DL_ICE,
558 "CPP half-integer narrower than CPP character");
560 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
561 cpp_error (pfile, CPP_DL_ICE,
562 "CPP on this host cannot handle wide character constants over"
563 " %lu bits, but the target requires %lu bits",
564 (unsigned long) BITS_PER_CPPCHAR_T,
565 (unsigned long) CPP_OPTION (pfile, wchar_precision));
567 #else
568 # define sanity_checks(PFILE)
569 #endif
571 /* This is called after options have been parsed, and partially
572 processed. */
573 void
574 cpp_post_options (cpp_reader *pfile)
576 int flags;
578 sanity_checks (pfile);
580 post_options (pfile);
582 /* Mark named operators before handling command line macros. */
583 flags = 0;
584 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
585 flags |= NODE_OPERATOR;
586 if (CPP_OPTION (pfile, warn_cxx_operator_names))
587 flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR;
588 if (flags != 0)
589 mark_named_operators (pfile, flags);
592 /* Setup for processing input from the file named FNAME, or stdin if
593 it is the empty string. Return the original filename
594 on success (e.g. foo.i->foo.c), or NULL on failure. */
595 const char *
596 cpp_read_main_file (cpp_reader *pfile, const char *fname)
598 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
600 if (!pfile->deps)
601 pfile->deps = deps_init ();
603 /* Set the default target (if there is none already). */
604 deps_add_default_target (pfile->deps, fname);
607 pfile->main_file
608 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0, false);
609 if (_cpp_find_failed (pfile->main_file))
610 return NULL;
612 _cpp_stack_file (pfile, pfile->main_file, false);
614 /* For foo.i, read the original filename foo.c now, for the benefit
615 of the front ends. */
616 if (CPP_OPTION (pfile, preprocessed))
618 read_original_filename (pfile);
619 fname =
620 ORDINARY_MAP_FILE_NAME
621 ((LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table)));
623 return fname;
626 /* For preprocessed files, if the first tokens are of the form # NUM.
627 handle the directive so we know the original file name. This will
628 generate file_change callbacks, which the front ends must handle
629 appropriately given their state of initialization. */
630 static void
631 read_original_filename (cpp_reader *pfile)
633 const cpp_token *token, *token1;
635 /* Lex ahead; if the first tokens are of the form # NUM, then
636 process the directive, otherwise back up. */
637 token = _cpp_lex_direct (pfile);
638 if (token->type == CPP_HASH)
640 pfile->state.in_directive = 1;
641 token1 = _cpp_lex_direct (pfile);
642 _cpp_backup_tokens (pfile, 1);
643 pfile->state.in_directive = 0;
645 /* If it's a #line directive, handle it. */
646 if (token1->type == CPP_NUMBER
647 && _cpp_handle_directive (pfile, token->flags & PREV_WHITE))
649 read_original_directory (pfile);
650 return;
654 /* Backup as if nothing happened. */
655 _cpp_backup_tokens (pfile, 1);
658 /* For preprocessed files, if the tokens following the first filename
659 line is of the form # <line> "/path/name//", handle the
660 directive so we know the original current directory. */
661 static void
662 read_original_directory (cpp_reader *pfile)
664 const cpp_token *hash, *token;
666 /* Lex ahead; if the first tokens are of the form # NUM, then
667 process the directive, otherwise back up. */
668 hash = _cpp_lex_direct (pfile);
669 if (hash->type != CPP_HASH)
671 _cpp_backup_tokens (pfile, 1);
672 return;
675 token = _cpp_lex_direct (pfile);
677 if (token->type != CPP_NUMBER)
679 _cpp_backup_tokens (pfile, 2);
680 return;
683 token = _cpp_lex_direct (pfile);
685 if (token->type != CPP_STRING
686 || ! (token->val.str.len >= 5
687 && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-2])
688 && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-3])))
690 _cpp_backup_tokens (pfile, 3);
691 return;
694 if (pfile->cb.dir_change)
696 char *debugdir = (char *) alloca (token->val.str.len - 3);
698 memcpy (debugdir, (const char *) token->val.str.text + 1,
699 token->val.str.len - 4);
700 debugdir[token->val.str.len - 4] = '\0';
702 pfile->cb.dir_change (pfile, debugdir);
706 /* This is called at the end of preprocessing. It pops the last
707 buffer and writes dependency output.
709 Maybe it should also reset state, such that you could call
710 cpp_start_read with a new filename to restart processing. */
711 void
712 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
714 /* Warn about unused macros before popping the final buffer. */
715 if (CPP_OPTION (pfile, warn_unused_macros))
716 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
718 /* lex.c leaves the final buffer on the stack. This it so that
719 it returns an unending stream of CPP_EOFs to the client. If we
720 popped the buffer, we'd dereference a NULL buffer pointer and
721 segfault. It's nice to allow the client to do worry-free excess
722 cpp_get_token calls. */
723 while (pfile->buffer)
724 _cpp_pop_buffer (pfile);
726 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
727 && deps_stream)
729 deps_write (pfile->deps, deps_stream, 72);
731 if (CPP_OPTION (pfile, deps.phony_targets))
732 deps_phony_targets (pfile->deps, deps_stream);
735 /* Report on headers that could use multiple include guards. */
736 if (CPP_OPTION (pfile, print_include_names))
737 _cpp_report_missing_guards (pfile);
740 static void
741 post_options (cpp_reader *pfile)
743 /* -Wtraditional is not useful in C++ mode. */
744 if (CPP_OPTION (pfile, cplusplus))
745 CPP_OPTION (pfile, cpp_warn_traditional) = 0;
747 /* Permanently disable macro expansion if we are rescanning
748 preprocessed text. Read preprocesed source in ISO mode. */
749 if (CPP_OPTION (pfile, preprocessed))
751 if (!CPP_OPTION (pfile, directives_only))
752 pfile->state.prevent_expansion = 1;
753 CPP_OPTION (pfile, traditional) = 0;
756 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
757 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
759 if (CPP_OPTION (pfile, traditional))
761 CPP_OPTION (pfile, cplusplus_comments) = 0;
763 CPP_OPTION (pfile, trigraphs) = 0;
764 CPP_OPTION (pfile, warn_trigraphs) = 0;