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 bool 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
->avoid_paste
.src_loc
= 0;
252 pfile
->endarg
.type
= CPP_EOF
;
253 pfile
->endarg
.flags
= 0;
254 pfile
->endarg
.src_loc
= 0;
256 /* Create a token buffer for the lexer. */
257 _cpp_init_tokenrun (&pfile
->base_run
, 250);
258 pfile
->cur_run
= &pfile
->base_run
;
259 pfile
->cur_token
= pfile
->base_run
.base
;
261 /* Initialize the base context. */
262 pfile
->context
= &pfile
->base_context
;
263 pfile
->base_context
.c
.macro
= 0;
264 pfile
->base_context
.prev
= pfile
->base_context
.next
= 0;
266 /* Aligned and unaligned storage. */
267 pfile
->a_buff
= _cpp_get_buff (pfile
, 0);
268 pfile
->u_buff
= _cpp_get_buff (pfile
, 0);
270 /* Initialize table for push_macro/pop_macro. */
271 pfile
->pushed_macros
= 0;
273 /* Do not force token locations by default. */
274 pfile
->forced_token_location
= 0;
276 /* Initialize source_date_epoch to -2 (not yet set). */
277 pfile
->source_date_epoch
= (time_t) -2;
279 /* The expression parser stack. */
280 _cpp_expand_op_stack (pfile
);
282 /* Initialize the buffer obstack. */
283 obstack_specify_allocation (&pfile
->buffer_ob
, 0, 0, xmalloc
, free
);
285 _cpp_init_files (pfile
);
287 _cpp_init_hashtable (pfile
, table
);
292 /* Set the line_table entry in PFILE. This is called after reading a
293 PCH file, as the old line_table will be incorrect. */
295 cpp_set_line_map (cpp_reader
*pfile
, class line_maps
*line_table
)
297 pfile
->line_table
= line_table
;
300 /* Free resources used by PFILE. Accessing PFILE after this function
301 returns leads to undefined behavior. Returns the error count. */
303 cpp_destroy (cpp_reader
*pfile
)
305 cpp_context
*context
, *contextn
;
306 struct def_pragma_macro
*pmacro
;
307 tokenrun
*run
, *runn
;
310 free (pfile
->op_stack
);
312 while (CPP_BUFFER (pfile
) != NULL
)
313 _cpp_pop_buffer (pfile
);
315 free (pfile
->out
.base
);
317 if (pfile
->macro_buffer
)
319 free (pfile
->macro_buffer
);
320 pfile
->macro_buffer
= NULL
;
321 pfile
->macro_buffer_len
= 0;
325 deps_free (pfile
->deps
);
326 obstack_free (&pfile
->buffer_ob
, 0);
328 _cpp_destroy_hashtable (pfile
);
329 _cpp_cleanup_files (pfile
);
330 _cpp_destroy_iconv (pfile
);
332 _cpp_free_buff (pfile
->a_buff
);
333 _cpp_free_buff (pfile
->u_buff
);
334 _cpp_free_buff (pfile
->free_buffs
);
336 for (run
= &pfile
->base_run
; run
; run
= runn
)
340 if (run
!= &pfile
->base_run
)
344 for (context
= pfile
->base_context
.next
; context
; context
= contextn
)
346 contextn
= context
->next
;
350 if (pfile
->comments
.entries
)
352 for (i
= 0; i
< pfile
->comments
.count
; i
++)
353 free (pfile
->comments
.entries
[i
].comment
);
355 free (pfile
->comments
.entries
);
357 if (pfile
->pushed_macros
)
361 pmacro
= pfile
->pushed_macros
;
362 pfile
->pushed_macros
= pmacro
->next
;
366 while (pfile
->pushed_macros
);
372 /* This structure defines one built-in identifier. A node will be
373 entered in the hash table under the name NAME, with value VALUE.
375 There are two tables of these. builtin_array holds all the
376 "builtin" macros: these are handled by builtin_macro() in
377 macro.c. Builtin is somewhat of a misnomer -- the property of
378 interest is that these macros require special code to compute their
379 expansions. The value is a "cpp_builtin_type" enumerator.
381 operator_array holds the C++ named operators. These are keywords
382 which act as aliases for punctuators. In C++, they cannot be
383 altered through #define, and #if recognizes them as operators. In
384 C, these are not entered into the hash table at all (but see
385 <iso646.h>). The value is a token-type enumerator. */
388 const uchar
*const name
;
389 const unsigned short len
;
390 const unsigned short value
;
391 const bool always_warn_if_redefined
;
394 #define B(n, t, f) { DSC(n), t, f }
395 static const struct builtin_macro builtin_array
[] =
397 B("__TIMESTAMP__", BT_TIMESTAMP
, false),
398 B("__TIME__", BT_TIME
, false),
399 B("__DATE__", BT_DATE
, false),
400 B("__FILE__", BT_FILE
, false),
401 B("__BASE_FILE__", BT_BASE_FILE
, false),
402 B("__LINE__", BT_SPECLINE
, true),
403 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL
, true),
404 B("__COUNTER__", BT_COUNTER
, true),
405 /* Make sure to update the list of built-in
406 function-like macros in traditional.c:
407 fun_like_macro() when adding more following */
408 B("__has_attribute", BT_HAS_ATTRIBUTE
, true),
409 B("__has_cpp_attribute", BT_HAS_ATTRIBUTE
, true),
410 B("__has_builtin", BT_HAS_BUILTIN
, true),
411 B("__has_include", BT_HAS_INCLUDE
, true),
412 B("__has_include_next",BT_HAS_INCLUDE_NEXT
, true),
413 /* Keep builtins not used for -traditional-cpp at the end, and
414 update init_builtins() if any more are added. */
415 B("_Pragma", BT_PRAGMA
, true),
416 B("__STDC__", BT_STDC
, true),
420 struct builtin_operator
422 const uchar
*const name
;
423 const unsigned short len
;
424 const unsigned short value
;
427 #define B(n, t) { DSC(n), t }
428 static const struct builtin_operator operator_array
[] =
430 B("and", CPP_AND_AND
),
431 B("and_eq", CPP_AND_EQ
),
432 B("bitand", CPP_AND
),
434 B("compl", CPP_COMPL
),
436 B("not_eq", CPP_NOT_EQ
),
438 B("or_eq", CPP_OR_EQ
),
440 B("xor_eq", CPP_XOR_EQ
)
444 /* Mark the C++ named operators in the hash table. */
446 mark_named_operators (cpp_reader
*pfile
, int flags
)
448 const struct builtin_operator
*b
;
450 for (b
= operator_array
;
451 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
454 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
456 hp
->is_directive
= 0;
457 hp
->directive_index
= b
->value
;
461 /* Helper function of cpp_type2name. Return the string associated with
462 named operator TYPE. */
464 cpp_named_operator2name (enum cpp_ttype type
)
466 const struct builtin_operator
*b
;
468 for (b
= operator_array
;
469 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
472 if (type
== b
->value
)
473 return (const char *) b
->name
;
480 cpp_init_special_builtins (cpp_reader
*pfile
)
482 const struct builtin_macro
*b
;
483 size_t n
= ARRAY_SIZE (builtin_array
);
485 if (CPP_OPTION (pfile
, traditional
))
487 else if (! CPP_OPTION (pfile
, stdc_0_in_system_headers
)
488 || CPP_OPTION (pfile
, std
))
491 for (b
= builtin_array
; b
< builtin_array
+ n
; b
++)
493 if ((b
->value
== BT_HAS_ATTRIBUTE
494 || b
->value
== BT_HAS_BUILTIN
)
495 && (CPP_OPTION (pfile
, lang
) == CLK_ASM
496 || pfile
->cb
.has_attribute
== NULL
))
498 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
499 hp
->type
= NT_BUILTIN_MACRO
;
500 if (b
->always_warn_if_redefined
)
501 hp
->flags
|= NODE_WARN
;
502 hp
->value
.builtin
= (enum cpp_builtin_type
) b
->value
;
506 /* Restore macro C to builtin macro definition. */
509 _cpp_restore_special_builtin (cpp_reader
*pfile
, struct def_pragma_macro
*c
)
511 size_t len
= strlen (c
->name
);
513 for (const struct builtin_macro
*b
= builtin_array
;
514 b
< builtin_array
+ ARRAY_SIZE (builtin_array
); b
++)
515 if (b
->len
== len
&& memcmp (c
->name
, b
->name
, len
+ 1) == 0)
517 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
518 hp
->type
= NT_BUILTIN_MACRO
;
519 if (b
->always_warn_if_redefined
)
520 hp
->flags
|= NODE_WARN
;
521 hp
->value
.builtin
= (enum cpp_builtin_type
) b
->value
;
525 /* Read the builtins table above and enter them, and language-specific
526 macros, into the hash table. HOSTED is true if this is a hosted
529 cpp_init_builtins (cpp_reader
*pfile
, int hosted
)
531 cpp_init_special_builtins (pfile
);
533 if (!CPP_OPTION (pfile
, traditional
)
534 && (! CPP_OPTION (pfile
, stdc_0_in_system_headers
)
535 || CPP_OPTION (pfile
, std
)))
536 _cpp_define_builtin (pfile
, "__STDC__ 1");
538 if (CPP_OPTION (pfile
, cplusplus
))
540 if (CPP_OPTION (pfile
, lang
) == CLK_CXX20
541 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX20
)
542 _cpp_define_builtin (pfile
, "__cplusplus 201709L");
543 else if (CPP_OPTION (pfile
, lang
) == CLK_CXX17
544 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX17
)
545 _cpp_define_builtin (pfile
, "__cplusplus 201703L");
546 else if (CPP_OPTION (pfile
, lang
) == CLK_CXX14
547 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX14
)
548 _cpp_define_builtin (pfile
, "__cplusplus 201402L");
549 else if (CPP_OPTION (pfile
, lang
) == CLK_CXX11
550 || CPP_OPTION (pfile
, lang
) == CLK_GNUCXX11
)
551 _cpp_define_builtin (pfile
, "__cplusplus 201103L");
553 _cpp_define_builtin (pfile
, "__cplusplus 199711L");
555 else if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
556 _cpp_define_builtin (pfile
, "__ASSEMBLER__ 1");
557 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC94
)
558 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199409L");
559 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC2X
560 || CPP_OPTION (pfile
, lang
) == CLK_GNUC2X
)
561 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 202000L");
562 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC17
563 || CPP_OPTION (pfile
, lang
) == CLK_GNUC17
)
564 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 201710L");
565 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC11
566 || CPP_OPTION (pfile
, lang
) == CLK_GNUC11
)
567 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 201112L");
568 else if (CPP_OPTION (pfile
, c99
))
569 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199901L");
571 if (CPP_OPTION (pfile
, uliterals
)
572 && !(CPP_OPTION (pfile
, cplusplus
)
573 && (CPP_OPTION (pfile
, lang
) == CLK_GNUCXX
574 || CPP_OPTION (pfile
, lang
) == CLK_CXX98
)))
576 _cpp_define_builtin (pfile
, "__STDC_UTF_16__ 1");
577 _cpp_define_builtin (pfile
, "__STDC_UTF_32__ 1");
581 _cpp_define_builtin (pfile
, "__STDC_HOSTED__ 1");
583 _cpp_define_builtin (pfile
, "__STDC_HOSTED__ 0");
585 if (CPP_OPTION (pfile
, objc
))
586 _cpp_define_builtin (pfile
, "__OBJC__ 1");
589 /* Sanity-checks are dependent on command-line options, so it is
590 called as a subroutine of cpp_read_main_file. */
592 static void sanity_checks (cpp_reader
*);
593 static void sanity_checks (cpp_reader
*pfile
)
596 size_t max_precision
= 2 * CHAR_BIT
* sizeof (cpp_num_part
);
598 /* Sanity checks for assumptions about CPP arithmetic and target
599 type precisions made by cpplib. */
602 cpp_error (pfile
, CPP_DL_ICE
, "cppchar_t must be an unsigned type");
604 if (CPP_OPTION (pfile
, precision
) > max_precision
)
605 cpp_error (pfile
, CPP_DL_ICE
,
606 "preprocessor arithmetic has maximum precision of %lu bits;"
607 " target requires %lu bits",
608 (unsigned long) max_precision
,
609 (unsigned long) CPP_OPTION (pfile
, precision
));
611 if (CPP_OPTION (pfile
, precision
) < CPP_OPTION (pfile
, int_precision
))
612 cpp_error (pfile
, CPP_DL_ICE
,
613 "CPP arithmetic must be at least as precise as a target int");
615 if (CPP_OPTION (pfile
, char_precision
) < 8)
616 cpp_error (pfile
, CPP_DL_ICE
, "target char is less than 8 bits wide");
618 if (CPP_OPTION (pfile
, wchar_precision
) < CPP_OPTION (pfile
, char_precision
))
619 cpp_error (pfile
, CPP_DL_ICE
,
620 "target wchar_t is narrower than target char");
622 if (CPP_OPTION (pfile
, int_precision
) < CPP_OPTION (pfile
, char_precision
))
623 cpp_error (pfile
, CPP_DL_ICE
,
624 "target int is narrower than target char");
626 /* This is assumed in eval_token() and could be fixed if necessary. */
627 if (sizeof (cppchar_t
) > sizeof (cpp_num_part
))
628 cpp_error (pfile
, CPP_DL_ICE
,
629 "CPP half-integer narrower than CPP character");
631 if (CPP_OPTION (pfile
, wchar_precision
) > BITS_PER_CPPCHAR_T
)
632 cpp_error (pfile
, CPP_DL_ICE
,
633 "CPP on this host cannot handle wide character constants over"
634 " %lu bits, but the target requires %lu bits",
635 (unsigned long) BITS_PER_CPPCHAR_T
,
636 (unsigned long) CPP_OPTION (pfile
, wchar_precision
));
639 # define sanity_checks(PFILE)
642 /* This is called after options have been parsed, and partially
645 cpp_post_options (cpp_reader
*pfile
)
649 sanity_checks (pfile
);
651 post_options (pfile
);
653 /* Mark named operators before handling command line macros. */
655 if (CPP_OPTION (pfile
, cplusplus
) && CPP_OPTION (pfile
, operator_names
))
656 flags
|= NODE_OPERATOR
;
657 if (CPP_OPTION (pfile
, warn_cxx_operator_names
))
658 flags
|= NODE_DIAGNOSTIC
| NODE_WARN_OPERATOR
;
660 mark_named_operators (pfile
, flags
);
663 /* Setup for processing input from the file named FNAME, or stdin if
664 it is the empty string. Return the original filename on success
665 (e.g. foo.i->foo.c), or NULL on failure. INJECTING is true if
666 there may be injected headers before line 1 of the main file. */
668 cpp_read_main_file (cpp_reader
*pfile
, const char *fname
, bool injecting
)
670 if (mkdeps
*deps
= cpp_get_deps (pfile
))
671 /* Set the default target (if there is none already). */
672 deps_add_default_target (deps
, fname
);
675 = _cpp_find_file (pfile
, fname
, &pfile
->no_search_path
, /*angle=*/0,
677 if (_cpp_find_failed (pfile
->main_file
))
680 _cpp_stack_file (pfile
, pfile
->main_file
,
681 injecting
|| CPP_OPTION (pfile
, preprocessed
)
682 ? IT_PRE_MAIN
: IT_MAIN
, 0);
684 /* For foo.i, read the original filename foo.c now, for the benefit
685 of the front ends. */
686 if (CPP_OPTION (pfile
, preprocessed
))
687 if (!read_original_filename (pfile
))
689 /* We're on line 1 after all. */
690 auto *last
= linemap_check_ordinary
691 (LINEMAPS_LAST_MAP (pfile
->line_table
, false));
693 /* Inform of as-if a file change. */
694 _cpp_do_file_change (pfile
, LC_RENAME_VERBATIM
, LINEMAP_FILE (last
),
695 LINEMAP_LINE (last
), LINEMAP_SYSP (last
));
698 return ORDINARY_MAP_FILE_NAME (LINEMAPS_LAST_ORDINARY_MAP (pfile
->line_table
));
701 /* For preprocessed files, if the very first characters are
702 '#<SPACE>[01]<SPACE>', then handle a line directive so we know the
703 original file name. This will generate file_change callbacks,
704 which the front ends must handle appropriately given their state of
705 initialization. We peek directly into the character buffer, so
706 that we're not confused by otherwise-skipped white space &
707 comments. We can be very picky, because this should have been
708 machine-generated text (by us, no less). This way we do not
709 interfere with the module directive state machine. */
712 read_original_filename (cpp_reader
*pfile
)
714 auto *buf
= pfile
->buffer
->next_line
;
716 if (pfile
->buffer
->rlimit
- buf
> 4
719 // Also permit '1', as that's what used to be here
720 && (buf
[2] == '0' || buf
[2] == '1')
723 const cpp_token
*token
= _cpp_lex_direct (pfile
);
724 gcc_checking_assert (token
->type
== CPP_HASH
);
725 if (_cpp_handle_directive (pfile
, token
->flags
& PREV_WHITE
))
727 read_original_directory (pfile
);
735 /* For preprocessed files, if the tokens following the first filename
736 line is of the form # <line> "/path/name//", handle the
737 directive so we know the original current directory.
739 As with the first line peeking, we can do this without lexing by
742 read_original_directory (cpp_reader
*pfile
)
744 auto *buf
= pfile
->buffer
->next_line
;
746 if (pfile
->buffer
->rlimit
- buf
> 4
749 // Also permit '1', as that's what used to be here
750 && (buf
[2] == '0' || buf
[2] == '1')
753 const cpp_token
*hash
= _cpp_lex_direct (pfile
);
754 gcc_checking_assert (hash
->type
== CPP_HASH
);
755 pfile
->state
.in_directive
= 1;
756 const cpp_token
*number
= _cpp_lex_direct (pfile
);
757 gcc_checking_assert (number
->type
== CPP_NUMBER
);
758 const cpp_token
*string
= _cpp_lex_direct (pfile
);
759 pfile
->state
.in_directive
= 0;
761 const unsigned char *text
= nullptr;
763 if (string
->type
== CPP_STRING
)
765 /* The string value includes the quotes. */
766 text
= string
->val
.str
.text
;
767 len
= string
->val
.str
.len
;
770 || !IS_DIR_SEPARATOR (text
[len
- 2])
771 || !IS_DIR_SEPARATOR (text
[len
- 3]))
773 /* That didn't work out, back out. */
774 _cpp_backup_tokens (pfile
, 3);
778 if (pfile
->cb
.dir_change
)
780 /* Smash the string directly, it's dead at this point */
781 char *smashy
= (char *)text
;
784 pfile
->cb
.dir_change (pfile
, smashy
+ 1);
787 /* We should be at EOL. */
791 /* This is called at the end of preprocessing. It pops the last
792 buffer and writes dependency output.
794 Maybe it should also reset state, such that you could call
795 cpp_start_read with a new filename to restart processing. */
797 cpp_finish (cpp_reader
*pfile
, FILE *deps_stream
)
799 /* Warn about unused macros before popping the final buffer. */
800 if (CPP_OPTION (pfile
, warn_unused_macros
))
801 cpp_forall_identifiers (pfile
, _cpp_warn_if_unused_macro
, NULL
);
803 /* lex.c leaves the final buffer on the stack. This it so that
804 it returns an unending stream of CPP_EOFs to the client. If we
805 popped the buffer, we'd dereference a NULL buffer pointer and
806 segfault. It's nice to allow the client to do worry-free excess
807 cpp_get_token calls. */
808 while (pfile
->buffer
)
809 _cpp_pop_buffer (pfile
);
812 deps_write (pfile
, deps_stream
, 72);
814 /* Report on headers that could use multiple include guards. */
815 if (CPP_OPTION (pfile
, print_include_names
))
816 _cpp_report_missing_guards (pfile
);
820 post_options (cpp_reader
*pfile
)
822 /* -Wtraditional is not useful in C++ mode. */
823 if (CPP_OPTION (pfile
, cplusplus
))
824 CPP_OPTION (pfile
, cpp_warn_traditional
) = 0;
826 /* Permanently disable macro expansion if we are rescanning
827 preprocessed text. Read preprocesed source in ISO mode. */
828 if (CPP_OPTION (pfile
, preprocessed
))
830 if (!CPP_OPTION (pfile
, directives_only
))
831 pfile
->state
.prevent_expansion
= 1;
832 CPP_OPTION (pfile
, traditional
) = 0;
835 if (CPP_OPTION (pfile
, warn_trigraphs
) == 2)
836 CPP_OPTION (pfile
, warn_trigraphs
) = !CPP_OPTION (pfile
, trigraphs
);
838 if (CPP_OPTION (pfile
, traditional
))
840 CPP_OPTION (pfile
, trigraphs
) = 0;
841 CPP_OPTION (pfile
, warn_trigraphs
) = 0;