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 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 2, 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; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
30 /* Stack of conditionals currently in progress
31 (including both successful and failing conditionals). */
34 struct if_stack
*next
;
35 unsigned int 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)
79 /* Defines one #-directive, including how to handle it. */
80 typedef void (*directive_handler
) (cpp_reader
*);
81 typedef struct directive directive
;
84 directive_handler handler
; /* Function to handle directive. */
85 const uchar
*name
; /* Name of directive. */
86 unsigned short length
; /* Length of name. */
87 unsigned char origin
; /* Origin of directive. */
88 unsigned char flags
; /* Flags describing this directive. */
91 /* Forward declarations. */
93 static void skip_rest_of_line (cpp_reader
*);
94 static void check_eol (cpp_reader
*);
95 static void start_directive (cpp_reader
*);
96 static void prepare_directive_trad (cpp_reader
*);
97 static void end_directive (cpp_reader
*, int);
98 static void directive_diagnostics (cpp_reader
*, const directive
*, int);
99 static void run_directive (cpp_reader
*, int, const char *, size_t);
100 static char *glue_header_name (cpp_reader
*);
101 static const char *parse_include (cpp_reader
*, int *, const cpp_token
***);
102 static void push_conditional (cpp_reader
*, int, int, const cpp_hashnode
*);
103 static unsigned int read_flag (cpp_reader
*, unsigned int);
104 static int strtoul_for_line (const uchar
*, unsigned int, unsigned long *);
105 static void do_diagnostic (cpp_reader
*, 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
*,
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_linemarker (cpp_reader
*);
120 static const cpp_token
*get_token_no_padding (cpp_reader
*);
121 static const cpp_token
*get__Pragma_string (cpp_reader
*);
122 static void destringize_and_run (cpp_reader
*, const cpp_string
*);
123 static int parse_answer (cpp_reader
*, struct answer
**, int);
124 static cpp_hashnode
*parse_assertion (cpp_reader
*, struct answer
**, int);
125 static struct answer
** find_answer (cpp_hashnode
*, const struct answer
*);
126 static void handle_assertion (cpp_reader
*, const char *, int);
128 /* This is the table of directive handlers. It is ordered by
129 frequency of occurrence; the numbers at the end are directive
130 counts from all the source code I have lying around (egcs and libc
131 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
132 pcmcia-cs-3.0.9). This is no longer important as directive lookup
133 is now O(1). All extensions other than #warning and #include_next
134 are deprecated. The name is where the extension appears to have
137 #define DIRECTIVE_TABLE \
138 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
139 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
140 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
141 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
142 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
143 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
144 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
145 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
146 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
147 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
148 D(error, T_ERROR, STDC89, 0) /* 475 */ \
149 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
150 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
151 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
152 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
153 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
154 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
155 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
156 D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */
158 /* #sccs is synonymous with #ident. */
159 #define do_sccs do_ident
161 /* Use the table to generate a series of prototypes, an enum for the
162 directive names, and an array of directive handlers. */
164 #define D(name, t, o, f) static void do_##name (cpp_reader *);
168 #define D(n, tag, o, f) tag,
176 #define D(name, t, origin, flags) \
177 { do_##name, (const uchar *) #name, \
178 sizeof #name - 1, origin, flags },
179 static const directive dtable
[] =
184 #undef DIRECTIVE_TABLE
186 /* Wrapper struct directive for linemarkers.
187 The origin is more or less true - the original K+R cpp
188 did use this notation in its preprocessed output. */
189 static const directive linemarker_dir
=
191 do_linemarker
, U
"#", 1, KANDR
, IN_I
194 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
196 /* Skip any remaining tokens in a directive. */
198 skip_rest_of_line (cpp_reader
*pfile
)
200 /* Discard all stacked contexts. */
201 while (pfile
->context
->prev
)
202 _cpp_pop_context (pfile
);
204 /* Sweep up all tokens remaining on the line. */
206 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
210 /* Ensure there are no stray tokens at the end of a directive. */
212 check_eol (cpp_reader
*pfile
)
214 if (! SEEN_EOL () && _cpp_lex_token (pfile
)->type
!= CPP_EOF
)
215 cpp_error (pfile
, CPP_DL_PEDWARN
, "extra tokens at end of #%s directive",
216 pfile
->directive
->name
);
219 /* Ensure there are no stray tokens other than comments at the end of
220 a directive, and gather the comments. */
221 static const cpp_token
**
222 check_eol_return_comments (cpp_reader
*pfile
)
226 const cpp_token
**buf
;
228 buf
= XNEWVEC (const cpp_token
*, capacity
);
234 const cpp_token
*tok
;
236 tok
= _cpp_lex_token (pfile
);
237 if (tok
->type
== CPP_EOF
)
239 if (tok
->type
!= CPP_COMMENT
)
240 cpp_error (pfile
, CPP_DL_PEDWARN
,
241 "extra tokens at end of #%s directive",
242 pfile
->directive
->name
);
245 if (c
+ 1 >= capacity
)
248 buf
= XRESIZEVEC (const cpp_token
*, buf
, capacity
);
259 /* Called when entering a directive, _Pragma or command-line directive. */
261 start_directive (cpp_reader
*pfile
)
263 /* Setup in-directive state. */
264 pfile
->state
.in_directive
= 1;
265 pfile
->state
.save_comments
= 0;
266 pfile
->directive_result
.type
= CPP_PADDING
;
268 /* Some handlers need the position of the # for diagnostics. */
269 pfile
->directive_line
= pfile
->line_table
->highest_line
;
272 /* Called when leaving a directive, _Pragma or command-line directive. */
274 end_directive (cpp_reader
*pfile
, int skip_line
)
276 if (pfile
->state
.in_deferred_pragma
)
278 else if (CPP_OPTION (pfile
, traditional
))
280 /* Revert change of prepare_directive_trad. */
281 pfile
->state
.prevent_expansion
--;
283 if (pfile
->directive
!= &dtable
[T_DEFINE
])
284 _cpp_remove_overlay (pfile
);
286 /* We don't skip for an assembler #. */
289 skip_rest_of_line (pfile
);
290 if (!pfile
->keep_tokens
)
292 pfile
->cur_run
= &pfile
->base_run
;
293 pfile
->cur_token
= pfile
->base_run
.base
;
298 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
299 pfile
->state
.in_directive
= 0;
300 pfile
->state
.in_expression
= 0;
301 pfile
->state
.angled_headers
= 0;
302 pfile
->directive
= 0;
305 /* Prepare to handle the directive in pfile->directive. */
307 prepare_directive_trad (cpp_reader
*pfile
)
309 if (pfile
->directive
!= &dtable
[T_DEFINE
])
311 bool no_expand
= (pfile
->directive
312 && ! (pfile
->directive
->flags
& EXPAND
));
313 bool was_skipping
= pfile
->state
.skipping
;
315 pfile
->state
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
316 || pfile
->directive
== &dtable
[T_ELIF
]);
317 if (pfile
->state
.in_expression
)
318 pfile
->state
.skipping
= false;
321 pfile
->state
.prevent_expansion
++;
322 _cpp_scan_out_logical_line (pfile
, NULL
);
324 pfile
->state
.prevent_expansion
--;
326 pfile
->state
.skipping
= was_skipping
;
327 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
328 pfile
->out
.cur
- pfile
->out
.base
);
331 /* Stop ISO C from expanding anything. */
332 pfile
->state
.prevent_expansion
++;
335 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
336 the '#' was indented. */
338 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
340 /* Issue -pedantic warnings for extensions. */
341 if (CPP_PEDANTIC (pfile
)
342 && ! pfile
->state
.skipping
343 && dir
->origin
== EXTENSION
)
344 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
346 /* Traditionally, a directive is ignored unless its # is in
347 column 1. Therefore in code intended to work with K+R
348 compilers, directives added by C89 must have their #
349 indented, and directives present in traditional C must not.
350 This is true even of directives in skipped conditional
351 blocks. #elif cannot be used at all. */
352 if (CPP_WTRADITIONAL (pfile
))
354 if (dir
== &dtable
[T_ELIF
])
355 cpp_error (pfile
, CPP_DL_WARNING
,
356 "suggest not using #elif in traditional C");
357 else if (indented
&& dir
->origin
== KANDR
)
358 cpp_error (pfile
, CPP_DL_WARNING
,
359 "traditional C ignores #%s with the # indented",
361 else if (!indented
&& dir
->origin
!= KANDR
)
362 cpp_error (pfile
, CPP_DL_WARNING
,
363 "suggest hiding #%s from traditional C with an indented #",
368 /* Check if we have a known directive. INDENTED is nonzero if the
369 '#' of the directive was indented. This function is in this file
370 to save unnecessarily exporting dtable etc. to lex.c. Returns
371 nonzero if the line of tokens has been handled, zero if we should
372 continue processing the line. */
374 _cpp_handle_directive (cpp_reader
*pfile
, int indented
)
376 const directive
*dir
= 0;
377 const cpp_token
*dname
;
378 bool was_parsing_args
= pfile
->state
.parsing_args
;
379 bool was_discarding_output
= pfile
->state
.discarding_output
;
382 if (was_discarding_output
)
383 pfile
->state
.prevent_expansion
= 0;
385 if (was_parsing_args
)
387 if (CPP_OPTION (pfile
, pedantic
))
388 cpp_error (pfile
, CPP_DL_PEDWARN
,
389 "embedding a directive within macro arguments is not portable");
390 pfile
->state
.parsing_args
= 0;
391 pfile
->state
.prevent_expansion
= 0;
393 start_directive (pfile
);
394 dname
= _cpp_lex_token (pfile
);
396 if (dname
->type
== CPP_NAME
)
398 if (dname
->val
.node
->is_directive
)
399 dir
= &dtable
[dname
->val
.node
->directive_index
];
401 /* We do not recognize the # followed by a number extension in
403 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
405 dir
= &linemarker_dir
;
406 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
407 && ! pfile
->state
.skipping
)
408 cpp_error (pfile
, CPP_DL_PEDWARN
,
409 "style of line directive is a GCC extension");
414 /* If we have a directive that is not an opening conditional,
415 invalidate any control macro. */
416 if (! (dir
->flags
& IF_COND
))
417 pfile
->mi_valid
= false;
419 /* Kluge alert. In order to be sure that code like this
424 does not cause '#define foo bar' to get executed when
425 compiled with -save-temps, we recognize directives in
426 -fpreprocessed mode only if the # is in column 1. macro.c
427 puts a space in front of any '#' at the start of a macro.
429 We exclude the -fdirectives-only case because macro expansion
430 has not been performed yet, and block comments can cause spaces
431 to preceed the directive. */
432 if (CPP_OPTION (pfile
, preprocessed
)
433 && !CPP_OPTION (pfile
, directives_only
)
434 && (indented
|| !(dir
->flags
& IN_I
)))
441 /* In failed conditional groups, all non-conditional
442 directives are ignored. Before doing that, whether
443 skipping or not, we should lex angle-bracketed headers
444 correctly, and maybe output some diagnostics. */
445 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
446 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
447 if (! CPP_OPTION (pfile
, preprocessed
))
448 directive_diagnostics (pfile
, dir
, indented
);
449 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
453 else if (dname
->type
== CPP_EOF
)
454 ; /* CPP_EOF is the "null directive". */
457 /* An unknown directive. Don't complain about it in assembly
458 source: we don't know where the comments are, and # may
459 introduce assembler pseudo-ops. Don't complain about invalid
460 directives in skipped conditional groups (6.10 p4). */
461 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
463 else if (!pfile
->state
.skipping
)
464 cpp_error (pfile
, CPP_DL_ERROR
, "invalid preprocessing directive #%s",
465 cpp_token_as_text (pfile
, dname
));
468 pfile
->directive
= dir
;
469 if (CPP_OPTION (pfile
, traditional
))
470 prepare_directive_trad (pfile
);
473 pfile
->directive
->handler (pfile
);
475 _cpp_backup_tokens (pfile
, 1);
477 end_directive (pfile
, skip
);
478 if (was_parsing_args
)
480 /* Restore state when within macro args. */
481 pfile
->state
.parsing_args
= 2;
482 pfile
->state
.prevent_expansion
= 1;
484 if (was_discarding_output
)
485 pfile
->state
.prevent_expansion
= 1;
489 /* Directive handler wrapper used by the command line option
490 processor. BUF is \n terminated. */
492 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
494 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
495 /* from_stage3 */ true);
496 start_directive (pfile
);
498 /* This is a short-term fix to prevent a leading '#' being
499 interpreted as a directive. */
500 _cpp_clean_line (pfile
);
502 pfile
->directive
= &dtable
[dir_no
];
503 if (CPP_OPTION (pfile
, traditional
))
504 prepare_directive_trad (pfile
);
505 pfile
->directive
->handler (pfile
);
506 end_directive (pfile
, 1);
507 _cpp_pop_buffer (pfile
);
510 /* Checks for validity the macro name in #define, #undef, #ifdef and
511 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
512 processing a #define or #undefine directive, and false
514 static cpp_hashnode
*
515 lex_macro_node (cpp_reader
*pfile
, bool is_def_or_undef
)
517 const cpp_token
*token
= _cpp_lex_token (pfile
);
519 /* The token immediately after #define must be an identifier. That
520 identifier may not be "defined", per C99 6.10.8p4.
521 In C++, it may not be any of the "named operators" either,
522 per C++98 [lex.digraph], [lex.key].
523 Finally, the identifier may not have been poisoned. (In that case
524 the lexer has issued the error message for us.) */
526 if (token
->type
== CPP_NAME
)
528 cpp_hashnode
*node
= token
->val
.node
;
530 if (is_def_or_undef
&& node
== pfile
->spec_nodes
.n_defined
)
531 cpp_error (pfile
, CPP_DL_ERROR
,
532 "\"defined\" cannot be used as a macro name");
533 else if (! (node
->flags
& NODE_POISONED
))
536 else if (token
->flags
& NAMED_OP
)
537 cpp_error (pfile
, CPP_DL_ERROR
,
538 "\"%s\" cannot be used as a macro name as it is an operator in C++",
539 NODE_NAME (token
->val
.node
));
540 else if (token
->type
== CPP_EOF
)
541 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
542 pfile
->directive
->name
);
544 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
549 /* Process a #define directive. Most work is done in macro.c. */
551 do_define (cpp_reader
*pfile
)
553 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
557 /* If we have been requested to expand comments into macros,
558 then re-enable saving of comments. */
559 pfile
->state
.save_comments
=
560 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
562 if (_cpp_create_definition (pfile
, node
))
563 if (pfile
->cb
.define
)
564 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
568 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
570 do_undef (cpp_reader
*pfile
)
572 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
577 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
579 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
580 identifier is not currently defined as a macro name. */
581 if (node
->type
== NT_MACRO
)
583 if (node
->flags
& NODE_WARN
)
584 cpp_error (pfile
, CPP_DL_WARNING
,
585 "undefining \"%s\"", NODE_NAME (node
));
587 if (CPP_OPTION (pfile
, warn_unused_macros
))
588 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
590 _cpp_free_definition (node
);
597 /* Undefine a single macro/assertion/whatever. */
600 undefine_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*h
,
601 void *data_p ATTRIBUTE_UNUSED
)
603 /* Body of _cpp_free_definition inlined here for speed.
604 Macros and assertions no longer have anything to free. */
606 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
);
610 /* Undefine all macros and assertions. */
613 cpp_undef_all (cpp_reader
*pfile
)
615 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
619 /* Helper routine used by parse_include. Reinterpret the current line
620 as an h-char-sequence (< ... >); we are looking at the first token
621 after the <. Returns a malloced filename. */
623 glue_header_name (cpp_reader
*pfile
)
625 const cpp_token
*token
;
627 size_t len
, total_len
= 0, capacity
= 1024;
629 /* To avoid lexed tokens overwriting our glued name, we can only
630 allocate from the string pool once we've lexed everything. */
631 buffer
= XNEWVEC (char, capacity
);
634 token
= get_token_no_padding (pfile
);
636 if (token
->type
== CPP_GREATER
)
638 if (token
->type
== CPP_EOF
)
640 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
644 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
645 if (total_len
+ len
> capacity
)
647 capacity
= (capacity
+ len
) * 2;
648 buffer
= XRESIZEVEC (char, buffer
, capacity
);
651 if (token
->flags
& PREV_WHITE
)
652 buffer
[total_len
++] = ' ';
654 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
],
659 buffer
[total_len
] = '\0';
663 /* Returns the file name of #include, #include_next, #import and
664 #pragma dependency. The string is malloced and the caller should
665 free it. Returns NULL on error. */
667 parse_include (cpp_reader
*pfile
, int *pangle_brackets
,
668 const cpp_token
***buf
)
671 const cpp_token
*header
;
673 /* Allow macro expansion. */
674 header
= get_token_no_padding (pfile
);
675 if (header
->type
== CPP_STRING
|| header
->type
== CPP_HEADER_NAME
)
677 fname
= XNEWVEC (char, header
->val
.str
.len
- 1);
678 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
679 fname
[header
->val
.str
.len
- 2] = '\0';
680 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
682 else if (header
->type
== CPP_LESS
)
684 fname
= glue_header_name (pfile
);
685 *pangle_brackets
= 1;
689 const unsigned char *dir
;
691 if (pfile
->directive
== &dtable
[T_PRAGMA
])
692 dir
= U
"pragma dependency";
694 dir
= pfile
->directive
->name
;
695 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
701 if (buf
== NULL
|| CPP_OPTION (pfile
, discard_comments
))
705 /* If we are not discarding comments, then gather them while
706 doing the eol check. */
707 *buf
= check_eol_return_comments (pfile
);
713 /* Handle #include, #include_next and #import. */
715 do_include_common (cpp_reader
*pfile
, enum include_type type
)
719 const cpp_token
**buf
= NULL
;
721 /* Re-enable saving of comments if requested, so that the include
722 callback can dump comments which follow #include. */
723 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
725 fname
= parse_include (pfile
, &angle_brackets
, &buf
);
735 cpp_error (pfile
, CPP_DL_ERROR
, "empty filename in #%s",
736 pfile
->directive
->name
);
743 /* Prevent #include recursion. */
744 if (pfile
->line_table
->depth
>= CPP_STACK_MAX
)
745 cpp_error (pfile
, CPP_DL_ERROR
, "#include nested too deeply");
748 /* Get out of macro context, if we are. */
749 skip_rest_of_line (pfile
);
751 if (pfile
->cb
.include
)
752 pfile
->cb
.include (pfile
, pfile
->directive_line
,
753 pfile
->directive
->name
, fname
, angle_brackets
,
756 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
);
765 do_include (cpp_reader
*pfile
)
767 do_include_common (pfile
, IT_INCLUDE
);
771 do_import (cpp_reader
*pfile
)
773 do_include_common (pfile
, IT_IMPORT
);
777 do_include_next (cpp_reader
*pfile
)
779 enum include_type type
= IT_INCLUDE_NEXT
;
781 /* If this is the primary source file, warn and use the normal
783 if (cpp_in_primary_file (pfile
))
785 cpp_error (pfile
, CPP_DL_WARNING
,
786 "#include_next in primary source file");
789 do_include_common (pfile
, type
);
792 /* Subroutine of do_linemarker. Read possible flags after file name.
793 LAST is the last flag seen; 0 if this is the first flag. Return the
794 flag if it is valid, 0 at the end of the directive. Otherwise
797 read_flag (cpp_reader
*pfile
, unsigned int last
)
799 const cpp_token
*token
= _cpp_lex_token (pfile
);
801 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
803 unsigned int flag
= token
->val
.str
.text
[0] - '0';
805 if (flag
> last
&& flag
<= 4
806 && (flag
!= 4 || last
== 3)
807 && (flag
!= 2 || last
== 0))
811 if (token
->type
!= CPP_EOF
)
812 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
813 cpp_token_as_text (pfile
, token
));
817 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
818 of length LEN, to binary; store it in NUMP, and return 0 if the
819 number was well-formed, 1 if not. Temporary, hopefully. */
821 strtoul_for_line (const uchar
*str
, unsigned int len
, long unsigned int *nump
)
823 unsigned long reg
= 0;
837 /* Interpret #line command.
838 Note that the filename string (if any) is a true string constant
839 (escapes are interpreted), unlike in #line. */
841 do_line (cpp_reader
*pfile
)
843 const struct line_maps
*line_table
= pfile
->line_table
;
844 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
846 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
849 unsigned char map_sysp
= map
->sysp
;
850 const cpp_token
*token
;
851 const char *new_file
= map
->to_file
;
852 unsigned long new_lineno
;
854 /* C99 raised the minimum limit on #line numbers. */
855 unsigned int cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
857 /* #line commands expand macros. */
858 token
= cpp_get_token (pfile
);
859 if (token
->type
!= CPP_NUMBER
860 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
863 cpp_error (pfile
, CPP_DL_ERROR
,
864 "\"%s\" after #line is not a positive integer",
865 cpp_token_as_text (pfile
, token
));
869 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
870 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
872 token
= cpp_get_token (pfile
);
873 if (token
->type
== CPP_STRING
)
875 cpp_string s
= { 0, 0 };
876 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, 1,
878 new_file
= (const char *)s
.text
;
881 else if (token
->type
!= CPP_EOF
)
883 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
884 cpp_token_as_text (pfile
, token
));
888 skip_rest_of_line (pfile
);
889 _cpp_do_file_change (pfile
, LC_RENAME
, new_file
, new_lineno
,
893 /* Interpret the # 44 "file" [flags] notation, which has slightly
894 different syntax and semantics from #line: Flags are allowed,
895 and we never complain about the line number being too big. */
897 do_linemarker (cpp_reader
*pfile
)
899 const struct line_maps
*line_table
= pfile
->line_table
;
900 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
901 const cpp_token
*token
;
902 const char *new_file
= map
->to_file
;
903 unsigned long new_lineno
;
904 unsigned int new_sysp
= map
->sysp
;
905 enum lc_reason reason
= LC_RENAME
;
908 /* Back up so we can get the number again. Putting this in
909 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
910 some circumstances, which can segfault. */
911 _cpp_backup_tokens (pfile
, 1);
913 /* #line commands expand macros. */
914 token
= cpp_get_token (pfile
);
915 if (token
->type
!= CPP_NUMBER
916 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
919 cpp_error (pfile
, CPP_DL_ERROR
,
920 "\"%s\" after # is not a positive integer",
921 cpp_token_as_text (pfile
, token
));
925 token
= cpp_get_token (pfile
);
926 if (token
->type
== CPP_STRING
)
928 cpp_string s
= { 0, 0 };
929 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
,
931 new_file
= (const char *)s
.text
;
934 flag
= read_flag (pfile
, 0);
938 /* Fake an include for cpp_included (). */
939 _cpp_fake_include (pfile
, new_file
);
940 flag
= read_flag (pfile
, flag
);
945 flag
= read_flag (pfile
, flag
);
950 flag
= read_flag (pfile
, flag
);
954 pfile
->buffer
->sysp
= new_sysp
;
958 else if (token
->type
!= CPP_EOF
)
960 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
961 cpp_token_as_text (pfile
, token
));
965 skip_rest_of_line (pfile
);
966 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
969 /* Arrange the file_change callback. pfile->line has changed to
970 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
971 header, 2 for a system header that needs to be extern "C" protected,
972 and zero otherwise. */
974 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
975 const char *to_file
, unsigned int file_line
,
978 const struct line_map
*map
= linemap_add (pfile
->line_table
, reason
, sysp
,
981 linemap_line_start (pfile
->line_table
, map
->to_line
, 127);
983 if (pfile
->cb
.file_change
)
984 pfile
->cb
.file_change (pfile
, map
);
987 /* Report a warning or error detected by the program we are
988 processing. Use the directive's tokens in the error message. */
990 do_diagnostic (cpp_reader
*pfile
, int code
, int print_dir
)
992 if (_cpp_begin_message (pfile
, code
, pfile
->cur_token
[-1].src_loc
, 0))
995 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
996 pfile
->state
.prevent_expansion
++;
997 cpp_output_line (pfile
, stderr
);
998 pfile
->state
.prevent_expansion
--;
1003 do_error (cpp_reader
*pfile
)
1005 do_diagnostic (pfile
, CPP_DL_ERROR
, 1);
1009 do_warning (cpp_reader
*pfile
)
1011 /* We want #warning diagnostics to be emitted in system headers too. */
1012 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, 1);
1015 /* Report program identification. */
1017 do_ident (cpp_reader
*pfile
)
1019 const cpp_token
*str
= cpp_get_token (pfile
);
1021 if (str
->type
!= CPP_STRING
)
1022 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #%s directive",
1023 pfile
->directive
->name
);
1024 else if (pfile
->cb
.ident
)
1025 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
1030 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1031 matching entry, or NULL if none is found. The returned entry could
1032 be the start of a namespace chain, or a pragma. */
1033 static struct pragma_entry
*
1034 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
1036 while (chain
&& chain
->pragma
!= pragma
)
1037 chain
= chain
->next
;
1042 /* Create and insert a blank pragma entry at the beginning of a
1043 singly-linked CHAIN. */
1044 static struct pragma_entry
*
1045 new_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
)
1047 struct pragma_entry
*new_entry
;
1049 new_entry
= (struct pragma_entry
*)
1050 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
1052 memset (new_entry
, 0, sizeof (struct pragma_entry
));
1053 new_entry
->next
= *chain
;
1059 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1060 goes in the global namespace. */
1061 static struct pragma_entry
*
1062 register_pragma_1 (cpp_reader
*pfile
, const char *space
, const char *name
,
1063 bool allow_name_expansion
)
1065 struct pragma_entry
**chain
= &pfile
->pragmas
;
1066 struct pragma_entry
*entry
;
1067 const cpp_hashnode
*node
;
1071 node
= cpp_lookup (pfile
, U space
, strlen (space
));
1072 entry
= lookup_pragma_entry (*chain
, node
);
1075 entry
= new_pragma_entry (pfile
, chain
);
1076 entry
->pragma
= node
;
1077 entry
->is_nspace
= true;
1078 entry
->allow_expansion
= allow_name_expansion
;
1080 else if (!entry
->is_nspace
)
1082 else if (entry
->allow_expansion
!= allow_name_expansion
)
1084 cpp_error (pfile
, CPP_DL_ICE
,
1085 "registering pragmas in namespace \"%s\" with mismatched "
1086 "name expansion", space
);
1089 chain
= &entry
->u
.space
;
1091 else if (allow_name_expansion
)
1093 cpp_error (pfile
, CPP_DL_ICE
,
1094 "registering pragma \"%s\" with name expansion "
1095 "and no namespace", name
);
1099 /* Check for duplicates. */
1100 node
= cpp_lookup (pfile
, U name
, strlen (name
));
1101 entry
= lookup_pragma_entry (*chain
, node
);
1104 entry
= new_pragma_entry (pfile
, chain
);
1105 entry
->pragma
= node
;
1109 if (entry
->is_nspace
)
1111 cpp_error (pfile
, CPP_DL_ICE
,
1112 "registering \"%s\" as both a pragma and a pragma namespace",
1115 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1118 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1123 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1125 register_pragma_internal (cpp_reader
*pfile
, const char *space
,
1126 const char *name
, pragma_cb handler
)
1128 struct pragma_entry
*entry
;
1130 entry
= register_pragma_1 (pfile
, space
, name
, false);
1131 entry
->is_internal
= true;
1132 entry
->u
.handler
= handler
;
1135 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1136 goes in the global namespace. HANDLER is the handler it will call,
1137 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1138 expansion while parsing pragma NAME. This function is exported
1141 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
1142 pragma_cb handler
, bool allow_expansion
)
1144 struct pragma_entry
*entry
;
1148 cpp_error (pfile
, CPP_DL_ICE
, "registering pragma with NULL handler");
1152 entry
= register_pragma_1 (pfile
, space
, name
, false);
1155 entry
->allow_expansion
= allow_expansion
;
1156 entry
->u
.handler
= handler
;
1160 /* Similarly, but create mark the pragma for deferred processing.
1161 When found, a CPP_PRAGMA token will be insertted into the stream
1162 with IDENT in the token->u.pragma slot. */
1164 cpp_register_deferred_pragma (cpp_reader
*pfile
, const char *space
,
1165 const char *name
, unsigned int ident
,
1166 bool allow_expansion
, bool allow_name_expansion
)
1168 struct pragma_entry
*entry
;
1170 entry
= register_pragma_1 (pfile
, space
, name
, allow_name_expansion
);
1173 entry
->is_deferred
= true;
1174 entry
->allow_expansion
= allow_expansion
;
1175 entry
->u
.ident
= ident
;
1179 /* Register the pragmas the preprocessor itself handles. */
1181 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1183 /* Pragmas in the global namespace. */
1184 register_pragma_internal (pfile
, 0, "once", do_pragma_once
);
1186 /* New GCC-specific pragmas should be put in the GCC namespace. */
1187 register_pragma_internal (pfile
, "GCC", "poison", do_pragma_poison
);
1188 register_pragma_internal (pfile
, "GCC", "system_header",
1189 do_pragma_system_header
);
1190 register_pragma_internal (pfile
, "GCC", "dependency", do_pragma_dependency
);
1193 /* Return the number of registered pragmas in PE. */
1196 count_registered_pragmas (struct pragma_entry
*pe
)
1199 for (; pe
!= NULL
; pe
= pe
->next
)
1202 ct
+= count_registered_pragmas (pe
->u
.space
);
1208 /* Save into SD the names of the registered pragmas referenced by PE,
1209 and return a pointer to the next free space in SD. */
1212 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1214 for (; pe
!= NULL
; pe
= pe
->next
)
1217 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1218 *sd
++ = (char *) xmemdup (HT_STR (&pe
->pragma
->ident
),
1219 HT_LEN (&pe
->pragma
->ident
),
1220 HT_LEN (&pe
->pragma
->ident
) + 1);
1225 /* Return a newly-allocated array which saves the names of the
1226 registered pragmas. */
1229 _cpp_save_pragma_names (cpp_reader
*pfile
)
1231 int ct
= count_registered_pragmas (pfile
->pragmas
);
1232 char **result
= XNEWVEC (char *, ct
);
1233 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1237 /* Restore from SD the names of the registered pragmas referenced by PE,
1238 and return a pointer to the next unused name in SD. */
1241 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1244 for (; pe
!= NULL
; pe
= pe
->next
)
1247 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1248 pe
->pragma
= cpp_lookup (pfile
, U
*sd
, strlen (*sd
));
1255 /* Restore the names of the registered pragmas from SAVED. */
1258 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1260 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1264 /* Pragmata handling. We handle some, and pass the rest on to the
1265 front end. C99 defines three pragmas and says that no macro
1266 expansion is to be performed on them; whether or not macro
1267 expansion happens for other pragmas is implementation defined.
1268 This implementation allows for a mix of both, since GCC did not
1269 traditionally macro expand its (few) pragmas, whereas OpenMP
1270 specifies that macro expansion should happen. */
1272 do_pragma (cpp_reader
*pfile
)
1274 const struct pragma_entry
*p
= NULL
;
1275 const cpp_token
*token
, *pragma_token
= pfile
->cur_token
;
1277 unsigned int count
= 1;
1279 pfile
->state
.prevent_expansion
++;
1281 token
= cpp_get_token (pfile
);
1283 if (token
->type
== CPP_NAME
)
1285 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
);
1286 if (p
&& p
->is_nspace
)
1288 bool allow_name_expansion
= p
->allow_expansion
;
1289 if (allow_name_expansion
)
1290 pfile
->state
.prevent_expansion
--;
1291 token
= cpp_get_token (pfile
);
1292 if (token
->type
== CPP_NAME
)
1293 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
);
1296 if (allow_name_expansion
)
1297 pfile
->state
.prevent_expansion
++;
1306 pfile
->directive_result
.src_loc
= pragma_token
->src_loc
;
1307 pfile
->directive_result
.type
= CPP_PRAGMA
;
1308 pfile
->directive_result
.flags
= pragma_token
->flags
;
1309 pfile
->directive_result
.val
.pragma
= p
->u
.ident
;
1310 pfile
->state
.in_deferred_pragma
= true;
1311 pfile
->state
.pragma_allow_expansion
= p
->allow_expansion
;
1312 if (!p
->allow_expansion
)
1313 pfile
->state
.prevent_expansion
++;
1317 /* Since the handler below doesn't get the line number, that
1318 it might need for diagnostics, make sure it has the right
1319 numbers in place. */
1320 if (pfile
->cb
.line_change
)
1321 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1322 if (p
->allow_expansion
)
1323 pfile
->state
.prevent_expansion
--;
1324 (*p
->u
.handler
) (pfile
);
1325 if (p
->allow_expansion
)
1326 pfile
->state
.prevent_expansion
++;
1329 else if (pfile
->cb
.def_pragma
)
1331 if (count
== 1 || pfile
->context
->prev
== NULL
)
1332 _cpp_backup_tokens (pfile
, count
);
1335 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1336 won't allow backing 2 tokens. */
1337 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1338 reads both tokens, we could perhaps free it, but if it doesn't,
1339 we don't know the exact lifespan. */
1340 cpp_token
*toks
= XNEWVEC (cpp_token
, 2);
1342 toks
[0].flags
|= NO_EXPAND
;
1344 toks
[1].flags
|= NO_EXPAND
;
1345 _cpp_push_token_context (pfile
, NULL
, toks
, 2);
1347 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1350 pfile
->state
.prevent_expansion
--;
1353 /* Handle #pragma once. */
1355 do_pragma_once (cpp_reader
*pfile
)
1357 if (cpp_in_primary_file (pfile
))
1358 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1361 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1364 /* Handle #pragma GCC poison, to poison one or more identifiers so
1365 that the lexer produces a hard error for each subsequent usage. */
1367 do_pragma_poison (cpp_reader
*pfile
)
1369 const cpp_token
*tok
;
1372 pfile
->state
.poisoned_ok
= 1;
1375 tok
= _cpp_lex_token (pfile
);
1376 if (tok
->type
== CPP_EOF
)
1378 if (tok
->type
!= CPP_NAME
)
1380 cpp_error (pfile
, CPP_DL_ERROR
,
1381 "invalid #pragma GCC poison directive");
1386 if (hp
->flags
& NODE_POISONED
)
1389 if (hp
->type
== NT_MACRO
)
1390 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1392 _cpp_free_definition (hp
);
1393 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1395 pfile
->state
.poisoned_ok
= 0;
1398 /* Mark the current header as a system header. This will suppress
1399 some categories of warnings (notably those from -pedantic). It is
1400 intended for use in system libraries that cannot be implemented in
1401 conforming C, but cannot be certain that their headers appear in a
1402 system include directory. To prevent abuse, it is rejected in the
1403 primary source file. */
1405 do_pragma_system_header (cpp_reader
*pfile
)
1407 if (cpp_in_primary_file (pfile
))
1408 cpp_error (pfile
, CPP_DL_WARNING
,
1409 "#pragma system_header ignored outside include file");
1413 skip_rest_of_line (pfile
);
1414 cpp_make_system_header (pfile
, 1, 0);
1418 /* Check the modified date of the current include file against a specified
1419 file. Issue a diagnostic, if the specified file is newer. We use this to
1420 determine if a fixed header should be refixed. */
1422 do_pragma_dependency (cpp_reader
*pfile
)
1425 int angle_brackets
, ordering
;
1427 fname
= parse_include (pfile
, &angle_brackets
, NULL
);
1431 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1433 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1434 else if (ordering
> 0)
1436 cpp_error (pfile
, CPP_DL_WARNING
,
1437 "current file is older than %s", fname
);
1438 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1440 _cpp_backup_tokens (pfile
, 1);
1441 do_diagnostic (pfile
, CPP_DL_WARNING
, 0);
1445 free ((void *) fname
);
1448 /* Get a token but skip padding. */
1449 static const cpp_token
*
1450 get_token_no_padding (cpp_reader
*pfile
)
1454 const cpp_token
*result
= cpp_get_token (pfile
);
1455 if (result
->type
!= CPP_PADDING
)
1460 /* Check syntax is "(string-literal)". Returns the string on success,
1461 or NULL on failure. */
1462 static const cpp_token
*
1463 get__Pragma_string (cpp_reader
*pfile
)
1465 const cpp_token
*string
;
1467 if (get_token_no_padding (pfile
)->type
!= CPP_OPEN_PAREN
)
1470 string
= get_token_no_padding (pfile
);
1471 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1474 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
1480 /* Destringize IN into a temporary buffer, by removing the first \ of
1481 \" and \\ sequences, and process the result as a #pragma directive. */
1483 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1485 const unsigned char *src
, *limit
;
1486 char *dest
, *result
;
1487 cpp_context
*saved_context
;
1488 cpp_token
*saved_cur_token
;
1489 tokenrun
*saved_cur_run
;
1493 dest
= result
= (char *) alloca (in
->len
- 1);
1494 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1495 limit
= in
->text
+ in
->len
- 1;
1498 /* We know there is a character following the backslash. */
1499 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1505 /* Ugh; an awful kludge. We are really not set up to be lexing
1506 tokens when in the middle of a macro expansion. Use a new
1507 context to force cpp_get_token to lex, and so skip_rest_of_line
1508 doesn't go beyond the end of the text. Also, remember the
1509 current lexing position so we can return to it later.
1511 Something like line-at-a-time lexing should remove the need for
1513 saved_context
= pfile
->context
;
1514 saved_cur_token
= pfile
->cur_token
;
1515 saved_cur_run
= pfile
->cur_run
;
1517 pfile
->context
= XNEW (cpp_context
);
1518 pfile
->context
->macro
= 0;
1519 pfile
->context
->prev
= 0;
1520 pfile
->context
->next
= 0;
1522 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1523 until we've read all of the tokens that we want. */
1524 cpp_push_buffer (pfile
, (const uchar
*) result
, dest
- result
,
1525 /* from_stage3 */ true);
1526 /* ??? Antique Disgusting Hack. What does this do? */
1527 if (pfile
->buffer
->prev
)
1528 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
1530 start_directive (pfile
);
1531 _cpp_clean_line (pfile
);
1533 end_directive (pfile
, 1);
1535 /* We always insert at least one token, the directive result. It'll
1536 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1537 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1539 /* If we're not handling the pragma internally, read all of the tokens from
1540 the string buffer now, while the string buffer is still installed. */
1541 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1542 to me what the true lifespan of the tokens are. It would appear that
1543 the lifespan is the entire parse of the main input stream, in which case
1544 this may not be wrong. */
1545 if (pfile
->directive_result
.type
== CPP_PRAGMA
)
1551 toks
= XNEWVEC (cpp_token
, maxcount
);
1552 toks
[0] = pfile
->directive_result
;
1556 if (count
== maxcount
)
1558 maxcount
= maxcount
* 3 / 2;
1559 toks
= XRESIZEVEC (cpp_token
, toks
, maxcount
);
1561 toks
[count
] = *cpp_get_token (pfile
);
1562 /* Macros have been already expanded by cpp_get_token
1563 if the pragma allowed expansion. */
1564 toks
[count
++].flags
|= NO_EXPAND
;
1566 while (toks
[count
-1].type
!= CPP_PRAGMA_EOL
);
1571 toks
= XNEW (cpp_token
);
1572 toks
[0] = pfile
->directive_result
;
1574 /* If we handled the entire pragma internally, make sure we get the
1575 line number correct for the next token. */
1576 if (pfile
->cb
.line_change
)
1577 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1580 /* Finish inlining run_directive. */
1581 pfile
->buffer
->file
= NULL
;
1582 _cpp_pop_buffer (pfile
);
1584 /* Reset the old macro state before ... */
1585 XDELETE (pfile
->context
);
1586 pfile
->context
= saved_context
;
1587 pfile
->cur_token
= saved_cur_token
;
1588 pfile
->cur_run
= saved_cur_run
;
1590 /* ... inserting the new tokens we collected. */
1591 _cpp_push_token_context (pfile
, NULL
, toks
, count
);
1594 /* Handle the _Pragma operator. */
1596 _cpp_do__Pragma (cpp_reader
*pfile
)
1598 const cpp_token
*string
= get__Pragma_string (pfile
);
1599 pfile
->directive_result
.type
= CPP_PADDING
;
1602 destringize_and_run (pfile
, &string
->val
.str
);
1604 cpp_error (pfile
, CPP_DL_ERROR
,
1605 "_Pragma takes a parenthesized string literal");
1608 /* Handle #ifdef. */
1610 do_ifdef (cpp_reader
*pfile
)
1614 if (! pfile
->state
.skipping
)
1616 const cpp_hashnode
*node
= lex_macro_node (pfile
, false);
1620 skip
= node
->type
!= NT_MACRO
;
1621 _cpp_mark_macro_used (node
);
1626 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1629 /* Handle #ifndef. */
1631 do_ifndef (cpp_reader
*pfile
)
1634 const cpp_hashnode
*node
= 0;
1636 if (! pfile
->state
.skipping
)
1638 node
= lex_macro_node (pfile
, false);
1642 skip
= node
->type
== NT_MACRO
;
1643 _cpp_mark_macro_used (node
);
1648 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1651 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1652 pfile->mi_ind_cmacro so we can handle multiple-include
1653 optimizations. If macro expansion occurs in the expression, we
1654 cannot treat it as a controlling conditional, since the expansion
1655 could change in the future. That is handled by cpp_get_token. */
1657 do_if (cpp_reader
*pfile
)
1661 if (! pfile
->state
.skipping
)
1662 skip
= _cpp_parse_expr (pfile
) == false;
1664 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1667 /* Flip skipping state if appropriate and continue without changing
1668 if_stack; this is so that the error message for missing #endif's
1669 etc. will point to the original #if. */
1671 do_else (cpp_reader
*pfile
)
1673 cpp_buffer
*buffer
= pfile
->buffer
;
1674 struct if_stack
*ifs
= buffer
->if_stack
;
1677 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1680 if (ifs
->type
== T_ELSE
)
1682 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1683 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1684 "the conditional began here");
1688 /* Skip any future (erroneous) #elses or #elifs. */
1689 pfile
->state
.skipping
= ifs
->skip_elses
;
1690 ifs
->skip_elses
= true;
1692 /* Invalidate any controlling macro. */
1695 /* Only check EOL if was not originally skipping. */
1696 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1701 /* Handle a #elif directive by not changing if_stack either. See the
1702 comment above do_else. */
1704 do_elif (cpp_reader
*pfile
)
1706 cpp_buffer
*buffer
= pfile
->buffer
;
1707 struct if_stack
*ifs
= buffer
->if_stack
;
1710 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1713 if (ifs
->type
== T_ELSE
)
1715 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1716 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1717 "the conditional began here");
1721 /* Only evaluate this if we aren't skipping elses. During
1722 evaluation, set skipping to false to get lexer warnings. */
1723 if (ifs
->skip_elses
)
1724 pfile
->state
.skipping
= 1;
1727 pfile
->state
.skipping
= 0;
1728 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1729 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1732 /* Invalidate any controlling macro. */
1737 /* #endif pops the if stack and resets pfile->state.skipping. */
1739 do_endif (cpp_reader
*pfile
)
1741 cpp_buffer
*buffer
= pfile
->buffer
;
1742 struct if_stack
*ifs
= buffer
->if_stack
;
1745 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
1748 /* Only check EOL if was not originally skipping. */
1749 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1752 /* If potential control macro, we go back outside again. */
1753 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1755 pfile
->mi_valid
= true;
1756 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1759 buffer
->if_stack
= ifs
->next
;
1760 pfile
->state
.skipping
= ifs
->was_skipping
;
1761 obstack_free (&pfile
->buffer_ob
, ifs
);
1765 /* Push an if_stack entry for a preprocessor conditional, and set
1766 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1767 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1768 we need to check here that we are at the top of the file. */
1770 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
1771 const cpp_hashnode
*cmacro
)
1773 struct if_stack
*ifs
;
1774 cpp_buffer
*buffer
= pfile
->buffer
;
1776 ifs
= XOBNEW (&pfile
->buffer_ob
, struct if_stack
);
1777 ifs
->line
= pfile
->directive_line
;
1778 ifs
->next
= buffer
->if_stack
;
1779 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1780 ifs
->was_skipping
= pfile
->state
.skipping
;
1782 /* This condition is effectively a test for top-of-file. */
1783 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1784 ifs
->mi_cmacro
= cmacro
;
1788 pfile
->state
.skipping
= skip
;
1789 buffer
->if_stack
= ifs
;
1792 /* Read the tokens of the answer into the macro pool, in a directive
1793 of type TYPE. Only commit the memory if we intend it as permanent
1794 storage, i.e. the #assert case. Returns 0 on success, and sets
1795 ANSWERP to point to the answer. */
1797 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1799 const cpp_token
*paren
;
1800 struct answer
*answer
;
1801 unsigned int acount
;
1803 /* In a conditional, it is legal to not have an open paren. We
1804 should save the following token in this case. */
1805 paren
= cpp_get_token (pfile
);
1807 /* If not a paren, see if we're OK. */
1808 if (paren
->type
!= CPP_OPEN_PAREN
)
1810 /* In a conditional no answer is a test for any answer. It
1811 could be followed by any token. */
1814 _cpp_backup_tokens (pfile
, 1);
1818 /* #unassert with no answer is valid - it removes all answers. */
1819 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1822 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' after predicate");
1826 for (acount
= 0;; acount
++)
1829 const cpp_token
*token
= cpp_get_token (pfile
);
1832 if (token
->type
== CPP_CLOSE_PAREN
)
1835 if (token
->type
== CPP_EOF
)
1837 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
1841 /* struct answer includes the space for one token. */
1842 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1844 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1845 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1847 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1850 /* Drop whitespace at start, for answer equivalence purposes. */
1852 dest
->flags
&= ~PREV_WHITE
;
1857 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
1861 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1862 answer
->count
= acount
;
1863 answer
->next
= NULL
;
1869 /* Parses an assertion directive of type TYPE, returning a pointer to
1870 the hash node of the predicate, or 0 on error. If an answer was
1871 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1872 static cpp_hashnode
*
1873 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1875 cpp_hashnode
*result
= 0;
1876 const cpp_token
*predicate
;
1878 /* We don't expand predicates or answers. */
1879 pfile
->state
.prevent_expansion
++;
1882 predicate
= cpp_get_token (pfile
);
1883 if (predicate
->type
== CPP_EOF
)
1884 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
1885 else if (predicate
->type
!= CPP_NAME
)
1886 cpp_error (pfile
, CPP_DL_ERROR
, "predicate must be an identifier");
1887 else if (parse_answer (pfile
, answerp
, type
) == 0)
1889 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1890 unsigned char *sym
= (unsigned char *) alloca (len
+ 1);
1892 /* Prefix '#' to get it out of macro namespace. */
1894 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1895 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1898 pfile
->state
.prevent_expansion
--;
1902 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1903 or a pointer to NULL if the answer is not in the chain. */
1904 static struct answer
**
1905 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
1908 struct answer
**result
;
1910 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1912 struct answer
*answer
= *result
;
1914 if (answer
->count
== candidate
->count
)
1916 for (i
= 0; i
< answer
->count
; i
++)
1917 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1920 if (i
== answer
->count
)
1928 /* Test an assertion within a preprocessor conditional. Returns
1929 nonzero on failure, zero on success. On success, the result of
1930 the test is written into VALUE, otherwise the value 0. */
1932 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
1934 struct answer
*answer
;
1937 node
= parse_assertion (pfile
, &answer
, T_IF
);
1939 /* For recovery, an erroneous assertion expression is handled as a
1940 failing assertion. */
1944 *value
= (node
->type
== NT_ASSERTION
&&
1945 (answer
== 0 || *find_answer (node
, answer
) != 0));
1946 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
1947 _cpp_backup_tokens (pfile
, 1);
1949 /* We don't commit the memory for the answer - it's temporary only. */
1953 /* Handle #assert. */
1955 do_assert (cpp_reader
*pfile
)
1957 struct answer
*new_answer
;
1960 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1965 /* Place the new answer in the answer list. First check there
1966 is not a duplicate. */
1967 new_answer
->next
= 0;
1968 if (node
->type
== NT_ASSERTION
)
1970 if (*find_answer (node
, new_answer
))
1972 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
1973 NODE_NAME (node
) + 1);
1976 new_answer
->next
= node
->value
.answers
;
1979 answer_size
= sizeof (struct answer
) + ((new_answer
->count
- 1)
1980 * sizeof (cpp_token
));
1981 /* Commit or allocate storage for the object. */
1982 if (pfile
->hash_table
->alloc_subobject
)
1984 struct answer
*temp_answer
= new_answer
;
1985 new_answer
= (struct answer
*) pfile
->hash_table
->alloc_subobject
1987 memcpy (new_answer
, temp_answer
, answer_size
);
1990 BUFF_FRONT (pfile
->a_buff
) += answer_size
;
1992 node
->type
= NT_ASSERTION
;
1993 node
->value
.answers
= new_answer
;
1998 /* Handle #unassert. */
2000 do_unassert (cpp_reader
*pfile
)
2003 struct answer
*answer
;
2005 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
2006 /* It isn't an error to #unassert something that isn't asserted. */
2007 if (node
&& node
->type
== NT_ASSERTION
)
2011 struct answer
**p
= find_answer (node
, answer
), *temp
;
2013 /* Remove the answer from the list. */
2018 /* Did we free the last answer? */
2019 if (node
->value
.answers
== 0)
2020 node
->type
= NT_VOID
;
2025 _cpp_free_definition (node
);
2028 /* We don't commit the memory for the answer - it's temporary only. */
2031 /* These are for -D, -U, -A. */
2033 /* Process the string STR as if it appeared as the body of a #define.
2034 If STR is just an identifier, define it with value 1.
2035 If STR has anything after the identifier, then it should
2036 be identifier=definition. */
2038 cpp_define (cpp_reader
*pfile
, const char *str
)
2043 /* Copy the entire option so we can modify it.
2044 Change the first "=" in the string to a space. If there is none,
2045 tack " 1" on the end. */
2047 count
= strlen (str
);
2048 buf
= (char *) alloca (count
+ 3);
2049 memcpy (buf
, str
, count
);
2051 p
= strchr (str
, '=');
2061 run_directive (pfile
, T_DEFINE
, buf
, count
);
2064 /* Slight variant of the above for use by initialize_builtins. */
2066 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
2068 size_t len
= strlen (str
);
2069 char *buf
= (char *) alloca (len
+ 1);
2070 memcpy (buf
, str
, len
);
2072 run_directive (pfile
, T_DEFINE
, buf
, len
);
2075 /* Process MACRO as if it appeared as the body of an #undef. */
2077 cpp_undef (cpp_reader
*pfile
, const char *macro
)
2079 size_t len
= strlen (macro
);
2080 char *buf
= (char *) alloca (len
+ 1);
2081 memcpy (buf
, macro
, len
);
2083 run_directive (pfile
, T_UNDEF
, buf
, len
);
2086 /* Like lex_macro_node, but read the input from STR. */
2087 static cpp_hashnode
*
2088 lex_macro_node_from_str (cpp_reader
*pfile
, const char *str
)
2090 size_t len
= strlen (str
);
2091 uchar
*buf
= (uchar
*) alloca (len
+ 1);
2094 memcpy (buf
, str
, len
);
2096 cpp_push_buffer (pfile
, buf
, len
, true);
2097 node
= lex_macro_node (pfile
, true);
2098 _cpp_pop_buffer (pfile
);
2103 /* If STR is a defined macro, return its definition node, else return NULL. */
2105 cpp_push_definition (cpp_reader
*pfile
, const char *str
)
2107 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2108 if (node
&& node
->type
== NT_MACRO
)
2109 return node
->value
.macro
;
2114 /* Replace a previous definition DFN of the macro STR. If DFN is NULL,
2115 then the macro should be undefined. */
2117 cpp_pop_definition (cpp_reader
*pfile
, const char *str
, cpp_macro
*dfn
)
2119 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2123 if (node
->type
== NT_MACRO
)
2125 if (pfile
->cb
.undef
)
2126 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
2127 if (CPP_OPTION (pfile
, warn_unused_macros
))
2128 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
2130 if (node
->type
!= NT_VOID
)
2131 _cpp_free_definition (node
);
2135 node
->type
= NT_MACRO
;
2136 node
->value
.macro
= dfn
;
2137 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
2138 node
->flags
|= NODE_WARN
;
2140 if (pfile
->cb
.define
)
2141 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
2145 /* Process the string STR as if it appeared as the body of a #assert. */
2147 cpp_assert (cpp_reader
*pfile
, const char *str
)
2149 handle_assertion (pfile
, str
, T_ASSERT
);
2152 /* Process STR as if it appeared as the body of an #unassert. */
2154 cpp_unassert (cpp_reader
*pfile
, const char *str
)
2156 handle_assertion (pfile
, str
, T_UNASSERT
);
2159 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2161 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
2163 size_t count
= strlen (str
);
2164 const char *p
= strchr (str
, '=');
2166 /* Copy the entire option so we can modify it. Change the first
2167 "=" in the string to a '(', and tack a ')' on the end. */
2168 char *buf
= (char *) alloca (count
+ 2);
2170 memcpy (buf
, str
, count
);
2179 run_directive (pfile
, type
, str
, count
);
2182 /* The number of errors for a given reader. */
2184 cpp_errors (cpp_reader
*pfile
)
2186 return pfile
->errors
;
2189 /* The options structure. */
2191 cpp_get_options (cpp_reader
*pfile
)
2193 return &pfile
->opts
;
2196 /* The callbacks structure. */
2198 cpp_get_callbacks (cpp_reader
*pfile
)
2203 /* Copy the given callbacks structure to our own. */
2205 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
2210 /* The dependencies structure. (Creates one if it hasn't already been.) */
2212 cpp_get_deps (cpp_reader
*pfile
)
2215 pfile
->deps
= deps_init ();
2219 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2220 doesn't fail. It does not generate a file change call back; that
2221 is the responsibility of the caller. */
2223 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
2226 cpp_buffer
*new_buffer
= XOBNEW (&pfile
->buffer_ob
, cpp_buffer
);
2228 /* Clears, amongst other things, if_stack and mi_cmacro. */
2229 memset (new_buffer
, 0, sizeof (cpp_buffer
));
2231 new_buffer
->next_line
= new_buffer
->buf
= buffer
;
2232 new_buffer
->rlimit
= buffer
+ len
;
2233 new_buffer
->from_stage3
= from_stage3
;
2234 new_buffer
->prev
= pfile
->buffer
;
2235 new_buffer
->need_line
= true;
2237 pfile
->buffer
= new_buffer
;
2242 /* Pops a single buffer, with a file change call-back if appropriate.
2243 Then pushes the next -include file, if any remain. */
2245 _cpp_pop_buffer (cpp_reader
*pfile
)
2247 cpp_buffer
*buffer
= pfile
->buffer
;
2248 struct _cpp_file
*inc
= buffer
->file
;
2249 struct if_stack
*ifs
;
2251 /* Walk back up the conditional stack till we reach its level at
2252 entry to this file, issuing error messages. */
2253 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
2254 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2255 "unterminated #%s", dtable
[ifs
->type
].name
);
2257 /* In case of a missing #endif. */
2258 pfile
->state
.skipping
= 0;
2260 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2261 pfile
->buffer
= buffer
->prev
;
2263 free (buffer
->notes
);
2265 /* Free the buffer object now; we may want to push a new buffer
2266 in _cpp_push_next_include_file. */
2267 obstack_free (&pfile
->buffer_ob
, buffer
);
2271 _cpp_pop_file_buffer (pfile
, inc
);
2273 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
2277 /* Enter all recognized directives in the hash table. */
2279 _cpp_init_directives (cpp_reader
*pfile
)
2284 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
2286 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
2287 node
->is_directive
= 1;
2288 node
->directive_index
= i
;