* testsuite/27_io/basic_ios/conv/bool_neg.cc: New.
[official-gcc.git] / libcpp / directives.c
blob173e609d1e07ccac92cf32466f06d6a71d7f64d5
1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986-2014 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
10 later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "cpplib.h"
24 #include "internal.h"
25 #include "mkdeps.h"
26 #include "obstack.h"
28 /* Stack of conditionals currently in progress
29 (including both successful and failing conditionals). */
30 struct if_stack
32 struct if_stack *next;
33 source_location 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 *);
42 struct pragma_entry
44 struct pragma_entry *next;
45 const cpp_hashnode *pragma; /* Name and length. */
46 bool is_nspace;
47 bool is_internal;
48 bool is_deferred;
49 bool allow_expansion;
50 union {
51 pragma_cb handler;
52 struct pragma_entry *space;
53 unsigned int ident;
54 } u;
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. */
60 #define KANDR 0
61 #define STDC89 1
62 #define EXTENSION 2
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. */
71 #define COND (1 << 0)
72 #define IF_COND (1 << 1)
73 #define INCL (1 << 2)
74 #define IN_I (1 << 3)
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;
81 struct 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 ***,
101 source_location *);
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 *, int, int, int);
106 static cpp_hashnode *lex_macro_node (cpp_reader *, bool);
107 static int undefine_macros (cpp_reader *, cpp_hashnode *, void *);
108 static void do_include_common (cpp_reader *, enum include_type);
109 static struct pragma_entry *lookup_pragma_entry (struct pragma_entry *,
110 const cpp_hashnode *);
111 static int count_registered_pragmas (struct pragma_entry *);
112 static char ** save_registered_pragmas (struct pragma_entry *, char **);
113 static char ** restore_registered_pragmas (cpp_reader *, struct pragma_entry *,
114 char **);
115 static void do_pragma_once (cpp_reader *);
116 static void do_pragma_poison (cpp_reader *);
117 static void do_pragma_system_header (cpp_reader *);
118 static void do_pragma_dependency (cpp_reader *);
119 static void do_pragma_warning_or_error (cpp_reader *, bool error);
120 static void do_pragma_warning (cpp_reader *);
121 static void do_pragma_error (cpp_reader *);
122 static void do_linemarker (cpp_reader *);
123 static const cpp_token *get_token_no_padding (cpp_reader *);
124 static const cpp_token *get__Pragma_string (cpp_reader *);
125 static void destringize_and_run (cpp_reader *, const cpp_string *);
126 static int parse_answer (cpp_reader *, struct answer **, int, source_location);
127 static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int);
128 static struct answer ** find_answer (cpp_hashnode *, const struct answer *);
129 static void handle_assertion (cpp_reader *, const char *, int);
130 static void do_pragma_push_macro (cpp_reader *);
131 static void do_pragma_pop_macro (cpp_reader *);
132 static void cpp_pop_definition (cpp_reader *, struct def_pragma_macro *);
134 /* This is the table of directive handlers. It is ordered by
135 frequency of occurrence; the numbers at the end are directive
136 counts from all the source code I have lying around (egcs and libc
137 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
138 pcmcia-cs-3.0.9). This is no longer important as directive lookup
139 is now O(1). All extensions other than #warning, #include_next,
140 and #import are deprecated. The name is where the extension
141 appears to have come from. */
143 #define DIRECTIVE_TABLE \
144 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
145 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
146 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
147 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
148 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
149 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
150 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
151 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
152 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
153 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
154 D(error, T_ERROR, STDC89, 0) /* 475 */ \
155 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
156 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
157 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
158 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
159 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
160 D(assert, T_ASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
161 D(unassert, T_UNASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
162 D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */
164 /* #sccs is synonymous with #ident. */
165 #define do_sccs do_ident
167 /* Use the table to generate a series of prototypes, an enum for the
168 directive names, and an array of directive handlers. */
170 #define D(name, t, o, f) static void do_##name (cpp_reader *);
171 DIRECTIVE_TABLE
172 #undef D
174 #define D(n, tag, o, f) tag,
175 enum
177 DIRECTIVE_TABLE
178 N_DIRECTIVES
180 #undef D
182 #define D(name, t, origin, flags) \
183 { do_##name, (const uchar *) #name, \
184 sizeof #name - 1, origin, flags },
185 static const directive dtable[] =
187 DIRECTIVE_TABLE
189 #undef D
190 #undef DIRECTIVE_TABLE
192 /* Wrapper struct directive for linemarkers.
193 The origin is more or less true - the original K+R cpp
194 did use this notation in its preprocessed output. */
195 static const directive linemarker_dir =
197 do_linemarker, UC"#", 1, KANDR, IN_I
200 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
202 /* Skip any remaining tokens in a directive. */
203 static void
204 skip_rest_of_line (cpp_reader *pfile)
206 /* Discard all stacked contexts. */
207 while (pfile->context->prev)
208 _cpp_pop_context (pfile);
210 /* Sweep up all tokens remaining on the line. */
211 if (! SEEN_EOL ())
212 while (_cpp_lex_token (pfile)->type != CPP_EOF)
216 /* Helper function for check_oel. */
218 static void
219 check_eol_1 (cpp_reader *pfile, bool expand, int reason)
221 if (! SEEN_EOL () && (expand
222 ? cpp_get_token (pfile)
223 : _cpp_lex_token (pfile))->type != CPP_EOF)
224 cpp_pedwarning (pfile, reason, "extra tokens at end of #%s directive",
225 pfile->directive->name);
228 /* Variant of check_eol used for Wendif-labels warnings. */
230 static void
231 check_eol_endif_labels (cpp_reader *pfile)
233 check_eol_1 (pfile, false, CPP_W_ENDIF_LABELS);
236 /* Ensure there are no stray tokens at the end of a directive. If
237 EXPAND is true, tokens macro-expanding to nothing are allowed. */
239 static void
240 check_eol (cpp_reader *pfile, bool expand)
242 check_eol_1 (pfile, expand, CPP_W_NONE);
245 /* Ensure there are no stray tokens other than comments at the end of
246 a directive, and gather the comments. */
247 static const cpp_token **
248 check_eol_return_comments (cpp_reader *pfile)
250 size_t c;
251 size_t capacity = 8;
252 const cpp_token **buf;
254 buf = XNEWVEC (const cpp_token *, capacity);
255 c = 0;
256 if (! SEEN_EOL ())
258 while (1)
260 const cpp_token *tok;
262 tok = _cpp_lex_token (pfile);
263 if (tok->type == CPP_EOF)
264 break;
265 if (tok->type != CPP_COMMENT)
266 cpp_error (pfile, CPP_DL_PEDWARN,
267 "extra tokens at end of #%s directive",
268 pfile->directive->name);
269 else
271 if (c + 1 >= capacity)
273 capacity *= 2;
274 buf = XRESIZEVEC (const cpp_token *, buf, capacity);
276 buf[c] = tok;
277 ++c;
281 buf[c] = NULL;
282 return buf;
285 /* Called when entering a directive, _Pragma or command-line directive. */
286 static void
287 start_directive (cpp_reader *pfile)
289 /* Setup in-directive state. */
290 pfile->state.in_directive = 1;
291 pfile->state.save_comments = 0;
292 pfile->directive_result.type = CPP_PADDING;
294 /* Some handlers need the position of the # for diagnostics. */
295 pfile->directive_line = pfile->line_table->highest_line;
298 /* Called when leaving a directive, _Pragma or command-line directive. */
299 static void
300 end_directive (cpp_reader *pfile, int skip_line)
302 if (CPP_OPTION (pfile, traditional))
304 /* Revert change of prepare_directive_trad. */
305 if (!pfile->state.in_deferred_pragma)
306 pfile->state.prevent_expansion--;
308 if (pfile->directive != &dtable[T_DEFINE])
309 _cpp_remove_overlay (pfile);
311 else if (pfile->state.in_deferred_pragma)
313 /* We don't skip for an assembler #. */
314 else if (skip_line)
316 skip_rest_of_line (pfile);
317 if (!pfile->keep_tokens)
319 pfile->cur_run = &pfile->base_run;
320 pfile->cur_token = pfile->base_run.base;
324 /* Restore state. */
325 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
326 pfile->state.in_directive = 0;
327 pfile->state.in_expression = 0;
328 pfile->state.angled_headers = 0;
329 pfile->directive = 0;
332 /* Prepare to handle the directive in pfile->directive. */
333 static void
334 prepare_directive_trad (cpp_reader *pfile)
336 if (pfile->directive != &dtable[T_DEFINE])
338 bool no_expand = (pfile->directive
339 && ! (pfile->directive->flags & EXPAND));
340 bool was_skipping = pfile->state.skipping;
342 pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
343 || pfile->directive == &dtable[T_ELIF]);
344 if (pfile->state.in_expression)
345 pfile->state.skipping = false;
347 if (no_expand)
348 pfile->state.prevent_expansion++;
349 _cpp_scan_out_logical_line (pfile, NULL);
350 if (no_expand)
351 pfile->state.prevent_expansion--;
353 pfile->state.skipping = was_skipping;
354 _cpp_overlay_buffer (pfile, pfile->out.base,
355 pfile->out.cur - pfile->out.base);
358 /* Stop ISO C from expanding anything. */
359 pfile->state.prevent_expansion++;
362 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
363 the '#' was indented. */
364 static void
365 directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)
367 /* Issue -pedantic or deprecated warnings for extensions. We let
368 -pedantic take precedence if both are applicable. */
369 if (! pfile->state.skipping)
371 if (dir->origin == EXTENSION
372 && !(dir == &dtable[T_IMPORT] && CPP_OPTION (pfile, objc))
373 && CPP_PEDANTIC (pfile))
374 cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);
375 else if (((dir->flags & DEPRECATED) != 0
376 || (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc)))
377 && CPP_OPTION (pfile, cpp_warn_deprecated))
378 cpp_warning (pfile, CPP_W_DEPRECATED,
379 "#%s is a deprecated GCC extension", dir->name);
382 /* Traditionally, a directive is ignored unless its # is in
383 column 1. Therefore in code intended to work with K+R
384 compilers, directives added by C89 must have their #
385 indented, and directives present in traditional C must not.
386 This is true even of directives in skipped conditional
387 blocks. #elif cannot be used at all. */
388 if (CPP_WTRADITIONAL (pfile))
390 if (dir == &dtable[T_ELIF])
391 cpp_warning (pfile, CPP_W_TRADITIONAL,
392 "suggest not using #elif in traditional C");
393 else if (indented && dir->origin == KANDR)
394 cpp_warning (pfile, CPP_W_TRADITIONAL,
395 "traditional C ignores #%s with the # indented",
396 dir->name);
397 else if (!indented && dir->origin != KANDR)
398 cpp_warning (pfile, CPP_W_TRADITIONAL,
399 "suggest hiding #%s from traditional C with an indented #",
400 dir->name);
404 /* Check if we have a known directive. INDENTED is nonzero if the
405 '#' of the directive was indented. This function is in this file
406 to save unnecessarily exporting dtable etc. to lex.c. Returns
407 nonzero if the line of tokens has been handled, zero if we should
408 continue processing the line. */
410 _cpp_handle_directive (cpp_reader *pfile, int indented)
412 const directive *dir = 0;
413 const cpp_token *dname;
414 bool was_parsing_args = pfile->state.parsing_args;
415 bool was_discarding_output = pfile->state.discarding_output;
416 int skip = 1;
418 if (was_discarding_output)
419 pfile->state.prevent_expansion = 0;
421 if (was_parsing_args)
423 if (CPP_OPTION (pfile, cpp_pedantic))
424 cpp_error (pfile, CPP_DL_PEDWARN,
425 "embedding a directive within macro arguments is not portable");
426 pfile->state.parsing_args = 0;
427 pfile->state.prevent_expansion = 0;
429 start_directive (pfile);
430 dname = _cpp_lex_token (pfile);
432 if (dname->type == CPP_NAME)
434 if (dname->val.node.node->is_directive)
435 dir = &dtable[dname->val.node.node->directive_index];
437 /* We do not recognize the # followed by a number extension in
438 assembler code. */
439 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
441 dir = &linemarker_dir;
442 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
443 && ! pfile->state.skipping)
444 cpp_error (pfile, CPP_DL_PEDWARN,
445 "style of line directive is a GCC extension");
448 if (dir)
450 /* If we have a directive that is not an opening conditional,
451 invalidate any control macro. */
452 if (! (dir->flags & IF_COND))
453 pfile->mi_valid = false;
455 /* Kluge alert. In order to be sure that code like this
457 #define HASH #
458 HASH define foo bar
460 does not cause '#define foo bar' to get executed when
461 compiled with -save-temps, we recognize directives in
462 -fpreprocessed mode only if the # is in column 1. macro.c
463 puts a space in front of any '#' at the start of a macro.
465 We exclude the -fdirectives-only case because macro expansion
466 has not been performed yet, and block comments can cause spaces
467 to precede the directive. */
468 if (CPP_OPTION (pfile, preprocessed)
469 && !CPP_OPTION (pfile, directives_only)
470 && (indented || !(dir->flags & IN_I)))
472 skip = 0;
473 dir = 0;
475 else
477 /* In failed conditional groups, all non-conditional
478 directives are ignored. Before doing that, whether
479 skipping or not, we should lex angle-bracketed headers
480 correctly, and maybe output some diagnostics. */
481 pfile->state.angled_headers = dir->flags & INCL;
482 pfile->state.directive_wants_padding = dir->flags & INCL;
483 if (! CPP_OPTION (pfile, preprocessed))
484 directive_diagnostics (pfile, dir, indented);
485 if (pfile->state.skipping && !(dir->flags & COND))
486 dir = 0;
489 else if (dname->type == CPP_EOF)
490 ; /* CPP_EOF is the "null directive". */
491 else
493 /* An unknown directive. Don't complain about it in assembly
494 source: we don't know where the comments are, and # may
495 introduce assembler pseudo-ops. Don't complain about invalid
496 directives in skipped conditional groups (6.10 p4). */
497 if (CPP_OPTION (pfile, lang) == CLK_ASM)
498 skip = 0;
499 else if (!pfile->state.skipping)
500 cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",
501 cpp_token_as_text (pfile, dname));
504 pfile->directive = dir;
505 if (CPP_OPTION (pfile, traditional))
506 prepare_directive_trad (pfile);
508 if (dir)
509 pfile->directive->handler (pfile);
510 else if (skip == 0)
511 _cpp_backup_tokens (pfile, 1);
513 end_directive (pfile, skip);
514 if (was_parsing_args && !pfile->state.in_deferred_pragma)
516 /* Restore state when within macro args. */
517 pfile->state.parsing_args = 2;
518 pfile->state.prevent_expansion = 1;
520 if (was_discarding_output)
521 pfile->state.prevent_expansion = 1;
522 return skip;
525 /* Directive handler wrapper used by the command line option
526 processor. BUF is \n terminated. */
527 static void
528 run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)
530 cpp_push_buffer (pfile, (const uchar *) buf, count,
531 /* from_stage3 */ true);
532 start_directive (pfile);
534 /* This is a short-term fix to prevent a leading '#' being
535 interpreted as a directive. */
536 _cpp_clean_line (pfile);
538 pfile->directive = &dtable[dir_no];
539 if (CPP_OPTION (pfile, traditional))
540 prepare_directive_trad (pfile);
541 pfile->directive->handler (pfile);
542 end_directive (pfile, 1);
543 _cpp_pop_buffer (pfile);
546 /* Checks for validity the macro name in #define, #undef, #ifdef and
547 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
548 processing a #define or #undefine directive, and false
549 otherwise. */
550 static cpp_hashnode *
551 lex_macro_node (cpp_reader *pfile, bool is_def_or_undef)
553 const cpp_token *token = _cpp_lex_token (pfile);
555 /* The token immediately after #define must be an identifier. That
556 identifier may not be "defined", per C99 6.10.8p4.
557 In C++, it may not be any of the "named operators" either,
558 per C++98 [lex.digraph], [lex.key].
559 Finally, the identifier may not have been poisoned. (In that case
560 the lexer has issued the error message for us.) */
562 if (token->type == CPP_NAME)
564 cpp_hashnode *node = token->val.node.node;
566 if (is_def_or_undef && node == pfile->spec_nodes.n_defined)
567 cpp_error (pfile, CPP_DL_ERROR,
568 "\"defined\" cannot be used as a macro name");
569 else if (! (node->flags & NODE_POISONED))
570 return node;
572 else if (token->flags & NAMED_OP)
573 cpp_error (pfile, CPP_DL_ERROR,
574 "\"%s\" cannot be used as a macro name as it is an operator in C++",
575 NODE_NAME (token->val.node.node));
576 else if (token->type == CPP_EOF)
577 cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",
578 pfile->directive->name);
579 else
580 cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");
582 return NULL;
585 /* Process a #define directive. Most work is done in macro.c. */
586 static void
587 do_define (cpp_reader *pfile)
589 cpp_hashnode *node = lex_macro_node (pfile, true);
591 if (node)
593 /* If we have been requested to expand comments into macros,
594 then re-enable saving of comments. */
595 pfile->state.save_comments =
596 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
598 if (pfile->cb.before_define)
599 pfile->cb.before_define (pfile);
601 if (_cpp_create_definition (pfile, node))
602 if (pfile->cb.define)
603 pfile->cb.define (pfile, pfile->directive_line, node);
605 node->flags &= ~NODE_USED;
609 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
610 static void
611 do_undef (cpp_reader *pfile)
613 cpp_hashnode *node = lex_macro_node (pfile, true);
615 if (node)
617 if (pfile->cb.before_define)
618 pfile->cb.before_define (pfile);
620 if (pfile->cb.undef)
621 pfile->cb.undef (pfile, pfile->directive_line, node);
623 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
624 identifier is not currently defined as a macro name. */
625 if (node->type == NT_MACRO)
627 if (node->flags & NODE_WARN)
628 cpp_error (pfile, CPP_DL_WARNING,
629 "undefining \"%s\"", NODE_NAME (node));
630 else if ((node->flags & NODE_BUILTIN)
631 && CPP_OPTION (pfile, warn_builtin_macro_redefined))
632 cpp_warning_with_line (pfile, CPP_W_BUILTIN_MACRO_REDEFINED,
633 pfile->directive_line, 0,
634 "undefining \"%s\"", NODE_NAME (node));
636 if (CPP_OPTION (pfile, warn_unused_macros))
637 _cpp_warn_if_unused_macro (pfile, node, NULL);
639 _cpp_free_definition (node);
643 check_eol (pfile, false);
646 /* Undefine a single macro/assertion/whatever. */
648 static int
649 undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,
650 void *data_p ATTRIBUTE_UNUSED)
652 /* Body of _cpp_free_definition inlined here for speed.
653 Macros and assertions no longer have anything to free. */
654 h->type = NT_VOID;
655 h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
656 return 1;
659 /* Undefine all macros and assertions. */
661 void
662 cpp_undef_all (cpp_reader *pfile)
664 cpp_forall_identifiers (pfile, undefine_macros, NULL);
668 /* Helper routine used by parse_include. Reinterpret the current line
669 as an h-char-sequence (< ... >); we are looking at the first token
670 after the <. Returns a malloced filename. */
671 static char *
672 glue_header_name (cpp_reader *pfile)
674 const cpp_token *token;
675 char *buffer;
676 size_t len, total_len = 0, capacity = 1024;
678 /* To avoid lexed tokens overwriting our glued name, we can only
679 allocate from the string pool once we've lexed everything. */
680 buffer = XNEWVEC (char, capacity);
681 for (;;)
683 token = get_token_no_padding (pfile);
685 if (token->type == CPP_GREATER)
686 break;
687 if (token->type == CPP_EOF)
689 cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
690 break;
693 len = cpp_token_len (token) + 2; /* Leading space, terminating \0. */
694 if (total_len + len > capacity)
696 capacity = (capacity + len) * 2;
697 buffer = XRESIZEVEC (char, buffer, capacity);
700 if (token->flags & PREV_WHITE)
701 buffer[total_len++] = ' ';
703 total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len],
704 true)
705 - (uchar *) buffer);
708 buffer[total_len] = '\0';
709 return buffer;
712 /* Returns the file name of #include, #include_next, #import and
713 #pragma dependency. The string is malloced and the caller should
714 free it. Returns NULL on error. LOCATION is the source location
715 of the file name. */
717 static const char *
718 parse_include (cpp_reader *pfile, int *pangle_brackets,
719 const cpp_token ***buf, source_location *location)
721 char *fname;
722 const cpp_token *header;
724 /* Allow macro expansion. */
725 header = get_token_no_padding (pfile);
726 *location = header->src_loc;
727 if ((header->type == CPP_STRING && header->val.str.text[0] != 'R')
728 || header->type == CPP_HEADER_NAME)
730 fname = XNEWVEC (char, header->val.str.len - 1);
731 memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
732 fname[header->val.str.len - 2] = '\0';
733 *pangle_brackets = header->type == CPP_HEADER_NAME;
735 else if (header->type == CPP_LESS)
737 fname = glue_header_name (pfile);
738 *pangle_brackets = 1;
740 else
742 const unsigned char *dir;
744 if (pfile->directive == &dtable[T_PRAGMA])
745 dir = UC"pragma dependency";
746 else
747 dir = pfile->directive->name;
748 cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
749 dir);
751 return NULL;
754 if (pfile->directive == &dtable[T_PRAGMA])
756 /* This pragma allows extra tokens after the file name. */
758 else if (buf == NULL || CPP_OPTION (pfile, discard_comments))
759 check_eol (pfile, true);
760 else
762 /* If we are not discarding comments, then gather them while
763 doing the eol check. */
764 *buf = check_eol_return_comments (pfile);
767 return fname;
770 /* Handle #include, #include_next and #import. */
771 static void
772 do_include_common (cpp_reader *pfile, enum include_type type)
774 const char *fname;
775 int angle_brackets;
776 const cpp_token **buf = NULL;
777 source_location location;
779 /* Re-enable saving of comments if requested, so that the include
780 callback can dump comments which follow #include. */
781 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
783 fname = parse_include (pfile, &angle_brackets, &buf, &location);
784 if (!fname)
786 if (buf)
787 XDELETEVEC (buf);
788 return;
791 if (!*fname)
793 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
794 "empty filename in #%s",
795 pfile->directive->name);
796 XDELETEVEC (fname);
797 if (buf)
798 XDELETEVEC (buf);
799 return;
802 /* Prevent #include recursion. */
803 if (pfile->line_table->depth >= CPP_STACK_MAX)
804 cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
805 else
807 /* Get out of macro context, if we are. */
808 skip_rest_of_line (pfile);
810 if (pfile->cb.include)
811 pfile->cb.include (pfile, pfile->directive_line,
812 pfile->directive->name, fname, angle_brackets,
813 buf);
815 _cpp_stack_include (pfile, fname, angle_brackets, type);
818 XDELETEVEC (fname);
819 if (buf)
820 XDELETEVEC (buf);
823 static void
824 do_include (cpp_reader *pfile)
826 do_include_common (pfile, IT_INCLUDE);
829 static void
830 do_import (cpp_reader *pfile)
832 do_include_common (pfile, IT_IMPORT);
835 static void
836 do_include_next (cpp_reader *pfile)
838 enum include_type type = IT_INCLUDE_NEXT;
840 /* If this is the primary source file, warn and use the normal
841 search logic. */
842 if (cpp_in_primary_file (pfile))
844 cpp_error (pfile, CPP_DL_WARNING,
845 "#include_next in primary source file");
846 type = IT_INCLUDE;
848 do_include_common (pfile, type);
851 /* Subroutine of do_linemarker. Read possible flags after file name.
852 LAST is the last flag seen; 0 if this is the first flag. Return the
853 flag if it is valid, 0 at the end of the directive. Otherwise
854 complain. */
855 static unsigned int
856 read_flag (cpp_reader *pfile, unsigned int last)
858 const cpp_token *token = _cpp_lex_token (pfile);
860 if (token->type == CPP_NUMBER && token->val.str.len == 1)
862 unsigned int flag = token->val.str.text[0] - '0';
864 if (flag > last && flag <= 4
865 && (flag != 4 || last == 3)
866 && (flag != 2 || last == 0))
867 return flag;
870 if (token->type != CPP_EOF)
871 cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
872 cpp_token_as_text (pfile, token));
873 return 0;
876 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
877 of length LEN, to binary; store it in NUMP, and return false if the
878 number was well-formed, true if not. WRAPPED is set to true if the
879 number did not fit into 'unsigned long'. */
880 static bool
881 strtolinenum (const uchar *str, size_t len, linenum_type *nump, bool *wrapped)
883 linenum_type reg = 0;
884 linenum_type reg_prev = 0;
886 uchar c;
887 *wrapped = false;
888 while (len--)
890 c = *str++;
891 if (!ISDIGIT (c))
892 return true;
893 reg *= 10;
894 reg += c - '0';
895 if (reg < reg_prev)
896 *wrapped = true;
897 reg_prev = reg;
899 *nump = reg;
900 return false;
903 /* Interpret #line command.
904 Note that the filename string (if any) is a true string constant
905 (escapes are interpreted), unlike in #line. */
906 static void
907 do_line (cpp_reader *pfile)
909 const struct line_maps *line_table = pfile->line_table;
910 const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
912 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
913 sysp right now. */
915 unsigned char map_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
916 const cpp_token *token;
917 const char *new_file = ORDINARY_MAP_FILE_NAME (map);
918 linenum_type new_lineno;
920 /* C99 raised the minimum limit on #line numbers. */
921 linenum_type cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
922 bool wrapped;
924 /* #line commands expand macros. */
925 token = cpp_get_token (pfile);
926 if (token->type != CPP_NUMBER
927 || strtolinenum (token->val.str.text, token->val.str.len,
928 &new_lineno, &wrapped))
930 if (token->type == CPP_EOF)
931 cpp_error (pfile, CPP_DL_ERROR, "unexpected end of file after #line");
932 else
933 cpp_error (pfile, CPP_DL_ERROR,
934 "\"%s\" after #line is not a positive integer",
935 cpp_token_as_text (pfile, token));
936 return;
939 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap || wrapped))
940 cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
941 else if (wrapped)
942 cpp_error (pfile, CPP_DL_WARNING, "line number out of range");
944 token = cpp_get_token (pfile);
945 if (token->type == CPP_STRING)
947 cpp_string s = { 0, 0 };
948 if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
949 &s, CPP_STRING))
950 new_file = (const char *)s.text;
951 check_eol (pfile, true);
953 else if (token->type != CPP_EOF)
955 cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
956 cpp_token_as_text (pfile, token));
957 return;
960 skip_rest_of_line (pfile);
961 _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, new_file, new_lineno,
962 map_sysp);
965 /* Interpret the # 44 "file" [flags] notation, which has slightly
966 different syntax and semantics from #line: Flags are allowed,
967 and we never complain about the line number being too big. */
968 static void
969 do_linemarker (cpp_reader *pfile)
971 const struct line_maps *line_table = pfile->line_table;
972 const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
973 const cpp_token *token;
974 const char *new_file = ORDINARY_MAP_FILE_NAME (map);
975 linenum_type new_lineno;
976 unsigned int new_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
977 enum lc_reason reason = LC_RENAME_VERBATIM;
978 int flag;
979 bool wrapped;
981 /* Back up so we can get the number again. Putting this in
982 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
983 some circumstances, which can segfault. */
984 _cpp_backup_tokens (pfile, 1);
986 /* #line commands expand macros. */
987 token = cpp_get_token (pfile);
988 if (token->type != CPP_NUMBER
989 || strtolinenum (token->val.str.text, token->val.str.len,
990 &new_lineno, &wrapped))
992 /* Unlike #line, there does not seem to be a way to get an EOF
993 here. So, it should be safe to always spell the token. */
994 cpp_error (pfile, CPP_DL_ERROR,
995 "\"%s\" after # is not a positive integer",
996 cpp_token_as_text (pfile, token));
997 return;
1000 token = cpp_get_token (pfile);
1001 if (token->type == CPP_STRING)
1003 cpp_string s = { 0, 0 };
1004 if (cpp_interpret_string_notranslate (pfile, &token->val.str,
1005 1, &s, CPP_STRING))
1006 new_file = (const char *)s.text;
1008 new_sysp = 0;
1009 flag = read_flag (pfile, 0);
1010 if (flag == 1)
1012 reason = LC_ENTER;
1013 /* Fake an include for cpp_included (). */
1014 _cpp_fake_include (pfile, new_file);
1015 flag = read_flag (pfile, flag);
1017 else if (flag == 2)
1019 reason = LC_LEAVE;
1020 flag = read_flag (pfile, flag);
1022 if (flag == 3)
1024 new_sysp = 1;
1025 flag = read_flag (pfile, flag);
1026 if (flag == 4)
1027 new_sysp = 2;
1029 pfile->buffer->sysp = new_sysp;
1031 check_eol (pfile, false);
1033 else if (token->type != CPP_EOF)
1035 cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
1036 cpp_token_as_text (pfile, token));
1037 return;
1040 skip_rest_of_line (pfile);
1042 /* Compensate for the increment in linemap_add that occurs in
1043 _cpp_do_file_change. We're currently at the start of the line
1044 *following* the #line directive. A separate source_location for this
1045 location makes no sense (until we do the LC_LEAVE), and
1046 complicates LAST_SOURCE_LINE_LOCATION. */
1047 pfile->line_table->highest_location--;
1049 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
1052 /* Arrange the file_change callback. pfile->line has changed to
1053 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
1054 header, 2 for a system header that needs to be extern "C" protected,
1055 and zero otherwise. */
1056 void
1057 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
1058 const char *to_file, linenum_type file_line,
1059 unsigned int sysp)
1061 const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
1062 to_file, file_line);
1063 if (map != NULL)
1064 linemap_line_start (pfile->line_table,
1065 ORDINARY_MAP_STARTING_LINE_NUMBER (map),
1066 127);
1068 if (pfile->cb.file_change)
1069 pfile->cb.file_change (pfile, map);
1072 /* Report a warning or error detected by the program we are
1073 processing. Use the directive's tokens in the error message. */
1074 static void
1075 do_diagnostic (cpp_reader *pfile, int code, int reason, int print_dir)
1077 const unsigned char *dir_name;
1078 unsigned char *line;
1079 source_location src_loc = pfile->cur_token[-1].src_loc;
1081 if (print_dir)
1082 dir_name = pfile->directive->name;
1083 else
1084 dir_name = NULL;
1085 pfile->state.prevent_expansion++;
1086 line = cpp_output_line_to_string (pfile, dir_name);
1087 pfile->state.prevent_expansion--;
1089 if (code == CPP_DL_WARNING_SYSHDR && reason)
1090 cpp_warning_with_line_syshdr (pfile, reason, src_loc, 0, "%s", line);
1091 else if (code == CPP_DL_WARNING && reason)
1092 cpp_warning_with_line (pfile, reason, src_loc, 0, "%s", line);
1093 else
1094 cpp_error_with_line (pfile, code, src_loc, 0, "%s", line);
1095 free (line);
1098 static void
1099 do_error (cpp_reader *pfile)
1101 do_diagnostic (pfile, CPP_DL_ERROR, 0, 1);
1104 static void
1105 do_warning (cpp_reader *pfile)
1107 /* We want #warning diagnostics to be emitted in system headers too. */
1108 do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, CPP_W_WARNING_DIRECTIVE, 1);
1111 /* Report program identification. */
1112 static void
1113 do_ident (cpp_reader *pfile)
1115 const cpp_token *str = cpp_get_token (pfile);
1117 if (str->type != CPP_STRING)
1118 cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1119 pfile->directive->name);
1120 else if (pfile->cb.ident)
1121 pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1123 check_eol (pfile, false);
1126 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1127 matching entry, or NULL if none is found. The returned entry could
1128 be the start of a namespace chain, or a pragma. */
1129 static struct pragma_entry *
1130 lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
1132 while (chain && chain->pragma != pragma)
1133 chain = chain->next;
1135 return chain;
1138 /* Create and insert a blank pragma entry at the beginning of a
1139 singly-linked CHAIN. */
1140 static struct pragma_entry *
1141 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1143 struct pragma_entry *new_entry;
1145 new_entry = (struct pragma_entry *)
1146 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1148 memset (new_entry, 0, sizeof (struct pragma_entry));
1149 new_entry->next = *chain;
1151 *chain = new_entry;
1152 return new_entry;
1155 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1156 goes in the global namespace. */
1157 static struct pragma_entry *
1158 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1159 bool allow_name_expansion)
1161 struct pragma_entry **chain = &pfile->pragmas;
1162 struct pragma_entry *entry;
1163 const cpp_hashnode *node;
1165 if (space)
1167 node = cpp_lookup (pfile, UC space, strlen (space));
1168 entry = lookup_pragma_entry (*chain, node);
1169 if (!entry)
1171 entry = new_pragma_entry (pfile, chain);
1172 entry->pragma = node;
1173 entry->is_nspace = true;
1174 entry->allow_expansion = allow_name_expansion;
1176 else if (!entry->is_nspace)
1177 goto clash;
1178 else if (entry->allow_expansion != allow_name_expansion)
1180 cpp_error (pfile, CPP_DL_ICE,
1181 "registering pragmas in namespace \"%s\" with mismatched "
1182 "name expansion", space);
1183 return NULL;
1185 chain = &entry->u.space;
1187 else if (allow_name_expansion)
1189 cpp_error (pfile, CPP_DL_ICE,
1190 "registering pragma \"%s\" with name expansion "
1191 "and no namespace", name);
1192 return NULL;
1195 /* Check for duplicates. */
1196 node = cpp_lookup (pfile, UC name, strlen (name));
1197 entry = lookup_pragma_entry (*chain, node);
1198 if (entry == NULL)
1200 entry = new_pragma_entry (pfile, chain);
1201 entry->pragma = node;
1202 return entry;
1205 if (entry->is_nspace)
1206 clash:
1207 cpp_error (pfile, CPP_DL_ICE,
1208 "registering \"%s\" as both a pragma and a pragma namespace",
1209 NODE_NAME (node));
1210 else if (space)
1211 cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1212 space, name);
1213 else
1214 cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1216 return NULL;
1219 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1220 static void
1221 register_pragma_internal (cpp_reader *pfile, const char *space,
1222 const char *name, pragma_cb handler)
1224 struct pragma_entry *entry;
1226 entry = register_pragma_1 (pfile, space, name, false);
1227 entry->is_internal = true;
1228 entry->u.handler = handler;
1231 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1232 goes in the global namespace. HANDLER is the handler it will call,
1233 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1234 expansion while parsing pragma NAME. This function is exported
1235 from libcpp. */
1236 void
1237 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1238 pragma_cb handler, bool allow_expansion)
1240 struct pragma_entry *entry;
1242 if (!handler)
1244 cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1245 return;
1248 entry = register_pragma_1 (pfile, space, name, false);
1249 if (entry)
1251 entry->allow_expansion = allow_expansion;
1252 entry->u.handler = handler;
1256 /* Similarly, but create mark the pragma for deferred processing.
1257 When found, a CPP_PRAGMA token will be insertted into the stream
1258 with IDENT in the token->u.pragma slot. */
1259 void
1260 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1261 const char *name, unsigned int ident,
1262 bool allow_expansion, bool allow_name_expansion)
1264 struct pragma_entry *entry;
1266 entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1267 if (entry)
1269 entry->is_deferred = true;
1270 entry->allow_expansion = allow_expansion;
1271 entry->u.ident = ident;
1275 /* Register the pragmas the preprocessor itself handles. */
1276 void
1277 _cpp_init_internal_pragmas (cpp_reader *pfile)
1279 /* Pragmas in the global namespace. */
1280 register_pragma_internal (pfile, 0, "once", do_pragma_once);
1281 register_pragma_internal (pfile, 0, "push_macro", do_pragma_push_macro);
1282 register_pragma_internal (pfile, 0, "pop_macro", do_pragma_pop_macro);
1284 /* New GCC-specific pragmas should be put in the GCC namespace. */
1285 register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1286 register_pragma_internal (pfile, "GCC", "system_header",
1287 do_pragma_system_header);
1288 register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1289 register_pragma_internal (pfile, "GCC", "warning", do_pragma_warning);
1290 register_pragma_internal (pfile, "GCC", "error", do_pragma_error);
1293 /* Return the number of registered pragmas in PE. */
1295 static int
1296 count_registered_pragmas (struct pragma_entry *pe)
1298 int ct = 0;
1299 for (; pe != NULL; pe = pe->next)
1301 if (pe->is_nspace)
1302 ct += count_registered_pragmas (pe->u.space);
1303 ct++;
1305 return ct;
1308 /* Save into SD the names of the registered pragmas referenced by PE,
1309 and return a pointer to the next free space in SD. */
1311 static char **
1312 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1314 for (; pe != NULL; pe = pe->next)
1316 if (pe->is_nspace)
1317 sd = save_registered_pragmas (pe->u.space, sd);
1318 *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident),
1319 HT_LEN (&pe->pragma->ident),
1320 HT_LEN (&pe->pragma->ident) + 1);
1322 return sd;
1325 /* Return a newly-allocated array which saves the names of the
1326 registered pragmas. */
1328 char **
1329 _cpp_save_pragma_names (cpp_reader *pfile)
1331 int ct = count_registered_pragmas (pfile->pragmas);
1332 char **result = XNEWVEC (char *, ct);
1333 (void) save_registered_pragmas (pfile->pragmas, result);
1334 return result;
1337 /* Restore from SD the names of the registered pragmas referenced by PE,
1338 and return a pointer to the next unused name in SD. */
1340 static char **
1341 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1342 char **sd)
1344 for (; pe != NULL; pe = pe->next)
1346 if (pe->is_nspace)
1347 sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1348 pe->pragma = cpp_lookup (pfile, UC *sd, strlen (*sd));
1349 free (*sd);
1350 sd++;
1352 return sd;
1355 /* Restore the names of the registered pragmas from SAVED. */
1357 void
1358 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1360 (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1361 free (saved);
1364 /* Pragmata handling. We handle some, and pass the rest on to the
1365 front end. C99 defines three pragmas and says that no macro
1366 expansion is to be performed on them; whether or not macro
1367 expansion happens for other pragmas is implementation defined.
1368 This implementation allows for a mix of both, since GCC did not
1369 traditionally macro expand its (few) pragmas, whereas OpenMP
1370 specifies that macro expansion should happen. */
1371 static void
1372 do_pragma (cpp_reader *pfile)
1374 const struct pragma_entry *p = NULL;
1375 const cpp_token *token, *pragma_token;
1376 source_location pragma_token_virt_loc = 0;
1377 cpp_token ns_token;
1378 unsigned int count = 1;
1380 pfile->state.prevent_expansion++;
1382 pragma_token = token = cpp_get_token_with_location (pfile,
1383 &pragma_token_virt_loc);
1384 ns_token = *token;
1385 if (token->type == CPP_NAME)
1387 p = lookup_pragma_entry (pfile->pragmas, token->val.node.node);
1388 if (p && p->is_nspace)
1390 bool allow_name_expansion = p->allow_expansion;
1391 if (allow_name_expansion)
1392 pfile->state.prevent_expansion--;
1394 token = cpp_get_token (pfile);
1395 if (token->type == CPP_NAME)
1396 p = lookup_pragma_entry (p->u.space, token->val.node.node);
1397 else
1398 p = NULL;
1399 if (allow_name_expansion)
1400 pfile->state.prevent_expansion++;
1401 count = 2;
1405 if (p)
1407 if (p->is_deferred)
1409 pfile->directive_result.src_loc = pragma_token_virt_loc;
1410 pfile->directive_result.type = CPP_PRAGMA;
1411 pfile->directive_result.flags = pragma_token->flags;
1412 pfile->directive_result.val.pragma = p->u.ident;
1413 pfile->state.in_deferred_pragma = true;
1414 pfile->state.pragma_allow_expansion = p->allow_expansion;
1415 if (!p->allow_expansion)
1416 pfile->state.prevent_expansion++;
1418 else
1420 /* Since the handler below doesn't get the line number, that
1421 it might need for diagnostics, make sure it has the right
1422 numbers in place. */
1423 if (pfile->cb.line_change)
1424 (*pfile->cb.line_change) (pfile, pragma_token, false);
1425 if (p->allow_expansion)
1426 pfile->state.prevent_expansion--;
1427 (*p->u.handler) (pfile);
1428 if (p->allow_expansion)
1429 pfile->state.prevent_expansion++;
1432 else if (pfile->cb.def_pragma)
1434 if (count == 1 || pfile->context->prev == NULL)
1435 _cpp_backup_tokens (pfile, count);
1436 else
1438 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1439 won't allow backing 2 tokens. */
1440 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1441 reads both tokens, we could perhaps free it, but if it doesn't,
1442 we don't know the exact lifespan. */
1443 cpp_token *toks = XNEWVEC (cpp_token, 2);
1444 toks[0] = ns_token;
1445 toks[0].flags |= NO_EXPAND;
1446 toks[1] = *token;
1447 toks[1].flags |= NO_EXPAND;
1448 _cpp_push_token_context (pfile, NULL, toks, 2);
1450 pfile->cb.def_pragma (pfile, pfile->directive_line);
1453 pfile->state.prevent_expansion--;
1456 /* Handle #pragma once. */
1457 static void
1458 do_pragma_once (cpp_reader *pfile)
1460 if (cpp_in_primary_file (pfile))
1461 cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1463 check_eol (pfile, false);
1464 _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1467 /* Handle #pragma push_macro(STRING). */
1468 static void
1469 do_pragma_push_macro (cpp_reader *pfile)
1471 cpp_hashnode *node;
1472 size_t defnlen;
1473 const uchar *defn = NULL;
1474 char *macroname, *dest;
1475 const char *limit, *src;
1476 const cpp_token *txt;
1477 struct def_pragma_macro *c;
1479 txt = get__Pragma_string (pfile);
1480 if (!txt)
1482 source_location src_loc = pfile->cur_token[-1].src_loc;
1483 cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1484 "invalid #pragma push_macro directive");
1485 check_eol (pfile, false);
1486 skip_rest_of_line (pfile);
1487 return;
1489 dest = macroname = (char *) alloca (txt->val.str.len + 2);
1490 src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1491 limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1492 while (src < limit)
1494 /* We know there is a character following the backslash. */
1495 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1496 src++;
1497 *dest++ = *src++;
1499 *dest = 0;
1500 check_eol (pfile, false);
1501 skip_rest_of_line (pfile);
1502 c = XNEW (struct def_pragma_macro);
1503 memset (c, 0, sizeof (struct def_pragma_macro));
1504 c->name = XNEWVAR (char, strlen (macroname) + 1);
1505 strcpy (c->name, macroname);
1506 c->next = pfile->pushed_macros;
1507 node = _cpp_lex_identifier (pfile, c->name);
1508 if (node->type == NT_VOID)
1509 c->is_undef = 1;
1510 else
1512 defn = cpp_macro_definition (pfile, node);
1513 defnlen = ustrlen (defn);
1514 c->definition = XNEWVEC (uchar, defnlen + 2);
1515 c->definition[defnlen] = '\n';
1516 c->definition[defnlen + 1] = 0;
1517 c->line = node->value.macro->line;
1518 c->syshdr = node->value.macro->syshdr;
1519 c->used = node->value.macro->used;
1520 memcpy (c->definition, defn, defnlen);
1523 pfile->pushed_macros = c;
1526 /* Handle #pragma pop_macro(STRING). */
1527 static void
1528 do_pragma_pop_macro (cpp_reader *pfile)
1530 char *macroname, *dest;
1531 const char *limit, *src;
1532 const cpp_token *txt;
1533 struct def_pragma_macro *l = NULL, *c = pfile->pushed_macros;
1534 txt = get__Pragma_string (pfile);
1535 if (!txt)
1537 source_location src_loc = pfile->cur_token[-1].src_loc;
1538 cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1539 "invalid #pragma pop_macro directive");
1540 check_eol (pfile, false);
1541 skip_rest_of_line (pfile);
1542 return;
1544 dest = macroname = (char *) alloca (txt->val.str.len + 2);
1545 src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1546 limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1547 while (src < limit)
1549 /* We know there is a character following the backslash. */
1550 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1551 src++;
1552 *dest++ = *src++;
1554 *dest = 0;
1555 check_eol (pfile, false);
1556 skip_rest_of_line (pfile);
1558 while (c != NULL)
1560 if (!strcmp (c->name, macroname))
1562 if (!l)
1563 pfile->pushed_macros = c->next;
1564 else
1565 l->next = c->next;
1566 cpp_pop_definition (pfile, c);
1567 free (c->definition);
1568 free (c->name);
1569 free (c);
1570 break;
1572 l = c;
1573 c = c->next;
1577 /* Handle #pragma GCC poison, to poison one or more identifiers so
1578 that the lexer produces a hard error for each subsequent usage. */
1579 static void
1580 do_pragma_poison (cpp_reader *pfile)
1582 const cpp_token *tok;
1583 cpp_hashnode *hp;
1585 pfile->state.poisoned_ok = 1;
1586 for (;;)
1588 tok = _cpp_lex_token (pfile);
1589 if (tok->type == CPP_EOF)
1590 break;
1591 if (tok->type != CPP_NAME)
1593 cpp_error (pfile, CPP_DL_ERROR,
1594 "invalid #pragma GCC poison directive");
1595 break;
1598 hp = tok->val.node.node;
1599 if (hp->flags & NODE_POISONED)
1600 continue;
1602 if (hp->type == NT_MACRO)
1603 cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1604 NODE_NAME (hp));
1605 _cpp_free_definition (hp);
1606 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1608 pfile->state.poisoned_ok = 0;
1611 /* Mark the current header as a system header. This will suppress
1612 some categories of warnings (notably those from -pedantic). It is
1613 intended for use in system libraries that cannot be implemented in
1614 conforming C, but cannot be certain that their headers appear in a
1615 system include directory. To prevent abuse, it is rejected in the
1616 primary source file. */
1617 static void
1618 do_pragma_system_header (cpp_reader *pfile)
1620 if (cpp_in_primary_file (pfile))
1621 cpp_error (pfile, CPP_DL_WARNING,
1622 "#pragma system_header ignored outside include file");
1623 else
1625 check_eol (pfile, false);
1626 skip_rest_of_line (pfile);
1627 cpp_make_system_header (pfile, 1, 0);
1631 /* Check the modified date of the current include file against a specified
1632 file. Issue a diagnostic, if the specified file is newer. We use this to
1633 determine if a fixed header should be refixed. */
1634 static void
1635 do_pragma_dependency (cpp_reader *pfile)
1637 const char *fname;
1638 int angle_brackets, ordering;
1639 source_location location;
1641 fname = parse_include (pfile, &angle_brackets, NULL, &location);
1642 if (!fname)
1643 return;
1645 ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1646 if (ordering < 0)
1647 cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1648 else if (ordering > 0)
1650 cpp_error (pfile, CPP_DL_WARNING,
1651 "current file is older than %s", fname);
1652 if (cpp_get_token (pfile)->type != CPP_EOF)
1654 _cpp_backup_tokens (pfile, 1);
1655 do_diagnostic (pfile, CPP_DL_WARNING, 0, 0);
1659 free ((void *) fname);
1662 /* Issue a diagnostic with the message taken from the pragma. If
1663 ERROR is true, the diagnostic is a warning, otherwise, it is an
1664 error. */
1665 static void
1666 do_pragma_warning_or_error (cpp_reader *pfile, bool error)
1668 const cpp_token *tok = _cpp_lex_token (pfile);
1669 cpp_string str;
1670 if (tok->type != CPP_STRING
1671 || !cpp_interpret_string_notranslate (pfile, &tok->val.str, 1, &str,
1672 CPP_STRING)
1673 || str.len == 0)
1675 cpp_error (pfile, CPP_DL_ERROR, "invalid \"#pragma GCC %s\" directive",
1676 error ? "error" : "warning");
1677 return;
1679 cpp_error (pfile, error ? CPP_DL_ERROR : CPP_DL_WARNING,
1680 "%s", str.text);
1681 free ((void *)str.text);
1684 /* Issue a warning diagnostic. */
1685 static void
1686 do_pragma_warning (cpp_reader *pfile)
1688 do_pragma_warning_or_error (pfile, false);
1691 /* Issue an error diagnostic. */
1692 static void
1693 do_pragma_error (cpp_reader *pfile)
1695 do_pragma_warning_or_error (pfile, true);
1698 /* Get a token but skip padding. */
1699 static const cpp_token *
1700 get_token_no_padding (cpp_reader *pfile)
1702 for (;;)
1704 const cpp_token *result = cpp_get_token (pfile);
1705 if (result->type != CPP_PADDING)
1706 return result;
1710 /* Check syntax is "(string-literal)". Returns the string on success,
1711 or NULL on failure. */
1712 static const cpp_token *
1713 get__Pragma_string (cpp_reader *pfile)
1715 const cpp_token *string;
1716 const cpp_token *paren;
1718 paren = get_token_no_padding (pfile);
1719 if (paren->type == CPP_EOF)
1720 _cpp_backup_tokens (pfile, 1);
1721 if (paren->type != CPP_OPEN_PAREN)
1722 return NULL;
1724 string = get_token_no_padding (pfile);
1725 if (string->type == CPP_EOF)
1726 _cpp_backup_tokens (pfile, 1);
1727 if (string->type != CPP_STRING && string->type != CPP_WSTRING
1728 && string->type != CPP_STRING32 && string->type != CPP_STRING16
1729 && string->type != CPP_UTF8STRING)
1730 return NULL;
1732 paren = get_token_no_padding (pfile);
1733 if (paren->type == CPP_EOF)
1734 _cpp_backup_tokens (pfile, 1);
1735 if (paren->type != CPP_CLOSE_PAREN)
1736 return NULL;
1738 return string;
1741 /* Destringize IN into a temporary buffer, by removing the first \ of
1742 \" and \\ sequences, and process the result as a #pragma directive. */
1743 static void
1744 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1746 const unsigned char *src, *limit;
1747 char *dest, *result;
1748 cpp_context *saved_context;
1749 cpp_token *saved_cur_token;
1750 tokenrun *saved_cur_run;
1751 cpp_token *toks;
1752 int count;
1753 const struct directive *save_directive;
1755 dest = result = (char *) alloca (in->len - 1);
1756 src = in->text + 1 + (in->text[0] == 'L');
1757 limit = in->text + in->len - 1;
1758 while (src < limit)
1760 /* We know there is a character following the backslash. */
1761 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1762 src++;
1763 *dest++ = *src++;
1765 *dest = '\n';
1767 /* Ugh; an awful kludge. We are really not set up to be lexing
1768 tokens when in the middle of a macro expansion. Use a new
1769 context to force cpp_get_token to lex, and so skip_rest_of_line
1770 doesn't go beyond the end of the text. Also, remember the
1771 current lexing position so we can return to it later.
1773 Something like line-at-a-time lexing should remove the need for
1774 this. */
1775 saved_context = pfile->context;
1776 saved_cur_token = pfile->cur_token;
1777 saved_cur_run = pfile->cur_run;
1779 pfile->context = XCNEW (cpp_context);
1781 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1782 until we've read all of the tokens that we want. */
1783 cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1784 /* from_stage3 */ true);
1785 /* ??? Antique Disgusting Hack. What does this do? */
1786 if (pfile->buffer->prev)
1787 pfile->buffer->file = pfile->buffer->prev->file;
1789 start_directive (pfile);
1790 _cpp_clean_line (pfile);
1791 save_directive = pfile->directive;
1792 pfile->directive = &dtable[T_PRAGMA];
1793 do_pragma (pfile);
1794 end_directive (pfile, 1);
1795 pfile->directive = save_directive;
1797 /* We always insert at least one token, the directive result. It'll
1798 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1799 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1801 /* If we're not handling the pragma internally, read all of the tokens from
1802 the string buffer now, while the string buffer is still installed. */
1803 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1804 to me what the true lifespan of the tokens are. It would appear that
1805 the lifespan is the entire parse of the main input stream, in which case
1806 this may not be wrong. */
1807 if (pfile->directive_result.type == CPP_PRAGMA)
1809 int maxcount;
1811 count = 1;
1812 maxcount = 50;
1813 toks = XNEWVEC (cpp_token, maxcount);
1814 toks[0] = pfile->directive_result;
1818 if (count == maxcount)
1820 maxcount = maxcount * 3 / 2;
1821 toks = XRESIZEVEC (cpp_token, toks, maxcount);
1823 toks[count] = *cpp_get_token (pfile);
1824 /* Macros have been already expanded by cpp_get_token
1825 if the pragma allowed expansion. */
1826 toks[count++].flags |= NO_EXPAND;
1828 while (toks[count-1].type != CPP_PRAGMA_EOL);
1830 else
1832 count = 1;
1833 toks = XNEW (cpp_token);
1834 toks[0] = pfile->directive_result;
1836 /* If we handled the entire pragma internally, make sure we get the
1837 line number correct for the next token. */
1838 if (pfile->cb.line_change)
1839 pfile->cb.line_change (pfile, pfile->cur_token, false);
1842 /* Finish inlining run_directive. */
1843 pfile->buffer->file = NULL;
1844 _cpp_pop_buffer (pfile);
1846 /* Reset the old macro state before ... */
1847 XDELETE (pfile->context);
1848 pfile->context = saved_context;
1849 pfile->cur_token = saved_cur_token;
1850 pfile->cur_run = saved_cur_run;
1852 /* ... inserting the new tokens we collected. */
1853 _cpp_push_token_context (pfile, NULL, toks, count);
1856 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1858 _cpp_do__Pragma (cpp_reader *pfile)
1860 const cpp_token *string = get__Pragma_string (pfile);
1861 pfile->directive_result.type = CPP_PADDING;
1863 if (string)
1865 destringize_and_run (pfile, &string->val.str);
1866 return 1;
1868 cpp_error (pfile, CPP_DL_ERROR,
1869 "_Pragma takes a parenthesized string literal");
1870 return 0;
1873 /* Handle #ifdef. */
1874 static void
1875 do_ifdef (cpp_reader *pfile)
1877 int skip = 1;
1879 if (! pfile->state.skipping)
1881 cpp_hashnode *node = lex_macro_node (pfile, false);
1883 if (node)
1885 /* Do not treat conditional macros as being defined. This is due to
1886 the powerpc and spu ports using conditional macros for 'vector',
1887 'bool', and 'pixel' to act as conditional keywords. This messes
1888 up tests like #ifndef bool. */
1889 skip = (node->type != NT_MACRO
1890 || ((node->flags & NODE_CONDITIONAL) != 0));
1891 _cpp_mark_macro_used (node);
1892 if (!(node->flags & NODE_USED))
1894 node->flags |= NODE_USED;
1895 if (node->type == NT_MACRO)
1897 if ((node->flags & NODE_BUILTIN)
1898 && pfile->cb.user_builtin_macro)
1899 pfile->cb.user_builtin_macro (pfile, node);
1900 if (pfile->cb.used_define)
1901 pfile->cb.used_define (pfile, pfile->directive_line, node);
1903 else
1905 if (pfile->cb.used_undef)
1906 pfile->cb.used_undef (pfile, pfile->directive_line, node);
1909 if (pfile->cb.used)
1910 pfile->cb.used (pfile, pfile->directive_line, node);
1911 check_eol (pfile, false);
1915 push_conditional (pfile, skip, T_IFDEF, 0);
1918 /* Handle #ifndef. */
1919 static void
1920 do_ifndef (cpp_reader *pfile)
1922 int skip = 1;
1923 cpp_hashnode *node = 0;
1925 if (! pfile->state.skipping)
1927 node = lex_macro_node (pfile, false);
1929 if (node)
1931 /* Do not treat conditional macros as being defined. This is due to
1932 the powerpc and spu ports using conditional macros for 'vector',
1933 'bool', and 'pixel' to act as conditional keywords. This messes
1934 up tests like #ifndef bool. */
1935 skip = (node->type == NT_MACRO
1936 && ((node->flags & NODE_CONDITIONAL) == 0));
1937 _cpp_mark_macro_used (node);
1938 if (!(node->flags & NODE_USED))
1940 node->flags |= NODE_USED;
1941 if (node->type == NT_MACRO)
1943 if ((node->flags & NODE_BUILTIN)
1944 && pfile->cb.user_builtin_macro)
1945 pfile->cb.user_builtin_macro (pfile, node);
1946 if (pfile->cb.used_define)
1947 pfile->cb.used_define (pfile, pfile->directive_line, node);
1949 else
1951 if (pfile->cb.used_undef)
1952 pfile->cb.used_undef (pfile, pfile->directive_line, node);
1955 if (pfile->cb.used)
1956 pfile->cb.used (pfile, pfile->directive_line, node);
1957 check_eol (pfile, false);
1961 push_conditional (pfile, skip, T_IFNDEF, node);
1964 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1965 pfile->mi_ind_cmacro so we can handle multiple-include
1966 optimizations. If macro expansion occurs in the expression, we
1967 cannot treat it as a controlling conditional, since the expansion
1968 could change in the future. That is handled by cpp_get_token. */
1969 static void
1970 do_if (cpp_reader *pfile)
1972 int skip = 1;
1974 if (! pfile->state.skipping)
1975 skip = _cpp_parse_expr (pfile, true) == false;
1977 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1980 /* Flip skipping state if appropriate and continue without changing
1981 if_stack; this is so that the error message for missing #endif's
1982 etc. will point to the original #if. */
1983 static void
1984 do_else (cpp_reader *pfile)
1986 cpp_buffer *buffer = pfile->buffer;
1987 struct if_stack *ifs = buffer->if_stack;
1989 if (ifs == NULL)
1990 cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1991 else
1993 if (ifs->type == T_ELSE)
1995 cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1996 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1997 "the conditional began here");
1999 ifs->type = T_ELSE;
2001 /* Skip any future (erroneous) #elses or #elifs. */
2002 pfile->state.skipping = ifs->skip_elses;
2003 ifs->skip_elses = true;
2005 /* Invalidate any controlling macro. */
2006 ifs->mi_cmacro = 0;
2008 /* Only check EOL if was not originally skipping. */
2009 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2010 check_eol_endif_labels (pfile);
2014 /* Handle a #elif directive by not changing if_stack either. See the
2015 comment above do_else. */
2016 static void
2017 do_elif (cpp_reader *pfile)
2019 cpp_buffer *buffer = pfile->buffer;
2020 struct if_stack *ifs = buffer->if_stack;
2022 if (ifs == NULL)
2023 cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
2024 else
2026 if (ifs->type == T_ELSE)
2028 cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
2029 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2030 "the conditional began here");
2032 ifs->type = T_ELIF;
2034 if (! ifs->was_skipping)
2036 bool value;
2037 /* The standard mandates that the expression be parsed even
2038 if we are skipping elses at this point -- the lexical
2039 restrictions on #elif only apply to skipped groups, but
2040 this group is not being skipped. Temporarily set
2041 skipping to false to get lexer warnings. */
2042 pfile->state.skipping = 0;
2043 value = _cpp_parse_expr (pfile, false);
2044 if (ifs->skip_elses)
2045 pfile->state.skipping = 1;
2046 else
2048 pfile->state.skipping = ! value;
2049 ifs->skip_elses = value;
2053 /* Invalidate any controlling macro. */
2054 ifs->mi_cmacro = 0;
2058 /* #endif pops the if stack and resets pfile->state.skipping. */
2059 static void
2060 do_endif (cpp_reader *pfile)
2062 cpp_buffer *buffer = pfile->buffer;
2063 struct if_stack *ifs = buffer->if_stack;
2065 if (ifs == NULL)
2066 cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
2067 else
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);
2073 /* If potential control macro, we go back outside again. */
2074 if (ifs->next == 0 && ifs->mi_cmacro)
2076 pfile->mi_valid = true;
2077 pfile->mi_cmacro = ifs->mi_cmacro;
2080 buffer->if_stack = ifs->next;
2081 pfile->state.skipping = ifs->was_skipping;
2082 obstack_free (&pfile->buffer_ob, ifs);
2086 /* Push an if_stack entry for a preprocessor conditional, and set
2087 pfile->state.skipping to SKIP. If TYPE indicates the conditional
2088 is #if or #ifndef, CMACRO is a potentially controlling macro, and
2089 we need to check here that we are at the top of the file. */
2090 static void
2091 push_conditional (cpp_reader *pfile, int skip, int type,
2092 const cpp_hashnode *cmacro)
2094 struct if_stack *ifs;
2095 cpp_buffer *buffer = pfile->buffer;
2097 ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
2098 ifs->line = pfile->directive_line;
2099 ifs->next = buffer->if_stack;
2100 ifs->skip_elses = pfile->state.skipping || !skip;
2101 ifs->was_skipping = pfile->state.skipping;
2102 ifs->type = type;
2103 /* This condition is effectively a test for top-of-file. */
2104 if (pfile->mi_valid && pfile->mi_cmacro == 0)
2105 ifs->mi_cmacro = cmacro;
2106 else
2107 ifs->mi_cmacro = 0;
2109 pfile->state.skipping = skip;
2110 buffer->if_stack = ifs;
2113 /* Read the tokens of the answer into the macro pool, in a directive
2114 of type TYPE. Only commit the memory if we intend it as permanent
2115 storage, i.e. the #assert case. Returns 0 on success, and sets
2116 ANSWERP to point to the answer. PRED_LOC is the location of the
2117 predicate. */
2118 static int
2119 parse_answer (cpp_reader *pfile, struct answer **answerp, int type,
2120 source_location pred_loc)
2122 const cpp_token *paren;
2123 struct answer *answer;
2124 unsigned int acount;
2126 /* In a conditional, it is legal to not have an open paren. We
2127 should save the following token in this case. */
2128 paren = cpp_get_token (pfile);
2130 /* If not a paren, see if we're OK. */
2131 if (paren->type != CPP_OPEN_PAREN)
2133 /* In a conditional no answer is a test for any answer. It
2134 could be followed by any token. */
2135 if (type == T_IF)
2137 _cpp_backup_tokens (pfile, 1);
2138 return 0;
2141 /* #unassert with no answer is valid - it removes all answers. */
2142 if (type == T_UNASSERT && paren->type == CPP_EOF)
2143 return 0;
2145 cpp_error_with_line (pfile, CPP_DL_ERROR, pred_loc, 0,
2146 "missing '(' after predicate");
2147 return 1;
2150 for (acount = 0;; acount++)
2152 size_t room_needed;
2153 const cpp_token *token = cpp_get_token (pfile);
2154 cpp_token *dest;
2156 if (token->type == CPP_CLOSE_PAREN)
2157 break;
2159 if (token->type == CPP_EOF)
2161 cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
2162 return 1;
2165 /* struct answer includes the space for one token. */
2166 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
2168 if (BUFF_ROOM (pfile->a_buff) < room_needed)
2169 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
2171 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
2172 *dest = *token;
2174 /* Drop whitespace at start, for answer equivalence purposes. */
2175 if (acount == 0)
2176 dest->flags &= ~PREV_WHITE;
2179 if (acount == 0)
2181 cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
2182 return 1;
2185 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
2186 answer->count = acount;
2187 answer->next = NULL;
2188 *answerp = answer;
2190 return 0;
2193 /* Parses an assertion directive of type TYPE, returning a pointer to
2194 the hash node of the predicate, or 0 on error. If an answer was
2195 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
2196 static cpp_hashnode *
2197 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
2199 cpp_hashnode *result = 0;
2200 const cpp_token *predicate;
2202 /* We don't expand predicates or answers. */
2203 pfile->state.prevent_expansion++;
2205 *answerp = 0;
2206 predicate = cpp_get_token (pfile);
2207 if (predicate->type == CPP_EOF)
2208 cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
2209 else if (predicate->type != CPP_NAME)
2210 cpp_error_with_line (pfile, CPP_DL_ERROR, predicate->src_loc, 0,
2211 "predicate must be an identifier");
2212 else if (parse_answer (pfile, answerp, type, predicate->src_loc) == 0)
2214 unsigned int len = NODE_LEN (predicate->val.node.node);
2215 unsigned char *sym = (unsigned char *) alloca (len + 1);
2217 /* Prefix '#' to get it out of macro namespace. */
2218 sym[0] = '#';
2219 memcpy (sym + 1, NODE_NAME (predicate->val.node.node), len);
2220 result = cpp_lookup (pfile, sym, len + 1);
2223 pfile->state.prevent_expansion--;
2224 return result;
2227 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2228 or a pointer to NULL if the answer is not in the chain. */
2229 static struct answer **
2230 find_answer (cpp_hashnode *node, const struct answer *candidate)
2232 unsigned int i;
2233 struct answer **result;
2235 for (result = &node->value.answers; *result; result = &(*result)->next)
2237 struct answer *answer = *result;
2239 if (answer->count == candidate->count)
2241 for (i = 0; i < answer->count; i++)
2242 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
2243 break;
2245 if (i == answer->count)
2246 break;
2250 return result;
2253 /* Test an assertion within a preprocessor conditional. Returns
2254 nonzero on failure, zero on success. On success, the result of
2255 the test is written into VALUE, otherwise the value 0. */
2257 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
2259 struct answer *answer;
2260 cpp_hashnode *node;
2262 node = parse_assertion (pfile, &answer, T_IF);
2264 /* For recovery, an erroneous assertion expression is handled as a
2265 failing assertion. */
2266 *value = 0;
2268 if (node)
2269 *value = (node->type == NT_ASSERTION &&
2270 (answer == 0 || *find_answer (node, answer) != 0));
2271 else if (pfile->cur_token[-1].type == CPP_EOF)
2272 _cpp_backup_tokens (pfile, 1);
2274 /* We don't commit the memory for the answer - it's temporary only. */
2275 return node == 0;
2278 /* Handle #assert. */
2279 static void
2280 do_assert (cpp_reader *pfile)
2282 struct answer *new_answer;
2283 cpp_hashnode *node;
2285 node = parse_assertion (pfile, &new_answer, T_ASSERT);
2286 if (node)
2288 size_t answer_size;
2290 /* Place the new answer in the answer list. First check there
2291 is not a duplicate. */
2292 new_answer->next = 0;
2293 if (node->type == NT_ASSERTION)
2295 if (*find_answer (node, new_answer))
2297 cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2298 NODE_NAME (node) + 1);
2299 return;
2301 new_answer->next = node->value.answers;
2304 answer_size = sizeof (struct answer) + ((new_answer->count - 1)
2305 * sizeof (cpp_token));
2306 /* Commit or allocate storage for the object. */
2307 if (pfile->hash_table->alloc_subobject)
2309 struct answer *temp_answer = new_answer;
2310 new_answer = (struct answer *) pfile->hash_table->alloc_subobject
2311 (answer_size);
2312 memcpy (new_answer, temp_answer, answer_size);
2314 else
2315 BUFF_FRONT (pfile->a_buff) += answer_size;
2317 node->type = NT_ASSERTION;
2318 node->value.answers = new_answer;
2319 check_eol (pfile, false);
2323 /* Handle #unassert. */
2324 static void
2325 do_unassert (cpp_reader *pfile)
2327 cpp_hashnode *node;
2328 struct answer *answer;
2330 node = parse_assertion (pfile, &answer, T_UNASSERT);
2331 /* It isn't an error to #unassert something that isn't asserted. */
2332 if (node && node->type == NT_ASSERTION)
2334 if (answer)
2336 struct answer **p = find_answer (node, answer), *temp;
2338 /* Remove the answer from the list. */
2339 temp = *p;
2340 if (temp)
2341 *p = temp->next;
2343 /* Did we free the last answer? */
2344 if (node->value.answers == 0)
2345 node->type = NT_VOID;
2347 check_eol (pfile, false);
2349 else
2350 _cpp_free_definition (node);
2353 /* We don't commit the memory for the answer - it's temporary only. */
2356 /* These are for -D, -U, -A. */
2358 /* Process the string STR as if it appeared as the body of a #define.
2359 If STR is just an identifier, define it with value 1.
2360 If STR has anything after the identifier, then it should
2361 be identifier=definition. */
2362 void
2363 cpp_define (cpp_reader *pfile, const char *str)
2365 char *buf;
2366 const char *p;
2367 size_t count;
2369 /* Copy the entire option so we can modify it.
2370 Change the first "=" in the string to a space. If there is none,
2371 tack " 1" on the end. */
2373 count = strlen (str);
2374 buf = (char *) alloca (count + 3);
2375 memcpy (buf, str, count);
2377 p = strchr (str, '=');
2378 if (p)
2379 buf[p - str] = ' ';
2380 else
2382 buf[count++] = ' ';
2383 buf[count++] = '1';
2385 buf[count] = '\n';
2387 run_directive (pfile, T_DEFINE, buf, count);
2391 /* Use to build macros to be run through cpp_define() as
2392 described above.
2393 Example: cpp_define_formatted (pfile, "MACRO=%d", value); */
2395 void
2396 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
2398 char *ptr = NULL;
2400 va_list ap;
2401 va_start (ap, fmt);
2402 vasprintf (&ptr, fmt, ap);
2403 va_end (ap);
2405 cpp_define (pfile, ptr);
2406 free (ptr);
2410 /* Slight variant of the above for use by initialize_builtins. */
2411 void
2412 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2414 size_t len = strlen (str);
2415 char *buf = (char *) alloca (len + 1);
2416 memcpy (buf, str, len);
2417 buf[len] = '\n';
2418 run_directive (pfile, T_DEFINE, buf, len);
2421 /* Process MACRO as if it appeared as the body of an #undef. */
2422 void
2423 cpp_undef (cpp_reader *pfile, const char *macro)
2425 size_t len = strlen (macro);
2426 char *buf = (char *) alloca (len + 1);
2427 memcpy (buf, macro, len);
2428 buf[len] = '\n';
2429 run_directive (pfile, T_UNDEF, buf, len);
2432 /* Replace a previous definition DEF of the macro STR. If DEF is NULL,
2433 or first element is zero, then the macro should be undefined. */
2434 static void
2435 cpp_pop_definition (cpp_reader *pfile, struct def_pragma_macro *c)
2437 cpp_hashnode *node = _cpp_lex_identifier (pfile, c->name);
2438 if (node == NULL)
2439 return;
2441 if (pfile->cb.before_define)
2442 pfile->cb.before_define (pfile);
2444 if (node->type == NT_MACRO)
2446 if (pfile->cb.undef)
2447 pfile->cb.undef (pfile, pfile->directive_line, node);
2448 if (CPP_OPTION (pfile, warn_unused_macros))
2449 _cpp_warn_if_unused_macro (pfile, node, NULL);
2451 if (node->type != NT_VOID)
2452 _cpp_free_definition (node);
2454 if (c->is_undef)
2455 return;
2457 size_t namelen;
2458 const uchar *dn;
2459 cpp_hashnode *h = NULL;
2460 cpp_buffer *nbuf;
2462 namelen = ustrcspn (c->definition, "( \n");
2463 h = cpp_lookup (pfile, c->definition, namelen);
2464 dn = c->definition + namelen;
2466 h->type = NT_VOID;
2467 h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
2468 nbuf = cpp_push_buffer (pfile, dn, ustrchr (dn, '\n') - dn, true);
2469 if (nbuf != NULL)
2471 _cpp_clean_line (pfile);
2472 nbuf->sysp = 1;
2473 if (!_cpp_create_definition (pfile, h))
2474 abort ();
2475 _cpp_pop_buffer (pfile);
2477 else
2478 abort ();
2479 h->value.macro->line = c->line;
2480 h->value.macro->syshdr = c->syshdr;
2481 h->value.macro->used = c->used;
2485 /* Process the string STR as if it appeared as the body of a #assert. */
2486 void
2487 cpp_assert (cpp_reader *pfile, const char *str)
2489 handle_assertion (pfile, str, T_ASSERT);
2492 /* Process STR as if it appeared as the body of an #unassert. */
2493 void
2494 cpp_unassert (cpp_reader *pfile, const char *str)
2496 handle_assertion (pfile, str, T_UNASSERT);
2499 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2500 static void
2501 handle_assertion (cpp_reader *pfile, const char *str, int type)
2503 size_t count = strlen (str);
2504 const char *p = strchr (str, '=');
2506 /* Copy the entire option so we can modify it. Change the first
2507 "=" in the string to a '(', and tack a ')' on the end. */
2508 char *buf = (char *) alloca (count + 2);
2510 memcpy (buf, str, count);
2511 if (p)
2513 buf[p - str] = '(';
2514 buf[count++] = ')';
2516 buf[count] = '\n';
2517 str = buf;
2519 run_directive (pfile, type, str, count);
2522 /* The options structure. */
2523 cpp_options *
2524 cpp_get_options (cpp_reader *pfile)
2526 return &pfile->opts;
2529 /* The callbacks structure. */
2530 cpp_callbacks *
2531 cpp_get_callbacks (cpp_reader *pfile)
2533 return &pfile->cb;
2536 /* Copy the given callbacks structure to our own. */
2537 void
2538 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2540 pfile->cb = *cb;
2543 /* The dependencies structure. (Creates one if it hasn't already been.) */
2544 struct deps *
2545 cpp_get_deps (cpp_reader *pfile)
2547 if (!pfile->deps)
2548 pfile->deps = deps_init ();
2549 return pfile->deps;
2552 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2553 doesn't fail. It does not generate a file change call back; that
2554 is the responsibility of the caller. */
2555 cpp_buffer *
2556 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2557 int from_stage3)
2559 cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2561 /* Clears, amongst other things, if_stack and mi_cmacro. */
2562 memset (new_buffer, 0, sizeof (cpp_buffer));
2564 new_buffer->next_line = new_buffer->buf = buffer;
2565 new_buffer->rlimit = buffer + len;
2566 new_buffer->from_stage3 = from_stage3;
2567 new_buffer->prev = pfile->buffer;
2568 new_buffer->need_line = true;
2570 pfile->buffer = new_buffer;
2572 return new_buffer;
2575 /* Pops a single buffer, with a file change call-back if appropriate.
2576 Then pushes the next -include file, if any remain. */
2577 void
2578 _cpp_pop_buffer (cpp_reader *pfile)
2580 cpp_buffer *buffer = pfile->buffer;
2581 struct _cpp_file *inc = buffer->file;
2582 struct if_stack *ifs;
2583 const unsigned char *to_free;
2585 /* Walk back up the conditional stack till we reach its level at
2586 entry to this file, issuing error messages. */
2587 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2588 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2589 "unterminated #%s", dtable[ifs->type].name);
2591 /* In case of a missing #endif. */
2592 pfile->state.skipping = 0;
2594 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2595 pfile->buffer = buffer->prev;
2597 to_free = buffer->to_free;
2598 free (buffer->notes);
2600 /* Free the buffer object now; we may want to push a new buffer
2601 in _cpp_push_next_include_file. */
2602 obstack_free (&pfile->buffer_ob, buffer);
2604 if (inc)
2606 _cpp_pop_file_buffer (pfile, inc, to_free);
2608 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2612 /* Enter all recognized directives in the hash table. */
2613 void
2614 _cpp_init_directives (cpp_reader *pfile)
2616 unsigned int i;
2617 cpp_hashnode *node;
2619 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2621 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2622 node->is_directive = 1;
2623 node->directive_index = i;