1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 Contributed by Per Bothner, 1994-95.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
30 /* Stack of conditionals currently in progress
31 (including both successful and failing conditionals). */
34 struct if_stack
*next
;
35 source_location line
; /* Line where condition started. */
36 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
37 bool skip_elses
; /* Can future #else / #elif be skipped? */
38 bool was_skipping
; /* If were skipping on entry. */
39 int type
; /* Most recent conditional for diagnostics. */
42 /* Contains a registered pragma or pragma namespace. */
43 typedef void (*pragma_cb
) (cpp_reader
*);
46 struct pragma_entry
*next
;
47 const cpp_hashnode
*pragma
; /* Name and length. */
54 struct pragma_entry
*space
;
59 /* Values for the origin field of struct directive. KANDR directives
60 come from traditional (K&R) C. STDC89 directives come from the
61 1989 C standard. EXTENSION directives are extensions. */
66 /* Values for the flags field of struct directive. COND indicates a
67 conditional; IF_COND an opening conditional. INCL means to treat
68 "..." and <...> as q-char and h-char sequences respectively. IN_I
69 means this directive should be handled even if -fpreprocessed is in
70 effect (these are the directives with callback hooks).
72 EXPAND is set on directives that are always macro-expanded. */
74 #define IF_COND (1 << 1)
77 #define EXPAND (1 << 4)
78 #define DEPRECATED (1 << 5)
80 /* Defines one #-directive, including how to handle it. */
81 typedef void (*directive_handler
) (cpp_reader
*);
82 typedef struct directive directive
;
85 directive_handler handler
; /* Function to handle directive. */
86 const uchar
*name
; /* Name of directive. */
87 unsigned short length
; /* Length of name. */
88 unsigned char origin
; /* Origin of directive. */
89 unsigned char flags
; /* Flags describing this directive. */
92 /* Forward declarations. */
94 static void skip_rest_of_line (cpp_reader
*);
95 static void check_eol (cpp_reader
*, bool);
96 static void start_directive (cpp_reader
*);
97 static void prepare_directive_trad (cpp_reader
*);
98 static void end_directive (cpp_reader
*, int);
99 static void directive_diagnostics (cpp_reader
*, const directive
*, int);
100 static void run_directive (cpp_reader
*, int, const char *, size_t);
101 static char *glue_header_name (cpp_reader
*);
102 static const char *parse_include (cpp_reader
*, int *, const cpp_token
***,
104 static void push_conditional (cpp_reader
*, int, int, const cpp_hashnode
*);
105 static unsigned int read_flag (cpp_reader
*, unsigned int);
106 static bool strtolinenum (const uchar
*, size_t, linenum_type
*, bool *);
107 static void do_diagnostic (cpp_reader
*, int, int, int);
108 static cpp_hashnode
*lex_macro_node (cpp_reader
*, bool);
109 static int undefine_macros (cpp_reader
*, cpp_hashnode
*, void *);
110 static void do_include_common (cpp_reader
*, enum include_type
);
111 static struct pragma_entry
*lookup_pragma_entry (struct pragma_entry
*,
112 const cpp_hashnode
*);
113 static int count_registered_pragmas (struct pragma_entry
*);
114 static char ** save_registered_pragmas (struct pragma_entry
*, char **);
115 static char ** restore_registered_pragmas (cpp_reader
*, struct pragma_entry
*,
117 static void do_pragma_once (cpp_reader
*);
118 static void do_pragma_poison (cpp_reader
*);
119 static void do_pragma_system_header (cpp_reader
*);
120 static void do_pragma_dependency (cpp_reader
*);
121 static void do_linemarker (cpp_reader
*);
122 static const cpp_token
*get_token_no_padding (cpp_reader
*);
123 static const cpp_token
*get__Pragma_string (cpp_reader
*);
124 static void destringize_and_run (cpp_reader
*, const cpp_string
*);
125 static int parse_answer (cpp_reader
*, struct answer
**, int, source_location
);
126 static cpp_hashnode
*parse_assertion (cpp_reader
*, struct answer
**, int);
127 static struct answer
** find_answer (cpp_hashnode
*, const struct answer
*);
128 static void handle_assertion (cpp_reader
*, const char *, int);
129 static void do_pragma_push_macro (cpp_reader
*);
130 static void do_pragma_pop_macro (cpp_reader
*);
131 static void cpp_pop_definition (cpp_reader
*, struct def_pragma_macro
*);
133 /* This is the table of directive handlers. It is ordered by
134 frequency of occurrence; the numbers at the end are directive
135 counts from all the source code I have lying around (egcs and libc
136 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
137 pcmcia-cs-3.0.9). This is no longer important as directive lookup
138 is now O(1). All extensions other than #warning, #include_next,
139 and #import are deprecated. The name is where the extension
140 appears to have come from. */
142 #define DIRECTIVE_TABLE \
143 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
144 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
145 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
146 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
147 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
148 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
149 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
150 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
151 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
152 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
153 D(error, T_ERROR, STDC89, 0) /* 475 */ \
154 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
155 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
156 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
157 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
158 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
159 D(assert, T_ASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
160 D(unassert, T_UNASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
161 D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */
163 /* #sccs is synonymous with #ident. */
164 #define do_sccs do_ident
166 /* Use the table to generate a series of prototypes, an enum for the
167 directive names, and an array of directive handlers. */
169 #define D(name, t, o, f) static void do_##name (cpp_reader *);
173 #define D(n, tag, o, f) tag,
181 #define D(name, t, origin, flags) \
182 { do_##name, (const uchar *) #name, \
183 sizeof #name - 1, origin, flags },
184 static const directive dtable
[] =
189 #undef DIRECTIVE_TABLE
191 /* Wrapper struct directive for linemarkers.
192 The origin is more or less true - the original K+R cpp
193 did use this notation in its preprocessed output. */
194 static const directive linemarker_dir
=
196 do_linemarker
, UC
"#", 1, KANDR
, IN_I
199 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
201 /* Skip any remaining tokens in a directive. */
203 skip_rest_of_line (cpp_reader
*pfile
)
205 /* Discard all stacked contexts. */
206 while (pfile
->context
->prev
)
207 _cpp_pop_context (pfile
);
209 /* Sweep up all tokens remaining on the line. */
211 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
215 /* Ensure there are no stray tokens at the end of a directive. If
216 EXPAND is true, tokens macro-expanding to nothing are allowed. */
218 check_eol (cpp_reader
*pfile
, bool expand
)
220 if (! SEEN_EOL () && (expand
221 ? cpp_get_token (pfile
)
222 : _cpp_lex_token (pfile
))->type
!= CPP_EOF
)
223 cpp_error (pfile
, CPP_DL_PEDWARN
, "extra tokens at end of #%s directive",
224 pfile
->directive
->name
);
227 /* Ensure there are no stray tokens other than comments at the end of
228 a directive, and gather the comments. */
229 static const cpp_token
**
230 check_eol_return_comments (cpp_reader
*pfile
)
234 const cpp_token
**buf
;
236 buf
= XNEWVEC (const cpp_token
*, capacity
);
242 const cpp_token
*tok
;
244 tok
= _cpp_lex_token (pfile
);
245 if (tok
->type
== CPP_EOF
)
247 if (tok
->type
!= CPP_COMMENT
)
248 cpp_error (pfile
, CPP_DL_PEDWARN
,
249 "extra tokens at end of #%s directive",
250 pfile
->directive
->name
);
253 if (c
+ 1 >= capacity
)
256 buf
= XRESIZEVEC (const cpp_token
*, buf
, capacity
);
267 /* Called when entering a directive, _Pragma or command-line directive. */
269 start_directive (cpp_reader
*pfile
)
271 /* Setup in-directive state. */
272 pfile
->state
.in_directive
= 1;
273 pfile
->state
.save_comments
= 0;
274 pfile
->directive_result
.type
= CPP_PADDING
;
276 /* Some handlers need the position of the # for diagnostics. */
277 pfile
->directive_line
= pfile
->line_table
->highest_line
;
280 /* Called when leaving a directive, _Pragma or command-line directive. */
282 end_directive (cpp_reader
*pfile
, int skip_line
)
284 if (CPP_OPTION (pfile
, traditional
))
286 /* Revert change of prepare_directive_trad. */
287 if (!pfile
->state
.in_deferred_pragma
)
288 pfile
->state
.prevent_expansion
--;
290 if (pfile
->directive
!= &dtable
[T_DEFINE
])
291 _cpp_remove_overlay (pfile
);
293 else if (pfile
->state
.in_deferred_pragma
)
295 /* We don't skip for an assembler #. */
298 skip_rest_of_line (pfile
);
299 if (!pfile
->keep_tokens
)
301 pfile
->cur_run
= &pfile
->base_run
;
302 pfile
->cur_token
= pfile
->base_run
.base
;
307 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
308 pfile
->state
.in_directive
= 0;
309 pfile
->state
.in_expression
= 0;
310 pfile
->state
.angled_headers
= 0;
311 pfile
->directive
= 0;
314 /* Prepare to handle the directive in pfile->directive. */
316 prepare_directive_trad (cpp_reader
*pfile
)
318 if (pfile
->directive
!= &dtable
[T_DEFINE
])
320 bool no_expand
= (pfile
->directive
321 && ! (pfile
->directive
->flags
& EXPAND
));
322 bool was_skipping
= pfile
->state
.skipping
;
324 pfile
->state
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
325 || pfile
->directive
== &dtable
[T_ELIF
]);
326 if (pfile
->state
.in_expression
)
327 pfile
->state
.skipping
= false;
330 pfile
->state
.prevent_expansion
++;
331 _cpp_scan_out_logical_line (pfile
, NULL
);
333 pfile
->state
.prevent_expansion
--;
335 pfile
->state
.skipping
= was_skipping
;
336 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
337 pfile
->out
.cur
- pfile
->out
.base
);
340 /* Stop ISO C from expanding anything. */
341 pfile
->state
.prevent_expansion
++;
344 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
345 the '#' was indented. */
347 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
349 /* Issue -pedantic or deprecated warnings for extensions. We let
350 -pedantic take precedence if both are applicable. */
351 if (! pfile
->state
.skipping
)
353 if (dir
->origin
== EXTENSION
354 && !(dir
== &dtable
[T_IMPORT
] && CPP_OPTION (pfile
, objc
))
355 && CPP_PEDANTIC (pfile
))
356 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
357 else if (((dir
->flags
& DEPRECATED
) != 0
358 || (dir
== &dtable
[T_IMPORT
] && !CPP_OPTION (pfile
, objc
)))
359 && CPP_OPTION (pfile
, cpp_warn_deprecated
))
360 cpp_warning (pfile
, CPP_W_DEPRECATED
,
361 "#%s is a deprecated GCC extension", dir
->name
);
364 /* Traditionally, a directive is ignored unless its # is in
365 column 1. Therefore in code intended to work with K+R
366 compilers, directives added by C89 must have their #
367 indented, and directives present in traditional C must not.
368 This is true even of directives in skipped conditional
369 blocks. #elif cannot be used at all. */
370 if (CPP_WTRADITIONAL (pfile
))
372 if (dir
== &dtable
[T_ELIF
])
373 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
374 "suggest not using #elif in traditional C");
375 else if (indented
&& dir
->origin
== KANDR
)
376 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
377 "traditional C ignores #%s with the # indented",
379 else if (!indented
&& dir
->origin
!= KANDR
)
380 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
381 "suggest hiding #%s from traditional C with an indented #",
386 /* Check if we have a known directive. INDENTED is nonzero if the
387 '#' of the directive was indented. This function is in this file
388 to save unnecessarily exporting dtable etc. to lex.c. Returns
389 nonzero if the line of tokens has been handled, zero if we should
390 continue processing the line. */
392 _cpp_handle_directive (cpp_reader
*pfile
, int indented
)
394 const directive
*dir
= 0;
395 const cpp_token
*dname
;
396 bool was_parsing_args
= pfile
->state
.parsing_args
;
397 bool was_discarding_output
= pfile
->state
.discarding_output
;
400 if (was_discarding_output
)
401 pfile
->state
.prevent_expansion
= 0;
403 if (was_parsing_args
)
405 if (CPP_OPTION (pfile
, cpp_pedantic
))
406 cpp_error (pfile
, CPP_DL_PEDWARN
,
407 "embedding a directive within macro arguments is not portable");
408 pfile
->state
.parsing_args
= 0;
409 pfile
->state
.prevent_expansion
= 0;
411 start_directive (pfile
);
412 dname
= _cpp_lex_token (pfile
);
414 if (dname
->type
== CPP_NAME
)
416 if (dname
->val
.node
.node
->is_directive
)
417 dir
= &dtable
[dname
->val
.node
.node
->directive_index
];
419 /* We do not recognize the # followed by a number extension in
421 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
423 dir
= &linemarker_dir
;
424 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
425 && ! pfile
->state
.skipping
)
426 cpp_error (pfile
, CPP_DL_PEDWARN
,
427 "style of line directive is a GCC extension");
432 /* If we have a directive that is not an opening conditional,
433 invalidate any control macro. */
434 if (! (dir
->flags
& IF_COND
))
435 pfile
->mi_valid
= false;
437 /* Kluge alert. In order to be sure that code like this
442 does not cause '#define foo bar' to get executed when
443 compiled with -save-temps, we recognize directives in
444 -fpreprocessed mode only if the # is in column 1. macro.c
445 puts a space in front of any '#' at the start of a macro.
447 We exclude the -fdirectives-only case because macro expansion
448 has not been performed yet, and block comments can cause spaces
449 to preceed the directive. */
450 if (CPP_OPTION (pfile
, preprocessed
)
451 && !CPP_OPTION (pfile
, directives_only
)
452 && (indented
|| !(dir
->flags
& IN_I
)))
459 /* In failed conditional groups, all non-conditional
460 directives are ignored. Before doing that, whether
461 skipping or not, we should lex angle-bracketed headers
462 correctly, and maybe output some diagnostics. */
463 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
464 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
465 if (! CPP_OPTION (pfile
, preprocessed
))
466 directive_diagnostics (pfile
, dir
, indented
);
467 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
471 else if (dname
->type
== CPP_EOF
)
472 ; /* CPP_EOF is the "null directive". */
475 /* An unknown directive. Don't complain about it in assembly
476 source: we don't know where the comments are, and # may
477 introduce assembler pseudo-ops. Don't complain about invalid
478 directives in skipped conditional groups (6.10 p4). */
479 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
481 else if (!pfile
->state
.skipping
)
482 cpp_error (pfile
, CPP_DL_ERROR
, "invalid preprocessing directive #%s",
483 cpp_token_as_text (pfile
, dname
));
486 pfile
->directive
= dir
;
487 if (CPP_OPTION (pfile
, traditional
))
488 prepare_directive_trad (pfile
);
491 pfile
->directive
->handler (pfile
);
493 _cpp_backup_tokens (pfile
, 1);
495 end_directive (pfile
, skip
);
496 if (was_parsing_args
&& !pfile
->state
.in_deferred_pragma
)
498 /* Restore state when within macro args. */
499 pfile
->state
.parsing_args
= 2;
500 pfile
->state
.prevent_expansion
= 1;
502 if (was_discarding_output
)
503 pfile
->state
.prevent_expansion
= 1;
507 /* Directive handler wrapper used by the command line option
508 processor. BUF is \n terminated. */
510 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
512 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
513 /* from_stage3 */ true);
514 start_directive (pfile
);
516 /* This is a short-term fix to prevent a leading '#' being
517 interpreted as a directive. */
518 _cpp_clean_line (pfile
);
520 pfile
->directive
= &dtable
[dir_no
];
521 if (CPP_OPTION (pfile
, traditional
))
522 prepare_directive_trad (pfile
);
523 pfile
->directive
->handler (pfile
);
524 end_directive (pfile
, 1);
525 _cpp_pop_buffer (pfile
);
528 /* Checks for validity the macro name in #define, #undef, #ifdef and
529 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
530 processing a #define or #undefine directive, and false
532 static cpp_hashnode
*
533 lex_macro_node (cpp_reader
*pfile
, bool is_def_or_undef
)
535 const cpp_token
*token
= _cpp_lex_token (pfile
);
537 /* The token immediately after #define must be an identifier. That
538 identifier may not be "defined", per C99 6.10.8p4.
539 In C++, it may not be any of the "named operators" either,
540 per C++98 [lex.digraph], [lex.key].
541 Finally, the identifier may not have been poisoned. (In that case
542 the lexer has issued the error message for us.) */
544 if (token
->type
== CPP_NAME
)
546 cpp_hashnode
*node
= token
->val
.node
.node
;
548 if (is_def_or_undef
&& node
== pfile
->spec_nodes
.n_defined
)
549 cpp_error (pfile
, CPP_DL_ERROR
,
550 "\"defined\" cannot be used as a macro name");
551 else if (! (node
->flags
& NODE_POISONED
))
554 else if (token
->flags
& NAMED_OP
)
555 cpp_error (pfile
, CPP_DL_ERROR
,
556 "\"%s\" cannot be used as a macro name as it is an operator in C++",
557 NODE_NAME (token
->val
.node
.node
));
558 else if (token
->type
== CPP_EOF
)
559 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
560 pfile
->directive
->name
);
562 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
567 /* Process a #define directive. Most work is done in macro.c. */
569 do_define (cpp_reader
*pfile
)
571 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
575 /* If we have been requested to expand comments into macros,
576 then re-enable saving of comments. */
577 pfile
->state
.save_comments
=
578 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
580 if (pfile
->cb
.before_define
)
581 pfile
->cb
.before_define (pfile
);
583 if (_cpp_create_definition (pfile
, node
))
584 if (pfile
->cb
.define
)
585 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
587 node
->flags
&= ~NODE_USED
;
591 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
593 do_undef (cpp_reader
*pfile
)
595 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
599 if (pfile
->cb
.before_define
)
600 pfile
->cb
.before_define (pfile
);
603 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
605 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
606 identifier is not currently defined as a macro name. */
607 if (node
->type
== NT_MACRO
)
609 if (node
->flags
& NODE_WARN
)
610 cpp_error (pfile
, CPP_DL_WARNING
,
611 "undefining \"%s\"", NODE_NAME (node
));
613 if (CPP_OPTION (pfile
, warn_unused_macros
))
614 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
616 _cpp_free_definition (node
);
620 check_eol (pfile
, false);
623 /* Undefine a single macro/assertion/whatever. */
626 undefine_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*h
,
627 void *data_p ATTRIBUTE_UNUSED
)
629 /* Body of _cpp_free_definition inlined here for speed.
630 Macros and assertions no longer have anything to free. */
632 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
|NODE_USED
);
636 /* Undefine all macros and assertions. */
639 cpp_undef_all (cpp_reader
*pfile
)
641 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
645 /* Helper routine used by parse_include. Reinterpret the current line
646 as an h-char-sequence (< ... >); we are looking at the first token
647 after the <. Returns a malloced filename. */
649 glue_header_name (cpp_reader
*pfile
)
651 const cpp_token
*token
;
653 size_t len
, total_len
= 0, capacity
= 1024;
655 /* To avoid lexed tokens overwriting our glued name, we can only
656 allocate from the string pool once we've lexed everything. */
657 buffer
= XNEWVEC (char, capacity
);
660 token
= get_token_no_padding (pfile
);
662 if (token
->type
== CPP_GREATER
)
664 if (token
->type
== CPP_EOF
)
666 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
670 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
671 if (total_len
+ len
> capacity
)
673 capacity
= (capacity
+ len
) * 2;
674 buffer
= XRESIZEVEC (char, buffer
, capacity
);
677 if (token
->flags
& PREV_WHITE
)
678 buffer
[total_len
++] = ' ';
680 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
],
685 buffer
[total_len
] = '\0';
689 /* Returns the file name of #include, #include_next, #import and
690 #pragma dependency. The string is malloced and the caller should
691 free it. Returns NULL on error. LOCATION is the source location
695 parse_include (cpp_reader
*pfile
, int *pangle_brackets
,
696 const cpp_token
***buf
, source_location
*location
)
699 const cpp_token
*header
;
701 /* Allow macro expansion. */
702 header
= get_token_no_padding (pfile
);
703 *location
= header
->src_loc
;
704 if ((header
->type
== CPP_STRING
&& header
->val
.str
.text
[0] != 'R')
705 || header
->type
== CPP_HEADER_NAME
)
707 fname
= XNEWVEC (char, header
->val
.str
.len
- 1);
708 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
709 fname
[header
->val
.str
.len
- 2] = '\0';
710 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
712 else if (header
->type
== CPP_LESS
)
714 fname
= glue_header_name (pfile
);
715 *pangle_brackets
= 1;
719 const unsigned char *dir
;
721 if (pfile
->directive
== &dtable
[T_PRAGMA
])
722 dir
= UC
"pragma dependency";
724 dir
= pfile
->directive
->name
;
725 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
731 if (pfile
->directive
== &dtable
[T_PRAGMA
])
733 /* This pragma allows extra tokens after the file name. */
735 else if (buf
== NULL
|| CPP_OPTION (pfile
, discard_comments
))
736 check_eol (pfile
, true);
739 /* If we are not discarding comments, then gather them while
740 doing the eol check. */
741 *buf
= check_eol_return_comments (pfile
);
747 /* Handle #include, #include_next and #import. */
749 do_include_common (cpp_reader
*pfile
, enum include_type type
)
753 const cpp_token
**buf
= NULL
;
754 source_location location
;
756 /* Re-enable saving of comments if requested, so that the include
757 callback can dump comments which follow #include. */
758 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
760 fname
= parse_include (pfile
, &angle_brackets
, &buf
, &location
);
770 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
771 "empty filename in #%s",
772 pfile
->directive
->name
);
779 /* Prevent #include recursion. */
780 if (pfile
->line_table
->depth
>= CPP_STACK_MAX
)
781 cpp_error (pfile
, CPP_DL_ERROR
, "#include nested too deeply");
784 /* Get out of macro context, if we are. */
785 skip_rest_of_line (pfile
);
787 if (pfile
->cb
.include
)
788 pfile
->cb
.include (pfile
, pfile
->directive_line
,
789 pfile
->directive
->name
, fname
, angle_brackets
,
792 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
);
801 do_include (cpp_reader
*pfile
)
803 do_include_common (pfile
, IT_INCLUDE
);
807 do_import (cpp_reader
*pfile
)
809 do_include_common (pfile
, IT_IMPORT
);
813 do_include_next (cpp_reader
*pfile
)
815 enum include_type type
= IT_INCLUDE_NEXT
;
817 /* If this is the primary source file, warn and use the normal
819 if (cpp_in_primary_file (pfile
))
821 cpp_error (pfile
, CPP_DL_WARNING
,
822 "#include_next in primary source file");
825 do_include_common (pfile
, type
);
828 /* Subroutine of do_linemarker. Read possible flags after file name.
829 LAST is the last flag seen; 0 if this is the first flag. Return the
830 flag if it is valid, 0 at the end of the directive. Otherwise
833 read_flag (cpp_reader
*pfile
, unsigned int last
)
835 const cpp_token
*token
= _cpp_lex_token (pfile
);
837 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
839 unsigned int flag
= token
->val
.str
.text
[0] - '0';
841 if (flag
> last
&& flag
<= 4
842 && (flag
!= 4 || last
== 3)
843 && (flag
!= 2 || last
== 0))
847 if (token
->type
!= CPP_EOF
)
848 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
849 cpp_token_as_text (pfile
, token
));
853 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
854 of length LEN, to binary; store it in NUMP, and return false if the
855 number was well-formed, true if not. WRAPPED is set to true if the
856 number did not fit into 'unsigned long'. */
858 strtolinenum (const uchar
*str
, size_t len
, linenum_type
*nump
, bool *wrapped
)
860 linenum_type reg
= 0;
861 linenum_type reg_prev
= 0;
880 /* Interpret #line command.
881 Note that the filename string (if any) is a true string constant
882 (escapes are interpreted), unlike in #line. */
884 do_line (cpp_reader
*pfile
)
886 const struct line_maps
*line_table
= pfile
->line_table
;
887 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
889 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
892 unsigned char map_sysp
= map
->sysp
;
893 const cpp_token
*token
;
894 const char *new_file
= map
->to_file
;
895 linenum_type new_lineno
;
897 /* C99 raised the minimum limit on #line numbers. */
898 linenum_type cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
901 /* #line commands expand macros. */
902 token
= cpp_get_token (pfile
);
903 if (token
->type
!= CPP_NUMBER
904 || strtolinenum (token
->val
.str
.text
, token
->val
.str
.len
,
905 &new_lineno
, &wrapped
))
907 if (token
->type
== CPP_EOF
)
908 cpp_error (pfile
, CPP_DL_ERROR
, "unexpected end of file after #line");
910 cpp_error (pfile
, CPP_DL_ERROR
,
911 "\"%s\" after #line is not a positive integer",
912 cpp_token_as_text (pfile
, token
));
916 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
|| wrapped
))
917 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
919 cpp_error (pfile
, CPP_DL_WARNING
, "line number out of range");
921 token
= cpp_get_token (pfile
);
922 if (token
->type
== CPP_STRING
)
924 cpp_string s
= { 0, 0 };
925 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, 1,
927 new_file
= (const char *)s
.text
;
928 check_eol (pfile
, true);
930 else if (token
->type
!= CPP_EOF
)
932 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
933 cpp_token_as_text (pfile
, token
));
937 skip_rest_of_line (pfile
);
938 _cpp_do_file_change (pfile
, LC_RENAME_VERBATIM
, new_file
, new_lineno
,
942 /* Interpret the # 44 "file" [flags] notation, which has slightly
943 different syntax and semantics from #line: Flags are allowed,
944 and we never complain about the line number being too big. */
946 do_linemarker (cpp_reader
*pfile
)
948 const struct line_maps
*line_table
= pfile
->line_table
;
949 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
950 const cpp_token
*token
;
951 const char *new_file
= map
->to_file
;
952 linenum_type new_lineno
;
953 unsigned int new_sysp
= map
->sysp
;
954 enum lc_reason reason
= LC_RENAME_VERBATIM
;
958 /* Back up so we can get the number again. Putting this in
959 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
960 some circumstances, which can segfault. */
961 _cpp_backup_tokens (pfile
, 1);
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 /* Unlike #line, there does not seem to be a way to get an EOF
970 here. So, it should be safe to always spell the token. */
971 cpp_error (pfile
, CPP_DL_ERROR
,
972 "\"%s\" after # is not a positive integer",
973 cpp_token_as_text (pfile
, token
));
977 token
= cpp_get_token (pfile
);
978 if (token
->type
== CPP_STRING
)
980 cpp_string s
= { 0, 0 };
981 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
,
983 new_file
= (const char *)s
.text
;
986 flag
= read_flag (pfile
, 0);
990 /* Fake an include for cpp_included (). */
991 _cpp_fake_include (pfile
, new_file
);
992 flag
= read_flag (pfile
, flag
);
997 flag
= read_flag (pfile
, flag
);
1002 flag
= read_flag (pfile
, flag
);
1006 pfile
->buffer
->sysp
= new_sysp
;
1008 check_eol (pfile
, false);
1010 else if (token
->type
!= CPP_EOF
)
1012 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
1013 cpp_token_as_text (pfile
, token
));
1017 skip_rest_of_line (pfile
);
1019 /* Compensate for the increment in linemap_add that occurs in
1020 _cpp_do_file_change. We're currently at the start of the line
1021 *following* the #line directive. A separate source_location for this
1022 location makes no sense (until we do the LC_LEAVE), and
1023 complicates LAST_SOURCE_LINE_LOCATION. */
1024 pfile
->line_table
->highest_location
--;
1026 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
1029 /* Arrange the file_change callback. pfile->line has changed to
1030 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
1031 header, 2 for a system header that needs to be extern "C" protected,
1032 and zero otherwise. */
1034 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
1035 const char *to_file
, linenum_type file_line
,
1038 const struct line_map
*map
= linemap_add (pfile
->line_table
, reason
, sysp
,
1039 to_file
, file_line
);
1041 linemap_line_start (pfile
->line_table
, map
->to_line
, 127);
1043 if (pfile
->cb
.file_change
)
1044 pfile
->cb
.file_change (pfile
, map
);
1047 /* Report a warning or error detected by the program we are
1048 processing. Use the directive's tokens in the error message. */
1050 do_diagnostic (cpp_reader
*pfile
, int code
, int reason
, int print_dir
)
1052 const unsigned char *dir_name
;
1053 unsigned char *line
;
1054 source_location src_loc
= pfile
->cur_token
[-1].src_loc
;
1057 dir_name
= pfile
->directive
->name
;
1060 pfile
->state
.prevent_expansion
++;
1061 line
= cpp_output_line_to_string (pfile
, dir_name
);
1062 pfile
->state
.prevent_expansion
--;
1064 if (code
== CPP_DL_WARNING_SYSHDR
&& reason
)
1065 cpp_warning_with_line_syshdr (pfile
, reason
, src_loc
, 0, "%s", line
);
1066 else if (code
== CPP_DL_WARNING
&& reason
)
1067 cpp_warning_with_line (pfile
, reason
, src_loc
, 0, "%s", line
);
1069 cpp_error_with_line (pfile
, code
, src_loc
, 0, "%s", line
);
1074 do_error (cpp_reader
*pfile
)
1076 do_diagnostic (pfile
, CPP_DL_ERROR
, 0, 1);
1080 do_warning (cpp_reader
*pfile
)
1082 /* We want #warning diagnostics to be emitted in system headers too. */
1083 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, CPP_W_WARNING_DIRECTIVE
, 1);
1086 /* Report program identification. */
1088 do_ident (cpp_reader
*pfile
)
1090 const cpp_token
*str
= cpp_get_token (pfile
);
1092 if (str
->type
!= CPP_STRING
)
1093 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #%s directive",
1094 pfile
->directive
->name
);
1095 else if (pfile
->cb
.ident
)
1096 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
1098 check_eol (pfile
, false);
1101 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1102 matching entry, or NULL if none is found. The returned entry could
1103 be the start of a namespace chain, or a pragma. */
1104 static struct pragma_entry
*
1105 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
1107 while (chain
&& chain
->pragma
!= pragma
)
1108 chain
= chain
->next
;
1113 /* Create and insert a blank pragma entry at the beginning of a
1114 singly-linked CHAIN. */
1115 static struct pragma_entry
*
1116 new_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
)
1118 struct pragma_entry
*new_entry
;
1120 new_entry
= (struct pragma_entry
*)
1121 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
1123 memset (new_entry
, 0, sizeof (struct pragma_entry
));
1124 new_entry
->next
= *chain
;
1130 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1131 goes in the global namespace. */
1132 static struct pragma_entry
*
1133 register_pragma_1 (cpp_reader
*pfile
, const char *space
, const char *name
,
1134 bool allow_name_expansion
)
1136 struct pragma_entry
**chain
= &pfile
->pragmas
;
1137 struct pragma_entry
*entry
;
1138 const cpp_hashnode
*node
;
1142 node
= cpp_lookup (pfile
, UC space
, strlen (space
));
1143 entry
= lookup_pragma_entry (*chain
, node
);
1146 entry
= new_pragma_entry (pfile
, chain
);
1147 entry
->pragma
= node
;
1148 entry
->is_nspace
= true;
1149 entry
->allow_expansion
= allow_name_expansion
;
1151 else if (!entry
->is_nspace
)
1153 else if (entry
->allow_expansion
!= allow_name_expansion
)
1155 cpp_error (pfile
, CPP_DL_ICE
,
1156 "registering pragmas in namespace \"%s\" with mismatched "
1157 "name expansion", space
);
1160 chain
= &entry
->u
.space
;
1162 else if (allow_name_expansion
)
1164 cpp_error (pfile
, CPP_DL_ICE
,
1165 "registering pragma \"%s\" with name expansion "
1166 "and no namespace", name
);
1170 /* Check for duplicates. */
1171 node
= cpp_lookup (pfile
, UC name
, strlen (name
));
1172 entry
= lookup_pragma_entry (*chain
, node
);
1175 entry
= new_pragma_entry (pfile
, chain
);
1176 entry
->pragma
= node
;
1180 if (entry
->is_nspace
)
1182 cpp_error (pfile
, CPP_DL_ICE
,
1183 "registering \"%s\" as both a pragma and a pragma namespace",
1186 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1189 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1194 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1196 register_pragma_internal (cpp_reader
*pfile
, const char *space
,
1197 const char *name
, pragma_cb handler
)
1199 struct pragma_entry
*entry
;
1201 entry
= register_pragma_1 (pfile
, space
, name
, false);
1202 entry
->is_internal
= true;
1203 entry
->u
.handler
= handler
;
1206 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1207 goes in the global namespace. HANDLER is the handler it will call,
1208 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1209 expansion while parsing pragma NAME. This function is exported
1212 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
1213 pragma_cb handler
, bool allow_expansion
)
1215 struct pragma_entry
*entry
;
1219 cpp_error (pfile
, CPP_DL_ICE
, "registering pragma with NULL handler");
1223 entry
= register_pragma_1 (pfile
, space
, name
, false);
1226 entry
->allow_expansion
= allow_expansion
;
1227 entry
->u
.handler
= handler
;
1231 /* Similarly, but create mark the pragma for deferred processing.
1232 When found, a CPP_PRAGMA token will be insertted into the stream
1233 with IDENT in the token->u.pragma slot. */
1235 cpp_register_deferred_pragma (cpp_reader
*pfile
, const char *space
,
1236 const char *name
, unsigned int ident
,
1237 bool allow_expansion
, bool allow_name_expansion
)
1239 struct pragma_entry
*entry
;
1241 entry
= register_pragma_1 (pfile
, space
, name
, allow_name_expansion
);
1244 entry
->is_deferred
= true;
1245 entry
->allow_expansion
= allow_expansion
;
1246 entry
->u
.ident
= ident
;
1250 /* Register the pragmas the preprocessor itself handles. */
1252 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1254 /* Pragmas in the global namespace. */
1255 register_pragma_internal (pfile
, 0, "once", do_pragma_once
);
1256 register_pragma_internal (pfile
, 0, "push_macro", do_pragma_push_macro
);
1257 register_pragma_internal (pfile
, 0, "pop_macro", do_pragma_pop_macro
);
1259 /* New GCC-specific pragmas should be put in the GCC namespace. */
1260 register_pragma_internal (pfile
, "GCC", "poison", do_pragma_poison
);
1261 register_pragma_internal (pfile
, "GCC", "system_header",
1262 do_pragma_system_header
);
1263 register_pragma_internal (pfile
, "GCC", "dependency", do_pragma_dependency
);
1266 /* Return the number of registered pragmas in PE. */
1269 count_registered_pragmas (struct pragma_entry
*pe
)
1272 for (; pe
!= NULL
; pe
= pe
->next
)
1275 ct
+= count_registered_pragmas (pe
->u
.space
);
1281 /* Save into SD the names of the registered pragmas referenced by PE,
1282 and return a pointer to the next free space in SD. */
1285 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1287 for (; pe
!= NULL
; pe
= pe
->next
)
1290 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1291 *sd
++ = (char *) xmemdup (HT_STR (&pe
->pragma
->ident
),
1292 HT_LEN (&pe
->pragma
->ident
),
1293 HT_LEN (&pe
->pragma
->ident
) + 1);
1298 /* Return a newly-allocated array which saves the names of the
1299 registered pragmas. */
1302 _cpp_save_pragma_names (cpp_reader
*pfile
)
1304 int ct
= count_registered_pragmas (pfile
->pragmas
);
1305 char **result
= XNEWVEC (char *, ct
);
1306 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1310 /* Restore from SD the names of the registered pragmas referenced by PE,
1311 and return a pointer to the next unused name in SD. */
1314 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1317 for (; pe
!= NULL
; pe
= pe
->next
)
1320 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1321 pe
->pragma
= cpp_lookup (pfile
, UC
*sd
, strlen (*sd
));
1328 /* Restore the names of the registered pragmas from SAVED. */
1331 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1333 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1337 /* Pragmata handling. We handle some, and pass the rest on to the
1338 front end. C99 defines three pragmas and says that no macro
1339 expansion is to be performed on them; whether or not macro
1340 expansion happens for other pragmas is implementation defined.
1341 This implementation allows for a mix of both, since GCC did not
1342 traditionally macro expand its (few) pragmas, whereas OpenMP
1343 specifies that macro expansion should happen. */
1345 do_pragma (cpp_reader
*pfile
)
1347 const struct pragma_entry
*p
= NULL
;
1348 const cpp_token
*token
, *pragma_token
= pfile
->cur_token
;
1350 unsigned int count
= 1;
1352 pfile
->state
.prevent_expansion
++;
1354 token
= cpp_get_token (pfile
);
1356 if (token
->type
== CPP_NAME
)
1358 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
.node
);
1359 if (p
&& p
->is_nspace
)
1361 bool allow_name_expansion
= p
->allow_expansion
;
1362 if (allow_name_expansion
)
1364 pfile
->state
.prevent_expansion
--;
1368 Consider this code snippet:
1374 Once we parsed the 'omp' namespace of the #pragma
1375 directive, we then parse the 'P' token that represents the
1376 pragma name. P being a macro, it is expanded into the
1377 resulting 'parallel' token.
1379 At this point the 'p' variable contains the 'parallel'
1380 pragma name. And pfile->context->macro is non-null
1381 because we are still right at the end of the macro
1382 context of 'P'. The problem is, if we are being
1383 (indirectly) called by cpp_get_token_with_location,
1384 that function might test pfile->context->macro to see
1385 if we are in the context of a macro expansion, (and we
1386 are) and then use pfile->invocation_location as the
1387 location of the macro invocation. So we must instruct
1388 cpp_get_token below to set
1389 pfile->invocation_location. */
1390 pfile
->set_invocation_location
= true;
1393 token
= cpp_get_token (pfile
);
1394 if (token
->type
== CPP_NAME
)
1395 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
.node
);
1398 if (allow_name_expansion
)
1399 pfile
->state
.prevent_expansion
++;
1408 pfile
->directive_result
.src_loc
= pragma_token
->src_loc
;
1409 pfile
->directive_result
.type
= CPP_PRAGMA
;
1410 pfile
->directive_result
.flags
= pragma_token
->flags
;
1411 pfile
->directive_result
.val
.pragma
= p
->u
.ident
;
1412 pfile
->state
.in_deferred_pragma
= true;
1413 pfile
->state
.pragma_allow_expansion
= p
->allow_expansion
;
1414 if (!p
->allow_expansion
)
1415 pfile
->state
.prevent_expansion
++;
1419 /* Since the handler below doesn't get the line number, that
1420 it might need for diagnostics, make sure it has the right
1421 numbers in place. */
1422 if (pfile
->cb
.line_change
)
1423 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1424 if (p
->allow_expansion
)
1425 pfile
->state
.prevent_expansion
--;
1426 (*p
->u
.handler
) (pfile
);
1427 if (p
->allow_expansion
)
1428 pfile
->state
.prevent_expansion
++;
1431 else if (pfile
->cb
.def_pragma
)
1433 if (count
== 1 || pfile
->context
->prev
== NULL
)
1434 _cpp_backup_tokens (pfile
, count
);
1437 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1438 won't allow backing 2 tokens. */
1439 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1440 reads both tokens, we could perhaps free it, but if it doesn't,
1441 we don't know the exact lifespan. */
1442 cpp_token
*toks
= XNEWVEC (cpp_token
, 2);
1444 toks
[0].flags
|= NO_EXPAND
;
1446 toks
[1].flags
|= NO_EXPAND
;
1447 _cpp_push_token_context (pfile
, NULL
, toks
, 2);
1449 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1452 pfile
->state
.prevent_expansion
--;
1455 /* Handle #pragma once. */
1457 do_pragma_once (cpp_reader
*pfile
)
1459 if (cpp_in_primary_file (pfile
))
1460 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1462 check_eol (pfile
, false);
1463 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1466 /* Handle #pragma push_macro(STRING). */
1468 do_pragma_push_macro (cpp_reader
*pfile
)
1472 const uchar
*defn
= NULL
;
1473 char *macroname
, *dest
;
1474 const char *limit
, *src
;
1475 const cpp_token
*txt
;
1476 struct def_pragma_macro
*c
;
1478 txt
= get__Pragma_string (pfile
);
1481 source_location src_loc
= pfile
->cur_token
[-1].src_loc
;
1482 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
1483 "invalid #pragma push_macro directive");
1484 check_eol (pfile
, false);
1485 skip_rest_of_line (pfile
);
1488 dest
= macroname
= (char *) alloca (txt
->val
.str
.len
+ 2);
1489 src
= (const char *) (txt
->val
.str
.text
+ 1 + (txt
->val
.str
.text
[0] == 'L'));
1490 limit
= (const char *) (txt
->val
.str
.text
+ txt
->val
.str
.len
- 1);
1493 /* We know there is a character following the backslash. */
1494 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1499 check_eol (pfile
, false);
1500 skip_rest_of_line (pfile
);
1501 c
= XNEW (struct def_pragma_macro
);
1502 memset (c
, 0, sizeof (struct def_pragma_macro
));
1503 c
->name
= XNEWVAR (char, strlen (macroname
) + 1);
1504 strcpy (c
->name
, macroname
);
1505 c
->next
= pfile
->pushed_macros
;
1506 node
= _cpp_lex_identifier (pfile
, c
->name
);
1507 if (node
->type
== NT_VOID
)
1511 defn
= cpp_macro_definition (pfile
, node
);
1512 defnlen
= ustrlen (defn
);
1513 c
->definition
= XNEWVEC (uchar
, defnlen
+ 2);
1514 c
->definition
[defnlen
] = '\n';
1515 c
->definition
[defnlen
+ 1] = 0;
1516 c
->line
= node
->value
.macro
->line
;
1517 c
->syshdr
= node
->value
.macro
->syshdr
;
1518 c
->used
= node
->value
.macro
->used
;
1519 memcpy (c
->definition
, defn
, defnlen
);
1522 pfile
->pushed_macros
= c
;
1525 /* Handle #pragma pop_macro(STRING). */
1527 do_pragma_pop_macro (cpp_reader
*pfile
)
1529 char *macroname
, *dest
;
1530 const char *limit
, *src
;
1531 const cpp_token
*txt
;
1532 struct def_pragma_macro
*l
= NULL
, *c
= pfile
->pushed_macros
;
1533 txt
= get__Pragma_string (pfile
);
1536 source_location src_loc
= pfile
->cur_token
[-1].src_loc
;
1537 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
1538 "invalid #pragma pop_macro directive");
1539 check_eol (pfile
, false);
1540 skip_rest_of_line (pfile
);
1543 dest
= macroname
= (char *) alloca (txt
->val
.str
.len
+ 2);
1544 src
= (const char *) (txt
->val
.str
.text
+ 1 + (txt
->val
.str
.text
[0] == 'L'));
1545 limit
= (const char *) (txt
->val
.str
.text
+ txt
->val
.str
.len
- 1);
1548 /* We know there is a character following the backslash. */
1549 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1554 check_eol (pfile
, false);
1555 skip_rest_of_line (pfile
);
1559 if (!strcmp (c
->name
, macroname
))
1562 pfile
->pushed_macros
= c
->next
;
1565 cpp_pop_definition (pfile
, c
);
1566 free (c
->definition
);
1576 /* Handle #pragma GCC poison, to poison one or more identifiers so
1577 that the lexer produces a hard error for each subsequent usage. */
1579 do_pragma_poison (cpp_reader
*pfile
)
1581 const cpp_token
*tok
;
1584 pfile
->state
.poisoned_ok
= 1;
1587 tok
= _cpp_lex_token (pfile
);
1588 if (tok
->type
== CPP_EOF
)
1590 if (tok
->type
!= CPP_NAME
)
1592 cpp_error (pfile
, CPP_DL_ERROR
,
1593 "invalid #pragma GCC poison directive");
1597 hp
= tok
->val
.node
.node
;
1598 if (hp
->flags
& NODE_POISONED
)
1601 if (hp
->type
== NT_MACRO
)
1602 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1604 _cpp_free_definition (hp
);
1605 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1607 pfile
->state
.poisoned_ok
= 0;
1610 /* Mark the current header as a system header. This will suppress
1611 some categories of warnings (notably those from -pedantic). It is
1612 intended for use in system libraries that cannot be implemented in
1613 conforming C, but cannot be certain that their headers appear in a
1614 system include directory. To prevent abuse, it is rejected in the
1615 primary source file. */
1617 do_pragma_system_header (cpp_reader
*pfile
)
1619 if (cpp_in_primary_file (pfile
))
1620 cpp_error (pfile
, CPP_DL_WARNING
,
1621 "#pragma system_header ignored outside include file");
1624 check_eol (pfile
, false);
1625 skip_rest_of_line (pfile
);
1626 cpp_make_system_header (pfile
, 1, 0);
1630 /* Check the modified date of the current include file against a specified
1631 file. Issue a diagnostic, if the specified file is newer. We use this to
1632 determine if a fixed header should be refixed. */
1634 do_pragma_dependency (cpp_reader
*pfile
)
1637 int angle_brackets
, ordering
;
1638 source_location location
;
1640 fname
= parse_include (pfile
, &angle_brackets
, NULL
, &location
);
1644 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1646 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1647 else if (ordering
> 0)
1649 cpp_error (pfile
, CPP_DL_WARNING
,
1650 "current file is older than %s", fname
);
1651 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1653 _cpp_backup_tokens (pfile
, 1);
1654 do_diagnostic (pfile
, CPP_DL_WARNING
, 0, 0);
1658 free ((void *) fname
);
1661 /* Get a token but skip padding. */
1662 static const cpp_token
*
1663 get_token_no_padding (cpp_reader
*pfile
)
1667 const cpp_token
*result
= cpp_get_token (pfile
);
1668 if (result
->type
!= CPP_PADDING
)
1673 /* Check syntax is "(string-literal)". Returns the string on success,
1674 or NULL on failure. */
1675 static const cpp_token
*
1676 get__Pragma_string (cpp_reader
*pfile
)
1678 const cpp_token
*string
;
1679 const cpp_token
*paren
;
1681 paren
= get_token_no_padding (pfile
);
1682 if (paren
->type
== CPP_EOF
)
1683 _cpp_backup_tokens (pfile
, 1);
1684 if (paren
->type
!= CPP_OPEN_PAREN
)
1687 string
= get_token_no_padding (pfile
);
1688 if (string
->type
== CPP_EOF
)
1689 _cpp_backup_tokens (pfile
, 1);
1690 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
1691 && string
->type
!= CPP_STRING32
&& string
->type
!= CPP_STRING16
1692 && string
->type
!= CPP_UTF8STRING
)
1695 paren
= get_token_no_padding (pfile
);
1696 if (paren
->type
== CPP_EOF
)
1697 _cpp_backup_tokens (pfile
, 1);
1698 if (paren
->type
!= CPP_CLOSE_PAREN
)
1704 /* Destringize IN into a temporary buffer, by removing the first \ of
1705 \" and \\ sequences, and process the result as a #pragma directive. */
1707 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1709 const unsigned char *src
, *limit
;
1710 char *dest
, *result
;
1711 cpp_context
*saved_context
;
1712 cpp_token
*saved_cur_token
;
1713 tokenrun
*saved_cur_run
;
1716 const struct directive
*save_directive
;
1718 dest
= result
= (char *) alloca (in
->len
- 1);
1719 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1720 limit
= in
->text
+ in
->len
- 1;
1723 /* We know there is a character following the backslash. */
1724 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1730 /* Ugh; an awful kludge. We are really not set up to be lexing
1731 tokens when in the middle of a macro expansion. Use a new
1732 context to force cpp_get_token to lex, and so skip_rest_of_line
1733 doesn't go beyond the end of the text. Also, remember the
1734 current lexing position so we can return to it later.
1736 Something like line-at-a-time lexing should remove the need for
1738 saved_context
= pfile
->context
;
1739 saved_cur_token
= pfile
->cur_token
;
1740 saved_cur_run
= pfile
->cur_run
;
1742 pfile
->context
= XNEW (cpp_context
);
1743 pfile
->context
->macro
= 0;
1744 pfile
->context
->prev
= 0;
1745 pfile
->context
->next
= 0;
1747 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1748 until we've read all of the tokens that we want. */
1749 cpp_push_buffer (pfile
, (const uchar
*) result
, dest
- result
,
1750 /* from_stage3 */ true);
1751 /* ??? Antique Disgusting Hack. What does this do? */
1752 if (pfile
->buffer
->prev
)
1753 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
1755 start_directive (pfile
);
1756 _cpp_clean_line (pfile
);
1757 save_directive
= pfile
->directive
;
1758 pfile
->directive
= &dtable
[T_PRAGMA
];
1760 end_directive (pfile
, 1);
1761 pfile
->directive
= save_directive
;
1763 /* We always insert at least one token, the directive result. It'll
1764 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1765 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1767 /* If we're not handling the pragma internally, read all of the tokens from
1768 the string buffer now, while the string buffer is still installed. */
1769 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1770 to me what the true lifespan of the tokens are. It would appear that
1771 the lifespan is the entire parse of the main input stream, in which case
1772 this may not be wrong. */
1773 if (pfile
->directive_result
.type
== CPP_PRAGMA
)
1779 toks
= XNEWVEC (cpp_token
, maxcount
);
1780 toks
[0] = pfile
->directive_result
;
1784 if (count
== maxcount
)
1786 maxcount
= maxcount
* 3 / 2;
1787 toks
= XRESIZEVEC (cpp_token
, toks
, maxcount
);
1789 toks
[count
] = *cpp_get_token (pfile
);
1790 /* Macros have been already expanded by cpp_get_token
1791 if the pragma allowed expansion. */
1792 toks
[count
++].flags
|= NO_EXPAND
;
1794 while (toks
[count
-1].type
!= CPP_PRAGMA_EOL
);
1799 toks
= XNEW (cpp_token
);
1800 toks
[0] = pfile
->directive_result
;
1802 /* If we handled the entire pragma internally, make sure we get the
1803 line number correct for the next token. */
1804 if (pfile
->cb
.line_change
)
1805 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1808 /* Finish inlining run_directive. */
1809 pfile
->buffer
->file
= NULL
;
1810 _cpp_pop_buffer (pfile
);
1812 /* Reset the old macro state before ... */
1813 XDELETE (pfile
->context
);
1814 pfile
->context
= saved_context
;
1815 pfile
->cur_token
= saved_cur_token
;
1816 pfile
->cur_run
= saved_cur_run
;
1818 /* ... inserting the new tokens we collected. */
1819 _cpp_push_token_context (pfile
, NULL
, toks
, count
);
1822 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1824 _cpp_do__Pragma (cpp_reader
*pfile
)
1826 const cpp_token
*string
= get__Pragma_string (pfile
);
1827 pfile
->directive_result
.type
= CPP_PADDING
;
1831 destringize_and_run (pfile
, &string
->val
.str
);
1834 cpp_error (pfile
, CPP_DL_ERROR
,
1835 "_Pragma takes a parenthesized string literal");
1839 /* Handle #ifdef. */
1841 do_ifdef (cpp_reader
*pfile
)
1845 if (! pfile
->state
.skipping
)
1847 cpp_hashnode
*node
= lex_macro_node (pfile
, false);
1851 /* Do not treat conditional macros as being defined. This is due to
1852 the powerpc and spu ports using conditional macros for 'vector',
1853 'bool', and 'pixel' to act as conditional keywords. This messes
1854 up tests like #ifndef bool. */
1855 skip
= (node
->type
!= NT_MACRO
1856 || ((node
->flags
& NODE_CONDITIONAL
) != 0));
1857 _cpp_mark_macro_used (node
);
1858 if (!(node
->flags
& NODE_USED
))
1860 node
->flags
|= NODE_USED
;
1861 if (node
->type
== NT_MACRO
)
1863 if ((node
->flags
& NODE_BUILTIN
)
1864 && pfile
->cb
.user_builtin_macro
)
1865 pfile
->cb
.user_builtin_macro (pfile
, node
);
1866 if (pfile
->cb
.used_define
)
1867 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1871 if (pfile
->cb
.used_undef
)
1872 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1876 pfile
->cb
.used (pfile
, pfile
->directive_line
, node
);
1877 check_eol (pfile
, false);
1881 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1884 /* Handle #ifndef. */
1886 do_ifndef (cpp_reader
*pfile
)
1889 cpp_hashnode
*node
= 0;
1891 if (! pfile
->state
.skipping
)
1893 node
= lex_macro_node (pfile
, false);
1897 /* Do not treat conditional macros as being defined. This is due to
1898 the powerpc and spu ports using conditional macros for 'vector',
1899 'bool', and 'pixel' to act as conditional keywords. This messes
1900 up tests like #ifndef bool. */
1901 skip
= (node
->type
== NT_MACRO
1902 && ((node
->flags
& NODE_CONDITIONAL
) == 0));
1903 _cpp_mark_macro_used (node
);
1904 if (!(node
->flags
& NODE_USED
))
1906 node
->flags
|= NODE_USED
;
1907 if (node
->type
== NT_MACRO
)
1909 if ((node
->flags
& NODE_BUILTIN
)
1910 && pfile
->cb
.user_builtin_macro
)
1911 pfile
->cb
.user_builtin_macro (pfile
, node
);
1912 if (pfile
->cb
.used_define
)
1913 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1917 if (pfile
->cb
.used_undef
)
1918 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1922 pfile
->cb
.used (pfile
, pfile
->directive_line
, node
);
1923 check_eol (pfile
, false);
1927 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1930 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1931 pfile->mi_ind_cmacro so we can handle multiple-include
1932 optimizations. If macro expansion occurs in the expression, we
1933 cannot treat it as a controlling conditional, since the expansion
1934 could change in the future. That is handled by cpp_get_token. */
1936 do_if (cpp_reader
*pfile
)
1940 if (! pfile
->state
.skipping
)
1941 skip
= _cpp_parse_expr (pfile
, true) == false;
1943 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1946 /* Flip skipping state if appropriate and continue without changing
1947 if_stack; this is so that the error message for missing #endif's
1948 etc. will point to the original #if. */
1950 do_else (cpp_reader
*pfile
)
1952 cpp_buffer
*buffer
= pfile
->buffer
;
1953 struct if_stack
*ifs
= buffer
->if_stack
;
1956 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1959 if (ifs
->type
== T_ELSE
)
1961 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1962 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1963 "the conditional began here");
1967 /* Skip any future (erroneous) #elses or #elifs. */
1968 pfile
->state
.skipping
= ifs
->skip_elses
;
1969 ifs
->skip_elses
= true;
1971 /* Invalidate any controlling macro. */
1974 /* Only check EOL if was not originally skipping. */
1975 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1976 check_eol (pfile
, false);
1980 /* Handle a #elif directive by not changing if_stack either. See the
1981 comment above do_else. */
1983 do_elif (cpp_reader
*pfile
)
1985 cpp_buffer
*buffer
= pfile
->buffer
;
1986 struct if_stack
*ifs
= buffer
->if_stack
;
1989 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1992 if (ifs
->type
== T_ELSE
)
1994 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1995 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1996 "the conditional began here");
2000 if (! ifs
->was_skipping
)
2003 /* The standard mandates that the expression be parsed even
2004 if we are skipping elses at this point -- the lexical
2005 restrictions on #elif only apply to skipped groups, but
2006 this group is not being skipped. Temporarily set
2007 skipping to false to get lexer warnings. */
2008 pfile
->state
.skipping
= 0;
2009 value
= _cpp_parse_expr (pfile
, false);
2010 if (ifs
->skip_elses
)
2011 pfile
->state
.skipping
= 1;
2014 pfile
->state
.skipping
= ! value
;
2015 ifs
->skip_elses
= value
;
2019 /* Invalidate any controlling macro. */
2024 /* #endif pops the if stack and resets pfile->state.skipping. */
2026 do_endif (cpp_reader
*pfile
)
2028 cpp_buffer
*buffer
= pfile
->buffer
;
2029 struct if_stack
*ifs
= buffer
->if_stack
;
2032 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
2035 /* Only check EOL if was not originally skipping. */
2036 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
2037 check_eol (pfile
, false);
2039 /* If potential control macro, we go back outside again. */
2040 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
2042 pfile
->mi_valid
= true;
2043 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
2046 buffer
->if_stack
= ifs
->next
;
2047 pfile
->state
.skipping
= ifs
->was_skipping
;
2048 obstack_free (&pfile
->buffer_ob
, ifs
);
2052 /* Push an if_stack entry for a preprocessor conditional, and set
2053 pfile->state.skipping to SKIP. If TYPE indicates the conditional
2054 is #if or #ifndef, CMACRO is a potentially controlling macro, and
2055 we need to check here that we are at the top of the file. */
2057 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
2058 const cpp_hashnode
*cmacro
)
2060 struct if_stack
*ifs
;
2061 cpp_buffer
*buffer
= pfile
->buffer
;
2063 ifs
= XOBNEW (&pfile
->buffer_ob
, struct if_stack
);
2064 ifs
->line
= pfile
->directive_line
;
2065 ifs
->next
= buffer
->if_stack
;
2066 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
2067 ifs
->was_skipping
= pfile
->state
.skipping
;
2069 /* This condition is effectively a test for top-of-file. */
2070 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
2071 ifs
->mi_cmacro
= cmacro
;
2075 pfile
->state
.skipping
= skip
;
2076 buffer
->if_stack
= ifs
;
2079 /* Read the tokens of the answer into the macro pool, in a directive
2080 of type TYPE. Only commit the memory if we intend it as permanent
2081 storage, i.e. the #assert case. Returns 0 on success, and sets
2082 ANSWERP to point to the answer. PRED_LOC is the location of the
2085 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
,
2086 source_location pred_loc
)
2088 const cpp_token
*paren
;
2089 struct answer
*answer
;
2090 unsigned int acount
;
2092 /* In a conditional, it is legal to not have an open paren. We
2093 should save the following token in this case. */
2094 paren
= cpp_get_token (pfile
);
2096 /* If not a paren, see if we're OK. */
2097 if (paren
->type
!= CPP_OPEN_PAREN
)
2099 /* In a conditional no answer is a test for any answer. It
2100 could be followed by any token. */
2103 _cpp_backup_tokens (pfile
, 1);
2107 /* #unassert with no answer is valid - it removes all answers. */
2108 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
2111 cpp_error_with_line (pfile
, CPP_DL_ERROR
, pred_loc
, 0,
2112 "missing '(' after predicate");
2116 for (acount
= 0;; acount
++)
2119 const cpp_token
*token
= cpp_get_token (pfile
);
2122 if (token
->type
== CPP_CLOSE_PAREN
)
2125 if (token
->type
== CPP_EOF
)
2127 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
2131 /* struct answer includes the space for one token. */
2132 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
2134 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
2135 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
2137 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
2140 /* Drop whitespace at start, for answer equivalence purposes. */
2142 dest
->flags
&= ~PREV_WHITE
;
2147 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
2151 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
2152 answer
->count
= acount
;
2153 answer
->next
= NULL
;
2159 /* Parses an assertion directive of type TYPE, returning a pointer to
2160 the hash node of the predicate, or 0 on error. If an answer was
2161 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
2162 static cpp_hashnode
*
2163 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
2165 cpp_hashnode
*result
= 0;
2166 const cpp_token
*predicate
;
2168 /* We don't expand predicates or answers. */
2169 pfile
->state
.prevent_expansion
++;
2172 predicate
= cpp_get_token (pfile
);
2173 if (predicate
->type
== CPP_EOF
)
2174 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
2175 else if (predicate
->type
!= CPP_NAME
)
2176 cpp_error_with_line (pfile
, CPP_DL_ERROR
, predicate
->src_loc
, 0,
2177 "predicate must be an identifier");
2178 else if (parse_answer (pfile
, answerp
, type
, predicate
->src_loc
) == 0)
2180 unsigned int len
= NODE_LEN (predicate
->val
.node
.node
);
2181 unsigned char *sym
= (unsigned char *) alloca (len
+ 1);
2183 /* Prefix '#' to get it out of macro namespace. */
2185 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
.node
), len
);
2186 result
= cpp_lookup (pfile
, sym
, len
+ 1);
2189 pfile
->state
.prevent_expansion
--;
2193 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2194 or a pointer to NULL if the answer is not in the chain. */
2195 static struct answer
**
2196 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
2199 struct answer
**result
;
2201 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
2203 struct answer
*answer
= *result
;
2205 if (answer
->count
== candidate
->count
)
2207 for (i
= 0; i
< answer
->count
; i
++)
2208 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
2211 if (i
== answer
->count
)
2219 /* Test an assertion within a preprocessor conditional. Returns
2220 nonzero on failure, zero on success. On success, the result of
2221 the test is written into VALUE, otherwise the value 0. */
2223 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
2225 struct answer
*answer
;
2228 node
= parse_assertion (pfile
, &answer
, T_IF
);
2230 /* For recovery, an erroneous assertion expression is handled as a
2231 failing assertion. */
2235 *value
= (node
->type
== NT_ASSERTION
&&
2236 (answer
== 0 || *find_answer (node
, answer
) != 0));
2237 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
2238 _cpp_backup_tokens (pfile
, 1);
2240 /* We don't commit the memory for the answer - it's temporary only. */
2244 /* Handle #assert. */
2246 do_assert (cpp_reader
*pfile
)
2248 struct answer
*new_answer
;
2251 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
2256 /* Place the new answer in the answer list. First check there
2257 is not a duplicate. */
2258 new_answer
->next
= 0;
2259 if (node
->type
== NT_ASSERTION
)
2261 if (*find_answer (node
, new_answer
))
2263 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
2264 NODE_NAME (node
) + 1);
2267 new_answer
->next
= node
->value
.answers
;
2270 answer_size
= sizeof (struct answer
) + ((new_answer
->count
- 1)
2271 * sizeof (cpp_token
));
2272 /* Commit or allocate storage for the object. */
2273 if (pfile
->hash_table
->alloc_subobject
)
2275 struct answer
*temp_answer
= new_answer
;
2276 new_answer
= (struct answer
*) pfile
->hash_table
->alloc_subobject
2278 memcpy (new_answer
, temp_answer
, answer_size
);
2281 BUFF_FRONT (pfile
->a_buff
) += answer_size
;
2283 node
->type
= NT_ASSERTION
;
2284 node
->value
.answers
= new_answer
;
2285 check_eol (pfile
, false);
2289 /* Handle #unassert. */
2291 do_unassert (cpp_reader
*pfile
)
2294 struct answer
*answer
;
2296 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
2297 /* It isn't an error to #unassert something that isn't asserted. */
2298 if (node
&& node
->type
== NT_ASSERTION
)
2302 struct answer
**p
= find_answer (node
, answer
), *temp
;
2304 /* Remove the answer from the list. */
2309 /* Did we free the last answer? */
2310 if (node
->value
.answers
== 0)
2311 node
->type
= NT_VOID
;
2313 check_eol (pfile
, false);
2316 _cpp_free_definition (node
);
2319 /* We don't commit the memory for the answer - it's temporary only. */
2322 /* These are for -D, -U, -A. */
2324 /* Process the string STR as if it appeared as the body of a #define.
2325 If STR is just an identifier, define it with value 1.
2326 If STR has anything after the identifier, then it should
2327 be identifier=definition. */
2329 cpp_define (cpp_reader
*pfile
, const char *str
)
2335 /* Copy the entire option so we can modify it.
2336 Change the first "=" in the string to a space. If there is none,
2337 tack " 1" on the end. */
2339 count
= strlen (str
);
2340 buf
= (char *) alloca (count
+ 3);
2341 memcpy (buf
, str
, count
);
2343 p
= strchr (str
, '=');
2353 run_directive (pfile
, T_DEFINE
, buf
, count
);
2357 /* Use to build macros to be run through cpp_define() as
2359 Example: cpp_define_formatted (pfile, "MACRO=%d", value); */
2362 cpp_define_formatted (cpp_reader
*pfile
, const char *fmt
, ...)
2368 vasprintf (&ptr
, fmt
, ap
);
2371 cpp_define (pfile
, ptr
);
2376 /* Slight variant of the above for use by initialize_builtins. */
2378 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
2380 size_t len
= strlen (str
);
2381 char *buf
= (char *) alloca (len
+ 1);
2382 memcpy (buf
, str
, len
);
2384 run_directive (pfile
, T_DEFINE
, buf
, len
);
2387 /* Process MACRO as if it appeared as the body of an #undef. */
2389 cpp_undef (cpp_reader
*pfile
, const char *macro
)
2391 size_t len
= strlen (macro
);
2392 char *buf
= (char *) alloca (len
+ 1);
2393 memcpy (buf
, macro
, len
);
2395 run_directive (pfile
, T_UNDEF
, buf
, len
);
2398 /* Replace a previous definition DEF of the macro STR. If DEF is NULL,
2399 or first element is zero, then the macro should be undefined. */
2401 cpp_pop_definition (cpp_reader
*pfile
, struct def_pragma_macro
*c
)
2403 cpp_hashnode
*node
= _cpp_lex_identifier (pfile
, c
->name
);
2407 if (pfile
->cb
.before_define
)
2408 pfile
->cb
.before_define (pfile
);
2410 if (node
->type
== NT_MACRO
)
2412 if (pfile
->cb
.undef
)
2413 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
2414 if (CPP_OPTION (pfile
, warn_unused_macros
))
2415 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
2417 if (node
->type
!= NT_VOID
)
2418 _cpp_free_definition (node
);
2425 cpp_hashnode
*h
= NULL
;
2428 namelen
= ustrcspn (c
->definition
, "( \n");
2429 h
= cpp_lookup (pfile
, c
->definition
, namelen
);
2430 dn
= c
->definition
+ namelen
;
2433 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
|NODE_USED
);
2434 nbuf
= cpp_push_buffer (pfile
, dn
, ustrchr (dn
, '\n') - dn
, true);
2437 _cpp_clean_line (pfile
);
2439 if (!_cpp_create_definition (pfile
, h
))
2441 _cpp_pop_buffer (pfile
);
2445 h
->value
.macro
->line
= c
->line
;
2446 h
->value
.macro
->syshdr
= c
->syshdr
;
2447 h
->value
.macro
->used
= c
->used
;
2451 /* Process the string STR as if it appeared as the body of a #assert. */
2453 cpp_assert (cpp_reader
*pfile
, const char *str
)
2455 handle_assertion (pfile
, str
, T_ASSERT
);
2458 /* Process STR as if it appeared as the body of an #unassert. */
2460 cpp_unassert (cpp_reader
*pfile
, const char *str
)
2462 handle_assertion (pfile
, str
, T_UNASSERT
);
2465 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2467 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
2469 size_t count
= strlen (str
);
2470 const char *p
= strchr (str
, '=');
2472 /* Copy the entire option so we can modify it. Change the first
2473 "=" in the string to a '(', and tack a ')' on the end. */
2474 char *buf
= (char *) alloca (count
+ 2);
2476 memcpy (buf
, str
, count
);
2485 run_directive (pfile
, type
, str
, count
);
2488 /* The options structure. */
2490 cpp_get_options (cpp_reader
*pfile
)
2492 return &pfile
->opts
;
2495 /* The callbacks structure. */
2497 cpp_get_callbacks (cpp_reader
*pfile
)
2502 /* Copy the given callbacks structure to our own. */
2504 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
2509 /* The dependencies structure. (Creates one if it hasn't already been.) */
2511 cpp_get_deps (cpp_reader
*pfile
)
2514 pfile
->deps
= deps_init ();
2518 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2519 doesn't fail. It does not generate a file change call back; that
2520 is the responsibility of the caller. */
2522 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
2525 cpp_buffer
*new_buffer
= XOBNEW (&pfile
->buffer_ob
, cpp_buffer
);
2527 /* Clears, amongst other things, if_stack and mi_cmacro. */
2528 memset (new_buffer
, 0, sizeof (cpp_buffer
));
2530 new_buffer
->next_line
= new_buffer
->buf
= buffer
;
2531 new_buffer
->rlimit
= buffer
+ len
;
2532 new_buffer
->from_stage3
= from_stage3
;
2533 new_buffer
->prev
= pfile
->buffer
;
2534 new_buffer
->need_line
= true;
2536 pfile
->buffer
= new_buffer
;
2541 /* Pops a single buffer, with a file change call-back if appropriate.
2542 Then pushes the next -include file, if any remain. */
2544 _cpp_pop_buffer (cpp_reader
*pfile
)
2546 cpp_buffer
*buffer
= pfile
->buffer
;
2547 struct _cpp_file
*inc
= buffer
->file
;
2548 struct if_stack
*ifs
;
2550 /* Walk back up the conditional stack till we reach its level at
2551 entry to this file, issuing error messages. */
2552 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
2553 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2554 "unterminated #%s", dtable
[ifs
->type
].name
);
2556 /* In case of a missing #endif. */
2557 pfile
->state
.skipping
= 0;
2559 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2560 pfile
->buffer
= buffer
->prev
;
2562 free (buffer
->notes
);
2564 /* Free the buffer object now; we may want to push a new buffer
2565 in _cpp_push_next_include_file. */
2566 obstack_free (&pfile
->buffer_ob
, buffer
);
2570 _cpp_pop_file_buffer (pfile
, inc
);
2572 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
2576 /* Enter all recognized directives in the hash table. */
2578 _cpp_init_directives (cpp_reader
*pfile
)
2583 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
2585 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
2586 node
->is_directive
= 1;
2587 node
->directive_index
= i
;