2 Copyright (C) 1986-2020 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
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/>. */
26 #include "localedir.h"
27 #include "filenames.h"
29 #ifndef ENABLE_CANONICAL_SYSTEM_HEADERS
30 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
31 #define ENABLE_CANONICAL_SYSTEM_HEADERS 1
33 #define ENABLE_CANONICAL_SYSTEM_HEADERS 0
37 static void init_library (void);
38 static void mark_named_operators (cpp_reader
*, int);
39 static void read_original_filename (cpp_reader
*);
40 static void read_original_directory (cpp_reader
*);
41 static void post_options (cpp_reader
*);
43 /* If we have designated initializers (GCC >2.7) these tables can be
44 initialized, constant data. Otherwise, they have to be filled in at
46 #if HAVE_DESIGNATED_INITIALIZERS
48 #define init_trigraph_map() /* Nothing. */
49 #define TRIGRAPH_MAP \
50 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
53 #define s(p, v) [p] = v,
57 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
58 static void init_trigraph_map (void) { \
59 unsigned char *x = _cpp_trigraph_map;
62 #define s(p, v) x[p] = v;
67 s('=', '#') s(')', ']') s('!', '|')
68 s('(', '[') s('\'', '^') s('>', '}')
69 s('/', '\\') s('<', '{') s('-', '~')
76 /* A set of booleans indicating what CPP features each source language
82 char extended_numbers
;
83 char extended_identifiers
;
90 char binary_constants
;
91 char digit_separators
;
93 char utf8_char_literals
;
99 static const struct lang_flags lang_defaults
[] =
100 { /* c99 c++ xnum xid c11 std digr ulit rlit udlit bincst digsep trig u8chlit vaopt scope dfp */
101 /* GNUC89 */ { 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
102 /* GNUC99 */ { 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0 },
103 /* GNUC11 */ { 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0 },
104 /* GNUC17 */ { 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0 },
105 /* GNUC2X */ { 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 },
106 /* STDC89 */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
107 /* STDC94 */ { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
108 /* STDC99 */ { 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
109 /* STDC11 */ { 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
110 /* STDC17 */ { 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
111 /* STDC2X */ { 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1 },
112 /* GNUCXX */ { 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
113 /* CXX98 */ { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0 },
114 /* GNUCXX11 */ { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0 },
115 /* CXX11 */ { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 },
116 /* GNUCXX14 */ { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0 },
117 /* CXX14 */ { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0 },
118 /* GNUCXX17 */ { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0 },
119 /* CXX17 */ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 },
120 /* GNUCXX20 */ { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0 },
121 /* CXX20 */ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0 },
122 /* ASM */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
125 /* Sets internal flags correctly for a given language. */
127 cpp_set_lang (cpp_reader
*pfile
, enum c_lang lang
)
129 const struct lang_flags
*l
= &lang_defaults
[(int) lang
];
131 CPP_OPTION (pfile
, lang
) = lang
;
133 CPP_OPTION (pfile
, c99
) = l
->c99
;
134 CPP_OPTION (pfile
, cplusplus
) = l
->cplusplus
;
135 CPP_OPTION (pfile
, extended_numbers
) = l
->extended_numbers
;
136 CPP_OPTION (pfile
, extended_identifiers
) = l
->extended_identifiers
;
137 CPP_OPTION (pfile
, c11_identifiers
) = l
->c11_identifiers
;
138 CPP_OPTION (pfile
, std
) = l
->std
;
139 CPP_OPTION (pfile
, digraphs
) = l
->digraphs
;
140 CPP_OPTION (pfile
, uliterals
) = l
->uliterals
;
141 CPP_OPTION (pfile
, rliterals
) = l
->rliterals
;
142 CPP_OPTION (pfile
, user_literals
) = l
->user_literals
;
143 CPP_OPTION (pfile
, binary_constants
) = l
->binary_constants
;
144 CPP_OPTION (pfile
, digit_separators
) = l
->digit_separators
;
145 CPP_OPTION (pfile
, trigraphs
) = l
->trigraphs
;
146 CPP_OPTION (pfile
, utf8_char_literals
) = l
->utf8_char_literals
;
147 CPP_OPTION (pfile
, va_opt
) = l
->va_opt
;
148 CPP_OPTION (pfile
, scope
) = l
->scope
;
149 CPP_OPTION (pfile
, dfp_constants
) = l
->dfp_constants
;
152 /* Initialize library global state. */
156 static int initialized
= 0;
164 /* Set up the trigraph map. This doesn't need to do anything if
165 we were compiled with a compiler that supports C99 designated
167 init_trigraph_map ();
170 (void) bindtextdomain (PACKAGE
, LOCALEDIR
);
175 /* Initialize a cpp_reader structure. */
177 cpp_create_reader (enum c_lang lang
, cpp_hash_table
*table
,
178 class line_maps
*line_table
)
182 /* Initialize this instance of the library if it hasn't been already. */
185 pfile
= XCNEW (cpp_reader
);
186 memset (&pfile
->base_context
, 0, sizeof (pfile
->base_context
));
188 cpp_set_lang (pfile
, lang
);
189 CPP_OPTION (pfile
, warn_multichar
) = 1;
190 CPP_OPTION (pfile
, discard_comments
) = 1;
191 CPP_OPTION (pfile
, discard_comments_in_macro_exp
) = 1;
192 CPP_OPTION (pfile
, max_include_depth
) = 200;
193 CPP_OPTION (pfile
, operator_names
) = 1;
194 CPP_OPTION (pfile
, warn_trigraphs
) = 2;
195 CPP_OPTION (pfile
, warn_endif_labels
) = 1;
196 CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) = -1;
197 CPP_OPTION (pfile
, cpp_warn_c11_c2x_compat
) = -1;
198 CPP_OPTION (pfile
, cpp_warn_cxx11_compat
) = 0;
199 CPP_OPTION (pfile
, cpp_warn_deprecated
) = 1;
200 CPP_OPTION (pfile
, cpp_warn_long_long
) = 0;
201 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
202 CPP_OPTION (pfile
, warn_dollars
) = 1;
203 CPP_OPTION (pfile
, warn_variadic_macros
) = 1;
204 CPP_OPTION (pfile
, warn_builtin_macro_redefined
) = 1;
205 CPP_OPTION (pfile
, cpp_warn_implicit_fallthrough
) = 0;
206 /* By default, track locations of tokens resulting from macro
207 expansion. The '2' means, track the locations with the highest
208 accuracy. Read the comments for struct
209 cpp_options::track_macro_expansion to learn about the other
211 CPP_OPTION (pfile
, track_macro_expansion
) = 2;
212 CPP_OPTION (pfile
, warn_normalize
) = normalized_C
;
213 CPP_OPTION (pfile
, warn_literal_suffix
) = 1;
214 CPP_OPTION (pfile
, canonical_system_headers
)
215 = ENABLE_CANONICAL_SYSTEM_HEADERS
;
216 CPP_OPTION (pfile
, ext_numeric_literals
) = 1;
217 CPP_OPTION (pfile
, warn_date_time
) = 0;
219 /* Default CPP arithmetic to something sensible for the host for the
220 benefit of dumb users like fix-header. */
221 CPP_OPTION (pfile
, precision
) = CHAR_BIT
* sizeof (long);
222 CPP_OPTION (pfile
, char_precision
) = CHAR_BIT
;
223 CPP_OPTION (pfile
, wchar_precision
) = CHAR_BIT
* sizeof (int);
224 CPP_OPTION (pfile
, int_precision
) = CHAR_BIT
* sizeof (int);
225 CPP_OPTION (pfile
, unsigned_char
) = 0;
226 CPP_OPTION (pfile
, unsigned_wchar
) = 1;
227 CPP_OPTION (pfile
, bytes_big_endian
) = 1; /* does not matter */
229 /* Default to no charset conversion. */
230 CPP_OPTION (pfile
, narrow_charset
) = _cpp_default_encoding ();
231 CPP_OPTION (pfile
, wide_charset
) = 0;
233 /* Default the input character set to UTF-8. */
234 CPP_OPTION (pfile
, input_charset
) = _cpp_default_encoding ();
236 /* A fake empty "directory" used as the starting point for files
237 looked up without a search path. Name cannot be '/' because we
238 don't want to prepend anything at all to filenames using it. All
239 other entries are correct zero-initialized. */
240 pfile
->no_search_path
.name
= (char *) "";
242 /* Initialize the line map. */
243 pfile
->line_table
= line_table
;
245 /* Initialize lexer state. */
246 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
248 /* Set up static tokens. */
249 pfile
->avoid_paste
.type
= CPP_PADDING
;
250 pfile
->avoid_paste
.val
.source
= NULL
;
251 pfile
->eof
.type
= CPP_EOF
;
252 pfile
->eof
.flags
= 0;
254 /* Create a token buffer for the lexer. */
255 _cpp_init_tokenrun (&pfile
->base_run
, 250);
256 pfile
->cur_run
= &pfile
->base_run
;
257 pfile
->cur_token
= pfile
->base_run
.base
;
259 /* Initialize the base context. */
260 pfile
->context
= &pfile
->base_context
;
261 pfile
->base_context
.c
.macro
= 0;
262 pfile
->base_context
.prev
= pfile
->base_context
.next
= 0;
264 /* Aligned and unaligned storage. */
265 pfile
->a_buff
= _cpp_get_buff (pfile
, 0);
266 pfile
->u_buff
= _cpp_get_buff (pfile
, 0);
268 /* Initialize table for push_macro/pop_macro. */
269 pfile
->pushed_macros
= 0;
271 /* Do not force token locations by default. */
272 pfile
->forced_token_location
= 0;
274 /* Initialize source_date_epoch to -2 (not yet set). */
275 pfile
->source_date_epoch
= (time_t) -2;
277 /* The expression parser stack. */
278 _cpp_expand_op_stack (pfile
);
280 /* Initialize the buffer obstack. */
281 obstack_specify_allocation (&pfile
->buffer_ob
, 0, 0, xmalloc
, free
);
283 _cpp_init_files (pfile
);
285 _cpp_init_hashtable (pfile
, table
);
290 /* Set the line_table entry in PFILE. This is called after reading a
291 PCH file, as the old line_table will be incorrect. */
293 cpp_set_line_map (cpp_reader
*pfile
, class line_maps
*line_table
)
295 pfile
->line_table
= line_table
;
298 /* Free resources used by PFILE. Accessing PFILE after this function
299 returns leads to undefined behavior. Returns the error count. */
301 cpp_destroy (cpp_reader
*pfile
)
303 cpp_context
*context
, *contextn
;
304 struct def_pragma_macro
*pmacro
;
305 tokenrun
*run
, *runn
;
308 free (pfile
->op_stack
);
310 while (CPP_BUFFER (pfile
) != NULL
)
311 _cpp_pop_buffer (pfile
);
313 free (pfile
->out
.base
);
315 if (pfile
->macro_buffer
)
317 free (pfile
->macro_buffer
);
318 pfile
->macro_buffer
= NULL
;
319 pfile
->macro_buffer_len
= 0;
323 deps_free (pfile
->deps
);
324 obstack_free (&pfile
->buffer_ob
, 0);
326 _cpp_destroy_hashtable (pfile
);
327 _cpp_cleanup_files (pfile
);
328 _cpp_destroy_iconv (pfile
);
330 _cpp_free_buff (pfile
->a_buff
);
331 _cpp_free_buff (pfile
->u_buff
);
332 _cpp_free_buff (pfile
->free_buffs
);
334 for (run
= &pfile
->base_run
; run
; run
= runn
)
338 if (run
!= &pfile
->base_run
)
342 for (context
= pfile
->base_context
.next
; context
; context
= contextn
)
344 contextn
= context
->next
;
348 if (pfile
->comments
.entries
)
350 for (i
= 0; i
< pfile
->comments
.count
; i
++)
351 free (pfile
->comments
.entries
[i
].comment
);
353 free (pfile
->comments
.entries
);
355 if (pfile
->pushed_macros
)
359 pmacro
= pfile
->pushed_macros
;
360 pfile
->pushed_macros
= pmacro
->next
;
364 while (pfile
->pushed_macros
);
370 /* This structure defines one built-in identifier. A node will be
371 entered in the hash table under the name NAME, with value VALUE.
373 There are two tables of these. builtin_array holds all the
374 "builtin" macros: these are handled by builtin_macro() in
375 macro.c. Builtin is somewhat of a misnomer -- the property of
376 interest is that these macros require special code to compute their
377 expansions. The value is a "cpp_builtin_type" enumerator.
379 operator_array holds the C++ named operators. These are keywords
380 which act as aliases for punctuators. In C++, they cannot be
381 altered through #define, and #if recognizes them as operators. In
382 C, these are not entered into the hash table at all (but see
383 <iso646.h>). The value is a token-type enumerator. */
386 const uchar
*const name
;
387 const unsigned short len
;
388 const unsigned short value
;
389 const bool always_warn_if_redefined
;
392 #define B(n, t, f) { DSC(n), t, f }
393 static const struct builtin_macro builtin_array
[] =
395 B("__TIMESTAMP__", BT_TIMESTAMP
, false),
396 B("__TIME__", BT_TIME
, false),
397 B("__DATE__", BT_DATE
, false),
398 B("__FILE__", BT_FILE
, false),
399 B("__BASE_FILE__", BT_BASE_FILE
, false),
400 B("__LINE__", BT_SPECLINE
, true),
401 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL
, true),
402 B("__COUNTER__", BT_COUNTER
, true),
403 /* Make sure to update the list of built-in
404 function-like macros in traditional.c:
405 fun_like_macro() when adding more following */
406 B("__has_attribute", BT_HAS_ATTRIBUTE
, true),
407 B("__has_cpp_attribute", BT_HAS_ATTRIBUTE
, true),
408 B("__has_builtin", BT_HAS_BUILTIN
, true),
409 B("__has_include", BT_HAS_INCLUDE
, true),
410 B("__has_include_next",BT_HAS_INCLUDE_NEXT
, true),
411 /* Keep builtins not used for -traditional-cpp at the end, and
412 update init_builtins() if any more are added. */
413 B("_Pragma", BT_PRAGMA
, true),
414 B("__STDC__", BT_STDC
, true),
418 struct builtin_operator
420 const uchar
*const name
;
421 const unsigned short len
;
422 const unsigned short value
;
425 #define B(n, t) { DSC(n), t }
426 static const struct builtin_operator operator_array
[] =
428 B("and", CPP_AND_AND
),
429 B("and_eq", CPP_AND_EQ
),
430 B("bitand", CPP_AND
),
432 B("compl", CPP_COMPL
),
434 B("not_eq", CPP_NOT_EQ
),
436 B("or_eq", CPP_OR_EQ
),
438 B("xor_eq", CPP_XOR_EQ
)
442 /* Mark the C++ named operators in the hash table. */
444 mark_named_operators (cpp_reader
*pfile
, int flags
)
446 const struct builtin_operator
*b
;
448 for (b
= operator_array
;
449 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
452 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
454 hp
->is_directive
= 0;
455 hp
->directive_index
= b
->value
;
459 /* Helper function of cpp_type2name. Return the string associated with
460 named operator TYPE. */
462 cpp_named_operator2name (enum cpp_ttype type
)
464 const struct builtin_operator
*b
;
466 for (b
= operator_array
;
467 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
470 if (type
== b
->value
)
471 return (const char *) b
->name
;
478 cpp_init_special_builtins (cpp_reader
*pfile
)
480 const struct builtin_macro
*b
;
481 size_t n
= ARRAY_SIZE (builtin_array
);
483 if (CPP_OPTION (pfile
, traditional
))
485 else if (! CPP_OPTION (pfile
, stdc_0_in_system_headers
)
486 || CPP_OPTION (pfile
, std
))
489 for (b
= builtin_array
; b
< builtin_array
+ n
; b
++)
491 if ((b
->value
== BT_HAS_ATTRIBUTE
492 || b
->value
== BT_HAS_BUILTIN
)
493 && (CPP_OPTION (pfile
, lang
) == CLK_ASM
494 || pfile
->cb
.has_attribute
== NULL
))
496 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
497 hp
->type
= NT_BUILTIN_MACRO
;
498 if (b
->always_warn_if_redefined
)
499 hp
->flags
|= NODE_WARN
;
500 hp
->value
.builtin
= (enum cpp_builtin_type
) b
->value
;
504 /* Restore macro C to builtin macro definition. */
507 _cpp_restore_special_builtin (cpp_reader
*pfile
, struct def_pragma_macro
*c
)
509 size_t len
= strlen (c
->name
);
511 for (const struct builtin_macro
*b
= builtin_array
;
512 b
< builtin_array
+ ARRAY_SIZE (builtin_array
); b
++)
513 if (b
->len
== len
&& memcmp (c
->name
, b
->name
, len
+ 1) == 0)
515 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
516 hp
->type
= NT_BUILTIN_MACRO
;
517 if (b
->always_warn_if_redefined
)
518 hp
->flags
|= NODE_WARN
;
519 hp
->value
.builtin
= (enum cpp_builtin_type
) b
->value
;
523 /* Read the builtins table above and enter them, and language-specific
524 macros, into the hash table. HOSTED is true if this is a hosted
527 cpp_init_builtins (cpp_reader
*pfile
, int hosted
)
529 cpp_init_special_builtins (pfile
);
531 if (!CPP_OPTION (pfile
, traditional
)
532 && (! CPP_OPTION (pfile
, stdc_0_in_system_headers
)
533 || CPP_OPTION (pfile
, std
)))
534 _cpp_define_builtin (pfile
, "__STDC__ 1");
536 if (CPP_OPTION (pfile
, cplusplus
))
538 if (CPP_OPTION (pfile
, lang
) == CLK_CXX20
539 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX20
)
540 _cpp_define_builtin (pfile
, "__cplusplus 201709L");
541 else if (CPP_OPTION (pfile
, lang
) == CLK_CXX17
542 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX17
)
543 _cpp_define_builtin (pfile
, "__cplusplus 201703L");
544 else if (CPP_OPTION (pfile
, lang
) == CLK_CXX14
545 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX14
)
546 _cpp_define_builtin (pfile
, "__cplusplus 201402L");
547 else if (CPP_OPTION (pfile
, lang
) == CLK_CXX11
548 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX11
)
549 _cpp_define_builtin (pfile
, "__cplusplus 201103L");
551 _cpp_define_builtin (pfile
, "__cplusplus 199711L");
553 else if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
554 _cpp_define_builtin (pfile
, "__ASSEMBLER__ 1");
555 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC94
)
556 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199409L");
557 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC2X
558 || CPP_OPTION (pfile
, lang
) == CLK_GNUC2X
)
559 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 202000L");
560 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC17
561 || CPP_OPTION (pfile
, lang
) == CLK_GNUC17
)
562 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 201710L");
563 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC11
564 || CPP_OPTION (pfile
, lang
) == CLK_GNUC11
)
565 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 201112L");
566 else if (CPP_OPTION (pfile
, c99
))
567 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199901L");
569 if (CPP_OPTION (pfile
, uliterals
)
570 && !(CPP_OPTION (pfile
, cplusplus
)
571 && (CPP_OPTION (pfile
, lang
) == CLK_GNUCXX
572 || CPP_OPTION (pfile
, lang
) == CLK_CXX98
)))
574 _cpp_define_builtin (pfile
, "__STDC_UTF_16__ 1");
575 _cpp_define_builtin (pfile
, "__STDC_UTF_32__ 1");
579 _cpp_define_builtin (pfile
, "__STDC_HOSTED__ 1");
581 _cpp_define_builtin (pfile
, "__STDC_HOSTED__ 0");
583 if (CPP_OPTION (pfile
, objc
))
584 _cpp_define_builtin (pfile
, "__OBJC__ 1");
587 /* Sanity-checks are dependent on command-line options, so it is
588 called as a subroutine of cpp_read_main_file. */
590 static void sanity_checks (cpp_reader
*);
591 static void sanity_checks (cpp_reader
*pfile
)
594 size_t max_precision
= 2 * CHAR_BIT
* sizeof (cpp_num_part
);
596 /* Sanity checks for assumptions about CPP arithmetic and target
597 type precisions made by cpplib. */
600 cpp_error (pfile
, CPP_DL_ICE
, "cppchar_t must be an unsigned type");
602 if (CPP_OPTION (pfile
, precision
) > max_precision
)
603 cpp_error (pfile
, CPP_DL_ICE
,
604 "preprocessor arithmetic has maximum precision of %lu bits;"
605 " target requires %lu bits",
606 (unsigned long) max_precision
,
607 (unsigned long) CPP_OPTION (pfile
, precision
));
609 if (CPP_OPTION (pfile
, precision
) < CPP_OPTION (pfile
, int_precision
))
610 cpp_error (pfile
, CPP_DL_ICE
,
611 "CPP arithmetic must be at least as precise as a target int");
613 if (CPP_OPTION (pfile
, char_precision
) < 8)
614 cpp_error (pfile
, CPP_DL_ICE
, "target char is less than 8 bits wide");
616 if (CPP_OPTION (pfile
, wchar_precision
) < CPP_OPTION (pfile
, char_precision
))
617 cpp_error (pfile
, CPP_DL_ICE
,
618 "target wchar_t is narrower than target char");
620 if (CPP_OPTION (pfile
, int_precision
) < CPP_OPTION (pfile
, char_precision
))
621 cpp_error (pfile
, CPP_DL_ICE
,
622 "target int is narrower than target char");
624 /* This is assumed in eval_token() and could be fixed if necessary. */
625 if (sizeof (cppchar_t
) > sizeof (cpp_num_part
))
626 cpp_error (pfile
, CPP_DL_ICE
,
627 "CPP half-integer narrower than CPP character");
629 if (CPP_OPTION (pfile
, wchar_precision
) > BITS_PER_CPPCHAR_T
)
630 cpp_error (pfile
, CPP_DL_ICE
,
631 "CPP on this host cannot handle wide character constants over"
632 " %lu bits, but the target requires %lu bits",
633 (unsigned long) BITS_PER_CPPCHAR_T
,
634 (unsigned long) CPP_OPTION (pfile
, wchar_precision
));
637 # define sanity_checks(PFILE)
640 /* This is called after options have been parsed, and partially
643 cpp_post_options (cpp_reader
*pfile
)
647 sanity_checks (pfile
);
649 post_options (pfile
);
651 /* Mark named operators before handling command line macros. */
653 if (CPP_OPTION (pfile
, cplusplus
) && CPP_OPTION (pfile
, operator_names
))
654 flags
|= NODE_OPERATOR
;
655 if (CPP_OPTION (pfile
, warn_cxx_operator_names
))
656 flags
|= NODE_DIAGNOSTIC
| NODE_WARN_OPERATOR
;
658 mark_named_operators (pfile
, flags
);
661 /* Setup for processing input from the file named FNAME, or stdin if
662 it is the empty string. Return the original filename on success
663 (e.g. foo.i->foo.c), or NULL on failure. INJECTING is true if
664 there may be injected headers before line 1 of the main file. */
666 cpp_read_main_file (cpp_reader
*pfile
, const char *fname
, bool injecting
)
668 if (CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
)
671 pfile
->deps
= deps_init ();
673 /* Set the default target (if there is none already). */
674 deps_add_default_target (pfile
->deps
, fname
);
678 = _cpp_find_file (pfile
, fname
, &pfile
->no_search_path
, /*angle=*/0,
680 if (_cpp_find_failed (pfile
->main_file
))
683 _cpp_stack_file (pfile
, pfile
->main_file
,
684 injecting
? IT_MAIN_INJECT
: IT_MAIN
, 0);
686 /* For foo.i, read the original filename foo.c now, for the benefit
687 of the front ends. */
688 if (CPP_OPTION (pfile
, preprocessed
))
689 read_original_filename (pfile
);
691 return ORDINARY_MAP_FILE_NAME (LINEMAPS_LAST_ORDINARY_MAP (pfile
->line_table
));
694 /* For preprocessed files, if the first tokens are of the form # NUM.
695 handle the directive so we know the original file name. This will
696 generate file_change callbacks, which the front ends must handle
697 appropriately given their state of initialization. */
699 read_original_filename (cpp_reader
*pfile
)
701 const cpp_token
*token
, *token1
;
703 /* Lex ahead; if the first tokens are of the form # NUM, then
704 process the directive, otherwise back up. */
705 token
= _cpp_lex_direct (pfile
);
706 if (token
->type
== CPP_HASH
)
708 pfile
->state
.in_directive
= 1;
709 token1
= _cpp_lex_direct (pfile
);
710 _cpp_backup_tokens (pfile
, 1);
711 pfile
->state
.in_directive
= 0;
713 /* If it's a #line directive, handle it. */
714 if (token1
->type
== CPP_NUMBER
715 && _cpp_handle_directive (pfile
, token
->flags
& PREV_WHITE
))
717 read_original_directory (pfile
);
722 /* Backup as if nothing happened. */
723 _cpp_backup_tokens (pfile
, 1);
726 /* For preprocessed files, if the tokens following the first filename
727 line is of the form # <line> "/path/name//", handle the
728 directive so we know the original current directory. */
730 read_original_directory (cpp_reader
*pfile
)
732 const cpp_token
*hash
, *token
;
734 /* Lex ahead; if the first tokens are of the form # NUM, then
735 process the directive, otherwise back up. */
736 hash
= _cpp_lex_direct (pfile
);
737 if (hash
->type
!= CPP_HASH
)
739 _cpp_backup_tokens (pfile
, 1);
743 token
= _cpp_lex_direct (pfile
);
745 if (token
->type
!= CPP_NUMBER
)
747 _cpp_backup_tokens (pfile
, 2);
751 token
= _cpp_lex_direct (pfile
);
753 if (token
->type
!= CPP_STRING
754 || ! (token
->val
.str
.len
>= 5
755 && IS_DIR_SEPARATOR (token
->val
.str
.text
[token
->val
.str
.len
-2])
756 && IS_DIR_SEPARATOR (token
->val
.str
.text
[token
->val
.str
.len
-3])))
758 _cpp_backup_tokens (pfile
, 3);
762 if (pfile
->cb
.dir_change
)
764 char *debugdir
= (char *) alloca (token
->val
.str
.len
- 3);
766 memcpy (debugdir
, (const char *) token
->val
.str
.text
+ 1,
767 token
->val
.str
.len
- 4);
768 debugdir
[token
->val
.str
.len
- 4] = '\0';
770 pfile
->cb
.dir_change (pfile
, debugdir
);
774 /* This is called at the end of preprocessing. It pops the last
775 buffer and writes dependency output.
777 Maybe it should also reset state, such that you could call
778 cpp_start_read with a new filename to restart processing. */
780 cpp_finish (cpp_reader
*pfile
, FILE *deps_stream
)
782 /* Warn about unused macros before popping the final buffer. */
783 if (CPP_OPTION (pfile
, warn_unused_macros
))
784 cpp_forall_identifiers (pfile
, _cpp_warn_if_unused_macro
, NULL
);
786 /* lex.c leaves the final buffer on the stack. This it so that
787 it returns an unending stream of CPP_EOFs to the client. If we
788 popped the buffer, we'd dereference a NULL buffer pointer and
789 segfault. It's nice to allow the client to do worry-free excess
790 cpp_get_token calls. */
791 while (pfile
->buffer
)
792 _cpp_pop_buffer (pfile
);
794 if (CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
&& deps_stream
)
795 deps_write (pfile
->deps
, deps_stream
,
796 CPP_OPTION (pfile
, deps
.phony_targets
), 72);
798 /* Report on headers that could use multiple include guards. */
799 if (CPP_OPTION (pfile
, print_include_names
))
800 _cpp_report_missing_guards (pfile
);
804 post_options (cpp_reader
*pfile
)
806 /* -Wtraditional is not useful in C++ mode. */
807 if (CPP_OPTION (pfile
, cplusplus
))
808 CPP_OPTION (pfile
, cpp_warn_traditional
) = 0;
810 /* Permanently disable macro expansion if we are rescanning
811 preprocessed text. Read preprocesed source in ISO mode. */
812 if (CPP_OPTION (pfile
, preprocessed
))
814 if (!CPP_OPTION (pfile
, directives_only
))
815 pfile
->state
.prevent_expansion
= 1;
816 CPP_OPTION (pfile
, traditional
) = 0;
819 if (CPP_OPTION (pfile
, warn_trigraphs
) == 2)
820 CPP_OPTION (pfile
, warn_trigraphs
) = !CPP_OPTION (pfile
, trigraphs
);
822 if (CPP_OPTION (pfile
, traditional
))
824 CPP_OPTION (pfile
, trigraphs
) = 0;
825 CPP_OPTION (pfile
, warn_trigraphs
) = 0;