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