1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986-2021 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/>. */
28 /* Stack of conditionals currently in progress
29 (including both successful and failing conditionals). */
32 struct if_stack
*next
;
33 location_t line
; /* Line where condition started. */
34 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
35 bool skip_elses
; /* Can future #else / #elif be skipped? */
36 bool was_skipping
; /* If were skipping on entry. */
37 int type
; /* Most recent conditional for diagnostics. */
40 /* Contains a registered pragma or pragma namespace. */
41 typedef void (*pragma_cb
) (cpp_reader
*);
44 struct pragma_entry
*next
;
45 const cpp_hashnode
*pragma
; /* Name and length. */
52 struct pragma_entry
*space
;
57 /* Values for the origin field of struct directive. KANDR directives
58 come from traditional (K&R) C. STDC89 directives come from the
59 1989 C standard. EXTENSION directives are extensions. */
64 /* Values for the flags field of struct directive. COND indicates a
65 conditional; IF_COND an opening conditional. INCL means to treat
66 "..." and <...> as q-char and h-char sequences respectively. IN_I
67 means this directive should be handled even if -fpreprocessed is in
68 effect (these are the directives with callback hooks).
70 EXPAND is set on directives that are always macro-expanded. */
72 #define IF_COND (1 << 1)
75 #define EXPAND (1 << 4)
76 #define DEPRECATED (1 << 5)
78 /* Defines one #-directive, including how to handle it. */
79 typedef void (*directive_handler
) (cpp_reader
*);
80 typedef struct directive directive
;
83 directive_handler handler
; /* Function to handle directive. */
84 const uchar
*name
; /* Name of directive. */
85 unsigned short length
; /* Length of name. */
86 unsigned char origin
; /* Origin of directive. */
87 unsigned char flags
; /* Flags describing this directive. */
90 /* Forward declarations. */
92 static void skip_rest_of_line (cpp_reader
*);
93 static void check_eol (cpp_reader
*, bool);
94 static void start_directive (cpp_reader
*);
95 static void prepare_directive_trad (cpp_reader
*);
96 static void end_directive (cpp_reader
*, int);
97 static void directive_diagnostics (cpp_reader
*, const directive
*, int);
98 static void run_directive (cpp_reader
*, int, const char *, size_t);
99 static char *glue_header_name (cpp_reader
*);
100 static const char *parse_include (cpp_reader
*, int *, const cpp_token
***,
102 static void push_conditional (cpp_reader
*, int, int, const cpp_hashnode
*);
103 static unsigned int read_flag (cpp_reader
*, unsigned int);
104 static bool strtolinenum (const uchar
*, size_t, linenum_type
*, bool *);
105 static void do_diagnostic (cpp_reader
*, enum cpp_diagnostic_level code
,
106 enum cpp_warning_reason reason
, int);
107 static cpp_hashnode
*lex_macro_node (cpp_reader
*, bool);
108 static int undefine_macros (cpp_reader
*, cpp_hashnode
*, void *);
109 static void do_include_common (cpp_reader
*, enum include_type
);
110 static struct pragma_entry
*lookup_pragma_entry (struct pragma_entry
*,
111 const cpp_hashnode
*);
112 static int count_registered_pragmas (struct pragma_entry
*);
113 static char ** save_registered_pragmas (struct pragma_entry
*, char **);
114 static char ** restore_registered_pragmas (cpp_reader
*, struct pragma_entry
*,
116 static void do_pragma_once (cpp_reader
*);
117 static void do_pragma_poison (cpp_reader
*);
118 static void do_pragma_system_header (cpp_reader
*);
119 static void do_pragma_dependency (cpp_reader
*);
120 static void do_pragma_warning_or_error (cpp_reader
*, bool error
);
121 static void do_pragma_warning (cpp_reader
*);
122 static void do_pragma_error (cpp_reader
*);
123 static void do_linemarker (cpp_reader
*);
124 static const cpp_token
*get_token_no_padding (cpp_reader
*);
125 static const cpp_token
*get__Pragma_string (cpp_reader
*);
126 static void destringize_and_run (cpp_reader
*, const cpp_string
*,
128 static bool parse_answer (cpp_reader
*, int, location_t
, cpp_macro
**);
129 static cpp_hashnode
*parse_assertion (cpp_reader
*, int, cpp_macro
**);
130 static cpp_macro
**find_answer (cpp_hashnode
*, const cpp_macro
*);
131 static void handle_assertion (cpp_reader
*, const char *, int);
132 static void do_pragma_push_macro (cpp_reader
*);
133 static void do_pragma_pop_macro (cpp_reader
*);
134 static void cpp_pop_definition (cpp_reader
*, struct def_pragma_macro
*);
136 /* This is the table of directive handlers. All extensions other than
137 #warning, #include_next, and #import are deprecated. The name is
138 where the extension appears to have come from. */
140 #define DIRECTIVE_TABLE \
141 D(define, T_DEFINE = 0, KANDR, IN_I) \
142 D(include, T_INCLUDE, KANDR, INCL | EXPAND) \
143 D(endif, T_ENDIF, KANDR, COND) \
144 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) \
145 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) \
146 D(else, T_ELSE, KANDR, COND) \
147 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) \
148 D(undef, T_UNDEF, KANDR, IN_I) \
149 D(line, T_LINE, KANDR, EXPAND) \
150 D(elif, T_ELIF, STDC89, COND | EXPAND) \
151 D(error, T_ERROR, STDC89, 0) \
152 D(pragma, T_PRAGMA, STDC89, IN_I) \
153 D(warning, T_WARNING, EXTENSION, 0) \
154 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) \
155 D(ident, T_IDENT, EXTENSION, IN_I) \
156 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* ObjC */ \
157 D(assert, T_ASSERT, EXTENSION, DEPRECATED) /* SVR4 */ \
158 D(unassert, T_UNASSERT, EXTENSION, DEPRECATED) /* SVR4 */ \
159 D(sccs, T_SCCS, EXTENSION, IN_I) /* SVR4? */
161 /* #sccs is synonymous with #ident. */
162 #define do_sccs do_ident
164 /* Use the table to generate a series of prototypes, an enum for the
165 directive names, and an array of directive handlers. */
167 #define D(name, t, o, f) static void do_##name (cpp_reader *);
171 #define D(n, tag, o, f) tag,
179 #define D(name, t, origin, flags) \
180 { do_##name, (const uchar *) #name, \
181 sizeof #name - 1, origin, flags },
182 static const directive dtable
[] =
188 /* A NULL-terminated array of directive names for use
189 when suggesting corrections for misspelled directives. */
190 #define D(name, t, origin, flags) #name,
191 static const char * const directive_names
[] = {
197 #undef DIRECTIVE_TABLE
199 /* Wrapper struct directive for linemarkers.
200 The origin is more or less true - the original K+R cpp
201 did use this notation in its preprocessed output. */
202 static const directive linemarker_dir
=
204 do_linemarker
, UC
"#", 1, KANDR
, IN_I
207 /* Skip any remaining tokens in a directive. */
209 skip_rest_of_line (cpp_reader
*pfile
)
211 /* Discard all stacked contexts. */
212 while (pfile
->context
->prev
)
213 _cpp_pop_context (pfile
);
215 /* Sweep up all tokens remaining on the line. */
217 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
221 /* Helper function for check_oel. */
224 check_eol_1 (cpp_reader
*pfile
, bool expand
, enum cpp_warning_reason reason
)
226 if (! SEEN_EOL () && (expand
227 ? cpp_get_token (pfile
)
228 : _cpp_lex_token (pfile
))->type
!= CPP_EOF
)
229 cpp_pedwarning (pfile
, reason
, "extra tokens at end of #%s directive",
230 pfile
->directive
->name
);
233 /* Variant of check_eol used for Wendif-labels warnings. */
236 check_eol_endif_labels (cpp_reader
*pfile
)
238 check_eol_1 (pfile
, false, CPP_W_ENDIF_LABELS
);
241 /* Ensure there are no stray tokens at the end of a directive. If
242 EXPAND is true, tokens macro-expanding to nothing are allowed. */
245 check_eol (cpp_reader
*pfile
, bool expand
)
247 check_eol_1 (pfile
, expand
, CPP_W_NONE
);
250 /* Ensure there are no stray tokens other than comments at the end of
251 a directive, and gather the comments. */
252 static const cpp_token
**
253 check_eol_return_comments (cpp_reader
*pfile
)
257 const cpp_token
**buf
;
259 buf
= XNEWVEC (const cpp_token
*, capacity
);
265 const cpp_token
*tok
;
267 tok
= _cpp_lex_token (pfile
);
268 if (tok
->type
== CPP_EOF
)
270 if (tok
->type
!= CPP_COMMENT
)
271 cpp_error (pfile
, CPP_DL_PEDWARN
,
272 "extra tokens at end of #%s directive",
273 pfile
->directive
->name
);
276 if (c
+ 1 >= capacity
)
279 buf
= XRESIZEVEC (const cpp_token
*, buf
, capacity
);
290 /* Called when entering a directive, _Pragma or command-line directive. */
292 start_directive (cpp_reader
*pfile
)
294 /* Setup in-directive state. */
295 pfile
->state
.in_directive
= 1;
296 pfile
->state
.save_comments
= 0;
297 pfile
->directive_result
.type
= CPP_PADDING
;
299 /* Some handlers need the position of the # for diagnostics. */
300 pfile
->directive_line
= pfile
->line_table
->highest_line
;
303 /* Called when leaving a directive, _Pragma or command-line directive. */
305 end_directive (cpp_reader
*pfile
, int skip_line
)
307 if (CPP_OPTION (pfile
, traditional
))
309 /* Revert change of prepare_directive_trad. */
310 if (!pfile
->state
.in_deferred_pragma
)
311 pfile
->state
.prevent_expansion
--;
313 if (pfile
->directive
!= &dtable
[T_DEFINE
])
314 _cpp_remove_overlay (pfile
);
316 else if (pfile
->state
.in_deferred_pragma
)
318 /* We don't skip for an assembler #. */
321 skip_rest_of_line (pfile
);
322 if (!pfile
->keep_tokens
)
324 pfile
->cur_run
= &pfile
->base_run
;
325 pfile
->cur_token
= pfile
->base_run
.base
;
330 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
331 pfile
->state
.in_directive
= 0;
332 pfile
->state
.in_expression
= 0;
333 pfile
->state
.angled_headers
= 0;
334 pfile
->directive
= 0;
337 /* Prepare to handle the directive in pfile->directive. */
339 prepare_directive_trad (cpp_reader
*pfile
)
341 if (pfile
->directive
!= &dtable
[T_DEFINE
])
343 bool no_expand
= (pfile
->directive
344 && ! (pfile
->directive
->flags
& EXPAND
));
345 bool was_skipping
= pfile
->state
.skipping
;
347 pfile
->state
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
348 || pfile
->directive
== &dtable
[T_ELIF
]);
349 if (pfile
->state
.in_expression
)
350 pfile
->state
.skipping
= false;
353 pfile
->state
.prevent_expansion
++;
354 _cpp_scan_out_logical_line (pfile
, NULL
, false);
356 pfile
->state
.prevent_expansion
--;
358 pfile
->state
.skipping
= was_skipping
;
359 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
360 pfile
->out
.cur
- pfile
->out
.base
);
363 /* Stop ISO C from expanding anything. */
364 pfile
->state
.prevent_expansion
++;
367 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
368 the '#' was indented. */
370 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
372 /* Issue -pedantic or deprecated warnings for extensions. We let
373 -pedantic take precedence if both are applicable. */
374 if (! pfile
->state
.skipping
)
376 if (dir
->origin
== EXTENSION
377 && !(dir
== &dtable
[T_IMPORT
] && CPP_OPTION (pfile
, objc
))
378 && CPP_PEDANTIC (pfile
))
379 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
380 else if (((dir
->flags
& DEPRECATED
) != 0
381 || (dir
== &dtable
[T_IMPORT
] && !CPP_OPTION (pfile
, objc
)))
382 && CPP_OPTION (pfile
, cpp_warn_deprecated
))
383 cpp_warning (pfile
, CPP_W_DEPRECATED
,
384 "#%s is a deprecated GCC extension", dir
->name
);
387 /* Traditionally, a directive is ignored unless its # is in
388 column 1. Therefore in code intended to work with K+R
389 compilers, directives added by C89 must have their #
390 indented, and directives present in traditional C must not.
391 This is true even of directives in skipped conditional
392 blocks. #elif cannot be used at all. */
393 if (CPP_WTRADITIONAL (pfile
))
395 if (dir
== &dtable
[T_ELIF
])
396 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
397 "suggest not using #elif in traditional C");
398 else if (indented
&& dir
->origin
== KANDR
)
399 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
400 "traditional C ignores #%s with the # indented",
402 else if (!indented
&& dir
->origin
!= KANDR
)
403 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
404 "suggest hiding #%s from traditional C with an indented #",
409 /* Check if we have a known directive. INDENTED is true if the
410 '#' of the directive was indented. This function is in this file
411 to save unnecessarily exporting dtable etc. to lex.c. Returns
412 nonzero if the line of tokens has been handled, zero if we should
413 continue processing the line. */
415 _cpp_handle_directive (cpp_reader
*pfile
, bool indented
)
417 const directive
*dir
= 0;
418 const cpp_token
*dname
;
419 bool was_parsing_args
= pfile
->state
.parsing_args
;
420 bool was_discarding_output
= pfile
->state
.discarding_output
;
423 if (was_discarding_output
)
424 pfile
->state
.prevent_expansion
= 0;
426 if (was_parsing_args
)
428 if (CPP_OPTION (pfile
, cpp_pedantic
))
429 cpp_error (pfile
, CPP_DL_PEDWARN
,
430 "embedding a directive within macro arguments is not portable");
431 pfile
->state
.parsing_args
= 0;
432 pfile
->state
.prevent_expansion
= 0;
434 start_directive (pfile
);
435 dname
= _cpp_lex_token (pfile
);
437 if (dname
->type
== CPP_NAME
)
439 if (dname
->val
.node
.node
->is_directive
)
440 dir
= &dtable
[dname
->val
.node
.node
->directive_index
];
442 /* We do not recognize the # followed by a number extension in
444 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
446 dir
= &linemarker_dir
;
447 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
448 && ! pfile
->state
.skipping
)
449 cpp_error (pfile
, CPP_DL_PEDWARN
,
450 "style of line directive is a GCC extension");
455 /* If we have a directive that is not an opening conditional,
456 invalidate any control macro. */
457 if (! (dir
->flags
& IF_COND
))
458 pfile
->mi_valid
= false;
460 /* Kluge alert. In order to be sure that code like this
465 does not cause '#define foo bar' to get executed when
466 compiled with -save-temps, we recognize directives in
467 -fpreprocessed mode only if the # is in column 1. macro.c
468 puts a space in front of any '#' at the start of a macro.
470 We exclude the -fdirectives-only case because macro expansion
471 has not been performed yet, and block comments can cause spaces
472 to precede the directive. */
473 if (CPP_OPTION (pfile
, preprocessed
)
474 && !CPP_OPTION (pfile
, directives_only
)
475 && (indented
|| !(dir
->flags
& IN_I
)))
482 /* In failed conditional groups, all non-conditional
483 directives are ignored. Before doing that, whether
484 skipping or not, we should lex angle-bracketed headers
485 correctly, and maybe output some diagnostics. */
486 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
487 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
488 if (! CPP_OPTION (pfile
, preprocessed
))
489 directive_diagnostics (pfile
, dir
, indented
);
490 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
494 else if (dname
->type
== CPP_EOF
)
495 ; /* CPP_EOF is the "null directive". */
498 /* An unknown directive. Don't complain about it in assembly
499 source: we don't know where the comments are, and # may
500 introduce assembler pseudo-ops. Don't complain about invalid
501 directives in skipped conditional groups (6.10 p4). */
502 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
504 else if (!pfile
->state
.skipping
)
506 const char *unrecognized
507 = (const char *)cpp_token_as_text (pfile
, dname
);
508 const char *hint
= NULL
;
510 /* Call back into gcc to get a spelling suggestion. Ideally
511 we'd just use best_match from gcc/spellcheck.h (and filter
512 out the uncommon directives), but that requires moving it
513 to a support library. */
514 if (pfile
->cb
.get_suggestion
)
515 hint
= pfile
->cb
.get_suggestion (pfile
, unrecognized
,
520 rich_location
richloc (pfile
->line_table
, dname
->src_loc
);
521 source_range misspelled_token_range
522 = get_range_from_loc (pfile
->line_table
, dname
->src_loc
);
523 richloc
.add_fixit_replace (misspelled_token_range
, hint
);
524 cpp_error_at (pfile
, CPP_DL_ERROR
, &richloc
,
525 "invalid preprocessing directive #%s;"
526 " did you mean #%s?",
530 cpp_error (pfile
, CPP_DL_ERROR
,
531 "invalid preprocessing directive #%s",
536 pfile
->directive
= dir
;
537 if (CPP_OPTION (pfile
, traditional
))
538 prepare_directive_trad (pfile
);
541 pfile
->directive
->handler (pfile
);
543 _cpp_backup_tokens (pfile
, 1);
545 end_directive (pfile
, skip
);
546 if (was_parsing_args
&& !pfile
->state
.in_deferred_pragma
)
548 /* Restore state when within macro args. */
549 pfile
->state
.parsing_args
= 2;
550 pfile
->state
.prevent_expansion
= 1;
552 if (was_discarding_output
)
553 pfile
->state
.prevent_expansion
= 1;
557 /* Directive handler wrapper used by the command line option
558 processor. BUF is \n terminated. */
560 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
562 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
563 /* from_stage3 */ true);
564 start_directive (pfile
);
566 /* This is a short-term fix to prevent a leading '#' being
567 interpreted as a directive. */
568 _cpp_clean_line (pfile
);
570 pfile
->directive
= &dtable
[dir_no
];
571 if (CPP_OPTION (pfile
, traditional
))
572 prepare_directive_trad (pfile
);
573 pfile
->directive
->handler (pfile
);
574 end_directive (pfile
, 1);
575 _cpp_pop_buffer (pfile
);
578 /* Checks for validity the macro name in #define, #undef, #ifdef and
579 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
580 processing a #define or #undefine directive, and false
582 static cpp_hashnode
*
583 lex_macro_node (cpp_reader
*pfile
, bool is_def_or_undef
)
585 const cpp_token
*token
= _cpp_lex_token (pfile
);
587 /* The token immediately after #define must be an identifier. That
588 identifier may not be "defined", per C99 6.10.8p4.
589 In C++, it may not be any of the "named operators" either,
590 per C++98 [lex.digraph], [lex.key].
591 Finally, the identifier may not have been poisoned. (In that case
592 the lexer has issued the error message for us.) */
594 if (token
->type
== CPP_NAME
)
596 cpp_hashnode
*node
= token
->val
.node
.node
;
599 && node
== pfile
->spec_nodes
.n_defined
)
600 cpp_error (pfile
, CPP_DL_ERROR
,
601 "\"%s\" cannot be used as a macro name",
603 else if (! (node
->flags
& NODE_POISONED
))
606 else if (token
->flags
& NAMED_OP
)
607 cpp_error (pfile
, CPP_DL_ERROR
,
608 "\"%s\" cannot be used as a macro name as it is an operator in C++",
609 NODE_NAME (token
->val
.node
.node
));
610 else if (token
->type
== CPP_EOF
)
611 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
612 pfile
->directive
->name
);
614 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
619 /* Process a #define directive. Most work is done in macro.c. */
621 do_define (cpp_reader
*pfile
)
623 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
627 /* If we have been requested to expand comments into macros,
628 then re-enable saving of comments. */
629 pfile
->state
.save_comments
=
630 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
632 if (pfile
->cb
.before_define
)
633 pfile
->cb
.before_define (pfile
);
635 if (_cpp_create_definition (pfile
, node
))
636 if (pfile
->cb
.define
)
637 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
639 node
->flags
&= ~NODE_USED
;
643 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
645 do_undef (cpp_reader
*pfile
)
647 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
651 if (pfile
->cb
.before_define
)
652 pfile
->cb
.before_define (pfile
);
655 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
657 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
658 identifier is not currently defined as a macro name. */
659 if (cpp_macro_p (node
))
661 if (node
->flags
& NODE_WARN
)
662 cpp_error (pfile
, CPP_DL_WARNING
,
663 "undefining \"%s\"", NODE_NAME (node
));
664 else if (cpp_builtin_macro_p (node
)
665 && CPP_OPTION (pfile
, warn_builtin_macro_redefined
))
666 cpp_warning_with_line (pfile
, CPP_W_BUILTIN_MACRO_REDEFINED
,
667 pfile
->directive_line
, 0,
668 "undefining \"%s\"", NODE_NAME (node
));
670 if (node
->value
.macro
671 && CPP_OPTION (pfile
, warn_unused_macros
))
672 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
674 _cpp_free_definition (node
);
678 check_eol (pfile
, false);
681 /* Undefine a single macro/assertion/whatever. */
684 undefine_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*h
,
685 void *data_p ATTRIBUTE_UNUSED
)
687 /* Body of _cpp_free_definition inlined here for speed.
688 Macros and assertions no longer have anything to free. */
690 h
->value
.answers
= NULL
;
691 h
->flags
&= ~(NODE_POISONED
|NODE_DISABLED
|NODE_USED
);
695 /* Undefine all macros and assertions. */
698 cpp_undef_all (cpp_reader
*pfile
)
700 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
704 /* Helper routine used by parse_include. Reinterpret the current line
705 as an h-char-sequence (< ... >); we are looking at the first token
706 after the <. Returns a malloced filename. */
708 glue_header_name (cpp_reader
*pfile
)
710 const cpp_token
*token
;
712 size_t len
, total_len
= 0, capacity
= 1024;
714 /* To avoid lexed tokens overwriting our glued name, we can only
715 allocate from the string pool once we've lexed everything. */
716 buffer
= XNEWVEC (char, capacity
);
719 token
= get_token_no_padding (pfile
);
721 if (token
->type
== CPP_GREATER
)
723 if (token
->type
== CPP_EOF
)
725 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
729 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
730 if (total_len
+ len
> capacity
)
732 capacity
= (capacity
+ len
) * 2;
733 buffer
= XRESIZEVEC (char, buffer
, capacity
);
736 if (token
->flags
& PREV_WHITE
)
737 buffer
[total_len
++] = ' ';
739 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
],
744 buffer
[total_len
] = '\0';
748 /* Returns the file name of #include, #include_next, #import and
749 #pragma dependency. The string is malloced and the caller should
750 free it. Returns NULL on error. LOCATION is the source location
754 parse_include (cpp_reader
*pfile
, int *pangle_brackets
,
755 const cpp_token
***buf
, location_t
*location
)
758 const cpp_token
*header
;
760 /* Allow macro expansion. */
761 header
= get_token_no_padding (pfile
);
762 *location
= header
->src_loc
;
763 if ((header
->type
== CPP_STRING
&& header
->val
.str
.text
[0] != 'R')
764 || header
->type
== CPP_HEADER_NAME
)
766 fname
= XNEWVEC (char, header
->val
.str
.len
- 1);
767 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
768 fname
[header
->val
.str
.len
- 2] = '\0';
769 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
771 else if (header
->type
== CPP_LESS
)
773 fname
= glue_header_name (pfile
);
774 *pangle_brackets
= 1;
778 const unsigned char *dir
;
780 if (pfile
->directive
== &dtable
[T_PRAGMA
])
781 dir
= UC
"pragma dependency";
783 dir
= pfile
->directive
->name
;
784 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
790 if (pfile
->directive
== &dtable
[T_PRAGMA
])
792 /* This pragma allows extra tokens after the file name. */
794 else if (buf
== NULL
|| CPP_OPTION (pfile
, discard_comments
))
795 check_eol (pfile
, true);
798 /* If we are not discarding comments, then gather them while
799 doing the eol check. */
800 *buf
= check_eol_return_comments (pfile
);
806 /* Handle #include, #include_next and #import. */
808 do_include_common (cpp_reader
*pfile
, enum include_type type
)
812 const cpp_token
**buf
= NULL
;
815 /* Re-enable saving of comments if requested, so that the include
816 callback can dump comments which follow #include. */
817 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
819 /* Tell the lexer this is an include directive -- we want it to
820 increment the line number even if this is the last line of a file. */
821 pfile
->state
.in_directive
= 2;
823 fname
= parse_include (pfile
, &angle_brackets
, &buf
, &location
);
829 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
830 "empty filename in #%s",
831 pfile
->directive
->name
);
835 /* Prevent #include recursion. */
836 if (pfile
->line_table
->depth
>= CPP_OPTION (pfile
, max_include_depth
))
839 "#include nested depth %u exceeds maximum of %u"
840 " (use -fmax-include-depth=DEPTH to increase the maximum)",
841 pfile
->line_table
->depth
,
842 CPP_OPTION (pfile
, max_include_depth
));
845 /* Get out of macro context, if we are. */
846 skip_rest_of_line (pfile
);
848 if (pfile
->cb
.include
)
849 pfile
->cb
.include (pfile
, pfile
->directive_line
,
850 pfile
->directive
->name
, fname
, angle_brackets
,
853 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
, location
);
863 do_include (cpp_reader
*pfile
)
865 do_include_common (pfile
, IT_INCLUDE
);
869 do_import (cpp_reader
*pfile
)
871 do_include_common (pfile
, IT_IMPORT
);
875 do_include_next (cpp_reader
*pfile
)
877 enum include_type type
= IT_INCLUDE_NEXT
;
879 /* If this is the primary source file, warn and use the normal
881 if (_cpp_in_main_source_file (pfile
))
883 cpp_error (pfile
, CPP_DL_WARNING
,
884 "#include_next in primary source file");
887 do_include_common (pfile
, type
);
890 /* Subroutine of do_linemarker. Read possible flags after file name.
891 LAST is the last flag seen; 0 if this is the first flag. Return the
892 flag if it is valid, 0 at the end of the directive. Otherwise
895 read_flag (cpp_reader
*pfile
, unsigned int last
)
897 const cpp_token
*token
= _cpp_lex_token (pfile
);
899 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
901 unsigned int flag
= token
->val
.str
.text
[0] - '0';
903 if (flag
> last
&& flag
<= 4
904 && (flag
!= 4 || last
== 3)
905 && (flag
!= 2 || last
== 0))
909 if (token
->type
!= CPP_EOF
)
910 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
911 cpp_token_as_text (pfile
, token
));
915 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
916 of length LEN, to binary; store it in NUMP, and return false if the
917 number was well-formed, true if not. WRAPPED is set to true if the
918 number did not fit into 'linenum_type'. */
920 strtolinenum (const uchar
*str
, size_t len
, linenum_type
*nump
, bool *wrapped
)
922 linenum_type reg
= 0;
931 if (reg
> ((linenum_type
) -1) / 10)
934 if (reg
> ((linenum_type
) -1) - (c
- '0'))
942 /* Interpret #line command.
943 Note that the filename string (if any) is a true string constant
944 (escapes are interpreted). */
946 do_line (cpp_reader
*pfile
)
948 class line_maps
*line_table
= pfile
->line_table
;
949 const line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
951 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
954 unsigned char map_sysp
= ORDINARY_MAP_IN_SYSTEM_HEADER_P (map
);
955 const cpp_token
*token
;
956 const char *new_file
= ORDINARY_MAP_FILE_NAME (map
);
957 linenum_type new_lineno
;
959 /* C99 raised the minimum limit on #line numbers. */
960 linenum_type cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
963 /* #line commands expand macros. */
964 token
= cpp_get_token (pfile
);
965 if (token
->type
!= CPP_NUMBER
966 || strtolinenum (token
->val
.str
.text
, token
->val
.str
.len
,
967 &new_lineno
, &wrapped
))
969 if (token
->type
== CPP_EOF
)
970 cpp_error (pfile
, CPP_DL_ERROR
, "unexpected end of file after #line");
972 cpp_error (pfile
, CPP_DL_ERROR
,
973 "\"%s\" after #line is not a positive integer",
974 cpp_token_as_text (pfile
, token
));
978 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
|| wrapped
))
979 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
981 cpp_error (pfile
, CPP_DL_WARNING
, "line number out of range");
983 token
= cpp_get_token (pfile
);
984 if (token
->type
== CPP_STRING
)
986 cpp_string s
= { 0, 0 };
987 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, 1,
989 new_file
= (const char *)s
.text
;
990 check_eol (pfile
, true);
992 else if (token
->type
!= CPP_EOF
)
994 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
995 cpp_token_as_text (pfile
, token
));
999 skip_rest_of_line (pfile
);
1000 _cpp_do_file_change (pfile
, LC_RENAME_VERBATIM
, new_file
, new_lineno
,
1002 line_table
->seen_line_directive
= true;
1005 /* Interpret the # 44 "file" [flags] notation, which has slightly
1006 different syntax and semantics from #line: Flags are allowed,
1007 and we never complain about the line number being too big. */
1009 do_linemarker (cpp_reader
*pfile
)
1011 class line_maps
*line_table
= pfile
->line_table
;
1012 const line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
1013 const cpp_token
*token
;
1014 const char *new_file
= ORDINARY_MAP_FILE_NAME (map
);
1015 linenum_type new_lineno
;
1016 unsigned int new_sysp
= ORDINARY_MAP_IN_SYSTEM_HEADER_P (map
);
1017 enum lc_reason reason
= LC_RENAME_VERBATIM
;
1021 /* Back up so we can get the number again. Putting this in
1022 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
1023 some circumstances, which can segfault. */
1024 _cpp_backup_tokens (pfile
, 1);
1026 /* #line commands expand macros. */
1027 token
= cpp_get_token (pfile
);
1028 if (token
->type
!= CPP_NUMBER
1029 || strtolinenum (token
->val
.str
.text
, token
->val
.str
.len
,
1030 &new_lineno
, &wrapped
))
1032 /* Unlike #line, there does not seem to be a way to get an EOF
1033 here. So, it should be safe to always spell the token. */
1034 cpp_error (pfile
, CPP_DL_ERROR
,
1035 "\"%s\" after # is not a positive integer",
1036 cpp_token_as_text (pfile
, token
));
1040 token
= cpp_get_token (pfile
);
1041 if (token
->type
== CPP_STRING
)
1043 cpp_string s
= { 0, 0 };
1044 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
,
1046 new_file
= (const char *)s
.text
;
1049 flag
= read_flag (pfile
, 0);
1053 /* Fake an include for cpp_included (). */
1054 _cpp_fake_include (pfile
, new_file
);
1055 flag
= read_flag (pfile
, flag
);
1060 flag
= read_flag (pfile
, flag
);
1065 flag
= read_flag (pfile
, flag
);
1069 pfile
->buffer
->sysp
= new_sysp
;
1071 check_eol (pfile
, false);
1073 else if (token
->type
!= CPP_EOF
)
1075 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
1076 cpp_token_as_text (pfile
, token
));
1080 skip_rest_of_line (pfile
);
1082 if (reason
== LC_LEAVE
)
1084 /* Reread map since cpp_get_token can invalidate it with a
1086 map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
1087 const line_map_ordinary
*from
1088 = linemap_included_from_linemap (line_table
, map
);
1092 else if (!new_file
[0])
1093 /* Leaving to "" means fill in the popped-to name. */
1094 new_file
= ORDINARY_MAP_FILE_NAME (from
);
1095 else if (filename_cmp (ORDINARY_MAP_FILE_NAME (from
), new_file
) != 0)
1096 /* It's the wrong name, Grommit! */
1101 cpp_warning (pfile
, CPP_W_NONE
,
1102 "file \"%s\" linemarker ignored due to "
1103 "incorrect nesting", new_file
);
1108 /* Compensate for the increment in linemap_add that occurs in
1109 _cpp_do_file_change. We're currently at the start of the line
1110 *following* the #line directive. A separate location_t for this
1111 location makes no sense (until we do the LC_LEAVE), and
1112 complicates LAST_SOURCE_LINE_LOCATION. */
1113 pfile
->line_table
->highest_location
--;
1115 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
1116 line_table
->seen_line_directive
= true;
1119 /* Arrange the file_change callback. Changing to TO_FILE:TO_LINE for
1120 REASON. SYSP is 1 for a system header, 2 for a system header that
1121 needs to be extern "C" protected, and zero otherwise. */
1123 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
1124 const char *to_file
, linenum_type to_line
,
1127 linemap_assert (reason
!= LC_ENTER_MACRO
);
1129 const line_map_ordinary
*ord_map
= NULL
;
1130 if (!to_line
&& reason
== LC_RENAME_VERBATIM
)
1132 /* A linemarker moving to line zero. If we're on the second
1133 line of the current map, and it also starts at zero, just
1134 rewind -- we're probably reading the builtins of a
1135 preprocessed source. */
1136 line_map_ordinary
*last
= LINEMAPS_LAST_ORDINARY_MAP (pfile
->line_table
);
1137 if (!ORDINARY_MAP_STARTING_LINE_NUMBER (last
)
1138 && 0 == filename_cmp (to_file
, ORDINARY_MAP_FILE_NAME (last
))
1139 && SOURCE_LINE (last
, pfile
->line_table
->highest_line
) == 2)
1142 pfile
->line_table
->highest_location
1143 = pfile
->line_table
->highest_line
= MAP_START_LOCATION (last
);
1148 if (const line_map
*map
= linemap_add (pfile
->line_table
, reason
, sysp
,
1151 ord_map
= linemap_check_ordinary (map
);
1152 linemap_line_start (pfile
->line_table
,
1153 ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
),
1157 if (pfile
->cb
.file_change
)
1158 pfile
->cb
.file_change (pfile
, ord_map
);
1161 /* Report a warning or error detected by the program we are
1162 processing. Use the directive's tokens in the error message. */
1164 do_diagnostic (cpp_reader
*pfile
, enum cpp_diagnostic_level code
,
1165 enum cpp_warning_reason reason
, int print_dir
)
1167 const unsigned char *dir_name
;
1168 unsigned char *line
;
1169 location_t src_loc
= pfile
->cur_token
[-1].src_loc
;
1172 dir_name
= pfile
->directive
->name
;
1175 pfile
->state
.prevent_expansion
++;
1176 line
= cpp_output_line_to_string (pfile
, dir_name
);
1177 pfile
->state
.prevent_expansion
--;
1179 if (code
== CPP_DL_WARNING_SYSHDR
&& reason
)
1180 cpp_warning_with_line_syshdr (pfile
, reason
, src_loc
, 0, "%s", line
);
1181 else if (code
== CPP_DL_WARNING
&& reason
)
1182 cpp_warning_with_line (pfile
, reason
, src_loc
, 0, "%s", line
);
1184 cpp_error_with_line (pfile
, code
, src_loc
, 0, "%s", line
);
1189 do_error (cpp_reader
*pfile
)
1191 do_diagnostic (pfile
, CPP_DL_ERROR
, CPP_W_NONE
, 1);
1195 do_warning (cpp_reader
*pfile
)
1197 /* We want #warning diagnostics to be emitted in system headers too. */
1198 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, CPP_W_WARNING_DIRECTIVE
, 1);
1201 /* Report program identification. */
1203 do_ident (cpp_reader
*pfile
)
1205 const cpp_token
*str
= cpp_get_token (pfile
);
1207 if (str
->type
!= CPP_STRING
)
1208 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #%s directive",
1209 pfile
->directive
->name
);
1210 else if (pfile
->cb
.ident
)
1211 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
1213 check_eol (pfile
, false);
1216 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1217 matching entry, or NULL if none is found. The returned entry could
1218 be the start of a namespace chain, or a pragma. */
1219 static struct pragma_entry
*
1220 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
1222 while (chain
&& chain
->pragma
!= pragma
)
1223 chain
= chain
->next
;
1228 /* Create and insert a blank pragma entry at the beginning of a
1229 singly-linked CHAIN. */
1230 static struct pragma_entry
*
1231 new_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
)
1233 struct pragma_entry
*new_entry
;
1235 new_entry
= (struct pragma_entry
*)
1236 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
1238 memset (new_entry
, 0, sizeof (struct pragma_entry
));
1239 new_entry
->next
= *chain
;
1245 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1246 goes in the global namespace. */
1247 static struct pragma_entry
*
1248 register_pragma_1 (cpp_reader
*pfile
, const char *space
, const char *name
,
1249 bool allow_name_expansion
)
1251 struct pragma_entry
**chain
= &pfile
->pragmas
;
1252 struct pragma_entry
*entry
;
1253 const cpp_hashnode
*node
;
1257 node
= cpp_lookup (pfile
, UC space
, strlen (space
));
1258 entry
= lookup_pragma_entry (*chain
, node
);
1261 entry
= new_pragma_entry (pfile
, chain
);
1262 entry
->pragma
= node
;
1263 entry
->is_nspace
= true;
1264 entry
->allow_expansion
= allow_name_expansion
;
1266 else if (!entry
->is_nspace
)
1268 else if (entry
->allow_expansion
!= allow_name_expansion
)
1270 cpp_error (pfile
, CPP_DL_ICE
,
1271 "registering pragmas in namespace \"%s\" with mismatched "
1272 "name expansion", space
);
1275 chain
= &entry
->u
.space
;
1277 else if (allow_name_expansion
)
1279 cpp_error (pfile
, CPP_DL_ICE
,
1280 "registering pragma \"%s\" with name expansion "
1281 "and no namespace", name
);
1285 /* Check for duplicates. */
1286 node
= cpp_lookup (pfile
, UC name
, strlen (name
));
1287 entry
= lookup_pragma_entry (*chain
, node
);
1290 entry
= new_pragma_entry (pfile
, chain
);
1291 entry
->pragma
= node
;
1295 if (entry
->is_nspace
)
1297 cpp_error (pfile
, CPP_DL_ICE
,
1298 "registering \"%s\" as both a pragma and a pragma namespace",
1301 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1304 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1309 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1311 register_pragma_internal (cpp_reader
*pfile
, const char *space
,
1312 const char *name
, pragma_cb handler
)
1314 struct pragma_entry
*entry
;
1316 entry
= register_pragma_1 (pfile
, space
, name
, false);
1317 entry
->is_internal
= true;
1318 entry
->u
.handler
= handler
;
1321 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1322 goes in the global namespace. HANDLER is the handler it will call,
1323 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1324 expansion while parsing pragma NAME. This function is exported
1327 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
1328 pragma_cb handler
, bool allow_expansion
)
1330 struct pragma_entry
*entry
;
1334 cpp_error (pfile
, CPP_DL_ICE
, "registering pragma with NULL handler");
1338 entry
= register_pragma_1 (pfile
, space
, name
, false);
1341 entry
->allow_expansion
= allow_expansion
;
1342 entry
->u
.handler
= handler
;
1346 /* Similarly, but create mark the pragma for deferred processing.
1347 When found, a CPP_PRAGMA token will be insertted into the stream
1348 with IDENT in the token->u.pragma slot. */
1350 cpp_register_deferred_pragma (cpp_reader
*pfile
, const char *space
,
1351 const char *name
, unsigned int ident
,
1352 bool allow_expansion
, bool allow_name_expansion
)
1354 struct pragma_entry
*entry
;
1356 entry
= register_pragma_1 (pfile
, space
, name
, allow_name_expansion
);
1359 entry
->is_deferred
= true;
1360 entry
->allow_expansion
= allow_expansion
;
1361 entry
->u
.ident
= ident
;
1365 /* Register the pragmas the preprocessor itself handles. */
1367 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1369 /* Pragmas in the global namespace. */
1370 register_pragma_internal (pfile
, 0, "once", do_pragma_once
);
1371 register_pragma_internal (pfile
, 0, "push_macro", do_pragma_push_macro
);
1372 register_pragma_internal (pfile
, 0, "pop_macro", do_pragma_pop_macro
);
1374 /* New GCC-specific pragmas should be put in the GCC namespace. */
1375 register_pragma_internal (pfile
, "GCC", "poison", do_pragma_poison
);
1376 register_pragma_internal (pfile
, "GCC", "system_header",
1377 do_pragma_system_header
);
1378 register_pragma_internal (pfile
, "GCC", "dependency", do_pragma_dependency
);
1379 register_pragma_internal (pfile
, "GCC", "warning", do_pragma_warning
);
1380 register_pragma_internal (pfile
, "GCC", "error", do_pragma_error
);
1383 /* Return the number of registered pragmas in PE. */
1386 count_registered_pragmas (struct pragma_entry
*pe
)
1389 for (; pe
!= NULL
; pe
= pe
->next
)
1392 ct
+= count_registered_pragmas (pe
->u
.space
);
1398 /* Save into SD the names of the registered pragmas referenced by PE,
1399 and return a pointer to the next free space in SD. */
1402 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1404 for (; pe
!= NULL
; pe
= pe
->next
)
1407 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1408 *sd
++ = (char *) xmemdup (HT_STR (&pe
->pragma
->ident
),
1409 HT_LEN (&pe
->pragma
->ident
),
1410 HT_LEN (&pe
->pragma
->ident
) + 1);
1415 /* Return a newly-allocated array which saves the names of the
1416 registered pragmas. */
1419 _cpp_save_pragma_names (cpp_reader
*pfile
)
1421 int ct
= count_registered_pragmas (pfile
->pragmas
);
1422 char **result
= XNEWVEC (char *, ct
);
1423 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1427 /* Restore from SD the names of the registered pragmas referenced by PE,
1428 and return a pointer to the next unused name in SD. */
1431 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1434 for (; pe
!= NULL
; pe
= pe
->next
)
1437 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1438 pe
->pragma
= cpp_lookup (pfile
, UC
*sd
, strlen (*sd
));
1445 /* Restore the names of the registered pragmas from SAVED. */
1448 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1450 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1454 /* Pragmata handling. We handle some, and pass the rest on to the
1455 front end. C99 defines three pragmas and says that no macro
1456 expansion is to be performed on them; whether or not macro
1457 expansion happens for other pragmas is implementation defined.
1458 This implementation allows for a mix of both, since GCC did not
1459 traditionally macro expand its (few) pragmas, whereas OpenMP
1460 specifies that macro expansion should happen. */
1462 do_pragma (cpp_reader
*pfile
)
1464 const struct pragma_entry
*p
= NULL
;
1465 const cpp_token
*token
, *pragma_token
;
1466 location_t pragma_token_virt_loc
= 0;
1468 unsigned int count
= 1;
1470 pfile
->state
.prevent_expansion
++;
1472 pragma_token
= token
= cpp_get_token_with_location (pfile
,
1473 &pragma_token_virt_loc
);
1475 if (token
->type
== CPP_NAME
)
1477 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
.node
);
1478 if (p
&& p
->is_nspace
)
1480 bool allow_name_expansion
= p
->allow_expansion
;
1481 if (allow_name_expansion
)
1482 pfile
->state
.prevent_expansion
--;
1484 token
= cpp_get_token (pfile
);
1485 if (token
->type
== CPP_NAME
)
1486 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
.node
);
1489 if (allow_name_expansion
)
1490 pfile
->state
.prevent_expansion
++;
1499 pfile
->directive_result
.src_loc
= pragma_token_virt_loc
;
1500 pfile
->directive_result
.type
= CPP_PRAGMA
;
1501 pfile
->directive_result
.flags
= pragma_token
->flags
;
1502 pfile
->directive_result
.val
.pragma
= p
->u
.ident
;
1503 pfile
->state
.in_deferred_pragma
= true;
1504 pfile
->state
.pragma_allow_expansion
= p
->allow_expansion
;
1505 if (!p
->allow_expansion
)
1506 pfile
->state
.prevent_expansion
++;
1510 /* Since the handler below doesn't get the line number, that
1511 it might need for diagnostics, make sure it has the right
1512 numbers in place. */
1513 if (pfile
->cb
.line_change
)
1514 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1515 if (p
->allow_expansion
)
1516 pfile
->state
.prevent_expansion
--;
1517 (*p
->u
.handler
) (pfile
);
1518 if (p
->allow_expansion
)
1519 pfile
->state
.prevent_expansion
++;
1522 else if (pfile
->cb
.def_pragma
)
1524 if (count
== 1 || pfile
->context
->prev
== NULL
)
1525 _cpp_backup_tokens (pfile
, count
);
1528 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1529 won't allow backing 2 tokens. */
1530 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1531 reads both tokens, we could perhaps free it, but if it doesn't,
1532 we don't know the exact lifespan. */
1533 cpp_token
*toks
= XNEWVEC (cpp_token
, 2);
1535 toks
[0].flags
|= NO_EXPAND
;
1537 toks
[1].flags
|= NO_EXPAND
;
1538 _cpp_push_token_context (pfile
, NULL
, toks
, 2);
1540 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1543 pfile
->state
.prevent_expansion
--;
1546 /* Handle #pragma once. */
1548 do_pragma_once (cpp_reader
*pfile
)
1550 if (_cpp_in_main_source_file (pfile
))
1551 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1553 check_eol (pfile
, false);
1554 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1557 /* Handle #pragma push_macro(STRING). */
1559 do_pragma_push_macro (cpp_reader
*pfile
)
1563 const uchar
*defn
= NULL
;
1564 char *macroname
, *dest
;
1565 const char *limit
, *src
;
1566 const cpp_token
*txt
;
1567 struct def_pragma_macro
*c
;
1569 txt
= get__Pragma_string (pfile
);
1572 location_t src_loc
= pfile
->cur_token
[-1].src_loc
;
1573 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
1574 "invalid #pragma push_macro directive");
1575 check_eol (pfile
, false);
1576 skip_rest_of_line (pfile
);
1579 dest
= macroname
= (char *) alloca (txt
->val
.str
.len
+ 2);
1580 src
= (const char *) (txt
->val
.str
.text
+ 1 + (txt
->val
.str
.text
[0] == 'L'));
1581 limit
= (const char *) (txt
->val
.str
.text
+ txt
->val
.str
.len
- 1);
1584 /* We know there is a character following the backslash. */
1585 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1590 check_eol (pfile
, false);
1591 skip_rest_of_line (pfile
);
1592 c
= XNEW (struct def_pragma_macro
);
1593 memset (c
, 0, sizeof (struct def_pragma_macro
));
1594 c
->name
= XNEWVAR (char, strlen (macroname
) + 1);
1595 strcpy (c
->name
, macroname
);
1596 c
->next
= pfile
->pushed_macros
;
1597 node
= _cpp_lex_identifier (pfile
, c
->name
);
1598 if (node
->type
== NT_VOID
)
1600 else if (node
->type
== NT_BUILTIN_MACRO
)
1604 defn
= cpp_macro_definition (pfile
, node
);
1605 defnlen
= ustrlen (defn
);
1606 c
->definition
= XNEWVEC (uchar
, defnlen
+ 2);
1607 c
->definition
[defnlen
] = '\n';
1608 c
->definition
[defnlen
+ 1] = 0;
1609 c
->line
= node
->value
.macro
->line
;
1610 c
->syshdr
= node
->value
.macro
->syshdr
;
1611 c
->used
= node
->value
.macro
->used
;
1612 memcpy (c
->definition
, defn
, defnlen
);
1615 pfile
->pushed_macros
= c
;
1618 /* Handle #pragma pop_macro(STRING). */
1620 do_pragma_pop_macro (cpp_reader
*pfile
)
1622 char *macroname
, *dest
;
1623 const char *limit
, *src
;
1624 const cpp_token
*txt
;
1625 struct def_pragma_macro
*l
= NULL
, *c
= pfile
->pushed_macros
;
1626 txt
= get__Pragma_string (pfile
);
1629 location_t src_loc
= pfile
->cur_token
[-1].src_loc
;
1630 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
1631 "invalid #pragma pop_macro directive");
1632 check_eol (pfile
, false);
1633 skip_rest_of_line (pfile
);
1636 dest
= macroname
= (char *) alloca (txt
->val
.str
.len
+ 2);
1637 src
= (const char *) (txt
->val
.str
.text
+ 1 + (txt
->val
.str
.text
[0] == 'L'));
1638 limit
= (const char *) (txt
->val
.str
.text
+ txt
->val
.str
.len
- 1);
1641 /* We know there is a character following the backslash. */
1642 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1647 check_eol (pfile
, false);
1648 skip_rest_of_line (pfile
);
1652 if (!strcmp (c
->name
, macroname
))
1655 pfile
->pushed_macros
= c
->next
;
1658 cpp_pop_definition (pfile
, c
);
1659 free (c
->definition
);
1669 /* Handle #pragma GCC poison, to poison one or more identifiers so
1670 that the lexer produces a hard error for each subsequent usage. */
1672 do_pragma_poison (cpp_reader
*pfile
)
1674 const cpp_token
*tok
;
1677 pfile
->state
.poisoned_ok
= 1;
1680 tok
= _cpp_lex_token (pfile
);
1681 if (tok
->type
== CPP_EOF
)
1683 if (tok
->type
!= CPP_NAME
)
1685 cpp_error (pfile
, CPP_DL_ERROR
,
1686 "invalid #pragma GCC poison directive");
1690 hp
= tok
->val
.node
.node
;
1691 if (hp
->flags
& NODE_POISONED
)
1694 if (cpp_macro_p (hp
))
1695 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1697 _cpp_free_definition (hp
);
1698 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1700 pfile
->state
.poisoned_ok
= 0;
1703 /* Mark the current header as a system header. This will suppress
1704 some categories of warnings (notably those from -pedantic). It is
1705 intended for use in system libraries that cannot be implemented in
1706 conforming C, but cannot be certain that their headers appear in a
1707 system include directory. To prevent abuse, it is rejected in the
1708 primary source file. */
1710 do_pragma_system_header (cpp_reader
*pfile
)
1712 if (_cpp_in_main_source_file (pfile
))
1713 cpp_error (pfile
, CPP_DL_WARNING
,
1714 "#pragma system_header ignored outside include file");
1717 check_eol (pfile
, false);
1718 skip_rest_of_line (pfile
);
1719 cpp_make_system_header (pfile
, 1, 0);
1723 /* Check the modified date of the current include file against a specified
1724 file. Issue a diagnostic, if the specified file is newer. We use this to
1725 determine if a fixed header should be refixed. */
1727 do_pragma_dependency (cpp_reader
*pfile
)
1730 int angle_brackets
, ordering
;
1731 location_t location
;
1733 fname
= parse_include (pfile
, &angle_brackets
, NULL
, &location
);
1737 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1739 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1740 else if (ordering
> 0)
1742 cpp_error (pfile
, CPP_DL_WARNING
,
1743 "current file is older than %s", fname
);
1744 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1746 _cpp_backup_tokens (pfile
, 1);
1747 do_diagnostic (pfile
, CPP_DL_WARNING
, CPP_W_NONE
, 0);
1751 free ((void *) fname
);
1754 /* Issue a diagnostic with the message taken from the pragma. If
1755 ERROR is true, the diagnostic is a warning, otherwise, it is an
1758 do_pragma_warning_or_error (cpp_reader
*pfile
, bool error
)
1760 const cpp_token
*tok
= _cpp_lex_token (pfile
);
1762 if (tok
->type
!= CPP_STRING
1763 || !cpp_interpret_string_notranslate (pfile
, &tok
->val
.str
, 1, &str
,
1767 cpp_error (pfile
, CPP_DL_ERROR
, "invalid \"#pragma GCC %s\" directive",
1768 error
? "error" : "warning");
1771 cpp_error (pfile
, error
? CPP_DL_ERROR
: CPP_DL_WARNING
,
1773 free ((void *)str
.text
);
1776 /* Issue a warning diagnostic. */
1778 do_pragma_warning (cpp_reader
*pfile
)
1780 do_pragma_warning_or_error (pfile
, false);
1783 /* Issue an error diagnostic. */
1785 do_pragma_error (cpp_reader
*pfile
)
1787 do_pragma_warning_or_error (pfile
, true);
1790 /* Get a token but skip padding. */
1791 static const cpp_token
*
1792 get_token_no_padding (cpp_reader
*pfile
)
1796 const cpp_token
*result
= cpp_get_token (pfile
);
1797 if (result
->type
!= CPP_PADDING
)
1802 /* Check syntax is "(string-literal)". Returns the string on success,
1803 or NULL on failure. */
1804 static const cpp_token
*
1805 get__Pragma_string (cpp_reader
*pfile
)
1807 const cpp_token
*string
;
1808 const cpp_token
*paren
;
1810 paren
= get_token_no_padding (pfile
);
1811 if (paren
->type
== CPP_EOF
)
1812 _cpp_backup_tokens (pfile
, 1);
1813 if (paren
->type
!= CPP_OPEN_PAREN
)
1816 string
= get_token_no_padding (pfile
);
1817 if (string
->type
== CPP_EOF
)
1818 _cpp_backup_tokens (pfile
, 1);
1819 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
1820 && string
->type
!= CPP_STRING32
&& string
->type
!= CPP_STRING16
1821 && string
->type
!= CPP_UTF8STRING
)
1824 paren
= get_token_no_padding (pfile
);
1825 if (paren
->type
== CPP_EOF
)
1826 _cpp_backup_tokens (pfile
, 1);
1827 if (paren
->type
!= CPP_CLOSE_PAREN
)
1833 /* Destringize IN into a temporary buffer, by removing the first \ of
1834 \" and \\ sequences, and process the result as a #pragma directive. */
1836 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
,
1837 location_t expansion_loc
)
1839 const unsigned char *src
, *limit
;
1840 char *dest
, *result
;
1841 cpp_context
*saved_context
;
1842 cpp_token
*saved_cur_token
;
1843 tokenrun
*saved_cur_run
;
1846 const struct directive
*save_directive
;
1848 dest
= result
= (char *) alloca (in
->len
- 1);
1849 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1850 limit
= in
->text
+ in
->len
- 1;
1853 /* We know there is a character following the backslash. */
1854 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1860 /* Ugh; an awful kludge. We are really not set up to be lexing
1861 tokens when in the middle of a macro expansion. Use a new
1862 context to force cpp_get_token to lex, and so skip_rest_of_line
1863 doesn't go beyond the end of the text. Also, remember the
1864 current lexing position so we can return to it later.
1866 Something like line-at-a-time lexing should remove the need for
1868 saved_context
= pfile
->context
;
1869 saved_cur_token
= pfile
->cur_token
;
1870 saved_cur_run
= pfile
->cur_run
;
1872 pfile
->context
= XCNEW (cpp_context
);
1874 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1875 until we've read all of the tokens that we want. */
1876 cpp_push_buffer (pfile
, (const uchar
*) result
, dest
- result
,
1877 /* from_stage3 */ true);
1878 /* ??? Antique Disgusting Hack. What does this do? */
1879 if (pfile
->buffer
->prev
)
1880 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
1882 start_directive (pfile
);
1883 _cpp_clean_line (pfile
);
1884 save_directive
= pfile
->directive
;
1885 pfile
->directive
= &dtable
[T_PRAGMA
];
1887 end_directive (pfile
, 1);
1888 pfile
->directive
= save_directive
;
1890 /* We always insert at least one token, the directive result. It'll
1891 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1892 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1894 /* If we're not handling the pragma internally, read all of the tokens from
1895 the string buffer now, while the string buffer is still installed. */
1896 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1897 to me what the true lifespan of the tokens are. It would appear that
1898 the lifespan is the entire parse of the main input stream, in which case
1899 this may not be wrong. */
1900 if (pfile
->directive_result
.type
== CPP_PRAGMA
)
1906 toks
= XNEWVEC (cpp_token
, maxcount
);
1907 toks
[0] = pfile
->directive_result
;
1911 if (count
== maxcount
)
1913 maxcount
= maxcount
* 3 / 2;
1914 toks
= XRESIZEVEC (cpp_token
, toks
, maxcount
);
1916 toks
[count
] = *cpp_get_token (pfile
);
1917 /* _Pragma is a builtin, so we're not within a macro-map, and so
1918 the token locations are set to bogus ordinary locations
1919 near to, but after that of the "_Pragma".
1920 Paper over this by setting them equal to the location of the
1921 _Pragma itself (PR preprocessor/69126). */
1922 toks
[count
].src_loc
= expansion_loc
;
1923 /* Macros have been already expanded by cpp_get_token
1924 if the pragma allowed expansion. */
1925 toks
[count
++].flags
|= NO_EXPAND
;
1927 while (toks
[count
-1].type
!= CPP_PRAGMA_EOL
);
1932 toks
= XNEW (cpp_token
);
1933 toks
[0] = pfile
->directive_result
;
1935 /* If we handled the entire pragma internally, make sure we get the
1936 line number correct for the next token. */
1937 if (pfile
->cb
.line_change
)
1938 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1941 /* Finish inlining run_directive. */
1942 pfile
->buffer
->file
= NULL
;
1943 _cpp_pop_buffer (pfile
);
1945 /* Reset the old macro state before ... */
1946 XDELETE (pfile
->context
);
1947 pfile
->context
= saved_context
;
1948 pfile
->cur_token
= saved_cur_token
;
1949 pfile
->cur_run
= saved_cur_run
;
1951 /* ... inserting the new tokens we collected. */
1952 _cpp_push_token_context (pfile
, NULL
, toks
, count
);
1955 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1957 _cpp_do__Pragma (cpp_reader
*pfile
, location_t expansion_loc
)
1959 const cpp_token
*string
= get__Pragma_string (pfile
);
1960 pfile
->directive_result
.type
= CPP_PADDING
;
1964 destringize_and_run (pfile
, &string
->val
.str
, expansion_loc
);
1967 cpp_error (pfile
, CPP_DL_ERROR
,
1968 "_Pragma takes a parenthesized string literal");
1972 /* Handle #ifdef. */
1974 do_ifdef (cpp_reader
*pfile
)
1978 if (! pfile
->state
.skipping
)
1980 cpp_hashnode
*node
= lex_macro_node (pfile
, false);
1984 skip
= !_cpp_defined_macro_p (node
);
1985 if (!_cpp_maybe_notify_macro_use (pfile
, node
, pfile
->directive_line
))
1986 /* It wasn't a macro after all. */
1988 _cpp_mark_macro_used (node
);
1990 pfile
->cb
.used (pfile
, pfile
->directive_line
, node
);
1991 check_eol (pfile
, false);
1995 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1998 /* Handle #ifndef. */
2000 do_ifndef (cpp_reader
*pfile
)
2003 cpp_hashnode
*node
= 0;
2005 if (! pfile
->state
.skipping
)
2007 node
= lex_macro_node (pfile
, false);
2011 skip
= _cpp_defined_macro_p (node
);
2012 if (!_cpp_maybe_notify_macro_use (pfile
, node
, pfile
->directive_line
))
2013 /* It wasn't a macro after all. */
2015 _cpp_mark_macro_used (node
);
2017 pfile
->cb
.used (pfile
, pfile
->directive_line
, node
);
2018 check_eol (pfile
, false);
2022 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
2025 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
2026 pfile->mi_ind_cmacro so we can handle multiple-include
2027 optimizations. If macro expansion occurs in the expression, we
2028 cannot treat it as a controlling conditional, since the expansion
2029 could change in the future. That is handled by cpp_get_token. */
2031 do_if (cpp_reader
*pfile
)
2035 if (! pfile
->state
.skipping
)
2036 skip
= _cpp_parse_expr (pfile
, true) == false;
2038 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
2041 /* Flip skipping state if appropriate and continue without changing
2042 if_stack; this is so that the error message for missing #endif's
2043 etc. will point to the original #if. */
2045 do_else (cpp_reader
*pfile
)
2047 cpp_buffer
*buffer
= pfile
->buffer
;
2048 struct if_stack
*ifs
= buffer
->if_stack
;
2051 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
2054 if (ifs
->type
== T_ELSE
)
2056 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
2057 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2058 "the conditional began here");
2062 /* Skip any future (erroneous) #elses or #elifs. */
2063 pfile
->state
.skipping
= ifs
->skip_elses
;
2064 ifs
->skip_elses
= true;
2066 /* Invalidate any controlling macro. */
2069 /* Only check EOL if was not originally skipping. */
2070 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
2071 check_eol_endif_labels (pfile
);
2075 /* Handle a #elif directive by not changing if_stack either. See the
2076 comment above do_else. */
2078 do_elif (cpp_reader
*pfile
)
2080 cpp_buffer
*buffer
= pfile
->buffer
;
2081 struct if_stack
*ifs
= buffer
->if_stack
;
2084 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
2087 if (ifs
->type
== T_ELSE
)
2089 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
2090 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2091 "the conditional began here");
2095 /* See DR#412: "Only the first group whose control condition
2096 evaluates to true (nonzero) is processed; any following groups
2097 are skipped and their controlling directives are processed as
2098 if they were in a group that is skipped." */
2099 if (ifs
->skip_elses
)
2100 pfile
->state
.skipping
= 1;
2103 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
, false);
2104 ifs
->skip_elses
= ! pfile
->state
.skipping
;
2107 /* Invalidate any controlling macro. */
2112 /* #endif pops the if stack and resets pfile->state.skipping. */
2114 do_endif (cpp_reader
*pfile
)
2116 cpp_buffer
*buffer
= pfile
->buffer
;
2117 struct if_stack
*ifs
= buffer
->if_stack
;
2120 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
2123 /* Only check EOL if was not originally skipping. */
2124 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
2125 check_eol_endif_labels (pfile
);
2127 /* If potential control macro, we go back outside again. */
2128 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
2130 pfile
->mi_valid
= true;
2131 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
2134 buffer
->if_stack
= ifs
->next
;
2135 pfile
->state
.skipping
= ifs
->was_skipping
;
2136 obstack_free (&pfile
->buffer_ob
, ifs
);
2140 /* Push an if_stack entry for a preprocessor conditional, and set
2141 pfile->state.skipping to SKIP. If TYPE indicates the conditional
2142 is #if or #ifndef, CMACRO is a potentially controlling macro, and
2143 we need to check here that we are at the top of the file. */
2145 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
2146 const cpp_hashnode
*cmacro
)
2148 struct if_stack
*ifs
;
2149 cpp_buffer
*buffer
= pfile
->buffer
;
2151 ifs
= XOBNEW (&pfile
->buffer_ob
, struct if_stack
);
2152 ifs
->line
= pfile
->directive_line
;
2153 ifs
->next
= buffer
->if_stack
;
2154 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
2155 ifs
->was_skipping
= pfile
->state
.skipping
;
2157 /* This condition is effectively a test for top-of-file. */
2158 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
2159 ifs
->mi_cmacro
= cmacro
;
2163 pfile
->state
.skipping
= skip
;
2164 buffer
->if_stack
= ifs
;
2167 /* Read the tokens of the answer into the macro pool, in a directive
2168 of type TYPE. Only commit the memory if we intend it as permanent
2169 storage, i.e. the #assert case. Returns 0 on success, and sets
2170 ANSWERP to point to the answer. PRED_LOC is the location of the
2173 parse_answer (cpp_reader
*pfile
, int type
, location_t pred_loc
,
2174 cpp_macro
**answer_ptr
)
2176 /* In a conditional, it is legal to not have an open paren. We
2177 should save the following token in this case. */
2178 const cpp_token
*paren
= cpp_get_token (pfile
);
2180 /* If not a paren, see if we're OK. */
2181 if (paren
->type
!= CPP_OPEN_PAREN
)
2183 /* In a conditional no answer is a test for any answer. It
2184 could be followed by any token. */
2187 _cpp_backup_tokens (pfile
, 1);
2191 /* #unassert with no answer is valid - it removes all answers. */
2192 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
2195 cpp_error_with_line (pfile
, CPP_DL_ERROR
, pred_loc
, 0,
2196 "missing '(' after predicate");
2200 cpp_macro
*answer
= _cpp_new_macro (pfile
, cmk_assert
,
2201 _cpp_reserve_room (pfile
, 0,
2202 sizeof (cpp_macro
)));
2203 answer
->parm
.next
= NULL
;
2207 const cpp_token
*token
= cpp_get_token (pfile
);
2209 if (token
->type
== CPP_CLOSE_PAREN
)
2212 if (token
->type
== CPP_EOF
)
2214 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
2218 answer
= (cpp_macro
*)_cpp_reserve_room
2219 (pfile
, sizeof (cpp_macro
) + count
* sizeof (cpp_token
),
2220 sizeof (cpp_token
));
2221 answer
->exp
.tokens
[count
++] = *token
;
2226 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
2230 /* Drop whitespace at start, for answer equivalence purposes. */
2231 answer
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
2233 answer
->count
= count
;
2234 *answer_ptr
= answer
;
2239 /* Parses an assertion directive of type TYPE, returning a pointer to
2240 the hash node of the predicate, or 0 on error. The node is
2241 guaranteed to be disjoint from the macro namespace, so can only
2242 have type 'NT_VOID'. If an answer was supplied, it is placed in
2243 *ANSWER_PTR, which is otherwise set to 0. */
2244 static cpp_hashnode
*
2245 parse_assertion (cpp_reader
*pfile
, int type
, cpp_macro
**answer_ptr
)
2247 cpp_hashnode
*result
= 0;
2249 /* We don't expand predicates or answers. */
2250 pfile
->state
.prevent_expansion
++;
2254 const cpp_token
*predicate
= cpp_get_token (pfile
);
2255 if (predicate
->type
== CPP_EOF
)
2256 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
2257 else if (predicate
->type
!= CPP_NAME
)
2258 cpp_error_with_line (pfile
, CPP_DL_ERROR
, predicate
->src_loc
, 0,
2259 "predicate must be an identifier");
2260 else if (parse_answer (pfile
, type
, predicate
->src_loc
, answer_ptr
))
2262 unsigned int len
= NODE_LEN (predicate
->val
.node
.node
);
2263 unsigned char *sym
= (unsigned char *) alloca (len
+ 1);
2265 /* Prefix '#' to get it out of macro namespace. */
2267 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
.node
), len
);
2268 result
= cpp_lookup (pfile
, sym
, len
+ 1);
2271 pfile
->state
.prevent_expansion
--;
2276 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2277 or a pointer to NULL if the answer is not in the chain. */
2279 find_answer (cpp_hashnode
*node
, const cpp_macro
*candidate
)
2282 cpp_macro
**result
= NULL
;
2284 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->parm
.next
)
2286 cpp_macro
*answer
= *result
;
2288 if (answer
->count
== candidate
->count
)
2290 for (i
= 0; i
< answer
->count
; i
++)
2291 if (!_cpp_equiv_tokens (&answer
->exp
.tokens
[i
],
2292 &candidate
->exp
.tokens
[i
]))
2295 if (i
== answer
->count
)
2303 /* Test an assertion within a preprocessor conditional. Returns
2304 nonzero on failure, zero on success. On success, the result of
2305 the test is written into VALUE, otherwise the value 0. */
2307 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
2310 cpp_hashnode
*node
= parse_assertion (pfile
, T_IF
, &answer
);
2312 /* For recovery, an erroneous assertion expression is handled as a
2313 failing assertion. */
2318 if (node
->value
.answers
)
2319 *value
= !answer
|| *find_answer (node
, answer
);
2321 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
2322 _cpp_backup_tokens (pfile
, 1);
2324 /* We don't commit the memory for the answer - it's temporary only. */
2328 /* Handle #assert. */
2330 do_assert (cpp_reader
*pfile
)
2333 cpp_hashnode
*node
= parse_assertion (pfile
, T_ASSERT
, &answer
);
2337 /* Place the new answer in the answer list. First check there
2338 is not a duplicate. */
2339 if (*find_answer (node
, answer
))
2341 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
2342 NODE_NAME (node
) + 1);
2346 /* Commit or allocate storage for the answer. */
2347 answer
= (cpp_macro
*)_cpp_commit_buff
2348 (pfile
, sizeof (cpp_macro
) - sizeof (cpp_token
)
2349 + sizeof (cpp_token
) * answer
->count
);
2351 /* Chain into the list. */
2352 answer
->parm
.next
= node
->value
.answers
;
2353 node
->value
.answers
= answer
;
2355 check_eol (pfile
, false);
2359 /* Handle #unassert. */
2361 do_unassert (cpp_reader
*pfile
)
2364 cpp_hashnode
*node
= parse_assertion (pfile
, T_UNASSERT
, &answer
);
2366 /* It isn't an error to #unassert something that isn't asserted. */
2371 cpp_macro
**p
= find_answer (node
, answer
);
2373 /* Remove the assert from the list. */
2374 if (cpp_macro
*temp
= *p
)
2375 *p
= temp
->parm
.next
;
2377 check_eol (pfile
, false);
2380 _cpp_free_definition (node
);
2383 /* We don't commit the memory for the answer - it's temporary only. */
2386 /* These are for -D, -U, -A. */
2388 /* Process the string STR as if it appeared as the body of a #define.
2389 If STR is just an identifier, define it with value 1.
2390 If STR has anything after the identifier, then it should
2391 be identifier=definition. */
2393 cpp_define (cpp_reader
*pfile
, const char *str
)
2399 /* Copy the entire option so we can modify it.
2400 Change the first "=" in the string to a space. If there is none,
2401 tack " 1" on the end. */
2403 count
= strlen (str
);
2404 buf
= (char *) alloca (count
+ 3);
2405 memcpy (buf
, str
, count
);
2407 p
= strchr (str
, '=');
2417 run_directive (pfile
, T_DEFINE
, buf
, count
);
2420 /* Like cpp_define, but does not warn about unused macro. */
2422 cpp_define_unused (cpp_reader
*pfile
, const char *str
)
2424 unsigned char warn_unused_macros
= CPP_OPTION (pfile
, warn_unused_macros
);
2425 CPP_OPTION (pfile
, warn_unused_macros
) = 0;
2426 cpp_define (pfile
, str
);
2427 CPP_OPTION (pfile
, warn_unused_macros
) = warn_unused_macros
;
2430 /* Use to build macros to be run through cpp_define() as
2432 Example: cpp_define_formatted (pfile, "MACRO=%d", value); */
2435 cpp_define_formatted (cpp_reader
*pfile
, const char *fmt
, ...)
2441 ptr
= xvasprintf (fmt
, ap
);
2444 cpp_define (pfile
, ptr
);
2448 /* Like cpp_define_formatted, but does not warn about unused macro. */
2450 cpp_define_formatted_unused (cpp_reader
*pfile
, const char *fmt
, ...)
2456 ptr
= xvasprintf (fmt
, ap
);
2459 cpp_define_unused (pfile
, ptr
);
2463 /* Slight variant of the above for use by initialize_builtins. */
2465 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
2467 size_t len
= strlen (str
);
2468 char *buf
= (char *) alloca (len
+ 1);
2469 memcpy (buf
, str
, len
);
2471 run_directive (pfile
, T_DEFINE
, buf
, len
);
2474 /* Process MACRO as if it appeared as the body of an #undef. */
2476 cpp_undef (cpp_reader
*pfile
, const char *macro
)
2478 size_t len
= strlen (macro
);
2479 char *buf
= (char *) alloca (len
+ 1);
2480 memcpy (buf
, macro
, len
);
2482 run_directive (pfile
, T_UNDEF
, buf
, len
);
2485 /* Replace a previous definition DEF of the macro STR. If DEF is NULL,
2486 or first element is zero, then the macro should be undefined. */
2488 cpp_pop_definition (cpp_reader
*pfile
, struct def_pragma_macro
*c
)
2490 cpp_hashnode
*node
= _cpp_lex_identifier (pfile
, c
->name
);
2494 if (pfile
->cb
.before_define
)
2495 pfile
->cb
.before_define (pfile
);
2497 if (cpp_macro_p (node
))
2499 if (pfile
->cb
.undef
)
2500 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
2501 if (CPP_OPTION (pfile
, warn_unused_macros
))
2502 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
2503 _cpp_free_definition (node
);
2510 _cpp_restore_special_builtin (pfile
, c
);
2517 cpp_hashnode
*h
= NULL
;
2520 namelen
= ustrcspn (c
->definition
, "( \n");
2521 h
= cpp_lookup (pfile
, c
->definition
, namelen
);
2522 dn
= c
->definition
+ namelen
;
2524 nbuf
= cpp_push_buffer (pfile
, dn
, ustrchr (dn
, '\n') - dn
, true);
2527 _cpp_clean_line (pfile
);
2529 if (!_cpp_create_definition (pfile
, h
))
2531 _cpp_pop_buffer (pfile
);
2535 h
->value
.macro
->line
= c
->line
;
2536 h
->value
.macro
->syshdr
= c
->syshdr
;
2537 h
->value
.macro
->used
= c
->used
;
2541 /* Process the string STR as if it appeared as the body of a #assert. */
2543 cpp_assert (cpp_reader
*pfile
, const char *str
)
2545 handle_assertion (pfile
, str
, T_ASSERT
);
2548 /* Process STR as if it appeared as the body of an #unassert. */
2550 cpp_unassert (cpp_reader
*pfile
, const char *str
)
2552 handle_assertion (pfile
, str
, T_UNASSERT
);
2555 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2557 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
2559 size_t count
= strlen (str
);
2560 const char *p
= strchr (str
, '=');
2562 /* Copy the entire option so we can modify it. Change the first
2563 "=" in the string to a '(', and tack a ')' on the end. */
2564 char *buf
= (char *) alloca (count
+ 2);
2566 memcpy (buf
, str
, count
);
2575 run_directive (pfile
, type
, str
, count
);
2578 /* The options structure. */
2580 cpp_get_options (cpp_reader
*pfile
)
2582 return &pfile
->opts
;
2585 /* The callbacks structure. */
2587 cpp_get_callbacks (cpp_reader
*pfile
)
2592 /* Copy the given callbacks structure to our own. */
2594 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
2599 /* The narrow character set identifier. */
2601 cpp_get_narrow_charset_name (cpp_reader
*pfile
)
2603 return pfile
->narrow_cset_desc
.to
;
2606 /* The wide character set identifier. */
2608 cpp_get_wide_charset_name (cpp_reader
*pfile
)
2610 return pfile
->wide_cset_desc
.to
;
2613 /* The dependencies structure. (Creates one if it hasn't already been.) */
2615 cpp_get_deps (cpp_reader
*pfile
)
2617 if (!pfile
->deps
&& CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
)
2618 pfile
->deps
= deps_init ();
2622 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2623 doesn't fail. It does not generate a file change call back; that
2624 is the responsibility of the caller. */
2626 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
2629 cpp_buffer
*new_buffer
= XOBNEW (&pfile
->buffer_ob
, cpp_buffer
);
2631 /* Clears, amongst other things, if_stack and mi_cmacro. */
2632 memset (new_buffer
, 0, sizeof (cpp_buffer
));
2634 new_buffer
->next_line
= new_buffer
->buf
= buffer
;
2635 new_buffer
->rlimit
= buffer
+ len
;
2636 new_buffer
->from_stage3
= from_stage3
;
2637 new_buffer
->prev
= pfile
->buffer
;
2638 new_buffer
->need_line
= true;
2640 pfile
->buffer
= new_buffer
;
2645 /* Pops a single buffer, with a file change call-back if appropriate.
2646 Then pushes the next -include file, if any remain. */
2648 _cpp_pop_buffer (cpp_reader
*pfile
)
2650 cpp_buffer
*buffer
= pfile
->buffer
;
2651 struct _cpp_file
*inc
= buffer
->file
;
2652 struct if_stack
*ifs
;
2653 const unsigned char *to_free
;
2655 /* Walk back up the conditional stack till we reach its level at
2656 entry to this file, issuing error messages. */
2657 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
2658 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2659 "unterminated #%s", dtable
[ifs
->type
].name
);
2661 /* In case of a missing #endif. */
2662 pfile
->state
.skipping
= 0;
2664 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2665 pfile
->buffer
= buffer
->prev
;
2667 to_free
= buffer
->to_free
;
2668 free (buffer
->notes
);
2670 /* Free the buffer object now; we may want to push a new buffer
2671 in _cpp_push_next_include_file. */
2672 obstack_free (&pfile
->buffer_ob
, buffer
);
2676 _cpp_pop_file_buffer (pfile
, inc
, to_free
);
2678 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
2681 free ((void *)to_free
);
2684 /* Enter all recognized directives in the hash table. */
2686 _cpp_init_directives (cpp_reader
*pfile
)
2688 for (int i
= 0; i
< N_DIRECTIVES
; i
++)
2690 cpp_hashnode
*node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
2691 node
->is_directive
= 1;
2692 node
->directive_index
= i
;
2696 /* Extract header file from a bracket include. Parsing starts after '<'.
2697 The string is malloced and must be freed by the caller. */
2699 _cpp_bracket_include(cpp_reader
*pfile
)
2701 return glue_header_name (pfile
);